This commit was manufactured by cvs2svn to create branch

'kseitz_interps-20020528-branch'.

Cherrypick from master 2002-06-19 16:55:28 UTC Daniel Jacobowitz <drow@false.org> '2002-06-19  Daniel Jacobowitz  <drow@mvista.com>':
    bfd/cpu-frv.c
    bfd/elf32-frv.c
    gdb/ada-lang.c
    gdb/config/sparc/nbsd.mt
    gdb/i386-sol2-tdep.c
    include/elf/frv.h
    include/gdb/sim-arm.h
    opcodes/frv-asm.c
    opcodes/frv-desc.c
    opcodes/frv-desc.h
    opcodes/frv-dis.c
    opcodes/frv-ibld.c
    opcodes/frv-opc.c
    opcodes/frv-opc.h
    sim/mips/mdmx.c

15 files changed, 28937 insertions, 0 deletions

diff --git a/bfd/cpu-frv.c b/bfd/cpu-frv.c
new file mode 100644
index 00000000000..cd9ff1ef5c6
--- /dev/null
+++ b/bfd/cpu-frv.c
@@ -0,0 +1,64 @@
+/* BFD support for the FRV processor.
+   Copyright (C) 2002 Free Software Foundation, Inc.
+
+This file is part of BFD, the Binary File Descriptor library.
+
+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 "bfd.h"
+#include "sysdep.h"
+#include "libbfd.h"
+
+enum {
+  I_frv_generic,
+  I_frv_simple,
+  I_frv_500,
+  I_frv_300,
+};
+
+#define FRV_ARCH(MACHINE, NAME, DEFAULT, NEXT)				\
+{									\
+  32,	                        /* 32 bits in a word */			\
+  32,	                        /* 32 bits in an address */		\
+  8,	                        /* 8 bits in a byte */			\
+  bfd_arch_frv,			/* architecture */			\
+  MACHINE,			/* which machine */			\
+  "frv",			/* architecture name */			\
+  NAME,				/* machine name */			\
+  4,				/* default alignment */			\
+  DEFAULT,			/* is this the default? */		\
+  bfd_default_compatible,	/* architecture comparison fn */	\
+  bfd_default_scan,		/* string to architecture convert fn */	\
+  NEXT				/* next in list */			\
+}
+
+static const bfd_arch_info_type arch_info_300
+  = FRV_ARCH (bfd_mach_fr300,   "fr300",   false, (bfd_arch_info_type *)0);
+
+static const bfd_arch_info_type arch_info_400
+  = FRV_ARCH (bfd_mach_fr400, "fr400", false, &arch_info_300);
+
+static const bfd_arch_info_type arch_info_500
+  = FRV_ARCH (bfd_mach_fr500, "fr500", false, &arch_info_400);
+
+static const bfd_arch_info_type arch_info_simple
+  = FRV_ARCH (bfd_mach_frvsimple, "simple", false, &arch_info_500);
+
+static const bfd_arch_info_type arch_info_tomcat
+  = FRV_ARCH (bfd_mach_frvtomcat, "tomcat", false, &arch_info_simple);
+
+const bfd_arch_info_type bfd_frv_arch
+  = FRV_ARCH (bfd_mach_frv, "frv", true, &arch_info_tomcat);
+
diff --git a/bfd/elf32-frv.c b/bfd/elf32-frv.c
new file mode 100644
index 00000000000..cc26b967c52
--- /dev/null
+++ b/bfd/elf32-frv.c
@@ -0,0 +1,1405 @@
+/* FRV-specific support for 32-bit ELF.
+   Copyright (C) 2002 Free Software Foundation, Inc.
+
+This file is part of BFD, the Binary File Descriptor library.
+
+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 "bfd.h"
+#include "sysdep.h"
+#include "libbfd.h"
+#include "elf-bfd.h"
+#include "elf/frv.h"
+
+/* Forward declarations.  */
+static bfd_reloc_status_type elf32_frv_relocate_lo16
+  PARAMS ((bfd *,  Elf_Internal_Rela *, bfd_byte *, bfd_vma));
+static bfd_reloc_status_type elf32_frv_relocate_hi16
+  PARAMS ((bfd *,  Elf_Internal_Rela *, bfd_byte *, bfd_vma));
+static bfd_reloc_status_type elf32_frv_relocate_label24
+  PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
+static bfd_reloc_status_type elf32_frv_relocate_gprel12
+  PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
+static bfd_reloc_status_type elf32_frv_relocate_gprelu12
+  PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
+static bfd_reloc_status_type elf32_frv_relocate_gprello
+  PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
+static bfd_reloc_status_type elf32_frv_relocate_gprelhi
+  PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
+static reloc_howto_type *frv_reloc_type_lookup
+  PARAMS ((bfd *, bfd_reloc_code_real_type));
+static void frv_info_to_howto_rela 
+  PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
+static boolean elf32_frv_relocate_section 
+  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
+static boolean elf32_frv_add_symbol_hook
+  PARAMS (( bfd *, struct bfd_link_info *, const Elf_Internal_Sym *, const char **, flagword *, asection **, bfd_vma *));
+static bfd_reloc_status_type frv_final_link_relocate
+  PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, bfd_vma));
+static boolean elf32_frv_gc_sweep_hook
+  PARAMS ((bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *));
+static asection * elf32_frv_gc_mark_hook
+  PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *, struct elf_link_hash_entry *, Elf_Internal_Sym *));
+static boolean elf32_frv_check_relocs
+  PARAMS ((bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *));
+static int elf32_frv_machine PARAMS ((bfd *));
+static boolean elf32_frv_object_p PARAMS ((bfd *));
+static boolean frv_elf_set_private_flags PARAMS ((bfd *, flagword));
+static boolean frv_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
+static boolean frv_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
+static boolean frv_elf_print_private_bfd_data PARAMS ((bfd *, PTR));
+
+static reloc_howto_type elf32_frv_howto_table [] =
+{
+  /* This reloc does nothing.  */
+  HOWTO (R_FRV_NONE,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_FRV_NONE",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* A 32 bit absolute relocation.  */
+  HOWTO (R_FRV_32,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_FRV_32",		/* name */
+	 false,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* A 16 bit pc-relative relocation.  */
+  HOWTO (R_FRV_LABEL16,	        /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_FRV_LABEL16",	/* name */
+	 false,			/* partial_inplace */
+	 0xffff,		/* src_mask */
+	 0xffff,		/* dst_mask */
+	 true),		        /* pcrel_offset */
+
+  /* A 24-bit pc-relative relocation.  */
+  HOWTO (R_FRV_LABEL24,	/* type */
+	 2,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 26,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_FRV_LABEL24",	/* name */
+	 false,			/* partial_inplace */
+	 0x7e03ffff,		/* src_mask */
+	 0x7e03ffff,		/* dst_mask */
+	 true),		        /* pcrel_offset */
+
+  HOWTO (R_FRV_LO16,	        /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_FRV_LO16",		/* name */
+	false,			/* partial_inplace */
+	 0xffff,		/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),	        /* pcrel_offset */
+
+  HOWTO (R_FRV_HI16,	        /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_FRV_HI16",		/* name */
+	 false,			/* partial_inplace */
+	 0xffff,		/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),	        /* pcrel_offset */
+
+  HOWTO (R_FRV_GPREL12,	        /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 12,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_FRV_GPREL12",       /* name */
+	 false,			/* partial_inplace */
+	 0xfff,		        /* src_mask */
+	 0xfff,		        /* dst_mask */
+	 false),	        /* pcrel_offset */
+
+  HOWTO (R_FRV_GPRELU12,        /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 12,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_FRV_GPRELU12",      /* name */
+	 false,			/* partial_inplace */
+	 0xfff,		        /* src_mask */
+	 0x3f03f,	        /* dst_mask */
+	 false),	        /* pcrel_offset */
+
+  HOWTO (R_FRV_GPREL32,         /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_FRV_GPREL32",	/* name */
+	 false,			/* partial_inplace */
+	 0xffffffff,            /* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),	        /* pcrel_offset */
+
+  HOWTO (R_FRV_GPRELHI,	        /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_FRV_GPRELHI",	/* name */
+	 false,			/* partial_inplace */
+	 0xffff,		        /* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),	        /* pcrel_offset */
+
+  HOWTO (R_FRV_GPRELLO,	        /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_FRV_GPRELLO",	/* name */
+	 false,			/* partial_inplace */
+	 0xffff,		        /* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),	        /* pcrel_offset */
+};
+
+/* GNU extension to record C++ vtable hierarchy.  */
+static reloc_howto_type elf32_frv_vtinherit_howto =
+  HOWTO (R_FRV_GNU_VTINHERIT,   /* type */
+         0,                     /* rightshift */
+         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         0,                     /* bitsize */
+         false,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_dont, /* complain_on_overflow */
+         NULL,                  /* special_function */
+         "R_FRV_GNU_VTINHERIT", /* name */
+         false,                 /* partial_inplace */
+         0,                     /* src_mask */
+         0,                     /* dst_mask */
+         false);                /* pcrel_offset */
+
+  /* GNU extension to record C++ vtable member usage.  */
+static reloc_howto_type elf32_frv_vtentry_howto =
+  HOWTO (R_FRV_GNU_VTENTRY,     /* type */
+         0,                     /* rightshift */
+         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         0,                     /* bitsize */
+         false,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_dont, /* complain_on_overflow */
+         _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
+         "R_FRV_GNU_VTENTRY",   /* name */
+         false,                 /* partial_inplace */
+         0,                     /* src_mask */
+         0,                     /* dst_mask */
+         false);                /* pcrel_offset */
+
+/* Map BFD reloc types to FRV ELF reloc types.  */
+#if 0
+struct frv_reloc_map
+{
+  unsigned int bfd_reloc_val;
+  unsigned int frv_reloc_val;
+};
+
+static const struct frv_reloc_map frv_reloc_map [] =
+{
+  { BFD_RELOC_NONE,           R_FRV_NONE },
+  { BFD_RELOC_32,             R_FRV_32 },
+  { BFD_RELOC_FRV_LABEL16,    R_FRV_LABEL16 },
+  { BFD_RELOC_FRV_LABEL24,    R_FRV_LABEL24 },
+  { BFD_RELOC_FRV_LO16,       R_FRV_LO16 },
+  { BFD_RELOC_FRV_HI16,       R_FRV_HI16 },
+  { BFD_RELOC_FRV_GPREL12,    R_FRV_GPREL12 },
+  { BFD_RELOC_FRV_GPRELU12,   R_FRV_GPRELU12 },
+  { BFD_RELOC_FRV_GPREL32,    R_FRV_GPREL32 },
+  { BFD_RELOC_FRV_GPRELHI,    R_FRV_GPRELHI },
+  { BFD_RELOC_FRV_GPRELLO,    R_FRV_GPRELLO },
+  { BFD_RELOC_VTABLE_INHERIT, R_FRV_GNU_VTINHERIT },
+  { BFD_RELOC_VTABLE_ENTRY,   R_FRV_GNU_VTENTRY },
+};
+#endif
+
+/* Handle an FRV small data reloc.  */
+
+static bfd_reloc_status_type
+elf32_frv_relocate_gprel12 (info, input_bfd, input_section, relocation, contents, value)
+     struct bfd_link_info *info;
+     bfd *input_bfd;
+     asection *input_section;
+     Elf_Internal_Rela *relocation;
+     bfd_byte *contents;
+     bfd_vma value;
+{
+  bfd_vma insn;
+  bfd_vma gp;
+  struct bfd_link_hash_entry *h;
+
+  h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
+
+  gp = (h->u.def.value
+	+ h->u.def.section->output_section->vma
+	+ h->u.def.section->output_offset);
+
+  value -= input_section->output_section->vma;
+  value -= (gp - input_section->output_section->vma);
+
+  insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
+
+  value += relocation->r_addend;
+
+  if ((long) value > 0x7ff || (long) value < -0x800)
+    return bfd_reloc_overflow;
+
+  bfd_put_32 (input_bfd,
+	      (insn & 0xfffff000) | (value & 0xfff),
+	      contents + relocation->r_offset);
+
+  return bfd_reloc_ok;
+}
+
+/* Handle an FRV small data reloc. for the u12 field.  */
+
+static bfd_reloc_status_type
+elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, relocation, contents, value)
+     struct bfd_link_info *info;
+     bfd *input_bfd;
+     asection *input_section;
+     Elf_Internal_Rela *relocation;
+     bfd_byte *contents;
+     bfd_vma value;
+{
+  bfd_vma insn;
+  bfd_vma gp;
+  struct bfd_link_hash_entry *h;
+  bfd_vma mask;
+
+  h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
+
+  gp = (h->u.def.value
+	+ h->u.def.section->output_section->vma
+	+ h->u.def.section->output_offset);
+ 
+  value -= input_section->output_section->vma;
+  value -= (gp - input_section->output_section->vma);
+
+  insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
+
+  value += relocation->r_addend;
+
+  if ((long) value > 0x7ff || (long) value < -0x800)
+    return bfd_reloc_overflow;
+
+  /* The high 6 bits go into bits 17-12. The low 6 bits go into bits 5-0.  */
+  mask = 0x3f03f;
+  insn = (insn & ~mask) | ((value & 0xfc0) << 12) | (value & 0x3f);
+
+  bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
+
+  return bfd_reloc_ok;
+}
+
+/* Handle an FRV ELF HI16 reloc.  */
+
+static bfd_reloc_status_type
+elf32_frv_relocate_hi16 (input_bfd, relhi, contents, value)
+     bfd *input_bfd;
+     Elf_Internal_Rela *relhi;
+     bfd_byte *contents;
+     bfd_vma value;
+{
+  bfd_vma insn;
+
+  insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
+
+  value += relhi->r_addend;
+  value = ((value >> 16) & 0xffff);
+
+  insn = (insn & 0xffff0000) | value;
+
+  if ((long) value > 0xffff || (long) value < -0x10000)
+    return bfd_reloc_overflow;
+
+  bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
+  return bfd_reloc_ok;
+
+}
+static bfd_reloc_status_type
+elf32_frv_relocate_lo16 (input_bfd, rello, contents, value)
+     bfd *input_bfd;
+     Elf_Internal_Rela *rello;
+     bfd_byte *contents;
+     bfd_vma value;
+{
+  bfd_vma insn;
+
+  insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
+
+  value += rello->r_addend;
+  value = value & 0xffff;
+
+  insn = (insn & 0xffff0000) | value;
+
+  if ((long) value > 0xffff || (long) value < -0x10000)
+    return bfd_reloc_overflow;
+
+  bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
+  return bfd_reloc_ok;
+}
+
+/* Perform the relocation for the CALL label24 instruction.  */
+
+static bfd_reloc_status_type
+elf32_frv_relocate_label24 (input_bfd, input_section, rello, contents, value)
+     bfd *input_bfd;
+     asection *input_section;
+     Elf_Internal_Rela *rello;
+     bfd_byte *contents;
+     bfd_vma value;
+{
+  bfd_vma insn;
+  bfd_vma label6;
+  bfd_vma label18;
+
+  /* The format for the call instruction is:
+
+    0 000000 0001111 000000000000000000 
+      label6 opcode  label18
+
+    The branch calculation is: pc + (4*label24)
+    where label24 is the concatenation of label6 and label18.  */
+
+  /* Grab the instruction.  */
+  insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
+
+  value -= input_section->output_section->vma + input_section->output_offset;
+  value -= rello->r_offset;
+  value += rello->r_addend;
+
+  value = value >> 2;
+
+  label6  = value & 0xfc0000;
+  label6  = label6 << 7;
+
+  label18 = value & 0x3ffff;
+
+  insn = insn & 0x803c0000;
+  insn = insn | label6;
+  insn = insn | label18;
+
+  bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
+
+  return bfd_reloc_ok;
+}
+
+static bfd_reloc_status_type
+elf32_frv_relocate_gprelhi (info, input_bfd, input_section, relocation, contents, value)
+     struct bfd_link_info *info;
+     bfd *input_bfd;
+     asection *input_section;
+     Elf_Internal_Rela *relocation;
+     bfd_byte *contents;
+     bfd_vma value;
+{
+  bfd_vma insn;
+  bfd_vma gp;
+  struct bfd_link_hash_entry *h;
+
+  h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
+
+  gp = (h->u.def.value
+        + h->u.def.section->output_section->vma
+        + h->u.def.section->output_offset);
+
+  value -= input_section->output_section->vma;
+  value -= (gp - input_section->output_section->vma);
+  value += relocation->r_addend;
+  value = ((value >> 16) & 0xffff);
+
+  if ((long) value > 0xffff || (long) value < -0x10000)
+    return bfd_reloc_overflow;
+
+  insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
+  insn = (insn & 0xffff0000) | value;
+
+  bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
+  return bfd_reloc_ok;
+}
+
+static bfd_reloc_status_type
+elf32_frv_relocate_gprello (info, input_bfd, input_section, relocation, contents, value)
+     struct bfd_link_info *info;
+     bfd *input_bfd;
+     asection *input_section;
+     Elf_Internal_Rela *relocation;
+     bfd_byte *contents;
+     bfd_vma value;
+{
+  bfd_vma insn;
+  bfd_vma gp;
+  struct bfd_link_hash_entry *h;
+
+  h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
+
+  gp = (h->u.def.value
+        + h->u.def.section->output_section->vma
+        + h->u.def.section->output_offset);
+
+  value -= input_section->output_section->vma;
+  value -= (gp - input_section->output_section->vma);
+  value += relocation->r_addend;
+  value = value & 0xffff;
+
+  if ((long) value > 0xffff || (long) value < -0x10000)
+    return bfd_reloc_overflow;
+
+  insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
+  insn = (insn & 0xffff0000) | value;
+
+  bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
+
+ return bfd_reloc_ok;
+}
+
+static reloc_howto_type *
+frv_reloc_type_lookup (abfd, code)
+     bfd * abfd ATTRIBUTE_UNUSED;
+     bfd_reloc_code_real_type code;
+{
+  switch (code)
+    {
+    default:
+      break;
+
+    case BFD_RELOC_NONE:
+      return &elf32_frv_howto_table[ (int) R_FRV_NONE];
+  
+    case BFD_RELOC_32:
+    case BFD_RELOC_CTOR:
+      return &elf32_frv_howto_table[ (int) R_FRV_32];
+
+    case BFD_RELOC_FRV_LABEL16:
+      return &elf32_frv_howto_table[ (int) R_FRV_LABEL16];
+
+    case BFD_RELOC_FRV_LABEL24:
+      return &elf32_frv_howto_table[ (int) R_FRV_LABEL24];
+
+    case BFD_RELOC_FRV_LO16:
+      return &elf32_frv_howto_table[ (int) R_FRV_LO16];
+
+    case BFD_RELOC_FRV_HI16:
+      return &elf32_frv_howto_table[ (int) R_FRV_HI16];
+
+    case BFD_RELOC_FRV_GPREL12:
+      return &elf32_frv_howto_table[ (int) R_FRV_GPREL12];
+
+    case BFD_RELOC_FRV_GPRELU12:
+      return &elf32_frv_howto_table[ (int) R_FRV_GPRELU12];
+
+    case BFD_RELOC_FRV_GPREL32:
+      return &elf32_frv_howto_table[ (int) R_FRV_GPREL32];
+
+    case BFD_RELOC_FRV_GPRELHI:
+      return &elf32_frv_howto_table[ (int) R_FRV_GPRELHI];
+
+    case BFD_RELOC_FRV_GPRELLO:
+      return &elf32_frv_howto_table[ (int) R_FRV_GPRELLO];
+
+    case BFD_RELOC_VTABLE_INHERIT:
+      return &elf32_frv_vtinherit_howto;
+
+    case BFD_RELOC_VTABLE_ENTRY:
+      return &elf32_frv_vtentry_howto;
+    }
+
+  return NULL;
+}
+
+/* Set the howto pointer for an FRV ELF reloc.  */
+
+static void
+frv_info_to_howto_rela (abfd, cache_ptr, dst)
+     bfd * abfd ATTRIBUTE_UNUSED;
+     arelent * cache_ptr;
+     Elf32_Internal_Rela * dst;
+{
+  unsigned int r_type;
+
+  r_type = ELF32_R_TYPE (dst->r_info);
+  switch (r_type)
+    {
+    case R_FRV_GNU_VTINHERIT:
+      cache_ptr->howto = &elf32_frv_vtinherit_howto;
+      break;
+
+    case R_FRV_GNU_VTENTRY:
+      cache_ptr->howto = &elf32_frv_vtentry_howto;
+      break;
+
+    default:
+      cache_ptr->howto = & elf32_frv_howto_table [r_type];
+      break;
+    }
+}
+
+/* Perform a single relocation.  By default we use the standard BFD
+   routines, but a few relocs, we have to do them ourselves.  */
+
+static bfd_reloc_status_type
+frv_final_link_relocate (howto, input_bfd, input_section, contents, rel, relocation)
+     reloc_howto_type *  howto;
+     bfd *               input_bfd;
+     asection *          input_section;
+     bfd_byte *          contents;
+     Elf_Internal_Rela * rel;
+     bfd_vma             relocation;
+{
+  return _bfd_final_link_relocate (howto, input_bfd, input_section,
+				   contents, rel->r_offset, relocation,
+				   rel->r_addend);
+}
+
+
+/* Relocate an FRV ELF section.
+   There is some attempt to make this function usable for many architectures,
+   both USE_REL and USE_RELA ['twould be nice if such a critter existed],
+   if only to serve as a learning tool.
+
+   The RELOCATE_SECTION function is called by the new ELF backend linker
+   to handle the relocations for a section.
+
+   The relocs are always passed as Rela structures; if the section
+   actually uses Rel structures, the r_addend field will always be
+   zero.
+
+   This function is responsible for adjusting the section contents as
+   necessary, and (if using Rela relocs and generating a relocateable
+   output file) adjusting the reloc addend as necessary.
+
+   This function does not have to worry about setting the reloc
+   address or the reloc symbol index.
+
+   LOCAL_SYMS is a pointer to the swapped in local symbols.
+
+   LOCAL_SECTIONS is an array giving the section in the input file
+   corresponding to the st_shndx field of each local symbol.
+
+   The global hash table entry for the global symbols can be found
+   via elf_sym_hashes (input_bfd).
+
+   When generating relocateable output, this function must handle
+   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
+   going to be the section symbol corresponding to the output
+   section, which means that the addend must be adjusted
+   accordingly.  */
+
+static boolean
+elf32_frv_relocate_section (output_bfd, info, input_bfd, input_section,
+			   contents, relocs, local_syms, local_sections)
+     bfd *                   output_bfd ATTRIBUTE_UNUSED;
+     struct bfd_link_info *  info;
+     bfd *                   input_bfd;
+     asection *              input_section;
+     bfd_byte *              contents;
+     Elf_Internal_Rela *     relocs;
+     Elf_Internal_Sym *      local_syms;
+     asection **             local_sections;
+{
+  Elf_Internal_Shdr *           symtab_hdr;
+  struct elf_link_hash_entry ** sym_hashes;
+  Elf_Internal_Rela *           rel;
+  Elf_Internal_Rela *           relend;
+
+  symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (input_bfd);
+  relend     = relocs + input_section->reloc_count;
+
+  for (rel = relocs; rel < relend; rel ++)
+    {
+      reloc_howto_type *           howto;
+      unsigned long                r_symndx;
+      Elf_Internal_Sym *           sym;
+      asection *                   sec;
+      struct elf_link_hash_entry * h;
+      bfd_vma                      relocation;
+      bfd_reloc_status_type        r;
+      const char *                 name = NULL;
+      int                          r_type;
+      
+      r_type = ELF32_R_TYPE (rel->r_info);
+      
+      if (   r_type == R_FRV_GNU_VTINHERIT
+	  || r_type == R_FRV_GNU_VTENTRY)
+	continue;
+      
+      r_symndx = ELF32_R_SYM (rel->r_info);
+
+      if (info->relocateable)
+	{
+	  /* This is a relocateable link.  We don't have to change
+             anything, unless the reloc is against a section symbol,
+             in which case we have to adjust according to where the
+             section symbol winds up in the output section.  */
+	  if (r_symndx < symtab_hdr->sh_info)
+	    {
+	      sym = local_syms + r_symndx;
+	      
+	      if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
+		{
+		  sec = local_sections [r_symndx];
+		  rel->r_addend += sec->output_offset + sym->st_value;
+		}
+	    }
+
+	  continue;
+	}
+
+      /* This is a final link.  */
+      howto  = elf32_frv_howto_table + ELF32_R_TYPE (rel->r_info);
+      h      = NULL;
+      sym    = NULL;
+      sec    = NULL;
+      
+      if (r_symndx < symtab_hdr->sh_info)
+	{
+	  sym = local_syms + r_symndx;
+	  sec = local_sections [r_symndx];
+	  relocation = (sec->output_section->vma
+			+ sec->output_offset
+			+ sym->st_value);
+	  
+	  name = bfd_elf_string_from_elf_section
+	    (input_bfd, symtab_hdr->sh_link, sym->st_name);
+	  name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
+	}
+      else
+	{
+	  h = sym_hashes [r_symndx - symtab_hdr->sh_info];
+	  
+	  while (h->root.type == bfd_link_hash_indirect
+		 || h->root.type == bfd_link_hash_warning)
+	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+	  name = h->root.root.string;
+	  
+	  if (h->root.type == bfd_link_hash_defined
+	      || h->root.type == bfd_link_hash_defweak)
+	    {
+	      sec = h->root.u.def.section;
+	      relocation = (h->root.u.def.value
+			    + sec->output_section->vma
+			    + sec->output_offset);
+	    }
+	  else if (h->root.type == bfd_link_hash_undefweak)
+	    {
+	      relocation = 0;
+	    }
+	  else
+	    {
+	      if (! ((*info->callbacks->undefined_symbol)
+		     (info, h->root.root.string, input_bfd,
+		      input_section, rel->r_offset, true)))
+		return false;
+	      relocation = 0;
+	    }
+	}
+      
+     if (r_type == R_FRV_HI16)
+       r = elf32_frv_relocate_hi16 (input_bfd, rel, contents, relocation);
+
+     else if (r_type == R_FRV_LO16)
+       r = elf32_frv_relocate_lo16 (input_bfd, rel, contents, relocation);
+
+     else if (r_type == R_FRV_LABEL24)
+       r = elf32_frv_relocate_label24 (input_bfd, input_section, rel, contents, relocation);
+
+     else if (r_type == R_FRV_GPREL12)
+       r = elf32_frv_relocate_gprel12 (info, input_bfd, input_section, rel, contents, relocation);
+
+     else if (r_type == R_FRV_GPRELU12)
+       r = elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, rel, contents, relocation);
+
+     else if (r_type == R_FRV_GPRELLO)
+       r = elf32_frv_relocate_gprello (info, input_bfd, input_section, rel, contents, relocation);
+
+     else if (r_type == R_FRV_GPRELHI)
+       r = elf32_frv_relocate_gprelhi (info, input_bfd, input_section, rel, contents, relocation);
+
+     else
+       r = frv_final_link_relocate (howto, input_bfd, input_section, contents, rel, relocation);
+
+      if (r != bfd_reloc_ok)
+	{
+	  const char * msg = (const char *) NULL;
+
+	  switch (r)
+	    {
+	    case bfd_reloc_overflow:
+	      r = info->callbacks->reloc_overflow
+		(info, name, howto->name, (bfd_vma) 0,
+		 input_bfd, input_section, rel->r_offset);
+	      break;
+	      
+	    case bfd_reloc_undefined:
+	      r = info->callbacks->undefined_symbol
+		(info, name, input_bfd, input_section, rel->r_offset, true);
+	      break;
+	      
+	    case bfd_reloc_outofrange:
+	      msg = _("internal error: out of range error");
+	      break;
+
+	    case bfd_reloc_notsupported:
+	      msg = _("internal error: unsupported relocation error");
+	      break;
+
+	    case bfd_reloc_dangerous:
+	      msg = _("internal error: dangerous relocation");
+	      break;
+
+	    default:
+	      msg = _("internal error: unknown error");
+	      break;
+	    }
+
+	  if (msg)
+	    r = info->callbacks->warning
+	      (info, msg, name, input_bfd, input_section, rel->r_offset);
+
+	  if (! r)
+	    return false;
+	}
+    }
+
+  return true;
+}
+
+/* Return the section that should be marked against GC for a given
+   relocation.  */
+
+static asection *
+elf32_frv_gc_mark_hook (abfd, info, rel, h, sym)
+     bfd *                        abfd;
+     struct bfd_link_info *       info ATTRIBUTE_UNUSED;
+     Elf_Internal_Rela *          rel;
+     struct elf_link_hash_entry * h;
+     Elf_Internal_Sym *           sym;
+{
+  if (h != NULL)
+    {
+      switch (ELF32_R_TYPE (rel->r_info))
+	{
+	case R_FRV_GNU_VTINHERIT:
+	case R_FRV_GNU_VTENTRY:
+	  break;
+
+	default:
+	  switch (h->root.type)
+	    {
+	    default:
+	      break;
+
+	    case bfd_link_hash_defined:
+	    case bfd_link_hash_defweak:
+	      return h->root.u.def.section;
+
+	    case bfd_link_hash_common:
+	      return h->root.u.c.p->section;
+	    }
+	}
+    }
+  else
+    {
+      if (!(elf_bad_symtab (abfd)
+	    && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
+	  && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
+		&& sym->st_shndx != SHN_COMMON))
+	return bfd_section_from_elf_index (abfd, sym->st_shndx);
+    }
+
+  return NULL;
+}
+
+/* Update the got entry reference counts for the section being removed.  */
+
+static boolean
+elf32_frv_gc_sweep_hook (abfd, info, sec, relocs)
+     bfd *                     abfd ATTRIBUTE_UNUSED;
+     struct bfd_link_info *    info ATTRIBUTE_UNUSED;
+     asection *                sec ATTRIBUTE_UNUSED;
+     const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;
+{
+  return true;
+}
+
+
+/* Hook called by the linker routine which adds symbols from an object
+   file.  We use it to put .comm items in .scomm, and not .comm.  */
+
+static boolean
+elf32_frv_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     const Elf_Internal_Sym *sym;
+     const char **namep ATTRIBUTE_UNUSED;
+     flagword *flagsp ATTRIBUTE_UNUSED;
+     asection **secp;
+     bfd_vma *valp;
+{
+  if (sym->st_shndx == SHN_COMMON
+      && !info->relocateable
+      && (int)sym->st_size <= (int)bfd_get_gp_size (abfd))
+    {
+      /* Common symbols less than or equal to -G nn bytes are
+	 automatically put into .sbss.  */
+
+      asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
+
+      if (scomm == NULL)
+	{
+	  scomm = bfd_make_section (abfd, ".scommon");
+	  if (scomm == NULL
+	      || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
+						       | SEC_IS_COMMON
+						       | SEC_LINKER_CREATED)))
+	    return false;
+	}
+
+      *secp = scomm;
+      *valp = sym->st_size;
+    }
+
+  return true;
+}
+/* Look through the relocs for a section during the first phase.
+   Since we don't do .gots or .plts, we just need to consider the
+   virtual table relocs for gc.  */
+ 
+static boolean
+elf32_frv_check_relocs (abfd, info, sec, relocs)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     asection *sec;
+     const Elf_Internal_Rela *relocs;
+{
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
+  const Elf_Internal_Rela *rel;
+  const Elf_Internal_Rela *rel_end;
+ 
+  if (info->relocateable)
+    return true;
+ 
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (abfd);
+  sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
+  if (!elf_bad_symtab (abfd))
+    sym_hashes_end -= symtab_hdr->sh_info;
+ 
+  rel_end = relocs + sec->reloc_count;
+  for (rel = relocs; rel < rel_end; rel++)
+    {
+      struct elf_link_hash_entry *h;
+      unsigned long r_symndx;
+ 
+      r_symndx = ELF32_R_SYM (rel->r_info);
+      if (r_symndx < symtab_hdr->sh_info)
+        h = NULL;
+      else
+        h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+ 
+      switch (ELF32_R_TYPE (rel->r_info))
+        {
+        /* This relocation describes the C++ object vtable hierarchy.
+           Reconstruct it for later use during GC.  */
+        case R_FRV_GNU_VTINHERIT:
+          if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
+            return false;
+          break;
+ 
+        /* This relocation describes which C++ vtable entries are actually
+           used.  Record for later use during GC.  */
+        case R_FRV_GNU_VTENTRY:
+          if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+            return false;
+          break;
+        }
+    }
+ 
+  return true;
+}
+
+
+/* Return the machine subcode from the ELF e_flags header.  */
+
+static int
+elf32_frv_machine (abfd)
+     bfd *abfd;
+{
+  switch (elf_elfheader (abfd)->e_flags & EF_FRV_CPU_MASK)
+    {
+    default:		    break;
+    case EF_FRV_CPU_FR500:  return bfd_mach_fr500;
+    case EF_FRV_CPU_FR400:  return bfd_mach_fr400;
+    case EF_FRV_CPU_FR300:  return bfd_mach_fr300;
+    case EF_FRV_CPU_SIMPLE: return bfd_mach_frvsimple;
+    case EF_FRV_CPU_TOMCAT: return bfd_mach_frvtomcat;
+    }
+
+  return bfd_mach_frv;
+}
+
+/* Set the right machine number for a FRV ELF file.  */
+
+static boolean
+elf32_frv_object_p (abfd)
+     bfd *abfd;
+{
+  bfd_default_set_arch_mach (abfd, bfd_arch_frv, elf32_frv_machine (abfd));
+  return true;
+}
+
+/* Function to set the ELF flag bits.  */
+
+static boolean
+frv_elf_set_private_flags (abfd, flags)
+     bfd *abfd;
+     flagword flags;
+{
+  elf_elfheader (abfd)->e_flags = flags;
+  elf_flags_init (abfd) = true;
+  return true;
+}
+
+/* Copy backend specific data from one object module to another.  */
+
+static boolean
+frv_elf_copy_private_bfd_data (ibfd, obfd)
+     bfd *ibfd;
+     bfd *obfd;
+{
+  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
+      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
+    return true;
+
+  BFD_ASSERT (!elf_flags_init (obfd)
+	      || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
+
+  elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
+  elf_flags_init (obfd) = true;
+  return true;
+}
+
+/* Merge backend specific data from an object file to the output
+   object file when linking.  */
+
+static boolean
+frv_elf_merge_private_bfd_data (ibfd, obfd)
+     bfd *ibfd;
+     bfd *obfd;
+{
+  flagword old_flags, old_partial;
+  flagword new_flags, new_partial;
+  boolean error = false;
+  char new_opt[80];
+  char old_opt[80];
+
+  new_opt[0] = old_opt[0] = '\0';
+  new_flags = elf_elfheader (ibfd)->e_flags;
+  old_flags = elf_elfheader (obfd)->e_flags;
+
+#ifdef DEBUG
+  (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
+			 old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
+			 bfd_get_filename (ibfd));
+#endif
+
+  if (!elf_flags_init (obfd))			/* First call, no flags set.  */
+    {
+      elf_flags_init (obfd) = true;
+      old_flags = new_flags;
+    }
+
+  else if (new_flags == old_flags)		/* Compatible flags are ok.  */
+    ;
+
+  else						/* Possibly incompatible flags.  */
+    {
+      /* Warn if different # of gprs are used.  Note, 0 means nothing is
+         said about the size of gprs.  */
+      new_partial = (new_flags & EF_FRV_GPR_MASK);
+      old_partial = (old_flags & EF_FRV_GPR_MASK);
+      if (new_partial == old_partial)
+	;
+
+      else if (new_partial == 0)
+	;
+
+      else if (old_partial == 0)
+	old_flags |= new_partial;
+
+      else
+	{
+	  switch (new_partial)
+	    {
+	    default:		strcat (new_opt, " -mgpr-??"); break;
+	    case EF_FRV_GPR_32: strcat (new_opt, " -mgpr-32"); break;
+	    case EF_FRV_GPR_64: strcat (new_opt, " -mgpr-64"); break;
+	    }
+
+	  switch (old_partial)
+	    {
+	    default:		strcat (old_opt, " -mgpr-??"); break;
+	    case EF_FRV_GPR_32: strcat (old_opt, " -mgpr-32"); break;
+	    case EF_FRV_GPR_64: strcat (old_opt, " -mgpr-64"); break;
+	    }
+	}
+
+      /* Warn if different # of fprs are used.  Note, 0 means nothing is
+         said about the size of fprs.  */
+      new_partial = (new_flags & EF_FRV_FPR_MASK);
+      old_partial = (old_flags & EF_FRV_FPR_MASK);
+      if (new_partial == old_partial)
+	;
+
+      else if (new_partial == 0)
+	;
+
+      else if (old_partial == 0)
+	old_flags |= new_partial;
+
+      else
+	{
+	  switch (new_partial)
+	    {
+	    default:		  strcat (new_opt, " -mfpr-?");      break;
+	    case EF_FRV_FPR_32:   strcat (new_opt, " -mfpr-32");     break;
+	    case EF_FRV_FPR_64:   strcat (new_opt, " -mfpr-64");     break;
+	    case EF_FRV_FPR_NONE: strcat (new_opt, " -msoft-float"); break;
+	    }
+
+	  switch (old_partial)
+	    {
+	    default:		  strcat (old_opt, " -mfpr-?");      break;
+	    case EF_FRV_FPR_32:   strcat (old_opt, " -mfpr-32");     break;
+	    case EF_FRV_FPR_64:   strcat (old_opt, " -mfpr-64");     break;
+	    case EF_FRV_FPR_NONE: strcat (old_opt, " -msoft-float"); break;
+	    }
+	}
+
+      /* Warn if different dword support was used.  Note, 0 means nothing is
+         said about the dword support.  */
+      new_partial = (new_flags & EF_FRV_DWORD_MASK);
+      old_partial = (old_flags & EF_FRV_DWORD_MASK);
+      if (new_partial == old_partial)
+	;
+
+      else if (new_partial == 0)
+	;
+
+      else if (old_partial == 0)
+	old_flags |= new_partial;
+
+      else
+	{
+	  switch (new_partial)
+	    {
+	    default:		   strcat (new_opt, " -mdword-?");  break;
+	    case EF_FRV_DWORD_YES: strcat (new_opt, " -mdword");    break;
+	    case EF_FRV_DWORD_NO:  strcat (new_opt, " -mno-dword"); break;
+	    }
+
+	  switch (old_partial)
+	    {
+	    default:		   strcat (old_opt, " -mdword-?");  break;
+	    case EF_FRV_DWORD_YES: strcat (old_opt, " -mdword");    break;
+	    case EF_FRV_DWORD_NO:  strcat (old_opt, " -mno-dword"); break;
+	    }
+	}
+
+      /* Or in flags that accumulate (ie, if one module uses it, mark that the
+	 feature is used.  */
+      old_flags |= new_flags & (EF_FRV_DOUBLE
+				| EF_FRV_MEDIA
+				| EF_FRV_MULADD
+				| EF_FRV_NON_PIC_RELOCS);
+
+      /* If any module was compiled without -G0, clear the G0 bit.  */
+      old_flags = ((old_flags & ~ EF_FRV_G0)
+		   | (old_flags & new_flags & EF_FRV_G0));
+
+      /* If any module was compiled without -mnopack, clear the mnopack bit.  */
+      old_flags = ((old_flags & ~ EF_FRV_NOPACK)
+		   | (old_flags & new_flags & EF_FRV_NOPACK));
+
+      /* We don't have to do anything if the pic flags are the same, or the new
+         module(s) were compiled with -mlibrary-pic.  */
+      new_partial = (new_flags & EF_FRV_PIC_FLAGS);
+      old_partial = (old_flags & EF_FRV_PIC_FLAGS);
+      if ((new_partial == old_partial) || ((new_partial & EF_FRV_LIBPIC) != 0))
+	;
+
+      /* If the old module(s) were compiled with -mlibrary-pic, copy in the pic
+         flags if any from the new module.  */
+      else if ((old_partial & EF_FRV_LIBPIC) != 0)
+	old_flags = (old_flags & ~ EF_FRV_PIC_FLAGS) | new_partial;
+
+      /* If we have mixtures of -fpic and -fPIC, or in both bits.  */
+      else if (new_partial != 0 && old_partial != 0)
+	old_flags |= new_partial;
+
+      /* One module was compiled for pic and the other was not, see if we have
+         had any relocations that are not pic-safe.  */
+      else
+	{
+	  if ((old_flags & EF_FRV_NON_PIC_RELOCS) == 0)
+	    old_flags |= new_partial;
+	  else
+	    {
+	      old_flags &= ~ EF_FRV_PIC_FLAGS;
+#ifndef FRV_NO_PIC_ERROR
+	      error = true;
+	      (*_bfd_error_handler)
+		(_("%s: compiled with %s and linked with modules that use non-pic relocations"),
+		 bfd_get_filename (ibfd),
+		 (new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
+#endif
+	    }
+	}
+
+      /* Warn if different cpu is used (allow a specific cpu to override
+	 the generic cpu).  */
+      new_partial = (new_flags & EF_FRV_CPU_MASK);
+      old_partial = (old_flags & EF_FRV_CPU_MASK);
+      if (new_partial == old_partial)
+	;
+
+      else if (new_partial == EF_FRV_CPU_GENERIC)
+	;
+
+      else if (old_partial == EF_FRV_CPU_GENERIC)
+	old_flags = (old_flags & ~EF_FRV_CPU_MASK) | new_partial;
+
+      else
+	{
+	  switch (new_partial)
+	    {
+	    default:		     strcat (new_opt, " -mcpu=?");      break;
+	    case EF_FRV_CPU_GENERIC: strcat (new_opt, " -mcpu=frv");    break;
+	    case EF_FRV_CPU_SIMPLE:  strcat (new_opt, " -mcpu=simple"); break;
+	    case EF_FRV_CPU_FR500:   strcat (new_opt, " -mcpu=fr500");  break;
+	    case EF_FRV_CPU_FR400:   strcat (new_opt, " -mcpu=fr400");  break;
+	    case EF_FRV_CPU_FR300:   strcat (new_opt, " -mcpu=fr300");  break;
+	    case EF_FRV_CPU_TOMCAT:  strcat (new_opt, " -mcpu=tomcat"); break;
+	    }
+
+	  switch (old_partial)
+	    {
+	    default:		     strcat (old_opt, " -mcpu=?");      break;
+	    case EF_FRV_CPU_GENERIC: strcat (old_opt, " -mcpu=frv");    break;
+	    case EF_FRV_CPU_SIMPLE:  strcat (old_opt, " -mcpu=simple"); break;
+	    case EF_FRV_CPU_FR500:   strcat (old_opt, " -mcpu=fr500");  break;
+	    case EF_FRV_CPU_FR400:   strcat (old_opt, " -mcpu=fr400");  break;
+	    case EF_FRV_CPU_FR300:   strcat (old_opt, " -mcpu=fr300");  break;
+	    case EF_FRV_CPU_TOMCAT:  strcat (old_opt, " -mcpu=tomcat"); break;
+	    }
+	}
+      
+      /* Print out any mismatches from above.  */
+      if (new_opt[0])
+	{
+	  error = true;
+	  (*_bfd_error_handler)
+	    (_("%s: compiled with %s and linked with modules compiled with %s"),
+	     bfd_get_filename (ibfd), new_opt, old_opt);
+	}
+
+      /* Warn about any other mismatches */
+      new_partial = (new_flags & ~ EF_FRV_ALL_FLAGS);
+      old_partial = (old_flags & ~ EF_FRV_ALL_FLAGS);
+      if (new_partial != old_partial)
+	{
+	  old_flags |= new_partial;
+	  error = true;
+	  (*_bfd_error_handler)
+	    (_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),
+	     bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);
+	}
+    }
+
+  /* If the cpu is -mcpu=simple, then set the -mnopack bit.  */
+  if ((old_flags & EF_FRV_CPU_MASK) == EF_FRV_CPU_SIMPLE)
+    old_flags |= EF_FRV_NOPACK;
+
+  /* Update the old flags now with changes made above.  */
+  old_partial = elf_elfheader (obfd)->e_flags & EF_FRV_CPU_MASK;
+  elf_elfheader (obfd)->e_flags = old_flags;
+  if (old_partial != (old_flags & EF_FRV_CPU_MASK))
+    bfd_default_set_arch_mach (obfd, bfd_arch_frv, elf32_frv_machine (obfd));
+
+  if (error)
+    bfd_set_error (bfd_error_bad_value);
+
+  return !error;
+}
+
+
+boolean
+frv_elf_print_private_bfd_data (abfd, ptr)
+     bfd *abfd;
+     PTR ptr;
+{
+  FILE *file = (FILE *) ptr;
+  flagword flags;
+
+  BFD_ASSERT (abfd != NULL && ptr != NULL);
+
+  /* Print normal ELF private data.  */
+  _bfd_elf_print_private_bfd_data (abfd, ptr);
+
+  flags = elf_elfheader (abfd)->e_flags;
+  fprintf (file, _("private flags = 0x%lx:"), (long)flags);
+
+  switch (flags & EF_FRV_CPU_MASK)
+    {
+    default:							break;
+    case EF_FRV_CPU_SIMPLE: fprintf (file, " -mcpu=simple");	break;
+    case EF_FRV_CPU_FR500:  fprintf (file, " -mcpu=fr500");	break;
+    case EF_FRV_CPU_FR400:  fprintf (file, " -mcpu=fr400");	break;
+    case EF_FRV_CPU_FR300:  fprintf (file, " -mcpu=fr300");	break;
+    case EF_FRV_CPU_TOMCAT: fprintf (file, " -mcpu=tomcat");	break;
+    }
+
+  switch (flags & EF_FRV_GPR_MASK)
+    {
+    default:							break;
+    case EF_FRV_GPR_32: fprintf (file, " -mgpr-32");		break;
+    case EF_FRV_GPR_64: fprintf (file, " -mgpr-64");		break;
+    }
+
+  switch (flags & EF_FRV_FPR_MASK)
+    {
+    default:							break;
+    case EF_FRV_FPR_32:   fprintf (file, " -mfpr-32");		break;
+    case EF_FRV_FPR_64:   fprintf (file, " -mfpr-64");		break;
+    case EF_FRV_FPR_NONE: fprintf (file, " -msoft-float");	break;
+    }
+
+  switch (flags & EF_FRV_DWORD_MASK)
+    {
+    default:							break;
+    case EF_FRV_DWORD_YES: fprintf (file, " -mdword");		break;
+    case EF_FRV_DWORD_NO:  fprintf (file, " -mno-dword");	break;
+    }
+
+  if (flags & EF_FRV_DOUBLE)
+    fprintf (file, " -mdouble");
+
+  if (flags & EF_FRV_MEDIA)
+    fprintf (file, " -mmedia");
+
+  if (flags & EF_FRV_MULADD)
+    fprintf (file, " -mmuladd");
+
+  if (flags & EF_FRV_PIC)
+    fprintf (file, " -fpic");
+
+  if (flags & EF_FRV_BIGPIC)
+    fprintf (file, " -fPIC");
+
+  if (flags & EF_FRV_NON_PIC_RELOCS)
+    fprintf (file, " non-pic relocations");
+
+  if (flags & EF_FRV_G0)
+    fprintf (file, " -G0");
+
+  fputc ('\n', file);
+  return true;
+}
+
+
+#define ELF_ARCH		bfd_arch_frv
+#define ELF_MACHINE_CODE	EM_CYGNUS_FRV
+#define ELF_MAXPAGESIZE		0x1000
+
+#define TARGET_BIG_SYM          bfd_elf32_frv_vec
+#define TARGET_BIG_NAME		"elf32-frv"
+
+#define elf_info_to_howto_rel			NULL
+#define elf_info_to_howto			frv_info_to_howto_rela
+#define elf_backend_relocate_section		elf32_frv_relocate_section
+#define elf_backend_gc_mark_hook		elf32_frv_gc_mark_hook
+#define elf_backend_gc_sweep_hook		elf32_frv_gc_sweep_hook
+#define elf_backend_check_relocs                elf32_frv_check_relocs
+#define elf_backend_object_p			elf32_frv_object_p
+#define elf_backend_add_symbol_hook             elf32_frv_add_symbol_hook
+
+#define elf_backend_can_gc_sections		1
+
+#define bfd_elf32_bfd_reloc_type_lookup		frv_reloc_type_lookup
+#define bfd_elf32_bfd_set_private_flags		frv_elf_set_private_flags
+#define bfd_elf32_bfd_copy_private_bfd_data	frv_elf_copy_private_bfd_data
+#define bfd_elf32_bfd_merge_private_bfd_data	frv_elf_merge_private_bfd_data
+#define bfd_elf32_bfd_print_private_bfd_data	frv_elf_print_private_bfd_data
+
+#include "elf32-target.h"
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
new file mode 100644
index 00000000000..db1d7d4f185
--- /dev/null
+++ b/gdb/ada-lang.c
@@ -0,0 +1,8618 @@
+/* Ada language support routines for GDB, the GNU debugger.  Copyright
+   1992, 1993, 1994, 1997, 1998, 1999, 2000 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include "demangle.h"
+#include "defs.h"
+#include "symtab.h"
+#include "gdbtypes.h"
+#include "gdbcmd.h"
+#include "expression.h"
+#include "parser-defs.h"
+#include "language.h"
+#include "c-lang.h"
+#include "inferior.h"
+#include "symfile.h"
+#include "objfiles.h"
+#include "breakpoint.h"
+#include "gdbcore.h"
+#include "ada-lang.h"
+#ifdef UI_OUT
+#include "ui-out.h"
+#endif
+
+struct cleanup* unresolved_names;
+
+void extract_string (CORE_ADDR addr, char *buf);
+
+static struct type * ada_create_fundamental_type (struct objfile *, int);
+
+static void modify_general_field (char *, LONGEST, int, int);
+
+static struct type* desc_base_type (struct type*);
+
+static struct type* desc_bounds_type (struct type*);
+
+static struct value* desc_bounds (struct value*);
+
+static int fat_pntr_bounds_bitpos (struct type*);
+
+static int fat_pntr_bounds_bitsize (struct type*);
+
+static struct type* desc_data_type (struct type*);
+
+static struct value* desc_data (struct value*);
+
+static int fat_pntr_data_bitpos (struct type*);
+
+static int fat_pntr_data_bitsize (struct type*);
+
+static struct value* desc_one_bound (struct value*, int, int);
+
+static int desc_bound_bitpos (struct type*, int, int);
+
+static int desc_bound_bitsize (struct type*, int, int);
+
+static struct type*  desc_index_type (struct type*, int);
+
+static int desc_arity (struct type*);
+
+static int ada_type_match (struct type*, struct type*, int);
+
+static int ada_args_match (struct symbol*, struct value**, int);
+
+static struct value* place_on_stack (struct value*, CORE_ADDR*);
+
+static struct value* convert_actual (struct value*, struct type*, CORE_ADDR*);
+
+static struct value* make_array_descriptor (struct type*, struct value*, CORE_ADDR*);
+
+static void ada_add_block_symbols (struct block*, const char*,
+				   namespace_enum, struct objfile*, int);
+
+static void fill_in_ada_prototype (struct symbol*);
+
+static int is_nonfunction (struct symbol**, int);
+
+static void add_defn_to_vec (struct symbol*, struct block*);
+
+static struct partial_symbol* 
+ada_lookup_partial_symbol (struct partial_symtab*, const char*, 
+			   int, namespace_enum, int);
+
+static struct symtab* symtab_for_sym (struct symbol*);
+
+static struct value* ada_resolve_subexp (struct expression**, int*, int, struct type*);
+
+static void replace_operator_with_call (struct expression**, int, int, int,
+					struct symbol*, struct block*);
+
+static int possible_user_operator_p (enum exp_opcode, struct value**);
+
+static const char* ada_op_name (enum exp_opcode);
+
+static int numeric_type_p (struct type*);
+
+static int integer_type_p (struct type*);
+
+static int scalar_type_p (struct type*);
+
+static int discrete_type_p (struct type*);
+
+static char* extended_canonical_line_spec (struct symtab_and_line, const char*);
+
+static struct value* evaluate_subexp (struct type*, struct expression*, int*, enum noside);
+
+static struct value* evaluate_subexp_type (struct expression*, int*);
+
+static struct type * ada_create_fundamental_type (struct objfile*, int);
+
+static int  is_dynamic_field (struct type *, int);
+
+static struct type*
+to_fixed_variant_branch_type (struct type*, char*, CORE_ADDR, struct value*);
+
+static struct type* to_fixed_range_type (char*, struct value*, struct objfile*);
+
+static struct type* to_static_fixed_type (struct type*);
+
+static struct value* unwrap_value (struct value*);
+
+static struct type* packed_array_type (struct type*, long*);
+
+static struct type* decode_packed_array_type (struct type*);
+
+static struct value* decode_packed_array (struct value*);
+
+static struct value* value_subscript_packed (struct value*, int, struct value**);
+
+static struct value* coerce_unspec_val_to_type (struct value*, long, struct type*);
+
+static struct value* get_var_value (char*, char*);
+
+static int lesseq_defined_than (struct symbol*, struct symbol*);
+
+static int equiv_types (struct type*, struct type*);
+
+static int is_name_suffix (const char*);
+
+static int wild_match (const char*, int, const char*);
+
+static struct symtabs_and_lines find_sal_from_funcs_and_line (const char*, int, struct symbol**, int);
+
+static int
+find_line_in_linetable (struct linetable*, int, struct symbol**, int, int*);
+
+static int find_next_line_in_linetable (struct linetable*, int, int, int);
+
+static struct symtabs_and_lines all_sals_for_line (const char*, int, char***);
+
+static void read_all_symtabs (const char*);
+
+static int is_plausible_func_for_line (struct symbol*, int);
+
+static struct value*  ada_coerce_ref (struct value*);
+
+static struct value* value_pos_atr (struct value*);
+
+static struct value* value_val_atr (struct type*, struct value*);
+
+static struct symbol* standard_lookup (const char*, namespace_enum);
+
+extern void markTimeStart (int index);
+extern void markTimeStop (int index);
+
+
+
+/* Maximum-sized dynamic type. */
+static unsigned int varsize_limit;
+
+static const char* ada_completer_word_break_characters =
+  " \t\n!@#$%^&*()+=|~`}{[]\";:?/,-";
+
+/* The name of the symbol to use to get the name of the main subprogram */
+#define ADA_MAIN_PROGRAM_SYMBOL_NAME "__gnat_ada_main_program_name"
+
+				/* Utilities */
+
+/* extract_string
+ *
+ * read the string located at ADDR from the inferior and store the
+ * result into BUF
+ */
+void
+extract_string (CORE_ADDR addr, char *buf)
+{
+   int char_index = 0;
+
+   /* Loop, reading one byte at a time, until we reach the '\000' 
+      end-of-string marker */
+   do
+   {
+     target_read_memory (addr + char_index * sizeof (char), 
+                         buf + char_index * sizeof (char), 
+                         sizeof (char));
+     char_index++;
+   }
+   while (buf[char_index - 1] != '\000');
+}
+
+/* Assuming *OLD_VECT points to an array of *SIZE objects of size
+   ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
+   updating *OLD_VECT and *SIZE as necessary. */
+
+void
+grow_vect (old_vect, size, min_size, element_size)
+     void** old_vect;
+     size_t* size;
+     size_t min_size;
+     int element_size;
+{
+  if (*size < min_size) {
+    *size *= 2;
+    if (*size < min_size)
+      *size = min_size;
+    *old_vect = xrealloc (*old_vect, *size * element_size);
+  }
+}
+
+/* True (non-zero) iff TARGET matches FIELD_NAME up to any trailing
+   suffix of FIELD_NAME beginning "___" */
+
+static int
+field_name_match (field_name, target)
+     const char *field_name;
+     const char *target;
+{
+  int len = strlen (target);
+  return 
+    STREQN (field_name, target, len) 
+    && (field_name[len] == '\0' 
+	|| (STREQN (field_name + len, "___", 3)
+	   && ! STREQ (field_name + strlen (field_name) - 6, "___XVN")));
+}
+
+
+/* The length of the prefix of NAME prior to any "___" suffix. */
+
+int
+ada_name_prefix_len (name)
+     const char* name;
+{
+  if (name == NULL)
+    return 0;
+  else 
+    {
+      const char* p = strstr (name, "___");
+      if (p == NULL)
+	return strlen (name);
+      else
+	return p - name;
+    }
+}
+
+/* SUFFIX is a suffix of STR. False if STR is null. */
+static int
+is_suffix (const char* str, const char* suffix)
+{
+  int len1, len2;
+  if (str == NULL)
+    return 0;
+  len1 = strlen (str);
+  len2 = strlen (suffix);
+  return (len1 >= len2 && STREQ (str + len1 - len2, suffix));
+}
+
+/* Create a value of type TYPE whose contents come from VALADDR, if it
+ * is non-null, and whose memory address (in the inferior) is
+ * ADDRESS. */
+struct value*
+value_from_contents_and_address (type, valaddr, address)
+     struct type* type;
+     char* valaddr;
+     CORE_ADDR address;
+{
+  struct value* v = allocate_value (type);
+  if (valaddr == NULL) 
+    VALUE_LAZY (v) = 1;
+  else
+    memcpy (VALUE_CONTENTS_RAW (v), valaddr, TYPE_LENGTH (type));
+  VALUE_ADDRESS (v) = address;
+  if (address != 0)
+    VALUE_LVAL (v) = lval_memory;
+  return v;
+}
+
+/* The contents of value VAL, beginning at offset OFFSET, treated as a
+   value of type TYPE.  The result is an lval in memory if VAL is. */
+
+static struct value*
+coerce_unspec_val_to_type (val, offset, type)
+     struct value* val;
+     long offset;
+     struct type *type;
+{
+  CHECK_TYPEDEF (type);
+  if (VALUE_LVAL (val) == lval_memory)
+    return value_at_lazy (type,
+      VALUE_ADDRESS (val) + VALUE_OFFSET (val) + offset, NULL);
+  else 
+    {
+      struct value* result = allocate_value (type);
+      VALUE_LVAL (result) = not_lval;
+      if (VALUE_ADDRESS (val) == 0) 
+	memcpy (VALUE_CONTENTS_RAW (result), VALUE_CONTENTS (val) + offset,
+		TYPE_LENGTH (type) > TYPE_LENGTH (VALUE_TYPE (val)) 
+		? TYPE_LENGTH (VALUE_TYPE (val)) : TYPE_LENGTH (type));
+      else 
+	{
+	  VALUE_ADDRESS (result) = 
+	    VALUE_ADDRESS (val) + VALUE_OFFSET (val) + offset;
+	  VALUE_LAZY (result) = 1;
+	}
+      return result;
+    }
+}
+
+static char*
+cond_offset_host (valaddr, offset)
+     char* valaddr;
+     long offset;
+{
+  if (valaddr == NULL)
+    return NULL;
+  else
+    return valaddr + offset;
+}
+
+static CORE_ADDR
+cond_offset_target (address, offset)
+     CORE_ADDR address;
+     long offset;
+{
+  if (address == 0)
+    return 0;
+  else 
+    return address + offset;
+}
+
+/* Perform execute_command on the result of concatenating all
+   arguments up to NULL. */
+static void
+do_command (const char* arg, ...)
+{
+  int len;
+  char* cmd;
+  const char* s;
+  va_list ap;
+
+  va_start (ap, arg);
+  len = 0;
+  s = arg;
+  cmd = "";
+  for (; s != NULL; s = va_arg (ap, const char*)) 
+    {
+      char* cmd1;
+      len += strlen (s);
+      cmd1 = alloca (len+1);
+      strcpy (cmd1, cmd);
+      strcat (cmd1, s);
+      cmd = cmd1;
+    }
+  va_end (ap);
+  execute_command (cmd, 0);
+}
+
+
+				/* Language Selection */
+
+/* If the main program is in Ada, return language_ada, otherwise return LANG
+   (the main program is in Ada iif the adainit symbol is found).
+
+   MAIN_PST is not used. */
+   
+enum language
+ada_update_initial_language (lang, main_pst)
+     enum language lang;
+     struct partial_symtab* main_pst;
+{
+  if (lookup_minimal_symbol ("adainit", (const char*) NULL,
+			     (struct objfile*) NULL) != NULL)
+    /*    return language_ada; */
+    /* FIXME: language_ada should be defined in defs.h */
+    return language_unknown;
+
+  return lang;
+}
+      
+
+				/* Symbols */
+
+/* Table of Ada operators and their GNAT-mangled names.  Last entry is pair 
+   of NULLs. */
+
+const struct ada_opname_map ada_opname_table[] =
+{
+  { "Oadd", "\"+\"", BINOP_ADD },
+  { "Osubtract", "\"-\"", BINOP_SUB },
+  { "Omultiply", "\"*\"", BINOP_MUL },
+  { "Odivide", "\"/\"", BINOP_DIV },
+  { "Omod", "\"mod\"", BINOP_MOD },
+  { "Orem", "\"rem\"", BINOP_REM },
+  { "Oexpon", "\"**\"", BINOP_EXP },
+  { "Olt", "\"<\"", BINOP_LESS },
+  { "Ole", "\"<=\"", BINOP_LEQ },
+  { "Ogt", "\">\"", BINOP_GTR },
+  { "Oge", "\">=\"", BINOP_GEQ },
+  { "Oeq", "\"=\"", BINOP_EQUAL },
+  { "One", "\"/=\"", BINOP_NOTEQUAL },
+  { "Oand", "\"and\"", BINOP_BITWISE_AND },
+  { "Oor", "\"or\"", BINOP_BITWISE_IOR },
+  { "Oxor", "\"xor\"", BINOP_BITWISE_XOR },
+  { "Oconcat", "\"&\"", BINOP_CONCAT },
+  { "Oabs", "\"abs\"", UNOP_ABS },
+  { "Onot", "\"not\"", UNOP_LOGICAL_NOT },
+  { "Oadd", "\"+\"", UNOP_PLUS },
+  { "Osubtract", "\"-\"", UNOP_NEG },
+  { NULL, NULL }
+};
+
+/* True if STR should be suppressed in info listings. */
+static int
+is_suppressed_name (str) 
+     const char* str;
+{
+  if (STREQN (str, "_ada_", 5))
+    str += 5;
+  if (str[0] == '_' || str[0] == '\000')
+    return 1;
+  else
+    {
+      const char* p;
+      const char* suffix = strstr (str, "___");
+      if (suffix != NULL && suffix[3] != 'X')
+	return 1;
+      if (suffix == NULL)
+	suffix = str + strlen (str);
+      for (p = suffix-1; p != str; p -= 1)
+	if (isupper (*p))
+	  {
+	    int i;
+	    if (p[0] == 'X' && p[-1] != '_')
+	      goto OK;
+	    if (*p != 'O')
+	      return 1;
+	    for (i = 0; ada_opname_table[i].mangled != NULL; i += 1)
+	      if (STREQN (ada_opname_table[i].mangled, p, 
+			  strlen (ada_opname_table[i].mangled)))
+		goto OK;
+	    return 1;
+	  OK: ;
+	  }
+      return 0;
+    }
+}
+
+/* The "mangled" form of DEMANGLED, according to GNAT conventions.
+ * The result is valid until the next call to ada_mangle. */
+char *
+ada_mangle (demangled)
+     const char* demangled;
+{
+  static char* mangling_buffer = NULL;
+  static size_t mangling_buffer_size = 0;
+  const char* p;
+  int k;
+  
+  if (demangled == NULL)
+    return NULL;
+
+  GROW_VECT (mangling_buffer, mangling_buffer_size, 2*strlen (demangled) + 10);
+
+  k = 0;
+  for (p = demangled; *p != '\0'; p += 1)
+    {
+      if (*p == '.') 
+	{
+	  mangling_buffer[k] = mangling_buffer[k+1] = '_';
+	  k += 2;
+	}
+      else if (*p == '"')
+	{
+	  const struct ada_opname_map* mapping;
+
+	  for (mapping = ada_opname_table;
+	       mapping->mangled != NULL && 
+	       ! STREQN (mapping->demangled, p, strlen (mapping->demangled));
+	       p += 1)
+	    ;
+	  if (mapping->mangled == NULL)
+	    error ("invalid Ada operator name: %s", p);
+	  strcpy (mangling_buffer+k, mapping->mangled);
+	  k += strlen (mapping->mangled);
+	  break;
+	}
+      else 
+	{
+	  mangling_buffer[k] = *p;
+	  k += 1;
+	}
+    }
+
+  mangling_buffer[k] = '\0';
+  return mangling_buffer;
+}
+
+/* Return NAME folded to lower case, or, if surrounded by single
+ * quotes, unfolded, but with the quotes stripped away.  Result good
+ * to next call. */
+char*
+ada_fold_name (const char* name)
+{
+  static char* fold_buffer = NULL;
+  static size_t fold_buffer_size = 0;
+
+  int len = strlen (name);
+  GROW_VECT (fold_buffer, fold_buffer_size, len+1);
+
+  if (name[0] == '\'')
+    {
+      strncpy (fold_buffer, name+1, len-2);
+      fold_buffer[len-2] = '\000';
+    }
+  else
+    {
+      int i;
+      for (i = 0; i <= len; i += 1)
+	fold_buffer[i] = tolower (name[i]);
+    }
+
+  return fold_buffer;
+}
+
+/* Demangle: 
+     1. Discard final __{DIGIT}+ or ${DIGIT}+
+     2. Convert other instances of embedded "__" to `.'.
+     3. Discard leading _ada_.
+     4. Convert operator names to the appropriate quoted symbols.
+     5. Remove everything after first ___ if it is followed by 
+        'X'.
+     6. Replace TK__ with __, and a trailing B or TKB with nothing.
+     7. Put symbols that should be suppressed in <...> brackets.
+     8. Remove trailing X[bn]* suffix (indicating names in package bodies).
+   The resulting string is valid until the next call of ada_demangle.
+  */
+
+char *
+ada_demangle (mangled)
+     const char* mangled;
+{
+  int i, j;
+  int len0;
+  const char* p;
+  char* demangled;
+  int at_start_name;
+  static char* demangling_buffer = NULL;
+  static size_t demangling_buffer_size = 0;
+  
+  if (STREQN (mangled, "_ada_", 5))
+    mangled += 5;
+
+  if (mangled[0] == '_' || mangled[0] == '<')
+    goto Suppress;
+
+  p = strstr (mangled, "___");
+  if (p == NULL)
+    len0 = strlen (mangled);
+  else 
+    {
+      if (p[3] == 'X')
+	len0 = p - mangled;
+      else
+	goto Suppress;
+    }
+  if (len0 > 3 && STREQ (mangled + len0 - 3, "TKB"))
+    len0 -= 3;
+  if (len0 > 1 && STREQ (mangled + len0 - 1, "B"))
+    len0 -= 1;
+
+  /* Make demangled big enough for possible expansion by operator name. */
+  GROW_VECT (demangling_buffer, demangling_buffer_size, 2*len0+1);
+  demangled = demangling_buffer;
+
+  if (isdigit (mangled[len0 - 1])) {
+    for (i = len0-2; i >= 0 && isdigit (mangled[i]); i -= 1)
+      ;
+    if (i > 1 && mangled[i] == '_' && mangled[i-1] == '_')
+      len0 = i - 1;
+    else if (mangled[i] == '$')
+      len0 = i;
+  }
+
+  for (i = 0, j = 0; i < len0 && ! isalpha (mangled[i]); i += 1, j += 1)
+    demangled[j] = mangled[i];
+
+  at_start_name = 1;
+  while (i < len0)
+    {
+      if (at_start_name && mangled[i] == 'O')
+	{
+	  int k;
+	  for (k = 0; ada_opname_table[k].mangled != NULL; k += 1)
+	    {
+	      int op_len = strlen (ada_opname_table[k].mangled); 
+	      if (STREQN (ada_opname_table[k].mangled+1, mangled+i+1, op_len-1)
+		  && ! isalnum (mangled[i + op_len]))
+		{
+		  strcpy (demangled + j, ada_opname_table[k].demangled);
+		  at_start_name = 0;
+		  i += op_len;
+		  j += strlen (ada_opname_table[k].demangled);
+		  break;
+		}
+	    }
+	  if (ada_opname_table[k].mangled != NULL)
+	    continue;
+	}
+      at_start_name = 0;
+
+      if (i < len0-4 && STREQN (mangled+i, "TK__", 4))
+	i += 2;
+      if (mangled[i] == 'X' && i != 0 && isalnum (mangled[i-1]))
+	{
+	  do
+	    i += 1;
+	  while (i < len0 && (mangled[i] == 'b' || mangled[i] == 'n'));
+	  if (i < len0)
+	    goto Suppress;
+	}
+      else if (i < len0-2 && mangled[i] == '_' && mangled[i+1] == '_') 
+	{
+	  demangled[j] = '.';
+	  at_start_name = 1;
+	  i += 2; j += 1;
+	}
+      else
+	{
+	  demangled[j] = mangled[i];
+	  i += 1;  j += 1;
+	}
+    }
+  demangled[j] = '\000';
+
+  for (i = 0; demangled[i] != '\0'; i += 1)
+    if (isupper (demangled[i]) || demangled[i] == ' ')
+      goto Suppress;
+
+  return demangled;
+
+Suppress:
+  GROW_VECT (demangling_buffer, demangling_buffer_size, 
+	     strlen (mangled) + 3);  
+  demangled = demangling_buffer;
+  if (mangled[0] == '<')
+    strcpy (demangled, mangled);
+  else
+    sprintf (demangled, "<%s>", mangled);
+  return demangled;
+
+}
+
+/* Returns non-zero iff SYM_NAME matches NAME, ignoring any trailing
+ * suffixes that encode debugging information or leading _ada_ on
+ * SYM_NAME (see is_name_suffix commentary for the debugging
+ * information that is ignored).  If WILD, then NAME need only match a
+ * suffix of SYM_NAME minus the same suffixes. Also returns 0 if
+ * either argument is NULL. */
+
+int
+ada_match_name (sym_name, name, wild)
+     const char* sym_name;
+     const char* name;
+     int wild;
+{
+  if (sym_name == NULL || name == NULL)
+    return 0;
+  else if (wild)
+    return wild_match (name, strlen (name), sym_name);
+  else {
+    int len_name = strlen (name);
+    return (STREQN (sym_name, name, len_name) 
+	    && is_name_suffix (sym_name+len_name))
+      ||   (STREQN (sym_name, "_ada_", 5) 
+	    && STREQN (sym_name+5, name, len_name)
+	    && is_name_suffix (sym_name+len_name+5));
+  }
+}
+
+/* True (non-zero) iff in Ada mode, the symbol SYM should be
+   suppressed in info listings. */
+
+int
+ada_suppress_symbol_printing (sym)
+     struct symbol *sym;
+{
+  if (SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE)
+    return 1;
+  else 
+    return is_suppressed_name (SYMBOL_NAME (sym));
+}
+
+
+				/* Arrays */
+
+/* Names of MAX_ADA_DIMENS bounds in P_BOUNDS fields of 
+   array descriptors.  */
+
+static char* bound_name[] = {
+  "LB0", "UB0", "LB1", "UB1", "LB2", "UB2", "LB3", "UB3", 
+  "LB4", "UB4", "LB5", "UB5", "LB6", "UB6", "LB7", "UB7"
+};
+
+/* Maximum number of array dimensions we are prepared to handle.  */
+
+#define MAX_ADA_DIMENS (sizeof(bound_name) / (2*sizeof(char*)))
+
+/* Like modify_field, but allows bitpos > wordlength. */
+
+static void
+modify_general_field (addr, fieldval, bitpos, bitsize)
+     char *addr;
+     LONGEST fieldval;
+     int bitpos, bitsize;
+{
+  modify_field (addr + sizeof (LONGEST) * bitpos / (8 * sizeof (LONGEST)), 
+		fieldval, bitpos % (8 * sizeof (LONGEST)), 
+		bitsize);
+}
+
+
+/* The desc_* routines return primitive portions of array descriptors 
+   (fat pointers). */
+
+/* The descriptor or array type, if any, indicated by TYPE; removes
+   level of indirection, if needed. */
+static struct type*
+desc_base_type (type)
+     struct type* type;
+{
+  if (type == NULL)
+    return NULL;
+  CHECK_TYPEDEF (type);
+  if (type != NULL && TYPE_CODE (type) == TYPE_CODE_PTR)
+    return check_typedef (TYPE_TARGET_TYPE (type));
+  else
+    return type;
+}
+
+/* True iff TYPE indicates a "thin" array pointer type. */
+static int
+is_thin_pntr (struct type* type)
+{
+  return 
+    is_suffix (ada_type_name (desc_base_type (type)), "___XUT")
+    || is_suffix (ada_type_name (desc_base_type (type)), "___XUT___XVE");
+}
+
+/* The descriptor type for thin pointer type TYPE. */
+static struct type*
+thin_descriptor_type (struct type* type)
+{
+  struct type* base_type = desc_base_type (type);
+  if (base_type == NULL)
+    return NULL;
+  if (is_suffix (ada_type_name (base_type), "___XVE"))
+    return base_type;
+  else 
+    {
+      struct type* alt_type = 
+	ada_find_parallel_type (base_type, "___XVE");
+      if (alt_type == NULL)
+	return base_type;
+      else
+	return alt_type;
+    }
+}
+
+/* A pointer to the array data for thin-pointer value VAL. */
+static struct value*
+thin_data_pntr (struct value* val)
+{
+  struct type* type = VALUE_TYPE (val);
+  if (TYPE_CODE (type) == TYPE_CODE_PTR)
+    return value_cast (desc_data_type (thin_descriptor_type (type)), 
+		       value_copy (val));
+  else	
+    return value_from_longest (desc_data_type (thin_descriptor_type (type)),
+			       VALUE_ADDRESS (val) + VALUE_OFFSET (val));
+}
+
+/* True iff TYPE indicates a "thick" array pointer type. */
+static int
+is_thick_pntr (struct type* type) 
+{
+  type = desc_base_type (type);
+  return (type != NULL && TYPE_CODE (type) == TYPE_CODE_STRUCT
+	  && lookup_struct_elt_type (type, "P_BOUNDS", 1) != NULL);
+}
+
+/* If TYPE is the type of an array descriptor (fat or thin pointer) or a 
+   pointer to one, the type of its bounds data; otherwise, NULL. */
+static struct type*
+desc_bounds_type (type)
+     struct type* type;
+{
+  struct type* r;
+
+  type = desc_base_type (type);
+
+  if (type == NULL)
+    return NULL;
+  else if (is_thin_pntr (type))
+    {
+      type = thin_descriptor_type (type);
+      if (type == NULL)
+	return NULL;
+      r = lookup_struct_elt_type (type, "BOUNDS", 1);
+      if (r != NULL)
+	return check_typedef (r);
+    }
+  else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
+    {
+      r = lookup_struct_elt_type (type, "P_BOUNDS", 1);
+      if (r != NULL)
+	return check_typedef (TYPE_TARGET_TYPE (check_typedef (r)));
+    }
+  return NULL;
+}
+
+/* If ARR is an array descriptor (fat or thin pointer), or pointer to
+   one, a pointer to its bounds data.   Otherwise NULL. */
+static struct value*
+desc_bounds (arr)
+     struct value* arr;
+{
+  struct type* type = check_typedef (VALUE_TYPE (arr));
+  if (is_thin_pntr (type)) 
+    {
+      struct type* bounds_type = desc_bounds_type (thin_descriptor_type (type));
+      LONGEST addr;
+
+      if (desc_bounds_type == NULL)
+	error ("Bad GNAT array descriptor");
+
+      /* NOTE: The following calculation is not really kosher, but
+	 since desc_type is an XVE-encoded type (and shouldn't be),
+	 the correct calculation is a real pain. FIXME (and fix GCC). */
+      if (TYPE_CODE (type) == TYPE_CODE_PTR)
+	addr = value_as_long (arr);
+      else 
+	addr = VALUE_ADDRESS (arr) + VALUE_OFFSET (arr);
+
+      return 
+	  value_from_longest (lookup_pointer_type (bounds_type), 
+			      addr - TYPE_LENGTH (bounds_type));
+    }
+
+  else if (is_thick_pntr (type))
+    return value_struct_elt (&arr, NULL, "P_BOUNDS", NULL, 
+			     "Bad GNAT array descriptor");
+  else
+    return NULL;
+}
+
+/* If TYPE is the type of an array-descriptor (fat pointer), the bit
+   position of the field containing the address of the bounds data. */
+static int
+fat_pntr_bounds_bitpos (type)
+     struct type* type;
+{
+  return TYPE_FIELD_BITPOS (desc_base_type (type), 1);
+}
+
+/* If TYPE is the type of an array-descriptor (fat pointer), the bit
+   size of the field containing the address of the bounds data. */
+static int
+fat_pntr_bounds_bitsize (type)
+     struct type* type;
+{
+  type = desc_base_type (type);
+
+  if (TYPE_FIELD_BITSIZE (type, 1) > 0) 
+    return TYPE_FIELD_BITSIZE (type, 1);
+  else
+    return 8 * TYPE_LENGTH (check_typedef (TYPE_FIELD_TYPE (type, 1)));
+}
+
+/* If TYPE is the type of an array descriptor (fat or thin pointer) or a 
+   pointer to one, the type of its array data (a
+   pointer-to-array-with-no-bounds type); otherwise,  NULL.  Use
+   ada_type_of_array to get an array type with bounds data. */
+static struct type*
+desc_data_type (type)
+     struct type* type;
+{
+  type = desc_base_type (type);
+
+  /* NOTE: The following is bogus; see comment in desc_bounds. */
+  if (is_thin_pntr (type))
+    return lookup_pointer_type 
+      (desc_base_type (TYPE_FIELD_TYPE (thin_descriptor_type (type),1)));
+  else if (is_thick_pntr (type))
+    return lookup_struct_elt_type (type, "P_ARRAY", 1);
+  else
+    return NULL;
+}
+
+/* If ARR is an array descriptor (fat or thin pointer), a pointer to
+   its array data.  */
+static struct value*
+desc_data (arr)
+     struct value* arr;
+{
+  struct type* type = VALUE_TYPE (arr);
+  if (is_thin_pntr (type))
+    return thin_data_pntr (arr);
+  else if (is_thick_pntr (type))
+    return value_struct_elt (&arr, NULL, "P_ARRAY", NULL, 
+			     "Bad GNAT array descriptor");
+  else
+    return NULL;
+}
+
+
+/* If TYPE is the type of an array-descriptor (fat pointer), the bit
+   position of the field containing the address of the data. */
+static int
+fat_pntr_data_bitpos (type)
+     struct type* type;
+{
+  return TYPE_FIELD_BITPOS (desc_base_type (type), 0);
+}
+
+/* If TYPE is the type of an array-descriptor (fat pointer), the bit
+   size of the field containing the address of the data. */
+static int
+fat_pntr_data_bitsize (type)
+     struct type* type;
+{
+  type = desc_base_type (type);
+
+  if (TYPE_FIELD_BITSIZE (type, 0) > 0)
+    return TYPE_FIELD_BITSIZE (type, 0);
+  else 
+    return TARGET_CHAR_BIT * TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0));
+}
+
+/* If BOUNDS is an array-bounds structure (or pointer to one), return 
+   the Ith lower bound stored in it, if WHICH is 0, and the Ith upper
+   bound, if WHICH is 1.  The first bound is I=1. */
+static struct value*
+desc_one_bound (bounds, i, which)
+     struct value* bounds;
+     int i;
+     int which;
+{
+  return value_struct_elt (&bounds, NULL, bound_name[2*i+which-2], NULL,
+			   "Bad GNAT array descriptor bounds");
+}
+
+/* If BOUNDS is an array-bounds structure type, return the bit position
+   of the Ith lower bound stored in it, if WHICH is 0, and the Ith upper
+   bound, if WHICH is 1.  The first bound is I=1. */
+static int
+desc_bound_bitpos (type, i, which)
+     struct type* type;
+     int i;
+     int which;
+{
+  return TYPE_FIELD_BITPOS (desc_base_type (type), 2*i+which-2);
+}
+
+/* If BOUNDS is an array-bounds structure type, return the bit field size
+   of the Ith lower bound stored in it, if WHICH is 0, and the Ith upper
+   bound, if WHICH is 1.  The first bound is I=1. */
+static int
+desc_bound_bitsize (type, i, which)
+     struct type* type;
+     int i;
+     int which;
+{
+  type = desc_base_type (type);
+
+  if (TYPE_FIELD_BITSIZE (type, 2*i+which-2) > 0)
+    return TYPE_FIELD_BITSIZE (type, 2*i+which-2);
+  else 
+    return 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (type, 2*i+which-2));
+}
+
+/* If TYPE is the type of an array-bounds structure, the type of its
+   Ith bound (numbering from 1). Otherwise, NULL. */ 
+static struct type* 
+desc_index_type (type, i)
+     struct type* type;
+     int i;
+{
+  type = desc_base_type (type);
+
+  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
+    return lookup_struct_elt_type (type, bound_name[2*i-2], 1);
+  else 
+    return NULL;
+}
+
+/* The number of index positions in the array-bounds type TYPE.  0
+   if TYPE is NULL. */
+static int
+desc_arity (type)
+     struct type* type;
+{
+  type = desc_base_type (type);
+
+  if (type != NULL)
+    return TYPE_NFIELDS (type) / 2;
+  return 0;
+}
+
+
+/* Non-zero iff type is a simple array type (or pointer to one). */
+int
+ada_is_simple_array (type)
+     struct type* type;
+{
+  if (type == NULL)
+    return 0;
+  CHECK_TYPEDEF (type);
+  return (TYPE_CODE (type) == TYPE_CODE_ARRAY
+	  || (TYPE_CODE (type) == TYPE_CODE_PTR
+	      && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_ARRAY));
+}
+
+/* Non-zero iff type belongs to a GNAT array descriptor. */
+int
+ada_is_array_descriptor (type)
+     struct type* type;
+{
+  struct type* data_type = desc_data_type (type);
+
+  if (type == NULL)
+    return 0;
+  CHECK_TYPEDEF (type);
+  return 
+    data_type != NULL
+    && ((TYPE_CODE (data_type) == TYPE_CODE_PTR
+	 && TYPE_TARGET_TYPE (data_type) != NULL
+	 && TYPE_CODE (TYPE_TARGET_TYPE (data_type)) == TYPE_CODE_ARRAY)
+	|| 
+	TYPE_CODE (data_type) == TYPE_CODE_ARRAY)
+    && desc_arity (desc_bounds_type (type)) > 0;
+}
+
+/* Non-zero iff type is a partially mal-formed GNAT array
+   descriptor.  (FIXME: This is to compensate for some problems with 
+   debugging output from GNAT.  Re-examine periodically to see if it
+   is still needed. */
+int
+ada_is_bogus_array_descriptor (type)
+     struct type *type;
+{
+  return 
+    type != NULL
+    && TYPE_CODE (type) == TYPE_CODE_STRUCT
+    && (lookup_struct_elt_type (type, "P_BOUNDS", 1) != NULL
+	|| lookup_struct_elt_type (type, "P_ARRAY", 1) != NULL)
+    && ! ada_is_array_descriptor (type);
+}
+
+
+/* If ARR has a record type in the form of a standard GNAT array descriptor, 
+   (fat pointer) returns the type of the array data described---specifically,
+   a pointer-to-array type.  If BOUNDS is non-zero, the bounds data are filled 
+   in from the descriptor; otherwise, they are left unspecified.  If
+   the ARR denotes a null array descriptor and BOUNDS is non-zero, 
+   returns NULL.  The result is simply the type of ARR if ARR is not 
+   a descriptor.  */
+struct type*
+ada_type_of_array (arr, bounds)
+     struct value* arr;
+     int bounds;
+{
+  if (ada_is_packed_array_type (VALUE_TYPE (arr)))
+    return decode_packed_array_type (VALUE_TYPE (arr));
+
+  if (! ada_is_array_descriptor (VALUE_TYPE (arr)))
+    return VALUE_TYPE (arr);
+  
+  if (! bounds)
+    return check_typedef (TYPE_TARGET_TYPE (desc_data_type (VALUE_TYPE (arr))));
+  else
+    {
+      struct type* elt_type;
+      int arity;
+      struct value* descriptor;
+      struct objfile *objf = TYPE_OBJFILE (VALUE_TYPE (arr));
+
+      elt_type = ada_array_element_type (VALUE_TYPE (arr), -1);
+      arity = ada_array_arity (VALUE_TYPE (arr));
+
+      if (elt_type == NULL || arity == 0) 
+	return check_typedef (VALUE_TYPE (arr));
+
+      descriptor = desc_bounds (arr);
+      if (value_as_long (descriptor) == 0) 
+	return NULL;
+      while (arity > 0) {
+	struct type* range_type = alloc_type (objf);
+	struct type* array_type = alloc_type (objf);
+	struct value* low = desc_one_bound (descriptor, arity, 0);
+	struct value* high = desc_one_bound (descriptor, arity, 1);
+	arity -= 1;
+
+	create_range_type (range_type, VALUE_TYPE (low), 
+			   (int) value_as_long (low), 
+			   (int) value_as_long (high));
+	elt_type = create_array_type (array_type, elt_type, range_type);
+      }
+
+      return lookup_pointer_type (elt_type);
+    }
+}
+
+/* If ARR does not represent an array, returns ARR unchanged.
+   Otherwise, returns either a standard GDB array with bounds set 
+   appropriately or, if ARR is a non-null fat pointer, a pointer to a standard 
+   GDB array.  Returns NULL if ARR is a null fat pointer. */
+struct value*
+ada_coerce_to_simple_array_ptr (arr)
+     struct value* arr;
+{
+  if (ada_is_array_descriptor (VALUE_TYPE (arr)))
+    {
+      struct type* arrType = ada_type_of_array (arr, 1);
+      if (arrType == NULL)
+	return NULL;
+      return value_cast (arrType, value_copy (desc_data (arr)));
+    }
+  else if (ada_is_packed_array_type (VALUE_TYPE (arr)))
+    return decode_packed_array (arr);
+  else
+    return arr;
+}
+
+/* If ARR does not represent an array, returns ARR unchanged.
+   Otherwise, returns a standard GDB array describing ARR (which may
+   be ARR itself if it already is in the proper form). */
+struct value*
+ada_coerce_to_simple_array (arr)
+     struct value* arr;
+{
+  if (ada_is_array_descriptor (VALUE_TYPE (arr)))
+    {
+      struct value* arrVal = ada_coerce_to_simple_array_ptr (arr);
+      if (arrVal == NULL)
+	error ("Bounds unavailable for null array pointer.");
+      return value_ind (arrVal);
+    }
+  else if (ada_is_packed_array_type (VALUE_TYPE (arr)))
+    return decode_packed_array (arr);
+  else 
+    return arr;
+}
+
+/* If TYPE represents a GNAT array type, return it translated to an
+   ordinary GDB array type (possibly with BITSIZE fields indicating
+   packing). For other types, is the identity. */
+struct type*
+ada_coerce_to_simple_array_type (type)
+     struct type* type;
+{
+  struct value* mark = value_mark ();
+  struct value* dummy = value_from_longest (builtin_type_long, 0);
+  struct type* result;
+  VALUE_TYPE (dummy) = type;
+  result = ada_type_of_array (dummy, 0);
+  value_free_to_mark (dummy);
+  return result;
+}
+
+/* Non-zero iff TYPE represents a standard GNAT packed-array type. */
+int
+ada_is_packed_array_type (type)
+     struct type* type;
+{
+  if (type == NULL)
+    return 0;
+  CHECK_TYPEDEF (type);
+  return 
+    ada_type_name (type) != NULL
+    && strstr (ada_type_name (type), "___XP") != NULL;
+}
+
+/* Given that TYPE is a standard GDB array type with all bounds filled
+   in, and that the element size of its ultimate scalar constituents
+   (that is, either its elements, or, if it is an array of arrays, its
+   elements' elements, etc.) is *ELT_BITS, return an identical type,
+   but with the bit sizes of its elements (and those of any
+   constituent arrays) recorded in the BITSIZE components of its
+   TYPE_FIELD_BITSIZE values, and with *ELT_BITS set to its total size 
+   in bits. */
+static struct type*
+packed_array_type (type, elt_bits)
+     struct type* type;
+     long* elt_bits;
+{
+  struct type* new_elt_type;
+  struct type* new_type;
+  LONGEST low_bound, high_bound;
+
+  CHECK_TYPEDEF (type);
+  if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
+    return type;
+
+  new_type = alloc_type (TYPE_OBJFILE (type));
+  new_elt_type = packed_array_type (check_typedef (TYPE_TARGET_TYPE (type)),
+				    elt_bits);
+  create_array_type (new_type, new_elt_type, TYPE_FIELD_TYPE (type, 0));
+  TYPE_FIELD_BITSIZE (new_type, 0) = *elt_bits;
+  TYPE_NAME (new_type) = ada_type_name (type);
+
+  if (get_discrete_bounds (TYPE_FIELD_TYPE (type, 0), 
+			   &low_bound, &high_bound) < 0)
+    low_bound = high_bound = 0;
+  if (high_bound < low_bound)
+    *elt_bits = TYPE_LENGTH (new_type) = 0;
+  else 
+    {
+      *elt_bits *= (high_bound - low_bound + 1);
+      TYPE_LENGTH (new_type) = 
+	(*elt_bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
+    }
+
+  /*  TYPE_FLAGS (new_type) |= TYPE_FLAG_FIXED_INSTANCE; */
+  /* FIXME:  TYPE_FLAG_FIXED_INSTANCE should be defined in gdbtypes.h */
+  return new_type;
+}
+
+/* The array type encoded by TYPE, where ada_is_packed_array_type (TYPE).
+ */
+static struct type*
+decode_packed_array_type (type)
+     struct type* type;
+{
+  struct symbol** syms;
+  struct block** blocks;
+  const char* raw_name = ada_type_name (check_typedef (type));
+  char* name = (char*) alloca (strlen (raw_name) + 1);
+  char* tail = strstr (raw_name, "___XP");
+  struct type* shadow_type;
+  long bits;
+  int i, n;
+
+  memcpy (name, raw_name, tail - raw_name);
+  name[tail - raw_name] = '\000';
+
+  /* NOTE: Use ada_lookup_symbol_list because of bug in some versions
+   * of gcc (Solaris, e.g.). FIXME when compiler is fixed. */
+  n = ada_lookup_symbol_list (name, get_selected_block (NULL), 
+			      VAR_NAMESPACE, &syms, &blocks);
+  for (i = 0; i < n; i += 1)
+    if (syms[i] != NULL && SYMBOL_CLASS (syms[i]) == LOC_TYPEDEF
+	&& STREQ (name, ada_type_name (SYMBOL_TYPE (syms[i]))))
+      break;
+  if (i >= n)
+    {
+      warning ("could not find bounds information on packed array");
+      return NULL;
+    }
+  shadow_type = SYMBOL_TYPE (syms[i]);
+
+  if (TYPE_CODE (shadow_type) != TYPE_CODE_ARRAY)
+    {
+      warning ("could not understand bounds information on packed array");
+      return NULL;
+    }
+				 				 
+  if (sscanf (tail + sizeof ("___XP") - 1, "%ld", &bits) != 1)
+    {
+      warning ("could not understand bit size information on packed array");
+      return NULL;
+    }
+    
+  return packed_array_type (shadow_type, &bits);
+}
+
+/* Given that ARR is a struct value* indicating a GNAT packed array,
+   returns a simple array that denotes that array.  Its type is a
+   standard GDB array type except that the BITSIZEs of the array
+   target types are set to the number of bits in each element, and the
+   type length is set appropriately. */
+
+static struct value*
+decode_packed_array (arr)
+     struct value* arr;
+{
+  struct type* type = decode_packed_array_type (VALUE_TYPE (arr));
+
+  if (type == NULL)
+    {
+      error ("can't unpack array");
+      return NULL;
+    }
+  else
+    return coerce_unspec_val_to_type (arr, 0, type);
+}
+
+
+/* The value of the element of packed array ARR at the ARITY indices
+   given in IND.   ARR must be a simple array. */
+
+static struct value*
+value_subscript_packed (arr, arity, ind)
+     struct value* arr;
+     int arity;
+     struct value** ind;
+{
+  int i;
+  int bits, elt_off, bit_off;
+  long elt_total_bit_offset;
+  struct type* elt_type;
+  struct value* v;
+
+  bits = 0;
+  elt_total_bit_offset = 0;
+  elt_type = check_typedef (VALUE_TYPE (arr));
+  for (i = 0; i < arity; i += 1) 
+    {
+      if (TYPE_CODE (elt_type) != TYPE_CODE_ARRAY 
+	  || TYPE_FIELD_BITSIZE (elt_type, 0) == 0)
+	error ("attempt to do packed indexing of something other than a packed array");
+      else
+	{
+	  struct type *range_type = TYPE_INDEX_TYPE (elt_type);
+	  LONGEST lowerbound, upperbound;
+	  LONGEST idx;
+
+	  if (get_discrete_bounds (range_type, &lowerbound,
+				   &upperbound) < 0)
+	    {
+	      warning ("don't know bounds of array");
+	      lowerbound = upperbound = 0;
+	    }
+      
+	  idx = value_as_long (value_pos_atr (ind[i]));
+	  if (idx < lowerbound || idx > upperbound)
+	    warning ("packed array index %ld out of bounds", (long) idx);
+	  bits = TYPE_FIELD_BITSIZE (elt_type, 0);
+	  elt_total_bit_offset += (idx - lowerbound) * bits;
+	  elt_type = check_typedef (TYPE_TARGET_TYPE (elt_type));
+	}
+    }
+  elt_off = elt_total_bit_offset / HOST_CHAR_BIT;
+  bit_off = elt_total_bit_offset % HOST_CHAR_BIT;
+  
+  v = ada_value_primitive_packed_val (arr, NULL, elt_off, bit_off, 
+				      bits, elt_type);
+  if (VALUE_LVAL (arr) == lval_internalvar)
+    VALUE_LVAL (v) = lval_internalvar_component;
+  else
+    VALUE_LVAL (v) = VALUE_LVAL (arr);
+  return v;
+}
+
+/* Non-zero iff TYPE includes negative integer values. */
+
+static int
+has_negatives (type)
+     struct type* type;
+{
+  switch (TYPE_CODE (type)) {
+  default:
+    return 0;
+  case TYPE_CODE_INT:
+    return ! TYPE_UNSIGNED (type);
+  case TYPE_CODE_RANGE:
+    return TYPE_LOW_BOUND (type) < 0;
+  }
+}
+      
+
+/* Create a new value of type TYPE from the contents of OBJ starting
+   at byte OFFSET, and bit offset BIT_OFFSET within that byte,
+   proceeding for BIT_SIZE bits.  If OBJ is an lval in memory, then
+   assigning through the result will set the field fetched from. OBJ
+   may also be NULL, in which case, VALADDR+OFFSET must address the
+   start of storage containing the packed value.  The value returned 
+   in this case is never an lval.   
+   Assumes 0 <= BIT_OFFSET < HOST_CHAR_BIT. */
+
+struct value*
+ada_value_primitive_packed_val (obj, valaddr, offset, bit_offset, 
+				bit_size, type)
+     struct value* obj;
+     char* valaddr;
+     long offset;
+     int bit_offset;
+     int bit_size;
+     struct type* type;
+{
+  struct value* v;
+  int src,			/* Index into the source area. */
+    targ,			/* Index into the target area. */
+    i, 
+    srcBitsLeft, 		/* Number of source bits left to move. */
+    nsrc, ntarg,		/* Number of source and target bytes. */
+    unusedLS,			/* Number of bits in next significant
+				 * byte of source that are unused. */
+    accumSize;			/* Number of meaningful bits in accum */
+  unsigned char* bytes;   /* First byte containing data to unpack. */
+  unsigned char* unpacked;
+  unsigned long accum;		/* Staging area for bits being transferred */
+  unsigned char sign;
+  int len = (bit_size + bit_offset + HOST_CHAR_BIT - 1) / 8;
+  /* Transmit bytes from least to most significant; delta is the
+   * direction the indices move. */     
+  int delta = BITS_BIG_ENDIAN ? -1 : 1;
+
+  CHECK_TYPEDEF (type);
+
+  if (obj == NULL)
+    {
+      v = allocate_value (type);
+      bytes = (unsigned char*) (valaddr + offset);
+    }
+  else if (VALUE_LAZY (obj))
+    {
+      v = value_at (type,
+		    VALUE_ADDRESS (obj) + VALUE_OFFSET (obj) + offset, NULL);
+      bytes = (unsigned char*) alloca (len);
+      read_memory (VALUE_ADDRESS (v), bytes, len);
+    }
+  else 
+    {
+      v = allocate_value (type);
+      bytes = (unsigned char*) VALUE_CONTENTS (obj) + offset;
+    }
+      
+  if (obj != NULL) 
+    {
+      VALUE_LVAL (v) = VALUE_LVAL (obj);
+      if (VALUE_LVAL (obj) == lval_internalvar)
+	VALUE_LVAL (v) = lval_internalvar_component;
+      VALUE_ADDRESS (v) = VALUE_ADDRESS (obj) + VALUE_OFFSET (obj) + offset;
+      VALUE_BITPOS (v) = bit_offset + VALUE_BITPOS (obj);
+      VALUE_BITSIZE (v) = bit_size;
+      if (VALUE_BITPOS (v) >= HOST_CHAR_BIT)
+        {
+          VALUE_ADDRESS (v) += 1;
+          VALUE_BITPOS (v) -= HOST_CHAR_BIT;
+        }
+    }
+  else
+    VALUE_BITSIZE (v) = bit_size;
+  unpacked = (unsigned char*) VALUE_CONTENTS (v);
+
+  srcBitsLeft = bit_size;
+  nsrc = len;
+  ntarg = TYPE_LENGTH (type);
+  sign = 0;
+  if (bit_size == 0)
+    {
+      memset (unpacked, 0, TYPE_LENGTH (type));
+      return v;
+    }
+  else if (BITS_BIG_ENDIAN)
+    {
+      src = len-1;
+      if (has_negatives (type) && 
+	  ((bytes[0] << bit_offset) & (1 << (HOST_CHAR_BIT-1))))
+	sign = ~0;
+      
+      unusedLS = 
+	(HOST_CHAR_BIT - (bit_size + bit_offset) % HOST_CHAR_BIT)
+	% HOST_CHAR_BIT;
+
+      switch (TYPE_CODE (type))
+        {
+        case TYPE_CODE_ARRAY:
+        case TYPE_CODE_UNION:
+        case TYPE_CODE_STRUCT:
+          /* Non-scalar values must be aligned at a byte boundary. */
+          accumSize =
+            (HOST_CHAR_BIT - bit_size % HOST_CHAR_BIT) % HOST_CHAR_BIT;
+	  /* And are placed at the beginning (most-significant) bytes
+	   * of the target. */
+	  targ = src;
+          break;
+        default:
+	  accumSize = 0;
+	  targ = TYPE_LENGTH (type) - 1;
+          break;
+        }
+    }
+  else 
+    {
+      int sign_bit_offset = (bit_size + bit_offset - 1) % 8;
+
+      src = targ = 0;
+      unusedLS = bit_offset;
+      accumSize = 0;
+
+      if (has_negatives (type) && (bytes[len-1] & (1 << sign_bit_offset)))
+	sign = ~0;
+    }
+      
+  accum = 0;
+  while (nsrc > 0)
+    {
+      /* Mask for removing bits of the next source byte that are not
+       * part of the value. */
+      unsigned int unusedMSMask = 
+	(1 << (srcBitsLeft >= HOST_CHAR_BIT ? HOST_CHAR_BIT : srcBitsLeft))-1;
+      /* Sign-extend bits for this byte. */
+      unsigned int signMask = sign & ~unusedMSMask;
+      accum |= 
+	(((bytes[src] >> unusedLS) & unusedMSMask) | signMask) << accumSize;
+      accumSize += HOST_CHAR_BIT - unusedLS;
+      if (accumSize >= HOST_CHAR_BIT) 
+	{
+	  unpacked[targ] = accum & ~(~0L << HOST_CHAR_BIT);
+	  accumSize -= HOST_CHAR_BIT;
+	  accum >>= HOST_CHAR_BIT;
+	  ntarg -= 1;
+	  targ += delta;
+	}
+      srcBitsLeft -= HOST_CHAR_BIT - unusedLS;
+      unusedLS = 0;
+      nsrc -= 1;
+      src += delta;
+    }
+  while (ntarg > 0)
+    {
+      accum |= sign << accumSize;
+      unpacked[targ] = accum & ~(~0L << HOST_CHAR_BIT);
+      accumSize -= HOST_CHAR_BIT;
+      accum >>= HOST_CHAR_BIT;
+      ntarg -= 1;
+      targ += delta;
+    }
+
+  return v;
+}
+      
+/* Move N bits from SOURCE, starting at bit offset SRC_OFFSET to
+   TARGET, starting at bit offset TARG_OFFSET.  SOURCE and TARGET must
+   not overlap. */
+static void
+move_bits (char* target, int targ_offset, char* source, int src_offset, int n)
+{
+  unsigned int accum, mask;
+  int accum_bits, chunk_size;
+
+  target += targ_offset / HOST_CHAR_BIT;
+  targ_offset %= HOST_CHAR_BIT;
+  source += src_offset / HOST_CHAR_BIT;
+  src_offset %= HOST_CHAR_BIT;
+  if (BITS_BIG_ENDIAN) 
+    {
+      accum = (unsigned char) *source;
+      source += 1;
+      accum_bits = HOST_CHAR_BIT - src_offset;
+
+      while (n > 0) 
+	{
+	  int unused_right;
+	  accum = (accum << HOST_CHAR_BIT) + (unsigned char) *source;
+	  accum_bits += HOST_CHAR_BIT;
+	  source += 1;
+	  chunk_size = HOST_CHAR_BIT - targ_offset;
+	  if (chunk_size > n)
+	    chunk_size = n;
+	  unused_right = HOST_CHAR_BIT - (chunk_size + targ_offset);
+	  mask = ((1 << chunk_size) - 1) << unused_right;
+	  *target = 
+	    (*target & ~mask) 
+	    | ((accum >> (accum_bits - chunk_size - unused_right)) & mask);
+	  n -= chunk_size;
+	  accum_bits -= chunk_size;
+	  target += 1;
+	  targ_offset = 0;
+	}
+    }
+  else
+    {
+      accum = (unsigned char) *source >> src_offset;
+      source += 1;
+      accum_bits = HOST_CHAR_BIT - src_offset;
+
+      while (n > 0) 
+	{
+	  accum = accum + ((unsigned char) *source << accum_bits);
+	  accum_bits += HOST_CHAR_BIT;
+	  source += 1;
+	  chunk_size = HOST_CHAR_BIT - targ_offset;
+	  if (chunk_size > n)
+	    chunk_size = n;
+	  mask = ((1 << chunk_size) - 1) << targ_offset;
+	  *target = 
+	    (*target & ~mask) | ((accum << targ_offset) & mask);
+	  n -= chunk_size;
+	  accum_bits -= chunk_size;
+	  accum >>= chunk_size;
+	  target += 1;
+	  targ_offset = 0;
+	}
+    }
+}
+
+
+/* Store the contents of FROMVAL into the location of TOVAL.
+   Return a new value with the location of TOVAL and contents of
+   FROMVAL.   Handles assignment into packed fields that have
+   floating-point or non-scalar types. */
+
+static struct value*
+ada_value_assign (struct value* toval, struct value* fromval)
+{
+  struct type* type = VALUE_TYPE (toval);
+  int bits = VALUE_BITSIZE (toval);
+
+  if (!toval->modifiable)
+    error ("Left operand of assignment is not a modifiable lvalue.");
+
+  COERCE_REF (toval);
+
+  if (VALUE_LVAL (toval) == lval_memory 
+      && bits > 0
+      && (TYPE_CODE (type) == TYPE_CODE_FLT 
+	  || TYPE_CODE (type) == TYPE_CODE_STRUCT))
+    {
+      int len = 
+	(VALUE_BITPOS (toval) + bits + HOST_CHAR_BIT - 1)
+	/ HOST_CHAR_BIT;
+      char* buffer = (char*) alloca (len);
+      struct value* val;
+
+      if (TYPE_CODE (type) == TYPE_CODE_FLT)
+	fromval = value_cast (type, fromval);
+
+      read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval), buffer, len);
+      if (BITS_BIG_ENDIAN)
+	move_bits (buffer, VALUE_BITPOS (toval), 
+		   VALUE_CONTENTS (fromval), 
+		   TYPE_LENGTH (VALUE_TYPE (fromval)) * TARGET_CHAR_BIT - bits,
+		   bits);
+      else
+	move_bits (buffer, VALUE_BITPOS (toval), VALUE_CONTENTS (fromval), 
+		   0, bits);
+      write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval), buffer, len);
+
+      val = value_copy (toval);
+      memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
+	      TYPE_LENGTH (type));
+      VALUE_TYPE (val) = type;
+  
+      return val;
+    }
+
+  return value_assign (toval, fromval);
+}
+
+
+/* The value of the element of array ARR at the ARITY indices given in IND. 
+   ARR may be either a simple array, GNAT array descriptor, or pointer 
+   thereto.  */
+
+struct value*
+ada_value_subscript (arr, arity, ind)
+     struct value* arr;
+     int arity;
+     struct value** ind;
+{
+  int k;
+  struct value* elt;
+  struct type* elt_type;
+
+  elt = ada_coerce_to_simple_array (arr);
+
+  elt_type = check_typedef (VALUE_TYPE (elt));
+  if (TYPE_CODE (elt_type) == TYPE_CODE_ARRAY 
+      && TYPE_FIELD_BITSIZE (elt_type, 0) > 0)
+    return value_subscript_packed (elt, arity, ind);
+
+  for (k = 0; k < arity; k += 1)
+    {
+      if (TYPE_CODE (elt_type) != TYPE_CODE_ARRAY)
+	error("too many subscripts (%d expected)", k);
+      elt = value_subscript (elt, value_pos_atr (ind[k]));
+    }
+  return elt;
+}
+
+/* Assuming ARR is a pointer to a standard GDB array of type TYPE, the
+   value of the element of *ARR at the ARITY indices given in
+   IND. Does not read the entire array into memory. */
+
+struct value*
+ada_value_ptr_subscript (arr, type, arity, ind)
+     struct value* arr;
+     struct type* type;
+     int arity;
+     struct value** ind;
+{
+  int k;
+
+  for (k = 0; k < arity; k += 1)
+    {
+      LONGEST lwb, upb;
+      struct value* idx;
+
+      if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
+	error("too many subscripts (%d expected)", k);
+      arr = value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)), 
+			value_copy (arr));
+      get_discrete_bounds (TYPE_INDEX_TYPE (type), &lwb, &upb);
+      if (lwb == 0) 
+	idx = ind[k];
+      else
+	idx = value_sub (ind[k], value_from_longest (builtin_type_int, lwb));
+      arr = value_add (arr, idx);
+      type = TYPE_TARGET_TYPE (type);
+    }
+
+  return value_ind (arr);
+}
+
+/* If type is a record type in the form of a standard GNAT array
+   descriptor, returns the number of dimensions for type.  If arr is a
+   simple array, returns the number of "array of"s that prefix its
+   type designation. Otherwise, returns 0. */
+
+int
+ada_array_arity (type)
+     struct type* type;
+{
+  int arity;
+
+  if (type == NULL)
+    return 0;
+
+  type = desc_base_type (type);
+
+  arity = 0;
+  if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 
+    return desc_arity (desc_bounds_type (type));
+  else 
+    while (TYPE_CODE (type) == TYPE_CODE_ARRAY) 
+      {
+	arity += 1;
+	type = check_typedef (TYPE_TARGET_TYPE (type));
+      }
+	    
+  return arity;
+}
+
+/* If TYPE is a record type in the form of a standard GNAT array
+   descriptor or a simple array type, returns the element type for
+   TYPE after indexing by NINDICES indices, or by all indices if
+   NINDICES is -1. Otherwise, returns NULL. */
+
+struct type*
+ada_array_element_type (type, nindices)
+     struct type* type;
+     int nindices;
+{
+  type = desc_base_type (type);
+
+  if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 
+    {
+      int k;
+      struct type* p_array_type;
+
+      p_array_type = desc_data_type (type);
+
+      k = ada_array_arity (type);
+      if (k == 0)
+	return NULL;
+      
+      /* Initially p_array_type = elt_type(*)[]...(k times)...[] */
+      if (nindices >= 0 && k > nindices)
+	k = nindices;
+      p_array_type = TYPE_TARGET_TYPE (p_array_type);
+      while (k > 0 && p_array_type != NULL) 
+	{
+	  p_array_type = check_typedef (TYPE_TARGET_TYPE (p_array_type));
+	  k -= 1;
+	}
+      return p_array_type;
+    }
+  else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+    {
+      while (nindices != 0 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
+	{
+	  type = TYPE_TARGET_TYPE (type);
+	  nindices -= 1;
+	}
+      return type;
+    }
+
+  return NULL;
+}
+
+/* The type of nth index in arrays of given type (n numbering from 1).  Does 
+   not examine memory. */
+
+struct type*
+ada_index_type (type, n)
+     struct type* type;
+     int n;
+{
+  type = desc_base_type (type);
+
+  if (n > ada_array_arity (type))
+    return NULL;
+
+  if (ada_is_simple_array (type))
+    {
+      int i;
+
+      for (i = 1; i < n; i += 1)
+	type = TYPE_TARGET_TYPE (type);
+
+      return TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0));
+    }
+  else 
+    return desc_index_type (desc_bounds_type (type), n);
+}
+
+/* Given that arr is an array type, returns the lower bound of the
+   Nth index (numbering from 1) if WHICH is 0, and the upper bound if
+   WHICH is 1. This returns bounds 0 .. -1 if ARR_TYPE is an
+   array-descriptor type.  If TYPEP is non-null, *TYPEP is set to the 
+   bounds type.  It works for other arrays with bounds supplied by 
+   run-time quantities other than discriminants. */
+
+LONGEST
+ada_array_bound_from_type (arr_type, n, which, typep)
+     struct type* arr_type;
+     int n; 
+     int which;
+     struct type** typep;
+{
+  struct type* type;
+  struct type* index_type_desc;
+
+  if (ada_is_packed_array_type (arr_type))
+    arr_type = decode_packed_array_type (arr_type);
+
+  if (arr_type == NULL || ! ada_is_simple_array (arr_type)) 
+    {
+      if (typep != NULL)
+	*typep = builtin_type_int;
+      return (LONGEST) -which;
+    }
+
+  if (TYPE_CODE (arr_type) == TYPE_CODE_PTR)
+    type = TYPE_TARGET_TYPE (arr_type);
+  else
+    type = arr_type;
+
+  index_type_desc = ada_find_parallel_type (type, "___XA");
+  if (index_type_desc == NULL) 
+    {
+      struct type* range_type;
+      struct type* index_type;
+
+      while (n > 1) 
+	{
+	  type = TYPE_TARGET_TYPE (type);
+	  n -= 1;
+	}
+
+      range_type = TYPE_INDEX_TYPE (type);
+      index_type = TYPE_TARGET_TYPE (range_type);
+      if (TYPE_CODE (index_type) == TYPE_CODE_UNDEF)
+	  index_type = builtin_type_long;
+      if (typep != NULL)
+	*typep = index_type;
+      return 
+	(LONGEST) (which == 0 
+		   ? TYPE_LOW_BOUND (range_type)
+		   : TYPE_HIGH_BOUND (range_type));
+    }
+  else 
+    {
+      struct type* index_type =
+	to_fixed_range_type (TYPE_FIELD_NAME (index_type_desc, n-1),
+			     NULL, TYPE_OBJFILE (arr_type));
+      if (typep != NULL)
+	*typep = TYPE_TARGET_TYPE (index_type);
+      return 
+	(LONGEST) (which == 0 
+		   ? TYPE_LOW_BOUND (index_type)
+		   : TYPE_HIGH_BOUND (index_type));
+    }
+}
+
+/* Given that arr is an array value, returns the lower bound of the
+   nth index (numbering from 1) if which is 0, and the upper bound if
+   which is 1. This routine will also work for arrays with bounds
+   supplied by run-time quantities other than discriminants. */
+
+struct value*
+ada_array_bound (arr, n, which)
+     struct value* arr;
+     int n; 
+     int which;
+{
+  struct type* arr_type = VALUE_TYPE (arr);
+
+  if (ada_is_packed_array_type (arr_type))
+    return ada_array_bound (decode_packed_array (arr), n, which);
+  else if (ada_is_simple_array (arr_type)) 
+    {
+      struct type* type;
+      LONGEST v = ada_array_bound_from_type (arr_type, n, which, &type);
+      return value_from_longest (type, v);
+    }
+  else
+    return desc_one_bound (desc_bounds (arr), n, which);
+}
+
+/* Given that arr is an array value, returns the length of the
+   nth index.  This routine will also work for arrays with bounds
+   supplied by run-time quantities other than discriminants. Does not
+   work for arrays indexed by enumeration types with representation
+   clauses at the moment. */ 
+
+struct value*
+ada_array_length (arr, n)
+     struct value* arr;
+     int n; 
+{
+  struct type* arr_type = check_typedef (VALUE_TYPE (arr));
+  struct type* index_type_desc;
+
+  if (ada_is_packed_array_type (arr_type))
+    return ada_array_length (decode_packed_array (arr), n);
+
+  if (ada_is_simple_array (arr_type))
+    {
+      struct type* type;
+      LONGEST v =
+	ada_array_bound_from_type (arr_type, n, 1, &type) -
+	ada_array_bound_from_type (arr_type, n, 0, NULL) + 1;
+      return value_from_longest (type, v);
+    }
+  else
+    return 
+      value_from_longest (builtin_type_ada_int,
+			  value_as_long (desc_one_bound (desc_bounds (arr),
+							 n, 1))
+			  - value_as_long (desc_one_bound (desc_bounds (arr),
+							   n, 0))
+			  + 1);
+}
+
+
+				/* Name resolution */
+
+/* The "demangled" name for the user-definable Ada operator corresponding
+   to op. */
+
+static const char*
+ada_op_name (op)
+     enum exp_opcode op;
+{
+  int i;
+
+  for (i = 0; ada_opname_table[i].mangled != NULL; i += 1)
+    {
+      if (ada_opname_table[i].op == op)
+	return ada_opname_table[i].demangled;
+    }
+  error ("Could not find operator name for opcode");
+}
+
+
+/* Same as evaluate_type (*EXP), but resolves ambiguous symbol 
+   references (OP_UNRESOLVED_VALUES) and converts operators that are 
+   user-defined into appropriate function calls.  If CONTEXT_TYPE is 
+   non-null, it provides a preferred result type [at the moment, only
+   type void has any effect---causing procedures to be preferred over
+   functions in calls].  A null CONTEXT_TYPE indicates that a non-void
+   return type is preferred.  The variable unresolved_names contains a list
+   of character strings referenced by expout that should be freed.  
+   May change (expand) *EXP.  */
+
+void
+ada_resolve (expp, context_type)
+     struct expression** expp;
+     struct type* context_type;
+{
+  int pc;
+  pc = 0;
+  ada_resolve_subexp (expp, &pc, 1, context_type);
+}
+
+/* Resolve the operator of the subexpression beginning at 
+   position *POS of *EXPP. "Resolving" consists of replacing
+   OP_UNRESOLVED_VALUE with an appropriate OP_VAR_VALUE, replacing
+   built-in operators with function calls to user-defined operators,
+   where appropriate, and (when DEPROCEDURE_P is non-zero), converting
+   function-valued variables into parameterless calls.  May expand
+   EXP. The CONTEXT_TYPE functions as in ada_resolve, above. */
+
+static struct value*
+ada_resolve_subexp (expp, pos, deprocedure_p, context_type) 
+     struct expression** expp;
+     int *pos;
+     int deprocedure_p;
+     struct type* context_type;
+{
+  int pc = *pos;
+  int i;
+  struct expression* exp;	/* Convenience: == *expp */
+  enum exp_opcode op = (*expp)->elts[pc].opcode;
+  struct value** argvec;		/* Vector of operand types (alloca'ed). */
+  int nargs;			/* Number of operands */
+
+  argvec = NULL;
+  nargs = 0;
+  exp = *expp;
+
+  /* Pass one: resolve operands, saving their types and updating *pos. */
+  switch (op)
+    {
+    case OP_VAR_VALUE:
+      /*    case OP_UNRESOLVED_VALUE:*/
+      /* FIXME:  OP_UNRESOLVED_VALUE should be defined in expression.h */
+      *pos += 4;
+      break;
+
+    case OP_FUNCALL:
+      nargs = longest_to_int (exp->elts[pc + 1].longconst) + 1;
+      /* FIXME:  OP_UNRESOLVED_VALUE should be defined in expression.h */
+      /*      if (exp->elts[pc+3].opcode == OP_UNRESOLVED_VALUE) 	
+	{
+	  *pos += 7;
+
+	  argvec = (struct value* *) alloca (sizeof (struct value*) * (nargs + 1));
+	  for (i = 0; i < nargs-1; i += 1)
+	    argvec[i] = ada_resolve_subexp (expp, pos, 1, NULL);
+	  argvec[i] = NULL;
+	}
+      else
+	{
+	  *pos += 3;
+	  ada_resolve_subexp (expp, pos, 0, NULL);
+	  for (i = 1; i < nargs; i += 1)
+	    ada_resolve_subexp (expp, pos, 1, NULL);
+	}
+      */
+      exp = *expp;
+      break;
+
+      /* FIXME:  UNOP_QUAL should be defined in expression.h */
+      /*    case UNOP_QUAL:
+      nargs = 1;
+      *pos += 3;
+      ada_resolve_subexp (expp, pos, 1, exp->elts[pc + 1].type);
+      exp = *expp;
+      break;
+      */
+      /* FIXME:  OP_ATTRIBUTE should be defined in expression.h */      
+      /*    case OP_ATTRIBUTE:
+      nargs = longest_to_int (exp->elts[pc + 1].longconst) + 1;
+      *pos += 4;
+      for (i = 0; i < nargs; i += 1)
+	ada_resolve_subexp (expp, pos, 1, NULL);
+      exp = *expp;
+      break;
+      */
+    case UNOP_ADDR:
+      nargs = 1;
+      *pos += 1;
+      ada_resolve_subexp (expp, pos, 0, NULL);
+      exp = *expp;
+      break;
+
+    case BINOP_ASSIGN:
+      {
+	struct value* arg1;
+	nargs = 2;
+	*pos += 1;
+	arg1 = ada_resolve_subexp (expp, pos, 0, NULL);
+	if (arg1 == NULL)
+	  ada_resolve_subexp (expp, pos, 1, NULL);
+	else
+	  ada_resolve_subexp (expp, pos, 1, VALUE_TYPE (arg1));
+	break;
+      }
+
+    default:
+      switch (op) 
+	{
+	default:
+	  error ("Unexpected operator during name resolution");
+	case UNOP_CAST:
+	  /*	case UNOP_MBR:
+	  nargs = 1;
+	  *pos += 3;
+	  break;
+	  */
+	case BINOP_ADD:
+	case BINOP_SUB:
+	case BINOP_MUL:
+	case BINOP_DIV:
+	case BINOP_REM:
+	case BINOP_MOD:
+	case BINOP_EXP:
+	case BINOP_CONCAT:
+	case BINOP_LOGICAL_AND:
+	case BINOP_LOGICAL_OR:
+	case BINOP_BITWISE_AND:
+	case BINOP_BITWISE_IOR:
+	case BINOP_BITWISE_XOR:
+
+	case BINOP_EQUAL:
+	case BINOP_NOTEQUAL:
+	case BINOP_LESS:
+	case BINOP_GTR:
+	case BINOP_LEQ:
+	case BINOP_GEQ:
+
+	case BINOP_REPEAT:
+	case BINOP_SUBSCRIPT:
+	case BINOP_COMMA:
+	  nargs = 2;
+	  *pos += 1;
+	  break;
+
+	case UNOP_NEG:
+	case UNOP_PLUS:
+	case UNOP_LOGICAL_NOT:
+	case UNOP_ABS:
+	case UNOP_IND:
+	  nargs = 1;
+	  *pos += 1;
+	  break;
+
+	case OP_LONG:
+	case OP_DOUBLE:
+	case OP_VAR_VALUE:
+	  *pos += 4;
+	  break;
+
+	case OP_TYPE:
+	case OP_BOOL:
+	case OP_LAST:
+	case OP_REGISTER:
+	case OP_INTERNALVAR:
+	  *pos += 3;
+	  break;
+
+	case UNOP_MEMVAL:
+	  *pos += 3;
+	  nargs = 1;
+	  break;
+
+	case STRUCTOP_STRUCT:
+	case STRUCTOP_PTR:
+	  nargs = 1;
+	  *pos += 4 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
+	  break;
+
+	case OP_ARRAY:
+	  *pos += 4;  
+	  nargs = longest_to_int (exp->elts[pc + 2].longconst) + 1;
+	  nargs -= longest_to_int (exp->elts[pc + 1].longconst);
+	  /* A null array contains one dummy element to give the type. */
+	  /*	  if (nargs == 0)
+	    nargs = 1;
+	    break;*/
+
+	case TERNOP_SLICE:
+	  /* FIXME: TERNOP_MBR should be defined in expression.h */
+	  /*	case TERNOP_MBR:
+	  *pos += 1;
+	  nargs = 3;
+	  break;
+	  */
+	  /* FIXME: BINOP_MBR should be defined in expression.h */
+	  /*	case BINOP_MBR:
+	  *pos += 3;
+	  nargs = 2;
+	  break;*/
+	}
+
+      argvec = (struct value* *) alloca (sizeof (struct value*) * (nargs + 1));
+      for (i = 0; i < nargs; i += 1)
+	argvec[i] = ada_resolve_subexp (expp, pos, 1, NULL);
+      argvec[i] = NULL;
+      exp = *expp;
+      break;
+    }
+
+  /* Pass two: perform any resolution on principal operator. */
+  switch (op)
+    {
+    default:
+      break;
+
+      /* FIXME:  OP_UNRESOLVED_VALUE should be defined in expression.h */
+      /*    case OP_UNRESOLVED_VALUE:
+      {
+	struct symbol** candidate_syms;
+	struct block** candidate_blocks;
+	int n_candidates;
+
+	n_candidates = ada_lookup_symbol_list (exp->elts[pc + 2].name,
+					       exp->elts[pc + 1].block,
+					       VAR_NAMESPACE,
+					       &candidate_syms,
+					       &candidate_blocks);
+	
+	if (n_candidates > 1) 
+	{*/
+	    /* Types tend to get re-introduced locally, so if there
+	       are any local symbols that are not types, first filter
+	       out all types.*/	       /*
+	    int j;
+	    for (j = 0; j < n_candidates; j += 1) 
+	      switch (SYMBOL_CLASS (candidate_syms[j])) 
+		{
+		case LOC_REGISTER:
+		case LOC_ARG:
+		case LOC_REF_ARG:
+		case LOC_REGPARM:
+		case LOC_REGPARM_ADDR:
+		case LOC_LOCAL:
+		case LOC_LOCAL_ARG:
+		case LOC_BASEREG:
+		case LOC_BASEREG_ARG:
+		  goto FoundNonType;
+		default:
+		  break;
+		}
+	  FoundNonType:
+	    if (j < n_candidates) 
+	      {
+		j = 0;
+		while (j < n_candidates) 
+		  {
+		    if (SYMBOL_CLASS (candidate_syms[j]) == LOC_TYPEDEF)
+		      {
+			candidate_syms[j] = candidate_syms[n_candidates-1];
+			candidate_blocks[j] = candidate_blocks[n_candidates-1];
+			n_candidates -= 1;
+		      }
+		    else
+		      j += 1;
+		  }
+	      }
+	  }
+
+	if (n_candidates == 0)
+	  error ("No definition found for %s", 
+		 ada_demangle (exp->elts[pc + 2].name));
+	else if (n_candidates == 1)
+	  i = 0;
+	else if (deprocedure_p 
+		 && ! is_nonfunction (candidate_syms, n_candidates))
+	  {
+	    i = ada_resolve_function (candidate_syms, candidate_blocks,
+				      n_candidates, NULL, 0,
+				      exp->elts[pc + 2].name, context_type);
+	    if (i < 0) 
+	      error ("Could not find a match for %s", 
+		     ada_demangle (exp->elts[pc + 2].name));
+	  }
+	else 
+	  {
+	    printf_filtered ("Multiple matches for %s\n", 
+			     ada_demangle (exp->elts[pc+2].name));
+	    user_select_syms (candidate_syms, candidate_blocks, 
+			      n_candidates, 1);
+	    i = 0;
+	  }
+
+	exp->elts[pc].opcode = exp->elts[pc + 3].opcode = OP_VAR_VALUE;
+	exp->elts[pc + 1].block = candidate_blocks[i];
+	exp->elts[pc + 2].symbol = candidate_syms[i];
+	if (innermost_block == NULL ||
+	    contained_in (candidate_blocks[i], innermost_block))
+	  innermost_block = candidate_blocks[i];
+      }*/
+      /* FALL THROUGH */
+
+    case OP_VAR_VALUE:
+      if (deprocedure_p && 
+	  TYPE_CODE (SYMBOL_TYPE (exp->elts[pc+2].symbol)) == TYPE_CODE_FUNC)
+	{
+	  replace_operator_with_call (expp, pc, 0, 0, 
+				      exp->elts[pc+2].symbol,
+				      exp->elts[pc+1].block);
+	  exp = *expp;
+	}
+      break;
+
+    case OP_FUNCALL:
+      {
+	/* FIXME:  OP_UNRESOLVED_VALUE should be defined in expression.h */
+	/*	if (exp->elts[pc+3].opcode == OP_UNRESOLVED_VALUE) 	
+	  {
+	    struct symbol** candidate_syms;
+	    struct block** candidate_blocks;
+	    int n_candidates;
+
+	    n_candidates = ada_lookup_symbol_list (exp->elts[pc + 5].name,
+						   exp->elts[pc + 4].block,
+						   VAR_NAMESPACE,
+						   &candidate_syms,
+						   &candidate_blocks);
+	    if (n_candidates == 1)
+	      i = 0;
+	    else
+	      {
+		i = ada_resolve_function (candidate_syms, candidate_blocks,
+					  n_candidates, argvec, nargs-1,
+					  exp->elts[pc + 5].name, context_type);
+		if (i < 0) 
+		  error ("Could not find a match for %s", 
+			 ada_demangle (exp->elts[pc + 5].name));
+	      }
+
+	    exp->elts[pc + 3].opcode = exp->elts[pc + 6].opcode = OP_VAR_VALUE;
+	    exp->elts[pc + 4].block = candidate_blocks[i];
+	    exp->elts[pc + 5].symbol = candidate_syms[i];
+	    if (innermost_block == NULL ||
+		contained_in (candidate_blocks[i], innermost_block))
+	      innermost_block = candidate_blocks[i];
+	      }*/
+	
+      }
+      break;
+    case BINOP_ADD:
+    case BINOP_SUB:
+    case BINOP_MUL:
+    case BINOP_DIV:
+    case BINOP_REM:
+    case BINOP_MOD:
+    case BINOP_CONCAT:
+    case BINOP_BITWISE_AND:
+    case BINOP_BITWISE_IOR:
+    case BINOP_BITWISE_XOR:
+    case BINOP_EQUAL:
+    case BINOP_NOTEQUAL:
+    case BINOP_LESS:
+    case BINOP_GTR:
+    case BINOP_LEQ:
+    case BINOP_GEQ:
+    case BINOP_EXP:
+    case UNOP_NEG:
+    case UNOP_PLUS:
+    case UNOP_LOGICAL_NOT:
+    case UNOP_ABS:
+      if (possible_user_operator_p (op, argvec))
+	{
+	  struct symbol** candidate_syms;
+	  struct block** candidate_blocks;
+	  int n_candidates;
+
+	  n_candidates = ada_lookup_symbol_list (ada_mangle (ada_op_name (op)),
+						 (struct block*) NULL,
+						 VAR_NAMESPACE,
+						 &candidate_syms,
+						 &candidate_blocks);
+	  i = ada_resolve_function (candidate_syms, candidate_blocks,
+				    n_candidates, argvec, nargs,
+				    ada_op_name (op), NULL);
+	  if (i < 0)
+	    break;
+
+	  replace_operator_with_call (expp, pc, nargs, 1,
+				      candidate_syms[i], candidate_blocks[i]);
+	  exp = *expp;
+	}
+      break;
+    }
+
+  *pos = pc;
+  return evaluate_subexp_type (exp, pos);
+}
+
+/* Return non-zero if formal type FTYPE matches actual type ATYPE.  If
+   MAY_DEREF is non-zero, the formal may be a pointer and the actual 
+   a non-pointer. */ 
+/* The term "match" here is rather loose.  The match is heuristic and
+   liberal.  FIXME: TOO liberal, in fact. */
+
+static int
+ada_type_match (ftype, atype, may_deref)
+     struct type* ftype;
+     struct type* atype;
+     int may_deref;
+{
+  CHECK_TYPEDEF (ftype);
+  CHECK_TYPEDEF (atype);
+
+  if (TYPE_CODE (ftype) == TYPE_CODE_REF)
+    ftype = TYPE_TARGET_TYPE (ftype);
+  if (TYPE_CODE (atype) == TYPE_CODE_REF)
+    atype = TYPE_TARGET_TYPE (atype);
+
+  if (TYPE_CODE (ftype) == TYPE_CODE_VOID 
+      || TYPE_CODE (atype) == TYPE_CODE_VOID)
+    return 1;
+
+  switch (TYPE_CODE (ftype)) 
+    {
+    default:
+      return 1;
+    case TYPE_CODE_PTR:
+      if (TYPE_CODE (atype) == TYPE_CODE_PTR)
+	return ada_type_match (TYPE_TARGET_TYPE (ftype),
+			       TYPE_TARGET_TYPE (atype), 0);
+      else return (may_deref && 
+		   ada_type_match (TYPE_TARGET_TYPE (ftype), atype, 0));
+    case TYPE_CODE_INT:
+    case TYPE_CODE_ENUM:
+    case TYPE_CODE_RANGE:
+      switch (TYPE_CODE (atype))
+	{
+	case TYPE_CODE_INT:
+	case TYPE_CODE_ENUM:
+	case TYPE_CODE_RANGE:
+	  return 1;
+	default:
+	  return 0;
+	}
+
+    case TYPE_CODE_ARRAY:
+      return (TYPE_CODE (atype) == TYPE_CODE_ARRAY 
+	      || ada_is_array_descriptor (atype));
+
+    case TYPE_CODE_STRUCT:
+      if (ada_is_array_descriptor (ftype))
+	return (TYPE_CODE (atype) == TYPE_CODE_ARRAY 
+		|| ada_is_array_descriptor (atype));
+      else
+	return (TYPE_CODE (atype) == TYPE_CODE_STRUCT
+		&& ! ada_is_array_descriptor (atype));
+
+    case TYPE_CODE_UNION:
+    case TYPE_CODE_FLT:
+      return (TYPE_CODE (atype) == TYPE_CODE (ftype));
+    }
+}
+
+/* Return non-zero if the formals of FUNC "sufficiently match" the
+   vector of actual argument types ACTUALS of size N_ACTUALS.  FUNC
+   may also be an enumeral, in which case it is treated as a 0-
+   argument function. */
+
+static int
+ada_args_match (func, actuals, n_actuals)
+     struct symbol* func;
+     struct value** actuals;
+     int n_actuals;
+{
+  int i;
+  struct type* func_type = SYMBOL_TYPE (func);
+
+  if (SYMBOL_CLASS (func) == LOC_CONST && 
+      TYPE_CODE (func_type) == TYPE_CODE_ENUM)
+    return (n_actuals == 0);
+  else if (func_type == NULL || TYPE_CODE (func_type) != TYPE_CODE_FUNC)
+    return 0;
+
+  if (TYPE_NFIELDS (func_type) != n_actuals)
+    return 0;
+
+  for (i = 0; i < n_actuals; i += 1)
+    {
+      struct type* ftype = check_typedef (TYPE_FIELD_TYPE (func_type, i));
+      struct type* atype = check_typedef (VALUE_TYPE (actuals[i]));
+
+      if (! ada_type_match (TYPE_FIELD_TYPE (func_type, i), 
+			    VALUE_TYPE (actuals[i]), 1))
+	return 0;
+    }
+  return 1;
+}
+
+/* False iff function type FUNC_TYPE definitely does not produce a value
+   compatible with type CONTEXT_TYPE.  Conservatively returns 1 if
+   FUNC_TYPE is not a valid function type with a non-null return type
+   or an enumerated type.  A null CONTEXT_TYPE indicates any non-void type.  */
+
+static int
+return_match (func_type, context_type)
+     struct type* func_type;
+     struct type* context_type;
+{
+  struct type* return_type;
+
+  if (func_type == NULL)
+    return 1;
+
+  /* FIXME: base_type should be declared in gdbtypes.h, implemented in valarith.c */
+  /*  if (TYPE_CODE (func_type) == TYPE_CODE_FUNC)
+        return_type = base_type (TYPE_TARGET_TYPE (func_type));
+      else 
+	return_type = base_type (func_type);*/
+  if (return_type == NULL)
+    return 1;
+
+  /* FIXME: base_type should be declared in gdbtypes.h, implemented in valarith.c */
+  /*  context_type = base_type (context_type);*/
+
+  if (TYPE_CODE (return_type) == TYPE_CODE_ENUM)
+    return context_type == NULL || return_type == context_type;
+  else if (context_type == NULL)
+    return TYPE_CODE (return_type) != TYPE_CODE_VOID;
+  else
+    return TYPE_CODE (return_type) == TYPE_CODE (context_type);
+}
+
+
+/* Return the index in SYMS[0..NSYMS-1] of symbol for the 
+   function (if any) that matches the types of the NARGS arguments in
+   ARGS.  If CONTEXT_TYPE is non-null, and there is at least one match
+   that returns type CONTEXT_TYPE, then eliminate other matches.  If
+   CONTEXT_TYPE is null, prefer a non-void-returning function.
+   Asks the user if there is more than one match remaining.  Returns -1
+   if there is no such symbol or none is selected.  NAME is used
+   solely for messages.   May re-arrange and modify SYMS in
+   the process; the index returned is for the modified vector.  BLOCKS
+   is modified in parallel to SYMS. */
+
+int
+ada_resolve_function (syms, blocks, nsyms, args, nargs, name, context_type)
+     struct symbol* syms[];
+     struct block* blocks[];
+     struct value** args;
+     int nsyms, nargs;
+     const char* name;
+     struct type* context_type;
+{
+  int k;
+  int m;			/* Number of hits */
+  struct type* fallback;
+  struct type* return_type;
+
+  return_type = context_type;
+  if (context_type == NULL)
+    fallback = builtin_type_void;
+  else
+    fallback = NULL;
+
+  m = 0; 
+  while (1)
+    {
+      for (k = 0; k < nsyms; k += 1)
+	{
+	  struct type* type = check_typedef (SYMBOL_TYPE (syms[k]));
+
+	  if (ada_args_match (syms[k], args, nargs)
+	      && return_match (SYMBOL_TYPE (syms[k]), return_type))
+	    {
+	      syms[m] = syms[k];
+	      if (blocks != NULL)
+		blocks[m] = blocks[k];
+	      m += 1;
+	    }
+	}
+      if (m > 0 || return_type == fallback)
+	break;
+      else
+	return_type = fallback;
+    }
+
+  if (m == 0)
+    return -1;
+  else if (m > 1)
+    {
+      printf_filtered ("Multiple matches for %s\n", name);
+      user_select_syms (syms, blocks, m, 1);
+      return 0;
+    }
+  return 0;
+}
+
+/* Returns true (non-zero) iff demangled name N0 should appear before N1 */
+/* in a listing of choices during disambiguation (see sort_choices, below). */
+/* The idea is that overloadings of a subprogram name from the */
+/* same package should sort in their source order.  We settle for ordering */
+/* such symbols by their trailing number (__N  or $N). */
+static int
+mangled_ordered_before (char* N0, char* N1)
+{
+  if (N1 == NULL)
+    return 0;
+  else if (N0 == NULL)
+    return 1;
+  else
+    {
+      int k0, k1;
+      for (k0 = strlen (N0)-1; k0 > 0 && isdigit (N0[k0]); k0 -= 1)
+	;
+      for (k1 = strlen (N1)-1; k1 > 0 && isdigit (N1[k1]); k1 -= 1)
+	;
+      if ((N0[k0] == '_' || N0[k0] == '$') && N0[k0+1] != '\000'
+	  && (N1[k1] == '_' || N1[k1] == '$') && N1[k1+1] != '\000')
+	{
+	  int n0, n1;
+	  n0 = k0;
+	  while (N0[n0] == '_' && n0 > 0 && N0[n0-1] == '_')
+	    n0 -= 1;
+	  n1 = k1;
+	  while (N1[n1] == '_' && n1 > 0 && N1[n1-1] == '_')
+	    n1 -= 1;
+	  if (n0 == n1 && STREQN (N0, N1, n0))
+	    return (atoi (N0+k0+1) < atoi (N1+k1+1));
+	}
+      return (strcmp (N0, N1) < 0);
+    }
+}
+	  
+/* Sort SYMS[0..NSYMS-1] to put the choices in a canonical order by their */
+/* mangled names, rearranging BLOCKS[0..NSYMS-1] according to the same */
+/* permutation. */
+static void 
+sort_choices (syms, blocks, nsyms)
+     struct symbol* syms[];
+     struct block* blocks[];
+     int nsyms;
+{
+  int i, j;
+  for (i = 1; i < nsyms; i += 1) 
+    {
+      struct symbol* sym = syms[i];
+      struct block* block = blocks[i];
+      int j;
+
+      for (j = i-1; j >= 0; j -= 1) 
+	{
+	  if (mangled_ordered_before (SYMBOL_NAME (syms[j]),
+				      SYMBOL_NAME (sym)))
+	    break;
+	  syms[j+1] = syms[j];
+	  blocks[j+1] = blocks[j];
+	}
+      syms[j+1] = sym;
+      blocks[j+1] = block;
+    }
+}
+
+/* Given a list of NSYMS symbols in SYMS and corresponding blocks in */
+/* BLOCKS, select up to MAX_RESULTS>0 by asking the user (if */
+/* necessary), returning the number selected, and setting the first */
+/* elements of SYMS and BLOCKS to the selected symbols and */
+/* corresponding blocks.  Error if no symbols selected.   BLOCKS may */
+/* be NULL, in which case it is ignored. */
+
+/* NOTE: Adapted from decode_line_2 in symtab.c, with which it ought
+   to be re-integrated one of these days. */
+
+int
+user_select_syms (syms, blocks, nsyms, max_results)
+     struct symbol* syms[];
+     struct block* blocks[];
+     int nsyms;
+     int max_results;
+{
+  int i;
+  int* chosen = (int*) alloca (sizeof(int) * nsyms);
+  int n_chosen;
+  int first_choice = (max_results == 1) ? 1 : 2;
+
+  if (max_results < 1)
+    error ("Request to select 0 symbols!");
+  if (nsyms <= 1)
+    return nsyms;
+
+  printf_unfiltered("[0] cancel\n");
+  if (max_results > 1)
+      printf_unfiltered("[1] all\n");
+
+  sort_choices (syms, blocks, nsyms);
+
+  for (i = 0; i < nsyms; i += 1)
+    {
+      if (syms[i] == NULL)
+	continue;
+
+      if (SYMBOL_CLASS (syms[i]) == LOC_BLOCK)
+	{
+	  struct symtab_and_line sal = find_function_start_sal (syms[i], 1);
+	  printf_unfiltered ("[%d] %s at %s:%d\n",
+			     i + first_choice, 
+			     SYMBOL_SOURCE_NAME (syms[i]),
+			     sal.symtab == NULL 
+			       ? "<no source file available>"
+			       : sal.symtab->filename, 
+			     sal.line);
+	  continue;
+	}
+      else 
+	{
+	  int is_enumeral = 
+	    (SYMBOL_CLASS (syms[i]) == LOC_CONST
+	     && SYMBOL_TYPE (syms[i]) != NULL
+	     && TYPE_CODE (SYMBOL_TYPE (syms[i]))
+	        == TYPE_CODE_ENUM);
+	  struct symtab* symtab = symtab_for_sym (syms[i]);
+
+	  if (SYMBOL_LINE (syms[i]) != 0 && symtab != NULL)
+	    printf_unfiltered ("[%d] %s at %s:%d\n",
+			       i + first_choice,
+			       SYMBOL_SOURCE_NAME (syms[i]),
+			       symtab->filename, SYMBOL_LINE (syms[i]));
+	  else if (is_enumeral && 
+		   TYPE_NAME (SYMBOL_TYPE (syms[i])) != NULL)
+	    {
+	      printf_unfiltered ("[%d] ", i + first_choice);
+	      ada_print_type (SYMBOL_TYPE (syms[i]), NULL, gdb_stdout, -1, 0);
+	      printf_unfiltered ("'(%s) (enumeral)\n",
+				 SYMBOL_SOURCE_NAME (syms[i]));
+	    }
+	  else if (symtab != NULL)
+	    printf_unfiltered (is_enumeral 
+			       ? "[%d] %s in %s (enumeral)\n"
+			       : "[%d] %s at %s:?\n",
+			       i + first_choice,
+			       SYMBOL_SOURCE_NAME (syms[i]),
+			       symtab->filename);
+	  else
+	    printf_unfiltered (is_enumeral
+			       ? "[%d] %s (enumeral)\n"
+			       : "[%d] %s at ?\n",
+			       i + first_choice, SYMBOL_SOURCE_NAME (syms[i]));
+	}
+    }
+  
+  n_chosen = get_selections (chosen, nsyms, max_results, max_results > 1,
+			     "overload-choice");
+
+  for (i = 0; i < n_chosen; i += 1)
+    {
+      syms[i] = syms[chosen[i]];
+      if (blocks != NULL) 
+	blocks[i] = blocks[chosen[i]];
+    }
+
+  return n_chosen;
+}
+
+/* Read and validate a set of numeric choices from the user in the
+   range 0 .. N_CHOICES-1. Place the results in increasing
+   order in CHOICES[0 .. N-1], and return N.
+
+   The user types choices as a sequence of numbers on one line
+   separated by blanks, encoding them as follows:
+
+     + A choice of 0 means to cancel the selection, throwing an error.  
+     + If IS_ALL_CHOICE, a choice of 1 selects the entire set 0 .. N_CHOICES-1.
+     + The user chooses k by typing k+IS_ALL_CHOICE+1.
+
+   The user is not allowed to choose more than MAX_RESULTS values. 
+
+   ANNOTATION_SUFFIX, if present, is used to annotate the input
+   prompts (for use with the -f switch). */
+
+int
+get_selections (choices, n_choices, max_results, is_all_choice, 
+		annotation_suffix)
+     int* choices;
+     int n_choices;
+     int max_results;
+     int is_all_choice;
+     char* annotation_suffix;
+{
+  int i;
+  char* args;
+  const char* prompt;
+  int n_chosen;
+  int first_choice = is_all_choice ? 2 : 1;
+  
+  prompt = getenv ("PS2");
+  if (prompt == NULL)
+    prompt = ">";
+
+  printf_unfiltered ("%s ", prompt);
+  gdb_flush (gdb_stdout);
+
+  args = command_line_input ((char *) NULL, 0, annotation_suffix);
+  
+  if (args == NULL)
+    error_no_arg ("one or more choice numbers");
+
+  n_chosen = 0;
+
+  /* Set choices[0 .. n_chosen-1] to the users' choices in ascending 
+     order, as given in args.   Choices are validated. */
+  while (1)
+    {
+      char* args2;
+      int choice, j;
+
+      while (isspace (*args))
+	args += 1;
+      if (*args == '\0' && n_chosen == 0)
+	error_no_arg ("one or more choice numbers");
+      else if (*args == '\0')
+	break;
+
+      choice = strtol (args, &args2, 10);
+      if (args == args2 || choice < 0 || choice > n_choices + first_choice - 1)
+	error ("Argument must be choice number");
+      args = args2;
+
+      if (choice == 0) 
+	error ("cancelled");
+
+      if (choice < first_choice)
+	{
+	  n_chosen = n_choices;
+	  for (j = 0; j < n_choices; j += 1)
+	    choices[j] = j;
+	  break;
+	}
+      choice -= first_choice;
+
+      for (j = n_chosen-1; j >= 0 && choice < choices[j]; j -= 1)
+	{}
+
+      if (j < 0 || choice != choices[j])
+	{
+	  int k;
+	  for (k = n_chosen-1; k > j; k -= 1)
+	    choices[k+1] = choices[k];
+	  choices[j+1] = choice;
+	  n_chosen += 1;
+	}
+    }
+
+  if (n_chosen > max_results)
+    error ("Select no more than %d of the above", max_results);
+  
+  return n_chosen;
+}
+
+/* Replace the operator of length OPLEN at position PC in *EXPP with a call */
+/* on the function identified by SYM and BLOCK, and taking NARGS */
+/* arguments.  Update *EXPP as needed to hold more space. */
+
+static void
+replace_operator_with_call (expp, pc, nargs, oplen, sym, block)
+     struct expression** expp;
+     int pc, nargs, oplen;
+     struct symbol* sym;
+     struct block* block; 
+{
+  /* A new expression, with 6 more elements (3 for funcall, 4 for function
+     symbol, -oplen for operator being replaced). */
+  struct expression* newexp = (struct expression*)
+    xmalloc (sizeof (struct expression)
+	     + EXP_ELEM_TO_BYTES ((*expp)->nelts + 7 - oplen));
+  struct expression* exp = *expp;
+
+  newexp->nelts = exp->nelts + 7 - oplen;
+  newexp->language_defn = exp->language_defn;
+  memcpy (newexp->elts, exp->elts, EXP_ELEM_TO_BYTES (pc));
+  memcpy (newexp->elts + pc + 7, exp->elts + pc + oplen, 
+	  EXP_ELEM_TO_BYTES (exp->nelts - pc - oplen));
+
+  newexp->elts[pc].opcode = newexp->elts[pc + 2].opcode = OP_FUNCALL;
+  newexp->elts[pc + 1].longconst = (LONGEST) nargs;
+
+  newexp->elts[pc + 3].opcode = newexp->elts[pc + 6].opcode = OP_VAR_VALUE;
+  newexp->elts[pc + 4].block = block;
+  newexp->elts[pc + 5].symbol = sym;
+
+  *expp = newexp;
+  free (exp);
+}  
+
+/* Type-class predicates */
+
+/* True iff TYPE is numeric (i.e., an INT, RANGE (of numeric type), or */
+/* FLOAT.) */
+
+static int
+numeric_type_p (type)
+     struct type* type;
+{
+  if (type == NULL)
+    return 0;
+  else {
+    switch (TYPE_CODE (type))
+      {
+      case TYPE_CODE_INT:
+      case TYPE_CODE_FLT:
+	return 1;
+      case TYPE_CODE_RANGE:
+	return (type == TYPE_TARGET_TYPE (type)
+		|| numeric_type_p (TYPE_TARGET_TYPE (type)));
+      default:
+	return 0;
+      }
+  }
+}
+
+/* True iff TYPE is integral (an INT or RANGE of INTs). */
+
+static int
+integer_type_p (type)
+     struct type* type;
+{
+  if (type == NULL)
+    return 0;
+  else {
+    switch (TYPE_CODE (type))
+      {
+      case TYPE_CODE_INT:
+	return 1;
+      case TYPE_CODE_RANGE:
+	return (type == TYPE_TARGET_TYPE (type) 
+		|| integer_type_p (TYPE_TARGET_TYPE (type)));
+      default:
+	return 0;
+      }
+  }
+}
+
+/* True iff TYPE is scalar (INT, RANGE, FLOAT, ENUM). */
+
+static int
+scalar_type_p (type)
+     struct type* type;
+{
+  if (type == NULL)
+    return 0;
+  else {
+    switch (TYPE_CODE (type))
+      {
+      case TYPE_CODE_INT:
+      case TYPE_CODE_RANGE:
+      case TYPE_CODE_ENUM:
+      case TYPE_CODE_FLT:
+	return 1;
+      default:
+	return 0;
+      }
+  }
+}
+
+/* True iff TYPE is discrete (INT, RANGE, ENUM). */
+
+static int
+discrete_type_p (type)
+     struct type* type;
+{
+  if (type == NULL)
+    return 0;
+  else {
+    switch (TYPE_CODE (type))
+      {
+      case TYPE_CODE_INT:
+      case TYPE_CODE_RANGE:
+      case TYPE_CODE_ENUM:
+	return 1;
+      default:
+	return 0;
+      }
+  }
+}
+
+/* Returns non-zero if OP with operatands in the vector ARGS could be
+   a user-defined function. Errs on the side of pre-defined operators
+   (i.e., result 0). */
+
+static int
+possible_user_operator_p (op, args)
+     enum exp_opcode op;
+     struct value* args[];
+{
+  struct type* type0 = check_typedef (VALUE_TYPE (args[0]));
+  struct type* type1 = 
+    (args[1] == NULL) ? NULL : check_typedef (VALUE_TYPE (args[1]));
+  
+  switch (op)
+    {
+    default:
+      return 0;
+
+    case BINOP_ADD:
+    case BINOP_SUB:
+    case BINOP_MUL:
+    case BINOP_DIV:
+      return (! (numeric_type_p (type0) && numeric_type_p (type1)));
+
+    case BINOP_REM:
+    case BINOP_MOD:
+    case BINOP_BITWISE_AND:
+    case BINOP_BITWISE_IOR:
+    case BINOP_BITWISE_XOR:
+      return (! (integer_type_p (type0) && integer_type_p (type1)));
+
+    case BINOP_EQUAL:
+    case BINOP_NOTEQUAL:
+    case BINOP_LESS:
+    case BINOP_GTR:
+    case BINOP_LEQ:
+    case BINOP_GEQ:
+      return (! (scalar_type_p (type0) && scalar_type_p (type1)));
+
+    case BINOP_CONCAT:
+      return ((TYPE_CODE (type0) != TYPE_CODE_ARRAY && 
+	       (TYPE_CODE (type0) != TYPE_CODE_PTR || 
+		TYPE_CODE (TYPE_TARGET_TYPE (type0)) 
+		    != TYPE_CODE_ARRAY))
+	      || (TYPE_CODE (type1) != TYPE_CODE_ARRAY && 
+		  (TYPE_CODE (type1) != TYPE_CODE_PTR || 
+		   TYPE_CODE (TYPE_TARGET_TYPE (type1)) 
+		     != TYPE_CODE_ARRAY)));
+
+    case BINOP_EXP:
+      return (! (numeric_type_p (type0) && integer_type_p (type1)));
+
+    case UNOP_NEG:
+    case UNOP_PLUS:
+    case UNOP_LOGICAL_NOT:
+    case UNOP_ABS:      
+      return (! numeric_type_p (type0));
+
+    }
+}
+
+				/* Renaming */
+
+/** NOTE: In the following, we assume that a renaming type's name may
+ *  have an ___XD suffix.  It would be nice if this went away at some
+ *  point. */
+
+/* If TYPE encodes a renaming, returns the renaming suffix, which
+ * is XR for an object renaming, XRP for a procedure renaming, XRE for
+ * an exception renaming, and XRS for a subprogram renaming.  Returns
+ * NULL if NAME encodes none of these. */
+const char*
+ada_renaming_type (type)
+     struct type* type;
+{
+  if (type != NULL && TYPE_CODE (type) == TYPE_CODE_ENUM)
+    {
+      const char* name = type_name_no_tag (type);
+      const char* suffix = (name == NULL) ? NULL : strstr (name, "___XR");
+      if (suffix == NULL 
+      || (suffix[5] != '\000' && strchr ("PES_", suffix[5]) == NULL))
+	return NULL;
+      else
+	return suffix + 3;
+    }
+  else
+    return NULL;
+}
+
+/* Return non-zero iff SYM encodes an object renaming. */
+int
+ada_is_object_renaming (sym)
+     struct symbol* sym;
+{
+  const char* renaming_type = ada_renaming_type (SYMBOL_TYPE (sym));
+  return renaming_type != NULL 
+    && (renaming_type[2] == '\0' || renaming_type[2] == '_');
+}
+
+/* Assuming that SYM encodes a non-object renaming, returns the original
+ * name of the renamed entity.   The name is good until the end of
+ * parsing. */
+const char*
+ada_simple_renamed_entity (sym)
+     struct symbol* sym;
+{
+  struct type* type;
+  const char* raw_name;
+  int len;
+  char* result;
+
+  type = SYMBOL_TYPE (sym);
+  if (type == NULL || TYPE_NFIELDS (type) < 1)
+    error ("Improperly encoded renaming.");
+
+  raw_name = TYPE_FIELD_NAME (type, 0);
+  len = (raw_name == NULL ? 0 : strlen (raw_name)) - 5;
+  if (len <= 0)
+    error ("Improperly encoded renaming.");
+
+  result = xmalloc (len + 1);
+  /* FIXME: add_name_string_cleanup should be defined in parse.c */  
+  /*  add_name_string_cleanup (result);*/
+  strncpy (result, raw_name, len);
+  result[len] = '\000';
+  return result;
+}
+
+
+				/* Evaluation: Function Calls */
+
+/* Copy VAL onto the stack, using and updating *SP as the stack 
+   pointer. Return VAL as an lvalue. */
+
+static struct value*
+place_on_stack (val, sp)
+    struct value* val;
+     CORE_ADDR* sp;
+{
+  CORE_ADDR old_sp = *sp;
+
+#ifdef STACK_ALIGN
+  *sp = push_bytes (*sp, VALUE_CONTENTS_RAW (val), 
+		    STACK_ALIGN (TYPE_LENGTH (check_typedef (VALUE_TYPE (val)))));
+#else
+  *sp = push_bytes (*sp, VALUE_CONTENTS_RAW (val), 
+		    TYPE_LENGTH (check_typedef (VALUE_TYPE (val))));
+#endif
+
+  VALUE_LVAL (val) = lval_memory;
+  if (INNER_THAN (1, 2))
+    VALUE_ADDRESS (val) = *sp;
+  else
+    VALUE_ADDRESS (val) = old_sp;
+
+  return val;
+}
+
+/* Return the value ACTUAL, converted to be an appropriate value for a
+   formal of type FORMAL_TYPE.  Use *SP as a stack pointer for
+   allocating any necessary descriptors (fat pointers), or copies of
+   values not residing in memory, updating it as needed. */ 
+
+static struct value*
+convert_actual (actual, formal_type0, sp)
+     struct value* actual;
+     struct type* formal_type0;
+     CORE_ADDR* sp;
+{
+  struct type* actual_type = check_typedef (VALUE_TYPE (actual));
+  struct type* formal_type = check_typedef (formal_type0);
+  struct type* formal_target =
+    TYPE_CODE (formal_type) == TYPE_CODE_PTR 
+      ? check_typedef (TYPE_TARGET_TYPE (formal_type)) : formal_type;
+  struct type* actual_target = 
+    TYPE_CODE (actual_type) == TYPE_CODE_PTR 
+      ? check_typedef (TYPE_TARGET_TYPE (actual_type)) : actual_type;
+
+  if (ada_is_array_descriptor (formal_target)
+      && TYPE_CODE (actual_target) == TYPE_CODE_ARRAY)
+    return make_array_descriptor (formal_type, actual, sp);
+  else if (TYPE_CODE (formal_type) == TYPE_CODE_PTR)
+    {
+      if (TYPE_CODE (formal_target) == TYPE_CODE_ARRAY
+	  && ada_is_array_descriptor (actual_target)) 
+	return desc_data (actual);
+      else if (TYPE_CODE (actual_type) != TYPE_CODE_PTR)
+	{
+	  if (VALUE_LVAL (actual) != lval_memory)
+	    {
+	      struct value* val;
+	      actual_type = check_typedef (VALUE_TYPE (actual));
+	      val = allocate_value (actual_type);
+	      memcpy ((char*) VALUE_CONTENTS_RAW (val), 
+		      (char*) VALUE_CONTENTS (actual),
+		      TYPE_LENGTH (actual_type));
+	      actual = place_on_stack (val, sp);
+	    }
+	  return value_addr (actual);
+	}
+    }
+  else if (TYPE_CODE (actual_type) == TYPE_CODE_PTR)
+    return ada_value_ind (actual);
+
+  return actual;
+}
+
+
+/* Push a descriptor of type TYPE for array value ARR on the stack at 
+   *SP, updating *SP to reflect the new descriptor.  Return either 
+   an lvalue representing the new descriptor, or (if TYPE is a pointer-
+   to-descriptor type rather than a descriptor type), a struct value*
+   representing a pointer to this descriptor. */
+
+static struct value*
+make_array_descriptor (type, arr, sp)
+     struct type* type;
+     struct value* arr;
+     CORE_ADDR* sp;
+{
+  struct type* bounds_type = desc_bounds_type (type);
+  struct type* desc_type = desc_base_type (type);
+  struct value* descriptor = allocate_value (desc_type);
+  struct value* bounds = allocate_value (bounds_type);
+  CORE_ADDR bounds_addr;
+  int i;
+  
+  for (i = ada_array_arity (check_typedef (VALUE_TYPE (arr))); i > 0; i -= 1)
+    {
+      modify_general_field (VALUE_CONTENTS (bounds),
+			    value_as_long (ada_array_bound (arr, i, 0)), 
+			    desc_bound_bitpos (bounds_type, i, 0),
+			    desc_bound_bitsize (bounds_type, i, 0));
+      modify_general_field (VALUE_CONTENTS (bounds),
+			    value_as_long (ada_array_bound (arr, i, 1)), 
+			    desc_bound_bitpos (bounds_type, i, 1),
+			    desc_bound_bitsize (bounds_type, i, 1));
+    }
+  
+  bounds = place_on_stack (bounds, sp);
+  
+  modify_general_field (VALUE_CONTENTS (descriptor),
+			arr,
+			fat_pntr_data_bitpos (desc_type),
+			fat_pntr_data_bitsize (desc_type));
+  modify_general_field (VALUE_CONTENTS (descriptor),
+			VALUE_ADDRESS (bounds),
+			fat_pntr_bounds_bitpos (desc_type),
+			fat_pntr_bounds_bitsize (desc_type));
+
+  descriptor = place_on_stack (descriptor, sp);
+
+  if (TYPE_CODE (type) == TYPE_CODE_PTR)
+    return value_addr (descriptor);
+  else
+    return descriptor;
+}
+
+
+/* Assuming a dummy frame has been established on the target, perform any 
+   conversions needed for calling function FUNC on the NARGS actual
+   parameters in ARGS, other than standard C conversions.   Does
+   nothing if FUNC does not have Ada-style prototype data, or if NARGS
+   does not match the number of arguments expected.   Use *SP as a
+   stack pointer for additional data that must be pushed, updating its
+   value as needed. */
+
+void
+ada_convert_actuals (func, nargs, args, sp)
+     struct value* func;
+     int nargs;
+     struct value* args[];
+     CORE_ADDR* sp;
+{
+  int i;
+
+  if (TYPE_NFIELDS (VALUE_TYPE (func)) == 0 
+      || nargs != TYPE_NFIELDS (VALUE_TYPE (func)))
+    return;
+
+  for (i = 0; i < nargs; i += 1)
+    args[i] = 
+      convert_actual (args[i], 
+		      TYPE_FIELD_TYPE (VALUE_TYPE (func), i), 
+		      sp);
+}
+
+
+				/* Symbol Lookup */
+
+
+/* The vectors of symbols and blocks ultimately returned from */
+/* ada_lookup_symbol_list. */
+
+/* Current size of defn_symbols and defn_blocks */
+static size_t defn_vector_size = 0; 
+
+/* Current number of symbols found. */
+static int ndefns = 0;
+
+static struct symbol** defn_symbols = NULL;
+static struct block** defn_blocks = NULL;
+
+/* Return the result of a standard (literal, C-like) lookup of NAME in 
+ * given NAMESPACE. */
+
+static struct symbol*
+standard_lookup (name, namespace)
+     const char* name;
+     namespace_enum namespace;
+{
+  struct symbol* sym;
+  struct symtab* symtab;
+  sym = lookup_symbol (name, (struct block*) NULL, namespace, 0, &symtab);
+  return sym;
+}
+  
+
+/* Non-zero iff there is at least one non-function/non-enumeral symbol */
+/* in SYMS[0..N-1].  We treat enumerals as functions, since they */
+/* contend in overloading in the same way. */ 
+static int
+is_nonfunction (syms, n)
+     struct symbol* syms[];
+     int n;
+{
+  int i;
+
+  for (i = 0; i < n; i += 1)
+    if (TYPE_CODE (SYMBOL_TYPE (syms[i])) != TYPE_CODE_FUNC
+	&& TYPE_CODE (SYMBOL_TYPE (syms[i])) != TYPE_CODE_ENUM)
+      return 1;
+
+  return 0;
+}
+
+/* If true (non-zero), then TYPE0 and TYPE1 represent equivalent
+   struct types.  Otherwise, they may not. */
+
+static int
+equiv_types (type0, type1)
+     struct type* type0;
+     struct type* type1;
+{
+  if (type0 == type1) 
+    return 1;
+  if (type0 == NULL || type1 == NULL 
+      || TYPE_CODE (type0) != TYPE_CODE (type1))
+    return 0;
+  if ((TYPE_CODE (type0) == TYPE_CODE_STRUCT 
+       || TYPE_CODE (type0) == TYPE_CODE_ENUM)
+      && ada_type_name (type0) != NULL && ada_type_name (type1) != NULL
+      && STREQ (ada_type_name (type0), ada_type_name (type1)))
+    return 1;
+  
+  return 0;
+}
+
+/* True iff SYM0 represents the same entity as SYM1, or one that is
+   no more defined than that of SYM1. */
+
+static int
+lesseq_defined_than (sym0, sym1)
+     struct symbol* sym0;
+     struct symbol* sym1;
+{
+  if (sym0 == sym1)
+    return 1;
+  if (SYMBOL_NAMESPACE (sym0) != SYMBOL_NAMESPACE (sym1)
+      || SYMBOL_CLASS (sym0) != SYMBOL_CLASS (sym1))
+    return 0;
+
+  switch (SYMBOL_CLASS (sym0)) 
+    {
+    case LOC_UNDEF:
+      return 1;
+    case LOC_TYPEDEF:
+      {
+	struct type* type0 = SYMBOL_TYPE (sym0);
+	struct type* type1 = SYMBOL_TYPE (sym1);
+	char* name0 = SYMBOL_NAME (sym0);
+	char* name1 = SYMBOL_NAME (sym1);
+	int len0 = strlen (name0);
+	return 
+	  TYPE_CODE (type0) == TYPE_CODE (type1)
+	  && (equiv_types (type0, type1)
+	      || (len0 < strlen (name1) && STREQN (name0, name1, len0)
+		  && STREQN (name1 + len0, "___XV", 5)));
+      }
+    case LOC_CONST:
+      return SYMBOL_VALUE (sym0) == SYMBOL_VALUE (sym1)
+	&& equiv_types (SYMBOL_TYPE (sym0), SYMBOL_TYPE (sym1));
+    default: 
+      return 0;      
+    }
+}
+
+/* Append SYM to the end of defn_symbols, and BLOCK to the end of
+   defn_blocks, updating ndefns, and expanding defn_symbols and
+   defn_blocks as needed.   Do not include SYM if it is a duplicate.  */
+
+static void
+add_defn_to_vec (sym, block)
+     struct symbol* sym;
+     struct block* block;
+{
+  int i;
+  size_t tmp;
+
+  if (SYMBOL_TYPE (sym) != NULL) 
+    CHECK_TYPEDEF (SYMBOL_TYPE (sym));
+  for (i = 0; i < ndefns; i += 1)
+    {
+      if (lesseq_defined_than (sym, defn_symbols[i]))
+	return;
+      else if (lesseq_defined_than (defn_symbols[i], sym))
+	{
+	  defn_symbols[i] = sym;
+	  defn_blocks[i] = block;
+	  return;
+	}
+    }
+
+  tmp = defn_vector_size;
+  GROW_VECT (defn_symbols, tmp, ndefns+2);
+  GROW_VECT (defn_blocks, defn_vector_size, ndefns+2);
+
+  defn_symbols[ndefns] = sym;
+  defn_blocks[ndefns] = block;
+  ndefns += 1;
+}
+
+/* Look, in partial_symtab PST, for symbol NAME in given namespace.
+   Check the global symbols if GLOBAL, the static symbols if not.  Do
+   wild-card match if WILD. */
+
+static struct partial_symbol *
+ada_lookup_partial_symbol (pst, name, global, namespace, wild)
+     struct partial_symtab *pst;
+     const char *name;
+     int global;
+     namespace_enum namespace;
+     int wild;
+{
+  struct partial_symbol **start;
+  int name_len = strlen (name);
+  int length = (global ? pst->n_global_syms : pst->n_static_syms);
+  int i;
+
+  if (length == 0)
+    {
+      return (NULL);
+    }
+  
+  start = (global ?
+	   pst->objfile->global_psymbols.list + pst->globals_offset :
+	   pst->objfile->static_psymbols.list + pst->statics_offset  );
+
+  if (wild)
+    {
+      for (i = 0; i < length; i += 1)
+	{
+	  struct partial_symbol* psym = start[i];
+
+	  if (SYMBOL_NAMESPACE (psym) == namespace &&
+	      wild_match (name, name_len, SYMBOL_NAME (psym)))
+	    return psym;
+	}
+      return NULL;
+    }
+  else 
+    {
+      if (global)
+	{
+	  int U;
+	  i = 0; U = length-1;
+	  while (U - i > 4) 
+	    {
+	      int M = (U+i) >> 1;
+	      struct partial_symbol* psym = start[M];
+	      if (SYMBOL_NAME (psym)[0] < name[0])
+		i = M+1;
+	      else if (SYMBOL_NAME (psym)[0] > name[0])
+		U = M-1;
+	      else if (strcmp (SYMBOL_NAME (psym), name) < 0)
+		i = M+1;
+	      else
+		U = M;
+	    }
+	}
+      else
+	i = 0;
+
+      while (i < length)
+	{
+	  struct partial_symbol *psym = start[i];
+
+	  if (SYMBOL_NAMESPACE (psym) == namespace)
+	    {
+	      int cmp = strncmp (name, SYMBOL_NAME (psym), name_len);
+	
+	      if (cmp < 0) 
+		{
+		  if (global)
+		    break;
+		}
+	      else if (cmp == 0 
+		       && is_name_suffix (SYMBOL_NAME (psym) + name_len)) 
+		return psym;
+	    }
+	  i += 1;
+	}
+
+      if (global)
+	{
+	  int U;
+	  i = 0; U = length-1;
+	  while (U - i > 4) 
+	    {
+	      int M = (U+i) >> 1;
+	      struct partial_symbol *psym = start[M];
+	      if (SYMBOL_NAME (psym)[0] < '_')
+		i = M+1;
+	      else if (SYMBOL_NAME (psym)[0] > '_')
+		U = M-1;
+	      else if (strcmp (SYMBOL_NAME (psym), "_ada_") < 0)
+		i = M+1;
+	      else
+		U = M;
+	    }
+	}
+      else
+	i = 0;
+
+      while (i < length)
+	{
+	  struct partial_symbol* psym = start[i];
+
+	  if (SYMBOL_NAMESPACE (psym) == namespace)
+	    {
+	      int cmp;
+
+	      cmp = (int) '_' - (int) SYMBOL_NAME (psym)[0];
+	      if (cmp == 0) 
+		{
+		  cmp = strncmp ("_ada_", SYMBOL_NAME (psym), 5);
+		  if (cmp == 0)
+		    cmp = strncmp (name, SYMBOL_NAME (psym) + 5, name_len);
+		}
+	
+	      if (cmp < 0) 
+		{
+		  if (global)
+		    break;
+		}
+	      else if (cmp == 0 
+		       && is_name_suffix (SYMBOL_NAME (psym) + name_len + 5)) 
+		return psym;
+	    }
+	  i += 1;
+	}
+      
+    }
+  return NULL;
+}
+
+
+/* Find a symbol table containing symbol SYM or NULL if none.  */
+static struct symtab*
+symtab_for_sym (sym)
+     struct symbol* sym;
+{
+  struct symtab* s;
+  struct objfile *objfile;
+  struct block *b;
+  int i, j;
+
+  ALL_SYMTABS (objfile, s)
+    {
+      switch (SYMBOL_CLASS (sym))
+	{
+	case LOC_CONST:
+	case LOC_STATIC:
+	case LOC_TYPEDEF:
+	case LOC_REGISTER:
+	case LOC_LABEL:
+	case LOC_BLOCK:
+	case LOC_CONST_BYTES:
+	  b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
+	  for (i = 0; i < BLOCK_NSYMS (b); i += 1)
+	    if (sym == BLOCK_SYM (b, i))
+	      return s;
+	  b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
+	  for (i = 0; i < BLOCK_NSYMS (b); i += 1)
+	    if (sym == BLOCK_SYM (b, i))
+	      return s;
+	  break;
+	default:
+	  break;
+	}
+      switch (SYMBOL_CLASS (sym))
+	{
+	case LOC_REGISTER:
+	case LOC_ARG:
+	case LOC_REF_ARG:
+	case LOC_REGPARM:
+	case LOC_REGPARM_ADDR:
+	case LOC_LOCAL:
+	case LOC_TYPEDEF:
+	case LOC_LOCAL_ARG:
+	case LOC_BASEREG:
+	case LOC_BASEREG_ARG:
+	  for (j = FIRST_LOCAL_BLOCK; 
+	       j < BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (s)); j += 1)
+	    {
+	      b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), j);
+	      for (i = 0; i < BLOCK_NSYMS (b); i += 1)
+		if (sym == BLOCK_SYM (b, i))
+		  return s;
+	    }
+	  break;
+	default:
+	  break;
+	}
+    }
+  return NULL;
+}
+
+/* Return a minimal symbol matching NAME according to Ada demangling 
+   rules. Returns NULL if there is no such minimal symbol. */
+
+struct minimal_symbol*
+ada_lookup_minimal_symbol (name)
+     const char* name;
+{
+  struct objfile* objfile;
+  struct minimal_symbol* msymbol;
+  int wild_match = (strstr (name, "__") == NULL);
+
+  ALL_MSYMBOLS (objfile, msymbol)
+    {
+      if (ada_match_name (SYMBOL_NAME (msymbol), name, wild_match)
+	  && MSYMBOL_TYPE (msymbol) != mst_solib_trampoline)
+	return msymbol;
+    }
+
+  return NULL;
+}
+
+/* For all subprograms that statically enclose the subprogram of the
+ * selected frame, add symbols matching identifier NAME in NAMESPACE
+ * and their blocks to vectors *defn_symbols and *defn_blocks, as for
+ * ada_add_block_symbols (q.v.).   If WILD, treat as NAME with a
+ * wildcard prefix.  At the moment, this function uses a heuristic to
+ * find the frames of enclosing subprograms: it treats the
+ * pointer-sized value at location 0 from the local-variable base of a
+ * frame as a static link, and then searches up the call stack for a
+ * frame with that same local-variable base. */
+static void
+add_symbols_from_enclosing_procs (name, namespace, wild_match)
+     const char* name;
+     namespace_enum namespace;
+     int wild_match;
+{
+#ifdef i386
+  static struct symbol static_link_sym;
+  static struct symbol *static_link;
+
+  struct cleanup* old_chain = make_cleanup (null_cleanup, NULL);
+  struct frame_info* frame;
+  struct frame_info* target_frame;
+
+  if (static_link == NULL)
+    {
+      /* Initialize the local variable symbol that stands for the
+       * static link (when it exists). */
+      static_link = &static_link_sym;
+      SYMBOL_NAME (static_link) = "";
+      SYMBOL_LANGUAGE (static_link) = language_unknown;
+      SYMBOL_CLASS (static_link) = LOC_LOCAL;
+      SYMBOL_NAMESPACE (static_link) = VAR_NAMESPACE;
+      SYMBOL_TYPE (static_link) = lookup_pointer_type (builtin_type_void);
+      SYMBOL_VALUE (static_link) = 
+	- (long) TYPE_LENGTH (SYMBOL_TYPE (static_link));
+    }
+
+  frame = selected_frame;
+  while (frame != NULL && ndefns == 0)
+    {
+      struct block* block;
+      struct value* target_link_val = read_var_value (static_link, frame);
+      CORE_ADDR target_link;
+
+      if (target_link_val == NULL)
+	break;
+      QUIT;
+
+      target_link = target_link_val;
+      do {
+	  QUIT;
+	  frame = get_prev_frame (frame);
+      } while (frame != NULL && FRAME_LOCALS_ADDRESS (frame) != target_link);
+
+      if (frame == NULL)
+	break;
+
+      block = get_frame_block (frame, 0);
+      while (block != NULL && block_function (block) != NULL && ndefns == 0)
+	{
+	  ada_add_block_symbols (block, name, namespace, NULL, wild_match);
+      
+	  block = BLOCK_SUPERBLOCK (block);
+	}
+    }
+
+  do_cleanups (old_chain);
+#endif
+}
+
+/* True if TYPE is definitely an artificial type supplied to a symbol
+ * for which no debugging information was given in the symbol file. */
+static int
+is_nondebugging_type (type)
+     struct type* type;
+{
+  char* name = ada_type_name (type);
+  return (name != NULL && STREQ (name, "<variable, no debug info>"));
+}
+
+/* Remove any non-debugging symbols in SYMS[0 .. NSYMS-1] that definitely 
+ * duplicate other symbols in the list.  (The only case I know of where
+ * this happens is when object files containing stabs-in-ecoff are
+ * linked with files containing ordinary ecoff debugging symbols (or no
+ * debugging symbols)). Modifies SYMS to squeeze out deleted symbols,
+ * and applies the same modification to BLOCKS to maintain the
+ * correspondence between SYMS[i] and BLOCKS[i].  Returns the number
+ * of symbols in the modified list. */
+static int
+remove_extra_symbols (syms, blocks, nsyms)
+     struct symbol** syms;
+     struct block** blocks;
+     int nsyms;
+{
+  int i, j;
+
+  i = 0;
+  while (i < nsyms)
+    {
+      if (SYMBOL_NAME (syms[i]) != NULL && SYMBOL_CLASS (syms[i]) == LOC_STATIC
+	  && is_nondebugging_type (SYMBOL_TYPE (syms[i])))
+	{
+	  for (j = 0; j < nsyms; j += 1)
+	    {
+	      if (i != j 
+		  && SYMBOL_NAME (syms[j]) != NULL
+		  && STREQ (SYMBOL_NAME (syms[i]), SYMBOL_NAME (syms[j]))
+		  && SYMBOL_CLASS (syms[i]) == SYMBOL_CLASS (syms[j])
+		  && SYMBOL_VALUE_ADDRESS (syms[i]) 
+		  == SYMBOL_VALUE_ADDRESS (syms[j]))
+		{
+		  int k;
+		  for (k = i+1; k < nsyms; k += 1) 
+		    {
+		      syms[k-1] = syms[k];
+		      blocks[k-1] = blocks[k];
+		    }
+		  nsyms -= 1;
+		  goto NextSymbol;
+		}
+	    }
+	}
+      i += 1;
+    NextSymbol:
+      ;
+    }
+  return nsyms;
+}
+
+/* Find symbols in NAMESPACE matching NAME, in BLOCK0 and enclosing 
+   scope and in global scopes, returning the number of matches.  Sets 
+   *SYMS to point to a vector of matching symbols, with *BLOCKS
+   pointing to the vector of corresponding blocks in which those
+   symbols reside.  These two vectors are transient---good only to the
+   next call of ada_lookup_symbol_list.  Any non-function/non-enumeral symbol
+   match within the nest of blocks whose innermost member is BLOCK0,
+   is the outermost match returned (no other matches in that or
+   enclosing blocks is returned).  If there are any matches in or
+   surrounding BLOCK0, then these alone are returned. */
+
+int
+ada_lookup_symbol_list (name, block0, namespace, syms, blocks)
+     const char *name;
+     struct block *block0;
+     namespace_enum namespace;
+     struct symbol*** syms;
+     struct block*** blocks;
+{
+  struct symbol *sym;
+  struct symtab *s;
+  struct partial_symtab *ps;
+  struct blockvector *bv;
+  struct objfile *objfile;
+  struct block *b;
+  struct block *block;
+  struct minimal_symbol *msymbol;
+  int wild_match = (strstr (name, "__") == NULL);
+  int cacheIfUnique;
+
+#ifdef TIMING
+  markTimeStart (0);
+#endif
+
+  ndefns = 0;
+  cacheIfUnique = 0;
+
+  /* Search specified block and its superiors.  */
+
+  block = block0;
+  while (block != NULL)
+    {
+      ada_add_block_symbols (block, name, namespace, NULL, wild_match);
+
+      /* If we found a non-function match, assume that's the one. */
+      if (is_nonfunction (defn_symbols, ndefns))
+	goto done;
+
+      block = BLOCK_SUPERBLOCK (block);
+    }
+
+  /* If we found ANY matches in the specified BLOCK, we're done. */
+
+  if (ndefns > 0)
+    goto done;
+  
+  cacheIfUnique = 1;
+
+  /* Now add symbols from all global blocks: symbol tables, minimal symbol
+     tables, and psymtab's */
+
+  ALL_SYMTABS (objfile, s)
+    {
+      QUIT;
+      if (! s->primary)
+	continue;
+      bv = BLOCKVECTOR (s);
+      block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+      ada_add_block_symbols (block, name, namespace, objfile, wild_match);
+    }
+
+  if (namespace == VAR_NAMESPACE)
+    {
+      ALL_MSYMBOLS (objfile, msymbol)
+	{
+	  if (ada_match_name (SYMBOL_NAME (msymbol), name, wild_match))
+	    {
+	      switch (MSYMBOL_TYPE (msymbol))
+		{
+		case mst_solib_trampoline:
+		  break;
+		default:
+		  s = find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol));
+		  if (s != NULL)
+		    {
+		      int old_ndefns = ndefns;
+		      QUIT;
+		      bv = BLOCKVECTOR (s);
+		      block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+		      ada_add_block_symbols (block, 
+					     SYMBOL_NAME (msymbol), 
+					     namespace, objfile, wild_match);
+		      if (ndefns == old_ndefns) 
+			{
+			  block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+			  ada_add_block_symbols (block, 
+						 SYMBOL_NAME (msymbol), 
+						 namespace, objfile,
+						 wild_match);
+			}
+		    }
+		}
+	    }
+	}
+    }
+      
+  ALL_PSYMTABS (objfile, ps)
+    {
+      QUIT;
+      if (!ps->readin 
+	  && ada_lookup_partial_symbol (ps, name, 1, namespace, wild_match))
+	{
+	  s = PSYMTAB_TO_SYMTAB (ps);
+	  if (! s->primary)
+	    continue;
+	  bv = BLOCKVECTOR (s);
+	  block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+	  ada_add_block_symbols (block, name, namespace, objfile, wild_match);
+	}
+    }
+  
+  /* Now add symbols from all per-file blocks if we've gotten no hits.  
+     (Not strictly correct, but perhaps better than an error).
+     Do the symtabs first, then check the psymtabs */
+  
+  if (ndefns == 0)
+    {
+
+      ALL_SYMTABS (objfile, s)
+	{
+	  QUIT;
+	  if (! s->primary)
+	    continue;
+	  bv = BLOCKVECTOR (s);
+	  block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+	  ada_add_block_symbols (block, name, namespace, objfile, wild_match);
+	}
+      
+      ALL_PSYMTABS (objfile, ps)
+	{
+	  QUIT;
+	  if (!ps->readin 
+	      && ada_lookup_partial_symbol (ps, name, 0, namespace, wild_match))
+	    {
+	      s = PSYMTAB_TO_SYMTAB(ps);
+	      bv = BLOCKVECTOR (s);
+	      if (! s->primary)
+		continue;
+	      block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+	      ada_add_block_symbols (block, name, namespace, 
+				     objfile, wild_match);
+	    }
+	}
+    }  
+
+  /* Finally, we try to find NAME as a local symbol in some lexically
+     enclosing block.  We do this last, expecting this case to be
+     rare. */
+  if (ndefns == 0) 
+    {
+      add_symbols_from_enclosing_procs (name, namespace, wild_match);
+      if (ndefns > 0)
+	goto done;
+    }
+
+ done:
+  ndefns = remove_extra_symbols (defn_symbols, defn_blocks, ndefns);
+
+
+  *syms = defn_symbols;
+  *blocks = defn_blocks;
+#ifdef TIMING
+  markTimeStop (0);
+#endif
+  return ndefns;
+}
+
+/* Return a symbol in NAMESPACE matching NAME, in BLOCK0 and enclosing 
+ * scope and in global scopes, or NULL if none.  NAME is folded to
+ * lower case first, unless it is surrounded in single quotes. 
+ * Otherwise, the result is as for ada_lookup_symbol_list, but is 
+ * disambiguated by user query if needed. */
+
+struct symbol*
+ada_lookup_symbol (name, block0, namespace)
+     const char *name;
+     struct block *block0;
+     namespace_enum namespace;
+{
+  struct symbol** candidate_syms;
+  struct block** candidate_blocks;
+  int n_candidates;
+
+  n_candidates = ada_lookup_symbol_list (name,
+					 block0, namespace,
+					 &candidate_syms, &candidate_blocks);
+
+  if (n_candidates == 0)
+    return NULL;
+  else if (n_candidates != 1)
+    user_select_syms (candidate_syms, candidate_blocks, n_candidates, 1);
+
+  return candidate_syms[0];
+}
+
+
+/* True iff STR is a possible encoded suffix of a normal Ada name 
+ * that is to be ignored for matching purposes.  Suffixes of parallel
+ * names (e.g., XVE) are not included here.  Currently, the possible suffixes 
+ * are given by the regular expression:
+ *        (X[nb]*)?(__[0-9]+|\$[0-9]+|___(LJM|X([FDBUP].*|R[^T]?)))?$
+ * 
+ */
+static int
+is_name_suffix (str)
+     const char* str;
+{
+  int k;
+  if (str[0] == 'X')
+    {
+      str += 1;
+      while (str[0] != '_' && str[0] != '\0') 
+	{
+	  if (str[0] != 'n' && str[0] != 'b')
+	    return 0;
+	  str += 1;
+	} 
+    }
+  if (str[0] == '\000')
+    return 1;
+  if (str[0] == '_') 
+    {
+      if (str[1] != '_' || str[2] == '\000')
+	return 0;
+      if (str[2] == '_') 
+	{
+	  if (STREQ (str+3, "LJM"))
+	    return 1;
+	  if (str[3] != 'X')
+	    return 0;
+	  if (str[4] == 'F' || str[4] == 'D' || str[4] == 'B' ||
+	      str[4] == 'U' || str[4] == 'P')
+	    return 1;
+	  if (str[4] == 'R' && str[5] != 'T')
+	    return 1;
+	  return 0;
+	}
+      for (k = 2; str[k] != '\0'; k += 1)
+	if (!isdigit (str[k]))
+	  return 0;
+      return 1;
+    }
+  if (str[0] == '$' && str[1] != '\000')
+    {
+      for (k = 1; str[k] != '\0'; k += 1)
+	if (!isdigit (str[k]))
+	  return 0;
+      return 1;
+    }
+  return 0;
+}
+      
+/* True if NAME represents a name of the form A1.A2....An, n>=1 and 
+ * PATN[0..PATN_LEN-1] = Ak.Ak+1.....An for some k >= 1.  Ignores
+ * informational suffixes of NAME (i.e., for which is_name_suffix is
+ * true). */ 
+static int
+wild_match (patn, patn_len, name)
+     const char* patn;
+     int patn_len;
+     const char* name;
+{
+  int name_len;
+  int s, e;
+
+  name_len = strlen (name);
+  if (name_len >= patn_len+5 && STREQN (name, "_ada_", 5)
+      && STREQN (patn, name+5, patn_len)
+      && is_name_suffix (name+patn_len+5))
+    return 1;
+
+  while (name_len >= patn_len) 
+    {
+      if (STREQN (patn, name, patn_len)
+	  && is_name_suffix (name+patn_len))
+	return 1;
+      do {
+	name += 1; name_len -= 1;
+      } while (name_len > 0
+	       && name[0] != '.' && (name[0] != '_' || name[1] != '_'));
+      if (name_len <= 0)
+	return 0;
+      if (name[0] == '_')
+	{
+	  if (! islower (name[2]))
+	    return 0;
+	  name += 2; name_len -= 2;
+	}
+      else
+	{
+	  if (! islower (name[1]))
+	    return 0;
+	  name += 1; name_len -= 1;
+	}
+    }
+
+  return 0;
+}
+
+
+/* Add symbols from BLOCK matching identifier NAME in NAMESPACE to 
+   vector *defn_symbols, updating *defn_symbols (if necessary), *SZ (the size of
+   the vector *defn_symbols), and *ndefns (the number of symbols
+   currently stored in *defn_symbols).  If WILD, treat as NAME with a
+   wildcard prefix. OBJFILE is the section containing BLOCK. */
+
+static void 
+ada_add_block_symbols (block, name, namespace, objfile, wild)
+     struct block* block;
+     const char* name;
+     namespace_enum namespace;
+     struct objfile* objfile;
+     int wild;
+{
+  int i;
+  int name_len = strlen (name);
+  /* A matching argument symbol, if any. */
+  struct symbol *arg_sym;
+  /* Set true when we find a matching non-argument symbol */
+  int found_sym;
+  int is_sorted = BLOCK_SHOULD_SORT (block);
+
+  arg_sym = NULL; found_sym = 0;
+  if (wild)
+    {
+      for (i = 0; i < BLOCK_NSYMS (block); i += 1)
+	{
+	  struct symbol *sym = BLOCK_SYM (block, i);
+
+	  if (SYMBOL_NAMESPACE (sym) == namespace &&
+	      wild_match (name, name_len, SYMBOL_NAME (sym)))
+	    {
+	      switch (SYMBOL_CLASS (sym))
+		{
+		case LOC_ARG:
+		case LOC_LOCAL_ARG:
+		case LOC_REF_ARG:
+		case LOC_REGPARM:
+		case LOC_REGPARM_ADDR:
+		case LOC_BASEREG_ARG:
+		  arg_sym = sym;
+		  break;
+		case LOC_UNRESOLVED:
+		  continue;
+		default:
+		  found_sym = 1;
+		  fill_in_ada_prototype (sym);
+		  add_defn_to_vec (fixup_symbol_section (sym, objfile), block);
+		  break;
+		}
+	    }
+	}
+    }
+  else 
+    {
+      if (is_sorted)
+	{
+	  int U;
+	  i = 0; U = BLOCK_NSYMS (block)-1;
+	  while (U - i > 4) 
+	    {
+	      int M = (U+i) >> 1;
+	      struct symbol *sym = BLOCK_SYM (block, M);
+	      if (SYMBOL_NAME (sym)[0] < name[0])
+		i = M+1;
+	      else if (SYMBOL_NAME (sym)[0] > name[0])
+		U = M-1;
+	      else if (strcmp (SYMBOL_NAME (sym), name) < 0)
+		i = M+1;
+	      else
+		U = M;
+	    }
+	}
+      else
+	i = 0;
+
+      for (; i < BLOCK_NSYMS (block); i += 1)
+	{
+	  struct symbol *sym = BLOCK_SYM (block, i);
+
+	  if (SYMBOL_NAMESPACE (sym) == namespace)
+	    {
+	      int cmp = strncmp (name, SYMBOL_NAME (sym), name_len);
+	
+	      if (cmp < 0) 
+		{
+		  if (is_sorted)
+		    break;
+		}
+	      else if (cmp == 0 
+		       && is_name_suffix (SYMBOL_NAME (sym) + name_len)) 
+		{
+		  switch (SYMBOL_CLASS (sym))
+		    {
+		    case LOC_ARG:
+		    case LOC_LOCAL_ARG:
+		    case LOC_REF_ARG:
+		    case LOC_REGPARM:
+		    case LOC_REGPARM_ADDR:
+		    case LOC_BASEREG_ARG:
+		      arg_sym = sym;
+		      break;
+		    case LOC_UNRESOLVED:
+		      break;
+		    default:
+		      found_sym = 1;
+		      fill_in_ada_prototype (sym);
+		      add_defn_to_vec (fixup_symbol_section (sym, objfile),
+				       block);
+		      break;
+		    }
+		}
+	    }
+	}
+    }
+
+  if (! found_sym && arg_sym != NULL)
+    {
+      fill_in_ada_prototype (arg_sym);
+      add_defn_to_vec (fixup_symbol_section (arg_sym, objfile), block);
+    }
+
+  if (! wild)
+    {
+      arg_sym = NULL; found_sym = 0;
+      if (is_sorted)
+	{
+	  int U;
+	  i = 0; U = BLOCK_NSYMS (block)-1;
+	  while (U - i > 4) 
+	    {
+	      int M = (U+i) >> 1;
+	      struct symbol *sym = BLOCK_SYM (block, M);
+	      if (SYMBOL_NAME (sym)[0] < '_')
+		i = M+1;
+	      else if (SYMBOL_NAME (sym)[0] > '_')
+		U = M-1;
+	      else if (strcmp (SYMBOL_NAME (sym), "_ada_") < 0)
+		i = M+1;
+	      else
+		U = M;
+	    }
+	}
+      else
+	i = 0;
+
+      for (; i < BLOCK_NSYMS (block); i += 1)
+	{
+	  struct symbol *sym = BLOCK_SYM (block, i);
+
+	  if (SYMBOL_NAMESPACE (sym) == namespace)
+	    {
+	      int cmp;
+
+	      cmp = (int) '_' - (int) SYMBOL_NAME (sym)[0];
+	      if (cmp == 0) 
+		{
+		  cmp = strncmp ("_ada_", SYMBOL_NAME (sym), 5);
+		  if (cmp == 0)
+		    cmp = strncmp (name, SYMBOL_NAME (sym) + 5, name_len);
+		}
+	
+	      if (cmp < 0) 
+		{
+		  if (is_sorted)
+		    break;
+		}
+	      else if (cmp == 0 
+		       && is_name_suffix (SYMBOL_NAME (sym) + name_len + 5)) 
+		{
+		  switch (SYMBOL_CLASS (sym))
+		    {
+		    case LOC_ARG:
+		    case LOC_LOCAL_ARG:
+		    case LOC_REF_ARG:
+		    case LOC_REGPARM:
+		    case LOC_REGPARM_ADDR:
+		    case LOC_BASEREG_ARG:
+		      arg_sym = sym;
+		      break;
+		    case LOC_UNRESOLVED:
+		      break;
+		    default:
+		      found_sym = 1;
+		      fill_in_ada_prototype (sym);
+		      add_defn_to_vec (fixup_symbol_section (sym, objfile),
+				       block);
+		      break;
+		    }
+		}
+	    }
+	}
+      
+      /* NOTE: This really shouldn't be needed for _ada_ symbols.
+	 They aren't parameters, right? */
+      if (! found_sym && arg_sym != NULL)
+	{
+	  fill_in_ada_prototype (arg_sym);
+	  add_defn_to_vec (fixup_symbol_section (arg_sym, objfile), block);
+	}
+    }
+}
+
+
+				/* Function Types */
+
+/* Assuming that SYM is the symbol for a function, fill in its type 
+   with prototype information, if it is not already there.  */
+
+static void
+fill_in_ada_prototype (func)
+     struct symbol* func;
+{
+  struct block* b;
+  int nargs, nsyms;
+  int i;
+  struct type* ftype;
+  struct type* rtype;
+  size_t max_fields;
+
+  if (func == NULL
+      || TYPE_CODE (SYMBOL_TYPE (func)) != TYPE_CODE_FUNC
+      || TYPE_FIELDS (SYMBOL_TYPE (func)) != NULL)
+    return;
+
+  /* We make each function type unique, so that each may have its own */
+  /* parameter types.  This particular way of doing so wastes space: */
+  /* it would be nicer to build the argument types while the original */
+  /* function type is being built (FIXME). */
+  rtype = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (func)));
+  ftype = alloc_type (TYPE_OBJFILE (SYMBOL_TYPE (func)));
+  make_function_type (rtype, &ftype);
+  SYMBOL_TYPE (func) = ftype;
+
+  b = SYMBOL_BLOCK_VALUE (func);
+  nsyms = BLOCK_NSYMS (b);
+
+  nargs = 0;
+  max_fields = 8; 
+  TYPE_FIELDS (ftype) = 
+    (struct field*) xmalloc (sizeof (struct field) * max_fields);
+  for (i = 0; i < nsyms; i += 1)
+    {
+      struct symbol *sym = BLOCK_SYM (b, i);
+
+      GROW_VECT (TYPE_FIELDS (ftype), max_fields, nargs+1);
+	
+      switch (SYMBOL_CLASS (sym)) 
+	{
+	case LOC_REF_ARG:
+	case LOC_REGPARM_ADDR:
+	  TYPE_FIELD_BITPOS (ftype, nargs) = nargs;
+	  TYPE_FIELD_BITSIZE (ftype, nargs) = 0;
+	  TYPE_FIELD_TYPE (ftype, nargs) = 
+	    lookup_pointer_type (check_typedef (SYMBOL_TYPE (sym)));
+	  TYPE_FIELD_NAME (ftype, nargs) = SYMBOL_NAME (sym);
+	  nargs += 1;
+	
+	  break;
+
+	case LOC_ARG:
+	case LOC_REGPARM:
+	case LOC_LOCAL_ARG:
+	case LOC_BASEREG_ARG:
+	  TYPE_FIELD_BITPOS (ftype, nargs) = nargs;
+	  TYPE_FIELD_BITSIZE (ftype, nargs) = 0;
+	  TYPE_FIELD_TYPE (ftype, nargs) = check_typedef (SYMBOL_TYPE (sym));
+	  TYPE_FIELD_NAME (ftype, nargs) = SYMBOL_NAME (sym);
+	  nargs += 1;
+	
+	  break;
+
+	default:
+	  break;
+	}
+    }
+
+  /* Re-allocate fields vector; if there are no fields, make the */
+  /* fields pointer non-null anyway, to mark that this function type */
+  /* has been filled in. */
+
+  TYPE_NFIELDS (ftype) = nargs;
+  if (nargs == 0)
+    {
+      static struct field dummy_field = {0, 0, 0, 0};
+      free (TYPE_FIELDS (ftype));
+      TYPE_FIELDS (ftype) = &dummy_field;
+    }
+  else
+    {
+      struct field* fields = 
+	(struct field*) TYPE_ALLOC (ftype, nargs * sizeof (struct field));
+      memcpy ((char*) fields, 
+	      (char*) TYPE_FIELDS (ftype), 
+	      nargs * sizeof (struct field));
+      free (TYPE_FIELDS (ftype));
+      TYPE_FIELDS (ftype) = fields;
+    }
+}
+
+
+				/* Breakpoint-related */
+
+char no_symtab_msg[] = "No symbol table is loaded.  Use the \"file\" command.";
+
+/* Assuming that LINE is pointing at the beginning of an argument to
+   'break', return a pointer to the delimiter for the initial segment
+   of that name.  This is the first ':', ' ', or end of LINE. 
+*/
+char*
+ada_start_decode_line_1 (line)
+     char* line;
+{
+  /* [NOTE: strpbrk would be more elegant, but I am reluctant to be
+     the first to use such a library function in GDB code.] */
+  char* p;
+  for (p = line; *p != '\000' && *p != ' ' && *p != ':'; p += 1)
+    ;
+  return p;
+}
+
+/* *SPEC points to a function and line number spec (as in a break
+   command), following any initial file name specification.
+
+   Return all symbol table/line specfications (sals) consistent with the
+   information in *SPEC and FILE_TABLE in the
+   following sense: 
+     + FILE_TABLE is null, or the sal refers to a line in the file
+       named by FILE_TABLE.
+     + If *SPEC points to an argument with a trailing ':LINENUM',
+       then the sal refers to that line (or one following it as closely as 
+       possible).
+     + If *SPEC does not start with '*', the sal is in a function with 
+       that name.
+
+   Returns with 0 elements if no matching non-minimal symbols found.
+
+   If *SPEC begins with a function name of the form <NAME>, then NAME
+   is taken as a literal name; otherwise the function name is subject
+   to the usual mangling.
+
+   *SPEC is updated to point after the function/line number specification.
+
+   FUNFIRSTLINE is non-zero if we desire the first line of real code
+   in each function (this is ignored in the presence of a LINENUM spec.).
+
+   If CANONICAL is non-NULL, and if any of the sals require a
+   'canonical line spec', then *CANONICAL is set to point to an array
+   of strings, corresponding to and equal in length to the returned
+   list of sals, such that (*CANONICAL)[i] is non-null and contains a 
+   canonical line spec for the ith returned sal, if needed.  If no 
+   canonical line specs are required and CANONICAL is non-null, 
+   *CANONICAL is set to NULL.
+
+   A 'canonical line spec' is simply a name (in the format of the
+   breakpoint command) that uniquely identifies a breakpoint position,
+   with no further contextual information or user selection.  It is
+   needed whenever the file name, function name, and line number
+   information supplied is insufficient for this unique
+   identification.  Currently overloaded functions, the name '*', 
+   or static functions without a filename yield a canonical line spec.
+   The array and the line spec strings are allocated on the heap; it
+   is the caller's responsibility to free them.   */
+
+struct symtabs_and_lines
+ada_finish_decode_line_1 (spec, file_table, funfirstline, canonical)
+     char** spec;
+     struct symtab* file_table;
+     int funfirstline;
+     char*** canonical;
+{
+  struct symbol** symbols;
+  struct block** blocks;
+  struct block* block;
+  int n_matches, i, line_num;
+  struct symtabs_and_lines selected;
+  struct cleanup* old_chain = make_cleanup (null_cleanup, NULL);
+  char* name;
+
+  int len;
+  char* lower_name;
+  char* unquoted_name;
+
+  if (file_table == NULL)
+    block = get_selected_block (NULL);
+  else
+    block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_table), STATIC_BLOCK);
+
+  if (canonical != NULL)
+    *canonical = (char**) NULL;
+
+  name = *spec;
+  if (**spec == '*') 
+    *spec += 1;
+  else
+    {
+      while (**spec != '\000' && 
+	     ! strchr (ada_completer_word_break_characters, **spec))
+	*spec += 1;
+    }
+  len = *spec - name;
+
+  line_num = -1;
+  if (file_table != NULL && (*spec)[0] == ':' && isdigit ((*spec)[1]))
+    {
+      line_num = strtol (*spec + 1, spec, 10);
+      while (**spec == ' ' || **spec == '\t') 
+	*spec += 1;
+    }
+
+  if (name[0] == '*') 
+    {
+      if (line_num == -1)
+	error ("Wild-card function with no line number or file name.");
+
+      return all_sals_for_line (file_table->filename, line_num, canonical);
+    }
+
+  if (name[0] == '\'')
+    {
+      name += 1;
+      len -= 2;
+    }
+
+  if (name[0] == '<')
+    {
+      unquoted_name = (char*) alloca (len-1);
+      memcpy (unquoted_name, name+1, len-2);
+      unquoted_name[len-2] = '\000';
+      lower_name = NULL;
+    }
+  else
+    {
+      unquoted_name = (char*) alloca (len+1);
+      memcpy (unquoted_name, name, len);
+      unquoted_name[len] = '\000';
+      lower_name = (char*) alloca (len + 1);
+      for (i = 0; i < len; i += 1)
+	lower_name[i] = tolower (name[i]);
+      lower_name[len] = '\000';
+    }
+
+  n_matches = 0;
+  if (lower_name != NULL) 
+    n_matches = ada_lookup_symbol_list (ada_mangle (lower_name), block, 
+					VAR_NAMESPACE, &symbols, &blocks);
+  if (n_matches == 0)
+    n_matches = ada_lookup_symbol_list (unquoted_name, block, 
+					VAR_NAMESPACE, &symbols, &blocks);
+  if (n_matches == 0 && line_num >= 0)
+    error ("No line number information found for %s.", unquoted_name);
+  else if (n_matches == 0)
+    {
+#ifdef HPPA_COMPILER_BUG
+      /* FIXME: See comment in symtab.c::decode_line_1 */
+#undef volatile
+      volatile struct symtab_and_line val;
+#define volatile /*nothing*/
+#else
+      struct symtab_and_line val;
+#endif
+      struct minimal_symbol* msymbol;
+
+      INIT_SAL (&val);
+
+      msymbol = NULL;
+      if (lower_name != NULL) 
+	msymbol = ada_lookup_minimal_symbol (ada_mangle (lower_name));
+      if (msymbol == NULL)
+	msymbol = ada_lookup_minimal_symbol (unquoted_name);
+      if (msymbol != NULL)
+	{
+	  val.pc      = SYMBOL_VALUE_ADDRESS (msymbol);
+	  val.section = SYMBOL_BFD_SECTION (msymbol);
+	  if (funfirstline)
+	    {
+	      val.pc += FUNCTION_START_OFFSET;
+	      SKIP_PROLOGUE (val.pc);
+	    }
+	  selected.sals = (struct symtab_and_line *)
+	    xmalloc (sizeof (struct symtab_and_line));
+	  selected.sals[0] = val;
+	  selected.nelts = 1;
+	  return selected;
+	}	
+      
+      if (!have_full_symbols () &&
+	  !have_partial_symbols () && !have_minimal_symbols ())
+	error (no_symtab_msg);
+
+      error ("Function \"%s\" not defined.", unquoted_name);
+      return selected;	/* for lint */
+    }
+
+  if (line_num >= 0)
+    {
+      return 
+	find_sal_from_funcs_and_line (file_table->filename, line_num, 
+				      symbols, n_matches);
+    }
+  else
+    {
+      selected.nelts = user_select_syms (symbols, blocks, n_matches, n_matches);
+    }
+
+  selected.sals = (struct symtab_and_line*) 
+    xmalloc (sizeof (struct symtab_and_line) * selected.nelts);
+  memset (selected.sals, 0, selected.nelts * sizeof (selected.sals[i]));
+  make_cleanup (free, selected.sals);
+
+  i = 0;
+  while (i < selected.nelts)
+    {
+      if (SYMBOL_CLASS (symbols[i]) == LOC_BLOCK) 
+	selected.sals[i] = find_function_start_sal (symbols[i], funfirstline);
+      else if (SYMBOL_LINE (symbols[i]) != 0) 
+	{
+	  selected.sals[i].symtab = symtab_for_sym (symbols[i]);
+	  selected.sals[i].line = SYMBOL_LINE (symbols[i]);
+	}
+      else if (line_num >= 0)
+	{
+	  /* Ignore this choice */
+	  symbols[i] = symbols[selected.nelts-1];
+	  blocks[i] = blocks[selected.nelts-1];
+	  selected.nelts -= 1;
+	  continue;
+	}
+      else 
+	error ("Line number not known for symbol \"%s\"", unquoted_name);
+      i += 1;
+    }
+
+  if (canonical != NULL && (line_num >= 0 || n_matches > 1))
+    {
+      *canonical = (char**) xmalloc (sizeof(char*) * selected.nelts);
+      for (i = 0; i < selected.nelts; i += 1)
+	(*canonical)[i] = 
+	  extended_canonical_line_spec (selected.sals[i], 
+					SYMBOL_SOURCE_NAME (symbols[i]));
+    }
+   
+  discard_cleanups (old_chain);
+  return selected;
+}  
+      
+/* The (single) sal corresponding to line LINE_NUM in a symbol table
+   with file name FILENAME that occurs in one of the functions listed 
+   in SYMBOLS[0 .. NSYMS-1]. */   
+static struct symtabs_and_lines
+find_sal_from_funcs_and_line (filename, line_num, symbols, nsyms)
+     const char* filename;
+     int line_num;
+     struct symbol** symbols;
+     int nsyms;
+{
+  struct symtabs_and_lines sals;
+  int best_index, best;
+  struct linetable* best_linetable;
+  struct objfile* objfile;
+  struct symtab* s;
+  struct symtab* best_symtab;
+
+  read_all_symtabs (filename);
+
+  best_index = 0; best_linetable = NULL; best_symtab = NULL;
+  best = 0;
+  ALL_SYMTABS (objfile, s)
+    {
+      struct linetable *l;
+      int ind, exact;
+
+      QUIT;	
+
+      if (!STREQ (filename, s->filename))
+	continue;
+      l = LINETABLE (s);
+      ind = find_line_in_linetable (l, line_num, symbols, nsyms, &exact);
+      if (ind >= 0)
+	{
+	  if (exact)
+	    {
+	      best_index = ind;
+	      best_linetable = l;
+	      best_symtab = s;
+	      goto done;
+	    }
+	  if (best == 0 || l->item[ind].line < best)
+	    {
+	      best = l->item[ind].line;
+	      best_index = ind;
+	      best_linetable = l;
+	      best_symtab = s;
+	    }
+	}
+    }
+
+  if (best == 0)
+    error ("Line number not found in designated function.");
+
+ done:
+  
+  sals.nelts = 1;
+  sals.sals = (struct symtab_and_line*) xmalloc (sizeof (sals.sals[0]));
+
+  INIT_SAL (&sals.sals[0]);
+  
+  sals.sals[0].line = best_linetable->item[best_index].line;
+  sals.sals[0].pc = best_linetable->item[best_index].pc;
+  sals.sals[0].symtab = best_symtab;
+
+  return sals;
+}
+
+/* Return the index in LINETABLE of the best match for LINE_NUM whose
+   pc falls within one of the functions denoted by SYMBOLS[0..NSYMS-1].  
+   Set *EXACTP to the 1 if the match is exact, and 0 otherwise. */
+static int
+find_line_in_linetable (linetable, line_num, symbols, nsyms, exactp)
+     struct linetable* linetable;
+     int line_num;
+     struct symbol** symbols;
+     int nsyms;
+     int* exactp;
+{
+  int i, len, best_index, best;
+
+  if (line_num <= 0 || linetable == NULL)
+    return -1;
+
+  len = linetable->nitems;
+  for (i = 0, best_index = -1, best = 0; i < len; i += 1)
+    {
+      int k;
+      struct linetable_entry* item = &(linetable->item[i]);
+
+      for (k = 0; k < nsyms; k += 1)
+	{
+	  if (symbols[k] != NULL && SYMBOL_CLASS (symbols[k]) == LOC_BLOCK
+	      && item->pc >= BLOCK_START (SYMBOL_BLOCK_VALUE (symbols[k]))
+	      && item->pc < BLOCK_END (SYMBOL_BLOCK_VALUE (symbols[k])))
+	    goto candidate;
+	}
+      continue;
+
+    candidate:
+
+      if (item->line == line_num)
+	{
+	  *exactp = 1;
+	  return i;
+	}
+
+      if (item->line > line_num && (best == 0 || item->line < best))
+	{
+	  best = item->line;
+	  best_index = i;
+	}
+    }
+
+  *exactp = 0;
+  return best_index;
+}
+
+/* Find the smallest k >= LINE_NUM such that k is a line number in
+   LINETABLE, and k falls strictly within a named function that begins at
+   or before LINE_NUM.  Return -1 if there is no such k. */
+static int
+nearest_line_number_in_linetable (linetable, line_num)
+     struct linetable* linetable;
+     int line_num;
+{
+  int i, len, best;
+
+  if (line_num <= 0 || linetable == NULL || linetable->nitems == 0)
+    return -1;
+  len = linetable->nitems;
+
+  i = 0; best = INT_MAX;
+  while (i < len)
+    {
+      int k;
+      struct linetable_entry* item = &(linetable->item[i]);
+
+      if (item->line >= line_num && item->line < best)
+	{
+	  char* func_name;
+	  CORE_ADDR start, end;
+
+	  func_name = NULL;
+	  find_pc_partial_function (item->pc, &func_name, &start, &end);
+
+	  if (func_name != NULL && item->pc < end)
+	    {
+	      if (item->line == line_num)
+		return line_num;
+	      else 
+		{
+		  struct symbol* sym = 
+		    standard_lookup (func_name, VAR_NAMESPACE);
+		  if (is_plausible_func_for_line (sym, line_num))
+		    best = item->line;
+		  else
+		    {
+		      do
+			i += 1;
+		      while (i < len && linetable->item[i].pc < end);
+		      continue;
+		    }
+		}
+	    }
+	}
+
+      i += 1;
+    }
+
+  return (best == INT_MAX) ? -1 : best;
+}
+
+
+/* Return the next higher index, k, into LINETABLE such that k > IND, 
+   entry k in LINETABLE has a line number equal to LINE_NUM, k
+   corresponds to a PC that is in a function different from that 
+   corresponding to IND, and falls strictly within a named function
+   that begins at a line at or preceding STARTING_LINE.  
+   Return -1 if there is no such k.  
+   IND == -1 corresponds to no function. */
+
+static int
+find_next_line_in_linetable (linetable, line_num, starting_line, ind)
+     struct linetable* linetable;
+     int line_num;
+     int starting_line;
+     int ind;
+{
+  int i, len;
+
+  if (line_num <= 0 || linetable == NULL || ind >= linetable->nitems)
+    return -1;
+  len = linetable->nitems;
+
+  if (ind >= 0) 
+    {
+      CORE_ADDR start, end;
+
+      if (find_pc_partial_function (linetable->item[ind].pc,
+				    (char**) NULL, &start, &end)) 
+	{
+	  while (ind < len && linetable->item[ind].pc < end)
+	    ind += 1;
+	}
+      else
+	ind += 1;
+    }
+  else
+    ind = 0;
+
+  i = ind;
+  while (i < len)
+    {
+      int k;
+      struct linetable_entry* item = &(linetable->item[i]);
+
+      if (item->line >= line_num)
+	{
+	  char* func_name;
+	  CORE_ADDR start, end;
+
+	  func_name = NULL;
+	  find_pc_partial_function (item->pc, &func_name, &start, &end);
+
+	  if (func_name != NULL && item->pc < end)
+	    {
+	      if (item->line == line_num)
+		{
+		  struct symbol* sym = 
+		    standard_lookup (func_name, VAR_NAMESPACE);
+		  if (is_plausible_func_for_line (sym, starting_line))
+		    return i;
+		  else
+		    {
+		      while ((i+1) < len && linetable->item[i+1].pc < end)
+			i += 1;
+		    }
+		}
+	    }
+	}
+      i += 1;
+    }
+
+  return -1;
+}
+
+/* True iff function symbol SYM starts somewhere at or before line #
+   LINE_NUM. */
+static int
+is_plausible_func_for_line (sym, line_num)
+     struct symbol* sym;
+     int line_num;
+{
+  struct symtab_and_line start_sal;
+
+  if (sym == NULL)
+    return 0;
+
+  start_sal = find_function_start_sal (sym, 0);
+
+  return (start_sal.line != 0 && line_num >= start_sal.line);
+}
+
+static void
+debug_print_lines (lt)
+     struct linetable* lt;
+{
+  int i;
+
+  if (lt == NULL) 
+    return;
+
+  fprintf (stderr, "\t");
+  for (i = 0; i < lt->nitems; i += 1)
+    fprintf (stderr, "(%d->%p) ", lt->item[i].line, (void *) lt->item[i].pc);
+  fprintf (stderr, "\n");
+}
+
+static void
+debug_print_block (b)
+     struct block* b;
+{
+  int i;
+  fprintf (stderr, "Block: %p; [0x%lx, 0x%lx]", 
+	   b, BLOCK_START(b), BLOCK_END(b));
+  if (BLOCK_FUNCTION(b) != NULL)
+    fprintf (stderr, " Function: %s", SYMBOL_NAME (BLOCK_FUNCTION(b)));
+  fprintf (stderr, "\n");
+  fprintf (stderr, "\t    Superblock: %p\n", BLOCK_SUPERBLOCK(b));
+  fprintf (stderr, "\t    Symbols:");
+  for (i = 0; i < BLOCK_NSYMS (b); i += 1)
+    {
+      if (i > 0 && i % 4 == 0)
+	fprintf (stderr, "\n\t\t    ");
+      fprintf (stderr, " %s", SYMBOL_NAME (BLOCK_SYM (b, i)));
+    }
+  fprintf (stderr, "\n");
+}
+
+static void
+debug_print_blocks (bv)
+     struct blockvector* bv;
+{
+  int i;
+
+  if (bv == NULL)
+    return;
+  for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i += 1) {
+    fprintf (stderr, "%6d. ", i);
+    debug_print_block (BLOCKVECTOR_BLOCK (bv, i));
+  }
+}
+
+static void
+debug_print_symtab (s)
+     struct symtab* s;
+{
+  fprintf (stderr, "Symtab %p\n    File: %s; Dir: %s\n", s,
+	   s->filename, s->dirname);
+  fprintf (stderr, "    Blockvector: %p, Primary: %d\n",
+	   BLOCKVECTOR(s), s->primary);
+  debug_print_blocks (BLOCKVECTOR(s));
+  fprintf (stderr, "    Line table: %p\n", LINETABLE (s));
+  debug_print_lines (LINETABLE(s));
+}
+
+/* Read in all symbol tables corresponding to partial symbol tables
+   with file name FILENAME. */
+static void
+read_all_symtabs (filename)
+     const char* filename;
+{
+  struct partial_symtab* ps;
+  struct objfile* objfile;
+
+  ALL_PSYMTABS (objfile, ps)
+    {
+      QUIT;
+
+      if (STREQ (filename, ps->filename))
+	PSYMTAB_TO_SYMTAB (ps);
+    }
+}
+
+/* All sals corresponding to line LINE_NUM in a symbol table from file
+   FILENAME, as filtered by the user.  If CANONICAL is not null, set
+   it to a corresponding array of canonical line specs. */
+static struct symtabs_and_lines
+all_sals_for_line (filename, line_num, canonical)
+     const char* filename;
+     int line_num;
+     char*** canonical;
+{
+  struct symtabs_and_lines result;
+  struct objfile* objfile;
+  struct symtab* s;
+  struct cleanup* old_chain = make_cleanup (null_cleanup, NULL);
+  size_t len;
+
+  read_all_symtabs (filename);
+
+  result.sals = (struct symtab_and_line*) xmalloc (4 * sizeof (result.sals[0]));
+  result.nelts = 0;
+  len = 4;
+  make_cleanup (free_current_contents, &result.sals);
+
+  ALL_SYMTABS (objfile, s) 
+    {
+      int ind, target_line_num;
+
+      QUIT;
+
+      if (!STREQ (s->filename, filename))
+	continue;
+
+      target_line_num = 
+	nearest_line_number_in_linetable (LINETABLE (s), line_num);
+      if (target_line_num == -1)
+	continue;
+
+      ind = -1;
+      while (1) 
+	{
+	  ind = 
+	    find_next_line_in_linetable (LINETABLE (s),
+					 target_line_num, line_num, ind);
+	  
+	  if (ind < 0)
+	    break;
+
+	  GROW_VECT (result.sals, len, result.nelts+1);
+	  INIT_SAL (&result.sals[result.nelts]);
+	  result.sals[result.nelts].line = LINETABLE(s)->item[ind].line;
+	  result.sals[result.nelts].pc = LINETABLE(s)->item[ind].pc;
+	  result.sals[result.nelts].symtab = s;
+	  result.nelts += 1;
+	}
+    }
+
+  if (canonical != NULL || result.nelts > 1)
+    {
+      int k;
+      char** func_names = (char**) alloca (result.nelts * sizeof (char*));
+      int first_choice = (result.nelts > 1) ? 2 : 1;
+      int n;
+      int* choices = (int*) alloca (result.nelts * sizeof (int));
+      
+      for (k = 0; k < result.nelts; k += 1) 
+	{
+	  find_pc_partial_function (result.sals[k].pc, &func_names[k], 
+				    (CORE_ADDR*) NULL, (CORE_ADDR*) NULL);
+	  if (func_names[k] == NULL)
+	    error ("Could not find function for one or more breakpoints.");
+	}
+      
+      if (result.nelts > 1) 
+	{
+	  printf_unfiltered("[0] cancel\n");
+	  if (result.nelts > 1) 
+	    printf_unfiltered("[1] all\n");
+	  for (k = 0; k < result.nelts; k += 1)
+	    printf_unfiltered ("[%d] %s\n", k + first_choice, 
+			       ada_demangle (func_names[k]));
+	  
+	  n = get_selections (choices, result.nelts, result.nelts,
+			      result.nelts > 1, "instance-choice");
+      
+	  for (k = 0; k < n; k += 1) 
+	    {
+	      result.sals[k] = result.sals[choices[k]];
+	      func_names[k] = func_names[choices[k]];
+	    }
+	  result.nelts = n;
+	}
+
+      if (canonical != NULL) 
+	{
+	  *canonical = (char**) xmalloc (result.nelts * sizeof (char**));
+	  make_cleanup (free, *canonical);
+	  for (k = 0; k < result.nelts; k += 1) 
+	    {
+	      (*canonical)[k] = 
+		extended_canonical_line_spec (result.sals[k], func_names[k]);
+	      if ((*canonical)[k] == NULL)
+		error ("Could not locate one or more breakpoints.");
+	      make_cleanup (free, (*canonical)[k]);
+	    }
+	}
+    }
+
+  discard_cleanups (old_chain);
+  return result;
+}
+
+
+/* A canonical line specification of the form FILE:NAME:LINENUM for
+   symbol table and line data SAL.  NULL if insufficient
+   information. The caller is responsible for releasing any space
+   allocated. */
+
+static char*
+extended_canonical_line_spec (sal, name)
+     struct symtab_and_line sal;
+     const char* name;
+{
+  char* r;
+
+  if (sal.symtab == NULL || sal.symtab->filename == NULL || 
+      sal.line <= 0)
+    return NULL;
+
+  r = (char*) xmalloc (strlen (name) + strlen (sal.symtab->filename)  
+		       + sizeof(sal.line)*3 + 3);
+  sprintf (r, "%s:'%s':%d", sal.symtab->filename, name, sal.line);
+  return r;
+}
+
+#if 0
+int begin_bnum = -1;
+#endif
+int begin_annotate_level = 0;
+
+static void 
+begin_cleanup (void* dummy) 
+{
+  begin_annotate_level = 0;
+}
+
+static void
+begin_command (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  struct minimal_symbol *msym;
+  CORE_ADDR main_program_name_addr;
+  char main_program_name[1024];
+  struct cleanup* old_chain = make_cleanup (begin_cleanup, NULL);
+  begin_annotate_level = 2;
+
+  /* Check that there is a program to debug */
+  if (!have_full_symbols () && !have_partial_symbols ())
+    error ("No symbol table is loaded.  Use the \"file\" command.");
+  
+  /* Check that we are debugging an Ada program */
+  /*  if (ada_update_initial_language (language_unknown, NULL) != language_ada)
+    error ("Cannot find the Ada initialization procedure.  Is this an Ada main program?");
+  */
+  /* FIXME: language_ada should be defined in defs.h */
+
+  /* Get the address of the name of the main procedure */
+  msym = lookup_minimal_symbol (ADA_MAIN_PROGRAM_SYMBOL_NAME, NULL, NULL);
+
+  if (msym != NULL)
+  {
+    main_program_name_addr = SYMBOL_VALUE_ADDRESS (msym);
+    if (main_program_name_addr == 0)
+      error ("Invalid address for Ada main program name.");
+
+    /* Read the name of the main procedure */
+    extract_string (main_program_name_addr, main_program_name);
+
+    /* Put a temporary breakpoint in the Ada main program and run */
+    do_command ("tbreak ", main_program_name, 0);
+    do_command ("run ", args, 0);
+  }
+  else
+  {
+    /* If we could not find the symbol containing the name of the
+       main program, that means that the compiler that was used to build
+       was not recent enough. In that case, we fallback to the previous
+       mechanism, which is a little bit less reliable, but has proved to work
+       in most cases. The only cases where it will fail is when the user
+       has set some breakpoints which will be hit before the end of the
+       begin command processing (eg in the initialization code).
+
+       The begining of the main Ada subprogram is located by breaking
+       on the adainit procedure. Since we know that the binder generates
+       the call to this procedure exactly 2 calls before the call to the
+       Ada main subprogram, it is then easy to put a breakpoint on this
+       Ada main subprogram once we hit adainit.
+     */
+     do_command ("tbreak adainit", 0);
+     do_command ("run ", args, 0);
+     do_command ("up", 0);
+     do_command ("tbreak +2", 0);
+     do_command ("continue", 0);
+     do_command ("step", 0);
+  }
+
+  do_cleanups (old_chain);
+}
+
+int
+is_ada_runtime_file (filename)
+     char *filename;
+{
+  return (STREQN (filename, "s-", 2) ||
+	  STREQN (filename, "a-", 2) ||
+	  STREQN (filename, "g-", 2) ||
+	  STREQN (filename, "i-", 2));
+}
+
+/* find the first frame that contains debugging information and that is not
+   part of the Ada run-time, starting from fi and moving upward. */
+
+int
+find_printable_frame (fi, level)
+     struct frame_info *fi;
+     int level;
+{
+  struct symtab_and_line sal;
+  
+  for (; fi != NULL; level += 1, fi = get_prev_frame (fi))
+    {
+      /* If fi is not the innermost frame, that normally means that fi->pc
+	 points to *after* the call instruction, and we want to get the line
+	 containing the call, never the next line.  But if the next frame is
+	 a signal_handler_caller or a dummy frame, then the next frame was
+	 not entered as the result of a call, and we want to get the line
+	 containing fi->pc.  */
+      sal =
+        find_pc_line (fi->pc,
+		      fi->next != NULL
+		      && !fi->next->signal_handler_caller
+		      && !frame_in_dummy (fi->next));
+      if (sal.symtab && !is_ada_runtime_file (sal.symtab->filename))
+	{
+#if defined(__alpha__) && defined(__osf__) && !defined(VXWORKS_TARGET)
+	/* libpthread.so contains some debugging information that prevents us
+	   from finding the right frame */
+
+	  if (sal.symtab->objfile &&
+	      STREQ (sal.symtab->objfile->name, "/usr/shlib/libpthread.so"))
+	      continue;
+#endif
+	  selected_frame = fi;
+	  break;
+	}
+    }
+
+  return level;
+}
+
+void
+ada_report_exception_break (b)
+     struct breakpoint *b;
+{
+#ifdef UI_OUT
+  /* FIXME: break_on_exception should be defined in breakpoint.h */
+  /*  if (b->break_on_exception == 1)
+    {
+      /* Assume that cond has 16 elements, the 15th
+	 being the exception */ /*
+      if (b->cond && b->cond->nelts == 16)
+	{
+	  ui_out_text (uiout, "on ");
+	  ui_out_field_string (uiout, "exception",
+			       SYMBOL_NAME (b->cond->elts[14].symbol));
+	}
+      else
+	ui_out_text (uiout, "on all exceptions");
+    }
+  else if (b->break_on_exception == 2)
+    ui_out_text (uiout, "on unhandled exception");
+  else if (b->break_on_exception == 3)
+    ui_out_text (uiout, "on assert failure");
+#else
+  if (b->break_on_exception == 1)
+  {*/
+      /* Assume that cond has 16 elements, the 15th
+	 being the exception */ /*
+      if (b->cond && b->cond->nelts == 16)
+	{
+	  fputs_filtered ("on ", gdb_stdout);
+	  fputs_filtered (SYMBOL_NAME
+			  (b->cond->elts[14].symbol), gdb_stdout);
+	}
+      else
+	fputs_filtered ("on all exceptions", gdb_stdout);
+    }
+  else if (b->break_on_exception == 2)
+    fputs_filtered ("on unhandled exception", gdb_stdout);
+  else if (b->break_on_exception == 3)
+    fputs_filtered ("on assert failure", gdb_stdout);
+*/    
+#endif
+}
+
+int
+ada_is_exception_sym (struct symbol* sym)
+{
+  char *type_name = type_name_no_tag (SYMBOL_TYPE (sym));
+  
+  return (SYMBOL_CLASS (sym) != LOC_TYPEDEF
+	  && SYMBOL_CLASS (sym) != LOC_BLOCK
+	  && SYMBOL_CLASS (sym) != LOC_CONST
+	  && type_name != NULL
+	  && STREQ (type_name, "exception"));
+}
+
+int
+ada_maybe_exception_partial_symbol (struct partial_symbol* sym)
+{
+  return (SYMBOL_CLASS (sym) != LOC_TYPEDEF
+	  && SYMBOL_CLASS (sym) != LOC_BLOCK
+	  && SYMBOL_CLASS (sym) != LOC_CONST);
+}
+
+/* If ARG points to an Ada exception or assert breakpoint, rewrite
+   into equivalent form.  Return resulting argument string. Set
+   *BREAK_ON_EXCEPTIONP to 1 for ordinary break on exception, 2 for
+   break on unhandled, 3 for assert, 0 otherwise. */
+char* ada_breakpoint_rewrite (char* arg, int* break_on_exceptionp)
+{
+  if (arg == NULL)
+    return arg;
+  *break_on_exceptionp = 0;
+  /* FIXME: language_ada should be defined in defs.h */  
+  /*  if (current_language->la_language == language_ada
+      && STREQN (arg, "exception", 9) &&
+      (arg[9] == ' ' || arg[9] == '\t' || arg[9] == '\0'))
+    {
+      char *tok, *end_tok;
+      int toklen;
+
+      *break_on_exceptionp = 1;
+
+      tok = arg+9;
+      while (*tok == ' ' || *tok == '\t')
+	tok += 1;
+
+      end_tok = tok;
+
+      while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
+	end_tok += 1;
+
+      toklen = end_tok - tok;
+
+      arg = (char*) xmalloc (sizeof ("__gnat_raise_nodefer_with_msg if "
+				     "long_integer(e) = long_integer(&)")
+			     + toklen + 1);
+      make_cleanup (free, arg);
+      if (toklen == 0)
+	strcpy (arg, "__gnat_raise_nodefer_with_msg");
+      else if (STREQN (tok, "unhandled", toklen))
+	{
+	  *break_on_exceptionp = 2;
+	  strcpy (arg, "__gnat_unhandled_exception");
+	}
+      else
+	{
+	  sprintf (arg, "__gnat_raise_nodefer_with_msg if "
+		   "long_integer(e) = long_integer(&%.*s)", 
+		   toklen, tok);
+	}
+    }
+  else if (current_language->la_language == language_ada
+	   && STREQN (arg, "assert", 6) &&
+	   (arg[6] == ' ' || arg[6] == '\t' || arg[6] == '\0'))
+    {
+      char *tok = arg + 6;
+
+      *break_on_exceptionp = 3;
+
+      arg = (char*) 
+	xmalloc (sizeof ("system__assertions__raise_assert_failure")
+		 + strlen (tok) + 1);
+      make_cleanup (free, arg);
+      sprintf (arg, "system__assertions__raise_assert_failure%s", tok);
+    }
+  */
+  return arg;
+}
+
+
+				/* Field Access */
+
+/* True if field number FIELD_NUM in struct or union type TYPE is supposed
+   to be invisible to users. */
+
+int
+ada_is_ignored_field (type, field_num)
+     struct type *type;
+     int field_num;
+{
+  if (field_num < 0 || field_num > TYPE_NFIELDS (type))
+    return 1;
+  else 
+    {
+      const char* name = TYPE_FIELD_NAME (type, field_num);
+      return (name == NULL
+	      || (name[0] == '_' && ! STREQN (name, "_parent", 7)));
+    }
+}
+
+/* True iff structure type TYPE has a tag field. */
+
+int
+ada_is_tagged_type (type)
+     struct type *type;
+{
+  if (type == NULL || TYPE_CODE (type) != TYPE_CODE_STRUCT)
+    return 0;
+
+  return (ada_lookup_struct_elt_type (type, "_tag", 1, NULL) != NULL);
+}
+
+/* The type of the tag on VAL. */
+
+struct type*
+ada_tag_type (val)
+     struct value* val;
+{
+  return ada_lookup_struct_elt_type (VALUE_TYPE (val), "_tag", 0, NULL);
+}
+
+/* The value of the tag on VAL. */
+
+struct value*
+ada_value_tag (val)
+     struct value* val;
+{
+  return ada_value_struct_elt (val, "_tag", "record");
+}
+
+/* The parent type of TYPE, or NULL if none. */
+
+struct type*
+ada_parent_type (type)
+     struct type *type;
+{
+  int i;
+
+  CHECK_TYPEDEF (type);
+
+  if (type == NULL || TYPE_CODE (type) != TYPE_CODE_STRUCT)
+    return NULL;
+
+  for (i = 0; i < TYPE_NFIELDS (type); i += 1)
+    if (ada_is_parent_field (type, i))
+      return check_typedef (TYPE_FIELD_TYPE (type, i));
+
+  return NULL;
+}
+
+/* True iff field number FIELD_NUM of structure type TYPE contains the 
+   parent-type (inherited) fields of a derived type.  Assumes TYPE is 
+   a structure type with at least FIELD_NUM+1 fields. */
+
+int
+ada_is_parent_field (type, field_num)
+     struct type *type;
+     int field_num;
+{
+  const char* name = TYPE_FIELD_NAME (check_typedef (type), field_num);
+  return (name != NULL && 
+	  (STREQN (name, "PARENT", 6) || STREQN (name, "_parent", 7)));
+}
+
+/* True iff field number FIELD_NUM of structure type TYPE is a 
+   transparent wrapper field (which should be silently traversed when doing
+   field selection and flattened when printing).  Assumes TYPE is a 
+   structure type with at least FIELD_NUM+1 fields.  Such fields are always
+   structures. */
+
+int
+ada_is_wrapper_field (type, field_num)
+     struct type *type;
+     int field_num;
+{
+  const char* name = TYPE_FIELD_NAME (type, field_num);
+  return (name != NULL 
+	  && (STREQN (name, "PARENT", 6) || STREQ (name, "REP") 
+	      || STREQN (name, "_parent", 7)
+	      || name[0] == 'S' || name[0] == 'R' || name[0] == 'O'));
+}
+
+/* True iff field number FIELD_NUM of structure or union type TYPE 
+   is a variant wrapper.  Assumes TYPE is a structure type with at least 
+   FIELD_NUM+1 fields. */ 
+
+int
+ada_is_variant_part (type, field_num)
+     struct type *type;
+     int field_num;
+{
+  struct type* field_type = TYPE_FIELD_TYPE (type, field_num);
+  return (TYPE_CODE (field_type) == TYPE_CODE_UNION
+	  || (is_dynamic_field (type, field_num)
+	      && TYPE_CODE (TYPE_TARGET_TYPE (field_type)) == TYPE_CODE_UNION));
+}
+
+/* Assuming that VAR_TYPE is a variant wrapper (type of the variant part)
+   whose discriminants are contained in the record type OUTER_TYPE, 
+   returns the type of the controlling discriminant for the variant.  */
+
+struct type*
+ada_variant_discrim_type (var_type, outer_type)
+     struct type *var_type;
+     struct type *outer_type;
+{
+  char* name = ada_variant_discrim_name (var_type);
+  struct type *type = 
+    ada_lookup_struct_elt_type (outer_type, name, 1, NULL);
+  if (type == NULL)
+    return builtin_type_int;
+  else
+    return type;
+}
+
+/* Assuming that TYPE is the type of a variant wrapper, and FIELD_NUM is a 
+   valid field number within it, returns 1 iff field FIELD_NUM of TYPE
+   represents a 'when others' clause; otherwise 0. */
+
+int
+ada_is_others_clause (type, field_num)
+     struct type *type;
+     int field_num;
+{
+  const char* name = TYPE_FIELD_NAME (type, field_num);
+  return (name != NULL && name[0] == 'O');
+}
+
+/* Assuming that TYPE0 is the type of the variant part of a record,
+   returns the name of the discriminant controlling the variant.  The
+   value is valid until the next call to ada_variant_discrim_name. */
+
+char * 
+ada_variant_discrim_name (type0)
+     struct type *type0;
+{
+  static char* result = NULL;
+  static size_t result_len = 0;
+  struct type* type;
+  const char* name;
+  const char* discrim_end; 
+  const char* discrim_start;
+
+  if (TYPE_CODE (type0) == TYPE_CODE_PTR)
+    type = TYPE_TARGET_TYPE (type0);
+  else
+    type = type0;
+
+  name = ada_type_name (type);
+
+  if (name == NULL || name[0] == '\000')
+    return "";
+
+  for (discrim_end = name + strlen (name) - 6; discrim_end != name;
+       discrim_end -= 1)
+    {
+      if (STREQN (discrim_end, "___XVN", 6))
+	break;
+    }
+  if (discrim_end == name)
+    return "";
+
+  for (discrim_start = discrim_end; discrim_start != name+3;
+       discrim_start -= 1)
+    {
+      if (discrim_start == name+1)
+	return "";
+      if ((discrim_start > name+3 && STREQN (discrim_start-3, "___", 3))
+	  || discrim_start[-1] == '.')
+	break;
+    }
+
+  GROW_VECT (result, result_len, discrim_end - discrim_start + 1);
+  strncpy (result, discrim_start, discrim_end - discrim_start);
+  result[discrim_end-discrim_start] = '\0';
+  return result;
+}
+
+/* Scan STR for a subtype-encoded number, beginning at position K. Put the 
+   position of the character just past the number scanned in *NEW_K, 
+   if NEW_K!=NULL. Put the scanned number in *R, if R!=NULL.  Return 1 
+   if there was a valid number at the given position, and 0 otherwise.  A 
+   "subtype-encoded" number consists of the absolute value in decimal, 
+   followed by the letter 'm' to indicate a negative number.  Assumes 0m 
+   does not occur. */
+
+int
+ada_scan_number (str, k, R, new_k)
+     const char str[];
+     int k;
+     LONGEST *R;
+     int *new_k;
+{
+  ULONGEST RU;
+
+  if (! isdigit (str[k]))
+    return 0;
+
+  /* Do it the hard way so as not to make any assumption about 
+     the relationship of unsigned long (%lu scan format code) and
+     LONGEST. */
+  RU = 0;
+  while (isdigit (str[k]))
+    {
+      RU = RU*10 + (str[k] - '0');
+      k += 1;
+    }
+
+  if (str[k] == 'm') 
+    {
+      if (R != NULL)
+	*R = (- (LONGEST) (RU-1)) - 1;
+      k += 1;
+    }
+  else if (R != NULL)
+    *R = (LONGEST) RU;
+
+  /* NOTE on the above: Technically, C does not say what the results of 
+     - (LONGEST) RU or (LONGEST) -RU are for RU == largest positive
+     number representable as a LONGEST (although either would probably work
+     in most implementations).  When RU>0, the locution in the then branch
+     above is always equivalent to the negative of RU. */
+
+  if (new_k != NULL)
+    *new_k = k;
+  return 1;
+}
+
+/* Assuming that TYPE is a variant part wrapper type (a VARIANTS field), 
+   and FIELD_NUM is a valid field number within it, returns 1 iff VAL is 
+   in the range encoded by field FIELD_NUM of TYPE; otherwise 0. */
+
+int 
+ada_in_variant (val, type, field_num)
+     LONGEST val;
+     struct type *type;
+     int field_num;
+{
+  const char* name = TYPE_FIELD_NAME (type, field_num);
+  int p;
+
+  p = 0;
+  while (1)
+    {
+      switch (name[p]) 
+	{
+	case '\0':
+	  return 0;
+	case 'S':
+	  {
+	    LONGEST W;
+	    if (! ada_scan_number (name, p + 1, &W, &p))
+	      return 0;
+	    if (val == W)
+	      return 1;
+	    break;
+	  }
+	case 'R':
+	  {
+	    LONGEST L, U;
+	    if (! ada_scan_number (name, p + 1, &L, &p)
+		|| name[p] != 'T'
+		|| ! ada_scan_number (name, p + 1, &U, &p))
+	      return 0;
+	    if (val >= L && val <= U)
+	      return 1;
+	    break;
+	  }
+	case 'O':
+	  return 1;
+	default:
+	  return 0;
+	}
+    }
+}
+
+/* Given a value ARG1 (offset by OFFSET bytes)
+   of a struct or union type ARG_TYPE,
+   extract and return the value of one of its (non-static) fields.
+   FIELDNO says which field.   Differs from value_primitive_field only
+   in that it can handle packed values of arbitrary type. */
+
+struct value*
+ada_value_primitive_field (arg1, offset, fieldno, arg_type)
+     struct value* arg1;
+     int offset;
+     int fieldno;
+     struct type *arg_type;
+{
+  struct value* v;
+  struct type *type;
+
+  CHECK_TYPEDEF (arg_type);
+  type = TYPE_FIELD_TYPE (arg_type, fieldno);
+
+  /* Handle packed fields */
+
+  if (TYPE_FIELD_BITSIZE (arg_type, fieldno) != 0)
+    {
+      int bit_pos = TYPE_FIELD_BITPOS (arg_type, fieldno);
+      int bit_size = TYPE_FIELD_BITSIZE (arg_type, fieldno);
+      
+      return ada_value_primitive_packed_val (arg1, VALUE_CONTENTS (arg1),
+					     offset + bit_pos/8, bit_pos % 8,
+					     bit_size, type);
+    }
+  else
+    return value_primitive_field (arg1, offset, fieldno, arg_type);
+}
+
+
+/* Look for a field NAME in ARG. Adjust the address of ARG by OFFSET bytes,
+   and search in it assuming it has (class) type TYPE.
+   If found, return value, else return NULL.
+
+   Searches recursively through wrapper fields (e.g., '_parent'). */
+
+struct value*
+ada_search_struct_field (name, arg, offset, type)
+     char *name;
+     struct value* arg;
+     int offset;
+     struct type *type;
+{
+  int i;
+  CHECK_TYPEDEF (type);
+
+  for (i = TYPE_NFIELDS (type)-1; i >= 0; i -= 1)
+    {
+      char *t_field_name = TYPE_FIELD_NAME (type, i);
+
+      if (t_field_name == NULL)
+	continue;
+
+      else if (field_name_match (t_field_name, name))
+	  return ada_value_primitive_field (arg, offset, i, type);
+
+      else if (ada_is_wrapper_field (type, i))
+	{
+	  struct value* v = 
+	    ada_search_struct_field (name, arg, 
+				     offset + TYPE_FIELD_BITPOS (type, i) / 8, 
+				     TYPE_FIELD_TYPE (type, i));
+	  if (v != NULL)
+	    return v;
+	}
+
+      else if (ada_is_variant_part (type, i))
+	{
+	  int j;
+	  struct type *field_type = check_typedef (TYPE_FIELD_TYPE (type, i));
+	  int var_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
+
+	  for (j = TYPE_NFIELDS (field_type) - 1; j >= 0; j -= 1)
+	    {
+	      struct value* v = 
+		ada_search_struct_field (name, arg, 
+					 var_offset 
+					 + TYPE_FIELD_BITPOS (field_type, j)/8,
+					 TYPE_FIELD_TYPE (field_type, j));
+	      if (v != NULL)
+		return v;
+	    }
+	}
+    }
+  return NULL;
+}
+  
+/* Given ARG, a value of type (pointer to a)* structure/union,
+   extract the component named NAME from the ultimate target structure/union
+   and return it as a value with its appropriate type.
+
+   The routine searches for NAME among all members of the structure itself 
+   and (recursively) among all members of any wrapper members 
+   (e.g., '_parent').
+
+   ERR is a name (for use in error messages) that identifies the class 
+   of entity that ARG is supposed to be. */
+
+struct value*
+ada_value_struct_elt (arg, name, err)
+     struct value* arg;
+     char *name;
+     char *err;
+{
+  struct type *t;
+  struct value* v;
+
+  arg = ada_coerce_ref (arg);
+  t = check_typedef (VALUE_TYPE (arg));
+
+  /* Follow pointers until we get to a non-pointer.  */
+
+  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
+    {
+      arg = ada_value_ind (arg);
+      t = check_typedef (VALUE_TYPE (arg));
+    }
+
+  if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
+      && TYPE_CODE (t) != TYPE_CODE_UNION)
+    error ("Attempt to extract a component of a value that is not a %s.", err);
+
+  v = ada_search_struct_field (name, arg, 0, t);
+  if (v == NULL)
+    error ("There is no member named %s.", name);
+
+  return v;
+}
+
+/* Given a type TYPE, look up the type of the component of type named NAME.
+   If DISPP is non-null, add its byte displacement from the beginning of a 
+   structure (pointed to by a value) of type TYPE to *DISPP (does not 
+   work for packed fields).
+
+   Matches any field whose name has NAME as a prefix, possibly
+   followed by "___". 
+
+   TYPE can be either a struct or union, or a pointer or reference to 
+   a struct or union.  If it is a pointer or reference, its target 
+   type is automatically used.
+
+   Looks recursively into variant clauses and parent types.
+
+   If NOERR is nonzero, return NULL if NAME is not suitably defined. */
+
+struct type *
+ada_lookup_struct_elt_type (type, name, noerr, dispp)
+     struct type *type;
+     char *name;
+     int noerr;
+     int *dispp;
+{
+  int i;
+
+  if (name == NULL)
+    goto BadName;
+
+  while (1)
+    {
+      CHECK_TYPEDEF (type);
+      if (TYPE_CODE (type) != TYPE_CODE_PTR
+	  && TYPE_CODE (type) != TYPE_CODE_REF)
+	break;
+      type = TYPE_TARGET_TYPE (type);
+    }
+
+  if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
+      TYPE_CODE (type) != TYPE_CODE_UNION)
+    {
+      target_terminal_ours ();
+      gdb_flush (gdb_stdout);
+      fprintf_unfiltered (gdb_stderr, "Type ");
+      type_print (type, "", gdb_stderr, -1);
+      error (" is not a structure or union type");
+    }
+
+  type = to_static_fixed_type (type);
+
+  for (i = 0; i < TYPE_NFIELDS (type); i += 1)
+    {
+      char *t_field_name = TYPE_FIELD_NAME (type, i);
+      struct type *t;
+      int disp;
+  
+      if (t_field_name == NULL)
+	continue;
+
+      else if (field_name_match (t_field_name, name))
+	{
+	  if (dispp != NULL) 
+	    *dispp += TYPE_FIELD_BITPOS (type, i) / 8;
+	  return check_typedef (TYPE_FIELD_TYPE (type, i));
+	}
+
+      else if (ada_is_wrapper_field (type, i))
+	{
+	  disp = 0;
+	  t = ada_lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 
+					  1, &disp);
+	  if (t != NULL)
+	    {
+	      if (dispp != NULL)
+		*dispp += disp + TYPE_FIELD_BITPOS (type, i) / 8;
+	      return t;
+	    }
+	}
+
+      else if (ada_is_variant_part (type, i))
+	{
+	  int j;
+	  struct type *field_type = check_typedef (TYPE_FIELD_TYPE (type, i));
+
+	  for (j = TYPE_NFIELDS (field_type) - 1; j >= 0; j -= 1)
+	    {
+	      disp = 0;
+	      t = ada_lookup_struct_elt_type (TYPE_FIELD_TYPE (field_type, j),
+					      name, 1, &disp);
+	      if (t != NULL)
+		{
+		  if (dispp != NULL) 
+		    *dispp += disp + TYPE_FIELD_BITPOS (type, i) / 8;
+		  return t;
+		}
+	    }
+	}
+
+    }
+
+BadName:
+  if (! noerr)
+    {
+      target_terminal_ours ();
+      gdb_flush (gdb_stdout);
+      fprintf_unfiltered (gdb_stderr, "Type ");
+      type_print (type, "", gdb_stderr, -1);
+      fprintf_unfiltered (gdb_stderr, " has no component named ");
+      error ("%s", name == NULL ? "<null>" : name);
+    }
+
+  return NULL;
+}
+
+/* Assuming that VAR_TYPE is the type of a variant part of a record (a union),
+   within a value of type OUTER_TYPE that is stored in GDB at
+   OUTER_VALADDR, determine which variant clause (field number in VAR_TYPE, 
+   numbering from 0) is applicable.  Returns -1 if none are. */
+
+int 
+ada_which_variant_applies (var_type, outer_type, outer_valaddr)
+     struct type *var_type;
+     struct type *outer_type;
+     char* outer_valaddr;
+{
+  int others_clause;
+  int i;
+  int disp;
+  struct type* discrim_type;
+  char* discrim_name = ada_variant_discrim_name (var_type);
+  LONGEST discrim_val;
+
+  disp = 0;
+  discrim_type = 
+    ada_lookup_struct_elt_type (outer_type, discrim_name, 1, &disp);
+  if (discrim_type == NULL)
+    return -1;
+  discrim_val = unpack_long (discrim_type, outer_valaddr + disp);
+
+  others_clause = -1;
+  for (i = 0; i < TYPE_NFIELDS (var_type); i += 1)
+    {
+      if (ada_is_others_clause (var_type, i))
+	others_clause = i;
+      else if (ada_in_variant (discrim_val, var_type, i))
+	return i;
+    }
+
+  return others_clause;
+}
+
+
+
+				/* Dynamic-Sized Records */
+
+/* Strategy: The type ostensibly attached to a value with dynamic size
+   (i.e., a size that is not statically recorded in the debugging
+   data) does not accurately reflect the size or layout of the value.
+   Our strategy is to convert these values to values with accurate,
+   conventional types that are constructed on the fly. */
+
+/* There is a subtle and tricky problem here.  In general, we cannot
+   determine the size of dynamic records without its data.  However,
+   the 'struct value' data structure, which GDB uses to represent
+   quantities in the inferior process (the target), requires the size
+   of the type at the time of its allocation in order to reserve space
+   for GDB's internal copy of the data.  That's why the
+   'to_fixed_xxx_type' routines take (target) addresses as parameters,
+   rather than struct value*s.  
+
+   However, GDB's internal history variables ($1, $2, etc.) are
+   struct value*s containing internal copies of the data that are not, in
+   general, the same as the data at their corresponding addresses in
+   the target.  Fortunately, the types we give to these values are all
+   conventional, fixed-size types (as per the strategy described
+   above), so that we don't usually have to perform the
+   'to_fixed_xxx_type' conversions to look at their values.
+   Unfortunately, there is one exception: if one of the internal
+   history variables is an array whose elements are unconstrained
+   records, then we will need to create distinct fixed types for each
+   element selected.  */
+
+/* The upshot of all of this is that many routines take a (type, host
+   address, target address) triple as arguments to represent a value.
+   The host address, if non-null, is supposed to contain an internal
+   copy of the relevant data; otherwise, the program is to consult the
+   target at the target address. */
+
+/* Assuming that VAL0 represents a pointer value, the result of
+   dereferencing it.  Differs from value_ind in its treatment of
+   dynamic-sized types. */
+
+struct value*
+ada_value_ind (val0)
+     struct value* val0;
+{
+  struct value* val = unwrap_value (value_ind (val0));
+  return ada_to_fixed_value (VALUE_TYPE (val), 0,
+			     VALUE_ADDRESS (val) + VALUE_OFFSET (val),
+			     val);
+}
+
+/* The value resulting from dereferencing any "reference to"
+ * qualifiers on VAL0. */
+static struct value* 
+ada_coerce_ref (val0)
+     struct value* val0;
+{
+  if (TYPE_CODE (VALUE_TYPE (val0)) == TYPE_CODE_REF) {
+    struct value* val = val0;
+    COERCE_REF (val);
+    val = unwrap_value (val);
+    return ada_to_fixed_value (VALUE_TYPE (val), 0, 
+			       VALUE_ADDRESS (val) + VALUE_OFFSET (val),
+			       val);
+  } else
+    return val0;
+}
+
+/* Return OFF rounded upward if necessary to a multiple of
+   ALIGNMENT (a power of 2). */
+
+static unsigned int
+align_value (off, alignment)
+     unsigned int off;
+     unsigned int alignment;
+{
+  return (off + alignment - 1) & ~(alignment - 1);
+}
+
+/* Return the additional bit offset required by field F of template
+   type TYPE. */
+
+static unsigned int
+field_offset (type, f)
+     struct type *type;
+     int f;
+{
+  int n = TYPE_FIELD_BITPOS (type, f);
+  /* Kludge (temporary?) to fix problem with dwarf output. */
+  if (n < 0)
+    return (unsigned int) n & 0xffff;
+  else
+    return n;
+}
+
+
+/* Return the bit alignment required for field #F of template type TYPE. */
+
+static unsigned int
+field_alignment (type, f)
+     struct type *type;
+     int f;
+{
+  const char* name = TYPE_FIELD_NAME (type, f);
+  int len = (name == NULL) ? 0 : strlen (name);
+  int align_offset;
+
+  if (len < 8 || ! isdigit (name[len-1]))
+    return TARGET_CHAR_BIT;
+
+  if (isdigit (name[len-2]))
+    align_offset = len - 2;
+  else
+    align_offset = len - 1;
+
+  if (align_offset < 7 || ! STREQN ("___XV", name+align_offset-6, 5))
+    return TARGET_CHAR_BIT;
+
+  return atoi (name+align_offset) * TARGET_CHAR_BIT;
+}
+
+/* Find a type named NAME.  Ignores ambiguity.  */
+struct type*
+ada_find_any_type (name)
+     const char *name;
+{
+  struct symbol* sym;
+
+  sym = standard_lookup (name, VAR_NAMESPACE);
+  if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+    return SYMBOL_TYPE (sym);
+
+  sym = standard_lookup (name, STRUCT_NAMESPACE);
+  if (sym != NULL)
+    return SYMBOL_TYPE (sym);
+
+  return NULL;
+}
+
+/* Because of GNAT encoding conventions, several GDB symbols may match a
+   given type name. If the type denoted by TYPE0 is to be preferred to
+   that of TYPE1 for purposes of type printing, return non-zero;
+   otherwise return 0. */
+int
+ada_prefer_type (type0, type1)
+     struct type* type0;
+     struct type* type1;
+{
+  if (type1 == NULL)
+    return 1;
+  else if (type0 == NULL)
+    return 0;
+  else if (TYPE_CODE (type1) == TYPE_CODE_VOID)
+    return 1;
+  else if (TYPE_CODE (type0) == TYPE_CODE_VOID)
+    return 0;
+  else if (ada_is_packed_array_type (type0))
+    return 1;
+  else if (ada_is_array_descriptor (type0) && ! ada_is_array_descriptor (type1))
+    return 1;
+  else if (ada_renaming_type (type0) != NULL 
+	   && ada_renaming_type (type1) == NULL)
+    return 1;
+  return 0;
+}
+
+/* The name of TYPE, which is either its TYPE_NAME, or, if that is
+   null, its TYPE_TAG_NAME.  Null if TYPE is null. */
+char*
+ada_type_name (type)
+     struct type* type;
+{
+  if (type == NULL) 
+    return NULL;
+  else if (TYPE_NAME (type) != NULL)
+    return TYPE_NAME (type);
+  else
+    return TYPE_TAG_NAME (type);
+}
+
+/* Find a parallel type to TYPE whose name is formed by appending
+   SUFFIX to the name of TYPE. */
+
+struct type*
+ada_find_parallel_type (type, suffix)
+     struct type *type;
+     const char *suffix;
+{
+  static char* name;
+  static size_t name_len = 0;
+  struct symbol** syms;
+  struct block** blocks;
+  int nsyms;
+  int len;
+  char* typename = ada_type_name (type);
+  
+  if (typename == NULL)
+    return NULL;
+
+  len = strlen (typename);
+
+  GROW_VECT (name, name_len, len+strlen (suffix)+1);
+
+  strcpy (name, typename);
+  strcpy (name + len, suffix);
+
+  return ada_find_any_type (name);
+}
+
+
+/* If TYPE is a variable-size record type, return the corresponding template
+   type describing its fields.  Otherwise, return NULL. */
+
+static struct type*
+dynamic_template_type (type)
+     struct type* type;
+{
+  CHECK_TYPEDEF (type);
+
+  if (type == NULL || TYPE_CODE (type) != TYPE_CODE_STRUCT
+      || ada_type_name (type) == NULL) 
+    return NULL;
+  else 
+    {
+      int len = strlen (ada_type_name (type));
+      if (len > 6 && STREQ (ada_type_name (type) + len - 6, "___XVE"))
+	return type;
+      else
+	return ada_find_parallel_type (type, "___XVE");
+    }
+}
+
+/* Assuming that TEMPL_TYPE is a union or struct type, returns
+   non-zero iff field FIELD_NUM of TEMPL_TYPE has dynamic size. */
+
+static int 
+is_dynamic_field (templ_type, field_num)
+     struct type* templ_type;
+     int field_num;
+{
+  const char *name = TYPE_FIELD_NAME (templ_type, field_num);
+  return name != NULL 
+    && TYPE_CODE (TYPE_FIELD_TYPE (templ_type, field_num)) == TYPE_CODE_PTR
+    && strstr (name, "___XVL") != NULL;
+}
+
+/* Assuming that TYPE is a struct type, returns non-zero iff TYPE
+   contains a variant part. */
+
+static int 
+contains_variant_part (type)
+     struct type* type;
+{
+  int f;
+
+  if (type == NULL || TYPE_CODE (type) != TYPE_CODE_STRUCT
+      || TYPE_NFIELDS (type) <= 0)
+    return 0;
+  return ada_is_variant_part (type, TYPE_NFIELDS (type) - 1);
+}
+
+/* A record type with no fields, . */
+static struct type*
+empty_record (objfile) 
+     struct objfile* objfile;
+{
+  struct type* type = alloc_type (objfile);
+  TYPE_CODE (type) = TYPE_CODE_STRUCT;
+  TYPE_NFIELDS (type) = 0;
+  TYPE_FIELDS (type) = NULL;
+  TYPE_NAME (type) = "<empty>";
+  TYPE_TAG_NAME (type) = NULL;
+  TYPE_FLAGS (type) = 0;
+  TYPE_LENGTH (type) = 0;
+  return type;
+}
+
+/* An ordinary record type (with fixed-length fields) that describes
+   the value of type TYPE at VALADDR or ADDRESS (see comments at 
+   the beginning of this section) VAL according to GNAT conventions.  
+   DVAL0 should describe the (portion of a) record that contains any 
+   necessary discriminants.  It should be NULL if VALUE_TYPE (VAL) is
+   an outer-level type (i.e., as opposed to a branch of a variant.)  A
+   variant field (unless unchecked) is replaced by a particular branch
+   of the variant. */
+/* NOTE: Limitations: For now, we assume that dynamic fields and
+ * variants occupy whole numbers of bytes.  However, they need not be
+ * byte-aligned.  */
+
+static struct type*
+template_to_fixed_record_type (type, valaddr, address, dval0)
+     struct type* type;
+     char* valaddr;
+     CORE_ADDR address;
+     struct value* dval0;
+
+{
+  struct value* mark = value_mark();
+  struct value* dval;
+  struct type* rtype;
+  int nfields, bit_len;
+  long off;
+  int f;
+
+  nfields = TYPE_NFIELDS (type);
+  rtype = alloc_type (TYPE_OBJFILE (type));
+  TYPE_CODE (rtype) = TYPE_CODE_STRUCT;
+  INIT_CPLUS_SPECIFIC (rtype);
+  TYPE_NFIELDS (rtype) = nfields;
+  TYPE_FIELDS (rtype) = (struct field*) 
+    TYPE_ALLOC (rtype, nfields * sizeof (struct field));
+  memset (TYPE_FIELDS (rtype), 0, sizeof (struct field) * nfields);
+  TYPE_NAME (rtype) = ada_type_name (type);
+  TYPE_TAG_NAME (rtype) = NULL;
+  /* FIXME: TYPE_FLAG_FIXED_INSTANCE should be defined in
+     gdbtypes.h */  
+  /*  TYPE_FLAGS (rtype) |= TYPE_FLAG_FIXED_INSTANCE;*/
+
+  off = 0; bit_len = 0;
+  for (f = 0; f < nfields; f += 1)
+    {
+      int fld_bit_len, bit_incr;
+      off = 
+	align_value (off, field_alignment (type, f))+TYPE_FIELD_BITPOS (type,f);
+      /* NOTE: used to use field_offset above, but that causes
+       * problems with really negative bit positions.  So, let's
+       * rediscover why we needed field_offset and fix it properly. */
+      TYPE_FIELD_BITPOS (rtype, f) = off;
+      TYPE_FIELD_BITSIZE (rtype, f) = 0;  
+
+      if (ada_is_variant_part (type, f)) 
+	{
+	  struct type *branch_type;
+
+	  if (dval0 == NULL)
+	    dval = 
+	      value_from_contents_and_address (rtype, valaddr, address);
+	  else
+	    dval = dval0;
+
+	  branch_type = 
+	    to_fixed_variant_branch_type 
+	      (TYPE_FIELD_TYPE (type, f),
+	       cond_offset_host (valaddr, off / TARGET_CHAR_BIT),
+	       cond_offset_target (address, off / TARGET_CHAR_BIT),
+	       dval);
+	  if (branch_type == NULL) 
+	    TYPE_NFIELDS (rtype) -= 1;
+	  else
+	    {
+	      TYPE_FIELD_TYPE (rtype, f) = branch_type;
+	      TYPE_FIELD_NAME (rtype, f) = "S";
+	    }
+	  bit_incr = 0;
+	  fld_bit_len =
+	    TYPE_LENGTH (TYPE_FIELD_TYPE (rtype, f)) * TARGET_CHAR_BIT;
+	}
+      else if (is_dynamic_field (type, f))
+	{
+	  if (dval0 == NULL)
+	    dval = 
+	      value_from_contents_and_address (rtype, valaddr, address);
+	  else
+	    dval = dval0;
+
+	  TYPE_FIELD_TYPE (rtype, f) = 
+	    ada_to_fixed_type 
+	      (ada_get_base_type 
+	       (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, f))),
+	       cond_offset_host (valaddr, off / TARGET_CHAR_BIT),
+	       cond_offset_target (address, off / TARGET_CHAR_BIT),
+	       dval);
+	  TYPE_FIELD_NAME (rtype, f) = TYPE_FIELD_NAME (type, f);
+	  bit_incr = fld_bit_len =
+	    TYPE_LENGTH (TYPE_FIELD_TYPE (rtype, f)) * TARGET_CHAR_BIT;
+	}
+      else
+	{
+	  TYPE_FIELD_TYPE (rtype, f) = TYPE_FIELD_TYPE (type, f);
+	  TYPE_FIELD_NAME (rtype, f) = TYPE_FIELD_NAME (type, f);
+	  if (TYPE_FIELD_BITSIZE (type, f) > 0)
+	    bit_incr = fld_bit_len = 
+	      TYPE_FIELD_BITSIZE (rtype, f) = TYPE_FIELD_BITSIZE (type, f);
+	  else
+	    bit_incr = fld_bit_len =
+	      TYPE_LENGTH (TYPE_FIELD_TYPE (type, f)) * TARGET_CHAR_BIT;
+	}
+      if (off + fld_bit_len > bit_len)
+	bit_len = off + fld_bit_len;
+      off += bit_incr;
+      TYPE_LENGTH (rtype) = bit_len / TARGET_CHAR_BIT;
+    }
+  TYPE_LENGTH (rtype) = align_value (TYPE_LENGTH (rtype), TYPE_LENGTH (type));
+
+  value_free_to_mark (mark);
+  if (TYPE_LENGTH (rtype) > varsize_limit) 
+    error ("record type with dynamic size is larger than varsize-limit");
+  return rtype;
+}
+
+/* As for template_to_fixed_record_type, but uses no run-time values.
+   As a result, this type can only be approximate, but that's OK,
+   since it is used only for type determinations.   Works on both
+   structs and unions.
+   Representation note: to save space, we memoize the result of this
+   function in the TYPE_TARGET_TYPE of the template type. */
+
+static struct type*
+template_to_static_fixed_type (templ_type)
+     struct type* templ_type;
+{
+  struct type *type;
+  int nfields;
+  int f;
+
+  if (TYPE_TARGET_TYPE (templ_type) != NULL)
+    return TYPE_TARGET_TYPE (templ_type);
+
+  nfields = TYPE_NFIELDS (templ_type);
+  TYPE_TARGET_TYPE (templ_type) = type = alloc_type (TYPE_OBJFILE (templ_type));
+  TYPE_CODE (type) = TYPE_CODE (templ_type);
+  INIT_CPLUS_SPECIFIC (type);
+  TYPE_NFIELDS (type) = nfields;
+  TYPE_FIELDS (type) = (struct field*) 
+    TYPE_ALLOC (type, nfields * sizeof (struct field));
+  memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
+  TYPE_NAME (type) = ada_type_name (templ_type);
+  TYPE_TAG_NAME (type) = NULL;
+  /* FIXME:  TYPE_FLAG_FIXED_INSTANCE should be defined in gdbtypes.h */  
+  /*  TYPE_FLAGS (type) |= TYPE_FLAG_FIXED_INSTANCE; */
+  TYPE_LENGTH (type) = 0;
+
+  for (f = 0; f < nfields; f += 1)
+    {
+      TYPE_FIELD_BITPOS (type, f) = 0;
+      TYPE_FIELD_BITSIZE (type, f) = 0;  
+
+      if (is_dynamic_field (templ_type, f))
+	{
+	  TYPE_FIELD_TYPE (type, f) = 
+	    to_static_fixed_type (TYPE_TARGET_TYPE 
+				  (TYPE_FIELD_TYPE (templ_type, f)));
+	  TYPE_FIELD_NAME (type, f) = TYPE_FIELD_NAME (templ_type, f);
+	}
+      else
+	{
+	  TYPE_FIELD_TYPE (type, f) = 
+	    check_typedef (TYPE_FIELD_TYPE (templ_type, f));
+	  TYPE_FIELD_NAME (type, f) = TYPE_FIELD_NAME (templ_type, f);
+	}
+    }
+
+  return type;
+}
+
+/* A revision of TYPE0 -- a non-dynamic-sized record with a variant
+   part -- in which the variant part is replaced with the appropriate
+   branch. */
+static struct type*
+to_record_with_fixed_variant_part (type, valaddr, address, dval)
+     struct type* type;
+     char* valaddr;
+     CORE_ADDR address;
+     struct value* dval;
+{
+  struct value* mark = value_mark();
+  struct type* rtype;
+  struct type *branch_type;
+  int nfields = TYPE_NFIELDS (type);
+
+  if (dval == NULL)
+    return type;
+
+  rtype = alloc_type (TYPE_OBJFILE (type));
+  TYPE_CODE (rtype) = TYPE_CODE_STRUCT;
+  INIT_CPLUS_SPECIFIC (type);
+  TYPE_NFIELDS (rtype) = TYPE_NFIELDS (type);
+  TYPE_FIELDS (rtype) = 
+    (struct field*) TYPE_ALLOC (rtype, nfields * sizeof (struct field));
+  memcpy (TYPE_FIELDS (rtype), TYPE_FIELDS (type), 
+	  sizeof (struct field) * nfields);
+  TYPE_NAME (rtype) = ada_type_name (type);
+  TYPE_TAG_NAME (rtype) = NULL;
+  /* FIXME:  TYPE_FLAG_FIXED_INSTANCE should be defined in gdbtypes.h */  
+  /*  TYPE_FLAGS (rtype) |= TYPE_FLAG_FIXED_INSTANCE; */
+  TYPE_LENGTH (rtype) = TYPE_LENGTH (type);
+
+  branch_type = 
+    to_fixed_variant_branch_type 
+      (TYPE_FIELD_TYPE (type, nfields - 1),
+       cond_offset_host (valaddr, 
+			 TYPE_FIELD_BITPOS (type, nfields-1) / TARGET_CHAR_BIT),
+       cond_offset_target (address, 
+			 TYPE_FIELD_BITPOS (type, nfields-1) / TARGET_CHAR_BIT),
+       dval);
+  if (branch_type == NULL) 
+    {
+      TYPE_NFIELDS (rtype) -= 1;
+      TYPE_LENGTH (rtype) -= TYPE_LENGTH (TYPE_FIELD_TYPE (type, nfields - 1));
+    }
+  else
+    {
+      TYPE_FIELD_TYPE (rtype, nfields-1) = branch_type;
+      TYPE_FIELD_NAME (rtype, nfields-1) = "S";
+      TYPE_FIELD_BITSIZE (rtype, nfields-1) = 0;
+      TYPE_LENGTH (rtype) += TYPE_LENGTH (branch_type);
+	- TYPE_LENGTH (TYPE_FIELD_TYPE (type, nfields - 1));
+    }
+  
+  return rtype;
+}
+
+/* An ordinary record type (with fixed-length fields) that describes
+   the value at (TYPE0, VALADDR, ADDRESS) [see explanation at
+   beginning of this section].   Any necessary discriminants' values
+   should be in DVAL, a record value; it should be NULL if the object
+   at ADDR itself contains any necessary  discriminant values.  A
+   variant field (unless unchecked) is replaced by a particular branch
+   of the variant. */ 
+
+static struct type*
+to_fixed_record_type (type0, valaddr, address, dval)
+     struct type* type0;
+     char* valaddr;
+     CORE_ADDR address;
+     struct value* dval;
+{
+  struct type* templ_type;
+
+  /* FIXME:  TYPE_FLAG_FIXED_INSTANCE should be defined in gdbtypes.h */
+  /*  if (TYPE_FLAGS (type0) & TYPE_FLAG_FIXED_INSTANCE)
+    return type0;
+  */
+  templ_type = dynamic_template_type (type0);  
+
+  if (templ_type != NULL)
+    return template_to_fixed_record_type (templ_type, valaddr, address, dval);
+  else if (contains_variant_part (type0))
+    return to_record_with_fixed_variant_part (type0, valaddr, address, dval);
+  else
+    {
+      /* FIXME:  TYPE_FLAG_FIXED_INSTANCE should be defined in gdbtypes.h */      
+      /*      TYPE_FLAGS (type0) |= TYPE_FLAG_FIXED_INSTANCE; */
+      return type0;
+    }
+
+}
+
+/* An ordinary record type (with fixed-length fields) that describes
+   the value at (VAR_TYPE0, VALADDR, ADDRESS), where VAR_TYPE0 is a
+   union type.  Any necessary discriminants' values should be in DVAL,
+   a record value.  That is, this routine selects the appropriate
+   branch of the union at ADDR according to the discriminant value
+   indicated in the union's type name. */
+
+static struct type*
+to_fixed_variant_branch_type (var_type0, valaddr, address, dval)
+     struct type* var_type0;
+     char* valaddr;
+     CORE_ADDR address;
+     struct value* dval;
+{
+  int which;
+  struct type* templ_type;
+  struct type* var_type;
+
+  if (TYPE_CODE (var_type0) == TYPE_CODE_PTR)
+    var_type = TYPE_TARGET_TYPE (var_type0);
+  else 
+    var_type = var_type0;
+
+  templ_type = ada_find_parallel_type (var_type, "___XVU");
+
+  if (templ_type != NULL)
+    var_type = templ_type;
+
+  which = 
+    ada_which_variant_applies (var_type, 
+			       VALUE_TYPE (dval), VALUE_CONTENTS (dval));
+
+  if (which < 0)
+    return empty_record (TYPE_OBJFILE (var_type));
+  else if (is_dynamic_field (var_type, which))
+    return 
+      to_fixed_record_type 
+         (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (var_type, which)),
+	  valaddr, address, dval);
+  else if (contains_variant_part (TYPE_FIELD_TYPE (var_type, which)))
+    return 
+      to_fixed_record_type 
+         (TYPE_FIELD_TYPE (var_type, which), valaddr, address, dval);
+  else
+    return TYPE_FIELD_TYPE (var_type, which);
+}
+
+/* Assuming that TYPE0 is an array type describing the type of a value
+   at ADDR, and that DVAL describes a record containing any
+   discriminants used in TYPE0, returns a type for the value that
+   contains no dynamic components (that is, no components whose sizes
+   are determined by run-time quantities).  Unless IGNORE_TOO_BIG is
+   true, gives an error message if the resulting type's size is over
+   varsize_limit.
+*/
+
+static struct type*
+to_fixed_array_type (type0, dval, ignore_too_big)
+     struct type* type0;
+     struct value* dval;
+     int ignore_too_big;
+{
+  struct type* index_type_desc;
+  struct type* result;
+
+  /* FIXME:  TYPE_FLAG_FIXED_INSTANCE should be defined in gdbtypes.h */
+  /*  if (ada_is_packed_array_type (type0)  /* revisit? */ /*
+      || (TYPE_FLAGS (type0) & TYPE_FLAG_FIXED_INSTANCE))
+    return type0;*/
+
+  index_type_desc = ada_find_parallel_type (type0, "___XA");
+  if (index_type_desc == NULL)
+    {
+      struct type *elt_type0 = check_typedef (TYPE_TARGET_TYPE (type0));
+      /* NOTE: elt_type---the fixed version of elt_type0---should never
+       * depend on the contents of the array in properly constructed
+       * debugging data. */       
+      struct type *elt_type = 
+	ada_to_fixed_type (elt_type0, 0, 0, dval);
+
+      if (elt_type0 == elt_type)
+	result = type0;
+      else
+	result = create_array_type (alloc_type (TYPE_OBJFILE (type0)), 
+				    elt_type, TYPE_INDEX_TYPE (type0));
+    }
+  else
+    {
+      int i;
+      struct type *elt_type0;
+
+      elt_type0 = type0;
+      for (i = TYPE_NFIELDS (index_type_desc); i > 0; i -= 1)
+	elt_type0 = TYPE_TARGET_TYPE (elt_type0);
+
+      /* NOTE: result---the fixed version of elt_type0---should never
+       * depend on the contents of the array in properly constructed
+       * debugging data. */       
+      result = 
+	ada_to_fixed_type (check_typedef (elt_type0), 0, 0, dval);
+      for (i = TYPE_NFIELDS (index_type_desc) - 1; i >= 0; i -= 1)
+	{
+	  struct type *range_type = 
+	    to_fixed_range_type (TYPE_FIELD_NAME (index_type_desc, i),
+				 dval, TYPE_OBJFILE (type0));
+	  result = create_array_type (alloc_type (TYPE_OBJFILE (type0)),
+				      result, range_type);
+	}
+      if (! ignore_too_big && TYPE_LENGTH (result) > varsize_limit) 
+	error ("array type with dynamic size is larger than varsize-limit");
+    }
+
+/* FIXME:  TYPE_FLAG_FIXED_INSTANCE should be defined in gdbtypes.h */
+/*  TYPE_FLAGS (result) |= TYPE_FLAG_FIXED_INSTANCE; */
+  return result;
+}  
+
+
+/* A standard type (containing no dynamically sized components)
+   corresponding to TYPE for the value (TYPE, VALADDR, ADDRESS)
+   DVAL describes a record containing any discriminants used in TYPE0,
+   and may be NULL if there are none. */
+
+struct type*
+ada_to_fixed_type (type, valaddr, address, dval)
+     struct type* type;
+     char* valaddr;
+     CORE_ADDR address;
+     struct value* dval;
+{
+  CHECK_TYPEDEF (type);
+  switch (TYPE_CODE (type)) {
+  default:
+    return type;
+  case TYPE_CODE_STRUCT:
+    return to_fixed_record_type (type, valaddr, address, NULL);
+  case TYPE_CODE_ARRAY:
+    return to_fixed_array_type (type, dval, 0);
+  case TYPE_CODE_UNION:
+    if (dval == NULL) 
+      return type;
+    else
+      return to_fixed_variant_branch_type (type, valaddr, address, dval);
+  }
+}
+
+/* A standard (static-sized) type corresponding as well as possible to
+   TYPE0, but based on no runtime data. */
+
+static struct type*
+to_static_fixed_type (type0)
+     struct type* type0;
+{
+  struct type* type;
+
+  if (type0 == NULL)
+    return NULL;
+
+  /* FIXME:  TYPE_FLAG_FIXED_INSTANCE should be defined in gdbtypes.h */
+  /*  if (TYPE_FLAGS (type0) & TYPE_FLAG_FIXED_INSTANCE)
+    return type0;
+  */
+  CHECK_TYPEDEF (type0);
+  
+  switch (TYPE_CODE (type0))
+    {
+    default:
+      return type0;
+    case TYPE_CODE_STRUCT:
+      type = dynamic_template_type (type0);
+      if (type != NULL) 
+	return template_to_static_fixed_type (type);
+      return type0;
+    case TYPE_CODE_UNION:
+      type = ada_find_parallel_type (type0, "___XVU");
+      if (type != NULL)
+	return template_to_static_fixed_type (type);
+      return type0;
+    }
+}
+
+/* A static approximation of TYPE with all type wrappers removed. */
+static struct type*
+static_unwrap_type (type)
+     struct type* type;
+{
+  if (ada_is_aligner_type (type))
+    {
+      struct type* type1 = TYPE_FIELD_TYPE (check_typedef (type), 0);
+      if (ada_type_name (type1) == NULL)
+	TYPE_NAME (type1) = ada_type_name (type);
+
+      return static_unwrap_type (type1);
+    }
+  else 
+    {
+      struct type* raw_real_type = ada_get_base_type (type);
+      if (raw_real_type == type) 
+	return type;
+      else
+	return to_static_fixed_type (raw_real_type);
+    }
+}
+
+/* In some cases, incomplete and private types require
+   cross-references that are not resolved as records (for example, 
+      type Foo;
+      type FooP is access Foo;
+      V: FooP;
+      type Foo is array ...;
+   ). In these cases, since there is no mechanism for producing 
+   cross-references to such types, we instead substitute for FooP a
+   stub enumeration type that is nowhere resolved, and whose tag is
+   the name of the actual type.  Call these types "non-record stubs". */
+
+/* A type equivalent to TYPE that is not a non-record stub, if one
+   exists, otherwise TYPE. */
+struct type*
+ada_completed_type (type)
+     struct type* type;
+{
+  CHECK_TYPEDEF (type);
+  if (type == NULL || TYPE_CODE (type) != TYPE_CODE_ENUM
+      || (TYPE_FLAGS (type) & TYPE_FLAG_STUB) == 0
+      || TYPE_TAG_NAME (type) == NULL)
+    return type;
+  else 
+    {
+      char* name = TYPE_TAG_NAME (type);
+      struct type* type1 = ada_find_any_type (name);
+      return (type1 == NULL) ? type : type1;
+    }
+}
+
+/* A value representing the data at VALADDR/ADDRESS as described by
+   type TYPE0, but with a standard (static-sized) type that correctly
+   describes it.  If VAL0 is not NULL and TYPE0 already is a standard
+   type, then return VAL0 [this feature is simply to avoid redundant
+   creation of struct values]. */ 
+
+struct value*
+ada_to_fixed_value (type0, valaddr, address, val0)
+     struct type* type0;
+     char* valaddr;
+     CORE_ADDR address;
+     struct value* val0;
+{
+  struct type* type = ada_to_fixed_type (type0, valaddr, address, NULL);
+  if (type == type0 && val0 != NULL)
+    return val0;
+  else return value_from_contents_and_address (type, valaddr, address);
+}
+
+/* A value representing VAL, but with a standard (static-sized) type 
+   chosen to approximate the real type of VAL as well as possible, but
+   without consulting any runtime values.  For Ada dynamic-sized
+   types, therefore, the type of the result is likely to be inaccurate. */
+
+struct value*
+ada_to_static_fixed_value (val)
+     struct value* val;
+{
+  struct type *type = 
+    to_static_fixed_type (static_unwrap_type (VALUE_TYPE (val)));
+  if (type == VALUE_TYPE (val))
+    return val;
+  else
+    return coerce_unspec_val_to_type (val, 0, type);
+}
+
+
+
+
+
+/* Attributes */
+
+/* Table mapping attribute numbers to names */
+/* NOTE: Keep up to date with enum ada_attribute definition in ada-lang.h */
+
+static const char* attribute_names[] = {
+  "<?>",
+
+  "first", 
+  "last",
+  "length",
+  "image",
+  "img",
+  "max",
+  "min",
+  "pos"
+  "tag",
+  "val",
+
+  0
+};
+
+const char*
+ada_attribute_name (n)
+     int n;
+{
+  if (n > 0 && n < (int) ATR_END)
+    return attribute_names[n];
+  else
+    return attribute_names[0];
+}
+
+/* Evaluate the 'POS attribute applied to ARG. */
+
+static struct value*
+value_pos_atr (arg)
+     struct value* arg;
+{
+  struct type *type = VALUE_TYPE (arg);
+
+  if (! discrete_type_p (type))
+    error ("'POS only defined on discrete types");
+
+  if (TYPE_CODE (type) == TYPE_CODE_ENUM)
+    {
+      int i;
+      LONGEST v = value_as_long (arg);
+
+      for (i = 0; i < TYPE_NFIELDS (type); i += 1) 
+	{
+	  if (v == TYPE_FIELD_BITPOS (type, i))
+	    return value_from_longest (builtin_type_ada_int, i);
+	}
+      error ("enumeration value is invalid: can't find 'POS");
+    }
+  else
+    return value_from_longest (builtin_type_ada_int, value_as_long (arg));
+}
+
+/* Evaluate the TYPE'VAL attribute applied to ARG. */
+
+static struct value*
+value_val_atr (type, arg)
+     struct type *type;
+     struct value* arg;
+{
+  if (! discrete_type_p (type))
+    error ("'VAL only defined on discrete types");
+  if (! integer_type_p (VALUE_TYPE (arg)))
+    error ("'VAL requires integral argument");
+
+  if (TYPE_CODE (type) == TYPE_CODE_ENUM)
+    {
+      long pos = value_as_long (arg);
+      if (pos < 0 || pos >= TYPE_NFIELDS (type))
+	error ("argument to 'VAL out of range");
+      return 
+	value_from_longest (type, TYPE_FIELD_BITPOS (type, pos));
+    }
+  else
+    return value_from_longest (type, value_as_long (arg));
+}
+
+
+				/* Evaluation */
+
+/* True if TYPE appears to be an Ada character type.  
+ * [At the moment, this is true only for Character and Wide_Character;
+ * It is a heuristic test that could stand improvement]. */
+
+int 
+ada_is_character_type (type)
+     struct type* type;
+{
+  const char* name = ada_type_name (type);
+  return 
+    name != NULL
+    && (TYPE_CODE (type) == TYPE_CODE_CHAR 
+	|| TYPE_CODE (type) == TYPE_CODE_INT
+	|| TYPE_CODE (type) == TYPE_CODE_RANGE)
+    && (STREQ (name, "character") || STREQ (name, "wide_character")
+	|| STREQ (name, "unsigned char"));
+}
+
+/* True if TYPE appears to be an Ada string type. */
+
+int
+ada_is_string_type (type)
+     struct type *type;
+{
+  CHECK_TYPEDEF (type);
+  if (type != NULL 
+      && TYPE_CODE (type) != TYPE_CODE_PTR
+      && (ada_is_simple_array (type) || ada_is_array_descriptor (type))
+      && ada_array_arity (type) == 1)
+    {
+      struct type *elttype = ada_array_element_type (type, 1);
+
+      return ada_is_character_type (elttype);
+    }
+  else 
+    return 0;
+}
+
+
+/* True if TYPE is a struct type introduced by the compiler to force the
+   alignment of a value.  Such types have a single field with a
+   distinctive name. */
+
+int
+ada_is_aligner_type (type)
+     struct type *type;
+{
+  CHECK_TYPEDEF (type);
+  return (TYPE_CODE (type) == TYPE_CODE_STRUCT
+	  && TYPE_NFIELDS (type) == 1
+	  && STREQ (TYPE_FIELD_NAME (type, 0), "F"));
+}
+
+/* If there is an ___XVS-convention type parallel to SUBTYPE, return
+   the parallel type. */
+
+struct type*
+ada_get_base_type (raw_type)
+     struct type* raw_type;
+{
+  struct type* real_type_namer;
+  struct type* raw_real_type;
+  struct type* real_type;
+
+  if (raw_type == NULL || TYPE_CODE (raw_type) != TYPE_CODE_STRUCT)
+    return raw_type;
+
+  real_type_namer = ada_find_parallel_type (raw_type, "___XVS");
+  if (real_type_namer == NULL 
+      || TYPE_CODE (real_type_namer) != TYPE_CODE_STRUCT
+      || TYPE_NFIELDS (real_type_namer) != 1)
+    return raw_type;
+
+  raw_real_type = ada_find_any_type (TYPE_FIELD_NAME (real_type_namer, 0));
+  if (raw_real_type == NULL) 
+    return raw_type;
+  else
+    return raw_real_type;
+}  
+
+/* The type of value designated by TYPE, with all aligners removed. */
+
+struct type*
+ada_aligned_type (type)
+     struct type* type;
+{
+  if (ada_is_aligner_type (type))
+    return ada_aligned_type (TYPE_FIELD_TYPE (type, 0));
+  else
+    return ada_get_base_type (type);
+}
+
+
+/* The address of the aligned value in an object at address VALADDR
+   having type TYPE.  Assumes ada_is_aligner_type (TYPE). */
+
+char*
+ada_aligned_value_addr (type, valaddr)
+     struct type *type;
+     char *valaddr;
+{
+  if (ada_is_aligner_type (type)) 
+    return ada_aligned_value_addr (TYPE_FIELD_TYPE (type, 0),
+				   valaddr + 
+				   TYPE_FIELD_BITPOS (type, 0)/TARGET_CHAR_BIT);
+  else
+    return valaddr;
+}
+
+/* The printed representation of an enumeration literal with encoded
+   name NAME. The value is good to the next call of ada_enum_name. */
+const char*
+ada_enum_name (name)
+     const char* name;
+{
+  char* tmp;
+
+  while (1) 
+    {
+      if ((tmp = strstr (name, "__")) != NULL)
+	name = tmp+2;
+      else if ((tmp = strchr (name, '.')) != NULL)
+	name = tmp+1;
+      else
+	break;
+    }
+
+  if (name[0] == 'Q')
+    {
+      static char result[16];
+      int v;
+      if (name[1] == 'U' || name[1] == 'W')
+	{
+	  if (sscanf (name+2, "%x", &v) != 1) 
+	    return name;
+	}
+      else
+	return name;
+
+      if (isascii (v) && isprint (v))
+	sprintf (result, "'%c'", v);
+      else if (name[1] == 'U')
+	sprintf (result, "[\"%02x\"]", v);
+      else
+	sprintf (result, "[\"%04x\"]", v);
+
+      return result;
+    }
+  else 
+    return name;
+}
+
+static struct value*
+evaluate_subexp (expect_type, exp, pos, noside)
+     struct type *expect_type;
+     struct expression *exp;
+     int *pos;
+     enum noside noside;
+{
+  return (*exp->language_defn->evaluate_exp) (expect_type, exp, pos, noside);
+}
+
+/* Evaluate the subexpression of EXP starting at *POS as for
+   evaluate_type, updating *POS to point just past the evaluated
+   expression. */
+
+static struct value*
+evaluate_subexp_type (exp, pos)
+     struct expression* exp;
+     int* pos;
+{
+  return (*exp->language_defn->evaluate_exp) 
+    (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+}
+
+/* If VAL is wrapped in an aligner or subtype wrapper, return the
+   value it wraps. */ 
+
+static struct value*
+unwrap_value (val)
+     struct value* val;
+{
+  struct type* type = check_typedef (VALUE_TYPE (val));
+  if (ada_is_aligner_type (type))
+    {
+      struct value* v = value_struct_elt (&val, NULL, "F", 
+				      NULL, "internal structure");
+      struct type* val_type = check_typedef (VALUE_TYPE (v));
+      if (ada_type_name (val_type) == NULL)
+	TYPE_NAME (val_type) = ada_type_name (type);
+
+      return unwrap_value (v);
+    }
+  else 
+    {
+      struct type* raw_real_type = 
+	ada_completed_type (ada_get_base_type (type));
+      
+      if (type == raw_real_type)
+	return val;
+
+      return 
+	coerce_unspec_val_to_type 
+	(val, 0, ada_to_fixed_type (raw_real_type, 0,
+				    VALUE_ADDRESS (val) + VALUE_OFFSET (val),
+				    NULL));
+    }
+}
+    
+static struct value*
+cast_to_fixed (type, arg)
+     struct type *type;
+     struct value* arg;
+{
+  LONGEST val;
+
+  if (type == VALUE_TYPE (arg))
+    return arg;
+  else if (ada_is_fixed_point_type (VALUE_TYPE (arg)))
+    val = ada_float_to_fixed (type, 
+			      ada_fixed_to_float (VALUE_TYPE (arg),
+						  value_as_long (arg)));
+  else 
+    {
+      DOUBLEST argd = 
+	value_as_double (value_cast (builtin_type_double, value_copy (arg)));
+      val = ada_float_to_fixed (type, argd);
+    }
+
+  return value_from_longest (type, val);
+}
+
+static struct value*
+cast_from_fixed_to_double (arg)
+     struct value* arg;
+{
+  DOUBLEST val = ada_fixed_to_float (VALUE_TYPE (arg),
+				     value_as_long (arg));
+  return value_from_double (builtin_type_double, val);
+}
+
+/* Coerce VAL as necessary for assignment to an lval of type TYPE, and 
+ * return the converted value. */
+static struct value*
+coerce_for_assign (type, val)
+     struct type* type;
+     struct value* val;
+{
+  struct type* type2 = VALUE_TYPE (val);
+  if (type == type2)
+    return val;
+
+  CHECK_TYPEDEF (type2);
+  CHECK_TYPEDEF (type);
+
+  if (TYPE_CODE (type2) == TYPE_CODE_PTR && TYPE_CODE (type) == TYPE_CODE_ARRAY)
+    {
+      val = ada_value_ind (val);
+      type2 = VALUE_TYPE (val);
+    }
+
+  if (TYPE_CODE (type2) == TYPE_CODE_ARRAY 
+      && TYPE_CODE (type) == TYPE_CODE_ARRAY)
+    {
+      if (TYPE_LENGTH (type2) != TYPE_LENGTH (type)
+	  || TYPE_LENGTH (TYPE_TARGET_TYPE (type2))
+	     != TYPE_LENGTH (TYPE_TARGET_TYPE (type2)))
+	error ("Incompatible types in assignment");
+      VALUE_TYPE (val) = type;
+    }
+  return val;  
+}
+
+struct value*
+ada_evaluate_subexp (expect_type, exp, pos, noside)
+     struct type *expect_type;
+     struct expression *exp;
+     int *pos;
+     enum noside noside;
+{
+  enum exp_opcode op;
+  enum ada_attribute atr;
+  int tem, tem2, tem3;
+  int pc;
+  struct value *arg1 = NULL, *arg2 = NULL, *arg3;
+  struct type *type;
+  int nargs;
+  struct value* *argvec;
+
+  pc = *pos; *pos += 1;
+  op = exp->elts[pc].opcode;
+
+  switch (op) 
+    {
+    default:
+      *pos -= 1;
+      return unwrap_value (evaluate_subexp_standard (expect_type, exp, pos, noside));
+
+    case UNOP_CAST:
+      (*pos) += 2;
+      type = exp->elts[pc + 1].type;
+      arg1 = evaluate_subexp (type, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (type != check_typedef (VALUE_TYPE (arg1)))
+	{
+	  if (ada_is_fixed_point_type (type))
+	    arg1 = cast_to_fixed (type, arg1);
+	  else if (ada_is_fixed_point_type (VALUE_TYPE (arg1)))
+	    arg1 = value_cast (type, cast_from_fixed_to_double (arg1));
+	  else if (VALUE_LVAL (arg1) == lval_memory) 
+	    {
+	      /* This is in case of the really obscure (and undocumented,
+		 but apparently expected) case of (Foo) Bar.all, where Bar 
+		 is an integer constant and Foo is a dynamic-sized type.
+		 If we don't do this, ARG1 will simply be relabeled with
+		 TYPE. */
+	      if (noside == EVAL_AVOID_SIDE_EFFECTS) 
+		return value_zero (to_static_fixed_type (type), not_lval);
+	      arg1 = 
+		ada_to_fixed_value 
+		  (type, 0, VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1), 0);
+	    }
+	  else		 
+	    arg1 = value_cast (type, arg1);	
+	}
+      return arg1;
+
+      /* FIXME:  UNOP_QUAL should be defined in expression.h */
+      /*    case UNOP_QUAL:
+      (*pos) += 2;
+      type = exp->elts[pc + 1].type;
+      return ada_evaluate_subexp (type, exp, pos, noside);
+      */
+    case BINOP_ASSIGN:
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
+      if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+	return arg1;
+      if (binop_user_defined_p (op, arg1, arg2))
+	return value_x_binop (arg1, arg2, op, OP_NULL, EVAL_NORMAL);
+      else 
+	{
+	  if (ada_is_fixed_point_type (VALUE_TYPE (arg1)))
+	    arg2 = cast_to_fixed (VALUE_TYPE (arg1), arg2);
+	  else if (ada_is_fixed_point_type (VALUE_TYPE (arg2)))
+	    error ("Fixed-point values must be assigned to fixed-point variables");
+	  else 
+	    arg2 = coerce_for_assign (VALUE_TYPE (arg1), arg2);
+	  return ada_value_assign (arg1, arg2);
+	}
+
+    case BINOP_ADD:
+      arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
+      arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (binop_user_defined_p (op, arg1, arg2))
+	return value_x_binop (arg1, arg2, op, OP_NULL, EVAL_NORMAL);
+      else
+	{
+	  if ((ada_is_fixed_point_type (VALUE_TYPE (arg1))
+	       || ada_is_fixed_point_type (VALUE_TYPE (arg2)))
+	      && VALUE_TYPE (arg1) != VALUE_TYPE (arg2))
+	    error ("Operands of fixed-point addition must have the same type");
+	  return value_cast (VALUE_TYPE (arg1), value_add (arg1, arg2));
+	}
+
+    case BINOP_SUB:
+      arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
+      arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (binop_user_defined_p (op, arg1, arg2))
+	return value_x_binop (arg1, arg2, op, OP_NULL, EVAL_NORMAL);
+      else
+	{
+	  if ((ada_is_fixed_point_type (VALUE_TYPE (arg1))
+	       || ada_is_fixed_point_type (VALUE_TYPE (arg2)))
+	      && VALUE_TYPE (arg1) != VALUE_TYPE (arg2))
+	    error ("Operands of fixed-point subtraction must have the same type");		
+	  return value_cast (VALUE_TYPE (arg1), value_sub (arg1, arg2));
+	}
+
+    case BINOP_MUL:
+    case BINOP_DIV:
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (binop_user_defined_p (op, arg1, arg2))
+	return value_x_binop (arg1, arg2, op, OP_NULL, EVAL_NORMAL);
+      else
+	if (noside == EVAL_AVOID_SIDE_EFFECTS
+	    && (op == BINOP_DIV || op == BINOP_REM || op == BINOP_MOD))
+	  return value_zero (VALUE_TYPE (arg1), not_lval);
+      else
+	{
+	  if (ada_is_fixed_point_type (VALUE_TYPE (arg1)))
+	    arg1 = cast_from_fixed_to_double (arg1);
+	  if (ada_is_fixed_point_type (VALUE_TYPE (arg2)))
+	    arg2 = cast_from_fixed_to_double (arg2);
+	  return value_binop (arg1, arg2, op);
+	}
+
+    case UNOP_NEG:
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (unop_user_defined_p (op, arg1))
+	return value_x_unop (arg1, op, EVAL_NORMAL);
+      else if (ada_is_fixed_point_type (VALUE_TYPE (arg1)))
+	return value_cast (VALUE_TYPE (arg1), value_neg (arg1));
+      else
+	return value_neg (arg1);
+
+      /* FIXME:  OP_UNRESOLVED_VALUE should be defined in expression.h */
+      /*    case OP_UNRESOLVED_VALUE:
+      /* Only encountered when an unresolved symbol occurs in a
+         context other than a function call, in which case, it is
+	 illegal. *//*
+      (*pos) += 3;
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      else 
+	error ("Unexpected unresolved symbol, %s, during evaluation",
+	       ada_demangle (exp->elts[pc + 2].name));
+      */
+    case OP_VAR_VALUE:
+      *pos -= 1;
+      if (noside == EVAL_SKIP)
+	{
+	  *pos += 4;
+	  goto nosideret;
+	} 
+      else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	{
+	  *pos += 4;
+	  return value_zero 
+	    (to_static_fixed_type 
+	     (static_unwrap_type (SYMBOL_TYPE (exp->elts[pc+2].symbol))),
+	     not_lval);
+	}
+      else 
+	{
+	  arg1 = unwrap_value (evaluate_subexp_standard (expect_type, exp, pos, 
+							 noside));
+	  return ada_to_fixed_value (VALUE_TYPE (arg1), 0,
+				     VALUE_ADDRESS (arg1) + VALUE_OFFSET(arg1),
+				     arg1);
+	}
+
+    case OP_ARRAY:
+      (*pos) += 3;
+      tem2 = longest_to_int (exp->elts[pc + 1].longconst);
+      tem3 = longest_to_int (exp->elts[pc + 2].longconst);
+      nargs = tem3 - tem2 + 1;
+      type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
+
+      argvec = (struct value* *) alloca (sizeof (struct value*) * (nargs + 1));
+      for (tem = 0; tem == 0 || tem < nargs; tem += 1)
+	/* At least one element gets inserted for the type */
+	{
+	  /* Ensure that array expressions are coerced into pointer objects. */
+	  argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
+	}
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_array (tem2, tem3, argvec);
+
+    case OP_FUNCALL:
+      (*pos) += 2;
+
+      /* Allocate arg vector, including space for the function to be
+	 called in argvec[0] and a terminating NULL */
+      nargs = longest_to_int (exp->elts[pc + 1].longconst);
+      argvec = (struct value* *) alloca (sizeof (struct value*) * (nargs + 2));
+
+      /* FIXME: OP_UNRESOLVED_VALUE should be defined in expression.h */
+      /* FIXME: name should be defined in expresion.h */
+      /*      if (exp->elts[*pos].opcode == OP_UNRESOLVED_VALUE)
+	error ("Unexpected unresolved symbol, %s, during evaluation",
+	       ada_demangle (exp->elts[pc + 5].name));
+      */
+      if (0) 
+	{
+	  error ("unexpected code path, FIXME");
+	}
+      else
+	{
+	  for (tem = 0; tem <= nargs; tem += 1)
+	    argvec[tem] = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+	  argvec[tem] = 0;
+
+	  if (noside == EVAL_SKIP)
+	    goto nosideret;
+	}
+
+      if (TYPE_CODE (VALUE_TYPE (argvec[0])) == TYPE_CODE_REF)
+	argvec[0] = value_addr (argvec[0]);
+
+      if (ada_is_packed_array_type (VALUE_TYPE (argvec[0])))
+	argvec[0] = ada_coerce_to_simple_array (argvec[0]);
+
+      type = check_typedef (VALUE_TYPE (argvec[0]));
+      if (TYPE_CODE (type) == TYPE_CODE_PTR)
+	{	
+	  switch (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (type))))
+	    {
+	    case TYPE_CODE_FUNC:
+	      type = check_typedef (TYPE_TARGET_TYPE (type));
+	      break;
+	    case TYPE_CODE_ARRAY:
+	      break;
+	    case TYPE_CODE_STRUCT:
+	      if (noside != EVAL_AVOID_SIDE_EFFECTS)
+		argvec[0] = ada_value_ind (argvec[0]);
+	      type = check_typedef (TYPE_TARGET_TYPE (type));
+	      break;
+	    default:
+	      error ("cannot subscript or call something of type `%s'",
+		     ada_type_name (VALUE_TYPE (argvec[0])));
+	      break;
+	  }
+	}
+	  
+      switch (TYPE_CODE (type))
+	{
+	case TYPE_CODE_FUNC:
+	  if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	    return allocate_value (TYPE_TARGET_TYPE (type));
+	  return call_function_by_hand (argvec[0], nargs, argvec + 1);
+	case TYPE_CODE_STRUCT: 
+	  {
+	    int arity = ada_array_arity (type);
+	    type = ada_array_element_type (type, nargs);
+	    if (type == NULL) 
+	      error ("cannot subscript or call a record");
+	    if (arity != nargs) 
+	      error ("wrong number of subscripts; expecting %d", arity);
+	    if (noside == EVAL_AVOID_SIDE_EFFECTS) 
+	      return allocate_value (ada_aligned_type (type));
+	    return unwrap_value (ada_value_subscript (argvec[0], nargs, argvec+1));
+	  }
+	case TYPE_CODE_ARRAY:
+	  if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	    {	
+	      type = ada_array_element_type (type, nargs);
+	      if (type == NULL)
+		error ("element type of array unknown");
+	      else
+		return allocate_value (ada_aligned_type (type));
+	    }
+	  return 
+	    unwrap_value (ada_value_subscript
+			  (ada_coerce_to_simple_array (argvec[0]),
+			   nargs, argvec+1));
+	case TYPE_CODE_PTR: /* Pointer to array */
+	  type = to_fixed_array_type (TYPE_TARGET_TYPE (type), NULL, 1);
+	  if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	    {	
+	      type = ada_array_element_type (type, nargs);
+	      if (type == NULL)
+		error ("element type of array unknown");
+	      else
+		return allocate_value (ada_aligned_type (type));
+	    }
+	  return 
+	    unwrap_value (ada_value_ptr_subscript (argvec[0], type, 
+						   nargs, argvec+1));
+
+	default:
+	  error ("Internal error in evaluate_subexp");
+	}
+
+    case TERNOP_SLICE:
+      {
+	struct value* array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+	int lowbound
+	  = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+	int upper
+	  = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+	if (noside == EVAL_SKIP)
+	  goto nosideret;
+        
+        /* If this is a reference to an array, then dereference it */
+        if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_REF
+            && TYPE_TARGET_TYPE (VALUE_TYPE (array)) != NULL
+            && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (array))) ==
+                 TYPE_CODE_ARRAY
+            && !ada_is_array_descriptor (check_typedef (VALUE_TYPE
+               (array))))
+          {
+            array = ada_coerce_ref (array);
+          }
+
+	if (noside == EVAL_AVOID_SIDE_EFFECTS &&
+	    ada_is_array_descriptor (check_typedef (VALUE_TYPE (array))))
+	  {
+	    /* Try to dereference the array, in case it is an access to array */
+	    struct type * arrType = ada_type_of_array (array, 0);
+	    if (arrType != NULL)
+	      array = value_at_lazy (arrType, 0, NULL); 
+	  }
+	if (ada_is_array_descriptor (VALUE_TYPE (array)))
+	  array = ada_coerce_to_simple_array (array);
+
+        /* If at this point we have a pointer to an array, it means that
+           it is a pointer to a simple (non-ada) array. We just then
+           dereference it */
+        if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_PTR
+            && TYPE_TARGET_TYPE (VALUE_TYPE (array)) != NULL
+            && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (array))) ==
+                 TYPE_CODE_ARRAY)
+          {
+              array = ada_value_ind (array);
+          }
+        
+	if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	  /* The following will get the bounds wrong, but only in contexts
+	     where the value is not being requested (FIXME?). */
+	  return array;
+	else
+	  return value_slice (array, lowbound, upper - lowbound + 1);
+      }
+
+      /* FIXME: UNOP_MBR should be defined in expression.h */
+      /*    case UNOP_MBR:
+      (*pos) += 2;
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      type = exp->elts[pc + 1].type;
+
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+
+      switch (TYPE_CODE (type)) 
+	{
+	default:
+	  warning ("Membership test incompletely implemented; always returns true");
+	  return value_from_longest (builtin_type_int, (LONGEST) 1);
+	  
+	case TYPE_CODE_RANGE:
+	  arg2 = value_from_longest (builtin_type_int, 
+				     (LONGEST) TYPE_LOW_BOUND (type));
+	  arg3 = value_from_longest (builtin_type_int, 
+				     (LONGEST) TYPE_HIGH_BOUND (type));
+	  return 
+	    value_from_longest (builtin_type_int,
+				(value_less (arg1,arg3) 
+				 || value_equal (arg1,arg3))
+				&& (value_less (arg2,arg1)
+				    || value_equal (arg2,arg1)));
+	}
+      */
+      /* FIXME: BINOP_MBR should be defined in expression.h */      
+      /*    case BINOP_MBR:
+      (*pos) += 2;
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+
+      if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	return value_zero (builtin_type_int, not_lval);
+
+      tem = longest_to_int (exp->elts[pc + 1].longconst);
+
+      if (tem < 1 || tem > ada_array_arity (VALUE_TYPE (arg2)))
+	error ("invalid dimension number to '%s", "range");
+
+      arg3 = ada_array_bound (arg2, tem, 1);
+      arg2 = ada_array_bound (arg2, tem, 0);
+
+      return 
+	value_from_longest (builtin_type_int,
+			    (value_less (arg1,arg3) 
+			     || value_equal (arg1,arg3))
+			    && (value_less (arg2,arg1)
+				|| value_equal (arg2,arg1)));
+      */
+      /* FIXME: TERNOP_MBR should be defined in expression.h */
+      /*    case TERNOP_MBR:
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      arg3 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+
+      return 
+	value_from_longest (builtin_type_int,
+			    (value_less (arg1,arg3) 
+			     || value_equal (arg1,arg3))
+			    && (value_less (arg2,arg1)
+				|| value_equal (arg2,arg1)));
+      */
+      /* FIXME: OP_ATTRIBUTE should be defined in expression.h */
+      /*    case OP_ATTRIBUTE:
+      *pos += 3;
+      atr = (enum ada_attribute) longest_to_int (exp->elts[pc + 2].longconst);
+      switch (atr) 
+	{
+	default:
+	  error ("unexpected attribute encountered");
+
+	case ATR_FIRST:
+	case ATR_LAST:
+	case ATR_LENGTH:
+	  {
+	    struct type* type_arg;
+	    if (exp->elts[*pos].opcode == OP_TYPE)
+	      {
+		evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+		arg1 = NULL;
+		type_arg = exp->elts[pc + 5].type;
+	      }
+	    else
+	      {
+		arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+		type_arg = NULL;
+	      }
+
+	    if (exp->elts[*pos].opcode != OP_LONG) 
+	      error ("illegal operand to '%s", ada_attribute_name (atr));
+	    tem = longest_to_int (exp->elts[*pos+2].longconst);
+	    *pos += 4;
+
+	    if (noside == EVAL_SKIP)
+	      goto nosideret;
+
+	    if (type_arg == NULL)
+	      {
+		arg1 = ada_coerce_ref (arg1);
+
+		if (ada_is_packed_array_type (VALUE_TYPE (arg1)))
+		  arg1 = ada_coerce_to_simple_array (arg1);
+
+		if (tem < 1 || tem > ada_array_arity (VALUE_TYPE (arg1)))
+		  error ("invalid dimension number to '%s", 
+			 ada_attribute_name (atr));
+
+		if (noside == EVAL_AVOID_SIDE_EFFECTS)
+		  {
+		    type = ada_index_type (VALUE_TYPE (arg1), tem);
+		    if (type == NULL) 
+		      error ("attempt to take bound of something that is not an array");
+		    return allocate_value (type);
+		  }
+
+		switch (atr) 
+		  {
+		  default: 
+		    error ("unexpected attribute encountered");
+		  case ATR_FIRST:
+		    return ada_array_bound (arg1, tem, 0);
+		  case ATR_LAST:
+		    return ada_array_bound (arg1, tem, 1);
+		  case ATR_LENGTH:
+		    return ada_array_length (arg1, tem);
+		  }
+	      }
+	    else if (TYPE_CODE (type_arg) == TYPE_CODE_RANGE
+		     || TYPE_CODE (type_arg) == TYPE_CODE_INT) 
+	      {
+		struct type* range_type;
+		char* name = ada_type_name (type_arg);
+		if (name == NULL)
+		  {
+		    if (TYPE_CODE (type_arg) == TYPE_CODE_RANGE) 
+		      range_type = type_arg;
+		    else
+		      error ("unimplemented type attribute");
+		  }
+		else 
+		  range_type = 
+		    to_fixed_range_type (name, NULL, TYPE_OBJFILE (type_arg));
+		switch (atr) 
+		  {
+		  default: 
+		    error ("unexpected attribute encountered");
+		  case ATR_FIRST:
+		    return value_from_longest (TYPE_TARGET_TYPE (range_type),
+					       TYPE_LOW_BOUND (range_type));
+		  case ATR_LAST:
+		    return value_from_longest (TYPE_TARGET_TYPE (range_type),
+					       TYPE_HIGH_BOUND (range_type));
+		  }
+	      }		
+	    else if (TYPE_CODE (type_arg) == TYPE_CODE_ENUM)
+	      {
+		switch (atr) 
+		  {
+		  default: 
+		    error ("unexpected attribute encountered");
+		  case ATR_FIRST:
+		    return value_from_longest 
+		      (type_arg, TYPE_FIELD_BITPOS (type_arg, 0));
+		  case ATR_LAST:
+		    return value_from_longest 
+		      (type_arg, 
+		       TYPE_FIELD_BITPOS (type_arg,
+					  TYPE_NFIELDS (type_arg) - 1));
+		  }
+	      }
+	    else if (TYPE_CODE (type_arg) == TYPE_CODE_FLT)
+	      error ("unimplemented type attribute");
+	    else 
+	      {
+		LONGEST low, high;
+
+		if (ada_is_packed_array_type (type_arg))
+		  type_arg = decode_packed_array_type (type_arg);
+
+		if (tem < 1 || tem > ada_array_arity (type_arg))
+		  error ("invalid dimension number to '%s", 
+			 ada_attribute_name (atr));
+
+		if (noside == EVAL_AVOID_SIDE_EFFECTS)
+		  {
+		    type = ada_index_type (type_arg, tem);
+		    if (type == NULL) 
+		      error ("attempt to take bound of something that is not an array");
+		    return allocate_value (type);
+		  }
+
+		switch (atr) 
+		  {
+		  default: 
+		    error ("unexpected attribute encountered");
+		  case ATR_FIRST:
+		    low = ada_array_bound_from_type (type_arg, tem, 0, &type);
+		    return value_from_longest (type, low);
+		  case ATR_LAST:
+		    high = ada_array_bound_from_type (type_arg, tem, 1, &type);
+		    return value_from_longest (type, high);
+		  case ATR_LENGTH:
+		    low = ada_array_bound_from_type (type_arg, tem, 0, &type);
+		    high = ada_array_bound_from_type (type_arg, tem, 1, NULL);
+		    return value_from_longest (type, high-low+1);
+		  }
+	      }
+	  }
+
+	case ATR_TAG:
+	  arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+	  if (noside == EVAL_SKIP)
+	    goto nosideret;
+
+	  if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	    return 	
+	      value_zero (ada_tag_type (arg1), not_lval);
+	  
+	  return ada_value_tag (arg1);
+	  
+	case ATR_MIN:
+	case ATR_MAX:
+	  evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+	  arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+	  arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+	  if (noside == EVAL_SKIP)
+	    goto nosideret;
+	  else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	    return value_zero (VALUE_TYPE (arg1), not_lval);
+	  else
+	    return value_binop (arg1, arg2, 
+				atr == ATR_MIN ? BINOP_MIN : BINOP_MAX);
+
+	case ATR_MODULUS:
+	  {
+	    struct type* type_arg = exp->elts[pc + 5].type;
+	    evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+	    *pos += 4;
+
+	    if (noside == EVAL_SKIP)
+	      goto nosideret;
+
+	    if (! ada_is_modular_type (type_arg))
+	      error ("'modulus must be applied to modular type");
+
+	    return value_from_longest (TYPE_TARGET_TYPE (type_arg),
+				       ada_modulus (type_arg));
+	  }
+	  
+
+	case ATR_POS:
+	  evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+	  arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+	  if (noside == EVAL_SKIP)
+	    goto nosideret;
+	  else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	    return value_zero (builtin_type_ada_int, not_lval);
+	  else 
+	    return value_pos_atr (arg1);
+
+	case ATR_SIZE:
+	  arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+	  if (noside == EVAL_SKIP)
+	    goto nosideret;
+	  else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	    return value_zero (builtin_type_ada_int, not_lval);
+	  else
+	    return value_from_longest (builtin_type_ada_int,
+				       TARGET_CHAR_BIT 
+				       * TYPE_LENGTH (VALUE_TYPE (arg1)));
+
+	case ATR_VAL:
+	  evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+	  arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+	  type = exp->elts[pc + 5].type;
+	  if (noside == EVAL_SKIP)
+	    goto nosideret;
+	  else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	    return value_zero (type, not_lval);
+	  else 
+	    return value_val_atr (type, arg1);
+	    }*/
+    case BINOP_EXP:
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (binop_user_defined_p (op, arg1, arg2))
+	return unwrap_value (value_x_binop (arg1, arg2, op, OP_NULL,
+	  EVAL_NORMAL));
+      else
+	if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	  return value_zero (VALUE_TYPE (arg1), not_lval);
+      else
+	return value_binop (arg1, arg2, op);
+
+    case UNOP_PLUS:
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (unop_user_defined_p (op, arg1))
+	return unwrap_value (value_x_unop (arg1, op, EVAL_NORMAL));
+      else
+	return arg1;
+
+    case UNOP_ABS:
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (value_less (arg1, value_zero (VALUE_TYPE (arg1), not_lval)))
+	return value_neg (arg1);
+      else
+	return arg1;
+
+    case UNOP_IND:
+      if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
+        expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
+      arg1 = evaluate_subexp (expect_type, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      type = check_typedef (VALUE_TYPE (arg1));
+      if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	{
+	  if (ada_is_array_descriptor (type))
+	    /* GDB allows dereferencing GNAT array descriptors. */
+	    {
+	      struct type* arrType = ada_type_of_array (arg1, 0); 
+	      if (arrType == NULL)
+		error ("Attempt to dereference null array pointer.");
+	      return value_at_lazy (arrType, 0, NULL);
+	    }
+	  else if (TYPE_CODE (type) == TYPE_CODE_PTR
+	      || TYPE_CODE (type) == TYPE_CODE_REF
+	      /* In C you can dereference an array to get the 1st elt.  */
+	      || TYPE_CODE (type) == TYPE_CODE_ARRAY
+	      )
+	    return 
+	      value_zero 
+	        (to_static_fixed_type 
+		  (ada_aligned_type (check_typedef (TYPE_TARGET_TYPE (type)))),
+		 lval_memory);
+	  else if (TYPE_CODE (type) == TYPE_CODE_INT)
+	    /* GDB allows dereferencing an int.  */
+	    return value_zero (builtin_type_int, lval_memory);
+	  else
+	    error ("Attempt to take contents of a non-pointer value.");
+	}
+      arg1 = ada_coerce_ref (arg1);
+      type = check_typedef (VALUE_TYPE (arg1));
+	  
+      if (ada_is_array_descriptor (type))
+	/* GDB allows dereferencing GNAT array descriptors. */
+	return ada_coerce_to_simple_array (arg1);
+      else
+	return ada_value_ind (arg1);
+
+    case STRUCTOP_STRUCT:
+      tem = longest_to_int (exp->elts[pc + 1].longconst);
+      (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	return value_zero (ada_aligned_type 
+			   (ada_lookup_struct_elt_type (VALUE_TYPE (arg1),
+							&exp->elts[pc + 2].string,
+							0, NULL)),
+			   lval_memory);
+      else
+	return unwrap_value (ada_value_struct_elt (arg1,
+						   &exp->elts[pc + 2].string,
+						   "record"));
+    case OP_TYPE:
+      /* The value is not supposed to be used. This is here to make it
+         easier to accommodate expressions that contain types. */
+      (*pos) += 2;
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	return allocate_value (builtin_type_void);
+      else 
+	error ("Attempt to use a type name as an expression");
+      
+    case STRUCTOP_PTR:
+      tem = longest_to_int (exp->elts[pc + 1].longconst);
+      (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	return value_zero (ada_aligned_type 
+			   (ada_lookup_struct_elt_type (VALUE_TYPE (arg1),
+							&exp->elts[pc + 2].string,
+							0, NULL)),
+			   lval_memory);
+      else
+	return unwrap_value (ada_value_struct_elt (arg1,
+						   &exp->elts[pc + 2].string,
+						   "record access"));
+    }
+
+nosideret:
+  return value_from_longest (builtin_type_long, (LONGEST) 1);
+}
+
+
+				/* Fixed point */
+
+/* If TYPE encodes an Ada fixed-point type, return the suffix of the
+   type name that encodes the 'small and 'delta information.
+   Otherwise, return NULL. */
+
+static const char*
+fixed_type_info (type)
+     struct type *type;
+{
+  const char* name = ada_type_name (type);
+  enum type_code code = (type == NULL) ? TYPE_CODE_UNDEF : TYPE_CODE (type);
+
+  if ((code == TYPE_CODE_INT || code == TYPE_CODE_RANGE)
+      && name != NULL)
+    {	
+      const char *tail = strstr (name, "___XF_");
+      if (tail == NULL)
+	return NULL;
+      else 
+	return tail + 5;
+    }
+  else if (code == TYPE_CODE_RANGE && TYPE_TARGET_TYPE (type) != type)
+    return fixed_type_info (TYPE_TARGET_TYPE (type));
+  else
+    return NULL;
+}
+
+/* Returns non-zero iff TYPE represents an Ada fixed-point type. */
+
+int
+ada_is_fixed_point_type (type)
+     struct type *type;
+{
+  return fixed_type_info (type) != NULL;
+}
+
+/* Assuming that TYPE is the representation of an Ada fixed-point
+   type, return its delta, or -1 if the type is malformed and the
+   delta cannot be determined. */
+
+DOUBLEST
+ada_delta (type)
+     struct type *type;
+{
+  const char *encoding = fixed_type_info (type);
+  long num, den;
+
+  if (sscanf (encoding, "_%ld_%ld", &num, &den) < 2)
+    return -1.0;
+  else 
+    return (DOUBLEST) num / (DOUBLEST) den;
+}
+
+/* Assuming that ada_is_fixed_point_type (TYPE), return the scaling
+   factor ('SMALL value) associated with the type. */
+
+static DOUBLEST
+scaling_factor (type)
+     struct type *type;
+{
+  const char *encoding = fixed_type_info (type);
+  unsigned long num0, den0, num1, den1;
+  int n;
+  
+  n = sscanf (encoding, "_%lu_%lu_%lu_%lu", &num0, &den0, &num1, &den1);
+
+  if (n < 2)
+    return 1.0;
+  else if (n == 4)
+    return (DOUBLEST) num1 / (DOUBLEST) den1;
+  else 
+    return (DOUBLEST) num0 / (DOUBLEST) den0;
+}
+
+
+/* Assuming that X is the representation of a value of fixed-point
+   type TYPE, return its floating-point equivalent. */
+
+DOUBLEST
+ada_fixed_to_float (type, x)
+     struct type *type;
+     LONGEST x;
+{
+  return (DOUBLEST) x * scaling_factor (type);
+}
+
+/* The representation of a fixed-point value of type TYPE 
+   corresponding to the value X. */
+
+LONGEST
+ada_float_to_fixed (type, x)
+     struct type *type;
+     DOUBLEST x;
+{
+  return (LONGEST) (x / scaling_factor (type) + 0.5);
+}
+
+
+				/* VAX floating formats */
+
+/* Non-zero iff TYPE represents one of the special VAX floating-point
+   types. */
+int
+ada_is_vax_floating_type (type)
+     struct type* type;
+{
+  int name_len = 
+    (ada_type_name (type) == NULL) ? 0 : strlen (ada_type_name (type));
+  return 
+    name_len > 6
+    && (TYPE_CODE (type) == TYPE_CODE_INT 
+	|| TYPE_CODE (type) == TYPE_CODE_RANGE)
+    && STREQN (ada_type_name (type) + name_len - 6, "___XF", 5);
+}
+
+/* The type of special VAX floating-point type this is, assuming
+   ada_is_vax_floating_point */
+int
+ada_vax_float_type_suffix (type)
+     struct type* type;
+{
+  return ada_type_name (type)[strlen (ada_type_name (type))-1];
+}
+
+/* A value representing the special debugging function that outputs 
+   VAX floating-point values of the type represented by TYPE.  Assumes
+   ada_is_vax_floating_type (TYPE). */
+struct value*
+ada_vax_float_print_function (type)
+
+     struct type* type;
+{
+  switch (ada_vax_float_type_suffix (type)) {
+  case 'F':
+    return 
+      get_var_value ("DEBUG_STRING_F", 0);
+  case 'D':
+    return 
+      get_var_value ("DEBUG_STRING_D", 0);
+  case 'G':
+    return 
+      get_var_value ("DEBUG_STRING_G", 0);
+  default:
+    error ("invalid VAX floating-point type");
+  }
+}
+
+
+				/* Range types */
+
+/* Scan STR beginning at position K for a discriminant name, and
+   return the value of that discriminant field of DVAL in *PX.  If
+   PNEW_K is not null, put the position of the character beyond the
+   name scanned in *PNEW_K.  Return 1 if successful; return 0 and do
+   not alter *PX and *PNEW_K if unsuccessful. */
+
+static int
+scan_discrim_bound (str, k, dval, px, pnew_k)
+     char *str;
+     int k;
+     struct value* dval;
+     LONGEST *px;
+     int *pnew_k;
+{
+  static char *bound_buffer = NULL;
+  static size_t bound_buffer_len = 0;
+  char *bound;
+  char *pend;
+  struct value* bound_val;
+
+  if (dval == NULL || str == NULL || str[k] == '\0')
+    return 0;
+
+  pend = strstr (str+k, "__");
+  if (pend == NULL)
+    {
+      bound = str+k;
+      k += strlen (bound);
+    }
+  else 
+    {
+      GROW_VECT (bound_buffer, bound_buffer_len, pend - (str+k) + 1);
+      bound = bound_buffer;
+      strncpy (bound_buffer, str+k, pend-(str+k));
+      bound[pend-(str+k)] = '\0';
+      k = pend-str;
+    }
+  
+  bound_val = 
+    ada_search_struct_field (bound, dval, 0, VALUE_TYPE (dval));
+  if (bound_val == NULL)
+    return 0;
+
+  *px = value_as_long (bound_val);
+  if (pnew_k != NULL)
+    *pnew_k = k;
+  return 1;
+}
+
+/* Value of variable named NAME in the current environment.  If
+   no such variable found, then if ERR_MSG is null, returns 0, and
+   otherwise causes an error with message ERR_MSG. */
+static struct value*
+get_var_value (name, err_msg)
+     char* name;
+     char* err_msg;
+{
+  struct symbol** syms;
+  struct block** blocks;
+  int nsyms;
+
+  nsyms = ada_lookup_symbol_list (name, get_selected_block (NULL), VAR_NAMESPACE,
+				  &syms, &blocks);
+
+  if (nsyms != 1)
+    {
+      if (err_msg == NULL)
+	return 0;
+      else
+	error ("%s", err_msg);
+    }
+
+  return value_of_variable (syms[0], blocks[0]);
+}
+ 
+/* Value of integer variable named NAME in the current environment.  If
+   no such variable found, then if ERR_MSG is null, returns 0, and sets
+   *FLAG to 0.  If successful, sets *FLAG to 1. */
+LONGEST
+get_int_var_value (name, err_msg, flag)
+     char* name;
+     char* err_msg;
+     int* flag;
+{
+  struct value* var_val = get_var_value (name, err_msg);
+  
+  if (var_val == 0)
+    {
+      if (flag != NULL)
+	*flag = 0;
+      return 0;
+    }
+  else
+    {
+      if (flag != NULL)
+	*flag = 1;
+      return value_as_long (var_val);
+    }
+}
+ 
+
+/* Return a range type whose base type is that of the range type named
+   NAME in the current environment, and whose bounds are calculated
+   from NAME according to the GNAT range encoding conventions. 
+   Extract discriminant values, if needed, from DVAL.  If a new type
+   must be created, allocate in OBJFILE's space.  The bounds
+   information, in general, is encoded in NAME, the base type given in
+   the named range type. */
+
+static struct type*
+to_fixed_range_type (name, dval, objfile)
+     char *name;
+     struct value *dval;
+     struct objfile *objfile;
+{
+  struct type *raw_type = ada_find_any_type (name);
+  struct type *base_type;
+  LONGEST low, high;
+  char* subtype_info;
+
+  if (raw_type == NULL)
+    base_type = builtin_type_int;
+  else if (TYPE_CODE (raw_type) == TYPE_CODE_RANGE)
+    base_type = TYPE_TARGET_TYPE (raw_type);
+  else
+    base_type = raw_type;
+
+  subtype_info = strstr (name, "___XD");
+  if (subtype_info == NULL)
+    return raw_type;
+  else
+    {
+      static char *name_buf = NULL;
+      static size_t name_len = 0;
+      int prefix_len = subtype_info - name;
+      LONGEST L, U;
+      struct type *type;
+      char *bounds_str;
+      int n;
+
+      GROW_VECT (name_buf, name_len, prefix_len + 5);
+      strncpy (name_buf, name, prefix_len);
+      name_buf[prefix_len] = '\0';
+
+      subtype_info += 5;
+      bounds_str = strchr (subtype_info, '_');
+      n = 1;
+
+      if (*subtype_info == 'L') 
+	{
+	  if (! ada_scan_number (bounds_str, n, &L, &n)
+	      && ! scan_discrim_bound (bounds_str, n, dval, &L, &n))
+	    return raw_type;
+	  if (bounds_str[n] == '_')
+	    n += 2;
+	  else if (bounds_str[n] == '.') /* FIXME? SGI Workshop kludge. */
+	    n += 1;
+	  subtype_info += 1;
+	}
+      else 
+	{
+	  strcpy (name_buf+prefix_len, "___L");
+	  L = get_int_var_value (name_buf, "Index bound unknown.", NULL);
+	}
+
+      if (*subtype_info == 'U') 
+	{
+	  if (! ada_scan_number (bounds_str, n, &U, &n)
+	      && !scan_discrim_bound (bounds_str, n, dval, &U, &n))
+	    return raw_type;
+	}
+      else 
+	{
+	  strcpy (name_buf+prefix_len, "___U");
+	  U = get_int_var_value (name_buf, "Index bound unknown.", NULL);
+	}
+
+      if (objfile == NULL) 
+	objfile = TYPE_OBJFILE (base_type);
+      type = create_range_type (alloc_type (objfile), base_type, L, U);
+      TYPE_NAME (type) = name; 
+      return type;
+    }
+}
+
+/* True iff NAME is the name of a range type. */
+int
+ada_is_range_type_name (name)
+     const char* name;
+{
+  return (name != NULL && strstr (name, "___XD"));
+}	  
+
+
+				/* Modular types */
+
+/* True iff TYPE is an Ada modular type. */
+int
+ada_is_modular_type (type)
+     struct type* type;
+{
+  /* FIXME: base_type should be declared in gdbtypes.h, implemented in
+     valarith.c */  
+  struct type* subranged_type; /* = base_type (type);*/
+
+  return (subranged_type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
+	  && TYPE_CODE (subranged_type) != TYPE_CODE_ENUM
+	  && TYPE_UNSIGNED (subranged_type));
+}
+
+/* Assuming ada_is_modular_type (TYPE), the modulus of TYPE. */
+LONGEST
+ada_modulus (type)
+     struct type* type;
+{
+    return TYPE_HIGH_BOUND (type) + 1;
+}
+
+
+
+				/* Operators */
+
+/* Table mapping opcodes into strings for printing operators
+   and precedences of the operators.  */
+
+static const struct op_print ada_op_print_tab[] =
+  {
+    {":=",  BINOP_ASSIGN, PREC_ASSIGN, 1},
+    {"or else", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
+    {"and then", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
+    {"or",  BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
+    {"xor",  BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
+    {"and",  BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
+    {"=", BINOP_EQUAL, PREC_EQUAL, 0},
+    {"/=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
+    {"<=", BINOP_LEQ, PREC_ORDER, 0},
+    {">=", BINOP_GEQ, PREC_ORDER, 0},
+    {">",  BINOP_GTR, PREC_ORDER, 0},
+    {"<",  BINOP_LESS, PREC_ORDER, 0},
+    {">>", BINOP_RSH, PREC_SHIFT, 0},
+    {"<<", BINOP_LSH, PREC_SHIFT, 0},
+    {"+",  BINOP_ADD, PREC_ADD, 0},
+    {"-",  BINOP_SUB, PREC_ADD, 0},
+    {"&",  BINOP_CONCAT, PREC_ADD, 0},
+    {"*",  BINOP_MUL, PREC_MUL, 0},
+    {"/",  BINOP_DIV, PREC_MUL, 0},
+    {"rem",  BINOP_REM, PREC_MUL, 0},
+    {"mod",  BINOP_MOD, PREC_MUL, 0},
+    {"**", BINOP_EXP, PREC_REPEAT, 0 },
+    {"@",  BINOP_REPEAT, PREC_REPEAT, 0},
+    {"-",  UNOP_NEG, PREC_PREFIX, 0},
+    {"+",  UNOP_PLUS, PREC_PREFIX, 0},
+    {"not ",  UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
+    {"not ",  UNOP_COMPLEMENT, PREC_PREFIX, 0},
+    {"abs ",  UNOP_ABS, PREC_PREFIX, 0},
+    {".all",  UNOP_IND, PREC_SUFFIX, 1},  /* FIXME: postfix .ALL */
+    {"'access",  UNOP_ADDR, PREC_SUFFIX, 1}, /* FIXME: postfix 'ACCESS */
+    {NULL, 0, 0, 0}
+};
+
+			/* Assorted Types and Interfaces */
+
+struct type* builtin_type_ada_int;
+struct type* builtin_type_ada_short;
+struct type* builtin_type_ada_long;
+struct type* builtin_type_ada_long_long;
+struct type* builtin_type_ada_char;
+struct type* builtin_type_ada_float;
+struct type* builtin_type_ada_double;
+struct type* builtin_type_ada_long_double;
+struct type* builtin_type_ada_natural;
+struct type* builtin_type_ada_positive;
+struct type* builtin_type_ada_system_address;
+
+struct type ** const (ada_builtin_types[]) = 
+{
+  
+  &builtin_type_ada_int,
+  &builtin_type_ada_long,
+  &builtin_type_ada_short,
+  &builtin_type_ada_char,
+  &builtin_type_ada_float,
+  &builtin_type_ada_double,
+  &builtin_type_ada_long_long,
+  &builtin_type_ada_long_double,
+  &builtin_type_ada_natural,
+  &builtin_type_ada_positive,
+
+  /* The following types are carried over from C for convenience. */
+  &builtin_type_int,
+  &builtin_type_long,
+  &builtin_type_short,
+  &builtin_type_char,
+  &builtin_type_float,
+  &builtin_type_double,
+  &builtin_type_long_long,
+  &builtin_type_void,
+  &builtin_type_signed_char,
+  &builtin_type_unsigned_char,
+  &builtin_type_unsigned_short,
+  &builtin_type_unsigned_int,
+  &builtin_type_unsigned_long,
+  &builtin_type_unsigned_long_long,
+  &builtin_type_long_double,
+  &builtin_type_complex,
+  &builtin_type_double_complex,
+  0
+};
+
+/* Not really used, but needed in the ada_language_defn. */
+static void emit_char (int c, struct ui_file* stream, int quoter) 
+{
+  ada_emit_char (c, stream, quoter, 1);
+}
+
+const struct language_defn ada_language_defn = {
+  "ada",			/* Language name */
+  /*  language_ada, */
+  language_unknown,
+  /* FIXME: language_ada should be defined in defs.h */
+  ada_builtin_types,
+  range_check_off,
+  type_check_off,
+  case_sensitive_on,		/* Yes, Ada is case-insensitive, but
+				 * that's not quite what this means. */
+  ada_parse,
+  ada_error,
+  ada_evaluate_subexp,
+  ada_printchar,		/* Print a character constant */
+  ada_printstr,			/* Function to print string constant */
+  emit_char,			/* Function to print single char (not used) */
+  ada_create_fundamental_type,	/* Create fundamental type in this language */
+  ada_print_type,		/* Print a type using appropriate syntax */
+  ada_val_print,		/* Print a value using appropriate syntax */
+  ada_value_print,		/* Print a top-level value */
+  {"",     "",    "",  ""},	/* Binary format info */
+#if 0
+  {"8#%lo#",  "8#",   "o", "#"},	/* Octal format info */
+  {"%ld",   "",    "d", ""},	/* Decimal format info */
+  {"16#%lx#", "16#",  "x", "#"},	/* Hex format info */
+#else
+  /* Copied from c-lang.c. */
+  {"0%lo",  "0",   "o", ""},	/* Octal format info */
+  {"%ld",   "",    "d", ""},	/* Decimal format info */
+  {"0x%lx", "0x",  "x", ""},	/* Hex format info */
+#endif
+  ada_op_print_tab,		/* expression operators for printing */
+  1,				/* c-style arrays (FIXME?) */
+  0,				/* String lower bound (FIXME?) */
+  &builtin_type_ada_char,
+  LANG_MAGIC
+};
+
+void
+_initialize_ada_language ()
+{
+  builtin_type_ada_int =
+    init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
+	       0,
+	       "integer", (struct objfile *) NULL);
+  builtin_type_ada_long =
+    init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
+	       0,
+	       "long_integer", (struct objfile *) NULL);
+  builtin_type_ada_short =
+    init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
+	       0,
+	       "short_integer", (struct objfile *) NULL);
+  builtin_type_ada_char =
+    init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+	       0,
+	       "character", (struct objfile *) NULL);
+  builtin_type_ada_float =
+    init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
+	       0,
+	       "float", (struct objfile *) NULL);
+  builtin_type_ada_double =
+    init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
+	       0,
+	       "long_float", (struct objfile *) NULL);
+  builtin_type_ada_long_long =
+    init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
+	       0,
+	       "long_long_integer", (struct objfile *) NULL);
+  builtin_type_ada_long_double =
+    init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
+	       0,
+	       "long_long_float", (struct objfile *) NULL);
+  builtin_type_ada_natural =
+    init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
+	       0,
+	       "natural", (struct objfile *) NULL);
+  builtin_type_ada_positive =
+    init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
+	       0,
+	       "positive", (struct objfile *) NULL);
+
+
+  builtin_type_ada_system_address = 
+    lookup_pointer_type (init_type (TYPE_CODE_VOID, 1, 0, "void", 
+				    (struct objfile *) NULL));
+  TYPE_NAME (builtin_type_ada_system_address) = "system__address";
+
+  add_language (&ada_language_defn);
+
+  add_show_from_set 
+    (add_set_cmd ("varsize-limit", class_support, var_uinteger,
+		  (char*) &varsize_limit,
+		  "Set maximum bytes in dynamic-sized object.",
+		  &setlist),
+     &showlist);
+  varsize_limit = 65536;
+
+  add_com ("begin", class_breakpoint, begin_command,
+	   "Start the debugged program, stopping at the beginning of the\n\
+main program.  You may specify command-line arguments to give it, as for\n\
+the \"run\" command (q.v.).");
+}
+
+
+/* Create a fundamental Ada type using default reasonable for the current
+   target machine.
+
+   Some object/debugging file formats (DWARF version 1, COFF, etc) do not
+   define fundamental types such as "int" or "double".  Others (stabs or
+   DWARF version 2, etc) do define fundamental types.  For the formats which
+   don't provide fundamental types, gdb can create such types using this
+   function.
+
+   FIXME:  Some compilers distinguish explicitly signed integral types
+   (signed short, signed int, signed long) from "regular" integral types
+   (short, int, long) in the debugging information.  There is some dis-
+   agreement as to how useful this feature is.  In particular, gcc does
+   not support this.  Also, only some debugging formats allow the
+   distinction to be passed on to a debugger.  For now, we always just
+   use "short", "int", or "long" as the type name, for both the implicit
+   and explicitly signed types.  This also makes life easier for the
+   gdb test suite since we don't have to account for the differences
+   in output depending upon what the compiler and debugging format
+   support.  We will probably have to re-examine the issue when gdb
+   starts taking it's fundamental type information directly from the
+   debugging information supplied by the compiler.  fnf@cygnus.com */
+
+static struct type *
+ada_create_fundamental_type (objfile, typeid)
+     struct objfile *objfile;
+     int typeid;
+{
+  struct type *type = NULL;
+
+  switch (typeid)
+    {
+      default:
+	/* FIXME:  For now, if we are asked to produce a type not in this
+	   language, create the equivalent of a C integer type with the
+	   name "<?type?>".  When all the dust settles from the type
+	   reconstruction work, this should probably become an error. */
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_INT_BIT / TARGET_CHAR_BIT,
+			  0, "<?type?>", objfile);
+        warning ("internal error: no Ada fundamental type %d", typeid);
+	break;
+      case FT_VOID:
+	type = init_type (TYPE_CODE_VOID,
+			  TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+			  0, "void", objfile);
+	break;
+      case FT_CHAR:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+			  0, "character", objfile);
+	break;
+      case FT_SIGNED_CHAR:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+			  0, "signed char", objfile);
+	break;
+      case FT_UNSIGNED_CHAR:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+			  TYPE_FLAG_UNSIGNED, "unsigned char", objfile);
+	break;
+      case FT_SHORT:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_SHORT_BIT / TARGET_CHAR_BIT,
+			  0, "short_integer", objfile);
+	break;
+      case FT_SIGNED_SHORT:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_SHORT_BIT / TARGET_CHAR_BIT,
+			  0, "short_integer", objfile);	
+	break;
+      case FT_UNSIGNED_SHORT:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_SHORT_BIT / TARGET_CHAR_BIT,
+			  TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
+	break;
+      case FT_INTEGER:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_INT_BIT / TARGET_CHAR_BIT,
+			  0, "integer", objfile);
+	break;
+      case FT_SIGNED_INTEGER:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_INT_BIT / TARGET_CHAR_BIT,
+			  0, "integer", objfile); /* FIXME -fnf */
+	break;
+      case FT_UNSIGNED_INTEGER:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_INT_BIT / TARGET_CHAR_BIT,
+			  TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
+	break;
+      case FT_LONG:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_LONG_BIT / TARGET_CHAR_BIT,
+			  0, "long_integer", objfile);
+	break;
+      case FT_SIGNED_LONG:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_LONG_BIT / TARGET_CHAR_BIT,
+			  0, "long_integer", objfile);
+	break;
+      case FT_UNSIGNED_LONG:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_LONG_BIT / TARGET_CHAR_BIT,
+			  TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
+	break;
+      case FT_LONG_LONG:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
+			  0, "long_long_integer", objfile);
+	break;
+      case FT_SIGNED_LONG_LONG:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
+			  0, "long_long_integer", objfile);
+	break;
+      case FT_UNSIGNED_LONG_LONG:
+	type = init_type (TYPE_CODE_INT,
+			  TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
+			  TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
+	break;
+      case FT_FLOAT:
+	type = init_type (TYPE_CODE_FLT,
+			  TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
+			  0, "float", objfile);
+	break;
+      case FT_DBL_PREC_FLOAT:
+	type = init_type (TYPE_CODE_FLT,
+			  TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
+			  0, "long_float", objfile);
+	break;
+      case FT_EXT_PREC_FLOAT:
+	type = init_type (TYPE_CODE_FLT,
+			  TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
+			  0, "long_long_float", objfile);
+	break;
+      }
+  return (type);
+}
+
+void ada_dump_symtab (struct symtab* s)
+{
+  int i;
+  fprintf (stderr, "New symtab: [\n");
+  fprintf (stderr, "  Name: %s/%s;\n", 
+	   s->dirname ? s->dirname : "?", 
+	   s->filename ? s->filename : "?");
+  fprintf (stderr, "  Format: %s;\n", s->debugformat);
+  if (s->linetable != NULL)
+    {
+      fprintf (stderr, "  Line table (section %d):\n", s->block_line_section);
+      for (i = 0; i < s->linetable->nitems; i += 1)
+	{
+	  struct linetable_entry* e = s->linetable->item + i;
+	  fprintf (stderr, "    %4ld: %8lx\n", (long) e->line, (long) e->pc);
+	}
+    }
+  fprintf (stderr, "]\n");
+}
+
diff --git a/gdb/config/sparc/nbsd.mt b/gdb/config/sparc/nbsd.mt
new file mode 100644
index 00000000000..b04dd42fabb
--- /dev/null
+++ b/gdb/config/sparc/nbsd.mt
@@ -0,0 +1,4 @@
+# Target: SPARC running NetBSD
+TDEPFILES= sparc-tdep.o sparcnbsd-tdep.o nbsd-tdep.o corelow.o solib.o \
+	solib-svr4.o
+TM_FILE= tm-nbsd.h
diff --git a/gdb/i386-sol2-tdep.c b/gdb/i386-sol2-tdep.c
new file mode 100644
index 00000000000..206e85cfe72
--- /dev/null
+++ b/gdb/i386-sol2-tdep.c
@@ -0,0 +1,74 @@
+/* Target-dependent code for Solaris x86.
+   Copyright 2002 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 "defs.h"
+
+#include "i386-tdep.h"
+
+static int
+i386_sol2_pc_in_sigtramp (CORE_ADDR pc, char *name)
+{
+  /* Signal handler frames under Solaris 2 are recognized by a return
+     address of 0xffffffff.  */
+  return (pc == 0xffffffff);
+}
+
+/* Solaris 2.  */
+
+static void
+i386_sol2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+  /* Solaris is SVR4-based.  */
+  i386_svr4_init_abi (info, gdbarch);
+
+  /* Signal trampolines are different from SVR4, in fact they're
+     rather similar to BSD.  */
+  set_gdbarch_pc_in_sigtramp (gdbarch, i386_sol2_pc_in_sigtramp);
+  tdep->sigtramp_saved_pc = i386bsd_sigtramp_saved_pc;
+  tdep->sc_pc_offset = 36 + 14 * 4;
+}
+
+
+static enum gdb_osabi
+i386_sol2_osabi_sniffer (bfd *abfd)
+{
+  /* If we have a section named .SUNW_version, then it is almost
+     certainly Solaris 2.  */
+  if (bfd_get_section_by_name (abfd, ".SUNW_version"))
+    return GDB_OSABI_SOLARIS;
+
+  return GDB_OSABI_UNKNOWN;
+}
+
+/* Provide a prototype to silence -Wmissing-prototypes.  */
+void _initialize_i386_sol2_tdep (void);
+
+void
+_initialize_i386_sol2_tdep (void)
+{
+  /* Register and ELF OS ABI sniffer for Solaris 2 binaries.  */
+  gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_elf_flavour,
+				  i386_sol2_osabi_sniffer);
+
+  gdbarch_register_osabi (bfd_arch_i386, GDB_OSABI_SOLARIS,
+			  i386_sol2_init_abi);
+}
diff --git a/include/elf/frv.h b/include/elf/frv.h
new file mode 100644
index 00000000000..65ce97d1ee3
--- /dev/null
+++ b/include/elf/frv.h
@@ -0,0 +1,95 @@
+/* FRV ELF support for BFD.
+   Copyright (C) 2002 Free Software Foundation, Inc.
+
+This file is part of BFD, the Binary File Descriptor library.
+
+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.  */
+
+#ifndef _ELF_FRV_H
+#define _ELF_FRV_H
+
+#include "elf/reloc-macros.h"
+
+/* Relocations.  */
+START_RELOC_NUMBERS (elf_frv_reloc_type)
+  RELOC_NUMBER (R_FRV_NONE, 0)
+  RELOC_NUMBER (R_FRV_32, 1)
+  RELOC_NUMBER (R_FRV_LABEL16, 2)
+  RELOC_NUMBER (R_FRV_LABEL24, 3)
+  RELOC_NUMBER (R_FRV_LO16, 4)
+  RELOC_NUMBER (R_FRV_HI16, 5)
+  RELOC_NUMBER (R_FRV_GPREL12, 6)
+  RELOC_NUMBER (R_FRV_GPRELU12, 7)
+  RELOC_NUMBER (R_FRV_GPREL32, 8)
+  RELOC_NUMBER (R_FRV_GPRELHI, 9)
+  RELOC_NUMBER (R_FRV_GPRELLO, 10)
+  RELOC_NUMBER (R_FRV_GNU_VTINHERIT, 200)
+  RELOC_NUMBER (R_FRV_GNU_VTENTRY, 201)
+END_RELOC_NUMBERS(R_FRV_max)
+
+/* Processor specific flags for the ELF header e_flags field.  */
+						/* gpr support */
+#define EF_FRV_GPR_MASK		0x00000003	/* mask for # of gprs */
+#define EF_FRV_GPR_32		0x00000001	/* -mgpr-32 */
+#define EF_FRV_GPR_64		0x00000002	/* -mgpr-64 */
+
+						/* fpr support */
+#define EF_FRV_FPR_MASK		0x0000000c	/* mask for # of fprs */
+#define EF_FRV_FPR_32		0x00000004	/* -mfpr-32 */
+#define EF_FRV_FPR_64		0x00000008	/* -mfpr-64 */
+#define EF_FRV_FPR_NONE		0x0000000c	/* -msoft-float */
+
+						/* double word support */
+#define EF_FRV_DWORD_MASK	0x00000030	/* mask for dword support */
+#define EF_FRV_DWORD_YES	0x00000010	/* use double word insns */
+#define EF_FRV_DWORD_NO		0x00000020	/* don't use double word insn*/
+
+#define EF_FRV_DOUBLE		0x00000040	/* -mdouble */
+#define EF_FRV_MEDIA		0x00000080	/* -mmedia */
+
+#define EF_FRV_PIC		0x00000100	/* -fpic */
+#define EF_FRV_NON_PIC_RELOCS	0x00000200	/* used non pic safe relocs */
+
+#define EF_FRV_MULADD		0x00000400	/* -mmuladd */
+#define EF_FRV_BIGPIC		0x00000800	/* -fPIC */
+#define	EF_FRV_LIBPIC		0x00001000	/* -mlibrary-pic */
+#define EF_FRV_G0		0x00002000	/* -G 0, no small data ptr */
+#define EF_FRV_NOPACK		0x00004000	/* -mnopack */
+
+#define	EF_FRV_CPU_MASK		0xff000000	/* specific cpu bits */
+#define EF_FRV_CPU_GENERIC	0x00000000	/* generic FRV */
+#define EF_FRV_CPU_FR500	0x01000000	/* FRV500 */
+#define EF_FRV_CPU_FR300	0x02000000	/* FRV300 */
+#define EF_FRV_CPU_SIMPLE	0x03000000	/* SIMPLE */
+#define EF_FRV_CPU_TOMCAT	0x04000000	/* Tomcat, FR500 prototype */
+#define EF_FRV_CPU_FR400	0x05000000	/* FRV400 */
+
+						/* Mask of PIC related bits */
+#define	EF_FRV_PIC_FLAGS	(EF_FRV_PIC | EF_FRV_LIBPIC | EF_FRV_BIGPIC)
+
+						/* Mask of all flags */
+#define EF_FRV_ALL_FLAGS	(EF_FRV_GPR_MASK | \
+				 EF_FRV_FPR_MASK | \
+				 EF_FRV_DWORD_MASK | \
+				 EF_FRV_DOUBLE | \
+				 EF_FRV_MEDIA | \
+				 EF_FRV_PIC_FLAGS | \
+				 EF_FRV_NON_PIC_RELOCS | \
+				 EF_FRV_MULADD | \
+				 EF_FRV_G0 | \
+				 EF_FRV_NOPACK | \
+				 EF_FRV_CPU_MASK)
+
+#endif /* _ELF_FRV_H */
diff --git a/include/gdb/sim-arm.h b/include/gdb/sim-arm.h
new file mode 100644
index 00000000000..6d80700ad7e
--- /dev/null
+++ b/include/gdb/sim-arm.h
@@ -0,0 +1,65 @@
+/* This file defines the interface between the Arm simulator and GDB.
+
+   Copyright 2002 Free Software Foundation, Inc.
+
+   Contributed by Red Hat.
+
+   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.  */
+
+#if !defined (SIM_ARM_H)
+#define SIM_ARM_H
+
+#ifdef __cplusplus
+extern "C" { // }
+#endif
+
+enum sim_arm_regs
+{
+  SIM_ARM_R0_REGNUM,
+  SIM_ARM_R1_REGNUM,
+  SIM_ARM_R2_REGNUM,
+  SIM_ARM_R3_REGNUM,
+  SIM_ARM_R4_REGNUM,
+  SIM_ARM_R5_REGNUM,
+  SIM_ARM_R6_REGNUM,
+  SIM_ARM_R7_REGNUM,
+  SIM_ARM_R8_REGNUM,
+  SIM_ARM_R9_REGNUM,
+  SIM_ARM_R10_REGNUM,
+  SIM_ARM_R11_REGNUM,
+  SIM_ARM_R12_REGNUM,
+  SIM_ARM_R13_REGNUM,
+  SIM_ARM_R14_REGNUM,
+  SIM_ARM_R15_REGNUM, /* PC */
+  SIM_ARM_FP0_REGNUM,
+  SIM_ARM_FP1_REGNUM,
+  SIM_ARM_FP2_REGNUM,
+  SIM_ARM_FP3_REGNUM,
+  SIM_ARM_FP4_REGNUM,
+  SIM_ARM_FP5_REGNUM,
+  SIM_ARM_FP6_REGNUM,
+  SIM_ARM_FP7_REGNUM,
+  SIM_ARM_FPS_REGNUM,
+  SIM_ARM_PS_REGNUM
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/opcodes/frv-asm.c b/opcodes/frv-asm.c
new file mode 100644
index 00000000000..538ed2dc8f1
--- /dev/null
+++ b/opcodes/frv-asm.c
@@ -0,0 +1,1023 @@
+/* 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 Free Software Foundation, Inc.
+
+This file is part of the GNU Binutils and GDB, the GNU debugger.
+
+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, 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.  */
+
+/* ??? 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 "frv-desc.h"
+#include "frv-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
+     PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *));
+
+/* -- assembler routines inserted here.  */
+
+/* -- asm.c */
+static const char * parse_ulo16
+  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *));
+static const char * parse_uslo16
+  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *));
+static const char * parse_uhi16
+  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *));
+static long parse_register_number
+  PARAMS ((const char **));
+static const char * parse_spr
+  PARAMS ((CGEN_CPU_DESC, const char **, CGEN_KEYWORD *, long *));
+static const char * parse_d12
+  PARAMS ((CGEN_CPU_DESC, const char **, int, long *));
+static const char * parse_s12
+  PARAMS ((CGEN_CPU_DESC, const char **, int, long *));
+static const char * parse_u12
+  PARAMS ((CGEN_CPU_DESC, const char **, int, long *));
+
+static const char *
+parse_ulo16 (cd, strp, opindex, valuep)
+     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 + 1, "lo(", 3) == 0)
+	{
+	  *strp += 4;
+	  errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_FRV_LO16,
+				       &result_type, &value);
+	  if (**strp != ')')
+	    return "missing `)'";
+	  ++*strp;
+	  if (errmsg == NULL
+	      && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+	    value &= 0xffff;
+	  *valuep = value;
+	  return errmsg;
+	}
+      if (strncasecmp (*strp + 1, "gprello(", 8) == 0)
+	{
+	  *strp += 9;
+	  errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_FRV_GPRELLO,
+				       &result_type, &value);
+	  if (**strp != ')')
+	    return "missing ')'";
+	  ++*strp;
+	  if (errmsg == NULL
+	      && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+	    value >>= 16;
+	  *valuep = value;
+	  return errmsg;
+	}
+    }
+  return cgen_parse_signed_integer (cd, strp, opindex, valuep);
+}
+
+static const char *
+parse_uslo16 (cd, strp, opindex, valuep)
+     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 + 1, "lo(", 3) == 0)
+	{
+	  *strp += 4;
+	  errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_FRV_LO16,
+				       &result_type, &value);
+	  if (**strp != ')')
+	    return "missing `)'";
+	  ++*strp;
+	  if (errmsg == NULL
+	      && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+	    value &= 0xffff;
+	  *valuep = value;
+	  return errmsg;
+	}
+      else if (strncasecmp (*strp + 1, "gprello(", 8) == 0)
+	{
+	  *strp += 9;
+	  errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_FRV_GPRELLO,
+				       &result_type, &value);
+	  if (**strp != ')')
+	    return "missing ')'";
+	  ++*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);
+}
+
+static const char *
+parse_uhi16 (cd, strp, opindex, valuep)
+     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 + 1, "hi(", 3) == 0)
+	{
+	  *strp += 4;
+	  errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_FRV_HI16,
+				       &result_type, &value);
+	  if (**strp != ')')
+	    return "missing `)'";
+	  ++*strp;
+	  if (errmsg == NULL
+	      && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+	    value >>= 16;
+	  *valuep = value;
+	  return errmsg;
+	}
+      else if (strncasecmp (*strp + 1, "gprelhi(", 8) == 0)
+	{
+	  *strp += 9;
+	  errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_FRV_GPRELHI,
+				       &result_type, &value);
+	  if (**strp != ')')
+	    return "missing ')'";
+	  ++*strp;
+	  if (errmsg == NULL
+	      && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+	    value >>= 16;
+	  *valuep = value;
+	  return errmsg;
+	}
+    }
+  return cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
+}
+
+static long
+parse_register_number (strp)
+     const char **strp;
+{
+  int regno;
+  if (**strp < '0' || **strp > '9')
+    return -1; /* error */
+
+  regno = **strp - '0';
+  for (++*strp; **strp >= '0' && **strp <= '9'; ++*strp)
+    regno = regno * 10 + (**strp - '0');
+
+  return regno;
+}
+
+static const char *
+parse_spr (cd, strp, table, valuep)
+     CGEN_CPU_DESC cd;
+     const char **strp;
+     CGEN_KEYWORD * table;
+     long *valuep;
+{
+  const char *save_strp;
+  long regno;
+
+  /* Check for spr index notation.  */
+  if (strncasecmp (*strp, "spr[", 4) == 0)
+    {
+      *strp += 4;
+      regno = parse_register_number (strp);
+      if (**strp != ']')
+        return "missing `]'";
+      ++*strp;
+      if (! spr_valid (regno))
+	return "Special purpose register number is out of range";
+      *valuep = regno;
+      return NULL;
+    }
+
+  save_strp = *strp;
+  regno = parse_register_number (strp);
+  if (regno != -1)
+    {
+      if (! spr_valid (regno))
+	return "Special purpose register number is out of range";
+      *valuep = regno;
+      return NULL;
+    }
+
+  *strp = save_strp;
+  return cgen_parse_keyword (cd, strp, table, valuep);
+}
+
+static const char *
+parse_d12 (cd, strp, opindex, valuep)
+     CGEN_CPU_DESC cd;
+     const char **strp;
+     int opindex;
+     long *valuep;
+{
+  const char *errmsg;
+  enum cgen_parse_operand_result result_type;
+  bfd_vma value;
+ 
+  /* Check for small data reference.  */
+  if (**strp == '#' || **strp == '%')
+    {
+      if (strncasecmp (*strp + 1, "gprel12(", 8) == 0)
+        {
+          *strp += 9;
+          errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_FRV_GPREL12,
+                                       &result_type, &value);
+          if (**strp != ')')
+            return "missing `)'";
+          ++*strp;
+          *valuep = value;
+          return errmsg;
+        }
+    }
+  return cgen_parse_signed_integer (cd, strp, opindex, valuep);
+}
+
+static const char *
+parse_s12 (cd, strp, opindex, valuep)
+     CGEN_CPU_DESC cd;
+     const char **strp;
+     int opindex;
+     long *valuep;
+{
+  const char *errmsg;
+  enum cgen_parse_operand_result result_type;
+  bfd_vma value;
+ 
+  /* Check for small data reference.  */
+  if ((**strp == '#' || **strp == '%')
+      && strncasecmp (*strp + 1, "gprel12(", 8) == 0)
+    {
+      *strp += 9;
+      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_FRV_GPREL12,
+                                    &result_type, &value);
+      if (**strp != ')')
+        return "missing `)'";
+      ++*strp;
+      *valuep = value;
+      return errmsg;
+    }
+  else
+    {
+      if (**strp == '#')
+        ++*strp;
+      return cgen_parse_signed_integer (cd, strp, opindex, valuep);
+    }
+}
+
+static const char *
+parse_u12 (cd, strp, opindex, valuep)
+     CGEN_CPU_DESC cd;
+     const char **strp;
+     int opindex;
+     long *valuep;
+{
+  const char *errmsg;
+  enum cgen_parse_operand_result result_type;
+  bfd_vma value;
+ 
+  /* Check for small data reference.  */
+  if ((**strp == '#' || **strp == '%')
+      && strncasecmp (*strp + 1, "gprel12(", 8) == 0)
+    {
+      *strp += 9;
+      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_FRV_GPRELU12,
+                                    &result_type, &value);
+      if (**strp != ')')
+        return "missing `)'";
+      ++*strp;
+      *valuep = value;
+      return errmsg;
+    }
+  else
+    {
+      if (**strp == '#')
+        ++*strp;
+      return cgen_parse_signed_integer (cd, strp, opindex, valuep);
+    }
+}
+
+/* -- */
+
+const char * frv_cgen_parse_operand
+  PARAMS ((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 *
+frv_cgen_parse_operand (cd, opindex, strp, fields)
+     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 FRV_OPERAND_A :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, FRV_OPERAND_A, &fields->f_A);
+      break;
+    case FRV_OPERAND_ACC40SI :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_acc_names, & fields->f_ACC40Si);
+      break;
+    case FRV_OPERAND_ACC40SK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_acc_names, & fields->f_ACC40Sk);
+      break;
+    case FRV_OPERAND_ACC40UI :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_acc_names, & fields->f_ACC40Ui);
+      break;
+    case FRV_OPERAND_ACC40UK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_acc_names, & fields->f_ACC40Uk);
+      break;
+    case FRV_OPERAND_ACCGI :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_accg_names, & fields->f_ACCGi);
+      break;
+    case FRV_OPERAND_ACCGK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_accg_names, & fields->f_ACCGk);
+      break;
+    case FRV_OPERAND_CCI :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_cccr_names, & fields->f_CCi);
+      break;
+    case FRV_OPERAND_CPRDOUBLEK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_cpr_names, & fields->f_CPRk);
+      break;
+    case FRV_OPERAND_CPRI :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_cpr_names, & fields->f_CPRi);
+      break;
+    case FRV_OPERAND_CPRJ :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_cpr_names, & fields->f_CPRj);
+      break;
+    case FRV_OPERAND_CPRK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_cpr_names, & fields->f_CPRk);
+      break;
+    case FRV_OPERAND_CRI :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_cccr_names, & fields->f_CRi);
+      break;
+    case FRV_OPERAND_CRJ :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_cccr_names, & fields->f_CRj);
+      break;
+    case FRV_OPERAND_CRJ_FLOAT :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_cccr_names, & fields->f_CRj_float);
+      break;
+    case FRV_OPERAND_CRJ_INT :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_cccr_names, & fields->f_CRj_int);
+      break;
+    case FRV_OPERAND_CRK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_cccr_names, & fields->f_CRk);
+      break;
+    case FRV_OPERAND_FCCI_1 :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fccr_names, & fields->f_FCCi_1);
+      break;
+    case FRV_OPERAND_FCCI_2 :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fccr_names, & fields->f_FCCi_2);
+      break;
+    case FRV_OPERAND_FCCI_3 :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fccr_names, & fields->f_FCCi_3);
+      break;
+    case FRV_OPERAND_FCCK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fccr_names, & fields->f_FCCk);
+      break;
+    case FRV_OPERAND_FRDOUBLEI :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fr_names, & fields->f_FRi);
+      break;
+    case FRV_OPERAND_FRDOUBLEJ :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fr_names, & fields->f_FRj);
+      break;
+    case FRV_OPERAND_FRDOUBLEK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fr_names, & fields->f_FRk);
+      break;
+    case FRV_OPERAND_FRI :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fr_names, & fields->f_FRi);
+      break;
+    case FRV_OPERAND_FRINTI :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fr_names, & fields->f_FRi);
+      break;
+    case FRV_OPERAND_FRINTJ :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fr_names, & fields->f_FRj);
+      break;
+    case FRV_OPERAND_FRINTK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fr_names, & fields->f_FRk);
+      break;
+    case FRV_OPERAND_FRJ :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fr_names, & fields->f_FRj);
+      break;
+    case FRV_OPERAND_FRK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fr_names, & fields->f_FRk);
+      break;
+    case FRV_OPERAND_FRKHI :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fr_names, & fields->f_FRk);
+      break;
+    case FRV_OPERAND_FRKLO :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_fr_names, & fields->f_FRk);
+      break;
+    case FRV_OPERAND_GRDOUBLEK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_gr_names, & fields->f_GRk);
+      break;
+    case FRV_OPERAND_GRI :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_gr_names, & fields->f_GRi);
+      break;
+    case FRV_OPERAND_GRJ :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_gr_names, & fields->f_GRj);
+      break;
+    case FRV_OPERAND_GRK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_gr_names, & fields->f_GRk);
+      break;
+    case FRV_OPERAND_GRKHI :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_gr_names, & fields->f_GRk);
+      break;
+    case FRV_OPERAND_GRKLO :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_gr_names, & fields->f_GRk);
+      break;
+    case FRV_OPERAND_ICCI_1 :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_iccr_names, & fields->f_ICCi_1);
+      break;
+    case FRV_OPERAND_ICCI_2 :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_iccr_names, & fields->f_ICCi_2);
+      break;
+    case FRV_OPERAND_ICCI_3 :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_iccr_names, & fields->f_ICCi_3);
+      break;
+    case FRV_OPERAND_LI :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, FRV_OPERAND_LI, &fields->f_LI);
+      break;
+    case FRV_OPERAND_AE :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, FRV_OPERAND_AE, &fields->f_ae);
+      break;
+    case FRV_OPERAND_CCOND :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, FRV_OPERAND_CCOND, &fields->f_ccond);
+      break;
+    case FRV_OPERAND_COND :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, FRV_OPERAND_COND, &fields->f_cond);
+      break;
+    case FRV_OPERAND_D12 :
+      errmsg = parse_d12 (cd, strp, FRV_OPERAND_D12, &fields->f_d12);
+      break;
+    case FRV_OPERAND_DEBUG :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, FRV_OPERAND_DEBUG, &fields->f_debug);
+      break;
+    case FRV_OPERAND_EIR :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, FRV_OPERAND_EIR, &fields->f_eir);
+      break;
+    case FRV_OPERAND_HINT :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, FRV_OPERAND_HINT, &fields->f_hint);
+      break;
+    case FRV_OPERAND_HINT_NOT_TAKEN :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_h_hint_not_taken, & fields->f_hint);
+      break;
+    case FRV_OPERAND_HINT_TAKEN :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_h_hint_taken, & fields->f_hint);
+      break;
+    case FRV_OPERAND_LABEL16 :
+      {
+        bfd_vma value;
+        errmsg = cgen_parse_address (cd, strp, FRV_OPERAND_LABEL16, 0, NULL,  & value);
+        fields->f_label16 = value;
+      }
+      break;
+    case FRV_OPERAND_LABEL24 :
+      {
+        bfd_vma value;
+        errmsg = cgen_parse_address (cd, strp, FRV_OPERAND_LABEL24, 0, NULL,  & value);
+        fields->f_label24 = value;
+      }
+      break;
+    case FRV_OPERAND_LOCK :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, FRV_OPERAND_LOCK, &fields->f_lock);
+      break;
+    case FRV_OPERAND_PACK :
+      errmsg = cgen_parse_keyword (cd, strp, & frv_cgen_opval_h_pack, & fields->f_pack);
+      break;
+    case FRV_OPERAND_S10 :
+      errmsg = cgen_parse_signed_integer (cd, strp, FRV_OPERAND_S10, &fields->f_s10);
+      break;
+    case FRV_OPERAND_S12 :
+      errmsg = parse_s12 (cd, strp, FRV_OPERAND_S12, &fields->f_d12);
+      break;
+    case FRV_OPERAND_S16 :
+      errmsg = cgen_parse_signed_integer (cd, strp, FRV_OPERAND_S16, &fields->f_s16);
+      break;
+    case FRV_OPERAND_S5 :
+      errmsg = cgen_parse_signed_integer (cd, strp, FRV_OPERAND_S5, &fields->f_s5);
+      break;
+    case FRV_OPERAND_S6 :
+      errmsg = cgen_parse_signed_integer (cd, strp, FRV_OPERAND_S6, &fields->f_s6);
+      break;
+    case FRV_OPERAND_S6_1 :
+      errmsg = cgen_parse_signed_integer (cd, strp, FRV_OPERAND_S6_1, &fields->f_s6_1);
+      break;
+    case FRV_OPERAND_SLO16 :
+      errmsg = parse_uslo16 (cd, strp, FRV_OPERAND_SLO16, &fields->f_s16);
+      break;
+    case FRV_OPERAND_SPR :
+      errmsg = parse_spr (cd, strp, & frv_cgen_opval_spr_names, & fields->f_spr);
+      break;
+    case FRV_OPERAND_U12 :
+      errmsg = parse_u12 (cd, strp, FRV_OPERAND_U12, &fields->f_u12);
+      break;
+    case FRV_OPERAND_U16 :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, FRV_OPERAND_U16, &fields->f_u16);
+      break;
+    case FRV_OPERAND_U6 :
+      errmsg = cgen_parse_unsigned_integer (cd, strp, FRV_OPERAND_U6, &fields->f_u6);
+      break;
+    case FRV_OPERAND_UHI16 :
+      errmsg = parse_uhi16 (cd, strp, FRV_OPERAND_UHI16, &fields->f_u16);
+      break;
+    case FRV_OPERAND_ULO16 :
+      errmsg = parse_ulo16 (cd, strp, FRV_OPERAND_ULO16, &fields->f_u16);
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex);
+      abort ();
+  }
+
+  return errmsg;
+}
+
+cgen_parse_fn * const frv_cgen_parse_handlers[] = 
+{
+  parse_insn_normal,
+};
+
+void
+frv_cgen_init_asm (cd)
+     CGEN_CPU_DESC cd;
+{
+  frv_cgen_init_opcode_table (cd);
+  frv_cgen_init_ibld_table (cd);
+  cd->parse_handlers = & frv_cgen_parse_handlers[0];
+  cd->parse_operand = frv_cgen_parse_operand;
+}
+
+
+
+/* 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 frv_cgen_assemble_insn
+
+   Returns NULL for success, an error message for failure.  */
+
+char * 
+frv_cgen_build_insn_regex (insn)
+     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 (cd, insn, strp, fields)
+     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 *
+frv_cgen_assemble_insn (cd, str, fields, buf, errmsg)
+     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 (! frv_cgen_insn_supported (cd, insn))
+	continue;
+#endif
+      /* If the RELAX 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_RELAX) != 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;
+  }
+}
+
+#if 0 /* This calls back to GAS which we can't do without care.  */
+
+/* Record each member of OPVALS in the assembler's symbol table.
+   This lets GAS parse registers for us.
+   ??? Interesting idea but not currently used.  */
+
+/* Record each member of OPVALS in the assembler's symbol table.
+   FIXME: Not currently used.  */
+
+void
+frv_cgen_asm_hash_keywords (cd, opvals)
+     CGEN_CPU_DESC cd;
+     CGEN_KEYWORD *opvals;
+{
+  CGEN_KEYWORD_SEARCH search = cgen_keyword_search_init (opvals, NULL);
+  const CGEN_KEYWORD_ENTRY * ke;
+
+  while ((ke = cgen_keyword_search_next (& search)) != NULL)
+    {
+#if 0 /* Unnecessary, should be done in the search routine.  */
+      if (! frv_cgen_opval_supported (ke))
+	continue;
+#endif
+      cgen_asm_record_register (cd, ke->name, ke->value);
+    }
+}
+
+#endif /* 0 */
diff --git a/opcodes/frv-desc.c b/opcodes/frv-desc.c
new file mode 100644
index 00000000000..8b8274c99ec
--- /dev/null
+++ b/opcodes/frv-desc.c
@@ -0,0 +1,6311 @@
+/* CPU data for frv.
+
+THIS FILE IS MACHINE GENERATED WITH CGEN.
+
+Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+
+This file is part of the GNU Binutils and/or GDB, the GNU debugger.
+
+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, 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 "sysdep.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include "ansidecl.h"
+#include "bfd.h"
+#include "symcat.h"
+#include "frv-desc.h"
+#include "frv-opc.h"
+#include "opintl.h"
+#include "libiberty.h"
+
+/* Attributes.  */
+
+static const CGEN_ATTR_ENTRY bool_attr[] =
+{
+  { "#f", 0 },
+  { "#t", 1 },
+  { 0, 0 }
+};
+
+static const CGEN_ATTR_ENTRY MACH_attr[] =
+{
+  { "base", MACH_BASE },
+  { "frv", MACH_FRV },
+  { "fr500", MACH_FR500 },
+  { "fr400", MACH_FR400 },
+  { "tomcat", MACH_TOMCAT },
+  { "simple", MACH_SIMPLE },
+  { "max", MACH_MAX },
+  { 0, 0 }
+};
+
+static const CGEN_ATTR_ENTRY ISA_attr[] =
+{
+  { "frv", ISA_FRV },
+  { "max", ISA_MAX },
+  { 0, 0 }
+};
+
+static const CGEN_ATTR_ENTRY UNIT_attr[] =
+{
+  { "NIL", UNIT_NIL },
+  { "I0", UNIT_I0 },
+  { "I1", UNIT_I1 },
+  { "I01", UNIT_I01 },
+  { "FM0", UNIT_FM0 },
+  { "FM1", UNIT_FM1 },
+  { "FM01", UNIT_FM01 },
+  { "B0", UNIT_B0 },
+  { "B1", UNIT_B1 },
+  { "B01", UNIT_B01 },
+  { "C", UNIT_C },
+  { "MULT_DIV", UNIT_MULT_DIV },
+  { "LOAD", UNIT_LOAD },
+  { "NUM_UNITS", UNIT_NUM_UNITS },
+  { 0, 0 }
+};
+
+static const CGEN_ATTR_ENTRY FR400_MAJOR_attr[] =
+{
+  { "NONE", FR400_MAJOR_NONE },
+  { "I_1", FR400_MAJOR_I_1 },
+  { "I_2", FR400_MAJOR_I_2 },
+  { "I_3", FR400_MAJOR_I_3 },
+  { "I_4", FR400_MAJOR_I_4 },
+  { "I_5", FR400_MAJOR_I_5 },
+  { "B_1", FR400_MAJOR_B_1 },
+  { "B_2", FR400_MAJOR_B_2 },
+  { "B_3", FR400_MAJOR_B_3 },
+  { "B_4", FR400_MAJOR_B_4 },
+  { "B_5", FR400_MAJOR_B_5 },
+  { "B_6", FR400_MAJOR_B_6 },
+  { "C_1", FR400_MAJOR_C_1 },
+  { "C_2", FR400_MAJOR_C_2 },
+  { "M_1", FR400_MAJOR_M_1 },
+  { "M_2", FR400_MAJOR_M_2 },
+  { 0, 0 }
+};
+
+static const CGEN_ATTR_ENTRY FR500_MAJOR_attr[] =
+{
+  { "NONE", FR500_MAJOR_NONE },
+  { "I_1", FR500_MAJOR_I_1 },
+  { "I_2", FR500_MAJOR_I_2 },
+  { "I_3", FR500_MAJOR_I_3 },
+  { "I_4", FR500_MAJOR_I_4 },
+  { "I_5", FR500_MAJOR_I_5 },
+  { "I_6", FR500_MAJOR_I_6 },
+  { "B_1", FR500_MAJOR_B_1 },
+  { "B_2", FR500_MAJOR_B_2 },
+  { "B_3", FR500_MAJOR_B_3 },
+  { "B_4", FR500_MAJOR_B_4 },
+  { "B_5", FR500_MAJOR_B_5 },
+  { "B_6", FR500_MAJOR_B_6 },
+  { "C_1", FR500_MAJOR_C_1 },
+  { "C_2", FR500_MAJOR_C_2 },
+  { "F_1", FR500_MAJOR_F_1 },
+  { "F_2", FR500_MAJOR_F_2 },
+  { "F_3", FR500_MAJOR_F_3 },
+  { "F_4", FR500_MAJOR_F_4 },
+  { "F_5", FR500_MAJOR_F_5 },
+  { "F_6", FR500_MAJOR_F_6 },
+  { "F_7", FR500_MAJOR_F_7 },
+  { "F_8", FR500_MAJOR_F_8 },
+  { "M_1", FR500_MAJOR_M_1 },
+  { "M_2", FR500_MAJOR_M_2 },
+  { "M_3", FR500_MAJOR_M_3 },
+  { "M_4", FR500_MAJOR_M_4 },
+  { "M_5", FR500_MAJOR_M_5 },
+  { "M_6", FR500_MAJOR_M_6 },
+  { "M_7", FR500_MAJOR_M_7 },
+  { "M_8", FR500_MAJOR_M_8 },
+  { 0, 0 }
+};
+
+const CGEN_ATTR_TABLE frv_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 frv_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 frv_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] },
+  { "HASH-PREFIX", &bool_attr[0], &bool_attr[0] },
+  { 0, 0, 0 }
+};
+
+const CGEN_ATTR_TABLE frv_cgen_insn_attr_table[] =
+{
+  { "MACH", & MACH_attr[0], & MACH_attr[0] },
+  { "UNIT", & UNIT_attr[0], & UNIT_attr[0] },
+  { "FR400-MAJOR", & FR400_MAJOR_attr[0], & FR400_MAJOR_attr[0] },
+  { "FR500-MAJOR", & FR500_MAJOR_attr[0], & FR500_MAJOR_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] },
+  { "RELAX", &bool_attr[0], &bool_attr[0] },
+  { "NO-DIS", &bool_attr[0], &bool_attr[0] },
+  { "PBB", &bool_attr[0], &bool_attr[0] },
+  { "PRIVILEGED", &bool_attr[0], &bool_attr[0] },
+  { "NON-EXCEPTING", &bool_attr[0], &bool_attr[0] },
+  { "CONDITIONAL", &bool_attr[0], &bool_attr[0] },
+  { "FR-ACCESS", &bool_attr[0], &bool_attr[0] },
+  { "PRESERVE-OVF", &bool_attr[0], &bool_attr[0] },
+  { 0, 0, 0 }
+};
+
+/* Instruction set variants.  */
+
+static const CGEN_ISA frv_cgen_isa_table[] = {
+  { "frv", 32, 32, 32, 32 },
+  { 0, 0, 0, 0, 0 }
+};
+
+/* Machine variants.  */
+
+static const CGEN_MACH frv_cgen_mach_table[] = {
+  { "frv", "frv", MACH_FRV, 0 },
+  { "fr500", "fr500", MACH_FR500, 0 },
+  { "tomcat", "tomcat", MACH_TOMCAT, 0 },
+  { "fr400", "fr400", MACH_FR400, 0 },
+  { "simple", "simple", MACH_SIMPLE, 0 },
+  { 0, 0, 0, 0 }
+};
+
+static CGEN_KEYWORD_ENTRY frv_cgen_opval_gr_names_entries[] =
+{
+  { "sp", 1, {0, {0}}, 0, 0 },
+  { "fp", 2, {0, {0}}, 0, 0 },
+  { "gr0", 0, {0, {0}}, 0, 0 },
+  { "gr1", 1, {0, {0}}, 0, 0 },
+  { "gr2", 2, {0, {0}}, 0, 0 },
+  { "gr3", 3, {0, {0}}, 0, 0 },
+  { "gr4", 4, {0, {0}}, 0, 0 },
+  { "gr5", 5, {0, {0}}, 0, 0 },
+  { "gr6", 6, {0, {0}}, 0, 0 },
+  { "gr7", 7, {0, {0}}, 0, 0 },
+  { "gr8", 8, {0, {0}}, 0, 0 },
+  { "gr9", 9, {0, {0}}, 0, 0 },
+  { "gr10", 10, {0, {0}}, 0, 0 },
+  { "gr11", 11, {0, {0}}, 0, 0 },
+  { "gr12", 12, {0, {0}}, 0, 0 },
+  { "gr13", 13, {0, {0}}, 0, 0 },
+  { "gr14", 14, {0, {0}}, 0, 0 },
+  { "gr15", 15, {0, {0}}, 0, 0 },
+  { "gr16", 16, {0, {0}}, 0, 0 },
+  { "gr17", 17, {0, {0}}, 0, 0 },
+  { "gr18", 18, {0, {0}}, 0, 0 },
+  { "gr19", 19, {0, {0}}, 0, 0 },
+  { "gr20", 20, {0, {0}}, 0, 0 },
+  { "gr21", 21, {0, {0}}, 0, 0 },
+  { "gr22", 22, {0, {0}}, 0, 0 },
+  { "gr23", 23, {0, {0}}, 0, 0 },
+  { "gr24", 24, {0, {0}}, 0, 0 },
+  { "gr25", 25, {0, {0}}, 0, 0 },
+  { "gr26", 26, {0, {0}}, 0, 0 },
+  { "gr27", 27, {0, {0}}, 0, 0 },
+  { "gr28", 28, {0, {0}}, 0, 0 },
+  { "gr29", 29, {0, {0}}, 0, 0 },
+  { "gr30", 30, {0, {0}}, 0, 0 },
+  { "gr31", 31, {0, {0}}, 0, 0 },
+  { "gr32", 32, {0, {0}}, 0, 0 },
+  { "gr33", 33, {0, {0}}, 0, 0 },
+  { "gr34", 34, {0, {0}}, 0, 0 },
+  { "gr35", 35, {0, {0}}, 0, 0 },
+  { "gr36", 36, {0, {0}}, 0, 0 },
+  { "gr37", 37, {0, {0}}, 0, 0 },
+  { "gr38", 38, {0, {0}}, 0, 0 },
+  { "gr39", 39, {0, {0}}, 0, 0 },
+  { "gr40", 40, {0, {0}}, 0, 0 },
+  { "gr41", 41, {0, {0}}, 0, 0 },
+  { "gr42", 42, {0, {0}}, 0, 0 },
+  { "gr43", 43, {0, {0}}, 0, 0 },
+  { "gr44", 44, {0, {0}}, 0, 0 },
+  { "gr45", 45, {0, {0}}, 0, 0 },
+  { "gr46", 46, {0, {0}}, 0, 0 },
+  { "gr47", 47, {0, {0}}, 0, 0 },
+  { "gr48", 48, {0, {0}}, 0, 0 },
+  { "gr49", 49, {0, {0}}, 0, 0 },
+  { "gr50", 50, {0, {0}}, 0, 0 },
+  { "gr51", 51, {0, {0}}, 0, 0 },
+  { "gr52", 52, {0, {0}}, 0, 0 },
+  { "gr53", 53, {0, {0}}, 0, 0 },
+  { "gr54", 54, {0, {0}}, 0, 0 },
+  { "gr55", 55, {0, {0}}, 0, 0 },
+  { "gr56", 56, {0, {0}}, 0, 0 },
+  { "gr57", 57, {0, {0}}, 0, 0 },
+  { "gr58", 58, {0, {0}}, 0, 0 },
+  { "gr59", 59, {0, {0}}, 0, 0 },
+  { "gr60", 60, {0, {0}}, 0, 0 },
+  { "gr61", 61, {0, {0}}, 0, 0 },
+  { "gr62", 62, {0, {0}}, 0, 0 },
+  { "gr63", 63, {0, {0}}, 0, 0 }
+};
+
+CGEN_KEYWORD frv_cgen_opval_gr_names =
+{
+  & frv_cgen_opval_gr_names_entries[0],
+  66,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY frv_cgen_opval_fr_names_entries[] =
+{
+  { "fr0", 0, {0, {0}}, 0, 0 },
+  { "fr1", 1, {0, {0}}, 0, 0 },
+  { "fr2", 2, {0, {0}}, 0, 0 },
+  { "fr3", 3, {0, {0}}, 0, 0 },
+  { "fr4", 4, {0, {0}}, 0, 0 },
+  { "fr5", 5, {0, {0}}, 0, 0 },
+  { "fr6", 6, {0, {0}}, 0, 0 },
+  { "fr7", 7, {0, {0}}, 0, 0 },
+  { "fr8", 8, {0, {0}}, 0, 0 },
+  { "fr9", 9, {0, {0}}, 0, 0 },
+  { "fr10", 10, {0, {0}}, 0, 0 },
+  { "fr11", 11, {0, {0}}, 0, 0 },
+  { "fr12", 12, {0, {0}}, 0, 0 },
+  { "fr13", 13, {0, {0}}, 0, 0 },
+  { "fr14", 14, {0, {0}}, 0, 0 },
+  { "fr15", 15, {0, {0}}, 0, 0 },
+  { "fr16", 16, {0, {0}}, 0, 0 },
+  { "fr17", 17, {0, {0}}, 0, 0 },
+  { "fr18", 18, {0, {0}}, 0, 0 },
+  { "fr19", 19, {0, {0}}, 0, 0 },
+  { "fr20", 20, {0, {0}}, 0, 0 },
+  { "fr21", 21, {0, {0}}, 0, 0 },
+  { "fr22", 22, {0, {0}}, 0, 0 },
+  { "fr23", 23, {0, {0}}, 0, 0 },
+  { "fr24", 24, {0, {0}}, 0, 0 },
+  { "fr25", 25, {0, {0}}, 0, 0 },
+  { "fr26", 26, {0, {0}}, 0, 0 },
+  { "fr27", 27, {0, {0}}, 0, 0 },
+  { "fr28", 28, {0, {0}}, 0, 0 },
+  { "fr29", 29, {0, {0}}, 0, 0 },
+  { "fr30", 30, {0, {0}}, 0, 0 },
+  { "fr31", 31, {0, {0}}, 0, 0 },
+  { "fr32", 32, {0, {0}}, 0, 0 },
+  { "fr33", 33, {0, {0}}, 0, 0 },
+  { "fr34", 34, {0, {0}}, 0, 0 },
+  { "fr35", 35, {0, {0}}, 0, 0 },
+  { "fr36", 36, {0, {0}}, 0, 0 },
+  { "fr37", 37, {0, {0}}, 0, 0 },
+  { "fr38", 38, {0, {0}}, 0, 0 },
+  { "fr39", 39, {0, {0}}, 0, 0 },
+  { "fr40", 40, {0, {0}}, 0, 0 },
+  { "fr41", 41, {0, {0}}, 0, 0 },
+  { "fr42", 42, {0, {0}}, 0, 0 },
+  { "fr43", 43, {0, {0}}, 0, 0 },
+  { "fr44", 44, {0, {0}}, 0, 0 },
+  { "fr45", 45, {0, {0}}, 0, 0 },
+  { "fr46", 46, {0, {0}}, 0, 0 },
+  { "fr47", 47, {0, {0}}, 0, 0 },
+  { "fr48", 48, {0, {0}}, 0, 0 },
+  { "fr49", 49, {0, {0}}, 0, 0 },
+  { "fr50", 50, {0, {0}}, 0, 0 },
+  { "fr51", 51, {0, {0}}, 0, 0 },
+  { "fr52", 52, {0, {0}}, 0, 0 },
+  { "fr53", 53, {0, {0}}, 0, 0 },
+  { "fr54", 54, {0, {0}}, 0, 0 },
+  { "fr55", 55, {0, {0}}, 0, 0 },
+  { "fr56", 56, {0, {0}}, 0, 0 },
+  { "fr57", 57, {0, {0}}, 0, 0 },
+  { "fr58", 58, {0, {0}}, 0, 0 },
+  { "fr59", 59, {0, {0}}, 0, 0 },
+  { "fr60", 60, {0, {0}}, 0, 0 },
+  { "fr61", 61, {0, {0}}, 0, 0 },
+  { "fr62", 62, {0, {0}}, 0, 0 },
+  { "fr63", 63, {0, {0}}, 0, 0 }
+};
+
+CGEN_KEYWORD frv_cgen_opval_fr_names =
+{
+  & frv_cgen_opval_fr_names_entries[0],
+  64,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY frv_cgen_opval_cpr_names_entries[] =
+{
+  { "cpr0", 0, {0, {0}}, 0, 0 },
+  { "cpr1", 1, {0, {0}}, 0, 0 },
+  { "cpr2", 2, {0, {0}}, 0, 0 },
+  { "cpr3", 3, {0, {0}}, 0, 0 },
+  { "cpr4", 4, {0, {0}}, 0, 0 },
+  { "cpr5", 5, {0, {0}}, 0, 0 },
+  { "cpr6", 6, {0, {0}}, 0, 0 },
+  { "cpr7", 7, {0, {0}}, 0, 0 },
+  { "cpr8", 8, {0, {0}}, 0, 0 },
+  { "cpr9", 9, {0, {0}}, 0, 0 },
+  { "cpr10", 10, {0, {0}}, 0, 0 },
+  { "cpr11", 11, {0, {0}}, 0, 0 },
+  { "cpr12", 12, {0, {0}}, 0, 0 },
+  { "cpr13", 13, {0, {0}}, 0, 0 },
+  { "cpr14", 14, {0, {0}}, 0, 0 },
+  { "cpr15", 15, {0, {0}}, 0, 0 },
+  { "cpr16", 16, {0, {0}}, 0, 0 },
+  { "cpr17", 17, {0, {0}}, 0, 0 },
+  { "cpr18", 18, {0, {0}}, 0, 0 },
+  { "cpr19", 19, {0, {0}}, 0, 0 },
+  { "cpr20", 20, {0, {0}}, 0, 0 },
+  { "cpr21", 21, {0, {0}}, 0, 0 },
+  { "cpr22", 22, {0, {0}}, 0, 0 },
+  { "cpr23", 23, {0, {0}}, 0, 0 },
+  { "cpr24", 24, {0, {0}}, 0, 0 },
+  { "cpr25", 25, {0, {0}}, 0, 0 },
+  { "cpr26", 26, {0, {0}}, 0, 0 },
+  { "cpr27", 27, {0, {0}}, 0, 0 },
+  { "cpr28", 28, {0, {0}}, 0, 0 },
+  { "cpr29", 29, {0, {0}}, 0, 0 },
+  { "cpr30", 30, {0, {0}}, 0, 0 },
+  { "cpr31", 31, {0, {0}}, 0, 0 },
+  { "cpr32", 32, {0, {0}}, 0, 0 },
+  { "cpr33", 33, {0, {0}}, 0, 0 },
+  { "cpr34", 34, {0, {0}}, 0, 0 },
+  { "cpr35", 35, {0, {0}}, 0, 0 },
+  { "cpr36", 36, {0, {0}}, 0, 0 },
+  { "cpr37", 37, {0, {0}}, 0, 0 },
+  { "cpr38", 38, {0, {0}}, 0, 0 },
+  { "cpr39", 39, {0, {0}}, 0, 0 },
+  { "cpr40", 40, {0, {0}}, 0, 0 },
+  { "cpr41", 41, {0, {0}}, 0, 0 },
+  { "cpr42", 42, {0, {0}}, 0, 0 },
+  { "cpr43", 43, {0, {0}}, 0, 0 },
+  { "cpr44", 44, {0, {0}}, 0, 0 },
+  { "cpr45", 45, {0, {0}}, 0, 0 },
+  { "cpr46", 46, {0, {0}}, 0, 0 },
+  { "cpr47", 47, {0, {0}}, 0, 0 },
+  { "cpr48", 48, {0, {0}}, 0, 0 },
+  { "cpr49", 49, {0, {0}}, 0, 0 },
+  { "cpr50", 50, {0, {0}}, 0, 0 },
+  { "cpr51", 51, {0, {0}}, 0, 0 },
+  { "cpr52", 52, {0, {0}}, 0, 0 },
+  { "cpr53", 53, {0, {0}}, 0, 0 },
+  { "cpr54", 54, {0, {0}}, 0, 0 },
+  { "cpr55", 55, {0, {0}}, 0, 0 },
+  { "cpr56", 56, {0, {0}}, 0, 0 },
+  { "cpr57", 57, {0, {0}}, 0, 0 },
+  { "cpr58", 58, {0, {0}}, 0, 0 },
+  { "cpr59", 59, {0, {0}}, 0, 0 },
+  { "cpr60", 60, {0, {0}}, 0, 0 },
+  { "cpr61", 61, {0, {0}}, 0, 0 },
+  { "cpr62", 62, {0, {0}}, 0, 0 },
+  { "cpr63", 63, {0, {0}}, 0, 0 }
+};
+
+CGEN_KEYWORD frv_cgen_opval_cpr_names =
+{
+  & frv_cgen_opval_cpr_names_entries[0],
+  64,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY frv_cgen_opval_spr_names_entries[] =
+{
+  { "psr", 0, {0, {0}}, 0, 0 },
+  { "pcsr", 1, {0, {0}}, 0, 0 },
+  { "bpcsr", 2, {0, {0}}, 0, 0 },
+  { "tbr", 3, {0, {0}}, 0, 0 },
+  { "bpsr", 4, {0, {0}}, 0, 0 },
+  { "hsr0", 16, {0, {0}}, 0, 0 },
+  { "hsr1", 17, {0, {0}}, 0, 0 },
+  { "hsr2", 18, {0, {0}}, 0, 0 },
+  { "hsr3", 19, {0, {0}}, 0, 0 },
+  { "hsr4", 20, {0, {0}}, 0, 0 },
+  { "hsr5", 21, {0, {0}}, 0, 0 },
+  { "hsr6", 22, {0, {0}}, 0, 0 },
+  { "hsr7", 23, {0, {0}}, 0, 0 },
+  { "hsr8", 24, {0, {0}}, 0, 0 },
+  { "hsr9", 25, {0, {0}}, 0, 0 },
+  { "hsr10", 26, {0, {0}}, 0, 0 },
+  { "hsr11", 27, {0, {0}}, 0, 0 },
+  { "hsr12", 28, {0, {0}}, 0, 0 },
+  { "hsr13", 29, {0, {0}}, 0, 0 },
+  { "hsr14", 30, {0, {0}}, 0, 0 },
+  { "hsr15", 31, {0, {0}}, 0, 0 },
+  { "hsr16", 32, {0, {0}}, 0, 0 },
+  { "hsr17", 33, {0, {0}}, 0, 0 },
+  { "hsr18", 34, {0, {0}}, 0, 0 },
+  { "hsr19", 35, {0, {0}}, 0, 0 },
+  { "hsr20", 36, {0, {0}}, 0, 0 },
+  { "hsr21", 37, {0, {0}}, 0, 0 },
+  { "hsr22", 38, {0, {0}}, 0, 0 },
+  { "hsr23", 39, {0, {0}}, 0, 0 },
+  { "hsr24", 40, {0, {0}}, 0, 0 },
+  { "hsr25", 41, {0, {0}}, 0, 0 },
+  { "hsr26", 42, {0, {0}}, 0, 0 },
+  { "hsr27", 43, {0, {0}}, 0, 0 },
+  { "hsr28", 44, {0, {0}}, 0, 0 },
+  { "hsr29", 45, {0, {0}}, 0, 0 },
+  { "hsr30", 46, {0, {0}}, 0, 0 },
+  { "hsr31", 47, {0, {0}}, 0, 0 },
+  { "hsr32", 48, {0, {0}}, 0, 0 },
+  { "hsr33", 49, {0, {0}}, 0, 0 },
+  { "hsr34", 50, {0, {0}}, 0, 0 },
+  { "hsr35", 51, {0, {0}}, 0, 0 },
+  { "hsr36", 52, {0, {0}}, 0, 0 },
+  { "hsr37", 53, {0, {0}}, 0, 0 },
+  { "hsr38", 54, {0, {0}}, 0, 0 },
+  { "hsr39", 55, {0, {0}}, 0, 0 },
+  { "hsr40", 56, {0, {0}}, 0, 0 },
+  { "hsr41", 57, {0, {0}}, 0, 0 },
+  { "hsr42", 58, {0, {0}}, 0, 0 },
+  { "hsr43", 59, {0, {0}}, 0, 0 },
+  { "hsr44", 60, {0, {0}}, 0, 0 },
+  { "hsr45", 61, {0, {0}}, 0, 0 },
+  { "hsr46", 62, {0, {0}}, 0, 0 },
+  { "hsr47", 63, {0, {0}}, 0, 0 },
+  { "hsr48", 64, {0, {0}}, 0, 0 },
+  { "hsr49", 65, {0, {0}}, 0, 0 },
+  { "hsr50", 66, {0, {0}}, 0, 0 },
+  { "hsr51", 67, {0, {0}}, 0, 0 },
+  { "hsr52", 68, {0, {0}}, 0, 0 },
+  { "hsr53", 69, {0, {0}}, 0, 0 },
+  { "hsr54", 70, {0, {0}}, 0, 0 },
+  { "hsr55", 71, {0, {0}}, 0, 0 },
+  { "hsr56", 72, {0, {0}}, 0, 0 },
+  { "hsr57", 73, {0, {0}}, 0, 0 },
+  { "hsr58", 74, {0, {0}}, 0, 0 },
+  { "hsr59", 75, {0, {0}}, 0, 0 },
+  { "hsr60", 76, {0, {0}}, 0, 0 },
+  { "hsr61", 77, {0, {0}}, 0, 0 },
+  { "hsr62", 78, {0, {0}}, 0, 0 },
+  { "hsr63", 79, {0, {0}}, 0, 0 },
+  { "ccr", 256, {0, {0}}, 0, 0 },
+  { "cccr", 263, {0, {0}}, 0, 0 },
+  { "lr", 272, {0, {0}}, 0, 0 },
+  { "lcr", 273, {0, {0}}, 0, 0 },
+  { "isr", 288, {0, {0}}, 0, 0 },
+  { "neear0", 352, {0, {0}}, 0, 0 },
+  { "neear1", 353, {0, {0}}, 0, 0 },
+  { "neear2", 354, {0, {0}}, 0, 0 },
+  { "neear3", 355, {0, {0}}, 0, 0 },
+  { "neear4", 356, {0, {0}}, 0, 0 },
+  { "neear5", 357, {0, {0}}, 0, 0 },
+  { "neear6", 358, {0, {0}}, 0, 0 },
+  { "neear7", 359, {0, {0}}, 0, 0 },
+  { "neear8", 360, {0, {0}}, 0, 0 },
+  { "neear9", 361, {0, {0}}, 0, 0 },
+  { "neear10", 362, {0, {0}}, 0, 0 },
+  { "neear11", 363, {0, {0}}, 0, 0 },
+  { "neear12", 364, {0, {0}}, 0, 0 },
+  { "neear13", 365, {0, {0}}, 0, 0 },
+  { "neear14", 366, {0, {0}}, 0, 0 },
+  { "neear15", 367, {0, {0}}, 0, 0 },
+  { "neear16", 368, {0, {0}}, 0, 0 },
+  { "neear17", 369, {0, {0}}, 0, 0 },
+  { "neear18", 370, {0, {0}}, 0, 0 },
+  { "neear19", 371, {0, {0}}, 0, 0 },
+  { "neear20", 372, {0, {0}}, 0, 0 },
+  { "neear21", 373, {0, {0}}, 0, 0 },
+  { "neear22", 374, {0, {0}}, 0, 0 },
+  { "neear23", 375, {0, {0}}, 0, 0 },
+  { "neear24", 376, {0, {0}}, 0, 0 },
+  { "neear25", 377, {0, {0}}, 0, 0 },
+  { "neear26", 378, {0, {0}}, 0, 0 },
+  { "neear27", 379, {0, {0}}, 0, 0 },
+  { "neear28", 380, {0, {0}}, 0, 0 },
+  { "neear29", 381, {0, {0}}, 0, 0 },
+  { "neear30", 382, {0, {0}}, 0, 0 },
+  { "neear31", 383, {0, {0}}, 0, 0 },
+  { "nesr0", 384, {0, {0}}, 0, 0 },
+  { "nesr1", 385, {0, {0}}, 0, 0 },
+  { "nesr2", 386, {0, {0}}, 0, 0 },
+  { "nesr3", 387, {0, {0}}, 0, 0 },
+  { "nesr4", 388, {0, {0}}, 0, 0 },
+  { "nesr5", 389, {0, {0}}, 0, 0 },
+  { "nesr6", 390, {0, {0}}, 0, 0 },
+  { "nesr7", 391, {0, {0}}, 0, 0 },
+  { "nesr8", 392, {0, {0}}, 0, 0 },
+  { "nesr9", 393, {0, {0}}, 0, 0 },
+  { "nesr10", 394, {0, {0}}, 0, 0 },
+  { "nesr11", 395, {0, {0}}, 0, 0 },
+  { "nesr12", 396, {0, {0}}, 0, 0 },
+  { "nesr13", 397, {0, {0}}, 0, 0 },
+  { "nesr14", 398, {0, {0}}, 0, 0 },
+  { "nesr15", 399, {0, {0}}, 0, 0 },
+  { "nesr16", 400, {0, {0}}, 0, 0 },
+  { "nesr17", 401, {0, {0}}, 0, 0 },
+  { "nesr18", 402, {0, {0}}, 0, 0 },
+  { "nesr19", 403, {0, {0}}, 0, 0 },
+  { "nesr20", 404, {0, {0}}, 0, 0 },
+  { "nesr21", 405, {0, {0}}, 0, 0 },
+  { "nesr22", 406, {0, {0}}, 0, 0 },
+  { "nesr23", 407, {0, {0}}, 0, 0 },
+  { "nesr24", 408, {0, {0}}, 0, 0 },
+  { "nesr25", 409, {0, {0}}, 0, 0 },
+  { "nesr26", 410, {0, {0}}, 0, 0 },
+  { "nesr27", 411, {0, {0}}, 0, 0 },
+  { "nesr28", 412, {0, {0}}, 0, 0 },
+  { "nesr29", 413, {0, {0}}, 0, 0 },
+  { "nesr30", 414, {0, {0}}, 0, 0 },
+  { "nesr31", 415, {0, {0}}, 0, 0 },
+  { "necr", 416, {0, {0}}, 0, 0 },
+  { "gner0", 432, {0, {0}}, 0, 0 },
+  { "gner1", 433, {0, {0}}, 0, 0 },
+  { "fner0", 434, {0, {0}}, 0, 0 },
+  { "fner1", 435, {0, {0}}, 0, 0 },
+  { "epcr0", 512, {0, {0}}, 0, 0 },
+  { "epcr1", 513, {0, {0}}, 0, 0 },
+  { "epcr2", 514, {0, {0}}, 0, 0 },
+  { "epcr3", 515, {0, {0}}, 0, 0 },
+  { "epcr4", 516, {0, {0}}, 0, 0 },
+  { "epcr5", 517, {0, {0}}, 0, 0 },
+  { "epcr6", 518, {0, {0}}, 0, 0 },
+  { "epcr7", 519, {0, {0}}, 0, 0 },
+  { "epcr8", 520, {0, {0}}, 0, 0 },
+  { "epcr9", 521, {0, {0}}, 0, 0 },
+  { "epcr10", 522, {0, {0}}, 0, 0 },
+  { "epcr11", 523, {0, {0}}, 0, 0 },
+  { "epcr12", 524, {0, {0}}, 0, 0 },
+  { "epcr13", 525, {0, {0}}, 0, 0 },
+  { "epcr14", 526, {0, {0}}, 0, 0 },
+  { "epcr15", 527, {0, {0}}, 0, 0 },
+  { "epcr16", 528, {0, {0}}, 0, 0 },
+  { "epcr17", 529, {0, {0}}, 0, 0 },
+  { "epcr18", 530, {0, {0}}, 0, 0 },
+  { "epcr19", 531, {0, {0}}, 0, 0 },
+  { "epcr20", 532, {0, {0}}, 0, 0 },
+  { "epcr21", 533, {0, {0}}, 0, 0 },
+  { "epcr22", 534, {0, {0}}, 0, 0 },
+  { "epcr23", 535, {0, {0}}, 0, 0 },
+  { "epcr24", 536, {0, {0}}, 0, 0 },
+  { "epcr25", 537, {0, {0}}, 0, 0 },
+  { "epcr26", 538, {0, {0}}, 0, 0 },
+  { "epcr27", 539, {0, {0}}, 0, 0 },
+  { "epcr28", 540, {0, {0}}, 0, 0 },
+  { "epcr29", 541, {0, {0}}, 0, 0 },
+  { "epcr30", 542, {0, {0}}, 0, 0 },
+  { "epcr31", 543, {0, {0}}, 0, 0 },
+  { "epcr32", 544, {0, {0}}, 0, 0 },
+  { "epcr33", 545, {0, {0}}, 0, 0 },
+  { "epcr34", 546, {0, {0}}, 0, 0 },
+  { "epcr35", 547, {0, {0}}, 0, 0 },
+  { "epcr36", 548, {0, {0}}, 0, 0 },
+  { "epcr37", 549, {0, {0}}, 0, 0 },
+  { "epcr38", 550, {0, {0}}, 0, 0 },
+  { "epcr39", 551, {0, {0}}, 0, 0 },
+  { "epcr40", 552, {0, {0}}, 0, 0 },
+  { "epcr41", 553, {0, {0}}, 0, 0 },
+  { "epcr42", 554, {0, {0}}, 0, 0 },
+  { "epcr43", 555, {0, {0}}, 0, 0 },
+  { "epcr44", 556, {0, {0}}, 0, 0 },
+  { "epcr45", 557, {0, {0}}, 0, 0 },
+  { "epcr46", 558, {0, {0}}, 0, 0 },
+  { "epcr47", 559, {0, {0}}, 0, 0 },
+  { "epcr48", 560, {0, {0}}, 0, 0 },
+  { "epcr49", 561, {0, {0}}, 0, 0 },
+  { "epcr50", 562, {0, {0}}, 0, 0 },
+  { "epcr51", 563, {0, {0}}, 0, 0 },
+  { "epcr52", 564, {0, {0}}, 0, 0 },
+  { "epcr53", 565, {0, {0}}, 0, 0 },
+  { "epcr54", 566, {0, {0}}, 0, 0 },
+  { "epcr55", 567, {0, {0}}, 0, 0 },
+  { "epcr56", 568, {0, {0}}, 0, 0 },
+  { "epcr57", 569, {0, {0}}, 0, 0 },
+  { "epcr58", 570, {0, {0}}, 0, 0 },
+  { "epcr59", 571, {0, {0}}, 0, 0 },
+  { "epcr60", 572, {0, {0}}, 0, 0 },
+  { "epcr61", 573, {0, {0}}, 0, 0 },
+  { "epcr62", 574, {0, {0}}, 0, 0 },
+  { "epcr63", 575, {0, {0}}, 0, 0 },
+  { "esr0", 576, {0, {0}}, 0, 0 },
+  { "esr1", 577, {0, {0}}, 0, 0 },
+  { "esr2", 578, {0, {0}}, 0, 0 },
+  { "esr3", 579, {0, {0}}, 0, 0 },
+  { "esr4", 580, {0, {0}}, 0, 0 },
+  { "esr5", 581, {0, {0}}, 0, 0 },
+  { "esr6", 582, {0, {0}}, 0, 0 },
+  { "esr7", 583, {0, {0}}, 0, 0 },
+  { "esr8", 584, {0, {0}}, 0, 0 },
+  { "esr9", 585, {0, {0}}, 0, 0 },
+  { "esr10", 586, {0, {0}}, 0, 0 },
+  { "esr11", 587, {0, {0}}, 0, 0 },
+  { "esr12", 588, {0, {0}}, 0, 0 },
+  { "esr13", 589, {0, {0}}, 0, 0 },
+  { "esr14", 590, {0, {0}}, 0, 0 },
+  { "esr15", 591, {0, {0}}, 0, 0 },
+  { "esr16", 592, {0, {0}}, 0, 0 },
+  { "esr17", 593, {0, {0}}, 0, 0 },
+  { "esr18", 594, {0, {0}}, 0, 0 },
+  { "esr19", 595, {0, {0}}, 0, 0 },
+  { "esr20", 596, {0, {0}}, 0, 0 },
+  { "esr21", 597, {0, {0}}, 0, 0 },
+  { "esr22", 598, {0, {0}}, 0, 0 },
+  { "esr23", 599, {0, {0}}, 0, 0 },
+  { "esr24", 600, {0, {0}}, 0, 0 },
+  { "esr25", 601, {0, {0}}, 0, 0 },
+  { "esr26", 602, {0, {0}}, 0, 0 },
+  { "esr27", 603, {0, {0}}, 0, 0 },
+  { "esr28", 604, {0, {0}}, 0, 0 },
+  { "esr29", 605, {0, {0}}, 0, 0 },
+  { "esr30", 606, {0, {0}}, 0, 0 },
+  { "esr31", 607, {0, {0}}, 0, 0 },
+  { "esr32", 608, {0, {0}}, 0, 0 },
+  { "esr33", 609, {0, {0}}, 0, 0 },
+  { "esr34", 610, {0, {0}}, 0, 0 },
+  { "esr35", 611, {0, {0}}, 0, 0 },
+  { "esr36", 612, {0, {0}}, 0, 0 },
+  { "esr37", 613, {0, {0}}, 0, 0 },
+  { "esr38", 614, {0, {0}}, 0, 0 },
+  { "esr39", 615, {0, {0}}, 0, 0 },
+  { "esr40", 616, {0, {0}}, 0, 0 },
+  { "esr41", 617, {0, {0}}, 0, 0 },
+  { "esr42", 618, {0, {0}}, 0, 0 },
+  { "esr43", 619, {0, {0}}, 0, 0 },
+  { "esr44", 620, {0, {0}}, 0, 0 },
+  { "esr45", 621, {0, {0}}, 0, 0 },
+  { "esr46", 622, {0, {0}}, 0, 0 },
+  { "esr47", 623, {0, {0}}, 0, 0 },
+  { "esr48", 624, {0, {0}}, 0, 0 },
+  { "esr49", 625, {0, {0}}, 0, 0 },
+  { "esr50", 626, {0, {0}}, 0, 0 },
+  { "esr51", 627, {0, {0}}, 0, 0 },
+  { "esr52", 628, {0, {0}}, 0, 0 },
+  { "esr53", 629, {0, {0}}, 0, 0 },
+  { "esr54", 630, {0, {0}}, 0, 0 },
+  { "esr55", 631, {0, {0}}, 0, 0 },
+  { "esr56", 632, {0, {0}}, 0, 0 },
+  { "esr57", 633, {0, {0}}, 0, 0 },
+  { "esr58", 634, {0, {0}}, 0, 0 },
+  { "esr59", 635, {0, {0}}, 0, 0 },
+  { "esr60", 636, {0, {0}}, 0, 0 },
+  { "esr61", 637, {0, {0}}, 0, 0 },
+  { "esr62", 638, {0, {0}}, 0, 0 },
+  { "esr63", 639, {0, {0}}, 0, 0 },
+  { "eir0", 640, {0, {0}}, 0, 0 },
+  { "eir1", 641, {0, {0}}, 0, 0 },
+  { "eir2", 642, {0, {0}}, 0, 0 },
+  { "eir3", 643, {0, {0}}, 0, 0 },
+  { "eir4", 644, {0, {0}}, 0, 0 },
+  { "eir5", 645, {0, {0}}, 0, 0 },
+  { "eir6", 646, {0, {0}}, 0, 0 },
+  { "eir7", 647, {0, {0}}, 0, 0 },
+  { "eir8", 648, {0, {0}}, 0, 0 },
+  { "eir9", 649, {0, {0}}, 0, 0 },
+  { "eir10", 650, {0, {0}}, 0, 0 },
+  { "eir11", 651, {0, {0}}, 0, 0 },
+  { "eir12", 652, {0, {0}}, 0, 0 },
+  { "eir13", 653, {0, {0}}, 0, 0 },
+  { "eir14", 654, {0, {0}}, 0, 0 },
+  { "eir15", 655, {0, {0}}, 0, 0 },
+  { "eir16", 656, {0, {0}}, 0, 0 },
+  { "eir17", 657, {0, {0}}, 0, 0 },
+  { "eir18", 658, {0, {0}}, 0, 0 },
+  { "eir19", 659, {0, {0}}, 0, 0 },
+  { "eir20", 660, {0, {0}}, 0, 0 },
+  { "eir21", 661, {0, {0}}, 0, 0 },
+  { "eir22", 662, {0, {0}}, 0, 0 },
+  { "eir23", 663, {0, {0}}, 0, 0 },
+  { "eir24", 664, {0, {0}}, 0, 0 },
+  { "eir25", 665, {0, {0}}, 0, 0 },
+  { "eir26", 666, {0, {0}}, 0, 0 },
+  { "eir27", 667, {0, {0}}, 0, 0 },
+  { "eir28", 668, {0, {0}}, 0, 0 },
+  { "eir29", 669, {0, {0}}, 0, 0 },
+  { "eir30", 670, {0, {0}}, 0, 0 },
+  { "eir31", 671, {0, {0}}, 0, 0 },
+  { "esfr0", 672, {0, {0}}, 0, 0 },
+  { "esfr1", 673, {0, {0}}, 0, 0 },
+  { "sr0", 768, {0, {0}}, 0, 0 },
+  { "sr1", 769, {0, {0}}, 0, 0 },
+  { "sr2", 770, {0, {0}}, 0, 0 },
+  { "sr3", 771, {0, {0}}, 0, 0 },
+  { "fsr0", 1024, {0, {0}}, 0, 0 },
+  { "fsr1", 1025, {0, {0}}, 0, 0 },
+  { "fsr2", 1026, {0, {0}}, 0, 0 },
+  { "fsr3", 1027, {0, {0}}, 0, 0 },
+  { "fsr4", 1028, {0, {0}}, 0, 0 },
+  { "fsr5", 1029, {0, {0}}, 0, 0 },
+  { "fsr6", 1030, {0, {0}}, 0, 0 },
+  { "fsr7", 1031, {0, {0}}, 0, 0 },
+  { "fsr8", 1032, {0, {0}}, 0, 0 },
+  { "fsr9", 1033, {0, {0}}, 0, 0 },
+  { "fsr10", 1034, {0, {0}}, 0, 0 },
+  { "fsr11", 1035, {0, {0}}, 0, 0 },
+  { "fsr12", 1036, {0, {0}}, 0, 0 },
+  { "fsr13", 1037, {0, {0}}, 0, 0 },
+  { "fsr14", 1038, {0, {0}}, 0, 0 },
+  { "fsr15", 1039, {0, {0}}, 0, 0 },
+  { "fsr16", 1040, {0, {0}}, 0, 0 },
+  { "fsr17", 1041, {0, {0}}, 0, 0 },
+  { "fsr18", 1042, {0, {0}}, 0, 0 },
+  { "fsr19", 1043, {0, {0}}, 0, 0 },
+  { "fsr20", 1044, {0, {0}}, 0, 0 },
+  { "fsr21", 1045, {0, {0}}, 0, 0 },
+  { "fsr22", 1046, {0, {0}}, 0, 0 },
+  { "fsr23", 1047, {0, {0}}, 0, 0 },
+  { "fsr24", 1048, {0, {0}}, 0, 0 },
+  { "fsr25", 1049, {0, {0}}, 0, 0 },
+  { "fsr26", 1050, {0, {0}}, 0, 0 },
+  { "fsr27", 1051, {0, {0}}, 0, 0 },
+  { "fsr28", 1052, {0, {0}}, 0, 0 },
+  { "fsr29", 1053, {0, {0}}, 0, 0 },
+  { "fsr30", 1054, {0, {0}}, 0, 0 },
+  { "fsr31", 1055, {0, {0}}, 0, 0 },
+  { "fsr32", 1056, {0, {0}}, 0, 0 },
+  { "fsr33", 1057, {0, {0}}, 0, 0 },
+  { "fsr34", 1058, {0, {0}}, 0, 0 },
+  { "fsr35", 1059, {0, {0}}, 0, 0 },
+  { "fsr36", 1060, {0, {0}}, 0, 0 },
+  { "fsr37", 1061, {0, {0}}, 0, 0 },
+  { "fsr38", 1062, {0, {0}}, 0, 0 },
+  { "fsr39", 1063, {0, {0}}, 0, 0 },
+  { "fsr40", 1064, {0, {0}}, 0, 0 },
+  { "fsr41", 1065, {0, {0}}, 0, 0 },
+  { "fsr42", 1066, {0, {0}}, 0, 0 },
+  { "fsr43", 1067, {0, {0}}, 0, 0 },
+  { "fsr44", 1068, {0, {0}}, 0, 0 },
+  { "fsr45", 1069, {0, {0}}, 0, 0 },
+  { "fsr46", 1070, {0, {0}}, 0, 0 },
+  { "fsr47", 1071, {0, {0}}, 0, 0 },
+  { "fsr48", 1072, {0, {0}}, 0, 0 },
+  { "fsr49", 1073, {0, {0}}, 0, 0 },
+  { "fsr50", 1074, {0, {0}}, 0, 0 },
+  { "fsr51", 1075, {0, {0}}, 0, 0 },
+  { "fsr52", 1076, {0, {0}}, 0, 0 },
+  { "fsr53", 1077, {0, {0}}, 0, 0 },
+  { "fsr54", 1078, {0, {0}}, 0, 0 },
+  { "fsr55", 1079, {0, {0}}, 0, 0 },
+  { "fsr56", 1080, {0, {0}}, 0, 0 },
+  { "fsr57", 1081, {0, {0}}, 0, 0 },
+  { "fsr58", 1082, {0, {0}}, 0, 0 },
+  { "fsr59", 1083, {0, {0}}, 0, 0 },
+  { "fsr60", 1084, {0, {0}}, 0, 0 },
+  { "fsr61", 1085, {0, {0}}, 0, 0 },
+  { "fsr62", 1086, {0, {0}}, 0, 0 },
+  { "fsr63", 1087, {0, {0}}, 0, 0 },
+  { "fqop0", 1088, {0, {0}}, 0, 0 },
+  { "fqop1", 1090, {0, {0}}, 0, 0 },
+  { "fqop2", 1092, {0, {0}}, 0, 0 },
+  { "fqop3", 1094, {0, {0}}, 0, 0 },
+  { "fqop4", 1096, {0, {0}}, 0, 0 },
+  { "fqop5", 1098, {0, {0}}, 0, 0 },
+  { "fqop6", 1100, {0, {0}}, 0, 0 },
+  { "fqop7", 1102, {0, {0}}, 0, 0 },
+  { "fqop8", 1104, {0, {0}}, 0, 0 },
+  { "fqop9", 1106, {0, {0}}, 0, 0 },
+  { "fqop10", 1108, {0, {0}}, 0, 0 },
+  { "fqop11", 1110, {0, {0}}, 0, 0 },
+  { "fqop12", 1112, {0, {0}}, 0, 0 },
+  { "fqop13", 1114, {0, {0}}, 0, 0 },
+  { "fqop14", 1116, {0, {0}}, 0, 0 },
+  { "fqop15", 1118, {0, {0}}, 0, 0 },
+  { "fqop16", 1120, {0, {0}}, 0, 0 },
+  { "fqop17", 1122, {0, {0}}, 0, 0 },
+  { "fqop18", 1124, {0, {0}}, 0, 0 },
+  { "fqop19", 1126, {0, {0}}, 0, 0 },
+  { "fqop20", 1128, {0, {0}}, 0, 0 },
+  { "fqop21", 1130, {0, {0}}, 0, 0 },
+  { "fqop22", 1132, {0, {0}}, 0, 0 },
+  { "fqop23", 1134, {0, {0}}, 0, 0 },
+  { "fqop24", 1136, {0, {0}}, 0, 0 },
+  { "fqop25", 1138, {0, {0}}, 0, 0 },
+  { "fqop26", 1140, {0, {0}}, 0, 0 },
+  { "fqop27", 1142, {0, {0}}, 0, 0 },
+  { "fqop28", 1144, {0, {0}}, 0, 0 },
+  { "fqop29", 1146, {0, {0}}, 0, 0 },
+  { "fqop30", 1148, {0, {0}}, 0, 0 },
+  { "fqop31", 1150, {0, {0}}, 0, 0 },
+  { "fqst0", 1089, {0, {0}}, 0, 0 },
+  { "fqst1", 1091, {0, {0}}, 0, 0 },
+  { "fqst2", 1093, {0, {0}}, 0, 0 },
+  { "fqst3", 1095, {0, {0}}, 0, 0 },
+  { "fqst4", 1097, {0, {0}}, 0, 0 },
+  { "fqst5", 1099, {0, {0}}, 0, 0 },
+  { "fqst6", 1101, {0, {0}}, 0, 0 },
+  { "fqst7", 1103, {0, {0}}, 0, 0 },
+  { "fqst8", 1105, {0, {0}}, 0, 0 },
+  { "fqst9", 1107, {0, {0}}, 0, 0 },
+  { "fqst10", 1109, {0, {0}}, 0, 0 },
+  { "fqst11", 1111, {0, {0}}, 0, 0 },
+  { "fqst12", 1113, {0, {0}}, 0, 0 },
+  { "fqst13", 1115, {0, {0}}, 0, 0 },
+  { "fqst14", 1117, {0, {0}}, 0, 0 },
+  { "fqst15", 1119, {0, {0}}, 0, 0 },
+  { "fqst16", 1121, {0, {0}}, 0, 0 },
+  { "fqst17", 1123, {0, {0}}, 0, 0 },
+  { "fqst18", 1125, {0, {0}}, 0, 0 },
+  { "fqst19", 1127, {0, {0}}, 0, 0 },
+  { "fqst20", 1129, {0, {0}}, 0, 0 },
+  { "fqst21", 1131, {0, {0}}, 0, 0 },
+  { "fqst22", 1133, {0, {0}}, 0, 0 },
+  { "fqst23", 1135, {0, {0}}, 0, 0 },
+  { "fqst24", 1137, {0, {0}}, 0, 0 },
+  { "fqst25", 1139, {0, {0}}, 0, 0 },
+  { "fqst26", 1141, {0, {0}}, 0, 0 },
+  { "fqst27", 1143, {0, {0}}, 0, 0 },
+  { "fqst28", 1145, {0, {0}}, 0, 0 },
+  { "fqst29", 1147, {0, {0}}, 0, 0 },
+  { "fqst30", 1149, {0, {0}}, 0, 0 },
+  { "fqst31", 1151, {0, {0}}, 0, 0 },
+  { "mcilr0", 1272, {0, {0}}, 0, 0 },
+  { "mcilr1", 1273, {0, {0}}, 0, 0 },
+  { "msr0", 1280, {0, {0}}, 0, 0 },
+  { "msr1", 1281, {0, {0}}, 0, 0 },
+  { "msr2", 1282, {0, {0}}, 0, 0 },
+  { "msr3", 1283, {0, {0}}, 0, 0 },
+  { "msr4", 1284, {0, {0}}, 0, 0 },
+  { "msr5", 1285, {0, {0}}, 0, 0 },
+  { "msr6", 1286, {0, {0}}, 0, 0 },
+  { "msr7", 1287, {0, {0}}, 0, 0 },
+  { "msr8", 1288, {0, {0}}, 0, 0 },
+  { "msr9", 1289, {0, {0}}, 0, 0 },
+  { "msr10", 1290, {0, {0}}, 0, 0 },
+  { "msr11", 1291, {0, {0}}, 0, 0 },
+  { "msr12", 1292, {0, {0}}, 0, 0 },
+  { "msr13", 1293, {0, {0}}, 0, 0 },
+  { "msr14", 1294, {0, {0}}, 0, 0 },
+  { "msr15", 1295, {0, {0}}, 0, 0 },
+  { "msr16", 1296, {0, {0}}, 0, 0 },
+  { "msr17", 1297, {0, {0}}, 0, 0 },
+  { "msr18", 1298, {0, {0}}, 0, 0 },
+  { "msr19", 1299, {0, {0}}, 0, 0 },
+  { "msr20", 1300, {0, {0}}, 0, 0 },
+  { "msr21", 1301, {0, {0}}, 0, 0 },
+  { "msr22", 1302, {0, {0}}, 0, 0 },
+  { "msr23", 1303, {0, {0}}, 0, 0 },
+  { "msr24", 1304, {0, {0}}, 0, 0 },
+  { "msr25", 1305, {0, {0}}, 0, 0 },
+  { "msr26", 1306, {0, {0}}, 0, 0 },
+  { "msr27", 1307, {0, {0}}, 0, 0 },
+  { "msr28", 1308, {0, {0}}, 0, 0 },
+  { "msr29", 1309, {0, {0}}, 0, 0 },
+  { "msr30", 1310, {0, {0}}, 0, 0 },
+  { "msr31", 1311, {0, {0}}, 0, 0 },
+  { "msr32", 1312, {0, {0}}, 0, 0 },
+  { "msr33", 1313, {0, {0}}, 0, 0 },
+  { "msr34", 1314, {0, {0}}, 0, 0 },
+  { "msr35", 1315, {0, {0}}, 0, 0 },
+  { "msr36", 1316, {0, {0}}, 0, 0 },
+  { "msr37", 1317, {0, {0}}, 0, 0 },
+  { "msr38", 1318, {0, {0}}, 0, 0 },
+  { "msr39", 1319, {0, {0}}, 0, 0 },
+  { "msr40", 1320, {0, {0}}, 0, 0 },
+  { "msr41", 1321, {0, {0}}, 0, 0 },
+  { "msr42", 1322, {0, {0}}, 0, 0 },
+  { "msr43", 1323, {0, {0}}, 0, 0 },
+  { "msr44", 1324, {0, {0}}, 0, 0 },
+  { "msr45", 1325, {0, {0}}, 0, 0 },
+  { "msr46", 1326, {0, {0}}, 0, 0 },
+  { "msr47", 1327, {0, {0}}, 0, 0 },
+  { "msr48", 1328, {0, {0}}, 0, 0 },
+  { "msr49", 1329, {0, {0}}, 0, 0 },
+  { "msr50", 1330, {0, {0}}, 0, 0 },
+  { "msr51", 1331, {0, {0}}, 0, 0 },
+  { "msr52", 1332, {0, {0}}, 0, 0 },
+  { "msr53", 1333, {0, {0}}, 0, 0 },
+  { "msr54", 1334, {0, {0}}, 0, 0 },
+  { "msr55", 1335, {0, {0}}, 0, 0 },
+  { "msr56", 1336, {0, {0}}, 0, 0 },
+  { "msr57", 1337, {0, {0}}, 0, 0 },
+  { "msr58", 1338, {0, {0}}, 0, 0 },
+  { "msr59", 1339, {0, {0}}, 0, 0 },
+  { "msr60", 1340, {0, {0}}, 0, 0 },
+  { "msr61", 1341, {0, {0}}, 0, 0 },
+  { "msr62", 1342, {0, {0}}, 0, 0 },
+  { "msr63", 1343, {0, {0}}, 0, 0 },
+  { "mqop0", 1344, {0, {0}}, 0, 0 },
+  { "mqop1", 1346, {0, {0}}, 0, 0 },
+  { "mqop2", 1348, {0, {0}}, 0, 0 },
+  { "mqop3", 1350, {0, {0}}, 0, 0 },
+  { "mqop4", 1352, {0, {0}}, 0, 0 },
+  { "mqop5", 1354, {0, {0}}, 0, 0 },
+  { "mqop6", 1356, {0, {0}}, 0, 0 },
+  { "mqop7", 1358, {0, {0}}, 0, 0 },
+  { "mqop8", 1360, {0, {0}}, 0, 0 },
+  { "mqop9", 1362, {0, {0}}, 0, 0 },
+  { "mqop10", 1364, {0, {0}}, 0, 0 },
+  { "mqop11", 1366, {0, {0}}, 0, 0 },
+  { "mqop12", 1368, {0, {0}}, 0, 0 },
+  { "mqop13", 1370, {0, {0}}, 0, 0 },
+  { "mqop14", 1372, {0, {0}}, 0, 0 },
+  { "mqop15", 1374, {0, {0}}, 0, 0 },
+  { "mqop16", 1376, {0, {0}}, 0, 0 },
+  { "mqop17", 1378, {0, {0}}, 0, 0 },
+  { "mqop18", 1380, {0, {0}}, 0, 0 },
+  { "mqop19", 1382, {0, {0}}, 0, 0 },
+  { "mqop20", 1384, {0, {0}}, 0, 0 },
+  { "mqop21", 1386, {0, {0}}, 0, 0 },
+  { "mqop22", 1388, {0, {0}}, 0, 0 },
+  { "mqop23", 1390, {0, {0}}, 0, 0 },
+  { "mqop24", 1392, {0, {0}}, 0, 0 },
+  { "mqop25", 1394, {0, {0}}, 0, 0 },
+  { "mqop26", 1396, {0, {0}}, 0, 0 },
+  { "mqop27", 1398, {0, {0}}, 0, 0 },
+  { "mqop28", 1400, {0, {0}}, 0, 0 },
+  { "mqop29", 1402, {0, {0}}, 0, 0 },
+  { "mqop30", 1404, {0, {0}}, 0, 0 },
+  { "mqop31", 1406, {0, {0}}, 0, 0 },
+  { "mqst0", 1345, {0, {0}}, 0, 0 },
+  { "mqst1", 1347, {0, {0}}, 0, 0 },
+  { "mqst2", 1349, {0, {0}}, 0, 0 },
+  { "mqst3", 1351, {0, {0}}, 0, 0 },
+  { "mqst4", 1353, {0, {0}}, 0, 0 },
+  { "mqst5", 1355, {0, {0}}, 0, 0 },
+  { "mqst6", 1357, {0, {0}}, 0, 0 },
+  { "mqst7", 1359, {0, {0}}, 0, 0 },
+  { "mqst8", 1361, {0, {0}}, 0, 0 },
+  { "mqst9", 1363, {0, {0}}, 0, 0 },
+  { "mqst10", 1365, {0, {0}}, 0, 0 },
+  { "mqst11", 1367, {0, {0}}, 0, 0 },
+  { "mqst12", 1369, {0, {0}}, 0, 0 },
+  { "mqst13", 1371, {0, {0}}, 0, 0 },
+  { "mqst14", 1373, {0, {0}}, 0, 0 },
+  { "mqst15", 1375, {0, {0}}, 0, 0 },
+  { "mqst16", 1377, {0, {0}}, 0, 0 },
+  { "mqst17", 1379, {0, {0}}, 0, 0 },
+  { "mqst18", 1381, {0, {0}}, 0, 0 },
+  { "mqst19", 1383, {0, {0}}, 0, 0 },
+  { "mqst20", 1385, {0, {0}}, 0, 0 },
+  { "mqst21", 1387, {0, {0}}, 0, 0 },
+  { "mqst22", 1389, {0, {0}}, 0, 0 },
+  { "mqst23", 1391, {0, {0}}, 0, 0 },
+  { "mqst24", 1393, {0, {0}}, 0, 0 },
+  { "mqst25", 1395, {0, {0}}, 0, 0 },
+  { "mqst26", 1397, {0, {0}}, 0, 0 },
+  { "mqst27", 1399, {0, {0}}, 0, 0 },
+  { "mqst28", 1401, {0, {0}}, 0, 0 },
+  { "mqst29", 1403, {0, {0}}, 0, 0 },
+  { "mqst30", 1405, {0, {0}}, 0, 0 },
+  { "mqst31", 1407, {0, {0}}, 0, 0 },
+  { "ear0", 1536, {0, {0}}, 0, 0 },
+  { "ear1", 1537, {0, {0}}, 0, 0 },
+  { "ear2", 1538, {0, {0}}, 0, 0 },
+  { "ear3", 1539, {0, {0}}, 0, 0 },
+  { "ear4", 1540, {0, {0}}, 0, 0 },
+  { "ear5", 1541, {0, {0}}, 0, 0 },
+  { "ear6", 1542, {0, {0}}, 0, 0 },
+  { "ear7", 1543, {0, {0}}, 0, 0 },
+  { "ear8", 1544, {0, {0}}, 0, 0 },
+  { "ear9", 1545, {0, {0}}, 0, 0 },
+  { "ear10", 1546, {0, {0}}, 0, 0 },
+  { "ear11", 1547, {0, {0}}, 0, 0 },
+  { "ear12", 1548, {0, {0}}, 0, 0 },
+  { "ear13", 1549, {0, {0}}, 0, 0 },
+  { "ear14", 1550, {0, {0}}, 0, 0 },
+  { "ear15", 1551, {0, {0}}, 0, 0 },
+  { "ear16", 1552, {0, {0}}, 0, 0 },
+  { "ear17", 1553, {0, {0}}, 0, 0 },
+  { "ear18", 1554, {0, {0}}, 0, 0 },
+  { "ear19", 1555, {0, {0}}, 0, 0 },
+  { "ear20", 1556, {0, {0}}, 0, 0 },
+  { "ear21", 1557, {0, {0}}, 0, 0 },
+  { "ear22", 1558, {0, {0}}, 0, 0 },
+  { "ear23", 1559, {0, {0}}, 0, 0 },
+  { "ear24", 1560, {0, {0}}, 0, 0 },
+  { "ear25", 1561, {0, {0}}, 0, 0 },
+  { "ear26", 1562, {0, {0}}, 0, 0 },
+  { "ear27", 1563, {0, {0}}, 0, 0 },
+  { "ear28", 1564, {0, {0}}, 0, 0 },
+  { "ear29", 1565, {0, {0}}, 0, 0 },
+  { "ear30", 1566, {0, {0}}, 0, 0 },
+  { "ear31", 1567, {0, {0}}, 0, 0 },
+  { "ear32", 1568, {0, {0}}, 0, 0 },
+  { "ear33", 1569, {0, {0}}, 0, 0 },
+  { "ear34", 1570, {0, {0}}, 0, 0 },
+  { "ear35", 1571, {0, {0}}, 0, 0 },
+  { "ear36", 1572, {0, {0}}, 0, 0 },
+  { "ear37", 1573, {0, {0}}, 0, 0 },
+  { "ear38", 1574, {0, {0}}, 0, 0 },
+  { "ear39", 1575, {0, {0}}, 0, 0 },
+  { "ear40", 1576, {0, {0}}, 0, 0 },
+  { "ear41", 1577, {0, {0}}, 0, 0 },
+  { "ear42", 1578, {0, {0}}, 0, 0 },
+  { "ear43", 1579, {0, {0}}, 0, 0 },
+  { "ear44", 1580, {0, {0}}, 0, 0 },
+  { "ear45", 1581, {0, {0}}, 0, 0 },
+  { "ear46", 1582, {0, {0}}, 0, 0 },
+  { "ear47", 1583, {0, {0}}, 0, 0 },
+  { "ear48", 1584, {0, {0}}, 0, 0 },
+  { "ear49", 1585, {0, {0}}, 0, 0 },
+  { "ear50", 1586, {0, {0}}, 0, 0 },
+  { "ear51", 1587, {0, {0}}, 0, 0 },
+  { "ear52", 1588, {0, {0}}, 0, 0 },
+  { "ear53", 1589, {0, {0}}, 0, 0 },
+  { "ear54", 1590, {0, {0}}, 0, 0 },
+  { "ear55", 1591, {0, {0}}, 0, 0 },
+  { "ear56", 1592, {0, {0}}, 0, 0 },
+  { "ear57", 1593, {0, {0}}, 0, 0 },
+  { "ear58", 1594, {0, {0}}, 0, 0 },
+  { "ear59", 1595, {0, {0}}, 0, 0 },
+  { "ear60", 1596, {0, {0}}, 0, 0 },
+  { "ear61", 1597, {0, {0}}, 0, 0 },
+  { "ear62", 1598, {0, {0}}, 0, 0 },
+  { "ear63", 1599, {0, {0}}, 0, 0 },
+  { "edr0", 1600, {0, {0}}, 0, 0 },
+  { "edr1", 1601, {0, {0}}, 0, 0 },
+  { "edr2", 1602, {0, {0}}, 0, 0 },
+  { "edr3", 1603, {0, {0}}, 0, 0 },
+  { "edr4", 1604, {0, {0}}, 0, 0 },
+  { "edr5", 1605, {0, {0}}, 0, 0 },
+  { "edr6", 1606, {0, {0}}, 0, 0 },
+  { "edr7", 1607, {0, {0}}, 0, 0 },
+  { "edr8", 1608, {0, {0}}, 0, 0 },
+  { "edr9", 1609, {0, {0}}, 0, 0 },
+  { "edr10", 1610, {0, {0}}, 0, 0 },
+  { "edr11", 1611, {0, {0}}, 0, 0 },
+  { "edr12", 1612, {0, {0}}, 0, 0 },
+  { "edr13", 1613, {0, {0}}, 0, 0 },
+  { "edr14", 1614, {0, {0}}, 0, 0 },
+  { "edr15", 1615, {0, {0}}, 0, 0 },
+  { "edr16", 1616, {0, {0}}, 0, 0 },
+  { "edr17", 1617, {0, {0}}, 0, 0 },
+  { "edr18", 1618, {0, {0}}, 0, 0 },
+  { "edr19", 1619, {0, {0}}, 0, 0 },
+  { "edr20", 1620, {0, {0}}, 0, 0 },
+  { "edr21", 1621, {0, {0}}, 0, 0 },
+  { "edr22", 1622, {0, {0}}, 0, 0 },
+  { "edr23", 1623, {0, {0}}, 0, 0 },
+  { "edr24", 1624, {0, {0}}, 0, 0 },
+  { "edr25", 1625, {0, {0}}, 0, 0 },
+  { "edr26", 1626, {0, {0}}, 0, 0 },
+  { "edr27", 1627, {0, {0}}, 0, 0 },
+  { "edr28", 1628, {0, {0}}, 0, 0 },
+  { "edr29", 1629, {0, {0}}, 0, 0 },
+  { "edr30", 1630, {0, {0}}, 0, 0 },
+  { "edr31", 1631, {0, {0}}, 0, 0 },
+  { "edr32", 1632, {0, {0}}, 0, 0 },
+  { "edr33", 1636, {0, {0}}, 0, 0 },
+  { "edr34", 1634, {0, {0}}, 0, 0 },
+  { "edr35", 1635, {0, {0}}, 0, 0 },
+  { "edr36", 1636, {0, {0}}, 0, 0 },
+  { "edr37", 1637, {0, {0}}, 0, 0 },
+  { "edr38", 1638, {0, {0}}, 0, 0 },
+  { "edr39", 1639, {0, {0}}, 0, 0 },
+  { "edr40", 1640, {0, {0}}, 0, 0 },
+  { "edr41", 1641, {0, {0}}, 0, 0 },
+  { "edr42", 1642, {0, {0}}, 0, 0 },
+  { "edr43", 1643, {0, {0}}, 0, 0 },
+  { "edr44", 1644, {0, {0}}, 0, 0 },
+  { "edr45", 1645, {0, {0}}, 0, 0 },
+  { "edr46", 1646, {0, {0}}, 0, 0 },
+  { "edr47", 1647, {0, {0}}, 0, 0 },
+  { "edr48", 1648, {0, {0}}, 0, 0 },
+  { "edr49", 1649, {0, {0}}, 0, 0 },
+  { "edr50", 1650, {0, {0}}, 0, 0 },
+  { "edr51", 1651, {0, {0}}, 0, 0 },
+  { "edr52", 1652, {0, {0}}, 0, 0 },
+  { "edr53", 1653, {0, {0}}, 0, 0 },
+  { "edr54", 1654, {0, {0}}, 0, 0 },
+  { "edr55", 1655, {0, {0}}, 0, 0 },
+  { "edr56", 1656, {0, {0}}, 0, 0 },
+  { "edr57", 1657, {0, {0}}, 0, 0 },
+  { "edr58", 1658, {0, {0}}, 0, 0 },
+  { "edr59", 1659, {0, {0}}, 0, 0 },
+  { "edr60", 1660, {0, {0}}, 0, 0 },
+  { "edr61", 1661, {0, {0}}, 0, 0 },
+  { "edr62", 1662, {0, {0}}, 0, 0 },
+  { "edr63", 1663, {0, {0}}, 0, 0 },
+  { "iamlr0", 1664, {0, {0}}, 0, 0 },
+  { "iamlr1", 1665, {0, {0}}, 0, 0 },
+  { "iamlr2", 1666, {0, {0}}, 0, 0 },
+  { "iamlr3", 1667, {0, {0}}, 0, 0 },
+  { "iamlr4", 1668, {0, {0}}, 0, 0 },
+  { "iamlr5", 1669, {0, {0}}, 0, 0 },
+  { "iamlr6", 1670, {0, {0}}, 0, 0 },
+  { "iamlr7", 1671, {0, {0}}, 0, 0 },
+  { "iamlr8", 1672, {0, {0}}, 0, 0 },
+  { "iamlr9", 1673, {0, {0}}, 0, 0 },
+  { "iamlr10", 1674, {0, {0}}, 0, 0 },
+  { "iamlr11", 1675, {0, {0}}, 0, 0 },
+  { "iamlr12", 1676, {0, {0}}, 0, 0 },
+  { "iamlr13", 1677, {0, {0}}, 0, 0 },
+  { "iamlr14", 1678, {0, {0}}, 0, 0 },
+  { "iamlr15", 1679, {0, {0}}, 0, 0 },
+  { "iamlr16", 1680, {0, {0}}, 0, 0 },
+  { "iamlr17", 1681, {0, {0}}, 0, 0 },
+  { "iamlr18", 1682, {0, {0}}, 0, 0 },
+  { "iamlr19", 1683, {0, {0}}, 0, 0 },
+  { "iamlr20", 1684, {0, {0}}, 0, 0 },
+  { "iamlr21", 1685, {0, {0}}, 0, 0 },
+  { "iamlr22", 1686, {0, {0}}, 0, 0 },
+  { "iamlr23", 1687, {0, {0}}, 0, 0 },
+  { "iamlr24", 1688, {0, {0}}, 0, 0 },
+  { "iamlr25", 1689, {0, {0}}, 0, 0 },
+  { "iamlr26", 1690, {0, {0}}, 0, 0 },
+  { "iamlr27", 1691, {0, {0}}, 0, 0 },
+  { "iamlr28", 1692, {0, {0}}, 0, 0 },
+  { "iamlr29", 1693, {0, {0}}, 0, 0 },
+  { "iamlr30", 1694, {0, {0}}, 0, 0 },
+  { "iamlr31", 1695, {0, {0}}, 0, 0 },
+  { "iamlr32", 1696, {0, {0}}, 0, 0 },
+  { "iamlr33", 1697, {0, {0}}, 0, 0 },
+  { "iamlr34", 1698, {0, {0}}, 0, 0 },
+  { "iamlr35", 1699, {0, {0}}, 0, 0 },
+  { "iamlr36", 1700, {0, {0}}, 0, 0 },
+  { "iamlr37", 1701, {0, {0}}, 0, 0 },
+  { "iamlr38", 1702, {0, {0}}, 0, 0 },
+  { "iamlr39", 1703, {0, {0}}, 0, 0 },
+  { "iamlr40", 1704, {0, {0}}, 0, 0 },
+  { "iamlr41", 1705, {0, {0}}, 0, 0 },
+  { "iamlr42", 1706, {0, {0}}, 0, 0 },
+  { "iamlr43", 1707, {0, {0}}, 0, 0 },
+  { "iamlr44", 1708, {0, {0}}, 0, 0 },
+  { "iamlr45", 1709, {0, {0}}, 0, 0 },
+  { "iamlr46", 1710, {0, {0}}, 0, 0 },
+  { "iamlr47", 1711, {0, {0}}, 0, 0 },
+  { "iamlr48", 1712, {0, {0}}, 0, 0 },
+  { "iamlr49", 1713, {0, {0}}, 0, 0 },
+  { "iamlr50", 1714, {0, {0}}, 0, 0 },
+  { "iamlr51", 1715, {0, {0}}, 0, 0 },
+  { "iamlr52", 1716, {0, {0}}, 0, 0 },
+  { "iamlr53", 1717, {0, {0}}, 0, 0 },
+  { "iamlr54", 1718, {0, {0}}, 0, 0 },
+  { "iamlr55", 1719, {0, {0}}, 0, 0 },
+  { "iamlr56", 1720, {0, {0}}, 0, 0 },
+  { "iamlr57", 1721, {0, {0}}, 0, 0 },
+  { "iamlr58", 1722, {0, {0}}, 0, 0 },
+  { "iamlr59", 1723, {0, {0}}, 0, 0 },
+  { "iamlr60", 1724, {0, {0}}, 0, 0 },
+  { "iamlr61", 1725, {0, {0}}, 0, 0 },
+  { "iamlr62", 1726, {0, {0}}, 0, 0 },
+  { "iamlr63", 1727, {0, {0}}, 0, 0 },
+  { "iampr0", 1728, {0, {0}}, 0, 0 },
+  { "iampr1", 1729, {0, {0}}, 0, 0 },
+  { "iampr2", 1730, {0, {0}}, 0, 0 },
+  { "iampr3", 1731, {0, {0}}, 0, 0 },
+  { "iampr4", 1732, {0, {0}}, 0, 0 },
+  { "iampr5", 1733, {0, {0}}, 0, 0 },
+  { "iampr6", 1734, {0, {0}}, 0, 0 },
+  { "iampr7", 1735, {0, {0}}, 0, 0 },
+  { "iampr8", 1736, {0, {0}}, 0, 0 },
+  { "iampr9", 1737, {0, {0}}, 0, 0 },
+  { "iampr10", 1738, {0, {0}}, 0, 0 },
+  { "iampr11", 1739, {0, {0}}, 0, 0 },
+  { "iampr12", 1740, {0, {0}}, 0, 0 },
+  { "iampr13", 1741, {0, {0}}, 0, 0 },
+  { "iampr14", 1742, {0, {0}}, 0, 0 },
+  { "iampr15", 1743, {0, {0}}, 0, 0 },
+  { "iampr16", 1744, {0, {0}}, 0, 0 },
+  { "iampr17", 1745, {0, {0}}, 0, 0 },
+  { "iampr18", 1746, {0, {0}}, 0, 0 },
+  { "iampr19", 1747, {0, {0}}, 0, 0 },
+  { "iampr20", 1748, {0, {0}}, 0, 0 },
+  { "iampr21", 1749, {0, {0}}, 0, 0 },
+  { "iampr22", 1750, {0, {0}}, 0, 0 },
+  { "iampr23", 1751, {0, {0}}, 0, 0 },
+  { "iampr24", 1752, {0, {0}}, 0, 0 },
+  { "iampr25", 1753, {0, {0}}, 0, 0 },
+  { "iampr26", 1754, {0, {0}}, 0, 0 },
+  { "iampr27", 1755, {0, {0}}, 0, 0 },
+  { "iampr28", 1756, {0, {0}}, 0, 0 },
+  { "iampr29", 1757, {0, {0}}, 0, 0 },
+  { "iampr30", 1758, {0, {0}}, 0, 0 },
+  { "iampr31", 1759, {0, {0}}, 0, 0 },
+  { "iampr32", 1760, {0, {0}}, 0, 0 },
+  { "iampr33", 1761, {0, {0}}, 0, 0 },
+  { "iampr34", 1762, {0, {0}}, 0, 0 },
+  { "iampr35", 1763, {0, {0}}, 0, 0 },
+  { "iampr36", 1764, {0, {0}}, 0, 0 },
+  { "iampr37", 1765, {0, {0}}, 0, 0 },
+  { "iampr38", 1766, {0, {0}}, 0, 0 },
+  { "iampr39", 1767, {0, {0}}, 0, 0 },
+  { "iampr40", 1768, {0, {0}}, 0, 0 },
+  { "iampr41", 1769, {0, {0}}, 0, 0 },
+  { "iampr42", 1770, {0, {0}}, 0, 0 },
+  { "iampr43", 1771, {0, {0}}, 0, 0 },
+  { "iampr44", 1772, {0, {0}}, 0, 0 },
+  { "iampr45", 1773, {0, {0}}, 0, 0 },
+  { "iampr46", 1774, {0, {0}}, 0, 0 },
+  { "iampr47", 1775, {0, {0}}, 0, 0 },
+  { "iampr48", 1776, {0, {0}}, 0, 0 },
+  { "iampr49", 1777, {0, {0}}, 0, 0 },
+  { "iampr50", 1778, {0, {0}}, 0, 0 },
+  { "iampr51", 1779, {0, {0}}, 0, 0 },
+  { "iampr52", 1780, {0, {0}}, 0, 0 },
+  { "iampr53", 1781, {0, {0}}, 0, 0 },
+  { "iampr54", 1782, {0, {0}}, 0, 0 },
+  { "iampr55", 1783, {0, {0}}, 0, 0 },
+  { "iampr56", 1784, {0, {0}}, 0, 0 },
+  { "iampr57", 1785, {0, {0}}, 0, 0 },
+  { "iampr58", 1786, {0, {0}}, 0, 0 },
+  { "iampr59", 1787, {0, {0}}, 0, 0 },
+  { "iampr60", 1788, {0, {0}}, 0, 0 },
+  { "iampr61", 1789, {0, {0}}, 0, 0 },
+  { "iampr62", 1790, {0, {0}}, 0, 0 },
+  { "iampr63", 1791, {0, {0}}, 0, 0 },
+  { "damlr0", 1792, {0, {0}}, 0, 0 },
+  { "damlr1", 1793, {0, {0}}, 0, 0 },
+  { "damlr2", 1794, {0, {0}}, 0, 0 },
+  { "damlr3", 1795, {0, {0}}, 0, 0 },
+  { "damlr4", 1796, {0, {0}}, 0, 0 },
+  { "damlr5", 1797, {0, {0}}, 0, 0 },
+  { "damlr6", 1798, {0, {0}}, 0, 0 },
+  { "damlr7", 1799, {0, {0}}, 0, 0 },
+  { "damlr8", 1800, {0, {0}}, 0, 0 },
+  { "damlr9", 1801, {0, {0}}, 0, 0 },
+  { "damlr10", 1802, {0, {0}}, 0, 0 },
+  { "damlr11", 1803, {0, {0}}, 0, 0 },
+  { "damlr12", 1804, {0, {0}}, 0, 0 },
+  { "damlr13", 1805, {0, {0}}, 0, 0 },
+  { "damlr14", 1806, {0, {0}}, 0, 0 },
+  { "damlr15", 1807, {0, {0}}, 0, 0 },
+  { "damlr16", 1808, {0, {0}}, 0, 0 },
+  { "damlr17", 1809, {0, {0}}, 0, 0 },
+  { "damlr18", 1810, {0, {0}}, 0, 0 },
+  { "damlr19", 1811, {0, {0}}, 0, 0 },
+  { "damlr20", 1812, {0, {0}}, 0, 0 },
+  { "damlr21", 1813, {0, {0}}, 0, 0 },
+  { "damlr22", 1814, {0, {0}}, 0, 0 },
+  { "damlr23", 1815, {0, {0}}, 0, 0 },
+  { "damlr24", 1816, {0, {0}}, 0, 0 },
+  { "damlr25", 1817, {0, {0}}, 0, 0 },
+  { "damlr26", 1818, {0, {0}}, 0, 0 },
+  { "damlr27", 1819, {0, {0}}, 0, 0 },
+  { "damlr28", 1820, {0, {0}}, 0, 0 },
+  { "damlr29", 1821, {0, {0}}, 0, 0 },
+  { "damlr30", 1822, {0, {0}}, 0, 0 },
+  { "damlr31", 1823, {0, {0}}, 0, 0 },
+  { "damlr32", 1824, {0, {0}}, 0, 0 },
+  { "damlr33", 1825, {0, {0}}, 0, 0 },
+  { "damlr34", 1826, {0, {0}}, 0, 0 },
+  { "damlr35", 1827, {0, {0}}, 0, 0 },
+  { "damlr36", 1828, {0, {0}}, 0, 0 },
+  { "damlr37", 1829, {0, {0}}, 0, 0 },
+  { "damlr38", 1830, {0, {0}}, 0, 0 },
+  { "damlr39", 1831, {0, {0}}, 0, 0 },
+  { "damlr40", 1832, {0, {0}}, 0, 0 },
+  { "damlr41", 1833, {0, {0}}, 0, 0 },
+  { "damlr42", 1834, {0, {0}}, 0, 0 },
+  { "damlr43", 1835, {0, {0}}, 0, 0 },
+  { "damlr44", 1836, {0, {0}}, 0, 0 },
+  { "damlr45", 1837, {0, {0}}, 0, 0 },
+  { "damlr46", 1838, {0, {0}}, 0, 0 },
+  { "damlr47", 1839, {0, {0}}, 0, 0 },
+  { "damlr48", 1840, {0, {0}}, 0, 0 },
+  { "damlr49", 1841, {0, {0}}, 0, 0 },
+  { "damlr50", 1842, {0, {0}}, 0, 0 },
+  { "damlr51", 1843, {0, {0}}, 0, 0 },
+  { "damlr52", 1844, {0, {0}}, 0, 0 },
+  { "damlr53", 1845, {0, {0}}, 0, 0 },
+  { "damlr54", 1846, {0, {0}}, 0, 0 },
+  { "damlr55", 1847, {0, {0}}, 0, 0 },
+  { "damlr56", 1848, {0, {0}}, 0, 0 },
+  { "damlr57", 1849, {0, {0}}, 0, 0 },
+  { "damlr58", 1850, {0, {0}}, 0, 0 },
+  { "damlr59", 1851, {0, {0}}, 0, 0 },
+  { "damlr60", 1852, {0, {0}}, 0, 0 },
+  { "damlr61", 1853, {0, {0}}, 0, 0 },
+  { "damlr62", 1854, {0, {0}}, 0, 0 },
+  { "damlr63", 1855, {0, {0}}, 0, 0 },
+  { "dampr0", 1856, {0, {0}}, 0, 0 },
+  { "dampr1", 1857, {0, {0}}, 0, 0 },
+  { "dampr2", 1858, {0, {0}}, 0, 0 },
+  { "dampr3", 1859, {0, {0}}, 0, 0 },
+  { "dampr4", 1860, {0, {0}}, 0, 0 },
+  { "dampr5", 1861, {0, {0}}, 0, 0 },
+  { "dampr6", 1862, {0, {0}}, 0, 0 },
+  { "dampr7", 1863, {0, {0}}, 0, 0 },
+  { "dampr8", 1864, {0, {0}}, 0, 0 },
+  { "dampr9", 1865, {0, {0}}, 0, 0 },
+  { "dampr10", 1866, {0, {0}}, 0, 0 },
+  { "dampr11", 1867, {0, {0}}, 0, 0 },
+  { "dampr12", 1868, {0, {0}}, 0, 0 },
+  { "dampr13", 1869, {0, {0}}, 0, 0 },
+  { "dampr14", 1870, {0, {0}}, 0, 0 },
+  { "dampr15", 1871, {0, {0}}, 0, 0 },
+  { "dampr16", 1872, {0, {0}}, 0, 0 },
+  { "dampr17", 1873, {0, {0}}, 0, 0 },
+  { "dampr18", 1874, {0, {0}}, 0, 0 },
+  { "dampr19", 1875, {0, {0}}, 0, 0 },
+  { "dampr20", 1876, {0, {0}}, 0, 0 },
+  { "dampr21", 1877, {0, {0}}, 0, 0 },
+  { "dampr22", 1878, {0, {0}}, 0, 0 },
+  { "dampr23", 1879, {0, {0}}, 0, 0 },
+  { "dampr24", 1880, {0, {0}}, 0, 0 },
+  { "dampr25", 1881, {0, {0}}, 0, 0 },
+  { "dampr26", 1882, {0, {0}}, 0, 0 },
+  { "dampr27", 1883, {0, {0}}, 0, 0 },
+  { "dampr28", 1884, {0, {0}}, 0, 0 },
+  { "dampr29", 1885, {0, {0}}, 0, 0 },
+  { "dampr30", 1886, {0, {0}}, 0, 0 },
+  { "dampr31", 1887, {0, {0}}, 0, 0 },
+  { "dampr32", 1888, {0, {0}}, 0, 0 },
+  { "dampr33", 1889, {0, {0}}, 0, 0 },
+  { "dampr34", 1890, {0, {0}}, 0, 0 },
+  { "dampr35", 1891, {0, {0}}, 0, 0 },
+  { "dampr36", 1892, {0, {0}}, 0, 0 },
+  { "dampr37", 1893, {0, {0}}, 0, 0 },
+  { "dampr38", 1894, {0, {0}}, 0, 0 },
+  { "dampr39", 1895, {0, {0}}, 0, 0 },
+  { "dampr40", 1896, {0, {0}}, 0, 0 },
+  { "dampr41", 1897, {0, {0}}, 0, 0 },
+  { "dampr42", 1898, {0, {0}}, 0, 0 },
+  { "dampr43", 1899, {0, {0}}, 0, 0 },
+  { "dampr44", 1900, {0, {0}}, 0, 0 },
+  { "dampr45", 1901, {0, {0}}, 0, 0 },
+  { "dampr46", 1902, {0, {0}}, 0, 0 },
+  { "dampr47", 1903, {0, {0}}, 0, 0 },
+  { "dampr48", 1904, {0, {0}}, 0, 0 },
+  { "dampr49", 1905, {0, {0}}, 0, 0 },
+  { "dampr50", 1906, {0, {0}}, 0, 0 },
+  { "dampr51", 1907, {0, {0}}, 0, 0 },
+  { "dampr52", 1908, {0, {0}}, 0, 0 },
+  { "dampr53", 1909, {0, {0}}, 0, 0 },
+  { "dampr54", 1910, {0, {0}}, 0, 0 },
+  { "dampr55", 1911, {0, {0}}, 0, 0 },
+  { "dampr56", 1912, {0, {0}}, 0, 0 },
+  { "dampr57", 1913, {0, {0}}, 0, 0 },
+  { "dampr58", 1914, {0, {0}}, 0, 0 },
+  { "dampr59", 1915, {0, {0}}, 0, 0 },
+  { "dampr60", 1916, {0, {0}}, 0, 0 },
+  { "dampr61", 1917, {0, {0}}, 0, 0 },
+  { "dampr62", 1918, {0, {0}}, 0, 0 },
+  { "dampr63", 1919, {0, {0}}, 0, 0 },
+  { "amcr", 1920, {0, {0}}, 0, 0 },
+  { "stbar", 1921, {0, {0}}, 0, 0 },
+  { "mmcr", 1922, {0, {0}}, 0, 0 },
+  { "dcr", 2048, {0, {0}}, 0, 0 },
+  { "brr", 2049, {0, {0}}, 0, 0 },
+  { "nmar", 2050, {0, {0}}, 0, 0 },
+  { "ibar0", 2052, {0, {0}}, 0, 0 },
+  { "ibar1", 2053, {0, {0}}, 0, 0 },
+  { "ibar2", 2054, {0, {0}}, 0, 0 },
+  { "ibar3", 2055, {0, {0}}, 0, 0 },
+  { "dbar0", 2056, {0, {0}}, 0, 0 },
+  { "dbar1", 2057, {0, {0}}, 0, 0 },
+  { "dbar2", 2058, {0, {0}}, 0, 0 },
+  { "dbar3", 2059, {0, {0}}, 0, 0 },
+  { "dbdr00", 2060, {0, {0}}, 0, 0 },
+  { "dbdr01", 2061, {0, {0}}, 0, 0 },
+  { "dbdr02", 2062, {0, {0}}, 0, 0 },
+  { "dbdr03", 2063, {0, {0}}, 0, 0 },
+  { "dbdr10", 2064, {0, {0}}, 0, 0 },
+  { "dbdr11", 2065, {0, {0}}, 0, 0 },
+  { "dbdr12", 2066, {0, {0}}, 0, 0 },
+  { "dbdr13", 2067, {0, {0}}, 0, 0 },
+  { "dbdr20", 2068, {0, {0}}, 0, 0 },
+  { "dbdr21", 2069, {0, {0}}, 0, 0 },
+  { "dbdr22", 2070, {0, {0}}, 0, 0 },
+  { "dbdr23", 2071, {0, {0}}, 0, 0 },
+  { "dbdr30", 2072, {0, {0}}, 0, 0 },
+  { "dbdr31", 2073, {0, {0}}, 0, 0 },
+  { "dbdr32", 2074, {0, {0}}, 0, 0 },
+  { "dbdr33", 2075, {0, {0}}, 0, 0 },
+  { "dbmr00", 2076, {0, {0}}, 0, 0 },
+  { "dbmr01", 2077, {0, {0}}, 0, 0 },
+  { "dbmr02", 2078, {0, {0}}, 0, 0 },
+  { "dbmr03", 2079, {0, {0}}, 0, 0 },
+  { "dbmr10", 2080, {0, {0}}, 0, 0 },
+  { "dbmr11", 2081, {0, {0}}, 0, 0 },
+  { "dbmr12", 2082, {0, {0}}, 0, 0 },
+  { "dbmr13", 2083, {0, {0}}, 0, 0 },
+  { "dbmr20", 2084, {0, {0}}, 0, 0 },
+  { "dbmr21", 2085, {0, {0}}, 0, 0 },
+  { "dbmr22", 2086, {0, {0}}, 0, 0 },
+  { "dbmr23", 2087, {0, {0}}, 0, 0 },
+  { "dbmr30", 2088, {0, {0}}, 0, 0 },
+  { "dbmr31", 2089, {0, {0}}, 0, 0 },
+  { "dbmr32", 2090, {0, {0}}, 0, 0 },
+  { "dbmr33", 2091, {0, {0}}, 0, 0 },
+  { "cpcfr", 2092, {0, {0}}, 0, 0 },
+  { "cpcr", 2093, {0, {0}}, 0, 0 },
+  { "cpsr", 2094, {0, {0}}, 0, 0 },
+  { "cpesr0", 2096, {0, {0}}, 0, 0 },
+  { "cpesr1", 2097, {0, {0}}, 0, 0 },
+  { "cpemr0", 2098, {0, {0}}, 0, 0 },
+  { "cpemr1", 2099, {0, {0}}, 0, 0 },
+  { "ihsr8", 3848, {0, {0}}, 0, 0 }
+};
+
+CGEN_KEYWORD frv_cgen_opval_spr_names =
+{
+  & frv_cgen_opval_spr_names_entries[0],
+  1005,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY frv_cgen_opval_accg_names_entries[] =
+{
+  { "accg0", 0, {0, {0}}, 0, 0 },
+  { "accg1", 1, {0, {0}}, 0, 0 },
+  { "accg2", 2, {0, {0}}, 0, 0 },
+  { "accg3", 3, {0, {0}}, 0, 0 },
+  { "accg4", 4, {0, {0}}, 0, 0 },
+  { "accg5", 5, {0, {0}}, 0, 0 },
+  { "accg6", 6, {0, {0}}, 0, 0 },
+  { "accg7", 7, {0, {0}}, 0, 0 },
+  { "accg8", 8, {0, {0}}, 0, 0 },
+  { "accg9", 9, {0, {0}}, 0, 0 },
+  { "accg10", 10, {0, {0}}, 0, 0 },
+  { "accg11", 11, {0, {0}}, 0, 0 },
+  { "accg12", 12, {0, {0}}, 0, 0 },
+  { "accg13", 13, {0, {0}}, 0, 0 },
+  { "accg14", 14, {0, {0}}, 0, 0 },
+  { "accg15", 15, {0, {0}}, 0, 0 },
+  { "accg16", 16, {0, {0}}, 0, 0 },
+  { "accg17", 17, {0, {0}}, 0, 0 },
+  { "accg18", 18, {0, {0}}, 0, 0 },
+  { "accg19", 19, {0, {0}}, 0, 0 },
+  { "accg20", 20, {0, {0}}, 0, 0 },
+  { "accg21", 21, {0, {0}}, 0, 0 },
+  { "accg22", 22, {0, {0}}, 0, 0 },
+  { "accg23", 23, {0, {0}}, 0, 0 },
+  { "accg24", 24, {0, {0}}, 0, 0 },
+  { "accg25", 25, {0, {0}}, 0, 0 },
+  { "accg26", 26, {0, {0}}, 0, 0 },
+  { "accg27", 27, {0, {0}}, 0, 0 },
+  { "accg28", 28, {0, {0}}, 0, 0 },
+  { "accg29", 29, {0, {0}}, 0, 0 },
+  { "accg30", 30, {0, {0}}, 0, 0 },
+  { "accg31", 31, {0, {0}}, 0, 0 },
+  { "accg32", 32, {0, {0}}, 0, 0 },
+  { "accg33", 33, {0, {0}}, 0, 0 },
+  { "accg34", 34, {0, {0}}, 0, 0 },
+  { "accg35", 35, {0, {0}}, 0, 0 },
+  { "accg36", 36, {0, {0}}, 0, 0 },
+  { "accg37", 37, {0, {0}}, 0, 0 },
+  { "accg38", 38, {0, {0}}, 0, 0 },
+  { "accg39", 39, {0, {0}}, 0, 0 },
+  { "accg40", 40, {0, {0}}, 0, 0 },
+  { "accg41", 41, {0, {0}}, 0, 0 },
+  { "accg42", 42, {0, {0}}, 0, 0 },
+  { "accg43", 43, {0, {0}}, 0, 0 },
+  { "accg44", 44, {0, {0}}, 0, 0 },
+  { "accg45", 45, {0, {0}}, 0, 0 },
+  { "accg46", 46, {0, {0}}, 0, 0 },
+  { "accg47", 47, {0, {0}}, 0, 0 },
+  { "accg48", 48, {0, {0}}, 0, 0 },
+  { "accg49", 49, {0, {0}}, 0, 0 },
+  { "accg50", 50, {0, {0}}, 0, 0 },
+  { "accg51", 51, {0, {0}}, 0, 0 },
+  { "accg52", 52, {0, {0}}, 0, 0 },
+  { "accg53", 53, {0, {0}}, 0, 0 },
+  { "accg54", 54, {0, {0}}, 0, 0 },
+  { "accg55", 55, {0, {0}}, 0, 0 },
+  { "accg56", 56, {0, {0}}, 0, 0 },
+  { "accg57", 57, {0, {0}}, 0, 0 },
+  { "accg58", 58, {0, {0}}, 0, 0 },
+  { "accg59", 59, {0, {0}}, 0, 0 },
+  { "accg60", 60, {0, {0}}, 0, 0 },
+  { "accg61", 61, {0, {0}}, 0, 0 },
+  { "accg62", 62, {0, {0}}, 0, 0 },
+  { "accg63", 63, {0, {0}}, 0, 0 }
+};
+
+CGEN_KEYWORD frv_cgen_opval_accg_names =
+{
+  & frv_cgen_opval_accg_names_entries[0],
+  64,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY frv_cgen_opval_acc_names_entries[] =
+{
+  { "acc0", 0, {0, {0}}, 0, 0 },
+  { "acc1", 1, {0, {0}}, 0, 0 },
+  { "acc2", 2, {0, {0}}, 0, 0 },
+  { "acc3", 3, {0, {0}}, 0, 0 },
+  { "acc4", 4, {0, {0}}, 0, 0 },
+  { "acc5", 5, {0, {0}}, 0, 0 },
+  { "acc6", 6, {0, {0}}, 0, 0 },
+  { "acc7", 7, {0, {0}}, 0, 0 },
+  { "acc8", 8, {0, {0}}, 0, 0 },
+  { "acc9", 9, {0, {0}}, 0, 0 },
+  { "acc10", 10, {0, {0}}, 0, 0 },
+  { "acc11", 11, {0, {0}}, 0, 0 },
+  { "acc12", 12, {0, {0}}, 0, 0 },
+  { "acc13", 13, {0, {0}}, 0, 0 },
+  { "acc14", 14, {0, {0}}, 0, 0 },
+  { "acc15", 15, {0, {0}}, 0, 0 },
+  { "acc16", 16, {0, {0}}, 0, 0 },
+  { "acc17", 17, {0, {0}}, 0, 0 },
+  { "acc18", 18, {0, {0}}, 0, 0 },
+  { "acc19", 19, {0, {0}}, 0, 0 },
+  { "acc20", 20, {0, {0}}, 0, 0 },
+  { "acc21", 21, {0, {0}}, 0, 0 },
+  { "acc22", 22, {0, {0}}, 0, 0 },
+  { "acc23", 23, {0, {0}}, 0, 0 },
+  { "acc24", 24, {0, {0}}, 0, 0 },
+  { "acc25", 25, {0, {0}}, 0, 0 },
+  { "acc26", 26, {0, {0}}, 0, 0 },
+  { "acc27", 27, {0, {0}}, 0, 0 },
+  { "acc28", 28, {0, {0}}, 0, 0 },
+  { "acc29", 29, {0, {0}}, 0, 0 },
+  { "acc30", 30, {0, {0}}, 0, 0 },
+  { "acc31", 31, {0, {0}}, 0, 0 },
+  { "acc32", 32, {0, {0}}, 0, 0 },
+  { "acc33", 33, {0, {0}}, 0, 0 },
+  { "acc34", 34, {0, {0}}, 0, 0 },
+  { "acc35", 35, {0, {0}}, 0, 0 },
+  { "acc36", 36, {0, {0}}, 0, 0 },
+  { "acc37", 37, {0, {0}}, 0, 0 },
+  { "acc38", 38, {0, {0}}, 0, 0 },
+  { "acc39", 39, {0, {0}}, 0, 0 },
+  { "acc40", 40, {0, {0}}, 0, 0 },
+  { "acc41", 41, {0, {0}}, 0, 0 },
+  { "acc42", 42, {0, {0}}, 0, 0 },
+  { "acc43", 43, {0, {0}}, 0, 0 },
+  { "acc44", 44, {0, {0}}, 0, 0 },
+  { "acc45", 45, {0, {0}}, 0, 0 },
+  { "acc46", 46, {0, {0}}, 0, 0 },
+  { "acc47", 47, {0, {0}}, 0, 0 },
+  { "acc48", 48, {0, {0}}, 0, 0 },
+  { "acc49", 49, {0, {0}}, 0, 0 },
+  { "acc50", 50, {0, {0}}, 0, 0 },
+  { "acc51", 51, {0, {0}}, 0, 0 },
+  { "acc52", 52, {0, {0}}, 0, 0 },
+  { "acc53", 53, {0, {0}}, 0, 0 },
+  { "acc54", 54, {0, {0}}, 0, 0 },
+  { "acc55", 55, {0, {0}}, 0, 0 },
+  { "acc56", 56, {0, {0}}, 0, 0 },
+  { "acc57", 57, {0, {0}}, 0, 0 },
+  { "acc58", 58, {0, {0}}, 0, 0 },
+  { "acc59", 59, {0, {0}}, 0, 0 },
+  { "acc60", 60, {0, {0}}, 0, 0 },
+  { "acc61", 61, {0, {0}}, 0, 0 },
+  { "acc62", 62, {0, {0}}, 0, 0 },
+  { "acc63", 63, {0, {0}}, 0, 0 }
+};
+
+CGEN_KEYWORD frv_cgen_opval_acc_names =
+{
+  & frv_cgen_opval_acc_names_entries[0],
+  64,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY frv_cgen_opval_iccr_names_entries[] =
+{
+  { "icc0", 0, {0, {0}}, 0, 0 },
+  { "icc1", 1, {0, {0}}, 0, 0 },
+  { "icc2", 2, {0, {0}}, 0, 0 },
+  { "icc3", 3, {0, {0}}, 0, 0 }
+};
+
+CGEN_KEYWORD frv_cgen_opval_iccr_names =
+{
+  & frv_cgen_opval_iccr_names_entries[0],
+  4,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY frv_cgen_opval_fccr_names_entries[] =
+{
+  { "fcc0", 0, {0, {0}}, 0, 0 },
+  { "fcc1", 1, {0, {0}}, 0, 0 },
+  { "fcc2", 2, {0, {0}}, 0, 0 },
+  { "fcc3", 3, {0, {0}}, 0, 0 }
+};
+
+CGEN_KEYWORD frv_cgen_opval_fccr_names =
+{
+  & frv_cgen_opval_fccr_names_entries[0],
+  4,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY frv_cgen_opval_cccr_names_entries[] =
+{
+  { "cc0", 0, {0, {0}}, 0, 0 },
+  { "cc1", 1, {0, {0}}, 0, 0 },
+  { "cc2", 2, {0, {0}}, 0, 0 },
+  { "cc3", 3, {0, {0}}, 0, 0 },
+  { "cc4", 4, {0, {0}}, 0, 0 },
+  { "cc5", 5, {0, {0}}, 0, 0 },
+  { "cc6", 6, {0, {0}}, 0, 0 },
+  { "cc7", 7, {0, {0}}, 0, 0 }
+};
+
+CGEN_KEYWORD frv_cgen_opval_cccr_names =
+{
+  & frv_cgen_opval_cccr_names_entries[0],
+  8,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY frv_cgen_opval_h_pack_entries[] =
+{
+  { "", 1, {0, {0}}, 0, 0 },
+  { ".p", 0, {0, {0}}, 0, 0 },
+  { ".P", 0, {0, {0}}, 0, 0 }
+};
+
+CGEN_KEYWORD frv_cgen_opval_h_pack =
+{
+  & frv_cgen_opval_h_pack_entries[0],
+  3,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY frv_cgen_opval_h_hint_taken_entries[] =
+{
+  { "", 2, {0, {0}}, 0, 0 },
+  { "", 0, {0, {0}}, 0, 0 },
+  { "", 1, {0, {0}}, 0, 0 },
+  { "", 3, {0, {0}}, 0, 0 }
+};
+
+CGEN_KEYWORD frv_cgen_opval_h_hint_taken =
+{
+  & frv_cgen_opval_h_hint_taken_entries[0],
+  4,
+  0, 0, 0, 0, ""
+};
+
+static CGEN_KEYWORD_ENTRY frv_cgen_opval_h_hint_not_taken_entries[] =
+{
+  { "", 0, {0, {0}}, 0, 0 },
+  { "", 1, {0, {0}}, 0, 0 },
+  { "", 2, {0, {0}}, 0, 0 },
+  { "", 3, {0, {0}}, 0, 0 }
+};
+
+CGEN_KEYWORD frv_cgen_opval_h_hint_not_taken =
+{
+  & frv_cgen_opval_h_hint_not_taken_entries[0],
+  4,
+  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 frv_cgen_hw_table[] =
+{
+  { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-sint", HW_H_SINT, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-uint", HW_H_UINT, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-addr", HW_H_ADDR, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-iaddr", HW_H_IADDR, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-pc", HW_H_PC, CGEN_ASM_NONE, 0, { 0|A(PROFILE)|A(PC), { (1<<MACH_BASE) } } },
+  { "h-psr_imple", HW_H_PSR_IMPLE, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-psr_ver", HW_H_PSR_VER, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-psr_ice", HW_H_PSR_ICE, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-psr_nem", HW_H_PSR_NEM, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-psr_cm", HW_H_PSR_CM, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-psr_be", HW_H_PSR_BE, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-psr_esr", HW_H_PSR_ESR, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-psr_ef", HW_H_PSR_EF, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-psr_em", HW_H_PSR_EM, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-psr_pil", HW_H_PSR_PIL, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-psr_ps", HW_H_PSR_PS, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-psr_et", HW_H_PSR_ET, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-psr_s", HW_H_PSR_S, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-tbr_tba", HW_H_TBR_TBA, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-tbr_tt", HW_H_TBR_TT, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-bpsr_bs", HW_H_BPSR_BS, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-bpsr_bet", HW_H_BPSR_BET, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-gr", HW_H_GR, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_gr_names, { 0|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-gr_double", HW_H_GR_DOUBLE, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_gr_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-gr_hi", HW_H_GR_HI, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_gr_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-gr_lo", HW_H_GR_LO, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_gr_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-fr", HW_H_FR, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_fr_names, { 0|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-fr_double", HW_H_FR_DOUBLE, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_fr_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-fr_int", HW_H_FR_INT, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_fr_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-fr_hi", HW_H_FR_HI, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_fr_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-fr_lo", HW_H_FR_LO, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_fr_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-fr_0", HW_H_FR_0, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_fr_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-fr_1", HW_H_FR_1, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_fr_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-fr_2", HW_H_FR_2, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_fr_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-fr_3", HW_H_FR_3, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_fr_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-cpr", HW_H_CPR, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_cpr_names, { 0|A(PROFILE), { (1<<MACH_FRV) } } },
+  { "h-cpr_double", HW_H_CPR_DOUBLE, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_cpr_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_FRV) } } },
+  { "h-spr", HW_H_SPR, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_spr_names, { 0|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-accg", HW_H_ACCG, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_accg_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-acc40S", HW_H_ACC40S, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_acc_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-acc40U", HW_H_ACC40U, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_acc_names, { 0|A(VIRTUAL)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-iccr", HW_H_ICCR, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_iccr_names, { 0|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-fccr", HW_H_FCCR, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_fccr_names, { 0|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-cccr", HW_H_CCCR, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_cccr_names, { 0|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-pack", HW_H_PACK, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_h_pack, { 0, { (1<<MACH_BASE) } } },
+  { "h-hint-taken", HW_H_HINT_TAKEN, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_h_hint_taken, { 0, { (1<<MACH_BASE) } } },
+  { "h-hint-not-taken", HW_H_HINT_NOT_TAKEN, CGEN_ASM_KEYWORD, (PTR) & frv_cgen_opval_h_hint_not_taken, { 0, { (1<<MACH_BASE) } } },
+  { 0, 0, CGEN_ASM_NONE, 0, {0, {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 frv_cgen_ifld_table[] =
+{
+  { FRV_F_NIL, "f-nil", 0, 0, 0, 0, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_ANYOF, "f-anyof", 0, 0, 0, 0, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_PACK, "f-pack", 0, 32, 31, 1, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_OP, "f-op", 0, 32, 24, 7, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_OPE1, "f-ope1", 0, 32, 11, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_OPE2, "f-ope2", 0, 32, 9, 4, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_OPE3, "f-ope3", 0, 32, 15, 3, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_OPE4, "f-ope4", 0, 32, 7, 2, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_GRI, "f-GRi", 0, 32, 17, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_GRJ, "f-GRj", 0, 32, 5, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_GRK, "f-GRk", 0, 32, 30, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_FRI, "f-FRi", 0, 32, 17, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_FRJ, "f-FRj", 0, 32, 5, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_FRK, "f-FRk", 0, 32, 30, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_CPRI, "f-CPRi", 0, 32, 17, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_CPRJ, "f-CPRj", 0, 32, 5, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_CPRK, "f-CPRk", 0, 32, 30, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_ACCGI, "f-ACCGi", 0, 32, 17, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_ACCGK, "f-ACCGk", 0, 32, 30, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_ACC40SI, "f-ACC40Si", 0, 32, 17, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_ACC40UI, "f-ACC40Ui", 0, 32, 17, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_ACC40SK, "f-ACC40Sk", 0, 32, 30, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_ACC40UK, "f-ACC40Uk", 0, 32, 30, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_CRI, "f-CRi", 0, 32, 14, 3, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_CRJ, "f-CRj", 0, 32, 2, 3, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_CRK, "f-CRk", 0, 32, 27, 3, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_CCI, "f-CCi", 0, 32, 11, 3, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_CRJ_INT, "f-CRj_int", 0, 32, 26, 2, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_CRJ_FLOAT, "f-CRj_float", 0, 32, 26, 2, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_ICCI_1, "f-ICCi_1", 0, 32, 11, 2, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_ICCI_2, "f-ICCi_2", 0, 32, 26, 2, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_ICCI_3, "f-ICCi_3", 0, 32, 1, 2, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_FCCI_1, "f-FCCi_1", 0, 32, 11, 2, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_FCCI_2, "f-FCCi_2", 0, 32, 26, 2, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_FCCI_3, "f-FCCi_3", 0, 32, 1, 2, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_FCCK, "f-FCCk", 0, 32, 26, 2, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_EIR, "f-eir", 0, 32, 17, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_S10, "f-s10", 0, 32, 9, 10, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_S12, "f-s12", 0, 32, 11, 12, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_D12, "f-d12", 0, 32, 11, 12, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_U16, "f-u16", 0, 32, 15, 16, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_S16, "f-s16", 0, 32, 15, 16, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_S6, "f-s6", 0, 32, 5, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_S6_1, "f-s6_1", 0, 32, 11, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_U6, "f-u6", 0, 32, 5, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_S5, "f-s5", 0, 32, 4, 5, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_U12_H, "f-u12-h", 0, 32, 17, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_U12_L, "f-u12-l", 0, 32, 5, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_INT_CC, "f-int-cc", 0, 32, 30, 4, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_FLT_CC, "f-flt-cc", 0, 32, 30, 4, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_COND, "f-cond", 0, 32, 8, 1, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_CCOND, "f-ccond", 0, 32, 12, 1, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_HINT, "f-hint", 0, 32, 17, 2, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_LI, "f-LI", 0, 32, 25, 1, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_LOCK, "f-lock", 0, 32, 25, 1, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_DEBUG, "f-debug", 0, 32, 25, 1, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_A, "f-A", 0, 32, 17, 1, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_AE, "f-ae", 0, 32, 25, 1, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_SPR_H, "f-spr-h", 0, 32, 30, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_SPR_L, "f-spr-l", 0, 32, 17, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_LABEL16, "f-label16", 0, 32, 15, 16, { 0|A(PCREL_ADDR), { (1<<MACH_BASE) } }  },
+  { FRV_F_LABELH6, "f-labelH6", 0, 32, 30, 6, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_LABELL18, "f-labelL18", 0, 32, 17, 18, { 0, { (1<<MACH_BASE) } }  },
+  { FRV_F_ICCI_1_NULL, "f-ICCi_1-null", 0, 32, 11, 2, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_ICCI_2_NULL, "f-ICCi_2-null", 0, 32, 26, 2, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_ICCI_3_NULL, "f-ICCi_3-null", 0, 32, 1, 2, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_FCCI_1_NULL, "f-FCCi_1-null", 0, 32, 11, 2, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_FCCI_2_NULL, "f-FCCi_2-null", 0, 32, 26, 2, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_FCCI_3_NULL, "f-FCCi_3-null", 0, 32, 1, 2, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_RS_NULL, "f-rs-null", 0, 32, 17, 6, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_GRI_NULL, "f-GRi-null", 0, 32, 17, 6, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_GRJ_NULL, "f-GRj-null", 0, 32, 5, 6, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_GRK_NULL, "f-GRk-null", 0, 32, 30, 6, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_FRI_NULL, "f-FRi-null", 0, 32, 17, 6, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_FRJ_NULL, "f-FRj-null", 0, 32, 5, 6, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_ACCJ_NULL, "f-ACCj-null", 0, 32, 5, 6, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_RD_NULL, "f-rd-null", 0, 32, 30, 6, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_COND_NULL, "f-cond-null", 0, 32, 30, 4, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_CCOND_NULL, "f-ccond-null", 0, 32, 12, 1, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_S12_NULL, "f-s12-null", 0, 32, 11, 12, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_LABEL16_NULL, "f-label16-null", 0, 32, 15, 16, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_MISC_NULL_1, "f-misc-null-1", 0, 32, 30, 5, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_MISC_NULL_2, "f-misc-null-2", 0, 32, 11, 6, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_MISC_NULL_3, "f-misc-null-3", 0, 32, 11, 4, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_MISC_NULL_4, "f-misc-null-4", 0, 32, 17, 2, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_MISC_NULL_5, "f-misc-null-5", 0, 32, 17, 16, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_MISC_NULL_6, "f-misc-null-6", 0, 32, 30, 3, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_MISC_NULL_7, "f-misc-null-7", 0, 32, 17, 3, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_MISC_NULL_8, "f-misc-null-8", 0, 32, 5, 3, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_MISC_NULL_9, "f-misc-null-9", 0, 32, 5, 4, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_MISC_NULL_10, "f-misc-null-10", 0, 32, 16, 5, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_MISC_NULL_11, "f-misc-null-11", 0, 32, 5, 1, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_LI_OFF, "f-LI-off", 0, 32, 25, 1, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { FRV_F_LI_ON, "f-LI-on", 0, 32, 25, 1, { 0|A(RESERVED), { (1<<MACH_BASE) } }  },
+  { 0, 0, 0, 0, 0, 0, {0, {0}} }
+};
+
+#undef A
+
+
+
+/* multi ifield declarations */
+
+const CGEN_MAYBE_MULTI_IFLD FRV_F_U12_MULTI_IFIELD [];
+const CGEN_MAYBE_MULTI_IFLD FRV_F_SPR_MULTI_IFIELD [];
+const CGEN_MAYBE_MULTI_IFLD FRV_F_LABEL24_MULTI_IFIELD [];
+
+
+/* multi ifield definitions */
+
+const CGEN_MAYBE_MULTI_IFLD FRV_F_U12_MULTI_IFIELD [] =
+{
+    { 0, &(frv_cgen_ifld_table[46]) },
+    { 0, &(frv_cgen_ifld_table[47]) },
+    {0,0}
+};
+const CGEN_MAYBE_MULTI_IFLD FRV_F_SPR_MULTI_IFIELD [] =
+{
+    { 0, &(frv_cgen_ifld_table[58]) },
+    { 0, &(frv_cgen_ifld_table[59]) },
+    {0,0}
+};
+const CGEN_MAYBE_MULTI_IFLD FRV_F_LABEL24_MULTI_IFIELD [] =
+{
+    { 0, &(frv_cgen_ifld_table[61]) },
+    { 0, &(frv_cgen_ifld_table[62]) },
+    {0,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) FRV_OPERAND_##op
+#else
+#define OPERAND(op) FRV_OPERAND_/**/op
+#endif
+
+const CGEN_OPERAND frv_cgen_operand_table[] =
+{
+/* pc: program counter */
+  { "pc", FRV_OPERAND_PC, HW_H_PC, 0, 0,
+    { 0, &(frv_cgen_ifld_table[0]) }, 
+    { 0|A(SEM_ONLY), { (1<<MACH_BASE) } }  },
+/* pack: packing bit */
+  { "pack", FRV_OPERAND_PACK, HW_H_PACK, 31, 1,
+    { 0, &(frv_cgen_ifld_table[2]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* GRi: source register 1 */
+  { "GRi", FRV_OPERAND_GRI, HW_H_GR, 17, 6,
+    { 0, &(frv_cgen_ifld_table[8]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* GRj: source register 2 */
+  { "GRj", FRV_OPERAND_GRJ, HW_H_GR, 5, 6,
+    { 0, &(frv_cgen_ifld_table[9]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* GRk: destination register */
+  { "GRk", FRV_OPERAND_GRK, HW_H_GR, 30, 6,
+    { 0, &(frv_cgen_ifld_table[10]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* GRkhi: destination register */
+  { "GRkhi", FRV_OPERAND_GRKHI, HW_H_GR_HI, 30, 6,
+    { 0, &(frv_cgen_ifld_table[10]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* GRklo: destination register */
+  { "GRklo", FRV_OPERAND_GRKLO, HW_H_GR_LO, 30, 6,
+    { 0, &(frv_cgen_ifld_table[10]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* GRdoublek: destination register */
+  { "GRdoublek", FRV_OPERAND_GRDOUBLEK, HW_H_GR_DOUBLE, 30, 6,
+    { 0, &(frv_cgen_ifld_table[10]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* ACC40Si: signed accumulator */
+  { "ACC40Si", FRV_OPERAND_ACC40SI, HW_H_ACC40S, 17, 6,
+    { 0, &(frv_cgen_ifld_table[19]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* ACC40Ui: unsigned accumulator */
+  { "ACC40Ui", FRV_OPERAND_ACC40UI, HW_H_ACC40U, 17, 6,
+    { 0, &(frv_cgen_ifld_table[20]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* ACC40Sk: target accumulator */
+  { "ACC40Sk", FRV_OPERAND_ACC40SK, HW_H_ACC40S, 30, 6,
+    { 0, &(frv_cgen_ifld_table[21]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* ACC40Uk: target accumulator */
+  { "ACC40Uk", FRV_OPERAND_ACC40UK, HW_H_ACC40U, 30, 6,
+    { 0, &(frv_cgen_ifld_table[22]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* ACCGi: source register */
+  { "ACCGi", FRV_OPERAND_ACCGI, HW_H_ACCG, 17, 6,
+    { 0, &(frv_cgen_ifld_table[17]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* ACCGk: target register */
+  { "ACCGk", FRV_OPERAND_ACCGK, HW_H_ACCG, 30, 6,
+    { 0, &(frv_cgen_ifld_table[18]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* CPRi: source register */
+  { "CPRi", FRV_OPERAND_CPRI, HW_H_CPR, 17, 6,
+    { 0, &(frv_cgen_ifld_table[14]) }, 
+    { 0, { (1<<MACH_FRV) } }  },
+/* CPRj: source register */
+  { "CPRj", FRV_OPERAND_CPRJ, HW_H_CPR, 5, 6,
+    { 0, &(frv_cgen_ifld_table[15]) }, 
+    { 0, { (1<<MACH_FRV) } }  },
+/* CPRk: destination register */
+  { "CPRk", FRV_OPERAND_CPRK, HW_H_CPR, 30, 6,
+    { 0, &(frv_cgen_ifld_table[16]) }, 
+    { 0, { (1<<MACH_FRV) } }  },
+/* CPRdoublek: destination register */
+  { "CPRdoublek", FRV_OPERAND_CPRDOUBLEK, HW_H_CPR_DOUBLE, 30, 6,
+    { 0, &(frv_cgen_ifld_table[16]) }, 
+    { 0, { (1<<MACH_FRV) } }  },
+/* FRinti: source register 1 */
+  { "FRinti", FRV_OPERAND_FRINTI, HW_H_FR_INT, 17, 6,
+    { 0, &(frv_cgen_ifld_table[11]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FRintj: source register 2 */
+  { "FRintj", FRV_OPERAND_FRINTJ, HW_H_FR_INT, 5, 6,
+    { 0, &(frv_cgen_ifld_table[12]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FRintk: target register */
+  { "FRintk", FRV_OPERAND_FRINTK, HW_H_FR_INT, 30, 6,
+    { 0, &(frv_cgen_ifld_table[13]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FRi: source register 1 */
+  { "FRi", FRV_OPERAND_FRI, HW_H_FR, 17, 6,
+    { 0, &(frv_cgen_ifld_table[11]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FRj: source register 2 */
+  { "FRj", FRV_OPERAND_FRJ, HW_H_FR, 5, 6,
+    { 0, &(frv_cgen_ifld_table[12]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FRk: destination register */
+  { "FRk", FRV_OPERAND_FRK, HW_H_FR, 30, 6,
+    { 0, &(frv_cgen_ifld_table[13]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FRkhi: destination register */
+  { "FRkhi", FRV_OPERAND_FRKHI, HW_H_FR_HI, 30, 6,
+    { 0, &(frv_cgen_ifld_table[13]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FRklo: destination register */
+  { "FRklo", FRV_OPERAND_FRKLO, HW_H_FR_LO, 30, 6,
+    { 0, &(frv_cgen_ifld_table[13]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FRdoublei: source register 1 */
+  { "FRdoublei", FRV_OPERAND_FRDOUBLEI, HW_H_FR_DOUBLE, 17, 6,
+    { 0, &(frv_cgen_ifld_table[11]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FRdoublej: source register 2 */
+  { "FRdoublej", FRV_OPERAND_FRDOUBLEJ, HW_H_FR_DOUBLE, 5, 6,
+    { 0, &(frv_cgen_ifld_table[12]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FRdoublek: target register */
+  { "FRdoublek", FRV_OPERAND_FRDOUBLEK, HW_H_FR_DOUBLE, 30, 6,
+    { 0, &(frv_cgen_ifld_table[13]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* CRi: source register 1 */
+  { "CRi", FRV_OPERAND_CRI, HW_H_CCCR, 14, 3,
+    { 0, &(frv_cgen_ifld_table[23]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* CRj: source register 2 */
+  { "CRj", FRV_OPERAND_CRJ, HW_H_CCCR, 2, 3,
+    { 0, &(frv_cgen_ifld_table[24]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* CRj_int: destination register */
+  { "CRj_int", FRV_OPERAND_CRJ_INT, HW_H_CCCR, 26, 2,
+    { 0, &(frv_cgen_ifld_table[27]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* CRj_float: destination register */
+  { "CRj_float", FRV_OPERAND_CRJ_FLOAT, HW_H_CCCR, 26, 2,
+    { 0, &(frv_cgen_ifld_table[28]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* CRk: destination register */
+  { "CRk", FRV_OPERAND_CRK, HW_H_CCCR, 27, 3,
+    { 0, &(frv_cgen_ifld_table[25]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* CCi: condition   register */
+  { "CCi", FRV_OPERAND_CCI, HW_H_CCCR, 11, 3,
+    { 0, &(frv_cgen_ifld_table[26]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* ICCi_1: condition   register */
+  { "ICCi_1", FRV_OPERAND_ICCI_1, HW_H_ICCR, 11, 2,
+    { 0, &(frv_cgen_ifld_table[29]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* ICCi_2: condition   register */
+  { "ICCi_2", FRV_OPERAND_ICCI_2, HW_H_ICCR, 26, 2,
+    { 0, &(frv_cgen_ifld_table[30]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* ICCi_3: condition   register */
+  { "ICCi_3", FRV_OPERAND_ICCI_3, HW_H_ICCR, 1, 2,
+    { 0, &(frv_cgen_ifld_table[31]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FCCi_1: condition   register */
+  { "FCCi_1", FRV_OPERAND_FCCI_1, HW_H_FCCR, 11, 2,
+    { 0, &(frv_cgen_ifld_table[32]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FCCi_2: condition   register */
+  { "FCCi_2", FRV_OPERAND_FCCI_2, HW_H_FCCR, 26, 2,
+    { 0, &(frv_cgen_ifld_table[33]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FCCi_3: condition   register */
+  { "FCCi_3", FRV_OPERAND_FCCI_3, HW_H_FCCR, 1, 2,
+    { 0, &(frv_cgen_ifld_table[34]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* FCCk: condition   register */
+  { "FCCk", FRV_OPERAND_FCCK, HW_H_FCCR, 26, 2,
+    { 0, &(frv_cgen_ifld_table[35]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* eir: exception insn reg */
+  { "eir", FRV_OPERAND_EIR, HW_H_UINT, 17, 6,
+    { 0, &(frv_cgen_ifld_table[36]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* s10: 10 bit signed immediate */
+  { "s10", FRV_OPERAND_S10, HW_H_SINT, 9, 10,
+    { 0, &(frv_cgen_ifld_table[37]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* u16: 16 bit unsigned immediate */
+  { "u16", FRV_OPERAND_U16, HW_H_UINT, 15, 16,
+    { 0, &(frv_cgen_ifld_table[40]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* s16: 16 bit signed   immediate */
+  { "s16", FRV_OPERAND_S16, HW_H_SINT, 15, 16,
+    { 0, &(frv_cgen_ifld_table[41]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* s6: 6  bit signed   immediate */
+  { "s6", FRV_OPERAND_S6, HW_H_SINT, 5, 6,
+    { 0, &(frv_cgen_ifld_table[42]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* s6_1: 6  bit signed   immediate */
+  { "s6_1", FRV_OPERAND_S6_1, HW_H_SINT, 11, 6,
+    { 0, &(frv_cgen_ifld_table[43]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* u6: 6  bit unsigned immediate */
+  { "u6", FRV_OPERAND_U6, HW_H_UINT, 5, 6,
+    { 0, &(frv_cgen_ifld_table[44]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* s5: 5  bit signed   immediate */
+  { "s5", FRV_OPERAND_S5, HW_H_SINT, 4, 5,
+    { 0, &(frv_cgen_ifld_table[45]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* cond: conditional arithmetic */
+  { "cond", FRV_OPERAND_COND, HW_H_UINT, 8, 1,
+    { 0, &(frv_cgen_ifld_table[50]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* ccond: lr branch condition */
+  { "ccond", FRV_OPERAND_CCOND, HW_H_UINT, 12, 1,
+    { 0, &(frv_cgen_ifld_table[51]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* hint: 2 bit branch predictor */
+  { "hint", FRV_OPERAND_HINT, HW_H_UINT, 17, 2,
+    { 0, &(frv_cgen_ifld_table[52]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* hint_taken: 2 bit branch predictor */
+  { "hint_taken", FRV_OPERAND_HINT_TAKEN, HW_H_HINT_TAKEN, 17, 2,
+    { 0, &(frv_cgen_ifld_table[52]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* hint_not_taken: 2 bit branch predictor */
+  { "hint_not_taken", FRV_OPERAND_HINT_NOT_TAKEN, HW_H_HINT_NOT_TAKEN, 17, 2,
+    { 0, &(frv_cgen_ifld_table[52]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* LI: link indicator */
+  { "LI", FRV_OPERAND_LI, HW_H_UINT, 25, 1,
+    { 0, &(frv_cgen_ifld_table[53]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* lock: cache lock indicator */
+  { "lock", FRV_OPERAND_LOCK, HW_H_UINT, 25, 1,
+    { 0, &(frv_cgen_ifld_table[54]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* debug: debug mode indicator */
+  { "debug", FRV_OPERAND_DEBUG, HW_H_UINT, 25, 1,
+    { 0, &(frv_cgen_ifld_table[55]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* A: all accumulator indicator */
+  { "A", FRV_OPERAND_A, HW_H_UINT, 17, 1,
+    { 0, &(frv_cgen_ifld_table[56]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* ae: all entries indicator */
+  { "ae", FRV_OPERAND_AE, HW_H_UINT, 25, 1,
+    { 0, &(frv_cgen_ifld_table[57]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* label16: 18 bit pc relative address */
+  { "label16", FRV_OPERAND_LABEL16, HW_H_IADDR, 15, 16,
+    { 0, &(frv_cgen_ifld_table[60]) }, 
+    { 0|A(PCREL_ADDR), { (1<<MACH_BASE) } }  },
+/* label24: 26 bit pc relative address */
+  { "label24", FRV_OPERAND_LABEL24, HW_H_IADDR, 17, 24,
+    { 2, &(FRV_F_LABEL24_MULTI_IFIELD[0]) }, 
+    { 0|A(PCREL_ADDR)|A(VIRTUAL), { (1<<MACH_BASE) } }  },
+/* d12: 12 bit signed immediate */
+  { "d12", FRV_OPERAND_D12, HW_H_SINT, 11, 12,
+    { 0, &(frv_cgen_ifld_table[39]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* s12: 12 bit signed immediate */
+  { "s12", FRV_OPERAND_S12, HW_H_SINT, 11, 12,
+    { 0, &(frv_cgen_ifld_table[39]) }, 
+    { 0|A(HASH_PREFIX), { (1<<MACH_BASE) } }  },
+/* u12: 12 bit signed immediate */
+  { "u12", FRV_OPERAND_U12, HW_H_SINT, 5, 12,
+    { 2, &(FRV_F_U12_MULTI_IFIELD[0]) }, 
+    { 0|A(HASH_PREFIX)|A(VIRTUAL), { (1<<MACH_BASE) } }  },
+/* spr: special purpose register */
+  { "spr", FRV_OPERAND_SPR, HW_H_SPR, 17, 12,
+    { 2, &(FRV_F_SPR_MULTI_IFIELD[0]) }, 
+    { 0|A(VIRTUAL), { (1<<MACH_BASE) } }  },
+/* ulo16: 16 bit unsigned immediate, for #lo() */
+  { "ulo16", FRV_OPERAND_ULO16, HW_H_UINT, 15, 16,
+    { 0, &(frv_cgen_ifld_table[40]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* slo16: 16 bit unsigned immediate, for #lo() */
+  { "slo16", FRV_OPERAND_SLO16, HW_H_SINT, 15, 16,
+    { 0, &(frv_cgen_ifld_table[41]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* uhi16: 16 bit unsigned immediate, for #hi() */
+  { "uhi16", FRV_OPERAND_UHI16, HW_H_UINT, 15, 16,
+    { 0, &(frv_cgen_ifld_table[40]) }, 
+    { 0, { (1<<MACH_BASE) } }  },
+/* psr_esr: PSR.ESR bit */
+  { "psr_esr", FRV_OPERAND_PSR_ESR, HW_H_PSR_ESR, 0, 0,
+    { 0, 0 }, 
+    { 0|A(SEM_ONLY), { (1<<MACH_BASE) } }  },
+/* psr_s: PSR.S   bit */
+  { "psr_s", FRV_OPERAND_PSR_S, HW_H_PSR_S, 0, 0,
+    { 0, 0 }, 
+    { 0|A(SEM_ONLY), { (1<<MACH_BASE) } }  },
+/* psr_ps: PSR.PS  bit */
+  { "psr_ps", FRV_OPERAND_PSR_PS, HW_H_PSR_PS, 0, 0,
+    { 0, 0 }, 
+    { 0|A(SEM_ONLY), { (1<<MACH_BASE) } }  },
+/* psr_et: PSR.ET  bit */
+  { "psr_et", FRV_OPERAND_PSR_ET, HW_H_PSR_ET, 0, 0,
+    { 0, 0 }, 
+    { 0|A(SEM_ONLY), { (1<<MACH_BASE) } }  },
+/* bpsr_bs: BPSR.BS  bit */
+  { "bpsr_bs", FRV_OPERAND_BPSR_BS, HW_H_BPSR_BS, 0, 0,
+    { 0, 0 }, 
+    { 0|A(SEM_ONLY), { (1<<MACH_BASE) } }  },
+/* bpsr_bet: BPSR.BET bit */
+  { "bpsr_bet", FRV_OPERAND_BPSR_BET, HW_H_BPSR_BET, 0, 0,
+    { 0, 0 }, 
+    { 0|A(SEM_ONLY), { (1<<MACH_BASE) } }  },
+/* tbr_tba: TBR.TBA */
+  { "tbr_tba", FRV_OPERAND_TBR_TBA, HW_H_TBR_TBA, 0, 0,
+    { 0, 0 }, 
+    { 0|A(SEM_ONLY), { (1<<MACH_BASE) } }  },
+/* tbr_tt: TBR.TT */
+  { "tbr_tt", FRV_OPERAND_TBR_TT, HW_H_TBR_TT, 0, 0,
+    { 0, 0 }, 
+    { 0|A(SEM_ONLY), { (1<<MACH_BASE) } }  },
+  { 0, 0, 0, 0, 0, {0, {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 frv_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, {0}} },
+/* add$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_ADD, "add", "add", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* sub$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_SUB, "sub", "sub", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* and$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_AND, "and", "and", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* or$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_OR, "or", "or", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* xor$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_XOR, "xor", "xor", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* not$pack $GRj,$GRk */
+  {
+    FRV_INSN_NOT, "not", "not", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* sdiv$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_SDIV, "sdiv", "sdiv", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* nsdiv$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_NSDIV, "nsdiv", "nsdiv", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_MULT_DIV, FR400_MAJOR_NONE, FR500_MAJOR_I_1 } }
+  },
+/* udiv$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_UDIV, "udiv", "udiv", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* nudiv$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_NUDIV, "nudiv", "nudiv", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_MULT_DIV, FR400_MAJOR_NONE, FR500_MAJOR_I_1 } }
+  },
+/* smul$pack $GRi,$GRj,$GRdoublek */
+  {
+    FRV_INSN_SMUL, "smul", "smul", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* umul$pack $GRi,$GRj,$GRdoublek */
+  {
+    FRV_INSN_UMUL, "umul", "umul", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* sll$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_SLL, "sll", "sll", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* srl$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_SRL, "srl", "srl", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* sra$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_SRA, "sra", "sra", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* scan$pack $GRi,$GRj,$GRk */
+  {
+    FRV_INSN_SCAN, "scan", "scan", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* cadd$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CADD, "cadd", "cadd", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* csub$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CSUB, "csub", "csub", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* cand$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CAND, "cand", "cand", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* cor$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_COR, "cor", "cor", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* cxor$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CXOR, "cxor", "cxor", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* cnot$pack $GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CNOT, "cnot", "cnot", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* csmul$pack $GRi,$GRj,$GRdoublek,$CCi,$cond */
+  {
+    FRV_INSN_CSMUL, "csmul", "csmul", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* csdiv$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CSDIV, "csdiv", "csdiv", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* cudiv$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CUDIV, "cudiv", "cudiv", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* csll$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CSLL, "csll", "csll", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* csrl$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CSRL, "csrl", "csrl", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* csra$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CSRA, "csra", "csra", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* cscan$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CSCAN, "cscan", "cscan", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* addcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_ADDCC, "addcc", "addcc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* subcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_SUBCC, "subcc", "subcc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* andcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_ANDCC, "andcc", "andcc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* orcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_ORCC, "orcc", "orcc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* xorcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_XORCC, "xorcc", "xorcc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* sllcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_SLLCC, "sllcc", "sllcc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* srlcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_SRLCC, "srlcc", "srlcc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* sracc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_SRACC, "sracc", "sracc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* smulcc$pack $GRi,$GRj,$GRdoublek,$ICCi_1 */
+  {
+    FRV_INSN_SMULCC, "smulcc", "smulcc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* umulcc$pack $GRi,$GRj,$GRdoublek,$ICCi_1 */
+  {
+    FRV_INSN_UMULCC, "umulcc", "umulcc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* caddcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CADDCC, "caddcc", "caddcc", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* csubcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CSUBCC, "csubcc", "csubcc", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* csmulcc$pack $GRi,$GRj,$GRdoublek,$CCi,$cond */
+  {
+    FRV_INSN_CSMULCC, "csmulcc", "csmulcc", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* candcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CANDCC, "candcc", "candcc", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* corcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CORCC, "corcc", "corcc", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* cxorcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CXORCC, "cxorcc", "cxorcc", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* csllcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CSLLCC, "csllcc", "csllcc", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* csrlcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CSRLCC, "csrlcc", "csrlcc", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* csracc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CSRACC, "csracc", "csracc", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* addx$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_ADDX, "addx", "addx", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* subx$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_SUBX, "subx", "subx", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* addxcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_ADDXCC, "addxcc", "addxcc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* subxcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_SUBXCC, "subxcc", "subxcc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* addi$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_ADDI, "addi", "addi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* subi$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_SUBI, "subi", "subi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* andi$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_ANDI, "andi", "andi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* ori$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_ORI, "ori", "ori", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* xori$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_XORI, "xori", "xori", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* sdivi$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_SDIVI, "sdivi", "sdivi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* nsdivi$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_NSDIVI, "nsdivi", "nsdivi", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_MULT_DIV, FR400_MAJOR_NONE, FR500_MAJOR_I_1 } }
+  },
+/* udivi$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_UDIVI, "udivi", "udivi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* nudivi$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_NUDIVI, "nudivi", "nudivi", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_MULT_DIV, FR400_MAJOR_NONE, FR500_MAJOR_I_1 } }
+  },
+/* smuli$pack $GRi,$s12,$GRdoublek */
+  {
+    FRV_INSN_SMULI, "smuli", "smuli", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* umuli$pack $GRi,$s12,$GRdoublek */
+  {
+    FRV_INSN_UMULI, "umuli", "umuli", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* slli$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_SLLI, "slli", "slli", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* srli$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_SRLI, "srli", "srli", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* srai$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_SRAI, "srai", "srai", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* scani$pack $GRi,$s12,$GRk */
+  {
+    FRV_INSN_SCANI, "scani", "scani", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* addicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_ADDICC, "addicc", "addicc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* subicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_SUBICC, "subicc", "subicc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* andicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_ANDICC, "andicc", "andicc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* oricc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_ORICC, "oricc", "oricc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* xoricc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_XORICC, "xoricc", "xoricc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* smulicc$pack $GRi,$s10,$GRdoublek,$ICCi_1 */
+  {
+    FRV_INSN_SMULICC, "smulicc", "smulicc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* umulicc$pack $GRi,$s10,$GRdoublek,$ICCi_1 */
+  {
+    FRV_INSN_UMULICC, "umulicc", "umulicc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_MULT_DIV, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* sllicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_SLLICC, "sllicc", "sllicc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* srlicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_SRLICC, "srlicc", "srlicc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* sraicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_SRAICC, "sraicc", "sraicc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* addxi$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_ADDXI, "addxi", "addxi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* subxi$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_SUBXI, "subxi", "subxi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* addxicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_ADDXICC, "addxicc", "addxicc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* subxicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    FRV_INSN_SUBXICC, "subxicc", "subxicc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* cmpb$pack $GRi,$GRj,$ICCi_1 */
+  {
+    FRV_INSN_CMPB, "cmpb", "cmpb", 32,
+    { 0, { (1<<MACH_FR400), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_NONE } }
+  },
+/* cmpba$pack $GRi,$GRj,$ICCi_1 */
+  {
+    FRV_INSN_CMPBA, "cmpba", "cmpba", 32,
+    { 0, { (1<<MACH_FR400), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_NONE } }
+  },
+/* setlo$pack $ulo16,$GRklo */
+  {
+    FRV_INSN_SETLO, "setlo", "setlo", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* sethi$pack $uhi16,$GRkhi */
+  {
+    FRV_INSN_SETHI, "sethi", "sethi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* setlos$pack $slo16,$GRk */
+  {
+    FRV_INSN_SETLOS, "setlos", "setlos", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* ldsb$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_LDSB, "ldsb", "ldsb", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldub$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_LDUB, "ldub", "ldub", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldsh$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_LDSH, "ldsh", "ldsh", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* lduh$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_LDUH, "lduh", "lduh", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ld$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_LD, "ld", "ld", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldbf$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_LDBF, "ldbf", "ldbf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldhf$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_LDHF, "ldhf", "ldhf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldf$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_LDF, "ldf", "ldf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldc$pack @($GRi,$GRj),$CPRk */
+  {
+    FRV_INSN_LDC, "ldc", "ldc", 32,
+    { 0, { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldsb$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_NLDSB, "nldsb", "nldsb", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldub$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_NLDUB, "nldub", "nldub", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldsh$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_NLDSH, "nldsh", "nldsh", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nlduh$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_NLDUH, "nlduh", "nlduh", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nld$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_NLD, "nld", "nld", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldbf$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_NLDBF, "nldbf", "nldbf", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldhf$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_NLDHF, "nldhf", "nldhf", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldf$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_NLDF, "nldf", "nldf", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* ldd$pack @($GRi,$GRj),$GRdoublek */
+  {
+    FRV_INSN_LDD, "ldd", "ldd", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* lddf$pack @($GRi,$GRj),$FRdoublek */
+  {
+    FRV_INSN_LDDF, "lddf", "lddf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* lddc$pack @($GRi,$GRj),$CPRdoublek */
+  {
+    FRV_INSN_LDDC, "lddc", "lddc", 32,
+    { 0, { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* nldd$pack @($GRi,$GRj),$GRdoublek */
+  {
+    FRV_INSN_NLDD, "nldd", "nldd", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nlddf$pack @($GRi,$GRj),$FRdoublek */
+  {
+    FRV_INSN_NLDDF, "nlddf", "nlddf", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* ldq$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_LDQ, "ldq", "ldq", 32,
+    { 0, { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* ldqf$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_LDQF, "ldqf", "ldqf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* ldqc$pack @($GRi,$GRj),$CPRk */
+  {
+    FRV_INSN_LDQC, "ldqc", "ldqc", 32,
+    { 0, { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldq$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_NLDQ, "nldq", "nldq", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldqf$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_NLDQF, "nldqf", "nldqf", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* ldsbu$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_LDSBU, "ldsbu", "ldsbu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldubu$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_LDUBU, "ldubu", "ldubu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldshu$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_LDSHU, "ldshu", "ldshu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* lduhu$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_LDUHU, "lduhu", "lduhu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldu$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_LDU, "ldu", "ldu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* nldsbu$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_NLDSBU, "nldsbu", "nldsbu", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldubu$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_NLDUBU, "nldubu", "nldubu", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldshu$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_NLDSHU, "nldshu", "nldshu", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nlduhu$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_NLDUHU, "nlduhu", "nlduhu", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldu$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_NLDU, "nldu", "nldu", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* ldbfu$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_LDBFU, "ldbfu", "ldbfu", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldhfu$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_LDHFU, "ldhfu", "ldhfu", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldfu$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_LDFU, "ldfu", "ldfu", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldcu$pack @($GRi,$GRj),$CPRk */
+  {
+    FRV_INSN_LDCU, "ldcu", "ldcu", 32,
+    { 0, { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldbfu$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_NLDBFU, "nldbfu", "nldbfu", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldhfu$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_NLDHFU, "nldhfu", "nldhfu", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldfu$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_NLDFU, "nldfu", "nldfu", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* lddu$pack @($GRi,$GRj),$GRdoublek */
+  {
+    FRV_INSN_LDDU, "lddu", "lddu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* nlddu$pack @($GRi,$GRj),$GRdoublek */
+  {
+    FRV_INSN_NLDDU, "nlddu", "nlddu", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* lddfu$pack @($GRi,$GRj),$FRdoublek */
+  {
+    FRV_INSN_LDDFU, "lddfu", "lddfu", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* lddcu$pack @($GRi,$GRj),$CPRdoublek */
+  {
+    FRV_INSN_LDDCU, "lddcu", "lddcu", 32,
+    { 0, { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* nlddfu$pack @($GRi,$GRj),$FRdoublek */
+  {
+    FRV_INSN_NLDDFU, "nlddfu", "nlddfu", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* ldqu$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_LDQU, "ldqu", "ldqu", 32,
+    { 0, { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldqu$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_NLDQU, "nldqu", "nldqu", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* ldqfu$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_LDQFU, "ldqfu", "ldqfu", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* ldqcu$pack @($GRi,$GRj),$CPRk */
+  {
+    FRV_INSN_LDQCU, "ldqcu", "ldqcu", 32,
+    { 0, { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldqfu$pack @($GRi,$GRj),$FRintk */
+  {
+    FRV_INSN_NLDQFU, "nldqfu", "nldqfu", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* ldsbi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_LDSBI, "ldsbi", "ldsbi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldshi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_LDSHI, "ldshi", "ldshi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_LDI, "ldi", "ldi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldubi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_LDUBI, "ldubi", "ldubi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* lduhi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_LDUHI, "lduhi", "lduhi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldbfi$pack @($GRi,$d12),$FRintk */
+  {
+    FRV_INSN_LDBFI, "ldbfi", "ldbfi", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldhfi$pack @($GRi,$d12),$FRintk */
+  {
+    FRV_INSN_LDHFI, "ldhfi", "ldhfi", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* ldfi$pack @($GRi,$d12),$FRintk */
+  {
+    FRV_INSN_LDFI, "ldfi", "ldfi", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* nldsbi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_NLDSBI, "nldsbi", "nldsbi", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldubi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_NLDUBI, "nldubi", "nldubi", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldshi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_NLDSHI, "nldshi", "nldshi", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nlduhi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_NLDUHI, "nlduhi", "nlduhi", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_NLDI, "nldi", "nldi", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldbfi$pack @($GRi,$d12),$FRintk */
+  {
+    FRV_INSN_NLDBFI, "nldbfi", "nldbfi", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldhfi$pack @($GRi,$d12),$FRintk */
+  {
+    FRV_INSN_NLDHFI, "nldhfi", "nldhfi", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldfi$pack @($GRi,$d12),$FRintk */
+  {
+    FRV_INSN_NLDFI, "nldfi", "nldfi", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* lddi$pack @($GRi,$d12),$GRdoublek */
+  {
+    FRV_INSN_LDDI, "lddi", "lddi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* lddfi$pack @($GRi,$d12),$FRdoublek */
+  {
+    FRV_INSN_LDDFI, "lddfi", "lddfi", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* nlddi$pack @($GRi,$d12),$GRdoublek */
+  {
+    FRV_INSN_NLDDI, "nlddi", "nlddi", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nlddfi$pack @($GRi,$d12),$FRdoublek */
+  {
+    FRV_INSN_NLDDFI, "nlddfi", "nlddfi", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* ldqi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_LDQI, "ldqi", "ldqi", 32,
+    { 0, { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* ldqfi$pack @($GRi,$d12),$FRintk */
+  {
+    FRV_INSN_LDQFI, "ldqfi", "ldqfi", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldqi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_NLDQI, "nldqi", "nldqi", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* nldqfi$pack @($GRi,$d12),$FRintk */
+  {
+    FRV_INSN_NLDQFI, "nldqfi", "nldqfi", 32,
+    { 0|A(FR_ACCESS)|A(NON_EXCEPTING), { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* stb$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STB, "stb", "stb", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* sth$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STH, "sth", "sth", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* st$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_ST, "st", "st", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stbf$pack $FRintk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STBF, "stbf", "stbf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* sthf$pack $FRintk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STHF, "sthf", "sthf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stf$pack $FRintk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STF, "stf", "stf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stc$pack $CPRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STC, "stc", "stc", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* rstb$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_RSTB, "rstb", "rstb", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* rsth$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_RSTH, "rsth", "rsth", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* rst$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_RST, "rst", "rst", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* rstbf$pack $FRintk,@($GRi,$GRj) */
+  {
+    FRV_INSN_RSTBF, "rstbf", "rstbf", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* rsthf$pack $FRintk,@($GRi,$GRj) */
+  {
+    FRV_INSN_RSTHF, "rsthf", "rsthf", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* rstf$pack $FRintk,@($GRi,$GRj) */
+  {
+    FRV_INSN_RSTF, "rstf", "rstf", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* std$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STD, "std", "std", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stdf$pack $FRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STDF, "stdf", "stdf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stdc$pack $CPRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STDC, "stdc", "stdc", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* rstd$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_RSTD, "rstd", "rstd", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* rstdf$pack $FRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_RSTDF, "rstdf", "rstdf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* stq$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STQ, "stq", "stq", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* stqf$pack $FRintk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STQF, "stqf", "stqf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* stqc$pack $CPRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STQC, "stqc", "stqc", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* rstq$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_RSTQ, "rstq", "rstq", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* rstqf$pack $FRintk,@($GRi,$GRj) */
+  {
+    FRV_INSN_RSTQF, "rstqf", "rstqf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* stbu$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STBU, "stbu", "stbu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* sthu$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STHU, "sthu", "sthu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stu$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STU, "stu", "stu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stbfu$pack $FRintk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STBFU, "stbfu", "stbfu", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* sthfu$pack $FRintk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STHFU, "sthfu", "sthfu", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stfu$pack $FRintk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STFU, "stfu", "stfu", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stcu$pack $CPRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STCU, "stcu", "stcu", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stdu$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STDU, "stdu", "stdu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stdfu$pack $FRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STDFU, "stdfu", "stdfu", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stdcu$pack $CPRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STDCU, "stdcu", "stdcu", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stqu$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STQU, "stqu", "stqu", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* stqfu$pack $FRintk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STQFU, "stqfu", "stqfu", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* stqcu$pack $CPRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_STQCU, "stqcu", "stqcu", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* cldsb$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CLDSB, "cldsb", "cldsb", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldub$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CLDUB, "cldub", "cldub", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldsh$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CLDSH, "cldsh", "cldsh", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* clduh$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CLDUH, "clduh", "clduh", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cld$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CLD, "cld", "cld", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldbf$pack @($GRi,$GRj),$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CLDBF, "cldbf", "cldbf", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldhf$pack @($GRi,$GRj),$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CLDHF, "cldhf", "cldhf", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldf$pack @($GRi,$GRj),$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CLDF, "cldf", "cldf", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldd$pack @($GRi,$GRj),$GRdoublek,$CCi,$cond */
+  {
+    FRV_INSN_CLDD, "cldd", "cldd", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* clddf$pack @($GRi,$GRj),$FRdoublek,$CCi,$cond */
+  {
+    FRV_INSN_CLDDF, "clddf", "clddf", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldq$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CLDQ, "cldq", "cldq", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* cldsbu$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CLDSBU, "cldsbu", "cldsbu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldubu$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CLDUBU, "cldubu", "cldubu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldshu$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CLDSHU, "cldshu", "cldshu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* clduhu$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CLDUHU, "clduhu", "clduhu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldu$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CLDU, "cldu", "cldu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldbfu$pack @($GRi,$GRj),$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CLDBFU, "cldbfu", "cldbfu", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldhfu$pack @($GRi,$GRj),$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CLDHFU, "cldhfu", "cldhfu", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldfu$pack @($GRi,$GRj),$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CLDFU, "cldfu", "cldfu", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* clddu$pack @($GRi,$GRj),$GRdoublek,$CCi,$cond */
+  {
+    FRV_INSN_CLDDU, "clddu", "clddu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* clddfu$pack @($GRi,$GRj),$FRdoublek,$CCi,$cond */
+  {
+    FRV_INSN_CLDDFU, "clddfu", "clddfu", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_LOAD, FR400_MAJOR_I_2, FR500_MAJOR_I_2 } }
+  },
+/* cldqu$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CLDQU, "cldqu", "cldqu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_FRV), UNIT_LOAD, FR400_MAJOR_NONE, FR500_MAJOR_I_2 } }
+  },
+/* cstb$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTB, "cstb", "cstb", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* csth$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTH, "csth", "csth", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* cst$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CST, "cst", "cst", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* cstbf$pack $FRintk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTBF, "cstbf", "cstbf", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* csthf$pack $FRintk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTHF, "csthf", "csthf", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* cstf$pack $FRintk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTF, "cstf", "cstf", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* cstd$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTD, "cstd", "cstd", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* cstdf$pack $FRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTDF, "cstdf", "cstdf", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* cstq$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTQ, "cstq", "cstq", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* cstbu$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTBU, "cstbu", "cstbu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* csthu$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTHU, "csthu", "csthu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* cstu$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTU, "cstu", "cstu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* cstbfu$pack $FRintk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTBFU, "cstbfu", "cstbfu", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* csthfu$pack $FRintk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTHFU, "csthfu", "csthfu", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* cstfu$pack $FRintk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTFU, "cstfu", "cstfu", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* cstdu$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTDU, "cstdu", "cstdu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* cstdfu$pack $FRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CSTDFU, "cstdfu", "cstdfu", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stbi$pack $GRk,@($GRi,$d12) */
+  {
+    FRV_INSN_STBI, "stbi", "stbi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* sthi$pack $GRk,@($GRi,$d12) */
+  {
+    FRV_INSN_STHI, "sthi", "sthi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* sti$pack $GRk,@($GRi,$d12) */
+  {
+    FRV_INSN_STI, "sti", "sti", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stbfi$pack $FRintk,@($GRi,$d12) */
+  {
+    FRV_INSN_STBFI, "stbfi", "stbfi", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* sthfi$pack $FRintk,@($GRi,$d12) */
+  {
+    FRV_INSN_STHFI, "sthfi", "sthfi", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stfi$pack $FRintk,@($GRi,$d12) */
+  {
+    FRV_INSN_STFI, "stfi", "stfi", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stdi$pack $GRk,@($GRi,$d12) */
+  {
+    FRV_INSN_STDI, "stdi", "stdi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stdfi$pack $FRk,@($GRi,$d12) */
+  {
+    FRV_INSN_STDFI, "stdfi", "stdfi", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_3, FR500_MAJOR_I_3 } }
+  },
+/* stqi$pack $GRk,@($GRi,$d12) */
+  {
+    FRV_INSN_STQI, "stqi", "stqi", 32,
+    { 0, { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* stqfi$pack $FRintk,@($GRi,$d12) */
+  {
+    FRV_INSN_STQFI, "stqfi", "stqfi", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_3 } }
+  },
+/* swap$pack @($GRi,$GRj),$GRk */
+  {
+    FRV_INSN_SWAP, "swap", "swap", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* swapi$pack @($GRi,$d12),$GRk */
+  {
+    FRV_INSN_SWAPI, "swapi", "swapi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* cswap$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    FRV_INSN_CSWAP, "cswap", "cswap", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* movgf$pack $GRj,$FRintk */
+  {
+    FRV_INSN_MOVGF, "movgf", "movgf", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_4, FR500_MAJOR_I_4 } }
+  },
+/* movfg$pack $FRintk,$GRj */
+  {
+    FRV_INSN_MOVFG, "movfg", "movfg", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_4, FR500_MAJOR_I_4 } }
+  },
+/* movgfd$pack $GRj,$FRintk */
+  {
+    FRV_INSN_MOVGFD, "movgfd", "movgfd", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_4, FR500_MAJOR_I_4 } }
+  },
+/* movfgd$pack $FRintk,$GRj */
+  {
+    FRV_INSN_MOVFGD, "movfgd", "movfgd", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_4, FR500_MAJOR_I_4 } }
+  },
+/* movgfq$pack $GRj,$FRintk */
+  {
+    FRV_INSN_MOVGFQ, "movgfq", "movgfq", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_4 } }
+  },
+/* movfgq$pack $FRintk,$GRj */
+  {
+    FRV_INSN_MOVFGQ, "movfgq", "movfgq", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_FRV), UNIT_I0, FR400_MAJOR_NONE, FR500_MAJOR_I_4 } }
+  },
+/* cmovgf$pack $GRj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMOVGF, "cmovgf", "cmovgf", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_4, FR500_MAJOR_I_4 } }
+  },
+/* cmovfg$pack $FRintk,$GRj,$CCi,$cond */
+  {
+    FRV_INSN_CMOVFG, "cmovfg", "cmovfg", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_4, FR500_MAJOR_I_4 } }
+  },
+/* cmovgfd$pack $GRj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMOVGFD, "cmovgfd", "cmovgfd", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_4, FR500_MAJOR_I_4 } }
+  },
+/* cmovfgd$pack $FRintk,$GRj,$CCi,$cond */
+  {
+    FRV_INSN_CMOVFGD, "cmovfgd", "cmovfgd", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_4, FR500_MAJOR_I_4 } }
+  },
+/* movgs$pack $GRj,$spr */
+  {
+    FRV_INSN_MOVGS, "movgs", "movgs", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* movsg$pack $spr,$GRj */
+  {
+    FRV_INSN_MOVSG, "movsg", "movsg", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* bra$pack $hint_taken$label16 */
+  {
+    FRV_INSN_BRA, "bra", "bra", 32,
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bno$pack$hint_not_taken */
+  {
+    FRV_INSN_BNO, "bno", "bno", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* beq$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BEQ, "beq", "beq", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bne$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BNE, "bne", "bne", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* ble$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BLE, "ble", "ble", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bgt$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BGT, "bgt", "bgt", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* blt$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BLT, "blt", "blt", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bge$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BGE, "bge", "bge", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bls$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BLS, "bls", "bls", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bhi$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BHI, "bhi", "bhi", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bc$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BC, "bc", "bc", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bnc$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BNC, "bnc", "bnc", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bn$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BN, "bn", "bn", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bp$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BP, "bp", "bp", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bv$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BV, "bv", "bv", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bnv$pack $ICCi_2,$hint,$label16 */
+  {
+    FRV_INSN_BNV, "bnv", "bnv", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbra$pack $hint_taken$label16 */
+  {
+    FRV_INSN_FBRA, "fbra", "fbra", 32,
+    { 0|A(FR_ACCESS)|A(UNCOND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbno$pack$hint_not_taken */
+  {
+    FRV_INSN_FBNO, "fbno", "fbno", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbne$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBNE, "fbne", "fbne", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbeq$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBEQ, "fbeq", "fbeq", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fblg$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBLG, "fblg", "fblg", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbue$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBUE, "fbue", "fbue", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbul$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBUL, "fbul", "fbul", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbge$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBGE, "fbge", "fbge", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fblt$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBLT, "fblt", "fblt", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbuge$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBUGE, "fbuge", "fbuge", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbug$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBUG, "fbug", "fbug", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fble$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBLE, "fble", "fble", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbgt$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBGT, "fbgt", "fbgt", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbule$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBULE, "fbule", "fbule", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbu$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBU, "fbu", "fbu", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* fbo$pack $FCCi_2,$hint,$label16 */
+  {
+    FRV_INSN_FBO, "fbo", "fbo", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_1, FR500_MAJOR_B_1 } }
+  },
+/* bctrlr$pack $ccond,$hint */
+  {
+    FRV_INSN_BCTRLR, "bctrlr", "bctrlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bralr$pack$hint_taken */
+  {
+    FRV_INSN_BRALR, "bralr", "bralr", 32,
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bnolr$pack$hint_not_taken */
+  {
+    FRV_INSN_BNOLR, "bnolr", "bnolr", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* beqlr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BEQLR, "beqlr", "beqlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bnelr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BNELR, "bnelr", "bnelr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* blelr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BLELR, "blelr", "blelr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bgtlr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BGTLR, "bgtlr", "bgtlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bltlr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BLTLR, "bltlr", "bltlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bgelr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BGELR, "bgelr", "bgelr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* blslr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BLSLR, "blslr", "blslr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bhilr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BHILR, "bhilr", "bhilr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bclr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BCLR, "bclr", "bclr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bnclr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BNCLR, "bnclr", "bnclr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bnlr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BNLR, "bnlr", "bnlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bplr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BPLR, "bplr", "bplr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bvlr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BVLR, "bvlr", "bvlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bnvlr$pack $ICCi_2,$hint */
+  {
+    FRV_INSN_BNVLR, "bnvlr", "bnvlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbralr$pack$hint_taken */
+  {
+    FRV_INSN_FBRALR, "fbralr", "fbralr", 32,
+    { 0|A(FR_ACCESS)|A(UNCOND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbnolr$pack$hint_not_taken */
+  {
+    FRV_INSN_FBNOLR, "fbnolr", "fbnolr", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbeqlr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBEQLR, "fbeqlr", "fbeqlr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbnelr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBNELR, "fbnelr", "fbnelr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fblglr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBLGLR, "fblglr", "fblglr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbuelr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBUELR, "fbuelr", "fbuelr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbullr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBULLR, "fbullr", "fbullr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbgelr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBGELR, "fbgelr", "fbgelr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbltlr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBLTLR, "fbltlr", "fbltlr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbugelr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBUGELR, "fbugelr", "fbugelr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbuglr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBUGLR, "fbuglr", "fbuglr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fblelr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBLELR, "fblelr", "fblelr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbgtlr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBGTLR, "fbgtlr", "fbgtlr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbulelr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBULELR, "fbulelr", "fbulelr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbulr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBULR, "fbulr", "fbulr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* fbolr$pack $FCCi_2,$hint */
+  {
+    FRV_INSN_FBOLR, "fbolr", "fbolr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* bcralr$pack $ccond$hint_taken */
+  {
+    FRV_INSN_BCRALR, "bcralr", "bcralr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bcnolr$pack$hint_not_taken */
+  {
+    FRV_INSN_BCNOLR, "bcnolr", "bcnolr", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bceqlr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCEQLR, "bceqlr", "bceqlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bcnelr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCNELR, "bcnelr", "bcnelr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bclelr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCLELR, "bclelr", "bclelr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bcgtlr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCGTLR, "bcgtlr", "bcgtlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bcltlr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCLTLR, "bcltlr", "bcltlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bcgelr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCGELR, "bcgelr", "bcgelr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bclslr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCLSLR, "bclslr", "bclslr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bchilr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCHILR, "bchilr", "bchilr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bcclr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCCLR, "bcclr", "bcclr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bcnclr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCNCLR, "bcnclr", "bcnclr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bcnlr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCNLR, "bcnlr", "bcnlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bcplr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCPLR, "bcplr", "bcplr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bcvlr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCVLR, "bcvlr", "bcvlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* bcnvlr$pack $ICCi_2,$ccond,$hint */
+  {
+    FRV_INSN_BCNVLR, "bcnvlr", "bcnvlr", 32,
+    { 0|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbralr$pack $ccond$hint_taken */
+  {
+    FRV_INSN_FCBRALR, "fcbralr", "fcbralr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbnolr$pack$hint_not_taken */
+  {
+    FRV_INSN_FCBNOLR, "fcbnolr", "fcbnolr", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbeqlr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBEQLR, "fcbeqlr", "fcbeqlr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbnelr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBNELR, "fcbnelr", "fcbnelr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcblglr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBLGLR, "fcblglr", "fcblglr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbuelr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBUELR, "fcbuelr", "fcbuelr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbullr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBULLR, "fcbullr", "fcbullr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbgelr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBGELR, "fcbgelr", "fcbgelr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbltlr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBLTLR, "fcbltlr", "fcbltlr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbugelr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBUGELR, "fcbugelr", "fcbugelr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbuglr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBUGLR, "fcbuglr", "fcbuglr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcblelr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBLELR, "fcblelr", "fcblelr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbgtlr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBGTLR, "fcbgtlr", "fcbgtlr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbulelr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBULELR, "fcbulelr", "fcbulelr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbulr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBULR, "fcbulr", "fcbulr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* fcbolr$pack $FCCi_2,$ccond,$hint */
+  {
+    FRV_INSN_FCBOLR, "fcbolr", "fcbolr", 32,
+    { 0|A(FR_ACCESS)|A(COND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_2, FR500_MAJOR_B_2 } }
+  },
+/* jmpl$pack @($GRi,$GRj) */
+  {
+    FRV_INSN_JMPL, "jmpl", "jmpl", 32,
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_5, FR500_MAJOR_I_5 } }
+  },
+/* calll$pack @($GRi,$GRj) */
+  {
+    FRV_INSN_CALLL, "calll", "calll", 32,
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_5, FR500_MAJOR_I_5 } }
+  },
+/* jmpil$pack @($GRi,$s12) */
+  {
+    FRV_INSN_JMPIL, "jmpil", "jmpil", 32,
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_5, FR500_MAJOR_I_5 } }
+  },
+/* callil$pack @($GRi,$s12) */
+  {
+    FRV_INSN_CALLIL, "callil", "callil", 32,
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_5, FR500_MAJOR_I_5 } }
+  },
+/* call$pack $label24 */
+  {
+    FRV_INSN_CALL, "call", "call", 32,
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE), UNIT_B0, FR400_MAJOR_B_4, FR500_MAJOR_B_4 } }
+  },
+/* rett$pack $debug */
+  {
+    FRV_INSN_RETT, "rett", "rett", 32,
+    { 0|A(PRIVILEGED)|A(UNCOND_CTI), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* rei$pack $eir */
+  {
+    FRV_INSN_REI, "rei", "rei", 32,
+    { 0|A(PRIVILEGED), { (1<<MACH_FRV), UNIT_C, FR400_MAJOR_NONE, FR500_MAJOR_C_1 } }
+  },
+/* tra$pack $GRi,$GRj */
+  {
+    FRV_INSN_TRA, "tra", "tra", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tno$pack */
+  {
+    FRV_INSN_TNO, "tno", "tno", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* teq$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TEQ, "teq", "teq", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tne$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TNE, "tne", "tne", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tle$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TLE, "tle", "tle", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tgt$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TGT, "tgt", "tgt", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tlt$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TLT, "tlt", "tlt", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tge$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TGE, "tge", "tge", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tls$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TLS, "tls", "tls", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* thi$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_THI, "thi", "thi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tc$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TC, "tc", "tc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tnc$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TNC, "tnc", "tnc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tn$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TN, "tn", "tn", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tp$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TP, "tp", "tp", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tv$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TV, "tv", "tv", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tnv$pack $ICCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_TNV, "tnv", "tnv", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftra$pack $GRi,$GRj */
+  {
+    FRV_INSN_FTRA, "ftra", "ftra", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftno$pack */
+  {
+    FRV_INSN_FTNO, "ftno", "ftno", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftne$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTNE, "ftne", "ftne", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* fteq$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTEQ, "fteq", "fteq", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftlg$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTLG, "ftlg", "ftlg", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftue$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTUE, "ftue", "ftue", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftul$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTUL, "ftul", "ftul", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftge$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTGE, "ftge", "ftge", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftlt$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTLT, "ftlt", "ftlt", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftuge$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTUGE, "ftuge", "ftuge", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftug$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTUG, "ftug", "ftug", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftle$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTLE, "ftle", "ftle", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftgt$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTGT, "ftgt", "ftgt", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftule$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTULE, "ftule", "ftule", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftu$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTU, "ftu", "ftu", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* fto$pack $FCCi_2,$GRi,$GRj */
+  {
+    FRV_INSN_FTO, "fto", "fto", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tira$pack $GRi,$s12 */
+  {
+    FRV_INSN_TIRA, "tira", "tira", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tino$pack */
+  {
+    FRV_INSN_TINO, "tino", "tino", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tieq$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TIEQ, "tieq", "tieq", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tine$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TINE, "tine", "tine", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tile$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TILE, "tile", "tile", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tigt$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TIGT, "tigt", "tigt", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tilt$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TILT, "tilt", "tilt", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tige$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TIGE, "tige", "tige", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tils$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TILS, "tils", "tils", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tihi$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TIHI, "tihi", "tihi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tic$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TIC, "tic", "tic", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tinc$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TINC, "tinc", "tinc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tin$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TIN, "tin", "tin", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tip$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TIP, "tip", "tip", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tiv$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TIV, "tiv", "tiv", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* tinv$pack $ICCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_TINV, "tinv", "tinv", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftira$pack $GRi,$s12 */
+  {
+    FRV_INSN_FTIRA, "ftira", "ftira", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftino$pack */
+  {
+    FRV_INSN_FTINO, "ftino", "ftino", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftine$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTINE, "ftine", "ftine", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftieq$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTIEQ, "ftieq", "ftieq", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftilg$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTILG, "ftilg", "ftilg", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftiue$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTIUE, "ftiue", "ftiue", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftiul$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTIUL, "ftiul", "ftiul", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftige$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTIGE, "ftige", "ftige", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftilt$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTILT, "ftilt", "ftilt", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftiuge$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTIUGE, "ftiuge", "ftiuge", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftiug$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTIUG, "ftiug", "ftiug", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftile$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTILE, "ftile", "ftile", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftigt$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTIGT, "ftigt", "ftigt", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftiule$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTIULE, "ftiule", "ftiule", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftiu$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTIU, "ftiu", "ftiu", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* ftio$pack $FCCi_2,$GRi,$s12 */
+  {
+    FRV_INSN_FTIO, "ftio", "ftio", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* break$pack */
+  {
+    FRV_INSN_BREAK, "break", "break", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* mtrap$pack */
+  {
+    FRV_INSN_MTRAP, "mtrap", "mtrap", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_1, FR500_MAJOR_C_1 } }
+  },
+/* andcr$pack $CRi,$CRj,$CRk */
+  {
+    FRV_INSN_ANDCR, "andcr", "andcr", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_6, FR500_MAJOR_B_6 } }
+  },
+/* orcr$pack $CRi,$CRj,$CRk */
+  {
+    FRV_INSN_ORCR, "orcr", "orcr", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_6, FR500_MAJOR_B_6 } }
+  },
+/* xorcr$pack $CRi,$CRj,$CRk */
+  {
+    FRV_INSN_XORCR, "xorcr", "xorcr", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_6, FR500_MAJOR_B_6 } }
+  },
+/* nandcr$pack $CRi,$CRj,$CRk */
+  {
+    FRV_INSN_NANDCR, "nandcr", "nandcr", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_6, FR500_MAJOR_B_6 } }
+  },
+/* norcr$pack $CRi,$CRj,$CRk */
+  {
+    FRV_INSN_NORCR, "norcr", "norcr", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_6, FR500_MAJOR_B_6 } }
+  },
+/* andncr$pack $CRi,$CRj,$CRk */
+  {
+    FRV_INSN_ANDNCR, "andncr", "andncr", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_6, FR500_MAJOR_B_6 } }
+  },
+/* orncr$pack $CRi,$CRj,$CRk */
+  {
+    FRV_INSN_ORNCR, "orncr", "orncr", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_6, FR500_MAJOR_B_6 } }
+  },
+/* nandncr$pack $CRi,$CRj,$CRk */
+  {
+    FRV_INSN_NANDNCR, "nandncr", "nandncr", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_6, FR500_MAJOR_B_6 } }
+  },
+/* norncr$pack $CRi,$CRj,$CRk */
+  {
+    FRV_INSN_NORNCR, "norncr", "norncr", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_6, FR500_MAJOR_B_6 } }
+  },
+/* notcr$pack $CRj,$CRk */
+  {
+    FRV_INSN_NOTCR, "notcr", "notcr", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_6, FR500_MAJOR_B_6 } }
+  },
+/* ckra$pack $CRj_int */
+  {
+    FRV_INSN_CKRA, "ckra", "ckra", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ckno$pack $CRj_int */
+  {
+    FRV_INSN_CKNO, "ckno", "ckno", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ckeq$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKEQ, "ckeq", "ckeq", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ckne$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKNE, "ckne", "ckne", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ckle$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKLE, "ckle", "ckle", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ckgt$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKGT, "ckgt", "ckgt", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cklt$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKLT, "cklt", "cklt", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ckge$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKGE, "ckge", "ckge", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ckls$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKLS, "ckls", "ckls", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ckhi$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKHI, "ckhi", "ckhi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ckc$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKC, "ckc", "ckc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cknc$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKNC, "cknc", "cknc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ckn$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKN, "ckn", "ckn", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ckp$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKP, "ckp", "ckp", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ckv$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKV, "ckv", "ckv", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cknv$pack $ICCi_3,$CRj_int */
+  {
+    FRV_INSN_CKNV, "cknv", "cknv", 32,
+    { 0, { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fckra$pack $CRj_float */
+  {
+    FRV_INSN_FCKRA, "fckra", "fckra", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fckno$pack $CRj_float */
+  {
+    FRV_INSN_FCKNO, "fckno", "fckno", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fckne$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKNE, "fckne", "fckne", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fckeq$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKEQ, "fckeq", "fckeq", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fcklg$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKLG, "fcklg", "fcklg", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fckue$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKUE, "fckue", "fckue", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fckul$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKUL, "fckul", "fckul", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fckge$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKGE, "fckge", "fckge", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fcklt$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKLT, "fcklt", "fcklt", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fckuge$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKUGE, "fckuge", "fckuge", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fckug$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKUG, "fckug", "fckug", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fckle$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKLE, "fckle", "fckle", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fckgt$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKGT, "fckgt", "fckgt", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fckule$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKULE, "fckule", "fckule", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fcku$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKU, "fcku", "fcku", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* fcko$pack $FCCi_3,$CRj_float */
+  {
+    FRV_INSN_FCKO, "fcko", "fcko", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckra$pack $CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKRA, "cckra", "cckra", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckno$pack $CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKNO, "cckno", "cckno", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckeq$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKEQ, "cckeq", "cckeq", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckne$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKNE, "cckne", "cckne", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckle$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKLE, "cckle", "cckle", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckgt$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKGT, "cckgt", "cckgt", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ccklt$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKLT, "ccklt", "ccklt", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckge$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKGE, "cckge", "cckge", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckls$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKLS, "cckls", "cckls", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckhi$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKHI, "cckhi", "cckhi", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckc$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKC, "cckc", "cckc", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ccknc$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKNC, "ccknc", "ccknc", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckn$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKN, "cckn", "cckn", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckp$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKP, "cckp", "cckp", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cckv$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKV, "cckv", "cckv", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* ccknv$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    FRV_INSN_CCKNV, "ccknv", "ccknv", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfckra$pack $CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKRA, "cfckra", "cfckra", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfckno$pack $CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKNO, "cfckno", "cfckno", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfckne$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKNE, "cfckne", "cfckne", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfckeq$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKEQ, "cfckeq", "cfckeq", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfcklg$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKLG, "cfcklg", "cfcklg", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfckue$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKUE, "cfckue", "cfckue", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfckul$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKUL, "cfckul", "cfckul", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfckge$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKGE, "cfckge", "cfckge", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfcklt$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKLT, "cfcklt", "cfcklt", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfckuge$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKUGE, "cfckuge", "cfckuge", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfckug$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKUG, "cfckug", "cfckug", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfckle$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKLE, "cfckle", "cfckle", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfckgt$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKGT, "cfckgt", "cfckgt", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfckule$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKULE, "cfckule", "cfckule", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfcku$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKU, "cfcku", "cfcku", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cfcko$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    FRV_INSN_CFCKO, "cfcko", "cfcko", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_5, FR500_MAJOR_B_5 } }
+  },
+/* cjmpl$pack @($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CJMPL, "cjmpl", "cjmpl", 32,
+    { 0|A(CONDITIONAL)|A(COND_CTI), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_5, FR500_MAJOR_I_5 } }
+  },
+/* ccalll$pack @($GRi,$GRj),$CCi,$cond */
+  {
+    FRV_INSN_CCALLL, "ccalll", "ccalll", 32,
+    { 0|A(CONDITIONAL)|A(COND_CTI), { (1<<MACH_BASE), UNIT_I0, FR400_MAJOR_I_5, FR500_MAJOR_I_5 } }
+  },
+/* ici$pack @($GRi,$GRj) */
+  {
+    FRV_INSN_ICI, "ici", "ici", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* dci$pack @($GRi,$GRj) */
+  {
+    FRV_INSN_DCI, "dci", "dci", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* icei$pack @($GRi,$GRj),$ae */
+  {
+    FRV_INSN_ICEI, "icei", "icei", 32,
+    { 0, { (1<<MACH_FR400), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_NONE } }
+  },
+/* dcei$pack @($GRi,$GRj),$ae */
+  {
+    FRV_INSN_DCEI, "dcei", "dcei", 32,
+    { 0, { (1<<MACH_FR400), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_NONE } }
+  },
+/* dcf$pack @($GRi,$GRj) */
+  {
+    FRV_INSN_DCF, "dcf", "dcf", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* dcef$pack @($GRi,$GRj),$ae */
+  {
+    FRV_INSN_DCEF, "dcef", "dcef", 32,
+    { 0, { (1<<MACH_FR400), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_NONE } }
+  },
+/* witlb$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_WITLB, "witlb", "witlb", 32,
+    { 0|A(PRIVILEGED), { (1<<MACH_FRV), UNIT_C, FR400_MAJOR_NONE, FR500_MAJOR_C_2 } }
+  },
+/* wdtlb$pack $GRk,@($GRi,$GRj) */
+  {
+    FRV_INSN_WDTLB, "wdtlb", "wdtlb", 32,
+    { 0|A(PRIVILEGED), { (1<<MACH_FRV), UNIT_C, FR400_MAJOR_NONE, FR500_MAJOR_C_2 } }
+  },
+/* itlbi$pack @($GRi,$GRj) */
+  {
+    FRV_INSN_ITLBI, "itlbi", "itlbi", 32,
+    { 0|A(PRIVILEGED), { (1<<MACH_FRV), UNIT_C, FR400_MAJOR_NONE, FR500_MAJOR_C_2 } }
+  },
+/* dtlbi$pack @($GRi,$GRj) */
+  {
+    FRV_INSN_DTLBI, "dtlbi", "dtlbi", 32,
+    { 0|A(PRIVILEGED), { (1<<MACH_FRV), UNIT_C, FR400_MAJOR_NONE, FR500_MAJOR_C_2 } }
+  },
+/* icpl$pack $GRi,$GRj,$lock */
+  {
+    FRV_INSN_ICPL, "icpl", "icpl", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* dcpl$pack $GRi,$GRj,$lock */
+  {
+    FRV_INSN_DCPL, "dcpl", "dcpl", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* icul$pack $GRi */
+  {
+    FRV_INSN_ICUL, "icul", "icul", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* dcul$pack $GRi */
+  {
+    FRV_INSN_DCUL, "dcul", "dcul", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* bar$pack */
+  {
+    FRV_INSN_BAR, "bar", "bar", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* membar$pack */
+  {
+    FRV_INSN_MEMBAR, "membar", "membar", 32,
+    { 0, { (1<<MACH_BASE), UNIT_C, FR400_MAJOR_C_2, FR500_MAJOR_C_2 } }
+  },
+/* cop1$pack $s6_1,$CPRi,$CPRj,$CPRk */
+  {
+    FRV_INSN_COP1, "cop1", "cop1", 32,
+    { 0, { (1<<MACH_FRV), UNIT_C, FR400_MAJOR_NONE, FR500_MAJOR_C_2 } }
+  },
+/* cop2$pack $s6_1,$CPRi,$CPRj,$CPRk */
+  {
+    FRV_INSN_COP2, "cop2", "cop2", 32,
+    { 0, { (1<<MACH_FRV), UNIT_C, FR400_MAJOR_NONE, FR500_MAJOR_C_2 } }
+  },
+/* clrgr$pack $GRk */
+  {
+    FRV_INSN_CLRGR, "clrgr", "clrgr", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_I01, FR400_MAJOR_NONE, FR500_MAJOR_I_6 } }
+  },
+/* clrfr$pack $FRk */
+  {
+    FRV_INSN_CLRFR, "clrfr", "clrfr", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_I01, FR400_MAJOR_NONE, FR500_MAJOR_I_6 } }
+  },
+/* clrga$pack */
+  {
+    FRV_INSN_CLRGA, "clrga", "clrga", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_I01, FR400_MAJOR_NONE, FR500_MAJOR_I_6 } }
+  },
+/* clrfa$pack */
+  {
+    FRV_INSN_CLRFA, "clrfa", "clrfa", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_I01, FR400_MAJOR_NONE, FR500_MAJOR_I_6 } }
+  },
+/* commitgr$pack $GRk */
+  {
+    FRV_INSN_COMMITGR, "commitgr", "commitgr", 32,
+    { 0, { (1<<MACH_FRV)|(1<<MACH_FR500), UNIT_I01, FR400_MAJOR_NONE, FR500_MAJOR_I_6 } }
+  },
+/* commitfr$pack $FRk */
+  {
+    FRV_INSN_COMMITFR, "commitfr", "commitfr", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_FRV)|(1<<MACH_FR500), UNIT_I01, FR400_MAJOR_NONE, FR500_MAJOR_I_6 } }
+  },
+/* commitga$pack */
+  {
+    FRV_INSN_COMMITGA, "commitga", "commitga", 32,
+    { 0, { (1<<MACH_FRV)|(1<<MACH_FR500), UNIT_I01, FR400_MAJOR_NONE, FR500_MAJOR_I_6 } }
+  },
+/* commitfa$pack */
+  {
+    FRV_INSN_COMMITFA, "commitfa", "commitfa", 32,
+    { 0|A(FR_ACCESS), { (1<<MACH_FRV)|(1<<MACH_FR500), UNIT_I01, FR400_MAJOR_NONE, FR500_MAJOR_I_6 } }
+  },
+/* fitos$pack $FRintj,$FRk */
+  {
+    FRV_INSN_FITOS, "fitos", "fitos", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fstoi$pack $FRj,$FRintk */
+  {
+    FRV_INSN_FSTOI, "fstoi", "fstoi", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fitod$pack $FRintj,$FRdoublek */
+  {
+    FRV_INSN_FITOD, "fitod", "fitod", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fdtoi$pack $FRdoublej,$FRintk */
+  {
+    FRV_INSN_FDTOI, "fdtoi", "fdtoi", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fditos$pack $FRintj,$FRk */
+  {
+    FRV_INSN_FDITOS, "fditos", "fditos", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fdstoi$pack $FRj,$FRintk */
+  {
+    FRV_INSN_FDSTOI, "fdstoi", "fdstoi", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* nfditos$pack $FRintj,$FRk */
+  {
+    FRV_INSN_NFDITOS, "nfditos", "nfditos", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* nfdstoi$pack $FRj,$FRintk */
+  {
+    FRV_INSN_NFDSTOI, "nfdstoi", "nfdstoi", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* cfitos$pack $FRintj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFITOS, "cfitos", "cfitos", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* cfstoi$pack $FRj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CFSTOI, "cfstoi", "cfstoi", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* nfitos$pack $FRintj,$FRk */
+  {
+    FRV_INSN_NFITOS, "nfitos", "nfitos", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* nfstoi$pack $FRj,$FRintk */
+  {
+    FRV_INSN_NFSTOI, "nfstoi", "nfstoi", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fmovs$pack $FRj,$FRk */
+  {
+    FRV_INSN_FMOVS, "fmovs", "fmovs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fmovd$pack $FRdoublej,$FRdoublek */
+  {
+    FRV_INSN_FMOVD, "fmovd", "fmovd", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fdmovs$pack $FRj,$FRk */
+  {
+    FRV_INSN_FDMOVS, "fdmovs", "fdmovs", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* cfmovs$pack $FRj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFMOVS, "cfmovs", "cfmovs", 32,
+    { 0|A(FR_ACCESS)|A(CONDITIONAL), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fnegs$pack $FRj,$FRk */
+  {
+    FRV_INSN_FNEGS, "fnegs", "fnegs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fnegd$pack $FRdoublej,$FRdoublek */
+  {
+    FRV_INSN_FNEGD, "fnegd", "fnegd", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fdnegs$pack $FRj,$FRk */
+  {
+    FRV_INSN_FDNEGS, "fdnegs", "fdnegs", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* cfnegs$pack $FRj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFNEGS, "cfnegs", "cfnegs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fabss$pack $FRj,$FRk */
+  {
+    FRV_INSN_FABSS, "fabss", "fabss", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fabsd$pack $FRdoublej,$FRdoublek */
+  {
+    FRV_INSN_FABSD, "fabsd", "fabsd", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fdabss$pack $FRj,$FRk */
+  {
+    FRV_INSN_FDABSS, "fdabss", "fdabss", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* cfabss$pack $FRj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFABSS, "cfabss", "cfabss", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_1 } }
+  },
+/* fsqrts$pack $FRj,$FRk */
+  {
+    FRV_INSN_FSQRTS, "fsqrts", "fsqrts", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_4 } }
+  },
+/* fdsqrts$pack $FRj,$FRk */
+  {
+    FRV_INSN_FDSQRTS, "fdsqrts", "fdsqrts", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_4 } }
+  },
+/* nfdsqrts$pack $FRj,$FRk */
+  {
+    FRV_INSN_NFDSQRTS, "nfdsqrts", "nfdsqrts", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_4 } }
+  },
+/* fsqrtd$pack $FRdoublej,$FRdoublek */
+  {
+    FRV_INSN_FSQRTD, "fsqrtd", "fsqrtd", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_4 } }
+  },
+/* cfsqrts$pack $FRj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFSQRTS, "cfsqrts", "cfsqrts", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_4 } }
+  },
+/* nfsqrts$pack $FRj,$FRk */
+  {
+    FRV_INSN_NFSQRTS, "nfsqrts", "nfsqrts", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_4 } }
+  },
+/* fadds$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FADDS, "fadds", "fadds", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_2 } }
+  },
+/* fsubs$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FSUBS, "fsubs", "fsubs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_2 } }
+  },
+/* fmuls$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FMULS, "fmuls", "fmuls", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_3 } }
+  },
+/* fdivs$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FDIVS, "fdivs", "fdivs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_4 } }
+  },
+/* faddd$pack $FRdoublei,$FRdoublej,$FRdoublek */
+  {
+    FRV_INSN_FADDD, "faddd", "faddd", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_2 } }
+  },
+/* fsubd$pack $FRdoublei,$FRdoublej,$FRdoublek */
+  {
+    FRV_INSN_FSUBD, "fsubd", "fsubd", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_2 } }
+  },
+/* fmuld$pack $FRdoublei,$FRdoublej,$FRdoublek */
+  {
+    FRV_INSN_FMULD, "fmuld", "fmuld", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_3 } }
+  },
+/* fdivd$pack $FRdoublei,$FRdoublej,$FRdoublek */
+  {
+    FRV_INSN_FDIVD, "fdivd", "fdivd", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_4 } }
+  },
+/* cfadds$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFADDS, "cfadds", "cfadds", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_2 } }
+  },
+/* cfsubs$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFSUBS, "cfsubs", "cfsubs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_2 } }
+  },
+/* cfmuls$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFMULS, "cfmuls", "cfmuls", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_3 } }
+  },
+/* cfdivs$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFDIVS, "cfdivs", "cfdivs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_4 } }
+  },
+/* nfadds$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFADDS, "nfadds", "nfadds", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_2 } }
+  },
+/* nfsubs$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFSUBS, "nfsubs", "nfsubs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_2 } }
+  },
+/* nfmuls$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFMULS, "nfmuls", "nfmuls", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_3 } }
+  },
+/* nfdivs$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFDIVS, "nfdivs", "nfdivs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_4 } }
+  },
+/* fcmps$pack $FRi,$FRj,$FCCi_2 */
+  {
+    FRV_INSN_FCMPS, "fcmps", "fcmps", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_2 } }
+  },
+/* fcmpd$pack $FRdoublei,$FRdoublej,$FCCi_2 */
+  {
+    FRV_INSN_FCMPD, "fcmpd", "fcmpd", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_2 } }
+  },
+/* cfcmps$pack $FRi,$FRj,$FCCi_2,$CCi,$cond */
+  {
+    FRV_INSN_CFCMPS, "cfcmps", "cfcmps", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_2 } }
+  },
+/* fdcmps$pack $FRi,$FRj,$FCCi_2 */
+  {
+    FRV_INSN_FDCMPS, "fdcmps", "fdcmps", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_6 } }
+  },
+/* fmadds$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FMADDS, "fmadds", "fmadds", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* fmsubs$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FMSUBS, "fmsubs", "fmsubs", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* fmaddd$pack $FRdoublei,$FRdoublej,$FRdoublek */
+  {
+    FRV_INSN_FMADDD, "fmaddd", "fmaddd", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* fmsubd$pack $FRdoublei,$FRdoublej,$FRdoublek */
+  {
+    FRV_INSN_FMSUBD, "fmsubd", "fmsubd", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* fdmadds$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FDMADDS, "fdmadds", "fdmadds", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* nfdmadds$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFDMADDS, "nfdmadds", "nfdmadds", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* cfmadds$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFMADDS, "cfmadds", "cfmadds", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* cfmsubs$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFMSUBS, "cfmsubs", "cfmsubs", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* nfmadds$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFMADDS, "nfmadds", "nfmadds", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* nfmsubs$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFMSUBS, "nfmsubs", "nfmsubs", 32,
+    { 0|A(NON_EXCEPTING), { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* fmas$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FMAS, "fmas", "fmas", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* fmss$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FMSS, "fmss", "fmss", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* fdmas$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FDMAS, "fdmas", "fdmas", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* fdmss$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FDMSS, "fdmss", "fdmss", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* nfdmas$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFDMAS, "nfdmas", "nfdmas", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* nfdmss$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFDMSS, "nfdmss", "nfdmss", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* cfmas$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFMAS, "cfmas", "cfmas", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* cfmss$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    FRV_INSN_CFMSS, "cfmss", "cfmss", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* fmad$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FMAD, "fmad", "fmad", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* fmsd$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FMSD, "fmsd", "fmsd", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* nfmas$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFMAS, "nfmas", "nfmas", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* nfmss$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFMSS, "nfmss", "nfmss", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_5 } }
+  },
+/* fdadds$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FDADDS, "fdadds", "fdadds", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_6 } }
+  },
+/* fdsubs$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FDSUBS, "fdsubs", "fdsubs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_6 } }
+  },
+/* fdmuls$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FDMULS, "fdmuls", "fdmuls", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_7 } }
+  },
+/* fddivs$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FDDIVS, "fddivs", "fddivs", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_7 } }
+  },
+/* fdsads$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FDSADS, "fdsads", "fdsads", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_6 } }
+  },
+/* fdmulcs$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_FDMULCS, "fdmulcs", "fdmulcs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_7 } }
+  },
+/* nfdmulcs$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFDMULCS, "nfdmulcs", "nfdmulcs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_7 } }
+  },
+/* nfdadds$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFDADDS, "nfdadds", "nfdadds", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_6 } }
+  },
+/* nfdsubs$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFDSUBS, "nfdsubs", "nfdsubs", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_6 } }
+  },
+/* nfdmuls$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFDMULS, "nfdmuls", "nfdmuls", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_7 } }
+  },
+/* nfddivs$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFDDIVS, "nfddivs", "nfddivs", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_7 } }
+  },
+/* nfdsads$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_NFDSADS, "nfdsads", "nfdsads", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_6 } }
+  },
+/* nfdcmps$pack $FRi,$FRj,$FCCi_2 */
+  {
+    FRV_INSN_NFDCMPS, "nfdcmps", "nfdcmps", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_6 } }
+  },
+/* mhsetlos$pack $u12,$FRklo */
+  {
+    FRV_INSN_MHSETLOS, "mhsetlos", "mhsetlos", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_NONE } }
+  },
+/* mhsethis$pack $u12,$FRkhi */
+  {
+    FRV_INSN_MHSETHIS, "mhsethis", "mhsethis", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_NONE } }
+  },
+/* mhdsets$pack $u12,$FRintk */
+  {
+    FRV_INSN_MHDSETS, "mhdsets", "mhdsets", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_NONE } }
+  },
+/* mhsetloh$pack $s5,$FRklo */
+  {
+    FRV_INSN_MHSETLOH, "mhsetloh", "mhsetloh", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_NONE } }
+  },
+/* mhsethih$pack $s5,$FRkhi */
+  {
+    FRV_INSN_MHSETHIH, "mhsethih", "mhsethih", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_NONE } }
+  },
+/* mhdseth$pack $s5,$FRintk */
+  {
+    FRV_INSN_MHDSETH, "mhdseth", "mhdseth", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_NONE } }
+  },
+/* mand$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MAND, "mand", "mand", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* mor$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MOR, "mor", "mor", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* mxor$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MXOR, "mxor", "mxor", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* cmand$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMAND, "cmand", "cmand", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* cmor$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMOR, "cmor", "cmor", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* cmxor$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMXOR, "cmxor", "cmxor", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* mnot$pack $FRintj,$FRintk */
+  {
+    FRV_INSN_MNOT, "mnot", "mnot", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* cmnot$pack $FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMNOT, "cmnot", "cmnot", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* mrotli$pack $FRinti,$u6,$FRintk */
+  {
+    FRV_INSN_MROTLI, "mrotli", "mrotli", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* mrotri$pack $FRinti,$u6,$FRintk */
+  {
+    FRV_INSN_MROTRI, "mrotri", "mrotri", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* mwcut$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MWCUT, "mwcut", "mwcut", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_2 } }
+  },
+/* mwcuti$pack $FRinti,$u6,$FRintk */
+  {
+    FRV_INSN_MWCUTI, "mwcuti", "mwcuti", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_2 } }
+  },
+/* mcut$pack $ACC40Si,$FRintj,$FRintk */
+  {
+    FRV_INSN_MCUT, "mcut", "mcut", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* mcuti$pack $ACC40Si,$s6,$FRintk */
+  {
+    FRV_INSN_MCUTI, "mcuti", "mcuti", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* mcutss$pack $ACC40Si,$FRintj,$FRintk */
+  {
+    FRV_INSN_MCUTSS, "mcutss", "mcutss", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* mcutssi$pack $ACC40Si,$s6,$FRintk */
+  {
+    FRV_INSN_MCUTSSI, "mcutssi", "mcutssi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* mdcutssi$pack $ACC40Si,$s6,$FRintk */
+  {
+    FRV_INSN_MDCUTSSI, "mdcutssi", "mdcutssi", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM0, FR400_MAJOR_M_2, FR500_MAJOR_NONE } }
+  },
+/* maveh$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MAVEH, "maveh", "maveh", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* msllhi$pack $FRinti,$u6,$FRintk */
+  {
+    FRV_INSN_MSLLHI, "msllhi", "msllhi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* msrlhi$pack $FRinti,$u6,$FRintk */
+  {
+    FRV_INSN_MSRLHI, "msrlhi", "msrlhi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* msrahi$pack $FRinti,$u6,$FRintk */
+  {
+    FRV_INSN_MSRAHI, "msrahi", "msrahi", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* mdrotli$pack $FRinti,$u6,$FRintk */
+  {
+    FRV_INSN_MDROTLI, "mdrotli", "mdrotli", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM0, FR400_MAJOR_M_2, FR500_MAJOR_NONE } }
+  },
+/* mcplhi$pack $FRinti,$u6,$FRintk */
+  {
+    FRV_INSN_MCPLHI, "mcplhi", "mcplhi", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM0, FR400_MAJOR_M_2, FR500_MAJOR_NONE } }
+  },
+/* mcpli$pack $FRinti,$u6,$FRintk */
+  {
+    FRV_INSN_MCPLI, "mcpli", "mcpli", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM0, FR400_MAJOR_M_2, FR500_MAJOR_NONE } }
+  },
+/* msaths$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MSATHS, "msaths", "msaths", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* mqsaths$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MQSATHS, "mqsaths", "mqsaths", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_NONE } }
+  },
+/* msathu$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MSATHU, "msathu", "msathu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* mcmpsh$pack $FRinti,$FRintj,$FCCk */
+  {
+    FRV_INSN_MCMPSH, "mcmpsh", "mcmpsh", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* mcmpuh$pack $FRinti,$FRintj,$FCCk */
+  {
+    FRV_INSN_MCMPUH, "mcmpuh", "mcmpuh", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* mabshs$pack $FRintj,$FRintk */
+  {
+    FRV_INSN_MABSHS, "mabshs", "mabshs", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_NONE } }
+  },
+/* maddhss$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MADDHSS, "maddhss", "maddhss", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* maddhus$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MADDHUS, "maddhus", "maddhus", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* msubhss$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MSUBHSS, "msubhss", "msubhss", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* msubhus$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MSUBHUS, "msubhus", "msubhus", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* cmaddhss$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMADDHSS, "cmaddhss", "cmaddhss", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* cmaddhus$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMADDHUS, "cmaddhus", "cmaddhus", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* cmsubhss$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMSUBHSS, "cmsubhss", "cmsubhss", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* cmsubhus$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMSUBHUS, "cmsubhus", "cmsubhus", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_1 } }
+  },
+/* mqaddhss$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MQADDHSS, "mqaddhss", "mqaddhss", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_1 } }
+  },
+/* mqaddhus$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MQADDHUS, "mqaddhus", "mqaddhus", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_1 } }
+  },
+/* mqsubhss$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MQSUBHSS, "mqsubhss", "mqsubhss", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_1 } }
+  },
+/* mqsubhus$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MQSUBHUS, "mqsubhus", "mqsubhus", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_1 } }
+  },
+/* cmqaddhss$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMQADDHSS, "cmqaddhss", "cmqaddhss", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_1 } }
+  },
+/* cmqaddhus$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMQADDHUS, "cmqaddhus", "cmqaddhus", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_1 } }
+  },
+/* cmqsubhss$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMQSUBHSS, "cmqsubhss", "cmqsubhss", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_1 } }
+  },
+/* cmqsubhus$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMQSUBHUS, "cmqsubhus", "cmqsubhus", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_1 } }
+  },
+/* maddaccs$pack $ACC40Si,$ACC40Sk */
+  {
+    FRV_INSN_MADDACCS, "maddaccs", "maddaccs", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_NONE } }
+  },
+/* msubaccs$pack $ACC40Si,$ACC40Sk */
+  {
+    FRV_INSN_MSUBACCS, "msubaccs", "msubaccs", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_NONE } }
+  },
+/* mdaddaccs$pack $ACC40Si,$ACC40Sk */
+  {
+    FRV_INSN_MDADDACCS, "mdaddaccs", "mdaddaccs", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM0, FR400_MAJOR_M_2, FR500_MAJOR_NONE } }
+  },
+/* mdsubaccs$pack $ACC40Si,$ACC40Sk */
+  {
+    FRV_INSN_MDSUBACCS, "mdsubaccs", "mdsubaccs", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM0, FR400_MAJOR_M_2, FR500_MAJOR_NONE } }
+  },
+/* masaccs$pack $ACC40Si,$ACC40Sk */
+  {
+    FRV_INSN_MASACCS, "masaccs", "masaccs", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_NONE } }
+  },
+/* mdasaccs$pack $ACC40Si,$ACC40Sk */
+  {
+    FRV_INSN_MDASACCS, "mdasaccs", "mdasaccs", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM0, FR400_MAJOR_M_2, FR500_MAJOR_NONE } }
+  },
+/* mmulhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MMULHS, "mmulhs", "mmulhs", 32,
+    { 0|A(PRESERVE_OVF), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* mmulhu$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MMULHU, "mmulhu", "mmulhu", 32,
+    { 0|A(PRESERVE_OVF), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* mmulxhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MMULXHS, "mmulxhs", "mmulxhs", 32,
+    { 0|A(PRESERVE_OVF), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* mmulxhu$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MMULXHU, "mmulxhu", "mmulxhu", 32,
+    { 0|A(PRESERVE_OVF), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* cmmulhs$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    FRV_INSN_CMMULHS, "cmmulhs", "cmmulhs", 32,
+    { 0|A(CONDITIONAL)|A(PRESERVE_OVF), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* cmmulhu$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    FRV_INSN_CMMULHU, "cmmulhu", "cmmulhu", 32,
+    { 0|A(CONDITIONAL)|A(PRESERVE_OVF), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* mqmulhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MQMULHS, "mqmulhs", "mqmulhs", 32,
+    { 0|A(PRESERVE_OVF), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* mqmulhu$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MQMULHU, "mqmulhu", "mqmulhu", 32,
+    { 0|A(PRESERVE_OVF), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* mqmulxhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MQMULXHS, "mqmulxhs", "mqmulxhs", 32,
+    { 0|A(PRESERVE_OVF), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* mqmulxhu$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MQMULXHU, "mqmulxhu", "mqmulxhu", 32,
+    { 0|A(PRESERVE_OVF), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* cmqmulhs$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    FRV_INSN_CMQMULHS, "cmqmulhs", "cmqmulhs", 32,
+    { 0|A(CONDITIONAL)|A(PRESERVE_OVF), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* cmqmulhu$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    FRV_INSN_CMQMULHU, "cmqmulhu", "cmqmulhu", 32,
+    { 0|A(CONDITIONAL)|A(PRESERVE_OVF), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* mmachs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MMACHS, "mmachs", "mmachs", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* mmachu$pack $FRinti,$FRintj,$ACC40Uk */
+  {
+    FRV_INSN_MMACHU, "mmachu", "mmachu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* mmrdhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MMRDHS, "mmrdhs", "mmrdhs", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* mmrdhu$pack $FRinti,$FRintj,$ACC40Uk */
+  {
+    FRV_INSN_MMRDHU, "mmrdhu", "mmrdhu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* cmmachs$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    FRV_INSN_CMMACHS, "cmmachs", "cmmachs", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* cmmachu$pack $FRinti,$FRintj,$ACC40Uk,$CCi,$cond */
+  {
+    FRV_INSN_CMMACHU, "cmmachu", "cmmachu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* mqmachs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MQMACHS, "mqmachs", "mqmachs", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* mqmachu$pack $FRinti,$FRintj,$ACC40Uk */
+  {
+    FRV_INSN_MQMACHU, "mqmachu", "mqmachu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* cmqmachs$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    FRV_INSN_CMQMACHS, "cmqmachs", "cmqmachs", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* cmqmachu$pack $FRinti,$FRintj,$ACC40Uk,$CCi,$cond */
+  {
+    FRV_INSN_CMQMACHU, "cmqmachu", "cmqmachu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* mqxmachs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MQXMACHS, "mqxmachs", "mqxmachs", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM0, FR400_MAJOR_M_2, FR500_MAJOR_NONE } }
+  },
+/* mqxmacxhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MQXMACXHS, "mqxmacxhs", "mqxmacxhs", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM0, FR400_MAJOR_M_2, FR500_MAJOR_NONE } }
+  },
+/* mqmacxhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MQMACXHS, "mqmacxhs", "mqmacxhs", 32,
+    { 0, { (1<<MACH_FR400), UNIT_FM0, FR400_MAJOR_M_2, FR500_MAJOR_NONE } }
+  },
+/* mcpxrs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MCPXRS, "mcpxrs", "mcpxrs", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* mcpxru$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MCPXRU, "mcpxru", "mcpxru", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* mcpxis$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MCPXIS, "mcpxis", "mcpxis", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* mcpxiu$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MCPXIU, "mcpxiu", "mcpxiu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* cmcpxrs$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    FRV_INSN_CMCPXRS, "cmcpxrs", "cmcpxrs", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* cmcpxru$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    FRV_INSN_CMCPXRU, "cmcpxru", "cmcpxru", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* cmcpxis$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    FRV_INSN_CMCPXIS, "cmcpxis", "cmcpxis", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* cmcpxiu$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    FRV_INSN_CMCPXIU, "cmcpxiu", "cmcpxiu", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_4 } }
+  },
+/* mqcpxrs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MQCPXRS, "mqcpxrs", "mqcpxrs", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* mqcpxru$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MQCPXRU, "mqcpxru", "mqcpxru", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* mqcpxis$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MQCPXIS, "mqcpxis", "mqcpxis", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* mqcpxiu$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    FRV_INSN_MQCPXIU, "mqcpxiu", "mqcpxiu", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_4 } }
+  },
+/* mexpdhw$pack $FRinti,$u6,$FRintk */
+  {
+    FRV_INSN_MEXPDHW, "mexpdhw", "mexpdhw", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* cmexpdhw$pack $FRinti,$u6,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMEXPDHW, "cmexpdhw", "cmexpdhw", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* mexpdhd$pack $FRinti,$u6,$FRintk */
+  {
+    FRV_INSN_MEXPDHD, "mexpdhd", "mexpdhd", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_2 } }
+  },
+/* cmexpdhd$pack $FRinti,$u6,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMEXPDHD, "cmexpdhd", "cmexpdhd", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_2 } }
+  },
+/* mpackh$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MPACKH, "mpackh", "mpackh", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* mdpackh$pack $FRinti,$FRintj,$FRintk */
+  {
+    FRV_INSN_MDPACKH, "mdpackh", "mdpackh", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_5 } }
+  },
+/* munpackh$pack $FRinti,$FRintk */
+  {
+    FRV_INSN_MUNPACKH, "munpackh", "munpackh", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_2 } }
+  },
+/* mdunpackh$pack $FRinti,$FRintk */
+  {
+    FRV_INSN_MDUNPACKH, "mdunpackh", "mdunpackh", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_M_7 } }
+  },
+/* mbtoh$pack $FRintj,$FRintk */
+  {
+    FRV_INSN_MBTOH, "mbtoh", "mbtoh", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_2 } }
+  },
+/* cmbtoh$pack $FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMBTOH, "cmbtoh", "cmbtoh", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_2 } }
+  },
+/* mhtob$pack $FRintj,$FRintk */
+  {
+    FRV_INSN_MHTOB, "mhtob", "mhtob", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_2 } }
+  },
+/* cmhtob$pack $FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMHTOB, "cmhtob", "cmhtob", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_2, FR500_MAJOR_M_2 } }
+  },
+/* mbtohe$pack $FRintj,$FRintk */
+  {
+    FRV_INSN_MBTOHE, "mbtohe", "mbtohe", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_M_7 } }
+  },
+/* cmbtohe$pack $FRintj,$FRintk,$CCi,$cond */
+  {
+    FRV_INSN_CMBTOHE, "cmbtohe", "cmbtohe", 32,
+    { 0|A(CONDITIONAL), { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_M_7 } }
+  },
+/* mclracc$pack $ACC40Sk,$A */
+  {
+    FRV_INSN_MCLRACC, "mclracc", "mclracc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_M_3 } }
+  },
+/* mrdacc$pack $ACC40Si,$FRintk */
+  {
+    FRV_INSN_MRDACC, "mrdacc", "mrdacc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* mrdaccg$pack $ACCGi,$FRintk */
+  {
+    FRV_INSN_MRDACCG, "mrdaccg", "mrdaccg", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_2 } }
+  },
+/* mwtacc$pack $FRinti,$ACC40Sk */
+  {
+    FRV_INSN_MWTACC, "mwtacc", "mwtacc", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_3 } }
+  },
+/* mwtaccg$pack $FRinti,$ACCGk */
+  {
+    FRV_INSN_MWTACCG, "mwtaccg", "mwtaccg", 32,
+    { 0, { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_M_1, FR500_MAJOR_M_3 } }
+  },
+/* mcop1$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_MCOP1, "mcop1", "mcop1", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_M_1 } }
+  },
+/* mcop2$pack $FRi,$FRj,$FRk */
+  {
+    FRV_INSN_MCOP2, "mcop2", "mcop2", 32,
+    { 0, { (1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_M_1 } }
+  },
+/* fnop$pack */
+  {
+    FRV_INSN_FNOP, "fnop", "fnop", 32,
+    { 0, { (1<<MACH_SIMPLE)|(1<<MACH_TOMCAT)|(1<<MACH_FR500)|(1<<MACH_FRV), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_F_8 } }
+  },
+};
+
+#undef OP
+#undef A
+
+/* Initialize anything needed to be done once, before any cpu_open call.  */
+static void init_tables PARAMS ((void));
+
+static void
+init_tables ()
+{
+}
+
+static const CGEN_MACH * lookup_mach_via_bfd_name
+  PARAMS ((const CGEN_MACH *, const char *));
+static void build_hw_table  PARAMS ((CGEN_CPU_TABLE *));
+static void build_ifield_table  PARAMS ((CGEN_CPU_TABLE *));
+static void build_operand_table PARAMS ((CGEN_CPU_TABLE *));
+static void build_insn_table    PARAMS ((CGEN_CPU_TABLE *));
+static void frv_cgen_rebuild_tables PARAMS ((CGEN_CPU_TABLE *));
+
+/* Subroutine of frv_cgen_cpu_open to look up a mach via its bfd name.  */
+
+static const CGEN_MACH *
+lookup_mach_via_bfd_name (table, name)
+     const CGEN_MACH *table;
+     const char *name;
+{
+  while (table->name)
+    {
+      if (strcmp (name, table->bfd_name) == 0)
+	return table;
+      ++table;
+    }
+  abort ();
+}
+
+/* Subroutine of frv_cgen_cpu_open to build the hardware table.  */
+
+static void
+build_hw_table (cd)
+     CGEN_CPU_TABLE *cd;
+{
+  int i;
+  int machs = cd->machs;
+  const CGEN_HW_ENTRY *init = & frv_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 frv_cgen_cpu_open to build the hardware table.  */
+
+static void
+build_ifield_table (cd)
+     CGEN_CPU_TABLE *cd;
+{
+  cd->ifld_table = & frv_cgen_ifld_table[0];
+}
+
+/* Subroutine of frv_cgen_cpu_open to build the hardware table.  */
+
+static void
+build_operand_table (cd)
+     CGEN_CPU_TABLE *cd;
+{
+  int i;
+  int machs = cd->machs;
+  const CGEN_OPERAND *init = & frv_cgen_operand_table[0];
+  /* MAX_OPERANDS is only an upper bound on the number of selected entries.
+     However each entry is indexed by it's enum so there can be holes in
+     the table.  */
+  const CGEN_OPERAND **selected =
+    (const CGEN_OPERAND **) xmalloc (MAX_OPERANDS * sizeof (CGEN_OPERAND *));
+
+  cd->operand_table.init_entries = init;
+  cd->operand_table.entry_size = sizeof (CGEN_OPERAND);
+  memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *));
+  /* ??? For now we just use mach to determine which ones we want.  */
+  for (i = 0; init[i].name != NULL; ++i)
+    if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH)
+	& machs)
+      selected[init[i].type] = &init[i];
+  cd->operand_table.entries = selected;
+  cd->operand_table.num_entries = MAX_OPERANDS;
+}
+
+/* Subroutine of frv_cgen_cpu_open to build the hardware table.
+   ??? This could leave out insns not supported by the specified mach/isa,
+   but that would cause errors like "foo only supported by bar" to become
+   "unknown insn", so for now we include all insns and require the app to
+   do the checking later.
+   ??? On the other hand, parsing of such insns may require their hardware or
+   operand elements to be in the table [which they mightn't be].  */
+
+static void
+build_insn_table (cd)
+     CGEN_CPU_TABLE *cd;
+{
+  int i;
+  const CGEN_IBASE *ib = & frv_cgen_insn_table[0];
+  CGEN_INSN *insns = (CGEN_INSN *) xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
+
+  memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
+  for (i = 0; i < MAX_INSNS; ++i)
+    insns[i].base = &ib[i];
+  cd->insn_table.init_entries = insns;
+  cd->insn_table.entry_size = sizeof (CGEN_IBASE);
+  cd->insn_table.num_init_entries = MAX_INSNS;
+}
+
+/* Subroutine of frv_cgen_cpu_open to rebuild the tables.  */
+
+static void
+frv_cgen_rebuild_tables (cd)
+     CGEN_CPU_TABLE *cd;
+{
+  int i;
+  unsigned int isas = cd->isas;
+  unsigned int machs = cd->machs;
+
+  cd->int_insn_p = CGEN_INT_INSN_P;
+
+  /* Data derived from the isa spec.  */
+#define UNSET (CGEN_SIZE_UNKNOWN + 1)
+  cd->default_insn_bitsize = UNSET;
+  cd->base_insn_bitsize = UNSET;
+  cd->min_insn_bitsize = 65535; /* some ridiculously big number */
+  cd->max_insn_bitsize = 0;
+  for (i = 0; i < MAX_ISAS; ++i)
+    if (((1 << i) & isas) != 0)
+      {
+	const CGEN_ISA *isa = & frv_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 = & frv_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, "frv_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
+frv_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...)
+{
+  CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE));
+  static int init_p;
+  unsigned int isas = 0;  /* 0 = "unspecified" */
+  unsigned int machs = 0; /* 0 = "unspecified" */
+  enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
+  va_list ap;
+
+  if (! init_p)
+    {
+      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, unsigned int);
+	  break;
+	case CGEN_CPU_OPEN_MACHS :
+	  machs = va_arg (ap, unsigned int);
+	  break;
+	case CGEN_CPU_OPEN_BFDMACH :
+	  {
+	    const char *name = va_arg (ap, const char *);
+	    const CGEN_MACH *mach =
+	      lookup_mach_via_bfd_name (frv_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, "frv_cgen_cpu_open: unsupported argument `%d'\n",
+		   arg_type);
+	  abort (); /* ??? return NULL? */
+	}
+      arg_type = va_arg (ap, enum cgen_cpu_open_arg);
+    }
+  va_end (ap);
+
+  /* mach unspecified means "all" */
+  if (machs == 0)
+    machs = (1 << MAX_MACHS) - 1;
+  /* base mach is always selected */
+  machs |= 1;
+  /* isa unspecified means "all" */
+  if (isas == 0)
+    isas = (1 << MAX_ISAS) - 1;
+  if (endian == CGEN_ENDIAN_UNKNOWN)
+    {
+      /* ??? If target has only one, could have a default.  */
+      fprintf (stderr, "frv_cgen_cpu_open: no endianness specified\n");
+      abort ();
+    }
+
+  cd->isas = isas;
+  cd->machs = machs;
+  cd->endian = endian;
+  /* FIXME: for the sparc case we can determine insn-endianness statically.
+     The worry here is where both data and insn endian can be independently
+     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 = frv_cgen_rebuild_tables;
+  frv_cgen_rebuild_tables (cd);
+
+  /* Default to not allowing signed overflow.  */
+  cd->signed_overflow_ok_p = 0;
+  
+  return (CGEN_CPU_DESC) cd;
+}
+
+/* Cover fn to frv_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
+frv_cgen_cpu_open_1 (mach_name, endian)
+     const char *mach_name;
+     enum cgen_endian endian;
+{
+  return frv_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
+frv_cgen_cpu_close (cd)
+     CGEN_CPU_DESC cd;
+{
+  unsigned int i;
+  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/frv-desc.h b/opcodes/frv-desc.h
new file mode 100644
index 00000000000..893919fc2dc
--- /dev/null
+++ b/opcodes/frv-desc.h
@@ -0,0 +1,748 @@
+/* CPU data header for frv.
+
+THIS FILE IS MACHINE GENERATED WITH CGEN.
+
+Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+
+This file is part of the GNU Binutils and/or GDB, the GNU debugger.
+
+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, 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.
+
+*/
+
+#ifndef FRV_CPU_H
+#define FRV_CPU_H
+
+#define CGEN_ARCH frv
+
+/* Given symbol S, return frv_cgen_<S>.  */
+#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
+#define CGEN_SYM(s) frv##_cgen_##s
+#else
+#define CGEN_SYM(s) frv/**/_cgen_/**/s
+#endif
+
+
+/* Selected cpu families.  */
+#define HAVE_CPU_FRVBF
+
+#define CGEN_INSN_LSB0_P 1
+
+/* 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 22
+
+/* 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 10
+
+/* Enums.  */
+
+/* Enum declaration for insn op enums.  */
+typedef enum insn_op {
+  OP_00, OP_01, OP_02, OP_03
+ , OP_04, OP_05, OP_06, OP_07
+ , OP_08, OP_09, OP_0A, OP_0B
+ , OP_0C, OP_0D, OP_0E, OP_0F
+ , OP_10, OP_11, OP_12, OP_13
+ , OP_14, OP_15, OP_16, OP_17
+ , OP_18, OP_19, OP_1A, OP_1B
+ , OP_1C, OP_1D, OP_1E, OP_1F
+ , OP_20, OP_21, OP_22, OP_23
+ , OP_24, OP_25, OP_26, OP_27
+ , OP_28, OP_29, OP_2A, OP_2B
+ , OP_2C, OP_2D, OP_2E, OP_2F
+ , OP_30, OP_31, OP_32, OP_33
+ , OP_34, OP_35, OP_36, OP_37
+ , OP_38, OP_39, OP_3A, OP_3B
+ , OP_3C, OP_3D, OP_3E, OP_3F
+ , OP_40, OP_41, OP_42, OP_43
+ , OP_44, OP_45, OP_46, OP_47
+ , OP_48, OP_49, OP_4A, OP_4B
+ , OP_4C, OP_4D, OP_4E, OP_4F
+ , OP_50, OP_51, OP_52, OP_53
+ , OP_54, OP_55, OP_56, OP_57
+ , OP_58, OP_59, OP_5A, OP_5B
+ , OP_5C, OP_5D, OP_5E, OP_5F
+ , OP_60, OP_61, OP_62, OP_63
+ , OP_64, OP_65, OP_66, OP_67
+ , OP_68, OP_69, OP_6A, OP_6B
+ , OP_6C, OP_6D, OP_6E, OP_6F
+ , OP_70, OP_71, OP_72, OP_73
+ , OP_74, OP_75, OP_76, OP_77
+ , OP_78, OP_79, OP_7A, OP_7B
+ , OP_7C, OP_7D, OP_7E, OP_7F
+} INSN_OP;
+
+/* Enum declaration for insn ope enums.  */
+typedef enum insn_ope1 {
+  OPE1_00, OPE1_01, OPE1_02, OPE1_03
+ , OPE1_04, OPE1_05, OPE1_06, OPE1_07
+ , OPE1_08, OPE1_09, OPE1_0A, OPE1_0B
+ , OPE1_0C, OPE1_0D, OPE1_0E, OPE1_0F
+ , OPE1_10, OPE1_11, OPE1_12, OPE1_13
+ , OPE1_14, OPE1_15, OPE1_16, OPE1_17
+ , OPE1_18, OPE1_19, OPE1_1A, OPE1_1B
+ , OPE1_1C, OPE1_1D, OPE1_1E, OPE1_1F
+ , OPE1_20, OPE1_21, OPE1_22, OPE1_23
+ , OPE1_24, OPE1_25, OPE1_26, OPE1_27
+ , OPE1_28, OPE1_29, OPE1_2A, OPE1_2B
+ , OPE1_2C, OPE1_2D, OPE1_2E, OPE1_2F
+ , OPE1_30, OPE1_31, OPE1_32, OPE1_33
+ , OPE1_34, OPE1_35, OPE1_36, OPE1_37
+ , OPE1_38, OPE1_39, OPE1_3A, OPE1_3B
+ , OPE1_3C, OPE1_3D, OPE1_3E, OPE1_3F
+} INSN_OPE1;
+
+/* Enum declaration for insn ope enums.  */
+typedef enum insn_ope2 {
+  OPE2_00, OPE2_01, OPE2_02, OPE2_03
+ , OPE2_04, OPE2_05, OPE2_06, OPE2_07
+ , OPE2_08, OPE2_09, OPE2_0A, OPE2_0B
+ , OPE2_0C, OPE2_0D, OPE2_0E, OPE2_0F
+} INSN_OPE2;
+
+/* Enum declaration for insn ope enums.  */
+typedef enum insn_ope3 {
+  OPE3_00, OPE3_01, OPE3_02, OPE3_03
+ , OPE3_04, OPE3_05, OPE3_06, OPE3_07
+} INSN_OPE3;
+
+/* Enum declaration for insn ope enums.  */
+typedef enum insn_ope4 {
+  OPE4_0, OPE4_1, OPE4_2, OPE4_3
+} INSN_OPE4;
+
+/* Enum declaration for integer branch cond enums.  */
+typedef enum int_cc {
+  ICC_NEV, ICC_C, ICC_V, ICC_LT
+ , ICC_EQ, ICC_LS, ICC_N, ICC_LE
+ , ICC_RA, ICC_NC, ICC_NV, ICC_GE
+ , ICC_NE, ICC_HI, ICC_P, ICC_GT
+} INT_CC;
+
+/* Enum declaration for float branch cond enums.  */
+typedef enum flt_cc {
+  FCC_NEV, FCC_U, FCC_GT, FCC_UG
+ , FCC_LT, FCC_UL, FCC_LG, FCC_NE
+ , FCC_EQ, FCC_UE, FCC_GE, FCC_UGE
+ , FCC_LE, FCC_ULE, FCC_O, FCC_RA
+} FLT_CC;
+
+/* Enum declaration for .  */
+typedef enum gr_names {
+  H_GR_SP = 1, H_GR_FP = 2, H_GR_GR0 = 0, H_GR_GR1 = 1
+ , H_GR_GR2 = 2, H_GR_GR3 = 3, H_GR_GR4 = 4, H_GR_GR5 = 5
+ , H_GR_GR6 = 6, H_GR_GR7 = 7, H_GR_GR8 = 8, H_GR_GR9 = 9
+ , H_GR_GR10 = 10, H_GR_GR11 = 11, H_GR_GR12 = 12, H_GR_GR13 = 13
+ , H_GR_GR14 = 14, H_GR_GR15 = 15, H_GR_GR16 = 16, H_GR_GR17 = 17
+ , H_GR_GR18 = 18, H_GR_GR19 = 19, H_GR_GR20 = 20, H_GR_GR21 = 21
+ , H_GR_GR22 = 22, H_GR_GR23 = 23, H_GR_GR24 = 24, H_GR_GR25 = 25
+ , H_GR_GR26 = 26, H_GR_GR27 = 27, H_GR_GR28 = 28, H_GR_GR29 = 29
+ , H_GR_GR30 = 30, H_GR_GR31 = 31, H_GR_GR32 = 32, H_GR_GR33 = 33
+ , H_GR_GR34 = 34, H_GR_GR35 = 35, H_GR_GR36 = 36, H_GR_GR37 = 37
+ , H_GR_GR38 = 38, H_GR_GR39 = 39, H_GR_GR40 = 40, H_GR_GR41 = 41
+ , H_GR_GR42 = 42, H_GR_GR43 = 43, H_GR_GR44 = 44, H_GR_GR45 = 45
+ , H_GR_GR46 = 46, H_GR_GR47 = 47, H_GR_GR48 = 48, H_GR_GR49 = 49
+ , H_GR_GR50 = 50, H_GR_GR51 = 51, H_GR_GR52 = 52, H_GR_GR53 = 53
+ , H_GR_GR54 = 54, H_GR_GR55 = 55, H_GR_GR56 = 56, H_GR_GR57 = 57
+ , H_GR_GR58 = 58, H_GR_GR59 = 59, H_GR_GR60 = 60, H_GR_GR61 = 61
+ , H_GR_GR62 = 62, H_GR_GR63 = 63
+} GR_NAMES;
+
+/* Enum declaration for .  */
+typedef enum fr_names {
+  H_FR_FR0, H_FR_FR1, H_FR_FR2, H_FR_FR3
+ , H_FR_FR4, H_FR_FR5, H_FR_FR6, H_FR_FR7
+ , H_FR_FR8, H_FR_FR9, H_FR_FR10, H_FR_FR11
+ , H_FR_FR12, H_FR_FR13, H_FR_FR14, H_FR_FR15
+ , H_FR_FR16, H_FR_FR17, H_FR_FR18, H_FR_FR19
+ , H_FR_FR20, H_FR_FR21, H_FR_FR22, H_FR_FR23
+ , H_FR_FR24, H_FR_FR25, H_FR_FR26, H_FR_FR27
+ , H_FR_FR28, H_FR_FR29, H_FR_FR30, H_FR_FR31
+ , H_FR_FR32, H_FR_FR33, H_FR_FR34, H_FR_FR35
+ , H_FR_FR36, H_FR_FR37, H_FR_FR38, H_FR_FR39
+ , H_FR_FR40, H_FR_FR41, H_FR_FR42, H_FR_FR43
+ , H_FR_FR44, H_FR_FR45, H_FR_FR46, H_FR_FR47
+ , H_FR_FR48, H_FR_FR49, H_FR_FR50, H_FR_FR51
+ , H_FR_FR52, H_FR_FR53, H_FR_FR54, H_FR_FR55
+ , H_FR_FR56, H_FR_FR57, H_FR_FR58, H_FR_FR59
+ , H_FR_FR60, H_FR_FR61, H_FR_FR62, H_FR_FR63
+} FR_NAMES;
+
+/* Enum declaration for .  */
+typedef enum cpr_names {
+  H_CPR_CPR0, H_CPR_CPR1, H_CPR_CPR2, H_CPR_CPR3
+ , H_CPR_CPR4, H_CPR_CPR5, H_CPR_CPR6, H_CPR_CPR7
+ , H_CPR_CPR8, H_CPR_CPR9, H_CPR_CPR10, H_CPR_CPR11
+ , H_CPR_CPR12, H_CPR_CPR13, H_CPR_CPR14, H_CPR_CPR15
+ , H_CPR_CPR16, H_CPR_CPR17, H_CPR_CPR18, H_CPR_CPR19
+ , H_CPR_CPR20, H_CPR_CPR21, H_CPR_CPR22, H_CPR_CPR23
+ , H_CPR_CPR24, H_CPR_CPR25, H_CPR_CPR26, H_CPR_CPR27
+ , H_CPR_CPR28, H_CPR_CPR29, H_CPR_CPR30, H_CPR_CPR31
+ , H_CPR_CPR32, H_CPR_CPR33, H_CPR_CPR34, H_CPR_CPR35
+ , H_CPR_CPR36, H_CPR_CPR37, H_CPR_CPR38, H_CPR_CPR39
+ , H_CPR_CPR40, H_CPR_CPR41, H_CPR_CPR42, H_CPR_CPR43
+ , H_CPR_CPR44, H_CPR_CPR45, H_CPR_CPR46, H_CPR_CPR47
+ , H_CPR_CPR48, H_CPR_CPR49, H_CPR_CPR50, H_CPR_CPR51
+ , H_CPR_CPR52, H_CPR_CPR53, H_CPR_CPR54, H_CPR_CPR55
+ , H_CPR_CPR56, H_CPR_CPR57, H_CPR_CPR58, H_CPR_CPR59
+ , H_CPR_CPR60, H_CPR_CPR61, H_CPR_CPR62, H_CPR_CPR63
+} CPR_NAMES;
+
+/* Enum declaration for .  */
+typedef enum spr_names {
+  H_SPR_PSR = 0, H_SPR_PCSR = 1, H_SPR_BPCSR = 2, H_SPR_TBR = 3
+ , H_SPR_BPSR = 4, H_SPR_HSR0 = 16, H_SPR_HSR1 = 17, H_SPR_HSR2 = 18
+ , H_SPR_HSR3 = 19, H_SPR_HSR4 = 20, H_SPR_HSR5 = 21, H_SPR_HSR6 = 22
+ , H_SPR_HSR7 = 23, H_SPR_HSR8 = 24, H_SPR_HSR9 = 25, H_SPR_HSR10 = 26
+ , H_SPR_HSR11 = 27, H_SPR_HSR12 = 28, H_SPR_HSR13 = 29, H_SPR_HSR14 = 30
+ , H_SPR_HSR15 = 31, H_SPR_HSR16 = 32, H_SPR_HSR17 = 33, H_SPR_HSR18 = 34
+ , H_SPR_HSR19 = 35, H_SPR_HSR20 = 36, H_SPR_HSR21 = 37, H_SPR_HSR22 = 38
+ , H_SPR_HSR23 = 39, H_SPR_HSR24 = 40, H_SPR_HSR25 = 41, H_SPR_HSR26 = 42
+ , H_SPR_HSR27 = 43, H_SPR_HSR28 = 44, H_SPR_HSR29 = 45, H_SPR_HSR30 = 46
+ , H_SPR_HSR31 = 47, H_SPR_HSR32 = 48, H_SPR_HSR33 = 49, H_SPR_HSR34 = 50
+ , H_SPR_HSR35 = 51, H_SPR_HSR36 = 52, H_SPR_HSR37 = 53, H_SPR_HSR38 = 54
+ , H_SPR_HSR39 = 55, H_SPR_HSR40 = 56, H_SPR_HSR41 = 57, H_SPR_HSR42 = 58
+ , H_SPR_HSR43 = 59, H_SPR_HSR44 = 60, H_SPR_HSR45 = 61, H_SPR_HSR46 = 62
+ , H_SPR_HSR47 = 63, H_SPR_HSR48 = 64, H_SPR_HSR49 = 65, H_SPR_HSR50 = 66
+ , H_SPR_HSR51 = 67, H_SPR_HSR52 = 68, H_SPR_HSR53 = 69, H_SPR_HSR54 = 70
+ , H_SPR_HSR55 = 71, H_SPR_HSR56 = 72, H_SPR_HSR57 = 73, H_SPR_HSR58 = 74
+ , H_SPR_HSR59 = 75, H_SPR_HSR60 = 76, H_SPR_HSR61 = 77, H_SPR_HSR62 = 78
+ , H_SPR_HSR63 = 79, H_SPR_CCR = 256, H_SPR_CCCR = 263, H_SPR_LR = 272
+ , H_SPR_LCR = 273, H_SPR_ISR = 288, H_SPR_NEEAR0 = 352, H_SPR_NEEAR1 = 353
+ , H_SPR_NEEAR2 = 354, H_SPR_NEEAR3 = 355, H_SPR_NEEAR4 = 356, H_SPR_NEEAR5 = 357
+ , H_SPR_NEEAR6 = 358, H_SPR_NEEAR7 = 359, H_SPR_NEEAR8 = 360, H_SPR_NEEAR9 = 361
+ , H_SPR_NEEAR10 = 362, H_SPR_NEEAR11 = 363, H_SPR_NEEAR12 = 364, H_SPR_NEEAR13 = 365
+ , H_SPR_NEEAR14 = 366, H_SPR_NEEAR15 = 367, H_SPR_NEEAR16 = 368, H_SPR_NEEAR17 = 369
+ , H_SPR_NEEAR18 = 370, H_SPR_NEEAR19 = 371, H_SPR_NEEAR20 = 372, H_SPR_NEEAR21 = 373
+ , H_SPR_NEEAR22 = 374, H_SPR_NEEAR23 = 375, H_SPR_NEEAR24 = 376, H_SPR_NEEAR25 = 377
+ , H_SPR_NEEAR26 = 378, H_SPR_NEEAR27 = 379, H_SPR_NEEAR28 = 380, H_SPR_NEEAR29 = 381
+ , H_SPR_NEEAR30 = 382, H_SPR_NEEAR31 = 383, H_SPR_NESR0 = 384, H_SPR_NESR1 = 385
+ , H_SPR_NESR2 = 386, H_SPR_NESR3 = 387, H_SPR_NESR4 = 388, H_SPR_NESR5 = 389
+ , H_SPR_NESR6 = 390, H_SPR_NESR7 = 391, H_SPR_NESR8 = 392, H_SPR_NESR9 = 393
+ , H_SPR_NESR10 = 394, H_SPR_NESR11 = 395, H_SPR_NESR12 = 396, H_SPR_NESR13 = 397
+ , H_SPR_NESR14 = 398, H_SPR_NESR15 = 399, H_SPR_NESR16 = 400, H_SPR_NESR17 = 401
+ , H_SPR_NESR18 = 402, H_SPR_NESR19 = 403, H_SPR_NESR20 = 404, H_SPR_NESR21 = 405
+ , H_SPR_NESR22 = 406, H_SPR_NESR23 = 407, H_SPR_NESR24 = 408, H_SPR_NESR25 = 409
+ , H_SPR_NESR26 = 410, H_SPR_NESR27 = 411, H_SPR_NESR28 = 412, H_SPR_NESR29 = 413
+ , H_SPR_NESR30 = 414, H_SPR_NESR31 = 415, H_SPR_NECR = 416, H_SPR_GNER0 = 432
+ , H_SPR_GNER1 = 433, H_SPR_FNER0 = 434, H_SPR_FNER1 = 435, H_SPR_EPCR0 = 512
+ , H_SPR_EPCR1 = 513, H_SPR_EPCR2 = 514, H_SPR_EPCR3 = 515, H_SPR_EPCR4 = 516
+ , H_SPR_EPCR5 = 517, H_SPR_EPCR6 = 518, H_SPR_EPCR7 = 519, H_SPR_EPCR8 = 520
+ , H_SPR_EPCR9 = 521, H_SPR_EPCR10 = 522, H_SPR_EPCR11 = 523, H_SPR_EPCR12 = 524
+ , H_SPR_EPCR13 = 525, H_SPR_EPCR14 = 526, H_SPR_EPCR15 = 527, H_SPR_EPCR16 = 528
+ , H_SPR_EPCR17 = 529, H_SPR_EPCR18 = 530, H_SPR_EPCR19 = 531, H_SPR_EPCR20 = 532
+ , H_SPR_EPCR21 = 533, H_SPR_EPCR22 = 534, H_SPR_EPCR23 = 535, H_SPR_EPCR24 = 536
+ , H_SPR_EPCR25 = 537, H_SPR_EPCR26 = 538, H_SPR_EPCR27 = 539, H_SPR_EPCR28 = 540
+ , H_SPR_EPCR29 = 541, H_SPR_EPCR30 = 542, H_SPR_EPCR31 = 543, H_SPR_EPCR32 = 544
+ , H_SPR_EPCR33 = 545, H_SPR_EPCR34 = 546, H_SPR_EPCR35 = 547, H_SPR_EPCR36 = 548
+ , H_SPR_EPCR37 = 549, H_SPR_EPCR38 = 550, H_SPR_EPCR39 = 551, H_SPR_EPCR40 = 552
+ , H_SPR_EPCR41 = 553, H_SPR_EPCR42 = 554, H_SPR_EPCR43 = 555, H_SPR_EPCR44 = 556
+ , H_SPR_EPCR45 = 557, H_SPR_EPCR46 = 558, H_SPR_EPCR47 = 559, H_SPR_EPCR48 = 560
+ , H_SPR_EPCR49 = 561, H_SPR_EPCR50 = 562, H_SPR_EPCR51 = 563, H_SPR_EPCR52 = 564
+ , H_SPR_EPCR53 = 565, H_SPR_EPCR54 = 566, H_SPR_EPCR55 = 567, H_SPR_EPCR56 = 568
+ , H_SPR_EPCR57 = 569, H_SPR_EPCR58 = 570, H_SPR_EPCR59 = 571, H_SPR_EPCR60 = 572
+ , H_SPR_EPCR61 = 573, H_SPR_EPCR62 = 574, H_SPR_EPCR63 = 575, H_SPR_ESR0 = 576
+ , H_SPR_ESR1 = 577, H_SPR_ESR2 = 578, H_SPR_ESR3 = 579, H_SPR_ESR4 = 580
+ , H_SPR_ESR5 = 581, H_SPR_ESR6 = 582, H_SPR_ESR7 = 583, H_SPR_ESR8 = 584
+ , H_SPR_ESR9 = 585, H_SPR_ESR10 = 586, H_SPR_ESR11 = 587, H_SPR_ESR12 = 588
+ , H_SPR_ESR13 = 589, H_SPR_ESR14 = 590, H_SPR_ESR15 = 591, H_SPR_ESR16 = 592
+ , H_SPR_ESR17 = 593, H_SPR_ESR18 = 594, H_SPR_ESR19 = 595, H_SPR_ESR20 = 596
+ , H_SPR_ESR21 = 597, H_SPR_ESR22 = 598, H_SPR_ESR23 = 599, H_SPR_ESR24 = 600
+ , H_SPR_ESR25 = 601, H_SPR_ESR26 = 602, H_SPR_ESR27 = 603, H_SPR_ESR28 = 604
+ , H_SPR_ESR29 = 605, H_SPR_ESR30 = 606, H_SPR_ESR31 = 607, H_SPR_ESR32 = 608
+ , H_SPR_ESR33 = 609, H_SPR_ESR34 = 610, H_SPR_ESR35 = 611, H_SPR_ESR36 = 612
+ , H_SPR_ESR37 = 613, H_SPR_ESR38 = 614, H_SPR_ESR39 = 615, H_SPR_ESR40 = 616
+ , H_SPR_ESR41 = 617, H_SPR_ESR42 = 618, H_SPR_ESR43 = 619, H_SPR_ESR44 = 620
+ , H_SPR_ESR45 = 621, H_SPR_ESR46 = 622, H_SPR_ESR47 = 623, H_SPR_ESR48 = 624
+ , H_SPR_ESR49 = 625, H_SPR_ESR50 = 626, H_SPR_ESR51 = 627, H_SPR_ESR52 = 628
+ , H_SPR_ESR53 = 629, H_SPR_ESR54 = 630, H_SPR_ESR55 = 631, H_SPR_ESR56 = 632
+ , H_SPR_ESR57 = 633, H_SPR_ESR58 = 634, H_SPR_ESR59 = 635, H_SPR_ESR60 = 636
+ , H_SPR_ESR61 = 637, H_SPR_ESR62 = 638, H_SPR_ESR63 = 639, H_SPR_EIR0 = 640
+ , H_SPR_EIR1 = 641, H_SPR_EIR2 = 642, H_SPR_EIR3 = 643, H_SPR_EIR4 = 644
+ , H_SPR_EIR5 = 645, H_SPR_EIR6 = 646, H_SPR_EIR7 = 647, H_SPR_EIR8 = 648
+ , H_SPR_EIR9 = 649, H_SPR_EIR10 = 650, H_SPR_EIR11 = 651, H_SPR_EIR12 = 652
+ , H_SPR_EIR13 = 653, H_SPR_EIR14 = 654, H_SPR_EIR15 = 655, H_SPR_EIR16 = 656
+ , H_SPR_EIR17 = 657, H_SPR_EIR18 = 658, H_SPR_EIR19 = 659, H_SPR_EIR20 = 660
+ , H_SPR_EIR21 = 661, H_SPR_EIR22 = 662, H_SPR_EIR23 = 663, H_SPR_EIR24 = 664
+ , H_SPR_EIR25 = 665, H_SPR_EIR26 = 666, H_SPR_EIR27 = 667, H_SPR_EIR28 = 668
+ , H_SPR_EIR29 = 669, H_SPR_EIR30 = 670, H_SPR_EIR31 = 671, H_SPR_ESFR0 = 672
+ , H_SPR_ESFR1 = 673, H_SPR_SR0 = 768, H_SPR_SR1 = 769, H_SPR_SR2 = 770
+ , H_SPR_SR3 = 771, H_SPR_FSR0 = 1024, H_SPR_FSR1 = 1025, H_SPR_FSR2 = 1026
+ , H_SPR_FSR3 = 1027, H_SPR_FSR4 = 1028, H_SPR_FSR5 = 1029, H_SPR_FSR6 = 1030
+ , H_SPR_FSR7 = 1031, H_SPR_FSR8 = 1032, H_SPR_FSR9 = 1033, H_SPR_FSR10 = 1034
+ , H_SPR_FSR11 = 1035, H_SPR_FSR12 = 1036, H_SPR_FSR13 = 1037, H_SPR_FSR14 = 1038
+ , H_SPR_FSR15 = 1039, H_SPR_FSR16 = 1040, H_SPR_FSR17 = 1041, H_SPR_FSR18 = 1042
+ , H_SPR_FSR19 = 1043, H_SPR_FSR20 = 1044, H_SPR_FSR21 = 1045, H_SPR_FSR22 = 1046
+ , H_SPR_FSR23 = 1047, H_SPR_FSR24 = 1048, H_SPR_FSR25 = 1049, H_SPR_FSR26 = 1050
+ , H_SPR_FSR27 = 1051, H_SPR_FSR28 = 1052, H_SPR_FSR29 = 1053, H_SPR_FSR30 = 1054
+ , H_SPR_FSR31 = 1055, H_SPR_FSR32 = 1056, H_SPR_FSR33 = 1057, H_SPR_FSR34 = 1058
+ , H_SPR_FSR35 = 1059, H_SPR_FSR36 = 1060, H_SPR_FSR37 = 1061, H_SPR_FSR38 = 1062
+ , H_SPR_FSR39 = 1063, H_SPR_FSR40 = 1064, H_SPR_FSR41 = 1065, H_SPR_FSR42 = 1066
+ , H_SPR_FSR43 = 1067, H_SPR_FSR44 = 1068, H_SPR_FSR45 = 1069, H_SPR_FSR46 = 1070
+ , H_SPR_FSR47 = 1071, H_SPR_FSR48 = 1072, H_SPR_FSR49 = 1073, H_SPR_FSR50 = 1074
+ , H_SPR_FSR51 = 1075, H_SPR_FSR52 = 1076, H_SPR_FSR53 = 1077, H_SPR_FSR54 = 1078
+ , H_SPR_FSR55 = 1079, H_SPR_FSR56 = 1080, H_SPR_FSR57 = 1081, H_SPR_FSR58 = 1082
+ , H_SPR_FSR59 = 1083, H_SPR_FSR60 = 1084, H_SPR_FSR61 = 1085, H_SPR_FSR62 = 1086
+ , H_SPR_FSR63 = 1087, H_SPR_FQOP0 = 1088, H_SPR_FQOP1 = 1090, H_SPR_FQOP2 = 1092
+ , H_SPR_FQOP3 = 1094, H_SPR_FQOP4 = 1096, H_SPR_FQOP5 = 1098, H_SPR_FQOP6 = 1100
+ , H_SPR_FQOP7 = 1102, H_SPR_FQOP8 = 1104, H_SPR_FQOP9 = 1106, H_SPR_FQOP10 = 1108
+ , H_SPR_FQOP11 = 1110, H_SPR_FQOP12 = 1112, H_SPR_FQOP13 = 1114, H_SPR_FQOP14 = 1116
+ , H_SPR_FQOP15 = 1118, H_SPR_FQOP16 = 1120, H_SPR_FQOP17 = 1122, H_SPR_FQOP18 = 1124
+ , H_SPR_FQOP19 = 1126, H_SPR_FQOP20 = 1128, H_SPR_FQOP21 = 1130, H_SPR_FQOP22 = 1132
+ , H_SPR_FQOP23 = 1134, H_SPR_FQOP24 = 1136, H_SPR_FQOP25 = 1138, H_SPR_FQOP26 = 1140
+ , H_SPR_FQOP27 = 1142, H_SPR_FQOP28 = 1144, H_SPR_FQOP29 = 1146, H_SPR_FQOP30 = 1148
+ , H_SPR_FQOP31 = 1150, H_SPR_FQST0 = 1089, H_SPR_FQST1 = 1091, H_SPR_FQST2 = 1093
+ , H_SPR_FQST3 = 1095, H_SPR_FQST4 = 1097, H_SPR_FQST5 = 1099, H_SPR_FQST6 = 1101
+ , H_SPR_FQST7 = 1103, H_SPR_FQST8 = 1105, H_SPR_FQST9 = 1107, H_SPR_FQST10 = 1109
+ , H_SPR_FQST11 = 1111, H_SPR_FQST12 = 1113, H_SPR_FQST13 = 1115, H_SPR_FQST14 = 1117
+ , H_SPR_FQST15 = 1119, H_SPR_FQST16 = 1121, H_SPR_FQST17 = 1123, H_SPR_FQST18 = 1125
+ , H_SPR_FQST19 = 1127, H_SPR_FQST20 = 1129, H_SPR_FQST21 = 1131, H_SPR_FQST22 = 1133
+ , H_SPR_FQST23 = 1135, H_SPR_FQST24 = 1137, H_SPR_FQST25 = 1139, H_SPR_FQST26 = 1141
+ , H_SPR_FQST27 = 1143, H_SPR_FQST28 = 1145, H_SPR_FQST29 = 1147, H_SPR_FQST30 = 1149
+ , H_SPR_FQST31 = 1151, H_SPR_MCILR0 = 1272, H_SPR_MCILR1 = 1273, H_SPR_MSR0 = 1280
+ , H_SPR_MSR1 = 1281, H_SPR_MSR2 = 1282, H_SPR_MSR3 = 1283, H_SPR_MSR4 = 1284
+ , H_SPR_MSR5 = 1285, H_SPR_MSR6 = 1286, H_SPR_MSR7 = 1287, H_SPR_MSR8 = 1288
+ , H_SPR_MSR9 = 1289, H_SPR_MSR10 = 1290, H_SPR_MSR11 = 1291, H_SPR_MSR12 = 1292
+ , H_SPR_MSR13 = 1293, H_SPR_MSR14 = 1294, H_SPR_MSR15 = 1295, H_SPR_MSR16 = 1296
+ , H_SPR_MSR17 = 1297, H_SPR_MSR18 = 1298, H_SPR_MSR19 = 1299, H_SPR_MSR20 = 1300
+ , H_SPR_MSR21 = 1301, H_SPR_MSR22 = 1302, H_SPR_MSR23 = 1303, H_SPR_MSR24 = 1304
+ , H_SPR_MSR25 = 1305, H_SPR_MSR26 = 1306, H_SPR_MSR27 = 1307, H_SPR_MSR28 = 1308
+ , H_SPR_MSR29 = 1309, H_SPR_MSR30 = 1310, H_SPR_MSR31 = 1311, H_SPR_MSR32 = 1312
+ , H_SPR_MSR33 = 1313, H_SPR_MSR34 = 1314, H_SPR_MSR35 = 1315, H_SPR_MSR36 = 1316
+ , H_SPR_MSR37 = 1317, H_SPR_MSR38 = 1318, H_SPR_MSR39 = 1319, H_SPR_MSR40 = 1320
+ , H_SPR_MSR41 = 1321, H_SPR_MSR42 = 1322, H_SPR_MSR43 = 1323, H_SPR_MSR44 = 1324
+ , H_SPR_MSR45 = 1325, H_SPR_MSR46 = 1326, H_SPR_MSR47 = 1327, H_SPR_MSR48 = 1328
+ , H_SPR_MSR49 = 1329, H_SPR_MSR50 = 1330, H_SPR_MSR51 = 1331, H_SPR_MSR52 = 1332
+ , H_SPR_MSR53 = 1333, H_SPR_MSR54 = 1334, H_SPR_MSR55 = 1335, H_SPR_MSR56 = 1336
+ , H_SPR_MSR57 = 1337, H_SPR_MSR58 = 1338, H_SPR_MSR59 = 1339, H_SPR_MSR60 = 1340
+ , H_SPR_MSR61 = 1341, H_SPR_MSR62 = 1342, H_SPR_MSR63 = 1343, H_SPR_MQOP0 = 1344
+ , H_SPR_MQOP1 = 1346, H_SPR_MQOP2 = 1348, H_SPR_MQOP3 = 1350, H_SPR_MQOP4 = 1352
+ , H_SPR_MQOP5 = 1354, H_SPR_MQOP6 = 1356, H_SPR_MQOP7 = 1358, H_SPR_MQOP8 = 1360
+ , H_SPR_MQOP9 = 1362, H_SPR_MQOP10 = 1364, H_SPR_MQOP11 = 1366, H_SPR_MQOP12 = 1368
+ , H_SPR_MQOP13 = 1370, H_SPR_MQOP14 = 1372, H_SPR_MQOP15 = 1374, H_SPR_MQOP16 = 1376
+ , H_SPR_MQOP17 = 1378, H_SPR_MQOP18 = 1380, H_SPR_MQOP19 = 1382, H_SPR_MQOP20 = 1384
+ , H_SPR_MQOP21 = 1386, H_SPR_MQOP22 = 1388, H_SPR_MQOP23 = 1390, H_SPR_MQOP24 = 1392
+ , H_SPR_MQOP25 = 1394, H_SPR_MQOP26 = 1396, H_SPR_MQOP27 = 1398, H_SPR_MQOP28 = 1400
+ , H_SPR_MQOP29 = 1402, H_SPR_MQOP30 = 1404, H_SPR_MQOP31 = 1406, H_SPR_MQST0 = 1345
+ , H_SPR_MQST1 = 1347, H_SPR_MQST2 = 1349, H_SPR_MQST3 = 1351, H_SPR_MQST4 = 1353
+ , H_SPR_MQST5 = 1355, H_SPR_MQST6 = 1357, H_SPR_MQST7 = 1359, H_SPR_MQST8 = 1361
+ , H_SPR_MQST9 = 1363, H_SPR_MQST10 = 1365, H_SPR_MQST11 = 1367, H_SPR_MQST12 = 1369
+ , H_SPR_MQST13 = 1371, H_SPR_MQST14 = 1373, H_SPR_MQST15 = 1375, H_SPR_MQST16 = 1377
+ , H_SPR_MQST17 = 1379, H_SPR_MQST18 = 1381, H_SPR_MQST19 = 1383, H_SPR_MQST20 = 1385
+ , H_SPR_MQST21 = 1387, H_SPR_MQST22 = 1389, H_SPR_MQST23 = 1391, H_SPR_MQST24 = 1393
+ , H_SPR_MQST25 = 1395, H_SPR_MQST26 = 1397, H_SPR_MQST27 = 1399, H_SPR_MQST28 = 1401
+ , H_SPR_MQST29 = 1403, H_SPR_MQST30 = 1405, H_SPR_MQST31 = 1407, H_SPR_EAR0 = 1536
+ , H_SPR_EAR1 = 1537, H_SPR_EAR2 = 1538, H_SPR_EAR3 = 1539, H_SPR_EAR4 = 1540
+ , H_SPR_EAR5 = 1541, H_SPR_EAR6 = 1542, H_SPR_EAR7 = 1543, H_SPR_EAR8 = 1544
+ , H_SPR_EAR9 = 1545, H_SPR_EAR10 = 1546, H_SPR_EAR11 = 1547, H_SPR_EAR12 = 1548
+ , H_SPR_EAR13 = 1549, H_SPR_EAR14 = 1550, H_SPR_EAR15 = 1551, H_SPR_EAR16 = 1552
+ , H_SPR_EAR17 = 1553, H_SPR_EAR18 = 1554, H_SPR_EAR19 = 1555, H_SPR_EAR20 = 1556
+ , H_SPR_EAR21 = 1557, H_SPR_EAR22 = 1558, H_SPR_EAR23 = 1559, H_SPR_EAR24 = 1560
+ , H_SPR_EAR25 = 1561, H_SPR_EAR26 = 1562, H_SPR_EAR27 = 1563, H_SPR_EAR28 = 1564
+ , H_SPR_EAR29 = 1565, H_SPR_EAR30 = 1566, H_SPR_EAR31 = 1567, H_SPR_EAR32 = 1568
+ , H_SPR_EAR33 = 1569, H_SPR_EAR34 = 1570, H_SPR_EAR35 = 1571, H_SPR_EAR36 = 1572
+ , H_SPR_EAR37 = 1573, H_SPR_EAR38 = 1574, H_SPR_EAR39 = 1575, H_SPR_EAR40 = 1576
+ , H_SPR_EAR41 = 1577, H_SPR_EAR42 = 1578, H_SPR_EAR43 = 1579, H_SPR_EAR44 = 1580
+ , H_SPR_EAR45 = 1581, H_SPR_EAR46 = 1582, H_SPR_EAR47 = 1583, H_SPR_EAR48 = 1584
+ , H_SPR_EAR49 = 1585, H_SPR_EAR50 = 1586, H_SPR_EAR51 = 1587, H_SPR_EAR52 = 1588
+ , H_SPR_EAR53 = 1589, H_SPR_EAR54 = 1590, H_SPR_EAR55 = 1591, H_SPR_EAR56 = 1592
+ , H_SPR_EAR57 = 1593, H_SPR_EAR58 = 1594, H_SPR_EAR59 = 1595, H_SPR_EAR60 = 1596
+ , H_SPR_EAR61 = 1597, H_SPR_EAR62 = 1598, H_SPR_EAR63 = 1599, H_SPR_EDR0 = 1600
+ , H_SPR_EDR1 = 1601, H_SPR_EDR2 = 1602, H_SPR_EDR3 = 1603, H_SPR_EDR4 = 1604
+ , H_SPR_EDR5 = 1605, H_SPR_EDR6 = 1606, H_SPR_EDR7 = 1607, H_SPR_EDR8 = 1608
+ , H_SPR_EDR9 = 1609, H_SPR_EDR10 = 1610, H_SPR_EDR11 = 1611, H_SPR_EDR12 = 1612
+ , H_SPR_EDR13 = 1613, H_SPR_EDR14 = 1614, H_SPR_EDR15 = 1615, H_SPR_EDR16 = 1616
+ , H_SPR_EDR17 = 1617, H_SPR_EDR18 = 1618, H_SPR_EDR19 = 1619, H_SPR_EDR20 = 1620
+ , H_SPR_EDR21 = 1621, H_SPR_EDR22 = 1622, H_SPR_EDR23 = 1623, H_SPR_EDR24 = 1624
+ , H_SPR_EDR25 = 1625, H_SPR_EDR26 = 1626, H_SPR_EDR27 = 1627, H_SPR_EDR28 = 1628
+ , H_SPR_EDR29 = 1629, H_SPR_EDR30 = 1630, H_SPR_EDR31 = 1631, H_SPR_EDR32 = 1632
+ , H_SPR_EDR33 = 1636, H_SPR_EDR34 = 1634, H_SPR_EDR35 = 1635, H_SPR_EDR36 = 1636
+ , H_SPR_EDR37 = 1637, H_SPR_EDR38 = 1638, H_SPR_EDR39 = 1639, H_SPR_EDR40 = 1640
+ , H_SPR_EDR41 = 1641, H_SPR_EDR42 = 1642, H_SPR_EDR43 = 1643, H_SPR_EDR44 = 1644
+ , H_SPR_EDR45 = 1645, H_SPR_EDR46 = 1646, H_SPR_EDR47 = 1647, H_SPR_EDR48 = 1648
+ , H_SPR_EDR49 = 1649, H_SPR_EDR50 = 1650, H_SPR_EDR51 = 1651, H_SPR_EDR52 = 1652
+ , H_SPR_EDR53 = 1653, H_SPR_EDR54 = 1654, H_SPR_EDR55 = 1655, H_SPR_EDR56 = 1656
+ , H_SPR_EDR57 = 1657, H_SPR_EDR58 = 1658, H_SPR_EDR59 = 1659, H_SPR_EDR60 = 1660
+ , H_SPR_EDR61 = 1661, H_SPR_EDR62 = 1662, H_SPR_EDR63 = 1663, H_SPR_IAMLR0 = 1664
+ , H_SPR_IAMLR1 = 1665, H_SPR_IAMLR2 = 1666, H_SPR_IAMLR3 = 1667, H_SPR_IAMLR4 = 1668
+ , H_SPR_IAMLR5 = 1669, H_SPR_IAMLR6 = 1670, H_SPR_IAMLR7 = 1671, H_SPR_IAMLR8 = 1672
+ , H_SPR_IAMLR9 = 1673, H_SPR_IAMLR10 = 1674, H_SPR_IAMLR11 = 1675, H_SPR_IAMLR12 = 1676
+ , H_SPR_IAMLR13 = 1677, H_SPR_IAMLR14 = 1678, H_SPR_IAMLR15 = 1679, H_SPR_IAMLR16 = 1680
+ , H_SPR_IAMLR17 = 1681, H_SPR_IAMLR18 = 1682, H_SPR_IAMLR19 = 1683, H_SPR_IAMLR20 = 1684
+ , H_SPR_IAMLR21 = 1685, H_SPR_IAMLR22 = 1686, H_SPR_IAMLR23 = 1687, H_SPR_IAMLR24 = 1688
+ , H_SPR_IAMLR25 = 1689, H_SPR_IAMLR26 = 1690, H_SPR_IAMLR27 = 1691, H_SPR_IAMLR28 = 1692
+ , H_SPR_IAMLR29 = 1693, H_SPR_IAMLR30 = 1694, H_SPR_IAMLR31 = 1695, H_SPR_IAMLR32 = 1696
+ , H_SPR_IAMLR33 = 1697, H_SPR_IAMLR34 = 1698, H_SPR_IAMLR35 = 1699, H_SPR_IAMLR36 = 1700
+ , H_SPR_IAMLR37 = 1701, H_SPR_IAMLR38 = 1702, H_SPR_IAMLR39 = 1703, H_SPR_IAMLR40 = 1704
+ , H_SPR_IAMLR41 = 1705, H_SPR_IAMLR42 = 1706, H_SPR_IAMLR43 = 1707, H_SPR_IAMLR44 = 1708
+ , H_SPR_IAMLR45 = 1709, H_SPR_IAMLR46 = 1710, H_SPR_IAMLR47 = 1711, H_SPR_IAMLR48 = 1712
+ , H_SPR_IAMLR49 = 1713, H_SPR_IAMLR50 = 1714, H_SPR_IAMLR51 = 1715, H_SPR_IAMLR52 = 1716
+ , H_SPR_IAMLR53 = 1717, H_SPR_IAMLR54 = 1718, H_SPR_IAMLR55 = 1719, H_SPR_IAMLR56 = 1720
+ , H_SPR_IAMLR57 = 1721, H_SPR_IAMLR58 = 1722, H_SPR_IAMLR59 = 1723, H_SPR_IAMLR60 = 1724
+ , H_SPR_IAMLR61 = 1725, H_SPR_IAMLR62 = 1726, H_SPR_IAMLR63 = 1727, H_SPR_IAMPR0 = 1728
+ , H_SPR_IAMPR1 = 1729, H_SPR_IAMPR2 = 1730, H_SPR_IAMPR3 = 1731, H_SPR_IAMPR4 = 1732
+ , H_SPR_IAMPR5 = 1733, H_SPR_IAMPR6 = 1734, H_SPR_IAMPR7 = 1735, H_SPR_IAMPR8 = 1736
+ , H_SPR_IAMPR9 = 1737, H_SPR_IAMPR10 = 1738, H_SPR_IAMPR11 = 1739, H_SPR_IAMPR12 = 1740
+ , H_SPR_IAMPR13 = 1741, H_SPR_IAMPR14 = 1742, H_SPR_IAMPR15 = 1743, H_SPR_IAMPR16 = 1744
+ , H_SPR_IAMPR17 = 1745, H_SPR_IAMPR18 = 1746, H_SPR_IAMPR19 = 1747, H_SPR_IAMPR20 = 1748
+ , H_SPR_IAMPR21 = 1749, H_SPR_IAMPR22 = 1750, H_SPR_IAMPR23 = 1751, H_SPR_IAMPR24 = 1752
+ , H_SPR_IAMPR25 = 1753, H_SPR_IAMPR26 = 1754, H_SPR_IAMPR27 = 1755, H_SPR_IAMPR28 = 1756
+ , H_SPR_IAMPR29 = 1757, H_SPR_IAMPR30 = 1758, H_SPR_IAMPR31 = 1759, H_SPR_IAMPR32 = 1760
+ , H_SPR_IAMPR33 = 1761, H_SPR_IAMPR34 = 1762, H_SPR_IAMPR35 = 1763, H_SPR_IAMPR36 = 1764
+ , H_SPR_IAMPR37 = 1765, H_SPR_IAMPR38 = 1766, H_SPR_IAMPR39 = 1767, H_SPR_IAMPR40 = 1768
+ , H_SPR_IAMPR41 = 1769, H_SPR_IAMPR42 = 1770, H_SPR_IAMPR43 = 1771, H_SPR_IAMPR44 = 1772
+ , H_SPR_IAMPR45 = 1773, H_SPR_IAMPR46 = 1774, H_SPR_IAMPR47 = 1775, H_SPR_IAMPR48 = 1776
+ , H_SPR_IAMPR49 = 1777, H_SPR_IAMPR50 = 1778, H_SPR_IAMPR51 = 1779, H_SPR_IAMPR52 = 1780
+ , H_SPR_IAMPR53 = 1781, H_SPR_IAMPR54 = 1782, H_SPR_IAMPR55 = 1783, H_SPR_IAMPR56 = 1784
+ , H_SPR_IAMPR57 = 1785, H_SPR_IAMPR58 = 1786, H_SPR_IAMPR59 = 1787, H_SPR_IAMPR60 = 1788
+ , H_SPR_IAMPR61 = 1789, H_SPR_IAMPR62 = 1790, H_SPR_IAMPR63 = 1791, H_SPR_DAMLR0 = 1792
+ , H_SPR_DAMLR1 = 1793, H_SPR_DAMLR2 = 1794, H_SPR_DAMLR3 = 1795, H_SPR_DAMLR4 = 1796
+ , H_SPR_DAMLR5 = 1797, H_SPR_DAMLR6 = 1798, H_SPR_DAMLR7 = 1799, H_SPR_DAMLR8 = 1800
+ , H_SPR_DAMLR9 = 1801, H_SPR_DAMLR10 = 1802, H_SPR_DAMLR11 = 1803, H_SPR_DAMLR12 = 1804
+ , H_SPR_DAMLR13 = 1805, H_SPR_DAMLR14 = 1806, H_SPR_DAMLR15 = 1807, H_SPR_DAMLR16 = 1808
+ , H_SPR_DAMLR17 = 1809, H_SPR_DAMLR18 = 1810, H_SPR_DAMLR19 = 1811, H_SPR_DAMLR20 = 1812
+ , H_SPR_DAMLR21 = 1813, H_SPR_DAMLR22 = 1814, H_SPR_DAMLR23 = 1815, H_SPR_DAMLR24 = 1816
+ , H_SPR_DAMLR25 = 1817, H_SPR_DAMLR26 = 1818, H_SPR_DAMLR27 = 1819, H_SPR_DAMLR28 = 1820
+ , H_SPR_DAMLR29 = 1821, H_SPR_DAMLR30 = 1822, H_SPR_DAMLR31 = 1823, H_SPR_DAMLR32 = 1824
+ , H_SPR_DAMLR33 = 1825, H_SPR_DAMLR34 = 1826, H_SPR_DAMLR35 = 1827, H_SPR_DAMLR36 = 1828
+ , H_SPR_DAMLR37 = 1829, H_SPR_DAMLR38 = 1830, H_SPR_DAMLR39 = 1831, H_SPR_DAMLR40 = 1832
+ , H_SPR_DAMLR41 = 1833, H_SPR_DAMLR42 = 1834, H_SPR_DAMLR43 = 1835, H_SPR_DAMLR44 = 1836
+ , H_SPR_DAMLR45 = 1837, H_SPR_DAMLR46 = 1838, H_SPR_DAMLR47 = 1839, H_SPR_DAMLR48 = 1840
+ , H_SPR_DAMLR49 = 1841, H_SPR_DAMLR50 = 1842, H_SPR_DAMLR51 = 1843, H_SPR_DAMLR52 = 1844
+ , H_SPR_DAMLR53 = 1845, H_SPR_DAMLR54 = 1846, H_SPR_DAMLR55 = 1847, H_SPR_DAMLR56 = 1848
+ , H_SPR_DAMLR57 = 1849, H_SPR_DAMLR58 = 1850, H_SPR_DAMLR59 = 1851, H_SPR_DAMLR60 = 1852
+ , H_SPR_DAMLR61 = 1853, H_SPR_DAMLR62 = 1854, H_SPR_DAMLR63 = 1855, H_SPR_DAMPR0 = 1856
+ , H_SPR_DAMPR1 = 1857, H_SPR_DAMPR2 = 1858, H_SPR_DAMPR3 = 1859, H_SPR_DAMPR4 = 1860
+ , H_SPR_DAMPR5 = 1861, H_SPR_DAMPR6 = 1862, H_SPR_DAMPR7 = 1863, H_SPR_DAMPR8 = 1864
+ , H_SPR_DAMPR9 = 1865, H_SPR_DAMPR10 = 1866, H_SPR_DAMPR11 = 1867, H_SPR_DAMPR12 = 1868
+ , H_SPR_DAMPR13 = 1869, H_SPR_DAMPR14 = 1870, H_SPR_DAMPR15 = 1871, H_SPR_DAMPR16 = 1872
+ , H_SPR_DAMPR17 = 1873, H_SPR_DAMPR18 = 1874, H_SPR_DAMPR19 = 1875, H_SPR_DAMPR20 = 1876
+ , H_SPR_DAMPR21 = 1877, H_SPR_DAMPR22 = 1878, H_SPR_DAMPR23 = 1879, H_SPR_DAMPR24 = 1880
+ , H_SPR_DAMPR25 = 1881, H_SPR_DAMPR26 = 1882, H_SPR_DAMPR27 = 1883, H_SPR_DAMPR28 = 1884
+ , H_SPR_DAMPR29 = 1885, H_SPR_DAMPR30 = 1886, H_SPR_DAMPR31 = 1887, H_SPR_DAMPR32 = 1888
+ , H_SPR_DAMPR33 = 1889, H_SPR_DAMPR34 = 1890, H_SPR_DAMPR35 = 1891, H_SPR_DAMPR36 = 1892
+ , H_SPR_DAMPR37 = 1893, H_SPR_DAMPR38 = 1894, H_SPR_DAMPR39 = 1895, H_SPR_DAMPR40 = 1896
+ , H_SPR_DAMPR41 = 1897, H_SPR_DAMPR42 = 1898, H_SPR_DAMPR43 = 1899, H_SPR_DAMPR44 = 1900
+ , H_SPR_DAMPR45 = 1901, H_SPR_DAMPR46 = 1902, H_SPR_DAMPR47 = 1903, H_SPR_DAMPR48 = 1904
+ , H_SPR_DAMPR49 = 1905, H_SPR_DAMPR50 = 1906, H_SPR_DAMPR51 = 1907, H_SPR_DAMPR52 = 1908
+ , H_SPR_DAMPR53 = 1909, H_SPR_DAMPR54 = 1910, H_SPR_DAMPR55 = 1911, H_SPR_DAMPR56 = 1912
+ , H_SPR_DAMPR57 = 1913, H_SPR_DAMPR58 = 1914, H_SPR_DAMPR59 = 1915, H_SPR_DAMPR60 = 1916
+ , H_SPR_DAMPR61 = 1917, H_SPR_DAMPR62 = 1918, H_SPR_DAMPR63 = 1919, H_SPR_AMCR = 1920
+ , H_SPR_STBAR = 1921, H_SPR_MMCR = 1922, H_SPR_DCR = 2048, H_SPR_BRR = 2049
+ , H_SPR_NMAR = 2050, H_SPR_IBAR0 = 2052, H_SPR_IBAR1 = 2053, H_SPR_IBAR2 = 2054
+ , H_SPR_IBAR3 = 2055, H_SPR_DBAR0 = 2056, H_SPR_DBAR1 = 2057, H_SPR_DBAR2 = 2058
+ , H_SPR_DBAR3 = 2059, H_SPR_DBDR00 = 2060, H_SPR_DBDR01 = 2061, H_SPR_DBDR02 = 2062
+ , H_SPR_DBDR03 = 2063, H_SPR_DBDR10 = 2064, H_SPR_DBDR11 = 2065, H_SPR_DBDR12 = 2066
+ , H_SPR_DBDR13 = 2067, H_SPR_DBDR20 = 2068, H_SPR_DBDR21 = 2069, H_SPR_DBDR22 = 2070
+ , H_SPR_DBDR23 = 2071, H_SPR_DBDR30 = 2072, H_SPR_DBDR31 = 2073, H_SPR_DBDR32 = 2074
+ , H_SPR_DBDR33 = 2075, H_SPR_DBMR00 = 2076, H_SPR_DBMR01 = 2077, H_SPR_DBMR02 = 2078
+ , H_SPR_DBMR03 = 2079, H_SPR_DBMR10 = 2080, H_SPR_DBMR11 = 2081, H_SPR_DBMR12 = 2082
+ , H_SPR_DBMR13 = 2083, H_SPR_DBMR20 = 2084, H_SPR_DBMR21 = 2085, H_SPR_DBMR22 = 2086
+ , H_SPR_DBMR23 = 2087, H_SPR_DBMR30 = 2088, H_SPR_DBMR31 = 2089, H_SPR_DBMR32 = 2090
+ , H_SPR_DBMR33 = 2091, H_SPR_CPCFR = 2092, H_SPR_CPCR = 2093, H_SPR_CPSR = 2094
+ , H_SPR_CPESR0 = 2096, H_SPR_CPESR1 = 2097, H_SPR_CPEMR0 = 2098, H_SPR_CPEMR1 = 2099
+ , H_SPR_IHSR8 = 3848
+} SPR_NAMES;
+
+/* Enum declaration for .  */
+typedef enum accg_names {
+  H_ACCG_ACCG0, H_ACCG_ACCG1, H_ACCG_ACCG2, H_ACCG_ACCG3
+ , H_ACCG_ACCG4, H_ACCG_ACCG5, H_ACCG_ACCG6, H_ACCG_ACCG7
+ , H_ACCG_ACCG8, H_ACCG_ACCG9, H_ACCG_ACCG10, H_ACCG_ACCG11
+ , H_ACCG_ACCG12, H_ACCG_ACCG13, H_ACCG_ACCG14, H_ACCG_ACCG15
+ , H_ACCG_ACCG16, H_ACCG_ACCG17, H_ACCG_ACCG18, H_ACCG_ACCG19
+ , H_ACCG_ACCG20, H_ACCG_ACCG21, H_ACCG_ACCG22, H_ACCG_ACCG23
+ , H_ACCG_ACCG24, H_ACCG_ACCG25, H_ACCG_ACCG26, H_ACCG_ACCG27
+ , H_ACCG_ACCG28, H_ACCG_ACCG29, H_ACCG_ACCG30, H_ACCG_ACCG31
+ , H_ACCG_ACCG32, H_ACCG_ACCG33, H_ACCG_ACCG34, H_ACCG_ACCG35
+ , H_ACCG_ACCG36, H_ACCG_ACCG37, H_ACCG_ACCG38, H_ACCG_ACCG39
+ , H_ACCG_ACCG40, H_ACCG_ACCG41, H_ACCG_ACCG42, H_ACCG_ACCG43
+ , H_ACCG_ACCG44, H_ACCG_ACCG45, H_ACCG_ACCG46, H_ACCG_ACCG47
+ , H_ACCG_ACCG48, H_ACCG_ACCG49, H_ACCG_ACCG50, H_ACCG_ACCG51
+ , H_ACCG_ACCG52, H_ACCG_ACCG53, H_ACCG_ACCG54, H_ACCG_ACCG55
+ , H_ACCG_ACCG56, H_ACCG_ACCG57, H_ACCG_ACCG58, H_ACCG_ACCG59
+ , H_ACCG_ACCG60, H_ACCG_ACCG61, H_ACCG_ACCG62, H_ACCG_ACCG63
+} ACCG_NAMES;
+
+/* Enum declaration for .  */
+typedef enum acc_names {
+  H_ACC40_ACC0, H_ACC40_ACC1, H_ACC40_ACC2, H_ACC40_ACC3
+ , H_ACC40_ACC4, H_ACC40_ACC5, H_ACC40_ACC6, H_ACC40_ACC7
+ , H_ACC40_ACC8, H_ACC40_ACC9, H_ACC40_ACC10, H_ACC40_ACC11
+ , H_ACC40_ACC12, H_ACC40_ACC13, H_ACC40_ACC14, H_ACC40_ACC15
+ , H_ACC40_ACC16, H_ACC40_ACC17, H_ACC40_ACC18, H_ACC40_ACC19
+ , H_ACC40_ACC20, H_ACC40_ACC21, H_ACC40_ACC22, H_ACC40_ACC23
+ , H_ACC40_ACC24, H_ACC40_ACC25, H_ACC40_ACC26, H_ACC40_ACC27
+ , H_ACC40_ACC28, H_ACC40_ACC29, H_ACC40_ACC30, H_ACC40_ACC31
+ , H_ACC40_ACC32, H_ACC40_ACC33, H_ACC40_ACC34, H_ACC40_ACC35
+ , H_ACC40_ACC36, H_ACC40_ACC37, H_ACC40_ACC38, H_ACC40_ACC39
+ , H_ACC40_ACC40, H_ACC40_ACC41, H_ACC40_ACC42, H_ACC40_ACC43
+ , H_ACC40_ACC44, H_ACC40_ACC45, H_ACC40_ACC46, H_ACC40_ACC47
+ , H_ACC40_ACC48, H_ACC40_ACC49, H_ACC40_ACC50, H_ACC40_ACC51
+ , H_ACC40_ACC52, H_ACC40_ACC53, H_ACC40_ACC54, H_ACC40_ACC55
+ , H_ACC40_ACC56, H_ACC40_ACC57, H_ACC40_ACC58, H_ACC40_ACC59
+ , H_ACC40_ACC60, H_ACC40_ACC61, H_ACC40_ACC62, H_ACC40_ACC63
+} ACC_NAMES;
+
+/* Enum declaration for .  */
+typedef enum iccr_names {
+  H_ICCR_ICC0, H_ICCR_ICC1, H_ICCR_ICC2, H_ICCR_ICC3
+} ICCR_NAMES;
+
+/* Enum declaration for .  */
+typedef enum fccr_names {
+  H_FCCR_FCC0, H_FCCR_FCC1, H_FCCR_FCC2, H_FCCR_FCC3
+} FCCR_NAMES;
+
+/* Enum declaration for .  */
+typedef enum cccr_names {
+  H_CCCR_CC0, H_CCCR_CC1, H_CCCR_CC2, H_CCCR_CC3
+ , H_CCCR_CC4, H_CCCR_CC5, H_CCCR_CC6, H_CCCR_CC7
+} CCCR_NAMES;
+
+/* Attributes.  */
+
+/* Enum declaration for machine type selection.  */
+typedef enum mach_attr {
+  MACH_BASE, MACH_FRV, MACH_FR500, MACH_FR400
+ , MACH_TOMCAT, MACH_SIMPLE, MACH_MAX
+} MACH_ATTR;
+
+/* Enum declaration for instruction set selection.  */
+typedef enum isa_attr {
+  ISA_FRV, ISA_MAX
+} ISA_ATTR;
+
+/* Enum declaration for parallel execution pipeline selection.  */
+typedef enum unit_attr {
+  UNIT_NIL, UNIT_I0, UNIT_I1, UNIT_I01
+ , UNIT_FM0, UNIT_FM1, UNIT_FM01, UNIT_B0
+ , UNIT_B1, UNIT_B01, UNIT_C, UNIT_MULT_DIV
+ , UNIT_LOAD, UNIT_NUM_UNITS
+} UNIT_ATTR;
+
+/* Enum declaration for fr400 major insn categories.  */
+typedef enum fr400_major_attr {
+  FR400_MAJOR_NONE, FR400_MAJOR_I_1, FR400_MAJOR_I_2, FR400_MAJOR_I_3
+ , FR400_MAJOR_I_4, FR400_MAJOR_I_5, FR400_MAJOR_B_1, FR400_MAJOR_B_2
+ , FR400_MAJOR_B_3, FR400_MAJOR_B_4, FR400_MAJOR_B_5, FR400_MAJOR_B_6
+ , FR400_MAJOR_C_1, FR400_MAJOR_C_2, FR400_MAJOR_M_1, FR400_MAJOR_M_2
+} FR400_MAJOR_ATTR;
+
+/* Enum declaration for fr500 major insn categories.  */
+typedef enum fr500_major_attr {
+  FR500_MAJOR_NONE, FR500_MAJOR_I_1, FR500_MAJOR_I_2, FR500_MAJOR_I_3
+ , FR500_MAJOR_I_4, FR500_MAJOR_I_5, FR500_MAJOR_I_6, FR500_MAJOR_B_1
+ , FR500_MAJOR_B_2, FR500_MAJOR_B_3, FR500_MAJOR_B_4, FR500_MAJOR_B_5
+ , FR500_MAJOR_B_6, FR500_MAJOR_C_1, FR500_MAJOR_C_2, FR500_MAJOR_F_1
+ , FR500_MAJOR_F_2, FR500_MAJOR_F_3, FR500_MAJOR_F_4, FR500_MAJOR_F_5
+ , FR500_MAJOR_F_6, FR500_MAJOR_F_7, FR500_MAJOR_F_8, FR500_MAJOR_M_1
+ , FR500_MAJOR_M_2, FR500_MAJOR_M_3, FR500_MAJOR_M_4, FR500_MAJOR_M_5
+ , FR500_MAJOR_M_6, FR500_MAJOR_M_7, FR500_MAJOR_M_8
+} FR500_MAJOR_ATTR;
+
+/* Number of architecture variants.  */
+#define MAX_ISAS  1
+#define MAX_MACHS ((int) MACH_MAX)
+
+/* Ifield support.  */
+
+extern const struct cgen_ifld frv_cgen_ifld_table[];
+
+/* 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)
+
+/* Enum declaration for frv ifield types.  */
+typedef enum ifield_type {
+  FRV_F_NIL, FRV_F_ANYOF, FRV_F_PACK, FRV_F_OP
+ , FRV_F_OPE1, FRV_F_OPE2, FRV_F_OPE3, FRV_F_OPE4
+ , FRV_F_GRI, FRV_F_GRJ, FRV_F_GRK, FRV_F_FRI
+ , FRV_F_FRJ, FRV_F_FRK, FRV_F_CPRI, FRV_F_CPRJ
+ , FRV_F_CPRK, FRV_F_ACCGI, FRV_F_ACCGK, FRV_F_ACC40SI
+ , FRV_F_ACC40UI, FRV_F_ACC40SK, FRV_F_ACC40UK, FRV_F_CRI
+ , FRV_F_CRJ, FRV_F_CRK, FRV_F_CCI, FRV_F_CRJ_INT
+ , FRV_F_CRJ_FLOAT, FRV_F_ICCI_1, FRV_F_ICCI_2, FRV_F_ICCI_3
+ , FRV_F_FCCI_1, FRV_F_FCCI_2, FRV_F_FCCI_3, FRV_F_FCCK
+ , FRV_F_EIR, FRV_F_S10, FRV_F_S12, FRV_F_D12
+ , FRV_F_U16, FRV_F_S16, FRV_F_S6, FRV_F_S6_1
+ , FRV_F_U6, FRV_F_S5, FRV_F_U12_H, FRV_F_U12_L
+ , FRV_F_U12, FRV_F_INT_CC, FRV_F_FLT_CC, FRV_F_COND
+ , FRV_F_CCOND, FRV_F_HINT, FRV_F_LI, FRV_F_LOCK
+ , FRV_F_DEBUG, FRV_F_A, FRV_F_AE, FRV_F_SPR_H
+ , FRV_F_SPR_L, FRV_F_SPR, FRV_F_LABEL16, FRV_F_LABELH6
+ , FRV_F_LABELL18, FRV_F_LABEL24, FRV_F_ICCI_1_NULL, FRV_F_ICCI_2_NULL
+ , FRV_F_ICCI_3_NULL, FRV_F_FCCI_1_NULL, FRV_F_FCCI_2_NULL, FRV_F_FCCI_3_NULL
+ , FRV_F_RS_NULL, FRV_F_GRI_NULL, FRV_F_GRJ_NULL, FRV_F_GRK_NULL
+ , FRV_F_FRI_NULL, FRV_F_FRJ_NULL, FRV_F_ACCJ_NULL, FRV_F_RD_NULL
+ , FRV_F_COND_NULL, FRV_F_CCOND_NULL, FRV_F_S12_NULL, FRV_F_LABEL16_NULL
+ , FRV_F_MISC_NULL_1, FRV_F_MISC_NULL_2, FRV_F_MISC_NULL_3, FRV_F_MISC_NULL_4
+ , FRV_F_MISC_NULL_5, FRV_F_MISC_NULL_6, FRV_F_MISC_NULL_7, FRV_F_MISC_NULL_8
+ , FRV_F_MISC_NULL_9, FRV_F_MISC_NULL_10, FRV_F_MISC_NULL_11, FRV_F_LI_OFF
+ , FRV_F_LI_ON, FRV_F_MAX
+} IFIELD_TYPE;
+
+#define MAX_IFLD ((int) FRV_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)
+
+/* Enum declaration for frv hardware types.  */
+typedef enum cgen_hw_type {
+  HW_H_MEMORY, HW_H_SINT, HW_H_UINT, HW_H_ADDR
+ , HW_H_IADDR, HW_H_PC, HW_H_PSR_IMPLE, HW_H_PSR_VER
+ , HW_H_PSR_ICE, HW_H_PSR_NEM, HW_H_PSR_CM, HW_H_PSR_BE
+ , HW_H_PSR_ESR, HW_H_PSR_EF, HW_H_PSR_EM, HW_H_PSR_PIL
+ , HW_H_PSR_PS, HW_H_PSR_ET, HW_H_PSR_S, HW_H_TBR_TBA
+ , HW_H_TBR_TT, HW_H_BPSR_BS, HW_H_BPSR_BET, HW_H_GR
+ , HW_H_GR_DOUBLE, HW_H_GR_HI, HW_H_GR_LO, HW_H_FR
+ , HW_H_FR_DOUBLE, HW_H_FR_INT, HW_H_FR_HI, HW_H_FR_LO
+ , HW_H_FR_0, HW_H_FR_1, HW_H_FR_2, HW_H_FR_3
+ , HW_H_CPR, HW_H_CPR_DOUBLE, HW_H_SPR, HW_H_ACCG
+ , HW_H_ACC40S, HW_H_ACC40U, HW_H_ICCR, HW_H_FCCR
+ , HW_H_CCCR, HW_H_PACK, HW_H_HINT_TAKEN, HW_H_HINT_NOT_TAKEN
+ , 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_HASH_PREFIX, 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)
+
+/* Enum declaration for frv operand types.  */
+typedef enum cgen_operand_type {
+  FRV_OPERAND_PC, FRV_OPERAND_PACK, FRV_OPERAND_GRI, FRV_OPERAND_GRJ
+ , FRV_OPERAND_GRK, FRV_OPERAND_GRKHI, FRV_OPERAND_GRKLO, FRV_OPERAND_GRDOUBLEK
+ , FRV_OPERAND_ACC40SI, FRV_OPERAND_ACC40UI, FRV_OPERAND_ACC40SK, FRV_OPERAND_ACC40UK
+ , FRV_OPERAND_ACCGI, FRV_OPERAND_ACCGK, FRV_OPERAND_CPRI, FRV_OPERAND_CPRJ
+ , FRV_OPERAND_CPRK, FRV_OPERAND_CPRDOUBLEK, FRV_OPERAND_FRINTI, FRV_OPERAND_FRINTJ
+ , FRV_OPERAND_FRINTK, FRV_OPERAND_FRI, FRV_OPERAND_FRJ, FRV_OPERAND_FRK
+ , FRV_OPERAND_FRKHI, FRV_OPERAND_FRKLO, FRV_OPERAND_FRDOUBLEI, FRV_OPERAND_FRDOUBLEJ
+ , FRV_OPERAND_FRDOUBLEK, FRV_OPERAND_CRI, FRV_OPERAND_CRJ, FRV_OPERAND_CRJ_INT
+ , FRV_OPERAND_CRJ_FLOAT, FRV_OPERAND_CRK, FRV_OPERAND_CCI, FRV_OPERAND_ICCI_1
+ , FRV_OPERAND_ICCI_2, FRV_OPERAND_ICCI_3, FRV_OPERAND_FCCI_1, FRV_OPERAND_FCCI_2
+ , FRV_OPERAND_FCCI_3, FRV_OPERAND_FCCK, FRV_OPERAND_EIR, FRV_OPERAND_S10
+ , FRV_OPERAND_U16, FRV_OPERAND_S16, FRV_OPERAND_S6, FRV_OPERAND_S6_1
+ , FRV_OPERAND_U6, FRV_OPERAND_S5, FRV_OPERAND_COND, FRV_OPERAND_CCOND
+ , FRV_OPERAND_HINT, FRV_OPERAND_HINT_TAKEN, FRV_OPERAND_HINT_NOT_TAKEN, FRV_OPERAND_LI
+ , FRV_OPERAND_LOCK, FRV_OPERAND_DEBUG, FRV_OPERAND_A, FRV_OPERAND_AE
+ , FRV_OPERAND_LABEL16, FRV_OPERAND_LABEL24, FRV_OPERAND_D12, FRV_OPERAND_S12
+ , FRV_OPERAND_U12, FRV_OPERAND_SPR, FRV_OPERAND_ULO16, FRV_OPERAND_SLO16
+ , FRV_OPERAND_UHI16, FRV_OPERAND_PSR_ESR, FRV_OPERAND_PSR_S, FRV_OPERAND_PSR_PS
+ , FRV_OPERAND_PSR_ET, FRV_OPERAND_BPSR_BS, FRV_OPERAND_BPSR_BET, FRV_OPERAND_TBR_TBA
+ , FRV_OPERAND_TBR_TT, FRV_OPERAND_MAX
+} CGEN_OPERAND_TYPE;
+
+/* Number of operands types.  */
+#define MAX_OPERANDS 77
+
+/* Maximum number of operands referenced by any insn.  */
+#define MAX_OPERAND_INSTANCES 8
+
+/* 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_RELAX
+ , CGEN_INSN_NO_DIS, CGEN_INSN_PBB, CGEN_INSN_PRIVILEGED, CGEN_INSN_NON_EXCEPTING
+ , CGEN_INSN_CONDITIONAL, CGEN_INSN_FR_ACCESS, CGEN_INSN_PRESERVE_OVF, CGEN_INSN_END_BOOLS
+ , CGEN_INSN_START_NBOOLS = 31, CGEN_INSN_MACH, CGEN_INSN_UNIT, CGEN_INSN_FR400_MAJOR
+ , CGEN_INSN_FR500_MAJOR, 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.h uses things we just defined.  */
+#include "opcode/cgen.h"
+
+/* Attributes.  */
+extern const CGEN_ATTR_TABLE frv_cgen_hardware_attr_table[];
+extern const CGEN_ATTR_TABLE frv_cgen_ifield_attr_table[];
+extern const CGEN_ATTR_TABLE frv_cgen_operand_attr_table[];
+extern const CGEN_ATTR_TABLE frv_cgen_insn_attr_table[];
+
+/* Hardware decls.  */
+
+extern CGEN_KEYWORD frv_cgen_opval_gr_names;
+extern CGEN_KEYWORD frv_cgen_opval_gr_names;
+extern CGEN_KEYWORD frv_cgen_opval_gr_names;
+extern CGEN_KEYWORD frv_cgen_opval_gr_names;
+extern CGEN_KEYWORD frv_cgen_opval_fr_names;
+extern CGEN_KEYWORD frv_cgen_opval_fr_names;
+extern CGEN_KEYWORD frv_cgen_opval_fr_names;
+extern CGEN_KEYWORD frv_cgen_opval_fr_names;
+extern CGEN_KEYWORD frv_cgen_opval_fr_names;
+extern CGEN_KEYWORD frv_cgen_opval_fr_names;
+extern CGEN_KEYWORD frv_cgen_opval_fr_names;
+extern CGEN_KEYWORD frv_cgen_opval_fr_names;
+extern CGEN_KEYWORD frv_cgen_opval_fr_names;
+extern CGEN_KEYWORD frv_cgen_opval_cpr_names;
+extern CGEN_KEYWORD frv_cgen_opval_cpr_names;
+extern CGEN_KEYWORD frv_cgen_opval_spr_names;
+extern CGEN_KEYWORD frv_cgen_opval_accg_names;
+extern CGEN_KEYWORD frv_cgen_opval_acc_names;
+extern CGEN_KEYWORD frv_cgen_opval_acc_names;
+extern CGEN_KEYWORD frv_cgen_opval_iccr_names;
+extern CGEN_KEYWORD frv_cgen_opval_fccr_names;
+extern CGEN_KEYWORD frv_cgen_opval_cccr_names;
+extern CGEN_KEYWORD frv_cgen_opval_h_pack;
+extern CGEN_KEYWORD frv_cgen_opval_h_hint_taken;
+extern CGEN_KEYWORD frv_cgen_opval_h_hint_not_taken;
+
+
+
+
+#endif /* FRV_CPU_H */
diff --git a/opcodes/frv-dis.c b/opcodes/frv-dis.c
new file mode 100644
index 00000000000..a6378763868
--- /dev/null
+++ b/opcodes/frv-dis.c
@@ -0,0 +1,789 @@
+/* Disassembler interface for targets using CGEN. -*- C -*-
+   CGEN: Cpu tools GENerator
+
+THIS FILE IS MACHINE GENERATED WITH CGEN.
+- the resultant file is machine generated, cgen-dis.in isn't
+
+Copyright 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+This file is part of the GNU Binutils and GDB, the GNU debugger.
+
+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, 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.  */
+
+/* ??? 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 "frv-desc.h"
+#include "frv-opc.h"
+#include "opintl.h"
+
+/* Default text to print if an instruction isn't recognized.  */
+#define UNKNOWN_INSN_MSG _("*unknown*")
+
+static void print_normal
+     PARAMS ((CGEN_CPU_DESC, PTR, long, unsigned int, bfd_vma, int));
+static void print_address
+     PARAMS ((CGEN_CPU_DESC, PTR, bfd_vma, unsigned int, bfd_vma, int));
+static void print_keyword
+     PARAMS ((CGEN_CPU_DESC, PTR, CGEN_KEYWORD *, long, unsigned int));
+static void print_insn_normal
+     PARAMS ((CGEN_CPU_DESC, PTR, const CGEN_INSN *, CGEN_FIELDS *,
+	      bfd_vma, int));
+static int print_insn
+     PARAMS ((CGEN_CPU_DESC, bfd_vma,  disassemble_info *, char *, unsigned));
+static int default_print_insn
+     PARAMS ((CGEN_CPU_DESC, bfd_vma, disassemble_info *));
+static int read_insn
+     PARAMS ((CGEN_CPU_DESC, bfd_vma, disassemble_info *, char *, int,
+	      CGEN_EXTRACT_INFO *, unsigned long *));
+
+/* -- disassembler routines inserted here */
+
+/* -- dis.c */
+static void print_spr
+  PARAMS ((CGEN_CPU_DESC, PTR, CGEN_KEYWORD *, long, unsigned));
+static void print_hi
+  PARAMS ((CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int));
+static void print_lo
+  PARAMS ((CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int));
+
+static void
+print_spr (cd, dis_info, names, regno, attrs)
+     CGEN_CPU_DESC cd;
+     PTR dis_info;
+     CGEN_KEYWORD *names;
+     long regno;
+     unsigned int attrs;
+{
+  /* Use the register index format for any unnamed registers.  */
+  if (cgen_keyword_lookup_value (names, regno) == NULL)
+    {
+      disassemble_info *info = (disassemble_info *) dis_info;
+      (*info->fprintf_func) (info->stream, "spr[%ld]", regno);
+    }
+  else
+    print_keyword (cd, dis_info, names, regno, attrs);
+}
+
+static void
+print_hi (cd, dis_info, value, attrs, pc, length)
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
+     PTR dis_info;
+     long value;
+     unsigned int attrs ATTRIBUTE_UNUSED;
+     bfd_vma pc ATTRIBUTE_UNUSED;
+     int length ATTRIBUTE_UNUSED;
+{
+  disassemble_info *info = (disassemble_info *) dis_info;
+  if (value)
+    (*info->fprintf_func) (info->stream, "0x%lx", value);
+  else
+    (*info->fprintf_func) (info->stream, "hi(0x%lx)", value);
+}
+
+static void
+print_lo (cd, dis_info, value, attrs, pc, length)
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
+     PTR dis_info;
+     long value;
+     unsigned int attrs ATTRIBUTE_UNUSED;
+     bfd_vma pc ATTRIBUTE_UNUSED;
+     int length ATTRIBUTE_UNUSED;
+{
+  disassemble_info *info = (disassemble_info *) dis_info;
+  if (value)
+    (*info->fprintf_func) (info->stream, "0x%lx", value);
+  else
+    (*info->fprintf_func) (info->stream, "lo(0x%lx)", value);
+}
+
+/* -- */
+
+void frv_cgen_print_operand
+  PARAMS ((CGEN_CPU_DESC, int, PTR, CGEN_FIELDS *,
+           void const *, bfd_vma, int));
+
+/* Main entry point for printing operands.
+   XINFO is a `void *' and not a `disassemble_info *' to not put a requirement
+   of dis-asm.h on cgen.h.
+
+   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.  */
+
+void
+frv_cgen_print_operand (cd, opindex, xinfo, fields, attrs, pc, length)
+     CGEN_CPU_DESC cd;
+     int opindex;
+     PTR xinfo;
+     CGEN_FIELDS *fields;
+     void const *attrs ATTRIBUTE_UNUSED;
+     bfd_vma pc;
+     int length;
+{
+ disassemble_info *info = (disassemble_info *) xinfo;
+
+  switch (opindex)
+    {
+    case FRV_OPERAND_A :
+      print_normal (cd, info, fields->f_A, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_ACC40SI :
+      print_keyword (cd, info, & frv_cgen_opval_acc_names, fields->f_ACC40Si, 0);
+      break;
+    case FRV_OPERAND_ACC40SK :
+      print_keyword (cd, info, & frv_cgen_opval_acc_names, fields->f_ACC40Sk, 0);
+      break;
+    case FRV_OPERAND_ACC40UI :
+      print_keyword (cd, info, & frv_cgen_opval_acc_names, fields->f_ACC40Ui, 0);
+      break;
+    case FRV_OPERAND_ACC40UK :
+      print_keyword (cd, info, & frv_cgen_opval_acc_names, fields->f_ACC40Uk, 0);
+      break;
+    case FRV_OPERAND_ACCGI :
+      print_keyword (cd, info, & frv_cgen_opval_accg_names, fields->f_ACCGi, 0);
+      break;
+    case FRV_OPERAND_ACCGK :
+      print_keyword (cd, info, & frv_cgen_opval_accg_names, fields->f_ACCGk, 0);
+      break;
+    case FRV_OPERAND_CCI :
+      print_keyword (cd, info, & frv_cgen_opval_cccr_names, fields->f_CCi, 0);
+      break;
+    case FRV_OPERAND_CPRDOUBLEK :
+      print_keyword (cd, info, & frv_cgen_opval_cpr_names, fields->f_CPRk, 0);
+      break;
+    case FRV_OPERAND_CPRI :
+      print_keyword (cd, info, & frv_cgen_opval_cpr_names, fields->f_CPRi, 0);
+      break;
+    case FRV_OPERAND_CPRJ :
+      print_keyword (cd, info, & frv_cgen_opval_cpr_names, fields->f_CPRj, 0);
+      break;
+    case FRV_OPERAND_CPRK :
+      print_keyword (cd, info, & frv_cgen_opval_cpr_names, fields->f_CPRk, 0);
+      break;
+    case FRV_OPERAND_CRI :
+      print_keyword (cd, info, & frv_cgen_opval_cccr_names, fields->f_CRi, 0);
+      break;
+    case FRV_OPERAND_CRJ :
+      print_keyword (cd, info, & frv_cgen_opval_cccr_names, fields->f_CRj, 0);
+      break;
+    case FRV_OPERAND_CRJ_FLOAT :
+      print_keyword (cd, info, & frv_cgen_opval_cccr_names, fields->f_CRj_float, 0);
+      break;
+    case FRV_OPERAND_CRJ_INT :
+      print_keyword (cd, info, & frv_cgen_opval_cccr_names, fields->f_CRj_int, 0);
+      break;
+    case FRV_OPERAND_CRK :
+      print_keyword (cd, info, & frv_cgen_opval_cccr_names, fields->f_CRk, 0);
+      break;
+    case FRV_OPERAND_FCCI_1 :
+      print_keyword (cd, info, & frv_cgen_opval_fccr_names, fields->f_FCCi_1, 0);
+      break;
+    case FRV_OPERAND_FCCI_2 :
+      print_keyword (cd, info, & frv_cgen_opval_fccr_names, fields->f_FCCi_2, 0);
+      break;
+    case FRV_OPERAND_FCCI_3 :
+      print_keyword (cd, info, & frv_cgen_opval_fccr_names, fields->f_FCCi_3, 0);
+      break;
+    case FRV_OPERAND_FCCK :
+      print_keyword (cd, info, & frv_cgen_opval_fccr_names, fields->f_FCCk, 0);
+      break;
+    case FRV_OPERAND_FRDOUBLEI :
+      print_keyword (cd, info, & frv_cgen_opval_fr_names, fields->f_FRi, 0);
+      break;
+    case FRV_OPERAND_FRDOUBLEJ :
+      print_keyword (cd, info, & frv_cgen_opval_fr_names, fields->f_FRj, 0);
+      break;
+    case FRV_OPERAND_FRDOUBLEK :
+      print_keyword (cd, info, & frv_cgen_opval_fr_names, fields->f_FRk, 0);
+      break;
+    case FRV_OPERAND_FRI :
+      print_keyword (cd, info, & frv_cgen_opval_fr_names, fields->f_FRi, 0);
+      break;
+    case FRV_OPERAND_FRINTI :
+      print_keyword (cd, info, & frv_cgen_opval_fr_names, fields->f_FRi, 0);
+      break;
+    case FRV_OPERAND_FRINTJ :
+      print_keyword (cd, info, & frv_cgen_opval_fr_names, fields->f_FRj, 0);
+      break;
+    case FRV_OPERAND_FRINTK :
+      print_keyword (cd, info, & frv_cgen_opval_fr_names, fields->f_FRk, 0);
+      break;
+    case FRV_OPERAND_FRJ :
+      print_keyword (cd, info, & frv_cgen_opval_fr_names, fields->f_FRj, 0);
+      break;
+    case FRV_OPERAND_FRK :
+      print_keyword (cd, info, & frv_cgen_opval_fr_names, fields->f_FRk, 0);
+      break;
+    case FRV_OPERAND_FRKHI :
+      print_keyword (cd, info, & frv_cgen_opval_fr_names, fields->f_FRk, 0);
+      break;
+    case FRV_OPERAND_FRKLO :
+      print_keyword (cd, info, & frv_cgen_opval_fr_names, fields->f_FRk, 0);
+      break;
+    case FRV_OPERAND_GRDOUBLEK :
+      print_keyword (cd, info, & frv_cgen_opval_gr_names, fields->f_GRk, 0);
+      break;
+    case FRV_OPERAND_GRI :
+      print_keyword (cd, info, & frv_cgen_opval_gr_names, fields->f_GRi, 0);
+      break;
+    case FRV_OPERAND_GRJ :
+      print_keyword (cd, info, & frv_cgen_opval_gr_names, fields->f_GRj, 0);
+      break;
+    case FRV_OPERAND_GRK :
+      print_keyword (cd, info, & frv_cgen_opval_gr_names, fields->f_GRk, 0);
+      break;
+    case FRV_OPERAND_GRKHI :
+      print_keyword (cd, info, & frv_cgen_opval_gr_names, fields->f_GRk, 0);
+      break;
+    case FRV_OPERAND_GRKLO :
+      print_keyword (cd, info, & frv_cgen_opval_gr_names, fields->f_GRk, 0);
+      break;
+    case FRV_OPERAND_ICCI_1 :
+      print_keyword (cd, info, & frv_cgen_opval_iccr_names, fields->f_ICCi_1, 0);
+      break;
+    case FRV_OPERAND_ICCI_2 :
+      print_keyword (cd, info, & frv_cgen_opval_iccr_names, fields->f_ICCi_2, 0);
+      break;
+    case FRV_OPERAND_ICCI_3 :
+      print_keyword (cd, info, & frv_cgen_opval_iccr_names, fields->f_ICCi_3, 0);
+      break;
+    case FRV_OPERAND_LI :
+      print_normal (cd, info, fields->f_LI, 0, pc, length);
+      break;
+    case FRV_OPERAND_AE :
+      print_normal (cd, info, fields->f_ae, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_CCOND :
+      print_normal (cd, info, fields->f_ccond, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_COND :
+      print_normal (cd, info, fields->f_cond, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_D12 :
+      print_normal (cd, info, fields->f_d12, 0|(1<<CGEN_OPERAND_SIGNED), pc, length);
+      break;
+    case FRV_OPERAND_DEBUG :
+      print_normal (cd, info, fields->f_debug, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_EIR :
+      print_normal (cd, info, fields->f_eir, 0, pc, length);
+      break;
+    case FRV_OPERAND_HINT :
+      print_normal (cd, info, fields->f_hint, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_HINT_NOT_TAKEN :
+      print_keyword (cd, info, & frv_cgen_opval_h_hint_not_taken, fields->f_hint, 0);
+      break;
+    case FRV_OPERAND_HINT_TAKEN :
+      print_keyword (cd, info, & frv_cgen_opval_h_hint_taken, fields->f_hint, 0);
+      break;
+    case FRV_OPERAND_LABEL16 :
+      print_address (cd, info, fields->f_label16, 0|(1<<CGEN_OPERAND_PCREL_ADDR), pc, length);
+      break;
+    case FRV_OPERAND_LABEL24 :
+      print_address (cd, info, fields->f_label24, 0|(1<<CGEN_OPERAND_PCREL_ADDR)|(1<<CGEN_OPERAND_VIRTUAL), pc, length);
+      break;
+    case FRV_OPERAND_LOCK :
+      print_normal (cd, info, fields->f_lock, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_PACK :
+      print_keyword (cd, info, & frv_cgen_opval_h_pack, fields->f_pack, 0);
+      break;
+    case FRV_OPERAND_S10 :
+      print_normal (cd, info, fields->f_s10, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_S12 :
+      print_normal (cd, info, fields->f_d12, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_S16 :
+      print_normal (cd, info, fields->f_s16, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_S5 :
+      print_normal (cd, info, fields->f_s5, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_S6 :
+      print_normal (cd, info, fields->f_s6, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_S6_1 :
+      print_normal (cd, info, fields->f_s6_1, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_SLO16 :
+      print_lo (cd, info, fields->f_s16, 0|(1<<CGEN_OPERAND_SIGNED), pc, length);
+      break;
+    case FRV_OPERAND_SPR :
+      print_spr (cd, info, & frv_cgen_opval_spr_names, fields->f_spr, 0|(1<<CGEN_OPERAND_VIRTUAL));
+      break;
+    case FRV_OPERAND_U12 :
+      print_normal (cd, info, fields->f_u12, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_HASH_PREFIX)|(1<<CGEN_OPERAND_VIRTUAL), pc, length);
+      break;
+    case FRV_OPERAND_U16 :
+      print_normal (cd, info, fields->f_u16, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_U6 :
+      print_normal (cd, info, fields->f_u6, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
+      break;
+    case FRV_OPERAND_UHI16 :
+      print_hi (cd, info, fields->f_u16, 0, pc, length);
+      break;
+    case FRV_OPERAND_ULO16 :
+      print_lo (cd, info, fields->f_u16, 0, pc, length);
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while printing insn.\n"),
+	       opindex);
+    abort ();
+  }
+}
+
+cgen_print_fn * const frv_cgen_print_handlers[] = 
+{
+  print_insn_normal,
+};
+
+
+void
+frv_cgen_init_dis (cd)
+     CGEN_CPU_DESC cd;
+{
+  frv_cgen_init_opcode_table (cd);
+  frv_cgen_init_ibld_table (cd);
+  cd->print_handlers = & frv_cgen_print_handlers[0];
+  cd->print_operand = frv_cgen_print_operand;
+}
+
+
+/* Default print handler.  */
+
+static void
+print_normal (cd, dis_info, value, attrs, pc, length)
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
+     PTR dis_info;
+     long value;
+     unsigned int attrs;
+     bfd_vma pc ATTRIBUTE_UNUSED;
+     int length ATTRIBUTE_UNUSED;
+{
+  disassemble_info *info = (disassemble_info *) dis_info;
+
+#ifdef CGEN_PRINT_NORMAL
+  CGEN_PRINT_NORMAL (cd, info, value, attrs, pc, length);
+#endif
+
+  /* Print the operand as directed by the attributes.  */
+  if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
+    ; /* nothing to do */
+  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
+    (*info->fprintf_func) (info->stream, "%ld", value);
+  else
+    (*info->fprintf_func) (info->stream, "0x%lx", value);
+}
+
+/* Default address handler.  */
+
+static void
+print_address (cd, dis_info, value, attrs, pc, length)
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
+     PTR dis_info;
+     bfd_vma value;
+     unsigned int attrs;
+     bfd_vma pc ATTRIBUTE_UNUSED;
+     int length ATTRIBUTE_UNUSED;
+{
+  disassemble_info *info = (disassemble_info *) dis_info;
+
+#ifdef CGEN_PRINT_ADDRESS
+  CGEN_PRINT_ADDRESS (cd, info, value, attrs, pc, length);
+#endif
+
+  /* Print the operand as directed by the attributes.  */
+  if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
+    ; /* nothing to do */
+  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR))
+    (*info->print_address_func) (value, info);
+  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR))
+    (*info->print_address_func) (value, info);
+  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
+    (*info->fprintf_func) (info->stream, "%ld", (long) value);
+  else
+    (*info->fprintf_func) (info->stream, "0x%lx", (long) value);
+}
+
+/* Keyword print handler.  */
+
+static void
+print_keyword (cd, dis_info, keyword_table, value, attrs)
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
+     PTR dis_info;
+     CGEN_KEYWORD *keyword_table;
+     long value;
+     unsigned int attrs ATTRIBUTE_UNUSED;
+{
+  disassemble_info *info = (disassemble_info *) dis_info;
+  const CGEN_KEYWORD_ENTRY *ke;
+
+  ke = cgen_keyword_lookup_value (keyword_table, value);
+  if (ke != NULL)
+    (*info->fprintf_func) (info->stream, "%s", ke->name);
+  else
+    (*info->fprintf_func) (info->stream, "???");
+}
+
+/* Default insn printer.
+
+   DIS_INFO is defined as `PTR' so the disassembler needn't know anything
+   about disassemble_info.  */
+
+static void
+print_insn_normal (cd, dis_info, insn, fields, pc, length)
+     CGEN_CPU_DESC cd;
+     PTR dis_info;
+     const CGEN_INSN *insn;
+     CGEN_FIELDS *fields;
+     bfd_vma pc;
+     int length;
+{
+  const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
+  disassemble_info *info = (disassemble_info *) dis_info;
+  const CGEN_SYNTAX_CHAR_TYPE *syn;
+
+  CGEN_INIT_PRINT (cd);
+
+  for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
+    {
+      if (CGEN_SYNTAX_MNEMONIC_P (*syn))
+	{
+	  (*info->fprintf_func) (info->stream, "%s", CGEN_INSN_MNEMONIC (insn));
+	  continue;
+	}
+      if (CGEN_SYNTAX_CHAR_P (*syn))
+	{
+	  (*info->fprintf_func) (info->stream, "%c", CGEN_SYNTAX_CHAR (*syn));
+	  continue;
+	}
+
+      /* We have an operand.  */
+      frv_cgen_print_operand (cd, CGEN_SYNTAX_FIELD (*syn), info,
+				 fields, CGEN_INSN_ATTRS (insn), pc, length);
+    }
+}
+
+/* Subroutine of print_insn. Reads an insn into the given buffers and updates
+   the extract info.
+   Returns 0 if all is well, non-zero otherwise.  */
+
+static int
+read_insn (cd, pc, info, buf, buflen, ex_info, insn_value)
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
+     bfd_vma pc;
+     disassemble_info *info;
+     char *buf;
+     int buflen;
+     CGEN_EXTRACT_INFO *ex_info;
+     unsigned long *insn_value;
+{
+  int status = (*info->read_memory_func) (pc, buf, buflen, info);
+  if (status != 0)
+    {
+      (*info->memory_error_func) (status, pc, info);
+      return -1;
+    }
+
+  ex_info->dis_info = info;
+  ex_info->valid = (1 << buflen) - 1;
+  ex_info->insn_bytes = buf;
+
+  *insn_value = bfd_get_bits (buf, buflen * 8, info->endian == BFD_ENDIAN_BIG);
+  return 0;
+}
+
+/* Utility to print an insn.
+   BUF is the base part of the insn, target byte order, BUFLEN bytes long.
+   The result is the size of the insn in bytes or zero for an unknown insn
+   or -1 if an error occurs fetching data (memory_error_func will have
+   been called).  */
+
+static int
+print_insn (cd, pc, info, buf, buflen)
+     CGEN_CPU_DESC cd;
+     bfd_vma pc;
+     disassemble_info *info;
+     char *buf;
+     unsigned int buflen;
+{
+  CGEN_INSN_INT insn_value;
+  const CGEN_INSN_LIST *insn_list;
+  CGEN_EXTRACT_INFO ex_info;
+  int basesize;
+
+  /* Extract base part of instruction, just in case CGEN_DIS_* uses it. */
+  basesize = cd->base_insn_bitsize < buflen * 8 ?
+                                     cd->base_insn_bitsize : buflen * 8;
+  insn_value = cgen_get_insn_value (cd, buf, basesize);
+
+
+  /* Fill in ex_info fields like read_insn would.  Don't actually call
+     read_insn, since the incoming buffer is already read (and possibly
+     modified a la m32r).  */
+  ex_info.valid = (1 << buflen) - 1;
+  ex_info.dis_info = info;
+  ex_info.insn_bytes = buf;
+
+  /* The instructions are stored in hash lists.
+     Pick the first one and keep trying until we find the right one.  */
+
+  insn_list = CGEN_DIS_LOOKUP_INSN (cd, buf, insn_value);
+  while (insn_list != NULL)
+    {
+      const CGEN_INSN *insn = insn_list->insn;
+      CGEN_FIELDS fields;
+      int length;
+      unsigned long insn_value_cropped;
+
+#ifdef CGEN_VALIDATE_INSN_SUPPORTED 
+      /* Not needed as insn shouldn't be in hash lists if not supported.  */
+      /* Supported by this cpu?  */
+      if (! frv_cgen_insn_supported (cd, insn))
+        {
+          insn_list = CGEN_DIS_NEXT_INSN (insn_list);
+	  continue;
+        }
+#endif
+
+      /* Basic bit mask must be correct.  */
+      /* ??? May wish to allow target to defer this check until the extract
+	 handler.  */
+
+      /* Base size may exceed this instruction's size.  Extract the
+         relevant part from the buffer. */
+      if ((unsigned) (CGEN_INSN_BITSIZE (insn) / 8) < buflen &&
+	  (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
+	insn_value_cropped = bfd_get_bits (buf, CGEN_INSN_BITSIZE (insn), 
+					   info->endian == BFD_ENDIAN_BIG);
+      else
+	insn_value_cropped = insn_value;
+
+      if ((insn_value_cropped & CGEN_INSN_BASE_MASK (insn))
+	  == CGEN_INSN_BASE_VALUE (insn))
+	{
+	  /* Printing is handled in two passes.  The first pass parses the
+	     machine insn and extracts the fields.  The second pass prints
+	     them.  */
+
+	  /* Make sure the entire insn is loaded into insn_value, if it
+	     can fit.  */
+	  if (((unsigned) CGEN_INSN_BITSIZE (insn) > cd->base_insn_bitsize) &&
+	      (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
+	    {
+	      unsigned long full_insn_value;
+	      int rc = read_insn (cd, pc, info, buf,
+				  CGEN_INSN_BITSIZE (insn) / 8,
+				  & ex_info, & full_insn_value);
+	      if (rc != 0)
+		return rc;
+	      length = CGEN_EXTRACT_FN (cd, insn)
+		(cd, insn, &ex_info, full_insn_value, &fields, pc);
+	    }
+	  else
+	    length = CGEN_EXTRACT_FN (cd, insn)
+	      (cd, insn, &ex_info, insn_value_cropped, &fields, pc);
+
+	  /* length < 0 -> error */
+	  if (length < 0)
+	    return length;
+	  if (length > 0)
+	    {
+	      CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length);
+	      /* length is in bits, result is in bytes */
+	      return length / 8;
+	    }
+	}
+
+      insn_list = CGEN_DIS_NEXT_INSN (insn_list);
+    }
+
+  return 0;
+}
+
+/* Default value for CGEN_PRINT_INSN.
+   The result is the size of the insn in bytes or zero for an unknown insn
+   or -1 if an error occured fetching bytes.  */
+
+#ifndef CGEN_PRINT_INSN
+#define CGEN_PRINT_INSN default_print_insn
+#endif
+
+static int
+default_print_insn (cd, pc, info)
+     CGEN_CPU_DESC cd;
+     bfd_vma pc;
+     disassemble_info *info;
+{
+  char buf[CGEN_MAX_INSN_SIZE];
+  int buflen;
+  int status;
+
+  /* Attempt to read the base part of the insn.  */
+  buflen = cd->base_insn_bitsize / 8;
+  status = (*info->read_memory_func) (pc, buf, buflen, info);
+
+  /* Try again with the minimum part, if min < base.  */
+  if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize))
+    {
+      buflen = cd->min_insn_bitsize / 8;
+      status = (*info->read_memory_func) (pc, buf, buflen, info);
+    }
+
+  if (status != 0)
+    {
+      (*info->memory_error_func) (status, pc, info);
+      return -1;
+    }
+
+  return print_insn (cd, pc, info, buf, buflen);
+}
+
+/* Main entry point.
+   Print one instruction from PC on INFO->STREAM.
+   Return the size of the instruction (in bytes).  */
+
+typedef struct cpu_desc_list {
+  struct cpu_desc_list *next;
+  int isa;
+  int mach;
+  int endian;
+  CGEN_CPU_DESC cd;
+} cpu_desc_list;
+
+int
+print_insn_frv (pc, info)
+     bfd_vma pc;
+     disassemble_info *info;
+{
+  static cpu_desc_list *cd_list = 0;
+  cpu_desc_list *cl = 0;
+  static CGEN_CPU_DESC cd = 0;
+  static int prev_isa;
+  static int prev_mach;
+  static int prev_endian;
+  int length;
+  int isa,mach;
+  int endian = (info->endian == BFD_ENDIAN_BIG
+		? CGEN_ENDIAN_BIG
+		: CGEN_ENDIAN_LITTLE);
+  enum bfd_architecture arch;
+
+  /* ??? gdb will set mach but leave the architecture as "unknown" */
+#ifndef CGEN_BFD_ARCH
+#define CGEN_BFD_ARCH bfd_arch_frv
+#endif
+  arch = info->arch;
+  if (arch == bfd_arch_unknown)
+    arch = CGEN_BFD_ARCH;
+   
+  /* There's no standard way to compute the machine or isa number
+     so we leave it to the target.  */
+#ifdef CGEN_COMPUTE_MACH
+  mach = CGEN_COMPUTE_MACH (info);
+#else
+  mach = info->mach;
+#endif
+
+#ifdef CGEN_COMPUTE_ISA
+  isa = CGEN_COMPUTE_ISA (info);
+#else
+  isa = info->insn_sets;
+#endif
+
+  /* If we've switched cpu's, try to find a handle we've used before */
+  if (cd
+      && (isa != prev_isa
+	  || mach != prev_mach
+	  || endian != prev_endian))
+    {
+      cd = 0;
+      for (cl = cd_list; cl; cl = cl->next)
+	{
+	  if (cl->isa == isa &&
+	      cl->mach == mach &&
+	      cl->endian == endian)
+	    {
+	      cd = cl->cd;
+	      break;
+	    }
+	}
+    } 
+
+  /* If we haven't initialized yet, initialize the opcode table.  */
+  if (! cd)
+    {
+      const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach);
+      const char *mach_name;
+
+      if (!arch_type)
+	abort ();
+      mach_name = arch_type->printable_name;
+
+      prev_isa = isa;
+      prev_mach = mach;
+      prev_endian = endian;
+      cd = frv_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa,
+				 CGEN_CPU_OPEN_BFDMACH, mach_name,
+				 CGEN_CPU_OPEN_ENDIAN, prev_endian,
+				 CGEN_CPU_OPEN_END);
+      if (!cd)
+	abort ();
+
+      /* save this away for future reference */
+      cl = xmalloc (sizeof (struct cpu_desc_list));
+      cl->cd = cd;
+      cl->isa = isa;
+      cl->mach = mach;
+      cl->endian = endian;
+      cl->next = cd_list;
+      cd_list = cl;
+
+      frv_cgen_init_dis (cd);
+    }
+
+  /* We try to have as much common code as possible.
+     But at this point some targets need to take over.  */
+  /* ??? Some targets may need a hook elsewhere.  Try to avoid this,
+     but if not possible try to move this hook elsewhere rather than
+     have two hooks.  */
+  length = CGEN_PRINT_INSN (cd, pc, info);
+  if (length > 0)
+    return length;
+  if (length < 0)
+    return -1;
+
+  (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
+  return cd->default_insn_bitsize / 8;
+}
diff --git a/opcodes/frv-ibld.c b/opcodes/frv-ibld.c
new file mode 100644
index 00000000000..316b2cc1bdb
--- /dev/null
+++ b/opcodes/frv-ibld.c
@@ -0,0 +1,2051 @@
+/* Instruction building/extraction support for frv. -*- 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 Free Software Foundation, Inc.
+
+This file is part of the GNU Binutils and GDB, the GNU debugger.
+
+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, 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.  */
+
+/* ??? 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 "frv-desc.h"
+#include "frv-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
+     PARAMS ((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
+     PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *,
+	      CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma));
+static int extract_normal
+     PARAMS ((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
+     PARAMS ((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
+     PARAMS ((CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT));
+#endif
+#if ! CGEN_INT_INSN_P
+static CGEN_INLINE void insert_1
+     PARAMS ((CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *));
+static CGEN_INLINE int fill_cache
+     PARAMS ((CGEN_CPU_DESC, CGEN_EXTRACT_INFO *,  int, int, bfd_vma));
+static CGEN_INLINE long extract_1
+     PARAMS ((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 (cd, value, start, length, word_length, bufp)
+     CGEN_CPU_DESC cd;
+     unsigned long value;
+     int start,length,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 (cd, value, attrs, word_offset, start, length, word_length,
+	       total_length, buffer)
+     CGEN_CPU_DESC cd;
+     long value;
+     unsigned int attrs;
+     unsigned int word_offset, start, length, word_length, 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 0
+  if (CGEN_INT_INSN_P
+      && word_offset != 0)
+    abort ();
+#endif
+
+  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;
+      
+      if ((unsigned long) value > maxval)
+	{
+	  /* xgettext:c-format */
+	  sprintf (errbuf,
+		   _("operand out of range (%lu not between 0 and %lu)"),
+		   value, 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 (cd, insn, fields, buffer, pc)
+     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 (cd, buf, length, insn_length, 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 (cd, ex_info, offset, bytes, pc)
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
+     CGEN_EXTRACT_INFO *ex_info;
+     int offset, 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 (cd, ex_info, start, length, word_length, bufp, pc)
+     CGEN_CPU_DESC cd;
+     CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED;
+     int start,length,word_length;
+     unsigned char *bufp;
+     bfd_vma pc ATTRIBUTE_UNUSED;
+{
+  unsigned long x;
+  int shift;
+#if 0
+  int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
+#endif
+  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 (cd, ex_info, insn_value, attrs, word_offset, start, length,
+		word_length, total_length, pc, valuep)
+     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, start, length, word_length, 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 0
+  if (CGEN_INT_INSN_P
+      && word_offset != 0)
+    abort ();
+#endif
+
+  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 == 0
+	  && word_length > total_length)
+	word_length = total_length;
+    }
+
+  /* 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 (cd, insn, ex_info, insn_value, fields, pc)
+     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 * frv_cgen_insert_operand
+  PARAMS ((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 *
+frv_cgen_insert_operand (cd, opindex, fields, buffer, pc)
+     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 FRV_OPERAND_A :
+      errmsg = insert_normal (cd, fields->f_A, 0, 0, 17, 1, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_ACC40SI :
+      errmsg = insert_normal (cd, fields->f_ACC40Si, 0, 0, 17, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_ACC40SK :
+      errmsg = insert_normal (cd, fields->f_ACC40Sk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_ACC40UI :
+      errmsg = insert_normal (cd, fields->f_ACC40Ui, 0, 0, 17, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_ACC40UK :
+      errmsg = insert_normal (cd, fields->f_ACC40Uk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_ACCGI :
+      errmsg = insert_normal (cd, fields->f_ACCGi, 0, 0, 17, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_ACCGK :
+      errmsg = insert_normal (cd, fields->f_ACCGk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_CCI :
+      errmsg = insert_normal (cd, fields->f_CCi, 0, 0, 11, 3, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_CPRDOUBLEK :
+      errmsg = insert_normal (cd, fields->f_CPRk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_CPRI :
+      errmsg = insert_normal (cd, fields->f_CPRi, 0, 0, 17, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_CPRJ :
+      errmsg = insert_normal (cd, fields->f_CPRj, 0, 0, 5, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_CPRK :
+      errmsg = insert_normal (cd, fields->f_CPRk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_CRI :
+      errmsg = insert_normal (cd, fields->f_CRi, 0, 0, 14, 3, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_CRJ :
+      errmsg = insert_normal (cd, fields->f_CRj, 0, 0, 2, 3, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_CRJ_FLOAT :
+      errmsg = insert_normal (cd, fields->f_CRj_float, 0, 0, 26, 2, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_CRJ_INT :
+      {
+        long value = fields->f_CRj_int;
+        value = ((value) - (4));
+        errmsg = insert_normal (cd, value, 0, 0, 26, 2, 32, total_length, buffer);
+      }
+      break;
+    case FRV_OPERAND_CRK :
+      errmsg = insert_normal (cd, fields->f_CRk, 0, 0, 27, 3, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FCCI_1 :
+      errmsg = insert_normal (cd, fields->f_FCCi_1, 0, 0, 11, 2, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FCCI_2 :
+      errmsg = insert_normal (cd, fields->f_FCCi_2, 0, 0, 26, 2, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FCCI_3 :
+      errmsg = insert_normal (cd, fields->f_FCCi_3, 0, 0, 1, 2, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FCCK :
+      errmsg = insert_normal (cd, fields->f_FCCk, 0, 0, 26, 2, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FRDOUBLEI :
+      errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FRDOUBLEJ :
+      errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FRDOUBLEK :
+      errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FRI :
+      errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FRINTI :
+      errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FRINTJ :
+      errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FRINTK :
+      errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FRJ :
+      errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FRK :
+      errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FRKHI :
+      errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_FRKLO :
+      errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_GRDOUBLEK :
+      errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_GRI :
+      errmsg = insert_normal (cd, fields->f_GRi, 0, 0, 17, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_GRJ :
+      errmsg = insert_normal (cd, fields->f_GRj, 0, 0, 5, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_GRK :
+      errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_GRKHI :
+      errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_GRKLO :
+      errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_ICCI_1 :
+      errmsg = insert_normal (cd, fields->f_ICCi_1, 0, 0, 11, 2, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_ICCI_2 :
+      errmsg = insert_normal (cd, fields->f_ICCi_2, 0, 0, 26, 2, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_ICCI_3 :
+      errmsg = insert_normal (cd, fields->f_ICCi_3, 0, 0, 1, 2, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_LI :
+      errmsg = insert_normal (cd, fields->f_LI, 0, 0, 25, 1, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_AE :
+      errmsg = insert_normal (cd, fields->f_ae, 0, 0, 25, 1, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_CCOND :
+      errmsg = insert_normal (cd, fields->f_ccond, 0, 0, 12, 1, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_COND :
+      errmsg = insert_normal (cd, fields->f_cond, 0, 0, 8, 1, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_D12 :
+      errmsg = insert_normal (cd, fields->f_d12, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_DEBUG :
+      errmsg = insert_normal (cd, fields->f_debug, 0, 0, 25, 1, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_EIR :
+      errmsg = insert_normal (cd, fields->f_eir, 0, 0, 17, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_HINT :
+      errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_HINT_NOT_TAKEN :
+      errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_HINT_TAKEN :
+      errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_LABEL16 :
+      {
+        long value = fields->f_label16;
+        value = ((int) (((value) - (pc))) >> (2));
+        errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 16, 32, total_length, buffer);
+      }
+      break;
+    case FRV_OPERAND_LABEL24 :
+      {
+{
+  FLD (f_labelH6) = ((int) (((FLD (f_label24)) - (pc))) >> (20));
+  FLD (f_labelL18) = ((((unsigned int) (((FLD (f_label24)) - (pc))) >> (2))) & (262143));
+}
+        errmsg = insert_normal (cd, fields->f_labelH6, 0|(1<<CGEN_IFLD_SIGNED), 0, 30, 6, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_labelL18, 0, 0, 17, 18, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case FRV_OPERAND_LOCK :
+      errmsg = insert_normal (cd, fields->f_lock, 0, 0, 25, 1, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_PACK :
+      errmsg = insert_normal (cd, fields->f_pack, 0, 0, 31, 1, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_S10 :
+      errmsg = insert_normal (cd, fields->f_s10, 0|(1<<CGEN_IFLD_SIGNED), 0, 9, 10, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_S12 :
+      errmsg = insert_normal (cd, fields->f_d12, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_S16 :
+      errmsg = insert_normal (cd, fields->f_s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_S5 :
+      errmsg = insert_normal (cd, fields->f_s5, 0|(1<<CGEN_IFLD_SIGNED), 0, 4, 5, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_S6 :
+      errmsg = insert_normal (cd, fields->f_s6, 0|(1<<CGEN_IFLD_SIGNED), 0, 5, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_S6_1 :
+      errmsg = insert_normal (cd, fields->f_s6_1, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_SLO16 :
+      errmsg = insert_normal (cd, fields->f_s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_SPR :
+      {
+{
+  FLD (f_spr_h) = ((unsigned int) (FLD (f_spr)) >> (6));
+  FLD (f_spr_l) = ((FLD (f_spr)) & (63));
+}
+        errmsg = insert_normal (cd, fields->f_spr_h, 0, 0, 30, 6, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_spr_l, 0, 0, 17, 6, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case FRV_OPERAND_U12 :
+      {
+{
+  FLD (f_u12_h) = ((int) (FLD (f_u12)) >> (6));
+  FLD (f_u12_l) = ((FLD (f_u12)) & (63));
+}
+        errmsg = insert_normal (cd, fields->f_u12_h, 0|(1<<CGEN_IFLD_SIGNED), 0, 17, 6, 32, total_length, buffer);
+        if (errmsg)
+          break;
+        errmsg = insert_normal (cd, fields->f_u12_l, 0, 0, 5, 6, 32, total_length, buffer);
+        if (errmsg)
+          break;
+      }
+      break;
+    case FRV_OPERAND_U16 :
+      errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_U6 :
+      errmsg = insert_normal (cd, fields->f_u6, 0, 0, 5, 6, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_UHI16 :
+      errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
+      break;
+    case FRV_OPERAND_ULO16 :
+      errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
+	       opindex);
+      abort ();
+  }
+
+  return errmsg;
+}
+
+int frv_cgen_extract_operand
+  PARAMS ((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
+frv_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc)
+     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 FRV_OPERAND_A :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 1, 32, total_length, pc, & fields->f_A);
+      break;
+    case FRV_OPERAND_ACC40SI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACC40Si);
+      break;
+    case FRV_OPERAND_ACC40SK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACC40Sk);
+      break;
+    case FRV_OPERAND_ACC40UI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACC40Ui);
+      break;
+    case FRV_OPERAND_ACC40UK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACC40Uk);
+      break;
+    case FRV_OPERAND_ACCGI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACCGi);
+      break;
+    case FRV_OPERAND_ACCGK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACCGk);
+      break;
+    case FRV_OPERAND_CCI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 3, 32, total_length, pc, & fields->f_CCi);
+      break;
+    case FRV_OPERAND_CPRDOUBLEK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_CPRk);
+      break;
+    case FRV_OPERAND_CPRI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_CPRi);
+      break;
+    case FRV_OPERAND_CPRJ :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_CPRj);
+      break;
+    case FRV_OPERAND_CPRK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_CPRk);
+      break;
+    case FRV_OPERAND_CRI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_CRi);
+      break;
+    case FRV_OPERAND_CRJ :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 2, 3, 32, total_length, pc, & fields->f_CRj);
+      break;
+    case FRV_OPERAND_CRJ_FLOAT :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_CRj_float);
+      break;
+    case FRV_OPERAND_CRJ_INT :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & value);
+        value = ((value) + (4));
+        fields->f_CRj_int = value;
+      }
+      break;
+    case FRV_OPERAND_CRK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 27, 3, 32, total_length, pc, & fields->f_CRk);
+      break;
+    case FRV_OPERAND_FCCI_1 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_FCCi_1);
+      break;
+    case FRV_OPERAND_FCCI_2 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_FCCi_2);
+      break;
+    case FRV_OPERAND_FCCI_3 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_FCCi_3);
+      break;
+    case FRV_OPERAND_FCCK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_FCCk);
+      break;
+    case FRV_OPERAND_FRDOUBLEI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
+      break;
+    case FRV_OPERAND_FRDOUBLEJ :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
+      break;
+    case FRV_OPERAND_FRDOUBLEK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
+      break;
+    case FRV_OPERAND_FRI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
+      break;
+    case FRV_OPERAND_FRINTI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
+      break;
+    case FRV_OPERAND_FRINTJ :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
+      break;
+    case FRV_OPERAND_FRINTK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
+      break;
+    case FRV_OPERAND_FRJ :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
+      break;
+    case FRV_OPERAND_FRK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
+      break;
+    case FRV_OPERAND_FRKHI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
+      break;
+    case FRV_OPERAND_FRKLO :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
+      break;
+    case FRV_OPERAND_GRDOUBLEK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
+      break;
+    case FRV_OPERAND_GRI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_GRi);
+      break;
+    case FRV_OPERAND_GRJ :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_GRj);
+      break;
+    case FRV_OPERAND_GRK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
+      break;
+    case FRV_OPERAND_GRKHI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
+      break;
+    case FRV_OPERAND_GRKLO :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
+      break;
+    case FRV_OPERAND_ICCI_1 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_ICCi_1);
+      break;
+    case FRV_OPERAND_ICCI_2 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_ICCi_2);
+      break;
+    case FRV_OPERAND_ICCI_3 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_ICCi_3);
+      break;
+    case FRV_OPERAND_LI :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_LI);
+      break;
+    case FRV_OPERAND_AE :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_ae);
+      break;
+    case FRV_OPERAND_CCOND :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 1, 32, total_length, pc, & fields->f_ccond);
+      break;
+    case FRV_OPERAND_COND :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 1, 32, total_length, pc, & fields->f_cond);
+      break;
+    case FRV_OPERAND_D12 :
+      length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, pc, & fields->f_d12);
+      break;
+    case FRV_OPERAND_DEBUG :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_debug);
+      break;
+    case FRV_OPERAND_EIR :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_eir);
+      break;
+    case FRV_OPERAND_HINT :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
+      break;
+    case FRV_OPERAND_HINT_NOT_TAKEN :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
+      break;
+    case FRV_OPERAND_HINT_TAKEN :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
+      break;
+    case FRV_OPERAND_LABEL16 :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 16, 32, total_length, pc, & value);
+        value = ((((value) << (2))) + (pc));
+        fields->f_label16 = value;
+      }
+      break;
+    case FRV_OPERAND_LABEL24 :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 30, 6, 32, total_length, pc, & fields->f_labelH6);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 18, 32, total_length, pc, & fields->f_labelL18);
+        if (length <= 0) break;
+{
+  FLD (f_label24) = ((((((((FLD (f_labelH6)) << (18))) | (FLD (f_labelL18)))) << (2))) + (pc));
+}
+      }
+      break;
+    case FRV_OPERAND_LOCK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_lock);
+      break;
+    case FRV_OPERAND_PACK :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 1, 32, total_length, pc, & fields->f_pack);
+      break;
+    case FRV_OPERAND_S10 :
+      length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 9, 10, 32, total_length, pc, & fields->f_s10);
+      break;
+    case FRV_OPERAND_S12 :
+      length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, pc, & fields->f_d12);
+      break;
+    case FRV_OPERAND_S16 :
+      length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & fields->f_s16);
+      break;
+    case FRV_OPERAND_S5 :
+      length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 4, 5, 32, total_length, pc, & fields->f_s5);
+      break;
+    case FRV_OPERAND_S6 :
+      length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 5, 6, 32, total_length, pc, & fields->f_s6);
+      break;
+    case FRV_OPERAND_S6_1 :
+      length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 6, 32, total_length, pc, & fields->f_s6_1);
+      break;
+    case FRV_OPERAND_SLO16 :
+      length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & fields->f_s16);
+      break;
+    case FRV_OPERAND_SPR :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_spr_h);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_spr_l);
+        if (length <= 0) break;
+{
+  FLD (f_spr) = ((((FLD (f_spr_h)) << (6))) | (FLD (f_spr_l)));
+}
+      }
+      break;
+    case FRV_OPERAND_U12 :
+      {
+        length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 17, 6, 32, total_length, pc, & fields->f_u12_h);
+        if (length <= 0) break;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_u12_l);
+        if (length <= 0) break;
+{
+  FLD (f_u12) = ((((FLD (f_u12_h)) << (6))) | (FLD (f_u12_l)));
+}
+      }
+      break;
+    case FRV_OPERAND_U16 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
+      break;
+    case FRV_OPERAND_U6 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_u6);
+      break;
+    case FRV_OPERAND_UHI16 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
+      break;
+    case FRV_OPERAND_ULO16 :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
+	       opindex);
+      abort ();
+    }
+
+  return length;
+}
+
+cgen_insert_fn * const frv_cgen_insert_handlers[] = 
+{
+  insert_insn_normal,
+};
+
+cgen_extract_fn * const frv_cgen_extract_handlers[] = 
+{
+  extract_insn_normal,
+};
+
+int frv_cgen_get_int_operand
+  PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
+bfd_vma frv_cgen_get_vma_operand
+  PARAMS ((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
+frv_cgen_get_int_operand (cd, opindex, fields)
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
+     int opindex;
+     const CGEN_FIELDS * fields;
+{
+  int value;
+
+  switch (opindex)
+    {
+    case FRV_OPERAND_A :
+      value = fields->f_A;
+      break;
+    case FRV_OPERAND_ACC40SI :
+      value = fields->f_ACC40Si;
+      break;
+    case FRV_OPERAND_ACC40SK :
+      value = fields->f_ACC40Sk;
+      break;
+    case FRV_OPERAND_ACC40UI :
+      value = fields->f_ACC40Ui;
+      break;
+    case FRV_OPERAND_ACC40UK :
+      value = fields->f_ACC40Uk;
+      break;
+    case FRV_OPERAND_ACCGI :
+      value = fields->f_ACCGi;
+      break;
+    case FRV_OPERAND_ACCGK :
+      value = fields->f_ACCGk;
+      break;
+    case FRV_OPERAND_CCI :
+      value = fields->f_CCi;
+      break;
+    case FRV_OPERAND_CPRDOUBLEK :
+      value = fields->f_CPRk;
+      break;
+    case FRV_OPERAND_CPRI :
+      value = fields->f_CPRi;
+      break;
+    case FRV_OPERAND_CPRJ :
+      value = fields->f_CPRj;
+      break;
+    case FRV_OPERAND_CPRK :
+      value = fields->f_CPRk;
+      break;
+    case FRV_OPERAND_CRI :
+      value = fields->f_CRi;
+      break;
+    case FRV_OPERAND_CRJ :
+      value = fields->f_CRj;
+      break;
+    case FRV_OPERAND_CRJ_FLOAT :
+      value = fields->f_CRj_float;
+      break;
+    case FRV_OPERAND_CRJ_INT :
+      value = fields->f_CRj_int;
+      break;
+    case FRV_OPERAND_CRK :
+      value = fields->f_CRk;
+      break;
+    case FRV_OPERAND_FCCI_1 :
+      value = fields->f_FCCi_1;
+      break;
+    case FRV_OPERAND_FCCI_2 :
+      value = fields->f_FCCi_2;
+      break;
+    case FRV_OPERAND_FCCI_3 :
+      value = fields->f_FCCi_3;
+      break;
+    case FRV_OPERAND_FCCK :
+      value = fields->f_FCCk;
+      break;
+    case FRV_OPERAND_FRDOUBLEI :
+      value = fields->f_FRi;
+      break;
+    case FRV_OPERAND_FRDOUBLEJ :
+      value = fields->f_FRj;
+      break;
+    case FRV_OPERAND_FRDOUBLEK :
+      value = fields->f_FRk;
+      break;
+    case FRV_OPERAND_FRI :
+      value = fields->f_FRi;
+      break;
+    case FRV_OPERAND_FRINTI :
+      value = fields->f_FRi;
+      break;
+    case FRV_OPERAND_FRINTJ :
+      value = fields->f_FRj;
+      break;
+    case FRV_OPERAND_FRINTK :
+      value = fields->f_FRk;
+      break;
+    case FRV_OPERAND_FRJ :
+      value = fields->f_FRj;
+      break;
+    case FRV_OPERAND_FRK :
+      value = fields->f_FRk;
+      break;
+    case FRV_OPERAND_FRKHI :
+      value = fields->f_FRk;
+      break;
+    case FRV_OPERAND_FRKLO :
+      value = fields->f_FRk;
+      break;
+    case FRV_OPERAND_GRDOUBLEK :
+      value = fields->f_GRk;
+      break;
+    case FRV_OPERAND_GRI :
+      value = fields->f_GRi;
+      break;
+    case FRV_OPERAND_GRJ :
+      value = fields->f_GRj;
+      break;
+    case FRV_OPERAND_GRK :
+      value = fields->f_GRk;
+      break;
+    case FRV_OPERAND_GRKHI :
+      value = fields->f_GRk;
+      break;
+    case FRV_OPERAND_GRKLO :
+      value = fields->f_GRk;
+      break;
+    case FRV_OPERAND_ICCI_1 :
+      value = fields->f_ICCi_1;
+      break;
+    case FRV_OPERAND_ICCI_2 :
+      value = fields->f_ICCi_2;
+      break;
+    case FRV_OPERAND_ICCI_3 :
+      value = fields->f_ICCi_3;
+      break;
+    case FRV_OPERAND_LI :
+      value = fields->f_LI;
+      break;
+    case FRV_OPERAND_AE :
+      value = fields->f_ae;
+      break;
+    case FRV_OPERAND_CCOND :
+      value = fields->f_ccond;
+      break;
+    case FRV_OPERAND_COND :
+      value = fields->f_cond;
+      break;
+    case FRV_OPERAND_D12 :
+      value = fields->f_d12;
+      break;
+    case FRV_OPERAND_DEBUG :
+      value = fields->f_debug;
+      break;
+    case FRV_OPERAND_EIR :
+      value = fields->f_eir;
+      break;
+    case FRV_OPERAND_HINT :
+      value = fields->f_hint;
+      break;
+    case FRV_OPERAND_HINT_NOT_TAKEN :
+      value = fields->f_hint;
+      break;
+    case FRV_OPERAND_HINT_TAKEN :
+      value = fields->f_hint;
+      break;
+    case FRV_OPERAND_LABEL16 :
+      value = fields->f_label16;
+      break;
+    case FRV_OPERAND_LABEL24 :
+      value = fields->f_label24;
+      break;
+    case FRV_OPERAND_LOCK :
+      value = fields->f_lock;
+      break;
+    case FRV_OPERAND_PACK :
+      value = fields->f_pack;
+      break;
+    case FRV_OPERAND_S10 :
+      value = fields->f_s10;
+      break;
+    case FRV_OPERAND_S12 :
+      value = fields->f_d12;
+      break;
+    case FRV_OPERAND_S16 :
+      value = fields->f_s16;
+      break;
+    case FRV_OPERAND_S5 :
+      value = fields->f_s5;
+      break;
+    case FRV_OPERAND_S6 :
+      value = fields->f_s6;
+      break;
+    case FRV_OPERAND_S6_1 :
+      value = fields->f_s6_1;
+      break;
+    case FRV_OPERAND_SLO16 :
+      value = fields->f_s16;
+      break;
+    case FRV_OPERAND_SPR :
+      value = fields->f_spr;
+      break;
+    case FRV_OPERAND_U12 :
+      value = fields->f_u12;
+      break;
+    case FRV_OPERAND_U16 :
+      value = fields->f_u16;
+      break;
+    case FRV_OPERAND_U6 :
+      value = fields->f_u6;
+      break;
+    case FRV_OPERAND_UHI16 :
+      value = fields->f_u16;
+      break;
+    case FRV_OPERAND_ULO16 :
+      value = fields->f_u16;
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
+		       opindex);
+      abort ();
+  }
+
+  return value;
+}
+
+bfd_vma
+frv_cgen_get_vma_operand (cd, opindex, fields)
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
+     int opindex;
+     const CGEN_FIELDS * fields;
+{
+  bfd_vma value;
+
+  switch (opindex)
+    {
+    case FRV_OPERAND_A :
+      value = fields->f_A;
+      break;
+    case FRV_OPERAND_ACC40SI :
+      value = fields->f_ACC40Si;
+      break;
+    case FRV_OPERAND_ACC40SK :
+      value = fields->f_ACC40Sk;
+      break;
+    case FRV_OPERAND_ACC40UI :
+      value = fields->f_ACC40Ui;
+      break;
+    case FRV_OPERAND_ACC40UK :
+      value = fields->f_ACC40Uk;
+      break;
+    case FRV_OPERAND_ACCGI :
+      value = fields->f_ACCGi;
+      break;
+    case FRV_OPERAND_ACCGK :
+      value = fields->f_ACCGk;
+      break;
+    case FRV_OPERAND_CCI :
+      value = fields->f_CCi;
+      break;
+    case FRV_OPERAND_CPRDOUBLEK :
+      value = fields->f_CPRk;
+      break;
+    case FRV_OPERAND_CPRI :
+      value = fields->f_CPRi;
+      break;
+    case FRV_OPERAND_CPRJ :
+      value = fields->f_CPRj;
+      break;
+    case FRV_OPERAND_CPRK :
+      value = fields->f_CPRk;
+      break;
+    case FRV_OPERAND_CRI :
+      value = fields->f_CRi;
+      break;
+    case FRV_OPERAND_CRJ :
+      value = fields->f_CRj;
+      break;
+    case FRV_OPERAND_CRJ_FLOAT :
+      value = fields->f_CRj_float;
+      break;
+    case FRV_OPERAND_CRJ_INT :
+      value = fields->f_CRj_int;
+      break;
+    case FRV_OPERAND_CRK :
+      value = fields->f_CRk;
+      break;
+    case FRV_OPERAND_FCCI_1 :
+      value = fields->f_FCCi_1;
+      break;
+    case FRV_OPERAND_FCCI_2 :
+      value = fields->f_FCCi_2;
+      break;
+    case FRV_OPERAND_FCCI_3 :
+      value = fields->f_FCCi_3;
+      break;
+    case FRV_OPERAND_FCCK :
+      value = fields->f_FCCk;
+      break;
+    case FRV_OPERAND_FRDOUBLEI :
+      value = fields->f_FRi;
+      break;
+    case FRV_OPERAND_FRDOUBLEJ :
+      value = fields->f_FRj;
+      break;
+    case FRV_OPERAND_FRDOUBLEK :
+      value = fields->f_FRk;
+      break;
+    case FRV_OPERAND_FRI :
+      value = fields->f_FRi;
+      break;
+    case FRV_OPERAND_FRINTI :
+      value = fields->f_FRi;
+      break;
+    case FRV_OPERAND_FRINTJ :
+      value = fields->f_FRj;
+      break;
+    case FRV_OPERAND_FRINTK :
+      value = fields->f_FRk;
+      break;
+    case FRV_OPERAND_FRJ :
+      value = fields->f_FRj;
+      break;
+    case FRV_OPERAND_FRK :
+      value = fields->f_FRk;
+      break;
+    case FRV_OPERAND_FRKHI :
+      value = fields->f_FRk;
+      break;
+    case FRV_OPERAND_FRKLO :
+      value = fields->f_FRk;
+      break;
+    case FRV_OPERAND_GRDOUBLEK :
+      value = fields->f_GRk;
+      break;
+    case FRV_OPERAND_GRI :
+      value = fields->f_GRi;
+      break;
+    case FRV_OPERAND_GRJ :
+      value = fields->f_GRj;
+      break;
+    case FRV_OPERAND_GRK :
+      value = fields->f_GRk;
+      break;
+    case FRV_OPERAND_GRKHI :
+      value = fields->f_GRk;
+      break;
+    case FRV_OPERAND_GRKLO :
+      value = fields->f_GRk;
+      break;
+    case FRV_OPERAND_ICCI_1 :
+      value = fields->f_ICCi_1;
+      break;
+    case FRV_OPERAND_ICCI_2 :
+      value = fields->f_ICCi_2;
+      break;
+    case FRV_OPERAND_ICCI_3 :
+      value = fields->f_ICCi_3;
+      break;
+    case FRV_OPERAND_LI :
+      value = fields->f_LI;
+      break;
+    case FRV_OPERAND_AE :
+      value = fields->f_ae;
+      break;
+    case FRV_OPERAND_CCOND :
+      value = fields->f_ccond;
+      break;
+    case FRV_OPERAND_COND :
+      value = fields->f_cond;
+      break;
+    case FRV_OPERAND_D12 :
+      value = fields->f_d12;
+      break;
+    case FRV_OPERAND_DEBUG :
+      value = fields->f_debug;
+      break;
+    case FRV_OPERAND_EIR :
+      value = fields->f_eir;
+      break;
+    case FRV_OPERAND_HINT :
+      value = fields->f_hint;
+      break;
+    case FRV_OPERAND_HINT_NOT_TAKEN :
+      value = fields->f_hint;
+      break;
+    case FRV_OPERAND_HINT_TAKEN :
+      value = fields->f_hint;
+      break;
+    case FRV_OPERAND_LABEL16 :
+      value = fields->f_label16;
+      break;
+    case FRV_OPERAND_LABEL24 :
+      value = fields->f_label24;
+      break;
+    case FRV_OPERAND_LOCK :
+      value = fields->f_lock;
+      break;
+    case FRV_OPERAND_PACK :
+      value = fields->f_pack;
+      break;
+    case FRV_OPERAND_S10 :
+      value = fields->f_s10;
+      break;
+    case FRV_OPERAND_S12 :
+      value = fields->f_d12;
+      break;
+    case FRV_OPERAND_S16 :
+      value = fields->f_s16;
+      break;
+    case FRV_OPERAND_S5 :
+      value = fields->f_s5;
+      break;
+    case FRV_OPERAND_S6 :
+      value = fields->f_s6;
+      break;
+    case FRV_OPERAND_S6_1 :
+      value = fields->f_s6_1;
+      break;
+    case FRV_OPERAND_SLO16 :
+      value = fields->f_s16;
+      break;
+    case FRV_OPERAND_SPR :
+      value = fields->f_spr;
+      break;
+    case FRV_OPERAND_U12 :
+      value = fields->f_u12;
+      break;
+    case FRV_OPERAND_U16 :
+      value = fields->f_u16;
+      break;
+    case FRV_OPERAND_U6 :
+      value = fields->f_u6;
+      break;
+    case FRV_OPERAND_UHI16 :
+      value = fields->f_u16;
+      break;
+    case FRV_OPERAND_ULO16 :
+      value = fields->f_u16;
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
+		       opindex);
+      abort ();
+  }
+
+  return value;
+}
+
+void frv_cgen_set_int_operand
+  PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, int));
+void frv_cgen_set_vma_operand
+  PARAMS ((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
+frv_cgen_set_int_operand (cd, opindex, fields, value)
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
+     int opindex;
+     CGEN_FIELDS * fields;
+     int value;
+{
+  switch (opindex)
+    {
+    case FRV_OPERAND_A :
+      fields->f_A = value;
+      break;
+    case FRV_OPERAND_ACC40SI :
+      fields->f_ACC40Si = value;
+      break;
+    case FRV_OPERAND_ACC40SK :
+      fields->f_ACC40Sk = value;
+      break;
+    case FRV_OPERAND_ACC40UI :
+      fields->f_ACC40Ui = value;
+      break;
+    case FRV_OPERAND_ACC40UK :
+      fields->f_ACC40Uk = value;
+      break;
+    case FRV_OPERAND_ACCGI :
+      fields->f_ACCGi = value;
+      break;
+    case FRV_OPERAND_ACCGK :
+      fields->f_ACCGk = value;
+      break;
+    case FRV_OPERAND_CCI :
+      fields->f_CCi = value;
+      break;
+    case FRV_OPERAND_CPRDOUBLEK :
+      fields->f_CPRk = value;
+      break;
+    case FRV_OPERAND_CPRI :
+      fields->f_CPRi = value;
+      break;
+    case FRV_OPERAND_CPRJ :
+      fields->f_CPRj = value;
+      break;
+    case FRV_OPERAND_CPRK :
+      fields->f_CPRk = value;
+      break;
+    case FRV_OPERAND_CRI :
+      fields->f_CRi = value;
+      break;
+    case FRV_OPERAND_CRJ :
+      fields->f_CRj = value;
+      break;
+    case FRV_OPERAND_CRJ_FLOAT :
+      fields->f_CRj_float = value;
+      break;
+    case FRV_OPERAND_CRJ_INT :
+      fields->f_CRj_int = value;
+      break;
+    case FRV_OPERAND_CRK :
+      fields->f_CRk = value;
+      break;
+    case FRV_OPERAND_FCCI_1 :
+      fields->f_FCCi_1 = value;
+      break;
+    case FRV_OPERAND_FCCI_2 :
+      fields->f_FCCi_2 = value;
+      break;
+    case FRV_OPERAND_FCCI_3 :
+      fields->f_FCCi_3 = value;
+      break;
+    case FRV_OPERAND_FCCK :
+      fields->f_FCCk = value;
+      break;
+    case FRV_OPERAND_FRDOUBLEI :
+      fields->f_FRi = value;
+      break;
+    case FRV_OPERAND_FRDOUBLEJ :
+      fields->f_FRj = value;
+      break;
+    case FRV_OPERAND_FRDOUBLEK :
+      fields->f_FRk = value;
+      break;
+    case FRV_OPERAND_FRI :
+      fields->f_FRi = value;
+      break;
+    case FRV_OPERAND_FRINTI :
+      fields->f_FRi = value;
+      break;
+    case FRV_OPERAND_FRINTJ :
+      fields->f_FRj = value;
+      break;
+    case FRV_OPERAND_FRINTK :
+      fields->f_FRk = value;
+      break;
+    case FRV_OPERAND_FRJ :
+      fields->f_FRj = value;
+      break;
+    case FRV_OPERAND_FRK :
+      fields->f_FRk = value;
+      break;
+    case FRV_OPERAND_FRKHI :
+      fields->f_FRk = value;
+      break;
+    case FRV_OPERAND_FRKLO :
+      fields->f_FRk = value;
+      break;
+    case FRV_OPERAND_GRDOUBLEK :
+      fields->f_GRk = value;
+      break;
+    case FRV_OPERAND_GRI :
+      fields->f_GRi = value;
+      break;
+    case FRV_OPERAND_GRJ :
+      fields->f_GRj = value;
+      break;
+    case FRV_OPERAND_GRK :
+      fields->f_GRk = value;
+      break;
+    case FRV_OPERAND_GRKHI :
+      fields->f_GRk = value;
+      break;
+    case FRV_OPERAND_GRKLO :
+      fields->f_GRk = value;
+      break;
+    case FRV_OPERAND_ICCI_1 :
+      fields->f_ICCi_1 = value;
+      break;
+    case FRV_OPERAND_ICCI_2 :
+      fields->f_ICCi_2 = value;
+      break;
+    case FRV_OPERAND_ICCI_3 :
+      fields->f_ICCi_3 = value;
+      break;
+    case FRV_OPERAND_LI :
+      fields->f_LI = value;
+      break;
+    case FRV_OPERAND_AE :
+      fields->f_ae = value;
+      break;
+    case FRV_OPERAND_CCOND :
+      fields->f_ccond = value;
+      break;
+    case FRV_OPERAND_COND :
+      fields->f_cond = value;
+      break;
+    case FRV_OPERAND_D12 :
+      fields->f_d12 = value;
+      break;
+    case FRV_OPERAND_DEBUG :
+      fields->f_debug = value;
+      break;
+    case FRV_OPERAND_EIR :
+      fields->f_eir = value;
+      break;
+    case FRV_OPERAND_HINT :
+      fields->f_hint = value;
+      break;
+    case FRV_OPERAND_HINT_NOT_TAKEN :
+      fields->f_hint = value;
+      break;
+    case FRV_OPERAND_HINT_TAKEN :
+      fields->f_hint = value;
+      break;
+    case FRV_OPERAND_LABEL16 :
+      fields->f_label16 = value;
+      break;
+    case FRV_OPERAND_LABEL24 :
+      fields->f_label24 = value;
+      break;
+    case FRV_OPERAND_LOCK :
+      fields->f_lock = value;
+      break;
+    case FRV_OPERAND_PACK :
+      fields->f_pack = value;
+      break;
+    case FRV_OPERAND_S10 :
+      fields->f_s10 = value;
+      break;
+    case FRV_OPERAND_S12 :
+      fields->f_d12 = value;
+      break;
+    case FRV_OPERAND_S16 :
+      fields->f_s16 = value;
+      break;
+    case FRV_OPERAND_S5 :
+      fields->f_s5 = value;
+      break;
+    case FRV_OPERAND_S6 :
+      fields->f_s6 = value;
+      break;
+    case FRV_OPERAND_S6_1 :
+      fields->f_s6_1 = value;
+      break;
+    case FRV_OPERAND_SLO16 :
+      fields->f_s16 = value;
+      break;
+    case FRV_OPERAND_SPR :
+      fields->f_spr = value;
+      break;
+    case FRV_OPERAND_U12 :
+      fields->f_u12 = value;
+      break;
+    case FRV_OPERAND_U16 :
+      fields->f_u16 = value;
+      break;
+    case FRV_OPERAND_U6 :
+      fields->f_u6 = value;
+      break;
+    case FRV_OPERAND_UHI16 :
+      fields->f_u16 = value;
+      break;
+    case FRV_OPERAND_ULO16 :
+      fields->f_u16 = value;
+      break;
+
+    default :
+      /* xgettext:c-format */
+      fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
+		       opindex);
+      abort ();
+  }
+}
+
+void
+frv_cgen_set_vma_operand (cd, opindex, fields, value)
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
+     int opindex;
+     CGEN_FIELDS * fields;
+     bfd_vma value;
+{
+  switch (opindex)
+    {
+    case FRV_OPERAND_A :
+      fields->f_A = value;
+      break;
+    case FRV_OPERAND_ACC40SI :
+      fields->f_ACC40Si = value;
+      break;
+    case FRV_OPERAND_ACC40SK :
+      fields->f_ACC40Sk = value;
+      break;
+    case FRV_OPERAND_ACC40UI :
+      fields->f_ACC40Ui = value;
+      break;
+    case FRV_OPERAND_ACC40UK :
+      fields->f_ACC40Uk = value;
+      break;
+    case FRV_OPERAND_ACCGI :
+      fields->f_ACCGi = value;
+      break;
+    case FRV_OPERAND_ACCGK :
+      fields->f_ACCGk = value;
+      break;
+    case FRV_OPERAND_CCI :
+      fields->f_CCi = value;
+      break;
+    case FRV_OPERAND_CPRDOUBLEK :
+      fields->f_CPRk = value;
+      break;
+    case FRV_OPERAND_CPRI :
+      fields->f_CPRi = value;
+      break;
+    case FRV_OPERAND_CPRJ :
+      fields->f_CPRj = value;
+      break;
+    case FRV_OPERAND_CPRK :
+      fields->f_CPRk = value;
+      break;
+    case FRV_OPERAND_CRI :
+      fields->f_CRi = value;
+      break;
+    case FRV_OPERAND_CRJ :
+      fields->f_CRj = value;
+      break;
+    case FRV_OPERAND_CRJ_FLOAT :
+      fields->f_CRj_float = value;
+      break;
+    case FRV_OPERAND_CRJ_INT :
+      fields->f_CRj_int = value;
+      break;
+    case FRV_OPERAND_CRK :
+      fields->f_CRk = value;
+      break;
+    case FRV_OPERAND_FCCI_1 :
+      fields->f_FCCi_1 = value;
+      break;
+    case FRV_OPERAND_FCCI_2 :
+      fields->f_FCCi_2 = value;
+      break;
+    case FRV_OPERAND_FCCI_3 :
+      fields->f_FCCi_3 = value;
+      break;
+    case FRV_OPERAND_FCCK :
+      fields->f_FCCk = value;
+      break;
+    case FRV_OPERAND_FRDOUBLEI :
+      fields->f_FRi = value;
+      break;
+    case FRV_OPERAND_FRDOUBLEJ :
+      fields->f_FRj = value;
+      break;
+    case FRV_OPERAND_FRDOUBLEK :
+      fields->f_FRk = value;
+      break;
+    case FRV_OPERAND_FRI :
+      fields->f_FRi = value;
+      break;
+    case FRV_OPERAND_FRINTI :
+      fields->f_FRi = value;
+      break;
+    case FRV_OPERAND_FRINTJ :
+      fields->f_FRj = value;
+      break;
+    case FRV_OPERAND_FRINTK :
+      fields->f_FRk = value;
+      break;
+    case FRV_OPERAND_FRJ :
+      fields->f_FRj = value;
+      break;
+    case FRV_OPERAND_FRK :
+      fields->f_FRk = value;
+      break;
+    case FRV_OPERAND_FRKHI :
+      fields->f_FRk = value;
+      break;
+    case FRV_OPERAND_FRKLO :
+      fields->f_FRk = value;
+      break;
+    case FRV_OPERAND_GRDOUBLEK :
+      fields->f_GRk = value;
+      break;
+    case FRV_OPERAND_GRI :
+      fields->f_GRi = value;
+      break;
+    case FRV_OPERAND_GRJ :
+      fields->f_GRj = value;
+      break;
+    case FRV_OPERAND_GRK :
+      fields->f_GRk = value;
+      break;
+    case FRV_OPERAND_GRKHI :
+      fields->f_GRk = value;
+      break;
+    case FRV_OPERAND_GRKLO :
+      fields->f_GRk = value;
+      break;
+    case FRV_OPERAND_ICCI_1 :
+      fields->f_ICCi_1 = value;
+      break;
+    case FRV_OPERAND_ICCI_2 :
+      fields->f_ICCi_2 = value;
+      break;
+    case FRV_OPERAND_ICCI_3 :
+      fields->f_ICCi_3 = value;
+      break;
+    case FRV_OPERAND_LI :
+      fields->f_LI = value;
+      break;
+    case FRV_OPERAND_AE :
+      fields->f_ae = value;
+      break;
+    case FRV_OPERAND_CCOND :
+      fields->f_ccond = value;
+      break;
+    case FRV_OPERAND_COND :
+      fields->f_cond = value;
+      break;
+    case FRV_OPERAND_D12 :
+      fields->f_d12 = value;
+      break;
+    case FRV_OPERAND_DEBUG :
+      fields->f_debug = value;
+      break;
+    case FRV_OPERAND_EIR :
+      fields->f_eir = value;
+      break;
+    case FRV_OPERAND_HINT :
+      fields->f_hint = value;
+      break;
+    case FRV_OPERAND_HINT_NOT_TAKEN :
+      fields->f_hint = value;
+      break;
+    case FRV_OPERAND_HINT_TAKEN :
+      fields->f_hint = value;
+      break;
+    case FRV_OPERAND_LABEL16 :
+      fields->f_label16 = value;
+      break;
+    case FRV_OPERAND_LABEL24 :
+      fields->f_label24 = value;
+      break;
+    case FRV_OPERAND_LOCK :
+      fields->f_lock = value;
+      break;
+    case FRV_OPERAND_PACK :
+      fields->f_pack = value;
+      break;
+    case FRV_OPERAND_S10 :
+      fields->f_s10 = value;
+      break;
+    case FRV_OPERAND_S12 :
+      fields->f_d12 = value;
+      break;
+    case FRV_OPERAND_S16 :
+      fields->f_s16 = value;
+      break;
+    case FRV_OPERAND_S5 :
+      fields->f_s5 = value;
+      break;
+    case FRV_OPERAND_S6 :
+      fields->f_s6 = value;
+      break;
+    case FRV_OPERAND_S6_1 :
+      fields->f_s6_1 = value;
+      break;
+    case FRV_OPERAND_SLO16 :
+      fields->f_s16 = value;
+      break;
+    case FRV_OPERAND_SPR :
+      fields->f_spr = value;
+      break;
+    case FRV_OPERAND_U12 :
+      fields->f_u12 = value;
+      break;
+    case FRV_OPERAND_U16 :
+      fields->f_u16 = value;
+      break;
+    case FRV_OPERAND_U6 :
+      fields->f_u6 = value;
+      break;
+    case FRV_OPERAND_UHI16 :
+      fields->f_u16 = value;
+      break;
+    case FRV_OPERAND_ULO16 :
+      fields->f_u16 = value;
+      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
+frv_cgen_init_ibld_table (cd)
+     CGEN_CPU_DESC cd;
+{
+  cd->insert_handlers = & frv_cgen_insert_handlers[0];
+  cd->extract_handlers = & frv_cgen_extract_handlers[0];
+
+  cd->insert_operand = frv_cgen_insert_operand;
+  cd->extract_operand = frv_cgen_extract_operand;
+
+  cd->get_int_operand = frv_cgen_get_int_operand;
+  cd->set_int_operand = frv_cgen_set_int_operand;
+  cd->get_vma_operand = frv_cgen_get_vma_operand;
+  cd->set_vma_operand = frv_cgen_set_vma_operand;
+}
diff --git a/opcodes/frv-opc.c b/opcodes/frv-opc.c
new file mode 100644
index 00000000000..96325570a83
--- /dev/null
+++ b/opcodes/frv-opc.c
@@ -0,0 +1,5842 @@
+/* Instruction opcode table for frv.
+
+THIS FILE IS MACHINE GENERATED WITH CGEN.
+
+Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+
+This file is part of the GNU Binutils and/or GDB, the GNU debugger.
+
+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, 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 "sysdep.h"
+#include "ansidecl.h"
+#include "bfd.h"
+#include "symcat.h"
+#include "frv-desc.h"
+#include "frv-opc.h"
+#include "libiberty.h"
+
+/* -- opc.c */
+#include "elf/frv.h"
+
+static int match_unit
+  PARAMS ((FRV_VLIW *, CGEN_ATTR_VALUE_TYPE, CGEN_ATTR_VALUE_TYPE));
+static int match_vliw
+  PARAMS ((VLIW_COMBO *, VLIW_COMBO *, int));
+static VLIW_COMBO * add_next_to_vliw
+  PARAMS ((FRV_VLIW *, CGEN_ATTR_VALUE_TYPE));
+static int find_major_in_vliw
+  PARAMS ((FRV_VLIW *, CGEN_ATTR_VALUE_TYPE));
+static int fr400_check_insn_major_constraints
+  PARAMS ((FRV_VLIW *, CGEN_ATTR_VALUE_TYPE));
+static int fr500_check_insn_major_constraints
+  PARAMS ((FRV_VLIW *, CGEN_ATTR_VALUE_TYPE));
+static int check_insn_major_constraints
+  PARAMS ((FRV_VLIW *, CGEN_ATTR_VALUE_TYPE));
+
+int
+frv_is_branch_major (CGEN_ATTR_VALUE_TYPE major, unsigned long mach)
+{
+  switch (mach)
+    {
+    case bfd_mach_fr400:
+      if (major >= FR400_MAJOR_B_1 && major <= FR400_MAJOR_B_6)
+	return 1; /* is a branch */
+      break;
+    default:
+      if (major >= FR500_MAJOR_B_1 && major <= FR500_MAJOR_B_6)
+	return 1; /* is a branch */
+      break;
+    }
+
+  return 0; /* not a branch */
+}
+
+int
+frv_is_float_major (CGEN_ATTR_VALUE_TYPE major, unsigned long mach)
+{
+  switch (mach)
+    {
+    case bfd_mach_fr400:
+      return 0; /* No float insns */
+    default:
+      if (major >= FR500_MAJOR_F_1 && major <= FR500_MAJOR_F_8)
+	return 1; /* is a float insn */
+      break;
+    }
+
+  return 0; /* not a branch */
+}
+
+int
+frv_is_media_major (CGEN_ATTR_VALUE_TYPE major, unsigned long mach)
+{
+  switch (mach)
+    {
+    case bfd_mach_fr400:
+      if (major >= FR400_MAJOR_M_1 && major <= FR400_MAJOR_M_2)
+	return 1; /* is a media insn */
+      break;
+    default:
+      if (major >= FR500_MAJOR_M_1 && major <= FR500_MAJOR_M_8)
+	return 1; /* is a media insn */
+      break;
+    }
+
+  return 0; /* not a branch */
+}
+
+int
+frv_is_branch_insn (const CGEN_INSN *insn)
+{
+  if (frv_is_branch_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR400_MAJOR),
+			   bfd_mach_fr400))
+    return 1;
+  if (frv_is_branch_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR500_MAJOR),
+			   bfd_mach_fr500))
+    return 1;
+
+  return 0;
+}
+
+int
+frv_is_float_insn (const CGEN_INSN *insn)
+{
+  if (frv_is_float_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR400_MAJOR),
+			  bfd_mach_fr400))
+    return 1;
+  if (frv_is_float_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR500_MAJOR),
+			  bfd_mach_fr500))
+    return 1;
+
+  return 0;
+}
+
+int
+frv_is_media_insn (const CGEN_INSN *insn)
+{
+  if (frv_is_media_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR400_MAJOR),
+			  bfd_mach_fr400))
+    return 1;
+  if (frv_is_media_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR500_MAJOR),
+			  bfd_mach_fr500))
+    return 1;
+
+  return 0;
+}
+
+/* This table represents the allowable packing for vliw insns for the fr400.
+   The fr400 has only 2 vliw slots. Represent this by not allowing any insns
+   in slots 2 and 3.
+   Subsets of any given row are also allowed.  */
+static VLIW_COMBO fr400_allowed_vliw[] =
+{
+  /*  slot0       slot1       slot2       slot3    */
+  {  UNIT_I0,    UNIT_I1,    UNIT_NIL,   UNIT_NIL  },
+  {  UNIT_I0,    UNIT_FM0,   UNIT_NIL,   UNIT_NIL  },
+  {  UNIT_I0,    UNIT_B0,    UNIT_NIL,   UNIT_NIL  },
+  {  UNIT_FM0,   UNIT_FM1,   UNIT_NIL,   UNIT_NIL  },
+  {  UNIT_FM0,   UNIT_B0,    UNIT_NIL,   UNIT_NIL  },
+  {  UNIT_B0,    UNIT_NIL,   UNIT_NIL,   UNIT_NIL  },
+  {  UNIT_C,     UNIT_NIL,   UNIT_NIL,   UNIT_NIL  },
+  {  UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL  }
+};
+
+/* This table represents the allowable packing for vliw insns for the fr500.
+   Subsets of any given row are also allowed.  */
+static VLIW_COMBO fr500_allowed_vliw[] =
+{
+  /*  slot0       slot1       slot2       slot3    */
+  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_FM1  },
+  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_B0   },
+  {  UNIT_I0,    UNIT_FM0,   UNIT_FM1,   UNIT_B0   },
+  {  UNIT_I0,    UNIT_FM0,   UNIT_B0,    UNIT_B1   },
+  {  UNIT_I0,    UNIT_I1,    UNIT_B0,    UNIT_B1   },
+  {  UNIT_I0,    UNIT_B0,    UNIT_B1,    UNIT_NIL  },
+  {  UNIT_FM0,   UNIT_FM1,   UNIT_B0,    UNIT_B1   },
+  {  UNIT_FM0,   UNIT_B0,    UNIT_B1,    UNIT_NIL  },
+  {  UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL  },
+  {  UNIT_C,     UNIT_NIL,   UNIT_NIL,   UNIT_NIL  },
+  {  UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL  }
+};
+
+/* Some insns are assigned specialized implementation units which map to
+   different actual implementation units on different machines.  These
+   tables perform that mapping.  */
+static CGEN_ATTR_VALUE_TYPE fr400_unit_mapping[] =
+{
+/* unit in insn    actual unit */
+/* NIL      */     UNIT_NIL,
+/* I0       */     UNIT_I0,
+/* I1       */     UNIT_I1,
+/* I01      */     UNIT_I01, 
+/* FM0      */     UNIT_FM0,
+/* FM1      */     UNIT_FM1,
+/* FM01     */     UNIT_FM01,
+/* B0       */     UNIT_B0,  /* branches only in B0 unit.  */
+/* B1       */     UNIT_B0,
+/* B01      */     UNIT_B0,
+/* C        */     UNIT_C,
+/* MULT-DIV */     UNIT_I0,  /* multiply and divide only in I0 unit.  */
+/* LOAD     */     UNIT_I0   /* load                only in I0 unit.  */
+};
+
+static CGEN_ATTR_VALUE_TYPE fr500_unit_mapping[] =
+{
+/* unit in insn    actual unit */
+/* NIL      */     UNIT_NIL,
+/* I0       */     UNIT_I0,
+/* I1       */     UNIT_I1,
+/* I01      */     UNIT_I01, 
+/* FM0      */     UNIT_FM0,
+/* FM1      */     UNIT_FM1,
+/* FM01     */     UNIT_FM01,
+/* B0       */     UNIT_B0,
+/* B1       */     UNIT_B1,
+/* B01      */     UNIT_B01,
+/* C        */     UNIT_C,
+/* MULT-DIV */     UNIT_I01, /* multiply and divide in I0 or I1 unit.  */
+/* LOAD     */     UNIT_I01  /* load                in I0 or I1 unit.  */
+};
+
+void
+frv_vliw_reset (FRV_VLIW *vliw, unsigned long mach, unsigned long elf_flags)
+{
+  vliw->next_slot = 0;
+  vliw->constraint_violation = 0;
+  vliw->mach = mach;
+  vliw->elf_flags = elf_flags;
+
+  switch (mach)
+    {
+    case bfd_mach_fr400:
+      vliw->current_vliw = fr400_allowed_vliw;
+      vliw->unit_mapping = fr400_unit_mapping;
+      break;
+    default:
+      vliw->current_vliw = fr500_allowed_vliw;
+      vliw->unit_mapping = fr500_unit_mapping;
+      break;
+    }
+}
+
+/* Return 1 if unit1 is a match for unit2.
+   Unit1 comes from the insn's UNIT attribute. unit2 comes from one of the
+   *_allowed_vliw tables above.  */
+static int
+match_unit (FRV_VLIW *vliw,
+	    CGEN_ATTR_VALUE_TYPE unit1, CGEN_ATTR_VALUE_TYPE unit2)
+{
+  /* Map any specialized implementation units to actual ones.  */
+  unit1 = vliw->unit_mapping[unit1];
+
+  if (unit1 == unit2)
+    return 1;
+  if (unit1 < unit2)
+    return 0;
+
+  switch (unit1)
+    {
+    case UNIT_I01:
+    case UNIT_FM01:
+    case UNIT_B01:
+      /* The 01 versions of these units are within 2 enums of the 0 or 1
+	 versions.  */
+      if (unit1 - unit2 <= 2)
+	return 1;
+      break;
+    default:
+      break;
+    }
+
+  return 0;
+}
+
+/* Return 1 if the vliws match, 0 otherwise.  */
+
+static int
+match_vliw (VLIW_COMBO *vliw1, VLIW_COMBO *vliw2, int vliw_size)
+{
+  int i;
+
+  for (i = 0; i < vliw_size; ++i)
+    {
+      if ((*vliw1)[i] != (*vliw2)[i])
+	return 0;
+    }
+
+  return 1;
+}
+
+/* Find the next vliw vliw in the table that can accomodate the new insn.
+   If one is found then return it. Otherwise return NULL.  */
+
+static VLIW_COMBO *
+add_next_to_vliw (FRV_VLIW *vliw, CGEN_ATTR_VALUE_TYPE unit)
+{
+  int           next    = vliw->next_slot;
+  VLIW_COMBO    *current = vliw->current_vliw;
+  VLIW_COMBO    *potential;
+
+  if (next <= 0)
+    abort (); /* Should never happen */
+
+  /* The table is sorted by units allowed within slots, so vliws with
+     identical starting sequences are together.  */
+  potential = current;
+  do
+    {
+      if (match_unit (vliw, unit, (*potential)[next]))
+	return potential;
+      ++potential;
+    }
+  while (match_vliw (potential, current, next));
+
+  return NULL;
+}
+
+/* Look for the given major insn type in the given vliw. Return 1 if found,
+   return 0 otherwise.  */
+
+static int
+find_major_in_vliw (FRV_VLIW *vliw, CGEN_ATTR_VALUE_TYPE major)
+{
+  int i;
+
+  for (i = 0; i < vliw->next_slot; ++i)
+    if (vliw->major[i] == major)
+      return 1;
+
+  return 0;
+}
+
+/* Check for constraints between the insns in the vliw due to major insn
+   types.  */
+
+static int
+fr400_check_insn_major_constraints (
+  FRV_VLIW *vliw, CGEN_ATTR_VALUE_TYPE major
+)
+{
+  /* In the cpu file, all media insns are represented as being allowed in
+     both media units. This makes it easier since this is the case for fr500.
+     Catch the invalid combinations here.  Insns of major class FR400_MAJOR_M_2
+     cannot coexist with any other media insn in a vliw.  */
+  switch (major)
+    {
+    case FR400_MAJOR_M_2:
+      return ! find_major_in_vliw (vliw, FR400_MAJOR_M_1)
+	&&   ! find_major_in_vliw (vliw, FR400_MAJOR_M_2);
+    default:
+      break;
+    }
+  return 1;
+}
+
+static int
+fr500_check_insn_major_constraints (
+  FRV_VLIW *vliw, CGEN_ATTR_VALUE_TYPE major
+)
+{
+  /* TODO: A table might be faster for some of the more complex instances
+     here.  */
+  switch (major)
+    {
+    case FR500_MAJOR_I_1:
+    case FR500_MAJOR_I_4:
+    case FR500_MAJOR_I_5:
+    case FR500_MAJOR_I_6:
+    case FR500_MAJOR_B_1:
+    case FR500_MAJOR_B_2:
+    case FR500_MAJOR_B_3:
+    case FR500_MAJOR_B_4:
+    case FR500_MAJOR_B_5:
+    case FR500_MAJOR_B_6:
+    case FR500_MAJOR_F_4:
+    case FR500_MAJOR_F_8:
+    case FR500_MAJOR_M_8:
+      return 1; /* OK */
+    case FR500_MAJOR_I_2:
+      /* Cannot coexist with I-3 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_I_3);
+    case FR500_MAJOR_I_3:
+      /* Cannot coexist with I-2 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_I_2);
+    case FR500_MAJOR_F_1:
+    case FR500_MAJOR_F_2:
+      /* Cannot coexist with F-5, F-6, or M-7 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_F_5)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_6)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
+    case FR500_MAJOR_F_3:
+      /* Cannot coexist with F-7, or M-7 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_F_7)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
+    case FR500_MAJOR_F_5:
+      /* Cannot coexist with F-1, F-2, F-6, F-7, or M-7 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_F_1)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_2)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_6)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_7)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
+    case FR500_MAJOR_F_6:
+      /* Cannot coexist with F-1, F-2, F-5, F-6, or M-7 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_F_1)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_2)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_5)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_6)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
+    case FR500_MAJOR_F_7:
+      /* Cannot coexist with F-3, F-5, F-7, or M-7 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_F_3)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_5)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_7)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
+    case FR500_MAJOR_M_1:
+      /* Cannot coexist with M-7 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
+    case FR500_MAJOR_M_2:
+    case FR500_MAJOR_M_3:
+      /* Cannot coexist with M-5, M-6 or M-7 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_M_5)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_6)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
+    case FR500_MAJOR_M_4:
+      /* Cannot coexist with M-6 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_M_6);
+    case FR500_MAJOR_M_5:
+      /* Cannot coexist with M-2, M-3, M-5, M-6  or M-7 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_M_2)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_3)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_5)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_6)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
+    case FR500_MAJOR_M_6:
+      /* Cannot coexist with M-2, M-3, M-4, M-5, M-6  or M-7 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_M_2)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_3)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_4)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_5)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_6)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
+    case FR500_MAJOR_M_7:
+      /* Cannot coexist with M-1, M-2, M-3, M-5, M-6  or M-7 insn.  */
+      return ! find_major_in_vliw (vliw, FR500_MAJOR_M_1)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_2)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_3)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_5)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_6)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_1)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_2)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_3)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_5)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_6)
+	&&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_7);
+    default:
+      abort ();
+      break;
+    }
+  return 1;
+}
+
+static int
+check_insn_major_constraints (
+  FRV_VLIW *vliw, CGEN_ATTR_VALUE_TYPE major
+)
+{
+  int rc;
+  switch (vliw->mach)
+    {
+    case bfd_mach_fr400:
+      rc = fr400_check_insn_major_constraints (vliw, major);
+      break;
+    default:
+      rc = fr500_check_insn_major_constraints (vliw, major);
+      break;
+    }
+  return rc;
+}
+
+/* Add in insn to the VLIW vliw if possible. Return 0 if successful,
+   non-zero otherwise.  */
+int
+frv_vliw_add_insn (FRV_VLIW *vliw, const CGEN_INSN *insn)
+{
+  int index;
+  CGEN_ATTR_VALUE_TYPE major;
+  CGEN_ATTR_VALUE_TYPE unit;
+  VLIW_COMBO *new_vliw;
+
+  if (vliw->constraint_violation || CGEN_INSN_INVALID_P (insn))
+    return 1;
+
+  index = vliw->next_slot;
+  if (index >= FRV_VLIW_SIZE)
+    return 1;
+
+  unit = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_UNIT);
+  if (unit == UNIT_NIL)
+    abort (); /* no UNIT specified for this insn in frv.cpu  */
+
+  if (vliw->mach == bfd_mach_fr400)
+    major = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR400_MAJOR);
+  else
+    major = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR500_MAJOR);
+
+  if (index <= 0)
+    {
+      /* Any insn can be added to slot 0.  */
+      while (! match_unit (vliw, unit, (*vliw->current_vliw)[0]))
+	++vliw->current_vliw;
+      vliw->major[0] = major;
+      vliw->next_slot = 1;
+      return 0;
+    }
+
+  /* If there are already insns in the vliw(s) check to see that
+     this one can be added.  Do this by finding an allowable vliw
+     combination that can accept the new insn.  */
+  if (! (vliw->elf_flags & EF_FRV_NOPACK))
+    {
+      new_vliw = add_next_to_vliw (vliw, unit);
+      if (new_vliw && check_insn_major_constraints (vliw, major))
+	{
+	  vliw->current_vliw = new_vliw;
+	  vliw->major[index] = major;
+	  vliw->next_slot++;
+	  return 0;
+	}
+
+      /* The frv machine supports all packing conbinations.  If we fail,
+	 to add the insn, then it could not be handled as if it was the fr500.
+	 Just return as if it was handled ok.  */
+      if (vliw->mach == bfd_mach_frv)
+	return 0;
+    }
+
+  vliw->constraint_violation = 1;
+  return 1;
+}
+
+int
+spr_valid (regno)
+     long regno;
+{
+  if (regno < 0)     return 0;
+  if (regno <= 4095) return 1;
+  return 0;
+}
+/* -- */
+/* The hash functions are recorded here to help keep assembler code out of
+   the disassembler and vice versa.  */
+
+static int asm_hash_insn_p PARAMS ((const CGEN_INSN *));
+static unsigned int asm_hash_insn PARAMS ((const char *));
+static int dis_hash_insn_p PARAMS ((const CGEN_INSN *));
+static unsigned int dis_hash_insn PARAMS ((const char *, CGEN_INSN_INT));
+
+/* Instruction formats.  */
+
+#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
+#define F(f) & frv_cgen_ifld_table[FRV_##f]
+#else
+#define F(f) & frv_cgen_ifld_table[FRV_/**/f]
+#endif
+static const CGEN_IFMT ifmt_empty = {
+  0, 0, 0x0, { { 0 } }
+};
+
+static const CGEN_IFMT ifmt_add = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_ICCI_1_NULL) }, { F (F_OPE2) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_not = {
+  32, 32, 0x1ffffc0, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_ICCI_1_NULL) }, { F (F_OPE2) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_smul = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_ICCI_1_NULL) }, { F (F_OPE2) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cadd = {
+  32, 32, 0x1fc00c0, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cnot = {
+  32, 32, 0x1fff0c0, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_csmul = {
+  32, 32, 0x1fc00c0, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_addcc = {
+  32, 32, 0x1fc03c0, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_ICCI_1) }, { F (F_OPE2) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_smulcc = {
+  32, 32, 0x1fc03c0, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_ICCI_1) }, { F (F_OPE2) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_addi = {
+  32, 32, 0x1fc0000, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_smuli = {
+  32, 32, 0x1fc0000, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_addicc = {
+  32, 32, 0x1fc0000, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_ICCI_1) }, { F (F_S10) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_smulicc = {
+  32, 32, 0x1fc0000, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_ICCI_1) }, { F (F_S10) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cmpb = {
+  32, 32, 0x7ffc03c0, { { F (F_PACK) }, { F (F_GRK_NULL) }, { F (F_OP) }, { F (F_GRI) }, { F (F_ICCI_1) }, { F (F_OPE2) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_setlo = {
+  32, 32, 0x1ff0000, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_MISC_NULL_4) }, { F (F_U16) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_sethi = {
+  32, 32, 0x1ff0000, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_MISC_NULL_4) }, { F (F_U16) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_setlos = {
+  32, 32, 0x1ff0000, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_MISC_NULL_4) }, { F (F_S16) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ldsb = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_OPE1) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ldbf = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_OPE1) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ldc = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_CPRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_OPE1) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ldd = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_OPE1) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_lddf = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_OPE1) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_lddc = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_CPRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_OPE1) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ldsbi = {
+  32, 32, 0x1fc0000, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ldbfi = {
+  32, 32, 0x1fc0000, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_lddi = {
+  32, 32, 0x1fc0000, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_lddfi = {
+  32, 32, 0x1fc0000, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_stdf = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_OPE1) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cldbf = {
+  32, 32, 0x1fc00c0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_clddf = {
+  32, 32, 0x1fc00c0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cstdf = {
+  32, 32, 0x1fc00c0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_stdfi = {
+  32, 32, 0x1fc0000, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_movgf = {
+  32, 32, 0x1ffffc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_OPE1) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cmovgf = {
+  32, 32, 0x1fff0c0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_movgs = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_OP) }, { F (F_SPR) }, { F (F_OPE1) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_bra = {
+  32, 32, 0x7ffc0000, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2_NULL) }, { F (F_OP) }, { F (F_HINT) }, { F (F_LABEL16) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_bno = {
+  32, 32, 0x7ffcffff, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2_NULL) }, { F (F_OP) }, { F (F_HINT) }, { F (F_LABEL16_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_beq = {
+  32, 32, 0x79fc0000, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2) }, { F (F_OP) }, { F (F_HINT) }, { F (F_LABEL16) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fbra = {
+  32, 32, 0x7ffc0000, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2_NULL) }, { F (F_OP) }, { F (F_HINT) }, { F (F_LABEL16) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fbno = {
+  32, 32, 0x7ffcffff, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2_NULL) }, { F (F_OP) }, { F (F_HINT) }, { F (F_LABEL16_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fbne = {
+  32, 32, 0x79fc0000, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2) }, { F (F_OP) }, { F (F_HINT) }, { F (F_LABEL16) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_bctrlr = {
+  32, 32, 0x7ffcefff, { { F (F_PACK) }, { F (F_COND_NULL) }, { F (F_ICCI_2_NULL) }, { F (F_OP) }, { F (F_HINT) }, { F (F_OPE3) }, { F (F_CCOND) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_bralr = {
+  32, 32, 0x7ffcffff, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2_NULL) }, { F (F_OP) }, { F (F_HINT) }, { F (F_OPE3) }, { F (F_CCOND_NULL) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_bnolr = {
+  32, 32, 0x7ffcffff, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2_NULL) }, { F (F_OP) }, { F (F_HINT) }, { F (F_OPE3) }, { F (F_CCOND_NULL) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_beqlr = {
+  32, 32, 0x79fcffff, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2) }, { F (F_OP) }, { F (F_HINT) }, { F (F_OPE3) }, { F (F_CCOND_NULL) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fbralr = {
+  32, 32, 0x7ffcffff, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2_NULL) }, { F (F_OP) }, { F (F_HINT) }, { F (F_OPE3) }, { F (F_CCOND_NULL) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fbnolr = {
+  32, 32, 0x7ffcffff, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2_NULL) }, { F (F_OP) }, { F (F_HINT) }, { F (F_OPE3) }, { F (F_CCOND_NULL) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fbeqlr = {
+  32, 32, 0x79fcffff, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2) }, { F (F_OP) }, { F (F_HINT) }, { F (F_OPE3) }, { F (F_CCOND_NULL) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_bcralr = {
+  32, 32, 0x7ffcefff, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2_NULL) }, { F (F_OP) }, { F (F_HINT) }, { F (F_OPE3) }, { F (F_CCOND) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_bceqlr = {
+  32, 32, 0x79fcefff, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2) }, { F (F_OP) }, { F (F_HINT) }, { F (F_OPE3) }, { F (F_CCOND) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fcbralr = {
+  32, 32, 0x7ffcefff, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2_NULL) }, { F (F_OP) }, { F (F_HINT) }, { F (F_OPE3) }, { F (F_CCOND) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fcbeqlr = {
+  32, 32, 0x79fcefff, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2) }, { F (F_OP) }, { F (F_HINT) }, { F (F_OPE3) }, { F (F_CCOND) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_jmpl = {
+  32, 32, 0x7ffc0fc0, { { F (F_PACK) }, { F (F_MISC_NULL_1) }, { F (F_LI_OFF) }, { F (F_OP) }, { F (F_GRI) }, { F (F_MISC_NULL_2) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_calll = {
+  32, 32, 0x7ffc0fc0, { { F (F_PACK) }, { F (F_MISC_NULL_1) }, { F (F_LI_ON) }, { F (F_OP) }, { F (F_GRI) }, { F (F_MISC_NULL_2) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_jmpil = {
+  32, 32, 0x7ffc0000, { { F (F_PACK) }, { F (F_MISC_NULL_1) }, { F (F_LI_OFF) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_callil = {
+  32, 32, 0x7ffc0000, { { F (F_PACK) }, { F (F_MISC_NULL_1) }, { F (F_LI_ON) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_call = {
+  32, 32, 0x1fc0000, { { F (F_PACK) }, { F (F_OP) }, { F (F_LABEL24) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_rett = {
+  32, 32, 0x7dffffff, { { F (F_PACK) }, { F (F_MISC_NULL_1) }, { F (F_DEBUG) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_rei = {
+  32, 32, 0x7ffc0fff, { { F (F_PACK) }, { F (F_RD_NULL) }, { F (F_OP) }, { F (F_EIR) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_tra = {
+  32, 32, 0x7ffc0fc0, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2_NULL) }, { F (F_OP) }, { F (F_GRI) }, { F (F_MISC_NULL_3) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_tno = {
+  32, 32, 0x7fffffff, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2_NULL) }, { F (F_OP) }, { F (F_GRI_NULL) }, { F (F_MISC_NULL_3) }, { F (F_OPE4) }, { F (F_GRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_teq = {
+  32, 32, 0x79fc0fc0, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2) }, { F (F_OP) }, { F (F_GRI) }, { F (F_MISC_NULL_3) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ftra = {
+  32, 32, 0x7ffc0fc0, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2_NULL) }, { F (F_OP) }, { F (F_GRI) }, { F (F_MISC_NULL_3) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ftno = {
+  32, 32, 0x7fffffff, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2_NULL) }, { F (F_OP) }, { F (F_GRI_NULL) }, { F (F_MISC_NULL_3) }, { F (F_OPE4) }, { F (F_GRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ftne = {
+  32, 32, 0x79fc0fc0, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2) }, { F (F_OP) }, { F (F_GRI) }, { F (F_MISC_NULL_3) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_tira = {
+  32, 32, 0x7ffc0000, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2_NULL) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_tino = {
+  32, 32, 0x7fffffff, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2_NULL) }, { F (F_OP) }, { F (F_GRI_NULL) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_tieq = {
+  32, 32, 0x79fc0000, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ftira = {
+  32, 32, 0x7ffc0000, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_ICCI_2_NULL) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ftino = {
+  32, 32, 0x7fffffff, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2_NULL) }, { F (F_OP) }, { F (F_GRI_NULL) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ftine = {
+  32, 32, 0x79fc0000, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_FCCI_2) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_break = {
+  32, 32, 0x7fffffff, { { F (F_PACK) }, { F (F_RD_NULL) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_MISC_NULL_3) }, { F (F_OPE4) }, { F (F_GRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_andcr = {
+  32, 32, 0x71ff8ff8, { { F (F_PACK) }, { F (F_MISC_NULL_6) }, { F (F_CRK) }, { F (F_OP) }, { F (F_MISC_NULL_7) }, { F (F_CRI) }, { F (F_OPE1) }, { F (F_MISC_NULL_8) }, { F (F_CRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_notcr = {
+  32, 32, 0x71fffff8, { { F (F_PACK) }, { F (F_MISC_NULL_6) }, { F (F_CRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_OPE1) }, { F (F_MISC_NULL_8) }, { F (F_CRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ckra = {
+  32, 32, 0x79ffffff, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_CRJ_INT) }, { F (F_OP) }, { F (F_MISC_NULL_5) }, { F (F_ICCI_3_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ckeq = {
+  32, 32, 0x79fffffc, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_CRJ_INT) }, { F (F_OP) }, { F (F_MISC_NULL_5) }, { F (F_ICCI_3) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fckra = {
+  32, 32, 0x79fffffc, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_CRJ_FLOAT) }, { F (F_OP) }, { F (F_MISC_NULL_5) }, { F (F_FCCI_3) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cckra = {
+  32, 32, 0x79fff0ff, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_CRJ_INT) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_MISC_NULL_9) }, { F (F_ICCI_3_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cckeq = {
+  32, 32, 0x79fff0fc, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_CRJ_INT) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_MISC_NULL_9) }, { F (F_ICCI_3) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cfckra = {
+  32, 32, 0x79fff0ff, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_CRJ_FLOAT) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_MISC_NULL_9) }, { F (F_FCCI_3_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cfckne = {
+  32, 32, 0x79fff0fc, { { F (F_PACK) }, { F (F_FLT_CC) }, { F (F_CRJ_FLOAT) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_MISC_NULL_9) }, { F (F_FCCI_3) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cjmpl = {
+  32, 32, 0x7ffc00c0, { { F (F_PACK) }, { F (F_MISC_NULL_1) }, { F (F_LI_OFF) }, { F (F_OP) }, { F (F_GRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ccalll = {
+  32, 32, 0x7ffc00c0, { { F (F_PACK) }, { F (F_MISC_NULL_1) }, { F (F_LI_ON) }, { F (F_OP) }, { F (F_GRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ici = {
+  32, 32, 0x7ffc0fc0, { { F (F_PACK) }, { F (F_RD_NULL) }, { F (F_OP) }, { F (F_GRI) }, { F (F_OPE1) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_icei = {
+  32, 32, 0x7dfc0fc0, { { F (F_PACK) }, { F (F_MISC_NULL_1) }, { F (F_AE) }, { F (F_OP) }, { F (F_GRI) }, { F (F_OPE1) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_icpl = {
+  32, 32, 0x7dfc0fc0, { { F (F_PACK) }, { F (F_MISC_NULL_1) }, { F (F_LOCK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_OPE1) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_icul = {
+  32, 32, 0x7ffc0fff, { { F (F_PACK) }, { F (F_RD_NULL) }, { F (F_OP) }, { F (F_GRI) }, { F (F_OPE1) }, { F (F_GRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_bar = {
+  32, 32, 0x7fffffff, { { F (F_PACK) }, { F (F_RD_NULL) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_OPE1) }, { F (F_GRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cop1 = {
+  32, 32, 0x1fc0000, { { F (F_PACK) }, { F (F_CPRK) }, { F (F_OP) }, { F (F_CPRI) }, { F (F_S6_1) }, { F (F_CPRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_clrgr = {
+  32, 32, 0x1ffffff, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_OPE1) }, { F (F_GRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_clrfr = {
+  32, 32, 0x1ffffff, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_OPE1) }, { F (F_GRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fitos = {
+  32, 32, 0x1ffffc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fstoi = {
+  32, 32, 0x1ffffc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fitod = {
+  32, 32, 0x1ffffc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fdtoi = {
+  32, 32, 0x1ffffc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cfitos = {
+  32, 32, 0x1fff0c0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cfstoi = {
+  32, 32, 0x1fff0c0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fmovs = {
+  32, 32, 0x1ffffc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fmovd = {
+  32, 32, 0x1ffffc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cfmovs = {
+  32, 32, 0x1fff0c0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fadds = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_faddd = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cfadds = {
+  32, 32, 0x1fc00c0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fcmps = {
+  32, 32, 0x79fc0fc0, { { F (F_PACK) }, { F (F_COND_NULL) }, { F (F_FCCI_2) }, { F (F_OP) }, { F (F_FRI) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fcmpd = {
+  32, 32, 0x79fc0fc0, { { F (F_PACK) }, { F (F_COND_NULL) }, { F (F_FCCI_2) }, { F (F_OP) }, { F (F_FRI) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cfcmps = {
+  32, 32, 0x79fc00c0, { { F (F_PACK) }, { F (F_COND_NULL) }, { F (F_FCCI_2) }, { F (F_OP) }, { F (F_FRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mhsetlos = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_OPE1) }, { F (F_U12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mhsethis = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_OPE1) }, { F (F_U12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mhdsets = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_OPE1) }, { F (F_U12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mhsetloh = {
+  32, 32, 0x1ffffe0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI_NULL) }, { F (F_OPE1) }, { F (F_MISC_NULL_11) }, { F (F_S5) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mhsethih = {
+  32, 32, 0x1ffffe0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI_NULL) }, { F (F_OPE1) }, { F (F_MISC_NULL_11) }, { F (F_S5) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mhdseth = {
+  32, 32, 0x1ffffe0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI_NULL) }, { F (F_OPE1) }, { F (F_MISC_NULL_11) }, { F (F_S5) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mand = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cmand = {
+  32, 32, 0x1fc00c0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mnot = {
+  32, 32, 0x1ffffc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cmnot = {
+  32, 32, 0x1fff0c0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_RS_NULL) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mrotli = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_OPE1) }, { F (F_U6) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mcut = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_ACC40SI) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mcuti = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_ACC40SI) }, { F (F_OPE1) }, { F (F_S6) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mcmpsh = {
+  32, 32, 0x79fc0fc0, { { F (F_PACK) }, { F (F_COND_NULL) }, { F (F_FCCK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mabshs = {
+  32, 32, 0x1ffffc0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI_NULL) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_maddaccs = {
+  32, 32, 0x1fc0fff, { { F (F_PACK) }, { F (F_ACC40SK) }, { F (F_OP) }, { F (F_ACC40SI) }, { F (F_OPE1) }, { F (F_ACCJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mmulhs = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_ACC40SK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cmmulhs = {
+  32, 32, 0x1fc00c0, { { F (F_PACK) }, { F (F_ACC40SK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mmachu = {
+  32, 32, 0x1fc0fc0, { { F (F_PACK) }, { F (F_ACC40UK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_OPE1) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cmmachu = {
+  32, 32, 0x1fc00c0, { { F (F_PACK) }, { F (F_ACC40UK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cmexpdhw = {
+  32, 32, 0x1fc00c0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_U6) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_munpackh = {
+  32, 32, 0x1fc0fff, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_OPE1) }, { F (F_FRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cmbtoh = {
+  32, 32, 0x1fff0c0, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_FRI_NULL) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_FRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mclracc = {
+  32, 32, 0x1fdffff, { { F (F_PACK) }, { F (F_ACC40SK) }, { F (F_OP) }, { F (F_A) }, { F (F_MISC_NULL_10) }, { F (F_OPE1) }, { F (F_FRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mrdacc = {
+  32, 32, 0x1fc0fff, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_ACC40SI) }, { F (F_OPE1) }, { F (F_FRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mrdaccg = {
+  32, 32, 0x1fc0fff, { { F (F_PACK) }, { F (F_FRK) }, { F (F_OP) }, { F (F_ACCGI) }, { F (F_OPE1) }, { F (F_FRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mwtacc = {
+  32, 32, 0x1fc0fff, { { F (F_PACK) }, { F (F_ACC40SK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_OPE1) }, { F (F_FRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mwtaccg = {
+  32, 32, 0x1fc0fff, { { F (F_PACK) }, { F (F_ACCGK) }, { F (F_OP) }, { F (F_FRI) }, { F (F_OPE1) }, { F (F_FRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_fnop = {
+  32, 32, 0x7fffffff, { { F (F_PACK) }, { F (F_RD_NULL) }, { F (F_OP) }, { F (F_FRI_NULL) }, { F (F_OPE1) }, { F (F_FRJ_NULL) }, { 0 } }
+};
+
+#undef F
+
+#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
+#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
+#define OPERAND(op) FRV_OPERAND_##op
+#else
+#define OPERAND(op) FRV_OPERAND_/**/op
+#endif
+#define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
+#define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
+
+/* The instruction table.  */
+
+static const CGEN_OPCODE frv_cgen_insn_opcode_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}}, 0, {0}},
+/* add$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x0 }
+  },
+/* sub$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x100 }
+  },
+/* and$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x40000 }
+  },
+/* or$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x40080 }
+  },
+/* xor$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x40100 }
+  },
+/* not$pack $GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_not, { 0x40180 }
+  },
+/* sdiv$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x380 }
+  },
+/* nsdiv$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x40380 }
+  },
+/* udiv$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x3c0 }
+  },
+/* nudiv$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x403c0 }
+  },
+/* smul$pack $GRi,$GRj,$GRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRDOUBLEK), 0 } },
+    & ifmt_smul, { 0x200 }
+  },
+/* umul$pack $GRi,$GRj,$GRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRDOUBLEK), 0 } },
+    & ifmt_smul, { 0x280 }
+  },
+/* sll$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x40200 }
+  },
+/* srl$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x40280 }
+  },
+/* sra$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x40300 }
+  },
+/* scan$pack $GRi,$GRj,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), 0 } },
+    & ifmt_add, { 0x2c0000 }
+  },
+/* cadd$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1600000 }
+  },
+/* csub$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1600040 }
+  },
+/* cand$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1680000 }
+  },
+/* cor$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1680040 }
+  },
+/* cxor$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1680080 }
+  },
+/* cnot$pack $GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cnot, { 0x16800c0 }
+  },
+/* csmul$pack $GRi,$GRj,$GRdoublek,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRDOUBLEK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_csmul, { 0x1600080 }
+  },
+/* csdiv$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x16000c0 }
+  },
+/* cudiv$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x16400c0 }
+  },
+/* csll$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1700000 }
+  },
+/* csrl$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1700040 }
+  },
+/* csra$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1700080 }
+  },
+/* cscan$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x19400c0 }
+  },
+/* addcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addcc, { 0x40 }
+  },
+/* subcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addcc, { 0x140 }
+  },
+/* andcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addcc, { 0x40040 }
+  },
+/* orcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addcc, { 0x400c0 }
+  },
+/* xorcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addcc, { 0x40140 }
+  },
+/* sllcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addcc, { 0x40240 }
+  },
+/* srlcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addcc, { 0x402c0 }
+  },
+/* sracc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addcc, { 0x40340 }
+  },
+/* smulcc$pack $GRi,$GRj,$GRdoublek,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRDOUBLEK), ',', OP (ICCI_1), 0 } },
+    & ifmt_smulcc, { 0x240 }
+  },
+/* umulcc$pack $GRi,$GRj,$GRdoublek,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRDOUBLEK), ',', OP (ICCI_1), 0 } },
+    & ifmt_smulcc, { 0x2c0 }
+  },
+/* caddcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1640000 }
+  },
+/* csubcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1640040 }
+  },
+/* csmulcc$pack $GRi,$GRj,$GRdoublek,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRDOUBLEK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_csmul, { 0x1640080 }
+  },
+/* candcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x16c0000 }
+  },
+/* corcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x16c0040 }
+  },
+/* cxorcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x16c0080 }
+  },
+/* csllcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1740000 }
+  },
+/* csrlcc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1740040 }
+  },
+/* csracc$pack $GRi,$GRj,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1740080 }
+  },
+/* addx$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addcc, { 0x80 }
+  },
+/* subx$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addcc, { 0x180 }
+  },
+/* addxcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addcc, { 0xc0 }
+  },
+/* subxcc$pack $GRi,$GRj,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addcc, { 0x1c0 }
+  },
+/* addi$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0x400000 }
+  },
+/* subi$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0x500000 }
+  },
+/* andi$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0x800000 }
+  },
+/* ori$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0x880000 }
+  },
+/* xori$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0x900000 }
+  },
+/* sdivi$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0x780000 }
+  },
+/* nsdivi$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0xb80000 }
+  },
+/* udivi$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0x7c0000 }
+  },
+/* nudivi$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0xbc0000 }
+  },
+/* smuli$pack $GRi,$s12,$GRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRDOUBLEK), 0 } },
+    & ifmt_smuli, { 0x600000 }
+  },
+/* umuli$pack $GRi,$s12,$GRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRDOUBLEK), 0 } },
+    & ifmt_smuli, { 0x680000 }
+  },
+/* slli$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0xa00000 }
+  },
+/* srli$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0xa80000 }
+  },
+/* srai$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0xb00000 }
+  },
+/* scani$pack $GRi,$s12,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), ',', OP (GRK), 0 } },
+    & ifmt_addi, { 0x11c0000 }
+  },
+/* addicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addicc, { 0x440000 }
+  },
+/* subicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addicc, { 0x540000 }
+  },
+/* andicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addicc, { 0x840000 }
+  },
+/* oricc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addicc, { 0x8c0000 }
+  },
+/* xoricc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addicc, { 0x940000 }
+  },
+/* smulicc$pack $GRi,$s10,$GRdoublek,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRDOUBLEK), ',', OP (ICCI_1), 0 } },
+    & ifmt_smulicc, { 0x640000 }
+  },
+/* umulicc$pack $GRi,$s10,$GRdoublek,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRDOUBLEK), ',', OP (ICCI_1), 0 } },
+    & ifmt_smulicc, { 0x6c0000 }
+  },
+/* sllicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addicc, { 0xa40000 }
+  },
+/* srlicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addicc, { 0xac0000 }
+  },
+/* sraicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addicc, { 0xb40000 }
+  },
+/* addxi$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addicc, { 0x480000 }
+  },
+/* subxi$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addicc, { 0x580000 }
+  },
+/* addxicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addicc, { 0x4c0000 }
+  },
+/* subxicc$pack $GRi,$s10,$GRk,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (GRK), ',', OP (ICCI_1), 0 } },
+    & ifmt_addicc, { 0x5c0000 }
+  },
+/* cmpb$pack $GRi,$GRj,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (ICCI_1), 0 } },
+    & ifmt_cmpb, { 0x300 }
+  },
+/* cmpba$pack $GRi,$GRj,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (ICCI_1), 0 } },
+    & ifmt_cmpb, { 0x340 }
+  },
+/* setlo$pack $ulo16,$GRklo */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ULO16), ',', OP (GRKLO), 0 } },
+    & ifmt_setlo, { 0xf40000 }
+  },
+/* sethi$pack $uhi16,$GRkhi */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (UHI16), ',', OP (GRKHI), 0 } },
+    & ifmt_sethi, { 0xf80000 }
+  },
+/* setlos$pack $slo16,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (SLO16), ',', OP (GRK), 0 } },
+    & ifmt_setlos, { 0xfc0000 }
+  },
+/* ldsb$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80000 }
+  },
+/* ldub$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80040 }
+  },
+/* ldsh$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80080 }
+  },
+/* lduh$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x800c0 }
+  },
+/* ld$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80100 }
+  },
+/* ldbf$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80200 }
+  },
+/* ldhf$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80240 }
+  },
+/* ldf$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80280 }
+  },
+/* ldc$pack @($GRi,$GRj),$CPRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CPRK), 0 } },
+    & ifmt_ldc, { 0x80340 }
+  },
+/* nldsb$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80800 }
+  },
+/* nldub$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80840 }
+  },
+/* nldsh$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80880 }
+  },
+/* nlduh$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x808c0 }
+  },
+/* nld$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80900 }
+  },
+/* nldbf$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80a00 }
+  },
+/* nldhf$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80a40 }
+  },
+/* nldf$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80a80 }
+  },
+/* ldd$pack @($GRi,$GRj),$GRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRDOUBLEK), 0 } },
+    & ifmt_ldd, { 0x80140 }
+  },
+/* lddf$pack @($GRi,$GRj),$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_lddf, { 0x802c0 }
+  },
+/* lddc$pack @($GRi,$GRj),$CPRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CPRDOUBLEK), 0 } },
+    & ifmt_lddc, { 0x80380 }
+  },
+/* nldd$pack @($GRi,$GRj),$GRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRDOUBLEK), 0 } },
+    & ifmt_ldd, { 0x80940 }
+  },
+/* nlddf$pack @($GRi,$GRj),$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_lddf, { 0x80ac0 }
+  },
+/* ldq$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80180 }
+  },
+/* ldqf$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80300 }
+  },
+/* ldqc$pack @($GRi,$GRj),$CPRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CPRK), 0 } },
+    & ifmt_ldc, { 0x803c0 }
+  },
+/* nldq$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80980 }
+  },
+/* nldqf$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80b00 }
+  },
+/* ldsbu$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80400 }
+  },
+/* ldubu$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80440 }
+  },
+/* ldshu$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80480 }
+  },
+/* lduhu$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x804c0 }
+  },
+/* ldu$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80500 }
+  },
+/* nldsbu$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80c00 }
+  },
+/* nldubu$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80c40 }
+  },
+/* nldshu$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80c80 }
+  },
+/* nlduhu$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80cc0 }
+  },
+/* nldu$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80d00 }
+  },
+/* ldbfu$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80600 }
+  },
+/* ldhfu$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80640 }
+  },
+/* ldfu$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80680 }
+  },
+/* ldcu$pack @($GRi,$GRj),$CPRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CPRK), 0 } },
+    & ifmt_ldc, { 0x80740 }
+  },
+/* nldbfu$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80e00 }
+  },
+/* nldhfu$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80e40 }
+  },
+/* nldfu$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80e80 }
+  },
+/* lddu$pack @($GRi,$GRj),$GRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRDOUBLEK), 0 } },
+    & ifmt_ldd, { 0x80540 }
+  },
+/* nlddu$pack @($GRi,$GRj),$GRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRDOUBLEK), 0 } },
+    & ifmt_ldd, { 0x80d40 }
+  },
+/* lddfu$pack @($GRi,$GRj),$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_lddf, { 0x806c0 }
+  },
+/* lddcu$pack @($GRi,$GRj),$CPRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CPRDOUBLEK), 0 } },
+    & ifmt_lddc, { 0x80780 }
+  },
+/* nlddfu$pack @($GRi,$GRj),$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_lddf, { 0x80ec0 }
+  },
+/* ldqu$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80580 }
+  },
+/* nldqu$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0x80d80 }
+  },
+/* ldqfu$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80700 }
+  },
+/* ldqcu$pack @($GRi,$GRj),$CPRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CPRK), 0 } },
+    & ifmt_ldc, { 0x807c0 }
+  },
+/* nldqfu$pack @($GRi,$GRj),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbf, { 0x80f00 }
+  },
+/* ldsbi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0xc00000 }
+  },
+/* ldshi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0xc40000 }
+  },
+/* ldi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0xc80000 }
+  },
+/* ldubi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0xd40000 }
+  },
+/* lduhi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0xd80000 }
+  },
+/* ldbfi$pack @($GRi,$d12),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbfi, { 0xe00000 }
+  },
+/* ldhfi$pack @($GRi,$d12),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbfi, { 0xe40000 }
+  },
+/* ldfi$pack @($GRi,$d12),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbfi, { 0xe80000 }
+  },
+/* nldsbi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0x1000000 }
+  },
+/* nldubi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0x1040000 }
+  },
+/* nldshi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0x1080000 }
+  },
+/* nlduhi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0x10c0000 }
+  },
+/* nldi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0x1100000 }
+  },
+/* nldbfi$pack @($GRi,$d12),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbfi, { 0x1200000 }
+  },
+/* nldhfi$pack @($GRi,$d12),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbfi, { 0x1240000 }
+  },
+/* nldfi$pack @($GRi,$d12),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbfi, { 0x1280000 }
+  },
+/* lddi$pack @($GRi,$d12),$GRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRDOUBLEK), 0 } },
+    & ifmt_lddi, { 0xcc0000 }
+  },
+/* lddfi$pack @($GRi,$d12),$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_lddfi, { 0xec0000 }
+  },
+/* nlddi$pack @($GRi,$d12),$GRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRDOUBLEK), 0 } },
+    & ifmt_lddi, { 0x1140000 }
+  },
+/* nlddfi$pack @($GRi,$d12),$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_lddfi, { 0x12c0000 }
+  },
+/* ldqi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0xd00000 }
+  },
+/* ldqfi$pack @($GRi,$d12),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbfi, { 0xf00000 }
+  },
+/* nldqi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0x1180000 }
+  },
+/* nldqfi$pack @($GRi,$d12),$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (FRINTK), 0 } },
+    & ifmt_ldbfi, { 0x1300000 }
+  },
+/* stb$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0000 }
+  },
+/* sth$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0040 }
+  },
+/* st$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0080 }
+  },
+/* stbf$pack $FRintk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldbf, { 0xc0200 }
+  },
+/* sthf$pack $FRintk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldbf, { 0xc0240 }
+  },
+/* stf$pack $FRintk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldbf, { 0xc0280 }
+  },
+/* stc$pack $CPRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CPRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldc, { 0xc0940 }
+  },
+/* rstb$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0800 }
+  },
+/* rsth$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0840 }
+  },
+/* rst$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0880 }
+  },
+/* rstbf$pack $FRintk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldbf, { 0xc0a00 }
+  },
+/* rsthf$pack $FRintk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldbf, { 0xc0a40 }
+  },
+/* rstf$pack $FRintk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldbf, { 0xc0a80 }
+  },
+/* std$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc00c0 }
+  },
+/* stdf$pack $FRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_stdf, { 0xc02c0 }
+  },
+/* stdc$pack $CPRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CPRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldc, { 0xc0980 }
+  },
+/* rstd$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc08c0 }
+  },
+/* rstdf$pack $FRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_stdf, { 0xc0ac0 }
+  },
+/* stq$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0100 }
+  },
+/* stqf$pack $FRintk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldbf, { 0xc0300 }
+  },
+/* stqc$pack $CPRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CPRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldc, { 0xc09c0 }
+  },
+/* rstq$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0900 }
+  },
+/* rstqf$pack $FRintk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldbf, { 0xc0b00 }
+  },
+/* stbu$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0400 }
+  },
+/* sthu$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0440 }
+  },
+/* stu$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0480 }
+  },
+/* stbfu$pack $FRintk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldbf, { 0xc0600 }
+  },
+/* sthfu$pack $FRintk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldbf, { 0xc0640 }
+  },
+/* stfu$pack $FRintk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldbf, { 0xc0680 }
+  },
+/* stcu$pack $CPRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CPRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldc, { 0xc0b40 }
+  },
+/* stdu$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc04c0 }
+  },
+/* stdfu$pack $FRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_stdf, { 0xc06c0 }
+  },
+/* stdcu$pack $CPRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CPRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldc, { 0xc0b80 }
+  },
+/* stqu$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0500 }
+  },
+/* stqfu$pack $FRintk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldbf, { 0xc0700 }
+  },
+/* stqcu$pack $CPRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CPRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldc, { 0xc0bc0 }
+  },
+/* cldsb$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1780000 }
+  },
+/* cldub$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1780040 }
+  },
+/* cldsh$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1780080 }
+  },
+/* clduh$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x17800c0 }
+  },
+/* cld$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x17c0000 }
+  },
+/* cldbf$pack @($GRi,$GRj),$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cldbf, { 0x1800000 }
+  },
+/* cldhf$pack @($GRi,$GRj),$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cldbf, { 0x1800040 }
+  },
+/* cldf$pack @($GRi,$GRj),$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cldbf, { 0x1800080 }
+  },
+/* cldd$pack @($GRi,$GRj),$GRdoublek,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRDOUBLEK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_csmul, { 0x17c0040 }
+  },
+/* clddf$pack @($GRi,$GRj),$FRdoublek,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRDOUBLEK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_clddf, { 0x18000c0 }
+  },
+/* cldq$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x17c0080 }
+  },
+/* cldsbu$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1840000 }
+  },
+/* cldubu$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1840040 }
+  },
+/* cldshu$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1840080 }
+  },
+/* clduhu$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x18400c0 }
+  },
+/* cldu$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1880000 }
+  },
+/* cldbfu$pack @($GRi,$GRj),$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cldbf, { 0x18c0000 }
+  },
+/* cldhfu$pack @($GRi,$GRj),$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cldbf, { 0x18c0040 }
+  },
+/* cldfu$pack @($GRi,$GRj),$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cldbf, { 0x18c0080 }
+  },
+/* clddu$pack @($GRi,$GRj),$GRdoublek,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRDOUBLEK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_csmul, { 0x1880040 }
+  },
+/* clddfu$pack @($GRi,$GRj),$FRdoublek,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (FRDOUBLEK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_clddf, { 0x18c00c0 }
+  },
+/* cldqu$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1880080 }
+  },
+/* cstb$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1900000 }
+  },
+/* csth$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1900040 }
+  },
+/* cst$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1900080 }
+  },
+/* cstbf$pack $FRintk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cldbf, { 0x1980000 }
+  },
+/* csthf$pack $FRintk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cldbf, { 0x1980040 }
+  },
+/* cstf$pack $FRintk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cldbf, { 0x1980080 }
+  },
+/* cstd$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x19000c0 }
+  },
+/* cstdf$pack $FRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cstdf, { 0x19800c0 }
+  },
+/* cstq$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1940000 }
+  },
+/* cstbu$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x19c0000 }
+  },
+/* csthu$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x19c0040 }
+  },
+/* cstu$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x19c0080 }
+  },
+/* cstbfu$pack $FRintk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cldbf, { 0x1a00000 }
+  },
+/* csthfu$pack $FRintk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cldbf, { 0x1a00040 }
+  },
+/* cstfu$pack $FRintk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cldbf, { 0x1a00080 }
+  },
+/* cstdu$pack $GRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x19c00c0 }
+  },
+/* cstdfu$pack $FRk,@($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cstdf, { 0x1a000c0 }
+  },
+/* stbi$pack $GRk,@($GRi,$d12) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (D12), ')', 0 } },
+    & ifmt_ldsbi, { 0x1400000 }
+  },
+/* sthi$pack $GRk,@($GRi,$d12) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (D12), ')', 0 } },
+    & ifmt_ldsbi, { 0x1440000 }
+  },
+/* sti$pack $GRk,@($GRi,$d12) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (D12), ')', 0 } },
+    & ifmt_ldsbi, { 0x1480000 }
+  },
+/* stbfi$pack $FRintk,@($GRi,$d12) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (D12), ')', 0 } },
+    & ifmt_ldbfi, { 0x1380000 }
+  },
+/* sthfi$pack $FRintk,@($GRi,$d12) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (D12), ')', 0 } },
+    & ifmt_ldbfi, { 0x13c0000 }
+  },
+/* stfi$pack $FRintk,@($GRi,$d12) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (D12), ')', 0 } },
+    & ifmt_ldbfi, { 0x1540000 }
+  },
+/* stdi$pack $GRk,@($GRi,$d12) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (D12), ')', 0 } },
+    & ifmt_ldsbi, { 0x14c0000 }
+  },
+/* stdfi$pack $FRk,@($GRi,$d12) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRK), ',', '@', '(', OP (GRI), ',', OP (D12), ')', 0 } },
+    & ifmt_stdfi, { 0x1580000 }
+  },
+/* stqi$pack $GRk,@($GRi,$d12) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (D12), ')', 0 } },
+    & ifmt_ldsbi, { 0x1500000 }
+  },
+/* stqfi$pack $FRintk,@($GRi,$d12) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', '@', '(', OP (GRI), ',', OP (D12), ')', 0 } },
+    & ifmt_ldbfi, { 0x15c0000 }
+  },
+/* swap$pack @($GRi,$GRj),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsb, { 0xc0140 }
+  },
+/* swapi$pack @($GRi,$d12),$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (D12), ')', ',', OP (GRK), 0 } },
+    & ifmt_ldsbi, { 0x1340000 }
+  },
+/* cswap$pack @($GRi,$GRj),$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cadd, { 0x1940080 }
+  },
+/* movgf$pack $GRj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRJ), ',', OP (FRINTK), 0 } },
+    & ifmt_movgf, { 0xc0540 }
+  },
+/* movfg$pack $FRintk,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', OP (GRJ), 0 } },
+    & ifmt_movgf, { 0xc0340 }
+  },
+/* movgfd$pack $GRj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRJ), ',', OP (FRINTK), 0 } },
+    & ifmt_movgf, { 0xc0580 }
+  },
+/* movfgd$pack $FRintk,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', OP (GRJ), 0 } },
+    & ifmt_movgf, { 0xc0380 }
+  },
+/* movgfq$pack $GRj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRJ), ',', OP (FRINTK), 0 } },
+    & ifmt_movgf, { 0xc05c0 }
+  },
+/* movfgq$pack $FRintk,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', OP (GRJ), 0 } },
+    & ifmt_movgf, { 0xc03c0 }
+  },
+/* cmovgf$pack $GRj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmovgf, { 0x1a40000 }
+  },
+/* cmovfg$pack $FRintk,$GRj,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', OP (GRJ), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmovgf, { 0x1a40080 }
+  },
+/* cmovgfd$pack $GRj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmovgf, { 0x1a40040 }
+  },
+/* cmovfgd$pack $FRintk,$GRj,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTK), ',', OP (GRJ), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmovgf, { 0x1a400c0 }
+  },
+/* movgs$pack $GRj,$spr */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRJ), ',', OP (SPR), 0 } },
+    & ifmt_movgs, { 0xc0180 }
+  },
+/* movsg$pack $spr,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (SPR), ',', OP (GRJ), 0 } },
+    & ifmt_movgs, { 0xc01c0 }
+  },
+/* bra$pack $hint_taken$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (HINT_TAKEN), OP (LABEL16), 0 } },
+    & ifmt_bra, { 0x40180000 }
+  },
+/* bno$pack$hint_not_taken */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), OP (HINT_NOT_TAKEN), 0 } },
+    & ifmt_bno, { 0x180000 }
+  },
+/* beq$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x20180000 }
+  },
+/* bne$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x60180000 }
+  },
+/* ble$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x38180000 }
+  },
+/* bgt$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x78180000 }
+  },
+/* blt$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x18180000 }
+  },
+/* bge$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x58180000 }
+  },
+/* bls$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x28180000 }
+  },
+/* bhi$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x68180000 }
+  },
+/* bc$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x8180000 }
+  },
+/* bnc$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x48180000 }
+  },
+/* bn$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x30180000 }
+  },
+/* bp$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x70180000 }
+  },
+/* bv$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x10180000 }
+  },
+/* bnv$pack $ICCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_beq, { 0x50180000 }
+  },
+/* fbra$pack $hint_taken$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (HINT_TAKEN), OP (LABEL16), 0 } },
+    & ifmt_fbra, { 0x781c0000 }
+  },
+/* fbno$pack$hint_not_taken */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), OP (HINT_NOT_TAKEN), 0 } },
+    & ifmt_fbno, { 0x1c0000 }
+  },
+/* fbne$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x381c0000 }
+  },
+/* fbeq$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x401c0000 }
+  },
+/* fblg$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x301c0000 }
+  },
+/* fbue$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x481c0000 }
+  },
+/* fbul$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x281c0000 }
+  },
+/* fbge$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x501c0000 }
+  },
+/* fblt$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x201c0000 }
+  },
+/* fbuge$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x581c0000 }
+  },
+/* fbug$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x181c0000 }
+  },
+/* fble$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x601c0000 }
+  },
+/* fbgt$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x101c0000 }
+  },
+/* fbule$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x681c0000 }
+  },
+/* fbu$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x81c0000 }
+  },
+/* fbo$pack $FCCi_2,$hint,$label16 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), ',', OP (LABEL16), 0 } },
+    & ifmt_fbne, { 0x701c0000 }
+  },
+/* bctrlr$pack $ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bctrlr, { 0x382000 }
+  },
+/* bralr$pack$hint_taken */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), OP (HINT_TAKEN), 0 } },
+    & ifmt_bralr, { 0x40384000 }
+  },
+/* bnolr$pack$hint_not_taken */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), OP (HINT_NOT_TAKEN), 0 } },
+    & ifmt_bnolr, { 0x384000 }
+  },
+/* beqlr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x20384000 }
+  },
+/* bnelr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x60384000 }
+  },
+/* blelr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x38384000 }
+  },
+/* bgtlr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x78384000 }
+  },
+/* bltlr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x18384000 }
+  },
+/* bgelr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x58384000 }
+  },
+/* blslr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x28384000 }
+  },
+/* bhilr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x68384000 }
+  },
+/* bclr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x8384000 }
+  },
+/* bnclr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x48384000 }
+  },
+/* bnlr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x30384000 }
+  },
+/* bplr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x70384000 }
+  },
+/* bvlr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x10384000 }
+  },
+/* bnvlr$pack $ICCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (HINT), 0 } },
+    & ifmt_beqlr, { 0x50384000 }
+  },
+/* fbralr$pack$hint_taken */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), OP (HINT_TAKEN), 0 } },
+    & ifmt_fbralr, { 0x7838c000 }
+  },
+/* fbnolr$pack$hint_not_taken */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), OP (HINT_NOT_TAKEN), 0 } },
+    & ifmt_fbnolr, { 0x38c000 }
+  },
+/* fbeqlr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x4038c000 }
+  },
+/* fbnelr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x3838c000 }
+  },
+/* fblglr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x3038c000 }
+  },
+/* fbuelr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x4838c000 }
+  },
+/* fbullr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x2838c000 }
+  },
+/* fbgelr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x5038c000 }
+  },
+/* fbltlr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x2038c000 }
+  },
+/* fbugelr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x5838c000 }
+  },
+/* fbuglr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x1838c000 }
+  },
+/* fblelr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x6038c000 }
+  },
+/* fbgtlr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x1038c000 }
+  },
+/* fbulelr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x6838c000 }
+  },
+/* fbulr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x838c000 }
+  },
+/* fbolr$pack $FCCi_2,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (HINT), 0 } },
+    & ifmt_fbeqlr, { 0x7038c000 }
+  },
+/* bcralr$pack $ccond$hint_taken */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CCOND), OP (HINT_TAKEN), 0 } },
+    & ifmt_bcralr, { 0x40386000 }
+  },
+/* bcnolr$pack$hint_not_taken */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), OP (HINT_NOT_TAKEN), 0 } },
+    & ifmt_bnolr, { 0x386000 }
+  },
+/* bceqlr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x20386000 }
+  },
+/* bcnelr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x60386000 }
+  },
+/* bclelr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x38386000 }
+  },
+/* bcgtlr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x78386000 }
+  },
+/* bcltlr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x18386000 }
+  },
+/* bcgelr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x58386000 }
+  },
+/* bclslr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x28386000 }
+  },
+/* bchilr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x68386000 }
+  },
+/* bcclr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x8386000 }
+  },
+/* bcnclr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x48386000 }
+  },
+/* bcnlr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x30386000 }
+  },
+/* bcplr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x70386000 }
+  },
+/* bcvlr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x10386000 }
+  },
+/* bcnvlr$pack $ICCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_bceqlr, { 0x50386000 }
+  },
+/* fcbralr$pack $ccond$hint_taken */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CCOND), OP (HINT_TAKEN), 0 } },
+    & ifmt_fcbralr, { 0x7838e000 }
+  },
+/* fcbnolr$pack$hint_not_taken */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), OP (HINT_NOT_TAKEN), 0 } },
+    & ifmt_fbnolr, { 0x38e000 }
+  },
+/* fcbeqlr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x4038e000 }
+  },
+/* fcbnelr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x3838e000 }
+  },
+/* fcblglr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x3038e000 }
+  },
+/* fcbuelr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x4838e000 }
+  },
+/* fcbullr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x2838e000 }
+  },
+/* fcbgelr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x5038e000 }
+  },
+/* fcbltlr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x2038e000 }
+  },
+/* fcbugelr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x5838e000 }
+  },
+/* fcbuglr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x1838e000 }
+  },
+/* fcblelr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x6038e000 }
+  },
+/* fcbgtlr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x1038e000 }
+  },
+/* fcbulelr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x6838e000 }
+  },
+/* fcbulr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x838e000 }
+  },
+/* fcbolr$pack $FCCi_2,$ccond,$hint */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (CCOND), ',', OP (HINT), 0 } },
+    & ifmt_fcbeqlr, { 0x7038e000 }
+  },
+/* jmpl$pack @($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_jmpl, { 0x300000 }
+  },
+/* calll$pack @($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_calll, { 0x2300000 }
+  },
+/* jmpil$pack @($GRi,$s12) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (S12), ')', 0 } },
+    & ifmt_jmpil, { 0x340000 }
+  },
+/* callil$pack @($GRi,$s12) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (S12), ')', 0 } },
+    & ifmt_callil, { 0x2340000 }
+  },
+/* call$pack $label24 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (LABEL24), 0 } },
+    & ifmt_call, { 0x3c0000 }
+  },
+/* rett$pack $debug */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (DEBUG), 0 } },
+    & ifmt_rett, { 0x140000 }
+  },
+/* rei$pack $eir */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (EIR), 0 } },
+    & ifmt_rei, { 0xdc0000 }
+  },
+/* tra$pack $GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_tra, { 0x40100000 }
+  },
+/* tno$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_tno, { 0x100000 }
+  },
+/* teq$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x20100000 }
+  },
+/* tne$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x60100000 }
+  },
+/* tle$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x38100000 }
+  },
+/* tgt$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x78100000 }
+  },
+/* tlt$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x18100000 }
+  },
+/* tge$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x58100000 }
+  },
+/* tls$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x28100000 }
+  },
+/* thi$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x68100000 }
+  },
+/* tc$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x8100000 }
+  },
+/* tnc$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x48100000 }
+  },
+/* tn$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x30100000 }
+  },
+/* tp$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x70100000 }
+  },
+/* tv$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x10100000 }
+  },
+/* tnv$pack $ICCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_teq, { 0x50100000 }
+  },
+/* ftra$pack $GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftra, { 0x78100040 }
+  },
+/* ftno$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_ftno, { 0x100040 }
+  },
+/* ftne$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x38100040 }
+  },
+/* fteq$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x40100040 }
+  },
+/* ftlg$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x30100040 }
+  },
+/* ftue$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x48100040 }
+  },
+/* ftul$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x28100040 }
+  },
+/* ftge$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x50100040 }
+  },
+/* ftlt$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x20100040 }
+  },
+/* ftuge$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x58100040 }
+  },
+/* ftug$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x18100040 }
+  },
+/* ftle$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x60100040 }
+  },
+/* ftgt$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x10100040 }
+  },
+/* ftule$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x68100040 }
+  },
+/* ftu$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x8100040 }
+  },
+/* fto$pack $FCCi_2,$GRi,$GRj */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (GRJ), 0 } },
+    & ifmt_ftne, { 0x70100040 }
+  },
+/* tira$pack $GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tira, { 0x40700000 }
+  },
+/* tino$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_tino, { 0x700000 }
+  },
+/* tieq$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x20700000 }
+  },
+/* tine$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x60700000 }
+  },
+/* tile$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x38700000 }
+  },
+/* tigt$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x78700000 }
+  },
+/* tilt$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x18700000 }
+  },
+/* tige$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x58700000 }
+  },
+/* tils$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x28700000 }
+  },
+/* tihi$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x68700000 }
+  },
+/* tic$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x8700000 }
+  },
+/* tinc$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x48700000 }
+  },
+/* tin$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x30700000 }
+  },
+/* tip$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x70700000 }
+  },
+/* tiv$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x10700000 }
+  },
+/* tinv$pack $ICCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_tieq, { 0x50700000 }
+  },
+/* ftira$pack $GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftira, { 0x78740000 }
+  },
+/* ftino$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_ftino, { 0x740000 }
+  },
+/* ftine$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x38740000 }
+  },
+/* ftieq$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x40740000 }
+  },
+/* ftilg$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x30740000 }
+  },
+/* ftiue$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x48740000 }
+  },
+/* ftiul$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x28740000 }
+  },
+/* ftige$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x50740000 }
+  },
+/* ftilt$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x20740000 }
+  },
+/* ftiuge$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x58740000 }
+  },
+/* ftiug$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x18740000 }
+  },
+/* ftile$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x60740000 }
+  },
+/* ftigt$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x10740000 }
+  },
+/* ftiule$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x68740000 }
+  },
+/* ftiu$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x8740000 }
+  },
+/* ftio$pack $FCCi_2,$GRi,$s12 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_2), ',', OP (GRI), ',', OP (S12), 0 } },
+    & ifmt_ftine, { 0x70740000 }
+  },
+/* break$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_break, { 0x1000c0 }
+  },
+/* mtrap$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_break, { 0x100080 }
+  },
+/* andcr$pack $CRi,$CRj,$CRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRI), ',', OP (CRJ), ',', OP (CRK), 0 } },
+    & ifmt_andcr, { 0x280200 }
+  },
+/* orcr$pack $CRi,$CRj,$CRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRI), ',', OP (CRJ), ',', OP (CRK), 0 } },
+    & ifmt_andcr, { 0x280240 }
+  },
+/* xorcr$pack $CRi,$CRj,$CRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRI), ',', OP (CRJ), ',', OP (CRK), 0 } },
+    & ifmt_andcr, { 0x280280 }
+  },
+/* nandcr$pack $CRi,$CRj,$CRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRI), ',', OP (CRJ), ',', OP (CRK), 0 } },
+    & ifmt_andcr, { 0x280300 }
+  },
+/* norcr$pack $CRi,$CRj,$CRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRI), ',', OP (CRJ), ',', OP (CRK), 0 } },
+    & ifmt_andcr, { 0x280340 }
+  },
+/* andncr$pack $CRi,$CRj,$CRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRI), ',', OP (CRJ), ',', OP (CRK), 0 } },
+    & ifmt_andcr, { 0x280400 }
+  },
+/* orncr$pack $CRi,$CRj,$CRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRI), ',', OP (CRJ), ',', OP (CRK), 0 } },
+    & ifmt_andcr, { 0x280440 }
+  },
+/* nandncr$pack $CRi,$CRj,$CRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRI), ',', OP (CRJ), ',', OP (CRK), 0 } },
+    & ifmt_andcr, { 0x280500 }
+  },
+/* norncr$pack $CRi,$CRj,$CRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRI), ',', OP (CRJ), ',', OP (CRK), 0 } },
+    & ifmt_andcr, { 0x280540 }
+  },
+/* notcr$pack $CRj,$CRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRJ), ',', OP (CRK), 0 } },
+    & ifmt_notcr, { 0x2802c0 }
+  },
+/* ckra$pack $CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRJ_INT), 0 } },
+    & ifmt_ckra, { 0x40200000 }
+  },
+/* ckno$pack $CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRJ_INT), 0 } },
+    & ifmt_ckra, { 0x200000 }
+  },
+/* ckeq$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x20200000 }
+  },
+/* ckne$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x60200000 }
+  },
+/* ckle$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x38200000 }
+  },
+/* ckgt$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x78200000 }
+  },
+/* cklt$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x18200000 }
+  },
+/* ckge$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x58200000 }
+  },
+/* ckls$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x28200000 }
+  },
+/* ckhi$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x68200000 }
+  },
+/* ckc$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x8200000 }
+  },
+/* cknc$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x48200000 }
+  },
+/* ckn$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x30200000 }
+  },
+/* ckp$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x70200000 }
+  },
+/* ckv$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x10200000 }
+  },
+/* cknv$pack $ICCi_3,$CRj_int */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), 0 } },
+    & ifmt_ckeq, { 0x50200000 }
+  },
+/* fckra$pack $CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x78240000 }
+  },
+/* fckno$pack $CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x240000 }
+  },
+/* fckne$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x38240000 }
+  },
+/* fckeq$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x40240000 }
+  },
+/* fcklg$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x30240000 }
+  },
+/* fckue$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x48240000 }
+  },
+/* fckul$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x28240000 }
+  },
+/* fckge$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x50240000 }
+  },
+/* fcklt$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x20240000 }
+  },
+/* fckuge$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x58240000 }
+  },
+/* fckug$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x18240000 }
+  },
+/* fckle$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x60240000 }
+  },
+/* fckgt$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x10240000 }
+  },
+/* fckule$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x68240000 }
+  },
+/* fcku$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x8240000 }
+  },
+/* fcko$pack $FCCi_3,$CRj_float */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), 0 } },
+    & ifmt_fckra, { 0x70240000 }
+  },
+/* cckra$pack $CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckra, { 0x41a80000 }
+  },
+/* cckno$pack $CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckra, { 0x1a80000 }
+  },
+/* cckeq$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x21a80000 }
+  },
+/* cckne$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x61a80000 }
+  },
+/* cckle$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x39a80000 }
+  },
+/* cckgt$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x79a80000 }
+  },
+/* ccklt$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x19a80000 }
+  },
+/* cckge$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x59a80000 }
+  },
+/* cckls$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x29a80000 }
+  },
+/* cckhi$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x69a80000 }
+  },
+/* cckc$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x9a80000 }
+  },
+/* ccknc$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x49a80000 }
+  },
+/* cckn$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x31a80000 }
+  },
+/* cckp$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x71a80000 }
+  },
+/* cckv$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x11a80000 }
+  },
+/* ccknv$pack $ICCi_3,$CRj_int,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ICCI_3), ',', OP (CRJ_INT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cckeq, { 0x51a80000 }
+  },
+/* cfckra$pack $CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckra, { 0x79a80040 }
+  },
+/* cfckno$pack $CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckra, { 0x1a80040 }
+  },
+/* cfckne$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x39a80040 }
+  },
+/* cfckeq$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x41a80040 }
+  },
+/* cfcklg$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x31a80040 }
+  },
+/* cfckue$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x49a80040 }
+  },
+/* cfckul$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x29a80040 }
+  },
+/* cfckge$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x51a80040 }
+  },
+/* cfcklt$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x21a80040 }
+  },
+/* cfckuge$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x59a80040 }
+  },
+/* cfckug$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x19a80040 }
+  },
+/* cfckle$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x61a80040 }
+  },
+/* cfckgt$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x11a80040 }
+  },
+/* cfckule$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x69a80040 }
+  },
+/* cfcku$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x9a80040 }
+  },
+/* cfcko$pack $FCCi_3,$CRj_float,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FCCI_3), ',', OP (CRJ_FLOAT), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfckne, { 0x71a80040 }
+  },
+/* cjmpl$pack @($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cjmpl, { 0x1a80080 }
+  },
+/* ccalll$pack @($GRi,$GRj),$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_ccalll, { 0x3a80080 }
+  },
+/* ici$pack @($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ici, { 0xc0e00 }
+  },
+/* dci$pack @($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ici, { 0xc0f00 }
+  },
+/* icei$pack @($GRi,$GRj),$ae */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (AE), 0 } },
+    & ifmt_icei, { 0xc0e40 }
+  },
+/* dcei$pack @($GRi,$GRj),$ae */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (AE), 0 } },
+    & ifmt_icei, { 0xc0e80 }
+  },
+/* dcf$pack @($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ici, { 0xc0f40 }
+  },
+/* dcef$pack @($GRi,$GRj),$ae */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', ',', OP (AE), 0 } },
+    & ifmt_icei, { 0xc0ec0 }
+  },
+/* witlb$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0c80 }
+  },
+/* wdtlb$pack $GRk,@($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), ',', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ldsb, { 0xc0d80 }
+  },
+/* itlbi$pack @($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ici, { 0xc0cc0 }
+  },
+/* dtlbi$pack @($GRi,$GRj) */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', '@', '(', OP (GRI), ',', OP (GRJ), ')', 0 } },
+    & ifmt_ici, { 0xc0dc0 }
+  },
+/* icpl$pack $GRi,$GRj,$lock */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (LOCK), 0 } },
+    & ifmt_icpl, { 0xc0c00 }
+  },
+/* dcpl$pack $GRi,$GRj,$lock */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (LOCK), 0 } },
+    & ifmt_icpl, { 0xc0d00 }
+  },
+/* icul$pack $GRi */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), 0 } },
+    & ifmt_icul, { 0xc0c40 }
+  },
+/* dcul$pack $GRi */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), 0 } },
+    & ifmt_icul, { 0xc0d40 }
+  },
+/* bar$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_bar, { 0xc0f80 }
+  },
+/* membar$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_bar, { 0xc0fc0 }
+  },
+/* cop1$pack $s6_1,$CPRi,$CPRj,$CPRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (S6_1), ',', OP (CPRI), ',', OP (CPRJ), ',', OP (CPRK), 0 } },
+    & ifmt_cop1, { 0x1f80000 }
+  },
+/* cop2$pack $s6_1,$CPRi,$CPRj,$CPRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (S6_1), ',', OP (CPRI), ',', OP (CPRJ), ',', OP (CPRK), 0 } },
+    & ifmt_cop1, { 0x1fc0000 }
+  },
+/* clrgr$pack $GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), 0 } },
+    & ifmt_clrgr, { 0x280000 }
+  },
+/* clrfr$pack $FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRK), 0 } },
+    & ifmt_clrfr, { 0x280080 }
+  },
+/* clrga$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_bar, { 0x280040 }
+  },
+/* clrfa$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_bar, { 0x2800c0 }
+  },
+/* commitgr$pack $GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRK), 0 } },
+    & ifmt_clrgr, { 0x280100 }
+  },
+/* commitfr$pack $FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRK), 0 } },
+    & ifmt_clrfr, { 0x280180 }
+  },
+/* commitga$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_bar, { 0x280140 }
+  },
+/* commitfa$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_bar, { 0x2801c0 }
+  },
+/* fitos$pack $FRintj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRK), 0 } },
+    & ifmt_fitos, { 0x1e40000 }
+  },
+/* fstoi$pack $FRj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRINTK), 0 } },
+    & ifmt_fstoi, { 0x1e40040 }
+  },
+/* fitod$pack $FRintj,$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_fitod, { 0x1e80000 }
+  },
+/* fdtoi$pack $FRdoublej,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRDOUBLEJ), ',', OP (FRINTK), 0 } },
+    & ifmt_fdtoi, { 0x1e80040 }
+  },
+/* fditos$pack $FRintj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRK), 0 } },
+    & ifmt_fitos, { 0x1e40400 }
+  },
+/* fdstoi$pack $FRj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRINTK), 0 } },
+    & ifmt_fstoi, { 0x1e40440 }
+  },
+/* nfditos$pack $FRintj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRK), 0 } },
+    & ifmt_fitos, { 0x1e40c00 }
+  },
+/* nfdstoi$pack $FRj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRINTK), 0 } },
+    & ifmt_fstoi, { 0x1e40c40 }
+  },
+/* cfitos$pack $FRintj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfitos, { 0x1ac0000 }
+  },
+/* cfstoi$pack $FRj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfstoi, { 0x1ac0040 }
+  },
+/* nfitos$pack $FRintj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRK), 0 } },
+    & ifmt_fitos, { 0x1e40800 }
+  },
+/* nfstoi$pack $FRj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRINTK), 0 } },
+    & ifmt_fstoi, { 0x1e40840 }
+  },
+/* fmovs$pack $FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fmovs, { 0x1e40080 }
+  },
+/* fmovd$pack $FRdoublej,$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRDOUBLEJ), ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_fmovd, { 0x1e80080 }
+  },
+/* fdmovs$pack $FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fmovs, { 0x1e40480 }
+  },
+/* cfmovs$pack $FRj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfmovs, { 0x1b00000 }
+  },
+/* fnegs$pack $FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fmovs, { 0x1e400c0 }
+  },
+/* fnegd$pack $FRdoublej,$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRDOUBLEJ), ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_fmovd, { 0x1e800c0 }
+  },
+/* fdnegs$pack $FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fmovs, { 0x1e404c0 }
+  },
+/* cfnegs$pack $FRj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfmovs, { 0x1b00040 }
+  },
+/* fabss$pack $FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fmovs, { 0x1e40100 }
+  },
+/* fabsd$pack $FRdoublej,$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRDOUBLEJ), ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_fmovd, { 0x1e80100 }
+  },
+/* fdabss$pack $FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fmovs, { 0x1e40500 }
+  },
+/* cfabss$pack $FRj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfmovs, { 0x1b00080 }
+  },
+/* fsqrts$pack $FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fmovs, { 0x1e40140 }
+  },
+/* fdsqrts$pack $FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fmovs, { 0x1e40540 }
+  },
+/* nfdsqrts$pack $FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fmovs, { 0x1e40d40 }
+  },
+/* fsqrtd$pack $FRdoublej,$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRDOUBLEJ), ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_fmovd, { 0x1e80140 }
+  },
+/* cfsqrts$pack $FRj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfmovs, { 0x1b80080 }
+  },
+/* nfsqrts$pack $FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fmovs, { 0x1e40940 }
+  },
+/* fadds$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40180 }
+  },
+/* fsubs$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e401c0 }
+  },
+/* fmuls$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40200 }
+  },
+/* fdivs$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40240 }
+  },
+/* faddd$pack $FRdoublei,$FRdoublej,$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRDOUBLEI), ',', OP (FRDOUBLEJ), ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_faddd, { 0x1e80180 }
+  },
+/* fsubd$pack $FRdoublei,$FRdoublej,$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRDOUBLEI), ',', OP (FRDOUBLEJ), ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_faddd, { 0x1e801c0 }
+  },
+/* fmuld$pack $FRdoublei,$FRdoublej,$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRDOUBLEI), ',', OP (FRDOUBLEJ), ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_faddd, { 0x1e80200 }
+  },
+/* fdivd$pack $FRdoublei,$FRdoublej,$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRDOUBLEI), ',', OP (FRDOUBLEJ), ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_faddd, { 0x1e80240 }
+  },
+/* cfadds$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfadds, { 0x1b40000 }
+  },
+/* cfsubs$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfadds, { 0x1b40040 }
+  },
+/* cfmuls$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfadds, { 0x1b80000 }
+  },
+/* cfdivs$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfadds, { 0x1b80040 }
+  },
+/* nfadds$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40980 }
+  },
+/* nfsubs$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e409c0 }
+  },
+/* nfmuls$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40a00 }
+  },
+/* nfdivs$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40a40 }
+  },
+/* fcmps$pack $FRi,$FRj,$FCCi_2 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FCCI_2), 0 } },
+    & ifmt_fcmps, { 0x1e40280 }
+  },
+/* fcmpd$pack $FRdoublei,$FRdoublej,$FCCi_2 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRDOUBLEI), ',', OP (FRDOUBLEJ), ',', OP (FCCI_2), 0 } },
+    & ifmt_fcmpd, { 0x1e80280 }
+  },
+/* cfcmps$pack $FRi,$FRj,$FCCi_2,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FCCI_2), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfcmps, { 0x1b40080 }
+  },
+/* fdcmps$pack $FRi,$FRj,$FCCi_2 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FCCI_2), 0 } },
+    & ifmt_fcmps, { 0x1e40680 }
+  },
+/* fmadds$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e402c0 }
+  },
+/* fmsubs$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40300 }
+  },
+/* fmaddd$pack $FRdoublei,$FRdoublej,$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRDOUBLEI), ',', OP (FRDOUBLEJ), ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_faddd, { 0x1e802c0 }
+  },
+/* fmsubd$pack $FRdoublei,$FRdoublej,$FRdoublek */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRDOUBLEI), ',', OP (FRDOUBLEJ), ',', OP (FRDOUBLEK), 0 } },
+    & ifmt_faddd, { 0x1e80300 }
+  },
+/* fdmadds$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e406c0 }
+  },
+/* nfdmadds$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40ec0 }
+  },
+/* cfmadds$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfadds, { 0x1bc0000 }
+  },
+/* cfmsubs$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfadds, { 0x1bc0040 }
+  },
+/* nfmadds$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40ac0 }
+  },
+/* nfmsubs$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40b00 }
+  },
+/* fmas$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40380 }
+  },
+/* fmss$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e403c0 }
+  },
+/* fdmas$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40700 }
+  },
+/* fdmss$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40740 }
+  },
+/* nfdmas$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40f00 }
+  },
+/* nfdmss$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40f40 }
+  },
+/* cfmas$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfadds, { 0x1bc0080 }
+  },
+/* cfmss$pack $FRi,$FRj,$FRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cfadds, { 0x1bc00c0 }
+  },
+/* fmad$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e80380 }
+  },
+/* fmsd$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e803c0 }
+  },
+/* nfmas$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40b80 }
+  },
+/* nfmss$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40bc0 }
+  },
+/* fdadds$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40580 }
+  },
+/* fdsubs$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e405c0 }
+  },
+/* fdmuls$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40600 }
+  },
+/* fddivs$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40640 }
+  },
+/* fdsads$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40780 }
+  },
+/* fdmulcs$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e407c0 }
+  },
+/* nfdmulcs$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40fc0 }
+  },
+/* nfdadds$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40d80 }
+  },
+/* nfdsubs$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40dc0 }
+  },
+/* nfdmuls$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40e00 }
+  },
+/* nfddivs$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40e40 }
+  },
+/* nfdsads$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1e40f80 }
+  },
+/* nfdcmps$pack $FRi,$FRj,$FCCi_2 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FCCI_2), 0 } },
+    & ifmt_fcmps, { 0x1e40e80 }
+  },
+/* mhsetlos$pack $u12,$FRklo */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (U12), ',', OP (FRKLO), 0 } },
+    & ifmt_mhsetlos, { 0x1e00800 }
+  },
+/* mhsethis$pack $u12,$FRkhi */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (U12), ',', OP (FRKHI), 0 } },
+    & ifmt_mhsethis, { 0x1e00880 }
+  },
+/* mhdsets$pack $u12,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (U12), ',', OP (FRINTK), 0 } },
+    & ifmt_mhdsets, { 0x1e00900 }
+  },
+/* mhsetloh$pack $s5,$FRklo */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (S5), ',', OP (FRKLO), 0 } },
+    & ifmt_mhsetloh, { 0x1e00840 }
+  },
+/* mhsethih$pack $s5,$FRkhi */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (S5), ',', OP (FRKHI), 0 } },
+    & ifmt_mhsethih, { 0x1e008c0 }
+  },
+/* mhdseth$pack $s5,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (S5), ',', OP (FRINTK), 0 } },
+    & ifmt_mhdseth, { 0x1e00940 }
+  },
+/* mand$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0000 }
+  },
+/* mor$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0040 }
+  },
+/* mxor$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0080 }
+  },
+/* cmand$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmand, { 0x1c00000 }
+  },
+/* cmor$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmand, { 0x1c00040 }
+  },
+/* cmxor$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmand, { 0x1c00080 }
+  },
+/* mnot$pack $FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mnot, { 0x1ec00c0 }
+  },
+/* cmnot$pack $FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmnot, { 0x1c000c0 }
+  },
+/* mrotli$pack $FRinti,$u6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), 0 } },
+    & ifmt_mrotli, { 0x1ec0100 }
+  },
+/* mrotri$pack $FRinti,$u6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), 0 } },
+    & ifmt_mrotli, { 0x1ec0140 }
+  },
+/* mwcut$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0180 }
+  },
+/* mwcuti$pack $FRinti,$u6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), 0 } },
+    & ifmt_mrotli, { 0x1ec01c0 }
+  },
+/* mcut$pack $ACC40Si,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mcut, { 0x1ec0b00 }
+  },
+/* mcuti$pack $ACC40Si,$s6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SI), ',', OP (S6), ',', OP (FRINTK), 0 } },
+    & ifmt_mcuti, { 0x1ec0b80 }
+  },
+/* mcutss$pack $ACC40Si,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mcut, { 0x1ec0b40 }
+  },
+/* mcutssi$pack $ACC40Si,$s6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SI), ',', OP (S6), ',', OP (FRINTK), 0 } },
+    & ifmt_mcuti, { 0x1ec0bc0 }
+  },
+/* mdcutssi$pack $ACC40Si,$s6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SI), ',', OP (S6), ',', OP (FRINTK), 0 } },
+    & ifmt_mcuti, { 0x1e00380 }
+  },
+/* maveh$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0200 }
+  },
+/* msllhi$pack $FRinti,$u6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), 0 } },
+    & ifmt_mrotli, { 0x1ec0240 }
+  },
+/* msrlhi$pack $FRinti,$u6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), 0 } },
+    & ifmt_mrotli, { 0x1ec0280 }
+  },
+/* msrahi$pack $FRinti,$u6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), 0 } },
+    & ifmt_mrotli, { 0x1ec02c0 }
+  },
+/* mdrotli$pack $FRinti,$u6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), 0 } },
+    & ifmt_mrotli, { 0x1e002c0 }
+  },
+/* mcplhi$pack $FRinti,$u6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), 0 } },
+    & ifmt_mrotli, { 0x1e00300 }
+  },
+/* mcpli$pack $FRinti,$u6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), 0 } },
+    & ifmt_mrotli, { 0x1e00340 }
+  },
+/* msaths$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0300 }
+  },
+/* mqsaths$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1e003c0 }
+  },
+/* msathu$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0340 }
+  },
+/* mcmpsh$pack $FRinti,$FRintj,$FCCk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FCCK), 0 } },
+    & ifmt_mcmpsh, { 0x1ec0380 }
+  },
+/* mcmpuh$pack $FRinti,$FRintj,$FCCk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FCCK), 0 } },
+    & ifmt_mcmpsh, { 0x1ec03c0 }
+  },
+/* mabshs$pack $FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mabshs, { 0x1e00280 }
+  },
+/* maddhss$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0400 }
+  },
+/* maddhus$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0440 }
+  },
+/* msubhss$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0480 }
+  },
+/* msubhus$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec04c0 }
+  },
+/* cmaddhss$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmand, { 0x1c40000 }
+  },
+/* cmaddhus$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmand, { 0x1c40040 }
+  },
+/* cmsubhss$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmand, { 0x1c40080 }
+  },
+/* cmsubhus$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmand, { 0x1c400c0 }
+  },
+/* mqaddhss$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0600 }
+  },
+/* mqaddhus$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0640 }
+  },
+/* mqsubhss$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0680 }
+  },
+/* mqsubhus$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec06c0 }
+  },
+/* cmqaddhss$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmand, { 0x1cc0000 }
+  },
+/* cmqaddhus$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmand, { 0x1cc0040 }
+  },
+/* cmqsubhss$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmand, { 0x1cc0080 }
+  },
+/* cmqsubhus$pack $FRinti,$FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmand, { 0x1cc00c0 }
+  },
+/* maddaccs$pack $ACC40Si,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SI), ',', OP (ACC40SK), 0 } },
+    & ifmt_maddaccs, { 0x1e00100 }
+  },
+/* msubaccs$pack $ACC40Si,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SI), ',', OP (ACC40SK), 0 } },
+    & ifmt_maddaccs, { 0x1e00140 }
+  },
+/* mdaddaccs$pack $ACC40Si,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SI), ',', OP (ACC40SK), 0 } },
+    & ifmt_maddaccs, { 0x1e00180 }
+  },
+/* mdsubaccs$pack $ACC40Si,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SI), ',', OP (ACC40SK), 0 } },
+    & ifmt_maddaccs, { 0x1e001c0 }
+  },
+/* masaccs$pack $ACC40Si,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SI), ',', OP (ACC40SK), 0 } },
+    & ifmt_maddaccs, { 0x1e00200 }
+  },
+/* mdasaccs$pack $ACC40Si,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SI), ',', OP (ACC40SK), 0 } },
+    & ifmt_maddaccs, { 0x1e00240 }
+  },
+/* mmulhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0500 }
+  },
+/* mmulhu$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0540 }
+  },
+/* mmulxhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0a00 }
+  },
+/* mmulxhu$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0a40 }
+  },
+/* cmmulhs$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmmulhs, { 0x1c80000 }
+  },
+/* cmmulhu$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmmulhs, { 0x1c80040 }
+  },
+/* mqmulhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0700 }
+  },
+/* mqmulhu$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0740 }
+  },
+/* mqmulxhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0a80 }
+  },
+/* mqmulxhu$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0ac0 }
+  },
+/* cmqmulhs$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmmulhs, { 0x1d00000 }
+  },
+/* cmqmulhu$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmmulhs, { 0x1d00040 }
+  },
+/* mmachs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0580 }
+  },
+/* mmachu$pack $FRinti,$FRintj,$ACC40Uk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40UK), 0 } },
+    & ifmt_mmachu, { 0x1ec05c0 }
+  },
+/* mmrdhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0c00 }
+  },
+/* mmrdhu$pack $FRinti,$FRintj,$ACC40Uk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40UK), 0 } },
+    & ifmt_mmachu, { 0x1ec0c40 }
+  },
+/* cmmachs$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmmulhs, { 0x1c80080 }
+  },
+/* cmmachu$pack $FRinti,$FRintj,$ACC40Uk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40UK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmmachu, { 0x1c800c0 }
+  },
+/* mqmachs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0780 }
+  },
+/* mqmachu$pack $FRinti,$FRintj,$ACC40Uk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40UK), 0 } },
+    & ifmt_mmachu, { 0x1ec07c0 }
+  },
+/* cmqmachs$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmmulhs, { 0x1d00080 }
+  },
+/* cmqmachu$pack $FRinti,$FRintj,$ACC40Uk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40UK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmmachu, { 0x1d000c0 }
+  },
+/* mqxmachs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1e00000 }
+  },
+/* mqxmacxhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1e00040 }
+  },
+/* mqmacxhs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1e00080 }
+  },
+/* mcpxrs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0800 }
+  },
+/* mcpxru$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0840 }
+  },
+/* mcpxis$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0880 }
+  },
+/* mcpxiu$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec08c0 }
+  },
+/* cmcpxrs$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmmulhs, { 0x1d40000 }
+  },
+/* cmcpxru$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmmulhs, { 0x1d40040 }
+  },
+/* cmcpxis$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmmulhs, { 0x1d40080 }
+  },
+/* cmcpxiu$pack $FRinti,$FRintj,$ACC40Sk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmmulhs, { 0x1d400c0 }
+  },
+/* mqcpxrs$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0900 }
+  },
+/* mqcpxru$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0940 }
+  },
+/* mqcpxis$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec0980 }
+  },
+/* mqcpxiu$pack $FRinti,$FRintj,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (ACC40SK), 0 } },
+    & ifmt_mmulhs, { 0x1ec09c0 }
+  },
+/* mexpdhw$pack $FRinti,$u6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), 0 } },
+    & ifmt_mrotli, { 0x1ec0c80 }
+  },
+/* cmexpdhw$pack $FRinti,$u6,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmexpdhw, { 0x1d80080 }
+  },
+/* mexpdhd$pack $FRinti,$u6,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), 0 } },
+    & ifmt_mrotli, { 0x1ec0cc0 }
+  },
+/* cmexpdhd$pack $FRinti,$u6,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (U6), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmexpdhw, { 0x1d800c0 }
+  },
+/* mpackh$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0d00 }
+  },
+/* mdpackh$pack $FRinti,$FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mand, { 0x1ec0d80 }
+  },
+/* munpackh$pack $FRinti,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTK), 0 } },
+    & ifmt_munpackh, { 0x1ec0d40 }
+  },
+/* mdunpackh$pack $FRinti,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (FRINTK), 0 } },
+    & ifmt_munpackh, { 0x1ec0dc0 }
+  },
+/* mbtoh$pack $FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mabshs, { 0x1ec0e00 }
+  },
+/* cmbtoh$pack $FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmbtoh, { 0x1dc0000 }
+  },
+/* mhtob$pack $FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mabshs, { 0x1ec0e40 }
+  },
+/* cmhtob$pack $FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmbtoh, { 0x1dc0040 }
+  },
+/* mbtohe$pack $FRintj,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRINTK), 0 } },
+    & ifmt_mabshs, { 0x1ec0e80 }
+  },
+/* cmbtohe$pack $FRintj,$FRintk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTJ), ',', OP (FRINTK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmbtoh, { 0x1dc0080 }
+  },
+/* mclracc$pack $ACC40Sk,$A */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SK), ',', OP (A), 0 } },
+    & ifmt_mclracc, { 0x1ec0ec0 }
+  },
+/* mrdacc$pack $ACC40Si,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACC40SI), ',', OP (FRINTK), 0 } },
+    & ifmt_mrdacc, { 0x1ec0f00 }
+  },
+/* mrdaccg$pack $ACCGi,$FRintk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (ACCGI), ',', OP (FRINTK), 0 } },
+    & ifmt_mrdaccg, { 0x1ec0f80 }
+  },
+/* mwtacc$pack $FRinti,$ACC40Sk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (ACC40SK), 0 } },
+    & ifmt_mwtacc, { 0x1ec0f40 }
+  },
+/* mwtaccg$pack $FRinti,$ACCGk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRINTI), ',', OP (ACCGK), 0 } },
+    & ifmt_mwtaccg, { 0x1ec0fc0 }
+  },
+/* mcop1$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1f00000 }
+  },
+/* mcop2$pack $FRi,$FRj,$FRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (FRI), ',', OP (FRJ), ',', OP (FRK), 0 } },
+    & ifmt_fadds, { 0x1f40000 }
+  },
+/* fnop$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_fnop, { 0x1e40340 }
+  },
+};
+
+#undef A
+#undef OPERAND
+#undef MNEM
+#undef OP
+
+/* Formats for ALIAS macro-insns.  */
+
+#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
+#define F(f) & frv_cgen_ifld_table[FRV_##f]
+#else
+#define F(f) & frv_cgen_ifld_table[FRV_/**/f]
+#endif
+static const CGEN_IFMT ifmt_nop = {
+  32, 32, 0x7fffffff, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mnop = {
+  32, 32, 0x7fffffff, { { F (F_PACK) }, { F (F_ACC40SK) }, { F (F_OP) }, { F (F_A) }, { F (F_MISC_NULL_10) }, { F (F_OPE1) }, { F (F_FRJ_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ret = {
+  32, 32, 0x7fffffff, { { F (F_PACK) }, { F (F_INT_CC) }, { F (F_ICCI_2_NULL) }, { F (F_OP) }, { F (F_HINT) }, { F (F_OPE3) }, { F (F_CCOND_NULL) }, { F (F_S12_NULL) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cmp = {
+  32, 32, 0x7ffc03c0, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_ICCI_1) }, { F (F_OPE2) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cmpi = {
+  32, 32, 0x7ffc0000, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_ICCI_1) }, { F (F_S10) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_ccmp = {
+  32, 32, 0x7ffc00c0, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_mov = {
+  32, 32, 0x1fc0fff, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_D12) }, { 0 } }
+};
+
+static const CGEN_IFMT ifmt_cmov = {
+  32, 32, 0x1fc00ff, { { F (F_PACK) }, { F (F_GRK) }, { F (F_OP) }, { F (F_GRI) }, { F (F_CCI) }, { F (F_COND) }, { F (F_OPE4) }, { F (F_GRJ) }, { 0 } }
+};
+
+#undef F
+
+/* Each non-simple macro entry points to an array of expansion possibilities.  */
+
+#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
+#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
+#define OPERAND(op) FRV_OPERAND_##op
+#else
+#define OPERAND(op) FRV_OPERAND_/**/op
+#endif
+#define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
+#define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
+
+/* The macro instruction table.  */
+
+static const CGEN_IBASE frv_cgen_macro_insn_table[] =
+{
+/* nop$pack */
+  {
+    -1, "nop", "nop", 32,
+    { 0|A(ALIAS), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* mnop$pack */
+  {
+    -1, "mnop", "mnop", 32,
+    { 0|A(NO_DIS)|A(ALIAS), { (1<<MACH_BASE), UNIT_FM01, FR400_MAJOR_NONE, FR500_MAJOR_M_3 } }
+  },
+/* ret$pack */
+  {
+    -1, "ret", "ret", 32,
+    { 0|A(NO_DIS)|A(ALIAS), { (1<<MACH_BASE), UNIT_B01, FR400_MAJOR_B_3, FR500_MAJOR_B_3 } }
+  },
+/* cmp$pack $GRi,$GRj,$ICCi_1 */
+  {
+    -1, "cmp", "cmp", 32,
+    { 0|A(NO_DIS)|A(ALIAS), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* cmpi$pack $GRi,$s10,$ICCi_1 */
+  {
+    -1, "cmpi", "cmpi", 32,
+    { 0|A(NO_DIS)|A(ALIAS), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* ccmp$pack $GRi,$GRj,$CCi,$cond */
+  {
+    -1, "ccmp", "ccmp", 32,
+    { 0|A(CONDITIONAL)|A(NO_DIS)|A(ALIAS), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* mov$pack $GRi,$GRk */
+  {
+    -1, "mov", "mov", 32,
+    { 0|A(NO_DIS)|A(ALIAS), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+/* cmov$pack $GRi,$GRk,$CCi,$cond */
+  {
+    -1, "cmov", "cmov", 32,
+    { 0|A(CONDITIONAL)|A(NO_DIS)|A(ALIAS), { (1<<MACH_BASE), UNIT_I01, FR400_MAJOR_I_1, FR500_MAJOR_I_1 } }
+  },
+};
+
+/* The macro instruction opcode table.  */
+
+static const CGEN_OPCODE frv_cgen_macro_insn_opcode_table[] =
+{
+/* nop$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_nop, { 0x880000 }
+  },
+/* mnop$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_mnop, { 0x7fee0ec0 }
+  },
+/* ret$pack */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), 0 } },
+    & ifmt_ret, { 0x403a4000 }
+  },
+/* cmp$pack $GRi,$GRj,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (ICCI_1), 0 } },
+    & ifmt_cmp, { 0x140 }
+  },
+/* cmpi$pack $GRi,$s10,$ICCi_1 */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (S10), ',', OP (ICCI_1), 0 } },
+    & ifmt_cmpi, { 0x540000 }
+  },
+/* ccmp$pack $GRi,$GRj,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRJ), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_ccmp, { 0x1640040 }
+  },
+/* mov$pack $GRi,$GRk */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRK), 0 } },
+    & ifmt_mov, { 0x880000 }
+  },
+/* cmov$pack $GRi,$GRk,$CCi,$cond */
+  {
+    { 0, 0, 0, 0 },
+    { { MNEM, OP (PACK), ' ', OP (GRI), ',', OP (GRK), ',', OP (CCI), ',', OP (COND), 0 } },
+    & ifmt_cmov, { 0x1680040 }
+  },
+};
+
+#undef A
+#undef OPERAND
+#undef MNEM
+#undef OP
+
+#ifndef CGEN_ASM_HASH_P
+#define CGEN_ASM_HASH_P(insn) 1
+#endif
+
+#ifndef CGEN_DIS_HASH_P
+#define CGEN_DIS_HASH_P(insn) 1
+#endif
+
+/* Return non-zero if INSN is to be added to the hash table.
+   Targets are free to override CGEN_{ASM,DIS}_HASH_P in the .opc file.  */
+
+static int
+asm_hash_insn_p (insn)
+     const CGEN_INSN *insn ATTRIBUTE_UNUSED;
+{
+  return CGEN_ASM_HASH_P (insn);
+}
+
+static int
+dis_hash_insn_p (insn)
+     const CGEN_INSN *insn;
+{
+  /* If building the hash table and the NO-DIS attribute is present,
+     ignore.  */
+  if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_NO_DIS))
+    return 0;
+  return CGEN_DIS_HASH_P (insn);
+}
+
+#ifndef CGEN_ASM_HASH
+#define CGEN_ASM_HASH_SIZE 127
+#ifdef CGEN_MNEMONIC_OPERANDS
+#define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE)
+#else
+#define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE) /*FIXME*/
+#endif
+#endif
+
+/* It doesn't make much sense to provide a default here,
+   but while this is under development we do.
+   BUFFER is a pointer to the bytes of the insn, target order.
+   VALUE is the first base_insn_bitsize bits as an int in host order.  */
+
+#ifndef CGEN_DIS_HASH
+#define CGEN_DIS_HASH_SIZE 256
+#define CGEN_DIS_HASH(buf, value) (*(unsigned char *) (buf))
+#endif
+
+/* The result is the hash value of the insn.
+   Targets are free to override CGEN_{ASM,DIS}_HASH in the .opc file.  */
+
+static unsigned int
+asm_hash_insn (mnem)
+     const char * mnem;
+{
+  return CGEN_ASM_HASH (mnem);
+}
+
+/* BUF is a pointer to the bytes of the insn, target order.
+   VALUE is the first base_insn_bitsize bits as an int in host order.  */
+
+static unsigned int
+dis_hash_insn (buf, value)
+     const char * buf ATTRIBUTE_UNUSED;
+     CGEN_INSN_INT value ATTRIBUTE_UNUSED;
+{
+  return CGEN_DIS_HASH (buf, value);
+}
+
+static void set_fields_bitsize PARAMS ((CGEN_FIELDS *, int));
+
+/* Set the recorded length of the insn in the CGEN_FIELDS struct.  */
+
+static void
+set_fields_bitsize (fields, size)
+     CGEN_FIELDS *fields;
+     int size;
+{
+  CGEN_FIELDS_BITSIZE (fields) = size;
+}
+
+/* Function to call before using the operand instance table.
+   This plugs the opcode entries and macro instructions into the cpu table.  */
+
+void
+frv_cgen_init_opcode_table (cd)
+     CGEN_CPU_DESC cd;
+{
+  int i;
+  int num_macros = (sizeof (frv_cgen_macro_insn_table) /
+		    sizeof (frv_cgen_macro_insn_table[0]));
+  const CGEN_IBASE *ib = & frv_cgen_macro_insn_table[0];
+  const CGEN_OPCODE *oc = & frv_cgen_macro_insn_opcode_table[0];
+  CGEN_INSN *insns = (CGEN_INSN *) xmalloc (num_macros * sizeof (CGEN_INSN));
+  memset (insns, 0, num_macros * sizeof (CGEN_INSN));
+  for (i = 0; i < num_macros; ++i)
+    {
+      insns[i].base = &ib[i];
+      insns[i].opcode = &oc[i];
+      frv_cgen_build_insn_regex (& insns[i]);
+    }
+  cd->macro_insn_table.init_entries = insns;
+  cd->macro_insn_table.entry_size = sizeof (CGEN_IBASE);
+  cd->macro_insn_table.num_init_entries = num_macros;
+
+  oc = & frv_cgen_insn_opcode_table[0];
+  insns = (CGEN_INSN *) cd->insn_table.init_entries;
+  for (i = 0; i < MAX_INSNS; ++i)
+    {
+      insns[i].opcode = &oc[i];
+      frv_cgen_build_insn_regex (& insns[i]);
+    }
+
+  cd->sizeof_fields = sizeof (CGEN_FIELDS);
+  cd->set_fields_bitsize = set_fields_bitsize;
+
+  cd->asm_hash_p = asm_hash_insn_p;
+  cd->asm_hash = asm_hash_insn;
+  cd->asm_hash_size = CGEN_ASM_HASH_SIZE;
+
+  cd->dis_hash_p = dis_hash_insn_p;
+  cd->dis_hash = dis_hash_insn;
+  cd->dis_hash_size = CGEN_DIS_HASH_SIZE;
+}
diff --git a/opcodes/frv-opc.h b/opcodes/frv-opc.h
new file mode 100644
index 00000000000..266031b6419
--- /dev/null
+++ b/opcodes/frv-opc.h
@@ -0,0 +1,372 @@
+/* Instruction opcode header for frv.
+
+THIS FILE IS MACHINE GENERATED WITH CGEN.
+
+Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+
+This file is part of the GNU Binutils and/or GDB, the GNU debugger.
+
+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, 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.
+
+*/
+
+#ifndef FRV_OPC_H
+#define FRV_OPC_H
+
+/* -- opc.h */
+
+#undef CGEN_DIS_HASH_SIZE
+#define CGEN_DIS_HASH_SIZE 128
+#undef CGEN_DIS_HASH
+#define CGEN_DIS_HASH(buffer, value) (((value) >> 18) & 127)
+
+/* Vliw support.  */
+#define FRV_VLIW_SIZE 4 /* fr500 has largest vliw size of 4.  */
+typedef CGEN_ATTR_VALUE_TYPE VLIW_COMBO[FRV_VLIW_SIZE];
+
+typedef struct
+{
+  int                   next_slot;
+  int                   constraint_violation;
+  unsigned long         mach;
+  unsigned long         elf_flags;
+  CGEN_ATTR_VALUE_TYPE *unit_mapping;
+  VLIW_COMBO           *current_vliw;
+  CGEN_ATTR_VALUE_TYPE  major[FRV_VLIW_SIZE];
+} FRV_VLIW;
+
+int frv_is_branch_major PARAMS ((CGEN_ATTR_VALUE_TYPE, unsigned long));
+int frv_is_float_major  PARAMS ((CGEN_ATTR_VALUE_TYPE, unsigned long));
+int frv_is_media_major  PARAMS ((CGEN_ATTR_VALUE_TYPE, unsigned long));
+int frv_is_branch_insn  PARAMS ((const CGEN_INSN *));
+int frv_is_float_insn   PARAMS ((const CGEN_INSN *));
+int frv_is_media_insn   PARAMS ((const CGEN_INSN *));
+void frv_vliw_reset     PARAMS ((FRV_VLIW *, unsigned long mach, unsigned long elf_flags));
+int frv_vliw_add_insn   PARAMS ((FRV_VLIW *, const CGEN_INSN *));
+int spr_valid           PARAMS ((long));
+/* -- */
+/* Enum declaration for frv instruction types.  */
+typedef enum cgen_insn_type {
+  FRV_INSN_INVALID, FRV_INSN_ADD, FRV_INSN_SUB, FRV_INSN_AND
+ , FRV_INSN_OR, FRV_INSN_XOR, FRV_INSN_NOT, FRV_INSN_SDIV
+ , FRV_INSN_NSDIV, FRV_INSN_UDIV, FRV_INSN_NUDIV, FRV_INSN_SMUL
+ , FRV_INSN_UMUL, FRV_INSN_SLL, FRV_INSN_SRL, FRV_INSN_SRA
+ , FRV_INSN_SCAN, FRV_INSN_CADD, FRV_INSN_CSUB, FRV_INSN_CAND
+ , FRV_INSN_COR, FRV_INSN_CXOR, FRV_INSN_CNOT, FRV_INSN_CSMUL
+ , FRV_INSN_CSDIV, FRV_INSN_CUDIV, FRV_INSN_CSLL, FRV_INSN_CSRL
+ , FRV_INSN_CSRA, FRV_INSN_CSCAN, FRV_INSN_ADDCC, FRV_INSN_SUBCC
+ , FRV_INSN_ANDCC, FRV_INSN_ORCC, FRV_INSN_XORCC, FRV_INSN_SLLCC
+ , FRV_INSN_SRLCC, FRV_INSN_SRACC, FRV_INSN_SMULCC, FRV_INSN_UMULCC
+ , FRV_INSN_CADDCC, FRV_INSN_CSUBCC, FRV_INSN_CSMULCC, FRV_INSN_CANDCC
+ , FRV_INSN_CORCC, FRV_INSN_CXORCC, FRV_INSN_CSLLCC, FRV_INSN_CSRLCC
+ , FRV_INSN_CSRACC, FRV_INSN_ADDX, FRV_INSN_SUBX, FRV_INSN_ADDXCC
+ , FRV_INSN_SUBXCC, FRV_INSN_ADDI, FRV_INSN_SUBI, FRV_INSN_ANDI
+ , FRV_INSN_ORI, FRV_INSN_XORI, FRV_INSN_SDIVI, FRV_INSN_NSDIVI
+ , FRV_INSN_UDIVI, FRV_INSN_NUDIVI, FRV_INSN_SMULI, FRV_INSN_UMULI
+ , FRV_INSN_SLLI, FRV_INSN_SRLI, FRV_INSN_SRAI, FRV_INSN_SCANI
+ , FRV_INSN_ADDICC, FRV_INSN_SUBICC, FRV_INSN_ANDICC, FRV_INSN_ORICC
+ , FRV_INSN_XORICC, FRV_INSN_SMULICC, FRV_INSN_UMULICC, FRV_INSN_SLLICC
+ , FRV_INSN_SRLICC, FRV_INSN_SRAICC, FRV_INSN_ADDXI, FRV_INSN_SUBXI
+ , FRV_INSN_ADDXICC, FRV_INSN_SUBXICC, FRV_INSN_CMPB, FRV_INSN_CMPBA
+ , FRV_INSN_SETLO, FRV_INSN_SETHI, FRV_INSN_SETLOS, FRV_INSN_LDSB
+ , FRV_INSN_LDUB, FRV_INSN_LDSH, FRV_INSN_LDUH, FRV_INSN_LD
+ , FRV_INSN_LDBF, FRV_INSN_LDHF, FRV_INSN_LDF, FRV_INSN_LDC
+ , FRV_INSN_NLDSB, FRV_INSN_NLDUB, FRV_INSN_NLDSH, FRV_INSN_NLDUH
+ , FRV_INSN_NLD, FRV_INSN_NLDBF, FRV_INSN_NLDHF, FRV_INSN_NLDF
+ , FRV_INSN_LDD, FRV_INSN_LDDF, FRV_INSN_LDDC, FRV_INSN_NLDD
+ , FRV_INSN_NLDDF, FRV_INSN_LDQ, FRV_INSN_LDQF, FRV_INSN_LDQC
+ , FRV_INSN_NLDQ, FRV_INSN_NLDQF, FRV_INSN_LDSBU, FRV_INSN_LDUBU
+ , FRV_INSN_LDSHU, FRV_INSN_LDUHU, FRV_INSN_LDU, FRV_INSN_NLDSBU
+ , FRV_INSN_NLDUBU, FRV_INSN_NLDSHU, FRV_INSN_NLDUHU, FRV_INSN_NLDU
+ , FRV_INSN_LDBFU, FRV_INSN_LDHFU, FRV_INSN_LDFU, FRV_INSN_LDCU
+ , FRV_INSN_NLDBFU, FRV_INSN_NLDHFU, FRV_INSN_NLDFU, FRV_INSN_LDDU
+ , FRV_INSN_NLDDU, FRV_INSN_LDDFU, FRV_INSN_LDDCU, FRV_INSN_NLDDFU
+ , FRV_INSN_LDQU, FRV_INSN_NLDQU, FRV_INSN_LDQFU, FRV_INSN_LDQCU
+ , FRV_INSN_NLDQFU, FRV_INSN_LDSBI, FRV_INSN_LDSHI, FRV_INSN_LDI
+ , FRV_INSN_LDUBI, FRV_INSN_LDUHI, FRV_INSN_LDBFI, FRV_INSN_LDHFI
+ , FRV_INSN_LDFI, FRV_INSN_NLDSBI, FRV_INSN_NLDUBI, FRV_INSN_NLDSHI
+ , FRV_INSN_NLDUHI, FRV_INSN_NLDI, FRV_INSN_NLDBFI, FRV_INSN_NLDHFI
+ , FRV_INSN_NLDFI, FRV_INSN_LDDI, FRV_INSN_LDDFI, FRV_INSN_NLDDI
+ , FRV_INSN_NLDDFI, FRV_INSN_LDQI, FRV_INSN_LDQFI, FRV_INSN_NLDQI
+ , FRV_INSN_NLDQFI, FRV_INSN_STB, FRV_INSN_STH, FRV_INSN_ST
+ , FRV_INSN_STBF, FRV_INSN_STHF, FRV_INSN_STF, FRV_INSN_STC
+ , FRV_INSN_RSTB, FRV_INSN_RSTH, FRV_INSN_RST, FRV_INSN_RSTBF
+ , FRV_INSN_RSTHF, FRV_INSN_RSTF, FRV_INSN_STD, FRV_INSN_STDF
+ , FRV_INSN_STDC, FRV_INSN_RSTD, FRV_INSN_RSTDF, FRV_INSN_STQ
+ , FRV_INSN_STQF, FRV_INSN_STQC, FRV_INSN_RSTQ, FRV_INSN_RSTQF
+ , FRV_INSN_STBU, FRV_INSN_STHU, FRV_INSN_STU, FRV_INSN_STBFU
+ , FRV_INSN_STHFU, FRV_INSN_STFU, FRV_INSN_STCU, FRV_INSN_STDU
+ , FRV_INSN_STDFU, FRV_INSN_STDCU, FRV_INSN_STQU, FRV_INSN_STQFU
+ , FRV_INSN_STQCU, FRV_INSN_CLDSB, FRV_INSN_CLDUB, FRV_INSN_CLDSH
+ , FRV_INSN_CLDUH, FRV_INSN_CLD, FRV_INSN_CLDBF, FRV_INSN_CLDHF
+ , FRV_INSN_CLDF, FRV_INSN_CLDD, FRV_INSN_CLDDF, FRV_INSN_CLDQ
+ , FRV_INSN_CLDSBU, FRV_INSN_CLDUBU, FRV_INSN_CLDSHU, FRV_INSN_CLDUHU
+ , FRV_INSN_CLDU, FRV_INSN_CLDBFU, FRV_INSN_CLDHFU, FRV_INSN_CLDFU
+ , FRV_INSN_CLDDU, FRV_INSN_CLDDFU, FRV_INSN_CLDQU, FRV_INSN_CSTB
+ , FRV_INSN_CSTH, FRV_INSN_CST, FRV_INSN_CSTBF, FRV_INSN_CSTHF
+ , FRV_INSN_CSTF, FRV_INSN_CSTD, FRV_INSN_CSTDF, FRV_INSN_CSTQ
+ , FRV_INSN_CSTBU, FRV_INSN_CSTHU, FRV_INSN_CSTU, FRV_INSN_CSTBFU
+ , FRV_INSN_CSTHFU, FRV_INSN_CSTFU, FRV_INSN_CSTDU, FRV_INSN_CSTDFU
+ , FRV_INSN_STBI, FRV_INSN_STHI, FRV_INSN_STI, FRV_INSN_STBFI
+ , FRV_INSN_STHFI, FRV_INSN_STFI, FRV_INSN_STDI, FRV_INSN_STDFI
+ , FRV_INSN_STQI, FRV_INSN_STQFI, FRV_INSN_SWAP, FRV_INSN_SWAPI
+ , FRV_INSN_CSWAP, FRV_INSN_MOVGF, FRV_INSN_MOVFG, FRV_INSN_MOVGFD
+ , FRV_INSN_MOVFGD, FRV_INSN_MOVGFQ, FRV_INSN_MOVFGQ, FRV_INSN_CMOVGF
+ , FRV_INSN_CMOVFG, FRV_INSN_CMOVGFD, FRV_INSN_CMOVFGD, FRV_INSN_MOVGS
+ , FRV_INSN_MOVSG, FRV_INSN_BRA, FRV_INSN_BNO, FRV_INSN_BEQ
+ , FRV_INSN_BNE, FRV_INSN_BLE, FRV_INSN_BGT, FRV_INSN_BLT
+ , FRV_INSN_BGE, FRV_INSN_BLS, FRV_INSN_BHI, FRV_INSN_BC
+ , FRV_INSN_BNC, FRV_INSN_BN, FRV_INSN_BP, FRV_INSN_BV
+ , FRV_INSN_BNV, FRV_INSN_FBRA, FRV_INSN_FBNO, FRV_INSN_FBNE
+ , FRV_INSN_FBEQ, FRV_INSN_FBLG, FRV_INSN_FBUE, FRV_INSN_FBUL
+ , FRV_INSN_FBGE, FRV_INSN_FBLT, FRV_INSN_FBUGE, FRV_INSN_FBUG
+ , FRV_INSN_FBLE, FRV_INSN_FBGT, FRV_INSN_FBULE, FRV_INSN_FBU
+ , FRV_INSN_FBO, FRV_INSN_BCTRLR, FRV_INSN_BRALR, FRV_INSN_BNOLR
+ , FRV_INSN_BEQLR, FRV_INSN_BNELR, FRV_INSN_BLELR, FRV_INSN_BGTLR
+ , FRV_INSN_BLTLR, FRV_INSN_BGELR, FRV_INSN_BLSLR, FRV_INSN_BHILR
+ , FRV_INSN_BCLR, FRV_INSN_BNCLR, FRV_INSN_BNLR, FRV_INSN_BPLR
+ , FRV_INSN_BVLR, FRV_INSN_BNVLR, FRV_INSN_FBRALR, FRV_INSN_FBNOLR
+ , FRV_INSN_FBEQLR, FRV_INSN_FBNELR, FRV_INSN_FBLGLR, FRV_INSN_FBUELR
+ , FRV_INSN_FBULLR, FRV_INSN_FBGELR, FRV_INSN_FBLTLR, FRV_INSN_FBUGELR
+ , FRV_INSN_FBUGLR, FRV_INSN_FBLELR, FRV_INSN_FBGTLR, FRV_INSN_FBULELR
+ , FRV_INSN_FBULR, FRV_INSN_FBOLR, FRV_INSN_BCRALR, FRV_INSN_BCNOLR
+ , FRV_INSN_BCEQLR, FRV_INSN_BCNELR, FRV_INSN_BCLELR, FRV_INSN_BCGTLR
+ , FRV_INSN_BCLTLR, FRV_INSN_BCGELR, FRV_INSN_BCLSLR, FRV_INSN_BCHILR
+ , FRV_INSN_BCCLR, FRV_INSN_BCNCLR, FRV_INSN_BCNLR, FRV_INSN_BCPLR
+ , FRV_INSN_BCVLR, FRV_INSN_BCNVLR, FRV_INSN_FCBRALR, FRV_INSN_FCBNOLR
+ , FRV_INSN_FCBEQLR, FRV_INSN_FCBNELR, FRV_INSN_FCBLGLR, FRV_INSN_FCBUELR
+ , FRV_INSN_FCBULLR, FRV_INSN_FCBGELR, FRV_INSN_FCBLTLR, FRV_INSN_FCBUGELR
+ , FRV_INSN_FCBUGLR, FRV_INSN_FCBLELR, FRV_INSN_FCBGTLR, FRV_INSN_FCBULELR
+ , FRV_INSN_FCBULR, FRV_INSN_FCBOLR, FRV_INSN_JMPL, FRV_INSN_CALLL
+ , FRV_INSN_JMPIL, FRV_INSN_CALLIL, FRV_INSN_CALL, FRV_INSN_RETT
+ , FRV_INSN_REI, FRV_INSN_TRA, FRV_INSN_TNO, FRV_INSN_TEQ
+ , FRV_INSN_TNE, FRV_INSN_TLE, FRV_INSN_TGT, FRV_INSN_TLT
+ , FRV_INSN_TGE, FRV_INSN_TLS, FRV_INSN_THI, FRV_INSN_TC
+ , FRV_INSN_TNC, FRV_INSN_TN, FRV_INSN_TP, FRV_INSN_TV
+ , FRV_INSN_TNV, FRV_INSN_FTRA, FRV_INSN_FTNO, FRV_INSN_FTNE
+ , FRV_INSN_FTEQ, FRV_INSN_FTLG, FRV_INSN_FTUE, FRV_INSN_FTUL
+ , FRV_INSN_FTGE, FRV_INSN_FTLT, FRV_INSN_FTUGE, FRV_INSN_FTUG
+ , FRV_INSN_FTLE, FRV_INSN_FTGT, FRV_INSN_FTULE, FRV_INSN_FTU
+ , FRV_INSN_FTO, FRV_INSN_TIRA, FRV_INSN_TINO, FRV_INSN_TIEQ
+ , FRV_INSN_TINE, FRV_INSN_TILE, FRV_INSN_TIGT, FRV_INSN_TILT
+ , FRV_INSN_TIGE, FRV_INSN_TILS, FRV_INSN_TIHI, FRV_INSN_TIC
+ , FRV_INSN_TINC, FRV_INSN_TIN, FRV_INSN_TIP, FRV_INSN_TIV
+ , FRV_INSN_TINV, FRV_INSN_FTIRA, FRV_INSN_FTINO, FRV_INSN_FTINE
+ , FRV_INSN_FTIEQ, FRV_INSN_FTILG, FRV_INSN_FTIUE, FRV_INSN_FTIUL
+ , FRV_INSN_FTIGE, FRV_INSN_FTILT, FRV_INSN_FTIUGE, FRV_INSN_FTIUG
+ , FRV_INSN_FTILE, FRV_INSN_FTIGT, FRV_INSN_FTIULE, FRV_INSN_FTIU
+ , FRV_INSN_FTIO, FRV_INSN_BREAK, FRV_INSN_MTRAP, FRV_INSN_ANDCR
+ , FRV_INSN_ORCR, FRV_INSN_XORCR, FRV_INSN_NANDCR, FRV_INSN_NORCR
+ , FRV_INSN_ANDNCR, FRV_INSN_ORNCR, FRV_INSN_NANDNCR, FRV_INSN_NORNCR
+ , FRV_INSN_NOTCR, FRV_INSN_CKRA, FRV_INSN_CKNO, FRV_INSN_CKEQ
+ , FRV_INSN_CKNE, FRV_INSN_CKLE, FRV_INSN_CKGT, FRV_INSN_CKLT
+ , FRV_INSN_CKGE, FRV_INSN_CKLS, FRV_INSN_CKHI, FRV_INSN_CKC
+ , FRV_INSN_CKNC, FRV_INSN_CKN, FRV_INSN_CKP, FRV_INSN_CKV
+ , FRV_INSN_CKNV, FRV_INSN_FCKRA, FRV_INSN_FCKNO, FRV_INSN_FCKNE
+ , FRV_INSN_FCKEQ, FRV_INSN_FCKLG, FRV_INSN_FCKUE, FRV_INSN_FCKUL
+ , FRV_INSN_FCKGE, FRV_INSN_FCKLT, FRV_INSN_FCKUGE, FRV_INSN_FCKUG
+ , FRV_INSN_FCKLE, FRV_INSN_FCKGT, FRV_INSN_FCKULE, FRV_INSN_FCKU
+ , FRV_INSN_FCKO, FRV_INSN_CCKRA, FRV_INSN_CCKNO, FRV_INSN_CCKEQ
+ , FRV_INSN_CCKNE, FRV_INSN_CCKLE, FRV_INSN_CCKGT, FRV_INSN_CCKLT
+ , FRV_INSN_CCKGE, FRV_INSN_CCKLS, FRV_INSN_CCKHI, FRV_INSN_CCKC
+ , FRV_INSN_CCKNC, FRV_INSN_CCKN, FRV_INSN_CCKP, FRV_INSN_CCKV
+ , FRV_INSN_CCKNV, FRV_INSN_CFCKRA, FRV_INSN_CFCKNO, FRV_INSN_CFCKNE
+ , FRV_INSN_CFCKEQ, FRV_INSN_CFCKLG, FRV_INSN_CFCKUE, FRV_INSN_CFCKUL
+ , FRV_INSN_CFCKGE, FRV_INSN_CFCKLT, FRV_INSN_CFCKUGE, FRV_INSN_CFCKUG
+ , FRV_INSN_CFCKLE, FRV_INSN_CFCKGT, FRV_INSN_CFCKULE, FRV_INSN_CFCKU
+ , FRV_INSN_CFCKO, FRV_INSN_CJMPL, FRV_INSN_CCALLL, FRV_INSN_ICI
+ , FRV_INSN_DCI, FRV_INSN_ICEI, FRV_INSN_DCEI, FRV_INSN_DCF
+ , FRV_INSN_DCEF, FRV_INSN_WITLB, FRV_INSN_WDTLB, FRV_INSN_ITLBI
+ , FRV_INSN_DTLBI, FRV_INSN_ICPL, FRV_INSN_DCPL, FRV_INSN_ICUL
+ , FRV_INSN_DCUL, FRV_INSN_BAR, FRV_INSN_MEMBAR, FRV_INSN_COP1
+ , FRV_INSN_COP2, FRV_INSN_CLRGR, FRV_INSN_CLRFR, FRV_INSN_CLRGA
+ , FRV_INSN_CLRFA, FRV_INSN_COMMITGR, FRV_INSN_COMMITFR, FRV_INSN_COMMITGA
+ , FRV_INSN_COMMITFA, FRV_INSN_FITOS, FRV_INSN_FSTOI, FRV_INSN_FITOD
+ , FRV_INSN_FDTOI, FRV_INSN_FDITOS, FRV_INSN_FDSTOI, FRV_INSN_NFDITOS
+ , FRV_INSN_NFDSTOI, FRV_INSN_CFITOS, FRV_INSN_CFSTOI, FRV_INSN_NFITOS
+ , FRV_INSN_NFSTOI, FRV_INSN_FMOVS, FRV_INSN_FMOVD, FRV_INSN_FDMOVS
+ , FRV_INSN_CFMOVS, FRV_INSN_FNEGS, FRV_INSN_FNEGD, FRV_INSN_FDNEGS
+ , FRV_INSN_CFNEGS, FRV_INSN_FABSS, FRV_INSN_FABSD, FRV_INSN_FDABSS
+ , FRV_INSN_CFABSS, FRV_INSN_FSQRTS, FRV_INSN_FDSQRTS, FRV_INSN_NFDSQRTS
+ , FRV_INSN_FSQRTD, FRV_INSN_CFSQRTS, FRV_INSN_NFSQRTS, FRV_INSN_FADDS
+ , FRV_INSN_FSUBS, FRV_INSN_FMULS, FRV_INSN_FDIVS, FRV_INSN_FADDD
+ , FRV_INSN_FSUBD, FRV_INSN_FMULD, FRV_INSN_FDIVD, FRV_INSN_CFADDS
+ , FRV_INSN_CFSUBS, FRV_INSN_CFMULS, FRV_INSN_CFDIVS, FRV_INSN_NFADDS
+ , FRV_INSN_NFSUBS, FRV_INSN_NFMULS, FRV_INSN_NFDIVS, FRV_INSN_FCMPS
+ , FRV_INSN_FCMPD, FRV_INSN_CFCMPS, FRV_INSN_FDCMPS, FRV_INSN_FMADDS
+ , FRV_INSN_FMSUBS, FRV_INSN_FMADDD, FRV_INSN_FMSUBD, FRV_INSN_FDMADDS
+ , FRV_INSN_NFDMADDS, FRV_INSN_CFMADDS, FRV_INSN_CFMSUBS, FRV_INSN_NFMADDS
+ , FRV_INSN_NFMSUBS, FRV_INSN_FMAS, FRV_INSN_FMSS, FRV_INSN_FDMAS
+ , FRV_INSN_FDMSS, FRV_INSN_NFDMAS, FRV_INSN_NFDMSS, FRV_INSN_CFMAS
+ , FRV_INSN_CFMSS, FRV_INSN_FMAD, FRV_INSN_FMSD, FRV_INSN_NFMAS
+ , FRV_INSN_NFMSS, FRV_INSN_FDADDS, FRV_INSN_FDSUBS, FRV_INSN_FDMULS
+ , FRV_INSN_FDDIVS, FRV_INSN_FDSADS, FRV_INSN_FDMULCS, FRV_INSN_NFDMULCS
+ , FRV_INSN_NFDADDS, FRV_INSN_NFDSUBS, FRV_INSN_NFDMULS, FRV_INSN_NFDDIVS
+ , FRV_INSN_NFDSADS, FRV_INSN_NFDCMPS, FRV_INSN_MHSETLOS, FRV_INSN_MHSETHIS
+ , FRV_INSN_MHDSETS, FRV_INSN_MHSETLOH, FRV_INSN_MHSETHIH, FRV_INSN_MHDSETH
+ , FRV_INSN_MAND, FRV_INSN_MOR, FRV_INSN_MXOR, FRV_INSN_CMAND
+ , FRV_INSN_CMOR, FRV_INSN_CMXOR, FRV_INSN_MNOT, FRV_INSN_CMNOT
+ , FRV_INSN_MROTLI, FRV_INSN_MROTRI, FRV_INSN_MWCUT, FRV_INSN_MWCUTI
+ , FRV_INSN_MCUT, FRV_INSN_MCUTI, FRV_INSN_MCUTSS, FRV_INSN_MCUTSSI
+ , FRV_INSN_MDCUTSSI, FRV_INSN_MAVEH, FRV_INSN_MSLLHI, FRV_INSN_MSRLHI
+ , FRV_INSN_MSRAHI, FRV_INSN_MDROTLI, FRV_INSN_MCPLHI, FRV_INSN_MCPLI
+ , FRV_INSN_MSATHS, FRV_INSN_MQSATHS, FRV_INSN_MSATHU, FRV_INSN_MCMPSH
+ , FRV_INSN_MCMPUH, FRV_INSN_MABSHS, FRV_INSN_MADDHSS, FRV_INSN_MADDHUS
+ , FRV_INSN_MSUBHSS, FRV_INSN_MSUBHUS, FRV_INSN_CMADDHSS, FRV_INSN_CMADDHUS
+ , FRV_INSN_CMSUBHSS, FRV_INSN_CMSUBHUS, FRV_INSN_MQADDHSS, FRV_INSN_MQADDHUS
+ , FRV_INSN_MQSUBHSS, FRV_INSN_MQSUBHUS, FRV_INSN_CMQADDHSS, FRV_INSN_CMQADDHUS
+ , FRV_INSN_CMQSUBHSS, FRV_INSN_CMQSUBHUS, FRV_INSN_MADDACCS, FRV_INSN_MSUBACCS
+ , FRV_INSN_MDADDACCS, FRV_INSN_MDSUBACCS, FRV_INSN_MASACCS, FRV_INSN_MDASACCS
+ , FRV_INSN_MMULHS, FRV_INSN_MMULHU, FRV_INSN_MMULXHS, FRV_INSN_MMULXHU
+ , FRV_INSN_CMMULHS, FRV_INSN_CMMULHU, FRV_INSN_MQMULHS, FRV_INSN_MQMULHU
+ , FRV_INSN_MQMULXHS, FRV_INSN_MQMULXHU, FRV_INSN_CMQMULHS, FRV_INSN_CMQMULHU
+ , FRV_INSN_MMACHS, FRV_INSN_MMACHU, FRV_INSN_MMRDHS, FRV_INSN_MMRDHU
+ , FRV_INSN_CMMACHS, FRV_INSN_CMMACHU, FRV_INSN_MQMACHS, FRV_INSN_MQMACHU
+ , FRV_INSN_CMQMACHS, FRV_INSN_CMQMACHU, FRV_INSN_MQXMACHS, FRV_INSN_MQXMACXHS
+ , FRV_INSN_MQMACXHS, FRV_INSN_MCPXRS, FRV_INSN_MCPXRU, FRV_INSN_MCPXIS
+ , FRV_INSN_MCPXIU, FRV_INSN_CMCPXRS, FRV_INSN_CMCPXRU, FRV_INSN_CMCPXIS
+ , FRV_INSN_CMCPXIU, FRV_INSN_MQCPXRS, FRV_INSN_MQCPXRU, FRV_INSN_MQCPXIS
+ , FRV_INSN_MQCPXIU, FRV_INSN_MEXPDHW, FRV_INSN_CMEXPDHW, FRV_INSN_MEXPDHD
+ , FRV_INSN_CMEXPDHD, FRV_INSN_MPACKH, FRV_INSN_MDPACKH, FRV_INSN_MUNPACKH
+ , FRV_INSN_MDUNPACKH, FRV_INSN_MBTOH, FRV_INSN_CMBTOH, FRV_INSN_MHTOB
+ , FRV_INSN_CMHTOB, FRV_INSN_MBTOHE, FRV_INSN_CMBTOHE, FRV_INSN_MCLRACC
+ , FRV_INSN_MRDACC, FRV_INSN_MRDACCG, FRV_INSN_MWTACC, FRV_INSN_MWTACCG
+ , FRV_INSN_MCOP1, FRV_INSN_MCOP2, FRV_INSN_FNOP
+} CGEN_INSN_TYPE;
+
+/* Index of `invalid' insn place holder.  */
+#define CGEN_INSN_INVALID FRV_INSN_INVALID
+
+/* Total number of insns in table.  */
+#define MAX_INSNS ((int) FRV_INSN_FNOP + 1)
+
+/* This struct records data prior to insertion or after extraction.  */
+struct cgen_fields
+{
+  int length;
+  long f_nil;
+  long f_anyof;
+  long f_pack;
+  long f_op;
+  long f_ope1;
+  long f_ope2;
+  long f_ope3;
+  long f_ope4;
+  long f_GRi;
+  long f_GRj;
+  long f_GRk;
+  long f_FRi;
+  long f_FRj;
+  long f_FRk;
+  long f_CPRi;
+  long f_CPRj;
+  long f_CPRk;
+  long f_ACCGi;
+  long f_ACCGk;
+  long f_ACC40Si;
+  long f_ACC40Ui;
+  long f_ACC40Sk;
+  long f_ACC40Uk;
+  long f_CRi;
+  long f_CRj;
+  long f_CRk;
+  long f_CCi;
+  long f_CRj_int;
+  long f_CRj_float;
+  long f_ICCi_1;
+  long f_ICCi_2;
+  long f_ICCi_3;
+  long f_FCCi_1;
+  long f_FCCi_2;
+  long f_FCCi_3;
+  long f_FCCk;
+  long f_eir;
+  long f_s10;
+  long f_s12;
+  long f_d12;
+  long f_u16;
+  long f_s16;
+  long f_s6;
+  long f_s6_1;
+  long f_u6;
+  long f_s5;
+  long f_u12_h;
+  long f_u12_l;
+  long f_u12;
+  long f_int_cc;
+  long f_flt_cc;
+  long f_cond;
+  long f_ccond;
+  long f_hint;
+  long f_LI;
+  long f_lock;
+  long f_debug;
+  long f_A;
+  long f_ae;
+  long f_spr_h;
+  long f_spr_l;
+  long f_spr;
+  long f_label16;
+  long f_labelH6;
+  long f_labelL18;
+  long f_label24;
+  long f_ICCi_1_null;
+  long f_ICCi_2_null;
+  long f_ICCi_3_null;
+  long f_FCCi_1_null;
+  long f_FCCi_2_null;
+  long f_FCCi_3_null;
+  long f_rs_null;
+  long f_GRi_null;
+  long f_GRj_null;
+  long f_GRk_null;
+  long f_FRi_null;
+  long f_FRj_null;
+  long f_ACCj_null;
+  long f_rd_null;
+  long f_cond_null;
+  long f_ccond_null;
+  long f_s12_null;
+  long f_label16_null;
+  long f_misc_null_1;
+  long f_misc_null_2;
+  long f_misc_null_3;
+  long f_misc_null_4;
+  long f_misc_null_5;
+  long f_misc_null_6;
+  long f_misc_null_7;
+  long f_misc_null_8;
+  long f_misc_null_9;
+  long f_misc_null_10;
+  long f_misc_null_11;
+  long f_LI_off;
+  long f_LI_on;
+};
+
+#define CGEN_INIT_PARSE(od) \
+{\
+}
+#define CGEN_INIT_INSERT(od) \
+{\
+}
+#define CGEN_INIT_EXTRACT(od) \
+{\
+}
+#define CGEN_INIT_PRINT(od) \
+{\
+}
+
+
+#endif /* FRV_OPC_H */
diff --git a/sim/mips/mdmx.c b/sim/mips/mdmx.c
new file mode 100644
index 00000000000..4955e821246
--- /dev/null
+++ b/sim/mips/mdmx.c
@@ -0,0 +1,1476 @@
+/* Simulation code for the MIPS MDMX ASE.
+   Copyright (C) 2002 Free Software Foundation, Inc.
+   Contributed by Broadcom Corporation (SiByte).
+
+This file is part of GDB, the GNU debugger.
+
+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, 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 "sim-main.h"
+
+/* Within mdmx.c we refer to the sim_cpu directly. */
+#define CPU cpu
+#define SD  (CPU_STATE(CPU))
+
+/* XXX FIXME: temporary hack while the impact of making unpredictable()
+   a "normal" (non-igen) function is evaluated.  */
+#undef Unpredictable
+#define Unpredictable() unpredictable_action (cpu, cia)
+
+/* MDMX Representations
+
+   An 8-bit packed byte element (OB) is always unsigned.
+   The 24-bit accumulators are signed and are represented as 32-bit
+   signed values, which are reduced to 24-bit signed values prior to
+   Round and Clamp operations.
+  
+   A 16-bit packed halfword element (QH) is always signed.
+   The 48-bit accumulators are signed and are represented as 64-bit
+   signed values, which are reduced to 48-bit signed values prior to
+   Round and Clamp operations.
+  
+   The code below assumes a 2's-complement representation of signed
+   quantities.  Care is required to clear extended sign bits when
+   repacking fields.
+  
+   The code (and the code for arithmetic shifts in mips.igen) also makes
+   the (not guaranteed portable) assumption that right shifts of signed
+   quantities in C do sign extension.  */
+
+typedef unsigned64 unsigned48;
+#define MASK48 (UNSIGNED64 (0xffffffffffff))
+
+typedef unsigned32 unsigned24;
+#define MASK24 (UNSIGNED32 (0xffffff))
+
+typedef enum {
+  mdmx_ob,          /* OB (octal byte) */
+  mdmx_qh           /* QH (quad half-word) */
+} MX_fmt;
+
+typedef enum {
+  sel_elem,         /* element select */
+  sel_vect,         /* vector select */
+  sel_imm           /* immediate select */
+} VT_select;
+
+#define OB_MAX  ((unsigned8)0xFF)
+#define QH_MIN  ((signed16)0x8000)
+#define QH_MAX  ((signed16)0x7FFF)
+
+#define OB_CLAMP(x)  ((unsigned8)((x) > OB_MAX ? OB_MAX : (x)))
+#define QH_CLAMP(x)  ((signed16)((x) < QH_MIN ? QH_MIN : \
+                                ((x) > QH_MAX ? QH_MAX : (x))))
+
+#define MX_FMT(fmtsel) (((fmtsel) & 0x1) == 0 ? mdmx_ob : mdmx_qh)
+#define MX_VT(fmtsel)  (((fmtsel) & 0x10) == 0 ?    sel_elem : \
+                       (((fmtsel) & 0x18) == 0x10 ? sel_vect : sel_imm))
+
+#define QH_ELEM(v,fmtsel) \
+        ((signed16)(((v) >> (((fmtsel) & 0xC) << 2)) & 0xFFFF))
+#define OB_ELEM(v,fmtsel) \
+        ((unsigned8)(((v) >> (((fmtsel) & 0xE) << 2)) & 0xFF))
+
+
+typedef signed16 (*QH_FUNC)(signed16, signed16);
+typedef unsigned8 (*OB_FUNC)(unsigned8, unsigned8);
+
+/* vectorized logical operators */
+
+static signed16
+AndQH(signed16 ts, signed16 tt)
+{
+  return (signed16)((unsigned16)ts & (unsigned16)tt);
+}
+
+static unsigned8
+AndOB(unsigned8 ts, unsigned8 tt)
+{
+  return ts & tt;
+}
+
+static signed16
+NorQH(signed16 ts, signed16 tt)
+{
+  return (signed16)(((unsigned16)ts | (unsigned16)tt) ^ 0xFFFF);
+}
+
+static unsigned8
+NorOB(unsigned8 ts, unsigned8 tt)
+{
+  return (ts | tt) ^ 0xFF;
+}
+
+static signed16
+OrQH(signed16 ts, signed16 tt)
+{
+  return (signed16)((unsigned16)ts | (unsigned16)tt);
+}
+
+static unsigned8
+OrOB(unsigned8 ts, unsigned8 tt)
+{
+  return ts | tt;
+}
+
+static signed16
+XorQH(signed16 ts, signed16 tt)
+{
+  return (signed16)((unsigned16)ts ^ (unsigned16)tt);
+}
+
+static unsigned8
+XorOB(unsigned8 ts, unsigned8 tt)
+{
+  return ts ^ tt;
+}
+
+static signed16
+SLLQH(signed16 ts, signed16 tt)
+{
+  unsigned32 s = (unsigned32)tt & 0xF;
+  return (signed16)(((unsigned32)ts << s) & 0xFFFF);
+}
+
+static unsigned8
+SLLOB(unsigned8 ts, unsigned8 tt)
+{
+  unsigned32 s = tt & 0x7;
+  return (ts << s) & 0xFF;
+}
+
+static signed16
+SRLQH(signed16 ts, signed16 tt)
+{
+  unsigned32 s = (unsigned32)tt & 0xF;
+  return (signed16)((unsigned16)ts >> s);
+}
+
+static unsigned8
+SRLOB(unsigned8 ts, unsigned8 tt)
+{
+  unsigned32 s = tt & 0x7;
+  return ts >> s;
+}
+
+
+/* Vectorized arithmetic operators.  */
+
+static signed16
+AddQH(signed16 ts, signed16 tt)
+{
+  signed32 t = (signed32)ts + (signed32)tt;
+  return QH_CLAMP(t);
+}
+
+static unsigned8
+AddOB(unsigned8 ts, unsigned8 tt)
+{
+  unsigned32 t = (unsigned32)ts + (unsigned32)tt;
+  return OB_CLAMP(t);
+}
+
+static signed16
+SubQH(signed16 ts, signed16 tt)
+{
+  signed32 t = (signed32)ts - (signed32)tt;
+  return QH_CLAMP(t);
+}
+
+static unsigned8
+SubOB(unsigned8 ts, unsigned8 tt)
+{
+  signed32 t;
+  t = (signed32)ts - (signed32)tt;
+  if (t < 0)
+    t = 0;
+  return (unsigned8)t;
+}
+
+static signed16
+MinQH(signed16 ts, signed16 tt)
+{
+  return (ts < tt ? ts : tt);
+}
+
+static unsigned8
+MinOB(unsigned8 ts, unsigned8 tt)
+{
+  return (ts < tt ? ts : tt);
+}
+
+static signed16
+MaxQH(signed16 ts, signed16 tt)
+{
+  return (ts > tt ? ts : tt);
+}
+
+static unsigned8
+MaxOB(unsigned8 ts, unsigned8 tt)
+{
+  return (ts > tt ? ts : tt);
+}
+
+static signed16
+MulQH(signed16 ts, signed16 tt)
+{
+  signed32 t = (signed32)ts * (signed32)tt;
+  return QH_CLAMP(t);
+}
+
+static unsigned8
+MulOB(unsigned8 ts, unsigned8 tt)
+{
+  unsigned32 t = (unsigned32)ts * (unsigned32)tt;
+  return OB_CLAMP(t);
+}
+
+/* "msgn" and "sra" are defined only for QH format.  */
+
+static signed16
+MsgnQH(signed16 ts, signed16 tt)
+{
+  signed16 t;
+  if (ts < 0)
+    t = (tt == QH_MIN ? QH_MAX : -tt);
+  else if (ts == 0)
+    t = 0;
+  else
+    t = tt;
+  return t;
+}
+
+static signed16
+SRAQH(signed16 ts, signed16 tt)
+{
+  unsigned32 s = (unsigned32)tt & 0xF;
+  return (signed16)((signed32)ts >> s);
+}
+
+
+/* "pabsdiff" and "pavg" are defined only for OB format.  */
+
+static unsigned8
+AbsDiffOB(unsigned8 ts, unsigned8 tt)
+{
+  return (ts >= tt ? ts - tt : tt - ts);
+}
+
+static unsigned8
+AvgOB(unsigned8 ts, unsigned8 tt)
+{
+  return ((unsigned32)ts + (unsigned32)tt + 1) >> 1;
+}
+
+
+/* Dispatch tables for operations that update a CPR.  */
+
+static const QH_FUNC qh_func[] = {
+  AndQH,  NorQH,  OrQH,   XorQH, SLLQH, SRLQH,
+  AddQH,  SubQH,  MinQH,  MaxQH,
+  MulQH,  MsgnQH, SRAQH,  NULL,  NULL
+};
+
+static const OB_FUNC ob_func[] = {
+  AndOB,  NorOB,  OrOB,   XorOB, SLLOB, SRLOB,
+  AddOB,  SubOB,  MinOB,  MaxOB,
+  MulOB,  NULL,   NULL,   AbsDiffOB, AvgOB
+};
+
+/* Auxiliary functions for CPR updates.  */
+
+/* Vector mapping for QH format.  */
+static unsigned64
+qh_vector_op(unsigned64 v1, unsigned64 v2, QH_FUNC func)
+{
+  unsigned64 result = 0;
+  int  i;
+  signed16 h, h1, h2;
+
+  for (i = 0; i < 64; i += 16)
+    {
+      h1 = (signed16)(v1 & 0xFFFF);  v1 >>= 16;
+      h2 = (signed16)(v2 & 0xFFFF);  v2 >>= 16;
+      h = (*func)(h1, h2);
+      result |= ((unsigned64)((unsigned16)h) << i);
+    }
+  return result;
+}
+
+static unsigned64
+qh_map_op(unsigned64 v1, signed16 h2, QH_FUNC func)
+{
+  unsigned64 result = 0;
+  int  i;
+  signed16 h, h1;
+
+  for (i = 0; i < 64; i += 16)
+    {
+      h1 = (signed16)(v1 & 0xFFFF);  v1 >>= 16;
+      h = (*func)(h1, h2);
+      result |= ((unsigned64)((unsigned16)h) << i);
+    }
+  return result;
+}
+
+
+/* Vector operations for OB format.  */
+
+static unsigned64
+ob_vector_op(unsigned64 v1, unsigned64 v2, OB_FUNC func)
+{
+  unsigned64 result = 0;
+  int  i;
+  unsigned8 b, b1, b2;
+
+  for (i = 0; i < 64; i += 8)
+    {
+      b1 = v1 & 0xFF;  v1 >>= 8;
+      b2 = v2 & 0xFF;  v2 >>= 8;
+      b = (*func)(b1, b2);
+      result |= ((unsigned64)b << i);
+    }
+  return result;
+}
+
+static unsigned64
+ob_map_op(unsigned64 v1, unsigned8 b2, OB_FUNC func)
+{
+  unsigned64 result = 0;
+  int  i;
+  unsigned8 b, b1;
+
+  for (i = 0; i < 64; i += 8)
+    {
+      b1 = v1 & 0xFF;  v1 >>= 8;
+      b = (*func)(b1, b2);
+      result |= ((unsigned64)b << i);
+    }
+  return result;
+}
+
+
+/* Primary entry for operations that update CPRs.  */
+unsigned64
+mdmx_cpr_op(sim_cpu *cpu,
+	    address_word cia,
+	    int op,
+	    unsigned64 op1,
+	    int vt,
+	    MX_fmtsel fmtsel) 
+{
+  unsigned64 op2;
+  unsigned64 result = 0;
+
+  switch (MX_FMT (fmtsel))
+    {
+    case mdmx_qh:
+      switch (MX_VT (fmtsel))
+	{
+	case sel_elem:
+	  op2 = ValueFPR(vt, fmt_mdmx);
+	  result = qh_map_op(op1, QH_ELEM(op2, fmtsel), qh_func[op]);
+	  break;
+	case sel_vect:
+	  result = qh_vector_op(op1, ValueFPR(vt, fmt_mdmx), qh_func[op]);
+	  break;
+	case sel_imm:
+	  result = qh_map_op(op1, vt, qh_func[op]);
+	  break;
+	}
+      break;
+    case mdmx_ob:
+      switch (MX_VT (fmtsel))
+	{
+	case sel_elem:
+	  op2 = ValueFPR(vt, fmt_mdmx);
+	  result = ob_map_op(op1, OB_ELEM(op2, fmtsel), ob_func[op]);
+	  break;
+	case sel_vect:
+	  result = ob_vector_op(op1, ValueFPR(vt, fmt_mdmx), ob_func[op]);
+	  break;
+	case sel_imm:
+	  result = ob_map_op(op1, vt, ob_func[op]);
+	  break;
+	}
+      break;
+    default:
+      Unpredictable ();
+    }
+
+  return result;
+}
+
+
+/* Operations that update CCs */
+
+static void
+qh_vector_test(sim_cpu *cpu, unsigned64 v1, unsigned64 v2, int cond)
+{
+  int  i;
+  signed16 h1, h2;
+  int  boolean;
+
+  for (i = 0; i < 4; i++)
+    {
+      h1 = (signed16)(v1 & 0xFFFF);  v1 >>= 16;
+      h2 = (signed16)(v2 & 0xFFFF);  v2 >>= 16;
+      boolean = ((cond & MX_C_EQ) && (h1 == h2)) ||
+	((cond & MX_C_LT) && (h1 < h2));
+      SETFCC(i, boolean);
+    }
+}
+
+static void
+qh_map_test(sim_cpu *cpu, unsigned64 v1, signed16 h2, int cond)
+{
+  int  i;
+  signed16 h1;
+  int  boolean;
+
+  for (i = 0; i < 4; i++)
+    {
+      h1 = (signed16)(v1 & 0xFFFF);  v1 >>= 16;
+      boolean = ((cond & MX_C_EQ) && (h1 == h2)) ||
+	((cond & MX_C_LT) && (h1 < h2));
+      SETFCC(i, boolean);
+    }
+}
+
+static void
+ob_vector_test(sim_cpu *cpu, unsigned64 v1, unsigned64 v2, int cond)
+{
+  int  i;
+  unsigned8 b1, b2;
+  int  boolean;
+
+  for (i = 0; i < 8; i++)
+    {
+      b1 = v1 & 0xFF;  v1 >>= 8;
+      b2 = v2 & 0xFF;  v2 >>= 8;
+      boolean = ((cond & MX_C_EQ) && (b1 == b2)) ||
+	((cond & MX_C_LT) && (b1 < b2));
+      SETFCC(i, boolean);
+    }
+}
+
+static void
+ob_map_test(sim_cpu *cpu, unsigned64 v1, unsigned8 b2, int cond)
+{
+  int  i;
+  unsigned8 b1;
+  int  boolean;
+
+  for (i = 0; i < 8; i++)
+    {
+      b1 = (unsigned8)(v1 & 0xFF);  v1 >>= 8;
+      boolean = ((cond & MX_C_EQ) && (b1 == b2)) ||
+	((cond & MX_C_LT) && (b1 < b2));
+      SETFCC(i, boolean);
+    }
+}
+
+
+void
+mdmx_cc_op(sim_cpu *cpu,
+	   address_word cia,
+	   int cond,
+	   unsigned64 v1,
+	   int vt,
+	   MX_fmtsel fmtsel)
+{
+  unsigned64 op2;
+
+  switch (MX_FMT (fmtsel))
+    {
+    case mdmx_qh:
+      switch (MX_VT (fmtsel))
+	{
+	case sel_elem:
+	  op2 = ValueFPR(vt, fmt_mdmx);
+	  qh_map_test(cpu, v1, QH_ELEM(op2, fmtsel), cond);
+	  break;
+	case sel_vect:
+	  qh_vector_test(cpu, v1, ValueFPR(vt, fmt_mdmx), cond);
+	  break;
+	case sel_imm:
+	  qh_map_test(cpu, v1, vt, cond);
+	  break;
+	}
+      break;
+    case mdmx_ob:
+      switch (MX_VT (fmtsel))
+	{
+	case sel_elem:
+	  op2 = ValueFPR(vt, fmt_mdmx);
+	  ob_map_test(cpu, v1, OB_ELEM(op2, fmtsel), cond);
+	  break;
+	case sel_vect:
+	  ob_vector_test(cpu, v1, ValueFPR(vt, fmt_mdmx), cond);
+	  break;
+	case sel_imm:
+	  ob_map_test(cpu, v1, vt, cond);
+	  break;
+	}
+      break;
+    default:
+      Unpredictable ();
+    }
+}
+
+
+/* Pick operations.  */
+
+static unsigned64
+qh_vector_pick(sim_cpu *cpu, unsigned64 v1, unsigned64 v2, int tf)
+{
+  unsigned64 result = 0;
+  int  i, s;
+  unsigned16 h;
+
+  s = 0;
+  for (i = 0; i < 4; i++)
+    {
+      h = ((GETFCC(i) == tf) ? (v1 & 0xFFFF) : (v2 & 0xFFFF));
+      v1 >>= 16;  v2 >>= 16;
+      result |= ((unsigned64)h << s);
+      s += 16;
+    }
+  return result;
+}
+
+static unsigned64
+qh_map_pick(sim_cpu *cpu, unsigned64 v1, signed16 h2, int tf)
+{
+  unsigned64 result = 0;
+  int  i, s;
+  unsigned16 h;
+
+  s = 0;
+  for (i = 0; i < 4; i++)
+    {
+      h = (GETFCC(i) == tf) ? (v1 & 0xFFFF) : (unsigned16)h2;
+      v1 >>= 16;
+      result |= ((unsigned64)h << s);
+      s += 16;
+    }
+  return result;
+}
+
+static unsigned64
+ob_vector_pick(sim_cpu *cpu, unsigned64 v1, unsigned64 v2, int tf)
+{
+  unsigned64 result = 0;
+  int  i, s;
+  unsigned8 b;
+
+  s = 0;
+  for (i = 0; i < 8; i++)
+    {
+      b = (GETFCC(i) == tf) ? (v1 & 0xFF) : (v2 & 0xFF);
+      v1 >>= 8;  v2 >>= 8;
+      result |= ((unsigned64)b << s);
+      s += 8;
+    }
+  return result;
+}
+
+static unsigned64
+ob_map_pick(sim_cpu *cpu, unsigned64 v1, unsigned8 b2, int tf)
+{
+  unsigned64 result = 0;
+  int  i, s;
+  unsigned8 b;
+
+  s = 0;
+  for (i = 0; i < 8; i++)
+    {
+      b = (GETFCC(i) == tf) ? (v1 & 0xFF) : b2;
+      v1 >>= 8;
+      result |= ((unsigned64)b << s);
+      s += 8;
+    }
+  return result;
+}
+
+
+unsigned64
+mdmx_pick_op(sim_cpu *cpu,
+	     address_word cia,
+	     int tf,
+	     unsigned64 v1,
+	     int vt,
+	     MX_fmtsel fmtsel)
+{
+  unsigned64 result = 0;
+  unsigned64 op2;
+
+  switch (MX_FMT (fmtsel))
+    {
+    case mdmx_qh:
+      switch (MX_VT (fmtsel))
+	{
+	case sel_elem:
+	  op2 = ValueFPR(vt, fmt_mdmx);
+	  result = qh_map_pick(cpu, v1, QH_ELEM(op2, fmtsel), tf);
+	  break;
+	case sel_vect:
+	  result = qh_vector_pick(cpu, v1, ValueFPR(vt, fmt_mdmx), tf);
+	  break;
+	case sel_imm:
+	  result = qh_map_pick(cpu, v1, vt, tf);
+	  break;
+	}
+      break;
+    case mdmx_ob:
+      switch (MX_VT (fmtsel))
+	{
+	case sel_elem:
+	  op2 = ValueFPR(vt, fmt_mdmx);
+	  result = ob_map_pick(cpu, v1, OB_ELEM(op2, fmtsel), tf);
+	  break;
+	case sel_vect:
+	  result = ob_vector_pick(cpu, v1, ValueFPR(vt, fmt_mdmx), tf);
+	  break;
+	case sel_imm:
+	  result = ob_map_pick(cpu, v1, vt, tf);
+	  break;
+	}
+      break;
+    default:
+      Unpredictable ();
+    }
+  return result;
+}
+
+
+/* Accumulators.  */
+
+typedef void (*QH_ACC)(signed48 *a, signed16 ts, signed16 tt);
+
+static void
+AccAddAQH(signed48 *a, signed16 ts, signed16 tt)
+{
+  *a += (signed48)ts + (signed48)tt;
+}
+
+static void
+AccAddLQH(signed48 *a, signed16 ts, signed16 tt)
+{
+  *a = (signed48)ts + (signed48)tt;
+}
+
+static void
+AccMulAQH(signed48 *a, signed16 ts, signed16 tt)
+{
+  *a += (signed48)ts * (signed48)tt;
+}
+
+static void
+AccMulLQH(signed48 *a, signed16 ts, signed16 tt)
+{
+  *a = (signed48)ts * (signed48)tt;
+}
+
+static void
+SubMulAQH(signed48 *a, signed16 ts, signed16 tt)
+{
+  *a -= (signed48)ts * (signed48)tt;
+}
+
+static void
+SubMulLQH(signed48 *a, signed16 ts, signed16 tt)
+{
+  *a = -((signed48)ts * (signed48)tt);
+}
+
+static void
+AccSubAQH(signed48 *a, signed16 ts, signed16 tt)
+{
+  *a += (signed48)ts - (signed48)tt;
+}
+
+static void
+AccSubLQH(signed48 *a, signed16 ts, signed16 tt)
+{
+  *a =  (signed48)ts - (signed48)tt;
+}
+
+
+typedef void (*OB_ACC)(signed24 *acc, unsigned8 ts, unsigned8 tt);
+
+static void
+AccAddAOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+{
+  *a += (signed24)ts + (signed24)tt;
+}
+
+static void
+AccAddLOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+{
+  *a = (signed24)ts + (signed24)tt;
+}
+
+static void
+AccMulAOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+{
+  *a += (signed24)ts * (signed24)tt;
+}
+
+static void
+AccMulLOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+{
+  *a = (signed24)ts * (signed24)tt;
+}
+
+static void
+SubMulAOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+{
+  *a -= (signed24)ts * (signed24)tt;
+}
+
+static void
+SubMulLOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+{
+  *a = -((signed24)ts * (signed24)tt);
+}
+
+static void
+AccSubAOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+{
+  *a += (signed24)ts - (signed24)tt;
+}
+
+static void
+AccSubLOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+{
+  *a = (signed24)ts - (signed24)tt;
+}
+
+static void
+AccAbsDiffOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+{
+  unsigned8 t = (ts >= tt ? ts - tt : tt - ts);
+  *a += (signed24)t;
+}
+
+
+/* Dispatch tables for operations that update a CPR.  */
+
+static const QH_ACC qh_acc[] = {
+  AccAddAQH, AccAddAQH, AccMulAQH, AccMulLQH,
+  SubMulAQH, SubMulLQH, AccSubAQH, AccSubLQH,
+  NULL
+};
+
+static const OB_ACC ob_acc[] = {
+  AccAddAOB, AccAddLOB, AccMulAOB, AccMulLOB,
+  SubMulAOB, SubMulLOB, AccSubAOB, AccSubLOB,
+  AccAbsDiffOB
+};
+
+
+static void
+qh_vector_acc(signed48 a[], unsigned64 v1, unsigned64 v2, QH_ACC acc)
+{
+  int  i;
+  signed16 h1, h2;
+
+  for (i = 0; i < 4; i++)
+    {
+      h1 = (signed16)(v1 & 0xFFFF);  v1 >>= 16;
+      h2 = (signed16)(v2 & 0xFFFF);  v2 >>= 16;
+      (*acc)(&a[i], h1, h2);
+    }
+}
+
+static void
+qh_map_acc(signed48 a[], unsigned64 v1, signed16 h2, QH_ACC acc)
+{
+  int  i;
+  signed16 h1;
+
+  for (i = 0; i < 4; i++)
+    {
+      h1 = (signed16)(v1 & 0xFFFF);  v1 >>= 16;
+      (*acc)(&a[i], h1, h2);
+    }
+}
+
+static void
+ob_vector_acc(signed24 a[], unsigned64 v1, unsigned64 v2, OB_ACC acc)
+{
+  int  i;
+  unsigned8  b1, b2;
+
+  for (i = 0; i < 8; i++)
+    {
+      b1 = v1 & 0xFF;  v1 >>= 8;
+      b2 = v2 & 0xFF;  v2 >>= 8;
+      (*acc)(&a[i], b1, b2);
+    }
+}
+
+static void
+ob_map_acc(signed24 a[], unsigned64 v1, unsigned8 b2, OB_ACC acc)
+{
+  int  i;
+  unsigned8 b1;
+
+  for (i = 0; i < 8; i++)
+    {
+      b1 = v1 & 0xFF;  v1 >>= 8;
+      (*acc)(&a[i], b1, b2);
+    }
+}
+
+
+/* Primary entry for operations that accumulate */
+void
+mdmx_acc_op(sim_cpu *cpu,
+	    address_word cia,
+	    int op,
+	    unsigned64 op1,
+	    int vt,
+	    MX_fmtsel fmtsel) 
+{
+  unsigned64 op2;
+
+  switch (MX_FMT (fmtsel))
+    {
+    case mdmx_qh:
+      switch (MX_VT (fmtsel))
+	{
+	case sel_elem:
+	  op2 = ValueFPR(vt, fmt_mdmx);
+	  qh_map_acc(ACC.qh, op1, QH_ELEM(op2, fmtsel), qh_acc[op]);
+	  break;
+	case sel_vect:
+	  qh_vector_acc(ACC.qh, op1, ValueFPR(vt, fmt_mdmx), qh_acc[op]);
+	  break;
+	case sel_imm:
+	  qh_map_acc(ACC.qh, op1, vt, qh_acc[op]);
+	  break;
+	}
+      break;
+    case mdmx_ob:
+      switch (MX_VT (fmtsel))
+	{
+	case sel_elem:
+	  op2 = ValueFPR(vt, fmt_mdmx);
+	  ob_map_acc(ACC.ob, op1, OB_ELEM(op2, fmtsel), ob_acc[op]);
+	  break;
+	case sel_vect:
+	  ob_vector_acc(ACC.ob, op1, ValueFPR(vt, fmt_mdmx), ob_acc[op]);
+	  break;
+	case sel_imm:
+	  ob_map_acc(ACC.ob, op1, vt, ob_acc[op]);
+	  break;
+	}
+      break;
+    default:
+      Unpredictable ();
+    }
+}
+
+
+/* Reading and writing accumulator (no conversion).  */
+
+unsigned64
+mdmx_rac_op(sim_cpu *cpu,
+	    address_word cia,
+	    int op,
+	    int fmt) 
+{
+  unsigned64    result;
+  unsigned int  shift;
+  int           i;
+
+  shift = op;          /* L = 00, M = 01, H = 10.  */
+  result = 0;
+
+  switch (fmt)
+    {
+    case MX_FMT_QH:
+      shift <<= 4;              /* 16 bits per element.  */
+      for (i = 3; i >= 0; --i)
+	{
+	  result <<= 16;
+	  result |= ((ACC.qh[i] >> shift) & 0xFFFF);
+	}
+      break;
+    case MX_FMT_OB:
+      shift <<= 3;              /*  8 bits per element.  */
+      for (i = 7; i >= 0; --i)
+	{
+	  result <<= 8;
+	  result |= ((ACC.ob[i] >> shift) & 0xFF);
+	}
+      break;
+    default:
+      Unpredictable ();
+    }
+  return result;
+}
+
+void
+mdmx_wacl(sim_cpu *cpu,
+	  address_word cia,
+	  int fmt,
+	  unsigned64 vs,
+	  unsigned64 vt) 
+{
+  int           i;
+
+  switch (fmt)
+    {
+    case MX_FMT_QH:
+      for (i = 0; i < 4; i++)
+	{
+	  signed32  s = (signed16)(vs & 0xFFFF);
+	  ACC.qh[i] = ((signed48)s << 16) | (vt & 0xFFFF);
+	  vs >>= 16;  vt >>= 16;
+	}
+      break;
+    case MX_FMT_OB:
+      for (i = 0; i < 8; i++)
+	{
+	  signed16  s = (signed8)(vs & 0xFF);
+	  ACC.ob[i] = ((signed24)s << 8) | (vt & 0xFF);
+	  vs >>= 8;   vt >>= 8;
+	}
+      break;
+    default:
+      Unpredictable ();
+    }
+}
+
+void
+mdmx_wach(sim_cpu *cpu,
+	  address_word cia,
+	  int fmt,
+	  unsigned64 vs)
+{
+  int           i;
+
+  switch (fmt)
+    {
+    case MX_FMT_QH:
+      for (i = 0; i < 4; i++)
+	{
+	  signed32  s = (signed16)(vs & 0xFFFF);
+	  ACC.qh[i] &= ~((signed48)0xFFFF << 32);
+	  ACC.qh[i] |=  ((signed48)s << 32);
+	  vs >>= 16;
+	}
+      break;
+    case MX_FMT_OB:
+      for (i = 0; i < 8; i++)
+	{
+	  ACC.ob[i] &= ~((signed24)0xFF << 16);
+	  ACC.ob[i] |=  ((signed24)(vs & 0xFF) << 16);
+	  vs >>= 8;
+	}
+      break;
+    default:
+      Unpredictable ();
+    }
+}
+
+
+/* Reading and writing accumulator (rounding conversions).
+   Enumerating function guarantees s >= 0 for QH ops.  */
+
+typedef signed16 (*QH_ROUND)(signed48 a, signed16 s);
+
+#define QH_BIT(n)  ((unsigned48)1 << (n))
+#define QH_ONES(n) (((unsigned48)1 << (n))-1)
+
+static signed16
+RNASQH(signed48 a, signed16 s)
+{
+  signed48 t;
+  signed16 result = 0;
+
+  if (s > 48)
+    result = 0;
+  else
+    {
+      t = (a >> s);
+      if ((a & QH_BIT(47)) == 0)
+	{
+	  if (s > 0 && ((a >> (s-1)) & 1) == 1)
+	    t++;
+	  if (t > QH_MAX)
+	    t = QH_MAX;
+	}
+      else
+	{
+	  if (s > 0 && ((a >> (s-1)) & 1) == 1)
+	    {
+	      if (s > 1 && ((unsigned48)a & QH_ONES(s-1)) != 0)
+		t++;
+	    }
+	  if (t < QH_MIN)
+	    t = QH_MIN;
+	}
+      result = (signed16)t;
+    }
+  return result;
+}
+
+static signed16
+RNAUQH(signed48 a, signed16 s)
+{
+  unsigned48 t;
+  signed16 result;
+
+  if (s > 48)
+    result = 0;
+  else if (s == 48)
+    result = ((unsigned48)a & MASK48) >> 47;
+  else
+    {
+      t = ((unsigned48)a & MASK48) >> s;
+      if (s > 0 && ((a >> (s-1)) & 1) == 1)
+	t++;
+      if (t > 0xFFFF)
+	t = 0xFFFF;
+      result = (signed16)t;
+    }
+  return result;
+}
+
+static signed16
+RNESQH(signed48 a, signed16 s)
+{
+  signed48 t;
+  signed16 result = 0;
+
+  if (s > 47)
+    result = 0;
+  else
+    {
+      t = (a >> s);
+      if (s > 0 && ((a >> (s-1)) & 1) == 1)
+	{
+	  if (s == 1 || (a & QH_ONES(s-1)) == 0)
+	    t += t & 1;
+	  else
+	    t += 1;
+	}
+      if ((a & QH_BIT(47)) == 0)
+	{
+	  if (t > QH_MAX)
+	    t = QH_MAX;
+	}
+      else
+	{
+	  if (t < QH_MIN)
+	    t = QH_MIN;
+	}
+      result = (signed16)t;
+    }
+  return result;
+}
+
+static signed16
+RNEUQH(signed48 a, signed16 s)
+{
+  unsigned48 t;
+  signed16 result;
+
+  if (s > 48)
+    result = 0;
+  else if (s == 48)
+    result = ((unsigned48)a > QH_BIT(47) ? 1 : 0);
+  else
+    {
+      t = ((unsigned48)a & MASK48) >> s;
+      if (s > 0 && ((a >> (s-1)) & 1) == 1)
+	{
+	  if (s > 1 && (a & QH_ONES(s-1)) != 0)
+	    t++;
+	  else
+	    t += t & 1;
+	}
+      if (t > 0xFFFF)
+	t = 0xFFFF;
+      result = (signed16)t;
+    }
+  return result;
+}
+
+static signed16
+RZSQH(signed48 a, signed16 s)
+{
+  signed48 t;
+  signed16 result = 0;
+
+  if (s > 47)
+    result = 0;
+  else
+    {
+      t = (a >> s);
+      if ((a & QH_BIT(47)) == 0)
+	{
+	  if (t > QH_MAX)
+	    t = QH_MAX;
+	}
+      else
+	{
+	  if (t < QH_MIN)
+	    t = QH_MIN;
+	}
+      result = (signed16)t;
+    }
+  return result;
+}
+
+static signed16
+RZUQH(signed48 a, signed16 s)
+{
+  unsigned48 t;
+  signed16 result = 0;
+
+  if (s > 48)
+    result = 0;
+  else if (s == 48)
+    result = ((unsigned48)a > QH_BIT(47) ? 1 : 0);
+  else
+    {
+      t = ((unsigned48)a & MASK48) >> s;
+      if (t > 0xFFFF)
+	t = 0xFFFF;
+      result = (signed16)t;
+    }
+  return result;
+}
+
+
+typedef unsigned8 (*OB_ROUND)(signed24 a, unsigned8 s);
+
+#define OB_BIT(n)  ((unsigned24)1 << (n))
+#define OB_ONES(n) (((unsigned24)1 << (n))-1)
+
+static unsigned8
+RNAUOB(signed24 a, unsigned8 s)
+{
+  unsigned8 result;
+  unsigned24 t;
+
+  if (s > 24)
+    result = 0;
+  else if (s == 24)
+    result = ((unsigned24)a & MASK24) >> 23;
+  else
+    {
+      t = ((unsigned24)a & MASK24) >> s;
+      if (s > 0 && ((a >> (s-1)) & 1) == 1)
+	t ++;
+      result = OB_CLAMP(t);
+    }
+  return result;
+}
+
+static unsigned8
+RNEUOB(signed24 a, unsigned8 s)
+{
+  unsigned8 result;
+  unsigned24 t;
+
+  if (s > 24)
+    result = 0;
+  else if (s == 24)
+    result = (((unsigned24)a & MASK24) > OB_BIT(23) ? 1 : 0);
+  else
+    {
+      t = ((unsigned24)a & MASK24) >> s;
+      if (s > 0 && ((a >> (s-1)) & 1) == 1)
+	{
+	  if (s > 1 && (a & OB_ONES(s-1)) != 0)
+	    t++;
+	  else
+	    t += t & 1;
+	}
+      result = OB_CLAMP(t);
+    }
+  return result;
+}
+
+static unsigned8
+RZUOB(signed24 a, unsigned8 s)
+{
+  unsigned8 result;
+  unsigned24 t;
+
+  if (s >= 24)
+    result = 0;
+  else
+    {
+      t = ((unsigned24)a & MASK24) >> s;
+      result = OB_CLAMP(t);
+    }
+  return result;
+}
+
+
+static const QH_ROUND qh_round[] = {
+  RNASQH, RNAUQH, RNESQH, RNEUQH, RZSQH,  RZUQH
+};
+
+static const OB_ROUND ob_round[] = {
+  NULL,   RNAUOB, NULL,   RNEUOB, NULL,   RZUOB
+};
+
+
+static unsigned64
+qh_vector_round(sim_cpu *cpu, address_word cia, unsigned64 v2, QH_ROUND round)
+{
+  unsigned64 result = 0;
+  int  i, s;
+  signed16 h, h2;
+
+  s = 0;
+  for (i = 0; i < 4; i++)
+    {
+      h2 = (signed16)(v2 & 0xFFFF);
+      if (h2 >= 0)
+	h = (*round)(ACC.qh[i], h2);
+      else
+	{
+	  UnpredictableResult ();
+	  h = 0xdead;
+	}
+      v2 >>= 16;
+      result |= ((unsigned64)((unsigned16)h) << s);
+      s += 16;
+    }
+  return result;
+}
+
+static unsigned64
+qh_map_round(sim_cpu *cpu, address_word cia, signed16 h2, QH_ROUND round)
+{
+  unsigned64 result = 0;
+  int  i, s;
+  signed16  h;
+
+  s = 0;
+  for (i = 0; i < 4; i++)
+    {
+      if (h2 >= 0)
+	h = (*round)(ACC.qh[i], h2);
+      else
+	{
+	  UnpredictableResult ();
+	  h = 0xdead;
+	}
+      result |= ((unsigned64)((unsigned16)h) << s);
+      s += 16;
+    }
+  return result;
+}
+
+static unsigned64
+ob_vector_round(sim_cpu *cpu, address_word cia, unsigned64 v2, OB_ROUND round)
+{
+  unsigned64 result = 0;
+  int  i, s;
+  unsigned8 b, b2;
+
+  s = 0;
+  for (i = 0; i < 8; i++)
+    {
+      b2 = v2 & 0xFF;  v2 >>= 8;
+      b = (*round)(ACC.ob[i], b2);
+      result |= ((unsigned64)b << s);
+      s += 8;
+    }
+  return result;
+}
+
+static unsigned64
+ob_map_round(sim_cpu *cpu, address_word cia, unsigned8 b2, OB_ROUND round)
+{
+  unsigned64 result = 0;
+  int  i, s;
+  unsigned8 b;
+
+  s = 0;
+  for (i = 0; i < 8; i++)
+    {
+      b = (*round)(ACC.ob[i], b2);
+      result |= ((unsigned64)b << s);
+      s += 8;
+    }
+  return result;
+}
+
+
+unsigned64
+mdmx_round_op(sim_cpu *cpu,
+	      address_word cia,
+	      int rm,
+	      int vt,
+	      MX_fmtsel fmtsel) 
+{
+  unsigned64 op2;
+  unsigned64 result = 0;
+
+  switch (MX_FMT (fmtsel))
+    {
+    case mdmx_qh:
+      switch (MX_VT (fmtsel))
+	{
+	case sel_elem:
+	  op2 = ValueFPR(vt, fmt_mdmx);
+	  result = qh_map_round(cpu, cia, QH_ELEM(op2, fmtsel), qh_round[rm]);
+	  break;
+	case sel_vect:
+	  op2 = ValueFPR(vt, fmt_mdmx);
+	  result = qh_vector_round(cpu, cia, op2, qh_round[rm]);
+	  break;
+	case sel_imm:
+	  result = qh_map_round(cpu, cia, vt, qh_round[rm]);
+	  break;
+	}
+      break;
+    case mdmx_ob:
+      switch (MX_VT (fmtsel))
+	{
+	case sel_elem:
+	  op2 = ValueFPR(vt, fmt_mdmx);
+	  result = ob_map_round(cpu, cia, OB_ELEM(op2, fmtsel), ob_round[rm]);
+	  break;
+	case sel_vect:
+	  op2 = ValueFPR(vt, fmt_mdmx);
+	  result = ob_vector_round(cpu, cia, op2, ob_round[rm]);
+	  break;
+	case sel_imm:
+	  result = ob_map_round(cpu, cia, vt, ob_round[rm]);
+	  break;
+	}
+      break;
+    default:
+      Unpredictable ();
+    }
+
+  return result;
+}
+
+
+/* Shuffle operation.  */
+
+typedef struct {
+  enum {vs, ss, vt} source;
+  unsigned int      index;
+} sh_map;
+
+static const sh_map ob_shuffle[][8] = {
+  /* MDMX 2.0 encodings (3-4, 6-7).  */
+  /* vr5400   encoding  (5), otherwise.  */
+  {                                                              }, /* RSVD */
+  {{vt,4}, {vs,4}, {vt,5}, {vs,5}, {vt,6}, {vs,6}, {vt,7}, {vs,7}}, /* RSVD */
+  {{vt,0}, {vs,0}, {vt,1}, {vs,1}, {vt,2}, {vs,2}, {vt,3}, {vs,3}}, /* RSVD */
+  {{vs,0}, {ss,0}, {vs,1}, {ss,1}, {vs,2}, {ss,2}, {vs,3}, {ss,3}}, /* upsl */
+  {{vt,1}, {vt,3}, {vt,5}, {vt,7}, {vs,1}, {vs,3}, {vs,5}, {vs,7}}, /* pach */
+  {{vt,0}, {vt,2}, {vt,4}, {vt,6}, {vs,0}, {vs,2}, {vs,4}, {vs,6}}, /* pacl */
+  {{vt,4}, {vs,4}, {vt,5}, {vs,5}, {vt,6}, {vs,6}, {vt,7}, {vs,7}}, /* mixh */
+  {{vt,0}, {vs,0}, {vt,1}, {vs,1}, {vt,2}, {vs,2}, {vt,3}, {vs,3}}  /* mixl */
+};
+
+static const sh_map qh_shuffle[][4] = {
+  {{vt,2}, {vs,2}, {vt,3}, {vs,3}},  /* mixh */
+  {{vt,0}, {vs,0}, {vt,1}, {vs,1}},  /* mixl */
+  {{vt,1}, {vt,3}, {vs,1}, {vs,3}},  /* pach */
+  {                              },  /* RSVD */
+  {{vt,1}, {vs,0}, {vt,3}, {vs,2}},  /* bfla */
+  {                              },  /* RSVD */
+  {{vt,2}, {vt,3}, {vs,2}, {vs,3}},  /* repa */
+  {{vt,0}, {vt,1}, {vs,0}, {vs,1}}   /* repb */
+};
+
+
+unsigned64
+mdmx_shuffle(sim_cpu *cpu,
+	     address_word cia,
+	     int shop,
+	     unsigned64 op1,
+	     unsigned64 op2)
+{
+  unsigned64 result = 0;
+  int  i, s;
+  int  op;
+
+  if ((shop & 0x3) == 0x1)       /* QH format.  */
+    {
+      op = shop >> 2;
+      s = 0;
+      for (i = 0; i < 4; i++)
+	{
+	  unsigned64 v;
+
+	  switch (qh_shuffle[op][i].source)
+	    {
+	    case vs:
+	      v = op1;
+	      break;
+	    case vt:
+	      v = op2;
+	      break;
+	    default:
+	      Unpredictable ();
+	      v = 0;
+	    }
+	  result |= (((v >> 16*qh_shuffle[op][i].index) & 0xFFFF) << s);
+	  s += 16;
+	}
+    }
+  else if ((shop & 0x1) == 0x0)  /* OB format.  */
+    {
+      op = shop >> 1;
+      s = 0;
+      for (i = 0; i < 8; i++)
+	{
+	  unsigned8 b;
+	  unsigned int ishift = 8*ob_shuffle[op][i].index;
+
+	  switch (ob_shuffle[op][i].source)
+	    {
+	    case vs:
+	      b = (op1 >> ishift) & 0xFF;
+	      break;
+	    case ss:
+	      b = ((op1 >> ishift) & 0x80) ? 0xFF : 0;
+	      break;
+	    case vt:
+	      b = (op2 >> ishift) & 0xFF;
+	      break;
+	    default:
+	      Unpredictable ();
+	      b = 0;
+	    }
+	  result |= ((unsigned64)b << s);
+	  s += 8;
+	}
+    }
+  else
+    Unpredictable ();
+
+  return result;
+}