Check in ARCompact simulator. A valid configuration is arc-elf.arc-sim-20090309

This is not quite finished and has most likely a few files that are
obsolete & not used, but it's good enough to run gcc regression tests.

38 files changed, 25100 insertions, 0 deletions

diff --git a/MANIFEST b/MANIFEST
new file mode 100644
index 0000000..1e876de
--- /dev/null
+++ b/MANIFEST
@@ -0,0 +1,249 @@
+By codito
+ added files:
+  gas/testsuite/gas/arc/general_a700.d
+  gas/testsuite/gas/arc/dsp1.d
+  gas/testsuite/gas/arc/general_a700.s
+  gas/testsuite/gas/arc/dsp1.s
+  gas/testsuite/gas/arc/ld_arc700.s
+  gas/testsuite/gas/arc/sub_s.d
+  gas/testsuite/gas/arc/lsl_s.d
+  gas/testsuite/gas/arc/gen_simd.d
+  gas/testsuite/gas/arc/sub_s.s
+  gas/testsuite/gas/arc/lsl_s.s
+  gas/testsuite/gas/arc/prefetch.d
+  gas/testsuite/gas/arc/gen_simd.s
+  gas/testsuite/gas/arc/reloctest.d
+  gas/testsuite/gas/arc/arc700.exp
+  gas/testsuite/gas/arc/dsp2.d
+  gas/testsuite/gas/arc/prefetch.s
+  gas/testsuite/gas/arc/reloctest.s
+  gas/testsuite/gas/arc/dsp2.s
+  gas/testsuite/gas/arc/mpy_a700.d
+  gas/testsuite/gas/arc/ex_arc700.s
+  gas/testsuite/gas/arc/mpy_a700.s
+  gas/config/extlib
+  gas/config/extlib/configure
+  gas/config/extlib/Makefile.in
+  gas/config/extlib/arcsimd.s
+  gas/config/extlib/configure.in
+  gas/config/extlib/arcextlib.s
+  include/elf/ChangeLog.codito
+  libgloss/arc/syscall.h (delivered as linux/include/asm-arcnommu/unistd.h)
+  ld/emultempl/arclinux.em
+  ld/configdoc.texi
+  ld/scripttempl/elfarc.sc
+  ld/scripttempl/arclinux.sc
+  ld/emulparams/arclinux.sh
+  md5.sum
+  opcodes/ChangeLog.codito
+  opcodes/arcompact-dis.c
+ changed files:
+  bfd/archures.c (merged)
+  bfd/bfd-in2.h (merged/regenerated)
+  bfd/config.bfd
+  bfd/configure.in
+  bfd/cpu-arc.c (merged)
+  bfd/elf32-arc.c
+  bfd/reloc.c
+  bfd/cpu-arc.c
+  Makefile.in
+  gas/configure.tgt (patch was originally in configure.in)
+  gas/doc/c-arc.texi
+  gas/doc/as.texinfo
+  gas/configure.in
+  gas/testsuite/gas/arc/swi.d
+  gas/testsuite/gas/arc/sbc.d
+  gas/testsuite/gas/arc/sleep.d
+  gas/testsuite/gas/arc/brk.d
+  gas/testsuite/gas/arc/swi.s
+  gas/testsuite/gas/arc/rrc.d
+  gas/testsuite/gas/arc/bic.d
+  gas/testsuite/gas/arc/extb.d
+  gas/testsuite/gas/arc/arc.exp
+  gas/testsuite/gas/arc/asl.d
+  gas/testsuite/gas/arc/asr.d
+  gas/testsuite/gas/arc/sexw.d
+  gas/testsuite/gas/arc/adc.d
+  gas/testsuite/gas/arc/lsr.d
+  gas/testsuite/gas/arc/mov.d
+  gas/testsuite/gas/arc/ror.d
+  gas/testsuite/gas/arc/and.d
+  gas/testsuite/gas/arc/xor.d
+  gas/testsuite/gas/arc/rlc.d
+  gas/testsuite/gas/arc/or.d
+  gas/testsuite/gas/arc/sexb.d
+  gas/testsuite/gas/arc/jl.d
+  gas/testsuite/gas/arc/extw.d
+  gas/testsuite/gas/arc/add.d
+  gas/testsuite/gas/arc/sub.d
+  gas/struc-symbol.h
+  gas/config/tc-arc.c
+  gas/config/tc-arc.h
+  gas/Makefile.am
+  include/dis-asm.h
+  include/elf/arc.h
+  include/elf/common.h (adapted)
+  include/opcode/arc.h
+  ld/configure.in
+  ld/emulparams/arcelf.sh
+  ld/configure.tgt
+  ld/Makefile.am
+  binutils/configure.in
+  binutils/testsuite/binutils-all/objdump.exp
+  binutils/readelf.c
+  opcodes/configure.in
+  opcodes/arc-dis.c
+  opcodes/arc-dis.h
+  opcodes/arc-opc.c
+  opcodes/Makefile.am
+  opcodes/arc-ext.c
+  opcodes/arc-ext.h
+  gdb/doc/Makefile.in
+  gdb/doc/gdb.texinfo
+  gdb/remote.c
+  gdb/testsuite/gdb.base/float.exp
+  gdb/testsuite/lib/gdbserver-support.exp
+  gdb/testsuite/gdb.asm/asm-source.exp
+  gdb/dwarf2read.c
+  gdb/dwarf2-frame.c
+  gdb/configure.tgt
+  gdb/version.in
+  gdb/gdbserver/Makefile.in
+  gdb/gdbserver/configure.srv
+  gdb/gdbserver/proc-service.c
+  gdb/gdbserver/remote-utils.c
+  gdb/Makefile.in
+
+By ARC employees:
+ added files:
+  cgen/cpu/ARCompact.cpu
+  cgen/cpu/arc.opc
+  cgen/cpu/arc.cpu
+  cpu/arc.opc
+  cpu/sh-sim.cpu
+  cpu/arc.cpu
+  cpu/ARCompact.cpu
+  gas/ChangeLog.ARC
+  gdb/config/arc/arc.mt
+  include/gdb/target-io/arc.h
+  ld/ChangeLog.ARC
+  opcodes/arc-opc.h
+  opcodes/arc-opinst.c
+  opcodes/arc-desc.c
+  opcodes/arc-desc.h
+  opcodes/arc-ibld.c
+  opcodes/arc-asm.c
+  sim/arc/ChangeLog
+  sim/arc/configure.ac
+  sim/arc/mloop5.in
+  sim/arc/mloop6.in
+  sim/arc/mloop7.in
+  sim/arc/arc-sim.h
+  sim/arc/Makefile.in
+  sim/arc/tconfig.in
+  sim/arc/sim-main.h
+  sim/arc/devices.c
+  sim/arc/sim-if.c
+  sim/arc/arc5.c
+  sim/arc/arc6.c
+  sim/arc/arc7.c
+  sim/arc/config.in
+  sim/arc/configure
+  sim/arc/arch.h
+  sim/arc/arch.c
+  sim/arc/decode5.h
+  sim/arc/decode6.h
+  sim/arc/decode7.h
+  sim/arc/decode5.c
+  sim/arc/decode6.c
+  sim/arc/decode7.c
+  sim/arc/sem5-switch.c
+  sim/arc/sem6-switch.c
+  sim/arc/sem7-switch.c
+  sim/arc/sem5.c
+  sim/arc/sem6.c
+  sim/arc/sem7.c
+  sim/arc/cpu5.h
+  sim/arc/cpu6.h
+  sim/arc/cpu7.h
+  sim/arc/cpuall.h
+  sim/arc/cpu5.c
+  sim/arc/cpu6.c
+  sim/arc/cpu7.c
+  sim/arc/model5.c
+  sim/arc/model6.c
+  sim/arc/model7.c
+  sim/arc/traps.c
+  sim/common/ChangeLog.ARC
+  newlib/ChangeLog.ARC
+  newlib/libc/sys/arc/sys/fcntl.h
+ replaced files:
+  opcodes/arc-dis.c
+  opcodes/arc-opc.c
+ changed files:
+  bfd/configure
+  bfd/elf32-arc.c
+  bfd/libbfd.h
+  bfd/bfd-in2.h
+  cgen/ChangeLog
+  cgen/read.scm
+  cgen/sim-cpu.scm
+  cgen/utils-sim.scm
+  cgen/cpu/ip2k.opc
+  cgen/cpu/sparc.opc
+  cgen/cpu/xc16x.opc
+  cgen/cpu/fr30.opc
+  cgen/cpu/mep.opc
+  cgen/cpu/m32r.opc
+  cgen/cpu/i960.opc
+  cgen/cpu/sh.opc
+  cgen/cpu/iq2000.opc
+  cgen/cpu/openrisc.opc
+  cgen/cpu/xstormy16.opc
+  cgen/opc-itab.scm
+  cpu/ChangeLog
+  gas/config/tc-arc.c
+  gas/config/tc-arc.h
+  gas/configure
+  gas/Makefile.in
+  gas/doc/c-arc.texi
+  gas/as.c
+  gas/symbols.c
+  gas/symbols.h
+  gdb/ChangeLog
+  gdb/configure.tgt
+  include/ChangeLog
+  include/dis-asm.h
+  include/gdb/callback.h
+  include/gdb/ChangeLog
+  include/opcode/arc.h
+  include/opcode/cgen.h
+  ld/ChangeLog
+  ld/scripttempl/arclinux.sc
+  ld/scripttempl/elfarc.sc
+  ld/emulparams/arclinux.sh
+  ld/Makefile.am
+  ld/Makefile.in
+  libgloss/ChangeLog
+  opcodes/arc-dis.h
+  opcodes/arc-dis.c
+  opcodes/arc-ext.h
+  opcodes/arc-ext.c
+  opcodes/arc-opc.c
+  opcodes/ChangeLog
+  opcodes/configure
+  opcodes/configure.in
+  opcodes/Makefile.am
+  opcodes/Makefile.in
+  opcodes/cgen-dis.c
+  sim/ChangeLog
+  sim/configure.ac
+  sim/configure
+  sim/common/callback.c
+  sim/common/cgen-trace.c
+  sim/common/ChangeLog
+  sim/common/gennltvals.sh
+  sim/common/gentvals.sh
+  sim/common/nltvals.def
+  sim/common/sim-utils.c
+  sim/common/syscall.c
diff --git a/gdb/ChangeLog.codito b/gdb/ChangeLog.codito
new file mode 100644
index 0000000..50bedf8
--- /dev/null
+++ b/gdb/ChangeLog.codito
@@ -0,0 +1,1198 @@
+2006-05-18  Kunal Parmar  <kunal.parmar@codito.com>
+
+	18th May 2006 Release
+	* version.in: Change to 6.3_codito_20060518, which is when it is
+	scheduled to be released.
+
+2006-05-11  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* arc-tdep.c (a4_scan_prologue): Include function only for A4. 
+
+2006-04-28  Ashwin Pathmudi  <ashwin.pathmudi@codito.com>
+
+	* arc-tdep.c (arc_push_dummy_call): Correct handling
+	of struct return for the a4 core.  
+
+2006-04-26  Ashwin Pathmudi  <ashwin.pathmudi@codito.com>
+
+	* arc-tdep.c (a4_address_to_pointer): New. Converts address
+	to pointer for the a4 core.  
+	(a4_pointer_to_address): New.  Converts pointers to address
+	for the a4 core.  
+	(arc_gdbarch_init): Add the above 2 new functions to the 
+	gdbarch structure for the A4 core. 
+
+2006-03-29  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* Makefile.in (arc-jtag-ops.o): Add arc-tdep.h to the list of
+	dependencies. 
+	* arc-jtag-ops.h: Include arc-tdep.h.
+	(IS_ARC700): New macro. Return 1 if processor connected is
+	ARC700. 
+	(IS_ARC600): New macro. Return 1 if processor connected is
+	ARC600. 
+	(IS_A5): New macro. Return 1 if processor connected is A5. 
+	(IS_A4): New macro. Return 1 if processor connected is A4. 
+	* arc-jtag-ops.c (ARCProcessor): New global variable. Contains the
+	processor type that has been connected.
+	(arc_get_architecture): New function. Return the processor type
+	that has been connected. Set ``ARCProcessor'' when run the
+	first time.
+	(arc_jtag_close): Unset ``ARCProcessor''.
+	(arc_jtag_open): Remove ifdefs and use above macros instead.
+	(arc_jtag_wait): Ditto.
+	* arc-jtag.c (arc_update_architecture): Use above macros.
+
+2006-03-13  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* arc-tdep.c (arc_gdbarch_init): Characters are unsigned by
+	default. 
+
+2006-03-08  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* arc-jtag-ops.c (arcjtag_retry_count): New variable. Defines the
+	number of times a JTAG operation is attempted before returning a
+	failure.	
+	(arc_jtag_read_core_reg): Use above variable.
+	(arc_jtag_write_core_reg): Ditto.
+	(arc_jtag_read_aux_reg): Ditto.
+	(arc_jtag_write_aux_reg): Ditto.
+	(read_mem): Ditto.
+	(write_mem): Ditto.
+	* arc-jtag.c (_initialize_arc_debug): Add command to set above
+	variable. 
+
+2006-03-03  Ashwin Pathmudi  <ashwin.pathmudi@codito.com>
+
+	* arc-tdep.c (arc_push_dummy_call): Add support for dummy
+	call for the A4 core.  
+	(arc_extract_return_value): Enable for A4 core.  
+	(arc_store_return_value): Likewise.  
+	(arc_return_value): Likewise.  
+	(arc_gdbarch_init): Set call_dummy_location to 
+	AT_ENTRY_POINT for A4 core.  
+
+	* arc-jtag-tdep.c (arc_jtag_register_reggroup_p): Adding the 
+	status register to save/restore group for the A4 core.  
+
+2006-03-03  Ashwin Pathmudi  <ashwin.pathmudi@codito.com>
+
+	* arc-tdep.c (printFrameInfo): Print more verbose messages.  
+	(printInsnState): Likewise.  
+	(a4_scan_prologue): New.  Function to scan the prologue and 
+	fill the unwind cache.  
+	(arc_skip_prologue): Call a4_scan_prologue for a A4 core.  
+	(arc_frame_unwind_cache): Likewise.  
+	(arc_dwarf2_frame_init_reg): Defined for A4 core.  
+	(arc_unwind_pc): Defined for A4 core.  
+	(arc_scan_prologue): Cosmetic change.  
+	(arc_frame_this_id): Likewise.  
+	(arc_frame_prev_register): Likewise.  
+	(arc_next_pc): Likewise.  
+	(arc_software_single_step): Likewise.  
+	(arc_extract_return_value): Likewise.  
+	(arc_store_return_value): Likewise.  
+	(arc_return_value): Likewise.  
+	(arc_sigtramp_frame_cache): Likewise.  
+	(arc_sigtramp_frame_this_id): Likewise.  
+	(arc_sigtramp_frame_prev_register): Likewise.
+	(arc_sigtramp_frame_cache): Likewise.  
+	(arc_sigtramp_frame_sniffer): Likewise.  
+	(arc_push_dummy_call): Likewise.  
+	(arc_gdbarch_init): Change definition of disassembler to
+	arc_get_disassembler for the A4 core.  
+
+	* arc-jtag.h (debug_arc_jtag_target_message): New.  Definition
+	moved here.  
+
+	* arc-jtag.c (arc_debug_open): Cosmetic change.  
+	(arc_get_hw_regnum_mapping): Setting boundary limit for
+	A4 core.  
+
+	* arc-jtag-tdep.c (A4_HALT_VALUE): New. Define Halt 
+	value in status register.  
+	(a4_jtag_write_pc): Correct handling of write pc.
+	(a4_jtag_read_pc): New.  Function to read pc for the 
+	a4 core.  
+	(arc_jtag_init): Modify tdep gdbarch structure to
+	include read_pc.
+
+2006-03-03  Ashwin Pathmudi  <ashwin.pathmudi@codito.com>
+
+	* arc-tdep.c (arc_scan_prologue): Disabling temporarily for
+	the A4 core.  
+	(arc_skip_prologue): Likewise.  
+	(arc_frame_unwind_cache): Likewise.  
+	(arc_frame_this_id): Likewise.  
+	(arc_frame_prev_register): Likewise.  
+	(arc_next_pc): Likewise.  
+	(arc_software_single_step): Likewise.  
+	(arc_dwarf2_frame_init_reg): Likewise.  
+	(arc_extract_return_value): Likewise.  
+	(arc_store_return_value): Likewise.  
+	(arc_return_value): Likewise.  
+	(arc_sigtramp_frame_cache): Likewise.  
+	(arc_sigtramp_frame_this_id): Likewise.  
+	(arc_sigtramp_frame_prev_register): Likewise.  
+	(arc_sigtramp_frame_sniffer): Likewise.  
+	(arc_push_dummy_call): Likewise.  
+	(arc_gdbarch_init): Modify gdbarch structure for A4. 
+	(arc_binutils_reg_to_regnum): Add A4 specific conversion of
+	register numbers.  
+
+	* arc-jtag.c (arc_debug_open): A4 specific status register
+	read.  
+	(arc_debug_resume): A4 specific change for status and 
+	debug auxillary registers.  
+	(arc_debug_insert_breakpoint): Add opcode for the A4 break
+	instruction.  
+	(arc_debug_remove_breakpoint): Write 4 bytes back for the 
+	A4.  
+	(arc_print_processor_variant_info): Adding A4 to the list
+	of processors.  
+
+	* arc-jtag-tdep.c (a4_jtag_breakpoint_size): New. Defines
+	the size of the breakpoint instruction for A4.  
+	(a4_jtag_breakpoint_insn): New.  Defines the opcode for 
+	the breakpoint instruction for A4.  
+	(arc_jtag_register_name): Exclude non A4 registers for
+	A4-gdb.  
+	(a4_jtag_write_pc): New.  Write value to the program
+	counter for A4.  
+	(arc_jtag_init): Modify the target dependent part of 
+	gdbarch struct for the A4 core.  
+
+	* arc-jtag-ops.c (A4_HALT_VALUE): New. Halt bit set in
+	the status auxillary (0x0) register.  
+	(ARC700_HALT_VALUE): New.  Halt bit set in status32
+	auxillary register.  
+	(arc_jtag_read_aux_reg): Add more verbose messages.  
+	(arc_jtag_write_aux_reg): Likewise.  
+	(arc_jtag_open): Read the status auxillary register
+	for the A4 core.  
+	(arc_jtag_wait): Likewise.  
+
+2006-03-02  Ashwin Pathmudi  <ashwin.pathmudi@codito.com>
+
+	* configure.tgt: Add A4-JTAG target.  
+	* config/arc/a4-jtag.mt: New. Makefile fragment for
+	new A4-JTAG target.  
+	* config/arc/tm-a4-jtag.h: New. Target specific header file 
+	for the A4-JTAG target.  
+
+	* arc-tdep.h: Add the A4 to the ARC processor version
+	information.  
+
+	* arc-tdep.c (arc_cannot_store_register): Exclude non A4 
+	registers for A4-gdb.  
+	(arc_next_pc): Likewise.  
+	(arc_register_reggroup_p): Likewise.  
+
+	* arc-regnums-defs.h: Exclude non-A4 registers for A4-gdb.  
+
+	* arc-jtag.c (arc_update_architecture): Identify the A4 core.  
+	(clear_status32_user_bit): Allow only A4 Registers.  
+	(restore_status32_user_bit): Likewise.  
+	(arc_debug_open): Not compiling for the A4 core yet.
+	(arc_debug_resume): Likewise.  
+	(arc_debug_wait): Excluding Arc600 specific part for A4 core.  
+	(arc_get_hw_regnum_mapping): Exclude non-A4 registers for
+	the A4 core.  
+	(arc_debug_fetch_regs): Likewise.  
+	(arc_debug_store_regs): Likewise.  
+	(init_arc_debug_ops): Modify target_ops for A4 core.  
+
+	* arc-jtag-tdep.c (arc_jtag_register_reggroup_p): Allow only A4 
+	Registers.  
+	(arc_jtag_print_registers_info): Likewise.  
+	(arc_jtag_init): Likewise.  
+
+2006-01-02  Ashwin Pathmudi  <ashwin.pathmudi@codito.com>
+
+        PR 1496
+	* dwarf2-frame.c (dwarf2_frame_state_copy_regs): Correct 
+	allocated size.  
+
+2005-12-17  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* arc-jtag.c (arc_debug_wait): Reverting to version 1.40
+
+2005-12-16  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* arc-jtag-ops.c (arc_jtag_open): Change the message printed when
+	processor is running.
+	* arc-jtag.c (arc_debug_wait): Dont assume the program to have
+	exited when SH bit is set.
+
+2005-11-08  Kunal Parmar  <kunal.parmar@codito.com>
+
+	8th November Release
+	* version.in: Change to 6.3_codito_20051108, which is when it is
+	going to be released.
+
+2005-09-28  Kunal Parmar  <kunal.parmar@codito.com>
+
+	Bug #1479
+	* arc-jtag-tdep.c (arc_jtag_register_reggroup_p): Remove IDENTITY
+	register from save/restore group.
+
+2005-09-27  Kunal Parmar  <kunal.parmar@codito.com>
+
+	Bug #1476
+	* arc-jtag.c (arc_debug_xfer_partial): Fix for Bug #1476 (gdb for
+	JTAG goes into infinite loop).
+
+2005-09-24  Kunal Parmar  <kunal.parmar@codito.com>
+
+	Bug #1475
+	* arc-jtag-ops.c (arc_jtag_read_chunk): Fix for Bug #1475 (printf
+	command in gdb for JTAG fails).
+
+2005-09-23  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* arc-jtag.c (arc_debug_xfer_partial): The value being returned
+	was incorrect.
+
+2005-09-23  Kunal Parmar  <kunal.parmar@codito.com>
+
+	Bug #1286
+	* arc-jtag-ops.c: Fix for Bug #1286 (reading an invalid register
+	causes next operation to fail).
+	
+2005-09-23  Kunal Parmar  <kunal.parmar@codito.com>
+
+	Bug #1272
+	* arc-jtag.c (arc_debug_create_inferior): Check if an executable
+	file has been handed to us, print an error if none is specified.
+
+2005-07-14  Sameer Dhavale  <sameer.dhavale@codito.com>
+
+        Bug #1381
+	* arc-jtag-ops.c (arc_jtag_close): Close file descriptor opened
+	for communication with gpio driver.
+
+2005-07-06  Soam Vasani  <soam.vasani@codito.com>
+
+	Bug #1364
+	* arc-jtag.c (arc_debug_xfer_partial): Restore the User bit in
+	status32.  This fixes bug #1364 (userland debugging: kernel
+	panic).
+
+2005-06-28  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag.c (arc_debug_detach): Resume the inferior.
+
+2005-06-28  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag.c (arc_debug_xfer_partial): Clear STATUS32 user bit
+	when reading or writing memory (earlier, we only cleared it while
+	writing.)
+
+2005-06-25  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-linux-tdep.c (arc_linux_register_name): Change name of
+	stop_pc from "stop_pc" to "pc".
+	(arc_linux_print_registers_info): Remove "ret" and add stop_pc.
+
+2005-06-24  Soam Vasani  <soam.vasani@codito.com>
+
+	Bug #1325 (core file support)
+	* arc-linux-tdep.c (arcompact_linux_core_reg_offsets): New array.
+	offsets of registers in core file's register section, for
+	ARCompact.
+	(arcompact_linux_supply_gregset): New function.  Get registers
+	from core file's register section, for ARCompact.
+	(arc_linux_supply_gregset): New function.  Get registers from core
+	file register section.
+	(arc_linux_gregset): For the gdbarch function.
+	(arc_linux_regset_from_core_section): This is called through
+	gdbarch.
+	* config/arc/linux.mt (TDEPFILES): Add corelow.c to list.
+
+2005-06-21  Soam Vasani  <soam.vasani@codito.com>
+
+	* gdb/arc-jtag.c (arc_update_architecture): Check for A5, print a
+	warning but don't give an error.
+	* gdb/arc-tdep.h (ARCProcessorVersion): Add A5.
+
+2005-06-20  Soam Vasani  <soam.vasani@codito.com>
+
+	Bug #1311
+	* arc-jtag.c (arc_debug_wait): In ARC600, try to detect the case
+	of a breakpoint on the last instruction of a ZOL and warn the
+	user.
+	(arc_debug_read_core_register): New function.  Read a core
+	register and check for errors.
+
+2005-06-19  Soam Vasani  <soam.vasani@codito.com>
+
+	Bug #1305
+	* dwarf2read.c: Fix for bug #1305 (Failure with Metaware compiled
+	binaries)
+
+2005-05-21  Soam Vasani  <soam.vasani@codito.com>
+
+	23rd May Release
+	* version.in: Change to 6.3_codito_20050523, which is when it is
+	going to be released.
+
+2005-05-21  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag.c (arc_debug_store_regs): Show regno argument in debug
+	message.
+
+2005-05-21  Soam Vasani  <soam.vasani@codito.com>
+
+	* Makefile.in (arc-tdep.o): Add observer.h to the list of
+	dependencies.
+
+2005-05-21  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag-tdep.c (arc_jtag_register_reggroup_p): Remove extension
+	registers from _all_ reggroups, because they do not exist (as of
+	now).  Narrow down the list of registers in the save/restore group.
+
+2005-05-21  Sameer Dhavale  <sameer.dhavale@codito.com>
+
+        * arc-jtag-ops.c: Included more header files to remove build time
+	warnings
+	
+2005-05-21  Sameer Dhavale  <sameer.dhavale@codito.com>
+
+        PR arcgdb/1282
+	* arc-jtag.c: small changes to remove warnings during compilation.
+	* arc-jtag-ops.c(arc_debug_wait): Adding code to block and unblock
+	signals so that ctrl+c should work.
+
+2005-05-21  Soam Vasani  <soam.vasani@codito.com>
+
+	21st May 2005 Release.
+        * version.in: Bump version to 6.3_codito_20050521
+
+2005-05-21  Soam Vasani  <soam.vasani@codito.com>
+
+	Bug #1278
+	* arc-tdep.c (arc_set_main_name): New function.  Set main name to
+	_main if necessary.
+	(arc_gdbarch_init): Make arc_set_main_name an observer of
+	inferior_created.
+
+2005-05-16  Soam Vasani  <soam.vasani@codito.com>
+
+	Bug #1279
+	* remote.c (remote_open_1): Call observer_notify_inferior_created.
+	
+2005-05-16  Soam Vasani  <soam.vasani@codito.com>
+
+	15th May 2005 Release.
+        * version.in: Bump version to 6.3.50_cdt_gdb_20050515
+
+2005-05-15  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag-tdep.c (arc_jtag_init): Rename the aux-read command to
+	arc-aux-read and aux-write to arc-aux-write.
+
+2005-05-15  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag.c (arc_debug_wait): If the SH (self halt) bit is set,
+	assume that the program has exited, with exit code in R0.
+	* arc-jtag.h (ARC_DEBUG_REG_SH_BIT): Define.  Self halt bit in the
+	debug register.
+
+2005-05-15  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag-ops.c (arc_jtag_open): Correct and conditionalise debug
+	printfs.
+
+2005-05-15  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag.c (arc_debug_open): Call target_preopen,
+	reopen_exec_file and reread_symbols.
+
+2005-05-13  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag-ops.c (arc_jtag_close): Conditionalize a debug printf.
+
+2005-05-13  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag.h (ARC_TARGET_OBJECT_AUXREGS): Define.  For use in
+	target_xfer_partial.
+	(target_read_aux_reg, target_write_aux_reg): Change to use
+	target_xfer_partial.
+	* arc-jtag.c (arc_debug_xfer_partial): Support reading/writing of
+	auxillary registers, using ARC_TARGET_OBJECT_AUXREGS.
+	(init_arc_debug_ops): Stop using to_data (we'll use
+	target_xfer_partial for aux registers).
+	* arc-jtag-tdep.c (arc_jtag_aux_read_command): New command: read a
+	range of aux registers.
+	(arc_jtag_aux_write_command): New command: write an aux register.
+	(arc_jtag_init): Add the above commands.
+
+2005-05-13  Ramana Radhakrishnan  <ramana@codito.com>
+
+	* arc-jtag-ops.c(check_and_raise_error_if_jtag_closed):New function
+	for sanity checks. 
+	(arc_jtag_reset_board):Use above.
+	(arc_jtag_wait):Likewise.
+	(arc_jtag_read_chunk):Likewise.
+	(arc_jtag_read_core_reg):Likewise.
+	(arc_jtag_write_core_reg):Likewise.
+	(arc_jtag_read_aux_reg):Likewise.
+	(arc_jtag_write_aux_reg):Likewise.
+
+
+2005-05-13  Ramana Radhakrishnan  <ramana@codito.com>
+
+	* arc-jtag.c: Rename cmd arc_bcr_registers to arc-bcr-registers.
+	Rename arcjtag-debugstatemachine to arcjtag-debug-statemachine 
+
+2005-05-13  Ramana Radhakrishnan  <ramana@codito.com>
+
+	* arc-jtag-ops.h: Rename members to JTAG_OPENED and JTAG_CLOSED.
+	* arc-jtag-ops.c(arc_jtag_reset_board): Introduce
+	  sanity checks for checking target being opened. 
+	  (arc_jtag_open):set status to JTAG_OPENED.  
+
+2005-05-13  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* arc-jtag-ops.h: Add new member for reset_board.
+	* arc-jtag-ops.c(arc_jtag_reset_board):New function.
+	(initialize_arc_jtag_ops):Initialize reset board. 
+	* arc-jtag.c: New command arc-reset-board
+
+2005-05-13  Sameer Dhavale <sameer.dhavale@codito.com>
+
+	* arc-jtag.c: Add corrections to code to remove build time
+	warnings.
+	
+2005-05-13  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag.c (clear_status32_user_bit, restore_status32_user_bit):
+	New functions: clear/restore the user-mode bit in the status32
+	register.
+	(set_debug_user_bit): Set the UB bit in the debug register, so
+	that breakpoints work in user mode.
+	(arc_debug_open, arc_debug_resume): Call set_debug_user_bit.
+	(arc_debug_xfer_partial): When writing, go to kernel mode so that
+	we are not affected by privileges.
+	
+2005-05-12  Sameer Dhavale  <sameer.dhavale@codito.com>
+
+        PR arcgdb/1277
+	* arc-jtag-ops.c(gpio_write): Add function to write data to
+	parallel port.
+	(gpio_read): Add function to read from parallel port.
+	* gpio.h: New file. Add to support the interface with /dev/gpio.
+	
+2005-05-12  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* dwarf2-frame.c(execute_cfa_program): Ignore the contents
+	for a MW_ARC_info cfa directive. 
+
+2005-05-12  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* dwarf2-frame.c(decode_frame_entry_1):Ignore High C compilers
+	augmentation value in the frame entry. 
+
+2005-05-12  Sameer Dhavale <sameer.dhavale@codito.com>
+
+	* arc-jtag-ops.c(arc_jtag_write_aux_reg): Return value on
+	successful transaction.
+	* arc-jtag-ops.h: Change in prototype of function
+	jtag_memory_read().	
+
+2005-05-11  Sameer Dhavale  <sameer.dhavale@codito.com>
+
+	* arc-jtag-ops.c: Remove extra messages introduced by prev commit
+	and changing all printf() to printf_filtered().
+
+2005-05-10  Sameer Dhavale  <sameer.dhavale@codito.com>
+
+        PR arcgdb/1275 
+	* arc-jtag-ops.h(struct jtag_ops):Change protypes of functions
+	jtag_read_core_reg(), jtag_read_aux_reg(), jtag_write_core_reg(),
+	jtag_write_aux_reg() to handle errors gracefully.
+	* arc-jtag-ops.h(arc_jtag_read_core_reg): Change definition of
+	function to return the no of bytes read instead of returning
+	value.
+	(arc_jtag_write_core_reg): Change definition of function to return
+	the no of bytes actually written.
+	(arc_jtag_read_aux_reg):  Change definition of
+	function to return the no of bytes read instead of returning
+	value.
+	(arc_jtag_write_aux_reg): Change definition of function to return
+	the no of bytes actually written.
+	*arc-jtag.c: Change all calls to interface functions to accomodate
+	the changes made above and check and handle error gracefully with
+	error messages.
+
+2005-05-10  Ramana Radhakrishnan  <ramana@codito.com>
+
+	* arc-jtag.c(arc_update_architecture):Set up decr_pc_after_break
+	for ARC600 as 2 and 0 for ARC700.
+
+2005-05-10  Ramana Radhakrishnan  <ramana@codito.com>
+
+	* arc-jtag.h(is_arc700):New Function.
+	(is_arc600):New Function.
+	* arc-jtag.c(arc_jtag_resume):Single Step Mask 
+	is different for both ARC600 and ARC700. Use functions is_arc700
+	and is_arc600.
+
+2005-05-10  Ramana Radhakrishnan  <ramana@codito.com>
+	    Soam Vasani		  <soam.vasani@codito.com>
+
+	* arc-jtag.c(arc_debug_resume): Invalidate caches
+	for single stepping or even while resuming. 
+
+2005-05-10  Ramana Radhakrishnan  <ramana@codito.com>
+
+	* arc-jtag.c(arc_debug_open):Set STATUS32 to 1 
+	when opening JTAG .
+
+2005-05-10  Ramana Radhakrishnan  <ramana@codito.com>
+
+	* Makefile.in:Update dependency for arc-jtag-tdep.o
+	* ChangeLog.codito: Correct changelog entry. 
+
+2005-05-10  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* arc-jtag-tdep.c: Update copyright notice.
+	* arc-tdep.h: Likewise.
+	
+2005-05-10  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* Makefile.in:Update dependencies for ARC specific files.
+
+2005-05-10  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	*arc-jtag.h: (enum arc_hw_regnums): New enum. 
+	(arc-regnum-defs.h):Include.
+	(Define and undefine R_AUX and R_BCR)
+	* arc-regnum-defs.h: New file. 
+	* arc-jtag-ops.h(enum arc700_hw_regnum):Remove. 
+	* arc-jtag.c(R):Remove Macro.
+	(arc-regnum-defs.h):Include. 
+	(RAUX):New macro.
+	(RBCR):New macro. 
+	(arc_bcr_reg_info):Use above macros.
+	(arc_aux_reg_map):Likewise.
+	(struct arc_reg_info):Change type to arc_hw_regnum
+	(arc_update_architecture):Use ARC_HW_IDENTITY_REGNUM. 
+	(invalidateCaches):Use ARC_HW_ICACHE_IVIC
+	Use ARC_HW_DCACHE_IVIC to invalidate caches. 
+	(disableCaches):Use ARC_HW_ICACHE_CONTROL, 
+	ARC_HW_DCACHE_CONTROL to disable caches. 
+	(arc_debug_resume):Use ARC_HW_STATUS32_REGNUM. 
+	Use ARC_HW_DEBUG_REGNUM.
+	
+
+2005-05-10  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* arc-jtag-tdep.c(struct arc_reg_info):New struct. 
+	(arc_jtag_register_name):Move BCR registers below all 
+	the Auxiliary registers. This is to take care of printing
+	Build Configuration Registers and Auxiliary registers in 
+	one chunk. 
+	Rename BCR Registers to their correct names. 
+	(arc_jtag_print_registers_info):Use the all parameter to print
+	bcr registers and all the known ARC700 auxiliary registers 
+	and Build Configuration Registers.
+	* arc-jtag.c:(arc_aux_reg_map):New regmap for Auxiliary registers. 
+	(arc_get_hw_regnum_mapping):Use this to create mapping 
+	between gdb regnums and hw regnums. 
+	(arc_debug_fetch_regs):Use above.
+	(arc_debug_store_regs):Use above. 
+	* arc-tdep.h:Add processor versions UNSUPPORTED and ARCompact. 
+	* config/arc/tm-embed.h:Restructure the AUX Registers
+	information to be above the BCRs.
+	
+
+2005-05-09  Ramana Radhakrishnan <ramana.radhakrishnan@codito.com>
+
+	* arc-jtag.c(arc_jtag_open):Remove call to invalidateCache. 
+	(arc_debug_load):Add code to zero out the bss section.
+
+2005-05-09  Ramana Radhakrishnan <ramana.radhakrishnan@codito.com>
+
+	* arc-jtag.c(struct arc_reg_info): Correct typo for arc_gdb_regnums.
+
+2005-05-09  Ramana Radhakrishnan <ramana.radhakrishnan@codito.com>
+
+	* arc-tdep.h (ARCProcessorVersion):New enum.
+	(ARCExtensionsSupportedInformation):New enum.
+	(ARCProcessorInformation):New structure to store ARC 
+	processor variant information.
+	(gdbarch_tdep):Add member of ARCProcessorInformation.
+	* arc-jtag-tdep.c (arc_debug_processor_information):Add new
+	variable. 
+	(arc_jtag_init):Initialize tdep->arc_processor_variant_info. 
+	* arc-linux-tdep.c (arc_linux_init_abi):Set ARC processor 
+	variant info to NULL.
+	* arc-jtag.c (arc_update_architecture):New function Update 
+	architecture information. 
+	(invalidateCaches):Invalidate Cache.
+	(disableCaches):Disable Cache.
+	(arc_debug_open):Call enable and invalidate caches and 
+	arc_update_architecture. 
+
+2005-05-06  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag.c (arc_debug_wait): Set status waitkind and signal
+	value, so that our caller thinks we stopped due to a SIGTRAP.
+
+2005-05-05  Sameer Dhavale  <sameer.dhavale@codito.com>
+
+	PR arcgdb/1271 
+	* arc-jtag.c (arc_debug_resume): Add support for hardware single
+	instruction stepping. 
+
+2005-05-05  Ramana Radhakrishnan <ramana.radhakrishnan@codito.com>
+
+	* arc-jtag.h: Add copyright notice.
+
+2005-05-05  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag.c (arc_debug_read_aux_register,
+	arc_debug_write_aux_register): New functions.
+	(arc_debug_aux_reg_functions): Struct containing pointers to
+	arc_debug_read/write_aux_register.
+	(init_arc_debug_ops): Set to_data to arc_debug_aux_reg_functions.
+	* arc-jtag.h (target_read_aux_reg, target_write_aux_reg): New
+	macros.
+
+2005-05-05  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* arc-jtag-ops.c(AA3SSPinState):New enum for target comms
+	to AA3.
+	(arc_jtag_read_chunk):Change usage of rw_flag.
+	(arc_jtag_write_chunk):Change usage of rw_flag.
+	(read_mem):Change usage of rw_flag.
+	(write_mem):Change usage of rw_flag to use the new enum.
+	(arc_jtag_write_chunk):Formatting cleanups.
+	
+	
+
+2005-05-05  Ramana Radhakrishnan <ramana.radhakrishnan@codito.com>
+
+	* arc-jtag-ops.c:Cleanup. 
+	(port_perms_setup): Make static.
+	(tapc_set_tms): Likewise.
+	(tapc_set_tck): Likewise.
+	(tapc_set_tdi): Likewise.
+	(clockdelay): Likewise.
+	(tapc_pulse): Likewise.
+	(tapc_reset): Likewise.
+	(tapc_tms): Likewise.
+	(tapc_readbit): Likewise.
+	(tapc_shiftbit): Likewise.
+	(tapc_shiftnbits): Likewise.
+	(read_jtag_status_reg): Likewise.
+	(print_jtag_status_reg_val): Likewise.
+	(write_jtag_reg): Likewise.
+	(read_jtag_reg): Likewise.
+	(arc_jtag_read_core_reg): Likewise.
+	(arc_jtag_write_core_reg): Likewise.
+	(arc_jtag_read_aux_reg): Likewise.
+	(arc_jtag_write_aux_reg): Likewise.
+	(read_mem): Likewise.
+	(write_mem): Likewise.
+	(arc_jtag_write_chunk): Likewise.
+	(arc_jtag_read_chunk): Likewise.
+	(arc_jtag_open): Likewise.
+	(arc_jtag_close): Likewise.
+	(arc_jtag_wait): Likewise.
+	(tapc_shift4bits):Remove.
+		
+2005-05-05  Ramana Radhakrishnan <ramana.radhakrishnan@codito.com>
+
+	* arc-jtag-ops.c, arc-jtag-ops.h: Add copyright notice.
+
+2005-05-05  Ramana Radhakrishnan <ramana.radhakrishnan@codito.com>
+
+	* arc-jtag.c:debug_arc_jtag_target_messages New variable. 
+	(_initialize_arc_debug):Use above. Add a new boolean command, 
+	arcjtag-debug-target to print debug target messages.
+
+2005-05-05  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag.c (arc_debug_open): Print message on success.
+
+2005-05-05  Sameer Dhavale  <sameer.dhavale@codito.com>
+
+        PR arcgdb/1270
+	* arc-jtag-ops.c (tapc_pulse): Remove cals to clock delay to
+	achieve download speed-up.
+	(arc_jtag_read_core_reg): Add a call to tapc_reset() before
+	reading any register.
+	(arc_jtag_write_core_reg): Add a call to tapc_reset() before
+	writing any register. 
+	(arc_jtag_read_aux_reg): Add transition to run-test-idle state in
+	the wait loop.
+	(arc_jtag_read_aux_reg): Add a call to tapc_reset() before reading
+	any aux register.
+	(arc_jtag_write_chunk): Add a fix to support the writes to memory
+	which are not integral multiples of four.
+	(arc_jtag_read_chunk): Add a fix to support the reads from memory
+	which are not integral multiples of four.
+	(_initialize_arc_jtag_ops): Add entries to initialize read/write
+	core registers.
+	* arc-jtag-tdep.c (arc_jtag_init): Add to initialize
+	tdep->sigtramp_p to NULL. This avoids the segmentation fault.
+	* arc-jtag.c (arc_debug_open): Disable Dcache and Icache.
+	(arc_debug_xfer_partial): Add fix for address alignment.
+	(arc_debug_insert_breakpoint): Modify to support ARC700 specific
+	breakpoint.
+	(arc_debug_remove_breakpoint): Modify to support ARC700 specific
+	breakpoint.
+	
+
+2005-05-04  Ramana Radhakrishnan  <ramana@codito.com>
+
+	* arc-jtag-ops.c: Correct ioperms error messages. 
+	Setup read_core_register correctly.
+
+2005-05-04  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	PR arcgdb/1267
+	* arc-jtag-ops.h: Add new enum arc_jtag_status for housekeeping. 
+	  (arc_jtag_ops):Add data member to this. 
+	* arc-jtag-ops.c: #define printf to printf_filtered when used 
+	in gdb. 
+	(port_perms_setup):Return error message in case of errors
+	(arc_jtag_close):Call tapc_reset only when the JTAG is not 
+	already closed. 
+	
+2005-05-03  Soam Vasani  <soam.vasani@codito.com>
+
+	PR arcgdb/1260
+	* arc-tdep.h (struct gdbarch_tdep): Add member lowest_pc, which is
+	initialized in the linux or jtag tdep files.  It's meant to stop
+	backtraces at the entry point (_start).
+	* arc-tdep.c (arc_frame_this_id): Don't set frame_id if 
+	func <= lowest_pc.
+	* arc-linux-tdep.c (arc_linux_init_abi): Init lowest_pc to 0x74.
+	* arc-jtag-tdep.c (arc_jtag_init): Init lowest_pc to 0.
+	
+2005-05-03  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-tdep.c (arc_software_single_step): We cannot single-step
+	single instruction zero overhead loops and branch-to-self's.  Step
+	over them and print a warning.
+
+2005-05-02  Sameer Dhavale <sameer.dhavale@codito.com>
+
+	PR arcgdb/1265
+	* arc-jtag-ops.h (arc700_hw_regnums): Add entries to map LP_START
+	and LP_END registers.
+	* arc-jtag.c (arc_debug_store_regs): Add register mapping from
+	gdbarch register numbers to hardware register numbers.
+	(arc_debug_fetch_regs): Add register mapping from
+	gdbarch register numbers to hardware register numbers.
+
+2005-04-29  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-tdep.c (arc_gdbarch_init): Move the call of
+	set_gdbarch_software_single_step to arc-linux-tdep.c.
+	* arc-linux-tdep.c (arc_linux_init_abi): Set gdbarch software
+	single step.
+
+2005-04-28  Soam Vasani  <soam.vasani@codito.com>
+
+	* config/arc/tm-embed.h (enum arc700_jtag_regnums): Fix mistakes
+	in numbering.
+
+2005-04-28  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-tdep.c (arc_scan_prologue): Pass stream and fprintf_func to
+	init_disassemble_info, to be used in case of a memory error.
+
+2005-04-28  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-tdep.c (arc_scan_prologue): Handle R27 along with other
+	callee-saved registers.
+
+2005-04-27  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-jtag.c (arc_debug_wait): Setup control-C signal handler.
+	(arc_debug_interrupt): New function; handler for SIGINT.
+	(arc_debug_interrupt_twice): New function; called when user does
+	control-C twice.
+
+2005-04-26  Soam Vasani <soam.vasani@codito.com>
+
+	* arc-tdep.c (arc_register_name): Moved to arc-linux-tdep.c and
+	arc-jtag-tdep.c.
+	(arc_register_reggroup_p): Save/restore reggroups contain all
+	writable registers.
+	* arc-tdep.h (arc700_api_regnums): Define ARC_ARGx_REGNUMs and
+	ARC_RETURNx_REGNUMs.
+	(arc700_regnums): Moved to tm-linux.h and tm-embed.h.
+	(gdbarch_tdep): Removed member register_name.
+	gdbarch_register_name is now in arc-linux-tdep.c and
+	arc-jtag-tdep.c.
+	* arc-linux-tdep.c (arc700_linux_regnums): Moved to
+	config/arc/tm-linux.h.
+	(arc_linux_register_name): Names for all the registers in linux.
+	Moved from arc-tdep.c.
+	* arc-jtag.h (arc700_jtag_regnums): Moved to
+	config/arc/tm-embed.h.
+	* arc-jtag-tdep.c (arc_jtag_register_name): Names for all the
+	registers.  Moved from arc-tdep.c.
+	(arc_jtag_pseudo_register_read, arc_jtag_pseudo_register_write):
+	Removed; no pseudo registers when using JTAG.
+	* config/arc/tm-embed.h (arc700_jtag_regnums): Define all the
+	basecase registers (core as well as aux).  Renamed the
+	ARC_*_PSEUDO_REGNUMs to ARC_*_REGNUMs; changed references
+	appropriately.
+	* config/arc/tm-linux.h (arc700_linux_regnums): Define all the
+	registers that linux/ptrace gives.
+
+2005-04-25  Sameer Dhavale  <sameer.dhavale@codito.com>
+
+	* arc-jtag-ops.h: Add
+	Previous commit did not actually add the file to cvs.  So adding it
+	via this commit. 
+
+2005-04-22  Soam Vasani <soam.vasani@codito.com>
+
+	* arc-linux-tdep.c (arc_linux_skip_solib_resolver): New function;
+	skip uClibc's runtime resolver.
+	* arc-linux-tdep.c (arc_linux_init_abi): Set gdbarch
+	fetch_link_map_offset and skip_solib_resolver.
+	* config/arc/linux.mt (TDEPFILES): Remove glibc-tdep, we don't
+	need it.
+
+2005-04-20  Sameer Dhavale  <sameer.dhavale@codito.com>
+
+	PR arcgdb/1242
+	* arc-jtag-ops.h: Add 
+	(jtag_ops): New structure defined.
+	* arc-jtag-ops.c: Add
+	(port_perms_setup): New function. Add to set desired permissions
+	for port access.
+	(tapc_set_tms): New function. Add for Setting value to TMS pin of JTAG
+	port.
+	(tapc_set_tck): New function. Add for setting or resetting TCK pin
+	of JTAG port.
+	(tapc_set_tdi): New function. Add for sending data into JTAG
+	module via TDI input pin.
+	(clockdelay): New function. Add to generate required pulse width.
+	(tapc_pulse): New function. Add to generate pulse over TCK.
+	(tapc_reset): New function. Add to reset the JTAG state machine
+	(tapc_tms): New function. Add to set or reset the TMS pin of JTAG
+	port.
+	(tapc_readbit): New function. Add to read a single bit from TDO
+	pin of JTAG port.
+	(tapc_shiftbit): New function. Add to shift in one bit through TDI
+	and simultaneously shift out bit through TDO.
+	(tapc_shiftnbits): New function. Add to shift n bits in either
+	LSB-first or MSB-first fashion.
+	(read_jtag_status_reg): New function. Add to read the status of
+	transaction being requested by JTAG module.
+	(write_jtag_reg): New function. Add to write to any internal
+	registers of JTAG module.
+	(read_jtag_reg): New function. Add to read from any internal
+	register of JTAG.
+	(read_core_reg): New function. Add to read from any core register
+	of ARC700 via JTAG.
+	(write_core_reg): New function. Add to write to any core register
+	of ARC700 via JTAG.
+	(arc_jtag_read_aux_reg): New function. Add to write to any auxillary
+	register of ARC700 via JTAG.
+	(arc_jtag_write_aux_reg): New function. Add to write to any
+	auxillary register of ARC700 via JTAG.
+	(read_mem): New function. Add to read 4 bytes from memory.
+	(write_mem): New function. Add to write 4 bytes at a specified
+	memory location.
+	(arc_jtag_write_chunk): New function. Add to write to a stream of
+	data starting from the specified memory location. This function
+	makes use of speacial feature supported by ARC-JTAG for streaming
+	data.
+	(arc_jtag_read_chunk): New function. Add to read a stream of
+	data starting from the specified memory location. This function
+	makes use of speacial feature supported by ARC-JTAG for streaming
+	data. 
+	(arc_jtag_open): New function. Add to provide target specific open
+	function for GDB backend. This function sets port permissions and
+	resets JTAG state machine.
+	(arc_jtag_close): New function. Add to provide target specific
+	close function to GDB backend.
+	(arc_jtag_wait): New function. Add to poll the status32 register
+	of ARC700 till the processor is halted.
+	(_initialize_arc_jtag_ops): New function. Add to initialize
+	function pointers for structure arc_jtag_ops.
+	* gdb/config/arc/embed.mt (TDEPFILES): Add entry for
+	arc-jtag-ops.o
+	
+2005-04-20  Sameer Dhavale  <sameer.dhavale@codito.com>
+
+	PR arcgdb/1241
+	* target.c (target_read_memory_partial): Correct the handling of
+	variable err depending on the value returned
+	target_xfer_partial().
+	(target_write_memory_partial): Correct the handling of
+	variable err depending on the value returned
+	target_xfer_partial(). 
+??? patch sites don't exist any more, need to check for regression.
+
+2005-04-19  Soam Vasani <soam.vasani@codito.com>
+
+	* arc-jtag.h (enum arc700_jtag_regnums): Add debug register.
+	* arc-jtag-tdep.c (arc_jtag_register_name): Ditto.
+
+2005-04-19  Soam Vasani <soam.vasani@codito.com>
+
+	* arc-jtag.h: New file, defines arc700_jtag_regnums.
+
+2005-04-19  Soam Vasani <soam.vasani@codito.com>
+
+	* arc-tdep.c (ARC_ILINK1_PSEUDO_REGNUM, ARC_ILINK2_PSEUDO_REGNUM,
+	ARC_ERET_PSEUDO_REGNUM, ARC_STATUSL1_PSEUDO_REGNUM,
+	ARC_STATUSL2_PSEUDO_REGNUM, ARC_ERSTATUS_PSEUDO_REGNUM): Move to
+	arc-tdep.h.
+	(arc_pseudo_register_read, arc_pseudo_register_write,
+	arc_print_registers_info): Move to arc-linux-tdep.c and
+	arc-jtag-tdep.c.
+	(arc_register_name): Registers are split into 3 classes: the
+	registers common to both linux and jtag; registers available only
+	in one of the two targets; and pseudo registers.  Common registers
+	and pseudo-registers have their names defined here; for other
+	registers, call tdep->register_name.
+	(arc_register_reggroup_p): Call tdep->register_reggroup_p, for the
+	target-specific registers.
+	(arc_sigtramp_frame_prev_register): Use
+	tdep->pc_regnum_in_sigcontext rather than ARC_RET_REGNUM directly.
+	(arc_gdbarch_init): Do not assume OSABI = Linux.  Instead, get the
+	OSABI from the new CONFIG_OSABI macro in tm-<target>.h file.
+	Move to arc-linux-tdep.c and arc-jtag-tdep.c: Set
+	gdbarch_num_regs, gdbarch_pc_regnum, gdbarch_pseudo_register_read,
+	gdbarch_pseudo_register_write, gdbarch_print_registers_info.
+	Call CONFIG_INIT_TDEP, which is a macro defined in tm-<target>.h.
+	
+	* arc-linux-tdep.c: (enum arc700_linux_regnums): Moved here from
+	arc-tdep.h, so that arc-tdep.c cannot see them.  Contains the
+	registers that linux makes up, but do not actually exist on the
+	processor.  Also, change ARC_RET_REGNUM such that it is after all
+	the common registers.
+	(arc_linux_register_name): Names of the arc700_linux_regnums.
+	(arc_linux_pseudo_register_read): Moved from arc-tdep.c.  Here
+	we'll use orig_r8 to get the pseudo-registers.
+	(arc_linux_pseudo_register_write): Moved from arc-tdep.c.
+	(arc_linux_print_registers_info): Moved from arc-tdep.c.  Register
+	sets are different for different targets.
+	(arc_linux_sc_reg_offset): ARC_RET_REGNUM was changed, so changed
+	this appropriately.
+	(arc_linux_init_abi): Set tdep->pc_regnum_in_sigcontext to
+	ARC_RET_REGNUM (see comment in arc-tdep.h).  Set
+	tdep->register_name to arc_linux_register_name.  
+	And moved from arc-tdep.c: Set gdbarch_num_regs,
+	gdbarch_pc_regnum, gdbarch_pseudo_register_read,
+	gdbarch_pseudo_register_write, gdbarch_print_registers_info.
+	(arc_linux_register_reggroup_p): Register groups for linux-only
+	registers.
+
+	* arc-jtag-tdep.c: New file.  Define the breakpoint intruction,
+	register_name, pseudo register read/write, register_reggroup_p,
+	and print_registers_info.
+
+	* arc-tdep.h (enum arc700_regnums): Remove linux-only regnums like
+	ARC_RET_REGNUMS.
+	(ARC_ILINK1_PSEUDO_REGNUM, ARC_ILINK2_PSEUDO_REGNUM,
+	ARC_ERET_PSEUDO_REGNUM, ARC_STATUSL1_PSEUDO_REGNUM,
+	ARC_STATUSL2_PSEUDO_REGNUM, ARC_ERSTATUS_PSEUDO_REGNUM): Moved
+	from arc-tdep.c.  Though the regnums are different across targets
+	for these registers, the macros are same because the regnums are
+	define in terms of NUM_REGS.
+	(struct gdbarch_tdep): New fields: pc_regnum_in_sigcontext,
+	register_reggroup_p.
+
+	* config/arc/embed.mt (TDEPFILES): Add arc-jtag-tdep.o to this
+	list.	
+
+	* config/arc/tm-embed.h (CONFIG_OSABI, CONFIG_INIT_TDEP): New macros.
+	* config/arc/tm-linux.h (CONFIG_OSABI, CONFIG_INIT_TDEP): Ditto.
+	
+	* gdbserver/linux-arc-low.c (arc_regmap): ARC_RET_REGNUM was
+	changed in GDB, change this appropriately.
+	* regformats/reg-arc.dat: Ditto.
+	
+2005-04-12  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* arc-jtag.c: Add copyright, add comments to each of the 
+	functions explaining their role. 
+
+2005-04-08  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* arc-tdep.c(arc_print_float_info): New function. 
+	  (gdbarch_init):Initialize gdbarch_print_float_info.
+
+2005-04-07  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	PR arcgdb/1198
+	* arc-tdep.c(arc_push_dummy_call):Correct handling for
+	structures.Move initial assignment of structure address
+	above initialization.
+	(arc_frame_align): Align frame to natural boundary.
+
+2005-04-06  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	PR arcgdb/1194 
+	* arc-tdep.c(arc_push_dummy_call):Correct limit check. The ARC has
+	8 parameter registers.
+	* arc-tdep.h(enum arc700_regnums):Add ARC_ARG7_REGNUM.
+
+2005-04-04  Sameer Dhavale <sameer.dhavale@codito.com>
+
+	PR arcgdb/1189
+	* arc-jtag.c(): Add
+	  (struct arc_jtag_ops): New structure. Add to support
+	arcjtag target operations.
+	  (arc_jtag_open): New function. Add for initializations.
+	  (arc_jtag_attach): New function. Add for attaching to already
+	  running targets.
+	  (arc_jtag_detach): New function. Add for detaching from a
+	  target.
+	  (arc_jtag_resume): New function. Make the inferior to resume
+	  execution.
+	  (arc_jtag_wait): New function.
+	  (arc_jtag_fetch_regs): New function. Put values in register
+	  cache.
+	  (arc_jtag_store_regs): New function.
+	  (arc_jtag_prepare_to_store): New function.
+	  (arc_jtag_xfer_memory): New function.
+	  (arc_jtag_files_info): New function.
+	  (arc_jtag_insert_breakpoint): New function.
+	  (arc_jtag_remove_breakpoint): New function.
+	  (arc_jtag_kill): New function.
+	  (arc_jtag_load): New function.
+	  (arc_jtag_create_inferior): New function.
+	  (arc_jtag_mourn_inferior): New function.
+	  (arc_jtag_thread_alive): New function.
+	  (arc_jtag_stop): New function.
+	  (init_arc_jtag_ops): New function. Initialize jtag_target_ops to
+	  values appropriate for arcjtag target.
+	  (_initialize_arc_jtag): New function. Add a new target to gdb.
+	* config/arc/embed.mt: Add change to include arc-jtag.o so that
+	new target should be automatically built with arc-elf32.
+	 
+2005-04-03  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	PR arcgdb/1185
+	* arc-tdep.c(arc_write_pc): Remove. 
+	  (arc_gdbarch_init): Remove initialization of write_pc.
+	* arc-linux-tdep.c(arc700_linux_write_pc): New function . Add
+	fix for orig_r8 hack.
+	 (arc_linux_init_abi): Set gdbarch_init to arc700_linux_write_pc.
+
+2005-04-03  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	PR arcgdb/1184
+	* arc-tdep.h(struct gdbarch_tdep): Add members breakpoint_insn
+	and breakpoint_size.
+	* arc-tdep.c(arc_breakpoint_from_pc): Return gdbarch_tdep value
+	for software bp instructions to be used. 
+	* arc-linux-tdep.c(arc_linux_init_abi): Initialize the tdep for 
+	arc700_linux_default_breakpoints. 
+	  arc700_linux_breakpoint_insn:New breakpoint insn for ARC700
+	  linux.
+	  arc700_linux_breakpoint_size:New breakpoint size for ARC700 
+	  linux.
+
+2005-04-03  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* arc-tdep.c(arc_linux_write_pc):Correct comment for orig_r8.
+
+2005-04-02  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* version.in: should have been 20050401.
+
+2005-04-01  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* version.in: Bump up version for release.
+	
+2005-04-01  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+	
+	* ChangeLog.codito: Remove more spurious entries.
+
+	PR arcgdb/1175
+	* arc-tdep.c(arc_push_dummy_call): New function.
+	  (push_stack_item):New function.
+	  (pop_stack_item):New function.
+	  (arc_add_reggroups_p):Register system_reggroup.
+	  (arc_register_reggroup_p):Add orig_r8 to system_reggroup.
+	  (arc_linux_write_pc):	Set orig_r8 to -3 to work correctly 
+	  dummy frames and signal handlers. Fixes failures in signals.exp.
+	  (arc_gdbarch_init):Set dummy call to use arc_push_dummy_call. 
+	  Set breakpoint for dummy code at entry point.
+	  Register arc_linux_write_pc.
+	* ChangeLog.codito: Remove spurious Changelog entry.
+
+2005-04-01  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* arc-tdep.h: Add enum arc700_regnums for ARC register types. 
+
+
+
+2005-03-30  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	PR arcgdb/1172
+	* arc-tdep.c(arc_scan_prologue): Skip over argument save
+	registers. 
+
+2005-03-28  Ramana Radhakrishnan  <ramana@codito.com>
+
+<	* arc-tdep.c: Add contribution tag. 
+	  (printFrameInfo): Conditionally compile with ARC_DEBUG.
+	  (printInsnState): Likewise.
+	  (UPDATESTACKSPACE): Correct for variadic args. 
+	  (PUSHBLINKFI): Correct for variadic args. 
+	  (ISSUBSPFI): Update for mixed code.
+	  (arc_scan_prologue): Update prologue description and correct.
+	  (arc_scan_prologue): Clean up declarations. 
+	  Handle callee saves, Handle 16 bit ARCompact insns.
+	
+
+2005-03-21  Soam Vasani  <soam.vasani@codito.com>
+
+	* arc-tdep.c (arc_gdbarch_init): Assume OSABI = Linux for now.
+	Call gdbarch_init_osabi.
+	* arc-linux-tdep.c (_initialize_arc_linux_tdep): Pass machine = 0
+	to gdbarch_register_osabi.
+
+2005-03-20  Soam Vasani <soam.vasani@codito.com>
+
+	PR gdb/1098
+	* arc-tdep.c(arc_cannot_store_register): Don't print warning.
+	  (arc_register_reggroup_p): Remove read-only registers from 
+	  save/restore reggroups.
+
+2005-03-17  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* arc-linux-tdep.c:Add copyright notice. 
+
+2005-03-17  Soam Vasani <soam.vasani@codito.com>
+
+	* gdb/arc-tdep.c: Cleanup and remove warnings.
+	* gdb/arc-linux-tdep.c: Ditto.
+
+2005-03-17  Soam Vasani <soam.vasani@codito.com>
+
+	* gdb/arc-linux-tdep.c (arc_sigtramp_insn): Defined.
+	  (arc_linux_sigtramp_p): Defined: check if PC is in a signal 
+	  trampoline.
+	  (arc_linux_sigcontext_addr): Defined: return the address of the
+	  sigcontext structure.
+	  (arc_linux_sc_reg_offset): Defined: mapping from regnum to
+	  sigcontext offset.
+	  (arc_linux_linux_init_abi): Defined: add stuff to gdbarch->tdep.
+	* gdb/arc-tdep.h (ARC_PC_REGNUM): Replaced by ARC_RET_REGNUM.
+	* gdb/arc-tdep.c (ARC_PC_REGNUM): Replace all references by either
+	  PC_REGNUM or ARC_RET_REGNUM.
+	  (arc_unwind_pc): Call the unwinder with PC_REGNUM instead of
+	  ARC_RET_REGNUM.  The unwinder will decide what register to give
+	  for PC_REGNUM, because PC_REGNUM itself is not a real register.
+	  (arc_sigtramp_frame_cache, arc_sigtramp_frame_this_id, 
+	  arc_sigtramp_frame_prev_register, arc_sigtramp_frame_unwind,
+	  arc_sigtramp_frame_sniffer): Defined.
+	  (arc_gdbarch_init): Append arc_sigtramp_frame_sniffer.
diff --git a/gdb/arc-jtag-ops.c b/gdb/arc-jtag-ops.c
new file mode 100644
index 0000000..0a237f6
--- /dev/null
+++ b/gdb/arc-jtag-ops.c
@@ -0,0 +1,1229 @@
+/* Target dependent code for ARC700, for GDB, the GNU debugger.
+
+   Copyright 2005 Free Software Foundation, Inc.
+
+   Contributed by Codito Technologies Pvt. Ltd. (www.codito.com)
+
+   Authors: 
+      Sameer Dhavale <sameer.dhavale@codito.com>
+      Soam Vasani <soam.vasani@codito.com>
+
+   This file is part of GDB.
+   
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+*/
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/io.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <assert.h>
+#include "arc-jtag-ops.h"
+#include "gpio.h"
+#include <signal.h>
+#include <defs.h>
+#include <sys/ioctl.h>
+#include "arc-tdep.h"
+#define printf printf_filtered
+
+
+unsigned int arcjtag_retry_count = 50;
+
+
+/* ------------------------------------ */
+/*         For ARC jtag Cable           */
+/*                                      */
+/* Pin no.  Signal           Word , Bit */
+/*                                      */
+/* - 	    TRST 	                */
+/* 8 	    TMS 	     Data 6     */
+/* 1 	    TCK 	     Control 0  */
+/* 9 	    TDI 	     Data 7     */
+/* 13 	    TDO 	     Status 4   */
+
+
+#define JTAG_TRST 0x00  /* not there */
+#define JTAG_TMS  0x40  /* data port */
+#define JTAG_TCK  0x01  /* control port. Driven Low. */
+
+#define JTAG_TDI  0x80  /* data port */
+#define JTAG_TDO  0x10  /* status port */
+
+/* ------------------------------------ */
+
+/* */
+#define A4_HALT_VALUE 0x02000000
+#define ARC700_HALT_VALUE 0x1
+
+
+/* Parallel port i/o addr. (LPT1) */
+#define DATA_PORT    0x378
+#define STATUS_PORT  0x379
+#define CONTROL_PORT 0x37A
+
+
+unsigned char tapc_dataport=0, tapc_statusport=0, tapc_controlport=0x1;
+int fd;
+struct GPIO_ioctl jtag_ioctl;
+sigset_t block_mask;
+
+enum AA3SSPinState
+  {
+    READ_FROM_AA3 = 0,
+    WRITE_TO_AA3 = 1
+  };
+enum AA3SSPinState rw_flag; 
+
+
+
+struct jtag_ops arc_jtag_ops;
+static enum ARCProcessorVersion ARCProcessor = UNSUPPORTED;
+
+
+/* Sanity check to give error if jtag is not opened at all. */
+
+static void 
+check_and_raise_error_if_jtag_closed (void)
+{
+  if( arc_jtag_ops.jtag_status == JTAG_CLOSED )
+    error ("JTAG connection is closed. Use target arcjtag first\n");
+}
+
+
+/* Initializations for GPIO interface */
+static int
+gpio_setup (void)
+{
+  fd=open("//dev//gpio",O_RDWR);
+  ioctl(fd,GPIO_IOC_HARDRESET);
+  ioctl(fd,GPIO_IOC_SET_PORT_BASE,0x378);
+  jtag_ioctl.inlen=0;
+  jtag_ioctl.outlen=0;
+  jtag_ioctl.inbuf=(unsigned char *)xmalloc(2*sizeof(unsigned char));
+  jtag_ioctl.outbuf=(unsigned char *)xmalloc(2*sizeof(unsigned char));
+  return 0;
+}
+
+void gpio_write(unsigned int port, unsigned char *data)
+{
+    jtag_ioctl.inlen=2;
+    jtag_ioctl.inbuf[1]=*data;
+    switch(port)
+    {
+    case DATA_PORT:
+	jtag_ioctl.inbuf[0]=0;
+	break;
+
+    case STATUS_PORT:
+	jtag_ioctl.inbuf[0]=1;
+	break;
+
+    case CONTROL_PORT:
+	jtag_ioctl.inbuf[0]=2;
+	break;
+	    
+    default:
+	error("Invalid port\n");
+    }
+
+ 
+    if(ioctl(fd,GPIO_IOC_DO_IO,&jtag_ioctl))
+	error("Failure writing to port 0x%x\n",port);
+
+}
+
+
+unsigned char gpio_read(unsigned int port)
+{
+    //jtag_ioctl.inbuf[1]=tapc_statusport;
+    jtag_ioctl.inlen=2;
+    jtag_ioctl.outlen=1;
+
+    switch(port)
+    {
+    case DATA_PORT:
+	jtag_ioctl.inbuf[0]=0x80;
+	break;
+
+    case STATUS_PORT:
+	jtag_ioctl.inbuf[0]=0x81;
+	break;
+
+    case CONTROL_PORT:
+	jtag_ioctl.inbuf[0]=0x82;
+	break;
+	    
+    default:
+	error("Invalid port\n");
+    }
+    
+    if(ioctl(fd,GPIO_IOC_DO_IO,&jtag_ioctl))
+	error("Failure reading from port 0x%x\n",port);
+	  
+    return jtag_ioctl.outbuf[0];
+
+
+}
+
+/* Helper functions for setting
+   TMS / TCK / TDI. Valid inputs
+   are 1 and 0. The tapc_<tms/tck/tdi> 
+   functions set the internal values 
+   to be written out to the port. The 
+   final values are written only by doing 
+   the pulse.
+ */
+
+static void
+tapc_set_tms (char x)
+{
+    if(x)
+	tapc_dataport |= JTAG_TMS;
+    else
+	tapc_dataport &= ~JTAG_TMS;
+
+    /* outb(tapc_dataport, DATA_PORT); */
+    gpio_write(DATA_PORT,&tapc_dataport);
+}
+
+
+/* Set TCK. */
+static void
+tapc_set_tck (char x)
+{
+  /* active low. The clock is active low. */
+    if(!x) 
+  	tapc_controlport |= JTAG_TCK;
+    else
+	tapc_controlport &= ~JTAG_TCK;
+    
+    if(rw_flag == READ_FROM_AA3)
+      tapc_controlport |= 0x4; 
+    else
+      tapc_controlport &= ~(0x4); 
+      
+    /* outb(tapc_controlport, CONTROL_PORT); */
+    gpio_write(CONTROL_PORT,&tapc_controlport);
+}
+
+
+static void
+tapc_set_tdi (char x)
+{
+    if(x)
+	tapc_dataport |= JTAG_TDI;
+    else
+	tapc_dataport &= ~JTAG_TDI;
+    
+    /* outb(tapc_dataport, DATA_PORT); */
+    gpio_write(DATA_PORT,&tapc_dataport);
+}
+
+/* Unused function clockdelay. Why not add a command
+ that allows the user to set the clock delay ? */
+
+static void
+clockdelay (void)
+{
+    int i;
+    //for (i=0; i<10; ++i)
+    
+    //   usleep(0);
+}
+
+/* Clock the JTAG on the ARC platform. */
+static void
+tapc_pulse (void)
+{
+    /* Control 0 bit is active low */
+    unsigned char temp;
+    assert( (tapc_controlport & JTAG_TCK) );  // clock should be zero on entry
+   
+    /* outb(tapc_controlport & ~JTAG_TCK, CONTROL_PORT); */
+    temp = tapc_controlport & ~JTAG_TCK;
+    gpio_write(CONTROL_PORT,&temp);
+   /*  outb(tapc_controlport, CONTROL_PORT); */
+    gpio_write(CONTROL_PORT,&tapc_controlport);
+    
+}
+
+/* All the JTAG state machine handlers.  */
+
+/* Reset the TAPC controller on the JTAG. 
+ */
+static void
+tapc_reset (void)
+{
+    /* from any state, these many ones should get us into "test-logic reset" 
+     */
+    tapc_set_tms(1);
+    tapc_set_tck(0);  /* want rising edge */
+    tapc_pulse();
+    tapc_pulse();
+    tapc_pulse();
+    tapc_pulse();
+    tapc_pulse();
+    tapc_pulse();
+}
+
+/* Set the tms to the value of the bit and 
+   clock the jtag. */
+
+static void
+tapc_tms (char x)
+{
+    tapc_set_tms(x);
+    tapc_pulse();
+}
+
+/* Read bit from the TDO of the JTAG. */
+static char
+tapc_readbit (void)
+{
+    if(gpio_read(STATUS_PORT) & JTAG_TDO)
+	return 1; 
+    else
+	return 0;
+}
+
+
+/* Interface functions that use the below mentioned 
+   JTAG state machine handler functions. 
+*/
+
+/* Shift one bit out on the JTAG TDI. */
+static char
+tapc_shiftbit (char x)
+{
+    char read;
+
+    //printf("tapc_shiftbit: Shifted %d\n", x);
+
+    read = tapc_readbit();    
+    tapc_set_tdi(x);
+    tapc_pulse();
+
+    return read;
+}
+
+
+/*
+ * Shift N bits from to_write into TDI, and out from TDO into read.
+ *
+ * If msb_first=0, shift LSB first, starting from to_write[0], to_write[1],
+ * etc.
+ 
+ * If msb_first=1, shift to_write[-1] MSB first, then to_write[-2] etc.
+ *
+ * Must be called in Shift DR/IR state.
+ * Leaves in Exit1 DR/IR state.
+ */ 
+static void
+tapc_shiftnbits (int n, 
+		unsigned char *to_write, 
+		unsigned char *read, 
+		char msb_first)
+{
+    unsigned char outbyte, inbyte;
+    int nbytes = (n-1)/8 + 1,limit=8;
+    int i, j;
+
+    for(i=0; i < nbytes; ++i)
+    {
+	if(msb_first)
+	    outbyte = to_write[-1-i];
+	else	   
+	    outbyte = to_write[i];
+
+	inbyte = 0;
+	/* should write a maximum of 8 bits */
+	if(i == nbytes-1)
+	    limit = ((n-1) % 8) + 1;  
+	
+	for(j = 0; j < limit; ++j)
+	{
+	    unsigned char outbit, inbit;
+
+	    if(msb_first)
+		outbit = !!(outbyte & 0x80);
+	    else
+		outbit = outbyte & 1;
+	    /* the last bit of the last byte */
+	    /* transition to EXIT-1 state before last bit */
+	    if((i == nbytes-1)&&(j == limit-1)) 
+	      tapc_set_tms(1); 
+	    
+	    inbit = tapc_shiftbit(outbit);
+
+	    if(msb_first)
+	      {
+		inbyte |= (inbit << (7-j));
+		outbyte <<= 1;
+	      }
+	    else
+	      {
+		inbyte |= inbit << j;
+		outbyte >>= 1;
+	    }
+	}
+
+	//tapc_tms(1);
+	if(msb_first)
+	    read[-1-i] = inbyte;
+	else
+	    read[i] = inbyte;
+    }
+}
+
+
+/* Read the JTAG status register. This indicates
+   the status of the JTAG for the user. 
+*/
+static unsigned int
+read_jtag_status_reg (void)
+{
+    unsigned int wr, rd;
+    int x;
+    //rw_flag=0;
+    //tapc_tms(0); // runtest/idle
+    tapc_tms(1); // select dr
+    tapc_tms(1); // select ir
+    tapc_tms(0); // capture ir
+    tapc_tms(0); // shift ir
+
+    wr = 0x8;    // IR = status register
+
+    tapc_shiftnbits(4, (unsigned char *)&wr, (unsigned char*)&rd, 0);
+
+    
+    
+    // goto shift DR
+    tapc_tms(1); // update ir
+    //tapc_tms(0); // runtest/idle
+    tapc_tms(1); // select dr
+    tapc_tms(0); // capture dr
+    tapc_tms(0); // shift dr
+
+    rd = 0;
+
+    // read 1 bit, if it is zero then keep reading
+    rd = tapc_shiftbit(0);
+    if (rd)
+	return rd; 
+
+    rd |= tapc_shiftbit(0) << 1;
+    if (rd)
+	return rd;
+    
+    rd |= tapc_shiftbit(0) << 2;
+
+    /* the last bit is optional */
+    /*rd |= tapc_shiftbit(0) << 3;*/
+    
+    return rd;    
+}
+
+
+/* Interpret the status message. */
+static void
+print_jtag_status_reg_val (unsigned int status)
+{
+    int i ;
+    char * messages [] = { "Stalled" , "Failure", "Ready", "PC Selected" };
+    for(i=0;i<=3;i++)
+    {
+	printf_filtered("%s %s \t",(status & 1)?"":"Not",messages[i]);
+	status = status >> 1;
+    }
+    printf_filtered("\n");
+}
+
+
+
+/* Write a JTAG Command to a JTAG register. 
+   enter in update dr/ir state
+   or Test-Logic-Reset.
+   exit in update dr
+*/
+static void
+write_jtag_reg (char regnum, unsigned int data, int ndatabits)
+{
+    unsigned int wr=0,rd=0;
+    rw_flag = WRITE_TO_AA3 ;
+    //    tapc_tms(0); // runtest/idle
+    tapc_tms(1); // select dr
+    tapc_tms(1); // select ir
+    tapc_tms(0); // capture ir
+    tapc_tms(0); // shift ir
+
+		
+    tapc_shiftnbits(4, (unsigned char *)&regnum, (unsigned char *)&rd, 0);
+
+    
+    tapc_tms(1); // update ir
+
+    tapc_tms(1); // select dr
+    tapc_tms(0); // capture dr
+    tapc_tms(0); // shift dr
+
+    tapc_shiftnbits(ndatabits, (unsigned char *)&data, 
+		    (unsigned char *)&rd, 0);
+    tapc_tms(1); // update dr
+}
+	    
+
+// enter in update dr/ir state
+// exit in update dr
+static unsigned int
+read_jtag_reg (char regnum, int ndatabits)
+{
+    unsigned int wr=0x0,rd=0;
+    rw_flag = READ_FROM_AA3;
+    //    tapc_tms(0); // runtest/idle
+    tapc_tms(1); // select dr
+    tapc_tms(1); // select ir
+    tapc_tms(0); // capture ir
+    tapc_tms(0); // shift ir
+
+    tapc_shiftnbits(4, (unsigned char *)&regnum, (unsigned char *)&rd, 0);
+    tapc_tms(1); // update ir
+
+    /* JTAG registers can be read without going to run-test/idle state.
+       
+       Doing tapc_tms(0) will take us to run-test/idle state.
+       This will make JTAG perform the transaction as per TCR.
+       We dont want this. 
+    */
+    //    tapc_tms(0); // runtest/idle
+    tapc_tms(1); // select dr
+    tapc_tms(0); // capture dr
+    tapc_tms(0); // shift dr
+
+    tapc_shiftnbits(ndatabits, (unsigned char *)&wr, (unsigned char *)&rd, 0);
+    tapc_tms(1); // update dr
+
+    return rd;
+}
+
+
+
+    
+    
+
+
+
+static int
+arc_jtag_read_core_reg (unsigned int regnum, unsigned int *readbuf)
+{
+    unsigned int rd, wr, data, i;
+    check_and_raise_error_if_jtag_closed();
+    tapc_reset();
+    tapc_tms(0);//run-test idle
+    write_jtag_reg(0xA, regnum, 32);//update dr
+
+    
+
+    // Setup instruction register to 0x9 indicating
+    // a JTAG instruction is being downloaded.
+    // jtag transaction command reg = 0x5 (read core reg)
+    write_jtag_reg(0x9, 0x5, 4);//update dr
+
+    /* Perform the transaction.
+     */
+    tapc_tms(0); // run-test idle
+    
+    // poll the status
+
+    for (i=0;i<arcjtag_retry_count;i++)
+    {
+	unsigned int status = read_jtag_status_reg();
+	//if( !(status & 1) && (status & 4) )
+	if(status == 4)
+	    break;
+	if(status == 2)
+	    return JTAG_READ_FAILURE;
+	tapc_tms(1);//exit1-dr
+	tapc_tms(1);//update-dr
+	/* Do not redo the transaction. Pause and re-try.
+	 */
+	//tapc_tms(0);//run-test-idle
+    }
+    if (i==arcjtag_retry_count)
+      return JTAG_READ_FAILURE;
+
+    /* JTAG status register leaves us in Shift DR */
+    tapc_tms(1); /* Move to Exit-1 DR */
+    tapc_tms(1); /* Move to Update DR */
+    
+    // data = jtag data reg
+    data = read_jtag_reg(0xB, 32);
+
+    *readbuf = data;
+    
+    return sizeof(data);
+}
+
+static int
+arc_jtag_write_core_reg (unsigned int regnum, unsigned int data)
+{
+    unsigned int rd, wr, i;
+
+    check_and_raise_error_if_jtag_closed();
+    tapc_reset();
+    tapc_tms(0);//run-test idle
+
+    // data = jtag data reg
+    write_jtag_reg(0xB, data, 32);//update dr
+
+    // jtag addr register = regnum:
+    write_jtag_reg(0xA, regnum, 32);//update dr
+    
+    
+
+    // jtag transaction command reg = 0x1(write core reg)
+    write_jtag_reg(0x9, 0x1, 4);//update dr
+
+    /* Perform the transaction.
+     */
+    tapc_tms(0); // run-test idle
+    
+    for (i=0;i<arcjtag_retry_count;i++)
+    {
+      unsigned int status = read_jtag_status_reg();
+      	if(status == 4)
+	    break;
+	if(status == 2)
+	    return JTAG_WRITE_FAILURE;
+	tapc_tms(1);//exit1-dr
+	tapc_tms(1);//update-dr
+	/* Do not redo the transaction. Pause and re-try.
+	 */
+	//tapc_tms(0);//run-test-idle
+    }
+    if (i==arcjtag_retry_count)
+      return JTAG_READ_FAILURE;
+
+    tapc_tms(1);//exit1-dr
+    tapc_tms(1);//update-dr
+    /* This should have been done earlier i.e. before
+       reading the JTAG status register.
+     */
+    //tapc_tms(0);//rn-test-idle
+    return sizeof(data);
+}
+
+static int
+arc_jtag_read_aux_reg (unsigned int regnum, unsigned int *readbuf)
+{
+    unsigned int rd, wr, data, i;
+    if(arc_jtag_ops.arc_jtag_state_machine_debug)
+      printf_filtered("\nEntered arc_jtag_read_aux_reg()\
+         \n Regnum:%d \n",regnum);
+    check_and_raise_error_if_jtag_closed();
+    check_and_raise_error_if_jtag_closed();
+    tapc_reset();
+    tapc_tms(0);//run-test idle
+    write_jtag_reg(0xA, regnum, 32);//update dr
+
+
+
+    // Setup instruction register to 0x9 indicating
+    // a JTAG instruction is being downloaded.
+    // jtag transaction command reg = 0x6 (read aux reg)
+    write_jtag_reg(0x9, 0x6, 4);//update dr
+
+    /* Perform the transaction.
+     */
+    tapc_tms(0); // run-test idle
+
+    // poll the status
+
+    for (i=0;i<arcjtag_retry_count;i++)
+    {
+	unsigned int status = read_jtag_status_reg();
+	
+	if(status == 4)
+	    break;
+	if(status == 2)
+	    return JTAG_READ_FAILURE;
+	tapc_tms(1);//exit1-dr
+	tapc_tms(1);//update-dr
+	/* Do not redo the transaction. Pause and re-try.
+	 */
+	//tapc_tms(0);//run-test-idle
+
+    }
+    if (i==arcjtag_retry_count)
+      return JTAG_READ_FAILURE;
+
+
+/*     JTAG status register leaves us in Shift DR */
+    tapc_tms(1); /* Move to Exit-1 IR */
+    tapc_tms(1); /* Move to Update IR */
+    
+    // data = jtag data reg
+    data = read_jtag_reg(0xB, 32);
+    *readbuf = data;
+    if(arc_jtag_ops.arc_jtag_state_machine_debug)
+      printf(" Data: %d\n",data);
+    return sizeof(data);
+}
+
+static int
+arc_jtag_write_aux_reg (unsigned int regnum, unsigned int data)
+{
+    unsigned int rd, wr, i;
+    if(arc_jtag_ops.arc_jtag_state_machine_debug)
+      printf_filtered("\nEntered arc_jtag_write_aux_reg()\n Regnum:%d\nData:%d\n",regnum,data);
+    check_and_raise_error_if_jtag_closed();
+    tapc_reset();
+    tapc_tms(0);//run-test idle
+    
+    // data = jtag data reg
+    write_jtag_reg(0xB, data, 32);//update dr
+
+    // jtag addr register = regnum:
+    write_jtag_reg(0xA, regnum, 32);//update dr
+    
+    
+
+    // jtag transaction command reg = 0x2 (write aux reg)
+    write_jtag_reg(0x9, 0x2, 4);//update dr
+
+    /* Perform the transaction.
+     */
+    tapc_tms(0); // run-test idle
+
+    for (i=0;i<arcjtag_retry_count;i++)
+    {
+	unsigned int status = read_jtag_status_reg();
+	if(status == 4)
+	    break;
+	if(status == 2)
+	    return JTAG_WRITE_FAILURE;
+	tapc_tms(1);//exit1-dr
+	tapc_tms(1);//update-dr
+	/* Do not redo the transaction. Pause and re-try.
+	 */
+	//tapc_tms(0);//run-test-idle
+    }
+    if (i==arcjtag_retry_count)
+      return JTAG_READ_FAILURE;
+
+	tapc_tms(1);//exit1-dr
+	tapc_tms(1);//update-dr
+	/* This should have been done earlier i.e. before
+	   reading the JTAG status register.
+	*/
+	//tapc_tms(0);//run-test-idle
+	return sizeof(data);
+}
+
+
+static int
+read_mem (unsigned int addr, unsigned int *readbuf)
+{
+    unsigned int rd, wr, data, i;
+
+    rw_flag = READ_FROM_AA3;
+    if(arc_jtag_ops.arc_jtag_state_machine_debug)
+      printf_filtered("\nEntered read_mem() 0x%x\n",addr);
+    // jtag addr register = regnum:
+    tapc_reset();
+    tapc_tms(0);//run-test idle
+    write_jtag_reg(0xA, addr, 32);//update dr
+
+    
+
+    // Setup instruction register to 0x9 indicating
+    // a JTAG instruction is being downloaded.
+    // jtag transaction command reg = 0x5 (read core reg)
+    write_jtag_reg(0x9, 0x4, 4);//update dr
+
+    /* Perform the transaction.
+     */
+    tapc_tms(0); // run-test idle
+
+    // poll the status
+
+    for (i=0;i<arcjtag_retry_count;i++)
+    {
+	unsigned int status = read_jtag_status_reg();
+	if(status == 4)
+	    break;
+	if(status == 2)
+	    return JTAG_READ_FAILURE;
+	tapc_tms(1);//exit1-dr
+	tapc_tms(1);//update-dr
+	/* Do not redo the transaction. Pause and re-try.
+	 */
+	//tapc_tms(0); // run-test-idle
+    }
+    if (i==arcjtag_retry_count)
+      return JTAG_READ_FAILURE;
+
+    /* JTAG status register leaves us in Shift DR */
+    tapc_tms(1); /* Move to Exit-1 DR */
+    tapc_tms(1); /* Move to Update DR */
+    
+    // data = jtag data reg
+    data = read_jtag_reg(0xB, 32);
+    *readbuf = data;
+    if(arc_jtag_ops.arc_jtag_state_machine_debug)
+    printf_filtered("\n Read rd =0x%x in read_mem",data);
+
+    return sizeof(data);
+}
+
+
+static int
+write_mem (unsigned int addr, unsigned int data)
+{
+    unsigned int rd, wr, i;
+    if(arc_jtag_ops.arc_jtag_state_machine_debug)
+      printf_filtered("\nEntered write_mem() to write 0x%x at 0x%x\n",data,addr);
+    tapc_reset();
+    tapc_tms(0);//run-test idle
+    
+    // data = jtag data reg
+    write_jtag_reg(0xB, data, 32);//update dr
+
+    // jtag addr register = regnum:
+    write_jtag_reg(0xA, addr, 32);//update dr
+    
+    
+
+    // jtag transaction command reg = 0x0(write mem)
+    write_jtag_reg(0x9, 0x0, 4);//update dr
+
+    /* Perform the transaction.
+     */
+    tapc_tms(0); // run-test idle
+
+    for (i=0;i<arcjtag_retry_count;i++)
+    {
+	unsigned int status = read_jtag_status_reg();
+	if(status == 4)
+	    break;
+	if(status == 2)
+	    return JTAG_WRITE_FAILURE;
+	tapc_tms(1);//exit1-dr
+	tapc_tms(1);//update-dr
+	/* Do not redo the transaction. Pause and re-try.
+	 */
+	//tapc_tms(0);//run-tes-idle
+    }
+    if (i==arcjtag_retry_count)
+      return JTAG_READ_FAILURE;
+
+    tapc_tms(1);//exit1-dr
+    tapc_tms(1);//update-dr
+    /* This should have been done earlier i.e. before
+       reading the JTAG status register.
+     */
+    //tapc_tms(0);//run-test-idle
+    return sizeof(data);
+}
+
+
+static int 
+arc_jtag_write_chunk (unsigned int addr, unsigned int *write_buf, int len)
+{
+  unsigned int rd, wr;
+  unsigned int status;
+  check_and_raise_error_if_jtag_closed();
+    
+  rw_flag = WRITE_TO_AA3 ;
+  int i = 0;
+  int len_mod = len % 4;
+  len = len - len_mod;
+  
+  tapc_reset();
+  if(arc_jtag_ops.arc_jtag_state_machine_debug)
+    printf_filtered("Entered arc_jtag_write_chunk()......0x%x\n",*write_buf);
+  tapc_tms(0);//run-test idle
+  
+  // jtag addr register = regnum:
+  write_jtag_reg(0xA, addr, 32);//update dr
+  
+  
+  
+  // jtag transaction command reg = 0x0(write mem)
+  write_jtag_reg(0x9, 0x0, 4);//update dr
+  
+  while(len)
+    {
+      
+      // data = jtag data reg
+      write_jtag_reg(0xB, write_buf[i++], 32);//update dr
+      
+      /* Perform the transaction.
+       */
+      tapc_tms(0); // run-test idle
+      
+      
+      while(1)
+	{
+	  status = read_jtag_status_reg();
+	  if(status == 4)
+	    break;
+	  if(status == 2)
+	    return (i-1) * 4;
+
+	  tapc_tms(1);//exit1-dr
+	  tapc_tms(1);//update-dr
+	  /* Do not redo the transaction. Pause and re-try.
+	   */
+	  //tapc_tms(0);//run-tes-idle
+	}
+      
+      tapc_tms(1);//exit1-dr
+      tapc_tms(1);//update-dr
+      /* This should have been done earlier i.e. before
+	 reading the JTAG status register.
+      */
+      //tapc_tms(0);//run-test idle
+      len = len - 4;
+    }
+
+  if(arc_jtag_ops.arc_jtag_state_machine_debug)
+    printf_filtered("leaving arc_jtag_write_chunk() with return value %d",i*4);
+  
+  // added support for writing no of bytes those are not exact mutiple of four
+  
+  if(!len_mod)
+    return i*4;
+  else
+    {
+      
+      addr=addr+(i*4);
+      if(read_mem(addr,&rd)==JTAG_READ_FAILURE)
+	  return i*4;
+      if(arc_jtag_ops.arc_jtag_state_machine_debug)
+      printf_filtered("\nrd=0x%x and wr=0x%x\n",rd,write_buf[i]);
+
+      switch(len_mod)
+	{
+	  
+	case 1:
+	  wr = (rd & 0xffffff00)|(write_buf[i] & 0xff);
+	  break;
+	  
+	case 2:
+	  wr = (rd & 0xffff0000)|(write_buf[i] & 0xffff);
+	  break;
+	  
+	case 3:
+	  wr = (rd & 0xff000000)|(write_buf[i] & 0xffffff);
+	  break;
+	  
+	}
+      if(arc_jtag_ops.arc_jtag_state_machine_debug)
+	printf_filtered("\nwrite_mem writing 0x%x at 0x%x",wr,addr);
+      arc_jtag_write_chunk(addr,&wr,4);
+      return (i*4 + len_mod);
+    }
+  
+  
+}
+
+static int 
+arc_jtag_read_chunk (unsigned int addr, unsigned int *read_buf, int len)
+{
+    unsigned int rd, wr, data;
+    int i=0;
+    rw_flag = READ_FROM_AA3 ;
+    int len_mod=len%4;
+    len=len-len_mod;
+    if(arc_jtag_ops.arc_jtag_state_machine_debug)
+      printf_filtered("\nEntered arc_jtag_read_chunk() 0x%x\n",addr);
+    check_and_raise_error_if_jtag_closed();
+
+    // jtag addr register = regnum:
+    tapc_reset();
+    tapc_tms(0);//run-test idle
+    
+    write_jtag_reg(0xA, addr, 32);//update dr
+
+    
+    while(len)
+    {
+    // Setup instruction register to 0x9 indicating
+    // a JTAG instruction is being downloaded.
+    // jtag transaction command reg = 0x5 (read core reg)
+    write_jtag_reg(0x9, 0x4, 4);//update dr
+
+    /* Perform the transaction.
+     */
+    tapc_tms(0); // run-test idle
+
+    // poll the status
+
+    while(1)
+    {
+	unsigned int status = read_jtag_status_reg();
+	if(status == 4)
+	    break;
+	if(status == 2)
+	    return (i-1)*4;
+	tapc_tms(1);//exit1-dr
+	tapc_tms(1);//update-dr
+	/* Do not redo the transaction. Pause and re-try.
+	 */
+	//tapc_tms(0);//run-test-idle
+
+    }
+
+    /* JTAG status register leaves us in Shift DR */
+    tapc_tms(1); /* Move to Exit-1 DR */
+    tapc_tms(1); /* Move to Update DR */
+    
+    // data = jtag data reg
+    read_buf[i++] = read_jtag_reg(0xB, 32);// exits in Update DR
+    len= len-4;
+    //tapc_tms(0);/* Move to run-test-idle */
+
+    }
+
+    // added support for reading no of bytes those are not exact mutiple of four
+
+    if(!len_mod)
+	return i*4;
+    else
+    {
+        char *ptr = (char *)read_buf + i*4;
+	addr=addr+(i*4);
+	if(read_mem(addr,&rd)==JTAG_READ_FAILURE)
+	    return i*4;
+
+	switch(len_mod)
+	{
+	case 1:
+	    ptr[0] = rd & 0xff;
+	    break;
+
+	case 2:
+	    ptr[0] = rd & 0xff;
+	    ptr[1] = (rd>>8) & 0xff;
+	    break;
+
+	case 3:
+	    ptr[0] = rd & 0xff;
+	    ptr[1] = (rd>>8) & 0xff;
+	    ptr[2] = (rd>>16) & 0xff;
+	    break;
+	}
+
+	return ((i*4)+len_mod);
+	
+    }
+
+
+}
+
+
+
+/*
+ * Return the Processor Variant that is connected.
+ */
+int
+arc_get_architecture() 
+{
+  if (ARCProcessor == UNSUPPORTED) {
+    unsigned int value;
+
+    /* Read the Identity Register. */
+    if (arc_jtag_read_aux_reg(4, &value) == JTAG_READ_FAILURE)
+      error("Failure reading from auxillary IDENTITY register");
+
+    /* Get Identity Mask. */
+    value &= 0xff ;
+
+    if((value >= 0x30) && (value <= 0x3f))
+      ARCProcessor = ARC700;
+    else if((value >= 0x20) && (value <= 0x2f))
+      ARCProcessor = ARC600;
+    else if((value >= 0x10) && (value <= 0x1f))
+      ARCProcessor = A5;
+    else if ((value >= 0x00) && (value <= 0x0f)) 
+      ARCProcessor = A4;
+    else 
+      error("Unsupported Processor Version 0x%x\n", value);
+  }
+
+  return ARCProcessor;
+}
+
+
+
+static void 
+arc_jtag_open (void)
+{
+  int retval;
+  unsigned int read_status = 0;
+  sigaddset(&block_mask,SIGINT);
+  retval = gpio_setup();
+  if(retval != 0)
+    {
+      error("Unable to open JTAG Port .%s \n",(retval == EINVAL)?
+	    "Invalid Params":"Permission Denied" );
+      arc_jtag_ops.jtag_status = JTAG_CLOSED;
+      return ;
+    }
+  arc_jtag_ops.jtag_status = JTAG_OPENED;
+
+  tapc_reset();
+  //Writing debug bit of debug register
+  
+  do
+    {
+      /* Note: Reading the status/status32 register here to
+         check if halt bit is set*/
+      if (IS_A4) {
+	if(arc_jtag_read_aux_reg( 0x0, &read_status) == JTAG_READ_FAILURE)
+	  error("Failure reading auxillary register 0xA\n");
+	if(read_status & A4_HALT_VALUE)
+	  break;
+      }
+      else {
+	if(arc_jtag_read_aux_reg( 0xA, &read_status) == JTAG_READ_FAILURE)
+	  error("Failure reading auxillary register 0xA\n");
+	if(read_status & ARC700_HALT_VALUE)
+	  break;
+      }
+      printf_filtered("Processor running. Trying to halt.....\n");
+      if(arc_jtag_write_aux_reg(0x5,0x2)==JTAG_WRITE_FAILURE)
+	error("Failure writing 0x2 to auxillary register 0x5:debug register\n");
+    }while(1);
+  if (arc_jtag_ops.arc_jtag_state_machine_debug)
+    printf_filtered("Processor halted.....\n");
+
+}
+
+static void 
+arc_jtag_close (void)
+{
+  ARCProcessor = UNSUPPORTED;
+
+  if(arc_jtag_ops.jtag_status != JTAG_CLOSED)
+    {
+      tapc_reset();
+      /* closing file descriptor opened for communication with gpio driver */
+      close(fd);
+      if(arc_jtag_ops.arc_jtag_state_machine_debug)
+	printf_filtered("arc-jtag closed\n");
+      arc_jtag_ops.jtag_status = JTAG_CLOSED;
+    }
+
+}
+
+static void 
+arc_jtag_wait(void)
+{
+  unsigned int read_status;
+  check_and_raise_error_if_jtag_closed();
+  do
+    {
+      sigprocmask(SIG_BLOCK,&block_mask, NULL);
+
+      if (IS_A4) {
+	if(arc_jtag_read_aux_reg( 0x0, &read_status) == JTAG_READ_FAILURE)
+	  error("Failure reading auxillary register 0x0\n");
+	//FIXMEA:    if(debug_arc_jtag_target_message)
+	//      printf_filtered ("\n Read Status: 0x%x,%d\n", read_status, read_status);
+
+	if(read_status & A4_HALT_VALUE)
+	  {
+	    sigprocmask(SIG_BLOCK,&block_mask, NULL);
+	    break;
+	  }
+      }
+      else {
+	if(arc_jtag_read_aux_reg( 0xA, &read_status) == JTAG_READ_FAILURE)
+	  error("Failure reading auxillary register 0xA\n");
+	if(read_status & ARC700_HALT_VALUE)
+	  {
+	    sigprocmask(SIG_BLOCK,&block_mask, NULL);
+	    break;
+
+	  }
+      }
+      sigprocmask(SIG_UNBLOCK,&block_mask, NULL);	
+    }while(1);
+
+  while (1)
+    {
+      if (arc_jtag_read_aux_reg (0x5,&read_status) == JTAG_READ_FAILURE)
+	error ("Failure reading Debug register \n");
+      if (!(read_status & 0x80000000))
+	break;
+    }
+}
+
+static void
+arc_jtag_reset_board (void)
+{
+  char c = 5;
+  int  auxval = 2 ;
+  check_and_raise_error_if_jtag_closed ();
+
+  /*
+    Writing 9 did not work. But thats 
+    what the manual says. Hmmm. 
+  gpio_write (CONTROL_PORT, &c);
+  */
+
+  gpio_write ( CONTROL_PORT, &c);
+  c = 0xd;
+  gpio_write ( CONTROL_PORT, &c);
+  c = 5;
+  gpio_write ( CONTROL_PORT, &c);
+
+  if (arc_jtag_write_aux_reg(0x5 , 2) == JTAG_WRITE_FAILURE)
+    error ("Failure writing to auxiliary register Debug\n");
+
+  c = 0;
+  gpio_write ( 0x378, &c);
+  c = 0x40;
+  gpio_write ( 0x378, &c);
+  c = 0;
+  gpio_write ( 0x378, &c);
+  
+  tapc_reset();
+}
+
+
+void
+_initialize_arc_jtag_ops (void)
+{
+    arc_jtag_ops.name=NULL;
+    arc_jtag_ops.jtag_open = arc_jtag_open;
+    arc_jtag_ops.jtag_close = arc_jtag_close;
+    arc_jtag_ops.jtag_memory_write = arc_jtag_write_chunk;
+    arc_jtag_ops.jtag_memory_read = arc_jtag_read_chunk;
+    arc_jtag_ops.jtag_memory_chunk_write = arc_jtag_write_chunk;
+    arc_jtag_ops.jtag_memory_chunk_read = arc_jtag_read_chunk;
+    arc_jtag_ops.jtag_write_aux_reg = arc_jtag_write_aux_reg;
+    arc_jtag_ops.jtag_read_aux_reg = arc_jtag_read_aux_reg;
+    arc_jtag_ops.jtag_read_core_reg = arc_jtag_read_core_reg;
+    arc_jtag_ops.jtag_write_core_reg = arc_jtag_write_core_reg;
+    arc_jtag_ops.jtag_wait = arc_jtag_wait;
+    arc_jtag_ops.jtag_reset_board = arc_jtag_reset_board;
+    arc_jtag_ops.jtag_status = JTAG_CLOSED ;
+}
diff --git a/gdb/arc-jtag-ops.h b/gdb/arc-jtag-ops.h
new file mode 100644
index 0000000..dbf49e6
--- /dev/null
+++ b/gdb/arc-jtag-ops.h
@@ -0,0 +1,62 @@
+/* Target dependent code for ARC700, for GDB, the GNU debugger.
+
+   Copyright 2005 Free Software Foundation, Inc.
+
+   Contributed by Codito Technologies Pvt. Ltd. (www.codito.com)
+
+   Authors: 
+      Sameer Dhavale <sameer.dhavale@codito.com>
+      Soam Vasani <soam.vasani@codito.com>
+
+   This file is part of GDB.
+   
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+*/
+
+
+#define ARC_NR_CORE_REGS        64
+#define MAX_ARC700_REG_SIZE     4
+#define JTAG_READ_FAILURE 0
+#define JTAG_WRITE_FAILURE 0
+enum arc_jtag_status
+  {
+    JTAG_OPENED,
+    JTAG_CLOSED, 
+    JTAG_RUNNING
+  };
+
+struct jtag_ops{
+  char *name;
+  void (*jtag_open) (void);
+  void (*jtag_close) (void);
+  int (*jtag_memory_write) (unsigned int, unsigned int *, int);
+  int (*jtag_memory_chunk_write) (unsigned int, unsigned int *, int);
+  int (*jtag_memory_read) (unsigned int, unsigned int *, int);
+  int (*jtag_memory_chunk_read) (unsigned int, unsigned int *, int);
+  int (*jtag_read_aux_reg) (unsigned int, unsigned int *);
+  int (*jtag_write_aux_reg) (unsigned int, unsigned int);
+  int (*jtag_read_core_reg) (unsigned int, unsigned int *);
+  int (*jtag_write_core_reg) (unsigned int, unsigned int);
+  void (*jtag_wait) (void);
+  void (*jtag_reset_board) (void);
+  enum arc_jtag_status jtag_status;
+  int arc_jtag_state_machine_debug;
+};
+
+
+#define IS_ARC700	(arc_get_architecture() == ARC700)
+#define IS_ARC600	(arc_get_architecture() == ARC600)
+#define IS_A5		(arc_get_architecture() == A5)
+#define IS_A4		(arc_get_architecture() == A4)
diff --git a/gdb/arc-jtag-tdep.c b/gdb/arc-jtag-tdep.c
new file mode 100644
index 0000000..8401538
--- /dev/null
+++ b/gdb/arc-jtag-tdep.c
@@ -0,0 +1,638 @@
+/* Target dependent code for ARC700, for GDB, the GNU debugger.
+
+   Copyright 2005 Free Software Foundation, Inc.
+
+   Contributed by Codito Technologies Pvt. Ltd. (www.codito.com)
+
+   Authors: 
+      Soam Vasani <soam.vasani@codito.com>
+      Ramana Radhakrishnan <ramana.radhakrishnan@codito.com> 
+
+   This file is part of GDB.
+   
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+*/
+#include <string.h>
+
+#include "defs.h"
+#include "osabi.h"
+#include "frame.h"
+#include "regcache.h"
+#include "gdb_assert.h"
+#include "inferior.h"
+#include "gdbcmd.h"
+#include "reggroups.h"
+
+#include "arc-tdep.h"
+#include "arc-jtag.h"
+
+
+#ifdef ARC4_JTAG
+/* brk */
+unsigned int a4_jtag_breakpoint_size = 4;
+unsigned char a4_jtag_breakpoint_insn[4] = { 0x00, 0xfe, 0xff, 0x1f };
+#define A4_HALT_VALUE 0x02000000
+#else
+/* brk_s */
+unsigned int arc700_jtag_breakpoint_size = 2;
+unsigned char arc700_jtag_breakpoint_insn[2] = { 0xff, 0x7f };
+#endif
+
+
+
+struct arc_reg_info 
+{
+  char *name ;
+  int hw_regno;
+  char *description;
+#ifdef ARC4_JTAG
+  enum arc4_jtag_regnums gdbregno;
+#else
+  enum arc700_jtag_regnums gdbregno;
+#endif
+  enum ARCProcessorVersion arcVersionSupported;
+};
+
+
+
+static const char *
+arc_jtag_register_name (int regno)
+{
+  static char jtag_names[][30] = {
+    "r0", "r1", "r2", "r3", "r4", "r5", "r6",
+    "r7", "r8", "r9", "r10", "r11", "r12", "r13",
+    "r14", "r15", "r16", "r17", "r18", "r19", "r20",
+    "r21", "r22", "r23", "r24", "r25", "r26",
+    
+    "fp",
+    "sp",
+    "ilink1",
+    "ilink2",
+    "blink",
+    
+    /* Extension core regs are 32..59 inclusive.  */
+    "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
+    "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47", "r48", "r49",
+    "r50", "r51", "r52", "r53", "r54", "r55", "r56", "r57", "r58", "r59",
+       
+    "lp_count",
+
+    /* 61 is reserved, 62 is not a real register.  */
+    /*FIXMEA: The following 3 are supposed to be registers
+     that are used only to encode immediate values in A4*/
+    "r61",
+    "r62",
+    
+    "pcl",
+
+    /* Now the aux registers.  */
+    
+    "status",
+    "semaphore",
+    "lp_start",
+    "lp_end",
+    "identity",
+    "debug",
+    
+#ifndef ARC4_JTAG
+    "pc",
+    "status32",
+    "status32_l1",
+    "status32_l2",
+
+    "count0",
+    "control0",
+    "limit0",
+    "int_vector_base",
+    "aux_macmode",
+    "aux_irq_lv12",
+
+
+    "count1",
+    "control1",
+    "limit1",
+    "aux_irq_lev",
+    "aux_irq_hint",
+    "eret",
+    "erbta",
+    "erstatus",
+    "ecr",
+    "efa",
+    "icause1",
+    "icause2",
+    "aux_ienable",
+    "aux_itrigger",
+    "xpu",
+    "bta",
+    "bta_l1",
+    "bta_l2",
+    "aux_irq_pulse_cancel",
+    "aux_irq_pending",
+
+    /* Build configuration registers.  */
+    "bcr_0",
+    "dccm_base_build",
+    "crc_base_build",
+    "bta_link_build",
+    "dvbf_build",
+    "tel_instr_build",
+    "bcr_6",
+    "memsubsys",
+    "vecbase_ac_build",
+    "p_base_address",
+    "bcr_a",
+    "bcr_b",
+    "bcr_c",
+    "bcr_d",
+    "bcr_e",
+    "mmu_build",
+    "arcangel_build",
+    "bcr_11",
+    "d_cache_build",
+    "madi_build",
+    "dccm_build",
+    "timer_build",
+    "ap_build",
+    "icache_build",
+    "iccm_build",
+    "dspram_build",
+    "mac_build",
+    "multiply_build",
+    "swap_build",
+    "norm_build",
+    "minmax_build",
+    "barrel_build",
+#endif
+    
+  };
+  
+  gdb_assert(ARRAY_SIZE (jtag_names) == NUM_REGS + NUM_PSEUDO_REGS);
+  gdb_assert(regno >=0 && regno < NUM_REGS + NUM_PSEUDO_REGS);
+
+  return jtag_names[regno];
+}
+
+int
+arc_jtag_register_reggroup_p (int regnum, struct reggroup *group)
+{
+  /* These registers don't exist, so they are not in any reggroup.  */
+  if ((regnum >= 32 && regnum <= 59) || (regnum == 61) || (regnum == 62))
+    return 0;
+
+  /* Which regs to save/restore ? */
+  if ((group == save_reggroup || group == restore_reggroup))
+    {
+      /* Save/restore:
+	 1. all core regs, except PCL (PCL is not writable)
+	 2. aux regs LP_START..LP_END (IDENTITY is not writable)
+	 3. aux regs PC_REGNUM..STATUS32_L2
+	 3. aux regs ERET..EFA */
+      return ( ( regnum >= 0 && regnum < ARC_PCL_REGNUM)
+	       || ( regnum >= ARC_LP_START_REGNUM && regnum<= ARC_LP_END_REGNUM)
+#ifdef ARC4_JTAG
+	       || ( regnum == ARC_STATUS_REGNUM)
+#else	       
+	       || ( regnum >= ARC_PC_REGNUM && regnum <= ARC_STATUS32_L2_REGNUM)
+	       || ( regnum >= ARC_ERET_REGNUM && regnum <= ARC_EFA_REGNUM)
+#endif
+	       );
+    }
+  
+  return -1;
+}
+
+static void
+arc_jtag_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
+			       struct frame_info *frame, int regnum, int all)
+{
+  int i;
+
+  if (regnum >= 0 )
+    {
+      default_print_registers_info (gdbarch, file, frame, regnum, all);
+      return;
+    }
+
+  /* if regnum < 0 , print all registers */
+
+  for (i=0; i <= 26; ++i)
+    default_print_registers_info (gdbarch, file, frame, i, all);
+  default_print_registers_info (gdbarch, file, frame, 
+				ARC_FP_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, 
+				ARC_SP_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, 
+				ARC_ILINK1_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, 
+				ARC_ILINK2_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, 
+				ARC_BLINK_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, 
+				ARC_LP_COUNT_REGNUM, all);
+  
+  /* now the aux registers */
+   if (!all)
+    {
+      default_print_registers_info (gdbarch, file, frame, 
+				    ARC_LP_START_REGNUM, all);
+      default_print_registers_info (gdbarch, file, frame, 
+				    ARC_LP_END_REGNUM, all);
+      
+#ifndef ARC4_JTAG 
+      default_print_registers_info (gdbarch, file,frame,
+				    ARC_STATUS32_REGNUM, all);
+      default_print_registers_info (gdbarch, file, frame, 
+				    ARC_BTA_REGNUM, all);
+      default_print_registers_info (gdbarch, file, frame, 
+				    ARC_EFA_REGNUM, all);
+      default_print_registers_info (gdbarch, file, frame, 
+				    ARC_ERET_REGNUM, all);
+      default_print_registers_info (gdbarch, file, frame, 
+				    ARC_STATUS32_L1_REGNUM, all);
+      default_print_registers_info (gdbarch, file, frame, 
+				    ARC_STATUS32_L2_REGNUM, all);
+      default_print_registers_info (gdbarch, file, frame, 
+				    ARC_ERSTATUS_REGNUM, all);
+      
+      
+      /* PC */
+      default_print_registers_info (gdbarch, file, frame, 
+				    ARC_PC_REGNUM, all);
+#endif
+    }
+   else
+     {
+       /* This part needs cleaning up. */
+       for (i = ARC_STATUS_REGNUM;
+#ifndef ARC4_JTAG
+	    i <= ARC_AUX_IRQ_PENDING_REGNUM;
+#else /*FIXMEA*/
+	    i <=  ARC_DEBUG_REGNUM;
+#endif
+	    i ++ )
+	 default_print_registers_info (gdbarch, file, frame , 
+				       i, all);
+
+       
+       for (i = ARC_STATUS_REGNUM ; 
+#ifndef ARC4_JTAG
+	    i <= ARC_AUX_IRQ_PENDING_REGNUM;
+#else /*FIXMEA*/
+	    i <=  ARC_DEBUG_REGNUM;
+#endif
+	    i ++ )
+	 default_print_registers_info (gdbarch, file, frame, 
+				       i, all);
+       
+#ifndef ARC4_JTAG
+       for (i = ARC_BCR_1_REGNUM ; 
+	    i <= ARC_BCR_5_REGNUM ;
+	    i ++ )
+	 default_print_registers_info (gdbarch, file , frame, 
+				       i , all);
+       
+       for (i = ARC_BCR_7_REGNUM ;
+	    i <= ARC_BCR_9_REGNUM;
+	    i ++ )
+	 default_print_registers_info (gdbarch, file, frame, 
+				       i , all);
+
+       for (i = ARC_BCR_F_REGNUM;
+	    i <= ARC_BCR_10_REGNUM;
+	    i ++ )
+	 default_print_registers_info (gdbarch, file, frame , 
+				       i , all);
+
+       for (i = ARC_BCR_12_REGNUM;
+	    i <= ARC_BCR_1F_REGNUM;
+	    i ++)
+	 default_print_registers_info (gdbarch, file, frame , 
+				       i , all);
+#endif //if no ARC4_JTAG
+
+
+     }
+}
+
+/* Command: aux-read <from> <to>
+
+   Read and display a range of aux registers.  Some of the aux registers
+   (pc, debug, etc.) are part of the register set, but this is a more
+   general interface.
+
+   We should eventually change this to use the ui_out stuff rather than
+   printf_filtered.  */
+static void
+arc_jtag_aux_read_command (char *arg, int from_tty)
+{
+  char *arg2 = 0;
+  struct expression *expr;
+  struct value *val;
+  struct cleanup *old_chain = 0;
+  int auxregno, auxregno2 = 0, nrregs;
+  unsigned int *buf;
+  int i, nrtransfered;
+
+  if (!arg)
+    {
+      printf_filtered ("aux-read <REG-FROM> [<REG-TO>]\n");
+      return;
+    }
+  
+  /* strip leading spaces */
+  while(*arg == ' ')
+    arg++;
+
+  /* two arguments ?  */
+  /* This assumes that the first arg cannot have spaces.  (The disas command
+     also seems to work this way.)  */
+  arg2 = strchr (arg, ' ');
+
+  /* get the second one */
+  if (arg2)
+    {
+      struct expression *expr2;
+      struct value *val2;
+
+      arg2[0] = 0;
+      arg2++;
+     
+      expr2 = parse_expression (arg2);
+      val2 = evaluate_expression (expr2);
+      xfree (expr2);
+
+      auxregno2 = *(int *)(VALUE_CONTENTS (val2));
+    }
+
+  /* first arg */
+  expr = parse_expression (arg);
+  val = evaluate_expression (expr);
+  old_chain = make_cleanup (free_current_contents, &expr);
+  
+  auxregno = *(int *)(VALUE_CONTENTS (val));
+
+  /* so, how many regs do we want ? */
+  if (arg2)
+    {
+      if (auxregno2 < auxregno)
+	{
+	  warning ("aux-read: %s < %s, showing one register", arg2, arg);
+	  nrregs = 1;
+	}
+      else
+	nrregs = auxregno2 - auxregno + 1;
+    }
+  else
+    nrregs = 1;
+
+  buf = xcalloc (nrregs, sizeof(int));
+  make_cleanup (free_current_contents, &buf);
+  
+  /* Go get 'em !  */
+  nrtransfered = target_read_aux_reg (buf, auxregno, nrregs);
+  if (nrtransfered <= 0)
+    {
+      do_cleanups (old_chain);
+      error ("aux-read: couldn't read any registers.");
+    }
+  else if (nrtransfered < nrregs)
+    {
+      warning ("aux-read: could only read %d registers", nrtransfered);
+    }
+  
+  gdb_assert (nrtransfered <= nrregs);
+
+  /* Show them.  */
+  for (i = auxregno; i - auxregno < nrtransfered; ++i)
+    {
+      if ((i - auxregno) % 4 == 0)
+	printf_filtered("%s%08x: ", ((i - auxregno) ? "\n" : ""), i);
+      
+      printf_filtered ("%08x ", buf[i - auxregno]);
+    }
+  printf_filtered ("\n");
+  
+  do_cleanups (old_chain);
+}
+
+/* aux-write <regnum> = <value>
+   Write VALUE to aux register REGNUM. */
+static void
+arc_jtag_aux_write_command (char *arg, int from_tty)
+{
+  char *value_arg = 0;
+  struct expression *regnum_expr, *value_expr;
+  struct value *regnum_val, *value_val;
+  struct cleanup *old_chain = 0;
+  unsigned int regnum, value;
+  int err;
+  
+  if (!arg)
+    {
+      printf_filtered ("aux-write <regnum> = <value>\n");
+      return;
+    }
+
+  value_arg = strchr(arg, '=');
+  if (!value_arg)
+    {
+      error ("aux-write: can't find second argument\n\
+Usage: aux-write <regnum> = <value>");
+      return;
+    }
+  value_arg[0] = 0;
+  value_arg++;
+
+  /* Regnum expression */
+  regnum_expr = parse_expression (arg);
+  regnum_val = evaluate_expression (regnum_expr);
+  old_chain = make_cleanup (free_current_contents, &regnum_expr);
+  regnum = *(unsigned int *)(VALUE_CONTENTS (regnum_val));
+
+  /* Value expression */
+  value_expr = parse_expression (value_arg);
+  value_val = evaluate_expression (value_expr);
+  make_cleanup (free_current_contents, &value_expr);
+  value = *(unsigned int *)(VALUE_CONTENTS (value_val));
+
+  /* Write it.  */
+  err = target_write_aux_reg (&value, regnum, 1);
+  if (err != 1)
+    {
+      do_cleanups (old_chain);
+      error ("aux-write: couldn't write to register 0x%x", regnum);
+    }
+
+  do_cleanups (old_chain);
+}
+
+#ifdef ARC4_JTAG
+//  gdbarch_write_pc_ftype *write_pc;
+/*
+  Write PC
+  Arguments:
+  1.CORE_ADDR val : Contains the value to be written into PC.
+  2.ptid_t ptid: Process id of the process.
+
+  Returns: void
+  Description: FIXMEA: Update
+      Reads the status register
+      Inserts the value (upper 24 bit) into the bits
+      0-23 in the status register
+      Write the status register
+ */
+void
+a4_jtag_write_pc (CORE_ADDR val, ptid_t ptid)
+{
+  CORE_ADDR insert_val = val >> 2;
+  unsigned int buffer;
+
+
+  if(debug_arc_jtag_target_message)
+      printf_filtered ("\n -----***------------ a4_jtag_write_pc Entered ---*%%*#\n");
+
+  
+  target_read_aux_reg (&buffer, ARC_HW_STATUS_REGNUM, 1);
+
+  if (!(buffer & A4_HALT_VALUE))
+    {
+      if(debug_arc_jtag_target_message)
+	printf_filtered ("\n***** Halting Processor... *********\n");
+      
+      buffer = buffer | A4_HALT_VALUE ;
+      target_write_aux_reg (&buffer, ARC_HW_STATUS_REGNUM, 1);
+      /* Now the A4 processor has halted*/
+    }
+  
+  if(debug_arc_jtag_target_message)
+    printf_filtered (" \nWriting value %u to PC\n", val);
+
+
+  target_read_aux_reg (&buffer, ARC_HW_STATUS_REGNUM, 1);
+  if(debug_arc_jtag_target_message)
+    printf_filtered (" \nValue of Status Register before writing %d\
+                     \n Value of PC: 0x%x\n", buffer, buffer & 0x00ffffff);
+
+  buffer = buffer & 0xff000000;
+  insert_val    = insert_val & 0x00ffffff;
+  buffer = buffer | insert_val ;
+  
+  if(debug_arc_jtag_target_message)
+    printf_filtered (" \nValue of Status Register to be written %d\
+                       \n Value of PC: 0x%x\n", buffer, buffer & 0x00ffffff);
+
+  //  jtag_ops.jtag_write_aux_reg (ARC_STATUS_REGNUM, buffer);
+  target_write_aux_reg (&buffer, ARC_HW_STATUS_REGNUM, 1);
+
+  if(debug_arc_jtag_target_message)
+    {
+      target_read_aux_reg (&buffer, ARC_HW_STATUS_REGNUM, 1);
+      printf_filtered (" \nValue of Status Register after reading again %d\
+                        \n Value of PC: 0x%x\n", buffer, buffer & 0x00ffffff);
+    }
+
+    if(debug_arc_jtag_target_message)
+      printf_filtered ("\n -----***------------ a4_jtag_write_pc Leaving ---*%%*#\n");
+
+}
+
+
+/*
+  Read PC
+  Arguments:
+  1.ptid_t ptid: Process id of the process.
+
+  Returns: CORE_ADDR 
+  Description:
+      Reads the status register
+      Extracts the PC value from it.
+      Right shift twice to get correct value of PC
+      return PC
+*/
+CORE_ADDR
+a4_jtag_read_pc (ptid_t ptid)
+{
+  unsigned int buffer;
+
+  if (debug_arc_jtag_target_message)
+    printf_filtered ("\n Entering a4_jtag_read_pc ()");
+  buffer = 0;
+  target_read_aux_reg (&buffer, ARC_HW_STATUS_REGNUM, 1);
+  if (debug_arc_jtag_target_message)
+    printf_filtered ("\n Value of Status Reg: 0x%x",buffer);
+  buffer = buffer & 0x00ffffff;
+  buffer = buffer << 2;
+
+  if (debug_arc_jtag_target_message)
+    printf_filtered ("\n Leaving a4_jtag_read_pc ()\
+                      \n Value of Pc: 0x%x\n", buffer);
+  
+  return buffer;
+}
+
+#endif // ARC4_JTAG
+
+ARCVariantsInfo arc_debug_processor_information;
+
+struct gdbarch *
+arc_jtag_init (struct gdbarch *gdbarch)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+#ifndef ARC4_JTAG
+  tdep->arc_breakpoint_size = arc700_jtag_breakpoint_size;
+  tdep->arc_breakpoint_insn = arc700_jtag_breakpoint_insn;
+#else
+  tdep->arc_breakpoint_size = a4_jtag_breakpoint_size;
+  tdep->arc_breakpoint_insn = a4_jtag_breakpoint_insn;
+#endif
+
+  set_gdbarch_num_regs (gdbarch, ARC_NR_REGS);
+#ifndef ARC4_JTAG
+  set_gdbarch_pc_regnum (gdbarch, ARC_PC_REGNUM);
+#else
+  //  set_gdbarch_pc_regnum (gdbarch, ARC_STATUS_REGNUM);
+  set_gdbarch_write_pc (gdbarch, a4_jtag_write_pc);
+  set_gdbarch_read_pc (gdbarch, a4_jtag_read_pc);
+#endif
+  set_gdbarch_register_name (gdbarch, arc_jtag_register_name);
+  
+  set_gdbarch_print_registers_info (gdbarch, arc_jtag_print_registers_info);
+
+  tdep->register_reggroup_p = arc_jtag_register_reggroup_p;
+
+  tdep->lowest_pc = 0;
+  
+  tdep->sigtramp_p = NULL;
+
+  tdep->arc_processor_variant_info = &arc_debug_processor_information;
+
+  /* Auxillary register commands.  */
+  add_cmd ("arc-aux-read", class_vars, arc_jtag_aux_read_command,
+	   "Read and show a range of auxillary registers.\n\
+Usage: arc-aux-read <REG-FROM> [<REG-TO>]\n\
+REG-FROM and REG-TO can be any expressions that evaluate to integers.\n\
+If REG-TO is not specified, one register is displayed.",
+	   &cmdlist);
+
+  add_cmd ("arc-aux-write", class_vars, arc_jtag_aux_write_command,
+	   "Write to an auxillary register.\n\
+Usage: arc-aux-write <REG> = <VALUE>\n\
+REG and VALUE can be any expressions that evaluate to integers.",
+	   &cmdlist);
+
+  return gdbarch;
+}
+
diff --git a/gdb/arc-jtag.c b/gdb/arc-jtag.c
new file mode 100644
index 0000000..9a86b6d
--- /dev/null
+++ b/gdb/arc-jtag.c
@@ -0,0 +1,1297 @@
+/* Target dependent code for ARC700, for GDB, the GNU debugger.
+
+   Copyright 2005 Free Software Foundation, Inc.
+
+   Contributed by Codito Technologies Pvt. Ltd. (www.codito.com)
+
+   Authors: 
+      Sameer Dhavale <sameer.dhavale@codito.com>
+      Ramana Radhakrishnan <ramana.radhakrishnan@codito.com> 
+
+   This file is part of GDB.
+   
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include "defs.h"
+#include "inferior.h"
+#include "target.h"
+#include "breakpoint.h"
+
+#include "arc-tdep.h"
+
+#include <unistd.h>
+#include <stdlib.h>
+
+#include <sys/io.h>
+#include <sys/types.h>
+
+#include <assert.h>
+
+#include "arc-jtag.h"
+#include "arc-jtag-ops.h"
+#include "gdbcore.h"
+#include "gdbarch.h"
+#include "regcache.h"
+#include "command.h"
+#include "gdbcmd.h"
+#include <signal.h>
+
+/* Flag to print debug messages from here. */
+/* FIXMEA:
+static int debug_arc_jtag_target_message;
+*/
+
+#define ENTERMSG  \
+do {\
+if(debug_arc_jtag_target_message) \
+printf_filtered ("--- entered %s:%s()\n", __FILE__, __FUNCTION__); \
+} while(0)
+
+#define ENTERARGS(fmt, args...) \
+do { \
+if(debug_arc_jtag_target_message) \
+printf_filtered ("--- entered %s:%s(" fmt ")\n", __FILE__, __FUNCTION__, args);\
+} while(0)
+
+#define LEAVEMSG \
+do { \
+if(debug_arc_jtag_target_message) \
+printf_filtered ("--- exited %s:%s()\n", __FILE__, __FUNCTION__); \
+} while(0)
+
+/* The number of times a memory read/write operation should be attempted
+   before returning an error.
+*/
+#define MEMORY_TRANSFER_ATTEMPTS 10
+
+/* defined in arc-jtag-ops.c */
+extern unsigned int arcjtag_retry_count;
+
+struct target_ops arc_debug_ops;
+extern struct jtag_ops arc_jtag_ops;
+
+static void arc_debug_interrupt (int signo);
+static void arc_debug_interrupt_twice (int signo);
+static void arc_print_processor_variant_info (void);
+static int arc_debug_write_aux_register (int hwregno, int *buf);
+static int arc_debug_read_aux_register (int hwregno, int *buf);
+static int arc_debug_read_core_register (int hwregno, int *buf);
+
+
+/* Register Mapping information between GDB regnums
+   and actual hardware register numbers. 
+*/
+
+struct arc_reg_info 
+{
+  char *name ;
+  enum arc_hw_regnums hw_regno;
+  char *description;
+#ifdef ARC4_JTAG
+  enum arc4_jtag_regnums gdbregno;
+#else
+  enum arc700_jtag_regnums gdbregno;
+#endif
+  enum ARCProcessorVersion arcVersionSupported;
+};
+
+#define RBCR(name, hwregno , desc, gdbregno, version) { #name, hwregno , desc , gdbregno , version } ,
+
+#undef RAUX
+struct arc_reg_info arc_bcr_reg_info [] = 
+  {
+   #include "arc-regnums-defs.h"
+  };
+
+#undef RAUX
+#undef RBCR
+#define RAUX(name, hwregno , desc, gdbregno, version) { #name , hwregno , desc , gdbregno , version } ,
+struct arc_reg_info arc_aux_reg_map[] =
+  {
+    #include "arc-regnums-defs.h"
+  };
+
+
+
+static void 
+arc_update_architecture(void)
+{
+  unsigned int idinfo;
+  unsigned short tmp;
+  struct gdbarch_tdep * tdep = gdbarch_tdep (current_gdbarch);
+
+  if (IS_ARC700) {
+    tdep->arc_processor_variant_info->arcprocessorversion = ARC700;
+    set_gdbarch_decr_pc_after_break (current_gdbarch,0);
+  }
+  else if(IS_ARC600) {
+    tdep->arc_processor_variant_info->arcprocessorversion = ARC600;
+    set_gdbarch_decr_pc_after_break (current_gdbarch,2);
+  }
+  else if(IS_A5) {
+    warning ("A5 debugging is unsupported and may be buggy.");
+    tdep->arc_processor_variant_info->arcprocessorversion = A5;
+  }
+  else {
+    tdep->arc_processor_variant_info->arcprocessorversion = A4;
+    set_gdbarch_decr_pc_after_break (current_gdbarch,0);
+  }    
+}
+
+/* Get us out of user mode.  */
+static unsigned int
+clear_status32_user_bit ()
+{
+  int rd;
+#ifndef ARC4_JTAG  
+  if(arc_jtag_ops.jtag_read_aux_reg(ARC_HW_STATUS32_REGNUM, &rd) == JTAG_READ_FAILURE)
+    error("Failure reading auxillary register 0x%x:status32 register", ARC_HW_STATUS32_REGNUM);
+
+  if(arc_jtag_ops.jtag_write_aux_reg(ARC_HW_STATUS32_REGNUM, rd & ~0x80) == JTAG_READ_FAILURE)
+    error("Failure writing to auxillary register 0x%x:status32 register", ARC_HW_STATUS32_REGNUM);
+#endif
+  return rd;
+}
+
+/* Restore a saved status32; use with clear_status32_user_bit().  */
+static void
+restore_status32_user_bit (unsigned int status32)
+{
+#ifndef ARC4_JTAG
+  if(arc_jtag_ops.jtag_write_aux_reg(ARC_HW_STATUS32_REGNUM, status32) == JTAG_READ_FAILURE)
+    error("Failure writing to auxillary register 0x%x:status32 register", ARC_HW_STATUS32_REGNUM);
+#endif
+}
+
+/* UB bit in the debug register.  It allows brk_s to work in user mode.  */
+static void
+set_debug_user_bit ()
+{
+  if(is_arc700 ())
+    {
+      /* set UB = 1 */
+      unsigned int debug;
+      if (arc_jtag_ops.jtag_read_aux_reg (ARC_HW_DEBUG_REGNUM, &debug) == JTAG_READ_FAILURE)
+	error("Failure reading auxillary register 0x%x:debug register",ARC_HW_DEBUG_REGNUM);
+      debug |= 0x10000000;                     
+      arc_jtag_ops.jtag_write_aux_reg (ARC_HW_DEBUG_REGNUM, debug);
+    }
+}
+
+
+
+static void
+invalidateCaches (void)
+{
+    if(arc_jtag_ops.jtag_write_aux_reg ( ARC_HW_ICACHE_IVIC , 1)==JTAG_WRITE_FAILURE)
+	error("Failure writing 0x1 to auxillary register 0x%x:Icache invalidate\n",ARC_HW_ICACHE_IVIC);
+    if(arc_jtag_ops.jtag_write_aux_reg ( ARC_HW_DCACHE_IVIC , 1)==JTAG_WRITE_FAILURE)
+	error("Failure writing 0x1 to auxillary register 0x%x:Dcache invalidate\n",ARC_HW_DCACHE_IVIC);
+}
+
+static void
+disableCaches (void)
+{
+  /* Disabling Icache */
+    if(arc_jtag_ops.jtag_write_aux_reg( ARC_HW_ICACHE_CONTROL ,0x1)==JTAG_WRITE_FAILURE)
+      error("Failure writing 0x1 to auxillary register 0x%x:Icache control register\n",ARC_HW_ICACHE_CONTROL);
+  /* Disabling Dcache */
+    if(arc_jtag_ops.jtag_write_aux_reg( ARC_HW_DCACHE_CONTROL ,0x1)==JTAG_WRITE_FAILURE)
+	error("Failure writing 0x1 to auxillary register 0x%x:Dcache control register\n",ARC_HW_DCACHE_CONTROL);
+}
+
+
+/* Function: arc_debug_open
+ * Parameters :
+ * 1. args :
+ * 2. from_tty:
+ * Returns : void
+ * Description: 
+	1. Connect to the jtag target . 
+	2. Read the number of action points supported. 
+	3. Read the configuration of action points. 
+	4. Set up internal data structures for number of hardware
+	   breakpoints and watchpoints. 
+	5. Set the UB bit to 1 for ARC700 and not for ARC600.
+ * 
+ */
+
+void
+arc_debug_open (char *args, int from_tty)
+{
+  ENTERARGS("%s", args);
+  target_preopen(from_tty);
+  
+  reopen_exec_file ();
+  reread_symbols ();
+  
+  unpush_target (&arc_debug_ops);  
+  arc_jtag_ops.jtag_open();
+  push_target (&arc_debug_ops);
+
+  /* Call arc_update_architecture if opened successfully.  */
+  arc_update_architecture();
+  /* Fixme  :: Should these be in create_inferior or 
+     some place else ?. We would not like these here
+     when attach starts working. 
+  */
+  disableCaches();
+#ifdef ARC4_JTAG
+  if(arc_jtag_ops.jtag_write_aux_reg (ARC_HW_STATUS_REGNUM, 0x02000000)==JTAG_WRITE_FAILURE)
+          error("Failure writing 0x0200 0000 to auxillary register 0x%x:status register\n",ARC_HW_STATUS_REGNUM);
+
+  if (from_tty)
+    printf_filtered ("Connected to the arcjtag target.\n");  
+  
+#else
+  if(arc_jtag_ops.jtag_write_aux_reg (ARC_HW_STATUS32_REGNUM, 0x1)==JTAG_WRITE_FAILURE)
+
+    error("Failure writing 0x1 to auxillary register 0x%x:status32 register\n",ARC_HW_STATUS32_REGNUM);
+  
+  /* allow breakpoints in user mode.  */
+  set_debug_user_bit ();
+
+
+  if (from_tty)
+    printf_filtered ("Connected to the arcjtag target.\n");  
+#endif
+}
+
+void arc_debug_close()
+{
+    arc_jtag_ops.jtag_close();
+}
+
+/* Function: arc_debug_attach
+ * Parameters :
+ * 1. char *x:
+ * 2. int i:
+ * Returns : void
+ * Description: 
+ *  1. attach without resetting the board 
+ *  2. get all Board configuration registers of interest.
+ *  if ARC700 set the UB bit to 1. (This is invalid in the 
+ *  ARC600).
+ */
+
+
+void
+arc_debug_attach (char *x, int i)
+{
+
+  ENTERMSG;
+}
+
+
+/* Function: arc_debug_attach
+ * Parameters :
+ * 1. char *x:
+ * 2. int i:
+ * Returns : void
+ * Description: 
+ *  1. Detach without resetting the board. 
+ */
+void
+arc_debug_detach (char *x, int i)
+{
+	
+  ENTERMSG;
+
+  /* Let it continue.  */
+  target_resume (inferior_ptid, 0, 0);
+}
+
+
+/* Function: arc_debug_resume
+ * Parameters :
+ * 1. ptid_t ptid:
+ * 2. int step: 1 - single step , 0 run freely.
+ * 3. enum target_signal signal;
+ * Returns : void
+ * Description: 
+ *  	1. What about Pipecleaning?
+ *	2. Write 0 to the HALT bit in status32.
+ *      3. Send a signal (ignore) in this case. 
+ *      4. if(step) use hardware single step on the ARC700.
+ *          done by setting the IS bit in the debug register
+ *          and clearing the halt bit in status32. 
+ *	
+ */
+
+void
+arc_debug_resume (ptid_t ptid, int step, enum target_signal signal)
+{
+  
+  ENTERARGS("%d,%d,%d", ptid.pid, step, signal);
+  /* Make the inferior resume execution, sending a signal if necessary */
+  unsigned int rd;
+
+  /* Because breakpoints may have been set/removed.  */
+  invalidateCaches ();
+
+  /* This bit is required if breakpoints are to be allowed in user mode.  We
+     set it in target_open, but the operating system might clear it.  So we
+     set it every time we resume.  */
+  set_debug_user_bit ();
+
+  if(step)
+  {
+
+    /* reading debug reg */
+      if(arc_jtag_ops.jtag_read_aux_reg(ARC_HW_DEBUG_REGNUM,&rd)==JTAG_READ_FAILURE)
+	  error("Failure reading auxillary register 0x%x:debug register",ARC_HW_DEBUG_REGNUM);
+#ifdef ARC4_JTAG      
+      rd |= 0x801; /*Setting the IS and the SS bit in the status register
+		     for the A4 core to allow it to single step.  */
+#else
+      /* Mask for Single Stepping changes for ARC600 and ARC700. */
+      if(is_arc700())
+	rd |= 0x800;
+      else
+	if(is_arc600())
+	  rd |= 0x801;
+#endif
+      
+      /* Writing to IS bit in DEBUG register for 
+	 hardware single instruction stepping.  */
+      if(arc_jtag_ops.jtag_write_aux_reg(ARC_HW_DEBUG_REGNUM ,rd)==JTAG_WRITE_FAILURE)
+	  error("Failure writing 0x%x to auxillary register 0x%x:debug register\n",rd,ARC_HW_DEBUG_REGNUM);
+  }
+  else
+  {
+    /* Restarting the processor by clearing the 'H' bit in the status register*/
+#ifdef ARC4_JTAG    
+    /* reading the status reg */     
+    if(arc_jtag_ops.jtag_read_aux_reg(ARC_HW_STATUS_REGNUM,&rd)==JTAG_READ_FAILURE)
+      error("Failure reading auxillary register 0x%x:status register",ARC_HW_STATUS_REGNUM);
+  
+    rd = rd & ~(0x02000000);
+  
+    /* starting the halted processor */
+    if(arc_jtag_ops.jtag_write_aux_reg(ARC_HW_STATUS_REGNUM,rd)==JTAG_WRITE_FAILURE)
+      error("Failure writing 0x%x to auxillary register 0x%x:status register\n",rd,ARC_HW_STATUS_REGNUM);
+#else
+    /* reading the status32 reg */     
+    if(arc_jtag_ops.jtag_read_aux_reg(ARC_HW_STATUS32_REGNUM,&rd)==JTAG_READ_FAILURE)
+      error("Failure reading auxillary register 0x%x:status32 register",ARC_HW_STATUS32_REGNUM);
+  
+    rd = rd & ~(0x1);
+  
+    /* starting the halted processor */
+    if(arc_jtag_ops.jtag_write_aux_reg(ARC_HW_STATUS32_REGNUM,rd)==JTAG_WRITE_FAILURE)
+      error("Failure writing 0x%x to auxillary register 0x%x:status32 register\n",rd,ARC_HW_STATUS32_REGNUM);
+#endif
+  }
+}
+
+/* For the ^C signal handler.  */
+static  void (*ofunc) (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 target_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
+arc_debug_interrupt (int signo)
+{
+  /* If we get the signal twice, do something more drastic.  */
+  signal (signo, arc_debug_interrupt_twice);
+  
+  target_stop ();
+}
+
+/* The user typed ^C twice.  */
+static void
+arc_debug_interrupt_twice (int signo)
+{
+  signal (signo, ofunc);
+
+  if (query ("Interrupted while waiting for the program.\n\
+Give up (and stop debugging it)? "))
+    {
+      target_mourn_inferior ();
+      throw_exception (RETURN_QUIT);
+    }
+
+  signal (signo, arc_debug_interrupt);
+}
+
+/* Function: arc_debug_wait
+ * Parameters :
+ * 1. ptid_t ptid:
+ * 2. struct target_waitstatus *status: Indicates status at end
+                                        of wait for F.E.
+ * Returns : void
+ * Description: 
+ *        Poll status32 for the value of H bit.	
+ *        After H bit is set in status32. 
+ *        Wait till LD(load pending bit) in the DEBUG register
+ *        is cleared.
+ *        SH bit is set if flag instruction was used to halt the processor.
+ *        BH bit is set if the ARCompact processor stopped due to 
+ *        a brk_s instruction. Set the target_waitstatus (signal) to SIGTRAP
+ *        only in such a situation. 
+ *	
+ */
+
+ptid_t
+arc_debug_wait (ptid_t ptid, struct target_waitstatus *status)
+{
+  unsigned int debug;
+  ENTERMSG;
+
+  /* signal handler for Control-C.  */
+  ofunc = signal (SIGINT, arc_debug_interrupt);
+
+  arc_jtag_ops.jtag_wait();
+  /* put the old function back.  */
+  signal (SIGINT, ofunc);
+
+  /* If the SH ("self halt") bit is set, we stopped because of the flag
+     instruction, which is used by programs to exit.  */
+  if (arc_jtag_ops.jtag_read_aux_reg (ARC_HW_DEBUG_REGNUM,
+				      &debug) == JTAG_READ_FAILURE)
+    {
+      error ("Failure reading from debug register");
+    }
+
+  /* SH bit of debug register */
+  if (debug & ARC_DEBUG_REG_SH_BIT)
+    {
+      int exitcode;
+      status->kind = TARGET_WAITKIND_EXITED;
+
+      /* Exit code of the program.  */
+      if (arc_jtag_ops.jtag_read_core_reg (0, &exitcode) == JTAG_READ_FAILURE)
+	{
+	  warning ("Failure reading from register r0, assuming exit code = 0");
+	  status->value.integer = 0;
+	}
+      status->value.integer = exitcode;
+    }
+  else
+    {
+      status->kind = TARGET_WAITKIND_STOPPED;
+      status->value.sig = TARGET_SIGNAL_TRAP;
+    }
+
+#ifndef ARC4_JTAG
+  /* Bug #1311 (ARC600): Setting a breakpoint on the last instruction of a
+     ZOL causes GDB to stop at LP_START.  Detect this condition and warn the
+     user.  */
+  if (is_arc600 ())
+    {
+      unsigned int pc, lp_start, lp_end, lp_count;
+      arc_debug_read_core_register (ARC_LP_COUNT_REGNUM, &lp_count);
+      if (lp_count != 0)
+	{
+	  arc_debug_read_aux_register (ARC_HW_PC_REGNUM, &pc);
+	  arc_debug_read_aux_register (ARC_HW_LP_START_REGNUM, &lp_start);
+	  
+	  if (pc == lp_start)
+	    {
+	      extern struct breakpoint *breakpoint_chain;
+	      struct breakpoint *b;
+	      arc_debug_read_aux_register (ARC_HW_LP_END_REGNUM, &lp_end);
+
+	      for (b = breakpoint_chain; b; b = b->next)
+		{
+		  /* lp_end is the address of the last instruction + the
+		     size of the last instruction.  We could use the
+		     disassembler and find out the size, or just try both
+		     possible sizes.  */
+		  if ((b->enable_state == bp_enabled && !b->pending) &&
+		      b->loc->address == lp_end-4 || b->loc->address == lp_end-2)
+		    {
+		      warning ("Did you set a breakpoint on the last instruction of \n\
+a Zero Overhead Loop ?  Such breakpoints do not work properly.");
+		    }
+		}
+	    }
+	}
+    }
+#endif
+  return inferior_ptid;
+}
+
+static unsigned int 
+arc_get_hw_regnum_mapping ( int regno )
+{
+  int i;
+
+  if (regno >= ARC_STATUS_REGNUM 
+#ifdef ARC4_JTAG
+      && regno <= ARC_DEBUG_REGNUM
+#else
+      && regno <= ARC_AUX_IRQ_PENDING_REGNUM
+#endif      
+      )
+    return  arc_aux_reg_map[regno - ARC_STATUS_REGNUM].hw_regno;
+  
+  for ( i = 0 ; i < (sizeof(arc_bcr_reg_info) / sizeof (struct arc_reg_info)) ; i++)
+    {
+      if (regno == arc_bcr_reg_info[i].gdbregno)
+	return arc_bcr_reg_info[i].hw_regno;
+    }
+
+  return -1;
+}
+
+
+/* Function: arc_debug_fetch_regs.
+ * Parameters :
+ * 1. int regnum: Register number. If register number is -1.Fetch
+ *                all the registers.Read all core registers here.
+ * Returns : void
+ * Description: 
+ *          Set up regcache_raw_supply(current_regcache,regno)
+ *
+ */
+void
+arc_debug_fetch_regs (int regno)
+{
+	/* Read all core registers */
+  ENTERARGS("%d",regno);
+
+  int dummyvalue = 0xABCDABCD;
+  unsigned int hw_regno;
+  unsigned int read_buf;
+
+  if( regno < ARC_NR_CORE_REGS )
+  {
+      hw_regno = regno;
+      if(arc_jtag_ops.jtag_read_core_reg(regno,&read_buf)==JTAG_READ_FAILURE)
+	  error("Failure reading from core register 0x%x\n",regno);
+  }
+  else
+  {
+#ifndef ARC4_JTAG    
+    if( regno > ARC_NR_REGS)
+      error("Invalid Register Number\n");
+#endif
+    
+    hw_regno  = arc_get_hw_regnum_mapping (regno);
+    if(arc_jtag_ops.jtag_read_aux_reg(hw_regno,&read_buf)==JTAG_READ_FAILURE)
+	error("Failure reading auxillary register 0x%x",hw_regno);
+  }
+  
+  if(debug_arc_jtag_target_message)
+    {
+      printf_filtered("HW_Regno=0x%x",hw_regno);
+      printf_filtered("Read Regno 0x%x the value 0x%x\n",hw_regno,read_buf);
+    }
+  regcache_raw_supply(current_regcache,regno,&read_buf);
+
+  LEAVEMSG;
+}
+
+
+/* Function: arc_debug_fetch_regs.
+ * Parameters :
+ * 1. int regnum: Register number. If register number is -1.Fetch
+ *                all the registers.Read all core registers here.
+ * Returns : void
+ * Description: 
+ *          Use deprecated register information for this or regcache_read_unsigned .
+ * FIXME: would need to change to use regcache_raw_supply instead.
+ */
+
+
+void
+arc_debug_store_regs (int regno)
+{
+  /* write_all core registers */
+  ENTERARGS("%d", regno);
+  unsigned int hw_regno;
+  unsigned int write_buf;
+
+  if(debug_arc_jtag_target_message)
+    printf_filtered("\n%d",regno);
+
+  regcache_raw_collect(current_regcache,regno,&write_buf);
+  if( regno < ARC_NR_CORE_REGS )
+  {
+      if(arc_jtag_ops.jtag_write_core_reg(regno,write_buf)==JTAG_WRITE_FAILURE)
+	  error("Failure writing 0x%x to core register 0x%x",write_buf,regno);
+  }
+  else
+  {
+#ifndef ARC4_JTAG    
+    if (regno > ARC_NR_REGS)
+      error ("Invalid register number \n");
+#endif
+
+    hw_regno = arc_get_hw_regnum_mapping (regno);
+
+    if(debug_arc_jtag_target_message)
+	printf_filtered("Writing to regno 0x%x the value 0x%x",
+			hw_regno,write_buf);
+    if(arc_jtag_ops.jtag_write_aux_reg(hw_regno,write_buf)==JTAG_WRITE_FAILURE)
+	error("Failure writing 0x%x to auxillary register 0x%x\n",write_buf,hw_regno);
+  }
+
+}
+
+
+/* Function: arc_debug_prepare_to_store.
+ * Parameters :
+ * 1. int regnum: Register number. If register number is -1.Fetch
+ *                all the registers.Read all core registers here.
+ * Returns : void
+ * Description: 
+ *          Use deprecated register information for this. 
+ * FIXME: would need to change to use regcache_raw_supply instead.
+ */
+
+/* This gets called just before store_regs */
+void
+arc_debug_prepare_to_store (void)
+{
+	/* does nothing . Why is this around ? */
+  ENTERMSG;
+}
+
+/* Read or write memory */
+
+
+
+/* Function: arc_debug_xfer_memory. 
+ * Parameters : 
+ * 1. int regnum: Register number. If register number is -1.Fetch
+ *                all the registers.Read all core registers here.
+ * Returns : void
+ * Description: 
+ *    This has been superceded by target_xfer_memory_partial.
+ *
+ */
+int
+arc_debug_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+		      struct mem_attrib *attrib, struct target_ops *target)
+{
+	/* There is no xfer_memory . Its been deprecated in 6.3 .Replace	
+	 * this by target_xfer_memory_partial .
+	 */
+  ENTERARGS("memaddr=%lx, myaddr=%lx, len=%d, write=%d",
+	    memaddr, (unsigned long)myaddr, len, write);
+  
+  return len; /* success */
+}
+
+
+    
+
+LONGEST 
+arc_debug_xfer_partial (struct target_ops *ops,
+			enum target_object object, 
+			const char *annex,
+			void *readbuf, 
+			const void *writebuf,
+			ULONGEST offset, 
+			LONGEST len)
+{
+
+  int i=0, read_num=0, temp_len=0;
+  unsigned int small_buf;
+  char query_type;
+  ULONGEST temp_offset=0;
+  if(debug_arc_jtag_target_message)
+    printf("..Entered arc_debug_xfer_partial()...with offset 0x%x\n",(unsigned int)offset);
+  /* Handle memory */
+  if (object == TARGET_OBJECT_MEMORY)
+    {
+      int saved_status32;
+      int xfered=0;
+      int attempts;
+      errno = 0;
+
+      /* Get out of user mode so that we can read/write anything anywhere.  */
+      saved_status32 = clear_status32_user_bit ();
+
+      if (writebuf != NULL)
+	{
+	    char *buffer=(char *)xmalloc(4);
+	    char *temp_buf = (char *)writebuf;
+
+	    /* Address alignment to integral multiple of four */
+	    temp_offset = offset;
+	    temp_len = temp_offset % 4;
+	    
+	    i = 0;
+	    if(temp_len)
+	    {
+		temp_offset = offset - temp_len;
+		if(debug_arc_jtag_target_message)
+		  {
+		    printf("---- Aligning-----------\n");
+		    printf("calling write_chunk at 0x%x where \
+offset = 0x%x\n",
+			   (unsigned int)temp_offset,(unsigned int)offset);
+		  }
+
+		attempts = 0;
+		do{
+		    if (attempts++ == MEMORY_TRANSFER_ATTEMPTS)
+		      return 0;
+		    xfered = arc_jtag_ops.jtag_memory_chunk_read(temp_offset,
+								 (unsigned int *)buffer,4);
+		}while(xfered != 4);
+		
+		for(i=0;i<len && i<(4-temp_len);i++)
+		    
+		    buffer[i+temp_len]=temp_buf[i];
+
+		attempts = 0;
+		do{
+		    if (attempts++ == MEMORY_TRANSFER_ATTEMPTS)
+		      return 0;
+		    xfered = arc_jtag_ops.jtag_memory_chunk_write(temp_offset,
+								  (unsigned int *)buffer,4);
+		}while(xfered != 4);
+
+		
+		temp_buf = (char *)writebuf + i;
+		temp_offset = offset + i;
+		len = len - i;
+	    }
+	    if(len>0)
+	      len =arc_jtag_ops.jtag_memory_chunk_write(temp_offset,
+							(unsigned int *)temp_buf,len);
+	    if(debug_arc_jtag_target_message)
+	      printf("...leaving arc_debug_xfer_partial() write.. \
+with return value %d",(int)len);
+
+	    restore_status32_user_bit (saved_status32);
+	  return (len + i);
+	}
+      else
+      {
+	  char *buffer=(char *)xmalloc(4);
+	  char *temp_buf = (char *)readbuf;
+	  /* Address alignment to integral multiple of four */
+	  temp_offset= offset;
+	  temp_len= temp_offset % 4 ;
+
+	  i = 0;
+	  if(temp_len)
+	    {
+	      temp_offset = offset - temp_len;
+	      if(debug_arc_jtag_target_message)
+		{
+		  printf("---- Aligning-----------\n");
+		  printf("calling read_chunk at 0x%x where offset =0x%x \n",
+			 (unsigned int)temp_offset,(unsigned int)offset);
+		}
+
+	      attempts = 0;
+	      do{
+		if (attempts++ == MEMORY_TRANSFER_ATTEMPTS)
+		  return 0;
+		xfered = arc_jtag_ops.jtag_memory_chunk_read(temp_offset,(unsigned int *)buffer,4);
+	      }while(xfered != 4);
+	      
+	      for(i=0;i<len && i<(4-temp_len);i++)
+		temp_buf[i]=buffer[i+temp_len];
+	      
+	      temp_buf = (char *)readbuf + i;
+	      temp_offset = offset + i;
+	      len = len - i;
+	    }
+	  if(len>0)
+	    len = arc_jtag_ops.jtag_memory_chunk_read(temp_offset,(unsigned int *)temp_buf,len);
+	  if(debug_arc_jtag_target_message)
+	    {
+	      printf("\nlen=%d",(int)len + temp_len);
+	      printf("...leaving arc_debug_xfer_partial() read.. \
+with return value %d",
+		     (int)len + temp_len);
+	    }
+
+	  restore_status32_user_bit (saved_status32);
+	  return (len + i);
+	  
+      }
+
+    }
+
+  /* ARC auxillary registers: they are 32bits wide and are in a 32 bit
+     address space, although only part of the address space is used.  */
+  else if (object == ARC_TARGET_OBJECT_AUXREGS)
+    {
+      unsigned int regno;
+
+      if (readbuf)
+	{
+	  for (regno = offset; regno < offset+len; ++regno)
+	    {
+	      unsigned int rd;
+
+	      if (arc_jtag_ops.jtag_read_aux_reg (regno, &rd) == JTAG_READ_FAILURE)
+		{
+		  return (regno - offset);
+		}
+	      ((int *)readbuf)[regno - offset] = rd;
+	    }
+	}
+      else if (writebuf)
+	{
+	  for (regno = offset; regno < offset+len; ++regno)
+	    {
+	      if (arc_jtag_ops.jtag_write_aux_reg (regno, ((int*)writebuf)[regno - offset]) ==
+		  JTAG_WRITE_FAILURE)
+		{
+		  return (regno - offset);
+		}
+	    }
+	}
+
+      /* success */
+      return (LONGEST)len;
+    }
+    else
+    {
+	printf("\nRequested target_object not yet supported with arc-jtag");
+    }
+
+  return -1;
+
+}
+
+
+
+
+void
+arc_debug_files_info (struct target_ops *target)
+{
+	/* Do nothing. Just say its a remote target */
+  ENTERMSG;
+}
+
+
+/* Function: arc_debug_insert_breakpoint
+ * Parameters : 
+ * 1. CORE_ADDR addr: Address for breakpoint.
+ * 2. char * contents: Contents for the breakpoint.
+ * Returns : int
+ * Description: 
+ * See if you can insert a hardware breakpoint using the actionpoints
+ * interface. Use brk_s if architecture is ARC700 and you need to use
+ * a software breakpoint.The gdbarch breakpoint should be initialized to
+ * the right value if used with target_arc_debug.
+ *
+ */
+
+
+int
+arc_debug_insert_breakpoint (CORE_ADDR addr, char *contents)
+{
+	
+  ENTERARGS("%x", (unsigned int)addr);
+#ifndef ARC4_JTAG
+  unsigned int bp = 0x20207fff; /*FIXMEA: what does 0x2020 stand for ?*/
+#else
+  unsigned int bp = 0x1ffffe00;
+#endif
+  unsigned int r;
+  int instr_size;
+  const unsigned char *breakpt_instr;
+  breakpt_instr=BREAKPOINT_FROM_PC(&addr,&instr_size);
+
+  /* save the existing value */
+  /* r==0 means the read succeeded */
+  if(debug_arc_jtag_target_message)
+    printf_filtered ("instrcution size = %d and instruction 0x%x",
+	   instr_size, *(unsigned int *)breakpt_instr);
+  r = target_read_memory (addr, contents, instr_size);
+  /* put the breakpoint */
+  if(r==0)
+    r = target_write_memory (addr, (char *)&bp, instr_size);
+  return r;
+}
+
+
+/* Function: arc_debug_remove_breakpoint. 
+ * Parameters : 
+ * 1. CORE_ADDR addr: Address. 
+ * 2. char * contents : contents. 
+ * Returns : int.
+ * Description: 
+ *  Write the old contents back for the breakpoint.
+ *
+ */
+
+int
+arc_debug_remove_breakpoint (CORE_ADDR addr, char *contents)
+{
+  ENTERARGS("%x, %lx", (unsigned int)addr, *(unsigned long *)contents);
+
+  /* write the old value back */
+#ifdef ARC4_JTAG
+  return target_write_memory (addr, contents, 4);
+#else
+  return target_write_memory (addr, contents, 2);
+#endif
+}
+
+
+
+/* Function: arc_debug_kill
+ * Parameters : void.
+
+ * Returns : void.
+ * Description: Heavy duty arsenal.Kill the process. 
+ * Maybe we do a board reset and kill it. Write 1 to Halt
+ * in Status32. 
+ */
+
+void
+arc_debug_kill (void)
+{
+  ENTERMSG;
+
+  /* Do stuff */
+
+  target_mourn_inferior ();
+}
+
+/* Function: arc_debug_load
+ * Parameters :
+ * 1. char * args: Arguments. 
+ * 2. int from_tty: Which terminal.
+ * Returns : void.
+ * Description: Load the program into jtag.
+ */
+
+void
+arc_debug_load (char *args, int from_tty)
+{
+	/* Write to RAM of the ARC700 board by running through the sections .*/
+  asection *bss_section;
+  CORE_ADDR bss_addr;
+  bfd_size_type bss_size;
+  char *zero_buf;
+  int target_errno;
+
+  ENTERARGS("%s", args);
+
+  generic_load(args, from_tty);
+
+  /* Zero the bss, if it exists.  */
+  bss_section = bfd_get_section_by_name (exec_bfd, ".bss");
+  if (bss_section)
+    {
+      bss_addr = bfd_section_lma (exec_bfd, bss_section);
+      bss_size = bfd_get_section_size (bss_section);
+      zero_buf = (char *)xcalloc (bss_size, 1);
+      
+      if (debug_arc_jtag_target_message)
+	printf_filtered("%s: bss at %x, size = %x\n", __FUNCTION__, (unsigned int)bss_addr,(unsigned int)bss_size);
+      
+      target_errno = target_write_memory (bss_addr, zero_buf, bss_size);
+      free (zero_buf);
+      if (target_errno)
+	{
+	  error ("load: error zeroing bss: %s\n", strerror(target_errno));
+	}
+    }
+  else
+    {
+      if (debug_arc_jtag_target_message)
+	printf_filtered("%s: no bss\n", __FUNCTION__);
+    }
+      
+  clear_symtab_users();
+}
+
+/* Function: arc_debug_create_inferior
+ * Parameters :
+ * 1. char * exec_file:
+ * 2. char * args: 
+ * 3. char ** env;
+ * Returns : void.
+ * Description: Set up sanity values for arc_debug_create_inferior. More thought
+ * needed for this. 
+ */
+
+
+void
+arc_debug_create_inferior (char *exec_file, char *args, char **env,int dummy)
+{
+  ENTERARGS("%s,%s", exec_file, args);
+
+  /* If no exec file handed to us, get it from the exec-file command
+     -- with a good, common error message if none is specified.  */
+  if (exec_file == 0)
+    exec_file = get_exec_file (1);
+
+  /* We dont really have a PID or anything, but GDB uses this value to check
+     if the program is running. */
+  inferior_ptid.pid = 42;
+
+  clear_proceed_status();
+  /* -1 means resume from current place
+     TARGET_SIGNAL_0 means dont give it any signal
+     Last arg should be true if you want to single step */
+  //proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
+  proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
+}
+
+
+/* Function: arc_debug_mourn_inferior
+ * Parameters :void.
+ * Returns : void.
+ * Description: Set up sanity values for arc_debug_create_inferior. More thought
+ * needed for this. 
+ */
+
+void
+arc_debug_mourn_inferior (void)
+{
+  ENTERMSG;
+
+  unpush_target (&arc_debug_ops);
+
+  generic_mourn_inferior ();
+}
+
+
+/* Function: arc_debug_mourn_inferior
+ * Parameters :ptid_t ptid.
+ * Returns : 1 always. 
+ * Description: Checks for return values .
+ */
+
+
+int
+arc_debug_thread_alive (ptid_t ptid)
+{
+  ENTERMSG;
+  return 1;
+}
+
+
+/* Function: arc_debug_stop
+ * Parameters: void
+ * Returns: void.
+ * Description: Stop the Processor. We stop by writing FH bit to Debug Register . 
+ *	write 1 to the FH bit in the Debug register after 
+ *	polling for the DEBUG register to have no loads pending .
+ */
+void
+arc_debug_stop (void)
+{
+
+  ENTERMSG;
+  int val = 0x2;
+  /* Stop using the FH bit in the debug register. */
+  arc_debug_write_aux_register (ARC_HW_DEBUG_REGNUM, &val);
+  
+}
+
+/* Read core register.  Return 0 on success.  */
+static int
+arc_debug_read_core_register (int hwregno, int *buf)
+{
+  int rd;
+  if(arc_jtag_ops.jtag_read_core_reg(hwregno,&rd)==JTAG_READ_FAILURE)
+      error("Failure reading auxillary register 0x%x",hwregno);
+  *buf = rd;
+  return 0;
+}
+
+/* Read aux register.  Return 0 on success.  */
+static int
+arc_debug_read_aux_register (int hwregno, int *buf)
+{
+  int rd;
+  if(arc_jtag_ops.jtag_read_aux_reg(hwregno,&rd)==JTAG_READ_FAILURE)
+      error("Failure reading auxillary register 0x%x",hwregno);
+  *buf = rd;
+  return 0;
+}
+
+/* Write aux register.  Return 0 on success.  */
+static int
+arc_debug_write_aux_register (int hwregno, int *buf)
+{
+    if(arc_jtag_ops.jtag_write_aux_reg(hwregno, *buf)==JTAG_WRITE_FAILURE)
+	error("Failure writing 0x%x to auxillary register 0x%x\n",*buf,hwregno);
+  return 0;
+}
+
+/* Helper routine for commands added.  */
+/* Print Processor Variant Info.  */
+static void
+arc_print_processor_variant_info (void)
+{
+  struct gdbarch_tdep *tdep  = gdbarch_tdep (current_gdbarch);
+  
+#ifdef ARC4_JTAG
+  if (tdep->arc_processor_variant_info && 
+      tdep->arc_processor_variant_info->arcprocessorversion == A4)
+    {
+      printf_filtered ("A4\n");
+    }
+#else
+  if (tdep->arc_processor_variant_info)
+    {
+      if(tdep->arc_processor_variant_info->arcprocessorversion == ARC700)
+	printf_filtered ("ARC700\n");
+      else
+	printf_filtered ("ARC600\n");
+    }
+#endif
+  else
+    {
+      printf_filtered ("ARC Processor Information not available \n");
+    }
+
+}
+
+
+static void 
+arc_print_bcr_regs (void)
+{
+  int i = 0;
+  unsigned int bcrval = 0;
+  for ( i = 0 ; i < (sizeof(arc_bcr_reg_info) / sizeof (struct arc_reg_info)) ; i++)
+    {
+	if(arc_jtag_ops.jtag_read_aux_reg (arc_bcr_reg_info[i].hw_regno, &bcrval)==JTAG_READ_FAILURE)
+	    error("Failure reading auxillary register 0x%x",arc_bcr_reg_info[i].hw_regno);
+      printf_filtered ("[%02x] %-15s : 0x%02x\n",arc_bcr_reg_info[i].hw_regno,
+		       arc_bcr_reg_info[i].name, bcrval );
+    }
+
+}
+
+static void
+arc_debug_jtag_reset_board (void)
+{
+  arc_jtag_ops.jtag_reset_board();
+}
+
+
+/* Function: init_arc_debug_ops
+ * Parameters: void
+ * Returns: void.
+ * Description: Initialize the jtag operations. 
+ */
+
+void
+init_arc_debug_ops (void)
+{
+  ENTERMSG;
+#ifdef ARC4_JTAG
+  arc_debug_ops.to_shortname = "arcjtag";
+  arc_debug_ops.to_longname = "Target for debugging an A4 board with JTAG.";
+  arc_debug_ops.to_doc = "Debug a remote A4 board via a JTAG"; /* to_doc */
+#else
+  arc_debug_ops.to_shortname = "arcjtag";
+  arc_debug_ops.to_longname = "Target for debugging an ARC700 board with JTAG.";
+  arc_debug_ops.to_doc = "Debug a remote ARC700 board via a JTAG"; /* to_doc */
+#endif
+
+
+  arc_debug_ops.to_open = arc_debug_open;
+  arc_debug_ops.to_close = arc_debug_close;
+  arc_debug_ops.to_attach = arc_debug_attach;
+  arc_debug_ops.to_detach = arc_debug_detach;
+  arc_debug_ops.to_resume = arc_debug_resume;
+  arc_debug_ops.to_wait = arc_debug_wait;
+
+  arc_debug_ops.to_fetch_registers = arc_debug_fetch_regs;
+  arc_debug_ops.to_store_registers = arc_debug_store_regs;
+  arc_debug_ops.to_prepare_to_store = arc_debug_prepare_to_store;
+  //arc_debug_ops.to_xfer_memory = arc_debug_xfer_memory;
+  arc_debug_ops.to_xfer_partial = arc_debug_xfer_partial;
+  arc_debug_ops.to_files_info = arc_debug_files_info;
+  arc_debug_ops.to_insert_breakpoint = arc_debug_insert_breakpoint;
+  arc_debug_ops.to_remove_breakpoint = arc_debug_remove_breakpoint;
+  arc_debug_ops.to_kill = arc_debug_kill;
+  arc_debug_ops.to_load = arc_debug_load;
+
+  arc_debug_ops.to_create_inferior = arc_debug_create_inferior;
+
+  arc_debug_ops.to_mourn_inferior = arc_debug_mourn_inferior;
+  arc_debug_ops.to_thread_alive = arc_debug_thread_alive;
+  arc_debug_ops.to_stop = arc_debug_stop;
+
+  arc_debug_ops.to_terminal_inferior = NULL;
+
+  
+  arc_debug_ops.to_stratum = process_stratum;
+  
+  arc_debug_ops.to_has_all_memory = 1;
+  arc_debug_ops.to_has_memory = 1;
+  arc_debug_ops.to_has_stack = 1;
+  arc_debug_ops.to_has_registers = 1;
+  arc_debug_ops.to_has_execution = 1;
+
+  arc_debug_ops.to_magic = OPS_MAGIC;
+}
+
+
+
+void
+_initialize_arc_debug (void)
+{
+  ENTERMSG;
+  init_arc_debug_ops ();
+  add_target (&arc_debug_ops);
+  add_setshow_boolean_cmd("arcjtag-debug-target",no_class, 
+			  &debug_arc_jtag_target_message,
+			  "Set whether to print arc jtag debug messages.\n",
+			  "Show whether to print arc jtag debug messages.\n",
+			  "If set the jtag debug messages from the target are \
+printed.\n",
+			  "Whether to print debug jtag messages is %s.\n",		  
+			  NULL,NULL,&setlist,&showlist);
+
+  add_setshow_boolean_cmd("arcjtag-debug-statemachine",no_class, 
+			  &(arc_jtag_ops.arc_jtag_state_machine_debug),
+			  "Set whether to print JTAG state machine \
+debug messages \n",
+			  "Show whether to print JTAG state machine \
+debug messages \n",
+			  "If set the JTAG state machine messages are \
+printed.\n",
+			  "Whether to print JTAG state machine debug \
+messages is %s\n",
+			  NULL,NULL,&setlist,&showlist);
+
+  add_setshow_uinteger_cmd("arcjtag-retry-count",no_class, &arcjtag_retry_count,
+			   "Set the number of attempts to be made for \
+a JTAG operation.\n",
+			   "Show the number of attempts to be made for \
+a JTAG operation.\n",
+			   "Indicates the number of times a JTAG operation \
+is attempted before returning a failure.\n",
+			   "The number of times a JTAG operation is attempted \
+before returning a failure is %s.\n",
+			   NULL, NULL, &setlist, &showlist);
+
+  add_cmd ("arc-configuration", class_info, arc_print_processor_variant_info,
+	   "Show ARC configuration information." , &infolist);
+
+  add_cmd ("arc-bcr-registers", class_info, arc_print_bcr_regs,
+           "Show BCR Registers in the ARC Processor Variant", &infolist);
+
+  add_cmd ("arc-reset-board", class_obscure, arc_debug_jtag_reset_board,
+           "Reset the board.", &cmdlist);
+
+}
diff --git a/gdb/arc-jtag.h b/gdb/arc-jtag.h
new file mode 100644
index 0000000..b770a53
--- /dev/null
+++ b/gdb/arc-jtag.h
@@ -0,0 +1,76 @@
+/* Target dependent code for ARC700, for GDB, the GNU debugger.
+
+   Copyright 2005 Free Software Foundation, Inc.
+
+   Contributed by Codito Technologies Pvt. Ltd. (www.codito.com)
+
+   Authors: 
+      Soam Vasani <soam.vasani@codito.com>
+
+   This file is part of GDB.
+   
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+*/
+
+#define ARC_DEBUG_REG_SH_BIT 	0x40000000
+
+#define RAUX(name, hwregno , desc, gdbregno, version)  ARC_HW_##name##_REGNUM = hwregno , 
+#define RBCR(name, hwregno , desc, gdbregno, version)  ARC_HW_##name##_REGNUM = hwregno , 
+
+
+enum arc_hw_regnums
+  {
+    #include "arc-regnums-defs.h"
+    /* Specific ARCAngel Registers for Caches.  */
+    ARC_HW_ICACHE_IVIC = 0x10 , /* Invalidate Cache. */
+    ARC_HW_ICACHE_CONTROL = 0x11 , /* Disable ICache. ICache control. */
+    ARC_HW_DCACHE_IVIC = 0x47, /* Invalidate Cache. */
+    ARC_HW_DCACHE_CONTROL = 0x48 , /* Disable DCache. DCache Control. */
+  };
+
+#undef RBCR
+#undef RAUX
+
+#define ARC_TARGET_OBJECT_AUXREGS 	-1
+
+#define target_read_aux_reg(readbuf, offset, len)               \
+         (current_target.to_xfer_partial(&current_target,        \
+                                         ARC_TARGET_OBJECT_AUXREGS, NULL, readbuf, NULL, offset, len))
+	  
+#define target_write_aux_reg(writebuf, offset, len)             \
+         (current_target.to_xfer_partial(&current_target,        \
+                                         ARC_TARGET_OBJECT_AUXREGS, NULL, NULL, writebuf, offset, len))
+
+
+static inline int 
+is_arc700 (void)
+{
+  struct gdbarch_tdep * tdep = gdbarch_tdep (current_gdbarch);
+  if(tdep->arc_processor_variant_info->arcprocessorversion == ARC700)
+    return 1;
+  return 0;
+  
+}
+
+static inline int 
+is_arc600 (void)
+{
+  struct gdbarch_tdep * tdep = gdbarch_tdep (current_gdbarch);
+  if(tdep->arc_processor_variant_info->arcprocessorversion == ARC600)
+    return 1;
+  return 0;
+  
+}
+ int debug_arc_jtag_target_message;
diff --git a/gdb/arc-linux-tdep.c b/gdb/arc-linux-tdep.c
new file mode 100644
index 0000000..14d34a6
--- /dev/null
+++ b/gdb/arc-linux-tdep.c
@@ -0,0 +1,506 @@
+/* Target dependent code for ARC700, for GDB, the GNU debugger.
+
+   Copyright 2005 Free Software Foundation, Inc.
+
+   Authors: 
+      Soam Vasani <soam.vasani@codito.com>
+      Ramana Radhakrishnan <ramana.radhakrishnan@codito.com> 
+
+   This file is part of GDB.
+   
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+*/
+
+#include <string.h>
+
+#include "defs.h"
+#include "osabi.h"
+#include "frame.h"
+#include "regcache.h"
+#include "gdb_assert.h"
+#include "inferior.h"
+#include "reggroups.h"
+#include "solib-svr4.h"
+#include "symtab.h"
+#include "objfiles.h"
+#include "block.h"
+
+#include "arc-tdep.h"
+#include "regset.h"
+
+//#define ARC_DEBUG 1
+
+/* Default Breakpoint instructions used for 
+   ARC700 Linux 
+*/
+unsigned int arc700_linux_breakpoint_size = 2;
+unsigned char arc700_linux_breakpoint_insn[2] = { 0x3e,0x78 } ;
+
+static const char *
+arc_linux_register_name (int regno)
+{
+  static char linux_names[][10] = {"r0", "r1", "r2", "r3", "r4", "r5", "r6",
+				   "r7", "r8", "r9", "r10", "r11", "r12", "r13",
+				   "r14", "r15", "r16", "r17", "r18", "r19", "r20",
+				   "r21", "r22", "r23", "r24", "r25", "r26",
+				   
+				   "bta",
+				   "lp_start", "lp_end", "lp_count",
+				   "status32", "blink",
+				   "fp", "sp", "efa",
+				   /* linux-only registers */
+				   "ret", "orig_r8", "pc",
+
+				   /* pseudo-regs */
+				   "ilink1", "ilink2", "eret",
+				   "status_l1", "status_l2", "erstatus" };
+
+  gdb_assert(ARRAY_SIZE (linux_names) == NUM_REGS + NUM_PSEUDO_REGS);
+  gdb_assert(regno >=0 && regno < NUM_REGS + NUM_PSEUDO_REGS);
+
+  return linux_names[regno];
+}
+
+/*
+ * The kernel stores only one of (ilink1,ilink2,eret).  This is stored in
+ * the ret "register".  ilink1 is stored when the kernel has been entered
+ * because of a level 1 interrupt, etc.
+ *
+ * Same story for (status_l1, status_l2, erstatus).
+ *
+ * This disambiguity has been fixed by adding orig_r8 to pt_regs.
+ * It will take the following values -
+ *    1. if an exception of any kind occurs then orig_r8 >= 0
+ *    2. Int level 1 : -1
+ *    3. Int level 2 : -2
+ *
+ * Registers whose value we don't know are given the value zero.
+ */
+static void
+arc_linux_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
+				int regno, void *buf)
+{
+  int status32, ret, orig_r8;
+  regcache_cooked_read (current_regcache, ARC_ORIG_R8_REGNUM, &orig_r8);
+
+  if(regno == ARC_ILINK1_REGNUM ||
+     regno == ARC_ILINK2_REGNUM ||
+     regno == ARC_ERET_REGNUM)
+    {
+      regcache_cooked_read (current_regcache, ARC_RET_REGNUM, &ret);
+
+      if(regno == ARC_ILINK1_REGNUM)
+	*((unsigned int *)buf) = ((orig_r8 == -1) ? ret : 0);
+      else if(regno == ARC_ILINK2_REGNUM)
+	*((unsigned int *)buf) = ((orig_r8 == -2) ? ret : 0);
+      else if(regno == ARC_ERET_REGNUM)
+	*((unsigned int *)buf) = ((orig_r8 >= 0) ? ret : 0);
+
+    }
+  else if(regno == ARC_STATUS32_L1_REGNUM ||
+	  regno == ARC_STATUS32_L2_REGNUM ||
+	  regno == ARC_ERSTATUS_REGNUM)
+    {
+      regcache_cooked_read (current_regcache, ARC_STATUS32_REGNUM, &status32);
+
+      if(regno == ARC_STATUS32_L1_REGNUM)
+	*((unsigned int *)buf) = ((orig_r8 == -1) ? status32 : 0);
+      else if(regno == ARC_STATUS32_L2_REGNUM)
+	*((unsigned int *)buf) = ((orig_r8 == -2) ? status32 : 0);
+      else if(regno == ARC_ERSTATUS_REGNUM)
+	*((unsigned int *)buf) = ((orig_r8 >= 0) ? status32 : 0);
+    }
+  else
+    internal_error(__FILE__, __LINE__, "arc_pseudo_register_read: bad register number (%d)", regno);
+}
+
+static void
+arc_linux_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
+				 int regno, const void *buf)
+{
+  /* none of our pseudo-regs are writable */
+  internal_error(__FILE__, __LINE__, "arc_pseudo_register_write: bad register number");
+}
+
+/*
+ * print registers in the correct order.
+ *
+ * Why not have the regnums in the right order in the first place ?
+ * Because some of the registers have to be pseudo-registers because of
+ * the way the kernel is written, and because gdb assumes that
+ * pseudo-registers have regnums greater than real register regnums.
+ */
+static void
+arc_linux_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
+				struct frame_info *frame, int regnum, int all)
+{
+  int i;
+
+  if (regnum >= 0)
+    {
+      default_print_registers_info (gdbarch, file, frame, regnum, all);
+      return;
+    }
+
+  /* print all registers */
+
+  /* r0..r26 */
+  for (i=0; i <= 26; ++i)
+    default_print_registers_info (gdbarch, file, frame, i, all);
+
+  default_print_registers_info (gdbarch, file, frame, ARC_FP_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, ARC_SP_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, ARC_ILINK1_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, ARC_ILINK2_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, ARC_BLINK_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, ARC_LP_COUNT_REGNUM, all);
+  
+  /* now the aux registers */
+  
+  default_print_registers_info (gdbarch, file, frame, ARC_BTA_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, ARC_LP_START_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, ARC_LP_END_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, ARC_EFA_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, ARC_ERET_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, ARC_STATUS32_L1_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, ARC_STATUS32_L2_REGNUM, all);
+  default_print_registers_info (gdbarch, file, frame, ARC_ERSTATUS_REGNUM, all);
+
+  /* show the pc */
+  default_print_registers_info (gdbarch, file, frame, ARC_STOP_PC_REGNUM, all);
+}
+
+
+/*
+ * mov r8,nr_sigreturn
+ * swi 
+ */
+static char arc_sigtramp_insn[] = { 0x8a, 0x20, 0xc1, 0x1d, 0x6f, 0x22, 0x3f, 0x00 };
+
+/* Return whether the frame preceding NEXT_FRAME corresponds to a
+   GNU/Linux sigtramp routine.  */
+static int
+arc_linux_sigtramp_p (struct frame_info *next_frame)
+{
+  CORE_ADDR pc = frame_pc_unwind (next_frame);
+  unsigned char buf[8];
+
+  if (!safe_frame_unwind_memory (next_frame, pc, buf, 8))
+    return 0;
+
+  if (memcmp(buf, arc_sigtramp_insn, 8) == 0)
+    return 1;
+  else
+    {
+      pc -= 4;
+      
+      if (!safe_frame_unwind_memory (next_frame, pc, buf, 8))
+	return 0;
+
+      if (memcmp(buf, arc_sigtramp_insn, 8) == 0)
+	return 1;
+    }
+
+  return 0;
+}
+
+/* Assuming NEXT_FRAME is a frame following a GNU/Linux sigtramp
+   routine, return the address of the associated sigcontext structure.  */
+static CORE_ADDR
+arc_linux_sigcontext_addr (struct frame_info *next_frame)
+{
+  char buf[4];
+  CORE_ADDR sp;
+  
+  frame_unwind_register (next_frame, ARC_SP_REGNUM, buf);
+  sp = extract_unsigned_integer (buf, 4);
+
+  return sp;
+}
+
+int
+arc_linux_register_reggroup_p (int regnum, struct reggroup *group)
+{
+  if(regnum == ARC_ORIG_R8_REGNUM && group == system_reggroup)
+    return 1;
+
+  if(regnum == ARC_RET_REGNUM && group == general_reggroup)
+    return 0;
+
+  return -1;
+}
+
+/* Mapping between the general-purpose registers in `struct
+   sigcontext' format and GDB's register cache layout.
+   arc_linux_sc_reg_offset[i] is the sigcontext offset of GDB regnum `i'.  */
+
+/* From <asm/sigcontext.h>.  */
+static int arc_linux_sc_reg_offset[] =
+{
+  23 * 4,				     /* r0 */
+  22 * 4,				     /* r1 */
+  21 * 4,				     /* r2 */
+  20 * 4,				     /* r3 */
+  19 * 4,				     /* r4 */
+  18 * 4,				     /* r5 */
+  17 * 4,				     /* r6 */
+  16 * 4,				     /* r7 */
+  15 * 4,				     /* r8 */
+  14 * 4,				     /* r9 */
+  13 * 4,				     /* r10 */
+  12 * 4,				     /* r11 */
+  11 * 4,				     /* r12 */
+  -1,					     /* r13 */
+  -1,					     /* r14 */
+  -1,					     /* r15 */
+  -1,					     /* r16 */
+  -1,					     /* r17 */
+  -1,					     /* r18 */
+  -1,					     /* r19 */
+  -1,					     /* r20 */
+  -1,					     /* r21 */
+  -1,					     /* r22 */
+  -1,					     /* r23 */
+  -1,					     /* r24 */
+  -1,					     /* r25 */
+  10 * 4,				     /* r26 */
+  2 * 4,				     /* bta */
+  3 * 4,				     /* lp_start */
+  4 * 4,				     /* lp_end */
+  5 * 4,				     /* lp_count */
+  6 * 4,				     /* status32 */
+  8 * 4,				     /* blink */
+  9 * 4,				     /* fp */
+  1 * 4,				     /* sp */
+  -1,					     /* efa */
+  7 * 4,				     /* ret */
+  -1,					     /* orig_r8 */
+  -1, 					     /* stop_pc */
+};
+
+
+/* Set the program counter for process PTID to PC.  */
+
+static void
+arc700_linux_write_pc (CORE_ADDR pc, ptid_t ptid)
+{
+  ULONGEST val;
+  write_register_pid (PC_REGNUM, pc, ptid);
+
+  /* We must be careful with modifying the program counter.  If we
+     just interrupted a system call, the kernel might try to restart
+     it when we resume the inferior.  On restarting the system call,
+     the kernel will try backing up the program counter even though it
+     no longer points at the system call.  This typically results in a
+     SIGSEGV or SIGILL.  We can prevent this by writing `-1' in the
+     "orig_r8" pseudo-register.
+
+     Note that "orig_r8" is saved when setting up a dummy call frame.
+     This means that it is properly restored when that frame is
+     popped, and that the interrupted system call will be restarted
+     when we resume the inferior on return from a function call from
+     within GDB.  In all other cases the system call will not be
+     restarted.  */
+  write_register_pid (ARC_ORIG_R8_REGNUM, -3, ptid);
+}
+
+
+/* See the comments for SKIP_SOLIB_RESOLVER at the top of infrun.c.
+
+   This is called on every single step thru the PLT and runtime resolver.
+
+   This function:
+   1) decides whether a PLT has sent us into the linker to resolve
+      a function reference, and 
+   2) if so, tells us where to set a temporary breakpoint that will
+      trigger when the dynamic linker is done.  */
+
+CORE_ADDR
+arc_linux_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
+{
+  /* For uClibc 0.9.26.
+
+     An unresolved PLT entry points to "__dl_linux_resolve", which calls
+     "__dl_linux_resolver" to do the resolving and then eventually jumps to
+     the function.
+
+     So we look for the symbol `_dl_linux_resolver', and if we are there,
+     we set a breakpoint at the return address, and continue.  */
+
+  /* lookup_minimal_symbol didn't work, for some reason.  */
+  struct symbol *resolver 
+    = lookup_symbol_global ("_dl_linux_resolver", 0, VAR_DOMAIN, 0);
+  
+#ifdef ARC_DEBUG
+  printf("--- arc_linux_skip_solib_resolver: pc = %x, resolver at %x\n", pc,
+	 resolver ? BLOCK_START (SYMBOL_BLOCK_VALUE (resolver)) : 0);
+#endif
+  
+  if (resolver && (BLOCK_START (SYMBOL_BLOCK_VALUE (resolver))) == pc)
+    {
+	return frame_pc_unwind (get_current_frame ());
+    }
+
+  return 0;
+}      
+
+
+/* arcompact_linux_core_reg_offsets[i] is the offset in the .reg section of GDB
+   regnum i .
+   
+   From include/asm-arc/user.h in the ARC Linux sources.  */
+static int arcompact_linux_core_reg_offsets[] = {
+  22 * 4,    /* r0 */
+  21 * 4,    /* r1 */
+  20 * 4,    /* r2 */
+  19 * 4,    /* r3 */
+  18 * 4,    /* r4 */
+  17 * 4,    /* r5 */
+  16 * 4,    /* r6 */
+  15 * 4,    /* r7 */
+  14 * 4,    /* r8 */
+  13 * 4,    /* r9 */
+  12 * 4,    /* r10 */
+  11 * 4,    /* r11 */
+  10 * 4,    /* r12 */
+  39 * 4,    /* r13 */
+  38 * 4,    /* r14 */
+  37 * 4,    /* r15 */
+  36 * 4,    /* r16 */
+  35 * 4,    /* r17 */
+  34 * 4,    /* r18 */
+  33 * 4,    /* r19 */
+  32 * 4,    /* r20 */
+  31 * 4,    /* r21 */
+  30 * 4,    /* r22 */
+  29 * 4,    /* r23 */
+  28 * 4,    /* r24 */
+  27 * 4,    /* r25 */
+   9 * 4,    /* r26 */
+   1 * 4,    /* bta */
+   2 * 4,    /* lp_start */
+   3 * 4,    /* lp_end */
+   4 * 4,    /* lp_count */
+   5 * 4,    /* status32 */
+   7 * 4,    /* blink */
+   8 * 4,    /* fp */
+  25 * 4,    /* sp */
+  -1,        /* efa */
+   6 * 4,    /* ret */
+  24 * 4,    /* orig_r8 */
+  40 * 4,    /* stop_pc */
+};
+
+/* Extract the register values found in the ABI GREGSET, storing their
+   values in REGCACHE.  */
+static void
+arcompact_linux_supply_gregset (struct regcache *regcache,
+				int regnum, const void *gregs, size_t size)
+{
+  int regi;
+  int arc_num_gprs = ARRAY_SIZE (arcompact_linux_core_reg_offsets);
+  const bfd_byte *buf = gregs;
+
+  for (regi = 0; regi < arc_num_gprs; regi++)
+    {
+      if (arcompact_linux_core_reg_offsets[regi] > 0)
+	regcache_raw_supply (regcache, regi,
+			     buf + arcompact_linux_core_reg_offsets[regi]);
+    }
+}
+
+/* Call the right architecture variant's supply_gregset function.  For now,
+   we only have ARCompact.  */
+static void
+arc_linux_supply_gregset (const struct regset *regset,
+			  struct regcache *regcache,
+			  int regnum, const void *gregs, size_t size)
+{
+  arcompact_linux_supply_gregset (regcache, regnum, gregs, size);
+}
+
+/* Functions for handling core files.
+   The first element is a parameter to pass the rest of the functions.  We
+   don't need it.
+   supply_gregset is for reading the core file.
+   collect_regset, which we haven't defined, would be for writing the core
+   file.  */
+static struct regset arc_linux_gregset = {
+  NULL, arc_linux_supply_gregset
+};
+
+/* This is called through gdbarch.  */
+static const struct regset *
+arc_linux_regset_from_core_section (struct gdbarch *core_arch,
+				    const char *sect_name, size_t sect_size)
+{
+  if (strcmp (sect_name, ".reg") == 0)
+    return &arc_linux_gregset;
+
+  return NULL;
+}
+
+/* Add the signal stuff to gdbarch->tdep.  */
+static void
+arc_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  
+  tdep->sigtramp_p = arc_linux_sigtramp_p;
+  tdep->sigcontext_addr = arc_linux_sigcontext_addr;
+  tdep->sc_reg_offset = arc_linux_sc_reg_offset;
+  tdep->sc_num_regs = ARRAY_SIZE (arc_linux_sc_reg_offset);
+
+  tdep->arc_breakpoint_size = arc700_linux_breakpoint_size;
+  tdep->arc_breakpoint_insn = arc700_linux_breakpoint_insn;
+
+  set_gdbarch_num_regs (gdbarch, ARC_NR_REGS);
+  set_gdbarch_num_pseudo_regs (gdbarch, ARC_NR_PSEUDO_REGS);
+  
+  set_gdbarch_pc_regnum (gdbarch, ARC_STOP_PC_REGNUM);
+  set_gdbarch_register_name (gdbarch, arc_linux_register_name);
+
+  set_gdbarch_software_single_step (gdbarch, arc_software_single_step);
+
+  set_gdbarch_write_pc (gdbarch, arc700_linux_write_pc);
+
+  tdep->pc_regnum_in_sigcontext = ARC_RET_REGNUM;
+
+
+  set_gdbarch_pseudo_register_read (gdbarch, arc_linux_pseudo_register_read);
+  set_gdbarch_pseudo_register_write (gdbarch, arc_linux_pseudo_register_write);
+
+  set_gdbarch_print_registers_info (gdbarch, arc_linux_print_registers_info);
+
+  tdep->register_reggroup_p = arc_linux_register_reggroup_p;
+  
+  tdep->lowest_pc = 0x74;
+
+  tdep->arc_processor_variant_info = NULL;
+  set_gdbarch_regset_from_core_section (gdbarch, 
+					arc_linux_regset_from_core_section);
+  /* GNU/Linux uses SVR4-style shared libraries.  */
+  set_solib_svr4_fetch_link_map_offsets
+    (gdbarch, svr4_ilp32_fetch_link_map_offsets);
+
+  set_gdbarch_skip_solib_resolver (gdbarch, arc_linux_skip_solib_resolver);
+}
+
+void
+_initialize_arc_linux_tdep (void)
+{
+  gdbarch_register_osabi (bfd_arch_arc, 0, GDB_OSABI_LINUX,
+			  arc_linux_init_abi);
+}
diff --git a/gdb/arc-regnums-defs.h b/gdb/arc-regnums-defs.h
new file mode 100644
index 0000000..6071ee4
--- /dev/null
+++ b/gdb/arc-regnums-defs.h
@@ -0,0 +1,108 @@
+/* Target dependent code for ARC700, for GDB, the GNU debugger.
+
+   Copyright 2005 Free Software Foundation, Inc.
+
+   Contributed by Codito Technologies Pvt. Ltd. (www.codito.com)
+
+   Authors: 
+      Ramana Radhakrishnan <ramana.radhakrishnan@codito.com> 
+
+   This file is part of GDB.
+   
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+*/
+
+#ifdef RAUX
+#ifdef ARC4_JTAG
+
+RAUX ( STATUS , 0x0, "Status Regnum " , ARC_STATUS_REGNUM , A4 )
+RAUX ( SEMAPHORE ,  0x1, "Semaphore Regnum ", ARC_SEMAPHORE_REGNUM , A4  ) 
+RAUX ( LP_START , 0x2, "Loop Start" , ARC_LP_START_REGNUM , A4  )
+RAUX ( LP_END , 0x3, "Loop End", ARC_LP_END_REGNUM , A4 )
+RAUX ( IDENTITY , 0x4, "Identity", ARC_IDENTITY_REGNUM , A4 )
+RAUX ( DEBUG , 0x5, "Debug" , ARC_DEBUG_REGNUM , A4 )
+
+#else
+
+RAUX ( STATUS , 0x0, "Status Regnum (obsolete)" , ARC_STATUS_REGNUM , ARCompact )
+RAUX ( SEMAPHORE ,  0x1, "Semaphore Regnum ", ARC_SEMAPHORE_REGNUM , ARCompact  ) 
+RAUX ( LP_START , 0x2, "Loop Start" , ARC_LP_START_REGNUM , ARCompact  )
+RAUX ( LP_END , 0x3, "Loop End", ARC_LP_END_REGNUM , ARCompact )
+RAUX ( IDENTITY , 0x4, "Identity", ARC_IDENTITY_REGNUM , ARCompact )
+RAUX ( DEBUG , 0x5, "Debug" , ARC_DEBUG_REGNUM , ARCompact )
+RAUX ( PC, 0x6,"PC" , ARC_PC_REGNUM ,ARCompact )
+RAUX ( STATUS32 ,0xA,"STATUS32", ARC_STATUS32_REGNUM , ARCompact ) 
+RAUX ( STATUS32_L1 , 0xB, "STATUS32 register in case of L1 interrupts" ,ARC_STATUS32_L1_REGNUM , ARCompact )
+RAUX ( STATUS32_L2 , 0xC, "STATUS32 register in case of L2 interrupts" ,ARC_STATUS32_L2_REGNUM , ARCompact )
+RAUX ( COUNT0 , 0x21, "Processor Timer 1 Count Value", ARC_COUNT0_REGNUM , ARCompact )
+RAUX ( CONTROL0 , 0x22, "Processor Timer 1 Control Value" , ARC_CONTROL0_REGNUM, ARCompact)
+RAUX ( LIMIT0 , 0x23, "Processor Timer 1 Limit Value" , ARC_LIMIT0_REGNUM, ARCompact )
+RAUX ( INT_VECTOR_BASE , 0x25, "Interrupt Vector Base Register", ARC_INT_VECTOR_BASE_REGNUM , ARCompact )
+RAUX ( AUX_IRQ_MACMODE , 0x41, "Aux IRQ MAC Mode " , ARC_AUX_MACMODE_REGNUM , ARCompact )
+RAUX ( AUX_IRQ_LV12 , 0x42, "Aux IRQ Level 2 " , ARC_AUX_IRQ_LV12_REGNUM , ARCompact )
+RAUX ( COUNT1 , 0x100, "Processor Timer 1 Count Value", ARC_COUNT1_REGNUM , ARCompact )
+RAUX ( CONTROL1 , 0x101, "Processor Timer 1 Control Value" , ARC_CONTROL1_REGNUM , ARCompact)
+RAUX ( LIMIT1 , 0x102, "Processor Timer 1 Limit Value", ARC_LIMIT1_REGNUM , ARCompact)
+RAUX ( AUX_IRQ_LEV , 0x200, "Interrupt Level programming. ", ARC_AUX_IRQ_LEV_REGNUM , ARCompact)
+RAUX ( AUX_IRQ_HINT , 0x201, "Software Triggered Interrupt" , ARC_AUX_IRQ_HINT_REGNUM, ARCompact )
+RAUX ( ERET , 0x400, "Exception Return " , ARC_ERET_REGNUM, ARC700 )
+RAUX ( ERBTA , 0x401, "Exception BTA ", ARC_ERBTA_REGNUM, ARC700 )
+RAUX ( ERSTATUS , 0x402, "Exception Return Status" , ARC_ERSTATUS_REGNUM, ARC700 )
+RAUX ( ECR , 0x403, "Exception Cause Register" , ARC_ECR_REGNUM, ARC700 )
+RAUX ( EFA , 0x404, "Exception Fault Address" , ARC_EFA_REGNUM, ARC700 )
+RAUX ( ICAUSE1 , 0x40A, "Interrupt Cause (Level 1)", ARC_ICAUSE1_REGNUM,ARC700 )
+RAUX ( ICAUSE2 , 0x40B, "Interrupt Cause (Level 2)", ARC_ICAUSE2_REGNUM, ARC700)
+RAUX ( AUX_IENABLE , 0x40C, "Interrupt Mask Programming", ARC_AUX_IENABLE_REGNUM, ARC700 )
+RAUX ( AUX_ITRIGGER , 0x40D, "Interrupt Sensitivity Programming", ARC_AUX_ITRIGGER_REGNUM, ARC700 )
+RAUX ( XPU , 0x410, "User Mode Extension Permissions", ARC_XPU_REGNUM, ARC700 )
+RAUX ( BTA , 0x412, "Branch Target Address", ARC_BTA_REGNUM, ARC700 )
+RAUX ( BTA_L1 , 0x413, "Branch Target Address in Level 1", ARC_BTA_L1_REGNUM, ARC700 )
+RAUX ( BTA_L2 , 0x414, "Branch Target Address in Level 2", ARC_BTA_L2_REGNUM, ARC700 )
+RAUX ( AUX_IRQ_PULSE_CANCEL , 0x415, "Interrupt Pulse Cancel", ARC_AUX_IRQ_PULSE_CANCEL_REGNUM, ARC700 )
+RAUX ( AUX_IRQ_PENDING , 0x416, "Interrupt Pending Register", ARC_AUX_IRQ_PENDING_REGNUM, ARC700 )
+#endif // ARC4_JTAG
+#endif // RAUX
+
+#ifdef RBCR
+#ifndef ARC4_JTAG
+
+RBCR ( DCCM_BASE_BUILD , 0x61, "Base address for DCCM.", ARC_BCR_1_REGNUM, ARCompact)
+RBCR ( CRC_BASE_BUILD , 0x62, "BCRBCR for CRC Unit.", ARC_BCR_2_REGNUM , ARCompact)
+RBCR ( BTA_LINK_BUILD , 0x63, "Interrupt Link Registers Available for BTA",ARC_BCR_3_REGNUM, ARCompact )
+RBCR ( DVBF_BUILD , 0x64, "BCRBCR for Dual Viterbi Instruction.",ARC_BCR_4_REGNUM, ARCompact )
+RBCR ( TEL_INSTR_BUILD , 0x65, "BCRBCR for Extended Arithmetic Instructions. ",ARC_BCR_5_REGNUM, ARCompact)
+RBCR ( MEMSUBSYS , 0x67, "BCRBCR for Memory Subsystem. ",ARC_BCR_7_REGNUM, ARCompact)
+RBCR ( VECBASE_AC_BUILD ,0x68, "BCRBCR for Interrupt Vector Base. ", ARC_BCR_8_REGNUM,ARCompact) 
+RBCR ( P_BASE_ADDRESS , 0x69, "Peripheral Base Address" , ARC_BCR_9_REGNUM , ARCompact) 
+RBCR ( MMU_BUILD , 0x6F, "MMU Build. " , ARC_BCR_F_REGNUM, ARCompact)
+RBCR ( ARCANGEL_BUILD , 0x70, "ARC Angel Build config. ", ARC_BCR_10_REGNUM, ARCompact)
+RBCR ( D_CACHE_BUILD , 0x72, "D Cache Build Config. ", ARC_BCR_12_REGNUM , ARCompact )
+RBCR ( MADI_BUILD , 0x73 , "Multiple ARC Debug Interface. " , ARC_BCR_13_REGNUM , ARCompact)
+RBCR ( DCCM_BUILD , 0x74, "BCRBCR for DCCM.(Data Closely coupled Memory", ARC_BCR_14_REGNUM, ARCompact)
+RBCR ( TIMER_BUILD , 0x75, "BCRBCR for Timers. " , ARC_BCR_15_REGNUM , ARCompact)
+RBCR ( AP_BUILD, 0x76, "Actionpoints build. ", ARC_BCR_16_REGNUM , ARCompact )
+RBCR ( ICACHE_BUILD , 0x77, "Instruction Cache BCR", ARC_BCR_17_REGNUM , ARCompact )
+RBCR ( ICCM_BUILD , 0x78, "ICCM BCRBCR (Instruction Closely Coupled Memory.", ARC_BCR_18_REGNUM , ARCompact)
+RBCR ( DSPRAM_BUILD , 0x79, "DSP RAM Build", ARC_BCR_19_REGNUM , ARCompact)
+RBCR ( MAC_BUILD , 0x7A, "MAC Unit Build", ARC_BCR_1A_REGNUM , ARCompact)
+RBCR ( MULTIPLY_BUILD , 0x7B, "(32 X 32) Multiply Unit Build", ARC_BCR_1B_REGNUM , ARCompact)
+RBCR ( SWAP_BUILD , 0x7C, "SWAP Build", ARC_BCR_1C_REGNUM , ARCompact)
+RBCR ( NORM_BUILD , 0x7D ,"NORM Unit Build", ARC_BCR_1D_REGNUM, ARCompact)
+RBCR ( MINMAX_BUILD , 0x7E, "Minmax Unit Build", ARC_BCR_1E_REGNUM, ARCompact)
+RBCR ( BARREL_BUILD , 0x7F, "Barrel Shifter Build", ARC_BCR_1F_REGNUM , ARCompact) 
+
+
+#endif // ARC4_JTAG
+#endif // RBCR 
diff --git a/gdb/arc-tdep.c b/gdb/arc-tdep.c
new file mode 100644
index 0000000..8b54257
--- /dev/null
+++ b/gdb/arc-tdep.c
@@ -0,0 +1,1999 @@
+/* Target dependent code for ARC700, for GDB, the GNU debugger.
+
+   Copyright 2005 Free Software Foundation, Inc.
+
+   Contributed by Codito Technologies Pvt. Ltd. (www.codito.com)
+
+   Authors: 
+      Soam Vasani <soam.vasani@codito.com>
+      Ramana Radhakrishnan <ramana.radhakrishnan@codito.com> 
+
+   This file is part of GDB.
+   
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+*/
+#include <string.h>
+
+#include "defs.h"
+#include "arch-utils.h"
+#include "dis-asm.h"
+#include "gdbtypes.h"
+#include "frame.h"
+#include "frame-unwind.h"
+#include "target.h"
+#include "breakpoint.h"
+#include "inferior.h"
+#include "regcache.h"
+#include "reggroups.h"
+#include "trad-frame.h"
+#include "dwarf2-frame.h"
+#include "gdbtypes.h"
+#include "gdb_assert.h"
+#include "gdbcore.h"
+#include "observer.h"
+#include "osabi.h"
+
+#include "opcode/arc.h"
+
+#include "arc-tdep.h"
+
+
+//#define ARC_DEBUG 1
+
+#if ARC_DEBUG
+#  define ENTERMSG printf ("--- entered %s:%s()\n", __FILE__, __FUNCTION__)
+#  define ENTERARGS(fmt, args...) printf ("--- entered %s:%s(" fmt ")\n", __FILE__, __FUNCTION__, args)
+#  define LEAVEMSG printf ("--- exited %s:%s()\n", __FILE__, __FUNCTION__)
+#else
+#  define ENTERMSG
+#  define ENTERARGS(fmt, args...) 
+#  define LEAVEMSG
+#endif
+
+#define ARC_STATUS32_A1 0x8
+#define ARC_STATUS32_A2 0x10
+#define ARC_STATUS32_AE 0x20
+#define ARC_STATUS32_L  0x100
+
+
+static CORE_ADDR arc_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp);
+/* The frame unwind cache for the ARC 
+ */
+
+struct arc_unwind_cache
+{
+  /* blink offset in stack */
+  int blink_offset ;
+
+  /* Caller's PC */
+  CORE_ADDR prev_pc;
+
+  
+  /* The stack pointer at the time this frame was created; i.e. the
+     caller's stack pointer when this function was called.  It is used
+     to identify this frame.  */
+  
+  CORE_ADDR prev_sp;
+  /* The frame base */
+  CORE_ADDR frame_base;
+  /* Frame size */
+  int framesize;
+  
+  /* offset of sp from the stack frame base */
+  LONGEST sp_offset;
+  /* offset of fp from the stack frame base */
+  LONGEST fp_offset;
+  /* Is this a leaf function */
+  int is_leaf ;
+  /* Is there a frame pointer */
+  int uses_fp;
+  
+  
+  /* Offsets for each register in the stack frame */
+  struct trad_frame_saved_reg *saved_regs;
+};
+
+
+
+
+/* Function Prototypes */
+
+static CORE_ADDR arc_unwind_sp (struct gdbarch *gdbarch, 
+			       struct frame_info *next_frame);
+
+static CORE_ADDR arc_unwind_pc (struct gdbarch *gdbarch, 
+			       struct frame_info *next_frame);
+
+static struct arc_unwind_cache * arc_frame_unwind_cache (struct frame_info *next_frame, 
+							 void ** this_prologue);
+
+static CORE_ADDR arc_scan_prologue (CORE_ADDR pc, 
+				     struct frame_info *next_frame,
+				     struct arc_unwind_cache *info);
+
+
+static int arc_binutils_reg_to_regnum (int reg);
+
+extern struct arcDisState arcAnalyzeInstr (  bfd_vma address,disassemble_info* info );
+extern struct arcDisState a4AnalyzeInstr (  bfd_vma address,disassemble_info* info );
+
+/* defined in opcodes, but there's no header file with this prototype... */
+disassembler_ftype arcompact_get_disassembler (void *);
+
+/*  Standard register type for the ARC platform . 
+ *  It would be builtin_type_uint32 until 
+ *  we consider the DSP extensions 
+ */
+
+static struct type *
+arc_register_type (struct gdbarch *gdbarch, int regnum)
+{
+  return builtin_type_uint32;
+}
+
+
+void printFrameInfo(struct arc_unwind_cache * info)
+{
+#ifdef ARC_DEBUG
+  printf("-------------------\n");
+  printf("%lx \n",info );
+  printf("prev_sp = %lx \n",info->prev_sp);
+  printf("prev_pc = %lx \n",info->prev_pc);
+  printf("frame_base is %lx \n",info->frame_base);
+  printf("framesize is %lx \n",info->framesize);
+  printf("Blink offset %lx \n",info->blink_offset);
+  printf("sp_offset = %lx \n",info->sp_offset );
+  printf("fp_offset is %lx \n",info->fp_offset);
+  printf("is_leaf = %d, uses_fp=%d",info->is_leaf, info->uses_fp);
+#endif
+}
+
+/* Print the instruction state returned 
+   by the disassembler . Used for internal
+   debugging only 
+*/
+
+void printInsnState(struct arcDisState state)
+{
+#ifdef ARC_DEBUG
+  printf("---------------------------------\n");
+  printf("Instruction Length %d\n", state.instructionLen);
+  printf("Opcode [0x%x] : Cond [%x]\n", state._opcode, state._cond);
+  printf("Words 1 [%lx] : 2 [%lx]\n", state.words[0], state.words[1]);
+  printf("ea present [%x] : memload [%x]\n", state._ea_present, state._mem_load);
+  printf("Load length [%d]:\n", state._load_len);
+  printf("Address writeback [%d]\n", state._addrWriteBack);
+  printf("ea reg1 is [%x] offset [%x] \n", state.ea_reg1, state._offset);
+  printf("ea reg2 is [%x] \n", state.ea_reg2);
+  printf("operands buffer is %s \n", state.operandBuffer);
+  printf("SourceType is %d \n",state.sourceType);
+  printf("Flow is %d\n",state.flow);
+  printf("Branch is %d,'%c'\n",state.isBranch, state.isBranch);
+#endif
+}
+
+
+/* Scan the prologue and update the 
+ * corresponding frame cache for the frame unwinder for unwinding
+ * frames without debug info . In such a situation GDB attempts to 
+ * parse the prologue for this purpose . This currently would attempt
+ * to parse the prologue generated by our gcc 2.95 .(We should support 
+ * Metaware generated binaries at some suitable point of time )
+ * This function is called with the pc where gdb stopped , the next_frame 
+ * to be filled in (if need be?) and the existing cached info . 
+
+ * scan_prologue is called by our unwinder as well 
+ * as from skip_prologue in the case that it cannot detect 
+ * the end of the prologue. next_frame is set to NULL if we are called from 
+ * arc_skip_prologue in an attempt to discover the end of the prologue. In
+ * such a case we don't fill the frame info that is passed to us :-)
+
+ * Todos. 
+ * 1. Support 32 bit normal frames generated by GCC 2.95 .
+ * 2. Support 16 and 32 bit mixed frames generated by GCC 2.95
+ * 3. Support 32 bit normal variadic function frames by GCC 2.95
+ * 4. Support 32 bit normal frames from GCC 3.4.x with variadic args
+ * 5. Support 16 and 32 bit normal frames from GCC 3.4.x with variadic args
+ * 6. Support 16 and 32 bit mixed frames generated by GCC 3.4.x 
+ * 7. Support Metaware generated prologues .( The difference is 
+ * in the use of thunks to identify the saving and restoring of 
+ * callee saves :-) May have to do some hackery even in next_pc. 
+ * since the call is going to create its own set of problems 
+ * with our stack setup :-( 
+ * We attempt to use the disassembler interface from the opcodes
+ * library to do our disassembling .
+
+ * The usual 32 bit normal 
+ * gcc -O0 prologue looks like this. 
+
+ * Complete Prologue for all GCC frames (Cases #1 to #6 in Todos above)
+
+ * sub  sp, sp, limm    ; space for variadic arguments.
+ * st.a blink, [sp,-4]  ; push blink (if not a leaf function) 
+ * sub  sp, sp , limm   ; (optional space creation for callee saves )
+ * st   r13, [sp]    ; pushes of all callee saves.
+ * st   r14, [sp,4]  ; pushes of more callee saves.
+ * XXXX
+ * st.a fp , [sp,-4]  ; push fp (if fp has to be saved ) 
+ * mov  fp , sp ; Set the current frame up correctly 
+ * sub  sp , sp , #immediate ; Create space for local vars on the stack.
+ */
+
+
+
+/* Macros to be used with disassembling the prologue 
+ * and update the frame info.The *FI macros are to update
+ * the frame info and the ACT macros are to actually do the 
+ * action on a corresponding match. 
+ *
+*/
+#define CHECKOPDSTRING(targetcheck,searchstring)  \
+                               if(strstr(targetcheck,searchstring) == targetcheck)  \
+                                     {continue;}
+
+#define CHECKOPDSTRINGANDACT(targetcheck,searchstring,action)  \
+                               if(strstr(targetcheck,searchstring) == targetcheck)  \
+                                     {\
+                                       action;\
+				       continue;}
+
+
+/* The frame info changes by changing the decrementing
+   the sp_offset and setting the leaf function to be NIL; 
+   Also the offset of the blink register from the previous
+   value of sp is calculated. Finally this can be updated 
+   as 
+   info->blink_offset = info-> prev_sp + info->blink_offset ;
+   Also the addition below is coz the offsets are usually negative 
+*/
+
+#define PUSHBLINKACT do { \
+                          if(info) \
+                            {      \
+                              info->sp_offset += current_instr._offset; \
+                              info->blink_offset = info->sp_offset ; \
+                              info->is_leaf = 0;\
+                            }}while(0);
+                      
+
+#define ISPUSHBLINK(state) CHECKOPDSTRING(state.operandBuffer,"blink") 
+#define ISPUSHBLINKFI(state) CHECKOPDSTRINGANDACT(state.operandBuffer,"blink",PUSHBLINKACT) 
+
+
+#define PUSHFPACT    do { \
+                          if(info)  \
+                            {       \
+                               info->sp_offset += current_instr._offset ; \
+                               info->fp_offset = -info->sp_offset; \
+                            }}while(0);
+                             
+#define ISPUSHFP(state)    CHECKOPDSTRING(state.operandBuffer,"fp")
+#define ISPUSHFPFI(state)    CHECKOPDSTRINGANDACT(state.operandBuffer,"fp",PUSHFPACT)
+#define ISINSTRUCTION(insnname,searchstring)    !strcmp(insnname,searchstring)
+
+
+
+#define UPDATEFPACT    do {\
+                             if(info) {\
+					 info->uses_fp = 1;\
+			       }}while(0);
+
+
+
+#define ISUPDATEFPFI(state)  \
+ if(ISINSTRUCTION(state.instrBuffer,"mov")) \
+{ \
+  CHECKOPDSTRINGANDACT(state.operandBuffer,"fp,sp",UPDATEFPACT); \
+}
+
+
+
+#define ISUPDATEFP(state)  \
+ if(ISINSTRUCTION(state.instrBuffer,"mov")) \
+{ \
+  CHECKOPDSTRING(state.operandBuffer,"fp,sp") \
+}
+
+
+
+#define ISSUBSP(state)   \
+if(ISINSTRUCTION(state.instrBuffer,"sub"))\
+{ \
+  CHECKOPDSTRING(state.operandBuffer,"sp,sp") \
+}
+
+#define UPDATESTACKSPACE(state) do { \
+                                 if(info){ \
+/* Eat up sp,sp */  \
+                                      int tmp = atoi(state.operandBuffer + 6); \
+                                      info->sp_offset -= tmp; \
+                                        }}while(0);
+
+
+#define ISSUBSPFI(state)   \
+if(ISINSTRUCTION(state.instrBuffer,"sub") \
+   || ISINSTRUCTION(state.instrBuffer,"sub_s"))\
+{ \
+  CHECKOPDSTRINGANDACT(state.operandBuffer,"sp,sp",UPDATESTACKSPACE(state)) \
+}
+
+/*Function to scan the prologue of a A4 binary
+
+ARCtangent-A4 Prolog
+ The stack back-trace data structure is a 16-byte structure which is
+  used to save the return register (blink, 4 bytes), the frame pointer
+  register (fp, 4-bytes) and 8-bytes is reserved.
+ 
+ The compiler-generated prolog code does the following:
+  --> Allocates space for register arguments in case of variadic function
+        (functions with variable argument lists)
+  --> Saves the return address register (blink)
+  --> Saves the caller's frame pointer (fp), if required, and
+        sets the new frame pointer to this location
+  --> Decrements the stack pointer to account for the new stack frame
+  --> Saves required non-volatile general-purpose registers into the
+        register save area
+  --> Stores the arguments above the stack back-trace data structure
+
+
+  Demo Patterns:
+     st         blink,[sp,4] ; Saves the return address
+     st         fp,[sp] ; Saves the callers frame pointer
+     mov        fp,sp   ; Saves 
+     sub        sp,sp,24
+
+0xa  538e7e20     sub        sp,sp,32     ; Space for variadic args
+0x2  100e3e04     st         blink,[sp,4] ; Saves the return address
+0x2  100e3600     st         fp,[sp]      ; Saves the callers frame pointer
+0xc  636e3800     mov        fp,sp        ; Resets stack pointer to fp
+0xa  538e7e18     sub        sp,sp,24     ; Decrements sp to add for new
+                                          ; stack frame
+0x2  100d81fc     st         r0,[fp,-4]   ; Stores the args 
+0x2  100d83f8     st         r1,[fp,-8]   ; ----"-------
+     ...
+
+*/
+
+/* FIXMEA:
+called from arc_skip_prologue as
+     skip_pc = arc_scan_prologue(pc,NULL,NULL);
+        Then it is supposed to return the first valid pc
+	after the prologue
+
+   Prologue analysis does the rest...  
+   Currently our scan prologue does not
+    support getting input for the frame unwinder
+
+  
+  pc = frame_func_unwind(next_frame);
+  arc_scan_prologue (pc, next_frame, info);
+
+*/
+
+#ifdef ARC4_JTAG
+static CORE_ADDR 
+a4_scan_prologue (CORE_ADDR pc, struct frame_info *next_frame,
+		    struct arc_unwind_cache *info)
+{
+  /* End of prologue */
+  CORE_ADDR prologue_ends_pc = pc;
+  int i = 0;
+  struct arcDisState current_instr, instr_in_delay;
+  int insn_length;
+
+  /* Initializations to use the opcodes 
+   * library .
+   */
+  
+  struct disassemble_info di;
+
+  unsigned int saved_regs_mask = 0;
+  /* An arbitrary length on the length of the 
+     prologue. If next_frame is NULL this means that there was 
+     no debug info and we are called from arc_skip_prologue
+  */
+  /*FIXMEANOW: pc + 64 is probably the max size of the prologue*/
+  CORE_ADDR final_pc = (next_frame)?frame_pc_unwind(next_frame):pc+(16*4);
+  
+  
+
+
+  if (info)
+    {
+      /* All functions start as leaf functions until 
+	 we identify push blink 
+      */
+      info->is_leaf = 1;
+    }
+  
+
+
+  /* Initializations to use the opcodes 
+   * library .
+   */
+  init_disassemble_info(&di, gdb_stderr, fprintf_unfiltered);
+  di.arch = gdbarch_bfd_arch_info(current_gdbarch)->arch;
+  di.mach = gdbarch_bfd_arch_info(current_gdbarch)->mach;
+  di.endian = gdbarch_byte_order(current_gdbarch);
+  di.read_memory_func = target_read_memory;
+  
+  
+  for (prologue_ends_pc= pc;
+       prologue_ends_pc< final_pc; 
+       prologue_ends_pc += current_instr.instructionLen ) /*FIXMEA: This could as
+							    well be 4 */
+    {
+      current_instr = a4AnalyzeInstr(prologue_ends_pc, &di);
+      printInsnState(current_instr);
+#ifdef ARC_DEBUG
+      printf("Prologue PC: %d\n", prologue_ends_pc);
+      printf("Final PC: %d\n", final_pc);
+#endif
+
+
+      if (current_instr._opcode == 0x2)
+	{
+	  // Saves the return address    st blink,[sp,4]   0x100e3e04
+	  // Save the callers fp         st fp,[sp]        0x100e3600
+	  // Saves the args              st rX,[fp, #imm]  0x100d8xxx
+	  if (current_instr.ea_reg1 == 28)
+	    {
+	      if( strstr(current_instr.operandBuffer,"blink") == current_instr.operandBuffer)
+		{
+                  if(info)
+		    {      
+		      info->sp_offset += current_instr._offset;
+ //		      info->blink_offset = info->sp_offset ;
+		      info->blink_offset = current_instr._offset;
+		      info->is_leaf = 0;
+
+#ifdef ARC_DEBUG
+		      printf("Blink instruction:\n");
+		      printFrameInfo(info);
+#endif
+		    }
+		  continue;
+		}
+	      else
+		if(strstr(current_instr.operandBuffer,"fp") == current_instr.operandBuffer)
+		{
+		  if(info)
+		    {
+/* 		      info->sp_offset += current_instr._offset ; */
+/* 		      info->fp_offset = info->sp_offset; */
+		      info->fp_offset = 0;
+		    }
+		  continue;
+		}
+	    }
+	  else if (current_instr.ea_reg1 == 27)
+	    {
+	      /* Saving of arguments onto the stack using the
+		 frame pointer (r27).  */
+	      if(info)
+		{
+		  // Save regs offsets 
+		}
+#ifdef ARC_DEBUG	      
+	      printf(" Saving registers onto stack\n%s\n",current_instr.operandBuffer);
+#endif	      
+	      continue;
+	    }
+	  //	  ISPUSHBLINK(current_instr);
+	}
+      else if (current_instr._opcode == 0xc)
+	{
+	  // Resets stack pointer to fp
+	  // 0x636e3800
+	  //	  636e3800     mov        fp,sp
+	  if (current_instr.words[0] == 0x636e3800)
+	    {
+	      if (info)
+		{
+		  info->uses_fp = 1;
+		}
+	      continue;
+	    }
+	}
+      else if (current_instr._opcode == 0xa)
+	{
+	  // Decrements stackpointer to add for new stack frame
+	  // 0x538e7e18   sub        sp,sp,#imm
+	  // 538e7e20     sub        sp,sp,32
+	  if( current_instr.words[0] == 0x538e7e20)
+	    {
+	      //sub sp,sp, 32  //// variadic
+	      if (info)
+		{
+		  int tmp = atoi(current_instr.operandBuffer + 6); 
+		  info->sp_offset -= tmp; 
+		}
+	      continue;
+	    }
+	  else if((current_instr.words[0] & 0xffffff00) == 0x538e7e00)
+	    {
+	      // sub sp,sp,xx
+	      if(info)
+		{
+		  int tmp = atoi(current_instr.operandBuffer + 6); 
+		  info->sp_offset -= tmp; 
+		}
+	      continue;
+	    }
+	}
+
+      /* Found a instruction that is not in
+         the prologue*/
+#ifdef ARC_DEBUG
+      printf("End of Prologue reached \n");
+#endif
+      break;
+    }
+
+  /* Means we were called from skip_prologue */
+  if((next_frame == NULL)&& (info == NULL))
+    {
+      return prologue_ends_pc;
+    }
+
+
+  info->framesize = -info->sp_offset;
+  /* Compute the previous frame's stack pointer (which is also the
+     frame's ID's stack address), and this frame's base pointer.  */
+  if(info->uses_fp)
+    {
+
+      ULONGEST this_base;
+      /* The SP was moved to the FP.  This indicates that a new frame
+         was created.  Get THIS frame's FP value by unwinding it from
+         the next frame.  */
+      frame_unwind_unsigned_register(next_frame, ARC_FP_REGNUM,
+				     &this_base);
+      info->frame_base = this_base;
+      info->saved_regs[ARC_FP_REGNUM].addr = info->frame_base;
+
+      /* The previous sp is the current frame base + the offset of the
+	 fp in the current frame */
+      info->prev_sp = info->frame_base + info->fp_offset;
+      for(i = 13; i < 26 ; i++ )
+	{
+	  if(saved_regs_mask & (1 << i))
+	    info->saved_regs[i].addr += info->frame_base ;
+	}
+      
+      printFrameInfo(info);
+   
+    }
+  else
+    {
+      ULONGEST this_base;
+      /* Assume that the FP is this frame's SP but with that pushed
+         stack space added back.  */
+      frame_unwind_unsigned_register (next_frame, ARC_SP_REGNUM, &this_base);
+      info->frame_base = this_base;
+
+      /* In such a case it would be the previous SP + the size of the current frame */
+      info->prev_sp = info->frame_base + info->framesize;
+     
+    }
+  
+
+  if(!info->is_leaf)
+    {
+
+      /* Usually blink is saved before the callee save registers and
+	 below the space created for variadic arguments  . We maintain
+	 info->blink_offset as negative when we stored it initially
+       */
+      info->saved_regs[ARC_BLINK_REGNUM].addr = info->prev_sp + info->blink_offset;
+#ifdef ARC_DEBUG
+      printf("blink offset is [%x] \n",info->blink_offset);
+#endif
+    }
+      
+    /* The PC is found in blink (the actual register or located on the stack).  */
+  // FIXMEA:
+  //info->saved_regs[ARC_STATUS_REGNUM] |= (info->saved_regs[ARC_BLINK_REGNUM] & 0xffffff)>>2;
+  info->saved_regs[ARC_STATUS_REGNUM] = info->saved_regs[ARC_BLINK_REGNUM];
+  return prologue_ends_pc;
+
+}
+#endif
+
+static CORE_ADDR 
+arc_scan_prologue (CORE_ADDR pc, struct frame_info *next_frame,
+		    struct arc_unwind_cache *info)
+{
+#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf("\narc_scan_prologue called\n");
+#endif
+#else
+  /* End of prologue */
+  CORE_ADDR prologue_ends_pc = pc;
+  int i = 0;
+  struct arcDisState current_instr, instr_in_delay;
+  int insn_length;
+
+  /* Initializations to use the opcodes 
+   * library .
+   */
+  
+  struct disassemble_info di;
+
+  unsigned int saved_regs_mask = 0;
+  /* An arbitrary length on the length of the 
+     prologue. If next_frame is NULL this means that there was 
+     no debug info and we are called from arc_skip_prologue
+  */
+  CORE_ADDR final_pc = (next_frame)?frame_pc_unwind(next_frame):pc+64; 
+  
+  
+
+
+  if (info)
+    {
+      /* All functions start as leaf functions until 
+	 we identify push blink 
+      */
+      info->is_leaf = 1;
+      
+    }
+  
+
+
+  /* Initializations to use the opcodes 
+   * library .
+   */
+  init_disassemble_info(&di, gdb_stderr, fprintf_unfiltered);
+  di.arch = gdbarch_bfd_arch_info(current_gdbarch)->arch;
+  di.mach = gdbarch_bfd_arch_info(current_gdbarch)->mach;
+  di.endian = gdbarch_byte_order(current_gdbarch);
+  di.read_memory_func = target_read_memory;
+  
+  
+  for(prologue_ends_pc= pc; prologue_ends_pc< final_pc; 
+      prologue_ends_pc += current_instr.instructionLen )
+    {
+      current_instr = arcAnalyzeInstr(prologue_ends_pc, &di);
+      printInsnState(current_instr);
+        /* Might be a push or a pop */
+      if(current_instr._opcode == 0x3)
+	{
+	  if(current_instr._addrWriteBack)
+	    {
+	      /* This is a st.a  */
+	      if((current_instr.ea_reg1 == 28) &&
+		 (current_instr._offset == -4))
+		{
+		  
+		  /* This is a push something at sp */
+		  /* Is it a push of the blink */
+		  ISPUSHBLINKFI(current_instr);
+		  /* Is it a push for fp */
+		  ISPUSHFPFI(current_instr);
+		  
+		}
+	      
+	    } 
+	  else
+	    {
+	      /* Is this a store of some register onto 
+		 the stack using the stack pointer.*/
+	      if(current_instr.ea_reg1 == 28)
+		{
+		  if(current_instr.sourceType == ARC_REGISTER )
+		    {
+		      /* R13..R26 are the callee saved registers.  [R27 (fp)
+			 is also a callee saved register, but it's usually
+			 pushed using st.a and so handled in the st.a case
+			 above.]  */
+		      if((current_instr.source_operand.registerNum > 12 
+			  && current_instr.source_operand.registerNum <= 26))
+			{
+			  if(info)
+			    {
+			      printFrameInfo(info);
+			      /* Save up the offsets for the correct instruction */
+			      info->saved_regs[current_instr.source_operand.registerNum].addr
+				= - info->sp_offset - current_instr._offset;
+			      saved_regs_mask |= (1 << current_instr.source_operand.registerNum);
+			    }
+			  continue;
+			}
+		      
+		    }		  
+		  
+		}
+	      /* Is this the store of some register on the 
+		 stack using the frame pointer. We check 
+		 for argument registers getting saved and
+		 restored.
+	      */
+	      if(current_instr.ea_reg1 == 27)
+		if((current_instr.source_operand.registerNum <= 7))
+		  {
+		    /* Saving argument registers.Don't save them in saved_regs, just skip. 
+		     */
+		    continue;
+		  }
+		
+	      
+	      
+	    }
+	}
+
+      if(current_instr._opcode == 0x4)
+	{
+	  /* A major opcode 0x4 instruction */
+	  /* We are usually interested in a 
+	     mov or a sub */
+	  ISUPDATEFPFI(current_instr);
+	  ISSUBSPFI(current_instr);
+	}
+      if(current_instr._opcode == 0x18)
+	{
+	  /* sub_s sp,sp,constant */
+	  ISSUBSPFI(current_instr);
+	  /* push_s blink */
+	  if(strcmp(current_instr.instrBuffer,"push_s") == 0)
+	    {
+	      if(strcmp(current_instr.operandBuffer,"blink") == 0)
+		{
+		  if(info) 
+		    {   
+		      info->sp_offset += 4; 
+		      info->blink_offset = info->sp_offset ; 
+		      info->is_leaf = 0;
+		    }
+		  continue;
+		}
+	    }
+	}
+
+      /* If we reach here . we have 
+       * reached end of the prologue
+       */
+      break;
+      
+    }
+  
+  /* Means we were called from skip_prologue */
+  if((next_frame == NULL)&& (info == NULL))
+    {
+      return prologue_ends_pc;
+    }
+  
+  
+  info->framesize = -info->sp_offset;
+  /* Compute the previous frame's stack pointer (which is also the
+     frame's ID's stack address), and this frame's base pointer.  */
+  if(info->uses_fp)
+    {
+
+      ULONGEST this_base;
+      /* The SP was moved to the FP.  This indicates that a new frame
+         was created.  Get THIS frame's FP value by unwinding it from
+         the next frame.  */
+      frame_unwind_unsigned_register(next_frame, ARC_FP_REGNUM,
+				     &this_base);
+      info->frame_base = this_base;
+      info->saved_regs[ARC_FP_REGNUM].addr = info->frame_base;
+
+      /* The previous sp is the current frame base + the offset of the 
+	 fp in the current frame */
+      info->prev_sp = info->frame_base + info->fp_offset;
+      for(i = 13; i < 26 ; i++ )
+	{
+	  if(saved_regs_mask & (1 << i))
+	    info->saved_regs[i].addr += info->frame_base ;
+	}
+      
+      printFrameInfo(info);
+   
+    }
+  else
+    {
+      ULONGEST this_base;      
+      /* Assume that the FP is this frame's SP but with that pushed
+         stack space added back.  */
+      frame_unwind_unsigned_register (next_frame, ARC_SP_REGNUM, &this_base);
+      info->frame_base = this_base;
+
+      /* In such a case it would be the previous SP + the size of the current frame */
+      info->prev_sp = info->frame_base + info->framesize;
+     
+    }
+  
+
+  if(!info->is_leaf)
+    {
+
+      /* Usually blink is saved before the callee save registers and 
+	 below the space created for variadic arguments  . We maintain
+	 info->blink_offset as negative when we stored it initially
+       */
+      info->saved_regs[ARC_BLINK_REGNUM].addr = info->prev_sp + info->blink_offset;
+#ifdef ARC_DEBUG
+      printf("blink offset is [%x] \n",info->blink_offset);
+#endif
+    }
+      
+    /* The PC is found in blink (the actual register or located on the stack).  */
+  info->saved_regs[PC_REGNUM] = info->saved_regs[ARC_BLINK_REGNUM];
+  /*info->saved_regs[ARC_PC_REGNUM] = info->saved_regs[ARC_BLINK_REGNUM];*/
+  return prologue_ends_pc;
+#endif
+}
+
+
+/* Skip the prologue for the function at pc. 
+ * This is done by checking from the line  
+ * information picked up during dwarf reading
+ * FIXME: more stuff to be added when we 
+ * parse the prologue.
+ */
+
+static CORE_ADDR
+arc_skip_prologue (CORE_ADDR pc)
+{
+  //#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\narc_skip_prologue called\n");
+#endif
+  // FIXMEA: cleanup #else
+  unsigned long inst;
+  unsigned long addend = 4;
+  CORE_ADDR skip_pc = pc;
+  CORE_ADDR func_addr, func_end = 0;
+  char *func_name;
+  struct symtab_and_line sal;
+
+  /* If we're in a dummy frame, don't even try to skip the prologue.  */
+  if (deprecated_pc_in_call_dummy (pc))
+    return pc;
+
+  /* See what the symbol table says.  */
+
+  if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
+    {
+      struct symbol *sym;
+
+      /* Found a function.  */
+      sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL, NULL);
+      if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
+        {
+	  /* Don't use this trick for assembly source files.  */
+	  sal = find_pc_line (func_addr, 0);
+	  if ((sal.line != 0) && (sal.end < func_end))
+	    return sal.end;
+        }
+    }
+  
+#ifdef ARC4_JTAG 
+  skip_pc = a4_scan_prologue(pc, NULL, NULL);
+#else
+  skip_pc = arc_scan_prologue(pc,NULL,NULL);
+#endif  
+  return skip_pc;		/* End of prologue */
+
+  //#endif
+}
+
+/* Breakpoint from pc. Return whatever is in the tdep 
+ * structure. The tdep structure is changed depending 
+ * on the correct target / architecture chosen. 
+ */
+
+static const unsigned char *
+arc_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+{
+
+  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  *lenptr = tdep->arc_breakpoint_size;
+  return tdep->arc_breakpoint_insn;
+}
+
+
+/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
+   dummy frame.  The frame ID's base needs to match the TOS value
+   saved by save_dummy_frame_tos(), and the PC match the dummy frame's
+   breakpoint. */
+
+static struct frame_id
+arc_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+  return frame_id_build (arc_unwind_sp (gdbarch, next_frame),
+			 frame_pc_unwind (next_frame));
+}
+
+/* The workhorse : frame_unwind_cache for the ARC700 platform .
+ */
+static struct arc_unwind_cache *
+arc_frame_unwind_cache  (struct frame_info *next_frame,
+			 void **this_prologue_cache)
+{
+  //#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\narc_frame_unwind_cache called\n ");
+#endif
+  //#else
+  CORE_ADDR pc;
+  struct arc_unwind_cache *info;
+  int i;
+
+ 
+  if ((*this_prologue_cache))
+    return (*this_prologue_cache);
+  
+  info = FRAME_OBSTACK_ZALLOC (struct arc_unwind_cache);
+  (*this_prologue_cache) = info;
+  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+
+  /* Zero all fields.  */
+  info->blink_offset = 0;
+  info->prev_pc = 0;
+  info->prev_sp = 0;
+  info->frame_base = 0;
+  info->framesize = 0;
+  info->sp_offset = 0;
+  info->fp_offset = 0;
+  info->prev_pc = 0;
+  info->is_leaf = 0;
+  info->uses_fp = 0;
+
+  /* Prologue analysis does the rest...  */
+  /* Currently our scan prologue does not
+   * support getting input for the frame unwinder
+   */ 
+  
+  pc = frame_func_unwind(next_frame);
+#ifdef ARC4_JTAG
+  a4_scan_prologue (pc, next_frame, info);
+#else
+  arc_scan_prologue (pc, next_frame, info);
+#endif
+
+  return info;
+  //#endif
+}
+
+
+
+/*
+ * Construct frame id for the normal frame 
+ */
+
+static void
+arc_frame_this_id (struct frame_info *next_frame,
+		    void **this_prologue_cache,
+		    struct frame_id *this_id)
+{
+  // FIXMEA: cleanup #ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\n arc_frame_this_id called()\n  ");
+#endif
+  //#else
+
+  struct arc_unwind_cache *info
+    = arc_frame_unwind_cache (next_frame, this_prologue_cache);
+  CORE_ADDR base;
+  CORE_ADDR func;
+  struct frame_id id;
+
+  /* The FUNC is easy.  */
+  func = frame_func_unwind (next_frame);
+
+ /* This is meant to halt the backtrace at the entry point (_start).  */
+  if (func <= gdbarch_tdep (current_gdbarch)->lowest_pc)
+    return;
+  
+  /* Hopefully the prologue analysis either correctly determined the
+     frame's base (which is the SP from the previous frame), or set
+     that base to "NULL".  */
+  base = info->prev_sp;
+  if (base == 0)
+    return;
+
+  id = frame_id_build (base, func);
+
+  (*this_id) = id;
+  //#endif
+
+}
+
+
+/* 
+ * Unwind and obtain the register information 
+ */
+static void
+arc_frame_prev_register (struct frame_info *next_frame,
+			  void **this_prologue_cache,
+			  int regnum, int *optimizedp,
+			  enum lval_type *lvalp, CORE_ADDR *addrp,
+			  int *realnump, void *bufferp)
+{
+  // FIXMEA:
+  //#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\n arc_frame_prev_register() called for regnum %d\n ",regnum );
+#endif
+  //#else
+  struct arc_unwind_cache *info
+    = arc_frame_unwind_cache (next_frame, this_prologue_cache);
+
+
+  /* If we are asked to unwind the PC, then we need to return blink
+     instead.  The saved value of PC points into this frame's
+     prologue, not the next frame's resume location.  */
+#ifdef ARC4_JTAG
+  if (regnum == ARC_STATUS_REGNUM)
+#else
+  if (regnum == PC_REGNUM)
+#endif
+    regnum = ARC_BLINK_REGNUM;
+
+  /* SP is generally not saved to the stack, but this frame is
+     identified by NEXT_FRAME's stack pointer at the time of the call.
+     The value was already reconstructed into PREV_SP.  */
+  if (regnum == ARC_SP_REGNUM)
+    {
+      *lvalp = not_lval;
+      if (bufferp)
+	store_unsigned_integer (bufferp, 4, info->prev_sp);
+      return;
+    }
+
+
+  trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
+				optimizedp, lvalp, addrp, realnump, bufferp);
+
+
+#ifdef ARC_DEBUG
+  printf("-*-*-*\n Regnum =%d, realnump=%d,%d \n",regnum, (char *)(bufferp), *((char*)bufferp));
+#endif
+  //#endif
+}
+
+
+
+
+static const struct frame_unwind arc_frame_unwind = {
+  NORMAL_FRAME,
+  arc_frame_this_id,
+  arc_frame_prev_register
+};
+
+const struct frame_unwind *
+arc_frame_sniffer (struct frame_info *next_frame)
+{
+  return &arc_frame_unwind;
+}
+
+
+/* read-only registers */
+static int
+arc_cannot_store_register (int regno)
+{
+  if(
+#ifndef ARC4_JTAG
+     regno == ARC_EFA_REGNUM ||
+     regno == ARC_ERET_REGNUM ||
+     regno == ARC_STATUS32_L1_REGNUM ||
+     regno == ARC_STATUS32_L2_REGNUM ||
+     regno == ARC_ERSTATUS_REGNUM ||
+#endif
+     regno == ARC_ILINK1_REGNUM ||
+     regno == ARC_ILINK2_REGNUM 
+     )
+    {
+      /* No warning should be printed.  arc_cannot_store_register being
+	 called does not imply that someone is actually writing to regnum.  */
+
+      /*warning("writing to read-only register: %s\n", arc_register_name(regno));*/
+      return 1;
+    }
+  return 0;
+}
+
+/* Returns true if the insn at PC is a branch. *fall_thru is the address of
+   the next insn.  *target is the branch target. */
+static int
+arc_next_pc(CORE_ADDR pc, CORE_ADDR *fall_thru, CORE_ADDR *target)
+{
+#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\narc_next_pc called\n");
+#endif
+#else
+  struct arcDisState instr, instr_d;
+  int insn_length;
+  struct disassemble_info di;
+  int two_targets = 0;
+  
+  init_disassemble_info(&di, NULL, NULL);
+  di.arch = gdbarch_bfd_arch_info(current_gdbarch)->arch;
+  di.mach = gdbarch_bfd_arch_info(current_gdbarch)->mach;
+  di.endian = gdbarch_byte_order(current_gdbarch);
+  di.read_memory_func = target_read_memory;
+  
+  instr = arcAnalyzeInstr(pc, &di);
+
+  *fall_thru = pc + instr.instructionLen;
+
+#ifdef ARC_DEBUG
+  printf("--- arc_next_pc(%x) = %x, isBranch = %d, tcnt = %d [%x], flow = %s (%d), "
+	 "reg for indirect jump = %d, nullifyMode = %s\n",
+	 pc, *fall_thru, instr.isBranch, instr.tcnt, instr.targets[0],
+	 (instr.flow == direct_jump || instr.flow == direct_call) ? "direct" : "indirect",
+	 instr.flow,
+	 instr.register_for_indirect_jump,
+	 (instr.nullifyMode == BR_exec_always ? "delay slot" : "no delay"));
+#endif
+
+  if(instr.isBranch)
+    {
+      two_targets = 1;
+      
+      if(instr.flow == direct_jump || instr.flow == direct_call)
+	*target = instr.targets[0];
+      else
+	regcache_cooked_read(current_regcache,
+			     arc_binutils_reg_to_regnum(instr.register_for_indirect_jump),
+			     target);
+    }
+
+  /* for instructions with delay slots, the fall thru is not the instruction
+     immediately after the branch instruction, but the one after that */
+  if(instr.isBranch && instr.nullifyMode == BR_exec_always)
+    {
+      instr_d = arcAnalyzeInstr(*fall_thru, &di);
+      *fall_thru += instr_d.instructionLen;
+    }
+
+  /* zero-overhead loops:
+        if(status32[L] == 0 && next_pc == lp_end && lp_count > 1)
+          next_pc = lp_start;
+  */
+  {
+    unsigned int lp_end, lp_start, lp_count, status32;
+
+    regcache_cooked_read(current_regcache, ARC_LP_START_REGNUM, &lp_start);
+    regcache_cooked_read(current_regcache, ARC_LP_END_REGNUM, &lp_end);
+    regcache_cooked_read(current_regcache, ARC_LP_COUNT_REGNUM, &lp_count);
+#ifndef ARC4_JTAG    
+    regcache_cooked_read(current_regcache, ARC_STATUS32_REGNUM, &status32);
+#endif
+
+    if( !(status32 & ARC_STATUS32_L) && *fall_thru == lp_end && lp_count > 1)
+      {
+	two_targets = 1;
+	*target = lp_start;
+      }
+  }
+  
+  return two_targets;
+#endif //
+}
+
+/* this is called with insert_breakpoints_p = 1 before single-stepping and
+   with insert_breakpoints_p = 0 after the step */
+void
+arc_software_single_step(enum target_signal ignore, int insert_breakpoints_p)
+{
+#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\narc_software_single_step called\n" );
+#endif
+#else
+  typedef char binsn_quantum[BREAKPOINT_MAX];
+
+  static CORE_ADDR fall_thru, branch_target;
+  static binsn_quantum break_mem[2];
+  static char two_breakpoints;
+  CORE_ADDR pc;
+
+  {
+#ifdef ARC_DEBUG
+    unsigned int efa, ret;
+    regcache_cooked_read(current_regcache, ARC_EFA_REGNUM, &efa);
+    //    regcache_cooked_read(current_regcache, ARC_RET_REGNUM, &ret);
+    
+    printf("--- arc_software_single_step, efa = %x, ret = %x, (%s)\n", efa, ret,
+	   (insert_breakpoints_p ? "add" : "remove"));
+#endif
+  }
+  
+  if (insert_breakpoints_p)
+    {
+      pc = read_pc ();
+      two_breakpoints = arc_next_pc (pc, &fall_thru, &branch_target);
+
+      if (two_breakpoints && branch_target == pc) 
+	{
+	  warning ("Cannot single-step branch-to-self or single instruction zero overhead loop,\n"
+		   "    Stepping across it.");
+	  /* Don't insert/remove the branch-target breakpoint.  */
+	  two_breakpoints = 0;
+	}
+      
+      target_insert_breakpoint (fall_thru, break_mem[0]);
+      if(two_breakpoints)
+	target_insert_breakpoint (branch_target, break_mem[1]);
+    }
+  else
+    {
+      target_remove_breakpoint (fall_thru, break_mem[0]);
+      if(two_breakpoints)
+	target_remove_breakpoint (branch_target, break_mem[1]);
+    }
+#endif
+}
+
+/*
+ * mapping from binutils/gcc register number to
+ * GDB register number ("regnum")
+ */
+static int
+arc_binutils_reg_to_regnum (int reg)
+{
+#ifdef ARC4_JTAG
+    if (reg >= 0 && reg <= 26)
+    return reg;
+  else if (reg == 27)			     /* fp */
+    return ARC_FP_REGNUM;
+  else if (reg == 28)			     /* sp */
+    return ARC_SP_REGNUM;
+  else if (reg == 29)			     /* ilink1 */
+    return ARC_ILINK1_REGNUM;
+  else if (reg == 30)			     /* ilink2 */
+    return ARC_ILINK2_REGNUM;
+  else if (reg == 31)			     /* blink */
+    return ARC_BLINK_REGNUM;
+
+#else
+  /* from gcc/config/arc/arc.h */
+
+  if (reg >= 0 && reg <= 26)
+    return reg;
+  else if (reg == 27)			     /* fp */
+    return ARC_FP_REGNUM;
+  else if (reg == 28)			     /* sp */
+    return ARC_SP_REGNUM;
+  else if (reg == 29)			     /* ilink1 */
+    return ARC_ILINK1_REGNUM;
+  else if (reg == 30)			     /* ilink2 */
+    return ARC_ILINK2_REGNUM;
+  else if (reg == 31)			     /* blink */
+    return ARC_BLINK_REGNUM;
+  else if (reg >= 32 && reg <= 59)	     /* reserved */
+    ;
+  else if (reg == 60)			     /* lp_count */
+    return ARC_LP_COUNT_REGNUM;
+  else if (reg == 61)			     /* reserved */
+    ;
+  else if (reg == 62)			     /* no such register */
+    ;
+/*   else if (reg == 63)			     /\* PCL *\/ */
+/*     return ARC_RET_REGNUM; */
+
+#endif
+  warning ("Unmapped register #%d encountered\n", reg);
+  return -1; 
+}
+
+
+static void
+arc_add_reggroups (struct gdbarch *gdbarch)
+{
+  reggroup_add (gdbarch, general_reggroup);
+  reggroup_add (gdbarch, all_reggroup);
+  reggroup_add (gdbarch, system_reggroup);
+}
+
+int
+arc_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
+			  struct reggroup *group)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  int tdep_answer;
+  
+  tdep_answer = tdep->register_reggroup_p (regnum, group);
+  if(tdep_answer != -1)
+    return tdep_answer;
+  
+  if (group == all_reggroup)
+    return 1;
+  else if (group == save_reggroup || group == restore_reggroup)
+    {
+      /* don't save/restore read-only registers. */
+      return (!arc_cannot_store_register(regnum)); 
+    }
+  else if (group == general_reggroup)
+    {
+#ifndef ARC4_JTAG
+      if (regnum == ARC_STATUS32_REGNUM)
+	return 0;
+#endif
+      return 1;
+    }
+  else
+    {
+      internal_error(__FILE__, __LINE__, "bad register group");
+    }
+}
+
+
+
+static void
+arc_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
+                            struct dwarf2_frame_state_reg *reg)
+{
+#ifdef ARC4_JTAG
+  // FIXMEA: Clean up.  if ( debug_arc_jtag_target_message)
+#ifdef ARC_DEBUG  
+  printf ("\n arc_dwarf2_frame_init_reg called.\n Regno no:%d,0x%x\n",regnum,regnum);
+#endif
+    /* The return address column.  */
+  if (regnum == ARC_STATUS_REGNUM)
+    reg->how = DWARF2_FRAME_REG_RA;
+  
+  /* The call frame address.  */
+  if (regnum == ARC_SP_REGNUM)
+    reg->how = DWARF2_FRAME_REG_CFA;
+
+#else
+  /* The return address column.  */
+  if (regnum == PC_REGNUM)
+    reg->how = DWARF2_FRAME_REG_RA;
+  
+  /* The call frame address.  */
+  if (regnum == ARC_SP_REGNUM)
+    reg->how = DWARF2_FRAME_REG_CFA;
+#endif
+}
+
+static CORE_ADDR
+arc_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+  ULONGEST pc;
+#ifdef ARC4_JTAG
+  frame_unwind_unsigned_register (next_frame, ARC_STATUS_REGNUM, &pc);
+  pc = pc & 0x00ffffff;
+  pc = pc << 2;
+#else
+  frame_unwind_unsigned_register (next_frame, PC_REGNUM, &pc);
+#endif
+  return pc;
+}
+
+static CORE_ADDR
+arc_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+  ULONGEST sp;
+  frame_unwind_unsigned_register (next_frame, SP_REGNUM, &sp);
+  return sp;
+}
+
+
+
+static void
+arc_extract_return_value (struct type *type, struct regcache *regcache,
+			  void *valbuf)
+{
+  //#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\narc_extract_return_value called\n");
+#endif
+  //#else
+  ULONGEST val;
+  int len = TYPE_LENGTH (type);
+  
+  if (len <= 4)
+    {
+      /* Get the return value from R0.  */
+      regcache_cooked_read_unsigned (regcache, ARC_RETURN1_REGNUM, &val);
+      store_unsigned_integer (valbuf, len, val);
+    }
+  else if (len <= 8)
+    {
+      /* Get the return value from R0 and R1.  */
+      /* R0 holds the lower-order bytes */
+      regcache_cooked_read_unsigned (regcache, ARC_RETURN1_REGNUM, &val);
+      store_unsigned_integer (valbuf, 4, val);
+      regcache_cooked_read_unsigned (regcache, ARC_RETURN2_REGNUM, &val);
+      store_unsigned_integer ((char *)valbuf + 4, len - 4, val);
+    }
+  else
+    error ("arc_extract_return_value: type length too large");
+  //#endif
+}
+
+static void
+arc_store_return_value (struct type *type, struct regcache *regcache,
+			const void *valbuf)
+{
+  //#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\narc_store_return_value called\n ");
+#endif
+  //#else
+  ULONGEST val;
+  int len = TYPE_LENGTH (type);
+  
+  if (len <= 4)
+    {
+      /* Put the return value in R0.  */
+      val = extract_unsigned_integer (valbuf, len);
+      regcache_cooked_write_unsigned (regcache, ARC_RETURN1_REGNUM, val);
+    }
+  else if (len <= 8)
+    {
+      /* Put the return value in R10 and R11.  */
+      val = extract_unsigned_integer (valbuf, 4);
+      regcache_cooked_write_unsigned (regcache, ARC_RETURN1_REGNUM, val);
+      val = extract_unsigned_integer ((char *)valbuf + 4, len - 4);
+      regcache_cooked_write_unsigned (regcache, ARC_RETURN2_REGNUM, val);
+    }
+  else
+    error ("arc_store_return_value: type length too large.");
+  //#endif
+}
+
+
+static enum return_value_convention
+arc_return_value (struct gdbarch *gdbarch, struct type *valtype,
+		  struct regcache *regcache, void *readbuf,
+		  const void *writebuf)
+{
+  //#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\narc_return_value called");
+#endif
+  //#else
+  /* This will change with the ABI */
+  int struct_return = (TYPE_CODE (valtype) == TYPE_CODE_STRUCT ||
+		       TYPE_CODE (valtype) == TYPE_CODE_UNION ||
+		       TYPE_LENGTH (valtype) > 8);
+  
+
+  if (writebuf != NULL)
+    {
+      gdb_assert (!struct_return);
+      arc_store_return_value (valtype, regcache, writebuf);
+    }
+
+  if (readbuf != NULL)
+    {
+      gdb_assert (!struct_return);
+      arc_extract_return_value (valtype, regcache, readbuf);
+    }
+
+  if (struct_return)
+    return RETURN_VALUE_STRUCT_CONVENTION;
+  else
+    return RETURN_VALUE_REGISTER_CONVENTION;
+  //#endif
+}
+
+/* Signal Trampoline Frame Unwinder. These 
+ * unwinders allow frame unwinding to happen 
+ * from within signal handlers. 
+ */
+
+static struct arc_unwind_cache *
+arc_sigtramp_frame_cache (struct frame_info *next_frame,
+			  void **this_cache)
+{
+  // FIXMEA: cleanup#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\narc_sigtramp_frame_cache called");
+#endif
+  //#else
+  struct arc_unwind_cache *cache;
+  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  CORE_ADDR addr;
+  char buf[4];
+
+  if (*this_cache)
+    return *this_cache;
+
+  cache = FRAME_OBSTACK_ZALLOC (struct arc_unwind_cache);
+  (*this_cache) = cache;
+  cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+
+  /* Zero all fields.  */
+  cache->blink_offset = 0;
+  cache->prev_pc = 0;
+  cache->prev_sp = 0;
+  cache->frame_base = 0;
+  cache->framesize = 0;
+  cache->sp_offset = 0;
+  cache->fp_offset = 0;
+  cache->prev_pc = 0;
+  cache->is_leaf = 0;
+  cache->uses_fp = 0;
+
+  
+  frame_unwind_register (next_frame, SP_REGNUM, buf);
+  cache->frame_base = extract_unsigned_integer (buf, 4);
+
+  addr = tdep->sigcontext_addr (next_frame);
+  if (tdep->sc_reg_offset)
+    {
+      int i;
+      
+      for (i = 0; i < tdep->sc_num_regs; i++)
+	if (tdep->sc_reg_offset[i] != -1)
+	  cache->saved_regs[i].addr = addr + tdep->sc_reg_offset[i];
+    }
+
+  return cache;
+  //#endif
+}
+
+static void
+arc_sigtramp_frame_this_id (struct frame_info *next_frame, void **this_cache,
+			    struct frame_id *this_id)
+{
+  //FIXMEA: cleanup #ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\narc_sigtramp_frame_this_id called");
+#endif
+  //#else
+  struct arc_unwind_cache *cache = 
+    arc_sigtramp_frame_cache (next_frame, this_cache);
+  
+  (*this_id) = frame_id_build (cache->frame_base, frame_pc_unwind (next_frame));
+  //#endif
+}
+
+static void
+arc_sigtramp_frame_prev_register (struct frame_info *next_frame,
+				  void **this_cache,
+				  int regnum, int *optimizedp,
+				  enum lval_type *lvalp, CORE_ADDR *addrp,
+				  int *realnump, void *valuep)
+{
+  // FIXMEA: cleanup#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\narc_sigtramp_frame_prev_register called");
+#endif
+  //#else
+  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+
+  /* Make sure we've initialized the cache.  */ 
+  struct arc_unwind_cache *cache = 
+    arc_sigtramp_frame_cache (next_frame, this_cache);
+
+  /* on a signal, the PC is in ret */
+#ifdef ARC4_JTAG
+  if (regnum == ARC_STATUS_REGNUM)
+#else
+  if(regnum == PC_REGNUM)
+#endif
+    regnum = tdep->pc_regnum_in_sigcontext;
+  
+  trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
+				optimizedp, lvalp, addrp, realnump, valuep);
+  //#endif
+}
+
+
+static const struct frame_unwind arc_sigtramp_frame_unwind =
+{
+  SIGTRAMP_FRAME,
+  arc_sigtramp_frame_this_id,
+  arc_sigtramp_frame_prev_register
+};
+
+const struct frame_unwind *
+arc_sigtramp_frame_sniffer (struct frame_info *next_frame)
+{
+  //FIXMEA: cleanup#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG  
+  printf ("\narc_sigtramp_frame_sniffer called() ");
+#endif
+  //#else
+  CORE_ADDR pc = frame_pc_unwind (next_frame);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (next_frame));
+
+  /* We shouldn't even bother if we don't have a sigcontext_addr
+     handler.  */
+  if (tdep->sigcontext_addr == NULL)
+    return NULL;
+
+  if (tdep->sigtramp_p != NULL)
+    {
+      if (tdep->sigtramp_p (next_frame))
+	{
+	  return &arc_sigtramp_frame_unwind;
+	}
+    }
+
+  return NULL;
+  //#endif
+}
+
+
+
+/* Allow calls to be made to functions defined in the debuggee. 
+   a.k.a dummy calls 
+*/
+/* When arguments must be pushed onto the stack, they go on in reverse
+   order.  The below implements a FILO (stack) to do this.  
+   Copied from d10v-tdep.c.  */
+
+struct stack_item
+{
+  int len;
+  struct stack_item *prev;
+  void *data;
+};
+
+static struct stack_item *
+push_stack_item (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 (struct stack_item *si)
+{
+  struct stack_item *dead = si;
+  si = si->prev;
+  xfree (dead->data);
+  xfree (dead);
+  return si;
+}
+
+
+
+
+/* arc_push_dummy_call :
+ *  gdbarch  : gdbarch structure for the backend to use if needed.
+ *  function : 
+ *  regcache : 
+ *  bp_addr  : Return address for the breakpoint.
+ *  sp       : Current value of sp.
+ *  struct_return: struct_return is 1 if structures are returned by 
+ *                 the function.
+ *  struct_addr: Hidden address for returning a struct.
+ */
+
+
+static CORE_ADDR
+arc_push_dummy_call(struct gdbarch *gdbarch, struct value *function,
+		     struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
+		     struct value **args, CORE_ADDR sp, int struct_return,
+		     CORE_ADDR struct_addr)
+
+{
+  //#ifdef ARC4_JTAG
+#ifdef ARC_DEBUG
+  printf ("\narc_push_dummy_call called");
+#endif
+  // #else
+  int stack_alloc;
+  int stack_offset;
+  int argreg;
+  int argnum;
+
+  CORE_ADDR regval;
+  struct stack_item *si = NULL;
+
+
+  /* Push the return address.  */
+#ifdef ARC4_JTAG
+  CORE_ADDR modified_bp_addr;
+  modified_bp_addr = arc_debug_fetch_regs(ARC_STATUS_REGNUM);
+  regcache_raw_collect(regcache, ARC_STATUS_REGNUM, &modified_bp_addr);
+  modified_bp_addr = modified_bp_addr & 0xff000000;
+  bp_addr = bp_addr >>2;
+  modified_bp_addr |= bp_addr;
+  regcache_cooked_write_unsigned (regcache, ARC_BLINK_REGNUM, modified_bp_addr);
+#else
+  regcache_cooked_write_unsigned (regcache, ARC_BLINK_REGNUM, bp_addr);
+#endif
+
+  /* Are we returning a value using a structure return or a normal value
+     return?  struct_addr is the address of the reserved space for the return
+     structure to be written on the stack.
+  */
+  /* FIXME:: Ramana :: What about 4 byte structures returned in r0 as
+     claimed by Metaware. 
+  */
+  
+  /* Now load as many as possible of the first arguments into registers,
+     and push the rest onto the stack.  */
+  argreg = ARC_ARG0_REGNUM;
+ 
+  if (struct_return)
+    {
+      regcache_cooked_write_unsigned (regcache, ARC_ARG0_REGNUM, struct_addr);
+      argreg++;
+#ifdef ARC4_JTAG
+      sp = sp - 16;
+#endif
+    }
+
+  stack_offset = 0;
+
+  for (argnum = 0; argnum < nargs; argnum++)
+    {
+      int len;
+      char *val;
+      int reg_demand;
+      int i;
+      
+      len = TYPE_LENGTH (VALUE_TYPE (args[argnum]));
+      val = (char *) VALUE_CONTENTS (args[argnum]);
+      
+      /* How may registers worth of storage do we need for this argument?  */
+      reg_demand = (len / 4) + (len % 4 != 0 ? 1 : 0);
+        
+      if (argreg + reg_demand - 1 <= ARC_ARG7_REGNUM)
+        {
+          /* Data passed by value.  Fits in available register(s).  */
+          for (i = 0; i < reg_demand; i++)
+            {
+              regcache_cooked_write_unsigned (regcache, argreg, 
+					      *(unsigned long *) val);
+              argreg++;
+              val += 4;
+            }
+        }
+      else if (argreg <= ARC_ARG7_REGNUM)
+        {
+          /* Data passed by value. Does not fit in available register(s).
+             Use the register(s) first, then the stack.  */
+          for (i = 0; i < reg_demand; i++)
+            {
+              if (argreg <= ARC_ARG7_REGNUM)
+                {
+		  regcache_cooked_write_unsigned (regcache, argreg, 
+						  *(unsigned long *) val);
+                  argreg++;
+                  val += 4;
+                }
+              else
+                {
+		  /* Push item for later so that pushed arguments
+		     come in the right order.  */
+		  si = push_stack_item (si, val, 4);
+                  val += 4;
+                }
+            }
+        }
+      else if (len > (2 * 4))
+        {
+	  /* FIXME */
+	  internal_error (__FILE__, __LINE__, "We don't do this");
+        }
+      else
+        {
+          /* Data passed by value.  No available registers.  Put it on
+             the stack.  */
+	   si = push_stack_item (si, val, len);
+        }
+    }
+
+  while (si)
+    {
+      /* fp_arg must be word-aligned (i.e., don't += len) to match
+	 the function prologue.  */
+      sp = (sp - si->len) & ~3;
+#ifdef ARC4_JTAG
+      write_memory (sp + 16, si->data, si->len);
+#else
+      write_memory (sp, si->data, si->len);
+#endif
+      si = pop_stack_item (si);
+    }
+
+  /* Finally, update the SP register.  */
+  regcache_cooked_write_unsigned (regcache, ARC_SP_REGNUM, sp);
+
+  return sp;
+  //#endif
+}
+
+/* Align Frame */
+static CORE_ADDR
+arc_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
+{
+  /* Align to the normal alignment on the stack).  */
+  return sp & ~3;
+}
+
+
+/* Print interesting information about the floating point processor
+   (if present) or emulator.  */
+static void
+arc_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
+		      struct frame_info *frame, const char *args)
+{
+  printf("Software FPU \n");
+}
+
+
+/* Set the main_name to "_main" if required.
+   This is set as an observer of inferior_created.  */
+static void
+arc_set_main_name (struct target_ops *objfile, int from_tty)
+{
+  struct minimal_symbol *umainsym, *mainsym;
+
+  /* Old ARC toolchains prepend an underscore to symbol names.  If there is
+     an _main but no main, then we're probably debugging a binary that was
+     made with the old toolchain.  */
+  umainsym = lookup_minimal_symbol ("_main", NULL, NULL);
+  mainsym = lookup_minimal_symbol ("main", NULL, NULL);
+  if(umainsym && !mainsym)
+    {
+      set_main_name ("_main");
+    }
+
+  /* If we don't have any symbols, the default, i.e. "main", will get used.  */
+}
+
+
+/* The following piece of code is borrowed from d10v */
+static void
+a4_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
+{
+#ifdef ARC4_JTAG
+  if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
+      || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
+    store_unsigned_integer (buf, TYPE_LENGTH (type), (addr>>2) & 0xffffff);
+  else
+    store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
+#endif
+}
+
+static CORE_ADDR
+a4_pointer_to_address (struct type *type, const void *buf)
+{
+#ifdef ARC4_JTAG  
+  CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH(type));
+  /* Is it a code address?  */
+  if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
+      || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD
+      || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
+    return ((addr<<2) & 0x2ffffff);
+  else
+    return addr;
+#endif
+}
+
+static struct gdbarch *
+arc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
+{
+  struct gdbarch_tdep *tdep;
+  struct gdbarch *gdbarch;
+
+  tdep = xmalloc (sizeof (struct gdbarch_tdep));
+  gdbarch = gdbarch_alloc (&info, tdep);
+  
+  /* Fixme :: Worry about default initialization of breakpoints 
+     for the ARC platform. In our case currently this is handled
+     out of arc-linux-tdep.c for default arc linux breakpoints.
+  */
+
+  info.osabi = CONFIG_OSABI;
+  gdbarch_init_osabi(info, gdbarch);
+  
+  /* Put stuff in gdbarch. */
+
+  /* Characters are unsigned by default */
+  set_gdbarch_char_signed (gdbarch, 0);
+
+  set_gdbarch_print_float_info (gdbarch, arc_print_float_info);
+  set_gdbarch_sp_regnum (gdbarch, ARC_SP_REGNUM);
+  set_gdbarch_register_type (gdbarch, arc_register_type);  
+
+  set_gdbarch_cannot_store_register (gdbarch, arc_cannot_store_register);
+
+
+  /* Advance PC across function entry code.  */
+  set_gdbarch_skip_prologue (gdbarch, arc_skip_prologue);
+
+  
+  /* Hook in the Dwarf-2 frame sniffer.  */
+  set_gdbarch_dwarf2_reg_to_regnum (gdbarch, arc_binutils_reg_to_regnum);
+  dwarf2_frame_set_init_reg (gdbarch, arc_dwarf2_frame_init_reg);
+  frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
+
+  /* signal frames */
+  frame_unwind_append_sniffer (gdbarch, arc_sigtramp_frame_sniffer);
+
+
+
+  /* The stack grows downward.  */
+  set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
+
+  set_gdbarch_unwind_pc (gdbarch, arc_unwind_pc);
+  set_gdbarch_unwind_sp (gdbarch, arc_unwind_sp);
+  set_gdbarch_unwind_dummy_id (gdbarch, arc_unwind_dummy_id);
+  frame_unwind_append_sniffer (gdbarch, arc_frame_sniffer);
+ 
+
+  set_gdbarch_return_value (gdbarch, arc_return_value);
+
+  /* Add the arc register groups.  */
+  arc_add_reggroups (gdbarch);
+  set_gdbarch_register_reggroup_p (gdbarch, arc_register_reggroup_p);
+  
+  /* Breakpoint manipulation.  */
+  set_gdbarch_breakpoint_from_pc (gdbarch, arc_breakpoint_from_pc);
+  set_gdbarch_frame_align(gdbarch,arc_frame_align);
+
+  /* Dummy Frame handling */
+  set_gdbarch_push_dummy_call (gdbarch, arc_push_dummy_call);
+  set_gdbarch_call_dummy_location (gdbarch,AT_ENTRY_POINT);
+  
+  /* Disassembly.  */
+  {
+    /* the arc libopcodes wants abfd so that it can find out what CPU
+       extensions are there */
+    bfd abfd;
+    abfd.sections = NULL;
+
+
+#ifndef ARC4_JTAG
+    set_gdbarch_print_insn(gdbarch, arcompact_get_disassembler(&abfd));
+#else
+    set_gdbarch_print_insn(gdbarch, arc_get_disassembler(&abfd));
+#endif
+  }
+
+#ifdef ARC4_JTAG  
+  set_gdbarch_address_to_pointer (gdbarch, a4_address_to_pointer);
+  set_gdbarch_pointer_to_address (gdbarch, a4_pointer_to_address);
+#endif
+  //#ifndef ARC4_JTAG
+  /* Set main_name to _main if necessary.  Ideally we'd want a hook that
+     gets called when symbols are loaded, but it seems there isn't one; so
+     we'll use this.  This will not work if the user does "target remote
+     ..." and then "add-symbol-file ..."  */
+  observer_attach_inferior_created (arc_set_main_name);
+  //#endif
+
+#ifdef ARC4_JTAG
+  //  set_gdbarch_write_pc (gdbarch, a4_write_pc);
+#endif
+
+  CONFIG_INIT_TDEP (gdbarch);
+  
+  return gdbarch;
+}
+
+static void
+arc_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
+{
+}
+
+void
+_initialize_arc_tdep (void)
+{
+  gdbarch_register (bfd_arch_arc, arc_gdbarch_init, arc_dump_tdep);
+}
+
diff --git a/gdb/arc-tdep.h b/gdb/arc-tdep.h
new file mode 100644
index 0000000..4251eb4
--- /dev/null
+++ b/gdb/arc-tdep.h
@@ -0,0 +1,109 @@
+/* Target dependent code for ARC700, for GDB, the GNU debugger.
+
+   Copyright 2005 Free Software Foundation, Inc.
+
+   Contributed by Codito Technologies Pvt. Ltd. (www.codito.com)
+
+   Authors: 
+      Soam Vasani <soam.vasani@codito.com>
+      Ramana Radhakrishnan <ramana.radhakrishnan@codito.com> 
+
+   This file is part of GDB.
+   
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+*/
+enum arc700_api_regnums
+  {
+    ARC_ARG0_REGNUM     =        0,
+    ARC_ARG1_REGNUM     =        1,
+    ARC_ARG2_REGNUM     =        2,
+    ARC_ARG3_REGNUM     =        3,
+    ARC_ARG4_REGNUM     =        4,
+    ARC_ARG5_REGNUM     =        5,
+    ARC_ARG6_REGNUM     =        6,
+    ARC_ARG7_REGNUM     =        7,
+
+    /* When a return value is stored in registers, is in either r0 or in
+       (r1,r0).  Used in arc_extract_return_value */
+    ARC_RETURN1_REGNUM	=	 0,
+    ARC_RETURN2_REGNUM 	=	 1
+  };
+
+
+
+enum ARCProcessorVersion
+  {
+    UNSUPPORTED,
+    ARCompact,
+    ARC600,
+    ARC700,
+    A5,
+    A4,
+  };
+
+
+enum ARCExtensionsSupportedInformation
+  {
+    ARC700_MMU
+  };
+
+
+
+typedef struct ARCProcessorInformation
+{
+  enum ARCProcessorVersion arcprocessorversion;
+  enum ARCExtensionsSupportedInformation extensionsSupported;
+
+}ARCVariantsInfo;
+
+struct gdbarch_tdep
+{
+  /* Detect sigtramp.  */
+  int (*sigtramp_p) (struct frame_info *);
+  
+  /* Get address of sigcontext for sigtramp.  */
+  CORE_ADDR (*sigcontext_addr) (struct frame_info *);
+
+  /* Offset of registers in `struct sigcontext'.  */
+  int *sc_reg_offset;
+  int sc_num_regs;
+
+  /* In our linux target, gdbarch_pc_regnum points to stop_pc, which is a
+     register that's made-up by the kernel and does not actually exist.
+     stop_pc is NOT saved in the sigcontext; what is saved is the ret
+     "register".  Since ret is a linux-only register, it's regnum is visible
+     only in arc-linux-tdep.c; hence initialize pc_regnum_in_sigcontext in
+     arc-linux-tdep.c.  */
+  int pc_regnum_in_sigcontext;
+
+  /* Returns false, true, or -1; -1 means the tdep has nothing to say about this
+     register and group.  */
+  int (*register_reggroup_p) (int, struct reggroup *);
+  
+  /* Breakpoint instruction to be used */
+  unsigned char * arc_breakpoint_insn;
+  int arc_breakpoint_size;
+
+  /* For stopping backtraces.  */
+  CORE_ADDR lowest_pc;
+  
+  /* ARC Processor variant information.  */
+  ARCVariantsInfo * arc_processor_variant_info ;
+
+};
+
+
+void arc_software_single_step(enum target_signal ignore, int insert_breakpoints_p);
+
diff --git a/gdb/doc/ChangeLog.codito b/gdb/doc/ChangeLog.codito
new file mode 100644
index 0000000..0a335d9
--- /dev/null
+++ b/gdb/doc/ChangeLog.codito
@@ -0,0 +1,7 @@
+2005-05-16  Soam Vasani  <soam.vasani@codito.com>
+
+	* gdb.texinfo (Embedded Processors): Add a menu item for ARC and
+	include arc.texi.
+	* arc.texi: New file.  ARC specific commands etc.
+	* Makefile.in (GDB_DOC_SOURCE_INCLUDES): Add arc.texi to the list.
+
diff --git a/gdb/doc/arc.texi b/gdb/doc/arc.texi
new file mode 100644
index 0000000..9a00571
--- /dev/null
+++ b/gdb/doc/arc.texi
@@ -0,0 +1,155 @@
+@c \input texinfo
+@c %**start of header
+@c @setfilename arc-cmds.info
+@c @settitle ARC specific commands
+@c @setchapternewpage off
+@c %**end of header
+
+@node ARC
+@subsection ARC
+
+GDB for ARC supports the ARC600 and ARC700 cores.
+
+On ARC700, you can debug linux applications using gdbserver.  On
+ARC700 and ARC600, you can debug any program using the arcjtag target.
+
+
+@menu
+* ARC specific commands::        ARC specific commands
+@end menu
+
+@node ARC specific commands, , , ARC
+@subsection ARC specific commands
+
+These commands can only be used when GDB has been build for ARC.
+
+
+@menu
+* target arcjtag::                  Use the JTAG target
+* arc-reset-board::                 Reset the ARC board
+* arc-aux-read::                    Read a range of auxillary registers
+* arc-aux-write::                   Write an auxillary register
+* info arc-bcr-registers::          Show build configuration registers
+
+Debugging:
+* set arcjtag-debug-statemachine::  JTAG state machine debugging messages
+* set arcjtag-debug-target::        arcjtag target debugging messages
+@end menu
+
+@node target arcjtag
+@subsubsection target arcjtag
+
+Usage: @code{target arcjtag}
+
+Connect to the arcjtag target.
+
+This target expects the ARC board to be connected to the parallel port
+on the host.  Currently we support debugging only on GNU/Linux hosts.
+
+This target uses the gpio device to access the parallel.  You must
+have the gpio driver installed and you must have read/write privileges
+to /dev/gpio.
+
+
+@node arc-reset-board
+@subsubsection arc-reset-board
+
+Usage: @code{arc-reset-board}
+
+Reset the board.
+
+For this command to work, you must be connected to the arcjtag target,
+by using the command @code{target arcjtag}.
+
+
+@node arc-aux-read
+@subsubsection arc-aux-read
+
+Usage: @code{arc-aux-read <REG-FROM> [<REG-TO>]}
+
+Read and show a range of auxillary registers.
+REG-FROM and REG-TO can be any expressions that evaluate to integers.
+REG-TO is optional; if it is not specified, only one register is displayed.
+
+For example:
+@example
+(gdb) arc-aux-read 0x400 0x406
+00000400: 00000100 80001abc 00001620 00200000
+00000404: 00000100 00000000 00000000
+@end example
+
+For this command to work, you must be connected to the arcjtag target,
+by using the command @code{target arcjtag}.
+
+
+
+@node arc-aux-write
+@subsubsection arc-aux-write
+
+Usage: @code{arc-aux-write <REG> = <VALUE>}
+
+Write to an auxillary register.
+REG and VALUE can be any expressions that evaluate to integers.
+
+For example:
+@example
+(gdb) arc-aux-write 6 = 0x123
+@end example
+
+For this command to work, you must be connected to the arcjtag target,
+by using the command @code{target arcjtag}.
+
+@node info arc-bcr-registers
+@subsubsection info arc-bcr-registers
+
+Usage: @code{info arc-bcr-registers}
+
+Show all the build configuration registers.
+
+For example:
+@example
+(gdb) info arc-bcr-registers
+[61] DCCM_BASE_BUILD : 0x1010121
+[62] CRC_BASE_BUILD  : 0x00
+[63] BTA_LINK_BUILD  : 0x1010121
+[64] DVBF_BUILD      : 0x00
+[65] TEL_INSTR_BUILD : 0x00
+[67] MEMSUBSYS       : 0x01
+[68] VECBASE_AC_BUILD : 0x01
+[69] P_BASE_ADDRESS  : 0xfc0001
+[6f] MMU_BUILD       : 0x1010121
+[70] ARCANGEL_BUILD  : 0x1010121
+[72] D_CACHE_BUILD   : 0x12001
+[73] MADI_BUILD      : 0x00
+[74] DCCM_BUILD      : 0x00
+[75] TIMER_BUILD     : 0x303
+[76] AP_BUILD        : 0x00
+[77] ICACHE_BUILD    : 0x22001
+[78] ICCM_BUILD      : 0x1010121
+[79] DSPRAM_BUILD    : 0x1203
+[7a] MAC_BUILD       : 0x00
+[7b] MULTIPLY_BUILD  : 0x01
+[7c] SWAP_BUILD      : 0x01
+[7d] NORM_BUILD      : 0x02
+[7e] MINMAX_BUILD    : 0x00
+[7f] BARREL_BUILD    : 0x02
+@end example
+
+For this command to work, you must be connected to the arcjtag target,
+by using the command @code{target arcjtag}.
+
+@node set arcjtag-debug-statemachine
+@subsubsection set arcjtag-debug-statemachine
+
+Usage: @code{set arcjtag-debug-statemachine ARG}
+
+Switch on JTAG state machine debugging messages if ARG is non-zero.
+Switch them off if it is zero.
+
+@node set arcjtag-debug-target
+@subsubsection set arcjtag-debug-target
+
+Usage: @code{set arcjtag-debug-target ARG}
+
+Switch on JTAG target debugging messages if ARG is non-zero.
+Switch them off if it is zero.
diff --git a/gdb/gdbserver/ChangeLog.codito b/gdb/gdbserver/ChangeLog.codito
new file mode 100644
index 0000000..e36df7c
--- /dev/null
+++ b/gdb/gdbserver/ChangeLog.codito
@@ -0,0 +1,34 @@
+2005-05-14  Soam Vasani  <soam.vasani@codito.com>
+
+	* proc-service.c (ps_pglobal_lookup): First look for NAME, then
+	for NAME with an underscore prepended.  The toolchain no longer
+	prepends underscores, but we should still work with older
+	toolchains.
+
+2005-05-14  Soam Vasani  <soam.vasani@codito.com>
+
+	* linux-arc-low.c (arg_regmap): Offsets were wrong, correct them.
+
+2005-05-14  Soam Vasani  <soam.vasani@codito.com>
+
+	* linux-arc-low.c: Remove #include reg.h.  Include linux/user.h to
+	get offsets of registers in the struct ptrace.
+
+2005-04-11  Soam Vasani  <soam.vasani@codito.com>
+
+	* linux-arc-low.c (arc_get_pc): Return stop_pc, not EFA.
+
+2005-04-09  Soam Vasani  <soam.vasani@codito.com>
+
+	* proc-service.c (ps_pglobal_lookup): Prepend underscore to symbol
+	names, because the toolchain does that.  Remove this hack when we
+	change the toolchain.
+	* linux-arc-low.c (arc_get_pc): Return EFA's value instead of RET,
+	so that gdbserver can do it's own breakpoints correctly.
+	(arc_reinsert_addr): Return blink's value.
+
+2005-04-07  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* configure.srv: Change arc-*-elf* to arc-linux .Include 
+	thread debugging for the ARC platform. 
+
diff --git a/gdb/gdbserver/linux-arc-low.c b/gdb/gdbserver/linux-arc-low.c
new file mode 100644
index 0000000..28c7ead
--- /dev/null
+++ b/gdb/gdbserver/linux-arc-low.c
@@ -0,0 +1,149 @@
+/* GNU/Linux/ARC specific low level interface, for the remote server for GDB.
+   Copyright 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004
+   Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "server.h"
+#include "linux-low.h"
+
+#include <linux/user.h>
+
+#define OFFSET(member,structure) (int)(&( ((struct structure *)0)->member ))
+
+#define arc_num_regs 39
+
+/* arc_regmap[i] is the offset of Ri in Linux's user struct */
+static int arc_regmap[] = {
+    OFFSET(r0, user_regs_struct),
+    OFFSET(r1, user_regs_struct),
+    OFFSET(r2, user_regs_struct),
+    OFFSET(r3, user_regs_struct),
+    OFFSET(r4, user_regs_struct),
+    OFFSET(r5, user_regs_struct),
+    OFFSET(r6, user_regs_struct),
+    OFFSET(r7, user_regs_struct),
+    OFFSET(r8, user_regs_struct),
+    OFFSET(r9, user_regs_struct),
+    OFFSET(r10, user_regs_struct),
+    OFFSET(r11, user_regs_struct),
+    OFFSET(r12, user_regs_struct),
+    OFFSET(r13, user_regs_struct),
+    OFFSET(r14, user_regs_struct),
+    OFFSET(r15, user_regs_struct),
+    OFFSET(r16, user_regs_struct),
+    OFFSET(r17, user_regs_struct),
+    OFFSET(r18, user_regs_struct),
+    OFFSET(r19, user_regs_struct),
+    OFFSET(r20, user_regs_struct),
+    OFFSET(r21, user_regs_struct),
+    OFFSET(r22, user_regs_struct),
+    OFFSET(r23, user_regs_struct),
+    OFFSET(r24, user_regs_struct),
+    OFFSET(r25, user_regs_struct),
+    OFFSET(r26, user_regs_struct),
+    OFFSET(bta, user_regs_struct),
+    OFFSET(lp_start, user_regs_struct),
+    OFFSET(lp_end, user_regs_struct),
+    OFFSET(lp_count, user_regs_struct),
+    OFFSET(status32, user_regs_struct),
+    OFFSET(blink, user_regs_struct),
+    OFFSET(fp, user_regs_struct),
+    OFFSET(sp, user_regs_struct),
+    OFFSET(efa, user_regs_struct),
+    OFFSET(ret, user_regs_struct),
+    OFFSET(orig_r8, user_regs_struct),
+    OFFSET(stop_pc, user_regs_struct)
+};
+
+static int
+arc_cannot_store_register (int regno)
+{
+  return (regno == 35 || regno >= arc_num_regs); /* FIXME, this is dirty */
+}
+
+static int
+arc_cannot_fetch_register (int regno)
+{
+  return (regno >= arc_num_regs);
+}
+
+extern int debug_threads;
+
+static CORE_ADDR
+arc_get_pc ()
+{
+  unsigned long pc;
+  collect_register_by_name ("stop_pc", &pc);
+  if (debug_threads)
+    fprintf (stderr, "stop pc is %08lx\n", pc);
+  return pc;
+}
+
+static void
+arc_set_pc (CORE_ADDR pc)
+{
+  unsigned long newpc = pc;
+  supply_register_by_name ("ret", &newpc);
+}
+
+
+/* trap_s 1 */
+/* FIXME: dependent on target endianness */
+static const unsigned long arc_breakpoint = 0x783E;
+#define arc_breakpoint_len 2
+
+static int
+arc_breakpoint_at (CORE_ADDR where)
+{
+  unsigned long insn;
+
+  (*the_target->read_memory) (where, (char *) &insn, arc_breakpoint_len);
+  if (insn == arc_breakpoint)
+    return 1;
+
+  /* If necessary, recognize more trap instructions here.  GDB only uses the
+     one.  */
+  return 0;
+}
+
+
+/* We only place breakpoints in empty marker functions, and thread locking
+   is outside of the function.  So rather than importing software single-step,
+   we can just run until exit.  */
+static CORE_ADDR
+arc_reinsert_addr ()
+{
+  unsigned long pc;
+  collect_register_by_name ("blink", &pc);
+  return pc;
+}
+
+struct linux_target_ops the_low_target = {
+  arc_num_regs,
+  arc_regmap,
+  arc_cannot_fetch_register,
+  arc_cannot_store_register,
+  arc_get_pc,
+  arc_set_pc,
+  (const char *) &arc_breakpoint,
+  arc_breakpoint_len,
+  arc_reinsert_addr,
+  0,
+  arc_breakpoint_at,
+};
diff --git a/gdb/gpio.h b/gdb/gpio.h
new file mode 100644
index 0000000..86aa4ca
--- /dev/null
+++ b/gdb/gpio.h
@@ -0,0 +1,38 @@
+struct GPIO_ioctl {
+    // This is used for general input and output in the same ioctl.
+    // inlen is replaced by the number of input bytes consumed.
+    // inlen is always even and represents a number of pairs:
+    //	[0/1/2,value]: write value to port_base+0/1/2.
+    //	[0x80/0x81/0x82, --]: read value from port_base+0/1/2
+    //	and append result to outbuf.
+    // Thus one can intermix read and write in the same ioctl.
+    unsigned inlen; char *inbuf;
+    // outlen is replaced by # of output bytes written.
+    unsigned outlen; char *outbuf;
+    };
+
+// IO control numbers
+
+// Linux kernel uses 0x54XX for special purposes.  Avoid such.
+// We'll pick large numbers.
+// We don't use the linux convention of dividing the IOC into a bunch
+// of bit fields.  We can always switch to this later, as the
+// IOC 0 returns the driver version (which IOC value will never change).
+
+#define GPIO_IOC_VERSION 0	// returns version
+#define GPIO_IOC_BASE 0xaa3a0000	// Intended for use on ARCangel 3!
+
+// Switch base address of parallel port.  0x3f8 is assumed.
+// WARNING!  You can write on any port whatsoever with this driver.
+// BE CAREFUL!
+#define GPIO_IOC_SET_PORT_BASE 	(GPIO_IOC_BASE+1) // cmd, arg=port base
+
+// General input/output ioctl.  See GPIO_ioctl struct.
+#define GPIO_IOC_DO_IO  	(GPIO_IOC_BASE+2) // cmd, arg=GPIO_ioctl *
+
+// For emergency purposes in case the driver is goofed up.
+#define GPIO_IOC_HARDRESET 	(GPIO_IOC_BASE+3) // cmd, no arg
+
+// Do you have an antiquated parallel port?  You might need to ask
+// the driver to use outb_p and inb_p (_p = pause).  Default is not to.
+#define GPIO_IOC_SET_PAUSE 	(GPIO_IOC_BASE+4) // arg = 1 => use pause; o/wise not.
diff --git a/gdb/regformats/reg-arc.dat b/gdb/regformats/reg-arc.dat
new file mode 100644
index 0000000..74f3b06
--- /dev/null
+++ b/gdb/regformats/reg-arc.dat
@@ -0,0 +1,41 @@
+name:arc
+expedite:fp,sp,ret
+32:r0
+32:r1
+32:r2
+32:r3
+32:r4
+32:r5
+32:r6
+32:r7
+32:r8
+32:r9
+32:r10
+32:r11
+32:r12
+32:r13
+32:r14
+32:r15
+32:r16
+32:r17
+32:r18
+32:r19
+32:r20
+32:r21
+32:r22
+32:r23
+32:r24
+32:r25
+32:r26
+32:bta
+32:lp_start
+32:lp_end
+32:lp_count
+32:status32
+32:blink
+32:fp
+32:sp
+32:efa
+32:ret
+32:orig_r8
+32:stop_pc
diff --git a/gdb/testsuite/ChangeLog.codito b/gdb/testsuite/ChangeLog.codito
new file mode 100644
index 0000000..87e1277
--- /dev/null
+++ b/gdb/testsuite/ChangeLog.codito
@@ -0,0 +1,151 @@
+2005-11-08  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* arcgdbserverusinggdbserver.exp: Is a duplicate of
+	lib/arc-gdbserver.exp. Remove it.
+	* lib/arc-jtag.exp: Remove hardcoded compiler, assembler, etc. Use
+	environment variables instead.
+	* lib/arc-gdbserver.exp: Ditto. Disallow fileio tests. Use default
+	timeout. 
+	* config/remote-gdbserver.exp (rsh_gdbserver_spawn): Expect output
+	from the spawned rsh program. Check for errors. Return -1 on
+	error.
+	(gdbserver_spawn): Return spawn_id.
+	(gdb_load): Check the returned spawn_id from gdbserver_spawn and
+	return -1 on error. Remove sleep and expect output from the
+	spawned process instead. Do a wait on the spawned process after it
+	finishes.
+	* lib/mi-support.exp (gdb_load): Ditto.
+
+2005-10-31  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* gdb.asm/asm-source.exp: Add linker flag -marclinux for target arc.
+
+2005-10-24  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* gdb.asm/asm-source.exp: Set debug-flags to -gdwarf-2 for target arc.
+
+2005-10-21  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* gdb.asm/arc.inc: Define macro's declare and end.
+
+2005-10-18  Kunal Parmar  <kunal.parmar@codito.com>
+
+	Bug #1183
+	* lib/mi-support.exp (mi_gdb_load): Add support for target
+	remote. Fix for Bug #1183 (Testsuite does not complete for
+	gdb.mi).
+
+2005-10-14  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* config/remote-gdbserver.exp (gdb_load): Check the return value
+	from gdb_target_cmd. Retry on failure.
+
+2005-09-28  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* lib/arc-jtag.exp: Skip the huge.exp test.
+
+2005-09-28  Kunal Parmar  <kunal.parmar@codito.com>
+
+	Bug #1183
+	* lib/mi-support.exp (mi_gdb_load): Add support for target
+	arcjtag. Fix for Bug #1183 (Testsuite does not complete for
+	gdb.mi).
+
+2005-09-23  Kunal Parmar  <kunal.parmar@codito.com>
+
+	* config/arc-jtag.exp: Take care about timeouts. Kill previous
+	program being debugged after doing arc-reset-board.
+	* lib/arc-jtag.exp: Add board_info to disallow unsupported tests.
+	Add board_info for arcjtag as gdb_protocol.
+
+2005-05-20  Soam Vasani  <soam.vasani@codito.com>
+
+	* gdb.arch/arc-step-jtag.s: Define "main" label.
+	* gdb.arch/arc-step.s: Ditto.
+
+2005-05-15  Soam Vasani  <soam.vasani@codito.com>
+
+	* gdb.arch/arc-step-jtag.exp: Check gdb_load's return value.
+
+2005-05-15  Soam Vasani  <soam.vasani@codito.com>
+
+	* config/arc-jtag.exp (gdb_target_arcjtag): Increase timeout.
+	Kill previous program being debugged.  Return zero on success,
+	non-zero otherwise.
+	(gdb_load): Check return value of gdb_target_arcjtag.  Return zero
+	on success, non-zero otherwise.
+
+2005-05-14  Soam Vasani  <soam.vasani@codito.com>
+
+	* gdb.arch/arc-step-jtag.exp: Oops.  Use arc-step-jtag.s, not
+	arc-step.s.
+
+2005-05-14  Soam Vasani  <soam.vasani@codito.com>
+
+	* gdb.arch/arc-step-jtag.exp: New file for the JTAG target.
+	* arc-step-jtag.s: New file, derived from arc-step.s: added labels
+	in delay slots and ended using "flag 1"
+	(JTAG uses hardware single step which can step thru delay slots,
+	unlike software single step.)
+	* gdb.arch/arc-step.exp: Quit if not on linux.
+
+2005-05-14  Soam Vasani  <soam.vasani@codito.com>
+
+	* config/arc-jtag.exp (gdb_target_arcjtag): If target arcjtag
+	fails, once do arc-reset-board and try again.
+
+2005-05-12  Ramana Radhakrishnan  <ramana@codito.com>
+
+	* lib/gdbserver.exp: Use a special tests dir for specifying
+	the tests directory where the tests have been downloaded. 
+	* arcgdbserverusinggdbserver.exp: Use this to run the testsuite. 
+
+2005-05-04  Soam Vasani  <soam.vasani@codito.com>
+
+	* config/arc-jtag.exp: Target-specific file for the arcjtag target.
+	* lib/arc-jtag.exp: Baseboard file for arcjtag target.  (No real
+	reason to put it in this directory, but...)
+
+2005-04-13  Soam Vasani  <soam.vasani@codito.com>
+
+	* gdb.arch/arc-step.exp: Tests for software single step across
+	32 bit / 16bit instructions, branches with/without delay slots,
+	and zero-overhead-loops.
+	* gdb.arch/arc-step.s: Ditto.
+
+2005-04-11  Soam Vasani  <soam.vasani@codito.com>
+
+	* gdb.threads/thread_check.exp: Applied
+	  http://sources.redhat.com/ml/gdb-patches/2004-11/msg00458.html,
+	  which corrects the filename and the regexp.
+
+2005-04-08  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* gdb.base/float.exp: Add support for the ARC platform. 
+
+2005-03-30  Soam Vasani  <soam.vasani@codito.com>
+
+	* config/remote-gdbserver.exp (rsh_gdbserver_spawn): Find RSH.
+	* lib/arc-gdbserver.exp: Use rsh instead of telnet.
+
+2005-03-21  Soam Vasani  <soam.vasani@codito.com>
+
+	* config/remote-gdbserver.exp (mynewtelnet_open_and_exec): Assume
+	that telnet-exec.exp is in the path; do not hardcode the path.
+	* lib/arc-gdbserver.exp: Remove hardcoded paths, port numbers,
+	etc.  Use environment variables instead.
+
+2005-03-15  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* config/remote-gdbserver.exp: New file for nfs copying
+	* gdb.asm/arc.inc: New file for assembly language testing
+	* gdb.asm/asm-source.exp: Handle the arc architecture. 
+	* lib/telnet-exec.exp: A replacement for rsh using telnet to allow
+	  executing commands on the arc board. Used while testing
+	  gdbserver on ARC700. 
+	* lib/arc-gdbserver.exp: A setup for running the testsuite
+	  using arc-gdbserver. Should be a part of the dejagnu
+	  distribution but is kept here for convinience. Tailor this 
+	  for use. (Store usually in /usr/share/dejagnu/baseboards directory)
+	
+
diff --git a/gdb/testsuite/config/arc-jtag.exp b/gdb/testsuite/config/arc-jtag.exp
new file mode 100644
index 0000000..1689111
--- /dev/null
+++ b/gdb/testsuite/config/arc-jtag.exp
@@ -0,0 +1,112 @@
+# Test Framework Driver for GDB using the arcjtag target.
+
+#   Copyright 2005 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
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+load_lib gdb.exp
+
+#
+# gdb_target_arcjtag
+# Set gdb to target arcjtag.
+#
+proc gdb_target_arcjtag { } {
+    global gdb_prompt
+    global exit_status
+
+    # our arcjtag target doesn't take any options (yet)
+    #set target_arcjtag_options "[board_info target gdb,target_sim_options]";
+
+    send_gdb "target arcjtag\n"
+
+    gdb_expect 60 {
+        -re "A program is being debugged already.*Kill it.*y or n. $" {
+            send_gdb "y\n"
+	    verbose "\t\tKilling previous program being debugged"
+            exp_continue
+        }
+	-re "Connected to the arcjtag target.*$gdb_prompt $"	{
+	    verbose "Set target to arcjtag"
+	}
+	-re "$gdb_prompt $" {
+	    verbose "Retrying target arcjtag..."
+	    send_gdb "arc-reset-board\n"
+	    send_gdb "target arcjtag\n"
+
+	    gdb_expect 60 {
+		-re "A program is being debugged already.*Kill it.*y or n. $" {
+		    send_gdb "y\n"
+		    verbose "\t\tKilling previous program being debugged"
+		    exp_continue
+		}
+		-re "Connected to the arcjtag target.*$gdb_prompt $"	{
+		    verbose "Set target to arcjtag"
+		}
+		timeout { 
+		    perror "Couldn't set target to arcjtag (timeout)."
+		    return 1
+		}
+	    }
+	}
+	timeout { 
+	    perror "Couldn't set target to arcjtag (timeout)."
+	    return 1
+	}
+    }
+
+    return 0
+}
+
+#
+# gdb_load -- load a file into the debugger.
+#             return a -1 if anything goes wrong.
+#
+proc gdb_load { arg } {
+    global verbose
+    global loadpath
+    global loadfile
+    global GDB
+    global gdb_prompt
+
+    if { $arg != "" } {
+	if [gdb_file_cmd $arg] then { return -1 }
+    }
+    
+    if { [gdb_target_arcjtag] != 0 } {
+	return -1
+    }
+
+    # gotta do something about the timeout....
+    send_gdb "load\n"
+
+    gdb_expect 180 {
+	-re ".*$gdb_prompt $" {
+	    if $verbose>1 then {
+		send_user "Loaded $arg into $GDB\n"
+	    }
+	    return 0
+	}
+	-re "$gdb_prompt $" {
+	    if $verbose>1 then {
+		perror "GDB couldn't load."
+	    }
+	}
+	timeout {
+	    perror "Timed out trying to load $arg."
+	}
+    }
+
+    return 1
+}
diff --git a/gdb/testsuite/config/remote-gdbserver.exp b/gdb/testsuite/config/remote-gdbserver.exp
new file mode 100644
index 0000000..60d106d
--- /dev/null
+++ b/gdb/testsuite/config/remote-gdbserver.exp
@@ -0,0 +1,570 @@
+# Test framework for GDB (remote protocol) using a "gdbserver",
+# ie. a debug agent running as a native process on the same or
+# a different host.
+
+# Copyright 2000, 2001, 2003 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
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# 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., 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
+
+# This file was written by Michael Snyder. (msnyder@redhat.com)
+
+#
+# This module to be used for testing gdb with a "gdbserver" 
+# built either from libremote or from gdb/gdbserver.
+#
+
+# Load the basic testing library, and the remote stuff.
+load_lib ../config/monitor.exp
+load_lib telnet.exp
+#
+# To be addressed or set in your baseboard config file:
+#
+#   set_board_info gdb_protocol "remote"
+#	Unles you have a gdbserver that uses a different protocol...
+#
+#   set_board_info use_gdb_stub 1
+#	This tells the rest of the test suite not to do things
+#	like "run" which don't work well on remote targets.
+#
+#   set_board_info gdb,do_reload_on_run 1
+#	Unles you have a gdbserver that can handle multiple sessions.
+#
+#   set_board_info noargs 1
+#	At present there is no provision in the remote protocol
+#	for passing arguments.  This test framework does not
+#	address the issue, so it's best to set this variable
+#	in your baseboard configuration file.  
+#	FIXME: there's no reason why the test harness couldn't
+#	pass commandline args when it spawns gdbserver.
+#
+#   set_board_info gdb,noinferiorio 1
+#	Neither the traditional gdbserver nor the one in libremote
+#	can presently capture stdout and relay it to GDB via the
+#	'O' packet.  This means that tests involving printf will
+#	fail unles you set this varibale in your baseboard
+#	configuration file.
+#   
+#   set_board_info gdb,no_hardware_watchpoints 1
+#	Unles you have a gdbserver that supports hardware watchpoints.
+#	FIXME: gdb should detect if the target doesn't support them,
+#	and fall back to using software watchpoints.
+#
+#   set_board_info gdb_server_prog
+#	This will be the path to the gdbserver program you want to test.
+#	Defaults to "gdbserver".
+#
+#   set_board_info sockethost
+#	The name of the host computer whose socket is being used.
+#	Defaults to "localhost".  Note: old gdbserver requires 
+#	that you define this, but libremote/gdbserver does not.
+#
+#   set_board_info socketport
+#	Port id to use for socket connection.  If not set explicitly,
+#	it will start at "2345" and increment for each use.
+#
+#   set_board_info rsh_prog
+#	The program to use to spawn executables on the remote board.
+#	Default: "rsh"
+#
+#   set_board_info rcp_prog
+#	The program to use to copy test executables to the remote board.
+#	Default: "rcp"
+#
+#   set_board_info nfsdir
+#	If rcp_prog is set to "cp", specify the local directory name that
+#	is NFS mounted by the board.
+
+#
+# gdb_load -- load a file into the debugger.
+#             return a -1 if anything goes wrong.
+#
+
+global server_exec;
+global portnum;
+set portnum "2000";
+
+proc gdb_load { args } {
+    global server_exec;
+    global portnum;
+    global verbose;
+    global gdb_prompt;
+
+    # Port id -- either specified in baseboard file, or managed here.
+    if [target_info exists gdb,socketport] {
+	set portnum [target_info gdb,socketport];
+    } else {
+	# Bump the port number to avoid conflicts with hung ports.
+	incr portnum;
+    }
+
+    # Extract the local and remote host ids from the target board struct.
+
+    if [target_info exists sockethost] {
+	set debughost  [target_info sockethost];
+    } else {
+	set debughost "localhost:";
+    }
+    # Extract the protocol
+    if [target_info exists gdb_protocol] {
+	set protocol [target_info gdb_protocol];
+    } else {
+	set protocol "remote";
+    }
+
+    # Extract the name of the gdbserver, if known (default 'gdbserver').
+    if [target_info exists gdb_server_prog] {
+	set gdbserver [target_info gdb_server_prog];
+    } else {
+	set gdbserver "gdbserver";
+    }
+    # Extract the socket hostname
+    if [target_info exists sockethost] {
+	set sockethost [target_info sockethost];
+    } else {
+	set sockethost ""
+    }
+
+    # Get target name
+    if [target_info exists hostname] {
+	set target_address [target_info hostname];
+    } else {
+	set target_address "localhost"
+    }
+
+    # Get the username on the target
+    if [target_info exists "username"] {
+	set username [target_info username];
+    } else {
+	set username "";
+    }
+
+    # Get download dir
+    if [target_info exists download_dir] {
+	set download_dir [target_info download_dir];
+    } else {
+	set download_dir "/tmp"
+    }
+
+    # Get tests dir
+    if [target_info exists tests_dir] {
+	set tests_dir [target_info tests_dir];
+    } else {
+	set tests_dir $download_dir
+    }
+
+    # Export the host:port pair.
+    set gdbport $debughost$portnum;
+
+    if { $args == "" || $args == "{}" } {
+	if [info exists server_exec] {
+	    set args $server_exec;
+	} else {
+	    send_gdb "info files\n";
+	    gdb_expect 30 {
+		-re "Symbols from \"(\[^\"\]+)\"" {
+		    set args $expect_out(1,string);
+		    exp_continue;
+		}
+		-re "Local exec file:\[\r\n\]+\[ \t\]*`(\[^'\]+)'," {
+		    set args $expect_out(1,string);
+		    exp_continue;
+		}
+		-re "$gdb_prompt $" { }
+	    }
+	}
+    }
+
+    # remember new exec file 
+    set server_exec $args;
+
+    # Download the test files into the test_board
+    gdbserver_download $target_address $username $server_exec \
+	$download_dir/a-$portnum.out
+
+    # tell gdb what file we are debugging
+    if [gdb_file_cmd $args] {
+	return -1;
+    }
+
+    if [target_info exists solib_path] {
+	send_gdb "set solib-absolute-prefix [target_info solib_path]\n"
+	gdb_expect 30 {
+	    -re "$gdb_prompt $" {
+		if $verbose>1 then {
+		    send_user "set library path\n"
+		}
+	    }
+	    default { 
+		perror "Couldn't set library path\n"
+		return -1
+	    }
+	}
+    }
+
+    for {set i 1} {$i <= 3} {incr i} {
+	# Fire off the debug agent
+	set server_spawn_id [gdbserver_spawn $target_address $username \
+				 "$gdbserver $target_address:$portnum $tests_dir/a-$portnum.out 2>&1"]
+	
+	if { $server_spawn_id <= 0 } { return -1 }
+
+	# Wait for the server to produce at least one line and an additional
+	# character of output.  This will wait until any TCP socket has been
+	# created, so that GDB can connect.
+	expect {
+	    # expect output from $server_spawn_id
+	    -i $server_spawn_id
+	    -re ".*\n." { }
+	}
+    
+	# We can't just call close, because if gdbserver is local then that means
+	# that it will get a SIGHUP.  Doing it this way could also allow us to
+	# get at the inferior's input or output if necessary, and means that we
+	# don't need to redirect output.
+	expect_background {
+	   -i $server_spawn_id
+	   -re "." { }
+	   eof {
+	       # The spawn ID is already closed now (but not yet waited for).
+	       wait -nowait -i $expect_out(spawn_id)
+	   }
+	}
+	
+	# attach to the "serial port"
+	if {[gdb_target_cmd $protocol $gdbport] == 0 } {
+	    break
+	}
+	verbose -log "Unable to connect to target. Re-trying.."
+    }	
+
+    # do the real load if needed
+    if [target_info exists gdb_server_do_load] {
+        send_gdb "load\n"
+        set timeout 2400
+        verbose "Timeout is now $timeout seconds" 2
+        gdb_expect {
+            -re ".*$gdb_prompt $" {
+                if $verbose>1 then {
+                    send_user "Loaded $arg into $GDB\n"
+                }
+                set timeout 30
+                verbose "Timeout is now $timeout seconds" 2
+                return 1
+            }
+            -re "$gdb_prompt $"     {
+                if $verbose>1 then {
+                    perror "GDB couldn't load."
+                }
+            }
+            timeout {
+                if $verbose>1 then {
+                    perror "Timed out trying to load $arg."
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+# Use RSH or telnet depending on the program chosen
+# by the board file. 
+# Return spawn_id
+proc gdbserver_spawn { dest username commandline } {
+    global board_info 
+    if ![target_info exists rsh_prog] {
+        if { [which remsh] != 0 } {
+            set RSH remsh
+        } else {
+            set RSH rsh
+        }
+    } else {
+        set RSH [target_info rsh_prog];
+    }
+
+    if { $RSH == "rsh" } {
+	return [rsh_gdbserver_spawn $dest $username $commandline]
+    } else {
+
+	if { $RSH == "telnet" } {
+	    # Spawn the shell
+	    return [telnet_gdbserver_spawn $dest $username $commandline]
+	    
+	    # expect the shell prompt obtained from 
+	    # the board description.
+	    # Now spawn gdbserver with its parameters
+	    # and dont expect any output from the gdbserver
+	    # other than the shell prompt
+	    # FIXME ?? Where do I close the telnet
+	    # session ( could use gdb_finish for closing the telnet session)
+
+	    
+
+	} else {
+	    verbose "Unknown rsh program "
+	    return -1
+	}
+    }
+}
+
+proc mynewtelnet_open_and_exec {  dest port shell_prompt commandline } {
+    global board_info
+    
+    spawn "telnet-exec.exp" $dest $commandline
+    set board_info($dest,fileid) $spawn_id;
+    return $spawn_id;
+}
+
+
+proc mytelnet_open_and_exec {  dest port shell_prompt commandline } {
+    set tries 0
+    set result -1
+    set need_respawn 1
+    
+    verbose "Starting a telnet connection to $dest:$port $shell_prompt " 2
+    while { $result < 0 && $tries <= 3 } {
+	if { $need_respawn } {
+	    set need_respawn 0
+	    spawn "telnet" $dest $port
+	}
+	expect {
+	    "Trying " {
+		exp_continue
+	    }
+	    -re "$shell_prompt.*$" {
+		verbose "Got prompt $shell_prompt\n"
+		set result 0
+		exp_send $commandline
+	   
+	    }
+	    -re "nt Name:|ogin:" {
+		if [board_info $connhost exists telnet_username] {
+		    exp_send "[board_info $connhost telnet_username]\n"
+		    exp_continue
+		}
+		if [board_info $connhost exists username] {
+		    exp_send "[board_info $connhost username]\n"
+		    exp_continue
+		}
+		perror "telnet: need to login"
+		break
+	    }
+	    "assword:" {
+		if [board_info $connhost exists telnet_password] {
+		    exp_send "[board_info $connhost telnet_password]\n"
+		    exp_continue
+		}
+		if [board_info $connhost exists password] {
+		    exp_send "[board_info $connhost password]\n"
+		    exp_continue
+		}
+		perror "telnet: need a password"
+		break
+	    }
+	    -re "advance.*y/n.*\\?" {
+		exp_send "n\n"
+		exp_continue
+	    }
+	    -re {([Aa]dvanced|[Ss]imple) or ([Ss]imple|[Aa]dvanced)} {
+		exp_send "simple\n"
+		exp_continue
+	    }
+	    "Connected to" {
+		exp_continue
+	    }
+	    "unknown host" {
+		exp_send "\003"
+		perror "telnet: unknown host"
+		break
+	    }
+	    "VxWorks Boot" {
+		exp_send "@\n"
+		sleep 20
+		exp_continue
+	    }
+	    -re "Escape character is.*\\.\[\r\n\]" {
+		    exp_continue
+	    }
+	    "has logged on from" {
+		exp_continue
+	    }
+	    "You have no Kerberos tickets" {
+		warning "telnet: no kerberos Tickets, please kinit"
+		break
+	    }
+	    -re "Connection refused.*$" {
+		catch "exp_send \"\003\"" foo
+		sleep 5
+		warning "telnet: connection refused."
+	    }
+	    -re "Sorry, this system is engaged.*" {
+		exp_send "\003"
+		warning "telnet: already connected."
+	    }
+	    "Connection closed by foreign host.*$" {
+		warning "telnet: connection closed by foreign host."
+		break
+	    }
+	    -re "\[\r\n\]+" {
+		exp_continue
+	    }
+	    timeout {
+		exp_send "\n"
+	    }
+	    eof {
+		warning "telnet: got unexpected EOF from telnet."
+		catch close
+		catch wait
+		set need_respawn 1
+		sleep 5
+	    }
+	}
+	incr tries
+    }
+
+    
+    verbose "spawn id is $spawn_id"
+    set board_info($dest,fileid) $spawn_id;
+    return $spawn_id
+}
+
+# Use telnet to spawn a session 
+proc telnet_gdbserver_spawn { dest username commandline } {
+    global board_info
+    set remote $dest
+    set telnet_prog "telnet"
+    set prompt [target_info shell_prompt]
+    set mport 23 
+    verbose "commandline is $commandline"
+    return [mynewtelnet_open_and_exec $remote $mport $prompt $commandline]
+}
+
+
+#
+# Use $RSH to spawn $commandline on remote machine $dest as user $username.
+# (Note $username on $dest will have to have appropriate .rhost entries.)
+#
+proc rsh_gdbserver_spawn { dest username commandline } {
+    global board_info
+
+    if [target_info exists rsh_prog] {
+	set RSH [target_info rsh_prog];
+    } else {
+        set RSH rsh
+    }
+
+    if [board_info $dest exists hostname] {
+	set remote [board_info $dest hostname];
+    } else {
+	set remote $dest;
+    }
+
+    if { $username == "" } {
+	set rsh_useropts ""
+    } else {
+	set rsh_useropts "-l"
+    }
+
+    verbose "spawn $RSH $rsh_useropts $username $remote $commandline";
+    spawn $RSH $rsh_useropts $username $remote $commandline;
+    set board_info($dest,fileid) $spawn_id;
+
+    set timeout 60
+    expect {
+	# expect output from $spawn_id
+	-i $spawn_id
+	-re "(.*No route to host)|(poll: protocol failure in circuit setup)|(.*Unknown host)|(.*Connection refused)|(Login incorrect)|(Permission denied)" {
+	    verbose -log "$RSH to $remote failed, output \"$expect_out(buffer)\""
+	    return -1
+	}
+	-re ".*\r" { }
+	timeout {
+	    verbose -log "$RSH to $remote timedout (timeout=$timeout)"
+	    return -1
+	}
+	eof {
+	    verbose -log "$RSH to $remote failed"	    
+	    return -1
+	}
+    }
+
+    return $spawn_id;
+}
+
+#
+# Download $srcfile to $destfile on $desthost as user $username using rcp.
+#
+
+proc gdbserver_download {desthost username srcfile destfile} {
+    if [target_info exists rsh_prog] {
+	set RSH [target_info rsh_prog];
+    } else {
+        set RSH rsh
+    }
+
+    if ![target_info exists rcp_prog] {
+        set RCP rcp
+    } else {
+	set RCP [target_info rcp_prog];
+    }
+
+    if [board_info $desthost exists name] {
+	set desthost [board_info $desthost name];
+    }
+
+    if [board_info $desthost exists hostname] {
+	set desthost [board_info $desthost hostname];
+    }
+
+    if { $username == "" } {
+	set rsh_useropts ""
+	set rcp_dest $desthost
+    } else {
+	set rsh_useropts "-l $username"
+	set rcp_dest "$username@$desthost"
+    }
+
+    # Delete the output file
+    # set status [catch "exec $RSH $rsh_useropts $desthost rm -f $destfile |& cat" output] 
+
+    if { $RCP != "cp" } {
+	set status [catch "exec $RCP $srcfile $rcp_dest:$destfile |& cat" output]
+    } else {
+	if [target_info exists nfsdir] {
+	    set nfsdir [target_info nfsdir];
+	    verbose -log "nfsdir is  $nfsdir"
+	    set status [catch "exec cp $srcfile $nfsdir/$destfile |& cat" output]
+	} else {
+	    verbose "\nnfsdir not set\n"
+	    set status 1
+	}
+    }
+    if { $status == 0 } {
+	if [target_info exists nfsdir] {
+	    verbose "Copied $srcfile to $nfsdir/$destfile" 2
+	    return $destfile;
+	} else {
+	    verbose "Copied $srcfile to $desthost:$destfile" 2
+	    return $destfile;
+	}
+    } else {
+	verbose "Download to $desthost failed, $output."
+	return ""
+    }
+}
diff --git a/gdb/testsuite/gdb.arch/arc-step-jtag.exp b/gdb/testsuite/gdb.arch/arc-step-jtag.exp
new file mode 100644
index 0000000..a51f00e
--- /dev/null
+++ b/gdb/testsuite/gdb.arch/arc-step-jtag.exp
@@ -0,0 +1,88 @@
+if $tracelevel {
+    strace $tracelevel
+}
+
+# Test single-stepping zero-overhead-loops and delay slots
+
+if ![istarget "arc-*-*"] then {
+    verbose "Skipping ARC single-step tests."
+    return
+}
+
+if ![istarget "*elf32*"] then {
+    verbose "Skipping ARC JTAG single-step tests."
+    return
+}
+
+set testfile "arc-step-jtag"
+set srcfile ${testfile}.s
+set binfile ${objdir}/${subdir}/${testfile}
+if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable ""] != "" } {
+    gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+
+if { [ gdb_load ${binfile} ] != 0 } {
+    gdb_suppress_entire_file "Load failed, so all tests in this file will automatically fail."
+}
+
+#
+# Run to `main' where we begin our tests.
+#
+
+gdb_test "adv _main" 	".* in _main .*"  "advance to _main"
+
+gdb_test "stepi"     	".* Lmov .*"      "step mov instruction"
+gdb_test "p \$r0"    	".*= 1"           "r0 value after mov instruction"
+
+gdb_test "stepi"     	".* Lmov_s .*"    "step mov_s instruction"
+gdb_test "p \$r0"    	".*= 2"           "r0 value after mov_s instruction"
+
+gdb_test "stepi"     	".* Lb .*"        "step b instruction"
+
+gdb_test "stepi"     	".* Lb_s .*"      "step b_s instruction"
+
+gdb_test "stepi"     	".* Lbdotd_dslot .*"    "step b.d branch"
+gdb_test "stepi"     	".* Lbdotd .*"          "step b.d delay slot"
+gdb_test "p \$r0"    	".*= 5"                 "r0 value after b.d delay slot"
+
+gdb_test "stepi"     	".* Lbl .*"       "step bl instruction"
+
+gdb_test "stepi"     	".* Lj_sdotd_dslot .*"  "step j_s.d \[blink\] branch"
+gdb_test "stepi"     	".* Lj_sdotd .*"        "step j_s.d \[blink\] delay slot"
+gdb_test "p \$r0"    	".*= 6"                 "r0 value after j_s.d \[blink\] delay slot"
+
+gdb_test "stepi"     	".* Lj .*"        "step j instruction"
+
+gdb_test "stepi"     	".*"              "step mov instruction"
+gdb_test "stepi"     	".* ZOLstart .*"  "step lp instruction"
+
+gdb_test "p \$lp_count" ".*= 3"           "lp_count value"
+gdb_test "p \$lp_end - \$lp_start" \
+                        ".* = 8"          "lp_end - lp_start == 8"
+
+gdb_test "p \$r0"       ".* = 6"          "r0 value before loop"
+
+# step thru the loop, checking the value of r0
+
+# first iteration
+gdb_test "stepi"        ".* ZOLmiddle .*" "step add instruction (inside ZOL)"
+gdb_test "p \$r0"       ".* = 7"          "r0 value after 1 iteration"
+gdb_test "stepi"        ".* ZOLstart .*"  "step across end of ZOL"
+
+# second iteration
+gdb_test "stepi"        ".* ZOLmiddle .*" "step add instruction (inside ZOL)"
+gdb_test "p \$r0"       ".* = 8"          "r0 value after 2 iterations"
+gdb_test "stepi"        ".* ZOLstart .*"  "step across end of ZOL"
+
+# last iteration
+gdb_test "stepi"        ".* ZOLmiddle .*" "step add instruction (inside ZOL)"
+gdb_test "p \$r0"       ".* = 9"          "r0 value after 3 iterations"
+gdb_test "stepi"        ".* ZOLend .*"    "step out of end of ZOL"
+
+# exit(r0)
+gdb_test "continue"     ".*Program exited.*011.*" \
+                                          "value of r0 on exit"
diff --git a/gdb/testsuite/gdb.arch/arc-step-jtag.s b/gdb/testsuite/gdb.arch/arc-step-jtag.s
new file mode 100644
index 0000000..7ad8e1f
--- /dev/null
+++ b/gdb/testsuite/gdb.arch/arc-step-jtag.s
@@ -0,0 +1,46 @@
+_main:
+	.global _main
+main:	
+	.global main
+
+	mov   r0,1		; 32 bit instruction
+Lmov:	
+	mov_s r0,2		; 16 bit instruction
+Lmov_s:	
+	b Lb			; 32 bit, no delay slot
+	mov r0,3
+	nop
+Lb:	
+	b_s Lb_s		; 16 bit, no delay slot
+	mov r0,4
+	nop
+Lb_s:	
+	b.d Lbdotd		; 32 bit, delay slot
+Lbdotd_dslot:
+	mov r0,5
+	nop
+Lbdotd:
+
+	bl Lbl
+Lj_sdotd:
+	j Lj
+Lbl:	
+	j_s.d [blink]		; 16 bit, delay slot
+Lj_sdotd_dslot:
+	mov r0,6
+Lj:	
+	mov lp_count,3		; zero-overhead loop
+	lp ZOLend
+ZOLstart:
+	add r0,r0,1
+ZOLmiddle:
+	nop
+ZOLend:	
+	;; r0 should be 9
+	
+	
+	;; exit(r0)
+	flag 1
+	nop
+	nop
+	nop
diff --git a/gdb/testsuite/gdb.arch/arc-step.exp b/gdb/testsuite/gdb.arch/arc-step.exp
new file mode 100644
index 0000000..e958b5f
--- /dev/null
+++ b/gdb/testsuite/gdb.arch/arc-step.exp
@@ -0,0 +1,83 @@
+if $tracelevel {
+    strace $tracelevel
+}
+
+# Test single-stepping zero-overhead-loops and delay slots
+
+if ![istarget "arc-*-*"] then {
+    verbose "Skipping ARC single-step tests."
+    return
+}
+
+if ![istarget "*linux*"] then {
+    verbose "Skipping ARC linux single-step tests."
+    return
+}
+
+set testfile "arc-step"
+set srcfile ${testfile}.s
+set binfile ${objdir}/${subdir}/${testfile}
+if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable ""] != "" } {
+    gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+gdb_load ${binfile}
+
+#
+# Run to `main' where we begin our tests.
+#
+
+gdb_test "adv _main" 	".* in _main .*"  "advance to _main"
+
+gdb_test "stepi"     	".* Lmov .*"      "step mov instruction"
+gdb_test "p \$r0"    	".*= 1"           "r0 value after mov instruction"
+
+gdb_test "stepi"     	".* Lmov_s .*"    "step mov_s instruction"
+gdb_test "p \$r0"    	".*= 2"           "r0 value after mov_s instruction"
+
+gdb_test "stepi"     	".* Lb .*"        "step b instruction"
+
+gdb_test "stepi"     	".* Lb_s .*"      "step b_s instruction"
+
+gdb_test "stepi"     	".* Lbdotd .*"    "step b.d instruction"
+gdb_test "p \$r0"    	".*= 5"           "r0 value after b.d instruction"
+
+gdb_test "stepi"     	".* Lbl .*"       "step bl instruction"
+
+gdb_test "stepi"     	".* Lj_sdotd .*"  "step j_s.d \[blink\] instruction"
+gdb_test "p \$r0"    	".*= 6"           "r0 value after j_s.d \[blink\] instruction"
+
+gdb_test "stepi"     	".* Lj .*"        "step j instruction"
+
+gdb_test "stepi"     	".*"              "step mov instruction"
+gdb_test "stepi"     	".* ZOLstart .*"  "step lp instruction"
+
+gdb_test "p \$lp_count" ".*= 3"           "lp_count value"
+gdb_test "p \$lp_end - \$lp_start" \
+                        ".* = 8"          "lp_end - lp_start == 8"
+
+gdb_test "p \$r0"       ".* = 6"          "r0 value before loop"
+
+# step thru the loop, checking the value of r0
+
+# first iteration
+gdb_test "stepi"        ".* ZOLmiddle .*" "step add instruction (inside ZOL)"
+gdb_test "p \$r0"       ".* = 7"          "r0 value after 1 iteration"
+gdb_test "stepi"        ".* ZOLstart .*"  "step across end of ZOL"
+
+# second iteration
+gdb_test "stepi"        ".* ZOLmiddle .*" "step add instruction (inside ZOL)"
+gdb_test "p \$r0"       ".* = 8"          "r0 value after 1 iteration"
+gdb_test "stepi"        ".* ZOLstart .*"  "step across end of ZOL"
+
+# last iteration
+gdb_test "stepi"        ".* ZOLmiddle .*" "step add instruction (inside ZOL)"
+gdb_test "p \$r0"       ".* = 9"          "r0 value after 1 iteration"
+gdb_test "stepi"        ".* ZOLend .*"    "step out of end of ZOL"
+
+# exit(r0)
+gdb_test "continue"     ".*Program exited.*011.*" \
+                                          "value of r0 on exit"
diff --git a/gdb/testsuite/gdb.arch/arc-step.s b/gdb/testsuite/gdb.arch/arc-step.s
new file mode 100644
index 0000000..8dce39a
--- /dev/null
+++ b/gdb/testsuite/gdb.arch/arc-step.s
@@ -0,0 +1,43 @@
+_main:
+	.global _main
+main:	
+	.global main
+
+	mov   r0,1		; 32 bit instruction
+Lmov:	
+	mov_s r0,2		; 16 bit instruction
+Lmov_s:	
+	b Lb			; 32 bit, no delay slot
+	mov r0,3
+	nop
+Lb:	
+	b_s Lb_s		; 16 bit, no delay slot
+	mov r0,4
+	nop
+Lb_s:	
+	b.d Lbdotd		; 32 bit, delay slot
+	mov r0,5
+	nop
+Lbdotd:
+
+	bl Lbl
+Lj_sdotd:
+	j Lj
+Lbl:	
+	j_s.d [blink]		; 16 bit, delay slot
+	mov r0,6
+Lj:	
+	mov lp_count,3		; zero-overhead loop
+	lp ZOLend
+ZOLstart:
+	add r0,r0,1
+ZOLmiddle:
+	nop
+ZOLend:	
+	;; r0 should be 9
+	
+	
+	;; exit(r0)
+	;; mov r0,0
+	mov r8,1
+	trap_s 0
diff --git a/gdb/testsuite/gdb.asm/arc.inc b/gdb/testsuite/gdb.asm/arc.inc
new file mode 100644
index 0000000..e22c35c
--- /dev/null
+++ b/gdb/testsuite/gdb.asm/arc.inc
@@ -0,0 +1,55 @@
+
+	comment "subroutine prologue"
+	.macro gdbasm_enter
+	st.a    blink,[sp,-4]
+	st.a	fp, [sp,-4]
+	mov	fp,sp
+	.endm
+
+	comment "subroutine epilogue"
+	.macro gdbasm_leave
+	ld.ab  fp, [sp,4]
+	ld     blink,[sp,0]
+	j.d    [blink]
+	add    sp,sp,4
+	.endm
+
+	.macro gdbasm_call subr
+	bl	\subr
+	.endm
+
+	.macro gdbasm_several_nops
+	nop
+	nop
+	nop
+	nop
+	.endm
+
+	comment "exit (0)"
+	.macro gdbasm_exit0
+	mov_s    r0,0
+	trap_s	 0
+	.endm
+
+	comment "crt0 startup"
+	.macro gdbasm_startup
+	mov    fp, 0
+	.endm
+
+	comment "Declare a data variable"
+	.macro gdbasm_datavar name value
+	.data
+\name:
+	.long	\value
+	.endm
+
+	comment "Declare the start of a subroutine"
+	.macro gdbasm_declare name
+	.type	\name, @function
+\name:
+	.endm
+
+	comment "End a subroutine"
+	.macro gdbasm_end name
+	.size	\name, .-name
+	.endm
diff --git a/gdb/testsuite/lib/arc-gdbserver.exp b/gdb/testsuite/lib/arc-gdbserver.exp
new file mode 100644
index 0000000..6674e92
--- /dev/null
+++ b/gdb/testsuite/lib/arc-gdbserver.exp
@@ -0,0 +1,98 @@
+# Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
+# Foundation, Inc.
+#
+# This file is part of DejaGnu.
+#
+# DejaGnu is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# DejaGnu is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with DejaGnu; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+# gdbserver running cross
+
+#load the config file
+load_generic_config "remote-gdbserver"
+
+
+process_multilib_options ""
+
+# The default compiler for this target.
+set_board_info compiler  "$env(GDBTEST_CC)"
+set_board_info cflags    "$env(GDBTEST_CFLAGS)"
+set_board_info assembler "$env(GDBTEST_AS) $env(GDBTEST_ASFLAGS)"
+set_board_info linker    "$env(GDBTEST_LD)" 
+set_board_info ldflags   "$env(GDBTEST_LDFLAGS)"
+
+# We will be using the standard GDB remote protocol
+set_board_info gdb_protocol "remote"
+
+set_board_info netport "$env(GDBTEST_GDBSERVER_HOST):$env(GDBTEST_GDBSERVER_PORT)"
+
+# Path to the gdbserver executable, if required.
+set_board_info gdb_server_prog $env(GDBTEST_GDBSERVER_PATH)
+#    "../gdbserver/gdbserver"
+
+# Name of the computer whose socket will be used, if required.
+set_board_info sockethost "$env(GDBTEST_GDBSERVER_HOST):"
+
+# Port ID to use for socket connection
+set_board_info gdb,socketport $env(GDBTEST_GDBSERVER_PORT)
+
+# Use techniques appropriate to a stub
+set_board_info use_gdb_stub 1
+
+# This gdbserver can only run a process once per session.
+set_board_info gdb,do_reload_on_run 1
+
+# There's no support for argument-passing (yet).
+set_board_info noargs 1
+
+# Can't do FILE IO in current gdbserver
+set_board_info gdb,nofileio 1
+
+# Can't do input (or output) in the current gdbserver.
+set_board_info gdb,noinferiorio 1
+
+# Can't do hardware watchpoints, in general
+set_board_info gdb,no_hardware_watchpoints 1
+
+# Copy the testcases using cp 
+set_board_info rcp_prog "cp"
+
+
+# Set nfs directory 
+# On my machine this is how it is mounted. - ramana
+# kanika:/home/opt/share on /mnt/nfsmounts type nfs (rw,addr=192.168.100.68)
+set_board_info nfsdir $env(GDBTEST_NFSDIR)
+
+# Set the test directory on the board. Where is this mounted 
+# on the board. 
+set_board_info tests_dir $env(GDBTEST_TESTS_DIR)
+
+# run on target using rsh
+set_board_info rsh_prog "rsh"
+
+# Download directory
+set_board_info download_dir $env(GDBTEST_DOWNLOAD_DIR)
+
+# Hostname 
+set_board_info hostname $env(GDBTEST_GDBSERVER_HOST)
+set_board_info username "root"
+set_board_info sockethost "$env(GDBTEST_GDBSERVER_HOST):"
+
+#Shell prompt
+set_board_info shell_prompt "\[arcLinux\]$"
+
+#set_board_info board,connect "telnet"
+
+# timeout
+#set_board_info gdb,timeout 300
diff --git a/gdb/testsuite/lib/arc-jtag.exp b/gdb/testsuite/lib/arc-jtag.exp
new file mode 100644
index 0000000..c613f30
--- /dev/null
+++ b/gdb/testsuite/lib/arc-jtag.exp
@@ -0,0 +1,32 @@
+#
+# The baseboard file for the arcjtag target
+#
+
+load_generic_config "arc-jtag"
+
+set_board_info compiler  "$env(GDBTEST_CC)"
+set_board_info cflags    "$env(GDBTEST_CFLAGS)"
+set_board_info assembler "$env(GDBTEST_AS) $env(GDBTEST_ASFLAGS)"
+set_board_info linker    "$env(GDBTEST_LD)"
+set_board_info ldflags   "$env(GDBTEST_LDFLAGS)"
+
+#Reload the file before running
+set_board_info gdb,do_reload_on_run 1
+
+#Arguments cannot be passed
+set_board_info noargs               1
+
+#File IO not supported
+set_board_info gdb,nofileio         1
+
+#Inferior is unable to do I/O
+set_board_info gdb,noinferiorio     1
+
+#Signals not supported
+set_board_info gdb,nosignals        1
+
+#Skip the huge.exp test
+set_board_info gdb,skip_huge_test   1
+
+#We use "target arcjtag" to talk to JTAG
+set_board_info gdb_protocol         "arcjtag"
diff --git a/gdb/testsuite/lib/telnet-exec.exp b/gdb/testsuite/lib/telnet-exec.exp
new file mode 100644
index 0000000..8bbaa8d
--- /dev/null
+++ b/gdb/testsuite/lib/telnet-exec.exp
@@ -0,0 +1,29 @@
+#!/usr/bin/expect -f 
+
+#
+#
+#
+
+
+set host "192.168.100.222"
+set debuggee [lindex $argv 0]
+
+set timeout 360
+set env(TERM) vt100;			# actual value doesn't matter, just has to be set
+
+spawn telnet $host
+sleep 1;				# wait for telnet to happen
+send "PS1=\\# \r"
+expect "\# "
+#expect "\[arcLinux\]\$"
+#send_user "one\n"
+
+
+send "cd /nfs/gdbserver-tests/ \r"
+expect "\# "
+#expect "\[arcLinux\]\$"
+send_user "starting gdbserver...\n"
+send "./gdbserver host:4004 /nfs/gdbserver-tests/ramana-tests/a-4004.out \r"
+
+expect "xxx"
+send "exit"
\ No newline at end of file
diff --git a/include/elf/ChangeLog.codito b/include/elf/ChangeLog.codito
new file mode 100644
index 0000000..d30c7c4
--- /dev/null
+++ b/include/elf/ChangeLog.codito
@@ -0,0 +1,8 @@
+2005-05-15  Ramana Radhakrishnan  <ramana@codito.com>
+
+	* arc.h: Merge new ELF relocs.
+
+2005-05-12  Ramana Radhakrishnan  <ramana@codito.com>
+
+	* dwarf2.h: Add Metaware specific CFA info. 
+
diff --git a/opcodes/ChangeLog.codito b/opcodes/ChangeLog.codito
new file mode 100644
index 0000000..253e0df
--- /dev/null
+++ b/opcodes/ChangeLog.codito
@@ -0,0 +1,16 @@
+2006-03-03  Ashwin Pathmudi  <ashwin.pathmudi@codito.com>
+
+	* arc-dis.c (a4AnalyzeInstr): New. Disassembler function
+	called by gdb for the a4 core.  
+
+2005-03-30  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* arcompact-dis.c(dsmOneArcInst): Update ARC register information
+	for the debugger.
+	* include/opcode/arc.h: Update struct arcDisState to contain
+	information about the targets of operands.
+
+2005-03-07  Ramana Radhakrishnan  <ramana.radhakrishnan@codito.com>
+
+	* arcompact-dis.c(dsmOneArcInst):Update address
+	writeback for the debugger. 
diff --git a/opcodes/arc-asm.c b/opcodes/arc-asm.c
new file mode 100644
index 0000000..498a7fd
--- /dev/null
+++ b/opcodes/arc-asm.c
@@ -0,0 +1,898 @@
+/* Assembler interface for targets using CGEN. -*- C -*-
+   CGEN: Cpu tools GENerator
+
+   THIS FILE IS MACHINE GENERATED WITH CGEN.
+   - the resultant file is machine generated, cgen-asm.in isn't
+
+   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2005, 2007
+   Free Software Foundation, Inc.
+
+   This file is part of libopcodes.
+
+   This library is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   It is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or FITNESS FOR A PARTICULAR PURPOSE.  See the 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.,
+   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
+
+
+/* ??? Eventually more and more of this stuff can go to cpu-independent files.
+   Keep that in mind.  */
+
+#include "sysdep.h"
+#include <stdio.h>
+#include "ansidecl.h"
+#include "bfd.h"
+#include "symcat.h"
+#include "arc-desc.h"
+#include "arc-opc.h"
+#include "opintl.h"
+#include "xregex.h"
+#include "libiberty.h"
+#include "safe-ctype.h"
+
+#undef  min
+#define min(a,b) ((a) < (b) ? (a) : (b))
+#undef  max
+#define max(a,b) ((a) > (b) ? (a) : (b))
+
+static const char * parse_insn_normal
+  (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *);
+
+/* -- assembler routines inserted here.  */
+
+/* -- asm.c */
+#if 0
+static const char * MISSING_CLOSING_PARENTHESIS = N_("missing `)'");
+
+/* Handle '#' prefixes (i.e. skip over them).  */
+
+static const char *
+parse_hash (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+	    const char **strp,
+	    int opindex ATTRIBUTE_UNUSED,
+	    long *valuep ATTRIBUTE_UNUSED)
+{
+  if (**strp == '#')
+    ++*strp;
+  return NULL;
+}
+
+/* Handle shigh(), high().  */
+
+static const char *
+parse_hi16 (CGEN_CPU_DESC cd,
+	    const char **strp,
+	    int opindex,
+	    unsigned long *valuep)
+{
+  const char *errmsg;
+  enum cgen_parse_operand_result result_type;
+  bfd_vma value;
+
+  if (**strp == '#')
+    ++*strp;
+
+  if (strncasecmp (*strp, "high(", 5) == 0)
+    {
+      *strp += 5;
+      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_HI16_ULO,
+				   & result_type, & value);
+      if (**strp != ')')
+	return MISSING_CLOSING_PARENTHESIS;
+      ++*strp;
+      if (errmsg == NULL
+  	  && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+	{
+	  value >>= 16;
+	  value &= 0xffff;
+	}
+      *valuep = value;
+      return errmsg;
+    }
+  else if (strncasecmp (*strp, "shigh(", 6) == 0)
+    {
+      *strp += 6;
+      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_HI16_SLO,
+ 				   & result_type, & value);
+      if (**strp != ')')
+	return MISSING_CLOSING_PARENTHESIS;
+      ++*strp;
+      if (errmsg == NULL
+	  && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+        {
+          value += 0x8000;
+          value >>= 16;
+	  value &= 0xffff;
+        }
+      *valuep = value;
+      return errmsg;
+    }
+
+  return cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
+}
+
+/* Handle low() in a signed context.  Also handle sda().
+   The signedness of the value doesn't matter to low(), but this also
+   handles the case where low() isn't present.  */
+
+static const char *
+parse_slo16 (CGEN_CPU_DESC cd,
+	     const char ** strp,
+	     int opindex,
+	     long * valuep)
+{
+  const char *errmsg;
+  enum cgen_parse_operand_result result_type;
+  bfd_vma value;
+
+  if (**strp == '#')
+    ++*strp;
+
+  if (strncasecmp (*strp, "low(", 4) == 0)
+    {
+      *strp += 4;
+      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_LO16,
+				   & result_type, & value);
+      if (**strp != ')')
+	return MISSING_CLOSING_PARENTHESIS;
+      ++*strp;
+      if (errmsg == NULL
+	  && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+	value = ((value & 0xffff) ^ 0x8000) - 0x8000;
+      *valuep = value;
+      return errmsg;
+    }
+
+  if (strncasecmp (*strp, "sda(", 4) == 0)
+    {
+      *strp += 4;
+      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_SDA16,
+				   NULL, & value);
+      if (**strp != ')')
+	return MISSING_CLOSING_PARENTHESIS;
+      ++*strp;
+      *valuep = value;
+      return errmsg;
+    }
+
+  return cgen_parse_signed_integer (cd, strp, opindex, valuep);
+}
+
+/* Handle low() in an unsigned context.
+   The signedness of the value doesn't matter to low(), but this also
+   handles the case where low() isn't present.  */
+
+static const char *
+parse_ulo16 (CGEN_CPU_DESC cd,
+	     const char **strp,
+	     int opindex,
+	     unsigned long *valuep)
+{
+  const char *errmsg;
+  enum cgen_parse_operand_result result_type;
+  bfd_vma value;
+
+  if (**strp == '#')
+    ++*strp;
+
+  if (strncasecmp (*strp, "low(", 4) == 0)
+    {
+      *strp += 4;
+      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_LO16,
+				   & result_type, & value);
+      if (**strp != ')')
+	return MISSING_CLOSING_PARENTHESIS;
+      ++*strp;
+      if (errmsg == NULL
+	  && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+	value &= 0xffff;
+      *valuep = value;
+      return errmsg;
+    }
+
+  return cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
+}
+#endif
+
+/* -- */
+
+const char * arc_cgen_parse_operand
+  (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
+
+/* Main entry point for operand parsing.
+
+   This function is basically just a big switch statement.  Earlier versions
+   used tables to look up the function to use, but
+   - if the table contains both assembler and disassembler functions then
+     the disassembler contains much of the assembler and vice-versa,
+   - there's a lot of inlining possibilities as things grow,
+   - using a switch statement avoids the function call overhead.
+
+   This function could be moved into `parse_insn_normal', but keeping it
+   separate makes clear the interface between `parse_insn_normal' and each of
+   the handlers.  */
+
+const char *
+arc_cgen_parse_operand (CGEN_CPU_DESC cd,
+			   int opindex,
+			   const char ** strp,
+			   CGEN_FIELDS * fields)
+{
+  const char * errmsg = NULL;
+  /* Used by scalar operands that still need to be parsed.  */
+  long junk ATTRIBUTE_UNUSED;
+
+  switch (opindex)
+    {
+    case ARC_OPERAND_EXDI :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_Di, & fields->f_F);
+      break;
+    case ARC_OPERAND_F :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_uflags, & fields->f_F);
+      break;
+    case ARC_OPERAND_F0 :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_nil, & fields->f_F);
+      break;
+    case ARC_OPERAND_F1 :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_auflags, & fields->f_F);
+      break;
+    case ARC_OPERAND_F1F :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_aufflags, & fields->f_F);
+      break;
+    case ARC_OPERAND_GP :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_gp, & junk);
+      break;
+    case ARC_OPERAND_LDODI :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_Di, & fields->f_LDODi);
+      break;
+    case ARC_OPERAND_LDRDI :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_Di, & fields->f_LDRDi);
+      break;
+    case ARC_OPERAND_NE :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_ne, & junk);
+      break;
+    case ARC_OPERAND_PCL :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_pcl, & junk);
+      break;
+    case ARC_OPERAND_QCONDB :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_Qcondb, & fields->f_cond_Q);
+      break;
+    case ARC_OPERAND_QCONDI :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_Qcondi, & fields->f_cond_Q);
+      break;
+    case ARC_OPERAND_QCONDJ :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_Qcondj, & fields->f_cond_Q);
+      break;
+    case ARC_OPERAND_R0 :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_r0, & junk);
+      break;
+    case ARC_OPERAND_R31 :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_r31, & junk);
+      break;
+    case ARC_OPERAND_RA :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_cr_names, & fields->f_op_A);
+      break;
+    case ARC_OPERAND_RA_0 :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_nil, & fields->f_op_A);
+      break;
+    case ARC_OPERAND_RB :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_cr_names, & fields->f_op_B);
+      break;
+    case ARC_OPERAND_RB_0 :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_nil, & fields->f_op_B);
+      break;
+    case ARC_OPERAND_RC :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_cr_names, & fields->f_op_C);
+      break;
+    case ARC_OPERAND_RC_ILINK :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_ilinkx, & fields->f_op_Cj);
+      break;
+    case ARC_OPERAND_RC_NOILINK :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_noilink, & fields->f_op_Cj);
+      break;
+    case ARC_OPERAND_R_A :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_cr16, & fields->f_op__a);
+      break;
+    case ARC_OPERAND_R_B :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_cr16, & fields->f_op__b);
+      break;
+    case ARC_OPERAND_R_C :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_cr16, & fields->f_op__c);
+      break;
+    case ARC_OPERAND_RCC :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_Rcc, & fields->f_brcond);
+      break;
+    case ARC_OPERAND_RCCS :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_RccS, & fields->f_brscond);
+      break;
+    case ARC_OPERAND_RH :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_cr_names, & fields->f_op_h);
+      break;
+    case ARC_OPERAND_SP :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_sp, & junk);
+      break;
+    case ARC_OPERAND_STODI :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_Di, & fields->f_STODi);
+      break;
+    case ARC_OPERAND_U6 :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_U6, (unsigned long *) (& fields->f_u6));
+      break;
+    case ARC_OPERAND_U6X2 :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_U6X2, (unsigned long *) (& fields->f_u6x2));
+      break;
+    case ARC_OPERAND__AW :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h__aw, & junk);
+      break;
+    case ARC_OPERAND__L :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_insn32, & junk);
+      break;
+    case ARC_OPERAND__S :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_insn16, & junk);
+      break;
+    case ARC_OPERAND_CBIT :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_CBIT, (unsigned long *) (& junk));
+      break;
+    case ARC_OPERAND_DELAY_N :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_delay, & fields->f_delay_N);
+      break;
+    case ARC_OPERAND_DUMMY_OP :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_DUMMY_OP, (unsigned long *) (& fields->f_dummy));
+      break;
+    case ARC_OPERAND_I2COND :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_i2cond, & fields->f_cond_i2);
+      break;
+    case ARC_OPERAND_I3COND :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_i3cond, & fields->f_cond_i3);
+      break;
+    case ARC_OPERAND_LABEL10 :
+      {
+        bfd_vma value = 0;
+        errmsg = cgen_parse_address (cd, strp, ARC_OPERAND_LABEL10, 0, NULL,  & value);
+        fields->f_rel10 = value;
+      }
+      break;
+    case ARC_OPERAND_LABEL13A :
+      {
+        bfd_vma value = 0;
+        errmsg = cgen_parse_address (cd, strp, ARC_OPERAND_LABEL13A, 0, NULL,  & value);
+        fields->f_rel13bl = value;
+      }
+      break;
+    case ARC_OPERAND_LABEL21 :
+      {
+        bfd_vma value = 0;
+        errmsg = cgen_parse_address (cd, strp, ARC_OPERAND_LABEL21, 0, NULL,  & value);
+        fields->f_rel21 = value;
+      }
+      break;
+    case ARC_OPERAND_LABEL21A :
+      {
+        bfd_vma value = 0;
+        errmsg = cgen_parse_address (cd, strp, ARC_OPERAND_LABEL21A, 0, NULL,  & value);
+        fields->f_rel21bl = value;
+      }
+      break;
+    case ARC_OPERAND_LABEL25 :
+      {
+        bfd_vma value = 0;
+        errmsg = cgen_parse_address (cd, strp, ARC_OPERAND_LABEL25, 0, NULL,  & value);
+        fields->f_rel25 = value;
+      }
+      break;
+    case ARC_OPERAND_LABEL25A :
+      {
+        bfd_vma value = 0;
+        errmsg = cgen_parse_address (cd, strp, ARC_OPERAND_LABEL25A, 0, NULL,  & value);
+        fields->f_rel25bl = value;
+      }
+      break;
+    case ARC_OPERAND_LABEL7 :
+      {
+        bfd_vma value = 0;
+        errmsg = cgen_parse_address (cd, strp, ARC_OPERAND_LABEL7, 0, NULL,  & value);
+        fields->f_rel7 = value;
+      }
+      break;
+    case ARC_OPERAND_LABEL8 :
+      {
+        bfd_vma value = 0;
+        errmsg = cgen_parse_address (cd, strp, ARC_OPERAND_LABEL8, 0, NULL,  & value);
+        fields->f_rel8 = value;
+      }
+      break;
+    case ARC_OPERAND_LABEL9 :
+      {
+        bfd_vma value = 0;
+        errmsg = cgen_parse_address (cd, strp, ARC_OPERAND_LABEL9, 0, NULL,  & value);
+        fields->f_rel9 = value;
+      }
+      break;
+    case ARC_OPERAND_LBIT :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_LBIT, (unsigned long *) (& junk));
+      break;
+    case ARC_OPERAND_NBIT :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_NBIT, (unsigned long *) (& junk));
+      break;
+    case ARC_OPERAND_S12 :
+      errmsg = cgen_parse_signed_integer (cd, strp, ARC_OPERAND_S12, (long *) (& fields->f_s12));
+      break;
+    case ARC_OPERAND_S12X2 :
+      errmsg = cgen_parse_signed_integer (cd, strp, ARC_OPERAND_S12X2, (long *) (& fields->f_s12x2));
+      break;
+    case ARC_OPERAND_S1BIT :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_S1BIT, (unsigned long *) (& junk));
+      break;
+    case ARC_OPERAND_S2BIT :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_S2BIT, (unsigned long *) (& junk));
+      break;
+    case ARC_OPERAND_S9 :
+      errmsg = cgen_parse_signed_integer (cd, strp, ARC_OPERAND_S9, (long *) (& fields->f_s9));
+      break;
+    case ARC_OPERAND_S9X4 :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_S9X4, (unsigned long *) (& fields->f_s9x4));
+      break;
+    case ARC_OPERAND_SC_S9_ :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_SC_S9_, (unsigned long *) (& fields->f_s9x4));
+      break;
+    case ARC_OPERAND_SC_S9B :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_SC_S9B, (unsigned long *) (& fields->f_s9x1));
+      break;
+    case ARC_OPERAND_SC_S9W :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_SC_S9W, (unsigned long *) (& fields->f_s9x2));
+      break;
+    case ARC_OPERAND_SC_U5_ :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_SC_U5_, (unsigned long *) (& fields->f_u5x4));
+      break;
+    case ARC_OPERAND_SC_U5B :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_SC_U5B, (unsigned long *) (& fields->f_u5));
+      break;
+    case ARC_OPERAND_SC_U5W :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_SC_U5W, (unsigned long *) (& fields->f_u5x2));
+      break;
+    case ARC_OPERAND_TRAPNUM :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_TRAPNUM, (unsigned long *) (& fields->f_trapnum));
+      break;
+    case ARC_OPERAND_U3 :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_U3, (unsigned long *) (& fields->f_u3));
+      break;
+    case ARC_OPERAND_U5 :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_U5, (unsigned long *) (& fields->f_u5));
+      break;
+    case ARC_OPERAND_U5X4 :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_U5X4, (unsigned long *) (& fields->f_u5x4));
+      break;
+    case ARC_OPERAND_U7 :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_U7, (unsigned long *) (& fields->f_u7));
+      break;
+    case ARC_OPERAND_U8 :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_U8, (unsigned long *) (& fields->f_u8));
+      break;
+    case ARC_OPERAND_U8X4 :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_U8X4, (unsigned long *) (& fields->f_u8x4));
+      break;
+    case ARC_OPERAND_UNCONDB :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_uncondb, & junk);
+      break;
+    case ARC_OPERAND_UNCONDI :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_uncondi, & junk);
+      break;
+    case ARC_OPERAND_UNCONDJ :
+      errmsg = cgen_parse_keyword (cd, strp, & arc_cgen_opval_h_uncondj, & junk);
+      break;
+    case ARC_OPERAND_VBIT :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_VBIT, (unsigned long *) (& junk));
+      break;
+    case ARC_OPERAND_ZBIT :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, ARC_OPERAND_ZBIT, (unsigned long *) (& junk));
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex);
+      abort ();
+  }
+
+  return errmsg;
+}
+
+cgen_parse_fn * const arc_cgen_parse_handlers[] = 
+{
+  parse_insn_normal,
+};
+
+void
+arc_cgen_init_asm (CGEN_CPU_DESC cd)
+{
+  arc_cgen_init_opcode_table (cd);
+  arc_cgen_init_ibld_table (cd);
+  cd->parse_handlers = & arc_cgen_parse_handlers[0];
+  cd->parse_operand = arc_cgen_parse_operand;
+#ifdef CGEN_ASM_INIT_HOOK
+CGEN_ASM_INIT_HOOK
+#endif
+}
+
+
+
+/* Regex construction routine.
+
+   This translates an opcode syntax string into a regex string,
+   by replacing any non-character syntax element (such as an
+   opcode) with the pattern '.*'
+
+   It then compiles the regex and stores it in the opcode, for
+   later use by arc_cgen_assemble_insn
+
+   Returns NULL for success, an error message for failure.  */
+
+char * 
+arc_cgen_build_insn_regex (CGEN_INSN *insn)
+{  
+  CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
+  const char *mnem = CGEN_INSN_MNEMONIC (insn);
+  char rxbuf[CGEN_MAX_RX_ELEMENTS];
+  char *rx = rxbuf;
+  const CGEN_SYNTAX_CHAR_TYPE *syn;
+  int reg_err;
+
+  syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
+
+  /* Mnemonics come first in the syntax string.  */
+  if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
+    return _("missing mnemonic in syntax string");
+  ++syn;
+
+  /* Generate a case sensitive regular expression that emulates case
+     insensitive matching in the "C" locale.  We cannot generate a case
+     insensitive regular expression because in Turkish locales, 'i' and 'I'
+     are not equal modulo case conversion.  */
+
+  /* Copy the literal mnemonic out of the insn.  */
+  for (; *mnem; mnem++)
+    {
+      char c = *mnem;
+
+      if (ISALPHA (c))
+	{
+	  *rx++ = '[';
+	  *rx++ = TOLOWER (c);
+	  *rx++ = TOUPPER (c);
+	  *rx++ = ']';
+	}
+      else
+	*rx++ = c;
+    }
+
+  /* Copy any remaining literals from the syntax string into the rx.  */
+  for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
+    {
+      if (CGEN_SYNTAX_CHAR_P (* syn)) 
+	{
+	  char c = CGEN_SYNTAX_CHAR (* syn);
+
+	  switch (c) 
+	    {
+	      /* Escape any regex metacharacters in the syntax.  */
+	    case '.': case '[': case '\\': 
+	    case '*': case '^': case '$': 
+
+#ifdef CGEN_ESCAPE_EXTENDED_REGEX
+	    case '?': case '{': case '}': 
+	    case '(': case ')': case '*':
+	    case '|': case '+': case ']':
+#endif
+	      *rx++ = '\\';
+	      *rx++ = c;
+	      break;
+
+	    default:
+	      if (ISALPHA (c))
+		{
+		  *rx++ = '[';
+		  *rx++ = TOLOWER (c);
+		  *rx++ = TOUPPER (c);
+		  *rx++ = ']';
+		}
+	      else
+		*rx++ = c;
+	      break;
+	    }
+	}
+      else
+	{
+	  /* Replace non-syntax fields with globs.  */
+	  *rx++ = '.';
+	  *rx++ = '*';
+	}
+    }
+
+  /* Trailing whitespace ok.  */
+  * rx++ = '['; 
+  * rx++ = ' '; 
+  * rx++ = '\t'; 
+  * rx++ = ']'; 
+  * rx++ = '*'; 
+
+  /* But anchor it after that.  */
+  * rx++ = '$'; 
+  * rx = '\0';
+
+  CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
+  reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
+
+  if (reg_err == 0) 
+    return NULL;
+  else
+    {
+      static char msg[80];
+
+      regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
+      regfree ((regex_t *) CGEN_INSN_RX (insn));
+      free (CGEN_INSN_RX (insn));
+      (CGEN_INSN_RX (insn)) = NULL;
+      return msg;
+    }
+}
+
+
+/* Default insn parser.
+
+   The syntax string is scanned and operands are parsed and stored in FIELDS.
+   Relocs are queued as we go via other callbacks.
+
+   ??? Note that this is currently an all-or-nothing parser.  If we fail to
+   parse the instruction, we return 0 and the caller will start over from
+   the beginning.  Backtracking will be necessary in parsing subexpressions,
+   but that can be handled there.  Not handling backtracking here may get
+   expensive in the case of the m68k.  Deal with later.
+
+   Returns NULL for success, an error message for failure.  */
+
+static const char *
+parse_insn_normal (CGEN_CPU_DESC cd,
+		   const CGEN_INSN *insn,
+		   const char **strp,
+		   CGEN_FIELDS *fields)
+{
+  /* ??? Runtime added insns not handled yet.  */
+  const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
+  const char *str = *strp;
+  const char *errmsg;
+  const char *p;
+  const CGEN_SYNTAX_CHAR_TYPE * syn;
+#ifdef CGEN_MNEMONIC_OPERANDS
+  /* FIXME: wip */
+  int past_opcode_p;
+#endif
+
+  /* For now we assume the mnemonic is first (there are no leading operands).
+     We can parse it without needing to set up operand parsing.
+     GAS's input scrubber will ensure mnemonics are lowercase, but we may
+     not be called from GAS.  */
+  p = CGEN_INSN_MNEMONIC (insn);
+  while (*p && TOLOWER (*p) == TOLOWER (*str))
+    ++p, ++str;
+
+  if (* p)
+    return _("unrecognized instruction");
+
+#ifndef CGEN_MNEMONIC_OPERANDS
+  if (* str && ! ISSPACE (* str))
+    return _("unrecognized instruction");
+#endif
+
+  CGEN_INIT_PARSE (cd);
+  cgen_init_parse_operand (cd);
+#ifdef CGEN_MNEMONIC_OPERANDS
+  past_opcode_p = 0;
+#endif
+
+  /* We don't check for (*str != '\0') here because we want to parse
+     any trailing fake arguments in the syntax string.  */
+  syn = CGEN_SYNTAX_STRING (syntax);
+
+  /* Mnemonics come first for now, ensure valid string.  */
+  if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
+    abort ();
+
+  ++syn;
+
+  while (* syn != 0)
+    {
+      /* Non operand chars must match exactly.  */
+      if (CGEN_SYNTAX_CHAR_P (* syn))
+	{
+	  /* FIXME: While we allow for non-GAS callers above, we assume the
+	     first char after the mnemonic part is a space.  */
+	  /* FIXME: We also take inappropriate advantage of the fact that
+	     GAS's input scrubber will remove extraneous blanks.  */
+	  if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+	    {
+#ifdef CGEN_MNEMONIC_OPERANDS
+	      if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+		past_opcode_p = 1;
+#endif
+	      ++ syn;
+	      ++ str;
+	    }
+	  else if (*str)
+	    {
+	      /* Syntax char didn't match.  Can't be this insn.  */
+	      static char msg [80];
+
+	      /* xgettext:c-format */
+	      sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
+		       CGEN_SYNTAX_CHAR(*syn), *str);
+	      return msg;
+	    }
+	  else
+	    {
+	      /* Ran out of input.  */
+	      static char msg [80];
+
+	      /* xgettext:c-format */
+	      sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
+		       CGEN_SYNTAX_CHAR(*syn));
+	      return msg;
+	    }
+	  continue;
+	}
+
+      /* We have an operand of some sort.  */
+      errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
+					  &str, fields);
+      if (errmsg)
+	return errmsg;
+
+      /* Done with this operand, continue with next one.  */
+      ++ syn;
+    }
+
+  /* If we're at the end of the syntax string, we're done.  */
+  if (* syn == 0)
+    {
+      /* FIXME: For the moment we assume a valid `str' can only contain
+	 blanks now.  IE: We needn't try again with a longer version of
+	 the insn and it is assumed that longer versions of insns appear
+	 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
+      while (ISSPACE (* str))
+	++ str;
+
+      if (* str != '\0')
+	return _("junk at end of line"); /* FIXME: would like to include `str' */
+
+      return NULL;
+    }
+
+  /* We couldn't parse it.  */
+  return _("unrecognized instruction");
+}
+
+/* Main entry point.
+   This routine is called for each instruction to be assembled.
+   STR points to the insn to be assembled.
+   We assume all necessary tables have been initialized.
+   The assembled instruction, less any fixups, is stored in BUF.
+   Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
+   still needs to be converted to target byte order, otherwise BUF is an array
+   of bytes in target byte order.
+   The result is a pointer to the insn's entry in the opcode table,
+   or NULL if an error occured (an error message will have already been
+   printed).
+
+   Note that when processing (non-alias) macro-insns,
+   this function recurses.
+
+   ??? It's possible to make this cpu-independent.
+   One would have to deal with a few minor things.
+   At this point in time doing so would be more of a curiosity than useful
+   [for example this file isn't _that_ big], but keeping the possibility in
+   mind helps keep the design clean.  */
+
+const CGEN_INSN *
+arc_cgen_assemble_insn (CGEN_CPU_DESC cd,
+			   const char *str,
+			   CGEN_FIELDS *fields,
+			   CGEN_INSN_BYTES_PTR buf,
+			   char **errmsg)
+{
+  const char *start;
+  CGEN_INSN_LIST *ilist;
+  const char *parse_errmsg = NULL;
+  const char *insert_errmsg = NULL;
+  int recognized_mnemonic = 0;
+
+  /* Skip leading white space.  */
+  while (ISSPACE (* str))
+    ++ str;
+
+  /* The instructions are stored in hashed lists.
+     Get the first in the list.  */
+  ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
+
+  /* Keep looking until we find a match.  */
+  start = str;
+  for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
+    {
+      const CGEN_INSN *insn = ilist->insn;
+      recognized_mnemonic = 1;
+
+#ifdef CGEN_VALIDATE_INSN_SUPPORTED 
+      /* Not usually needed as unsupported opcodes
+	 shouldn't be in the hash lists.  */
+      /* Is this insn supported by the selected cpu?  */
+      if (! arc_cgen_insn_supported (cd, insn))
+	continue;
+#endif
+      /* If the RELAXED attribute is set, this is an insn that shouldn't be
+	 chosen immediately.  Instead, it is used during assembler/linker
+	 relaxation if possible.  */
+      if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
+	continue;
+
+      str = start;
+
+      /* Skip this insn if str doesn't look right lexically.  */
+      if (CGEN_INSN_RX (insn) != NULL &&
+	  regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
+	continue;
+
+      /* Allow parse/insert handlers to obtain length of insn.  */
+      CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
+
+      parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
+      if (parse_errmsg != NULL)
+	continue;
+
+      /* ??? 0 is passed for `pc'.  */
+      insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
+						 (bfd_vma) 0);
+      if (insert_errmsg != NULL)
+        continue;
+
+      /* It is up to the caller to actually output the insn and any
+         queued relocs.  */
+      return insn;
+    }
+
+  {
+    static char errbuf[150];
+#ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
+    const char *tmp_errmsg;
+
+    /* If requesting verbose error messages, use insert_errmsg.
+       Failing that, use parse_errmsg.  */
+    tmp_errmsg = (insert_errmsg ? insert_errmsg :
+		  parse_errmsg ? parse_errmsg :
+		  recognized_mnemonic ?
+		  _("unrecognized form of instruction") :
+		  _("unrecognized instruction"));
+
+    if (strlen (start) > 50)
+      /* xgettext:c-format */
+      sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
+    else 
+      /* xgettext:c-format */
+      sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
+#else
+    if (strlen (start) > 50)
+      /* xgettext:c-format */
+      sprintf (errbuf, _("bad instruction `%.50s...'"), start);
+    else 
+      /* xgettext:c-format */
+      sprintf (errbuf, _("bad instruction `%.50s'"), start);
+#endif
+      
+    *errmsg = errbuf;
+    return NULL;
+  }
+}
diff --git a/opcodes/arc-desc.c b/opcodes/arc-desc.c
new file mode 100644
index 0000000..006b6eb
--- /dev/null
+++ b/opcodes/arc-desc.c
@@ -0,0 +1,4057 @@
+/* CPU data for arc.
+
+THIS FILE IS MACHINE GENERATED WITH CGEN.
+
+Copyright 1996-2007 Free Software Foundation, Inc.
+
+This file is part of the GNU Binutils and/or GDB, the GNU debugger.
+
+   This file is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   It is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or FITNESS FOR A PARTICULAR PURPOSE.  See the 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.,
+   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
+
+*/
+
+#include "sysdep.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include "ansidecl.h"
+#include "bfd.h"
+#include "symcat.h"
+#include "arc-desc.h"
+#include "arc-opc.h"
+#include "opintl.h"
+#include "libiberty.h"
+#include "xregex.h"
+
+/* Attributes.  */
+
+static const CGEN_ATTR_ENTRY bool_attr[] =
+{
+  { "#f", 0 },
+  { "#t", 1 },
+  { 0, 0 }
+};
+
+static const CGEN_ATTR_ENTRY MACH_attr[] ATTRIBUTE_UNUSED =
+{
+  { "base", MACH_BASE },
+  { "a5", MACH_A5 },
+  { "arc600", MACH_ARC600 },
+  { "arc700", MACH_ARC700 },
+  { "max", MACH_MAX },
+  { 0, 0 }
+};
+
+static const CGEN_ATTR_ENTRY ISA_attr[] ATTRIBUTE_UNUSED =
+{
+  { "ARCompact", ISA_ARCOMPACT },
+  { "max", ISA_MAX },
+  { 0, 0 }
+};
+
+static const CGEN_ATTR_ENTRY LIMM_attr[] ATTRIBUTE_UNUSED =
+{
+  { "none", LIMM_NONE },
+  { "h", LIMM_H },
+  { "B", LIMM_B },
+  { "BC", LIMM_BC },
+  { "C", LIMM_C },
+  { 0, 0 }
+};
+
+const CGEN_ATTR_TABLE arc_cgen_ifield_attr_table[] =
+{
+  { "MACH", & MACH_attr[0], & MACH_attr[0] },
+  { "VIRTUAL", &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 }
+};
+
+const CGEN_ATTR_TABLE arc_cgen_hardware_attr_table[] =
+{
+  { "MACH", & MACH_attr[0], & MACH_attr[0] },
+  { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
+  { "CACHE-ADDR", &bool_attr[0], &bool_attr[0] },
+  { "PC", &bool_attr[0], &bool_attr[0] },
+  { "PROFILE", &bool_attr[0], &bool_attr[0] },
+  { 0, 0, 0 }
+};
+
+const CGEN_ATTR_TABLE arc_cgen_operand_attr_table[] =
+{
+  { "MACH", & MACH_attr[0], & MACH_attr[0] },
+  { "VIRTUAL", &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] },
+  { 0, 0, 0 }
+};
+
+const CGEN_ATTR_TABLE arc_cgen_insn_attr_table[] =
+{
+  { "MACH", & MACH_attr[0], & MACH_attr[0] },
+  { "LIMM", & LIMM_attr[0], & LIMM_attr[0] },
+  { "ALIAS", &bool_attr[0], &bool_attr[0] },
+  { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
+  { "UNCOND-CTI", &bool_attr[0], &bool_attr[0] },
+  { "COND-CTI", &bool_attr[0], &bool_attr[0] },
+  { "SKIP-CTI", &bool_attr[0], &bool_attr[0] },
+  { "DELAY-SLOT", &bool_attr[0], &bool_attr[0] },
+  { "RELAXABLE", &bool_attr[0], &bool_attr[0] },
+  { "RELAXED", &bool_attr[0], &bool_attr[0] },
+  { "NO-DIS", &bool_attr[0], &bool_attr[0] },
+  { "PBB", &bool_attr[0], &bool_attr[0] },
+  { "SHORT_P", &bool_attr[0], &bool_attr[0] },
+  { 0, 0, 0 }
+};
+
+/* Instruction set variants.  */
+
+static const CGEN_ISA arc_cgen_isa_table[] = {
+  { "ARCompact", 32, 32, 32, 32 },
+  { 0, 0, 0, 0, 0 }
+};
+
+/* Machine variants.  */
+
+static const CGEN_MACH arc_cgen_mach_table[] = {
+  { "a5", "A5", MACH_A5, 16 },
+  { "arc600", "ARC600", MACH_ARC600, 16 },
+  { "arc700", "ARC700", MACH_ARC700, 16 },
+  { 0, 0, 0, 0 }
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_cr_names_entries[] =
+{
+  { "gp", 26, {0, {{{0, 0}}}}, 0, 0 },
+  { "fp", 27, {0, {{{0, 0}}}}, 0, 0 },
+  { "sp", 28, {0, {{{0, 0}}}}, 0, 0 },
+  { "blink", 31, {0, {{{0, 0}}}}, 0, 0 },
+  { "mlo", 57, {0, {{{0, 0}}}}, 0, 0 },
+  { "mmid", 58, {0, {{{0, 0}}}}, 0, 0 },
+  { "mhi", 59, {0, {{{0, 0}}}}, 0, 0 },
+  { "lp_count", 60, {0, {{{0, 0}}}}, 0, 0 },
+  { "pcl", 63, {0, {{{0, 0}}}}, 0, 0 },
+  { "ilink1", 29, {0, {{{0, 0}}}}, 0, 0 },
+  { "ilink2", 30, {0, {{{0, 0}}}}, 0, 0 },
+  { "r29", 29, {0, {{{0, 0}}}}, 0, 0 },
+  { "r30", 30, {0, {{{0, 0}}}}, 0, 0 },
+  { "r0", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "r1", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { "r2", 2, {0, {{{0, 0}}}}, 0, 0 },
+  { "r3", 3, {0, {{{0, 0}}}}, 0, 0 },
+  { "r4", 4, {0, {{{0, 0}}}}, 0, 0 },
+  { "r5", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "r6", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { "r7", 7, {0, {{{0, 0}}}}, 0, 0 },
+  { "r8", 8, {0, {{{0, 0}}}}, 0, 0 },
+  { "r9", 9, {0, {{{0, 0}}}}, 0, 0 },
+  { "r10", 10, {0, {{{0, 0}}}}, 0, 0 },
+  { "r11", 11, {0, {{{0, 0}}}}, 0, 0 },
+  { "r12", 12, {0, {{{0, 0}}}}, 0, 0 },
+  { "r13", 13, {0, {{{0, 0}}}}, 0, 0 },
+  { "r14", 14, {0, {{{0, 0}}}}, 0, 0 },
+  { "r15", 15, {0, {{{0, 0}}}}, 0, 0 },
+  { "r16", 16, {0, {{{0, 0}}}}, 0, 0 },
+  { "r17", 17, {0, {{{0, 0}}}}, 0, 0 },
+  { "r18", 18, {0, {{{0, 0}}}}, 0, 0 },
+  { "r19", 19, {0, {{{0, 0}}}}, 0, 0 },
+  { "r20", 20, {0, {{{0, 0}}}}, 0, 0 },
+  { "r21", 21, {0, {{{0, 0}}}}, 0, 0 },
+  { "r22", 22, {0, {{{0, 0}}}}, 0, 0 },
+  { "r23", 23, {0, {{{0, 0}}}}, 0, 0 },
+  { "r24", 24, {0, {{{0, 0}}}}, 0, 0 },
+  { "r25", 25, {0, {{{0, 0}}}}, 0, 0 },
+  { "r26", 26, {0, {{{0, 0}}}}, 0, 0 },
+  { "r27", 27, {0, {{{0, 0}}}}, 0, 0 },
+  { "r28", 28, {0, {{{0, 0}}}}, 0, 0 },
+  { "r31", 31, {0, {{{0, 0}}}}, 0, 0 },
+  { "r32", 32, {0, {{{0, 0}}}}, 0, 0 },
+  { "r33", 33, {0, {{{0, 0}}}}, 0, 0 },
+  { "r34", 34, {0, {{{0, 0}}}}, 0, 0 },
+  { "r35", 35, {0, {{{0, 0}}}}, 0, 0 },
+  { "r36", 36, {0, {{{0, 0}}}}, 0, 0 },
+  { "r37", 37, {0, {{{0, 0}}}}, 0, 0 },
+  { "r38", 38, {0, {{{0, 0}}}}, 0, 0 },
+  { "r39", 39, {0, {{{0, 0}}}}, 0, 0 },
+  { "r40", 40, {0, {{{0, 0}}}}, 0, 0 },
+  { "r41", 41, {0, {{{0, 0}}}}, 0, 0 },
+  { "r42", 42, {0, {{{0, 0}}}}, 0, 0 },
+  { "r43", 43, {0, {{{0, 0}}}}, 0, 0 },
+  { "r44", 44, {0, {{{0, 0}}}}, 0, 0 },
+  { "r45", 45, {0, {{{0, 0}}}}, 0, 0 },
+  { "r46", 46, {0, {{{0, 0}}}}, 0, 0 },
+  { "r47", 47, {0, {{{0, 0}}}}, 0, 0 },
+  { "r48", 48, {0, {{{0, 0}}}}, 0, 0 },
+  { "r49", 49, {0, {{{0, 0}}}}, 0, 0 },
+  { "r50", 50, {0, {{{0, 0}}}}, 0, 0 },
+  { "r51", 51, {0, {{{0, 0}}}}, 0, 0 },
+  { "r52", 52, {0, {{{0, 0}}}}, 0, 0 },
+  { "r53", 53, {0, {{{0, 0}}}}, 0, 0 },
+  { "r54", 54, {0, {{{0, 0}}}}, 0, 0 },
+  { "r55", 55, {0, {{{0, 0}}}}, 0, 0 },
+  { "r56", 56, {0, {{{0, 0}}}}, 0, 0 },
+  { "r57", 57, {0, {{{0, 0}}}}, 0, 0 },
+  { "r58", 58, {0, {{{0, 0}}}}, 0, 0 },
+  { "r59", 59, {0, {{{0, 0}}}}, 0, 0 },
+  { "r60", 60, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_cr_names =
+{
+  & arc_cgen_opval_cr_names_entries[0],
+  72,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_Qcondb_entries[] =
+{
+  { "", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "ra", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "al", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "eq", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { "z", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { "ne", 2, {0, {{{0, 0}}}}, 0, 0 },
+  { "nz", 2, {0, {{{0, 0}}}}, 0, 0 },
+  { "pl", 3, {0, {{{0, 0}}}}, 0, 0 },
+  { "p", 3, {0, {{{0, 0}}}}, 0, 0 },
+  { "mi", 4, {0, {{{0, 0}}}}, 0, 0 },
+  { "n", 4, {0, {{{0, 0}}}}, 0, 0 },
+  { "cs", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "c", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "lo", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "cc", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { "nc", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { "hs", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { "vs", 7, {0, {{{0, 0}}}}, 0, 0 },
+  { "v", 7, {0, {{{0, 0}}}}, 0, 0 },
+  { "vc", 8, {0, {{{0, 0}}}}, 0, 0 },
+  { "nv", 8, {0, {{{0, 0}}}}, 0, 0 },
+  { "gt", 9, {0, {{{0, 0}}}}, 0, 0 },
+  { "ge", 10, {0, {{{0, 0}}}}, 0, 0 },
+  { "lt", 11, {0, {{{0, 0}}}}, 0, 0 },
+  { "le", 12, {0, {{{0, 0}}}}, 0, 0 },
+  { "hi", 13, {0, {{{0, 0}}}}, 0, 0 },
+  { "ls", 14, {0, {{{0, 0}}}}, 0, 0 },
+  { "pnz", 15, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_Qcondb =
+{
+  & arc_cgen_opval_h_Qcondb_entries[0],
+  28,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_Qcondj_entries[] =
+{
+  { "", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "al", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "eq", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { "z", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { "ne", 2, {0, {{{0, 0}}}}, 0, 0 },
+  { "nz", 2, {0, {{{0, 0}}}}, 0, 0 },
+  { "pl", 3, {0, {{{0, 0}}}}, 0, 0 },
+  { "p", 3, {0, {{{0, 0}}}}, 0, 0 },
+  { "mi", 4, {0, {{{0, 0}}}}, 0, 0 },
+  { "n", 4, {0, {{{0, 0}}}}, 0, 0 },
+  { "cs", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "c", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "lo", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "cc", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { "nc", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { "hs", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { "vs", 7, {0, {{{0, 0}}}}, 0, 0 },
+  { "v", 7, {0, {{{0, 0}}}}, 0, 0 },
+  { "vc", 8, {0, {{{0, 0}}}}, 0, 0 },
+  { "nv", 8, {0, {{{0, 0}}}}, 0, 0 },
+  { "gt", 9, {0, {{{0, 0}}}}, 0, 0 },
+  { "ge", 10, {0, {{{0, 0}}}}, 0, 0 },
+  { "lt", 11, {0, {{{0, 0}}}}, 0, 0 },
+  { "le", 12, {0, {{{0, 0}}}}, 0, 0 },
+  { "hi", 13, {0, {{{0, 0}}}}, 0, 0 },
+  { "ls", 14, {0, {{{0, 0}}}}, 0, 0 },
+  { "pnz", 15, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_Qcondj =
+{
+  & arc_cgen_opval_h_Qcondj_entries[0],
+  27,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_Qcondi_entries[] =
+{
+  { "", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { ".al", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { ".eq", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { ".z", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { ".ne", 2, {0, {{{0, 0}}}}, 0, 0 },
+  { ".nz", 2, {0, {{{0, 0}}}}, 0, 0 },
+  { ".pl", 3, {0, {{{0, 0}}}}, 0, 0 },
+  { ".p", 3, {0, {{{0, 0}}}}, 0, 0 },
+  { ".mi", 4, {0, {{{0, 0}}}}, 0, 0 },
+  { ".n", 4, {0, {{{0, 0}}}}, 0, 0 },
+  { ".cs", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { ".c", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { ".lo", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { ".cc", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { ".nc", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { ".hs", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { ".vs", 7, {0, {{{0, 0}}}}, 0, 0 },
+  { ".v", 7, {0, {{{0, 0}}}}, 0, 0 },
+  { ".vc", 8, {0, {{{0, 0}}}}, 0, 0 },
+  { ".nv", 8, {0, {{{0, 0}}}}, 0, 0 },
+  { ".gt", 9, {0, {{{0, 0}}}}, 0, 0 },
+  { ".ge", 10, {0, {{{0, 0}}}}, 0, 0 },
+  { ".lt", 11, {0, {{{0, 0}}}}, 0, 0 },
+  { ".le", 12, {0, {{{0, 0}}}}, 0, 0 },
+  { ".hi", 13, {0, {{{0, 0}}}}, 0, 0 },
+  { ".ls", 14, {0, {{{0, 0}}}}, 0, 0 },
+  { ".pnz", 15, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_Qcondi =
+{
+  & arc_cgen_opval_h_Qcondi_entries[0],
+  27,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_uncondb_entries[] =
+{
+  { "", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "al", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "ra", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_uncondb =
+{
+  & arc_cgen_opval_h_uncondb_entries[0],
+  3,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_uncondj_entries[] =
+{
+  { "", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "al", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_uncondj =
+{
+  & arc_cgen_opval_h_uncondj_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_uncondi_entries[] =
+{
+  { "", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { ".al", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_uncondi =
+{
+  & arc_cgen_opval_h_uncondi_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_i2cond_entries[] =
+{
+  { "COND2_", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND2_al", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND2_ra", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND2_eq", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND2_z", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND2_ne", 2, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND2_nz", 2, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_i2cond =
+{
+  & arc_cgen_opval_h_i2cond_entries[0],
+  7,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_i3cond_entries[] =
+{
+  { "COND3_gt", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND3_ge", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND3_lt", 2, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND3_le", 3, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND3_hi", 4, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND3_cc", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND3_nc", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND3_hs", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND3_cs", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND3_c", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND3_lo", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { "COND3_ls", 7, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_i3cond =
+{
+  & arc_cgen_opval_h_i3cond_entries[0],
+  12,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_delay_entries[] =
+{
+  { "", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { ".d", 1, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_delay =
+{
+  & arc_cgen_opval_h_delay_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_uflags_entries[] =
+{
+  { "", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { ".f", 1, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_uflags =
+{
+  & arc_cgen_opval_h_uflags_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_nil_entries[] =
+{
+  { "", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_nil =
+{
+  & arc_cgen_opval_h_nil_entries[0],
+  1,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_auflags_entries[] =
+{
+  { "", 1, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_auflags =
+{
+  & arc_cgen_opval_h_auflags_entries[0],
+  1,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_aufflags_entries[] =
+{
+  { ".f", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { "", 1, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_aufflags =
+{
+  & arc_cgen_opval_h_aufflags_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_Di_entries[] =
+{
+  { "", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { ".di", 1, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_Di =
+{
+  & arc_cgen_opval_h_Di_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_insn16_entries[] =
+{
+  { "_s", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_insn16 =
+{
+  & arc_cgen_opval_h_insn16_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_insn32_entries[] =
+{
+  { "", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "_l", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_insn32 =
+{
+  & arc_cgen_opval_h_insn32_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h__aw_entries[] =
+{
+  { ".a", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { ".aw", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h__aw =
+{
+  & arc_cgen_opval_h__aw_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_cr16_entries[] =
+{
+  { "r0", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "r1", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { "r2", 2, {0, {{{0, 0}}}}, 0, 0 },
+  { "r3", 3, {0, {{{0, 0}}}}, 0, 0 },
+  { "r12", 4, {0, {{{0, 0}}}}, 0, 0 },
+  { "r13", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "r14", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { "r15", 7, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_cr16 =
+{
+  & arc_cgen_opval_h_cr16_entries[0],
+  8,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_r0_entries[] =
+{
+  { "r0", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_r0 =
+{
+  & arc_cgen_opval_h_r0_entries[0],
+  1,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_gp_entries[] =
+{
+  { "r26", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "gp", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_gp =
+{
+  & arc_cgen_opval_h_gp_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_sp_entries[] =
+{
+  { "sp", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "r28", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_sp =
+{
+  & arc_cgen_opval_h_sp_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_pcl_entries[] =
+{
+  { "pcl", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "r63", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_pcl =
+{
+  & arc_cgen_opval_h_pcl_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_noilink_entries[] =
+{
+  { "gp", 26, {0, {{{0, 0}}}}, 0, 0 },
+  { "fp", 27, {0, {{{0, 0}}}}, 0, 0 },
+  { "sp", 28, {0, {{{0, 0}}}}, 0, 0 },
+  { "blink", 31, {0, {{{0, 0}}}}, 0, 0 },
+  { "mlo", 57, {0, {{{0, 0}}}}, 0, 0 },
+  { "mmid", 58, {0, {{{0, 0}}}}, 0, 0 },
+  { "mhi", 59, {0, {{{0, 0}}}}, 0, 0 },
+  { "lp_count", 60, {0, {{{0, 0}}}}, 0, 0 },
+  { "pcl", 63, {0, {{{0, 0}}}}, 0, 0 },
+  { "r0", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "r1", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { "r2", 2, {0, {{{0, 0}}}}, 0, 0 },
+  { "r3", 3, {0, {{{0, 0}}}}, 0, 0 },
+  { "r4", 4, {0, {{{0, 0}}}}, 0, 0 },
+  { "r5", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "r6", 6, {0, {{{0, 0}}}}, 0, 0 },
+  { "r7", 7, {0, {{{0, 0}}}}, 0, 0 },
+  { "r8", 8, {0, {{{0, 0}}}}, 0, 0 },
+  { "r9", 9, {0, {{{0, 0}}}}, 0, 0 },
+  { "r10", 10, {0, {{{0, 0}}}}, 0, 0 },
+  { "r11", 11, {0, {{{0, 0}}}}, 0, 0 },
+  { "r12", 12, {0, {{{0, 0}}}}, 0, 0 },
+  { "r13", 13, {0, {{{0, 0}}}}, 0, 0 },
+  { "r14", 14, {0, {{{0, 0}}}}, 0, 0 },
+  { "r15", 15, {0, {{{0, 0}}}}, 0, 0 },
+  { "r16", 16, {0, {{{0, 0}}}}, 0, 0 },
+  { "r17", 17, {0, {{{0, 0}}}}, 0, 0 },
+  { "r18", 18, {0, {{{0, 0}}}}, 0, 0 },
+  { "r19", 19, {0, {{{0, 0}}}}, 0, 0 },
+  { "r20", 20, {0, {{{0, 0}}}}, 0, 0 },
+  { "r21", 21, {0, {{{0, 0}}}}, 0, 0 },
+  { "r22", 22, {0, {{{0, 0}}}}, 0, 0 },
+  { "r23", 23, {0, {{{0, 0}}}}, 0, 0 },
+  { "r24", 24, {0, {{{0, 0}}}}, 0, 0 },
+  { "r25", 25, {0, {{{0, 0}}}}, 0, 0 },
+  { "r26", 26, {0, {{{0, 0}}}}, 0, 0 },
+  { "r27", 27, {0, {{{0, 0}}}}, 0, 0 },
+  { "r28", 28, {0, {{{0, 0}}}}, 0, 0 },
+  { "r31", 31, {0, {{{0, 0}}}}, 0, 0 },
+  { "r32", 32, {0, {{{0, 0}}}}, 0, 0 },
+  { "r33", 33, {0, {{{0, 0}}}}, 0, 0 },
+  { "r34", 34, {0, {{{0, 0}}}}, 0, 0 },
+  { "r35", 35, {0, {{{0, 0}}}}, 0, 0 },
+  { "r36", 36, {0, {{{0, 0}}}}, 0, 0 },
+  { "r37", 37, {0, {{{0, 0}}}}, 0, 0 },
+  { "r38", 38, {0, {{{0, 0}}}}, 0, 0 },
+  { "r39", 39, {0, {{{0, 0}}}}, 0, 0 },
+  { "r40", 40, {0, {{{0, 0}}}}, 0, 0 },
+  { "r41", 41, {0, {{{0, 0}}}}, 0, 0 },
+  { "r42", 42, {0, {{{0, 0}}}}, 0, 0 },
+  { "r43", 43, {0, {{{0, 0}}}}, 0, 0 },
+  { "r44", 44, {0, {{{0, 0}}}}, 0, 0 },
+  { "r45", 45, {0, {{{0, 0}}}}, 0, 0 },
+  { "r46", 46, {0, {{{0, 0}}}}, 0, 0 },
+  { "r47", 47, {0, {{{0, 0}}}}, 0, 0 },
+  { "r48", 48, {0, {{{0, 0}}}}, 0, 0 },
+  { "r49", 49, {0, {{{0, 0}}}}, 0, 0 },
+  { "r50", 50, {0, {{{0, 0}}}}, 0, 0 },
+  { "r51", 51, {0, {{{0, 0}}}}, 0, 0 },
+  { "r52", 52, {0, {{{0, 0}}}}, 0, 0 },
+  { "r53", 53, {0, {{{0, 0}}}}, 0, 0 },
+  { "r54", 54, {0, {{{0, 0}}}}, 0, 0 },
+  { "r55", 55, {0, {{{0, 0}}}}, 0, 0 },
+  { "r56", 56, {0, {{{0, 0}}}}, 0, 0 },
+  { "r57", 57, {0, {{{0, 0}}}}, 0, 0 },
+  { "r58", 58, {0, {{{0, 0}}}}, 0, 0 },
+  { "r59", 59, {0, {{{0, 0}}}}, 0, 0 },
+  { "r60", 60, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_noilink =
+{
+  & arc_cgen_opval_h_noilink_entries[0],
+  68,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_ilinkx_entries[] =
+{
+  { "ilink1", 29, {0, {{{0, 0}}}}, 0, 0 },
+  { "r29", 29, {0, {{{0, 0}}}}, 0, 0 },
+  { "ilink2", 30, {0, {{{0, 0}}}}, 0, 0 },
+  { "r30", 30, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_ilinkx =
+{
+  & arc_cgen_opval_h_ilinkx_entries[0],
+  4,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_r31_entries[] =
+{
+  { "blink", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "r31", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_r31 =
+{
+  & arc_cgen_opval_h_r31_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_status32_entries[] =
+{
+  { "status32", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_status32 =
+{
+  & arc_cgen_opval_h_status32_entries[0],
+  1,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_ne_entries[] =
+{
+  { "ne", 0, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_ne =
+{
+  & arc_cgen_opval_h_ne_entries[0],
+  1,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_RccS_entries[] =
+{
+  { "eq", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "ne", 1, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_RccS =
+{
+  & arc_cgen_opval_h_RccS_entries[0],
+  2,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY arc_cgen_opval_h_Rcc_entries[] =
+{
+  { "req", 0, {0, {{{0, 0}}}}, 0, 0 },
+  { "rne", 1, {0, {{{0, 0}}}}, 0, 0 },
+  { "rlt", 2, {0, {{{0, 0}}}}, 0, 0 },
+  { "rge", 3, {0, {{{0, 0}}}}, 0, 0 },
+  { "rlo", 4, {0, {{{0, 0}}}}, 0, 0 },
+  { "rhs", 5, {0, {{{0, 0}}}}, 0, 0 },
+  { "bit0", 14, {0, {{{0, 0}}}}, 0, 0 },
+  { "bit1", 15, {0, {{{0, 0}}}}, 0, 0 }
+};
+
+CGEN_KEYWORD arc_cgen_opval_h_Rcc =
+{
+  & arc_cgen_opval_h_Rcc_entries[0],
+  8,
+  0, 0, 0, 0, ""
+};
+
+
+/* The hardware table.  */
+
+#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
+#define A(a) (1 << CGEN_HW_##a)
+#else
+#define A(a) (1 << CGEN_HW_/**/a)
+#endif
+
+const CGEN_HW_ENTRY arc_cgen_hw_table[] =
+{
+  { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-sint", HW_H_SINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-uint", HW_H_UINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-addr", HW_H_ADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-iaddr", HW_H_IADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-lbit", HW_H_LBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-zbit", HW_H_ZBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-nbit", HW_H_NBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-cbit", HW_H_CBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-vbit", HW_H_VBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-ubit", HW_H_UBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-e1", HW_H_E1, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-e2", HW_H_E2, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-s1bit", HW_H_S1BIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-s2bit", HW_H_S2BIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-Qcondb", HW_H_QCONDB, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_Qcondb, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-Qcondj", HW_H_QCONDJ, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_Qcondj, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-Qcondi", HW_H_QCONDI, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_Qcondi, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-uncondb", HW_H_UNCONDB, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_uncondb, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-uncondj", HW_H_UNCONDJ, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_uncondj, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-uncondi", HW_H_UNCONDI, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_uncondi, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-i2cond", HW_H_I2COND, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_i2cond, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-i3cond", HW_H_I3COND, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_i3cond, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-delay", HW_H_DELAY, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_delay, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-uflags", HW_H_UFLAGS, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_uflags, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-nil", HW_H_NIL, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_nil, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-auflags", HW_H_AUFLAGS, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_auflags, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-aufflags", HW_H_AUFFLAGS, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_aufflags, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-Di", HW_H_DI, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_Di, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-insn16", HW_H_INSN16, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_insn16, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-insn32", HW_H_INSN32, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_insn32, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-_aw", HW_H__AW, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h__aw, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-cr", HW_H_CR, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_cr_names, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-cr16", HW_H_CR16, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_cr16, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-r0", HW_H_R0, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_r0, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-gp", HW_H_GP, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_gp, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-sp", HW_H_SP, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_sp, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-pcl", HW_H_PCL, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_pcl, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-noilink", HW_H_NOILINK, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_noilink, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-ilinkx", HW_H_ILINKX, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_ilinkx, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-r31", HW_H_R31, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_r31, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-auxr", HW_H_AUXR, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_cr_names, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-status32", HW_H_STATUS32, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_status32, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-timer-expire", HW_H_TIMER_EXPIRE, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-prof-offset", HW_H_PROF_OFFSET, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-ne", HW_H_NE, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_ne, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-pc", HW_H_PC, CGEN_ASM_NONE, 0, { 0|A(PROFILE)|A(PC), { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-RccS", HW_H_RCCS, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_RccS, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { "h-Rcc", HW_H_RCC, CGEN_ASM_KEYWORD, (PTR) & arc_cgen_opval_h_Rcc, { 0, { { { (1<<MACH_BASE), 0 } } } } },
+  { 0, 0, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
+};
+
+#undef A
+
+
+/* The instruction field table.  */
+
+#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
+#define A(a) (1 << CGEN_IFLD_##a)
+#else
+#define A(a) (1 << CGEN_IFLD_/**/a)
+#endif
+
+const CGEN_IFLD arc_cgen_ifld_table[] =
+{
+  { ARC_F_NIL, "f-nil", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_ANYOF, "f-anyof", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_COND_Q, "f-cond-Q", 0, 32, 27, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_COND_I2, "f-cond-i2", 0, 32, 5, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_COND_I3, "f-cond-i3", 0, 32, 7, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_BRCOND, "f-brcond", 0, 32, 28, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_OP__A, "f-op--a", 0, 32, 13, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_OP__B, "f-op--b", 0, 32, 5, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_OP__C, "f-op--c", 0, 32, 8, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_B_5_3, "f-B-5-3", 0, 32, 17, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_OP_B, "f-op-B", 0, 0, 0, 0,{ 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_OP_C, "f-op-C", 0, 32, 20, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_OP_CJ, "f-op-Cj", 0, 32, 20, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_H_2_0, "f-h-2-0", 0, 32, 8, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_H_5_3, "f-h-5-3", 0, 32, 13, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_OP_H, "f-op-h", 0, 0, 0, 0,{ 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_U6, "f-u6", 0, 32, 20, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_U6X2, "f-u6x2", 0, 32, 20, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_DELAY_N, "f-delay-N", 0, 32, 26, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_RES27, "f-res27", 0, 32, 27, 1, { 0|A(RESERVED), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_F, "f-F", 0, 32, 16, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_CBRANCH_IMM, "f-cbranch-imm", 0, 32, 27, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_OP_A, "f-op-A", 0, 32, 26, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_S12H, "f-s12h", 0, 32, 26, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_S12, "f-s12", 0, 0, 0, 0,{ 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_S12X2, "f-s12x2", 0, 0, 0, 0,{ 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_REL10, "f-rel10", 0, 32, 7, 9, { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_REL7, "f-rel7", 0, 32, 10, 6, { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_REL8, "f-rel8", 0, 32, 9, 7, { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_REL13BL, "f-rel13bl", 0, 32, 5, 11, { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_D21L, "f-d21l", 0, 32, 5, 10, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_D21BL, "f-d21bl", 0, 32, 5, 9, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_D21H, "f-d21h", 0, 32, 16, 10, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_D25M, "f-d25m", 0, 32, 16, 10, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_D25H, "f-d25h", 0, 32, 28, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_REL21, "f-rel21", 0, 0, 0, 0,{ 0|A(PCREL_ADDR)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_REL21BL, "f-rel21bl", 0, 0, 0, 0,{ 0|A(PCREL_ADDR)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_REL25, "f-rel25", 0, 0, 0, 0,{ 0|A(PCREL_ADDR)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_REL25BL, "f-rel25bl", 0, 0, 0, 0,{ 0|A(PCREL_ADDR)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_D9L, "f-d9l", 0, 32, 8, 7, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_D9H, "f-d9h", 0, 32, 16, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_REL9, "f-rel9", 0, 0, 0, 0,{ 0|A(PCREL_ADDR)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_U3, "f-u3", 0, 32, 13, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_U5, "f-u5", 0, 32, 11, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_U7, "f-u7", 0, 32, 9, 7, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_U8, "f-u8", 0, 32, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_S9, "f-s9", 0, 0, 0, 0,{ 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_U5X2, "f-u5x2", 0, 32, 11, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_U5X4, "f-u5x4", 0, 32, 11, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_U8X4, "f-u8x4", 0, 32, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_S9X1, "f-s9x1", 0, 32, 7, 9, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_S9X2, "f-s9x2", 0, 32, 7, 9, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_S9X4, "f-s9x4", 0, 32, 7, 9, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_DUMMY, "f-dummy", 0, 32, 16, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_OPM, "f-opm", 0, 32, 0, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_GO_TYPE, "f-go-type", 0, 32, 8, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_GO_CC_TYPE, "f-go-cc-type", 0, 32, 26, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_GO_OP, "f-go-op", 0, 32, 10, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_I16_43, "f-i16-43", 0, 32, 11, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_I16_GO, "f-i16-go", 0, 32, 11, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_I16_GP_TYPE, "f-i16-gp-type", 0, 32, 5, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_I16ADDCMPU7_TYPE, "f-i16addcmpu7-type", 0, 32, 8, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_BUF, "f-buf", 0, 32, 15, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_BR, "f-br", 0, 32, 27, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_BLUF, "f-bluf", 0, 32, 14, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_BRSCOND, "f-brscond", 0, 32, 8, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_LDOZZX, "f-ldozzx", 0, 32, 23, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_LDR6ZZX, "f-ldr6zzx", 0, 32, 10, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_STOZZR, "f-stozzr", 0, 32, 29, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_LDOAA, "f-ldoaa", 0, 32, 21, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_LDRAA, "f-ldraa", 0, 32, 8, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_STOAA, "f-stoaa", 0, 32, 27, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_LDODI, "f-LDODi", 0, 32, 20, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_LDRDI, "f-LDRDi", 0, 32, 16, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_STODI, "f-STODi", 0, 32, 26, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { ARC_F_TRAPNUM, "f-trapnum", 0, 32, 5, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+  { 0, 0, 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
+};
+
+#undef A
+
+
+
+/* multi ifield declarations */
+
+const CGEN_MAYBE_MULTI_IFLD ARC_F_OP_B_MULTI_IFIELD [];
+const CGEN_MAYBE_MULTI_IFLD ARC_F_OP_H_MULTI_IFIELD [];
+const CGEN_MAYBE_MULTI_IFLD ARC_F_S12_MULTI_IFIELD [];
+const CGEN_MAYBE_MULTI_IFLD ARC_F_S12X2_MULTI_IFIELD [];
+const CGEN_MAYBE_MULTI_IFLD ARC_F_REL21_MULTI_IFIELD [];
+const CGEN_MAYBE_MULTI_IFLD ARC_F_REL21BL_MULTI_IFIELD [];
+const CGEN_MAYBE_MULTI_IFLD ARC_F_REL25_MULTI_IFIELD [];
+const CGEN_MAYBE_MULTI_IFLD ARC_F_REL25BL_MULTI_IFIELD [];
+const CGEN_MAYBE_MULTI_IFLD ARC_F_REL9_MULTI_IFIELD [];
+const CGEN_MAYBE_MULTI_IFLD ARC_F_S9_MULTI_IFIELD [];
+
+
+/* multi ifield definitions */
+
+const CGEN_MAYBE_MULTI_IFLD ARC_F_OP_B_MULTI_IFIELD [] =
+{
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_OP__B] } },
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_B_5_3] } },
+    { 0, { (const PTR) 0 } }
+};
+const CGEN_MAYBE_MULTI_IFLD ARC_F_OP_H_MULTI_IFIELD [] =
+{
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_H_2_0] } },
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_H_5_3] } },
+    { 0, { (const PTR) 0 } }
+};
+const CGEN_MAYBE_MULTI_IFLD ARC_F_S12_MULTI_IFIELD [] =
+{
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U6] } },
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_S12H] } },
+    { 0, { (const PTR) 0 } }
+};
+const CGEN_MAYBE_MULTI_IFLD ARC_F_S12X2_MULTI_IFIELD [] =
+{
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U6] } },
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_S12H] } },
+    { 0, { (const PTR) 0 } }
+};
+const CGEN_MAYBE_MULTI_IFLD ARC_F_REL21_MULTI_IFIELD [] =
+{
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D21L] } },
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D21H] } },
+    { 0, { (const PTR) 0 } }
+};
+const CGEN_MAYBE_MULTI_IFLD ARC_F_REL21BL_MULTI_IFIELD [] =
+{
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D21BL] } },
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D21H] } },
+    { 0, { (const PTR) 0 } }
+};
+const CGEN_MAYBE_MULTI_IFLD ARC_F_REL25_MULTI_IFIELD [] =
+{
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D21L] } },
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D25M] } },
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D25H] } },
+    { 0, { (const PTR) 0 } }
+};
+const CGEN_MAYBE_MULTI_IFLD ARC_F_REL25BL_MULTI_IFIELD [] =
+{
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D21BL] } },
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D25M] } },
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D25H] } },
+    { 0, { (const PTR) 0 } }
+};
+const CGEN_MAYBE_MULTI_IFLD ARC_F_REL9_MULTI_IFIELD [] =
+{
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D9L] } },
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D9H] } },
+    { 0, { (const PTR) 0 } }
+};
+const CGEN_MAYBE_MULTI_IFLD ARC_F_S9_MULTI_IFIELD [] =
+{
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U8] } },
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_D9H] } },
+    { 0, { (const PTR) 0 } }
+};
+
+/* The operand table.  */
+
+#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
+#define A(a) (1 << CGEN_OPERAND_##a)
+#else
+#define A(a) (1 << CGEN_OPERAND_/**/a)
+#endif
+#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
+#define OPERAND(op) ARC_OPERAND_##op
+#else
+#define OPERAND(op) ARC_OPERAND_/**/op
+#endif
+
+const CGEN_OPERAND arc_cgen_operand_table[] =
+{
+/* pc: program counter */
+  { "pc", ARC_OPERAND_PC, HW_H_PC, 0, 0,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_NIL] } }, 
+    { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
+/* lbit: loop inhibit bit */
+  { "lbit", ARC_OPERAND_LBIT, HW_H_LBIT, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* zbit: zero bit */
+  { "zbit", ARC_OPERAND_ZBIT, HW_H_ZBIT, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* nbit: negative bit */
+  { "nbit", ARC_OPERAND_NBIT, HW_H_NBIT, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* cbit: carry bit */
+  { "cbit", ARC_OPERAND_CBIT, HW_H_CBIT, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* vbit: overflow bit */
+  { "vbit", ARC_OPERAND_VBIT, HW_H_VBIT, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* s1bit: channel 1 saturate */
+  { "s1bit", ARC_OPERAND_S1BIT, HW_H_S1BIT, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* s2bit: channel 2 saturate */
+  { "s2bit", ARC_OPERAND_S2BIT, HW_H_S2BIT, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* Qcondb: Condition */
+  { "Qcondb", ARC_OPERAND_QCONDB, HW_H_QCONDB, 27, 5,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_COND_Q] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* Qcondj: Condition */
+  { "Qcondj", ARC_OPERAND_QCONDJ, HW_H_QCONDJ, 27, 5,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_COND_Q] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* Qcondi: Condition */
+  { "Qcondi", ARC_OPERAND_QCONDI, HW_H_QCONDI, 27, 5,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_COND_Q] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* uncondb: unconditional branch */
+  { "uncondb", ARC_OPERAND_UNCONDB, HW_H_UNCONDB, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* uncondj: unconditional jump */
+  { "uncondj", ARC_OPERAND_UNCONDJ, HW_H_UNCONDJ, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* uncondi: unconditional insn */
+  { "uncondi", ARC_OPERAND_UNCONDI, HW_H_UNCONDI, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* i2cond: Condition */
+  { "i2cond", ARC_OPERAND_I2COND, HW_H_I2COND, 5, 2,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_COND_I2] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* i3cond: Condition */
+  { "i3cond", ARC_OPERAND_I3COND, HW_H_I3COND, 7, 3,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_COND_I3] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* delay_N: Delay slot exposed */
+  { "delay_N", ARC_OPERAND_DELAY_N, HW_H_DELAY, 26, 1,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_DELAY_N] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* _S: 16 bit opcode */
+  { "_S", ARC_OPERAND__S, HW_H_INSN16, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* _L: 32 bit opcode */
+  { "_L", ARC_OPERAND__L, HW_H_INSN32, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* F: update flags */
+  { "F", ARC_OPERAND_F, HW_H_UFLAGS, 16, 1,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_F] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* F1: always update flags */
+  { "F1", ARC_OPERAND_F1, HW_H_AUFLAGS, 16, 1,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_F] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* F1F: always update flags; .F allowed */
+  { "F1F", ARC_OPERAND_F1F, HW_H_AUFFLAGS, 16, 1,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_F] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* F0: never update flags */
+  { "F0", ARC_OPERAND_F0, HW_H_NIL, 16, 1,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_F] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* R_a: Core Register a */
+  { "R_a", ARC_OPERAND_R_A, HW_H_CR16, 13, 3,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_OP__A] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* RA: Core Register A */
+  { "RA", ARC_OPERAND_RA, HW_H_CR, 26, 6,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_OP_A] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* R_b: Core Register b */
+  { "R_b", ARC_OPERAND_R_B, HW_H_CR16, 5, 3,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_OP__B] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* RB: Core Register B */
+  { "RB", ARC_OPERAND_RB, HW_H_CR, 5, 6,
+    { 2, { (const PTR) &ARC_F_OP_B_MULTI_IFIELD[0] } }, 
+    { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+/* R_c: Core Register b */
+  { "R_c", ARC_OPERAND_R_C, HW_H_CR16, 8, 3,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_OP__C] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* RC: Core Register C */
+  { "RC", ARC_OPERAND_RC, HW_H_CR, 20, 6,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_OP_C] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* Rh: Core register h */
+  { "Rh", ARC_OPERAND_RH, HW_H_CR, 8, 6,
+    { 2, { (const PTR) &ARC_F_OP_H_MULTI_IFIELD[0] } }, 
+    { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+/* R0: Core Register 0 */
+  { "R0", ARC_OPERAND_R0, HW_H_R0, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* R31: Core Register 31 */
+  { "R31", ARC_OPERAND_R31, HW_H_R31, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* GP: Global Pointer */
+  { "GP", ARC_OPERAND_GP, HW_H_GP, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* SP: Stack Pointer */
+  { "SP", ARC_OPERAND_SP, HW_H_SP, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* PCL: read PC - aligned */
+  { "PCL", ARC_OPERAND_PCL, HW_H_PCL, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* RA_0: encode A as 0 */
+  { "RA_0", ARC_OPERAND_RA_0, HW_H_NIL, 26, 6,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_OP_A] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* RB_0: encode B as 0 */
+  { "RB_0", ARC_OPERAND_RB_0, HW_H_NIL, 5, 6,
+    { 2, { (const PTR) &ARC_F_OP_B_MULTI_IFIELD[0] } }, 
+    { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+/* RC_ilink: inlink[01] as op C */
+  { "RC_ilink", ARC_OPERAND_RC_ILINK, HW_H_ILINKX, 20, 6,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_OP_CJ] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* RC_noilink: Core reg C, not ilink */
+  { "RC_noilink", ARC_OPERAND_RC_NOILINK, HW_H_NOILINK, 20, 6,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_OP_CJ] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* NE: NE condition  */
+  { "NE", ARC_OPERAND_NE, HW_H_NE, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* U6: 6 bit unsigned immediate */
+  { "U6", ARC_OPERAND_U6, HW_H_UINT, 20, 6,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U6] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* U6x2: 6 bit unsigned immediate */
+  { "U6x2", ARC_OPERAND_U6X2, HW_H_UINT, 20, 6,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U6X2] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* u3: 3 bit unsigned immediate */
+  { "u3", ARC_OPERAND_U3, HW_H_UINT, 13, 3,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U3] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* u5: 5 bit unsigned immediate */
+  { "u5", ARC_OPERAND_U5, HW_H_UINT, 11, 5,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U5] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* u7: 7 bit unsigned immediate */
+  { "u7", ARC_OPERAND_U7, HW_H_UINT, 9, 7,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U7] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* u8: 8 bit unsigned immediate */
+  { "u8", ARC_OPERAND_U8, HW_H_UINT, 8, 8,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U8] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* s9: 8 bit signed immediate */
+  { "s9", ARC_OPERAND_S9, HW_H_SINT, 8, 9,
+    { 2, { (const PTR) &ARC_F_S9_MULTI_IFIELD[0] } }, 
+    { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+/* s12: 12 bit signed immediate */
+  { "s12", ARC_OPERAND_S12, HW_H_SINT, 20, 12,
+    { 2, { (const PTR) &ARC_F_S12_MULTI_IFIELD[0] } }, 
+    { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+/* s12x2: 12 bit signed immediate */
+  { "s12x2", ARC_OPERAND_S12X2, HW_H_SINT, 20, 12,
+    { 2, { (const PTR) &ARC_F_S12X2_MULTI_IFIELD[0] } }, 
+    { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+/* u5x4: 5 bit uns imm times 4 */
+  { "u5x4", ARC_OPERAND_U5X4, HW_H_UINT, 11, 5,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U5X4] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* sc_u5_: 5 bit uns imm times 4 */
+  { "sc_u5_", ARC_OPERAND_SC_U5_, HW_H_UINT, 11, 5,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U5X4] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* sc_u5w: 5 bit uns imm times 2 */
+  { "sc_u5w", ARC_OPERAND_SC_U5W, HW_H_UINT, 11, 5,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U5X2] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* sc_u5b: 5 bit uns imm times 1 */
+  { "sc_u5b", ARC_OPERAND_SC_U5B, HW_H_UINT, 11, 5,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U5] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* u8x4: 8 bit uns imm times 4 */
+  { "u8x4", ARC_OPERAND_U8X4, HW_H_UINT, 8, 8,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_U8X4] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* s9x4: 9 bit sgn imm times 4 */
+  { "s9x4", ARC_OPERAND_S9X4, HW_H_UINT, 7, 9,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_S9X4] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* sc_s9_: 8 bit uns imm times 4 */
+  { "sc_s9_", ARC_OPERAND_SC_S9_, HW_H_UINT, 7, 9,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_S9X4] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* sc_s9w: 8 bit uns imm times 2 */
+  { "sc_s9w", ARC_OPERAND_SC_S9W, HW_H_UINT, 7, 9,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_S9X2] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* sc_s9b: 8 bit uns imm times 1 */
+  { "sc_s9b", ARC_OPERAND_SC_S9B, HW_H_UINT, 7, 9,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_S9X1] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* label7: 7 bit pc relative address */
+  { "label7", ARC_OPERAND_LABEL7, HW_H_IADDR, 10, 6,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_REL7] } }, 
+    { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
+/* label8: 8 bit pc relative address */
+  { "label8", ARC_OPERAND_LABEL8, HW_H_IADDR, 9, 7,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_REL8] } }, 
+    { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
+/* label9: 9 bit pc relative address */
+  { "label9", ARC_OPERAND_LABEL9, HW_H_IADDR, 8, 8,
+    { 2, { (const PTR) &ARC_F_REL9_MULTI_IFIELD[0] } }, 
+    { 0|A(PCREL_ADDR)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+/* label10: 10 bit pc relative address */
+  { "label10", ARC_OPERAND_LABEL10, HW_H_IADDR, 7, 9,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_REL10] } }, 
+    { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
+/* label13a: 13 bit bl pc rel address */
+  { "label13a", ARC_OPERAND_LABEL13A, HW_H_IADDR, 5, 11,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_REL13BL] } }, 
+    { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
+/* label21: 21 bit pc relative address */
+  { "label21", ARC_OPERAND_LABEL21, HW_H_IADDR, 5, 20,
+    { 2, { (const PTR) &ARC_F_REL21_MULTI_IFIELD[0] } }, 
+    { 0|A(PCREL_ADDR)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+/* label21a: 21 bit bl pc rel address */
+  { "label21a", ARC_OPERAND_LABEL21A, HW_H_IADDR, 5, 19,
+    { 2, { (const PTR) &ARC_F_REL21BL_MULTI_IFIELD[0] } }, 
+    { 0|A(PCREL_ADDR)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+/* label25: 25 bit pc relative address */
+  { "label25", ARC_OPERAND_LABEL25, HW_H_IADDR, 5, 24,
+    { 3, { (const PTR) &ARC_F_REL25_MULTI_IFIELD[0] } }, 
+    { 0|A(PCREL_ADDR)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+/* label25a: 25 bit bl pc rel address */
+  { "label25a", ARC_OPERAND_LABEL25A, HW_H_IADDR, 5, 23,
+    { 3, { (const PTR) &ARC_F_REL25BL_MULTI_IFIELD[0] } }, 
+    { 0|A(PCREL_ADDR)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
+/* dummy-op: (first 16 bit of) next insn */
+  { "dummy-op", ARC_OPERAND_DUMMY_OP, HW_H_UINT, 16, 16,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_DUMMY] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* RccS: BRcc_s */
+  { "RccS", ARC_OPERAND_RCCS, HW_H_RCCS, 8, 1,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_BRSCOND] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* Rcc: BRcc / BBIT Condition */
+  { "Rcc", ARC_OPERAND_RCC, HW_H_RCC, 28, 4,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_BRCOND] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* LDODi: ld /w offs Direct mem access */
+  { "LDODi", ARC_OPERAND_LDODI, HW_H_DI, 20, 1,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_LDODI] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* LDRDi: ld reg-reg Direct mem access */
+  { "LDRDi", ARC_OPERAND_LDRDI, HW_H_DI, 16, 1,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_LDRDI] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* STODi: ld w/ offs Direct mem access */
+  { "STODi", ARC_OPERAND_STODI, HW_H_DI, 26, 1,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_STODI] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* EXDi: ex Direct memory access */
+  { "EXDi", ARC_OPERAND_EXDI, HW_H_DI, 16, 1,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_F] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* _AW: .AW suffix */
+  { "_AW", ARC_OPERAND__AW, HW_H__AW, 0, 0,
+    { 0, { (const PTR) 0 } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* trapnum: 6 bit trap number */
+  { "trapnum", ARC_OPERAND_TRAPNUM, HW_H_UINT, 5, 6,
+    { 0, { (const PTR) &arc_cgen_ifld_table[ARC_F_TRAPNUM] } }, 
+    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
+/* sentinel */
+  { 0, 0, 0, 0, 0,
+    { 0, { (const PTR) 0 } },
+    { 0, { { { (1<<MACH_BASE), 0 } } } } }
+};
+
+#undef A
+
+
+/* The instruction table.  */
+
+#define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
+#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
+#define A(a) (1 << CGEN_INSN_##a)
+#else
+#define A(a) (1 << CGEN_INSN_/**/a)
+#endif
+
+static const CGEN_IBASE arc_cgen_insn_table[MAX_INSNS] =
+{
+  /* Special null first entry.
+     A `num' value of zero is thus invalid.
+     Also, the special `invalid' insn resides here.  */
+  { 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } } },
+/* b$i2cond $label10 */
+  {
+    ARC_INSN_B_S, "b_s", "b", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* b$i3cond$_S $label7 */
+  {
+    ARC_INSN_BCC_S, "bcc_s", "b", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* br$RccS$_S $R_b,0,$label8 */
+  {
+    ARC_INSN_BRCC_S, "brcc_s", "br", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* b$Qcondb$_L $label21 */
+  {
+    ARC_INSN_BCC_L, "bcc_l", "b", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* b$Qcondb$_L.d $label21 */
+  {
+    ARC_INSN_BCC_L_D, "bcc_l.d", "b", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* b$uncondb$_L $label25 */
+  {
+    ARC_INSN_B_L, "b_l", "b", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* b$uncondb$_L.d $label25 */
+  {
+    ARC_INSN_B_L_D, "b_l.d", "b", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* b$Rcc $RB,$RC,$label9 */
+  {
+    ARC_INSN_BRCC_RC, "brcc_RC", "b", 32,
+    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* b$Rcc.d $RB,$RC,$label9 */
+  {
+    ARC_INSN_BRCC_RC_D, "brcc_RC.d", "b", 32,
+    { 0|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* b$Rcc $RB,$U6,$label9 */
+  {
+    ARC_INSN_BRCC_U6, "brcc_U6", "b", 32,
+    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* b$Rcc.d $RB,$U6,$label9 */
+  {
+    ARC_INSN_BRCC_U6_D, "brcc_U6.d", "b", 32,
+    { 0|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* bl$uncondj$_S $label13a */
+  {
+    ARC_INSN_BL_S, "bl_s", "bl", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* bl$Qcondj$_L $label21 */
+  {
+    ARC_INSN_BLCC, "blcc", "bl", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* bl$Qcondj$_L.d $label21 */
+  {
+    ARC_INSN_BLCC_D, "blcc.d", "bl", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* bl$uncondj$_L $label25a */
+  {
+    ARC_INSN_BL, "bl", "bl", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* bl$uncondj$_L.d $label25a */
+  {
+    ARC_INSN_BL_D, "bl.d", "bl", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ld$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LD_ABS, "ld_abs", "ld", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ld$_AW$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LD__AW_ABS, "ld$_AW_abs", "ld", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ld.ab$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LD_AB_ABS, "ld.ab_abs", "ld.ab", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ld.as$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LD_AS_ABS, "ld.as_abs", "ld.as", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ld$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LD_ABC, "ld_abc", "ld", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ld$_AW$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LD__AW_ABC, "ld$_AW_abc", "ld", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ld.ab$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LD_AB_ABC, "ld.ab_abc", "ld.ab", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ld.as$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LD_AS_ABC, "ld.as_abc", "ld.as", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ld$_S $R_a,[$R_b,$R_c] */
+  {
+    ARC_INSN_LD_S_ABC, "ld_s_abc", "ld", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ld$_S $R_c,[$R_b,$sc_u5_] */
+  {
+    ARC_INSN_LD_S_ABU, "ld_s_abu", "ld", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ld$_S $R_b,[$SP,$u5x4] */
+  {
+    ARC_INSN_LD_S_ABSP, "ld_s_absp", "ld", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ld$_S $R_b,[$GP,$sc_s9_] */
+  {
+    ARC_INSN_LD_S_GPREL, "ld_s_gprel", "ld", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ld$_S $R_b,[$PCL,$u8x4] */
+  {
+    ARC_INSN_LD_S_PCREL, "ld_s_pcrel", "ld", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ldb$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDB_ABS, "ldb_abs", "ldb", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldb$_AW$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDB__AW_ABS, "ldb$_AW_abs", "ldb", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldb.ab$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDB_AB_ABS, "ldb.ab_abs", "ldb.ab", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldb.as$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDB_AS_ABS, "ldb.as_abs", "ldb.as", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldb$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDB_ABC, "ldb_abc", "ldb", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldb$_AW$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDB__AW_ABC, "ldb$_AW_abc", "ldb", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldb.ab$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDB_AB_ABC, "ldb.ab_abc", "ldb.ab", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldb.as$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDB_AS_ABC, "ldb.as_abc", "ldb.as", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldb$_S $R_a,[$R_b,$R_c] */
+  {
+    ARC_INSN_LDB_S_ABC, "ldb_s_abc", "ldb", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ldb$_S $R_c,[$R_b,$sc_u5b] */
+  {
+    ARC_INSN_LDB_S_ABU, "ldb_s_abu", "ldb", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ldb$_S $R_b,[$SP,$u5x4] */
+  {
+    ARC_INSN_LDB_S_ABSP, "ldb_s_absp", "ldb", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ldb$_S $R_b,[$GP,$sc_s9b] */
+  {
+    ARC_INSN_LDB_S_GPREL, "ldb_s_gprel", "ldb", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ldb.x$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDB_X_ABS, "ldb.x_abs", "ldb.x", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldb$_AW.x$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDB__AW_X_ABS, "ldb$_AW.x_abs", "ldb", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldb.ab.x$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDB_AB_X_ABS, "ldb.ab.x_abs", "ldb.ab.x", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldb.as.x$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDB_AS_X_ABS, "ldb.as.x_abs", "ldb.as.x", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldb.x$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDB_X_ABC, "ldb.x_abc", "ldb.x", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldb$_AW.x$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDB__AW_X_ABC, "ldb$_AW.x_abc", "ldb", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldb.ab.x$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDB_AB_X_ABC, "ldb.ab.x_abc", "ldb.ab.x", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldb.as.x$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDB_AS_X_ABC, "ldb.as.x_abc", "ldb.as.x", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldw$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDW_ABS, "ldw_abs", "ldw", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldw$_AW$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDW__AW_ABS, "ldw$_AW_abs", "ldw", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldw.ab$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDW_AB_ABS, "ldw.ab_abs", "ldw.ab", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldw.as$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDW_AS_ABS, "ldw.as_abs", "ldw.as", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldw$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDW_ABC, "ldw_abc", "ldw", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldw$_AW$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDW__AW_ABC, "ldw$_AW_abc", "ldw", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldw.ab$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDW_AB_ABC, "ldw.ab_abc", "ldw.ab", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldw.as$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDW_AS_ABC, "ldw.as_abc", "ldw.as", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldw$_S $R_a,[$R_b,$R_c] */
+  {
+    ARC_INSN_LDW_S_ABC, "ldw_s_abc", "ldw", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ldw$_S $R_c,[$R_b,$sc_u5w] */
+  {
+    ARC_INSN_LDW_S_ABU, "ldw_s_abu", "ldw", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ldw$_S $R_b,[$GP,$sc_s9w] */
+  {
+    ARC_INSN_LDW_S_GPREL, "ldw_s_gprel", "ldw", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ldw.x$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDW_X_ABS, "ldw.x_abs", "ldw.x", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldw$_AW.x$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDW__AW_X_ABS, "ldw$_AW.x_abs", "ldw", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldw.ab.x$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDW_AB_X_ABS, "ldw.ab.x_abs", "ldw.ab.x", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldw.as.x$LDODi $RA,[$RB,$s9] */
+  {
+    ARC_INSN_LDW_AS_X_ABS, "ldw.as.x_abs", "ldw.as.x", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ldw.x$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDW_X_ABC, "ldw.x_abc", "ldw.x", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldw$_AW.x$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDW__AW_X_ABC, "ldw$_AW.x_abc", "ldw", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldw.ab.x$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDW_AB_X_ABC, "ldw.ab.x_abc", "ldw.ab.x", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldw.as.x$LDRDi $RA,[$RB,$RC] */
+  {
+    ARC_INSN_LDW_AS_X_ABC, "ldw.as.x_abc", "ldw.as.x", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ldw$_S.x $R_c,[$R_b,$sc_u5w] */
+  {
+    ARC_INSN_LDW_S_X_ABU, "ldw_s.x_abu", "ldw", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* st$STODi $RC,[$RB,$s9] */
+  {
+    ARC_INSN_ST_ABS, "st_abs", "st", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* st$_AW$STODi $RC,[$RB,$s9] */
+  {
+    ARC_INSN_ST__AW_ABS, "st$_AW_abs", "st", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* st.ab$STODi $RC,[$RB,$s9] */
+  {
+    ARC_INSN_ST_AB_ABS, "st.ab_abs", "st.ab", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* st.as$STODi $RC,[$RB,$s9] */
+  {
+    ARC_INSN_ST_AS_ABS, "st.as_abs", "st.as", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* st$_S $R_c,[$R_b,$sc_u5_] */
+  {
+    ARC_INSN_ST_S_ABU, "st_s_abu", "st", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* st$_S $R_b,[$SP,$u5x4] */
+  {
+    ARC_INSN_ST_S_ABSP, "st_s_absp", "st", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* stb$STODi $RC,[$RB,$s9] */
+  {
+    ARC_INSN_STB_ABS, "stb_abs", "stb", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* stb$_AW$STODi $RC,[$RB,$s9] */
+  {
+    ARC_INSN_STB__AW_ABS, "stb$_AW_abs", "stb", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* stb.ab$STODi $RC,[$RB,$s9] */
+  {
+    ARC_INSN_STB_AB_ABS, "stb.ab_abs", "stb.ab", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* stb.as$STODi $RC,[$RB,$s9] */
+  {
+    ARC_INSN_STB_AS_ABS, "stb.as_abs", "stb.as", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* stb$_S $R_c,[$R_b,$sc_u5b] */
+  {
+    ARC_INSN_STB_S_ABU, "stb_s_abu", "stb", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* stb$_S $R_b,[$SP,$u5x4] */
+  {
+    ARC_INSN_STB_S_ABSP, "stb_s_absp", "stb", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* stw$STODi $RC,[$RB,$s9] */
+  {
+    ARC_INSN_STW_ABS, "stw_abs", "stw", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* stw$_AW$STODi $RC,[$RB,$s9] */
+  {
+    ARC_INSN_STW__AW_ABS, "stw$_AW_abs", "stw", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* stw.ab$STODi $RC,[$RB,$s9] */
+  {
+    ARC_INSN_STW_AB_ABS, "stw.ab_abs", "stw.ab", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* stw.as$STODi $RC,[$RB,$s9] */
+  {
+    ARC_INSN_STW_AS_ABS, "stw.as_abs", "stw.as", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* stw$_S $R_c,[$R_b,$sc_u5w] */
+  {
+    ARC_INSN_STW_S_ABU, "stw_s_abu", "stw", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* add$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_ADD_L_S12__RA_, "add_L_s12 $RA,", "add", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* add$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_ADD_CCU6__RA_, "add_ccu6 $RA,", "add", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* add$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_ADD_L_U6__RA_, "add_L_u6 $RA,", "add", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* add$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_ADD_L_R_R__RA__RC, "add_L_r_r $RA,$RC", "add", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* add$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_ADD_CC__RA__RC, "add_cc $RA,$RC", "add", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* add$_S $R_a,$R_b,$R_c */
+  {
+    ARC_INSN_ADD_S_ABC, "add_s_abc", "add", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* add$_S $R_c,$R_b,$u3 */
+  {
+    ARC_INSN_ADD_S_CBU3, "add_s_cbu3", "add", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* add$_S $R_b,$R_b,$Rh */
+  {
+    ARC_INSN_ADD_S_MCAH, "add_s_mcah", "add", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_H, 0 } } } }
+  },
+/* add$_S $R_b,$SP,$u5x4 */
+  {
+    ARC_INSN_ADD_S_ABSP, "add_s_absp", "add", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* add$_S $SP,$SP,$u5x4 */
+  {
+    ARC_INSN_ADD_S_ASSPSP, "add_s_asspsp", "add", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* add$_S $R0,$GP,$s9x4 */
+  {
+    ARC_INSN_ADD_S_GP, "add_s_gp", "add", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* add$_S $R_b,$R_b,$u7 */
+  {
+    ARC_INSN_ADD_S_R_U7, "add_s_r_u7", "add", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* adc$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_ADC_L_S12__RA_, "adc_L_s12 $RA,", "adc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* adc$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_ADC_CCU6__RA_, "adc_ccu6 $RA,", "adc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* adc$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_ADC_L_U6__RA_, "adc_L_u6 $RA,", "adc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* adc$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_ADC_L_R_R__RA__RC, "adc_L_r_r $RA,$RC", "adc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* adc$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_ADC_CC__RA__RC, "adc_cc $RA,$RC", "adc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* sub$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_SUB_L_S12__RA_, "sub_L_s12 $RA,", "sub", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sub$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_SUB_CCU6__RA_, "sub_ccu6 $RA,", "sub", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sub$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_SUB_L_U6__RA_, "sub_L_u6 $RA,", "sub", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sub$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_SUB_L_R_R__RA__RC, "sub_L_r_r $RA,$RC", "sub", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* sub$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_SUB_CC__RA__RC, "sub_cc $RA,$RC", "sub", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* sub$_S $R_c,$R_b,$u3 */
+  {
+    ARC_INSN_SUB_S_CBU3, "sub_s_cbu3", "sub", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* sub$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_SUB_S_GO, "I16_GO_SUB_s_go", "sub", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* sub$_S $NE$R_b,$R_b,$R_b */
+  {
+    ARC_INSN_SUB_S_GO_SUB_NE, "sub_s_go_sub_ne", "sub", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* sub$_S $R_b,$R_b,$u5 */
+  {
+    ARC_INSN_SUB_S_SSB, "sub_s_ssb", "sub", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* sub$_S $SP,$SP,$u5x4 */
+  {
+    ARC_INSN_SUB_S_ASSPSP, "sub_s_asspsp", "sub", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* sbc$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_SBC_L_S12__RA_, "sbc_L_s12 $RA,", "sbc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sbc$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_SBC_CCU6__RA_, "sbc_ccu6 $RA,", "sbc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sbc$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_SBC_L_U6__RA_, "sbc_L_u6 $RA,", "sbc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sbc$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_SBC_L_R_R__RA__RC, "sbc_L_r_r $RA,$RC", "sbc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* sbc$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_SBC_CC__RA__RC, "sbc_cc $RA,$RC", "sbc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* and$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_AND_L_S12__RA_, "and_L_s12 $RA,", "and", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* and$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_AND_CCU6__RA_, "and_ccu6 $RA,", "and", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* and$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_AND_L_U6__RA_, "and_L_u6 $RA,", "and", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* and$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_AND_L_R_R__RA__RC, "and_L_r_r $RA,$RC", "and", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* and$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_AND_CC__RA__RC, "and_cc $RA,$RC", "and", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* and$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_AND_S_GO, "I16_GO_AND_s_go", "and", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* or$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_OR_L_S12__RA_, "or_L_s12 $RA,", "or", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* or$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_OR_CCU6__RA_, "or_ccu6 $RA,", "or", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* or$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_OR_L_U6__RA_, "or_L_u6 $RA,", "or", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* or$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_OR_L_R_R__RA__RC, "or_L_r_r $RA,$RC", "or", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* or$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_OR_CC__RA__RC, "or_cc $RA,$RC", "or", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* or$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_OR_S_GO, "I16_GO_OR_s_go", "or", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* bic$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_BIC_L_S12__RA_, "bic_L_s12 $RA,", "bic", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bic$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_BIC_CCU6__RA_, "bic_ccu6 $RA,", "bic", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bic$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_BIC_L_U6__RA_, "bic_L_u6 $RA,", "bic", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bic$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_BIC_L_R_R__RA__RC, "bic_L_r_r $RA,$RC", "bic", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* bic$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_BIC_CC__RA__RC, "bic_cc $RA,$RC", "bic", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* bic$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_BIC_S_GO, "I16_GO_BIC_s_go", "bic", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* xor$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_XOR_L_S12__RA_, "xor_L_s12 $RA,", "xor", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* xor$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_XOR_CCU6__RA_, "xor_ccu6 $RA,", "xor", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* xor$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_XOR_L_U6__RA_, "xor_L_u6 $RA,", "xor", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* xor$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_XOR_L_R_R__RA__RC, "xor_L_r_r $RA,$RC", "xor", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* xor$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_XOR_CC__RA__RC, "xor_cc $RA,$RC", "xor", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* xor$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_XOR_S_GO, "I16_GO_XOR_s_go", "xor", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* max$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_MAX_L_S12__RA_, "max_L_s12 $RA,", "max", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* max$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_MAX_CCU6__RA_, "max_ccu6 $RA,", "max", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* max$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_MAX_L_U6__RA_, "max_L_u6 $RA,", "max", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* max$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_MAX_L_R_R__RA__RC, "max_L_r_r $RA,$RC", "max", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* max$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_MAX_CC__RA__RC, "max_cc $RA,$RC", "max", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* min$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_MIN_L_S12__RA_, "min_L_s12 $RA,", "min", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* min$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_MIN_CCU6__RA_, "min_ccu6 $RA,", "min", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* min$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_MIN_L_U6__RA_, "min_L_u6 $RA,", "min", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* min$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_MIN_L_R_R__RA__RC, "min_L_r_r $RA,$RC", "min", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* min$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_MIN_CC__RA__RC, "min_cc $RA,$RC", "min", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mov$_L$F $RB,$s12 */
+  {
+    ARC_INSN_MOV_L_S12_, "mov_L_s12 ", "mov", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* mov$Qcondi$F $RB,$U6 */
+  {
+    ARC_INSN_MOV_CCU6_, "mov_ccu6 ", "mov", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* mov$_L$F $RB,$U6 */
+  {
+    ARC_INSN_MOV_L_U6_, "mov_L_u6 ", "mov", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* mov$_L$F $RB,$RC */
+  {
+    ARC_INSN_MOV_L_R_R__RC, "mov_L_r_r $RC", "mov", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* mov$Qcondi$F $RB,$RC */
+  {
+    ARC_INSN_MOV_CC__RC, "mov_cc $RC", "mov", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* mov$_S $R_b,$Rh */
+  {
+    ARC_INSN_MOV_S_MCAH, "mov_s_mcah", "mov", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_H, 0 } } } }
+  },
+/* mov$_S $Rh,$R_b */
+  {
+    ARC_INSN_MOV_S_MCAHB, "mov_s_mcahb", "mov", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* mov$_S $R_b,$u7 */
+  {
+    ARC_INSN_MOV_S_R_U7, "mov_s_r_u7", "mov", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* tst$_L$F1 $RB,$s12 */
+  {
+    ARC_INSN_TST_L_S12_, "tst_L_s12 ", "tst", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* tst$Qcondi$F1 $RB,$U6 */
+  {
+    ARC_INSN_TST_CCU6_, "tst_ccu6 ", "tst", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* tst$_L$F1 $RB,$U6 */
+  {
+    ARC_INSN_TST_L_U6_, "tst_L_u6 ", "tst", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* tst$_L$F1 $RB,$RC */
+  {
+    ARC_INSN_TST_L_R_R__RC, "tst_L_r_r $RC", "tst", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* tst$Qcondi$F1 $RB,$RC */
+  {
+    ARC_INSN_TST_CC__RC, "tst_cc $RC", "tst", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* tst$_S $R_b,$R_c */
+  {
+    ARC_INSN_TST_S_GO, "tst_s_go", "tst", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* cmp$_L$F1 $RB,$s12 */
+  {
+    ARC_INSN_CMP_L_S12_, "cmp_L_s12 ", "cmp", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* cmp$Qcondi$F1 $RB,$U6 */
+  {
+    ARC_INSN_CMP_CCU6_, "cmp_ccu6 ", "cmp", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* cmp$_L$F1 $RB,$U6 */
+  {
+    ARC_INSN_CMP_L_U6_, "cmp_L_u6 ", "cmp", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* cmp$_L$F1 $RB,$RC */
+  {
+    ARC_INSN_CMP_L_R_R__RC, "cmp_L_r_r $RC", "cmp", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* cmp$Qcondi$F1 $RB,$RC */
+  {
+    ARC_INSN_CMP_CC__RC, "cmp_cc $RC", "cmp", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* cmp$_S $R_b,$Rh */
+  {
+    ARC_INSN_CMP_S_MCAH, "cmp_s_mcah", "cmp", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_H, 0 } } } }
+  },
+/* cmp$_S $R_b,$u7 */
+  {
+    ARC_INSN_CMP_S_R_U7, "cmp_s_r_u7", "cmp", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* rcmp$_L$F1 $RB,$s12 */
+  {
+    ARC_INSN_RCMP_L_S12_, "rcmp_L_s12 ", "rcmp", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* rcmp$Qcondi$F1 $RB,$U6 */
+  {
+    ARC_INSN_RCMP_CCU6_, "rcmp_ccu6 ", "rcmp", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* rcmp$_L$F1 $RB,$U6 */
+  {
+    ARC_INSN_RCMP_L_U6_, "rcmp_L_u6 ", "rcmp", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* rcmp$_L$F1 $RB,$RC */
+  {
+    ARC_INSN_RCMP_L_R_R__RC, "rcmp_L_r_r $RC", "rcmp", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* rcmp$Qcondi$F1 $RB,$RC */
+  {
+    ARC_INSN_RCMP_CC__RC, "rcmp_cc $RC", "rcmp", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* rsub$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_RSUB_L_S12__RA_, "rsub_L_s12 $RA,", "rsub", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* rsub$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_RSUB_CCU6__RA_, "rsub_ccu6 $RA,", "rsub", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* rsub$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_RSUB_L_U6__RA_, "rsub_L_u6 $RA,", "rsub", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* rsub$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_RSUB_L_R_R__RA__RC, "rsub_L_r_r $RA,$RC", "rsub", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* rsub$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_RSUB_CC__RA__RC, "rsub_cc $RA,$RC", "rsub", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* bset$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_BSET_L_S12__RA_, "bset_L_s12 $RA,", "bset", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bset$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_BSET_CCU6__RA_, "bset_ccu6 $RA,", "bset", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bset$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_BSET_L_U6__RA_, "bset_L_u6 $RA,", "bset", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bset$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_BSET_L_R_R__RA__RC, "bset_L_r_r $RA,$RC", "bset", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* bset$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_BSET_CC__RA__RC, "bset_cc $RA,$RC", "bset", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* bset$_S $R_b,$R_b,$u5 */
+  {
+    ARC_INSN_BSET_S_SSB, "bset_s_ssb", "bset", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* bclr$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_BCLR_L_S12__RA_, "bclr_L_s12 $RA,", "bclr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bclr$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_BCLR_CCU6__RA_, "bclr_ccu6 $RA,", "bclr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bclr$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_BCLR_L_U6__RA_, "bclr_L_u6 $RA,", "bclr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bclr$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_BCLR_L_R_R__RA__RC, "bclr_L_r_r $RA,$RC", "bclr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* bclr$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_BCLR_CC__RA__RC, "bclr_cc $RA,$RC", "bclr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* bclr$_S $R_b,$R_b,$u5 */
+  {
+    ARC_INSN_BCLR_S_SSB, "bclr_s_ssb", "bclr", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* btst$_L$F1 $RB,$s12 */
+  {
+    ARC_INSN_BTST_L_S12_, "btst_L_s12 ", "btst", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* btst$Qcondi$F1 $RB,$U6 */
+  {
+    ARC_INSN_BTST_CCU6_, "btst_ccu6 ", "btst", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* btst$_L$F1 $RB,$U6 */
+  {
+    ARC_INSN_BTST_L_U6_, "btst_L_u6 ", "btst", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* btst$_L$F1 $RB,$RC */
+  {
+    ARC_INSN_BTST_L_R_R__RC, "btst_L_r_r $RC", "btst", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* btst$Qcondi$F1 $RB,$RC */
+  {
+    ARC_INSN_BTST_CC__RC, "btst_cc $RC", "btst", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* btst$_S $R_b,$u5 */
+  {
+    ARC_INSN_BTST_S_SSB, "btst_s_ssb", "btst", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* bxor$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_BXOR_L_S12__RA_, "bxor_L_s12 $RA,", "bxor", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bxor$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_BXOR_CCU6__RA_, "bxor_ccu6 $RA,", "bxor", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bxor$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_BXOR_L_U6__RA_, "bxor_L_u6 $RA,", "bxor", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bxor$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_BXOR_L_R_R__RA__RC, "bxor_L_r_r $RA,$RC", "bxor", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* bxor$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_BXOR_CC__RA__RC, "bxor_cc $RA,$RC", "bxor", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* bmsk$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_BMSK_L_S12__RA_, "bmsk_L_s12 $RA,", "bmsk", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bmsk$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_BMSK_CCU6__RA_, "bmsk_ccu6 $RA,", "bmsk", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bmsk$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_BMSK_L_U6__RA_, "bmsk_L_u6 $RA,", "bmsk", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* bmsk$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_BMSK_L_R_R__RA__RC, "bmsk_L_r_r $RA,$RC", "bmsk", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* bmsk$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_BMSK_CC__RA__RC, "bmsk_cc $RA,$RC", "bmsk", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* bmsk$_S $R_b,$R_b,$u5 */
+  {
+    ARC_INSN_BMSK_S_SSB, "bmsk_s_ssb", "bmsk", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* add1$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_ADD1_L_S12__RA_, "add1_L_s12 $RA,", "add1", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* add1$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_ADD1_CCU6__RA_, "add1_ccu6 $RA,", "add1", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* add1$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_ADD1_L_U6__RA_, "add1_L_u6 $RA,", "add1", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* add1$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_ADD1_L_R_R__RA__RC, "add1_L_r_r $RA,$RC", "add1", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* add1$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_ADD1_CC__RA__RC, "add1_cc $RA,$RC", "add1", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* add1$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_ADD1_S_GO, "I16_GO_ADD1_s_go", "add1", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* add2$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_ADD2_L_S12__RA_, "add2_L_s12 $RA,", "add2", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* add2$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_ADD2_CCU6__RA_, "add2_ccu6 $RA,", "add2", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* add2$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_ADD2_L_U6__RA_, "add2_L_u6 $RA,", "add2", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* add2$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_ADD2_L_R_R__RA__RC, "add2_L_r_r $RA,$RC", "add2", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* add2$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_ADD2_CC__RA__RC, "add2_cc $RA,$RC", "add2", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* add2$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_ADD2_S_GO, "I16_GO_ADD2_s_go", "add2", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* add3$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_ADD3_L_S12__RA_, "add3_L_s12 $RA,", "add3", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* add3$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_ADD3_CCU6__RA_, "add3_ccu6 $RA,", "add3", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* add3$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_ADD3_L_U6__RA_, "add3_L_u6 $RA,", "add3", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* add3$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_ADD3_L_R_R__RA__RC, "add3_L_r_r $RA,$RC", "add3", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* add3$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_ADD3_CC__RA__RC, "add3_cc $RA,$RC", "add3", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* add3$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_ADD3_S_GO, "I16_GO_ADD3_s_go", "add3", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* sub1$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_SUB1_L_S12__RA_, "sub1_L_s12 $RA,", "sub1", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sub1$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_SUB1_CCU6__RA_, "sub1_ccu6 $RA,", "sub1", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sub1$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_SUB1_L_U6__RA_, "sub1_L_u6 $RA,", "sub1", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sub1$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_SUB1_L_R_R__RA__RC, "sub1_L_r_r $RA,$RC", "sub1", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* sub1$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_SUB1_CC__RA__RC, "sub1_cc $RA,$RC", "sub1", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* sub2$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_SUB2_L_S12__RA_, "sub2_L_s12 $RA,", "sub2", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sub2$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_SUB2_CCU6__RA_, "sub2_ccu6 $RA,", "sub2", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sub2$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_SUB2_L_U6__RA_, "sub2_L_u6 $RA,", "sub2", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sub2$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_SUB2_L_R_R__RA__RC, "sub2_L_r_r $RA,$RC", "sub2", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* sub2$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_SUB2_CC__RA__RC, "sub2_cc $RA,$RC", "sub2", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* sub3$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_SUB3_L_S12__RA_, "sub3_L_s12 $RA,", "sub3", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sub3$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_SUB3_CCU6__RA_, "sub3_ccu6 $RA,", "sub3", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sub3$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_SUB3_L_U6__RA_, "sub3_L_u6 $RA,", "sub3", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sub3$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_SUB3_L_R_R__RA__RC, "sub3_L_r_r $RA,$RC", "sub3", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* sub3$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_SUB3_CC__RA__RC, "sub3_cc $RA,$RC", "sub3", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mpy$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_MPY_L_S12__RA_, "mpy_L_s12 $RA,", "mpy", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mpy$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_MPY_CCU6__RA_, "mpy_ccu6 $RA,", "mpy", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mpy$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_MPY_L_U6__RA_, "mpy_L_u6 $RA,", "mpy", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mpy$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_MPY_L_R_R__RA__RC, "mpy_L_r_r $RA,$RC", "mpy", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mpy$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_MPY_CC__RA__RC, "mpy_cc $RA,$RC", "mpy", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mpyh$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_MPYH_L_S12__RA_, "mpyh_L_s12 $RA,", "mpyh", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mpyh$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_MPYH_CCU6__RA_, "mpyh_ccu6 $RA,", "mpyh", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mpyh$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_MPYH_L_U6__RA_, "mpyh_L_u6 $RA,", "mpyh", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mpyh$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_MPYH_L_R_R__RA__RC, "mpyh_L_r_r $RA,$RC", "mpyh", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mpyh$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_MPYH_CC__RA__RC, "mpyh_cc $RA,$RC", "mpyh", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mpyhu$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_MPYHU_L_S12__RA_, "mpyhu_L_s12 $RA,", "mpyhu", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mpyhu$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_MPYHU_CCU6__RA_, "mpyhu_ccu6 $RA,", "mpyhu", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mpyhu$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_MPYHU_L_U6__RA_, "mpyhu_L_u6 $RA,", "mpyhu", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mpyhu$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_MPYHU_L_R_R__RA__RC, "mpyhu_L_r_r $RA,$RC", "mpyhu", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mpyhu$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_MPYHU_CC__RA__RC, "mpyhu_cc $RA,$RC", "mpyhu", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mpyu$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_MPYU_L_S12__RA_, "mpyu_L_s12 $RA,", "mpyu", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mpyu$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_MPYU_CCU6__RA_, "mpyu_ccu6 $RA,", "mpyu", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mpyu$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_MPYU_L_U6__RA_, "mpyu_L_u6 $RA,", "mpyu", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mpyu$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_MPYU_L_R_R__RA__RC, "mpyu_L_r_r $RA,$RC", "mpyu", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mpyu$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_MPYU_CC__RA__RC, "mpyu_cc $RA,$RC", "mpyu", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* j$_L$F0 [$RC_noilink] */
+  {
+    ARC_INSN_J_L_R_R___RC_NOILINK_, "j_L_r_r [$RC_noilink]", "j", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* j$Qcondi$F0 [$RC_noilink] */
+  {
+    ARC_INSN_J_CC___RC_NOILINK_, "j_cc [$RC_noilink]", "j", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* j$_L$F1F [$RC_ilink] */
+  {
+    ARC_INSN_J_L_R_R___RC_ILINK_, "j_L_r_r [$RC_ilink]", "j", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* j$Qcondi$F1F [$RC_ilink] */
+  {
+    ARC_INSN_J_CC___RC_ILINK_, "j_cc [$RC_ilink]", "j", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* j$_L$F0 $s12 */
+  {
+    ARC_INSN_J_L_S12_, "j_L_s12 ", "j", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* j$Qcondi$F0 $U6 */
+  {
+    ARC_INSN_J_CCU6_, "j_ccu6 ", "j", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* j$_L$F0 $U6 */
+  {
+    ARC_INSN_J_L_U6_, "j_L_u6 ", "j", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* j$_S [$R_b] */
+  {
+    ARC_INSN_J_S, "j_s", "j", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* j$_S [$R31] */
+  {
+    ARC_INSN_J_S__S, "j_s$_S", "j", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* jeq$_S [$R31] */
+  {
+    ARC_INSN_J_SEQ__S, "j_seq$_S", "jeq", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* jne$_S [$R31] */
+  {
+    ARC_INSN_J_SNE__S, "j_sne$_S", "jne", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* j$_L$F0.d $s12 */
+  {
+    ARC_INSN_J_L_S12_D_, "j_L_s12.d ", "j", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* j$Qcondi$F0.d $U6 */
+  {
+    ARC_INSN_J_CCU6_D_, "j_ccu6.d ", "j", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* j$_L$F0.d $U6 */
+  {
+    ARC_INSN_J_L_U6_D_, "j_L_u6.d ", "j", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* j$_L$F0.d [$RC] */
+  {
+    ARC_INSN_J_L_R_R_D___RC_, "j_L_r_r.d [$RC]", "j", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* j$Qcondi$F0.d [$RC] */
+  {
+    ARC_INSN_J_CC_D___RC_, "j_cc.d [$RC]", "j", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* j$_S.d [$R_b] */
+  {
+    ARC_INSN_J_S_D, "j_s.d", "j", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* j$_S.d [$R31] */
+  {
+    ARC_INSN_J_S__S_D, "j_s$_S.d", "j", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* jl$_L$F0 $s12 */
+  {
+    ARC_INSN_JL_L_S12_, "jl_L_s12 ", "jl", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* jl$Qcondi$F0 $U6 */
+  {
+    ARC_INSN_JL_CCU6_, "jl_ccu6 ", "jl", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* jl$_L$F0 $U6 */
+  {
+    ARC_INSN_JL_L_U6_, "jl_L_u6 ", "jl", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* jl$_S [$R_b] */
+  {
+    ARC_INSN_JL_S, "jl_s", "jl", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* jl$_L$F0 [$RC_noilink] */
+  {
+    ARC_INSN_JL_L_R_R___RC_NOILINK_, "jl_L_r_r [$RC_noilink]", "jl", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* jl$Qcondi$F0 [$RC_noilink] */
+  {
+    ARC_INSN_JL_CC___RC_NOILINK_, "jl_cc [$RC_noilink]", "jl", 32,
+    { 0|A(RELAXED)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* jl$_L$F0.d $s12 */
+  {
+    ARC_INSN_JL_L_S12_D_, "jl_L_s12.d ", "jl", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* jl$Qcondi$F0.d $U6 */
+  {
+    ARC_INSN_JL_CCU6_D_, "jl_ccu6.d ", "jl", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* jl$_L$F0.d $U6 */
+  {
+    ARC_INSN_JL_L_U6_D_, "jl_L_u6.d ", "jl", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* jl$_L$F0.d [$RC] */
+  {
+    ARC_INSN_JL_L_R_R_D___RC_, "jl_L_r_r.d [$RC]", "jl", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* jl$Qcondi$F0.d [$RC] */
+  {
+    ARC_INSN_JL_CC_D___RC_, "jl_cc.d [$RC]", "jl", 32,
+    { 0|A(RELAXED)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* jl$_S.d [$R_b] */
+  {
+    ARC_INSN_JL_S_D, "jl_s.d", "jl", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* lp$_L$F0 $s12x2 */
+  {
+    ARC_INSN_LP_L_S12_, "lp_L_s12 ", "lp", 32,
+    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* lp$Qcondi$F0 $U6x2 */
+  {
+    ARC_INSN_LPCC_CCU6, "lpcc_ccu6", "lp", 32,
+    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* flag$_L$F0 $s12 */
+  {
+    ARC_INSN_FLAG_L_S12_, "flag_L_s12 ", "flag", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* flag$Qcondi$F0 $U6 */
+  {
+    ARC_INSN_FLAG_CCU6_, "flag_ccu6 ", "flag", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* flag$_L$F0 $U6 */
+  {
+    ARC_INSN_FLAG_L_U6_, "flag_L_u6 ", "flag", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* flag$_L$F0 $RC */
+  {
+    ARC_INSN_FLAG_L_R_R__RC, "flag_L_r_r $RC", "flag", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* flag$Qcondi$F0 $RC */
+  {
+    ARC_INSN_FLAG_CC__RC, "flag_cc $RC", "flag", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* lr$_L$F0 $RB,[$RC] */
+  {
+    ARC_INSN_LR_L_R_R___RC_, "lr_L_r_r [$RC]", "lr", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* lr$_L$F0 $RB,[$s12] */
+  {
+    ARC_INSN_LR_L_S12_, "lr_L_s12 ", "lr", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* lr$_L$F0 $RB,[$U6] */
+  {
+    ARC_INSN_LR_L_U6_, "lr_L_u6 ", "lr", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sr$_L$F0 $RB,[$RC] */
+  {
+    ARC_INSN_SR_L_R_R___RC_, "sr_L_r_r [$RC]", "sr", 32,
+    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* sr$_L$F0 $RB,[$s12] */
+  {
+    ARC_INSN_SR_L_S12_, "sr_L_s12 ", "sr", 32,
+    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sr$_L$F0 $RB,[$U6] */
+  {
+    ARC_INSN_SR_L_U6_, "sr_L_u6 ", "sr", 32,
+    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asl$_L$F $RB,$RC */
+  {
+    ARC_INSN_ASL_L_R_R__RC, "asl_L_r_r $RC", "asl", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* asl$_L$F $RB,$U6 */
+  {
+    ARC_INSN_ASL_L_U6_, "asl_L_u6 ", "asl", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asl$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_ASL_S_GO, "I16_GO_ASL_s_go", "asl", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* asr$_L$F $RB,$RC */
+  {
+    ARC_INSN_ASR_L_R_R__RC, "asr_L_r_r $RC", "asr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* asr$_L$F $RB,$U6 */
+  {
+    ARC_INSN_ASR_L_U6_, "asr_L_u6 ", "asr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asr$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_ASR_S_GO, "I16_GO_ASR_s_go", "asr", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* lsr$_L$F $RB,$RC */
+  {
+    ARC_INSN_LSR_L_R_R__RC, "lsr_L_r_r $RC", "lsr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* lsr$_L$F $RB,$U6 */
+  {
+    ARC_INSN_LSR_L_U6_, "lsr_L_u6 ", "lsr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* lsr$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_LSR_S_GO, "I16_GO_LSR_s_go", "lsr", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ror$_L$F $RB,$RC */
+  {
+    ARC_INSN_ROR_L_R_R__RC, "ror_L_r_r $RC", "ror", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* ror$_L$F $RB,$U6 */
+  {
+    ARC_INSN_ROR_L_U6_, "ror_L_u6 ", "ror", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* rrc$_L$F $RB,$RC */
+  {
+    ARC_INSN_RRC_L_R_R__RC, "rrc_L_r_r $RC", "rrc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* rrc$_L$F $RB,$U6 */
+  {
+    ARC_INSN_RRC_L_U6_, "rrc_L_u6 ", "rrc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sexb$_L$F $RB,$RC */
+  {
+    ARC_INSN_SEXB_L_R_R__RC, "sexb_L_r_r $RC", "sexb", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* sexb$_L$F $RB,$U6 */
+  {
+    ARC_INSN_SEXB_L_U6_, "sexb_L_u6 ", "sexb", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sexb$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_SEXB_S_GO, "I16_GO_SEXB_s_go", "sexb", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* sexw$_L$F $RB,$RC */
+  {
+    ARC_INSN_SEXW_L_R_R__RC, "sexw_L_r_r $RC", "sexw", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* sexw$_L$F $RB,$U6 */
+  {
+    ARC_INSN_SEXW_L_U6_, "sexw_L_u6 ", "sexw", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* sexw$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_SEXW_S_GO, "I16_GO_SEXW_s_go", "sexw", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* extb$_L$F $RB,$RC */
+  {
+    ARC_INSN_EXTB_L_R_R__RC, "extb_L_r_r $RC", "extb", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* extb$_L$F $RB,$U6 */
+  {
+    ARC_INSN_EXTB_L_U6_, "extb_L_u6 ", "extb", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* extb$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_EXTB_S_GO, "I16_GO_EXTB_s_go", "extb", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* extw$_L$F $RB,$RC */
+  {
+    ARC_INSN_EXTW_L_R_R__RC, "extw_L_r_r $RC", "extw", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* extw$_L$F $RB,$U6 */
+  {
+    ARC_INSN_EXTW_L_U6_, "extw_L_u6 ", "extw", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* extw$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_EXTW_S_GO, "I16_GO_EXTW_s_go", "extw", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* abs$_L$F $RB,$RC */
+  {
+    ARC_INSN_ABS_L_R_R__RC, "abs_L_r_r $RC", "abs", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* abs$_L$F $RB,$U6 */
+  {
+    ARC_INSN_ABS_L_U6_, "abs_L_u6 ", "abs", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* abs$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_ABS_S_GO, "I16_GO_ABS_s_go", "abs", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* not$_L$F $RB,$RC */
+  {
+    ARC_INSN_NOT_L_R_R__RC, "not_L_r_r $RC", "not", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* not$_L$F $RB,$U6 */
+  {
+    ARC_INSN_NOT_L_U6_, "not_L_u6 ", "not", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* not$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_NOT_S_GO, "I16_GO_NOT_s_go", "not", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* rlc$_L$F $RB,$RC */
+  {
+    ARC_INSN_RLC_L_R_R__RC, "rlc_L_r_r $RC", "rlc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* rlc$_L$F $RB,$U6 */
+  {
+    ARC_INSN_RLC_L_U6_, "rlc_L_u6 ", "rlc", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ex$_L$EXDi $RB,$RC */
+  {
+    ARC_INSN_EX_L_R_R__RC, "ex_L_r_r $RC", "ex", 32,
+    { 0, { { { (1<<MACH_ARC700), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ex$_L$EXDi $RB,$U6 */
+  {
+    ARC_INSN_EX_L_U6_, "ex_L_u6 ", "ex", 32,
+    { 0, { { { (1<<MACH_ARC700), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* neg$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_NEG_S_GO, "I16_GO_NEG_s_go", "neg", 32,
+    { 0|A(SHORT_P), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* swi */
+  {
+    ARC_INSN_SWI, "swi", "swi", 32,
+    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* trap$_S $trapnum */
+  {
+    ARC_INSN_TRAP_S, "trap_s", "trap", 32,
+    { 0|A(SHORT_P)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* brk */
+  {
+    ARC_INSN_BRK, "brk", "brk", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* brk_s */
+  {
+    ARC_INSN_BRK_S, "brk_s", "brk_s", 32,
+    { 0|A(SHORT_P), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* asl$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_ASL_L_S12__RA_, "asl_L_s12 $RA,", "asl", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asl$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_ASL_CCU6__RA_, "asl_ccu6 $RA,", "asl", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asl$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_ASL_L_U6__RA_, "asl_L_u6 $RA,", "asl", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asl$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_ASL_L_R_R__RA__RC, "asl_L_r_r $RA,$RC", "asl", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* asl$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_ASL_CC__RA__RC, "asl_cc $RA,$RC", "asl", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* asl$_S $R_c,$R_b,$u3 */
+  {
+    ARC_INSN_ASL_S_CBU3, "asl_s_cbu3", "asl", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* asl$_S $R_b,$R_b,$u5 */
+  {
+    ARC_INSN_ASL_S_SSB, "asl_s_ssb", "asl", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* asl$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_ASLM_S_GO, "I16_GO_ASLM_s_go", "asl", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* lsr$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_LSR_L_S12__RA_, "lsr_L_s12 $RA,", "lsr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* lsr$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_LSR_CCU6__RA_, "lsr_ccu6 $RA,", "lsr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* lsr$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_LSR_L_U6__RA_, "lsr_L_u6 $RA,", "lsr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* lsr$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_LSR_L_R_R__RA__RC, "lsr_L_r_r $RA,$RC", "lsr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* lsr$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_LSR_CC__RA__RC, "lsr_cc $RA,$RC", "lsr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* lsr$_S $R_b,$R_b,$u5 */
+  {
+    ARC_INSN_LSR_S_SSB, "lsr_s_ssb", "lsr", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* lsr$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_LSRM_S_GO, "I16_GO_LSRM_s_go", "lsr", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* asr$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_ASR_L_S12__RA_, "asr_L_s12 $RA,", "asr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asr$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_ASR_CCU6__RA_, "asr_ccu6 $RA,", "asr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asr$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_ASR_L_U6__RA_, "asr_L_u6 $RA,", "asr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asr$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_ASR_L_R_R__RA__RC, "asr_L_r_r $RA,$RC", "asr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* asr$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_ASR_CC__RA__RC, "asr_cc $RA,$RC", "asr", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* asr$_S $R_c,$R_b,$u3 */
+  {
+    ARC_INSN_ASR_S_CBU3, "asr_s_cbu3", "asr", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* asr$_S $R_b,$R_b,$u5 */
+  {
+    ARC_INSN_ASR_S_SSB, "asr_s_ssb", "asr", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* asr$_S $R_b,$R_b,$R_c */
+  {
+    ARC_INSN_I16_GO_ASRM_S_GO, "I16_GO_ASRM_s_go", "asr", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* ror$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_ROR_L_S12__RA_, "ror_L_s12 $RA,", "ror", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ror$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_ROR_CCU6__RA_, "ror_ccu6 $RA,", "ror", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ror$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_ROR_L_U6__RA_, "ror_L_u6 $RA,", "ror", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* ror$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_ROR_L_R_R__RA__RC, "ror_L_r_r $RA,$RC", "ror", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* ror$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_ROR_CC__RA__RC, "ror_cc $RA,$RC", "ror", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mul64$_L$F1 $RB,$s12 */
+  {
+    ARC_INSN_MUL64_L_S12_, "mul64_L_s12 ", "mul64", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mul64$Qcondi$F1 $RB,$U6 */
+  {
+    ARC_INSN_MUL64_CCU6_, "mul64_ccu6 ", "mul64", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mul64$_L$F1 $RB,$U6 */
+  {
+    ARC_INSN_MUL64_L_U6_, "mul64_L_u6 ", "mul64", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mul64$_L$F1 $RB,$RC */
+  {
+    ARC_INSN_MUL64_L_R_R__RC, "mul64_L_r_r $RC", "mul64", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mul64$Qcondi$F1 $RB,$RC */
+  {
+    ARC_INSN_MUL64_CC__RC, "mul64_cc $RC", "mul64", 32,
+    { 0|A(RELAXED), { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mul64$_S $R_b,$R_c */
+  {
+    ARC_INSN_MUL64_S_GO, "mul64_s_go", "mul64", 32,
+    { 0|A(SHORT_P)|A(RELAXABLE), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* mulu64$_L$F1 $RB,$s12 */
+  {
+    ARC_INSN_MULU64_L_S12_, "mulu64_L_s12 ", "mulu64", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mulu64$Qcondi$F1 $RB,$U6 */
+  {
+    ARC_INSN_MULU64_CCU6_, "mulu64_ccu6 ", "mulu64", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mulu64$_L$F1 $RB,$U6 */
+  {
+    ARC_INSN_MULU64_L_U6_, "mulu64_L_u6 ", "mulu64", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mulu64$_L$F1 $RB,$RC */
+  {
+    ARC_INSN_MULU64_L_R_R__RC, "mulu64_L_r_r $RC", "mulu64", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mulu64$Qcondi$F1 $RB,$RC */
+  {
+    ARC_INSN_MULU64_CC__RC, "mulu64_cc $RC", "mulu64", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* adds$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_ADDS_L_S12__RA_, "adds_L_s12 $RA,", "adds", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* adds$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_ADDS_CCU6__RA_, "adds_ccu6 $RA,", "adds", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* adds$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_ADDS_L_U6__RA_, "adds_L_u6 $RA,", "adds", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* adds$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_ADDS_L_R_R__RA__RC, "adds_L_r_r $RA,$RC", "adds", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* adds$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_ADDS_CC__RA__RC, "adds_cc $RA,$RC", "adds", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* subs$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_SUBS_L_S12__RA_, "subs_L_s12 $RA,", "subs", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* subs$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_SUBS_CCU6__RA_, "subs_ccu6 $RA,", "subs", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* subs$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_SUBS_L_U6__RA_, "subs_L_u6 $RA,", "subs", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* subs$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_SUBS_L_R_R__RA__RC, "subs_L_r_r $RA,$RC", "subs", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* subs$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_SUBS_CC__RA__RC, "subs_cc $RA,$RC", "subs", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* divaw$_L$F0 $RB,$RB,$s12 */
+  {
+    ARC_INSN_DIVAW_L_S12__RA_, "divaw_L_s12 $RA,", "divaw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* divaw$Qcondi$F0 $RB,$RB,$U6 */
+  {
+    ARC_INSN_DIVAW_CCU6__RA_, "divaw_ccu6 $RA,", "divaw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* divaw$_L$F0 $RA,$RB,$U6 */
+  {
+    ARC_INSN_DIVAW_L_U6__RA_, "divaw_L_u6 $RA,", "divaw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* divaw$_L$F0 $RA,$RB,$RC */
+  {
+    ARC_INSN_DIVAW_L_R_R__RA__RC, "divaw_L_r_r $RA,$RC", "divaw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* divaw$Qcondi$F0 $RB,$RB,$RC */
+  {
+    ARC_INSN_DIVAW_CC__RA__RC, "divaw_cc $RA,$RC", "divaw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* asls$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_ASLS_L_S12__RA_, "asls_L_s12 $RA,", "asls", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asls$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_ASLS_CCU6__RA_, "asls_ccu6 $RA,", "asls", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asls$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_ASLS_L_U6__RA_, "asls_L_u6 $RA,", "asls", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asls$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_ASLS_L_R_R__RA__RC, "asls_L_r_r $RA,$RC", "asls", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* asls$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_ASLS_CC__RA__RC, "asls_cc $RA,$RC", "asls", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* asrs$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_ASRS_L_S12__RA_, "asrs_L_s12 $RA,", "asrs", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asrs$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_ASRS_CCU6__RA_, "asrs_ccu6 $RA,", "asrs", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asrs$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_ASRS_L_U6__RA_, "asrs_L_u6 $RA,", "asrs", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* asrs$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_ASRS_L_R_R__RA__RC, "asrs_L_r_r $RA,$RC", "asrs", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* asrs$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_ASRS_CC__RA__RC, "asrs_cc $RA,$RC", "asrs", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* addsdw$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_ADDSDW_L_S12__RA_, "addsdw_L_s12 $RA,", "addsdw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* addsdw$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_ADDSDW_CCU6__RA_, "addsdw_ccu6 $RA,", "addsdw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* addsdw$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_ADDSDW_L_U6__RA_, "addsdw_L_u6 $RA,", "addsdw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* addsdw$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_ADDSDW_L_R_R__RA__RC, "addsdw_L_r_r $RA,$RC", "addsdw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* addsdw$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_ADDSDW_CC__RA__RC, "addsdw_cc $RA,$RC", "addsdw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* subsdw$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_SUBSDW_L_S12__RA_, "subsdw_L_s12 $RA,", "subsdw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* subsdw$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_SUBSDW_CCU6__RA_, "subsdw_ccu6 $RA,", "subsdw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* subsdw$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_SUBSDW_L_U6__RA_, "subsdw_L_u6 $RA,", "subsdw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* subsdw$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_SUBSDW_L_R_R__RA__RC, "subsdw_L_r_r $RA,$RC", "subsdw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* subsdw$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_SUBSDW_CC__RA__RC, "subsdw_cc $RA,$RC", "subsdw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* swap$_L$F $RB,$RC */
+  {
+    ARC_INSN_SWAP_L_R_R__RC, "swap_L_r_r $RC", "swap", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* swap$_L$F $RB,$U6 */
+  {
+    ARC_INSN_SWAP_L_U6_, "swap_L_u6 ", "swap", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* norm$_L$F $RB,$RC */
+  {
+    ARC_INSN_NORM_L_R_R__RC, "norm_L_r_r $RC", "norm", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* norm$_L$F $RB,$U6 */
+  {
+    ARC_INSN_NORM_L_U6_, "norm_L_u6 ", "norm", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* rnd16$_L$F $RB,$RC */
+  {
+    ARC_INSN_RND16_L_R_R__RC, "rnd16_L_r_r $RC", "rnd16", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* rnd16$_L$F $RB,$U6 */
+  {
+    ARC_INSN_RND16_L_U6_, "rnd16_L_u6 ", "rnd16", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* abssw$_L$F $RB,$RC */
+  {
+    ARC_INSN_ABSSW_L_R_R__RC, "abssw_L_r_r $RC", "abssw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* abssw$_L$F $RB,$U6 */
+  {
+    ARC_INSN_ABSSW_L_U6_, "abssw_L_u6 ", "abssw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* abss$_L$F $RB,$RC */
+  {
+    ARC_INSN_ABSS_L_R_R__RC, "abss_L_r_r $RC", "abss", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* abss$_L$F $RB,$U6 */
+  {
+    ARC_INSN_ABSS_L_U6_, "abss_L_u6 ", "abss", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* negsw$_L$F $RB,$RC */
+  {
+    ARC_INSN_NEGSW_L_R_R__RC, "negsw_L_r_r $RC", "negsw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* negsw$_L$F $RB,$U6 */
+  {
+    ARC_INSN_NEGSW_L_U6_, "negsw_L_u6 ", "negsw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* negs$_L$F $RB,$RC */
+  {
+    ARC_INSN_NEGS_L_R_R__RC, "negs_L_r_r $RC", "negs", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* negs$_L$F $RB,$U6 */
+  {
+    ARC_INSN_NEGS_L_U6_, "negs_L_u6 ", "negs", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* normw$_L$F $RB,$RC */
+  {
+    ARC_INSN_NORMW_L_R_R__RC, "normw_L_r_r $RC", "normw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_C, 0 } } } }
+  },
+/* normw$_L$F $RB,$U6 */
+  {
+    ARC_INSN_NORMW_L_U6_, "normw_L_u6 ", "normw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* nop_s */
+  {
+    ARC_INSN_NOP_S, "nop_s", "nop_s", 32,
+    { 0|A(SHORT_P), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* unimp_s */
+  {
+    ARC_INSN_UNIMP_S, "unimp_s", "unimp_s", 32,
+    { 0|A(SHORT_P), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* pop$_S $R_b */
+  {
+    ARC_INSN_POP_S_B, "pop_s_b", "pop", 32,
+    { 0|A(SHORT_P), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* pop$_S $R31 */
+  {
+    ARC_INSN_POP_S_BLINK, "pop_s_blink", "pop", 32,
+    { 0|A(SHORT_P), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* push$_S $R_b */
+  {
+    ARC_INSN_PUSH_S_B, "push_s_b", "push", 32,
+    { 0|A(SHORT_P), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* push$_S $R31 */
+  {
+    ARC_INSN_PUSH_S_BLINK, "push_s_blink", "push", 32,
+    { 0|A(SHORT_P), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/* mullw$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_MULLW_L_S12__RA_, "mullw_L_s12 $RA,", "mullw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mullw$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_MULLW_CCU6__RA_, "mullw_ccu6 $RA,", "mullw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mullw$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_MULLW_L_U6__RA_, "mullw_L_u6 $RA,", "mullw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mullw$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_MULLW_L_R_R__RA__RC, "mullw_L_r_r $RA,$RC", "mullw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mullw$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_MULLW_CC__RA__RC, "mullw_cc $RA,$RC", "mullw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* maclw$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_MACLW_L_S12__RA_, "maclw_L_s12 $RA,", "maclw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* maclw$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_MACLW_CCU6__RA_, "maclw_ccu6 $RA,", "maclw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* maclw$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_MACLW_L_U6__RA_, "maclw_L_u6 $RA,", "maclw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* maclw$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_MACLW_L_R_R__RA__RC, "maclw_L_r_r $RA,$RC", "maclw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* maclw$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_MACLW_CC__RA__RC, "maclw_cc $RA,$RC", "maclw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* machlw$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_MACHLW_L_S12__RA_, "machlw_L_s12 $RA,", "machlw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* machlw$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_MACHLW_CCU6__RA_, "machlw_ccu6 $RA,", "machlw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* machlw$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_MACHLW_L_U6__RA_, "machlw_L_u6 $RA,", "machlw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* machlw$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_MACHLW_L_R_R__RA__RC, "machlw_L_r_r $RA,$RC", "machlw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* machlw$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_MACHLW_CC__RA__RC, "machlw_cc $RA,$RC", "machlw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mululw$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_MULULW_L_S12__RA_, "mululw_L_s12 $RA,", "mululw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mululw$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_MULULW_CCU6__RA_, "mululw_ccu6 $RA,", "mululw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mululw$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_MULULW_L_U6__RA_, "mululw_L_u6 $RA,", "mululw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* mululw$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_MULULW_L_R_R__RA__RC, "mululw_L_r_r $RA,$RC", "mululw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* mululw$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_MULULW_CC__RA__RC, "mululw_cc $RA,$RC", "mululw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* machulw$_L$F $RB,$RB,$s12 */
+  {
+    ARC_INSN_MACHULW_L_S12__RA_, "machulw_L_s12 $RA,", "machulw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* machulw$Qcondi$F $RB,$RB,$U6 */
+  {
+    ARC_INSN_MACHULW_CCU6__RA_, "machulw_ccu6 $RA,", "machulw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* machulw$_L$F $RA,$RB,$U6 */
+  {
+    ARC_INSN_MACHULW_L_U6__RA_, "machulw_L_u6 $RA,", "machulw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_B, 0 } } } }
+  },
+/* machulw$_L$F $RA,$RB,$RC */
+  {
+    ARC_INSN_MACHULW_L_R_R__RA__RC, "machulw_L_r_r $RA,$RC", "machulw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/* machulw$Qcondi$F $RB,$RB,$RC */
+  {
+    ARC_INSN_MACHULW_CC__RA__RC, "machulw_cc $RA,$RC", "machulw", 32,
+    { 0, { { { (1<<MACH_BASE), 0 } }, { { LIMM_BC, 0 } } } }
+  },
+/*  */
+  {
+    ARC_INSN_CURRENT_LOOP_END, "current_loop_end", "", 32,
+    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/*  */
+  {
+    ARC_INSN_CURRENT_LOOP_END_AFTER_BRANCH, "current_loop_end_after_branch", "", 32,
+    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+/*  */
+  {
+    ARC_INSN_ARC600_CURRENT_LOOP_END_AFTER_BRANCH, "arc600_current_loop_end_after_branch", "", 32,
+    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { LIMM_NONE, 0 } } } }
+  },
+};
+
+#undef OP
+#undef A
+
+/* Initialize anything needed to be done once, before any cpu_open call.  */
+
+static void
+init_tables (void)
+{
+}
+
+static const CGEN_MACH * lookup_mach_via_bfd_name (const CGEN_MACH *, const char *);
+static void build_hw_table      (CGEN_CPU_TABLE *);
+static void build_ifield_table  (CGEN_CPU_TABLE *);
+static void build_operand_table (CGEN_CPU_TABLE *);
+static void build_insn_table    (CGEN_CPU_TABLE *);
+static void arc_cgen_rebuild_tables (CGEN_CPU_TABLE *);
+
+/* Subroutine of arc_cgen_cpu_open to look up a mach via its bfd name.  */
+
+static const CGEN_MACH *
+lookup_mach_via_bfd_name (const CGEN_MACH *table, const char *name)
+{
+  while (table->name)
+    {
+      if (strcmp (name, table->bfd_name) == 0)
+	return table;
+      ++table;
+    }
+  abort ();
+}
+
+/* Subroutine of arc_cgen_cpu_open to build the hardware table.  */
+
+static void
+build_hw_table (CGEN_CPU_TABLE *cd)
+{
+  int i;
+  int machs = cd->machs;
+  const CGEN_HW_ENTRY *init = & arc_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 arc_cgen_cpu_open to build the hardware table.  */
+
+static void
+build_ifield_table (CGEN_CPU_TABLE *cd)
+{
+  cd->ifld_table = & arc_cgen_ifld_table[0];
+}
+
+/* Subroutine of arc_cgen_cpu_open to build the hardware table.  */
+
+static void
+build_operand_table (CGEN_CPU_TABLE *cd)
+{
+  int i;
+  int machs = cd->machs;
+  const CGEN_OPERAND *init = & arc_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 = xmalloc (MAX_OPERANDS * sizeof (* selected));
+
+  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 arc_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 (CGEN_CPU_TABLE *cd)
+{
+  int i;
+  const CGEN_IBASE *ib = & arc_cgen_insn_table[0];
+  CGEN_INSN *insns = 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 arc_cgen_cpu_open to rebuild the tables.  */
+
+static void
+arc_cgen_rebuild_tables (CGEN_CPU_TABLE *cd)
+{
+  int i;
+  CGEN_BITSET *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 (cgen_bitset_contains (isas, i))
+      {
+	const CGEN_ISA *isa = & arc_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;
+      }
+
+  /* Data derived from the mach spec.  */
+  for (i = 0; i < MAX_MACHS; ++i)
+    if (((1 << i) & machs) != 0)
+      {
+	const CGEN_MACH *mach = & arc_cgen_mach_table[i];
+
+	if (mach->insn_chunk_bitsize != 0)
+	{
+	  if (cd->insn_chunk_bitsize != 0 && cd->insn_chunk_bitsize != mach->insn_chunk_bitsize)
+	    {
+	      fprintf (stderr, "arc_cgen_rebuild_tables: conflicting insn-chunk-bitsize values: `%d' vs. `%d'\n",
+		       cd->insn_chunk_bitsize, mach->insn_chunk_bitsize);
+	      abort ();
+	    }
+
+ 	  cd->insn_chunk_bitsize = mach->insn_chunk_bitsize;
+	}
+      }
+
+  /* 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.
+   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
+arc_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;
+  CGEN_BITSET *isas = 0;  /* 0 = "unspecified" */
+  unsigned int machs = 0; /* 0 = "unspecified" */
+  enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
+  va_list ap;
+
+  if (! init_p)
+    {
+      init_tables ();
+      init_p = 1;
+    }
+
+  memset (cd, 0, sizeof (*cd));
+
+  va_start (ap, arg_type);
+  while (arg_type != CGEN_CPU_OPEN_END)
+    {
+      switch (arg_type)
+	{
+	case CGEN_CPU_OPEN_ISAS :
+	  isas = va_arg (ap, CGEN_BITSET *);
+	  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 (arc_cgen_mach_table, name);
+
+	    machs |= 1 << mach->num;
+	    break;
+	  }
+	case CGEN_CPU_OPEN_ENDIAN :
+	  endian = va_arg (ap, enum cgen_endian);
+	  break;
+	default :
+	  fprintf (stderr, "arc_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;
+  if (endian == CGEN_ENDIAN_UNKNOWN)
+    {
+      /* ??? If target has only one, could have a default.  */
+      fprintf (stderr, "arc_cgen_cpu_open: no endianness specified\n");
+      abort ();
+    }
+
+  cd->isas = cgen_bitset_copy (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
+     chosen, in which case this function will need another argument.
+     Actually, will want to allow for more arguments in the future anyway.  */
+  cd->insn_endian = endian;
+
+  /* Table (re)builder.  */
+  cd->rebuild_tables = arc_cgen_rebuild_tables;
+  arc_cgen_rebuild_tables (cd);
+
+  /* Default to not allowing signed overflow.  */
+  cd->signed_overflow_ok_p = 0;
+  
+  return (CGEN_CPU_DESC) cd;
+}
+
+/* Cover fn to arc_cgen_cpu_open to handle the simple case of 1 isa, 1 mach.
+   MACH_NAME is the bfd name of the mach.  */
+
+CGEN_CPU_DESC
+arc_cgen_cpu_open_1 (const char *mach_name, enum cgen_endian endian)
+{
+  return arc_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
+			       CGEN_CPU_OPEN_ENDIAN, endian,
+			       CGEN_CPU_OPEN_END);
+}
+
+/* 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
+arc_cgen_cpu_close (CGEN_CPU_DESC cd)
+{
+  unsigned int i;
+  const CGEN_INSN *insns;
+
+  if (cd->macro_insn_table.init_entries)
+    {
+      insns = cd->macro_insn_table.init_entries;
+      for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns)
+	if (CGEN_INSN_RX ((insns)))
+	  regfree (CGEN_INSN_RX (insns));
+    }
+
+  if (cd->insn_table.init_entries)
+    {
+      insns = cd->insn_table.init_entries;
+      for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns)
+	if (CGEN_INSN_RX (insns))
+	  regfree (CGEN_INSN_RX (insns));
+    }  
+
+  if (cd->macro_insn_table.init_entries)
+    free ((CGEN_INSN *) cd->macro_insn_table.init_entries);
+
+  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);
+
+  if (cd->operand_table.entries)
+    free ((CGEN_HW_ENTRY *) cd->operand_table.entries);
+
+  free (cd);
+}
+
diff --git a/opcodes/arc-desc.h b/opcodes/arc-desc.h
new file mode 100644
index 0000000..85d8564
--- /dev/null
+++ b/opcodes/arc-desc.h
@@ -0,0 +1,575 @@
+/* CPU data header for arc.
+
+THIS FILE IS MACHINE GENERATED WITH CGEN.
+
+Copyright 1996-2007 Free Software Foundation, Inc.
+
+This file is part of the GNU Binutils and/or GDB, the GNU debugger.
+
+   This file is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   It is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or FITNESS FOR A PARTICULAR PURPOSE.  See the 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.,
+   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
+
+*/
+
+#ifndef ARC_CPU_H
+#define ARC_CPU_H
+
+#include "opcode/cgen-bitset.h"
+
+#define CGEN_ARCH arc
+
+/* Given symbol S, return arc_cgen_<S>.  */
+#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
+#define CGEN_SYM(s) arc##_cgen_##s
+#else
+#define CGEN_SYM(s) arc/**/_cgen_/**/s
+#endif
+
+
+/* Selected cpu families.  */
+#define HAVE_CPU_A5F
+#define HAVE_CPU_ARC600F
+#define HAVE_CPU_ARC700F
+
+#define CGEN_INSN_LSB0_P 0
+
+/* Minimum size of any insn (in bytes).  */
+#define CGEN_MIN_INSN_SIZE 4
+
+/* Maximum size of any insn (in bytes).  */
+#define CGEN_MAX_INSN_SIZE 4
+
+#define CGEN_INT_INSN_P 1
+
+/* Maximum number of syntax elements in an instruction.  */
+#define CGEN_ACTUAL_MAX_SYNTAX_ELEMENTS 19
+
+/* CGEN_MNEMONIC_OPERANDS is defined if mnemonics have operands.
+   e.g. In "b,a foo" the ",a" is an operand.  If mnemonics have operands
+   we can't hash on everything up to the space.  */
+#define CGEN_MNEMONIC_OPERANDS
+
+/* Maximum number of fields in an instruction.  */
+#define CGEN_ACTUAL_MAX_IFMT_OPERANDS 8
+
+/* Enums.  */
+
+/* Enum declaration for enum values for Qcond to be used in case form.  */
+typedef enum e_qvalues {
+  COND_AL = 0, COND_EQ = 1, COND_Z = 1, COND_NE = 2
+ , COND_NZ = 2, COND_PL = 3, COND_P = 3, COND_MI = 4
+ , COND_N = 4, COND_CS = 5, COND_C = 5, COND_LO = 5
+ , COND_CC = 6, COND_NC = 6, COND_HS = 6, COND_VS = 7
+ , COND_V = 7, COND_VC = 8, COND_NV = 8, COND_GT = 9
+ , COND_GE = 10, COND_LT = 11, COND_LE = 12, COND_HI = 13
+ , COND_LS = 14, COND_PNZ = 15
+} E_QVALUES;
+
+/* Enum declaration for enum values for i3cond to be used in case form.  */
+typedef enum e_i3cond {
+  COND3_GT = 0, COND3_GE = 1, COND3_LT = 2, COND3_LE = 3
+ , COND3_HI = 4, COND3_CC = 5, COND3_NC = 5, COND3_HS = 5
+ , COND3_CS = 6, COND3_C = 6, COND3_LO = 6, COND3_LS = 7
+} E_I3COND;
+
+/* Enum declaration for enum values for brcond to be used in case form.  */
+typedef enum e_brcond {
+  CONDBR_REQ = 0, CONDBR_RNE = 1, CONDBR_RLT = 2, CONDBR_RGE = 3
+ , CONDBR_RLO = 4, CONDBR_RHS = 5, CONDBR_BIT0 = 14, CONDBR_BIT1 = 15
+} E_BRCOND;
+
+/* Enum declaration for .  */
+typedef enum cr_names {
+  H_CR_GP = 26, H_CR_FP = 27, H_CR_SP = 28, H_CR_BLINK = 31
+ , H_CR_MLO = 57, H_CR_MMID = 58, H_CR_MHI = 59, H_CR_LP_COUNT = 60
+ , H_CR_PCL = 63, H_CR_ILINK1 = 29, H_CR_ILINK2 = 30, H_CR_R29 = 29
+ , H_CR_R30 = 30, H_CR_R0 = 0, H_CR_R1 = 1, H_CR_R2 = 2
+ , H_CR_R3 = 3, H_CR_R4 = 4, H_CR_R5 = 5, H_CR_R6 = 6
+ , H_CR_R7 = 7, H_CR_R8 = 8, H_CR_R9 = 9, H_CR_R10 = 10
+ , H_CR_R11 = 11, H_CR_R12 = 12, H_CR_R13 = 13, H_CR_R14 = 14
+ , H_CR_R15 = 15, H_CR_R16 = 16, H_CR_R17 = 17, H_CR_R18 = 18
+ , H_CR_R19 = 19, H_CR_R20 = 20, H_CR_R21 = 21, H_CR_R22 = 22
+ , H_CR_R23 = 23, H_CR_R24 = 24, H_CR_R25 = 25, H_CR_R26 = 26
+ , H_CR_R27 = 27, H_CR_R28 = 28, H_CR_R31 = 31, H_CR_R32 = 32
+ , H_CR_R33 = 33, H_CR_R34 = 34, H_CR_R35 = 35, H_CR_R36 = 36
+ , H_CR_R37 = 37, H_CR_R38 = 38, H_CR_R39 = 39, H_CR_R40 = 40
+ , H_CR_R41 = 41, H_CR_R42 = 42, H_CR_R43 = 43, H_CR_R44 = 44
+ , H_CR_R45 = 45, H_CR_R46 = 46, H_CR_R47 = 47, H_CR_R48 = 48
+ , H_CR_R49 = 49, H_CR_R50 = 50, H_CR_R51 = 51, H_CR_R52 = 52
+ , H_CR_R53 = 53, H_CR_R54 = 54, H_CR_R55 = 55, H_CR_R56 = 56
+ , H_CR_R57 = 57, H_CR_R58 = 58, H_CR_R59 = 59, H_CR_R60 = 60
+} CR_NAMES;
+
+/* Enum declaration for Core Register A encodings.  */
+typedef enum e_ra_rn {
+  RA_R0, RA_R1, RA_R2, RA_R3
+ , RA_R4, RA_R5, RA_R6, RA_R7
+ , RA_R8, RA_R9, RA_R10, RA_R11
+ , RA_R12, RA_R13, RA_R14, RA_R15
+ , RA_R16, RA_R17, RA_R18, RA_R19
+ , RA_R20, RA_R21, RA_R22, RA_R23
+ , RA_R24, RA_R25, RA_R26, RA_R27
+ , RA_R28, RA_R29, RA_R30, RA_R31
+ , RA_R32, RA_R33, RA_R34, RA_R35
+ , RA_R36, RA_R37, RA_R38, RA_R39
+ , RA_R40, RA_R41, RA_R42, RA_R43
+ , RA_R44, RA_R45, RA_R46, RA_R47
+ , RA_R48, RA_R49, RA_R50, RA_R51
+ , RA_R52, RA_R53, RA_R54, RA_R55
+ , RA_R56, RA_R57, RA_R58, RA_R59
+ , RA_R60, RA_R61, RA_R62, RA_R63
+} E_RA_RN;
+
+/* Enum declaration for major opcode.  */
+typedef enum op_maj {
+  OPM_B = 0, OPM_BLR = 1, OPM_LD_S9 = 2, OPM_ST_S9 = 3
+ , OPM_GO = 4, OPM_X05 = 5, OPM_X06 = 6, OPM_X07 = 7
+ , OPM_SLDADDR = 12, OPM_SADDSUBSHI = 13, OPM_SMOVCMPADDH = 14, OPM_SGO = 15
+ , OPM_LDO_S = 16, OPM_LDOB_S = 17, OPM_LDOW_S = 18, OPM_LDOWX_S = 19
+ , OPM_STO_S = 20, OPM_STOB_S = 21, OPM_STOW_S = 22, OPM_SSHSUBBIMM = 23
+ , OPM_SP = 24, OPM_GP = 25, OPM_LDPCREL = 26, OPM_SMOVU8 = 27
+ , OPM_SADDCMPU7 = 28, OPM_BR_S = 29, OPM_B_S = 30, OPM_BL_S = 31
+ , OPM_PSEUDO = 32
+} OP_MAJ;
+
+/* Enum declaration for general operations type.  */
+typedef enum go_type {
+  GO_TYPE_R_R, GO_TYPE_U6, GO_TYPE_S12, GO_TYPE_CC
+} GO_TYPE;
+
+/* Enum declaration for general operations conditional subtype.  */
+typedef enum go_cc_type {
+  GO_CC_REG, GO_CC_U6
+} GO_CC_TYPE;
+
+/* Enum declaration for general operations type.  */
+typedef enum go_op {
+  GO_OP_ADD = 0, GO_OP_ADC = 1, GO_OP_SUB = 2, GO_OP_SBC = 3
+ , GO_OP_AND = 4, GO_OP_OR = 5, GO_OP_BIC = 6, GO_OP_XOR = 7
+ , GO_OP_MAX = 8, GO_OP_MIN = 9, GO_OP_MOV = 10, GO_OP_TST = 11
+ , GO_OP_CMP = 12, GO_OP_RCMP = 13, GO_OP_RSUB = 14, GO_OP_BSET = 15
+ , GO_OP_BCLR = 16, GO_OP_BTST = 17, GO_OP_BXOR = 18, GO_OP_BMSK = 19
+ , GO_OP_ADD1 = 20, GO_OP_ADD2 = 21, GO_OP_ADD3 = 22, GO_OP_SUB1 = 23
+ , GO_OP_SUB2 = 24, GO_OP_SUB3 = 25, GO_OP_MPY = 26, GO_OP_MPYH = 27
+ , GO_OP_MPYHU = 28, GO_OP_MPYU = 29, GO_OP_RES30 = 30, GO_OP_RES31 = 31
+ , GO_OP_J = 32, GO_OP_J_D = 33, GO_OP_JL = 34, GO_OP_JL_D = 35
+ , GO_OP_LP = 40, GO_OP_FLAG = 41, GO_OP_LR = 42, GO_OP_SR = 43
+ , GO_OP_SOP = 47
+} GO_OP;
+
+/* Enum declaration for general single-operand operations type.  */
+typedef enum go_sop {
+  GO_OP_SOP_ASL = 0, GO_OP_SOP_ASR = 1, GO_OP_SOP_LSR = 2, GO_OP_SOP_ROR = 3
+ , GO_OP_SOP_RRC = 4, GO_OP_SOP_SEXB = 5, GO_OP_SOP_SEXW = 6, GO_OP_SOP_EXTB = 7
+ , GO_OP_SOP_EXTW = 8, GO_OP_SOP_ABS = 9, GO_OP_SOP_NOT = 10, GO_OP_SOP_RLC = 11
+ , GO_OP_SOP_EX = 12, GO_OP_SOP_ZOP = 63, GO_OP_SOP_PSEUDO = 62
+} GO_SOP;
+
+/* Enum declaration for short add / sub immediate type.  */
+typedef enum i16ldaddr_type {
+  I16_LDADDR_LD, I16_LDADDR_LDB, I16_LDADDR_LDW, I16_LDADDR_ADD
+} I16LDADDR_TYPE;
+
+/* Enum declaration for short add / sub immediate type.  */
+typedef enum i16addsubshi_type {
+  I16_ADDSUBSHI_ADD, I16_ADDSUBSHI_SUB, I16_ADDSUBSHI_ASL, I16_ADDSUBSHI_ASR
+} I16ADDSUBSHI_TYPE;
+
+/* Enum declaration for short mov / cmp / add  with high register type.  */
+typedef enum i16movcmpaddh_type {
+  I16_MOVCMPADDH_ADD, I16_MOVCMPADDH_MOVBH, I16_MOVCMPADDH_CMP, I16_MOVCMPADDH_MOVHB
+} I16MOVCMPADDH_TYPE;
+
+/* Enum declaration for short general operations.  */
+typedef enum i16go_type {
+  I16_GO_SOP = 0, I16_GO_SUB = 2, I16_GO_AND = 4, I16_GO_OR = 5
+ , I16_GO_BIC = 6, I16_GO_XOR = 7, I16_GO_TST = 11, I16_GO_MUL64 = 12
+ , I16_GO_SEXB = 13, I16_GO_SEXW = 14, I16_GO_EXTB = 15, I16_GO_EXTW = 16
+ , I16_GO_ABS = 17, I16_GO_NOT = 18, I16_GO_NEG = 19, I16_GO_ADD1 = 20
+ , I16_GO_ADD2 = 21, I16_GO_ADD3 = 22, I16_GO_ASLM = 24, I16_GO_LSRM = 25
+ , I16_GO_ASRM = 26, I16_GO_ASL = 27, I16_GO_ASR = 28, I16_GO_LSR = 29
+ , I16_GO_TRAP = 30, I16_GO_BRK = 31
+} I16GO_TYPE;
+
+/* Enum declaration for short general operations single operand.  */
+typedef enum i16go_sop_type {
+  I16_GO_SOP_J = 0, I16_GO_SOP_J_D = 1, I16_GO_SOP_JL = 2, I16_GO_SOP_JL_D = 3
+ , I16_GO_SOP_SUB_NE = 6, I16_GO_SOP_ZOP = 7
+} I16GO_SOP_TYPE;
+
+/* Enum declaration for short general operations single operand.  */
+typedef enum i16go_zop_type {
+  I16_GO_ZOP_NOP = 0, I16_GO_ZOP_UNIMP = 1, I16_GO_ZOP_JEQ = 4, I16_GO_ZOP_JNE = 5
+ , I16_GO_ZOP_J = 6, I16_GO_ZOP_J_D = 7
+} I16GO_ZOP_TYPE;
+
+/* Enum declaration for sp based insn type.  */
+typedef enum i16sp_type {
+  I16_SP_LD, I16_SP_LDB, I16_SP_ST, I16_SP_STB
+ , I16_SP_ADD, I16_SP_ADDSUB, I16_SP_POP, I16_SP_PUSH
+} I16SP_TYPE;
+
+/* Enum declaration for sp based 1op insn type.  */
+typedef enum i16addsub_spsp_type {
+  I16_SP_ADDSUB_ADD, I16_SP_ADDSUB_SUB
+} I16ADDSUB_SPSP_TYPE;
+
+/* Enum declaration for gp-relative insn type.  */
+typedef enum i16gp_type {
+  I16_GP_LD, I16_GP_LDB, I16_GP_LDW, I16_GP_ADD
+} I16GP_TYPE;
+
+/* Enum declaration for short add / cmp immediate type.  */
+typedef enum i16addcmpu7_type {
+  I16_ADDCMPU7_ADD, I16_ADDCMPU7_CMP
+} I16ADDCMPU7_TYPE;
+
+/* Enum declaration for shift / sub / bit immediate short insn w/ u5 type.  */
+typedef enum i16shsubbimm {
+  I16_SHSUBBIMM_ASL, I16_SHSUBBIMM_LSR, I16_SHSUBBIMM_ASR, I16_SHSUBBIMM_SUB
+ , I16_SHSUBBIMM_BSET, I16_SHSUBBIMM_BCLR, I16_SHSUBBIMM_BMSK, I16_SHSUBBIMM_BTST
+} I16SHSUBBIMM;
+
+/* Enum declaration for .  */
+typedef enum i_buf {
+  B_CC, B_UNCOND_FAR
+} I_BUF;
+
+/* Enum declaration for .  */
+typedef enum i_blr {
+  BLR_BL, BLR_BR
+} I_BLR;
+
+/* Enum declaration for .  */
+typedef enum i_br {
+  BR_RC, BR_U6
+} I_BR;
+
+/* Enum declaration for .  */
+typedef enum op_bl {
+  BL_CC, BL_UNCOND_FAR
+} OP_BL;
+
+/* Enum declaration for .  */
+typedef enum i_bcc_s {
+  B_S_CC = 3
+} I_BCC_S;
+
+/* Enum declaration for .  */
+typedef enum i_ldozz {
+  LDO_LD = 0, LDO_LDB = 2, LDO_LDBX = 3, LDO_LDW = 4
+ , LDO_LDWX = 5
+} I_LDOZZ;
+
+/* Enum declaration for .  */
+typedef enum i_ldr6zzx {
+  LDR_LD = 48, LDR_LDB = 50, LDR_LDBX = 51, LDR_LDW = 52
+ , LDR_LDWX = 53
+} I_LDR6ZZX;
+
+/* Enum declaration for .  */
+typedef enum i_stozzr {
+  STO_ST = 0, STO_STB = 2, STO_STW = 4
+} I_STOZZR;
+
+/* Enum declaration for .  */
+typedef enum i_ldoaa {
+  LDOAA_NO, LDOAA_AW, LDOAA_AB, LDOAA_AS
+} I_LDOAA;
+
+/* Enum declaration for .  */
+typedef enum i_ldraa {
+  LDRAA_NO, LDRAA_AW, LDRAA_AB, LDRAA_AS
+} I_LDRAA;
+
+/* Enum declaration for .  */
+typedef enum i_stoaa {
+  STOAA_NO, STOAA_AW, STOAA_AB, STOAA_AS
+} I_STOAA;
+
+/* Enum declaration for general zero-operand operations type.  */
+typedef enum go_zop {
+  GO_OP_ZOP_SLEEP = 1, GO_OP_ZOP_SWI = 2, GO_OP_ZOP_SYNC = 3, GO_OP_ZOP_RTIE = 4
+ , GO_OP_ZOP_BRK = 5
+} GO_ZOP;
+
+/* Enum declaration for general operations type.  */
+typedef enum x05_go_op {
+  X05_ASL = 0, X05_LSR = 1, X05_ASR = 2, X05_ROR = 3
+ , X05_MUL64 = 4, X05_MULU64 = 5, X05_ADDS = 6, X05_SUBS = 7
+ , X05_DIVAW = 8, X05_ASLS = 10, X05_ASRS = 11, X05_ADDSDW = 40
+ , X05_SUBSDW = 41, X05_SOP = 47, X05_CMACRDW = 38, X05_MACDW = 16
+ , X05_MACFLW = 52, X05_MACHFLW = 55, X05_MACHLW = 54, X05_MACHULW = 53
+ , X05_MACLW = 51, X05_MACRDW = 18, X05_MACUDW = 17, X05_MSUBDW = 20
+ , X05_MULDW = 12, X05_MULFLW = 50, X05_MULHFLW = 57, X05_MULHLW = 56
+ , X05_MULLW = 49, X05_MULRDW = 14, X05_MULUDW = 13, X05_MULULW = 48
+} X05_GO_OP;
+
+/* Enum declaration for x06 extension single-operand operantion.  */
+typedef enum x05_sop_kind {
+  X05_SOP_SWAP = 0, X05_SOP_NORM = 1, X05_SOP_SAT16 = 2, X05_SOP_RND16 = 3
+ , X05_SOP_ABSSW = 4, X05_SOP_ABSS = 5, X05_SOP_NEGSW = 6, X05_SOP_NEGS = 7
+ , X05_SOP_NORMW = 8, X05_SOP_ZOP = 63
+} X05_SOP_KIND;
+
+/* Enum declaration for .  */
+typedef enum pushpop_kind {
+  PUSHPOP_B = 1, PUSHPOP_BLINK = 17
+} PUSHPOP_KIND;
+
+/* Enum declaration for .  */
+typedef enum pushpop_r_b {
+  OP_B_0
+} PUSHPOP_R_B;
+
+/* Attributes.  */
+
+/* Enum declaration for machine type selection.  */
+typedef enum mach_attr {
+  MACH_BASE, MACH_A5, MACH_ARC600, MACH_ARC700
+ , MACH_MAX
+} MACH_ATTR;
+
+/* Enum declaration for instruction set selection.  */
+typedef enum isa_attr {
+  ISA_ARCOMPACT, ISA_MAX
+} ISA_ATTR;
+
+/* Enum declaration for can take long immediate for operand.  */
+typedef enum limm_attr {
+  LIMM_NONE, LIMM_H, LIMM_B, LIMM_BC
+ , LIMM_C
+} LIMM_ATTR;
+
+/* Number of architecture variants.  */
+#define MAX_ISAS  1
+#define MAX_MACHS ((int) MACH_MAX)
+
+/* Ifield support.  */
+
+/* Ifield attribute indices.  */
+
+/* Enum declaration for cgen_ifld attrs.  */
+typedef enum cgen_ifld_attr {
+  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_attr.  */
+#define CGEN_IFLD_NBOOL_ATTRS (CGEN_IFLD_END_NBOOLS - CGEN_IFLD_START_NBOOLS - 1)
+
+/* cgen_ifld attribute accessor macros.  */
+#define CGEN_ATTR_CGEN_IFLD_MACH_VALUE(attrs) ((attrs)->nonbool[CGEN_IFLD_MACH-CGEN_IFLD_START_NBOOLS-1].nonbitset)
+#define CGEN_ATTR_CGEN_IFLD_VIRTUAL_VALUE(attrs) (((attrs)->bool & (1 << CGEN_IFLD_VIRTUAL)) != 0)
+#define CGEN_ATTR_CGEN_IFLD_PCREL_ADDR_VALUE(attrs) (((attrs)->bool & (1 << CGEN_IFLD_PCREL_ADDR)) != 0)
+#define CGEN_ATTR_CGEN_IFLD_ABS_ADDR_VALUE(attrs) (((attrs)->bool & (1 << CGEN_IFLD_ABS_ADDR)) != 0)
+#define CGEN_ATTR_CGEN_IFLD_RESERVED_VALUE(attrs) (((attrs)->bool & (1 << CGEN_IFLD_RESERVED)) != 0)
+#define CGEN_ATTR_CGEN_IFLD_SIGN_OPT_VALUE(attrs) (((attrs)->bool & (1 << CGEN_IFLD_SIGN_OPT)) != 0)
+#define CGEN_ATTR_CGEN_IFLD_SIGNED_VALUE(attrs) (((attrs)->bool & (1 << CGEN_IFLD_SIGNED)) != 0)
+
+/* Enum declaration for arc ifield types.  */
+typedef enum ifield_type {
+  ARC_F_NIL, ARC_F_ANYOF, ARC_F_COND_Q, ARC_F_COND_I2
+ , ARC_F_COND_I3, ARC_F_BRCOND, ARC_F_OP__A, ARC_F_OP__B
+ , ARC_F_OP__C, ARC_F_B_5_3, ARC_F_OP_B, ARC_F_OP_C
+ , ARC_F_OP_CJ, ARC_F_H_2_0, ARC_F_H_5_3, ARC_F_OP_H
+ , ARC_F_U6, ARC_F_U6X2, ARC_F_DELAY_N, ARC_F_RES27
+ , ARC_F_F, ARC_F_CBRANCH_IMM, ARC_F_OP_A, ARC_F_S12H
+ , ARC_F_S12, ARC_F_S12X2, ARC_F_REL10, ARC_F_REL7
+ , ARC_F_REL8, ARC_F_REL13BL, ARC_F_D21L, ARC_F_D21BL
+ , ARC_F_D21H, ARC_F_D25M, ARC_F_D25H, ARC_F_REL21
+ , ARC_F_REL21BL, ARC_F_REL25, ARC_F_REL25BL, ARC_F_D9L
+ , ARC_F_D9H, ARC_F_REL9, ARC_F_U3, ARC_F_U5
+ , ARC_F_U7, ARC_F_U8, ARC_F_S9, ARC_F_U5X2
+ , ARC_F_U5X4, ARC_F_U8X4, ARC_F_S9X1, ARC_F_S9X2
+ , ARC_F_S9X4, ARC_F_DUMMY, ARC_F_OPM, ARC_F_GO_TYPE
+ , ARC_F_GO_CC_TYPE, ARC_F_GO_OP, ARC_F_I16_43, ARC_F_I16_GO
+ , ARC_F_I16_GP_TYPE, ARC_F_I16ADDCMPU7_TYPE, ARC_F_BUF, ARC_F_BR
+ , ARC_F_BLUF, ARC_F_BRSCOND, ARC_F_LDOZZX, ARC_F_LDR6ZZX
+ , ARC_F_STOZZR, ARC_F_LDOAA, ARC_F_LDRAA, ARC_F_STOAA
+ , ARC_F_LDODI, ARC_F_LDRDI, ARC_F_STODI, ARC_F_TRAPNUM
+ , ARC_F_MAX
+} IFIELD_TYPE;
+
+#define MAX_IFLD ((int) ARC_F_MAX)
+
+/* Hardware attribute indices.  */
+
+/* Enum declaration for cgen_hw attrs.  */
+typedef enum cgen_hw_attr {
+  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_attr.  */
+#define CGEN_HW_NBOOL_ATTRS (CGEN_HW_END_NBOOLS - CGEN_HW_START_NBOOLS - 1)
+
+/* cgen_hw attribute accessor macros.  */
+#define CGEN_ATTR_CGEN_HW_MACH_VALUE(attrs) ((attrs)->nonbool[CGEN_HW_MACH-CGEN_HW_START_NBOOLS-1].nonbitset)
+#define CGEN_ATTR_CGEN_HW_VIRTUAL_VALUE(attrs) (((attrs)->bool & (1 << CGEN_HW_VIRTUAL)) != 0)
+#define CGEN_ATTR_CGEN_HW_CACHE_ADDR_VALUE(attrs) (((attrs)->bool & (1 << CGEN_HW_CACHE_ADDR)) != 0)
+#define CGEN_ATTR_CGEN_HW_PC_VALUE(attrs) (((attrs)->bool & (1 << CGEN_HW_PC)) != 0)
+#define CGEN_ATTR_CGEN_HW_PROFILE_VALUE(attrs) (((attrs)->bool & (1 << CGEN_HW_PROFILE)) != 0)
+
+/* Enum declaration for arc hardware types.  */
+typedef enum cgen_hw_type {
+  HW_H_MEMORY, HW_H_SINT, HW_H_UINT, HW_H_ADDR
+ , HW_H_IADDR, HW_H_LBIT, HW_H_ZBIT, HW_H_NBIT
+ , HW_H_CBIT, HW_H_VBIT, HW_H_UBIT, HW_H_E1
+ , HW_H_E2, HW_H_S1BIT, HW_H_S2BIT, HW_H_QCONDB
+ , HW_H_QCONDJ, HW_H_QCONDI, HW_H_UNCONDB, HW_H_UNCONDJ
+ , HW_H_UNCONDI, HW_H_I2COND, HW_H_I3COND, HW_H_DELAY
+ , HW_H_UFLAGS, HW_H_NIL, HW_H_AUFLAGS, HW_H_AUFFLAGS
+ , HW_H_DI, HW_H_INSN16, HW_H_INSN32, HW_H__AW
+ , HW_H_CR, HW_H_CR16, HW_H_R0, HW_H_GP
+ , HW_H_SP, HW_H_PCL, HW_H_NOILINK, HW_H_ILINKX
+ , HW_H_R31, HW_H_AUXR, HW_H_STATUS32, HW_H_TIMER_EXPIRE
+ , HW_H_PROF_OFFSET, HW_H_NE, HW_H_PC, HW_H_RCCS
+ , HW_H_RCC, HW_MAX
+} CGEN_HW_TYPE;
+
+#define MAX_HW ((int) HW_MAX)
+
+/* Operand attribute indices.  */
+
+/* Enum declaration for cgen_operand attrs.  */
+typedef enum cgen_operand_attr {
+  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_attr.  */
+#define CGEN_OPERAND_NBOOL_ATTRS (CGEN_OPERAND_END_NBOOLS - CGEN_OPERAND_START_NBOOLS - 1)
+
+/* cgen_operand attribute accessor macros.  */
+#define CGEN_ATTR_CGEN_OPERAND_MACH_VALUE(attrs) ((attrs)->nonbool[CGEN_OPERAND_MACH-CGEN_OPERAND_START_NBOOLS-1].nonbitset)
+#define CGEN_ATTR_CGEN_OPERAND_VIRTUAL_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_VIRTUAL)) != 0)
+#define CGEN_ATTR_CGEN_OPERAND_PCREL_ADDR_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_PCREL_ADDR)) != 0)
+#define CGEN_ATTR_CGEN_OPERAND_ABS_ADDR_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_ABS_ADDR)) != 0)
+#define CGEN_ATTR_CGEN_OPERAND_SIGN_OPT_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_SIGN_OPT)) != 0)
+#define CGEN_ATTR_CGEN_OPERAND_SIGNED_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_SIGNED)) != 0)
+#define CGEN_ATTR_CGEN_OPERAND_NEGATIVE_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_NEGATIVE)) != 0)
+#define CGEN_ATTR_CGEN_OPERAND_RELAX_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_RELAX)) != 0)
+#define CGEN_ATTR_CGEN_OPERAND_SEM_ONLY_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_SEM_ONLY)) != 0)
+
+/* Enum declaration for arc operand types.  */
+typedef enum cgen_operand_type {
+  ARC_OPERAND_PC, ARC_OPERAND_LBIT, ARC_OPERAND_ZBIT, ARC_OPERAND_NBIT
+ , ARC_OPERAND_CBIT, ARC_OPERAND_VBIT, ARC_OPERAND_S1BIT, ARC_OPERAND_S2BIT
+ , ARC_OPERAND_QCONDB, ARC_OPERAND_QCONDJ, ARC_OPERAND_QCONDI, ARC_OPERAND_UNCONDB
+ , ARC_OPERAND_UNCONDJ, ARC_OPERAND_UNCONDI, ARC_OPERAND_I2COND, ARC_OPERAND_I3COND
+ , ARC_OPERAND_DELAY_N, ARC_OPERAND__S, ARC_OPERAND__L, ARC_OPERAND_F
+ , ARC_OPERAND_F1, ARC_OPERAND_F1F, ARC_OPERAND_F0, ARC_OPERAND_R_A
+ , ARC_OPERAND_RA, ARC_OPERAND_R_B, ARC_OPERAND_RB, ARC_OPERAND_R_C
+ , ARC_OPERAND_RC, ARC_OPERAND_RH, ARC_OPERAND_R0, ARC_OPERAND_R31
+ , ARC_OPERAND_GP, ARC_OPERAND_SP, ARC_OPERAND_PCL, ARC_OPERAND_RA_0
+ , ARC_OPERAND_RB_0, ARC_OPERAND_RC_ILINK, ARC_OPERAND_RC_NOILINK, ARC_OPERAND_NE
+ , ARC_OPERAND_U6, ARC_OPERAND_U6X2, ARC_OPERAND_U3, ARC_OPERAND_U5
+ , ARC_OPERAND_U7, ARC_OPERAND_U8, ARC_OPERAND_S9, ARC_OPERAND_S12
+ , ARC_OPERAND_S12X2, ARC_OPERAND_U5X4, ARC_OPERAND_SC_U5_, ARC_OPERAND_SC_U5W
+ , ARC_OPERAND_SC_U5B, ARC_OPERAND_U8X4, ARC_OPERAND_S9X4, ARC_OPERAND_SC_S9_
+ , ARC_OPERAND_SC_S9W, ARC_OPERAND_SC_S9B, ARC_OPERAND_LABEL7, ARC_OPERAND_LABEL8
+ , ARC_OPERAND_LABEL9, ARC_OPERAND_LABEL10, ARC_OPERAND_LABEL13A, ARC_OPERAND_LABEL21
+ , ARC_OPERAND_LABEL21A, ARC_OPERAND_LABEL25, ARC_OPERAND_LABEL25A, ARC_OPERAND_DUMMY_OP
+ , ARC_OPERAND_RCCS, ARC_OPERAND_RCC, ARC_OPERAND_LDODI, ARC_OPERAND_LDRDI
+ , ARC_OPERAND_STODI, ARC_OPERAND_EXDI, ARC_OPERAND__AW, ARC_OPERAND_TRAPNUM
+ , ARC_OPERAND_MAX
+} CGEN_OPERAND_TYPE;
+
+/* Number of operands types.  */
+#define MAX_OPERANDS 76
+
+/* Maximum number of operands referenced by any insn.  */
+#define MAX_OPERAND_INSTANCES 26
+
+/* Insn attribute indices.  */
+
+/* Enum declaration for cgen_insn attrs.  */
+typedef enum cgen_insn_attr {
+  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_RELAXED
+ , CGEN_INSN_NO_DIS, CGEN_INSN_PBB, CGEN_INSN_SHORT_P, CGEN_INSN_END_BOOLS
+ , CGEN_INSN_START_NBOOLS = 31, CGEN_INSN_MACH, CGEN_INSN_LIMM, CGEN_INSN_END_NBOOLS
+} CGEN_INSN_ATTR;
+
+/* Number of non-boolean elements in cgen_insn_attr.  */
+#define CGEN_INSN_NBOOL_ATTRS (CGEN_INSN_END_NBOOLS - CGEN_INSN_START_NBOOLS - 1)
+
+/* cgen_insn attribute accessor macros.  */
+#define CGEN_ATTR_CGEN_INSN_MACH_VALUE(attrs) ((attrs)->nonbool[CGEN_INSN_MACH-CGEN_INSN_START_NBOOLS-1].nonbitset)
+#define CGEN_ATTR_CGEN_INSN_LIMM_VALUE(attrs) ((attrs)->nonbool[CGEN_INSN_LIMM-CGEN_INSN_START_NBOOLS-1].nonbitset)
+#define CGEN_ATTR_CGEN_INSN_ALIAS_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_ALIAS)) != 0)
+#define CGEN_ATTR_CGEN_INSN_VIRTUAL_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_VIRTUAL)) != 0)
+#define CGEN_ATTR_CGEN_INSN_UNCOND_CTI_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_UNCOND_CTI)) != 0)
+#define CGEN_ATTR_CGEN_INSN_COND_CTI_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_COND_CTI)) != 0)
+#define CGEN_ATTR_CGEN_INSN_SKIP_CTI_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_SKIP_CTI)) != 0)
+#define CGEN_ATTR_CGEN_INSN_DELAY_SLOT_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_DELAY_SLOT)) != 0)
+#define CGEN_ATTR_CGEN_INSN_RELAXABLE_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_RELAXABLE)) != 0)
+#define CGEN_ATTR_CGEN_INSN_RELAXED_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_RELAXED)) != 0)
+#define CGEN_ATTR_CGEN_INSN_NO_DIS_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_NO_DIS)) != 0)
+#define CGEN_ATTR_CGEN_INSN_PBB_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_PBB)) != 0)
+#define CGEN_ATTR_CGEN_INSN_SHORT_P_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_SHORT_P)) != 0)
+
+/* cgen.h uses things we just defined.  */
+#include "opcode/cgen.h"
+
+extern const struct cgen_ifld arc_cgen_ifld_table[];
+
+/* Attributes.  */
+extern const CGEN_ATTR_TABLE arc_cgen_hardware_attr_table[];
+extern const CGEN_ATTR_TABLE arc_cgen_ifield_attr_table[];
+extern const CGEN_ATTR_TABLE arc_cgen_operand_attr_table[];
+extern const CGEN_ATTR_TABLE arc_cgen_insn_attr_table[];
+
+/* Hardware decls.  */
+
+extern CGEN_KEYWORD arc_cgen_opval_h_Qcondb;
+extern CGEN_KEYWORD arc_cgen_opval_h_Qcondj;
+extern CGEN_KEYWORD arc_cgen_opval_h_Qcondi;
+extern CGEN_KEYWORD arc_cgen_opval_h_uncondb;
+extern CGEN_KEYWORD arc_cgen_opval_h_uncondj;
+extern CGEN_KEYWORD arc_cgen_opval_h_uncondi;
+extern CGEN_KEYWORD arc_cgen_opval_h_i2cond;
+extern CGEN_KEYWORD arc_cgen_opval_h_i3cond;
+extern CGEN_KEYWORD arc_cgen_opval_h_delay;
+extern CGEN_KEYWORD arc_cgen_opval_h_uflags;
+extern CGEN_KEYWORD arc_cgen_opval_h_nil;
+extern CGEN_KEYWORD arc_cgen_opval_h_auflags;
+extern CGEN_KEYWORD arc_cgen_opval_h_aufflags;
+extern CGEN_KEYWORD arc_cgen_opval_h_Di;
+extern CGEN_KEYWORD arc_cgen_opval_h_insn16;
+extern CGEN_KEYWORD arc_cgen_opval_h_insn32;
+extern CGEN_KEYWORD arc_cgen_opval_h__aw;
+extern CGEN_KEYWORD arc_cgen_opval_cr_names;
+extern CGEN_KEYWORD arc_cgen_opval_h_cr16;
+extern CGEN_KEYWORD arc_cgen_opval_h_r0;
+extern CGEN_KEYWORD arc_cgen_opval_h_gp;
+extern CGEN_KEYWORD arc_cgen_opval_h_sp;
+extern CGEN_KEYWORD arc_cgen_opval_h_pcl;
+extern CGEN_KEYWORD arc_cgen_opval_h_noilink;
+extern CGEN_KEYWORD arc_cgen_opval_h_ilinkx;
+extern CGEN_KEYWORD arc_cgen_opval_h_r31;
+extern CGEN_KEYWORD arc_cgen_opval_cr_names;
+extern CGEN_KEYWORD arc_cgen_opval_h_status32;
+extern CGEN_KEYWORD arc_cgen_opval_h_ne;
+extern CGEN_KEYWORD arc_cgen_opval_h_RccS;
+extern CGEN_KEYWORD arc_cgen_opval_h_Rcc;
+
+extern const CGEN_HW_ENTRY arc_cgen_hw_table[];
+
+
+
+#endif /* ARC_CPU_H */
diff --git a/opcodes/arc-ibld.c b/opcodes/arc-ibld.c
new file mode 100644
index 0000000..958dde7
--- /dev/null
+++ b/opcodes/arc-ibld.c
@@ -0,0 +1,2340 @@
+/* Instruction building/extraction support for arc. -*- C -*-
+
+   THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator.
+   - the resultant file is machine generated, cgen-ibld.in isn't
+
+   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2005, 2006, 2007
+   Free Software Foundation, Inc.
+
+   This file is part of libopcodes.
+
+   This library is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   It is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or FITNESS FOR A PARTICULAR PURPOSE.  See the 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.,
+   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
+
+/* ??? Eventually more and more of this stuff can go to cpu-independent files.
+   Keep that in mind.  */
+
+#include "sysdep.h"
+#include <stdio.h>
+#include "ansidecl.h"
+#include "dis-asm.h"
+#include "bfd.h"
+#include "symcat.h"
+#include "arc-desc.h"
+#include "arc-opc.h"
+#include "opintl.h"
+#include "safe-ctype.h"
+
+#undef  min
+#define min(a,b) ((a) < (b) ? (a) : (b))
+#undef  max
+#define max(a,b) ((a) > (b) ? (a) : (b))
+
+/* Used by the ifield rtx function.  */
+#define FLD(f) (fields->f)
+
+static const char * insert_normal
+  (CGEN_CPU_DESC, long, unsigned int, unsigned int, unsigned int,
+   unsigned int, unsigned int, unsigned int, CGEN_INSN_BYTES_PTR);
+static const char * insert_insn_normal
+  (CGEN_CPU_DESC, const CGEN_INSN *,
+   CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
+static int extract_normal
+  (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
+   unsigned int, unsigned int, unsigned int, unsigned int,
+   unsigned int, unsigned int, bfd_vma, long *);
+static int extract_insn_normal
+  (CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *,
+   CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
+#if CGEN_INT_INSN_P
+static void put_insn_int_value
+  (CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT);
+#endif
+#if ! CGEN_INT_INSN_P
+static CGEN_INLINE void insert_1
+  (CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *);
+static CGEN_INLINE int fill_cache
+  (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *,  int, int, bfd_vma);
+static CGEN_INLINE long extract_1
+  (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int, unsigned char *, bfd_vma);
+#endif
+
+/* Operand insertion.  */
+
+#if ! CGEN_INT_INSN_P
+
+/* Subroutine of insert_normal.  */
+
+static CGEN_INLINE void
+insert_1 (CGEN_CPU_DESC cd,
+	  unsigned long value,
+	  int start,
+	  int length,
+	  int word_length,
+	  unsigned char *bufp)
+{
+  unsigned long x,mask;
+  int shift;
+
+  x = cgen_get_insn_value (cd, bufp, word_length);
+
+  /* Written this way to avoid undefined behaviour.  */
+  mask = (((1L << (length - 1)) - 1) << 1) | 1;
+  if (CGEN_INSN_LSB0_P)
+    shift = (start + 1) - length;
+  else
+    shift = (word_length - (start + length));
+  x = (x & ~(mask << shift)) | ((value & mask) << shift);
+
+  cgen_put_insn_value (cd, bufp, word_length, (bfd_vma) x);
+}
+
+#endif /* ! CGEN_INT_INSN_P */
+
+/* Default insertion routine.
+
+   ATTRS is a mask of the boolean attributes.
+   WORD_OFFSET is the offset in bits from the start of the insn of the value.
+   WORD_LENGTH is the length of the word in bits in which the value resides.
+   START is the starting bit number in the word, architecture origin.
+   LENGTH is the length of VALUE in bits.
+   TOTAL_LENGTH is the total length of the insn in bits.
+
+   The result is an error message or NULL if success.  */
+
+/* ??? This duplicates functionality with bfd's howto table and
+   bfd_install_relocation.  */
+/* ??? This doesn't handle bfd_vma's.  Create another function when
+   necessary.  */
+
+static const char *
+insert_normal (CGEN_CPU_DESC cd,
+	       long value,
+	       unsigned int attrs,
+	       unsigned int word_offset,
+	       unsigned int start,
+	       unsigned int length,
+	       unsigned int word_length,
+	       unsigned int total_length,
+	       CGEN_INSN_BYTES_PTR buffer)
+{
+  static char errbuf[100];
+  /* Written this way to avoid undefined behaviour.  */
+  unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1;
+
+  /* If LENGTH is zero, this operand doesn't contribute to the value.  */
+  if (length == 0)
+    return NULL;
+
+  if (word_length > 32)
+    abort ();
+
+  /* For architectures with insns smaller than the base-insn-bitsize,
+     word_length may be too big.  */
+  if (cd->min_insn_bitsize < cd->base_insn_bitsize)
+    {
+      if (word_offset == 0
+	  && word_length > total_length)
+	word_length = total_length;
+    }
+
+  /* Ensure VALUE will fit.  */
+  if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT))
+    {
+      long minval = - (1L << (length - 1));
+      unsigned long maxval = mask;
+      
+      if ((value > 0 && (unsigned long) value > maxval)
+	  || value < minval)
+	{
+	  /* xgettext:c-format */
+	  sprintf (errbuf,
+		   _("operand out of range (%ld not between %ld and %lu)"),
+		   value, minval, maxval);
+	  return errbuf;
+	}
+    }
+  else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
+    {
+      unsigned long maxval = mask;
+      unsigned long val = (unsigned long) value;
+
+      /* For hosts with a word size > 32 check to see if value has been sign
+	 extended beyond 32 bits.  If so then ignore these higher sign bits
+	 as the user is attempting to store a 32-bit signed value into an
+	 unsigned 32-bit field which is allowed.  */
+      if (sizeof (unsigned long) > 4 && ((value >> 32) == -1))
+	val &= 0xFFFFFFFF;
+
+      if (val > maxval)
+	{
+	  /* xgettext:c-format */
+	  sprintf (errbuf,
+		   _("operand out of range (0x%lx not between 0 and 0x%lx)"),
+		   val, maxval);
+	  return errbuf;
+	}
+    }
+  else
+    {
+      if (! cgen_signed_overflow_ok_p (cd))
+	{
+	  long minval = - (1L << (length - 1));
+	  long maxval =   (1L << (length - 1)) - 1;
+	  
+	  if (value < minval || value > maxval)
+	    {
+	      sprintf
+		/* xgettext:c-format */
+		(errbuf, _("operand out of range (%ld not between %ld and %ld)"),
+		 value, minval, maxval);
+	      return errbuf;
+	    }
+	}
+    }
+
+#if CGEN_INT_INSN_P
+
+  {
+    int shift;
+
+    if (CGEN_INSN_LSB0_P)
+      shift = (word_offset + start + 1) - length;
+    else
+      shift = total_length - (word_offset + start + length);
+    *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
+  }
+
+#else /* ! CGEN_INT_INSN_P */
+
+  {
+    unsigned char *bufp = (unsigned char *) buffer + word_offset / 8;
+
+    insert_1 (cd, value, start, length, word_length, bufp);
+  }
+
+#endif /* ! CGEN_INT_INSN_P */
+
+  return NULL;
+}
+
+/* Default insn builder (insert handler).
+   The instruction is recorded in CGEN_INT_INSN_P byte order (meaning
+   that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is
+   recorded in host byte order, otherwise BUFFER is an array of bytes
+   and the value is recorded in target byte order).
+   The result is an error message or NULL if success.  */
+
+static const char *
+insert_insn_normal (CGEN_CPU_DESC cd,
+		    const CGEN_INSN * insn,
+		    CGEN_FIELDS * fields,
+		    CGEN_INSN_BYTES_PTR buffer,
+		    bfd_vma pc)
+{
+  const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
+  unsigned long value;
+  const CGEN_SYNTAX_CHAR_TYPE * syn;
+
+  CGEN_INIT_INSERT (cd);
+  value = CGEN_INSN_BASE_VALUE (insn);
+
+  /* If we're recording insns as numbers (rather than a string of bytes),
+     target byte order handling is deferred until later.  */
+
+#if CGEN_INT_INSN_P
+
+  put_insn_int_value (cd, buffer, cd->base_insn_bitsize,
+		      CGEN_FIELDS_BITSIZE (fields), value);
+
+#else
+
+  cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize,
+					(unsigned) CGEN_FIELDS_BITSIZE (fields)),
+		       value);
+
+#endif /* ! CGEN_INT_INSN_P */
+
+  /* ??? It would be better to scan the format's fields.
+     Still need to be able to insert a value based on the operand though;
+     e.g. storing a branch displacement that got resolved later.
+     Needs more thought first.  */
+
+  for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn)
+    {
+      const char *errmsg;
+
+      if (CGEN_SYNTAX_CHAR_P (* syn))
+	continue;
+
+      errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
+				       fields, buffer, pc);
+      if (errmsg)
+	return errmsg;
+    }
+
+  return NULL;
+}
+
+#if CGEN_INT_INSN_P
+/* Cover function to store an insn value into an integral insn.  Must go here
+   because it needs <prefix>-desc.h for CGEN_INT_INSN_P.  */
+
+static void
+put_insn_int_value (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+		    CGEN_INSN_BYTES_PTR buf,
+		    int length,
+		    int insn_length,
+		    CGEN_INSN_INT value)
+{
+  /* For architectures with insns smaller than the base-insn-bitsize,
+     length may be too big.  */
+  if (length > insn_length)
+    *buf = value;
+  else
+    {
+      int shift = insn_length - length;
+      /* Written this way to avoid undefined behaviour.  */
+      CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1;
+
+      *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift);
+    }
+}
+#endif
+
+/* Operand extraction.  */
+
+#if ! CGEN_INT_INSN_P
+
+/* Subroutine of extract_normal.
+   Ensure sufficient bytes are cached in EX_INFO.
+   OFFSET is the offset in bytes from the start of the insn of the value.
+   BYTES is the length of the needed value.
+   Returns 1 for success, 0 for failure.  */
+
+static CGEN_INLINE int
+fill_cache (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+	    CGEN_EXTRACT_INFO *ex_info,
+	    int offset,
+	    int bytes,
+	    bfd_vma pc)
+{
+  /* It's doubtful that the middle part has already been fetched so
+     we don't optimize that case.  kiss.  */
+  unsigned int mask;
+  disassemble_info *info = (disassemble_info *) ex_info->dis_info;
+
+  /* First do a quick check.  */
+  mask = (1 << bytes) - 1;
+  if (((ex_info->valid >> offset) & mask) == mask)
+    return 1;
+
+  /* Search for the first byte we need to read.  */
+  for (mask = 1 << offset; bytes > 0; --bytes, ++offset, mask <<= 1)
+    if (! (mask & ex_info->valid))
+      break;
+
+  if (bytes)
+    {
+      int status;
+
+      pc += offset;
+      status = (*info->read_memory_func)
+	(pc, ex_info->insn_bytes + offset, bytes, info);
+
+      if (status != 0)
+	{
+	  (*info->memory_error_func) (status, pc, info);
+	  return 0;
+	}
+
+      ex_info->valid |= ((1 << bytes) - 1) << offset;
+    }
+
+  return 1;
+}
+
+/* Subroutine of extract_normal.  */
+
+static CGEN_INLINE long
+extract_1 (CGEN_CPU_DESC cd,
+	   CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
+	   int start,
+	   int length,
+	   int word_length,
+	   unsigned char *bufp,
+	   bfd_vma pc ATTRIBUTE_UNUSED)
+{
+  unsigned long x;
+  int shift;
+
+  x = cgen_get_insn_value (cd, bufp, word_length);
+
+  if (CGEN_INSN_LSB0_P)
+    shift = (start + 1) - length;
+  else
+    shift = (word_length - (start + length));
+  return x >> shift;
+}
+
+#endif /* ! CGEN_INT_INSN_P */
+
+/* Default extraction routine.
+
+   INSN_VALUE is the first base_insn_bitsize bits of the insn in host order,
+   or sometimes less for cases like the m32r where the base insn size is 32
+   but some insns are 16 bits.
+   ATTRS is a mask of the boolean attributes.  We only need `SIGNED',
+   but for generality we take a bitmask of all of them.
+   WORD_OFFSET is the offset in bits from the start of the insn of the value.
+   WORD_LENGTH is the length of the word in bits in which the value resides.
+   START is the starting bit number in the word, architecture origin.
+   LENGTH is the length of VALUE in bits.
+   TOTAL_LENGTH is the total length of the insn in bits.
+
+   Returns 1 for success, 0 for failure.  */
+
+/* ??? The return code isn't properly used.  wip.  */
+
+/* ??? This doesn't handle bfd_vma's.  Create another function when
+   necessary.  */
+
+static int
+extract_normal (CGEN_CPU_DESC cd,
+#if ! CGEN_INT_INSN_P
+		CGEN_EXTRACT_INFO *ex_info,
+#else
+		CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
+#endif
+		CGEN_INSN_INT insn_value,
+		unsigned int attrs,
+		unsigned int word_offset,
+		unsigned int start,
+		unsigned int length,
+		unsigned int word_length,
+		unsigned int total_length,
+#if ! CGEN_INT_INSN_P
+		bfd_vma pc,
+#else
+		bfd_vma pc ATTRIBUTE_UNUSED,
+#endif
+		long *valuep)
+{
+  long value, mask;
+
+  /* If LENGTH is zero, this operand doesn't contribute to the value
+     so give it a standard value of zero.  */
+  if (length == 0)
+    {
+      *valuep = 0;
+      return 1;
+    }
+
+  if (word_length > 32)
+    abort ();
+
+  /* For architectures with insns smaller than the insn-base-bitsize,
+     word_length may be too big.  */
+  if (cd->min_insn_bitsize < cd->base_insn_bitsize)
+    {
+      if (word_offset + word_length > total_length)
+	word_length = total_length - word_offset;
+    }
+
+  /* Does the value reside in INSN_VALUE, and at the right alignment?  */
+
+  if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))
+    {
+      if (CGEN_INSN_LSB0_P)
+	value = insn_value >> ((word_offset + start + 1) - length);
+      else
+	value = insn_value >> (total_length - ( word_offset + start + length));
+    }
+
+#if ! CGEN_INT_INSN_P
+
+  else
+    {
+      unsigned char *bufp = ex_info->insn_bytes + word_offset / 8;
+
+      if (word_length > 32)
+	abort ();
+
+      if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0)
+	return 0;
+
+      value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc);
+    }
+
+#endif /* ! CGEN_INT_INSN_P */
+
+  /* Written this way to avoid undefined behaviour.  */
+  mask = (((1L << (length - 1)) - 1) << 1) | 1;
+
+  value &= mask;
+  /* sign extend? */
+  if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
+      && (value & (1L << (length - 1))))
+    value |= ~mask;
+
+  *valuep = value;
+
+  return 1;
+}
+
+/* Default insn extractor.
+
+   INSN_VALUE is the first base_insn_bitsize bits, translated to host order.
+   The extracted fields are stored in FIELDS.
+   EX_INFO is used to handle reading variable length insns.
+   Return the length of the insn in bits, or 0 if no match,
+   or -1 if an error occurs fetching data (memory_error_func will have
+   been called).  */
+
+static int
+extract_insn_normal (CGEN_CPU_DESC cd,
+		     const CGEN_INSN *insn,
+		     CGEN_EXTRACT_INFO *ex_info,
+		     CGEN_INSN_INT insn_value,
+		     CGEN_FIELDS *fields,
+		     bfd_vma pc)
+{
+  const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
+  const CGEN_SYNTAX_CHAR_TYPE *syn;
+
+  CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
+
+  CGEN_INIT_EXTRACT (cd);
+
+  for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
+    {
+      int length;
+
+      if (CGEN_SYNTAX_CHAR_P (*syn))
+	continue;
+
+      length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
+					ex_info, insn_value, fields, pc);
+      if (length <= 0)
+	return length;
+    }
+
+  /* We recognized and successfully extracted this insn.  */
+  return CGEN_INSN_BITSIZE (insn);
+}
+
+/* Machine generated code added here.  */
+
+const char * arc_cgen_insert_operand
+  (CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
+
+/* Main entry point for operand insertion.
+
+   This function is basically just a big switch statement.  Earlier versions
+   used tables to look up the function to use, but
+   - if the table contains both assembler and disassembler functions then
+     the disassembler contains much of the assembler and vice-versa,
+   - there's a lot of inlining possibilities as things grow,
+   - using a switch statement avoids the function call overhead.
+
+   This function could be moved into `parse_insn_normal', but keeping it
+   separate makes clear the interface between `parse_insn_normal' and each of
+   the handlers.  It's also needed by GAS to insert operands that couldn't be
+   resolved during parsing.  */
+
+const char *
+arc_cgen_insert_operand (CGEN_CPU_DESC cd,
+			     int opindex,
+			     CGEN_FIELDS * fields,
+			     CGEN_INSN_BYTES_PTR buffer,
+			     bfd_vma pc ATTRIBUTE_UNUSED)
+{
+  const char * errmsg = NULL;
+  unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
+
+  switch (opindex)
+    {
+    case ARC_OPERAND_EXDI :
+      errmsg = insert_normal (cd, fields->f_F, 0, 0, 16, 1, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_F :
+      errmsg = insert_normal (cd, fields->f_F, 0, 0, 16, 1, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_F0 :
+      errmsg = insert_normal (cd, fields->f_F, 0, 0, 16, 1, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_F1 :
+      errmsg = insert_normal (cd, fields->f_F, 0, 0, 16, 1, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_F1F :
+      errmsg = insert_normal (cd, fields->f_F, 0, 0, 16, 1, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_GP :
+      break;
+    case ARC_OPERAND_LDODI :
+      errmsg = insert_normal (cd, fields->f_LDODi, 0, 0, 20, 1, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_LDRDI :
+      errmsg = insert_normal (cd, fields->f_LDRDi, 0, 0, 16, 1, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_NE :
+      break;
+    case ARC_OPERAND_PCL :
+      break;
+    case ARC_OPERAND_QCONDB :
+      errmsg = insert_normal (cd, fields->f_cond_Q, 0, 0, 27, 5, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_QCONDI :
+      errmsg = insert_normal (cd, fields->f_cond_Q, 0, 0, 27, 5, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_QCONDJ :
+      errmsg = insert_normal (cd, fields->f_cond_Q, 0, 0, 27, 5, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_R0 :
+      break;
+    case ARC_OPERAND_R31 :
+      break;
+    case ARC_OPERAND_RA :
+      errmsg = insert_normal (cd, fields->f_op_A, 0, 0, 26, 6, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_RA_0 :
+      errmsg = insert_normal (cd, fields->f_op_A, 0, 0, 26, 6, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_RB :
+      {
+{
+  FLD (f_op__b) = ((FLD (f_op_B)) & (7));
+  FLD (f_B_5_3) = ((unsigned int) (FLD (f_op_B)) >> (3));
+}
+        errmsg = insert_normal (cd, fields->f_op__b, 0, 0, 5, 3, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_B_5_3, 0, 0, 17, 3, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case ARC_OPERAND_RB_0 :
+      {
+{
+  FLD (f_op__b) = ((FLD (f_op_B)) & (7));
+  FLD (f_B_5_3) = ((unsigned int) (FLD (f_op_B)) >> (3));
+}
+        errmsg = insert_normal (cd, fields->f_op__b, 0, 0, 5, 3, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_B_5_3, 0, 0, 17, 3, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case ARC_OPERAND_RC :
+      errmsg = insert_normal (cd, fields->f_op_C, 0, 0, 20, 6, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_RC_ILINK :
+      errmsg = insert_normal (cd, fields->f_op_Cj, 0, 0, 20, 6, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_RC_NOILINK :
+      errmsg = insert_normal (cd, fields->f_op_Cj, 0, 0, 20, 6, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_R_A :
+      errmsg = insert_normal (cd, fields->f_op__a, 0, 0, 13, 3, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_R_B :
+      errmsg = insert_normal (cd, fields->f_op__b, 0, 0, 5, 3, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_R_C :
+      errmsg = insert_normal (cd, fields->f_op__c, 0, 0, 8, 3, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_RCC :
+      errmsg = insert_normal (cd, fields->f_brcond, 0, 0, 28, 4, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_RCCS :
+      errmsg = insert_normal (cd, fields->f_brscond, 0, 0, 8, 1, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_RH :
+      {
+{
+  FLD (f_h_2_0) = ((FLD (f_op_h)) & (7));
+  FLD (f_h_5_3) = ((unsigned int) (FLD (f_op_h)) >> (3));
+}
+        errmsg = insert_normal (cd, fields->f_h_2_0, 0, 0, 8, 3, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_h_5_3, 0, 0, 13, 3, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case ARC_OPERAND_SP :
+      break;
+    case ARC_OPERAND_STODI :
+      errmsg = insert_normal (cd, fields->f_STODi, 0, 0, 26, 1, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_U6 :
+      errmsg = insert_normal (cd, fields->f_u6, 0, 0, 20, 6, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_U6X2 :
+      {
+        long value = fields->f_u6x2;
+        value = ((unsigned int) (value) >> (1));
+        errmsg = insert_normal (cd, value, 0, 0, 20, 6, 32, total_length, buffer);
+      }
+      break;
+    case ARC_OPERAND__AW :
+      break;
+    case ARC_OPERAND__L :
+      break;
+    case ARC_OPERAND__S :
+      break;
+    case ARC_OPERAND_CBIT :
+      break;
+    case ARC_OPERAND_DELAY_N :
+      errmsg = insert_normal (cd, fields->f_delay_N, 0, 0, 26, 1, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_DUMMY_OP :
+      errmsg = insert_normal (cd, fields->f_dummy, 0, 0, 16, 16, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_I2COND :
+      errmsg = insert_normal (cd, fields->f_cond_i2, 0, 0, 5, 2, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_I3COND :
+      errmsg = insert_normal (cd, fields->f_cond_i3, 0, 0, 7, 3, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_LABEL10 :
+      {
+        long value = fields->f_rel10;
+        value = ((int) (((value) - (((pc) & (-4))))) >> (1));
+        errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 7, 9, 32, total_length, buffer);
+      }
+      break;
+    case ARC_OPERAND_LABEL13A :
+      {
+        long value = fields->f_rel13bl;
+        value = ((int) (((value) - (((pc) & (-4))))) >> (2));
+        errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 5, 11, 32, total_length, buffer);
+      }
+      break;
+    case ARC_OPERAND_LABEL21 :
+      {
+{
+  FLD (f_d21l) = ((((unsigned int) (((FLD (f_rel21)) - (((pc) & (-4))))) >> (1))) & (1023));
+  FLD (f_d21h) = ((unsigned int) (((FLD (f_rel21)) - (((pc) & (-4))))) >> (11));
+}
+        errmsg = insert_normal (cd, fields->f_d21l, 0, 0, 5, 10, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_d21h, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 10, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case ARC_OPERAND_LABEL21A :
+      {
+{
+  FLD (f_d21bl) = ((((unsigned int) (((FLD (f_rel21bl)) - (((pc) & (-4))))) >> (2))) & (511));
+  FLD (f_d21h) = ((unsigned int) (((FLD (f_rel21bl)) - (((pc) & (-4))))) >> (11));
+}
+        errmsg = insert_normal (cd, fields->f_d21bl, 0, 0, 5, 9, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_d21h, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 10, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case ARC_OPERAND_LABEL25 :
+      {
+{
+  FLD (f_d21l) = ((((unsigned int) (((FLD (f_rel25)) - (((pc) & (-4))))) >> (1))) & (1023));
+  FLD (f_d25m) = ((unsigned int) (((FLD (f_rel25)) - (((pc) & (-4))))) >> (11));
+  FLD (f_d25h) = ((unsigned int) (((FLD (f_rel25)) - (((pc) & (-4))))) >> (21));
+}
+        errmsg = insert_normal (cd, fields->f_d21l, 0, 0, 5, 10, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_d25m, 0, 0, 16, 10, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_d25h, 0|(1<<CGEN_IFLD_SIGNED), 0, 28, 4, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case ARC_OPERAND_LABEL25A :
+      {
+{
+  FLD (f_d21bl) = ((((unsigned int) (((FLD (f_rel25bl)) - (((pc) & (-4))))) >> (2))) & (511));
+  FLD (f_d25m) = ((unsigned int) (((FLD (f_rel25bl)) - (((pc) & (-4))))) >> (11));
+  FLD (f_d25h) = ((unsigned int) (((FLD (f_rel25bl)) - (((pc) & (-4))))) >> (21));
+}
+        errmsg = insert_normal (cd, fields->f_d21bl, 0, 0, 5, 9, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_d25m, 0, 0, 16, 10, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_d25h, 0|(1<<CGEN_IFLD_SIGNED), 0, 28, 4, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case ARC_OPERAND_LABEL7 :
+      {
+        long value = fields->f_rel7;
+        value = ((int) (((value) - (((pc) & (-4))))) >> (1));
+        errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 10, 6, 32, total_length, buffer);
+      }
+      break;
+    case ARC_OPERAND_LABEL8 :
+      {
+        long value = fields->f_rel8;
+        value = ((int) (((value) - (((pc) & (-4))))) >> (1));
+        errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 9, 7, 32, total_length, buffer);
+      }
+      break;
+    case ARC_OPERAND_LABEL9 :
+      {
+{
+  FLD (f_d9l) = ((((unsigned int) (((FLD (f_rel9)) - (((pc) & (-4))))) >> (1))) & (127));
+  FLD (f_d9h) = ((unsigned int) (((FLD (f_rel9)) - (((pc) & (-4))))) >> (8));
+}
+        errmsg = insert_normal (cd, fields->f_d9l, 0, 0, 8, 7, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_d9h, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 1, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case ARC_OPERAND_LBIT :
+      break;
+    case ARC_OPERAND_NBIT :
+      break;
+    case ARC_OPERAND_S12 :
+      {
+{
+  FLD (f_u6) = ((FLD (f_s12)) & (63));
+  FLD (f_s12h) = ((unsigned int) (FLD (f_s12)) >> (6));
+}
+        errmsg = insert_normal (cd, fields->f_u6, 0, 0, 20, 6, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_s12h, 0|(1<<CGEN_IFLD_SIGNED), 0, 26, 6, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case ARC_OPERAND_S12X2 :
+      {
+{
+  FLD (f_u6) = ((((unsigned int) (FLD (f_s12x2)) >> (1))) & (63));
+  FLD (f_s12h) = ((unsigned int) (FLD (f_s12x2)) >> (7));
+}
+        errmsg = insert_normal (cd, fields->f_u6, 0, 0, 20, 6, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_s12h, 0|(1<<CGEN_IFLD_SIGNED), 0, 26, 6, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case ARC_OPERAND_S1BIT :
+      break;
+    case ARC_OPERAND_S2BIT :
+      break;
+    case ARC_OPERAND_S9 :
+      {
+{
+  FLD (f_u8) = ((FLD (f_s9)) & (255));
+  FLD (f_d9h) = ((unsigned int) (FLD (f_s9)) >> (8));
+}
+        errmsg = insert_normal (cd, fields->f_u8, 0, 0, 8, 8, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_d9h, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 1, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case ARC_OPERAND_S9X4 :
+      {
+        long value = fields->f_s9x4;
+        value = ((unsigned int) (value) >> (2));
+        errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 7, 9, 32, total_length, buffer);
+      }
+      break;
+    case ARC_OPERAND_SC_S9_ :
+      {
+        long value = fields->f_s9x4;
+        value = ((unsigned int) (value) >> (2));
+        errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 7, 9, 32, total_length, buffer);
+      }
+      break;
+    case ARC_OPERAND_SC_S9B :
+      errmsg = insert_normal (cd, fields->f_s9x1, 0|(1<<CGEN_IFLD_SIGNED), 0, 7, 9, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_SC_S9W :
+      {
+        long value = fields->f_s9x2;
+        value = ((unsigned int) (value) >> (1));
+        errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 7, 9, 32, total_length, buffer);
+      }
+      break;
+    case ARC_OPERAND_SC_U5_ :
+      {
+        long value = fields->f_u5x4;
+        value = ((unsigned int) (value) >> (2));
+        errmsg = insert_normal (cd, value, 0, 0, 11, 5, 32, total_length, buffer);
+      }
+      break;
+    case ARC_OPERAND_SC_U5B :
+      errmsg = insert_normal (cd, fields->f_u5, 0, 0, 11, 5, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_SC_U5W :
+      {
+        long value = fields->f_u5x2;
+        value = ((unsigned int) (value) >> (1));
+        errmsg = insert_normal (cd, value, 0, 0, 11, 5, 32, total_length, buffer);
+      }
+      break;
+    case ARC_OPERAND_TRAPNUM :
+      errmsg = insert_normal (cd, fields->f_trapnum, 0, 0, 5, 6, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_U3 :
+      errmsg = insert_normal (cd, fields->f_u3, 0, 0, 13, 3, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_U5 :
+      errmsg = insert_normal (cd, fields->f_u5, 0, 0, 11, 5, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_U5X4 :
+      {
+        long value = fields->f_u5x4;
+        value = ((unsigned int) (value) >> (2));
+        errmsg = insert_normal (cd, value, 0, 0, 11, 5, 32, total_length, buffer);
+      }
+      break;
+    case ARC_OPERAND_U7 :
+      errmsg = insert_normal (cd, fields->f_u7, 0, 0, 9, 7, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_U8 :
+      errmsg = insert_normal (cd, fields->f_u8, 0, 0, 8, 8, 32, total_length, buffer);
+      break;
+    case ARC_OPERAND_U8X4 :
+      {
+        long value = fields->f_u8x4;
+        value = ((unsigned int) (value) >> (2));
+        errmsg = insert_normal (cd, value, 0, 0, 8, 8, 32, total_length, buffer);
+      }
+      break;
+    case ARC_OPERAND_UNCONDB :
+      break;
+    case ARC_OPERAND_UNCONDI :
+      break;
+    case ARC_OPERAND_UNCONDJ :
+      break;
+    case ARC_OPERAND_VBIT :
+      break;
+    case ARC_OPERAND_ZBIT :
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
+	       opindex);
+      abort ();
+  }
+
+  return errmsg;
+}
+
+int arc_cgen_extract_operand
+  (CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
+
+/* Main entry point for operand extraction.
+   The result is <= 0 for error, >0 for success.
+   ??? Actual values aren't well defined right now.
+
+   This function is basically just a big switch statement.  Earlier versions
+   used tables to look up the function to use, but
+   - if the table contains both assembler and disassembler functions then
+     the disassembler contains much of the assembler and vice-versa,
+   - there's a lot of inlining possibilities as things grow,
+   - using a switch statement avoids the function call overhead.
+
+   This function could be moved into `print_insn_normal', but keeping it
+   separate makes clear the interface between `print_insn_normal' and each of
+   the handlers.  */
+
+int
+arc_cgen_extract_operand (CGEN_CPU_DESC cd,
+			     int opindex,
+			     CGEN_EXTRACT_INFO *ex_info,
+			     CGEN_INSN_INT insn_value,
+			     CGEN_FIELDS * fields,
+			     bfd_vma pc)
+{
+  /* Assume success (for those operands that are nops).  */
+  int length = 1;
+  unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
+
+  switch (opindex)
+    {
+    case ARC_OPERAND_EXDI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 1, 32, total_length, pc, & fields->f_F);
+      break;
+    case ARC_OPERAND_F :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 1, 32, total_length, pc, & fields->f_F);
+      break;
+    case ARC_OPERAND_F0 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 1, 32, total_length, pc, & fields->f_F);
+      break;
+    case ARC_OPERAND_F1 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 1, 32, total_length, pc, & fields->f_F);
+      break;
+    case ARC_OPERAND_F1F :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 1, 32, total_length, pc, & fields->f_F);
+      break;
+    case ARC_OPERAND_GP :
+      break;
+    case ARC_OPERAND_LDODI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 1, 32, total_length, pc, & fields->f_LDODi);
+      break;
+    case ARC_OPERAND_LDRDI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 1, 32, total_length, pc, & fields->f_LDRDi);
+      break;
+    case ARC_OPERAND_NE :
+      break;
+    case ARC_OPERAND_PCL :
+      break;
+    case ARC_OPERAND_QCONDB :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 27, 5, 32, total_length, pc, & fields->f_cond_Q);
+      break;
+    case ARC_OPERAND_QCONDI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 27, 5, 32, total_length, pc, & fields->f_cond_Q);
+      break;
+    case ARC_OPERAND_QCONDJ :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 27, 5, 32, total_length, pc, & fields->f_cond_Q);
+      break;
+    case ARC_OPERAND_R0 :
+      break;
+    case ARC_OPERAND_R31 :
+      break;
+    case ARC_OPERAND_RA :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 6, 32, total_length, pc, & fields->f_op_A);
+      break;
+    case ARC_OPERAND_RA_0 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 6, 32, total_length, pc, & fields->f_op_A);
+      break;
+    case ARC_OPERAND_RB :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_op__b);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 3, 32, total_length, pc, & fields->f_B_5_3);
+        if (length <= 0) break;
+{
+  FLD (f_op_B) = ((FLD (f_op__b)) | (((FLD (f_B_5_3)) << (3))));
+}
+      }
+      break;
+    case ARC_OPERAND_RB_0 :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_op__b);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 3, 32, total_length, pc, & fields->f_B_5_3);
+        if (length <= 0) break;
+{
+  FLD (f_op_B) = ((FLD (f_op__b)) | (((FLD (f_B_5_3)) << (3))));
+}
+      }
+      break;
+    case ARC_OPERAND_RC :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 6, 32, total_length, pc, & fields->f_op_C);
+      break;
+    case ARC_OPERAND_RC_ILINK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 6, 32, total_length, pc, & fields->f_op_Cj);
+      break;
+    case ARC_OPERAND_RC_NOILINK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 6, 32, total_length, pc, & fields->f_op_Cj);
+      break;
+    case ARC_OPERAND_R_A :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 13, 3, 32, total_length, pc, & fields->f_op__a);
+      break;
+    case ARC_OPERAND_R_B :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_op__b);
+      break;
+    case ARC_OPERAND_R_C :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 3, 32, total_length, pc, & fields->f_op__c);
+      break;
+    case ARC_OPERAND_RCC :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 4, 32, total_length, pc, & fields->f_brcond);
+      break;
+    case ARC_OPERAND_RCCS :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 1, 32, total_length, pc, & fields->f_brscond);
+      break;
+    case ARC_OPERAND_RH :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 3, 32, total_length, pc, & fields->f_h_2_0);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 13, 3, 32, total_length, pc, & fields->f_h_5_3);
+        if (length <= 0) break;
+{
+  FLD (f_op_h) = ((FLD (f_h_2_0)) | (((FLD (f_h_5_3)) << (3))));
+}
+      }
+      break;
+    case ARC_OPERAND_SP :
+      break;
+    case ARC_OPERAND_STODI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 1, 32, total_length, pc, & fields->f_STODi);
+      break;
+    case ARC_OPERAND_U6 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 6, 32, total_length, pc, & fields->f_u6);
+      break;
+    case ARC_OPERAND_U6X2 :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 6, 32, total_length, pc, & value);
+        value = ((value) << (1));
+        fields->f_u6x2 = value;
+      }
+      break;
+    case ARC_OPERAND__AW :
+      break;
+    case ARC_OPERAND__L :
+      break;
+    case ARC_OPERAND__S :
+      break;
+    case ARC_OPERAND_CBIT :
+      break;
+    case ARC_OPERAND_DELAY_N :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 1, 32, total_length, pc, & fields->f_delay_N);
+      break;
+    case ARC_OPERAND_DUMMY_OP :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_dummy);
+      break;
+    case ARC_OPERAND_I2COND :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 2, 32, total_length, pc, & fields->f_cond_i2);
+      break;
+    case ARC_OPERAND_I3COND :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 3, 32, total_length, pc, & fields->f_cond_i3);
+      break;
+    case ARC_OPERAND_LABEL10 :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 7, 9, 32, total_length, pc, & value);
+        value = ((((value) << (1))) + (((pc) & (-4))));
+        fields->f_rel10 = value;
+      }
+      break;
+    case ARC_OPERAND_LABEL13A :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 5, 11, 32, total_length, pc, & value);
+        value = ((((value) << (2))) + (((pc) & (-4))));
+        fields->f_rel13bl = value;
+      }
+      break;
+    case ARC_OPERAND_LABEL21 :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 10, 32, total_length, pc, & fields->f_d21l);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 10, 32, total_length, pc, & fields->f_d21h);
+        if (length <= 0) break;
+{
+  FLD (f_rel21) = ((((((FLD (f_d21l)) << (1))) | (((FLD (f_d21h)) << (11))))) + (((pc) & (-4))));
+}
+      }
+      break;
+    case ARC_OPERAND_LABEL21A :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 9, 32, total_length, pc, & fields->f_d21bl);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 10, 32, total_length, pc, & fields->f_d21h);
+        if (length <= 0) break;
+{
+  FLD (f_rel21bl) = ((((((FLD (f_d21bl)) << (2))) | (((FLD (f_d21h)) << (11))))) + (((pc) & (-4))));
+}
+      }
+      break;
+    case ARC_OPERAND_LABEL25 :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 10, 32, total_length, pc, & fields->f_d21l);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 10, 32, total_length, pc, & fields->f_d25m);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 28, 4, 32, total_length, pc, & fields->f_d25h);
+        if (length <= 0) break;
+{
+  FLD (f_rel25) = ((((((((FLD (f_d21l)) << (1))) | (((FLD (f_d25m)) << (11))))) | (((FLD (f_d25h)) << (21))))) + (((pc) & (-4))));
+}
+      }
+      break;
+    case ARC_OPERAND_LABEL25A :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 9, 32, total_length, pc, & fields->f_d21bl);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 10, 32, total_length, pc, & fields->f_d25m);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 28, 4, 32, total_length, pc, & fields->f_d25h);
+        if (length <= 0) break;
+{
+  FLD (f_rel25bl) = ((((((((FLD (f_d21bl)) << (2))) | (((FLD (f_d25m)) << (11))))) | (((FLD (f_d25h)) << (21))))) + (((pc) & (-4))));
+}
+      }
+      break;
+    case ARC_OPERAND_LABEL7 :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 10, 6, 32, total_length, pc, & value);
+        value = ((((value) << (1))) + (((pc) & (-4))));
+        fields->f_rel7 = value;
+      }
+      break;
+    case ARC_OPERAND_LABEL8 :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 9, 7, 32, total_length, pc, & value);
+        value = ((((value) << (1))) + (((pc) & (-4))));
+        fields->f_rel8 = value;
+      }
+      break;
+    case ARC_OPERAND_LABEL9 :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 7, 32, total_length, pc, & fields->f_d9l);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 1, 32, total_length, pc, & fields->f_d9h);
+        if (length <= 0) break;
+{
+  FLD (f_rel9) = ((((((FLD (f_d9l)) << (1))) | (((FLD (f_d9h)) << (8))))) + (((pc) & (-4))));
+}
+      }
+      break;
+    case ARC_OPERAND_LBIT :
+      break;
+    case ARC_OPERAND_NBIT :
+      break;
+    case ARC_OPERAND_S12 :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 6, 32, total_length, pc, & fields->f_u6);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 26, 6, 32, total_length, pc, & fields->f_s12h);
+        if (length <= 0) break;
+{
+  FLD (f_s12) = ((FLD (f_u6)) | (((FLD (f_s12h)) << (6))));
+}
+      }
+      break;
+    case ARC_OPERAND_S12X2 :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 6, 32, total_length, pc, & fields->f_u6);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 26, 6, 32, total_length, pc, & fields->f_s12h);
+        if (length <= 0) break;
+{
+  FLD (f_s12x2) = ((((FLD (f_u6)) << (1))) | (((FLD (f_s12h)) << (7))));
+}
+      }
+      break;
+    case ARC_OPERAND_S1BIT :
+      break;
+    case ARC_OPERAND_S2BIT :
+      break;
+    case ARC_OPERAND_S9 :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 8, 32, total_length, pc, & fields->f_u8);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 1, 32, total_length, pc, & fields->f_d9h);
+        if (length <= 0) break;
+{
+  FLD (f_s9) = ((FLD (f_u8)) | (((FLD (f_d9h)) << (8))));
+}
+      }
+      break;
+    case ARC_OPERAND_S9X4 :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 7, 9, 32, total_length, pc, & value);
+        value = ((value) << (2));
+        fields->f_s9x4 = value;
+      }
+      break;
+    case ARC_OPERAND_SC_S9_ :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 7, 9, 32, total_length, pc, & value);
+        value = ((value) << (2));
+        fields->f_s9x4 = value;
+      }
+      break;
+    case ARC_OPERAND_SC_S9B :
+      length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 7, 9, 32, total_length, pc, & fields->f_s9x1);
+      break;
+    case ARC_OPERAND_SC_S9W :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 7, 9, 32, total_length, pc, & value);
+        value = ((value) << (1));
+        fields->f_s9x2 = value;
+      }
+      break;
+    case ARC_OPERAND_SC_U5_ :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 5, 32, total_length, pc, & value);
+        value = ((value) << (2));
+        fields->f_u5x4 = value;
+      }
+      break;
+    case ARC_OPERAND_SC_U5B :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 5, 32, total_length, pc, & fields->f_u5);
+      break;
+    case ARC_OPERAND_SC_U5W :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 5, 32, total_length, pc, & value);
+        value = ((value) << (1));
+        fields->f_u5x2 = value;
+      }
+      break;
+    case ARC_OPERAND_TRAPNUM :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_trapnum);
+      break;
+    case ARC_OPERAND_U3 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 13, 3, 32, total_length, pc, & fields->f_u3);
+      break;
+    case ARC_OPERAND_U5 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 5, 32, total_length, pc, & fields->f_u5);
+      break;
+    case ARC_OPERAND_U5X4 :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 5, 32, total_length, pc, & value);
+        value = ((value) << (2));
+        fields->f_u5x4 = value;
+      }
+      break;
+    case ARC_OPERAND_U7 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 7, 32, total_length, pc, & fields->f_u7);
+      break;
+    case ARC_OPERAND_U8 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 8, 32, total_length, pc, & fields->f_u8);
+      break;
+    case ARC_OPERAND_U8X4 :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 8, 32, total_length, pc, & value);
+        value = ((value) << (2));
+        fields->f_u8x4 = value;
+      }
+      break;
+    case ARC_OPERAND_UNCONDB :
+      break;
+    case ARC_OPERAND_UNCONDI :
+      break;
+    case ARC_OPERAND_UNCONDJ :
+      break;
+    case ARC_OPERAND_VBIT :
+      break;
+    case ARC_OPERAND_ZBIT :
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
+	       opindex);
+      abort ();
+    }
+
+  return length;
+}
+
+cgen_insert_fn * const arc_cgen_insert_handlers[] = 
+{
+  insert_insn_normal,
+};
+
+cgen_extract_fn * const arc_cgen_extract_handlers[] = 
+{
+  extract_insn_normal,
+};
+
+int arc_cgen_get_int_operand     (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
+bfd_vma arc_cgen_get_vma_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
+
+/* Getting values from cgen_fields is handled by a collection of functions.
+   They are distinguished by the type of the VALUE argument they return.
+   TODO: floating point, inlining support, remove cases where result type
+   not appropriate.  */
+
+int
+arc_cgen_get_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+			     int opindex,
+			     const CGEN_FIELDS * fields)
+{
+  int value;
+
+  switch (opindex)
+    {
+    case ARC_OPERAND_EXDI :
+      value = fields->f_F;
+      break;
+    case ARC_OPERAND_F :
+      value = fields->f_F;
+      break;
+    case ARC_OPERAND_F0 :
+      value = fields->f_F;
+      break;
+    case ARC_OPERAND_F1 :
+      value = fields->f_F;
+      break;
+    case ARC_OPERAND_F1F :
+      value = fields->f_F;
+      break;
+    case ARC_OPERAND_GP :
+      value = 0;
+      break;
+    case ARC_OPERAND_LDODI :
+      value = fields->f_LDODi;
+      break;
+    case ARC_OPERAND_LDRDI :
+      value = fields->f_LDRDi;
+      break;
+    case ARC_OPERAND_NE :
+      value = 0;
+      break;
+    case ARC_OPERAND_PCL :
+      value = 0;
+      break;
+    case ARC_OPERAND_QCONDB :
+      value = fields->f_cond_Q;
+      break;
+    case ARC_OPERAND_QCONDI :
+      value = fields->f_cond_Q;
+      break;
+    case ARC_OPERAND_QCONDJ :
+      value = fields->f_cond_Q;
+      break;
+    case ARC_OPERAND_R0 :
+      value = 0;
+      break;
+    case ARC_OPERAND_R31 :
+      value = 0;
+      break;
+    case ARC_OPERAND_RA :
+      value = fields->f_op_A;
+      break;
+    case ARC_OPERAND_RA_0 :
+      value = fields->f_op_A;
+      break;
+    case ARC_OPERAND_RB :
+      value = fields->f_op_B;
+      break;
+    case ARC_OPERAND_RB_0 :
+      value = fields->f_op_B;
+      break;
+    case ARC_OPERAND_RC :
+      value = fields->f_op_C;
+      break;
+    case ARC_OPERAND_RC_ILINK :
+      value = fields->f_op_Cj;
+      break;
+    case ARC_OPERAND_RC_NOILINK :
+      value = fields->f_op_Cj;
+      break;
+    case ARC_OPERAND_R_A :
+      value = fields->f_op__a;
+      break;
+    case ARC_OPERAND_R_B :
+      value = fields->f_op__b;
+      break;
+    case ARC_OPERAND_R_C :
+      value = fields->f_op__c;
+      break;
+    case ARC_OPERAND_RCC :
+      value = fields->f_brcond;
+      break;
+    case ARC_OPERAND_RCCS :
+      value = fields->f_brscond;
+      break;
+    case ARC_OPERAND_RH :
+      value = fields->f_op_h;
+      break;
+    case ARC_OPERAND_SP :
+      value = 0;
+      break;
+    case ARC_OPERAND_STODI :
+      value = fields->f_STODi;
+      break;
+    case ARC_OPERAND_U6 :
+      value = fields->f_u6;
+      break;
+    case ARC_OPERAND_U6X2 :
+      value = fields->f_u6x2;
+      break;
+    case ARC_OPERAND__AW :
+      value = 0;
+      break;
+    case ARC_OPERAND__L :
+      value = 0;
+      break;
+    case ARC_OPERAND__S :
+      value = 0;
+      break;
+    case ARC_OPERAND_CBIT :
+      value = 0;
+      break;
+    case ARC_OPERAND_DELAY_N :
+      value = fields->f_delay_N;
+      break;
+    case ARC_OPERAND_DUMMY_OP :
+      value = fields->f_dummy;
+      break;
+    case ARC_OPERAND_I2COND :
+      value = fields->f_cond_i2;
+      break;
+    case ARC_OPERAND_I3COND :
+      value = fields->f_cond_i3;
+      break;
+    case ARC_OPERAND_LABEL10 :
+      value = fields->f_rel10;
+      break;
+    case ARC_OPERAND_LABEL13A :
+      value = fields->f_rel13bl;
+      break;
+    case ARC_OPERAND_LABEL21 :
+      value = fields->f_rel21;
+      break;
+    case ARC_OPERAND_LABEL21A :
+      value = fields->f_rel21bl;
+      break;
+    case ARC_OPERAND_LABEL25 :
+      value = fields->f_rel25;
+      break;
+    case ARC_OPERAND_LABEL25A :
+      value = fields->f_rel25bl;
+      break;
+    case ARC_OPERAND_LABEL7 :
+      value = fields->f_rel7;
+      break;
+    case ARC_OPERAND_LABEL8 :
+      value = fields->f_rel8;
+      break;
+    case ARC_OPERAND_LABEL9 :
+      value = fields->f_rel9;
+      break;
+    case ARC_OPERAND_LBIT :
+      value = 0;
+      break;
+    case ARC_OPERAND_NBIT :
+      value = 0;
+      break;
+    case ARC_OPERAND_S12 :
+      value = fields->f_s12;
+      break;
+    case ARC_OPERAND_S12X2 :
+      value = fields->f_s12x2;
+      break;
+    case ARC_OPERAND_S1BIT :
+      value = 0;
+      break;
+    case ARC_OPERAND_S2BIT :
+      value = 0;
+      break;
+    case ARC_OPERAND_S9 :
+      value = fields->f_s9;
+      break;
+    case ARC_OPERAND_S9X4 :
+      value = fields->f_s9x4;
+      break;
+    case ARC_OPERAND_SC_S9_ :
+      value = fields->f_s9x4;
+      break;
+    case ARC_OPERAND_SC_S9B :
+      value = fields->f_s9x1;
+      break;
+    case ARC_OPERAND_SC_S9W :
+      value = fields->f_s9x2;
+      break;
+    case ARC_OPERAND_SC_U5_ :
+      value = fields->f_u5x4;
+      break;
+    case ARC_OPERAND_SC_U5B :
+      value = fields->f_u5;
+      break;
+    case ARC_OPERAND_SC_U5W :
+      value = fields->f_u5x2;
+      break;
+    case ARC_OPERAND_TRAPNUM :
+      value = fields->f_trapnum;
+      break;
+    case ARC_OPERAND_U3 :
+      value = fields->f_u3;
+      break;
+    case ARC_OPERAND_U5 :
+      value = fields->f_u5;
+      break;
+    case ARC_OPERAND_U5X4 :
+      value = fields->f_u5x4;
+      break;
+    case ARC_OPERAND_U7 :
+      value = fields->f_u7;
+      break;
+    case ARC_OPERAND_U8 :
+      value = fields->f_u8;
+      break;
+    case ARC_OPERAND_U8X4 :
+      value = fields->f_u8x4;
+      break;
+    case ARC_OPERAND_UNCONDB :
+      value = 0;
+      break;
+    case ARC_OPERAND_UNCONDI :
+      value = 0;
+      break;
+    case ARC_OPERAND_UNCONDJ :
+      value = 0;
+      break;
+    case ARC_OPERAND_VBIT :
+      value = 0;
+      break;
+    case ARC_OPERAND_ZBIT :
+      value = 0;
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
+		       opindex);
+      abort ();
+  }
+
+  return value;
+}
+
+bfd_vma
+arc_cgen_get_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+			     int opindex,
+			     const CGEN_FIELDS * fields)
+{
+  bfd_vma value;
+
+  switch (opindex)
+    {
+    case ARC_OPERAND_EXDI :
+      value = fields->f_F;
+      break;
+    case ARC_OPERAND_F :
+      value = fields->f_F;
+      break;
+    case ARC_OPERAND_F0 :
+      value = fields->f_F;
+      break;
+    case ARC_OPERAND_F1 :
+      value = fields->f_F;
+      break;
+    case ARC_OPERAND_F1F :
+      value = fields->f_F;
+      break;
+    case ARC_OPERAND_GP :
+      value = 0;
+      break;
+    case ARC_OPERAND_LDODI :
+      value = fields->f_LDODi;
+      break;
+    case ARC_OPERAND_LDRDI :
+      value = fields->f_LDRDi;
+      break;
+    case ARC_OPERAND_NE :
+      value = 0;
+      break;
+    case ARC_OPERAND_PCL :
+      value = 0;
+      break;
+    case ARC_OPERAND_QCONDB :
+      value = fields->f_cond_Q;
+      break;
+    case ARC_OPERAND_QCONDI :
+      value = fields->f_cond_Q;
+      break;
+    case ARC_OPERAND_QCONDJ :
+      value = fields->f_cond_Q;
+      break;
+    case ARC_OPERAND_R0 :
+      value = 0;
+      break;
+    case ARC_OPERAND_R31 :
+      value = 0;
+      break;
+    case ARC_OPERAND_RA :
+      value = fields->f_op_A;
+      break;
+    case ARC_OPERAND_RA_0 :
+      value = fields->f_op_A;
+      break;
+    case ARC_OPERAND_RB :
+      value = fields->f_op_B;
+      break;
+    case ARC_OPERAND_RB_0 :
+      value = fields->f_op_B;
+      break;
+    case ARC_OPERAND_RC :
+      value = fields->f_op_C;
+      break;
+    case ARC_OPERAND_RC_ILINK :
+      value = fields->f_op_Cj;
+      break;
+    case ARC_OPERAND_RC_NOILINK :
+      value = fields->f_op_Cj;
+      break;
+    case ARC_OPERAND_R_A :
+      value = fields->f_op__a;
+      break;
+    case ARC_OPERAND_R_B :
+      value = fields->f_op__b;
+      break;
+    case ARC_OPERAND_R_C :
+      value = fields->f_op__c;
+      break;
+    case ARC_OPERAND_RCC :
+      value = fields->f_brcond;
+      break;
+    case ARC_OPERAND_RCCS :
+      value = fields->f_brscond;
+      break;
+    case ARC_OPERAND_RH :
+      value = fields->f_op_h;
+      break;
+    case ARC_OPERAND_SP :
+      value = 0;
+      break;
+    case ARC_OPERAND_STODI :
+      value = fields->f_STODi;
+      break;
+    case ARC_OPERAND_U6 :
+      value = fields->f_u6;
+      break;
+    case ARC_OPERAND_U6X2 :
+      value = fields->f_u6x2;
+      break;
+    case ARC_OPERAND__AW :
+      value = 0;
+      break;
+    case ARC_OPERAND__L :
+      value = 0;
+      break;
+    case ARC_OPERAND__S :
+      value = 0;
+      break;
+    case ARC_OPERAND_CBIT :
+      value = 0;
+      break;
+    case ARC_OPERAND_DELAY_N :
+      value = fields->f_delay_N;
+      break;
+    case ARC_OPERAND_DUMMY_OP :
+      value = fields->f_dummy;
+      break;
+    case ARC_OPERAND_I2COND :
+      value = fields->f_cond_i2;
+      break;
+    case ARC_OPERAND_I3COND :
+      value = fields->f_cond_i3;
+      break;
+    case ARC_OPERAND_LABEL10 :
+      value = fields->f_rel10;
+      break;
+    case ARC_OPERAND_LABEL13A :
+      value = fields->f_rel13bl;
+      break;
+    case ARC_OPERAND_LABEL21 :
+      value = fields->f_rel21;
+      break;
+    case ARC_OPERAND_LABEL21A :
+      value = fields->f_rel21bl;
+      break;
+    case ARC_OPERAND_LABEL25 :
+      value = fields->f_rel25;
+      break;
+    case ARC_OPERAND_LABEL25A :
+      value = fields->f_rel25bl;
+      break;
+    case ARC_OPERAND_LABEL7 :
+      value = fields->f_rel7;
+      break;
+    case ARC_OPERAND_LABEL8 :
+      value = fields->f_rel8;
+      break;
+    case ARC_OPERAND_LABEL9 :
+      value = fields->f_rel9;
+      break;
+    case ARC_OPERAND_LBIT :
+      value = 0;
+      break;
+    case ARC_OPERAND_NBIT :
+      value = 0;
+      break;
+    case ARC_OPERAND_S12 :
+      value = fields->f_s12;
+      break;
+    case ARC_OPERAND_S12X2 :
+      value = fields->f_s12x2;
+      break;
+    case ARC_OPERAND_S1BIT :
+      value = 0;
+      break;
+    case ARC_OPERAND_S2BIT :
+      value = 0;
+      break;
+    case ARC_OPERAND_S9 :
+      value = fields->f_s9;
+      break;
+    case ARC_OPERAND_S9X4 :
+      value = fields->f_s9x4;
+      break;
+    case ARC_OPERAND_SC_S9_ :
+      value = fields->f_s9x4;
+      break;
+    case ARC_OPERAND_SC_S9B :
+      value = fields->f_s9x1;
+      break;
+    case ARC_OPERAND_SC_S9W :
+      value = fields->f_s9x2;
+      break;
+    case ARC_OPERAND_SC_U5_ :
+      value = fields->f_u5x4;
+      break;
+    case ARC_OPERAND_SC_U5B :
+      value = fields->f_u5;
+      break;
+    case ARC_OPERAND_SC_U5W :
+      value = fields->f_u5x2;
+      break;
+    case ARC_OPERAND_TRAPNUM :
+      value = fields->f_trapnum;
+      break;
+    case ARC_OPERAND_U3 :
+      value = fields->f_u3;
+      break;
+    case ARC_OPERAND_U5 :
+      value = fields->f_u5;
+      break;
+    case ARC_OPERAND_U5X4 :
+      value = fields->f_u5x4;
+      break;
+    case ARC_OPERAND_U7 :
+      value = fields->f_u7;
+      break;
+    case ARC_OPERAND_U8 :
+      value = fields->f_u8;
+      break;
+    case ARC_OPERAND_U8X4 :
+      value = fields->f_u8x4;
+      break;
+    case ARC_OPERAND_UNCONDB :
+      value = 0;
+      break;
+    case ARC_OPERAND_UNCONDI :
+      value = 0;
+      break;
+    case ARC_OPERAND_UNCONDJ :
+      value = 0;
+      break;
+    case ARC_OPERAND_VBIT :
+      value = 0;
+      break;
+    case ARC_OPERAND_ZBIT :
+      value = 0;
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
+		       opindex);
+      abort ();
+  }
+
+  return value;
+}
+
+void arc_cgen_set_int_operand  (CGEN_CPU_DESC, int, CGEN_FIELDS *, int);
+void arc_cgen_set_vma_operand  (CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma);
+
+/* Stuffing values in cgen_fields is handled by a collection of functions.
+   They are distinguished by the type of the VALUE argument they accept.
+   TODO: floating point, inlining support, remove cases where argument type
+   not appropriate.  */
+
+void
+arc_cgen_set_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+			     int opindex,
+			     CGEN_FIELDS * fields,
+			     int value)
+{
+  switch (opindex)
+    {
+    case ARC_OPERAND_EXDI :
+      fields->f_F = value;
+      break;
+    case ARC_OPERAND_F :
+      fields->f_F = value;
+      break;
+    case ARC_OPERAND_F0 :
+      fields->f_F = value;
+      break;
+    case ARC_OPERAND_F1 :
+      fields->f_F = value;
+      break;
+    case ARC_OPERAND_F1F :
+      fields->f_F = value;
+      break;
+    case ARC_OPERAND_GP :
+      break;
+    case ARC_OPERAND_LDODI :
+      fields->f_LDODi = value;
+      break;
+    case ARC_OPERAND_LDRDI :
+      fields->f_LDRDi = value;
+      break;
+    case ARC_OPERAND_NE :
+      break;
+    case ARC_OPERAND_PCL :
+      break;
+    case ARC_OPERAND_QCONDB :
+      fields->f_cond_Q = value;
+      break;
+    case ARC_OPERAND_QCONDI :
+      fields->f_cond_Q = value;
+      break;
+    case ARC_OPERAND_QCONDJ :
+      fields->f_cond_Q = value;
+      break;
+    case ARC_OPERAND_R0 :
+      break;
+    case ARC_OPERAND_R31 :
+      break;
+    case ARC_OPERAND_RA :
+      fields->f_op_A = value;
+      break;
+    case ARC_OPERAND_RA_0 :
+      fields->f_op_A = value;
+      break;
+    case ARC_OPERAND_RB :
+      fields->f_op_B = value;
+      break;
+    case ARC_OPERAND_RB_0 :
+      fields->f_op_B = value;
+      break;
+    case ARC_OPERAND_RC :
+      fields->f_op_C = value;
+      break;
+    case ARC_OPERAND_RC_ILINK :
+      fields->f_op_Cj = value;
+      break;
+    case ARC_OPERAND_RC_NOILINK :
+      fields->f_op_Cj = value;
+      break;
+    case ARC_OPERAND_R_A :
+      fields->f_op__a = value;
+      break;
+    case ARC_OPERAND_R_B :
+      fields->f_op__b = value;
+      break;
+    case ARC_OPERAND_R_C :
+      fields->f_op__c = value;
+      break;
+    case ARC_OPERAND_RCC :
+      fields->f_brcond = value;
+      break;
+    case ARC_OPERAND_RCCS :
+      fields->f_brscond = value;
+      break;
+    case ARC_OPERAND_RH :
+      fields->f_op_h = value;
+      break;
+    case ARC_OPERAND_SP :
+      break;
+    case ARC_OPERAND_STODI :
+      fields->f_STODi = value;
+      break;
+    case ARC_OPERAND_U6 :
+      fields->f_u6 = value;
+      break;
+    case ARC_OPERAND_U6X2 :
+      fields->f_u6x2 = value;
+      break;
+    case ARC_OPERAND__AW :
+      break;
+    case ARC_OPERAND__L :
+      break;
+    case ARC_OPERAND__S :
+      break;
+    case ARC_OPERAND_CBIT :
+      break;
+    case ARC_OPERAND_DELAY_N :
+      fields->f_delay_N = value;
+      break;
+    case ARC_OPERAND_DUMMY_OP :
+      fields->f_dummy = value;
+      break;
+    case ARC_OPERAND_I2COND :
+      fields->f_cond_i2 = value;
+      break;
+    case ARC_OPERAND_I3COND :
+      fields->f_cond_i3 = value;
+      break;
+    case ARC_OPERAND_LABEL10 :
+      fields->f_rel10 = value;
+      break;
+    case ARC_OPERAND_LABEL13A :
+      fields->f_rel13bl = value;
+      break;
+    case ARC_OPERAND_LABEL21 :
+      fields->f_rel21 = value;
+      break;
+    case ARC_OPERAND_LABEL21A :
+      fields->f_rel21bl = value;
+      break;
+    case ARC_OPERAND_LABEL25 :
+      fields->f_rel25 = value;
+      break;
+    case ARC_OPERAND_LABEL25A :
+      fields->f_rel25bl = value;
+      break;
+    case ARC_OPERAND_LABEL7 :
+      fields->f_rel7 = value;
+      break;
+    case ARC_OPERAND_LABEL8 :
+      fields->f_rel8 = value;
+      break;
+    case ARC_OPERAND_LABEL9 :
+      fields->f_rel9 = value;
+      break;
+    case ARC_OPERAND_LBIT :
+      break;
+    case ARC_OPERAND_NBIT :
+      break;
+    case ARC_OPERAND_S12 :
+      fields->f_s12 = value;
+      break;
+    case ARC_OPERAND_S12X2 :
+      fields->f_s12x2 = value;
+      break;
+    case ARC_OPERAND_S1BIT :
+      break;
+    case ARC_OPERAND_S2BIT :
+      break;
+    case ARC_OPERAND_S9 :
+      fields->f_s9 = value;
+      break;
+    case ARC_OPERAND_S9X4 :
+      fields->f_s9x4 = value;
+      break;
+    case ARC_OPERAND_SC_S9_ :
+      fields->f_s9x4 = value;
+      break;
+    case ARC_OPERAND_SC_S9B :
+      fields->f_s9x1 = value;
+      break;
+    case ARC_OPERAND_SC_S9W :
+      fields->f_s9x2 = value;
+      break;
+    case ARC_OPERAND_SC_U5_ :
+      fields->f_u5x4 = value;
+      break;
+    case ARC_OPERAND_SC_U5B :
+      fields->f_u5 = value;
+      break;
+    case ARC_OPERAND_SC_U5W :
+      fields->f_u5x2 = value;
+      break;
+    case ARC_OPERAND_TRAPNUM :
+      fields->f_trapnum = value;
+      break;
+    case ARC_OPERAND_U3 :
+      fields->f_u3 = value;
+      break;
+    case ARC_OPERAND_U5 :
+      fields->f_u5 = value;
+      break;
+    case ARC_OPERAND_U5X4 :
+      fields->f_u5x4 = value;
+      break;
+    case ARC_OPERAND_U7 :
+      fields->f_u7 = value;
+      break;
+    case ARC_OPERAND_U8 :
+      fields->f_u8 = value;
+      break;
+    case ARC_OPERAND_U8X4 :
+      fields->f_u8x4 = value;
+      break;
+    case ARC_OPERAND_UNCONDB :
+      break;
+    case ARC_OPERAND_UNCONDI :
+      break;
+    case ARC_OPERAND_UNCONDJ :
+      break;
+    case ARC_OPERAND_VBIT :
+      break;
+    case ARC_OPERAND_ZBIT :
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
+		       opindex);
+      abort ();
+  }
+}
+
+void
+arc_cgen_set_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+			     int opindex,
+			     CGEN_FIELDS * fields,
+			     bfd_vma value)
+{
+  switch (opindex)
+    {
+    case ARC_OPERAND_EXDI :
+      fields->f_F = value;
+      break;
+    case ARC_OPERAND_F :
+      fields->f_F = value;
+      break;
+    case ARC_OPERAND_F0 :
+      fields->f_F = value;
+      break;
+    case ARC_OPERAND_F1 :
+      fields->f_F = value;
+      break;
+    case ARC_OPERAND_F1F :
+      fields->f_F = value;
+      break;
+    case ARC_OPERAND_GP :
+      break;
+    case ARC_OPERAND_LDODI :
+      fields->f_LDODi = value;
+      break;
+    case ARC_OPERAND_LDRDI :
+      fields->f_LDRDi = value;
+      break;
+    case ARC_OPERAND_NE :
+      break;
+    case ARC_OPERAND_PCL :
+      break;
+    case ARC_OPERAND_QCONDB :
+      fields->f_cond_Q = value;
+      break;
+    case ARC_OPERAND_QCONDI :
+      fields->f_cond_Q = value;
+      break;
+    case ARC_OPERAND_QCONDJ :
+      fields->f_cond_Q = value;
+      break;
+    case ARC_OPERAND_R0 :
+      break;
+    case ARC_OPERAND_R31 :
+      break;
+    case ARC_OPERAND_RA :
+      fields->f_op_A = value;
+      break;
+    case ARC_OPERAND_RA_0 :
+      fields->f_op_A = value;
+      break;
+    case ARC_OPERAND_RB :
+      fields->f_op_B = value;
+      break;
+    case ARC_OPERAND_RB_0 :
+      fields->f_op_B = value;
+      break;
+    case ARC_OPERAND_RC :
+      fields->f_op_C = value;
+      break;
+    case ARC_OPERAND_RC_ILINK :
+      fields->f_op_Cj = value;
+      break;
+    case ARC_OPERAND_RC_NOILINK :
+      fields->f_op_Cj = value;
+      break;
+    case ARC_OPERAND_R_A :
+      fields->f_op__a = value;
+      break;
+    case ARC_OPERAND_R_B :
+      fields->f_op__b = value;
+      break;
+    case ARC_OPERAND_R_C :
+      fields->f_op__c = value;
+      break;
+    case ARC_OPERAND_RCC :
+      fields->f_brcond = value;
+      break;
+    case ARC_OPERAND_RCCS :
+      fields->f_brscond = value;
+      break;
+    case ARC_OPERAND_RH :
+      fields->f_op_h = value;
+      break;
+    case ARC_OPERAND_SP :
+      break;
+    case ARC_OPERAND_STODI :
+      fields->f_STODi = value;
+      break;
+    case ARC_OPERAND_U6 :
+      fields->f_u6 = value;
+      break;
+    case ARC_OPERAND_U6X2 :
+      fields->f_u6x2 = value;
+      break;
+    case ARC_OPERAND__AW :
+      break;
+    case ARC_OPERAND__L :
+      break;
+    case ARC_OPERAND__S :
+      break;
+    case ARC_OPERAND_CBIT :
+      break;
+    case ARC_OPERAND_DELAY_N :
+      fields->f_delay_N = value;
+      break;
+    case ARC_OPERAND_DUMMY_OP :
+      fields->f_dummy = value;
+      break;
+    case ARC_OPERAND_I2COND :
+      fields->f_cond_i2 = value;
+      break;
+    case ARC_OPERAND_I3COND :
+      fields->f_cond_i3 = value;
+      break;
+    case ARC_OPERAND_LABEL10 :
+      fields->f_rel10 = value;
+      break;
+    case ARC_OPERAND_LABEL13A :
+      fields->f_rel13bl = value;
+      break;
+    case ARC_OPERAND_LABEL21 :
+      fields->f_rel21 = value;
+      break;
+    case ARC_OPERAND_LABEL21A :
+      fields->f_rel21bl = value;
+      break;
+    case ARC_OPERAND_LABEL25 :
+      fields->f_rel25 = value;
+      break;
+    case ARC_OPERAND_LABEL25A :
+      fields->f_rel25bl = value;
+      break;
+    case ARC_OPERAND_LABEL7 :
+      fields->f_rel7 = value;
+      break;
+    case ARC_OPERAND_LABEL8 :
+      fields->f_rel8 = value;
+      break;
+    case ARC_OPERAND_LABEL9 :
+      fields->f_rel9 = value;
+      break;
+    case ARC_OPERAND_LBIT :
+      break;
+    case ARC_OPERAND_NBIT :
+      break;
+    case ARC_OPERAND_S12 :
+      fields->f_s12 = value;
+      break;
+    case ARC_OPERAND_S12X2 :
+      fields->f_s12x2 = value;
+      break;
+    case ARC_OPERAND_S1BIT :
+      break;
+    case ARC_OPERAND_S2BIT :
+      break;
+    case ARC_OPERAND_S9 :
+      fields->f_s9 = value;
+      break;
+    case ARC_OPERAND_S9X4 :
+      fields->f_s9x4 = value;
+      break;
+    case ARC_OPERAND_SC_S9_ :
+      fields->f_s9x4 = value;
+      break;
+    case ARC_OPERAND_SC_S9B :
+      fields->f_s9x1 = value;
+      break;
+    case ARC_OPERAND_SC_S9W :
+      fields->f_s9x2 = value;
+      break;
+    case ARC_OPERAND_SC_U5_ :
+      fields->f_u5x4 = value;
+      break;
+    case ARC_OPERAND_SC_U5B :
+      fields->f_u5 = value;
+      break;
+    case ARC_OPERAND_SC_U5W :
+      fields->f_u5x2 = value;
+      break;
+    case ARC_OPERAND_TRAPNUM :
+      fields->f_trapnum = value;
+      break;
+    case ARC_OPERAND_U3 :
+      fields->f_u3 = value;
+      break;
+    case ARC_OPERAND_U5 :
+      fields->f_u5 = value;
+      break;
+    case ARC_OPERAND_U5X4 :
+      fields->f_u5x4 = value;
+      break;
+    case ARC_OPERAND_U7 :
+      fields->f_u7 = value;
+      break;
+    case ARC_OPERAND_U8 :
+      fields->f_u8 = value;
+      break;
+    case ARC_OPERAND_U8X4 :
+      fields->f_u8x4 = value;
+      break;
+    case ARC_OPERAND_UNCONDB :
+      break;
+    case ARC_OPERAND_UNCONDI :
+      break;
+    case ARC_OPERAND_UNCONDJ :
+      break;
+    case ARC_OPERAND_VBIT :
+      break;
+    case ARC_OPERAND_ZBIT :
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"),
+		       opindex);
+      abort ();
+  }
+}
+
+/* Function to call before using the instruction builder tables.  */
+
+void
+arc_cgen_init_ibld_table (CGEN_CPU_DESC cd)
+{
+  cd->insert_handlers = & arc_cgen_insert_handlers[0];
+  cd->extract_handlers = & arc_cgen_extract_handlers[0];
+
+  cd->insert_operand = arc_cgen_insert_operand;
+  cd->extract_operand = arc_cgen_extract_operand;
+
+  cd->get_int_operand = arc_cgen_get_int_operand;
+  cd->set_int_operand = arc_cgen_set_int_operand;
+  cd->get_vma_operand = arc_cgen_get_vma_operand;
+  cd->set_vma_operand = arc_cgen_set_vma_operand;
+}
diff --git a/opcodes/arc-opc.h b/opcodes/arc-opc.h
new file mode 100644
index 0000000..0a020b2
--- /dev/null
+++ b/opcodes/arc-opc.h
@@ -0,0 +1,313 @@
+/* Instruction opcode header for arc.
+
+THIS FILE IS MACHINE GENERATED WITH CGEN.
+
+Copyright 1996-2007 Free Software Foundation, Inc.
+
+This file is part of the GNU Binutils and/or GDB, the GNU debugger.
+
+   This file is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   It is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or FITNESS FOR A PARTICULAR PURPOSE.  See the 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.,
+   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
+
+*/
+
+#ifndef ARC_OPC_H
+#define ARC_OPC_H
+
+/* -- opc.h */
+
+#undef  CGEN_DIS_HASH_SIZE
+#define CGEN_DIS_HASH_SIZE 1024
+#undef  CGEN_DIS_HASH
+#define CGEN_DIS_HASH(buffer, value, big_p) \
+  arc_cgen_dis_hash (buffer, big_p)
+extern unsigned int arc_cgen_dis_hash (const char *, int);
+/* Override CGEN_INSN_BITSIZE for sim/common/cgen-trace.c .
+   insn extraction for simulation is fine with 32 bits, since we fetch long
+   immediates as part of the semantics if required, but for disassembly
+   we must make sure we read all the bits while we have the information how
+   to read them.  */
+#define CGEN_INSN_DISASM_BITSIZE(insn) 64
+extern char limm_str[];
+
+/* cgen can't generate correct decoders for variable-length insns,
+   so we have it generate a decoder that assumes all insns are 32 bit.
+   And even if the decoder generator bug were fixed, having the decoder
+   understand long immediates would be messy.
+   The simulator calculates instruction sizes as part of the semantics.
+   For disassembly, we redefine CGEN_EXTRACT_FN so that we can correct
+   the calculated instruction length.  */
+#undef CGEN_EXTRACT_FN
+#define CGEN_EXTRACT_FN(cd, insn) ARC_CGEN_EXTRACT_FN
+extern int arc_insn_length (unsigned long insn_value, const CGEN_INSN *insn,
+			   CGEN_EXTRACT_INFO *info, bfd_vma pc);
+static inline int
+ARC_CGEN_EXTRACT_FN (CGEN_CPU_DESC cd, const CGEN_INSN *insn,
+		     CGEN_EXTRACT_INFO *info, CGEN_INSN_INT insn_value,
+		     CGEN_FIELDS *fields, bfd_vma pc)
+{
+  static int initialized = 0;
+  /* ??? There is no suitable hook for one-time initialization.  */
+  if (!initialized)
+    {
+      static CGEN_KEYWORD_ENTRY arc_cgen_opval_limm_entry0 =
+	{ limm_str, 62, {0, {{{0, 0}}}}, 0, 0 };
+      static CGEN_KEYWORD_ENTRY arc_cgen_opval_limm_entry1 =
+	{ limm_str, 62, {0, {{{0, 0}}}}, 0, 0 };
+
+      cgen_keyword_add (&arc_cgen_opval_cr_names, &arc_cgen_opval_limm_entry0);
+      cgen_keyword_add (&arc_cgen_opval_h_noilink, &arc_cgen_opval_limm_entry1);
+      initialized = 1;
+    }
+  /* ??? sim/common/cgen-trace.c:sim_cgen_disassemble_insn uses its own
+     home-brewn instruction target-to-host conversion, which gets the
+     endianness wrong for ARC.  */
+  if (cd->endian == CGEN_ENDIAN_LITTLE)
+    insn_value = ((insn_value >> 16) & 0xffff) | (insn_value << 16);
+
+  /* First, do the normal extract handler call, but ignore its value.  */
+  ((cd)->extract_handlers[(insn)->opcode->handlers.extract]
+    (cd, insn, info, insn_value, fields, pc));
+  /* Now calculate the actual insn length, and extract any long immediate
+     if present.  */
+  return arc_insn_length (insn_value, insn, info, pc);
+}
+
+/* -- */
+/* Enum declaration for arc instruction types.  */
+typedef enum cgen_insn_type {
+  ARC_INSN_INVALID, ARC_INSN_B_S, ARC_INSN_BCC_S, ARC_INSN_BRCC_S
+ , ARC_INSN_BCC_L, ARC_INSN_BCC_L_D, ARC_INSN_B_L, ARC_INSN_B_L_D
+ , ARC_INSN_BRCC_RC, ARC_INSN_BRCC_RC_D, ARC_INSN_BRCC_U6, ARC_INSN_BRCC_U6_D
+ , ARC_INSN_BL_S, ARC_INSN_BLCC, ARC_INSN_BLCC_D, ARC_INSN_BL
+ , ARC_INSN_BL_D, ARC_INSN_LD_ABS, ARC_INSN_LD__AW_ABS, ARC_INSN_LD_AB_ABS
+ , ARC_INSN_LD_AS_ABS, ARC_INSN_LD_ABC, ARC_INSN_LD__AW_ABC, ARC_INSN_LD_AB_ABC
+ , ARC_INSN_LD_AS_ABC, ARC_INSN_LD_S_ABC, ARC_INSN_LD_S_ABU, ARC_INSN_LD_S_ABSP
+ , ARC_INSN_LD_S_GPREL, ARC_INSN_LD_S_PCREL, ARC_INSN_LDB_ABS, ARC_INSN_LDB__AW_ABS
+ , ARC_INSN_LDB_AB_ABS, ARC_INSN_LDB_AS_ABS, ARC_INSN_LDB_ABC, ARC_INSN_LDB__AW_ABC
+ , ARC_INSN_LDB_AB_ABC, ARC_INSN_LDB_AS_ABC, ARC_INSN_LDB_S_ABC, ARC_INSN_LDB_S_ABU
+ , ARC_INSN_LDB_S_ABSP, ARC_INSN_LDB_S_GPREL, ARC_INSN_LDB_X_ABS, ARC_INSN_LDB__AW_X_ABS
+ , ARC_INSN_LDB_AB_X_ABS, ARC_INSN_LDB_AS_X_ABS, ARC_INSN_LDB_X_ABC, ARC_INSN_LDB__AW_X_ABC
+ , ARC_INSN_LDB_AB_X_ABC, ARC_INSN_LDB_AS_X_ABC, ARC_INSN_LDW_ABS, ARC_INSN_LDW__AW_ABS
+ , ARC_INSN_LDW_AB_ABS, ARC_INSN_LDW_AS_ABS, ARC_INSN_LDW_ABC, ARC_INSN_LDW__AW_ABC
+ , ARC_INSN_LDW_AB_ABC, ARC_INSN_LDW_AS_ABC, ARC_INSN_LDW_S_ABC, ARC_INSN_LDW_S_ABU
+ , ARC_INSN_LDW_S_GPREL, ARC_INSN_LDW_X_ABS, ARC_INSN_LDW__AW_X_ABS, ARC_INSN_LDW_AB_X_ABS
+ , ARC_INSN_LDW_AS_X_ABS, ARC_INSN_LDW_X_ABC, ARC_INSN_LDW__AW_X_ABC, ARC_INSN_LDW_AB_X_ABC
+ , ARC_INSN_LDW_AS_X_ABC, ARC_INSN_LDW_S_X_ABU, ARC_INSN_ST_ABS, ARC_INSN_ST__AW_ABS
+ , ARC_INSN_ST_AB_ABS, ARC_INSN_ST_AS_ABS, ARC_INSN_ST_S_ABU, ARC_INSN_ST_S_ABSP
+ , ARC_INSN_STB_ABS, ARC_INSN_STB__AW_ABS, ARC_INSN_STB_AB_ABS, ARC_INSN_STB_AS_ABS
+ , ARC_INSN_STB_S_ABU, ARC_INSN_STB_S_ABSP, ARC_INSN_STW_ABS, ARC_INSN_STW__AW_ABS
+ , ARC_INSN_STW_AB_ABS, ARC_INSN_STW_AS_ABS, ARC_INSN_STW_S_ABU, ARC_INSN_ADD_L_S12__RA_
+ , ARC_INSN_ADD_CCU6__RA_, ARC_INSN_ADD_L_U6__RA_, ARC_INSN_ADD_L_R_R__RA__RC, ARC_INSN_ADD_CC__RA__RC
+ , ARC_INSN_ADD_S_ABC, ARC_INSN_ADD_S_CBU3, ARC_INSN_ADD_S_MCAH, ARC_INSN_ADD_S_ABSP
+ , ARC_INSN_ADD_S_ASSPSP, ARC_INSN_ADD_S_GP, ARC_INSN_ADD_S_R_U7, ARC_INSN_ADC_L_S12__RA_
+ , ARC_INSN_ADC_CCU6__RA_, ARC_INSN_ADC_L_U6__RA_, ARC_INSN_ADC_L_R_R__RA__RC, ARC_INSN_ADC_CC__RA__RC
+ , ARC_INSN_SUB_L_S12__RA_, ARC_INSN_SUB_CCU6__RA_, ARC_INSN_SUB_L_U6__RA_, ARC_INSN_SUB_L_R_R__RA__RC
+ , ARC_INSN_SUB_CC__RA__RC, ARC_INSN_SUB_S_CBU3, ARC_INSN_I16_GO_SUB_S_GO, ARC_INSN_SUB_S_GO_SUB_NE
+ , ARC_INSN_SUB_S_SSB, ARC_INSN_SUB_S_ASSPSP, ARC_INSN_SBC_L_S12__RA_, ARC_INSN_SBC_CCU6__RA_
+ , ARC_INSN_SBC_L_U6__RA_, ARC_INSN_SBC_L_R_R__RA__RC, ARC_INSN_SBC_CC__RA__RC, ARC_INSN_AND_L_S12__RA_
+ , ARC_INSN_AND_CCU6__RA_, ARC_INSN_AND_L_U6__RA_, ARC_INSN_AND_L_R_R__RA__RC, ARC_INSN_AND_CC__RA__RC
+ , ARC_INSN_I16_GO_AND_S_GO, ARC_INSN_OR_L_S12__RA_, ARC_INSN_OR_CCU6__RA_, ARC_INSN_OR_L_U6__RA_
+ , ARC_INSN_OR_L_R_R__RA__RC, ARC_INSN_OR_CC__RA__RC, ARC_INSN_I16_GO_OR_S_GO, ARC_INSN_BIC_L_S12__RA_
+ , ARC_INSN_BIC_CCU6__RA_, ARC_INSN_BIC_L_U6__RA_, ARC_INSN_BIC_L_R_R__RA__RC, ARC_INSN_BIC_CC__RA__RC
+ , ARC_INSN_I16_GO_BIC_S_GO, ARC_INSN_XOR_L_S12__RA_, ARC_INSN_XOR_CCU6__RA_, ARC_INSN_XOR_L_U6__RA_
+ , ARC_INSN_XOR_L_R_R__RA__RC, ARC_INSN_XOR_CC__RA__RC, ARC_INSN_I16_GO_XOR_S_GO, ARC_INSN_MAX_L_S12__RA_
+ , ARC_INSN_MAX_CCU6__RA_, ARC_INSN_MAX_L_U6__RA_, ARC_INSN_MAX_L_R_R__RA__RC, ARC_INSN_MAX_CC__RA__RC
+ , ARC_INSN_MIN_L_S12__RA_, ARC_INSN_MIN_CCU6__RA_, ARC_INSN_MIN_L_U6__RA_, ARC_INSN_MIN_L_R_R__RA__RC
+ , ARC_INSN_MIN_CC__RA__RC, ARC_INSN_MOV_L_S12_, ARC_INSN_MOV_CCU6_, ARC_INSN_MOV_L_U6_
+ , ARC_INSN_MOV_L_R_R__RC, ARC_INSN_MOV_CC__RC, ARC_INSN_MOV_S_MCAH, ARC_INSN_MOV_S_MCAHB
+ , ARC_INSN_MOV_S_R_U7, ARC_INSN_TST_L_S12_, ARC_INSN_TST_CCU6_, ARC_INSN_TST_L_U6_
+ , ARC_INSN_TST_L_R_R__RC, ARC_INSN_TST_CC__RC, ARC_INSN_TST_S_GO, ARC_INSN_CMP_L_S12_
+ , ARC_INSN_CMP_CCU6_, ARC_INSN_CMP_L_U6_, ARC_INSN_CMP_L_R_R__RC, ARC_INSN_CMP_CC__RC
+ , ARC_INSN_CMP_S_MCAH, ARC_INSN_CMP_S_R_U7, ARC_INSN_RCMP_L_S12_, ARC_INSN_RCMP_CCU6_
+ , ARC_INSN_RCMP_L_U6_, ARC_INSN_RCMP_L_R_R__RC, ARC_INSN_RCMP_CC__RC, ARC_INSN_RSUB_L_S12__RA_
+ , ARC_INSN_RSUB_CCU6__RA_, ARC_INSN_RSUB_L_U6__RA_, ARC_INSN_RSUB_L_R_R__RA__RC, ARC_INSN_RSUB_CC__RA__RC
+ , ARC_INSN_BSET_L_S12__RA_, ARC_INSN_BSET_CCU6__RA_, ARC_INSN_BSET_L_U6__RA_, ARC_INSN_BSET_L_R_R__RA__RC
+ , ARC_INSN_BSET_CC__RA__RC, ARC_INSN_BSET_S_SSB, ARC_INSN_BCLR_L_S12__RA_, ARC_INSN_BCLR_CCU6__RA_
+ , ARC_INSN_BCLR_L_U6__RA_, ARC_INSN_BCLR_L_R_R__RA__RC, ARC_INSN_BCLR_CC__RA__RC, ARC_INSN_BCLR_S_SSB
+ , ARC_INSN_BTST_L_S12_, ARC_INSN_BTST_CCU6_, ARC_INSN_BTST_L_U6_, ARC_INSN_BTST_L_R_R__RC
+ , ARC_INSN_BTST_CC__RC, ARC_INSN_BTST_S_SSB, ARC_INSN_BXOR_L_S12__RA_, ARC_INSN_BXOR_CCU6__RA_
+ , ARC_INSN_BXOR_L_U6__RA_, ARC_INSN_BXOR_L_R_R__RA__RC, ARC_INSN_BXOR_CC__RA__RC, ARC_INSN_BMSK_L_S12__RA_
+ , ARC_INSN_BMSK_CCU6__RA_, ARC_INSN_BMSK_L_U6__RA_, ARC_INSN_BMSK_L_R_R__RA__RC, ARC_INSN_BMSK_CC__RA__RC
+ , ARC_INSN_BMSK_S_SSB, ARC_INSN_ADD1_L_S12__RA_, ARC_INSN_ADD1_CCU6__RA_, ARC_INSN_ADD1_L_U6__RA_
+ , ARC_INSN_ADD1_L_R_R__RA__RC, ARC_INSN_ADD1_CC__RA__RC, ARC_INSN_I16_GO_ADD1_S_GO, ARC_INSN_ADD2_L_S12__RA_
+ , ARC_INSN_ADD2_CCU6__RA_, ARC_INSN_ADD2_L_U6__RA_, ARC_INSN_ADD2_L_R_R__RA__RC, ARC_INSN_ADD2_CC__RA__RC
+ , ARC_INSN_I16_GO_ADD2_S_GO, ARC_INSN_ADD3_L_S12__RA_, ARC_INSN_ADD3_CCU6__RA_, ARC_INSN_ADD3_L_U6__RA_
+ , ARC_INSN_ADD3_L_R_R__RA__RC, ARC_INSN_ADD3_CC__RA__RC, ARC_INSN_I16_GO_ADD3_S_GO, ARC_INSN_SUB1_L_S12__RA_
+ , ARC_INSN_SUB1_CCU6__RA_, ARC_INSN_SUB1_L_U6__RA_, ARC_INSN_SUB1_L_R_R__RA__RC, ARC_INSN_SUB1_CC__RA__RC
+ , ARC_INSN_SUB2_L_S12__RA_, ARC_INSN_SUB2_CCU6__RA_, ARC_INSN_SUB2_L_U6__RA_, ARC_INSN_SUB2_L_R_R__RA__RC
+ , ARC_INSN_SUB2_CC__RA__RC, ARC_INSN_SUB3_L_S12__RA_, ARC_INSN_SUB3_CCU6__RA_, ARC_INSN_SUB3_L_U6__RA_
+ , ARC_INSN_SUB3_L_R_R__RA__RC, ARC_INSN_SUB3_CC__RA__RC, ARC_INSN_MPY_L_S12__RA_, ARC_INSN_MPY_CCU6__RA_
+ , ARC_INSN_MPY_L_U6__RA_, ARC_INSN_MPY_L_R_R__RA__RC, ARC_INSN_MPY_CC__RA__RC, ARC_INSN_MPYH_L_S12__RA_
+ , ARC_INSN_MPYH_CCU6__RA_, ARC_INSN_MPYH_L_U6__RA_, ARC_INSN_MPYH_L_R_R__RA__RC, ARC_INSN_MPYH_CC__RA__RC
+ , ARC_INSN_MPYHU_L_S12__RA_, ARC_INSN_MPYHU_CCU6__RA_, ARC_INSN_MPYHU_L_U6__RA_, ARC_INSN_MPYHU_L_R_R__RA__RC
+ , ARC_INSN_MPYHU_CC__RA__RC, ARC_INSN_MPYU_L_S12__RA_, ARC_INSN_MPYU_CCU6__RA_, ARC_INSN_MPYU_L_U6__RA_
+ , ARC_INSN_MPYU_L_R_R__RA__RC, ARC_INSN_MPYU_CC__RA__RC, ARC_INSN_J_L_R_R___RC_NOILINK_, ARC_INSN_J_CC___RC_NOILINK_
+ , ARC_INSN_J_L_R_R___RC_ILINK_, ARC_INSN_J_CC___RC_ILINK_, ARC_INSN_J_L_S12_, ARC_INSN_J_CCU6_
+ , ARC_INSN_J_L_U6_, ARC_INSN_J_S, ARC_INSN_J_S__S, ARC_INSN_J_SEQ__S
+ , ARC_INSN_J_SNE__S, ARC_INSN_J_L_S12_D_, ARC_INSN_J_CCU6_D_, ARC_INSN_J_L_U6_D_
+ , ARC_INSN_J_L_R_R_D___RC_, ARC_INSN_J_CC_D___RC_, ARC_INSN_J_S_D, ARC_INSN_J_S__S_D
+ , ARC_INSN_JL_L_S12_, ARC_INSN_JL_CCU6_, ARC_INSN_JL_L_U6_, ARC_INSN_JL_S
+ , ARC_INSN_JL_L_R_R___RC_NOILINK_, ARC_INSN_JL_CC___RC_NOILINK_, ARC_INSN_JL_L_S12_D_, ARC_INSN_JL_CCU6_D_
+ , ARC_INSN_JL_L_U6_D_, ARC_INSN_JL_L_R_R_D___RC_, ARC_INSN_JL_CC_D___RC_, ARC_INSN_JL_S_D
+ , ARC_INSN_LP_L_S12_, ARC_INSN_LPCC_CCU6, ARC_INSN_FLAG_L_S12_, ARC_INSN_FLAG_CCU6_
+ , ARC_INSN_FLAG_L_U6_, ARC_INSN_FLAG_L_R_R__RC, ARC_INSN_FLAG_CC__RC, ARC_INSN_LR_L_R_R___RC_
+ , ARC_INSN_LR_L_S12_, ARC_INSN_LR_L_U6_, ARC_INSN_SR_L_R_R___RC_, ARC_INSN_SR_L_S12_
+ , ARC_INSN_SR_L_U6_, ARC_INSN_ASL_L_R_R__RC, ARC_INSN_ASL_L_U6_, ARC_INSN_I16_GO_ASL_S_GO
+ , ARC_INSN_ASR_L_R_R__RC, ARC_INSN_ASR_L_U6_, ARC_INSN_I16_GO_ASR_S_GO, ARC_INSN_LSR_L_R_R__RC
+ , ARC_INSN_LSR_L_U6_, ARC_INSN_I16_GO_LSR_S_GO, ARC_INSN_ROR_L_R_R__RC, ARC_INSN_ROR_L_U6_
+ , ARC_INSN_RRC_L_R_R__RC, ARC_INSN_RRC_L_U6_, ARC_INSN_SEXB_L_R_R__RC, ARC_INSN_SEXB_L_U6_
+ , ARC_INSN_I16_GO_SEXB_S_GO, ARC_INSN_SEXW_L_R_R__RC, ARC_INSN_SEXW_L_U6_, ARC_INSN_I16_GO_SEXW_S_GO
+ , ARC_INSN_EXTB_L_R_R__RC, ARC_INSN_EXTB_L_U6_, ARC_INSN_I16_GO_EXTB_S_GO, ARC_INSN_EXTW_L_R_R__RC
+ , ARC_INSN_EXTW_L_U6_, ARC_INSN_I16_GO_EXTW_S_GO, ARC_INSN_ABS_L_R_R__RC, ARC_INSN_ABS_L_U6_
+ , ARC_INSN_I16_GO_ABS_S_GO, ARC_INSN_NOT_L_R_R__RC, ARC_INSN_NOT_L_U6_, ARC_INSN_I16_GO_NOT_S_GO
+ , ARC_INSN_RLC_L_R_R__RC, ARC_INSN_RLC_L_U6_, ARC_INSN_EX_L_R_R__RC, ARC_INSN_EX_L_U6_
+ , ARC_INSN_I16_GO_NEG_S_GO, ARC_INSN_SWI, ARC_INSN_TRAP_S, ARC_INSN_BRK
+ , ARC_INSN_BRK_S, ARC_INSN_ASL_L_S12__RA_, ARC_INSN_ASL_CCU6__RA_, ARC_INSN_ASL_L_U6__RA_
+ , ARC_INSN_ASL_L_R_R__RA__RC, ARC_INSN_ASL_CC__RA__RC, ARC_INSN_ASL_S_CBU3, ARC_INSN_ASL_S_SSB
+ , ARC_INSN_I16_GO_ASLM_S_GO, ARC_INSN_LSR_L_S12__RA_, ARC_INSN_LSR_CCU6__RA_, ARC_INSN_LSR_L_U6__RA_
+ , ARC_INSN_LSR_L_R_R__RA__RC, ARC_INSN_LSR_CC__RA__RC, ARC_INSN_LSR_S_SSB, ARC_INSN_I16_GO_LSRM_S_GO
+ , ARC_INSN_ASR_L_S12__RA_, ARC_INSN_ASR_CCU6__RA_, ARC_INSN_ASR_L_U6__RA_, ARC_INSN_ASR_L_R_R__RA__RC
+ , ARC_INSN_ASR_CC__RA__RC, ARC_INSN_ASR_S_CBU3, ARC_INSN_ASR_S_SSB, ARC_INSN_I16_GO_ASRM_S_GO
+ , ARC_INSN_ROR_L_S12__RA_, ARC_INSN_ROR_CCU6__RA_, ARC_INSN_ROR_L_U6__RA_, ARC_INSN_ROR_L_R_R__RA__RC
+ , ARC_INSN_ROR_CC__RA__RC, ARC_INSN_MUL64_L_S12_, ARC_INSN_MUL64_CCU6_, ARC_INSN_MUL64_L_U6_
+ , ARC_INSN_MUL64_L_R_R__RC, ARC_INSN_MUL64_CC__RC, ARC_INSN_MUL64_S_GO, ARC_INSN_MULU64_L_S12_
+ , ARC_INSN_MULU64_CCU6_, ARC_INSN_MULU64_L_U6_, ARC_INSN_MULU64_L_R_R__RC, ARC_INSN_MULU64_CC__RC
+ , ARC_INSN_ADDS_L_S12__RA_, ARC_INSN_ADDS_CCU6__RA_, ARC_INSN_ADDS_L_U6__RA_, ARC_INSN_ADDS_L_R_R__RA__RC
+ , ARC_INSN_ADDS_CC__RA__RC, ARC_INSN_SUBS_L_S12__RA_, ARC_INSN_SUBS_CCU6__RA_, ARC_INSN_SUBS_L_U6__RA_
+ , ARC_INSN_SUBS_L_R_R__RA__RC, ARC_INSN_SUBS_CC__RA__RC, ARC_INSN_DIVAW_L_S12__RA_, ARC_INSN_DIVAW_CCU6__RA_
+ , ARC_INSN_DIVAW_L_U6__RA_, ARC_INSN_DIVAW_L_R_R__RA__RC, ARC_INSN_DIVAW_CC__RA__RC, ARC_INSN_ASLS_L_S12__RA_
+ , ARC_INSN_ASLS_CCU6__RA_, ARC_INSN_ASLS_L_U6__RA_, ARC_INSN_ASLS_L_R_R__RA__RC, ARC_INSN_ASLS_CC__RA__RC
+ , ARC_INSN_ASRS_L_S12__RA_, ARC_INSN_ASRS_CCU6__RA_, ARC_INSN_ASRS_L_U6__RA_, ARC_INSN_ASRS_L_R_R__RA__RC
+ , ARC_INSN_ASRS_CC__RA__RC, ARC_INSN_ADDSDW_L_S12__RA_, ARC_INSN_ADDSDW_CCU6__RA_, ARC_INSN_ADDSDW_L_U6__RA_
+ , ARC_INSN_ADDSDW_L_R_R__RA__RC, ARC_INSN_ADDSDW_CC__RA__RC, ARC_INSN_SUBSDW_L_S12__RA_, ARC_INSN_SUBSDW_CCU6__RA_
+ , ARC_INSN_SUBSDW_L_U6__RA_, ARC_INSN_SUBSDW_L_R_R__RA__RC, ARC_INSN_SUBSDW_CC__RA__RC, ARC_INSN_SWAP_L_R_R__RC
+ , ARC_INSN_SWAP_L_U6_, ARC_INSN_NORM_L_R_R__RC, ARC_INSN_NORM_L_U6_, ARC_INSN_RND16_L_R_R__RC
+ , ARC_INSN_RND16_L_U6_, ARC_INSN_ABSSW_L_R_R__RC, ARC_INSN_ABSSW_L_U6_, ARC_INSN_ABSS_L_R_R__RC
+ , ARC_INSN_ABSS_L_U6_, ARC_INSN_NEGSW_L_R_R__RC, ARC_INSN_NEGSW_L_U6_, ARC_INSN_NEGS_L_R_R__RC
+ , ARC_INSN_NEGS_L_U6_, ARC_INSN_NORMW_L_R_R__RC, ARC_INSN_NORMW_L_U6_, ARC_INSN_NOP_S
+ , ARC_INSN_UNIMP_S, ARC_INSN_POP_S_B, ARC_INSN_POP_S_BLINK, ARC_INSN_PUSH_S_B
+ , ARC_INSN_PUSH_S_BLINK, ARC_INSN_MULLW_L_S12__RA_, ARC_INSN_MULLW_CCU6__RA_, ARC_INSN_MULLW_L_U6__RA_
+ , ARC_INSN_MULLW_L_R_R__RA__RC, ARC_INSN_MULLW_CC__RA__RC, ARC_INSN_MACLW_L_S12__RA_, ARC_INSN_MACLW_CCU6__RA_
+ , ARC_INSN_MACLW_L_U6__RA_, ARC_INSN_MACLW_L_R_R__RA__RC, ARC_INSN_MACLW_CC__RA__RC, ARC_INSN_MACHLW_L_S12__RA_
+ , ARC_INSN_MACHLW_CCU6__RA_, ARC_INSN_MACHLW_L_U6__RA_, ARC_INSN_MACHLW_L_R_R__RA__RC, ARC_INSN_MACHLW_CC__RA__RC
+ , ARC_INSN_MULULW_L_S12__RA_, ARC_INSN_MULULW_CCU6__RA_, ARC_INSN_MULULW_L_U6__RA_, ARC_INSN_MULULW_L_R_R__RA__RC
+ , ARC_INSN_MULULW_CC__RA__RC, ARC_INSN_MACHULW_L_S12__RA_, ARC_INSN_MACHULW_CCU6__RA_, ARC_INSN_MACHULW_L_U6__RA_
+ , ARC_INSN_MACHULW_L_R_R__RA__RC, ARC_INSN_MACHULW_CC__RA__RC, ARC_INSN_CURRENT_LOOP_END, ARC_INSN_CURRENT_LOOP_END_AFTER_BRANCH
+ , ARC_INSN_ARC600_CURRENT_LOOP_END_AFTER_BRANCH
+} CGEN_INSN_TYPE;
+
+/* Index of `invalid' insn place holder.  */
+#define CGEN_INSN_INVALID ARC_INSN_INVALID
+
+/* Total number of insns in table.  */
+#define MAX_INSNS ((int) ARC_INSN_ARC600_CURRENT_LOOP_END_AFTER_BRANCH + 1)
+
+/* This struct records data prior to insertion or after extraction.  */
+struct cgen_fields
+{
+  int length;
+  long f_nil;
+  long f_anyof;
+  long f_cond_Q;
+  long f_cond_i2;
+  long f_cond_i3;
+  long f_brcond;
+  long f_op__a;
+  long f_op__b;
+  long f_op__c;
+  long f_B_5_3;
+  long f_op_B;
+  long f_op_C;
+  long f_op_Cj;
+  long f_h_2_0;
+  long f_h_5_3;
+  long f_op_h;
+  long f_u6;
+  long f_u6x2;
+  long f_delay_N;
+  long f_res27;
+  long f_F;
+  long f_cbranch_imm;
+  long f_op_A;
+  long f_s12h;
+  long f_s12;
+  long f_s12x2;
+  long f_rel10;
+  long f_rel7;
+  long f_rel8;
+  long f_rel13bl;
+  long f_d21l;
+  long f_d21bl;
+  long f_d21h;
+  long f_d25m;
+  long f_d25h;
+  long f_rel21;
+  long f_rel21bl;
+  long f_rel25;
+  long f_rel25bl;
+  long f_d9l;
+  long f_d9h;
+  long f_rel9;
+  long f_u3;
+  long f_u5;
+  long f_u7;
+  long f_u8;
+  long f_s9;
+  long f_u5x2;
+  long f_u5x4;
+  long f_u8x4;
+  long f_s9x1;
+  long f_s9x2;
+  long f_s9x4;
+  long f_dummy;
+  long f_opm;
+  long f_go_type;
+  long f_go_cc_type;
+  long f_go_op;
+  long f_i16_43;
+  long f_i16_go;
+  long f_i16_gp_type;
+  long f_i16addcmpu7_type;
+  long f_buf;
+  long f_br;
+  long f_bluf;
+  long f_brscond;
+  long f_ldozzx;
+  long f_ldr6zzx;
+  long f_stozzr;
+  long f_ldoaa;
+  long f_ldraa;
+  long f_stoaa;
+  long f_LDODi;
+  long f_LDRDi;
+  long f_STODi;
+  long f_trapnum;
+};
+
+#define CGEN_INIT_PARSE(od) \
+{\
+}
+#define CGEN_INIT_INSERT(od) \
+{\
+}
+#define CGEN_INIT_EXTRACT(od) \
+{\
+}
+#define CGEN_INIT_PRINT(od) \
+{\
+}
+
+
+#endif /* ARC_OPC_H */
diff --git a/opcodes/arc-opinst.c b/opcodes/arc-opinst.c
new file mode 100644
index 0000000..94c814c
--- /dev/null
+++ b/opcodes/arc-opinst.c
@@ -0,0 +1,3816 @@
+/* Semantic operand instances for arc.
+
+THIS FILE IS MACHINE GENERATED WITH CGEN.
+
+Copyright 1996-2007 Free Software Foundation, Inc.
+
+This file is part of the GNU Binutils and/or GDB, the GNU debugger.
+
+   This file is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   It is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or FITNESS FOR A PARTICULAR PURPOSE.  See the 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.,
+   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
+
+*/
+
+#include "sysdep.h"
+#include "ansidecl.h"
+#include "bfd.h"
+#include "symcat.h"
+#include "arc-desc.h"
+#include "arc-opc.h"
+
+/* Operand references.  */
+
+#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
+#define OP_ENT(op) ARC_OPERAND_##op
+#else
+#define OP_ENT(op) ARC_OPERAND_/**/op
+#endif
+#define INPUT CGEN_OPINST_INPUT
+#define OUTPUT CGEN_OPINST_OUTPUT
+#define END CGEN_OPINST_END
+#define COND_REF CGEN_OPINST_COND_REF
+
+static const CGEN_OPINST sfmt_empty_ops[] ATTRIBUTE_UNUSED = {
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_b_s_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "i2cond", HW_H_I2COND, CGEN_MODE_BI, OP_ENT (I2COND), 0, 0 },
+  { INPUT, "label10", HW_H_IADDR, CGEN_MODE_USI, OP_ENT (LABEL10), 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_bcc_s_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "i3cond", HW_H_I3COND, CGEN_MODE_BI, OP_ENT (I3COND), 0, 0 },
+  { INPUT, "label7", HW_H_IADDR, CGEN_MODE_USI, OP_ENT (LABEL7), 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_brcc_s_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, COND_REF },
+  { INPUT, "RccS", HW_H_RCCS, CGEN_MODE_BI, OP_ENT (RCCS), 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "label8", HW_H_IADDR, CGEN_MODE_USI, OP_ENT (LABEL8), 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_bcc_l_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "label21", HW_H_IADDR, CGEN_MODE_USI, OP_ENT (LABEL21), 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_b_l_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "label25", HW_H_IADDR, CGEN_MODE_USI, OP_ENT (LABEL25), 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_brcc_RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "Rcc", HW_H_RCC, CGEN_MODE_SI, OP_ENT (RCC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "label9", HW_H_IADDR, CGEN_MODE_USI, OP_ENT (LABEL9), 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_brcc_U6_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "Rcc", HW_H_RCC, CGEN_MODE_SI, OP_ENT (RCC), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "label9", HW_H_IADDR, CGEN_MODE_USI, OP_ENT (LABEL9), 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_bl_s_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "label13a", HW_H_IADDR, CGEN_MODE_USI, OP_ENT (LABEL13A), 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_blcc_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "label21a", HW_H_IADDR, CGEN_MODE_USI, OP_ENT (LABEL21A), 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_bl_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "label25a", HW_H_IADDR, CGEN_MODE_USI, OP_ENT (LABEL25A), 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_bl_d_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "label25a", HW_H_IADDR, CGEN_MODE_USI, OP_ENT (LABEL25A), 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ld_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s9", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S9), 0, 0 },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ld__AW_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s9", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S9), 0, 0 },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ld_abc_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ld__AW_abc_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ld_s_abc_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { INPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { OUTPUT, "R_a", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_A), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ld_s_abu_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "sc_u5_", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (SC_U5_), 0, 0 },
+  { OUTPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ld_s_absp_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "u5x4", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U5X4), 0, 0 },
+  { OUTPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ld_s_gprel_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "GP", HW_H_GP, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "sc_s9_", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (SC_S9_), 0, 0 },
+  { OUTPUT, "R0", HW_H_R0, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ld_s_pcrel_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, 0 },
+  { INPUT, "u8x4", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U8X4), 0, 0 },
+  { OUTPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldb_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s9", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S9), 0, 0 },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldb__AW_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s9", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S9), 0, 0 },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldb_as_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldb_abc_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldb__AW_abc_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldb_as_abc_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldb_s_abc_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { INPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { OUTPUT, "R_a", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_A), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldb_s_abu_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { INPUT, "sc_u5b", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (SC_U5B), 0, 0 },
+  { OUTPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldb_s_absp_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { INPUT, "u5x4", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U5X4), 0, 0 },
+  { OUTPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldb_s_gprel_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "GP", HW_H_GP, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { INPUT, "sc_s9b", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (SC_S9B), 0, 0 },
+  { OUTPUT, "R0", HW_H_R0, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldw_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_eaddr", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s9", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S9), 0, 0 },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldw__AW_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_eaddr", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s9", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S9), 0, 0 },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldw_abc_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_eaddr", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldw__AW_abc_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_eaddr", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldw_s_abc_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { INPUT, "h_memory_HI_eaddr", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, 0 },
+  { OUTPUT, "R_a", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_A), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldw_s_abu_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "h_memory_HI_eaddr", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, 0 },
+  { INPUT, "sc_u5w", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (SC_U5W), 0, 0 },
+  { OUTPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ldw_s_gprel_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "GP", HW_H_GP, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_eaddr", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, 0 },
+  { INPUT, "sc_s9w", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (SC_S9W), 0, 0 },
+  { OUTPUT, "R0", HW_H_R0, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_st_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s9", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S9), 0, 0 },
+  { OUTPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_st__AW_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s9", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S9), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_st_s_abu_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { INPUT, "sc_u5_", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (SC_U5_), 0, 0 },
+  { OUTPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_st_s_absp_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "u5x4", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U5X4), 0, 0 },
+  { OUTPUT, "h_memory_SI_eaddr", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_stb_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s9", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S9), 0, 0 },
+  { OUTPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_stb__AW_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s9", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S9), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_stb_as_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_stb_s_abu_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { INPUT, "sc_u5b", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (SC_U5B), 0, 0 },
+  { OUTPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_stb_s_absp_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "u5x4", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U5X4), 0, 0 },
+  { OUTPUT, "h_memory_QI_eaddr", HW_H_MEMORY, CGEN_MODE_QI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_stw_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s9", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S9), 0, 0 },
+  { OUTPUT, "h_memory_HI_eaddr", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_stw__AW_abs_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s9", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S9), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "h_memory_HI_eaddr", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_stw_s_abu_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { INPUT, "sc_u5w", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (SC_U5W), 0, 0 },
+  { OUTPUT, "h_memory_HI_eaddr", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_add_L_s12__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_add_ccu6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_add_L_u6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_add_L_r_r__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_add_cc__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_add_s_abc_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { OUTPUT, "R_a", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_A), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_add_s_cbu3_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "u3", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U3), 0, 0 },
+  { OUTPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_add_s_mcah_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "Rh", HW_H_CR, CGEN_MODE_SI, OP_ENT (RH), 0, 0 },
+  { INPUT, "f_op_h", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_2_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_add_s_absp_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "u5x4", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U5X4), 0, 0 },
+  { OUTPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_add_s_asspsp_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "u5x4", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U5X4), 0, 0 },
+  { OUTPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_add_s_gp_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "GP", HW_H_GP, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "s9x4", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (S9X4), 0, 0 },
+  { OUTPUT, "R0", HW_H_R0, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_add_s_r_u7_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "u7", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U7), 0, 0 },
+  { OUTPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_adc_L_s12__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_adc_ccu6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_adc_L_u6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, 0 },
+  { INPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_adc_L_r_r__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_adc_cc__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_I16_GO_SUB_s_go_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { OUTPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_sub_s_go_sub_ne_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_sub_s_ssb_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "u5", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U5), 0, 0 },
+  { OUTPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_and_L_s12__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_and_ccu6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_and_L_u6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_and_L_r_r__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_and_cc__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mov_L_s12__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_SI, OP_ENT (F), 0, 0 },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mov_ccu6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_SI, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mov_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_SI, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mov_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_SI, OP_ENT (F), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mov_cc__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_SI, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mov_s_mcah_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Rh", HW_H_CR, CGEN_MODE_SI, OP_ENT (RH), 0, 0 },
+  { INPUT, "f_op_h", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_2_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mov_s_mcahb_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { OUTPUT, "Rh", HW_H_CR, CGEN_MODE_SI, OP_ENT (RH), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mov_s_r_u7_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "u8", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U8), 0, 0 },
+  { OUTPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_tst_L_s12__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_tst_ccu6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_tst_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_tst_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_tst_cc__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_tst_s_go_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_cmp_L_s12__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_cmp_ccu6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_cmp_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_cmp_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_cmp_cc__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_cmp_s_mcah_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "Rh", HW_H_CR, CGEN_MODE_SI, OP_ENT (RH), 0, 0 },
+  { INPUT, "f_op_h", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_2_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_cmp_s_r_u7_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "u7", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U7), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_btst_s_ssb_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "u5", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U5), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mpy_L_s12__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mpy_ccu6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mpy_L_u6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mpy_L_r_r__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mpy_cc__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_L_r_r___RC_noilink__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "RC_noilink", HW_H_NOILINK, CGEN_MODE_SI, OP_ENT (RC_NOILINK), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_Cj", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { INPUT, "h_auxr_SI_12", HW_H_AUXR, CGEN_MODE_SI, 0, 12, COND_REF },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_cc___RC_noilink__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RC_noilink", HW_H_NOILINK, CGEN_MODE_SI, OP_ENT (RC_NOILINK), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_Cj", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { INPUT, "h_auxr_SI_12", HW_H_AUXR, CGEN_MODE_SI, 0, 12, COND_REF },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_L_r_r___RC_ilink__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "RC_ilink", HW_H_ILINKX, CGEN_MODE_SI, OP_ENT (RC_ILINK), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_Cj", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { INPUT, "h_auxr_SI_12", HW_H_AUXR, CGEN_MODE_SI, 0, 12, COND_REF },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_cc___RC_ilink__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RC_ilink", HW_H_ILINKX, CGEN_MODE_SI, OP_ENT (RC_ILINK), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_Cj", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { INPUT, "h_auxr_SI_12", HW_H_AUXR, CGEN_MODE_SI, 0, 12, COND_REF },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_L_s12__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_ccu6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_s_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, COND_REF },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_s__S_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R31", HW_H_R31, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_seq__S_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R31", HW_H_R31, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_L_s12_d__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_ccu6_d__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_L_u6_d__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_L_r_r_d___RC__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_j_cc_d___RC__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_jl_L_s12__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_jl_ccu6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_jl_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_jl_s_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, COND_REF },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_jl_L_r_r___RC_noilink__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RC_noilink", HW_H_NOILINK, CGEN_MODE_SI, OP_ENT (RC_NOILINK), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_jl_cc___RC_noilink__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RC_noilink", HW_H_NOILINK, CGEN_MODE_SI, OP_ENT (RC_NOILINK), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_jl_L_r_r_d___RC__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_jl_cc_d___RC__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_jl_s_d_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, COND_REF },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_31", HW_H_CR, CGEN_MODE_SI, 0, 31, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_lp_L_s12__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12x2", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12X2), 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_2", HW_H_AUXR, CGEN_MODE_SI, 0, 2, COND_REF },
+  { OUTPUT, "h_auxr_SI_3", HW_H_AUXR, CGEN_MODE_SI, 0, 3, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_lpcc_ccu6_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "U6x2", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6X2), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_2", HW_H_AUXR, CGEN_MODE_SI, 0, 2, COND_REF },
+  { OUTPUT, "h_auxr_SI_3", HW_H_AUXR, CGEN_MODE_SI, 0, 3, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_flag_L_s12__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, 0 },
+  { OUTPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_flag_ccu6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_flag_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_flag_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_flag_cc__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_lr_L_r_r___RC__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_INT, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_RC", HW_H_AUXR, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_lr_L_s12__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_s12", HW_H_AUXR, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_lr_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_INT, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_auxr_SI_U6", HW_H_AUXR, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_sr_L_r_r___RC__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_INT, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_RC", HW_H_AUXR, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_sr_L_s12__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, 0 },
+  { OUTPUT, "h_auxr_SI_s12", HW_H_AUXR, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_sr_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_INT, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_U6", HW_H_AUXR, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asl_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asl_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asr_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asr_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_rrc_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_rrc_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, 0 },
+  { INPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_sexb_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_QI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_sexb_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_QI, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_sexw_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_HI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_sexw_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_HI, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_abs_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_abs_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_not_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_not_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ex_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_USI, OP_ENT (RC), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_SI_RC", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "h_memory_SI_RC", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_ex_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_USI, OP_ENT (U6), 0, 0 },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_SI_U6", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "h_memory_SI_U6", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_swi_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_0", HW_H_CR, CGEN_MODE_SI, 0, 0, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_trap_s_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, 0 },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "trapnum", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (TRAPNUM), 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_0", HW_H_CR, CGEN_MODE_SI, 0, 0, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_brk_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asl_L_s12__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asl_ccu6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asl_L_u6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asl_L_r_r__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asl_cc__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mul64_L_s12__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, COND_REF },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { OUTPUT, "h_cr_SI_58", HW_H_CR, CGEN_MODE_SI, 0, 58, COND_REF },
+  { OUTPUT, "h_cr_SI_59", HW_H_CR, CGEN_MODE_SI, 0, 59, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mul64_ccu6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { OUTPUT, "h_cr_SI_58", HW_H_CR, CGEN_MODE_SI, 0, 58, COND_REF },
+  { OUTPUT, "h_cr_SI_59", HW_H_CR, CGEN_MODE_SI, 0, 59, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mul64_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { OUTPUT, "h_cr_SI_58", HW_H_CR, CGEN_MODE_SI, 0, 58, COND_REF },
+  { OUTPUT, "h_cr_SI_59", HW_H_CR, CGEN_MODE_SI, 0, 59, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mul64_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { OUTPUT, "h_cr_SI_58", HW_H_CR, CGEN_MODE_SI, 0, 58, COND_REF },
+  { OUTPUT, "h_cr_SI_59", HW_H_CR, CGEN_MODE_SI, 0, 59, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mul64_cc__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { OUTPUT, "h_cr_SI_58", HW_H_CR, CGEN_MODE_SI, 0, 58, COND_REF },
+  { OUTPUT, "h_cr_SI_59", HW_H_CR, CGEN_MODE_SI, 0, 59, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mul64_s_go_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, COND_REF },
+  { INPUT, "R_c", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_C), 0, COND_REF },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { OUTPUT, "h_cr_SI_58", HW_H_CR, CGEN_MODE_SI, 0, 58, COND_REF },
+  { OUTPUT, "h_cr_SI_59", HW_H_CR, CGEN_MODE_SI, 0, 59, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_adds_L_s12__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_adds_ccu6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_adds_L_u6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_adds_L_r_r__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_adds_cc__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "cbit", HW_H_CBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_divaw_L_s12__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_SI, OP_ENT (S12), 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_divaw_ccu6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_SI, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_divaw_L_u6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_SI, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_divaw_L_r_r__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_divaw_cc__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asls_L_s12__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_SI, OP_ENT (S12), 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asls_ccu6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_SI, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asls_L_u6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_SI, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asls_L_r_r__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_asls_cc__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_swap_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_swap_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_norm_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_SI, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_rnd16_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_rnd16_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_abssw_L_r_r__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_HI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_abssw_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_HI, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_abss_L_u6__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_SI, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_nop_s_ops[] ATTRIBUTE_UNUSED = {
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_pop_s_b_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "SP", HW_H_SP, CGEN_MODE_USI, 0, 0, 0 },
+  { INPUT, "h_memory_SI_SP", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { OUTPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { OUTPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_pop_s_blink_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "SP", HW_H_SP, CGEN_MODE_USI, 0, 0, 0 },
+  { INPUT, "h_memory_SI_SP", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { OUTPUT, "R31", HW_H_R31, CGEN_MODE_SI, 0, 0, 0 },
+  { OUTPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_push_s_b_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R_b", HW_H_CR16, CGEN_MODE_SI, OP_ENT (R_B), 0, 0 },
+  { INPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { OUTPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { OUTPUT, "h_memory_SI_SP", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_push_s_blink_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "R31", HW_H_R31, CGEN_MODE_SI, 0, 0, 0 },
+  { INPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { OUTPUT, "SP", HW_H_SP, CGEN_MODE_SI, 0, 0, 0 },
+  { OUTPUT, "h_memory_SI_SP", HW_H_MEMORY, CGEN_MODE_SI, 0, 0, 0 },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mullw_L_s12__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mullw_ccu6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, COND_REF },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mullw_L_u6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mullw_L_r_r__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_mullw_cc__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, COND_REF },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_maclw_L_s12__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { INPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, COND_REF },
+  { INPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_maclw_ccu6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, COND_REF },
+  { INPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, COND_REF },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_maclw_L_u6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { INPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_maclw_L_r_r__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { INPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_maclw_cc__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, COND_REF },
+  { INPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, COND_REF },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_machulw_L_s12__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { INPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { INPUT, "s12", HW_H_SINT, CGEN_MODE_INT, OP_ENT (S12), 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, 0 },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_machulw_ccu6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, COND_REF },
+  { INPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, COND_REF },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_machulw_L_u6__RA__ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "U6", HW_H_UINT, CGEN_MODE_UINT, OP_ENT (U6), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { INPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_machulw_L_r_r__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { INPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RA", HW_H_CR, CGEN_MODE_SI, OP_ENT (RA), 0, 0 },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, 0 },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, 0 },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_machulw_cc__RA__RC_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "F", HW_H_UFLAGS, CGEN_MODE_UINT, OP_ENT (F), 0, COND_REF },
+  { INPUT, "Qcondb", HW_H_QCONDB, CGEN_MODE_BI, OP_ENT (QCONDB), 0, 0 },
+  { INPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { INPUT, "RC", HW_H_CR, CGEN_MODE_SI, OP_ENT (RC), 0, COND_REF },
+  { INPUT, "f_op_B", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "f_op_C", HW_H_UINT, CGEN_MODE_UINT, 0, 0, 0 },
+  { INPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, COND_REF },
+  { INPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_4", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "h_memory_HI_add__DFLT_pc_add__DFLT_4_2", HW_H_MEMORY, CGEN_MODE_HI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "RB", HW_H_CR, CGEN_MODE_SI, OP_ENT (RB), 0, COND_REF },
+  { OUTPUT, "h_cr_SI_56", HW_H_CR, CGEN_MODE_SI, 0, 56, COND_REF },
+  { OUTPUT, "h_cr_SI_57", HW_H_CR, CGEN_MODE_SI, 0, 57, COND_REF },
+  { OUTPUT, "nbit", HW_H_NBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s1bit", HW_H_S1BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "s2bit", HW_H_S2BIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "vbit", HW_H_VBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "zbit", HW_H_ZBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_current_loop_end_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "h_auxr_SI_2", HW_H_AUXR, CGEN_MODE_SI, 0, 2, COND_REF },
+  { INPUT, "h_auxr_SI_3", HW_H_AUXR, CGEN_MODE_SI, 0, 3, 0 },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_cr_SI_60", HW_H_CR, CGEN_MODE_SI, 0, 60, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "lbit", HW_H_LBIT, CGEN_MODE_BI, 0, 0, 0 },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, 0 },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_60", HW_H_CR, CGEN_MODE_SI, 0, 60, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+static const CGEN_OPINST sfmt_current_loop_end_after_branch_ops[] ATTRIBUTE_UNUSED = {
+  { INPUT, "h_auxr_SI_2", HW_H_AUXR, CGEN_MODE_SI, 0, 2, COND_REF },
+  { INPUT, "h_auxr_SI_3", HW_H_AUXR, CGEN_MODE_SI, 0, 3, COND_REF },
+  { INPUT, "h_auxr_SI_34", HW_H_AUXR, CGEN_MODE_SI, 0, 34, COND_REF },
+  { INPUT, "h_auxr_SI_37", HW_H_AUXR, CGEN_MODE_SI, 0, 37, COND_REF },
+  { INPUT, "h_cr_SI_60", HW_H_CR, CGEN_MODE_SI, 0, 60, COND_REF },
+  { INPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { INPUT, "h_prof_offset_SI_0", HW_H_PROF_OFFSET, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_status32_SI_0", HW_H_STATUS32, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_timer_expire_SI_0", HW_H_TIMER_EXPIRE, CGEN_MODE_SI, 0, 0, COND_REF },
+  { INPUT, "h_ubit_BI", HW_H_UBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "lbit", HW_H_LBIT, CGEN_MODE_BI, 0, 0, COND_REF },
+  { INPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { OUTPUT, "h_auxr_SI_11", HW_H_AUXR, CGEN_MODE_SI, 0, 11, COND_REF },
+  { OUTPUT, "h_auxr_SI_33", HW_H_AUXR, CGEN_MODE_SI, 0, 33, COND_REF },
+  { OUTPUT, "h_cr_SI_29", HW_H_CR, CGEN_MODE_SI, 0, 29, COND_REF },
+  { OUTPUT, "h_cr_SI_60", HW_H_CR, CGEN_MODE_SI, 0, 60, COND_REF },
+  { OUTPUT, "h_e1_BI", HW_H_E1, CGEN_MODE_BI, 0, 0, COND_REF },
+  { OUTPUT, "h_memory_UHI_countp", HW_H_MEMORY, CGEN_MODE_UHI, 0, 0, COND_REF },
+  { OUTPUT, "pc", HW_H_PC, CGEN_MODE_USI, 0, 0, COND_REF },
+  { END, (const char *)0, (enum cgen_hw_type)0, (enum cgen_mode)0, (enum cgen_operand_type)0, 0, 0 }
+};
+
+#undef OP_ENT
+#undef INPUT
+#undef OUTPUT
+#undef END
+#undef COND_REF
+
+/* Operand instance lookup table.  */
+
+static const CGEN_OPINST *arc_cgen_opinst_table[MAX_INSNS] = {
+  0,
+  & sfmt_b_s_ops[0],
+  & sfmt_bcc_s_ops[0],
+  & sfmt_brcc_s_ops[0],
+  & sfmt_bcc_l_ops[0],
+  & sfmt_bcc_l_ops[0],
+  & sfmt_b_l_ops[0],
+  & sfmt_b_l_ops[0],
+  & sfmt_brcc_RC_ops[0],
+  & sfmt_brcc_RC_ops[0],
+  & sfmt_brcc_U6_ops[0],
+  & sfmt_brcc_U6_ops[0],
+  & sfmt_bl_s_ops[0],
+  & sfmt_blcc_ops[0],
+  & sfmt_blcc_ops[0],
+  & sfmt_bl_ops[0],
+  & sfmt_bl_d_ops[0],
+  & sfmt_ld_abs_ops[0],
+  & sfmt_ld__AW_abs_ops[0],
+  & sfmt_ld__AW_abs_ops[0],
+  & sfmt_ld_abs_ops[0],
+  & sfmt_ld_abc_ops[0],
+  & sfmt_ld__AW_abc_ops[0],
+  & sfmt_ld__AW_abc_ops[0],
+  & sfmt_ld_abc_ops[0],
+  & sfmt_ld_s_abc_ops[0],
+  & sfmt_ld_s_abu_ops[0],
+  & sfmt_ld_s_absp_ops[0],
+  & sfmt_ld_s_gprel_ops[0],
+  & sfmt_ld_s_pcrel_ops[0],
+  & sfmt_ldb_abs_ops[0],
+  & sfmt_ldb__AW_abs_ops[0],
+  & sfmt_ldb__AW_abs_ops[0],
+  & sfmt_ldb_as_abs_ops[0],
+  & sfmt_ldb_abc_ops[0],
+  & sfmt_ldb__AW_abc_ops[0],
+  & sfmt_ldb__AW_abc_ops[0],
+  & sfmt_ldb_as_abc_ops[0],
+  & sfmt_ldb_s_abc_ops[0],
+  & sfmt_ldb_s_abu_ops[0],
+  & sfmt_ldb_s_absp_ops[0],
+  & sfmt_ldb_s_gprel_ops[0],
+  & sfmt_ldb_abs_ops[0],
+  & sfmt_ldb__AW_abs_ops[0],
+  & sfmt_ldb__AW_abs_ops[0],
+  & sfmt_ldb_as_abs_ops[0],
+  & sfmt_ldb_abc_ops[0],
+  & sfmt_ldb__AW_abc_ops[0],
+  & sfmt_ldb__AW_abc_ops[0],
+  & sfmt_ldb_as_abc_ops[0],
+  & sfmt_ldw_abs_ops[0],
+  & sfmt_ldw__AW_abs_ops[0],
+  & sfmt_ldw__AW_abs_ops[0],
+  & sfmt_ldw_abs_ops[0],
+  & sfmt_ldw_abc_ops[0],
+  & sfmt_ldw__AW_abc_ops[0],
+  & sfmt_ldw__AW_abc_ops[0],
+  & sfmt_ldw_abc_ops[0],
+  & sfmt_ldw_s_abc_ops[0],
+  & sfmt_ldw_s_abu_ops[0],
+  & sfmt_ldw_s_gprel_ops[0],
+  & sfmt_ldw_abs_ops[0],
+  & sfmt_ldw__AW_abs_ops[0],
+  & sfmt_ldw__AW_abs_ops[0],
+  & sfmt_ldw_abs_ops[0],
+  & sfmt_ldw_abc_ops[0],
+  & sfmt_ldw__AW_abc_ops[0],
+  & sfmt_ldw__AW_abc_ops[0],
+  & sfmt_ldw_abc_ops[0],
+  & sfmt_ldw_s_abu_ops[0],
+  & sfmt_st_abs_ops[0],
+  & sfmt_st__AW_abs_ops[0],
+  & sfmt_st__AW_abs_ops[0],
+  & sfmt_st_abs_ops[0],
+  & sfmt_st_s_abu_ops[0],
+  & sfmt_st_s_absp_ops[0],
+  & sfmt_stb_abs_ops[0],
+  & sfmt_stb__AW_abs_ops[0],
+  & sfmt_stb__AW_abs_ops[0],
+  & sfmt_stb_as_abs_ops[0],
+  & sfmt_stb_s_abu_ops[0],
+  & sfmt_stb_s_absp_ops[0],
+  & sfmt_stw_abs_ops[0],
+  & sfmt_stw__AW_abs_ops[0],
+  & sfmt_stw__AW_abs_ops[0],
+  & sfmt_stw_abs_ops[0],
+  & sfmt_stw_s_abu_ops[0],
+  & sfmt_add_L_s12__RA__ops[0],
+  & sfmt_add_ccu6__RA__ops[0],
+  & sfmt_add_L_u6__RA__ops[0],
+  & sfmt_add_L_r_r__RA__RC_ops[0],
+  & sfmt_add_cc__RA__RC_ops[0],
+  & sfmt_add_s_abc_ops[0],
+  & sfmt_add_s_cbu3_ops[0],
+  & sfmt_add_s_mcah_ops[0],
+  & sfmt_add_s_absp_ops[0],
+  & sfmt_add_s_asspsp_ops[0],
+  & sfmt_add_s_gp_ops[0],
+  & sfmt_add_s_r_u7_ops[0],
+  & sfmt_adc_L_s12__RA__ops[0],
+  & sfmt_adc_ccu6__RA__ops[0],
+  & sfmt_adc_L_u6__RA__ops[0],
+  & sfmt_adc_L_r_r__RA__RC_ops[0],
+  & sfmt_adc_cc__RA__RC_ops[0],
+  & sfmt_add_L_s12__RA__ops[0],
+  & sfmt_add_ccu6__RA__ops[0],
+  & sfmt_add_L_u6__RA__ops[0],
+  & sfmt_add_L_r_r__RA__RC_ops[0],
+  & sfmt_add_cc__RA__RC_ops[0],
+  & sfmt_add_s_cbu3_ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_sub_s_go_sub_ne_ops[0],
+  & sfmt_sub_s_ssb_ops[0],
+  & sfmt_add_s_asspsp_ops[0],
+  & sfmt_adc_L_s12__RA__ops[0],
+  & sfmt_adc_ccu6__RA__ops[0],
+  & sfmt_adc_L_u6__RA__ops[0],
+  & sfmt_adc_L_r_r__RA__RC_ops[0],
+  & sfmt_adc_cc__RA__RC_ops[0],
+  & sfmt_and_L_s12__RA__ops[0],
+  & sfmt_and_ccu6__RA__ops[0],
+  & sfmt_and_L_u6__RA__ops[0],
+  & sfmt_and_L_r_r__RA__RC_ops[0],
+  & sfmt_and_cc__RA__RC_ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_and_L_s12__RA__ops[0],
+  & sfmt_and_ccu6__RA__ops[0],
+  & sfmt_and_L_u6__RA__ops[0],
+  & sfmt_and_L_r_r__RA__RC_ops[0],
+  & sfmt_and_cc__RA__RC_ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_and_L_s12__RA__ops[0],
+  & sfmt_and_ccu6__RA__ops[0],
+  & sfmt_and_L_u6__RA__ops[0],
+  & sfmt_and_L_r_r__RA__RC_ops[0],
+  & sfmt_and_cc__RA__RC_ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_and_L_s12__RA__ops[0],
+  & sfmt_and_ccu6__RA__ops[0],
+  & sfmt_and_L_u6__RA__ops[0],
+  & sfmt_and_L_r_r__RA__RC_ops[0],
+  & sfmt_and_cc__RA__RC_ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_add_L_s12__RA__ops[0],
+  & sfmt_add_ccu6__RA__ops[0],
+  & sfmt_add_L_u6__RA__ops[0],
+  & sfmt_add_L_r_r__RA__RC_ops[0],
+  & sfmt_add_cc__RA__RC_ops[0],
+  & sfmt_add_L_s12__RA__ops[0],
+  & sfmt_add_ccu6__RA__ops[0],
+  & sfmt_add_L_u6__RA__ops[0],
+  & sfmt_add_L_r_r__RA__RC_ops[0],
+  & sfmt_add_cc__RA__RC_ops[0],
+  & sfmt_mov_L_s12__ops[0],
+  & sfmt_mov_ccu6__ops[0],
+  & sfmt_mov_L_u6__ops[0],
+  & sfmt_mov_L_r_r__RC_ops[0],
+  & sfmt_mov_cc__RC_ops[0],
+  & sfmt_mov_s_mcah_ops[0],
+  & sfmt_mov_s_mcahb_ops[0],
+  & sfmt_mov_s_r_u7_ops[0],
+  & sfmt_tst_L_s12__ops[0],
+  & sfmt_tst_ccu6__ops[0],
+  & sfmt_tst_L_u6__ops[0],
+  & sfmt_tst_L_r_r__RC_ops[0],
+  & sfmt_tst_cc__RC_ops[0],
+  & sfmt_tst_s_go_ops[0],
+  & sfmt_cmp_L_s12__ops[0],
+  & sfmt_cmp_ccu6__ops[0],
+  & sfmt_cmp_L_u6__ops[0],
+  & sfmt_cmp_L_r_r__RC_ops[0],
+  & sfmt_cmp_cc__RC_ops[0],
+  & sfmt_cmp_s_mcah_ops[0],
+  & sfmt_cmp_s_r_u7_ops[0],
+  & sfmt_cmp_L_s12__ops[0],
+  & sfmt_cmp_ccu6__ops[0],
+  & sfmt_cmp_L_u6__ops[0],
+  & sfmt_cmp_L_r_r__RC_ops[0],
+  & sfmt_cmp_cc__RC_ops[0],
+  & sfmt_add_L_s12__RA__ops[0],
+  & sfmt_add_ccu6__RA__ops[0],
+  & sfmt_add_L_u6__RA__ops[0],
+  & sfmt_add_L_r_r__RA__RC_ops[0],
+  & sfmt_add_cc__RA__RC_ops[0],
+  & sfmt_and_L_s12__RA__ops[0],
+  & sfmt_and_ccu6__RA__ops[0],
+  & sfmt_and_L_u6__RA__ops[0],
+  & sfmt_and_L_r_r__RA__RC_ops[0],
+  & sfmt_and_cc__RA__RC_ops[0],
+  & sfmt_sub_s_ssb_ops[0],
+  & sfmt_and_L_s12__RA__ops[0],
+  & sfmt_and_ccu6__RA__ops[0],
+  & sfmt_and_L_u6__RA__ops[0],
+  & sfmt_and_L_r_r__RA__RC_ops[0],
+  & sfmt_and_cc__RA__RC_ops[0],
+  & sfmt_sub_s_ssb_ops[0],
+  & sfmt_tst_L_s12__ops[0],
+  & sfmt_tst_ccu6__ops[0],
+  & sfmt_tst_L_u6__ops[0],
+  & sfmt_tst_L_r_r__RC_ops[0],
+  & sfmt_tst_cc__RC_ops[0],
+  & sfmt_btst_s_ssb_ops[0],
+  & sfmt_and_L_s12__RA__ops[0],
+  & sfmt_and_ccu6__RA__ops[0],
+  & sfmt_and_L_u6__RA__ops[0],
+  & sfmt_and_L_r_r__RA__RC_ops[0],
+  & sfmt_and_cc__RA__RC_ops[0],
+  & sfmt_and_L_s12__RA__ops[0],
+  & sfmt_and_ccu6__RA__ops[0],
+  & sfmt_and_L_u6__RA__ops[0],
+  & sfmt_and_L_r_r__RA__RC_ops[0],
+  & sfmt_and_cc__RA__RC_ops[0],
+  & sfmt_sub_s_ssb_ops[0],
+  & sfmt_add_L_s12__RA__ops[0],
+  & sfmt_add_ccu6__RA__ops[0],
+  & sfmt_add_L_u6__RA__ops[0],
+  & sfmt_add_L_r_r__RA__RC_ops[0],
+  & sfmt_add_cc__RA__RC_ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_add_L_s12__RA__ops[0],
+  & sfmt_add_ccu6__RA__ops[0],
+  & sfmt_add_L_u6__RA__ops[0],
+  & sfmt_add_L_r_r__RA__RC_ops[0],
+  & sfmt_add_cc__RA__RC_ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_add_L_s12__RA__ops[0],
+  & sfmt_add_ccu6__RA__ops[0],
+  & sfmt_add_L_u6__RA__ops[0],
+  & sfmt_add_L_r_r__RA__RC_ops[0],
+  & sfmt_add_cc__RA__RC_ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_add_L_s12__RA__ops[0],
+  & sfmt_add_ccu6__RA__ops[0],
+  & sfmt_add_L_u6__RA__ops[0],
+  & sfmt_add_L_r_r__RA__RC_ops[0],
+  & sfmt_add_cc__RA__RC_ops[0],
+  & sfmt_add_L_s12__RA__ops[0],
+  & sfmt_add_ccu6__RA__ops[0],
+  & sfmt_add_L_u6__RA__ops[0],
+  & sfmt_add_L_r_r__RA__RC_ops[0],
+  & sfmt_add_cc__RA__RC_ops[0],
+  & sfmt_add_L_s12__RA__ops[0],
+  & sfmt_add_ccu6__RA__ops[0],
+  & sfmt_add_L_u6__RA__ops[0],
+  & sfmt_add_L_r_r__RA__RC_ops[0],
+  & sfmt_add_cc__RA__RC_ops[0],
+  & sfmt_mpy_L_s12__RA__ops[0],
+  & sfmt_mpy_ccu6__RA__ops[0],
+  & sfmt_mpy_L_u6__RA__ops[0],
+  & sfmt_mpy_L_r_r__RA__RC_ops[0],
+  & sfmt_mpy_cc__RA__RC_ops[0],
+  & sfmt_mpy_L_s12__RA__ops[0],
+  & sfmt_mpy_ccu6__RA__ops[0],
+  & sfmt_mpy_L_u6__RA__ops[0],
+  & sfmt_mpy_L_r_r__RA__RC_ops[0],
+  & sfmt_mpy_cc__RA__RC_ops[0],
+  & sfmt_mpy_L_s12__RA__ops[0],
+  & sfmt_mpy_ccu6__RA__ops[0],
+  & sfmt_mpy_L_u6__RA__ops[0],
+  & sfmt_mpy_L_r_r__RA__RC_ops[0],
+  & sfmt_mpy_cc__RA__RC_ops[0],
+  & sfmt_mpy_L_s12__RA__ops[0],
+  & sfmt_mpy_ccu6__RA__ops[0],
+  & sfmt_mpy_L_u6__RA__ops[0],
+  & sfmt_mpy_L_r_r__RA__RC_ops[0],
+  & sfmt_mpy_cc__RA__RC_ops[0],
+  & sfmt_j_L_r_r___RC_noilink__ops[0],
+  & sfmt_j_cc___RC_noilink__ops[0],
+  & sfmt_j_L_r_r___RC_ilink__ops[0],
+  & sfmt_j_cc___RC_ilink__ops[0],
+  & sfmt_j_L_s12__ops[0],
+  & sfmt_j_ccu6__ops[0],
+  & sfmt_j_L_u6__ops[0],
+  & sfmt_j_s_ops[0],
+  & sfmt_j_s__S_ops[0],
+  & sfmt_j_seq__S_ops[0],
+  & sfmt_j_seq__S_ops[0],
+  & sfmt_j_L_s12_d__ops[0],
+  & sfmt_j_ccu6_d__ops[0],
+  & sfmt_j_L_u6_d__ops[0],
+  & sfmt_j_L_r_r_d___RC__ops[0],
+  & sfmt_j_cc_d___RC__ops[0],
+  & sfmt_j_s_ops[0],
+  & sfmt_j_s__S_ops[0],
+  & sfmt_jl_L_s12__ops[0],
+  & sfmt_jl_ccu6__ops[0],
+  & sfmt_jl_L_u6__ops[0],
+  & sfmt_jl_s_ops[0],
+  & sfmt_jl_L_r_r___RC_noilink__ops[0],
+  & sfmt_jl_cc___RC_noilink__ops[0],
+  & sfmt_jl_L_s12__ops[0],
+  & sfmt_jl_ccu6__ops[0],
+  & sfmt_jl_L_u6__ops[0],
+  & sfmt_jl_L_r_r_d___RC__ops[0],
+  & sfmt_jl_cc_d___RC__ops[0],
+  & sfmt_jl_s_d_ops[0],
+  & sfmt_lp_L_s12__ops[0],
+  & sfmt_lpcc_ccu6_ops[0],
+  & sfmt_flag_L_s12__ops[0],
+  & sfmt_flag_ccu6__ops[0],
+  & sfmt_flag_L_u6__ops[0],
+  & sfmt_flag_L_r_r__RC_ops[0],
+  & sfmt_flag_cc__RC_ops[0],
+  & sfmt_lr_L_r_r___RC__ops[0],
+  & sfmt_lr_L_s12__ops[0],
+  & sfmt_lr_L_u6__ops[0],
+  & sfmt_sr_L_r_r___RC__ops[0],
+  & sfmt_sr_L_s12__ops[0],
+  & sfmt_sr_L_u6__ops[0],
+  & sfmt_asl_L_r_r__RC_ops[0],
+  & sfmt_asl_L_u6__ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_asr_L_r_r__RC_ops[0],
+  & sfmt_asr_L_u6__ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_asr_L_r_r__RC_ops[0],
+  & sfmt_asr_L_u6__ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_asr_L_r_r__RC_ops[0],
+  & sfmt_asr_L_u6__ops[0],
+  & sfmt_rrc_L_r_r__RC_ops[0],
+  & sfmt_rrc_L_u6__ops[0],
+  & sfmt_sexb_L_r_r__RC_ops[0],
+  & sfmt_sexb_L_u6__ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_sexw_L_r_r__RC_ops[0],
+  & sfmt_sexw_L_u6__ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_sexb_L_r_r__RC_ops[0],
+  & sfmt_sexb_L_u6__ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_sexw_L_r_r__RC_ops[0],
+  & sfmt_sexw_L_u6__ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_abs_L_r_r__RC_ops[0],
+  & sfmt_abs_L_u6__ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_not_L_r_r__RC_ops[0],
+  & sfmt_not_L_u6__ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_rrc_L_r_r__RC_ops[0],
+  & sfmt_rrc_L_u6__ops[0],
+  & sfmt_ex_L_r_r__RC_ops[0],
+  & sfmt_ex_L_u6__ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_swi_ops[0],
+  & sfmt_trap_s_ops[0],
+  & sfmt_brk_ops[0],
+  & sfmt_brk_ops[0],
+  & sfmt_asl_L_s12__RA__ops[0],
+  & sfmt_asl_ccu6__RA__ops[0],
+  & sfmt_asl_L_u6__RA__ops[0],
+  & sfmt_asl_L_r_r__RA__RC_ops[0],
+  & sfmt_asl_cc__RA__RC_ops[0],
+  & sfmt_add_s_cbu3_ops[0],
+  & sfmt_sub_s_ssb_ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_asl_L_s12__RA__ops[0],
+  & sfmt_asl_ccu6__RA__ops[0],
+  & sfmt_asl_L_u6__RA__ops[0],
+  & sfmt_asl_L_r_r__RA__RC_ops[0],
+  & sfmt_asl_cc__RA__RC_ops[0],
+  & sfmt_sub_s_ssb_ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_asl_L_s12__RA__ops[0],
+  & sfmt_asl_ccu6__RA__ops[0],
+  & sfmt_asl_L_u6__RA__ops[0],
+  & sfmt_asl_L_r_r__RA__RC_ops[0],
+  & sfmt_asl_cc__RA__RC_ops[0],
+  & sfmt_add_s_cbu3_ops[0],
+  & sfmt_sub_s_ssb_ops[0],
+  & sfmt_I16_GO_SUB_s_go_ops[0],
+  & sfmt_asl_L_s12__RA__ops[0],
+  & sfmt_asl_ccu6__RA__ops[0],
+  & sfmt_asl_L_u6__RA__ops[0],
+  & sfmt_asl_L_r_r__RA__RC_ops[0],
+  & sfmt_asl_cc__RA__RC_ops[0],
+  & sfmt_mul64_L_s12__ops[0],
+  & sfmt_mul64_ccu6__ops[0],
+  & sfmt_mul64_L_u6__ops[0],
+  & sfmt_mul64_L_r_r__RC_ops[0],
+  & sfmt_mul64_cc__RC_ops[0],
+  & sfmt_mul64_s_go_ops[0],
+  & sfmt_mul64_L_s12__ops[0],
+  & sfmt_mul64_ccu6__ops[0],
+  & sfmt_mul64_L_u6__ops[0],
+  & sfmt_mul64_L_r_r__RC_ops[0],
+  & sfmt_mul64_cc__RC_ops[0],
+  & sfmt_adds_L_s12__RA__ops[0],
+  & sfmt_adds_ccu6__RA__ops[0],
+  & sfmt_adds_L_u6__RA__ops[0],
+  & sfmt_adds_L_r_r__RA__RC_ops[0],
+  & sfmt_adds_cc__RA__RC_ops[0],
+  & sfmt_adds_L_s12__RA__ops[0],
+  & sfmt_adds_ccu6__RA__ops[0],
+  & sfmt_adds_L_u6__RA__ops[0],
+  & sfmt_adds_L_r_r__RA__RC_ops[0],
+  & sfmt_adds_cc__RA__RC_ops[0],
+  & sfmt_divaw_L_s12__RA__ops[0],
+  & sfmt_divaw_ccu6__RA__ops[0],
+  & sfmt_divaw_L_u6__RA__ops[0],
+  & sfmt_divaw_L_r_r__RA__RC_ops[0],
+  & sfmt_divaw_cc__RA__RC_ops[0],
+  & sfmt_asls_L_s12__RA__ops[0],
+  & sfmt_asls_ccu6__RA__ops[0],
+  & sfmt_asls_L_u6__RA__ops[0],
+  & sfmt_asls_L_r_r__RA__RC_ops[0],
+  & sfmt_asls_cc__RA__RC_ops[0],
+  & sfmt_asls_L_s12__RA__ops[0],
+  & sfmt_asls_ccu6__RA__ops[0],
+  & sfmt_asls_L_u6__RA__ops[0],
+  & sfmt_asls_L_r_r__RA__RC_ops[0],
+  & sfmt_asls_cc__RA__RC_ops[0],
+  & sfmt_asls_L_s12__RA__ops[0],
+  & sfmt_asls_ccu6__RA__ops[0],
+  & sfmt_asls_L_u6__RA__ops[0],
+  & sfmt_asls_L_r_r__RA__RC_ops[0],
+  & sfmt_asls_cc__RA__RC_ops[0],
+  & sfmt_asls_L_s12__RA__ops[0],
+  & sfmt_asls_ccu6__RA__ops[0],
+  & sfmt_asls_L_u6__RA__ops[0],
+  & sfmt_asls_L_r_r__RA__RC_ops[0],
+  & sfmt_asls_cc__RA__RC_ops[0],
+  & sfmt_swap_L_r_r__RC_ops[0],
+  & sfmt_swap_L_u6__ops[0],
+  & sfmt_swap_L_r_r__RC_ops[0],
+  & sfmt_norm_L_u6__ops[0],
+  & sfmt_rnd16_L_r_r__RC_ops[0],
+  & sfmt_rnd16_L_u6__ops[0],
+  & sfmt_abssw_L_r_r__RC_ops[0],
+  & sfmt_abssw_L_u6__ops[0],
+  & sfmt_rnd16_L_r_r__RC_ops[0],
+  & sfmt_abss_L_u6__ops[0],
+  & sfmt_abssw_L_r_r__RC_ops[0],
+  & sfmt_abssw_L_u6__ops[0],
+  & sfmt_rnd16_L_r_r__RC_ops[0],
+  & sfmt_rnd16_L_u6__ops[0],
+  & sfmt_swap_L_r_r__RC_ops[0],
+  & sfmt_swap_L_u6__ops[0],
+  & sfmt_nop_s_ops[0],
+  & sfmt_nop_s_ops[0],
+  & sfmt_pop_s_b_ops[0],
+  & sfmt_pop_s_blink_ops[0],
+  & sfmt_push_s_b_ops[0],
+  & sfmt_push_s_blink_ops[0],
+  & sfmt_mullw_L_s12__RA__ops[0],
+  & sfmt_mullw_ccu6__RA__ops[0],
+  & sfmt_mullw_L_u6__RA__ops[0],
+  & sfmt_mullw_L_r_r__RA__RC_ops[0],
+  & sfmt_mullw_cc__RA__RC_ops[0],
+  & sfmt_maclw_L_s12__RA__ops[0],
+  & sfmt_maclw_ccu6__RA__ops[0],
+  & sfmt_maclw_L_u6__RA__ops[0],
+  & sfmt_maclw_L_r_r__RA__RC_ops[0],
+  & sfmt_maclw_cc__RA__RC_ops[0],
+  & sfmt_maclw_L_s12__RA__ops[0],
+  & sfmt_maclw_ccu6__RA__ops[0],
+  & sfmt_maclw_L_u6__RA__ops[0],
+  & sfmt_maclw_L_r_r__RA__RC_ops[0],
+  & sfmt_maclw_cc__RA__RC_ops[0],
+  & sfmt_mullw_L_s12__RA__ops[0],
+  & sfmt_mullw_ccu6__RA__ops[0],
+  & sfmt_mullw_L_u6__RA__ops[0],
+  & sfmt_mullw_L_r_r__RA__RC_ops[0],
+  & sfmt_mullw_cc__RA__RC_ops[0],
+  & sfmt_machulw_L_s12__RA__ops[0],
+  & sfmt_machulw_ccu6__RA__ops[0],
+  & sfmt_machulw_L_u6__RA__ops[0],
+  & sfmt_machulw_L_r_r__RA__RC_ops[0],
+  & sfmt_machulw_cc__RA__RC_ops[0],
+  & sfmt_current_loop_end_ops[0],
+  & sfmt_current_loop_end_after_branch_ops[0],
+  & sfmt_current_loop_end_after_branch_ops[0],
+};
+
+/* Function to call before using the operand instance table.  */
+
+void
+arc_cgen_init_opinst_table (cd)
+     CGEN_CPU_DESC cd;
+{
+  int i;
+  const CGEN_OPINST **oi = & arc_cgen_opinst_table[0];
+  CGEN_INSN *insns = (CGEN_INSN *) cd->insn_table.init_entries;
+  for (i = 0; i < MAX_INSNS; ++i)
+    insns[i].opinst = oi[i];
+}
diff --git a/opcodes/arcompact-dis.c b/opcodes/arcompact-dis.c
new file mode 100644
index 0000000..545eecb
--- /dev/null
+++ b/opcodes/arcompact-dis.c
@@ -0,0 +1,3833 @@
+/* Instruction printing code for the ARC.
+   Copyright (C) 1994, 1995, 1997, 1998 Free Software Foundation, Inc.
+   Contributed by Doug Evans (dje@cygnus.com).
+
+   Sources derived from work done by Sankhya Technologies (www.sankhya.com)
+
+   Cleaned up , Comments Added, Support For A700 instructions by
+   Saurabh Verma (saurabh.verma@codito.com)
+   Ramana Radhakrishnan(ramana.radhakrishnan@codito.com)
+
+
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */
+
+#include <ansidecl.h>
+#include "dis-asm.h"
+#include "opcode/arc.h"
+#include "elf-bfd.h"
+#include "elf/arc.h"
+#include <string.h>
+
+#include <ctype.h>
+#include <stdarg.h>
+#include "arc-dis.h"
+#include "arc-ext.h"
+
+  /*
+    warning: implicit declaration of function `printf_unfiltered'
+    if dbg is 1 then this definition is required
+  */
+  void printf_unfiltered (const char *,...);
+static bfd_vma bfd_getm32 (unsigned int);
+static bfd_vma bfd_getm32_ac (unsigned int) ATTRIBUTE_UNUSED;
+struct arcDisState arcAnalyzeInstr (bfd_vma, disassemble_info*);
+
+
+#ifndef dbg
+#define dbg	(0)
+#endif
+
+  /*
+    Ravi:
+    : undefined reference to `printf_unfiltered'
+    if dbg is 1 then this definition is required
+  */
+#if dbg
+  void printf_unfiltered (const char *,...)
+ {
+   va_list args;
+   va_start (args, format);
+   vfprintf_unfiltered (gdb_stdout, format, args);
+   va_end (args);
+ }
+#endif
+
+#undef _NELEM
+#define _NELEM(ary)	(sizeof(ary) / sizeof(ary[0]))
+
+#define BIT(word,n)       ((word) & (1 << n))
+#define BITS(word,s,e)    (((word) << (31-e)) >> (s+(31-e)))
+#define OPCODE(word)      (BITS ((word), 27, 31))
+#define FIELDA(word)      (BITS ((word), 0, 5))
+#define FIELDb(word)      (BITS ((word), 24, 26))
+#define FIELDB(word)      (BITS ((word), 12, 14))
+#define FIELDC(word)      (BITS ((word), 6, 11))
+#define OPCODE_AC(word)   (BITS ((word), 11, 15))
+#define FIELDA_AC(word)   (BITS ((word), 0, 2))
+#define FIELDB_AC(word)   (BITS ((word), 8, 10))
+#define FIELDC_AC(word)   (BITS ((word), 5, 7))
+#define FIELDU_AC(word)   (BITS ((word), 0, 4))
+
+/*
+ * FIELDS_AC is the 11-bit signed immediate value used for
+ * GP-relative instructions.
+ */
+#define FIELDS_AC(word)   (BITS (((signed int) word), 0, 8))
+
+/*
+ * FIELDD is signed in all of its uses, so we make sure argument is
+ * treated as signed for bit shifting purposes.
+ */
+#define FIELDD(word)      (BITS (((signed int) word), 16, 23))
+
+/*
+ * FIELDD9 is the 9-bit signed immediate value used for
+ * load/store instructions.
+ */
+#define FIELDD9(word)     ((BITS(((signed int)word),15,15) << 8) | (BITS((word),16,23)))
+
+/*
+ * FIELDS is the 12-bit signed immediate value
+ */
+#define FIELDS(word)      ((BITS(((signed int)word),0,5) << 6) | (BITS((word),6,11)))					\
+
+/*
+ * FIELD S9 is the 9-bit signed immediate value used for
+ * bbit0/bbit instruction
+ */
+#define FIELDS9(word)     (((BITS(((signed int)word),15,15) << 7) | (BITS((word),17,23))) << 1)
+#define FIELDS9_FLAG(word)     (((BITS(((signed int)word),0,5) << 6) | (BITS((word),6,11))) )
+
+#define PUT_NEXT_WORD_IN(a) {		\
+	if (is_limm==1 && !NEXT_WORD(1))       	\
+	  mwerror(state, "Illegal limm reference in last instruction!\n"); \
+        a = ((state->words[1] & 0xff00) | (state->words[1] & 0xff)) << 16; \
+        a |= ((state->words[1] & 0xff0000) | (state->words[1] & 0xff000000)) >> 16;	\
+	}
+
+#define CHECK_NULLIFY() do{		\
+	state->nullifyMode = BITS(state->words[0],5,5);	\
+	}while(0)
+
+#define CHECK_COND_NULLIFY() do {		\
+	state->nullifyMode = BITS(state->words[0],5,5);	\
+	cond = BITS(state->words[0],0,4);	\
+	}while(0)
+
+#define CHECK_FLAG_COND_NULLIFY() do{	\
+	if (is_shimm == 0) {			\
+	  flag = BIT(state->words[0],15);	\
+	  state->nullifyMode = BITS(state->words[0],5,5); \
+	  cond = BITS(state->words[0],0,4);	\
+	}					\
+	}while(0)
+
+#define CHECK_FLAG_COND() {		\
+	if (is_shimm == 0) {			\
+	  flag = BIT(state->words[0],15);	\
+	  cond = BITS(state->words[0],0,4);	\
+	}					\
+	}
+
+#define CHECK_FLAG() {			\
+	flag = BIT(state->words[0],15);	\
+	}
+
+#define CHECK_COND() {		                \
+	if (is_shimm == 0) {			\
+	  cond = BITS(state->words[0],0,4);	\
+	}					\
+	}
+
+#define CHECK_FIELD(field) {			\
+	if (field == 62) {			\
+	  is_limm++;				\
+	  field##isReg = 0;			\
+	  PUT_NEXT_WORD_IN(field);		\
+	  limm_value = field;			\
+	}					\
+	}
+
+#define CHECK_FIELD_A() {			\
+	fieldA = FIELDA(state->words[0]);	\
+	if (fieldA == 62) {			\
+	  fieldAisReg = 0;			\
+	  fieldA = 0;				\
+	}					\
+	}
+
+#define FIELD_B() {				\
+	fieldB = (FIELDB(state->words[0]) << 3);\
+	fieldB |= FIELDb(state->words[0]);	\
+	if (fieldB == 62) {			\
+	  fieldBisReg = 0;			\
+	  fieldB = 0;				\
+	}					\
+	}
+
+#define FIELD_C() {				\
+	fieldC = FIELDC(state->words[0]);	\
+	if (fieldC == 62) {  			\
+	  fieldCisReg = 0; 			\
+	}					\
+	}
+/********** Aurora SIMD ARC 8 - bit constant **********/
+#define FIELD_U8() {                            \
+                                                \
+          fieldC  = BITS(state->words[0],15,16);\
+          fieldC  = fieldC <<6;                 \
+          fieldC |= FIELDC(state->words[0]);    \
+          fieldCisReg = 0;                      \
+        }
+
+#define CHECK_FIELD_B() {			\
+	fieldB = (FIELDB(state->words[0]) << 3);\
+	fieldB |= FIELDb(state->words[0]);	\
+	CHECK_FIELD(fieldB);			\
+	}
+
+#define CHECK_FIELD_C() {			\
+	fieldC = FIELDC(state->words[0]);	\
+	CHECK_FIELD(fieldC);			\
+	}
+
+#define FIELD_C_S() {				\
+	fieldC_S = (FIELDC_S(state->words[0]) << 3);	\
+	}
+
+#define FIELD_B_S() {				\
+	fieldB_S = (FIELDB_S(state->words[0]) << 3);	\
+	}
+
+#define CHECK_FIELD_H_AC() {			\
+	fieldC = ((FIELDA_AC(state->words[0])) << 3);	\
+	fieldC |= FIELDC_AC(state->words[0]);	\
+	CHECK_FIELD(fieldC);			\
+	}
+
+#define FIELD_H_AC() {				\
+	fieldC = ((FIELDA_AC(state->words[0])) << 3);	\
+	fieldC |= FIELDC_AC(state->words[0]);	\
+	if (fieldC > 60) {  			\
+	  fieldCisReg = 0; 			\
+	  fieldC = 0;				\
+	}					\
+	}
+
+#define FIELD_C_AC() {				\
+	fieldC = FIELDC_AC(state->words[0]);	\
+	if (fieldC > 3) {  			\
+	  fieldC += 8;  			\
+	}				  	\
+	}
+
+#define FIELD_B_AC() {				\
+	fieldB = FIELDB_AC(state->words[0]);	\
+	if (fieldB > 3) {  			\
+	  fieldB += 8; 				\
+	}				  	\
+	}
+
+#define FIELD_A_AC() {				\
+	fieldA = FIELDA_AC(state->words[0]);	\
+	if (fieldA > 3) {  			\
+	  fieldA += 8; 				\
+	}				  	\
+	}
+
+#define IS_SMALL(x) (((field##x) < 256) && ((field##x) > -257))
+#define IS_REG(x)   (field##x##isReg)
+#define IS_SIMD_128_REG(x)  (usesSimdReg##x == 1)
+#define IS_SIMD_16_REG(x)   (usesSimdReg##x == 2)
+#define IS_SIMD_DATA_REG(x) (usesSimdReg##x == 3)
+#define WRITE_FORMAT_LB_Rx_RB(x)     WRITE_FORMAT(x,"[","]","","")
+#define WRITE_FORMAT_x_COMMA_LB(x)   WRITE_FORMAT(x,"",",[","",",[")
+#define WRITE_FORMAT_COMMA_x_RB(x)   WRITE_FORMAT(x,",","]",",","]")
+#define WRITE_FORMAT_x_RB(x)         WRITE_FORMAT(x,"","]","","]")
+#define WRITE_FORMAT_COMMA_x(x)      WRITE_FORMAT(x,",","",",","")
+#define WRITE_FORMAT_x_COMMA(x)      WRITE_FORMAT(x,"",",","",",")
+#define WRITE_FORMAT_x(x)            WRITE_FORMAT(x,"","","","")
+#define WRITE_FORMAT(x,cb1,ca1,cb,ca) strcat(formatString,              \
+                                     (IS_SIMD_128_REG(x) ? cb1"%S"ca1:  \
+                                      IS_SIMD_16_REG(x)  ? cb1"%I"ca1:  \
+                                      IS_SIMD_DATA_REG(x)? cb1"%D"ca1:  \
+                                      IS_REG(x)          ? cb1"%r"ca1:  \
+                                      usesAuxReg         ?  cb"%a"ca :  \
+                                      IS_SMALL(x) ? cb"%d"ca : cb"%h"ca))
+
+#define WRITE_FORMAT_LB() strcat(formatString, "[")
+#define WRITE_FORMAT_RB() strcat(formatString, "]")
+#define WRITE_COMMENT(str)	(state->comm[state->commNum++] = (str))
+#define WRITE_NOP_COMMENT() if (!fieldAisReg && !flag) WRITE_COMMENT("nop");
+
+#define NEXT_WORD(x) (offset += 4, state->words[x])
+
+#define NEXT_WORD_AC(x) (offset += 2, state->words[x])
+
+#define add_target(x) 	(state->targets[state->tcnt++] = (x))
+
+static char comment_prefix[] = "\t; ";
+short int enable_simd = 0;
+
+static const char *
+core_reg_name(struct arcDisState *state, int val)
+{
+  if (state->coreRegName)
+    return (*state->coreRegName)(state->_this, val);
+  return 0;
+}
+
+static const char *
+aux_reg_name(struct arcDisState *state, int val)
+{
+  if (state->auxRegName)
+    return (*state->auxRegName)(state->_this, val);
+  return 0;
+}
+
+static const char *
+cond_code_name(struct arcDisState *state, int val)
+{
+  if (state->condCodeName)
+    return (*state->condCodeName)(state->_this, val);
+  return 0;
+}
+
+static const char *
+instruction_name(struct arcDisState *state, int op1, int op2, int *flags)
+{
+  if (state->instName)
+    return (*state->instName)(state->_this, op1, op2, flags);
+  return 0;
+}
+
+static void
+mwerror(struct arcDisState *state, const char *msg)
+{
+  if (state->err != 0)
+    (*state->err)(state->_this, (msg));
+}
+
+static const char *
+post_address(struct arcDisState *state, int addr)
+{
+  static char id[3*_NELEM(state->addresses)];
+  unsigned int j, i = state->acnt;
+  if (i < _NELEM(state->addresses)) {
+    state->addresses[i] = addr;
+    ++state->acnt;
+    j = i*3;
+    id[j+0] = '@';
+    id[j+1] = '0'+i;
+    id[j+2] = 0;
+    return id+j;
+  }
+  return "";
+}
+
+static void
+my_sprintf (struct arcDisState *state, char *buf, const char*format, ...)
+{
+  char *bp;
+  const char *p;
+  int size, leading_zero, regMap[2];
+  long auxNum;
+  va_list ap;
+
+  va_start(ap,format);
+  bp = buf;
+  *bp = 0;
+  p = format;
+  auxNum = -1;
+  regMap[0] = 0;
+  regMap[1] = 0;
+  while (1)
+    switch(*p++) {
+    case 0: goto DOCOMM; /*(return) */
+    default:
+      *bp++ = p[-1];
+      break;
+    case '%':
+      size = 0;
+      leading_zero = 0;
+    RETRY: ;
+      switch(*p++)
+	{
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	  {
+	    /* size. */
+	    size = p[-1]-'0';
+	    if (size == 0) leading_zero = 1; /* e.g. %08x */
+	    while (*p >= '0' && *p <= '9')
+	      size = size*10+*p-'0', p++;
+	    goto RETRY;
+	  }
+#define inc_bp() bp = bp+strlen(bp)
+
+	case 'h':
+	  {
+	    unsigned u = va_arg(ap,int);
+	    /*
+	     * Hex.  We can change the format to 0x%08x in
+	     * one place, here, if we wish.
+	     * We add underscores for easy reading.
+	     */
+#define CDT_DEBUG
+	    if (u > 65536)
+#ifndef CDT_DEBUG
+	      sprintf(bp,"0x%x_%04x",u >> 16, u & 0xffff);
+#else
+	      sprintf(bp,"0x%08x",u);
+#endif // CDT_DEBUG
+	    else
+	      sprintf(bp,"0x%x",u);
+	    inc_bp();
+	  }
+	  break;
+	case 'X': case 'x':
+	  {
+	    int val = va_arg(ap,int);
+	    if (size != 0)
+	      if (leading_zero) sprintf(bp,"%0*x",size,val);
+	      else sprintf(bp,"%*x",size,val);
+	    else sprintf(bp,"%x",val);
+	    inc_bp();
+	  }
+	  break;
+	case 'd':
+	  {
+	    int val = va_arg(ap,int);
+	    if (size != 0) sprintf(bp,"%*d",size,val);
+	    else sprintf(bp,"%d",val);
+	    inc_bp();
+	  }
+	  break;
+	case 'r':
+	  {
+	    /* Register. */
+	    int val = va_arg(ap,int);
+
+#define REG2NAME(num, name) case num: sprintf(bp,""name); \
+			regMap[(num<32)?0:1] |= 1<<(num-((num<32)?0:32)); break;
+	    switch (val)
+	      {
+		REG2NAME(26, "gp");
+		REG2NAME(27, "fp");
+		REG2NAME(28, "sp");
+		REG2NAME(29, "ilink1");
+		REG2NAME(30, "ilink2");
+		REG2NAME(31, "blink");
+		REG2NAME(60, "lp_count");
+		REG2NAME(63, "pcl");
+	      default:
+		{
+		  const char *ext;
+		  ext = core_reg_name(state, val);
+		  if (ext) sprintf(bp, "%s", ext);
+		  else     sprintf(bp,"r%d",val);
+		}break;
+	      }
+	    inc_bp();
+	  } break;
+
+	case 'a':
+	  {
+	  /* Aux Register. */
+	    int val = va_arg(ap,int);
+	    char *ret;
+	    ret = arc_aux_reg_name(val);
+	    if(ret)
+	      sprintf(bp,"%s",ret);
+	    else
+	      {
+		const char *ext;
+		  ext = aux_reg_name(state, val);
+		  if (ext) sprintf(bp, "%s", ext);
+		  else     my_sprintf(state, bp,"%h",val);
+	      }
+
+	    inc_bp();
+	  }
+	  break;
+	case 's':
+	  {
+	    sprintf(bp,"%s",va_arg(ap,char*));
+	    inc_bp();
+	  }
+	  break;
+	case '*':
+	  {
+	    va_arg(ap,char*);
+	    inc_bp();
+	    break;
+	  }
+
+	  /* SIMD operands follow*/
+	case 'S':
+	  {
+	    int val = va_arg (ap,int);
+
+	    sprintf (bp, "vr%d",val);
+	    inc_bp ();
+	    break;
+	  }
+	case 'I':
+	  {
+	    int val = va_arg (ap,int);
+
+	    sprintf (bp, "i%d",val);
+	    inc_bp ();
+	    break;
+	  }
+	case 'D':
+	  {
+	    int val = va_arg (ap,int);
+
+	    sprintf (bp, "dr%d",val);
+	    inc_bp ();
+	    break;
+	  }
+	  /* SIMD operands end */
+	default:
+	  fprintf(stderr,"?? format %c\n",p[-1]);
+	  break;
+	}
+    }
+
+
+ DOCOMM: *bp = 0;
+
+}
+
+static void
+write_comments_(struct arcDisState *state, int shimm, int is_limm, long limm_value)
+{
+  if (state->commentBuffer != 0)
+    {
+      int i;
+      if (is_limm)
+	{
+	  const char *name = post_address(state, limm_value+shimm);
+	  if (*name != 0) WRITE_COMMENT(name);
+	}
+      for(i = 0; i < state->commNum; i++)
+	{
+	  if (i == 0) strcpy(state->commentBuffer, comment_prefix);
+	  else  strcat(state->commentBuffer, ", ");
+	  strncat(state->commentBuffer, state->comm[i], sizeof(state->commentBuffer));
+	}
+    }
+}
+
+#define write_comments2(x)	write_comments_(state, x, is_limm, limm_value)
+#define write_comments()	write_comments2(0)
+
+static const char *condName[] =
+{
+  /* 0..15. */
+  ""   , "z"  , "nz" , "p"  , "n"  , "c"  , "nc" , "v"  ,
+  "nv" , "gt" , "ge" , "lt" , "le" , "hi" , "ls" , "pnz",
+  "ss" , "sc"
+
+};
+
+static void
+write_instr_name_(struct arcDisState *state,
+		  const char *instrName,
+		  int cond,
+		  int condCodeIsPartOfName,
+		  int flag,
+		  int signExtend,
+		  int addrWriteBack,
+		  int directMem)
+{
+  strcpy(state->instrBuffer, instrName);
+  if (cond > 0)
+    {
+      int condlim = 0; /* condition code limit*/
+      const char *cc = 0;
+      if (!condCodeIsPartOfName) strcat(state->instrBuffer, ".");
+      condlim = 18;
+      if (cond < condlim)
+	cc = condName[cond];
+      else
+	cc = cond_code_name(state, cond);
+      if (!cc) cc = "???";
+      strcat(state->instrBuffer, cc);
+    }
+  if (flag) strcat(state->instrBuffer, ".f");
+  if (state->nullifyMode)
+    strcat(state->instrBuffer, ".d");
+  if (signExtend)    strcat(state->instrBuffer, ".x");
+  switch (addrWriteBack)
+  {
+    case 1: strcat(state->instrBuffer, ".a"); break;
+    case 2: strcat(state->instrBuffer, ".ab"); break;
+    case 3: strcat(state->instrBuffer, ".as"); break;
+  }
+  if (directMem)     strcat(state->instrBuffer, ".di");
+}
+
+#define write_instr_name()	{\
+  write_instr_name_(state, instrName,cond, condCodeIsPartOfName, flag, signExtend, addrWriteBack, directMem); \
+ formatString[0] = '\0'; \
+}
+
+enum
+{
+  op_BC = 0, op_BLC = 1, op_LD  = 2, op_ST = 3, op_MAJOR_4  = 4,
+  op_MAJOR_5 = 5, op_SIMD=6,      op_LD_ADD = 12, op_ADD_SUB_SHIFT  = 13,
+  op_ADD_MOV_CMP = 14, op_S = 15, op_LD_S = 16, op_LDB_S = 17,
+  op_LDW_S = 18, op_LDWX_S  = 19, op_ST_S = 20, op_STB_S = 21,
+  op_STW_S = 22, op_Su5     = 23, op_SP   = 24, op_GP    = 25, op_Pcl = 26,
+  op_MOV_S = 27, op_ADD_CMP = 28, op_BR_S = 29, op_B_S   = 30, op_BL_S = 31
+};
+
+extern disassemble_info tm_print_insn_info;
+
+/*
+ * bfd_getm32 - To retrieve the upper 16-bits of the ARCtangent-A5
+ *              basecase (32-bit) instruction
+ */
+static bfd_vma
+bfd_getm32 (data)
+     unsigned int data;
+{
+   bfd_vma value = 0;
+
+   value = ((data & 0xff00) | (data & 0xff)) << 16;
+   value |= ((data & 0xff0000) | (data & 0xff000000)) >> 16;
+   return value;
+}
+
+/*
+ * bfd_getm32_ac - To retrieve the upper 8-bits of the ARCompact
+ *                 16-bit instruction
+ */
+static bfd_vma
+bfd_getm32_ac (data)
+     unsigned int data;
+{
+   bfd_vma value = 0;
+
+   value = ((data & 0xff) << 8 | (data & 0xff00) >> 8);
+   return value;
+}
+
+/*
+ * sign_extend - Sign Extend the value
+ *
+ */
+static int
+sign_extend (int value, int bits)
+{
+  if (BIT(value, (bits-1)))
+    value |= (0xffffffff << bits);
+  return value;
+}
+
+/* dsmOneArcInst - This module is used to identify the instruction
+ *		   and to decode them based on the ARCtangent-A5
+ *                 instruction set architecture.
+ *                 First, the major opcode is computed. Based on the
+ *		   major opcode and sub opcode, the instruction is
+ * 		   identified. The appropriate decoding class is assigned
+ *		   based on the instruction.Further subopcode 2 is used in
+ *                 cases where decoding upto subopcode1 is not possible.
+ *
+ *		   The instruction is then decoded accordingly.
+ */
+static int
+dsmOneArcInst (bfd_vma addr, struct arcDisState *state, disassemble_info * info)
+{
+
+  int subopcode, mul;
+  int condCodeIsPartOfName=0;
+  int decodingClass;
+  const char *instrName;
+  int fieldAisReg=1, fieldBisReg=1, fieldCisReg=1;
+  int fieldA=0, fieldB=0, fieldC=0;
+  int flag=0, cond=0, is_shimm=0, is_limm=0;
+  long limm_value=0;
+  int signExtend=0, addrWriteBack=0, directMem=0;
+  int is_linked=0;
+  int offset=0;
+  int usesAuxReg = 0;
+  int usesSimdRegA= 0, usesSimdRegB=0, usesSimdRegC=0,simd_scale_u8=-1;
+  int flags = !E_ARC_MACH_A4;
+  char formatString[60];
+
+  state->nullifyMode = BR_exec_when_no_jump;
+  state->isBranch = 0;
+
+  state->_mem_load = 0;
+  state->_ea_present = 0;
+  state->_load_len = 0;
+  state->ea_reg1 = no_reg;
+  state->ea_reg2 = no_reg;
+  state->_offset = 0;
+  state->_addrWriteBack = 0;
+
+  state->instructionLen = info->bytes_per_line;
+
+  /* ARCtangent-A5 basecase instruction and little-endian mode */
+  if ((info->endian == BFD_ENDIAN_LITTLE) && (state->instructionLen == 4))
+    state->words[0] = bfd_getm32(state->words[0]);
+
+  if (state->instructionLen == 4)
+  {
+    if (!NEXT_WORD(0))
+      return 0;
+    /* Get the major opcode of the ARCtangent-A5 32-bit instruction. */
+    state->_opcode = OPCODE(state->words[0]);
+  }
+  else
+  {
+    /* ARCompact 16-bit instruction */
+    if (!NEXT_WORD_AC(0))
+      return 0;
+    /* Get the major opcode of the ARCompact 16-bit instruction. */
+    state->_opcode = OPCODE_AC(state->words[0]);
+  }
+
+  instrName = 0;
+  decodingClass = 0; /* default! */
+  mul = 0;
+  condCodeIsPartOfName=0;
+  state->commNum = 0;
+  state->tcnt = 0;
+  state->acnt = 0;
+  state->flow = noflow;
+
+  if (state->commentBuffer)
+    state->commentBuffer[0] = '\0';
+
+  /* Find the match for the opcode. Once the major opcode category is
+   * identified, get the subopcode to determine the exact instruction.
+   * Based on the instruction identified, select the decoding class.
+   * If condition code is part of the instruction name, then set the
+   * flag 'condCodeIsPartOfName'.
+   * For branch, jump instructions set 'isBranch' (state->isBranch).
+   */
+
+  switch (state->_opcode)
+    {
+    case op_BC:
+    /* Branch Conditionally */
+      instrName = "b";
+      decodingClass = 13;
+      condCodeIsPartOfName = 1;
+      state->isBranch = 1;
+      break;
+
+    case op_BLC:
+    /* Branch and Link, Compare and Branch  */
+      decodingClass = 9;
+      state->isBranch = 1;
+      switch (BITS(state->words[0],16,16))
+      {
+	case 0:
+	  if (!instrName)
+	    instrName = "bl";
+	  decodingClass = 13;
+      	  condCodeIsPartOfName = 1;
+	  break;
+	case 1:
+	  switch (BITS(state->words[0],0,3))
+	  {
+	    case 0: instrName = "breq"; break;
+	    case 1: instrName = "brne"; break;
+	    case 2: instrName = "brlt"; break;
+	    case 3: instrName = "brge"; break;
+	    case 4: instrName = "brlo"; break;
+	    case 5: instrName = "brhs"; break;
+	    case 14: instrName = "bbit0"; break;
+	    case 15: instrName = "bbit1"; break;
+	    default:
+	      instrName = "??? (0[3])";
+	      state->flow = invalid_instr;
+	      break;
+	  }
+	  break;
+	default:
+	  instrName = "??? (0[3])";
+	  state->flow = invalid_instr;
+	  break;
+      }
+      break;
+
+    case op_LD:
+    /* Load register with offset [major opcode 2]  */
+      decodingClass = 6;
+      switch (BITS(state->words[0],7,8))
+      {
+	case 0: instrName  = "ld";  state->_load_len = 4; break;
+	case 1: instrName  = "ldb"; state->_load_len = 1; break;
+	case 2: instrName  = "ldw"; state->_load_len = 2; break;
+	default:
+	  instrName = "??? (0[3])";
+	  state->flow = invalid_instr;
+	  break;
+      }
+      break;
+
+    case op_ST:
+    /* Store register with offset [major opcode 0x03] */
+      decodingClass = 7;
+      switch (BITS(state->words[0],1,2))
+      {
+	case 0: instrName = "st";  break;
+	case 1: instrName = "stb"; break;
+  	case 2: instrName = "stw"; break;
+	default:
+	  instrName = "??? (2[3])";
+	  state->flow = invalid_instr;
+	  break;
+      }
+      break;
+
+    case op_MAJOR_4:
+    /* ARC 32-bit basecase instructions with 3 Operands */
+      decodingClass = 0;  /* Default for 3 operand instructions */
+      subopcode = BITS(state->words[0],16,21);
+      switch (subopcode)
+        {
+	case 0: instrName = "add";  break;
+	case 1: instrName = "adc";  break;
+	case 2: instrName = "sub";  break;
+	case 3: instrName = "sbc";  break;
+	case 4: instrName = "and";  break;
+	case 5: instrName = "or";   break;
+	case 6: instrName = "bic";  break;
+	case 7: instrName = "xor";  break;
+	case 8: instrName = "max";  break;
+	case 9: instrName = "min";  break;
+	case 10:
+	  {
+	    if(state->words[0] == 0x264a7000)
+	      {
+		instrName = "nop";
+		decodingClass = 26;
+	      }
+	    else
+	      {
+		instrName = "mov";
+		decodingClass = 12;
+	      }
+	    break;
+	  }
+	case 11: instrName = "tst"; decodingClass = 2; break;
+	case 12: instrName = "cmp"; decodingClass = 2; break;
+	case 13: instrName = "rcmp"; decodingClass = 2; break;
+	case 14: instrName = "rsub"; break;
+	case 15: instrName = "bset"; break;
+	case 16: instrName = "bclr"; break;
+	case 17: instrName = "btst"; decodingClass = 2; break;
+	case 18: instrName = "bxor"; break;
+	case 19: instrName = "bmsk"; break;
+	case 20: instrName = "add1"; break;
+	case 21: instrName = "add2"; break;
+	case 22: instrName = "add3"; break;
+	case 23: instrName = "sub1"; break;
+	case 24: instrName = "sub2"; break;
+	case 25: instrName = "sub3"; break;
+	case 26: instrName = "mpylo"; break;
+	case 27: instrName = "mpyhi"; break;
+	case 28: instrName = "mpyhiu";break;
+	case 29: instrName = "mpylou";break;
+        case 32:
+        case 33:
+	  instrName = "j";
+        case 34:
+        case 35:
+	  if (!instrName) instrName = "jl";
+	  decodingClass = 4;
+	  condCodeIsPartOfName = 1;
+          state->isBranch = 1;
+	  break;
+        case 40:
+	  instrName = "lp";
+	  decodingClass = 11;
+	  condCodeIsPartOfName = 1;
+          state->isBranch = 1;
+	  break;
+        case 41: instrName = "flag"; decodingClass = 3; break;
+        case 42: instrName = "lr"; decodingClass = 10;  break;
+        case 43: instrName = "sr"; decodingClass =  8;  break;
+        case 47:
+	  decodingClass = 1;
+          switch (BITS(state->words[0],0,5)) /* Checking based on Subopcode2 */
+	  {
+	  case 0: instrName = "asl";  break;
+	  case 1: instrName = "asr";  break;
+	  case 2: instrName = "lsr";  break;
+	  case 3: instrName = "ror";  break;
+	  case 4: instrName = "rrc";  break;
+	  case 5: instrName = "sexb"; break;
+	  case 6: instrName = "sexw"; break;
+	  case 7: instrName = "extb"; break;
+	  case 8: instrName = "extw"; break;
+	  case 9: instrName = "abs";  break;
+	  case 10: instrName = "not"; break;
+	  case 11: instrName = "rlc"; break;
+	  case 12:  instrName = "ex";
+
+
+	    decodingClass = 34;
+	    break; // ramana adds
+
+	  case 63:
+	    decodingClass = 26;
+	    switch (BITS(state->words[0],24,26))
+	      {
+	      case 1 : instrName = "sleep"; decodingClass = 32; break;
+	      case 2 :
+		if((info->mach) == ARC_MACH_ARC7)
+		  instrName = "trap0";
+		else
+		  instrName = "swi";
+		break;
+	      case 3:
+
+		if(BITS(state->words[0],22,23) == 1)
+		  instrName = "sync" ;
+
+		break;
+	      case 4 : instrName = "rtie" ; break;
+	      case 5 : instrName = "brk"; break;
+	      default:
+
+		instrName = "???";
+		state->flow=invalid_instr;
+		break;
+	      }
+	    break;
+	  }
+	  break;
+      }
+
+      if (!instrName)
+      {
+        subopcode = BITS(state->words[0],17,21);
+	decodingClass = 5;
+	switch (subopcode)
+    	{
+	  case 24: instrName  = "ld";   state->_load_len = 4; break;
+	  case 25: instrName  = "ldb";  state->_load_len = 1; break;
+	  case 26: instrName  = "ldw";  state->_load_len = 2; break;
+	  default:
+	    instrName = "??? (0[3])";
+	    state->flow = invalid_instr;
+	    break;
+	}
+      }
+      break;
+
+    case op_MAJOR_5:
+    /* ARC 32-bit extension instructions */
+      decodingClass = 0;  /* Default for Major opcode 5 ... */
+      subopcode = BITS(state->words[0],16,21);
+      switch (subopcode)
+      {
+	case 0: instrName = "asl"; break;
+	case 1: instrName = "lsr"; break;
+	case 2: instrName = "asr"; break;
+	case 3: instrName = "ror"; break;
+	case 4: instrName = "mul64"; mul =1; decodingClass = 2; break;
+	case 5: instrName = "mulu64"; mul =1; decodingClass = 2; break;
+
+	  /* ARC A700 */
+      case 6: instrName = "adds" ;break;
+
+      case 7: instrName = "subs"; break;
+      case 8: instrName = "divaw"; break;
+      case 0xA: instrName = "asls"; break;
+      case 0xB: instrName = "asrs"; break;
+      case 0x28: instrName = "addsdw";break;
+      case 0x29: instrName = "subsdw"; break;
+
+      case 47:
+	switch(BITS(state->words[0],0,5))
+	  {
+	  case 0: instrName = "swap"; decodingClass = 1; break;
+	  case 1: instrName = "norm"; decodingClass = 1; break;
+	    /* ARC A700 DSP Extensions */
+	  case 2: instrName = "sat16"; decodingClass = 1; break;
+	  case 3: instrName = "rnd16"; decodingClass = 1; break;
+	  case 4: instrName = "abssw"; decodingClass = 1; break;
+	  case 5: instrName = "abss"; decodingClass = 1; break;
+	  case 6: instrName = "negsw"; decodingClass = 1; break;
+	  case 7: instrName = "negs"; decodingClass = 1; break;
+
+
+	  case 8: instrName = "normw"; decodingClass = 1; break;
+	  default:
+	    instrName = "???";
+	    state->flow =invalid_instr;
+	    break;
+
+	  }
+	break;
+      default:
+	instrName = "??? (2[3])";
+	state->flow = invalid_instr;
+	break;
+      }
+    break;
+
+
+    /* Aurora SIMD instruction support*/
+  case op_SIMD:
+
+    if (enable_simd)
+      {
+	decodingClass = 42;
+	subopcode     = BITS(state->words[0], 17, 23);
+
+	switch (subopcode)
+	  {
+
+	  case 68:
+	    instrName = "vld32";
+	    decodingClass = 37;
+	    usesSimdRegA=1;
+	    usesSimdRegB=2;
+	    usesSimdRegC=0;
+	    simd_scale_u8 = 2;
+	    break;
+
+	  case 72:
+	    instrName = "vld64";
+	    decodingClass = 37;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = 2;
+	    usesSimdRegC  = 0;
+	    simd_scale_u8 = 3;
+	    break;
+
+	  case 74:
+	    instrName = "vld64w";
+	    decodingClass = 37;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = 2;
+	    usesSimdRegC  = 0;
+	    simd_scale_u8 = 3;
+	    break;
+
+	  case 70:
+	    instrName = "vld32wl";
+	    decodingClass = 37;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = 2;
+	    usesSimdRegC  = 0;
+	    simd_scale_u8 = 2;
+	    break;
+
+	  case 66:
+	    instrName = "vld32wh";
+	    decodingClass = 37;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = 2;
+	    usesSimdRegC  = 0;
+	    simd_scale_u8 = 2;
+	    break;
+
+	  case 76:
+	    instrName = "vld128";
+	    decodingClass = 37;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = 2;
+	    usesSimdRegC  = 0;
+	    simd_scale_u8 = 4;
+	    break;
+
+	  case 78:
+	    {
+	      short  sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vld128r";
+		  decodingClass = 38;
+		  usesSimdRegA  = 1;
+		  usesSimdRegB  = usesSimdRegC = 0;
+		  break;
+		default:
+		  instrName = "SIMD";
+		  state->flow = invalid_instr;
+		}
+	    }
+	    break;
+	  case 71:
+	    instrName = "vst16_0";
+	    decodingClass = 37;
+	    usesSimdRegA = 1;
+	    usesSimdRegB = 2;
+	    usesSimdRegC = 0;
+	    simd_scale_u8 = 1;
+	    break;
+
+	  case 81:
+	    instrName = "vst16_1";
+	    decodingClass = 37;
+	    usesSimdRegA = 1;
+	    usesSimdRegB = 2;
+	    usesSimdRegC = 0;
+	    simd_scale_u8 = 1;
+	    break;
+
+	  case 67:
+	    instrName = "vst16_2";
+	    decodingClass = 37;
+	    usesSimdRegA = 1;
+	    usesSimdRegB = 2;
+	    usesSimdRegC = 0;
+	    simd_scale_u8 = 1;
+	    break;
+
+	  case 75:
+	    instrName = "vst16_3";
+	    decodingClass = 37;
+	    usesSimdRegA = 1;
+	    usesSimdRegB = 2;
+	    usesSimdRegC = 0;
+	    simd_scale_u8 = 1;
+	    break;
+
+	  case 83:
+	    instrName = "vst16_4";
+	    decodingClass = 37;
+	    usesSimdRegA = 1;
+	    usesSimdRegB = 2;
+	    usesSimdRegC = 0;
+	    simd_scale_u8 = 1;
+	    break;
+
+	  case 89:
+	    instrName = "vst16_5";
+	    decodingClass = 37;
+	    usesSimdRegA = 1;
+	    usesSimdRegB = 2;
+	    usesSimdRegC = 0;
+	    simd_scale_u8 = 1;
+	    break;
+
+	  case 91:
+	    instrName = "vst16_6";
+	    decodingClass = 37;
+	    usesSimdRegA = 1;
+	    usesSimdRegB = 2;
+	    usesSimdRegC = 0;
+	    simd_scale_u8 = 1;
+	    break;
+
+	  case 93:
+	    instrName = "vst16_7";
+	    decodingClass = 37;
+	    usesSimdRegA = 1;
+	    usesSimdRegB = 2;
+	    usesSimdRegC = 0;
+	    simd_scale_u8 = 1;
+	    break;
+
+	  case 69:
+	    instrName = "vst32_0";
+	    decodingClass = 37;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = 2;
+	    usesSimdRegC  = 0;
+	    simd_scale_u8 = 2;
+	    break;
+
+	  case 82:
+	    instrName = "vst32_2";
+	    decodingClass = 37;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = 2;
+	    usesSimdRegC  = 0;
+	    simd_scale_u8 = 2;
+	    break;
+
+	  case 86:
+	    instrName = "vst32_4";
+	    decodingClass = 37;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = 2;
+	    usesSimdRegC  = 0;
+	    simd_scale_u8 = 2;
+	    break;
+
+	  case 88:
+	    instrName = "vst32_6";
+	    decodingClass = 37;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = 2;
+	    usesSimdRegC  = 0;
+	    simd_scale_u8 = 2;
+	    break;
+
+	  case 73:
+	    instrName = "vst64";
+	    decodingClass = 37 ;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = 2;
+	    usesSimdRegC  = 0;
+	    simd_scale_u8 = 3;
+	    break;
+
+	  case 77:
+	    instrName = "vst128";
+	    decodingClass = 37;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = 2;
+	    usesSimdRegC  = 0;
+	    simd_scale_u8 = 4;
+	    break;
+
+	  case 79:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vst128r";
+		  decodingClass = 38;
+		  usesSimdRegA = 1;
+		  usesSimdRegB = usesSimdRegC = 0;
+		  break;
+
+		default:
+		  instrName = "SIMD";
+		  state->flow = invalid_instr;
+		}
+
+	    }
+	    break;
+	  case 80:
+	    instrName = "vmvw";
+	    usesSimdRegA = usesSimdRegB = 1;
+	    usesSimdRegC = 0;
+	    decodingClass = 39;
+	    break;
+
+	  case 84:
+	    instrName = "vmvzw";
+	    decodingClass = 39;
+	    usesSimdRegA = usesSimdRegB = 1;
+	    usesSimdRegC = 0;
+	    break;
+
+	  case 90:
+	    instrName = "vmovw";
+	    decodingClass = 39;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = usesSimdRegC = 0;
+	    break;
+
+	  case 94:
+	    instrName = "vmovzw";
+	    decodingClass = 39;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = usesSimdRegC = 0;
+	    break;
+
+	  case 85:
+	    instrName = "vmvaw";
+	    decodingClass = 39;
+	    usesSimdRegA  = usesSimdRegB = 1;
+	    usesSimdRegC  = 0;
+	    break;
+
+	  case 95:
+	    instrName = "vmovaw";
+	    decodingClass = 39;
+	    usesSimdRegA  = 1;
+	    usesSimdRegB  = usesSimdRegC = 0;
+	    break;
+
+	  case 10:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vaddw"; decodingClass = 42;
+		  usesSimdRegA = usesSimdRegB = usesSimdRegC =1;
+		  break;
+
+		case 1:
+		  instrName = "vaddaw"; decodingClass = 42;
+		  usesSimdRegA = usesSimdRegB = usesSimdRegC =1;
+		  break;
+
+		case 2:
+		  instrName = "vbaddw"; decodingClass = 42;
+		  usesSimdRegA = usesSimdRegB = 1;
+		  usesSimdRegC = 0;
+		  break;
+		}
+	      break;
+	    }
+
+	  case 11:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vsubw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+		  break;
+
+		case 1:
+		  instrName = "vsubaw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+		  break;
+
+		case 2:
+		  instrName = "vbsubw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 0;
+		  break;
+		}
+	    }
+	    break;
+
+	  case 12:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vmulw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+		  break;
+
+		case 1:
+		  instrName = "vmulaw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+		  break;
+
+		case 2:
+		  instrName = "vbmulw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 0;
+		  break;
+
+		case 3:
+		  instrName = "vbmulaw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 0;
+		  break;
+		}
+	    }
+	    break;
+
+	  case 13:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vmulfw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+		  break;
+
+		case 1:
+		  instrName = "vmulfaw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+		  break;
+
+		case 2:
+		  instrName = "vbmulfw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 0;
+		  break;
+		}
+	    }
+	    break;
+
+	  case 15:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vsummw";
+		  decodingClass = 42;
+		  usesSimdRegA = usesSimdRegB = usesSimdRegC = 1;
+		  break;
+		case 2:
+		  instrName = "vbrsubw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 0;
+		  break;
+		}
+	    }
+	    break;
+
+	  case 23:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vmr7w";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+		  break;
+
+		case 1:
+		  instrName = "vmr7aw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+		  break;
+
+
+		case 2:
+		  switch (BITS(state->words[0], 0, 5))
+		    {
+		    case 0:
+		      instrName = "vaddsuw";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = 1;
+		      usesSimdRegA  = 0;
+		      break;
+
+		    case 1:
+		      instrName = "vabsw";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = 1;
+		      usesSimdRegA  = 0;
+		      break;
+
+		    case 2:
+		      instrName = "vsignw";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = 1;
+		      usesSimdRegA  = 0;
+		      break;
+
+		    case 3:
+		      instrName = "vupbw";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = 1;
+		      usesSimdRegA  = 0;
+		      break;
+
+		    case 4:
+		      instrName = "vexch1";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = 1;
+		      usesSimdRegA  = 0;
+		      break;
+
+		    case 5:
+		      instrName = "vexch2";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = 1;
+		      usesSimdRegA  = 0;
+		      break;
+
+		    case 6:
+		      instrName = "vexch4";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = 1;
+		      usesSimdRegA  = 0;
+		      break;
+
+		    case 7:
+		      instrName = "vupsbw";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = 1;
+		      usesSimdRegA  = 0;
+		      break;
+
+		    case 8:
+		      instrName = "vdirun";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = usesSimdRegA = 0;
+		      break;
+
+		    case 9:
+		      instrName = "vdorun";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = usesSimdRegA = 0;
+		      break;
+
+		    case 10:
+		      instrName = "vdiwr";
+		      decodingClass = 40;
+		      usesSimdRegB  = 3;
+		      usesSimdRegA  = usesSimdRegC = 0;
+		      fieldCisReg   = 1;
+		      break;
+
+		    case 11:
+		      instrName = "vdowr";
+		      decodingClass = 40;
+		      usesSimdRegB  = 3;
+		      usesSimdRegA  = usesSimdRegC = 0;
+		      fieldCisReg   = 1;
+		      break;
+
+		    case 12:
+		      instrName = "vdird";
+		      decodingClass = 40;
+		      usesSimdRegB  = 1;
+		      usesSimdRegC  = 3;
+		      usesSimdRegA  = 0;
+		      break;
+
+		    case 13:
+		      instrName = "vdord";
+		      decodingClass = 40;
+		      usesSimdRegB  = 1;
+		      usesSimdRegC  = 3;
+		      usesSimdRegA  = 0;
+		      break;
+
+		    case 63:
+		      {
+			switch (BITS(state->words[0], 24, 25))
+			  {
+			  case 0:
+			    instrName = "vrec";
+			    decodingClass = 43;
+			    usesSimdRegC  = 0;
+			    usesSimdRegB  = usesSimdRegA = 0;
+			    break;
+
+			  case 1:
+			    instrName = "vrecrun";
+			    decodingClass = 43;
+			    usesSimdRegC  = 0;
+			    usesSimdRegA  = usesSimdRegB = 0;
+			    break;
+
+			  case 2:
+			    instrName = "vrun";
+			    decodingClass = 43;
+			    usesSimdRegC  = 0;
+			    usesSimdRegB  = usesSimdRegA = 0;
+			    break;
+
+			  case 3:
+			    instrName = "vendrec";
+			    decodingClass = 43;
+			    usesSimdRegC  = 0;
+			    usesSimdRegB  = usesSimdRegA = 0;
+			    break;
+			  }
+		      }
+		      break;
+		    }
+		  break;
+
+		case 3:
+		  switch (BITS(state->words[0], 0, 2))
+		    {
+		    case 1:
+		      instrName = "vabsaw";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = 1;
+		      usesSimdRegA  = 0;
+		      break;
+		    case 3:
+		      instrName = "vupbaw";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = 1;
+		      usesSimdRegA  = 0;
+		      break;
+		    case 7:
+		      instrName = "vupsbaw";
+		      decodingClass = 40;
+		      usesSimdRegC  = usesSimdRegB = 1;
+		      usesSimdRegA  = 0;
+		      break;
+		    }
+		  break;
+		}
+	    }
+	    break;
+
+	  case 16:
+	    instrName = "vasrw";
+	    decodingClass = 42;
+	    usesSimdRegA  = usesSimdRegB = 1;
+	    usesSimdRegC  = 2;
+	    break;
+
+	  case 48:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vasrwi";
+		  decodingClass = 41;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 0;
+		  break;
+		case 2:
+		  instrName = "vasrrwi";
+		  decodingClass = 41;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 0;
+		  break;
+		}
+	    }
+	    break;
+
+	  case 59:
+	    instrName = "vasrsrwi";
+	    decodingClass = 41;
+	    usesSimdRegA  = usesSimdRegB = 1;
+	    usesSimdRegC  = 0;
+	    break;
+
+	  case 18:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vmaxw";
+		  usesSimdRegC = 1;
+		  break;
+		case 1:
+		  instrName = "vmaxaw";
+		  usesSimdRegC = 1;
+		  break;
+		case 2:
+		  instrName = "vbmaxw";
+		  usesSimdRegC = 0;
+		  break;
+		}
+	      decodingClass = 42;
+	      usesSimdRegA  = usesSimdRegB = 1;
+	      break;
+	    }
+
+	  case 19:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vminw";
+		  usesSimdRegC = 1;
+		  break;
+		case 1:
+		  instrName = "vminaw";
+		  usesSimdRegC = 0;
+		  break;
+		case 2:
+		  instrName = "vbminw";
+		  usesSimdRegC = 0;
+		  break;
+		}
+	      decodingClass = 42;
+	      usesSimdRegA  = usesSimdRegB = 1;
+	      break;
+	    }
+
+	  case 14:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vdifw";
+		  break;
+		case 1:
+		  instrName = "vdifaw";
+		  break;
+		case 2:
+		  instrName = "vmrb";
+		  break;
+		}
+	      decodingClass = 42;
+	      usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+	      break;
+	    }
+
+	  case 24:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vand";
+		  decodingClass = 42;
+		  usesSimdRegA = usesSimdRegB = usesSimdRegC = 1;
+		  break;
+		case 1:
+		  instrName = "vandaw";
+		  decodingClass = 42;
+		  usesSimdRegA = usesSimdRegB = usesSimdRegC = 1;
+		  break;
+		}
+	      break;
+	    }
+
+	  case 25:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vor";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+		  break;
+		}
+	      break;
+	    }
+
+	  case 26:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vxor";
+		  break;
+		case 1:
+		  instrName = "vxoraw";
+		  break;
+		}
+	      decodingClass = 42;
+	      usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+	      break;
+	    }
+
+	  case 27:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vbic";
+		  break;
+		case 1:
+		  instrName = "vbicaw";
+		  break;
+		}
+	      decodingClass = 42;
+	      usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+	      break;
+	    }
+
+	  case 4:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vavb";
+		  break;
+		case 2:
+		  instrName = "vavrb";
+		  break;
+		}
+	      decodingClass = 42;
+	      usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+	      break;
+	    }
+
+	  case 28:
+	    instrName = "veqw";
+	    decodingClass = 42;
+	    usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+	    break;
+
+	  case 29:
+	    instrName = "vnew";
+	    decodingClass = 42;
+	    usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+	    break;
+
+	  case 30:
+	    instrName = "vlew";
+	    decodingClass = 42;
+	    usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+	    break;
+
+	  case 31:
+	    instrName = "vltw";
+	    decodingClass = 42;
+	    usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+	    break;
+
+	  case 49:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vasrpwbi";
+		  decodingClass = 41;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 0;
+		  break;
+		case 2:
+		  instrName = "vasrrpwbi";
+		  decodingClass = 41;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 0;
+		  break;
+		}
+	      break;
+	    }
+
+	  case 5:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vsr8";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 2;
+		  break;
+
+		case 1:
+		  instrName = "vsr8aw";
+		  decodingClass = 42;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 2;
+		  break;
+		}
+	      break;
+	    }
+
+	  case 37:
+	    {
+	      short sub_subopcode = BITS(state->words[0], 15, 16);
+	      switch (sub_subopcode)
+		{
+		case 0:
+		  instrName = "vsr8i";
+		  decodingClass = 41;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 0;
+		  break;
+
+		case 1:
+		  instrName = "vsr8awi";
+		  decodingClass = 41;
+		  usesSimdRegA  = usesSimdRegB = 1;
+		  usesSimdRegC  = 0;
+		  break;
+		}
+	      break;
+	    }
+
+	  case 20:
+	  case 21:
+	  case 22:
+	    {
+	      short subopcode2 = BITS(state->words[0], 15, 18);
+	      switch (subopcode2)
+		{
+		case 0:
+		  instrName = "vmr1w";
+		  break;
+
+		case 2:
+		  instrName = "vmr2w";
+		  break;
+
+		case 4:
+		  instrName = "vmr3w";
+		  break;
+
+		case 6:
+		  instrName = "vmr4w";
+		  break;
+
+		case 8:
+		  instrName = "vmr5w";
+		  break;
+
+		case 10:
+		  instrName = "vmr6w";
+		  break;
+
+		case 1:
+		  instrName = "vmr1aw";
+		  break;
+
+		case 3:
+		  instrName = "vmr2aw";
+		  break;
+
+		case 5:
+		  instrName = "vmr3aw";
+		  break;
+
+		case 7:
+		  instrName = "vmr4aw";
+		  break;
+
+		case 9:
+		  instrName = "vmr5aw";
+		  break;
+
+		case 11:
+		  instrName = "vmr6aw";
+		  break;
+
+		}
+
+	      decodingClass = 42;
+	      usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+	      break;
+	    }
+
+
+	  case 7:
+	  case 6:
+	    {
+	      switch (BITS(state->words[0], 16, 19))
+		{
+		case 15:
+		  instrName = "vh264ft";
+		  break;
+		case 14:
+		  instrName = "vh264f";
+		  break;
+		case 13:
+		  instrName = "vvc1ft";
+		  break;
+		case 12:
+		  instrName = "vvc1f";
+		  break;
+		}
+	      decodingClass = 42;
+	      usesSimdRegA  = usesSimdRegB = usesSimdRegC = 1;
+	      break;
+
+	    }
+
+	  case 92:
+	    instrName = "vd6tapf";
+	    decodingClass = 39;
+	    usesSimdRegA  = usesSimdRegB = 1;
+	    usesSimdRegC  = 0;
+	    break;
+
+	  case 55:
+	    instrName = "vinti";
+	    decodingClass = 43;
+	    usesSimdRegA  = usesSimdRegB = usesSimdRegC = 0;
+	    break;
+
+	  default:
+	    instrName = "SIMD";
+	    state->flow = invalid_instr;
+	    break;
+	  }
+      }
+    else
+      {
+	instrName = "???_SIMD";
+	state->flow = invalid_instr;
+      }
+	break;
+
+
+    case op_LD_ADD:
+    /* Load/Add resister-register */
+      decodingClass = 15;  /* default for Major opcode 12 ... */
+      switch(BITS(state->words[0],3,4))
+	{
+	case 0: instrName = "ld_s"; break;
+	case 1: instrName = "ldb_s"; break;
+	case 2: instrName = "ldw_s"; break;
+	case 3: instrName = "add_s"; break;
+        default:
+	  instrName = "??? (2[3])";
+	  state->flow = invalid_instr;
+	  break;
+	}
+      break;
+
+  case op_ADD_SUB_SHIFT:
+    /* Add/sub/shift immediate */
+    decodingClass = 16;  /* default for Major opcode 13 ... */
+    switch(BITS(state->words[0],3,4))
+      {
+      case 0: instrName = "add_s"; break;
+      case 1: instrName = "sub_s"; break;
+      case 2: instrName = "asl_s"; break;
+      case 3: instrName = "asr_s"; break;
+      default:
+	instrName = "??? (2[3])";
+	state->flow = invalid_instr;
+	break;
+      }
+    break;
+
+    case op_ADD_MOV_CMP:
+    /* One Dest/Source can be any of r0 - r63 */
+      decodingClass = 17;  /* default for Major opcode 14 ... */
+      switch(BITS(state->words[0],3,4))
+      {
+	case 0: instrName = "add_s"; break;
+	case 1:
+	case 3: instrName = "mov_s"; decodingClass = 18; break;
+	case 2: instrName = "cmp_s"; decodingClass = 18; break;
+        default:
+	  instrName = "??? (2[3])";
+	  state->flow = invalid_instr;
+	  break;
+      }
+      break;
+
+    case op_S:
+    /* ARCompact 16-bit instructions, General ops/ single ops */
+      decodingClass = 22;  /* default for Major opcode 15 ... */
+      switch(BITS(state->words[0],0,4))
+      {
+	case 0:
+	  decodingClass = 27;
+          switch(BITS(state->words[0],5,7))
+	  {
+            case 0 : instrName = "j_s";
+            case 2 : if (!instrName) instrName = "jl_s";
+	             state->isBranch = 1;
+		     state->nullifyMode = BR_exec_when_no_jump;
+		     break;
+            case 1 : if (!instrName) instrName = "j_s.d";
+            case 3 : if (!instrName) instrName = "jl_s.d";
+          	     state->isBranch = 1;
+		     state->nullifyMode = BR_exec_always;
+		     break;
+            case 6 : instrName = "sub_s.ne";
+	             decodingClass = 35;
+	             break;
+            case 7 :
+	      decodingClass = 26;
+              switch(BITS(state->words[0],8,10))
+	      {
+              	case 0 : instrName = "nop_s"; break;
+
+		  /* Unimplemented instruction reserved in ARC700 */
+	        case 1: instrName = "unimp_s";break;
+
+
+	        case 4: instrName = "jeq_s [blink]";
+		case 5: if (!instrName) instrName = "jne_s [blink]";
+		case 6:
+		  if (!instrName)
+		    instrName = "j_s [blink]";
+		  state->isBranch = 1;
+		  state->nullifyMode = BR_exec_when_no_jump;
+		  break;
+		case 7:
+		  if (!instrName)
+		    {
+		      instrName = "j_s.d [blink]";
+		      state->flow = indirect_jump;
+		      state->register_for_indirect_jump = 31; /* blink is r31 */
+		    }
+		  state->isBranch = 1;
+		  state->nullifyMode = BR_exec_always;
+		  break;
+                default:
+		  instrName = "??? (2[3])";
+	      	  state->flow = invalid_instr;
+		  break;
+	      }
+	      break;
+            default:
+	      instrName = "??? (2[3])";
+	      state->flow = invalid_instr;
+	      break;
+	  }
+	  break;
+        case 2 : instrName = "sub_s"; break;
+        case 4 : instrName = "and_s"; break;
+        case 5 : instrName = "or_s"; break;
+        case 6 : instrName = "bic_s"; break;
+        case 7 : instrName = "xor_s"; break;
+	case 11: instrName = "tst_s"; decodingClass = 14; break;
+	case 12: instrName = "mul64_s"; mul =1; decodingClass = 14; break;
+	case 13: instrName = "sexb_s"; decodingClass = 14; break;
+	case 14: instrName = "sexw_s"; decodingClass = 14; break;
+	case 15: instrName = "extb_s"; decodingClass = 14; break;
+	case 16: instrName = "extw_s"; decodingClass = 14; break;
+	case 17: instrName = "abs_s"; decodingClass = 14; break;
+	case 18: instrName = "not_s"; decodingClass = 14; break;
+	case 19: instrName = "neg_s"; decodingClass = 14; break;
+        case 20: instrName = "add1_s"; break;
+        case 21: instrName = "add2_s"; break;
+        case 22: instrName = "add3_s"; break;
+        case 24: instrName = "asl_s"; break;
+        case 25: instrName = "lsr_s"; break;
+        case 26: instrName = "asr_s"; break;
+        case 27: instrName = "asl_s"; decodingClass = 14; break;
+        case 28: instrName = "asr_s"; decodingClass = 14; break;
+        case 29: instrName = "lsr_s"; decodingClass = 14; break;
+      case 30: instrName = "trap_s"; decodingClass = 33; break;
+      case 31: instrName = "brk_s"; decodingClass = 26; break;
+
+        default:
+	  instrName = "??? (2[3])";
+	  state->flow = invalid_instr;
+	  break;
+      }
+      break;
+
+       case op_LD_S:
+    /* ARCompact 16-bit Load with offset, Major Opcode 0x10 */
+      instrName = "ld_s";
+      decodingClass = 28;
+      break;
+
+    case op_LDB_S:
+    /* ARCompact 16-bit Load with offset, Major Opcode 0x11 */
+      instrName = "ldb_s";
+      decodingClass = 28;
+      break;
+
+    case op_LDW_S:
+    /* ARCompact 16-bit Load with offset, Major Opcode 0x12 */
+      instrName = "ldw_s";
+      decodingClass = 28;
+      break;
+
+    case op_LDWX_S:
+    /* ARCompact 16-bit Load with offset, Major Opcode 0x13 */
+      instrName = "ldw_s.x";
+      decodingClass = 28;
+      break;
+
+    case op_ST_S:
+    /* ARCompact 16-bit Store with offset, Major Opcode 0x14 */
+      instrName = "st_s";
+      decodingClass = 28;
+      break;
+
+    case op_STB_S:
+    /* ARCompact 16-bit Store with offset, Major Opcode 0x15 */
+      instrName = "stb_s";
+      decodingClass = 28;
+      break;
+
+    case op_STW_S:
+    /* ARCompact 16-bit Store with offset, Major Opcode 0x16 */
+      instrName = "stw_s";
+      decodingClass = 28;
+      break;
+
+    case op_Su5:
+    /* ARCompact 16-bit involving unsigned 5-bit immediate operand */
+      decodingClass = 23;  /* default for major opcode 0x17 ... */
+      switch (BITS(state->words[0],5,7))
+      {
+	case 0: instrName = "asl_s"; break;
+	case 1: instrName = "lsr_s"; break;
+	case 2: instrName = "asr_s"; break;
+	case 3: instrName = "sub_s"; break;
+	case 4: instrName = "bset_s"; break;
+	case 5: instrName = "bclr_s"; break;
+	case 6: instrName = "bmsk_s"; break;
+	case 7: instrName = "btst_s"; decodingClass = 21; break;
+      }
+      break;
+
+    case op_SP:
+    /* ARCompact 16-bit Stack pointer-based instructions */
+      decodingClass = 19;  /* default for Stack pointer-based insns ... */
+      switch (BITS(state->words[0],5,7))
+      {
+        case 0: instrName = "ld_s"; break;
+        case 1: instrName = "ldb_s"; break;
+        case 2: instrName = "st_s"; break;
+        case 3: instrName = "stb_s"; break;
+        case 4: instrName = "add_s"; break;
+        case 5:
+      	  if (!BITS(state->words[0],8,8))
+	    instrName = "add_s";
+	  else
+	    instrName = "sub_s";
+	  break;
+        case 6: instrName = "pop_s"; decodingClass = 31; break;
+        case 7: instrName = "push_s"; decodingClass = 31; break;
+	default:
+          instrName = "??? (2[3])";
+          state->flow = invalid_instr;
+	  break;
+      }
+    break;
+
+    case op_GP:
+    /* ARCompact 16-bit Gp-based ld/add (data aligned offset) */
+      decodingClass = 20;  /* default for gp-relative insns ... */
+      switch (BITS(state->words[0],9,10))
+      {
+        case 0: instrName = "ld_s"; break;
+        case 1: instrName = "ldb_s"; break;
+        case 2: instrName = "ldw_s"; break;
+        case 3: instrName = "add_s"; break;
+      }
+      break;
+
+    case op_Pcl:
+    /* ARCompact 16-bit Pcl-based ld (32-bit aligned offset) */
+      instrName = "ld_s";
+      decodingClass = 29;
+      break;
+
+    case op_MOV_S:
+    /* ARCompact 16-bit Move immediate */
+      instrName = "mov_s";
+      decodingClass = 30;
+      break;
+
+    case op_ADD_CMP:
+    /* ARCompact 16-bit Add/compare immediate */
+      decodingClass = 21;  /* default for major opcode 0x1c ... */
+      if (BIT(state->words[0],7))
+	instrName = "cmp_s";
+      else
+	instrName = "add_s";
+      break;
+
+    case op_BR_S:
+    /* ARCompact 16-bit Branch conditionally on reg z/nz */
+      decodingClass = 25; /* Default for BR_S instruction ... */
+      if (BIT(state->words[0],7))
+	instrName = "brne_s";
+      else
+	instrName = "breq_s";
+      state->isBranch = 1;
+      break;
+
+    case op_B_S:
+    /* ARCompact 16-bit Branch conditionally */
+      decodingClass = 24; /* Default for B_S instruction ... */
+      state->isBranch = 1;
+      switch (BITS(state->words[0],9,10))
+      {
+	case 0: instrName = "b_s"; break;
+	case 1: instrName = "beq_s"; break;
+	case 2: instrName = "bne_s"; break;
+	case 3:
+          switch (BITS(state->words[0],6,8))
+	  {
+	    case 0: instrName = "bgt_s"; break;
+	    case 1: instrName = "bge_s"; break;
+	    case 2: instrName = "blt_s"; break;
+	    case 3: instrName = "ble_s"; break;
+	    case 4: instrName = "bhi_s"; break;
+	    case 5: instrName = "bhs_s"; break;
+	    case 6: instrName = "blo_s"; break;
+	    case 7: instrName = "bls_s"; break;
+	  }
+	  break;
+      }
+      break;
+
+    case op_BL_S:
+    /* ARCompact 16-bit Branch and link unconditionally */
+      decodingClass = 24; /* Default for B_S instruction ... */
+      instrName = "bl_s";
+      state->isBranch = 1;
+      break;
+
+    default:
+      instrName = instruction_name (state, state->_opcode, 0, &flags);
+      if (!instrName)
+	{
+	  instrName = "???";
+	  state->flow=invalid_instr;
+	}
+      break;
+  }
+
+  /* Maybe we should be checking for extension instructions over here
+   * instead of all over this crazy switch case. */
+  if (state->flow == invalid_instr)
+    {
+      if (!((state->_opcode == op_SIMD) && enable_simd))
+	instrName = instruction_name(state,state->_opcode,
+				     state->words[0],
+				     &flags);
+
+      if (state->instructionLen == 2)
+	{
+	  switch (flags)
+	    {
+	    case AC_SYNTAX_3OP:
+	      decodingClass = 22;
+	      break;
+	    case AC_SYNTAX_2OP:
+	      decodingClass = 14;
+	      break;
+	    case AC_SYNTAX_1OP:
+	      decodingClass = 36;
+	      break;
+	    case AC_SYNTAX_NOP:
+	      decodingClass = 26;
+	      break;
+	    default:
+	      mwerror(state, "Invalid syntax class\n");
+	    }
+	}
+      else
+	{
+/* Must do the above for this one too */
+	  switch (flags)
+	    {
+	    case AC_SYNTAX_3OP:
+	      decodingClass = 0;
+	      break;
+	    case AC_SYNTAX_2OP:
+	      decodingClass = 1;
+	      break;
+	    case AC_SYNTAX_1OP:
+	      decodingClass = 32;
+	      break;
+	    case AC_SYNTAX_NOP:
+	      break;
+	    case AC_SYNTAX_SIMD:
+	      break;
+	    default:
+	      mwerror(state, "Invalid syntax class\n");
+	    }
+	}
+
+      if (!instrName)
+	{
+	  instrName = "???";
+	  state->flow=invalid_instr;
+	}
+    }
+
+  fieldAisReg = fieldBisReg = fieldCisReg = 1; /* assume regs for now */
+  flag = cond = is_shimm = is_limm = 0;
+  signExtend = addrWriteBack = directMem = 0;
+  usesAuxReg = 0;
+
+  /* The following module decodes the instruction */
+  switch (decodingClass)
+  {
+    case 0:
+
+      /* For ARCtangent 32-bit instructions with 3 operands */
+
+      subopcode = BITS(state->words[0],22,23);
+      switch (subopcode)
+      {
+	case 0:
+
+          /* Either fieldB or fieldC or both can be a limm value;
+	   * fieldA can be 0;
+           */
+
+          CHECK_FIELD_C();
+     	  if (!is_limm)
+	  {
+	    /* If fieldC is not a limm, then fieldB may be a limm value */
+            CHECK_FIELD_B();
+	  }
+      	  else
+	  {
+            FIELD_B();
+      	    if (!fieldBisReg)
+	      fieldB = fieldC;
+	  }
+      	  CHECK_FIELD_A();
+      	  CHECK_FLAG();
+	  break;
+
+	case 1:
+
+          /* fieldB may ba a limm value
+	   * fieldC is a shimm (unsigned 6-bit immediate)
+	   * fieldA can be 0
+           */
+
+          CHECK_FIELD_B();
+          FIELD_C();
+	  fieldCisReg = 0;
+          /* Say ea is not present, so only one of us will do the
+	     name lookup. */
+	  state->_offset += fieldB, state->_ea_present = 0;
+      	  CHECK_FIELD_A();
+      	  CHECK_FLAG();
+	  break;
+
+	case 2:
+
+          /* fieldB may ba a limm value
+	   * fieldC is a shimm (signed 12-bit immediate)
+	   * fieldA can be 0
+           */
+
+	  fieldCisReg = 0;
+          fieldC = FIELDS(state->words[0]);
+          CHECK_FIELD_B();
+          /* Say ea is not present, so only one of us will do the
+	     name lookup. */
+	  state->_offset += fieldB, state->_ea_present = 0;
+	  if (is_limm)
+	    fieldAisReg = fieldA = 0;
+	  else
+	    fieldA = fieldB;
+      	  CHECK_FLAG();
+	  break;
+
+	case 3:
+
+          /* fieldB may ba a limm value
+	   * fieldC may be a limm or a shimm (unsigned 6-bit immediate)
+	   * fieldA can be 0
+	   * Conditional instructions
+           */
+
+          CHECK_FIELD_B();
+	  /* fieldC is a shimm (unsigned 6-bit immediate) */
+	  if (is_limm)
+	  {
+	    fieldAisReg = fieldA = 0;
+            FIELD_C();
+            if (BIT(state->words[0],5))
+	      fieldCisReg = 0;
+	    else if (fieldC == 62)
+	    {
+              fieldCisReg = 0;
+	      fieldC = fieldB;
+	    }
+	  }
+	  else
+	  {
+	    fieldA = fieldB;
+            if (BIT(state->words[0],5))
+	    {
+              FIELD_C();
+              fieldCisReg = 0;
+	    }
+	    else
+	    {
+              CHECK_FIELD_C();
+	    }
+	  }
+      	  CHECK_FLAG_COND();
+	  break;
+      }
+
+      write_instr_name();
+      WRITE_FORMAT_x(A);
+      WRITE_FORMAT_COMMA_x(B);
+      WRITE_FORMAT_COMMA_x(C);
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldA, fieldB, fieldC);
+      write_comments();
+      break;
+
+    case 1:
+
+      /* For ARCtangent 32-bit instructions with 2 operands */
+
+      /* field C is either a register or limm (different!) */
+      CHECK_FIELD_C();
+      FIELD_B();
+      CHECK_FLAG();
+
+      if (BITS(state->words[0],22,23) == 1 )
+	fieldCisReg = 0;
+      if (fieldCisReg) state->ea_reg1 = fieldC;
+      /* field C is either a shimm (same as fieldC) or limm (different!) */
+      /* Say ea is not present, so only one of us will do the name lookup. */
+      else state->_offset += fieldB, state->_ea_present = 0;
+
+      write_instr_name();
+      WRITE_FORMAT_x(B);
+      WRITE_FORMAT_COMMA_x(C);
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC);
+      write_comments();
+      break;
+
+    case 2:
+
+      /* For BTST, CMP, MUL64, MULU64 instruction */
+
+      /* field C is either a register or limm (different!) */
+      subopcode =  BITS(state->words[0],22,23);
+      if (subopcode == 0 || ((subopcode == 3) && (!BIT(state->words[0],5))))
+      {
+      	CHECK_FIELD_C();
+	if (is_limm)
+	{
+	  FIELD_B();
+	  if (!fieldBisReg)
+	    fieldB = fieldC;
+	}
+	else
+	{
+      	  CHECK_FIELD_B();
+	}
+      }
+      else if (subopcode == 1 || ((subopcode == 3) && (BIT(state->words[0],5))))
+      {
+	FIELD_C();
+	fieldCisReg = 0;
+      	CHECK_FIELD_B();
+      }
+      else if (subopcode == 2)
+      {
+	FIELD_B();
+	fieldC = FIELDS(state->words[0]);
+	fieldCisReg = 0;
+      }
+      if (subopcode == 3)
+	CHECK_COND();
+
+      if (fieldCisReg) state->ea_reg1 = fieldC;
+      /* field C is either a shimm (same as fieldC) or limm (different!) */
+      /* Say ea is not present, so only one of us will do the name lookup. */
+      else state->_offset += fieldB, state->_ea_present = 0;
+
+      write_instr_name();
+      if (mul)
+      {
+	/* For Multiply instructions, the first operand is 0 */
+	WRITE_FORMAT_x(A);
+	WRITE_FORMAT_COMMA_x(B);
+        WRITE_FORMAT_COMMA_x(C);
+        WRITE_NOP_COMMENT();
+        my_sprintf(state, state->operandBuffer, formatString, 0, fieldB, fieldC);
+      }
+      else
+      {
+	WRITE_FORMAT_x(B);
+        WRITE_FORMAT_COMMA_x(C);
+        WRITE_NOP_COMMENT();
+        my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC);
+      }
+      write_comments();
+      break;
+
+    case 3:
+      /*
+       * For FLAG instruction
+       */
+      subopcode =  BITS(state->words[0],22,23);
+
+      if (subopcode == 0 || ((subopcode == 3) && (!BIT(state->words[0],5))))
+      {
+        CHECK_FIELD_C();
+      }
+      else if (subopcode == 1 || ((subopcode == 3) && (BIT(state->words[0],5))))
+      {
+        FIELD_C();
+	fieldCisReg = 0;
+      }
+      else if (subopcode == 2)
+      {
+	fieldC = FIELDS(state->words[0]);
+	fieldCisReg = 0;
+      }
+      if (subopcode == 3)
+        CHECK_COND();
+      flag = 0;  /* this is the FLAG instruction -- it's redundant */
+
+      write_instr_name();
+      WRITE_FORMAT_x(C);
+      my_sprintf(state, state->operandBuffer, formatString, fieldC);
+      write_comments();
+      break;
+
+    case 4:
+      /*
+       * For op_JC -- jump to address specified.
+       *     Also covers jump and link--bit 9 of the instr. word
+       *     selects whether linked, thus "is_linked" is set above.
+       */
+      subopcode =  BITS(state->words[0],22,23);
+      if (subopcode == 0 || ((subopcode == 3) && (!BIT(state->words[0],5))))
+      {
+        CHECK_FIELD_C();
+	/* ilink registers */
+	if (fieldC == 29 || fieldC == 31)
+      	  CHECK_FLAG();
+      }
+      else if (subopcode == 1 || ((subopcode == 3) && (BIT(state->words[0],5))))
+      {
+        FIELD_C();
+	fieldCisReg = 0;
+      }
+      else if (subopcode == 2)
+      {
+	fieldC = FIELDS(state->words[0]);
+	fieldCisReg = 0;
+      }
+
+      if (subopcode == 3)
+        CHECK_COND();
+
+      state->nullifyMode = BITS(state->words[0],16,16);
+
+      if (!fieldCisReg)
+	{
+	  state->flow = is_linked ? direct_call : direct_jump;
+	  add_target(fieldC);
+	}
+      else
+	{
+	  state->flow = is_linked ? indirect_call : indirect_jump;
+	  /*
+	   * We should also treat this as indirect call if NOT linked
+	   * but the preceding instruction was a "lr blink,[status]"
+	   * and we have a delay slot with "add blink,blink,2".
+	   * For now we can't detect such.
+	   */
+	  state->register_for_indirect_jump = fieldC;
+	}
+
+      write_instr_name();
+      strcat(formatString,
+	     IS_REG(C)?"[%r]":"%s"); /* address/label name */
+
+      if (IS_REG(C))
+	my_sprintf(state, state->operandBuffer, formatString, fieldC);
+      else
+	my_sprintf(state, state->operandBuffer, formatString,
+		   post_address(state, fieldC));
+      write_comments();
+      break;
+
+    case 5:
+      /* LD instruction.  B and C can be regs, or one or both can be limm. */
+
+      CHECK_FIELD_A();
+      CHECK_FIELD_B();
+
+      if(FIELDA(state->words[0]) == 62)
+	{
+	  instrName = "prefetch";
+	}
+
+
+
+      if (is_limm)
+      {
+        FIELD_C();
+        if (!fieldCisReg)
+          fieldC = fieldB;
+      }
+      else
+      {
+        CHECK_FIELD_C();
+      }
+      if (dbg) printf("5:b reg %d %d c reg %d %d  \n",
+		      fieldBisReg,fieldB,fieldCisReg,fieldC);
+      state->_offset = 0;
+      state->_ea_present = 1;
+      if (fieldBisReg) state->ea_reg1 = fieldB; else state->_offset += fieldB;
+      if (fieldCisReg) state->ea_reg2 = fieldC; else state->_offset += fieldC;
+      state->_mem_load = 1;
+
+      directMem     = BIT(state->words[0],15);
+      /* Check if address writeback is allowed before decoding the
+	 address writeback field of a load instruction.*/
+      if (fieldBisReg && (fieldB != 62))
+        addrWriteBack = BITS(state->words[0],22,23);
+      signExtend    = BIT(state->words[0],16);
+
+      write_instr_name();
+
+      /* Check for prefetch or ld 0,...*/
+      if(IS_REG(A))
+	WRITE_FORMAT_x_COMMA_LB(A);
+      else
+	{
+	  strcat(formatString,"%*");
+	  WRITE_FORMAT_LB();
+	}
+
+
+      if (fieldBisReg || fieldB != 0)
+	WRITE_FORMAT_x(B);
+      else
+	fieldB = fieldC;
+
+      WRITE_FORMAT_COMMA_x_RB(C);
+      my_sprintf(state, state->operandBuffer, formatString, fieldA, fieldB, fieldC);
+      write_comments();
+      break;
+
+    case 6:
+      /* LD instruction. */
+      CHECK_FIELD_B();
+      CHECK_FIELD_A();
+      /* Support for Prefetch */
+      /* Fixme :: Check for A700 within this function */
+
+      if(FIELDA(state->words[0]) == 62)
+	{
+	  instrName = "prefetch";
+	}
+
+      fieldC = FIELDD9(state->words[0]);
+      fieldCisReg = 0;
+
+      if (dbg) printf_unfiltered("6:b reg %d %d c 0x%x  \n",
+				 fieldBisReg,fieldB,fieldC);
+      state->_ea_present = 1;
+      state->_offset = fieldC;
+      state->_mem_load = 1;
+      if (fieldBisReg) state->ea_reg1 = fieldB;
+      /* field B is either a shimm (same as fieldC) or limm (different!) */
+      /* Say ea is not present, so only one of us will do the name lookup. */
+      else state->_offset += fieldB, state->_ea_present = 0;
+
+      directMem     = BIT(state->words[0],11);
+      /* Check if address writeback is allowed before decoding the
+	 address writeback field of a load instruction.*/
+      if (fieldBisReg && (fieldB != 62))
+        addrWriteBack = BITS(state->words[0],9,10);
+      signExtend    = BIT(state->words[0],6);
+
+      write_instr_name();
+      if(IS_REG(A))
+	WRITE_FORMAT_x_COMMA_LB(A);
+      else
+	{
+	  strcat(formatString,"%*");
+	  WRITE_FORMAT_LB();
+	}
+      if (!fieldBisReg)
+	{
+	  fieldB = state->_offset;
+	  WRITE_FORMAT_x_RB(B);
+	}
+      else
+	{
+	  WRITE_FORMAT_x(B);
+	  WRITE_FORMAT_COMMA_x_RB(C);
+	}
+      my_sprintf(state, state->operandBuffer, formatString, fieldA, fieldB, fieldC);
+      write_comments();
+      break;
+
+    case 7:
+      /* ST instruction. */
+      CHECK_FIELD_B ();
+      CHECK_FIELD_C ();
+      state->source_operand.registerNum = fieldC;
+      state->sourceType = fieldCisReg ? ARC_REGISTER : ARC_LIMM;
+      fieldA  = FIELDD9 (state->words[0]); /* shimm */
+      fieldAisReg = 0;
+
+      /* [B,A offset] */
+      if (dbg) printf_unfiltered("7:b reg %d %x off %x\n",
+				 fieldBisReg,fieldB,fieldA);
+      state->_ea_present = 1;
+      state->_offset = fieldA;
+      if (fieldBisReg) state->ea_reg1 = fieldB;
+      /*
+       * field B is either a shimm (same as fieldA) or limm (different!)
+       * Say ea is not present, so only one of us will do the name lookup.
+       * (for is_limm we do the name translation here).
+       */
+      else
+	state->_offset += fieldB, state->_ea_present = 0;
+
+      directMem     = BIT (state->words[0], 5);
+      addrWriteBack = BITS (state->words[0], 3, 4);
+      state->_addrWriteBack = addrWriteBack;
+      write_instr_name ();
+      WRITE_FORMAT_x_COMMA_LB (C);
+      if (fieldA == 0)
+      {
+        WRITE_FORMAT_x_RB(B);
+      }
+      else
+      {
+	WRITE_FORMAT_x(B);
+        fieldAisReg = 0;
+        WRITE_FORMAT_COMMA_x_RB(A);
+      }
+      my_sprintf(state, state->operandBuffer, formatString, fieldC, fieldB, fieldA);
+      write_comments2(fieldA);
+      break;
+
+    case 8:
+      /* SR instruction */
+      CHECK_FIELD_B();
+      switch (BITS(state->words[0],22,23))
+      {
+ 	case 0:
+          if (is_limm)
+          {
+       	    FIELD_C();
+      	    if (!fieldCisReg)
+	      fieldC = fieldB;
+      	  }
+      	  else
+	  {
+	    CHECK_FIELD_C();
+	  }
+	  break;
+	case 1:
+	  FIELD_C();
+	  fieldCisReg = 0;
+	  break;
+	case 2:
+	  fieldC = FIELDS(state->words[0]);
+	  fieldCisReg = 0;
+	  break;
+      }
+
+      write_instr_name();
+      WRITE_FORMAT_x_COMMA_LB(B);
+      /* Try to print B as an aux reg if it is not a core reg. */
+      usesAuxReg = 1;
+      WRITE_FORMAT_x(C);
+      WRITE_FORMAT_RB();
+      my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC);
+      write_comments();
+      break;
+
+    case 9:
+      /* BBIT0/BBIT1 Instruction */
+
+      CHECK_FIELD_C();
+      if (is_limm || BIT(state->words[0],4))
+      {
+	fieldCisReg = 0;
+        FIELD_B();
+      }
+      else
+      {
+        CHECK_FIELD_B();
+      }
+      fieldAisReg = fieldA = 0;
+      fieldA = FIELDS9(state->words[0]);
+      fieldA += (addr & ~0x3);
+      CHECK_NULLIFY();
+
+      write_instr_name();
+
+      add_target(fieldA);
+      state->flow = state->_opcode == op_BLC ? direct_call : direct_jump;
+      WRITE_FORMAT_x(B);
+      WRITE_FORMAT_COMMA_x(C);
+      strcat(formatString, ",%s"); /* address/label name */
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC, post_address(state, fieldA));
+      write_comments();
+      break;
+
+    case 10:
+      /* LR instruction */
+      CHECK_FIELD_B();
+      switch (BITS(state->words[0],22,23))
+      {
+ 	case 0:
+	  CHECK_FIELD_C(); break;
+	case 1:
+	  FIELD_C();
+	  fieldCisReg = 0;
+	  break;
+	case 2:
+	  fieldC = FIELDS(state->words[0]);
+	  fieldCisReg = 0;
+	  break;
+      }
+
+      write_instr_name();
+      WRITE_FORMAT_x_COMMA_LB(B);
+      /* Try to print B as an aux reg if it is not a core reg. */
+      usesAuxReg = 1;
+      WRITE_FORMAT_x(C);
+      WRITE_FORMAT_RB();
+      my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC);
+      write_comments();
+      break;
+
+    case 11:
+      /* lp instruction */
+
+      if (BITS(state->words[0],22,23) == 3)
+      {
+        FIELD_C();
+        CHECK_COND();
+      }
+      else
+      {
+	fieldC = FIELDS(state->words[0]);
+      }
+
+      fieldC = fieldC << 1;
+      fieldC += (addr & ~0x3);
+
+      write_instr_name();
+
+      /* This address could be a label we know.  Convert it. */
+      add_target(fieldC);
+      state->flow = state->_opcode == op_BLC ? direct_call : direct_jump;
+
+      fieldCisReg = 0;
+      strcat(formatString, "%s"); /* address/label name */
+      my_sprintf(state, state->operandBuffer, formatString, post_address(state, fieldC));
+      write_comments();
+      break;
+
+    case 12:
+      /* MOV instruction */
+      FIELD_B();
+      subopcode = BITS(state->words[0],22,23);
+      if (subopcode == 0 || ((subopcode == 3) && (!BIT(state->words[0],5))))
+      {
+      	CHECK_FIELD_C();
+      }
+      else if (subopcode == 1 || ((subopcode == 3) && (BIT(state->words[0],5))))
+      {
+      	FIELD_C();
+	fieldCisReg = 0;
+      }
+      else if (subopcode == 2)
+      {
+	fieldC = FIELDS(state->words[0]);
+	fieldCisReg = 0;
+      }
+      if (subopcode == 3)
+      {
+        CHECK_FLAG_COND();
+      }
+      else
+      {
+        CHECK_FLAG();
+      }
+
+     write_instr_name();
+     WRITE_FORMAT_x(B);
+     WRITE_FORMAT_COMMA_x(C);
+     WRITE_NOP_COMMENT();
+     my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC);
+     break;
+
+    case 13:
+    /* "B", "BL" instruction */
+
+      fieldA = 0;
+      if ((state->_opcode == op_BC  && (BIT(state->words[0],16))) ||
+ 	  (state->_opcode == op_BLC && (BIT(state->words[0],17))))
+      {
+	/* unconditional branch s25 or branch and link d25 */
+        fieldA = (BITS(state->words[0],0,4)) << 10;
+      }
+      fieldA |= BITS(state->words[0],6,15);
+
+      if (state->_opcode == op_BLC)
+      {
+	  /* Fix for Bug #553.  A bl unconditional has only 9 bits in the
+	   * least order bits. */
+	fieldA = fieldA << 9;
+        fieldA |= BITS(state->words[0],18,26);
+	fieldA = fieldA << 2;
+      }
+      else
+      {
+	fieldA = fieldA << 10;
+        fieldA |= BITS(state->words[0],17,26);
+	fieldA = fieldA << 1;
+      }
+
+      if ((state->_opcode == op_BC  && (BIT(state->words[0],16))) ||
+ 	  (state->_opcode == op_BLC && (BIT(state->words[0],17))))
+	/* unconditional branch s25 or branch and link d25 */
+        fieldA = sign_extend(fieldA, 25);
+      else
+	/* conditional branch s21 or branch and link d21 */
+        fieldA = sign_extend(fieldA, 21);
+
+      fieldA += (addr & ~0x3);
+
+      if (BIT(state->words[0],16) && state->_opcode == op_BC)
+        CHECK_NULLIFY();
+      else
+	/* Checking for bl unconditionally FIX For Bug #553 */
+	if((state->_opcode == op_BLC && BITS(state->words[0],16,17) == 2 )
+	   ||(state->_opcode == op_BC && (BIT(state->words[0],16))))
+	    CHECK_NULLIFY();
+	  else
+	    CHECK_COND_NULLIFY();
+
+
+
+      write_instr_name();
+      /* This address could be a label we know.  Convert it. */
+      add_target(fieldA); /* For debugger. */
+      state->flow = state->_opcode == op_BLC /* BL */
+          ? direct_call
+          : direct_jump;
+        /* indirect calls are achieved by "lr blink,[status]; */
+        /*      lr dest<- func addr; j [dest]" */
+
+      strcat(formatString, "%s"); /* address/label name */
+      my_sprintf(state, state->operandBuffer, formatString, post_address(state, fieldA));
+      write_comments();
+      break;
+
+    case 14:
+
+      /* Extension Instructions */
+
+      FIELD_C_AC();
+      FIELD_B_AC();
+
+      write_instr_name();
+      if (mul)
+      {
+        fieldA = fieldAisReg = 0;
+	WRITE_FORMAT_x(A);
+        WRITE_FORMAT_COMMA_x(B);
+      }
+      else
+        WRITE_FORMAT_x(B);
+      WRITE_FORMAT_COMMA_x(C);
+      WRITE_NOP_COMMENT();
+      if (mul)
+        my_sprintf(state, state->operandBuffer, formatString, 0, fieldB, fieldC);
+      else
+        my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC);
+      break;
+
+    case 15:
+
+      /* ARCompact 16-bit Load/Add resister-register */
+
+      FIELD_C_AC();
+      FIELD_B_AC();
+      FIELD_A_AC();
+
+      write_instr_name();
+
+      if (BITS(state->words[0],3,4) != 3)
+      {
+        WRITE_FORMAT_x_COMMA_LB(A);
+	WRITE_FORMAT_x(B);
+	WRITE_FORMAT_COMMA_x_RB(C);
+      }
+      else
+      {
+        WRITE_FORMAT_x(A);
+        WRITE_FORMAT_COMMA_x(B);
+        WRITE_FORMAT_COMMA_x(C);
+      }
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldA, fieldB, fieldC);
+      break;
+
+    case 16:
+
+    /* ARCompact 16-bit Add/Sub/Shift instructions */
+
+      FIELD_C_AC();
+      FIELD_B_AC();
+      fieldA = FIELDA_AC(state->words[0]);
+      fieldAisReg = 0;
+
+      write_instr_name();
+      WRITE_FORMAT_x(C);
+      WRITE_FORMAT_COMMA_x(B);
+      WRITE_FORMAT_COMMA_x(A);
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldC, fieldB, fieldA);
+      break;
+
+    case 17:
+
+      /* add_s instruction, one Dest/Source can be any of r0 - r63 */
+
+      CHECK_FIELD_H_AC();
+      FIELD_B_AC();
+
+      write_instr_name();
+      WRITE_FORMAT_x(B);
+      WRITE_FORMAT_COMMA_x(B);
+      WRITE_FORMAT_COMMA_x(C);
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldB, fieldC);
+      break;
+
+    case 18:
+
+      /* mov_s/cmp_s instruction, one Dest/Source can be any of r0 - r63 */
+
+      if ((BITS(state->words[0],3,4) == 1) || (BITS(state->words[0],3,4) == 2))
+      {
+      	CHECK_FIELD_H_AC();
+      }
+      else if (BITS(state->words[0],3,4) == 3)
+      {
+	FIELD_H_AC();
+      }
+      FIELD_B_AC();
+
+      write_instr_name();
+      if (BITS(state->words[0],3,4) == 3)
+      {
+        WRITE_FORMAT_x(C);
+        WRITE_FORMAT_COMMA_x(B);
+        WRITE_NOP_COMMENT();
+        my_sprintf(state, state->operandBuffer, formatString, fieldC, fieldB);
+      }
+      else
+      {
+        WRITE_FORMAT_x(B);
+        WRITE_FORMAT_COMMA_x(C);
+        WRITE_NOP_COMMENT();
+        my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC);
+      }
+      break;
+
+    case 19:
+
+      /* Stack pointer-based instructions [major opcode 0x18] */
+
+      if (BITS(state->words[0],5,7) == 5)
+        fieldA = 28;
+      else
+      {
+        FIELD_B_AC();
+	fieldA = fieldB;
+      }
+      fieldB = 28; /* Field B is the stack pointer register */
+      fieldC = (FIELDU_AC(state->words[0])) << 2;
+      fieldCisReg = 0;
+
+      write_instr_name();
+
+      switch (BITS(state->words[0],5,7))
+      {
+	case 0:
+	case 1:
+	case 2:
+	case 3:
+          WRITE_FORMAT_x_COMMA_LB(A);
+	  WRITE_FORMAT_x(B);
+	  WRITE_FORMAT_COMMA_x_RB(C);
+	  break;
+	case 4:
+	case 5:
+          WRITE_FORMAT_x(A);
+          WRITE_FORMAT_COMMA_x(B);
+          WRITE_FORMAT_COMMA_x(C);
+	  break;
+      }
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldA, fieldB, fieldC);
+      break;
+
+    case 20:
+
+      /* gp-relative instructions [major opcode 0x19] */
+
+      fieldA = 0;
+      fieldB = 26; /* Field B is the gp register */
+      fieldC = FIELDS_AC(state->words[0]);
+      switch (BITS(state->words[0],9,10))
+      {
+	case 0:
+	case 3:
+	  fieldC = fieldC << 2; break;
+	case 2:
+	  fieldC = fieldC << 1; break;
+      }
+      fieldCisReg = 0;
+
+      write_instr_name();
+
+      if (BITS(state->words[0],9,10) != 3)
+      {
+        WRITE_FORMAT_x_COMMA_LB(A);
+	WRITE_FORMAT_x(B);
+	WRITE_FORMAT_COMMA_x_RB(C);
+      }
+      else
+      {
+        WRITE_FORMAT_x(A);
+        WRITE_FORMAT_COMMA_x(B);
+        WRITE_FORMAT_COMMA_x(C);
+      }
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldA, fieldB, fieldC);
+      break;
+
+    case 21:
+
+      /* add/cmp/btst instructions [major opcode 28] */
+
+      FIELD_B_AC();
+      if (state->_opcode == op_Su5)
+        fieldC = (BITS(state->words[0],0,4));
+      else
+        fieldC = (BITS(state->words[0],0,6));
+      fieldCisReg = 0;
+      write_instr_name();
+
+      if (!BIT(state->words[0],7))
+      {
+        WRITE_FORMAT_x(B);
+        WRITE_FORMAT_COMMA_x(B);
+        WRITE_FORMAT_COMMA_x(C);
+        WRITE_NOP_COMMENT();
+        my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldB, fieldC);
+      }
+      else
+      {
+        WRITE_FORMAT_x(B);
+        WRITE_FORMAT_COMMA_x(C);
+        WRITE_NOP_COMMENT();
+        my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC);
+      }
+      break;
+
+    case 22:
+
+      /* ARCompact 16-bit instructions, General ops/ single ops */
+
+      FIELD_C_AC();
+      FIELD_B_AC();
+
+      write_instr_name();
+
+      WRITE_FORMAT_x(B);
+      WRITE_FORMAT_COMMA_x(B);
+      WRITE_FORMAT_COMMA_x(C);
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldB, fieldC);
+      break;
+
+    case 23:
+
+      /* Shift/subtract/bit immediate instructions [major opcode 23] */
+
+      FIELD_B_AC();
+      fieldC = FIELDU_AC(state->words[0]);
+      fieldCisReg = 0;
+      write_instr_name();
+      WRITE_FORMAT_x(B);
+      WRITE_FORMAT_COMMA_x(B);
+      WRITE_FORMAT_COMMA_x(C);
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldB, fieldC);
+      break;
+
+    case 24:
+
+      /* ARCompact 16-bit Branch conditionally */
+
+      if (state->_opcode == op_BL_S)
+      {
+        fieldA = (BITS(state->words[0],0,10)) << 2;
+	fieldA = sign_extend(fieldA, 13);
+      }
+      else if (BITS(state->words[0],9,10) != 3)
+      {
+        fieldA = (BITS(state->words[0],0,8)) << 1;
+	fieldA = sign_extend(fieldA, 10);
+      }
+      else
+      {
+        fieldA = (BITS(state->words[0],0,5)) << 1;
+	fieldA = sign_extend(fieldA, 7);
+      }
+      fieldA += (addr & ~0x3);
+
+      write_instr_name();
+      /* This address could be a label we know.  Convert it. */
+      add_target(fieldA); /* For debugger. */
+      state->flow = state->_opcode == op_BL_S /* BL */
+          ? direct_call
+          : direct_jump;
+        /* indirect calls are achieved by "lr blink,[status]; */
+        /*      lr dest<- func addr; j [dest]" */
+
+      strcat(formatString, "%s"); /* address/label name */
+      my_sprintf(state, state->operandBuffer, formatString, post_address(state, fieldA));
+      write_comments();
+      break;
+
+    case 25:
+
+      /* ARCompact 16-bit Branch conditionally on reg z/nz */
+
+      FIELD_B_AC();
+      fieldC = (BITS(state->words[0],0,6)) << 1;
+      fieldC = sign_extend (fieldC, 8);
+
+      fieldC += (addr & ~0x3);
+      fieldA = fieldAisReg = fieldCisReg = 0;
+
+      write_instr_name();
+      /* This address could be a label we know.  Convert it. */
+      add_target(fieldC); /* For debugger. */
+
+      WRITE_FORMAT_x(B);
+      WRITE_FORMAT_COMMA_x(A);
+      strcat(formatString, ",%s"); /* address/label name */
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldA, post_address(state, fieldC));
+      write_comments();
+      break;
+
+    case 26:
+
+      /* Zero operand Instructions */
+
+      write_instr_name();
+      state->operandBuffer[0] = '\0';
+      break;
+
+    case 27:
+
+      /* j_s instruction */
+
+      FIELD_B_AC ();
+      state->register_for_indirect_jump = fieldB;
+      write_instr_name ();
+      strcat (formatString,"[%r]");
+      my_sprintf (state, state->operandBuffer, formatString, fieldB);
+      break;
+
+    case 28:
+
+      /* Load/Store with offset */
+
+      FIELD_C_AC();
+      FIELD_B_AC();
+      switch (state->_opcode)
+      {
+	case op_LD_S :
+	case op_ST_S :
+      	  fieldA = (FIELDU_AC(state->words[0])) << 2;
+	  break;
+	case op_LDB_S :
+	case op_STB_S :
+      	  fieldA = (FIELDU_AC(state->words[0]));
+	  break;
+	case op_LDW_S :
+	case op_LDWX_S :
+	case op_STW_S :
+      	  fieldA = (FIELDU_AC(state->words[0])) << 1;
+	  break;
+      }
+      fieldAisReg = 0;
+
+      write_instr_name();
+
+      WRITE_FORMAT_x_COMMA_LB(C);
+      WRITE_FORMAT_x(B);
+      WRITE_FORMAT_COMMA_x(A);
+      WRITE_FORMAT_RB();
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldC, fieldB, fieldA);
+      write_comments();
+      break;
+
+    case 29:
+
+      /* Load pc-relative */
+
+      FIELD_B_AC();
+      fieldC = 63;
+      fieldA = (BITS(state->words[0],0,7)) << 2;
+      fieldAisReg = 0;
+
+      write_instr_name();
+
+      WRITE_FORMAT_x(B);
+      WRITE_FORMAT_COMMA_x(C);
+      WRITE_FORMAT_COMMA_x(A);
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC, fieldA);
+      write_comments();
+      break;
+
+    case 30:
+
+      /* mov immediate */
+
+      FIELD_B_AC();
+      fieldC = (BITS(state->words[0],0,7));
+      fieldCisReg = 0;
+
+      write_instr_name();
+
+      WRITE_FORMAT_x(B);
+      WRITE_FORMAT_COMMA_x(C);
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC);
+      write_comments();
+      break;
+
+    case 31:
+
+      /* push/pop instructions */
+
+      if (BITS(state->words[0],0,4) == 1)
+      {
+        FIELD_B_AC();
+      }
+      else if (BITS(state->words[0],0,4) == 17)
+	fieldB = 31;
+
+      write_instr_name();
+
+      WRITE_FORMAT_x(B);
+      WRITE_NOP_COMMENT();
+      my_sprintf(state, state->operandBuffer, formatString, fieldB);
+      break;
+
+    case 32:
+
+      /* Single operand instruction */
+
+      if (!BITS(state->words[0],22,23))
+      {
+        CHECK_FIELD_C();
+      }
+      else
+      {
+	FIELD_C();
+	fieldCisReg = 0;
+      }
+
+      write_instr_name();
+
+      if (!fieldC)
+        state->operandBuffer[0] = '\0';
+      else
+      {
+        WRITE_FORMAT_x(C);
+        WRITE_NOP_COMMENT();
+        my_sprintf(state, state->operandBuffer, formatString, fieldC);
+      }
+      break;
+
+  case 33:
+    /* For trap_s and the class of instructions that have
+       unsigned 6 bits in the fields B and C in A700 16 bit
+       instructions */
+    fieldC = FIELDC_AC(state->words[0]);
+    fieldB = FIELDB_AC(state->words[0]);
+    fieldCisReg = 0;
+    fieldBisReg = 0;
+    write_instr_name();
+    strcat(formatString,"%d");
+    my_sprintf(state,state->operandBuffer,formatString, ((fieldB << 3) | fieldC));
+    break;
+
+  case 34:
+    /* For ex.di and its class of instructions within op_major_4
+       This class is different from the normal set of instructions
+       in op_major_4 because this uses bit 15 as .di and the second
+       operand is actually a memory operand.
+       This is of the class
+       <op>.<di> b,[c] and <op>.<di> b,[limm]
+    */
+
+
+    /* field C is either a register or limm (different!) */
+
+    CHECK_FIELD_C();
+    FIELD_B();
+    directMem = BIT(state->words[0],15);
+
+
+    if (BITS(state->words[0],22,23) == 1 )
+      fieldCisReg = 0;
+    if (fieldCisReg)
+      state->ea_reg1 = fieldC;
+
+    write_instr_name();
+    WRITE_FORMAT_x_COMMA_LB(B);
+
+    WRITE_FORMAT_x_RB(C);
+
+    WRITE_NOP_COMMENT();
+    my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC);
+    write_comments();
+    break;
+
+  case 35:
+
+    /* sub_s.ne instruction */
+
+    FIELD_B_AC();
+    write_instr_name();
+    strcat(formatString,"%r,%r,%r");
+    my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldB, fieldB);
+    break;
+
+  case 36:
+
+    FIELD_B_AC();
+
+    write_instr_name();
+
+    WRITE_FORMAT_x(B);
+    WRITE_NOP_COMMENT();
+    my_sprintf(state, state->operandBuffer, formatString, fieldB);
+
+    break;
+    /*******SIMD instructions decoding follows*************/
+  case 37:
+  case 39:
+  case 41:
+    /*fieldA is vr register
+      fieldB is I register
+      fieldC is a constant
+      %*,[%(,%<]
+      or
+      %*,%(,%<
+      or
+      %*,%(,%u
+    */
+
+    CHECK_FIELD_A();
+
+    CHECK_FIELD_B();
+    if (decodingClass == 41)
+       {
+	 FIELD_C();
+       }
+    else
+      {
+	FIELD_U8();
+
+	if (simd_scale_u8>0)
+	  fieldC = fieldC << simd_scale_u8;
+      }
+
+    fieldCisReg = 0;
+
+    write_instr_name();
+    (decodingClass == 37 ? WRITE_FORMAT_x_COMMA_LB(A) :
+                           WRITE_FORMAT_x_COMMA(A));
+    WRITE_FORMAT_x_COMMA(B);
+    (decodingClass == 37 ?  WRITE_FORMAT_x_RB(C):
+                            WRITE_FORMAT_x(C));
+    WRITE_NOP_COMMENT();
+    my_sprintf(state,state->operandBuffer, formatString, fieldA, fieldB, fieldC);
+
+
+    break;
+  case 38:
+    /* fieldA is a vr register
+       fieldB is a ARC700 basecase register.
+       %*,[%b]
+    */
+    CHECK_FIELD_A();
+    CHECK_FIELD_B();
+
+    write_instr_name();
+    WRITE_FORMAT_x_COMMA_LB(A);
+    WRITE_FORMAT_x_RB(B);
+    WRITE_NOP_COMMENT();
+    my_sprintf(state,state->operandBuffer, formatString, fieldA, fieldB);
+
+    break;
+  case 40:
+    /* fieldB & fieldC are vr registers
+       %(,%)
+       or
+       %B,%C
+       or
+       %(,%C
+    */
+    CHECK_FIELD_B();
+    CHECK_FIELD_C();
+
+    write_instr_name();
+    WRITE_FORMAT_x(B);
+    WRITE_FORMAT_COMMA_x(C);
+    my_sprintf(state, state->operandBuffer, formatString, fieldB, fieldC);
+    break;
+
+  case 42:
+    /* fieldA, fieldB, fieldC are all vr registers
+       %*, %(, %) */
+    CHECK_FIELD_A();
+    CHECK_FIELD_B();
+    FIELD_C();
+
+    write_instr_name();
+    WRITE_FORMAT_x(A);
+    WRITE_FORMAT_COMMA_x(B);
+    WRITE_FORMAT_COMMA_x(C);
+    my_sprintf(state, state->operandBuffer, formatString, fieldA, fieldB, fieldC);
+    break;
+
+  case 43:
+    /* Only fieldC is a register
+     %C*/
+    CHECK_FIELD_C();
+
+    if (BITS(state->words[0], 17, 23) == 55)
+      fieldCisReg = 0;
+
+    write_instr_name();
+    WRITE_FORMAT_x(C);
+    my_sprintf(state, state->operandBuffer, formatString, fieldC);
+    break;
+
+    /***************SIMD decoding ends*********************/
+  default:
+    mwerror(state, "Bad decoding class in ARC disassembler");
+    break;
+  }
+
+  state->_cond = cond;
+  return state->instructionLen = offset;
+}
+
+
+/*
+ * _coreRegName - Returns the name the user specified core extension
+ *                register.
+ */
+static const char *
+_coreRegName
+(
+ void *_this ATTRIBUTE_UNUSED, /* C++ this pointer */
+ int v                         /* Register value */
+ )
+{
+  return arcExtMap_coreRegName(v);
+}
+
+/*
+ * _auxRegName - Returns the name the user specified AUX extension
+ *               register.
+ */
+static const char *
+_auxRegName
+( void *_this ATTRIBUTE_UNUSED, /* C++ this pointer */
+  int v                         /* Register value */
+  )
+{
+  return arcExtMap_auxRegName(v);
+}
+
+
+/*
+ * _condCodeName - Returns the name the user specified condition code
+ *                 name.
+ */
+static const char *
+_condCodeName
+(
+ void *_this ATTRIBUTE_UNUSED, /* C++ this pointer */
+ int v                         /* Register value */
+ )
+{
+  return arcExtMap_condCodeName(v);
+}
+
+
+/*
+ * _instName - Returns the name the user specified extension instruction.
+ */
+static const char *
+_instName
+(
+ void *_this ATTRIBUTE_UNUSED, /* C++ this pointer */
+ int op1,                      /* major opcode value */
+ int op2,                      /* minor opcode value */
+ int *flags                    /* instruction flags */
+ )
+{
+  return arcExtMap_instName(op1, op2, flags);
+}
+
+static void
+parse_disassembler_options (char *options)
+{
+  if (!strncasecmp (options, "simd",4))
+    {
+      enable_simd = 1;
+    }
+}
+
+/*
+ * This function is the same as decodeInstr except that this function
+ * returns a struct arcDisState instead of the instruction length.
+ *
+ * This struct contains information useful to the debugger.
+ */
+struct arcDisState
+arcAnalyzeInstr
+(
+ bfd_vma address,		/* Address of this instruction */
+ disassemble_info* info
+ )
+{
+  int status;
+  bfd_byte buffer[4];
+  struct arcDisState s;	/* ARC Disassembler state */
+  int lowbyte, highbyte;
+
+  lowbyte = ((info->endian == BFD_ENDIAN_LITTLE) ? 1 : 0);
+  highbyte = ((info->endian == BFD_ENDIAN_LITTLE) ? 0 : 1);
+
+  memset (&s, 0, sizeof (struct arcDisState));
+
+  /* read first instruction */
+  status = (*info->read_memory_func) (address, buffer, 2, info);
+
+  if (status != 0)
+    {
+      (*info->memory_error_func) (status, address, info);
+      s.instructionLen = -1;
+      return s;
+    }
+
+  if ((buffer[lowbyte] & 0xf8) > 0x38)
+    {
+      info->bytes_per_line = 2;
+      s.words[0] = (buffer[lowbyte] << 8) | buffer[highbyte];
+      status = (*info->read_memory_func) (address + 2, buffer, 4, info);
+      if (info->endian == BFD_ENDIAN_LITTLE)
+	s.words[1] = bfd_getl32 (buffer);
+      else
+	s.words[1] = bfd_getb32 (buffer);
+    }
+  else
+    {
+      info->bytes_per_line = 4;
+      status = (*info->read_memory_func) (address + 2, &buffer[2], 2, info);
+      if (status != 0)
+	{
+	  (*info->memory_error_func) (status, address + 2, info);
+	  s.instructionLen = -1;
+	  return s;
+	}
+      if (info->endian == BFD_ENDIAN_LITTLE)
+	s.words[0] = bfd_getl32(buffer);
+      else
+	s.words[0] = bfd_getb32(buffer);
+
+      /* Always read second word in case of limm.  */
+      /* We ignore the result since the last insn may not have a limm.  */
+      status = (*info->read_memory_func) (address + 4, buffer, 4, info);
+      if (info->endian == BFD_ENDIAN_LITTLE)
+	s.words[1] = bfd_getl32(buffer);
+      else
+	s.words[1] = bfd_getb32(buffer);
+    }
+
+  s._this = &s;
+  s.coreRegName = _coreRegName;
+  s.auxRegName = _auxRegName;
+  s.condCodeName = _condCodeName;
+  s.instName = _instName;
+
+  /* disassemble */
+  dsmOneArcInst (address, (void *)&s, info);
+
+  return s;
+}
+
+/* ARCompact_decodeInstr - Decode an ARCompact instruction returning the
+   size of the instruction in bytes or zero if unrecognized.  */
+int
+ARCompact_decodeInstr (address, info)
+     bfd_vma address; /* Address of this instruction.  */
+     disassemble_info* info;
+{
+  void *stream = info->stream; /* output stream */
+  fprintf_ftype func = info->fprintf_func;
+  char buf[256];
+
+  if (info->disassembler_options)
+    {
+      parse_disassembler_options (info->disassembler_options);
+
+      /* To avoid repeated parsing of these options, we remove them here.  */
+      info->disassembler_options = NULL;
+    }
+
+  s = arcAnalyzeInstr (address, info);
+
+  if (!s.this)
+    return -1;
+
+  /* display the disassembly instruction */
+
+  if (s.instructionLen == 2)
+    (*func) (stream, "        ");
+
+  (*func) (stream, "%08x ", s.words[0]);
+  (*func) (stream, "    ");
+
+  (*func) (stream, "%-10s ", s.instrBuffer);
+
+  if (__TRANSLATION_REQUIRED(s))
+    {
+      bfd_vma addr;
+      char *tmpBuffer;
+      int i = 1;
+      if (s.operandBuffer[0] != '@')
+	{
+	  /* Branch instruction with 3 operands, Translation is required
+	     only for the third operand. Print the first 2 operands */
+	  strcpy (buf, s.operandBuffer);
+	  tmpBuffer = strtok (buf,"@");
+	  (*func) (stream, "%s",tmpBuffer);
+	  i = strlen (tmpBuffer)+1;
+	}
+      addr = s.addresses[s.operandBuffer[i] - '0'];
+      (*info->print_address_func) ((bfd_vma) addr, info);
+      (*func) (stream, "\n");
+    }
+  else
+    (*func) (stream, "%s",s.operandBuffer);
+  return s.instructionLen;
+
+}
diff --git a/sim/common/ChangeLog.ARC b/sim/common/ChangeLog.ARC
new file mode 100644
index 0000000..2b73a9f
--- /dev/null
+++ b/sim/common/ChangeLog.ARC
@@ -0,0 +1,42 @@
+2007-09-17  J"orn Rennecke  <joern.rennecke@arc.com>
+
+	* gentvals.sh: Allow target-specific definitions to override
+	later generic ones.
+	* gennltvals.sh: Use ${srcroot}/newlib/libc/sys/arc/sys/fcntl.h
+	for open on arc.
+	* nltvals.def: Regenerate.
+
+2007-08-22  J"orn Rennecke  <joern.rennecke@arc.com>
+
+	* cgen-trace.c (sim_cgen_disassemble_insn):
+	Check for CGEN_INSN_DISASM_BITSIZE.
+
+2007-08-21  J"orn Rennecke  <joern.rennecke@arc.com>
+
+	* cgen-trace.c (sim_cgen_disassemble_insn): Disable bogus sanity check.
+
+2007-05-14  J"orn Rennecke  <joern.rennecke@arc.com>
+
+	* callback.c (fdmap, fdbad): No longer static.
+
+2007-05-02  J"orn Rennecke  <joern.rennecke@arc.com>
+
+	* syscall.c (get_path): No longer static.
+
+2007-04-30  J"orn Rennecke  <joern.rennecke@arc.com>
+
+	* gennltvals.sh: Add arc code.
+	* nltvals.def: Regenerate.
+
+	Speed up simulator startup:
+	* sim-utils.c (zalloc): Use xcalloc.
+
+	Debugging utility functions:
+	* sim-utils.c (dump_hex, dump_strn_1, dump_asc): New functions.
+	* (dump_str, dump_strn): Likewise.
+
+	Fix descriptor 0/1/2 handling in pesence of freopen:
+	* syscall.c (cb_syscall): Add comments about descriptors 0/1/2.
+	* callback.c (os_read_stdin): Use os_read.
+	(os_write): Use fwrite to stdout / stderr for descriptor 1 / 2.
+	(os_write_stdout, os_write_stderr): Use os_write.