From: Felix Fietkau Date: Fri, 21 Aug 2009 22:31:47 +0000 (+0000) Subject: add a heavily cleaned up version of ubicom32 toolchain support X-Git-Url: http://git.lede-project.org./?a=commitdiff_plain;h=aee9d6c31c1c72ab0831d88cd51fa4d76c364fc4;p=openwrt%2Fstaging%2Fynezz.git add a heavily cleaned up version of ubicom32 toolchain support SVN-Revision: 17346 --- diff --git a/scripts/config.sub b/scripts/config.sub index c060f44833..139347a381 100755 --- a/scripts/config.sub +++ b/scripts/config.sub @@ -284,6 +284,7 @@ case $basic_machine in | spu | strongarm \ | tahoe | thumb | tic4x | tic80 | tron \ | v850 | v850e \ + | ubicom32 \ | we32k \ | x86 | xc16x | xscale | xscalee[bl] | xstormy16 | xtensa \ | z8k) @@ -367,6 +368,7 @@ case $basic_machine in | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ | tron-* \ | v850-* | v850e-* | vax-* \ + | ubicom32-* \ | we32k-* \ | x86-* | x86_64-* | xc16x-* | xps100-* | xscale-* | xscalee[bl]-* \ | xstormy16-* | xtensa-* \ diff --git a/target/Config.in b/target/Config.in index ffd81d3f6c..0d597e69b1 100644 --- a/target/Config.in +++ b/target/Config.in @@ -124,6 +124,10 @@ config sparc config x86_64 bool +config ubicom32 + select BIG_ENDIAN + bool + config ARCH string default "arm" if arm @@ -144,4 +148,5 @@ config ARCH default "sh4eb" if sh4eb default "sparc" if sparc default "x86_64" if x86_64 + default "ubicom32" if ubicom32 diff --git a/toolchain/binutils/patches/2.19.1/600-ubicom32_binutils_20090818.patch b/toolchain/binutils/patches/2.19.1/600-ubicom32_binutils_20090818.patch new file mode 100644 index 0000000000..f95c05dca0 --- /dev/null +++ b/toolchain/binutils/patches/2.19.1/600-ubicom32_binutils_20090818.patch @@ -0,0 +1,48967 @@ +--- a/bfd/archures.c ++++ b/bfd/archures.c +@@ -375,6 +375,11 @@ DESCRIPTION + . bfd_arch_score, {* Sunplus score *} + . bfd_arch_openrisc, {* OpenRISC *} + . bfd_arch_mmix, {* Donald Knuth's educational processor. *} ++. bfd_arch_ubicom32, ++.#define bfd_mach_ubicom32 0 ++.#define bfd_mach_ubicom32dsp 1 ++.#define bfd_mach_ubicom32ver4 2 ++.#define bfd_mach_ubicom32posix 3 + . bfd_arch_xstormy16, + .#define bfd_mach_xstormy16 1 + . bfd_arch_msp430, {* Texas Instruments MSP430 architecture. *} +@@ -501,6 +506,7 @@ extern const bfd_arch_info_type bfd_tic3 + extern const bfd_arch_info_type bfd_tic4x_arch; + extern const bfd_arch_info_type bfd_tic54x_arch; + extern const bfd_arch_info_type bfd_tic80_arch; ++extern const bfd_arch_info_type bfd_ubicom32_arch; + extern const bfd_arch_info_type bfd_v850_arch; + extern const bfd_arch_info_type bfd_vax_arch; + extern const bfd_arch_info_type bfd_we32k_arch; +@@ -570,6 +576,7 @@ static const bfd_arch_info_type * const + &bfd_tic4x_arch, + &bfd_tic54x_arch, + &bfd_tic80_arch, ++ &bfd_ubicom32_arch, + &bfd_v850_arch, + &bfd_vax_arch, + &bfd_w65_arch, +--- a/bfd/bfd-in2.h ++++ b/bfd/bfd-in2.h +@@ -1997,6 +1997,11 @@ enum bfd_architecture + bfd_arch_score, /* Sunplus score */ + bfd_arch_openrisc, /* OpenRISC */ + bfd_arch_mmix, /* Donald Knuth's educational processor. */ ++ bfd_arch_ubicom32, ++#define bfd_mach_ubicom32 0 ++#define bfd_mach_ubicom32dsp 1 ++#define bfd_mach_ubicom32ver4 2 ++#define bfd_mach_ubicom32posix 3 + bfd_arch_xstormy16, + #define bfd_mach_xstormy16 1 + bfd_arch_msp430, /* Texas Instruments MSP430 architecture. */ +@@ -3908,6 +3913,41 @@ instructions */ + BFD_RELOC_VPE4KMATH_DATA, + BFD_RELOC_VPE4KMATH_INSN, + ++/* Ubicom UBICOM32 Relocations. */ ++ BFD_RELOC_UBICOM32_21_PCREL, ++ BFD_RELOC_UBICOM32_24_PCREL, ++ BFD_RELOC_UBICOM32_HI24, ++ BFD_RELOC_UBICOM32_LO7_S, ++ BFD_RELOC_UBICOM32_LO7_2_S, ++ BFD_RELOC_UBICOM32_LO7_4_S, ++ BFD_RELOC_UBICOM32_LO7_D, ++ BFD_RELOC_UBICOM32_LO7_2_D, ++ BFD_RELOC_UBICOM32_LO7_4_D, ++ BFD_RELOC_UBICOM32_LO7_CALLI, ++ BFD_RELOC_UBICOM32_LO16_CALLI, ++ BFD_RELOC_UBICOM32_GOT_HI24, ++ BFD_RELOC_UBICOM32_GOT_LO7_S, ++ BFD_RELOC_UBICOM32_GOT_LO7_2_S, ++ BFD_RELOC_UBICOM32_GOT_LO7_4_S, ++ BFD_RELOC_UBICOM32_GOT_LO7_D, ++ BFD_RELOC_UBICOM32_GOT_LO7_2_D, ++ BFD_RELOC_UBICOM32_GOT_LO7_4_D, ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_HI24, ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_S, ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_2_S, ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_4_S, ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_D, ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_2_D, ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_4_D, ++ BFD_RELOC_UBICOM32_GOT_LO7_CALLI, ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_CALLI, ++ BFD_RELOC_UBICOM32_FUNCDESC_VALUE, ++ BFD_RELOC_UBICOM32_FUNCDESC, ++ BFD_RELOC_UBICOM32_GOTOFFSET_LO, ++ BFD_RELOC_UBICOM32_GOTOFFSET_HI, ++ BFD_RELOC_UBICOM32_FUNCDESC_GOTOFFSET_LO, ++ BFD_RELOC_UBICOM32_FUNCDESC_GOTOFFSET_HI, ++ + /* These two relocations are used by the linker to determine which of + the entries in a C++ virtual function table are actually used. When + the --gc-sections option is given, the linker will zero out the entries +--- a/bfd/config.bfd ++++ b/bfd/config.bfd +@@ -1432,6 +1432,11 @@ case "${targ}" in + targ_underscore=yes + ;; + ++ ubicom32-*-*) ++ targ_defvec=bfd_elf32_ubicom32_vec ++ targ_selvecs=bfd_elf32_ubicom32fdpic_vec ++ ;; ++ + v850-*-*) + targ_defvec=bfd_elf32_v850_vec + ;; +--- a/bfd/configure ++++ b/bfd/configure +@@ -19743,6 +19743,8 @@ do + bfd_elf32_tradbigmips_vec) tb="$tb elf32-mips.lo elfxx-mips.lo elf-vxworks.lo elf32.lo $elf ecofflink.lo" ;; + bfd_elf32_tradlittlemips_vec) tb="$tb elf32-mips.lo elfxx-mips.lo elf-vxworks.lo elf32.lo $elf ecofflink.lo" ;; + bfd_elf32_us_cris_vec) tb="$tb elf32-cris.lo elf32.lo $elf" ;; ++ bfd_elf32_ubicom32_vec) tb="$tb elf32-ubicom32.lo elf32.lo $elf" ;; ++ bfd_elf32_ubicom32fdpic_vec) tb="$tb elf32-ubicom32.lo elf32.lo $elf" ;; + bfd_elf32_v850_vec) tb="$tb elf32-v850.lo elf32.lo $elf" ;; + bfd_elf32_vax_vec) tb="$tb elf32-vax.lo elf32.lo $elf" ;; + bfd_elf32_xstormy16_vec) tb="$tb elf32-xstormy16.lo elf32.lo $elf" ;; +--- a/bfd/configure.in ++++ b/bfd/configure.in +@@ -736,6 +736,8 @@ do + bfd_elf32_tradbigmips_vec) tb="$tb elf32-mips.lo elfxx-mips.lo elf-vxworks.lo elf32.lo $elf ecofflink.lo" ;; + bfd_elf32_tradlittlemips_vec) tb="$tb elf32-mips.lo elfxx-mips.lo elf-vxworks.lo elf32.lo $elf ecofflink.lo" ;; + bfd_elf32_us_cris_vec) tb="$tb elf32-cris.lo elf32.lo $elf" ;; ++ bfd_elf32_ubicom32_vec) tb="$tb elf32-ubicom32.lo elf32.lo $elf" ;; ++ bfd_elf32_ubicom32fdpic_vec) tb="$tb elf32-ubicom32.lo elf32.lo $elf" ;; + bfd_elf32_v850_vec) tb="$tb elf32-v850.lo elf32.lo $elf" ;; + bfd_elf32_vax_vec) tb="$tb elf32-vax.lo elf32.lo $elf" ;; + bfd_elf32_xstormy16_vec) tb="$tb elf32-xstormy16.lo elf32.lo $elf" ;; +--- /dev/null ++++ b/bfd/cpu-ubicom32.c +@@ -0,0 +1,126 @@ ++/* BFD support for the Ubicom32 processor. ++ Copyright (C) 2000 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" ++ ++static const bfd_arch_info_type * ++ubicom32_arch_compatible (const bfd_arch_info_type *a, ++ const bfd_arch_info_type *b) ++{ ++ if (a->arch != b->arch) ++ return NULL; ++ ++ if (a->bits_per_word != b->bits_per_word) ++ return NULL; ++ ++ if (a->mach > b->mach) ++ return a; ++ ++ if (b->mach > a->mach) ++ return b; ++ ++ if (b->mach == bfd_mach_ubicom32ver4 && ++ strcmp("ubicom32uclinux", b->printable_name) == 0) { ++ return b; ++ } ++ ++ return a; ++} ++ ++const bfd_arch_info_type bfd_ubicom32_uclinux_arch = ++{ ++ 32, /* bits per word */ ++ 32, /* bits per address */ ++ 8, /* bits per byte */ ++ bfd_arch_ubicom32, /* architecture */ ++ bfd_mach_ubicom32ver4, /* machine */ ++ "ubicom32", /* architecture name */ ++ "ubicom32uclinux", /* printable name */ ++ 3, /* section align power */ ++ FALSE, /* the default ? */ ++ ubicom32_arch_compatible, /* architecture comparison fn */ ++ bfd_default_scan, /* string to architecture convert fn */ ++ NULL /* next in list */ ++}; ++ ++const bfd_arch_info_type bfd_ubicom32_posix_arch = ++{ ++ 32, /* bits per word */ ++ 32, /* bits per address */ ++ 8, /* bits per byte */ ++ bfd_arch_ubicom32, /* architecture */ ++ bfd_mach_ubicom32ver4, /* machine */ ++ "ubicom32", /* architecture name */ ++ "ubicom32posix", /* printable name */ ++ 3, /* section align power */ ++ FALSE, /* the default ? */ ++ bfd_default_compatible, /* architecture comparison fn */ ++ bfd_default_scan, /* string to architecture convert fn */ ++ &bfd_ubicom32_uclinux_arch, /* next in list */ ++}; ++ ++const bfd_arch_info_type bfd_ubicom32_ver4_arch = ++{ ++ 32, /* bits per word */ ++ 32, /* bits per address */ ++ 8, /* bits per byte */ ++ bfd_arch_ubicom32, /* architecture */ ++ bfd_mach_ubicom32ver4, /* machine */ ++ "ubicom32", /* architecture name */ ++ "ubicom32ver4", /* printable name */ ++ 3, /* section align power */ ++ FALSE, /* the default ? */ ++ ubicom32_arch_compatible, /* architecture comparison fn */ ++ bfd_default_scan, /* string to architecture convert fn */ ++ &bfd_ubicom32_posix_arch /* next in list */ ++}; ++ ++const bfd_arch_info_type bfd_ubicom32_nonext_arch = ++{ ++ 32, /* bits per word */ ++ 32, /* bits per address */ ++ 8, /* bits per byte */ ++ bfd_arch_ubicom32, /* architecture */ ++ bfd_mach_ubicom32dsp, /* machine */ ++ "ubicom32", /* architecture name */ ++ "ubicom32dsp", /* printable name */ ++ 3, /* section align power */ ++ FALSE, /* the default ? */ ++ bfd_default_compatible, /* architecture comparison fn */ ++ bfd_default_scan, /* string to architecture convert fn */ ++ & bfd_ubicom32_ver4_arch /* next in list */ ++}; ++ ++const bfd_arch_info_type bfd_ubicom32_arch = ++{ ++ 32, /* bits per word */ ++ 32, /* bits per address */ ++ 8, /* bits per byte */ ++ bfd_arch_ubicom32, /* architecture */ ++ bfd_mach_ubicom32, /* machine */ ++ "ubicom32", /* architecture name */ ++ "ubicom32", /* printable name */ ++ 3, /* section align power */ ++ TRUE, /* the default ? */ ++ bfd_default_compatible, /* architecture comparison fn */ ++ bfd_default_scan, /* string to architecture convert fn */ ++ & bfd_ubicom32_nonext_arch /* next in list */ ++}; +--- a/bfd/doc/archures.texi ++++ b/bfd/doc/archures.texi +@@ -303,6 +303,11 @@ enum bfd_architecture + bfd_arch_ip2k, /* Ubicom IP2K microcontrollers. */ + #define bfd_mach_ip2022 1 + #define bfd_mach_ip2022ext 2 ++ bfd_arch_ubicom32, ++#define bfd_mach_ubicom32 0 ++#define bfd_mach_ubicom32dsp 1 ++#define bfd_mach_ubicom32ver4 2 ++#define bfd_mach_ubicom32posix 3 + bfd_arch_iq2000, /* Vitesse IQ2000. */ + #define bfd_mach_iq2000 1 + #define bfd_mach_iq10 2 +--- /dev/null ++++ b/bfd/elf32-ubicom32.c +@@ -0,0 +1,5008 @@ ++/* Ubicom32 specific support for 32-bit ELF ++ Copyright 2000 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 ++#include "bfd.h" ++#include "sysdep.h" ++#include "libbfd.h" ++#include "elf-bfd.h" ++#include "elf/ubicom32.h" ++#include "elf/dwarf2.h" ++ ++/* Call offset = signed 24bit word offset ++ => 26bit signed byte offset. */ ++#define UBICOM32_CALL_MAX_POS_OFFS ((1 << 25) - 1) ++#define UBICOM32_CALL_MAX_NEG_OFFS (-(1 << 25)) ++ ++#define UNDEFINED_SYMBOL (~(bfd_vma)0) ++#define BASEADDR(SEC) ((SEC)->output_section->vma + (SEC)->output_offset) ++ ++#if 0 ++#define DPRINTF(fmt, ...) { printf("DBG %4d:" fmt, __LINE__, __VA_ARGS__); fflush(stdout); } ++#else ++#define DPRINTF(fmt, ...) {} ++#endif ++struct debugLineInfo { ++ unsigned int startOffset; ++ unsigned int length; ++ char *sectionName; ++ unsigned int startRelocIndex; ++ unsigned int endRelocIndex; ++ unsigned int discard; ++}; ++ ++struct debugLineInfoHeader { ++ unsigned int numEntries; ++ struct debugLineInfo linfo[1]; ++}; ++ ++/* we want RELA relocations, not REL */ ++#undef USE_REL ++#define USE_RELA ++ ++static bfd_reloc_status_type ubicom32_elf_generic_reloc ++ PARAMS ((bfd *abfd, arelent *reloc_entry, asymbol *symbol, PTR data, ++ asection *input_section, bfd *output_bfd, char **error_message)); ++static bfd_reloc_status_type ubicom32_elf_relocate_hi16 ++ PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); ++static bfd_reloc_status_type ubicom32_elf_relocate_lo16 ++ PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); ++static bfd_reloc_status_type ubicom32_elf_relocate_hi24 ++ PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); ++static bfd_reloc_status_type ubicom32_elf_relocate_lo7_s ++ PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); ++static bfd_reloc_status_type ubicom32_elf_relocate_lo7_2_s ++ PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); ++static bfd_reloc_status_type ubicom32_elf_relocate_lo7_4_s ++ PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); ++static bfd_reloc_status_type ubicom32_elf_relocate_lo7_d ++ PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); ++static bfd_reloc_status_type ubicom32_elf_relocate_lo7_2_d ++ PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); ++static bfd_reloc_status_type ubicom32_elf_relocate_lo7_4_d ++ PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); ++static bfd_reloc_status_type ubicom32_elf_relocate_pcrel24 ++ PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); ++static bfd_reloc_status_type ubicom32_elf_relocate_lo_calli ++ PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma, int)); ++ ++static void ubicom32_info_to_howto_rela ++ PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); ++ ++static reloc_howto_type * ubicom32_reloc_type_lookup ++ PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); ++ ++static bfd_vma symbol_value ++ PARAMS ((bfd *, Elf_Internal_Rela *)); ++static Elf_Internal_Shdr *file_symtab_hdr ++ PARAMS ((bfd *)); ++static Elf_Internal_Sym *file_isymbuf ++ PARAMS ((bfd *)); ++static Elf_Internal_Rela *section_relocs ++ PARAMS ((bfd *, asection *)); ++static bfd_byte *section_contents ++ PARAMS ((bfd *, asection *)); ++static bfd_boolean ubicom32_elf_relax_section ++ PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *)); ++static bfd_boolean ubicom32_elf_relax_calli ++ PARAMS ((bfd *, asection *, bfd_boolean *)); ++static bfd_boolean ubicom32_elf_relax_delete_bytes ++ PARAMS ((bfd *, asection *, bfd_vma, int)); ++static void adjust_sec_relocations ++ PARAMS ((bfd *, asection *, asection *, bfd_vma, int)); ++static void adjust_all_relocations ++ PARAMS ((bfd *, asection *, bfd_vma, int)); ++ ++static bfd_reloc_status_type ubicom32_final_link_relocate ++ PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *, ++ Elf_Internal_Rela *, bfd_vma)); ++static bfd_boolean ubicom32_elf_relocate_section ++ PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, ++ bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, ++ asection **)); ++ ++static bfd_boolean ubicom32_elf_gc_sweep_hook ++ PARAMS ((bfd *, struct bfd_link_info *, asection *, const ++ Elf_Internal_Rela *)); ++static asection * ubicom32_elf_gc_mark_hook ++ PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *, struct ++ elf_link_hash_entry *, Elf_Internal_Sym *)); ++static bfd_boolean ubicom32_elf_check_relocs ++ PARAMS ((bfd *, struct bfd_link_info *, asection *, ++ const Elf_Internal_Rela *)); ++extern bfd_boolean ubicom32_elf_discard_info ++ PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *)); ++ ++static bfd_boolean ubicom32_elf_object_p PARAMS ((bfd *)); ++static bfd_boolean ubicom32_elf_set_private_flags PARAMS ((bfd *, flagword)); ++static bfd_boolean ubicom32_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *)); ++static bfd_boolean ubicom32_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *)); ++static bfd_boolean ubicom32_elf_print_private_bfd_data PARAMS ((bfd *, PTR)); ++ ++//static unsigned long read_unsigned_leb128 (bfd *, char *, unsigned int *); ++ ++//static long read_signed_leb128 (bfd *, char *, unsigned int *); ++ ++/* read dwarf information from a buffer */ ++ ++#define UBICOM32_HOWTO(t,rs,s,bs,pr,bp,name,sm,dm) \ ++ HOWTO(t, /* type */ \ ++ rs, /* rightshift */ \ ++ s, /* size (0 = byte, 1 = short, 2 = long) */ \ ++ bs, /* bitsize */ \ ++ pr, /* pc_relative */ \ ++ bp, /* bitpos */ \ ++ complain_overflow_bitfield, /* complain_on_overflow */ \ ++ ubicom32_elf_generic_reloc, /* special_function */ \ ++ name, /* name */ \ ++ FALSE, /* partial_inplace */ \ ++ sm, /* src_mask */ \ ++ dm, /* dst_mask */ \ ++ pr) /* pcrel_offset */ ++ ++/* Special Note: For addresses, we must always zero out the top byte of a ++ address because the harvard address space is represented as ++ a single virtual address space that uses the top byte to denote ++ whether the address belongs in the data or program space. This is ++ done to accomodate GDB which cannot handle program and data addresses ++ overlapping. */ ++ ++static reloc_howto_type ubicom32_elf_howto_table [] = ++{ ++ /* This reloc does nothing. */ ++ UBICOM32_HOWTO (R_UBICOM32_NONE, 0, 2, 32, FALSE, 0, "R_UBICOM32_NONE", 0, 0), ++ ++ /* A 16 bit absolute relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_16, 0, 1, 16, FALSE, 0, "R_UBICOM32_16", 0, 0xffff), ++ ++ /* A 32 bit absolute relocation. Must zero top byte of virtual address. */ ++ UBICOM32_HOWTO (R_UBICOM32_32, 0, 2, 32, FALSE, 0, "R_UBICOM32_32", 0, 0xffffffff), ++ ++ /* A 16 bit indirect relocation, low 16 bits of 32 */ ++ UBICOM32_HOWTO (R_UBICOM32_LO16, 0, 2, 16, FALSE, 0, "R_UBICOM32_LO16", 0x0, 0x0000ffff), ++ ++ /* A 16 bit indirect relocation, high 16 bits of 32 - must zero top byte of virtual address */ ++ UBICOM32_HOWTO (R_UBICOM32_HI16, 0, 2, 16, FALSE, 0, "R_UBICOM32_HI16", 0x0, 0x0000ffff), ++ ++ /* A 21 bit relative relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_21_PCREL, 2, 2, 21, TRUE, 0, "R_UBICOM32_21_PCREL", 0x0, 0x001fffff), ++ ++ /* A 24 bit relative relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_24_PCREL, 2, 2, 24, TRUE, 0, "R_UBICOM32_24_PCREL", 0x0, 0x071fffff), ++ ++ /* A 24 bit indirect relocation, bits 31:7 - assume top byte zero. */ ++ UBICOM32_HOWTO (R_UBICOM32_HI24, 7, 2, 24, FALSE, 0, "R_UBICOM32_HI24", 0x0, 0x0001ffff), ++ ++ /* A source operand low 7 bit indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_LO7_S, 0, 2, 7, FALSE, 0, "R_UBICOM32_LO7_S", 0x0, 0x0000031f), ++ ++ /* A source operand low 7 bit .2 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_LO7_2_S, 1, 2, 7, FALSE, 0, "R_UBICOM32_LO7_2_S", 0x0, 0x0000031f), ++ ++ /* A source operand low 7 bit .4 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_LO7_4_S, 2, 2, 7, FALSE, 0, "R_UBICOM32_LO7_4_S", 0x0, 0x0000031f), ++ ++ /* A destination operand low 7 bit indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_LO7_D, 0, 2, 7, FALSE, 0, "R_UBICOM32_LO7_D", 0x0, 0x031f0000), ++ ++ /* A destination operand low 7 bit .2 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_LO7_2_D, 1, 2, 7, FALSE, 0, "R_UBICOM32_LO7_2_D", 0x0, 0x031f0000), ++ ++ /* A destination operand low 7 bit .2 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_LO7_4_D, 2, 2, 7, FALSE, 0, "R_UBICOM32_LO7_4_D", 0x0, 0x031f0000), ++ ++ /* A 32 bit absolute relocation in debug section. Must retain top byte of virtual address. */ ++ UBICOM32_HOWTO (R_UBICOM32_32_HARVARD, 0, 2, 32, FALSE, 0, "R_UBICOM32_32_HARVARD", 0, 0xffffffff), ++ ++ /* A calli offset operand low 7 bit .4 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_LO7_CALLI, 2, 2, 7, FALSE, 0, "R_UBICOM32_LO7_CALLI", 0x0, 0x071f071f), ++ ++ /* A calli offset operand low 18 bit .4 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_LO16_CALLI, 2, 2, 16, FALSE, 0, "R_UBICOM32_LO16_CALLI", 0x0, 0x071f071f), ++ ++ /* A 24 bit indirect relocation, bits 31:7 - assume top byte zero. */ ++ UBICOM32_HOWTO (R_UBICOM32_GOT_HI24, 7, 2, 24, FALSE, 0, "R_UBICOM32_GOT_HI24", 0x0, 0x0001ffff), ++ ++ /* A source operand low 7 bit indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_GOT_LO7_S, 0, 2, 7, FALSE, 0, "R_UBICOM32_GOT_LO7_S", 0x0, 0x0000031f), ++ ++ /* A source operand low 7 bit .2 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_GOT_LO7_2_S, 1, 2, 7, FALSE, 0, "R_UBICOM32_GOT_LO7_2_S", 0x0, 0x0000031f), ++ ++ /* A source operand low 7 bit .4 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_GOT_LO7_4_S, 2, 2, 7, FALSE, 0, "R_UBICOM32_GOT_LO7_4_S", 0x0, 0x0000031f), ++ ++ /* A destination operand low 7 bit indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_GOT_LO7_D, 0, 2, 7, FALSE, 0, "R_UBICOM32_GOT_LO7_D", 0x0, 0x031f0000), ++ ++ /* A destination operand low 7 bit .2 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_GOT_LO7_2_D, 1, 2, 7, FALSE, 0, "R_UBICOM32_GOT_LO7_2_D", 0x0, 0x031f0000), ++ ++ /* A destination operand low 7 bit .2 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_GOT_LO7_4_D, 2, 2, 7, FALSE, 0, "R_UBICOM32_GOT_LO7_4_D", 0x0, 0x031f0000), ++ ++ /* A 24 bit indirect relocation, bits 31:7 - assume top byte zero. */ ++ UBICOM32_HOWTO (R_UBICOM32_FUNCDESC_GOT_HI24, 7, 2, 24, FALSE, 0, "R_UBICOM32_FUNCDESC_GOT_HI24", 0x0, 0x0001ffff), ++ ++ /* A source operand low 7 bit indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_FUNCDESC_GOT_LO7_S, 0, 2, 7, FALSE, 0, "R_UBICOM32_FUNCDESC_GOT_LO7_S", 0x0, 0x0000031f), ++ ++ /* A source operand low 7 bit .2 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_FUNCDESC_GOT_LO7_2_S, 1, 2, 7, FALSE, 0, "R_UBICOM32_FUNCDESC_GOT_LO7_2_S", 0x0, 0x0000031f), ++ ++ /* A source operand low 7 bit .4 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_FUNCDESC_GOT_LO7_4_S, 2, 2, 7, FALSE, 0, "R_UBICOM32_FUNCDESC_GOT_LO7_4_S", 0x0, 0x0000031f), ++ ++ /* A destination operand low 7 bit indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_FUNCDESC_GOT_LO7_D, 0, 2, 7, FALSE, 0, "R_UBICOM32_FUNCDESC_GOT_LO7_D", 0x0, 0x031f0000), ++ ++ /* A destination operand low 7 bit .2 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_FUNCDESC_GOT_LO7_2_D, 1, 2, 7, FALSE, 0, "R_UBICOM32_FUNCDESC_GOT_LO7_2_D", 0x0, 0x031f0000), ++ ++ /* A destination operand low 7 bit .2 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_FUNCDESC_GOT_LO7_4_D, 2, 2, 7, FALSE, 0, "R_UBICOM32_FUNCDESC_GOT_LO7_4_D", 0x0, 0x031f0000), ++ ++ /* A calli offset operand low 7 bit .4 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_GOT_LO7_CALLI, 2, 2, 7, FALSE, 0, "R_UBICOM32_GOT_LO7_CALLI", 0x0, 0x071f071f), ++ ++ /* A calli offset operand low 7 bit .4 insn indirect relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_FUNCDESC_GOT_LO7_CALLI, 2, 2, 7, FALSE, 0, "R_UBICOM32_FUNCDESC_GOT_LO7_CALLI", 0x0, 0x071f071f), ++ ++ /* A 32 bit absolute relocation. Must zero top byte of virtual address. */ ++ UBICOM32_HOWTO (R_UBICOM32_FUNCDESC_VALUE, 0, 2, 32, FALSE, 0, "R_UBICOM32_FUNCDESC_VALUE", 0, 0xffffffff), ++ ++ /* A 32 bit absolute relocation. Must zero top byte of virtual address. */ ++ UBICOM32_HOWTO (R_UBICOM32_FUNCDESC, 0, 2, 32, FALSE, 0, "R_UBICOM32_FUNCDESC", 0, 0xffffffff), ++ ++ /* A 16 bit absolute relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_GOTOFFSET_LO, 0, 1, 16, FALSE, 0, "R_UBICOM32_GOTOFFSET_LO", 0, 0xffff), ++ ++ /* A 16 bit absolute relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_GOTOFFSET_HI, 0, 1, 16, FALSE, 0, "R_UBICOM32_GOTOFFSET_HI", 0, 0xffff), ++ ++ /* A 16 bit absolute relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_FUNCDESC_GOTOFFSET_LO, 0, 1, 16, FALSE, 0, "R_UBICOM32_FUNCDESC_GOTOFFSET_LO", 0, 0xffff), ++ ++ /* A 16 bit absolute relocation. */ ++ UBICOM32_HOWTO (R_UBICOM32_FUNCDESC_GOTOFFSET_HI, 0, 1, 16, FALSE, 0, "R_UBICOM32_FUNCDESC_GOTOFFSET_HI", 0, 0xffff), ++}; ++ ++/* GNU extension to record C++ vtable hierarchy */ ++static reloc_howto_type ubicom32_elf_vtinherit_howto = ++ HOWTO (R_UBICOM32_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_UBICOM32_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 ubicom32_elf_vtentry_howto = ++ HOWTO (R_UBICOM32_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_UBICOM32_GNU_VTENTRY", /* name */ ++ FALSE, /* partial_inplace */ ++ 0, /* src_mask */ ++ 0, /* dst_mask */ ++ FALSE); /* pcrel_offset */ ++ ++extern const bfd_target bfd_elf32_ubicom32fdpic_vec; ++#define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_ubicom32fdpic_vec) ++ ++/* Relocation helpers */ ++bfd_reloc_status_type ++ubicom32_elf_generic_reloc (abfd, ++ reloc_entry, ++ symbol, ++ data, ++ input_section, ++ output_bfd, ++ error_message) ++ bfd *abfd ATTRIBUTE_UNUSED; ++ arelent *reloc_entry; ++ asymbol *symbol; ++ PTR data ATTRIBUTE_UNUSED; ++ asection *input_section; ++ bfd *output_bfd; ++ char **error_message ATTRIBUTE_UNUSED; ++{ ++ if (output_bfd != (bfd *) NULL ++ && (symbol->flags & BSF_SECTION_SYM) == 0 ++ && (! reloc_entry->howto->partial_inplace ++ || reloc_entry->addend == 0)) ++ { ++ reloc_entry->address += input_section->output_offset; ++ symbol = *reloc_entry->sym_ptr_ptr; ++ ++ if((symbol->flags & BSF_OBJECT) == 0) ++ { ++ reloc_entry->addend -= symbol->value; ++ } ++ return bfd_reloc_ok; ++ } ++ ++ return bfd_reloc_continue; ++} ++ ++bfd_reloc_status_type ++ubicom32_elf_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 >>= 16; ++ value &= 0xffff; /* take off top byte of virtual address */ ++ insn = ((insn & ~0xFFFF) | value); ++ ++ bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); ++ return bfd_reloc_ok; ++} ++ ++bfd_reloc_status_type ++ubicom32_elf_relocate_lo16 (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 &= 0xFFFF; ++ insn = ((insn & ~0xFFFF) | value); ++ ++ bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); ++ return bfd_reloc_ok; ++} ++ ++bfd_reloc_status_type ++ubicom32_elf_relocate_hi24 (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; ++ if (value & 0x80000000) { ++ fprintf (stderr,"@@@: You are trying load the address of something at %08lx\n This is >= 0x80000000 and the moveai instruction does not support it!\n",value); ++ } ++ value &= 0x7fffffff; /* zero off top bit of virtual address */ ++ value >>= 7; ++ insn = (insn & ~0x071FFFFF); ++ ++ insn |= (value & 0x1FFFFF); ++ insn |= (value & 0xe00000) << 3; ++ ++ bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); ++ return bfd_reloc_ok; ++} ++ ++bfd_reloc_status_type ++ubicom32_elf_relocate_lo7_s (input_bfd, relhi, contents, value) ++ bfd *input_bfd; ++ Elf_Internal_Rela *relhi; ++ bfd_byte *contents; ++ bfd_vma value; ++{ ++ bfd_vma insn; ++ bfd_vma top; ++ bfd_vma bottom; ++ ++ insn = bfd_get_32 (input_bfd, contents + relhi->r_offset); ++ ++ value += relhi->r_addend; ++ value &= 0x7f; ++ ++ /* must split up value into top 2 bits and bottom 5 bits */ ++ top = value >> 5; ++ bottom = value & 0x1f; ++ insn = ((insn & ~0x31f) | (top << 8) | bottom); ++ ++ bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); ++ return bfd_reloc_ok; ++} ++ ++bfd_reloc_status_type ++ubicom32_elf_relocate_lo7_2_s (input_bfd, relhi, contents, value) ++ bfd *input_bfd; ++ Elf_Internal_Rela *relhi; ++ bfd_byte *contents; ++ bfd_vma value; ++{ ++ bfd_vma insn; ++ bfd_vma top; ++ bfd_vma bottom; ++ ++ insn = bfd_get_32 (input_bfd, contents + relhi->r_offset); ++ ++ value += relhi->r_addend; ++ value &= 0x7f; ++ value >>= 1; /* must shift by 1 because this is .2 insn */ ++ ++ /* must split up value into top 2 bits and bottom 5 bits */ ++ top = value >> 5; ++ bottom = value & 0x1f; ++ insn = ((insn & ~0x31f) | (top << 8) | bottom); ++ ++ bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); ++ return bfd_reloc_ok; ++} ++ ++bfd_reloc_status_type ++ubicom32_elf_relocate_lo7_4_s (input_bfd, relhi, contents, value) ++ bfd *input_bfd; ++ Elf_Internal_Rela *relhi; ++ bfd_byte *contents; ++ bfd_vma value; ++{ ++ bfd_vma insn; ++ bfd_vma top; ++ bfd_vma bottom; ++ ++ insn = bfd_get_32 (input_bfd, contents + relhi->r_offset); ++ ++ value += relhi->r_addend; ++ value &= 0x7f; ++ value >>= 2; /* must shift by 1 because this is .4 insn */ ++ ++ /* must split up value into top 2 bits and bottom 5 bits */ ++ top = value >> 5; ++ bottom = value & 0x1f; ++ insn = ((insn & ~0x31f) | (top << 8) | bottom); ++ ++ bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); ++ return bfd_reloc_ok; ++} ++ ++bfd_reloc_status_type ++ubicom32_elf_relocate_lo7_d (input_bfd, relhi, contents, value) ++ bfd *input_bfd; ++ Elf_Internal_Rela *relhi; ++ bfd_byte *contents; ++ bfd_vma value; ++{ ++ bfd_vma insn; ++ bfd_vma top; ++ bfd_vma bottom; ++ ++ insn = bfd_get_32 (input_bfd, contents + relhi->r_offset); ++ ++ value += relhi->r_addend; ++ value &= 0x7f; ++ ++ /* must split up value into top 2 bits and bottom 5 bits */ ++ top = value >> 5; ++ bottom = value & 0x1f; ++ insn = ((insn & ~0x031f0000) | (top << 24) | (bottom << 16)); ++ ++ bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); ++ return bfd_reloc_ok; ++} ++ ++bfd_reloc_status_type ++ubicom32_elf_relocate_lo7_2_d (input_bfd, relhi, contents, value) ++ bfd *input_bfd; ++ Elf_Internal_Rela *relhi; ++ bfd_byte *contents; ++ bfd_vma value; ++{ ++ bfd_vma insn; ++ bfd_vma top; ++ bfd_vma bottom; ++ ++ insn = bfd_get_32 (input_bfd, contents + relhi->r_offset); ++ ++ value += relhi->r_addend; ++ value &= 0x7f; ++ value >>= 1; /* must shift by 1 because this is for a .2 insn */ ++ ++ /* must split up value into top 2 bits and bottom 5 bits */ ++ top = value >> 5; ++ bottom = value & 0x1f; ++ insn = ((insn & ~0x031f0000) | (top << 24) | (bottom << 16)); ++ ++ bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); ++ return bfd_reloc_ok; ++} ++ ++bfd_reloc_status_type ++ubicom32_elf_relocate_lo7_4_d (input_bfd, relhi, contents, value) ++ bfd *input_bfd; ++ Elf_Internal_Rela *relhi; ++ bfd_byte *contents; ++ bfd_vma value; ++{ ++ bfd_vma insn; ++ bfd_vma top; ++ bfd_vma bottom; ++ ++ insn = bfd_get_32 (input_bfd, contents + relhi->r_offset); ++ ++ value += relhi->r_addend; ++ value &= 0x7f; ++ value >>= 2; /* must shift by 2 because this is for a .4 insn */ ++ ++ /* must split up value into top 2 bits and bottom 5 bits */ ++ top = value >> 5; ++ bottom = value & 0x1f; ++ insn = ((insn & ~0x031f0000) | (top << 24) | (bottom << 16)); ++ ++ bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); ++ return bfd_reloc_ok; ++} ++ ++/* Perform the relocation for call instructions */ ++static bfd_reloc_status_type ++ubicom32_elf_relocate_pcrel24 (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 value_top; ++ bfd_vma value_bottom; ++ ++ /* 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; ++ ++ /* insn uses bottom 24 bits of relocation value times 4 */ ++ if (value & 0x03) ++ return bfd_reloc_dangerous; ++ ++ value = (value & 0x3ffffff) >> 2; ++ ++ if ((long) value > 0xffffff) ++ return bfd_reloc_overflow; ++ ++ value_top = (value >> 21) << 24; ++ value_bottom = value & 0x1fffff; ++ ++ insn = insn & 0xf8e00000; ++ insn = insn | value_top | value_bottom; ++ ++ bfd_put_32 (input_bfd, insn, contents + rello->r_offset); ++ ++ return bfd_reloc_ok; ++} ++ ++static bfd_reloc_status_type ++ubicom32_elf_relocate_gotoffset_lo (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; ++ ++ /* Grab the instruction */ ++ insn = bfd_get_32 (input_bfd, contents + rello->r_offset); ++ ++ /* Truncte to 16 and store. */ ++ value &= 0xffff; ++ ++ insn = (insn & 0xffff0000) | value; ++ ++ /* output it. */ ++ bfd_put_32 (input_bfd, insn, contents + rello->r_offset); ++} ++ ++static bfd_reloc_status_type ++ubicom32_elf_relocate_funcdesc_gotoffset_lo (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; ++ ++ /* Grab the instruction */ ++ insn = bfd_get_32 (input_bfd, contents + rello->r_offset); ++ ++ /* Truncte to 16 and store. */ ++ value &= 0xffff; ++ ++ insn = (insn & 0xffff0000) | value; ++ ++ /* output it. */ ++ bfd_put_32 (input_bfd, insn, contents + rello->r_offset); ++} ++ ++static bfd_reloc_status_type ++ubicom32_elf_relocate_funcdesc (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; ++ ++ /* Grab the instruction */ ++ insn = bfd_get_32 (input_bfd, contents + rello->r_offset); ++ ++ /* Truncte to 16 and store. */ ++ value &= 0xffff; ++ ++ insn = (insn & 0xffff0000) | value; ++ ++ /* output it. */ ++ bfd_put_32 (input_bfd, insn, contents + rello->r_offset); ++} ++ ++bfd_reloc_status_type ++ubicom32_elf_relocate_lo_calli (input_bfd, relhi, contents, value, bits) ++ bfd *input_bfd; ++ Elf_Internal_Rela *relhi; ++ bfd_byte *contents; ++ bfd_vma value; ++ int bits; ++{ ++ bfd_vma insn; ++ ++ insn = bfd_get_32 (input_bfd, contents + relhi->r_offset); ++ ++ value += relhi->r_addend; ++ value &= (1 << bits) - 1; ++ value >>= 2; /* must shift by 2 because this is .4 insn */ ++ ++ /* must split up value into top 2 bits and bottom 5 bits */ ++ insn &= ~0x071f071f; ++ insn |= (value & 0x1f) << 0; ++ value >>= 5; ++ insn |= (value & 0x07) << 8; ++ value >>= 3; ++ insn |= (value & 0x1f) << 16; ++ value >>= 5; ++ insn |= (value & 0x07) << 24; ++ ++ bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); ++ return bfd_reloc_ok; ++} ++ ++ ++/* Set the howto pointer for a UBICOM32 ELF reloc. */ ++ ++static void ++ubicom32_info_to_howto_rela (abfd, cache_ptr, dst) ++ bfd * abfd ATTRIBUTE_UNUSED; ++ arelent * cache_ptr; ++ Elf_Internal_Rela * dst; ++{ ++ unsigned int r_type; ++ ++ r_type = ELF32_R_TYPE (dst->r_info); ++ switch (r_type) ++ { ++ case R_UBICOM32_GNU_VTINHERIT: ++ cache_ptr->howto = &ubicom32_elf_vtinherit_howto; ++ break; ++ ++ case R_UBICOM32_GNU_VTENTRY: ++ cache_ptr->howto = &ubicom32_elf_vtentry_howto; ++ break; ++ ++ default: ++ cache_ptr->howto = &ubicom32_elf_howto_table[r_type]; ++ break; ++ } ++} ++ ++ ++static reloc_howto_type * ++ubicom32_reloc_type_lookup (abfd, code) ++ bfd * abfd ATTRIBUTE_UNUSED; ++ bfd_reloc_code_real_type code; ++{ ++ switch (code) ++ { ++ case BFD_RELOC_NONE: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_NONE]; ++ ++ case BFD_RELOC_16: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_16]; ++ ++ case BFD_RELOC_32: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_32]; ++ ++ case BFD_RELOC_LO16: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_LO16]; ++ ++ case BFD_RELOC_HI16: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_HI16]; ++ ++ case BFD_RELOC_UBICOM32_HI24: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_HI24]; ++ ++ case BFD_RELOC_UBICOM32_LO7_S: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_LO7_S]; ++ ++ case BFD_RELOC_UBICOM32_LO7_2_S: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_LO7_2_S]; ++ ++ case BFD_RELOC_UBICOM32_LO7_4_S: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_LO7_4_S]; ++ ++ case BFD_RELOC_UBICOM32_LO7_D: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_LO7_D]; ++ ++ case BFD_RELOC_UBICOM32_LO7_2_D: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_LO7_2_D]; ++ ++ case BFD_RELOC_UBICOM32_LO7_4_D: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_LO7_4_D]; ++ ++ case BFD_RELOC_UBICOM32_21_PCREL: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_21_PCREL]; ++ ++ case BFD_RELOC_UBICOM32_24_PCREL: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_24_PCREL]; ++ ++ case BFD_RELOC_UBICOM32_GOT_HI24: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_GOT_HI24]; ++ ++ case BFD_RELOC_UBICOM32_GOT_LO7_S: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_GOT_LO7_S]; ++ ++ case BFD_RELOC_UBICOM32_GOT_LO7_2_S: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_GOT_LO7_2_S]; ++ ++ case BFD_RELOC_UBICOM32_GOT_LO7_4_S: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_GOT_LO7_4_S]; ++ ++ case BFD_RELOC_UBICOM32_GOT_LO7_D: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_GOT_LO7_D]; ++ ++ case BFD_RELOC_UBICOM32_GOT_LO7_2_D: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_GOT_LO7_2_D]; ++ ++ case BFD_RELOC_UBICOM32_GOT_LO7_4_D: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_GOT_LO7_4_D]; ++ ++ case BFD_RELOC_UBICOM32_FUNCDESC_GOT_HI24: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_FUNCDESC_GOT_HI24]; ++ ++ case BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_S: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_FUNCDESC_GOT_LO7_S]; ++ ++ case BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_2_S: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_FUNCDESC_GOT_LO7_2_S]; ++ ++ case BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_4_S: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_FUNCDESC_GOT_LO7_4_S]; ++ ++ case BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_D: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_FUNCDESC_GOT_LO7_D]; ++ ++ case BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_2_D: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_FUNCDESC_GOT_LO7_2_D]; ++ ++ case BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_4_D: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_FUNCDESC_GOT_LO7_4_D]; ++ ++ case BFD_RELOC_UBICOM32_LO7_CALLI: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_LO7_CALLI]; ++ ++ case BFD_RELOC_UBICOM32_GOT_LO7_CALLI: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_GOT_LO7_CALLI]; ++ ++ case BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_CALLI: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_FUNCDESC_GOT_LO7_CALLI]; ++ ++ case BFD_RELOC_UBICOM32_LO16_CALLI: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_LO16_CALLI]; ++ ++ case BFD_RELOC_UBICOM32_FUNCDESC_VALUE: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_FUNCDESC_VALUE]; ++ ++ case BFD_RELOC_UBICOM32_FUNCDESC: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_FUNCDESC]; ++ ++ case BFD_RELOC_UBICOM32_GOTOFFSET_LO: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_GOTOFFSET_LO]; ++ ++ case BFD_RELOC_UBICOM32_GOTOFFSET_HI: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_GOTOFFSET_HI]; ++ ++ case BFD_RELOC_UBICOM32_FUNCDESC_GOTOFFSET_LO: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_FUNCDESC_GOTOFFSET_LO]; ++ ++ case BFD_RELOC_UBICOM32_FUNCDESC_GOTOFFSET_HI: ++ return &ubicom32_elf_howto_table[(int)R_UBICOM32_FUNCDESC_GOTOFFSET_HI]; ++ ++ case BFD_RELOC_VTABLE_INHERIT: ++ return &ubicom32_elf_vtinherit_howto; ++ ++ case BFD_RELOC_VTABLE_ENTRY: ++ return &ubicom32_elf_vtentry_howto; ++ ++ default: ++ /* Pacify gcc -Wall. */ ++ return NULL; ++ } ++ ++ return NULL; ++} ++ ++static reloc_howto_type * ++ubicom32_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, ++ const char *r_name) ++{ ++ unsigned int i; ++ ++ for (i = 0; ++ i < (sizeof (ubicom32_elf_howto_table) ++ / sizeof (ubicom32_elf_howto_table[0])); ++ i++) ++ if (ubicom32_elf_howto_table[i].name != NULL ++ && strcasecmp (ubicom32_elf_howto_table[i].name, r_name) == 0) ++ return &ubicom32_elf_howto_table[i]; ++ ++ return NULL; ++} ++ ++/* Return the value of the symbol associated with the relocation IREL. */ ++ ++static bfd_vma ++symbol_value (abfd, irel) ++ bfd *abfd; ++ Elf_Internal_Rela *irel; ++{ ++ Elf_Internal_Shdr *symtab_hdr = file_symtab_hdr (abfd); ++ Elf_Internal_Sym *isymbuf = file_isymbuf (abfd); ++ ++ if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) ++ { ++ Elf_Internal_Sym *isym; ++ asection *sym_sec; ++ ++ isym = isymbuf + ELF32_R_SYM (irel->r_info); ++ if (isym->st_shndx == SHN_UNDEF) ++ sym_sec = bfd_und_section_ptr; ++ else if (isym->st_shndx == SHN_ABS) ++ sym_sec = bfd_abs_section_ptr; ++ else if (isym->st_shndx == SHN_COMMON) ++ sym_sec = bfd_com_section_ptr; ++ else ++ sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); ++ ++ return isym->st_value + BASEADDR (sym_sec); ++ } ++ else ++ { ++ unsigned long indx; ++ struct elf_link_hash_entry *h; ++ ++ indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; ++ h = elf_sym_hashes (abfd)[indx]; ++ BFD_ASSERT (h != NULL); ++ ++ if (h->root.type != bfd_link_hash_defined ++ && h->root.type != bfd_link_hash_defweak) ++ return UNDEFINED_SYMBOL; ++ ++ return (h->root.u.def.value + BASEADDR (h->root.u.def.section)); ++ } ++} ++ ++ ++static Elf_Internal_Shdr * ++file_symtab_hdr (abfd) ++ bfd *abfd; ++{ ++ return &elf_tdata (abfd)->symtab_hdr; ++} ++ ++static Elf_Internal_Sym * ++file_isymbuf (abfd) ++ bfd *abfd; ++{ ++ Elf_Internal_Shdr *symtab_hdr; ++ ++ symtab_hdr = file_symtab_hdr (abfd); ++ if (symtab_hdr->sh_info == 0) ++ return NULL; ++ ++ if (symtab_hdr->contents == NULL) ++ { ++ Elf_Internal_Sym * contents = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, ++ NULL, NULL, NULL); ++ symtab_hdr->contents = (unsigned char *) contents; ++ } ++ ++ return (Elf_Internal_Sym *) symtab_hdr->contents; ++} ++ ++static Elf_Internal_Rela * ++section_relocs (abfd, sec) ++ bfd *abfd; ++ asection *sec; ++{ ++ if ((sec->flags & SEC_RELOC) == 0) ++ return NULL; ++ ++ if (sec->reloc_count == 0) ++ return NULL; ++ ++ if (elf_section_data (sec)->relocs == NULL) ++ elf_section_data (sec)->relocs = ++ _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, 1); ++ ++ return elf_section_data (sec)->relocs; ++} ++ ++static bfd_byte * ++section_contents (abfd, sec) ++ bfd *abfd; ++ asection *sec; ++{ ++ bfd_byte *contents; ++ ++ sec->rawsize = sec->rawsize ? sec->rawsize: sec->size; ++ ++ if (elf_section_data (sec)->this_hdr.contents) ++ return elf_section_data (sec)->this_hdr.contents; ++ ++ contents = (bfd_byte *) bfd_malloc (sec->rawsize); ++ if (contents == NULL) ++ return NULL; ++ ++ if (! bfd_get_section_contents (abfd, sec, contents, ++ (file_ptr) 0, sec->rawsize)) ++ { ++ free (contents); ++ return NULL; ++ } ++ ++ elf_section_data (sec)->this_hdr.contents = contents; ++ return contents; ++} ++ ++/* This function handles relaxing for the ubicom32. ++ ++ Principle: Start with the first page and remove page instructions that ++ are not require on this first page. By removing page instructions more ++ code will fit into this page - repeat until nothing more can be achieved ++ for this page. Move on to the next page. ++ ++ Processing the pages one at a time from the lowest page allows a removal ++ only policy to be used - pages can be removed but are never reinserted. */ ++ ++static bfd_boolean ++ubicom32_elf_relax_section (abfd, sec, link_info, again) ++ bfd *abfd; ++ asection *sec; ++ struct bfd_link_info *link_info; ++ bfd_boolean *again; ++{ ++ /* Assume nothing changes. */ ++ *again = FALSE; ++ ++ /* We don't have to do anything for a relocatable link, ++ if this section does not have relocs, or if this is ++ not a code section. */ ++ if (link_info->relocatable ++ || (sec->flags & SEC_RELOC) == 0 ++ || sec->reloc_count == 0 ++ || (sec->flags & SEC_CODE) == 0) ++ return TRUE; ++ ++ /* If this is the first time we have been called ++ for this section, initialise the cooked size. ++ if (sec->_cooked_size == 0) ++ sec->_cooked_size = sec->rawsize; ++ */ ++ ++ /* This is where all the relaxation actually get done. */ ++ if (!ubicom32_elf_relax_calli (abfd, sec, again)) ++ return FALSE; ++ ++ if (sec->rawsize != sec->size) ++ sec->size = sec->rawsize; ++ ++ /* Success! */ ++ return TRUE; ++} ++ ++static bfd_boolean ++ubicom32_elf_relax_calli (abfd, sec, again) ++ bfd *abfd; ++ asection *sec; ++ bfd_boolean *again; ++{ ++ bfd_byte *contents = section_contents (abfd, sec); ++ Elf_Internal_Rela *irelbase = section_relocs (abfd, sec); ++ Elf_Internal_Rela *irelend = irelbase + sec->reloc_count; ++ Elf_Internal_Rela *irel_moveai = NULL; ++ Elf_Internal_Rela *irel; ++ unsigned long insn; ++ bfd_vma symval; ++ bfd_vma pc; ++ bfd_vma dest; ++ signed long offs; ++ ++ /* Walk thru the section looking for relaxation opertunities. */ ++ for (irel = irelbase; irel < irelend; irel++) ++ { ++ /* Remember last moveai instruction */ ++ if (ELF32_R_TYPE (irel->r_info) == (int) R_UBICOM32_HI24) ++ { ++ irel_moveai = irel; ++ continue; ++ } ++ ++ /* Ignore non calli instructions */ ++ if (ELF32_R_TYPE (irel->r_info) != (int) R_UBICOM32_LO7_CALLI) ++ continue; ++ ++ /* calli instruction => verify it is a calli instruction ++ using a5 with a 5 bit positive offset */ ++ insn = bfd_get_32 (abfd, (bfd_byte *)(contents + irel->r_offset)); ++ if ((insn & 0xffffffe0) != 0xf0a000a0) ++ continue; ++ symval = symbol_value (abfd, irel); ++ if (symval == UNDEFINED_SYMBOL) ++ continue; ++ dest = symval + irel->r_addend; ++ ++ /* Check proceeding instruction for a valid moveai */ ++ if (!irel_moveai) ++ continue; ++ if (irel_moveai->r_offset != (irel->r_offset - 4)) ++ continue; ++ insn = bfd_get_32 (abfd, (bfd_byte *)(contents + irel_moveai->r_offset)); ++ if ((insn & 0xf8e00000) != 0xe0a00000) ++ continue; ++ symval = symbol_value (abfd, irel_moveai); ++ if (symval == UNDEFINED_SYMBOL) ++ continue; ++ symval += irel_moveai->r_addend; ++ if (symval != dest) ++ continue; ++ ++ /* Check offset required */ ++ pc = BASEADDR (sec) + irel_moveai->r_offset; ++ offs = dest - pc; ++ if (offs > (UBICOM32_CALL_MAX_POS_OFFS + 4)) ++ continue; ++ if (offs < UBICOM32_CALL_MAX_NEG_OFFS) ++ continue; ++ ++ /* Replace calli with a call instruction */ ++ irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_UBICOM32_24_PCREL); ++ bfd_put_32 (abfd, 0xd8a00000, contents + irel->r_offset); ++ ++ /* Delete moveai instruction */ ++ irel_moveai->r_info = ELF32_R_INFO (ELF32_R_SYM (irel_moveai->r_info), R_UBICOM32_NONE); ++ if (!ubicom32_elf_relax_delete_bytes (abfd, sec, irel_moveai->r_offset, 4)) ++ return FALSE; ++ ++ /* Modified => will need to iterate relaxation again. */ ++ *again = TRUE; ++ } ++ ++ return TRUE; ++} ++ ++/* Delete some bytes from a section while relaxing. */ ++ ++static bfd_boolean ++ubicom32_elf_relax_delete_bytes (abfd, sec, addr, count) ++ bfd *abfd; ++ asection *sec; ++ bfd_vma addr; ++ int count; ++{ ++ bfd_byte *contents = elf_section_data (sec)->this_hdr.contents; ++ bfd_vma endaddr = sec->rawsize; ++ ++ /* Actually delete the bytes. */ ++ memmove (contents + addr, contents + addr + count, ++ endaddr - addr - count); ++ ++ sec->rawsize -= count; ++ ++ adjust_all_relocations (abfd, sec, addr + count, -count); ++ return TRUE; ++} ++ ++/* Adjust all the relocations entries after adding or inserting instructions. */ ++ ++static void ++adjust_sec_relocations (abfd, sec_to_process, addr_sec, addr, count) ++ bfd *abfd; ++ asection *sec_to_process; ++ asection *addr_sec; ++ bfd_vma addr; ++ int count; ++{ ++ Elf_Internal_Shdr *symtab_hdr; ++ Elf_Internal_Sym *isymbuf, *isym; ++ Elf_Internal_Rela *irel, *irelend, *irelbase; ++ unsigned int addr_shndx; ++ ++ irelbase = section_relocs (abfd, sec_to_process); ++ if (irelbase == NULL) ++ return; ++ irelend = irelbase + sec_to_process->reloc_count; ++ ++ symtab_hdr = file_symtab_hdr (abfd); ++ isymbuf = file_isymbuf (abfd); ++ ++ addr_shndx = _bfd_elf_section_from_bfd_section (abfd, addr_sec); ++ ++ for (irel = irelbase; irel < irelend; irel++) ++ { ++ if (ELF32_R_TYPE (irel->r_info) != R_UBICOM32_NONE) ++ { ++ /* Get the value of the symbol referred to by the reloc. */ ++ if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) ++ { ++ asection *sym_sec; ++ bfd_vma xaddr, symval, relval; ++ ++ /* A local symbol. */ ++ isym = isymbuf + ELF32_R_SYM (irel->r_info); ++ sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); ++ xaddr = BASEADDR (addr_sec) + addr; ++ symval = BASEADDR (sym_sec) + isym->st_value; ++ relval = symval + irel->r_addend; ++ ++ if ((isym->st_shndx == addr_shndx) ++ && (xaddr > symval) ++ && (xaddr <= relval)) ++ irel->r_addend += count; ++ } ++ } ++ ++ /* Adjust irel base address for PC space relocations after a deleted instruction. */ ++ if (sec_to_process == addr_sec) ++ { ++ if (addr <= irel->r_offset) ++ irel->r_offset += count; ++ } ++ } ++} ++ ++static void ++adjust_all_relocations (abfd, sec, addr, count) ++ bfd *abfd; ++ asection *sec; ++ bfd_vma addr; ++ int count; ++{ ++ Elf_Internal_Shdr *symtab_hdr; ++ Elf_Internal_Sym *isymbuf, *isym, *isymend; ++ struct elf_link_hash_entry **sym_hashes; ++ struct elf_link_hash_entry **end_hashes; ++ unsigned int symcount; ++ asection *section; ++ unsigned int shndx; ++ ++ symtab_hdr = file_symtab_hdr (abfd); ++ isymbuf = file_isymbuf (abfd); ++ ++ shndx = _bfd_elf_section_from_bfd_section (abfd, sec); ++ ++ /* Adjust all relocations that are affected. */ ++ for (section = abfd->sections; section != NULL; section = section->next) ++ adjust_sec_relocations (abfd, section, sec, addr, count); ++ ++ /* Adjust the local symbols defined in this section. */ ++ isymend = isymbuf + symtab_hdr->sh_info; ++ for (isym = isymbuf; isym < isymend; isym++) ++ { ++ if (isym->st_shndx == shndx ++ && addr <= isym->st_value) ++ isym->st_value += count; ++ } ++ ++ /* Now adjust the global symbols defined in this section. */ ++ symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) ++ - symtab_hdr->sh_info); ++ sym_hashes = elf_sym_hashes (abfd); ++ end_hashes = sym_hashes + symcount; ++ for (; sym_hashes < end_hashes; sym_hashes++) ++ { ++ struct elf_link_hash_entry *sym_hash = *sym_hashes; ++ ++ if ((sym_hash->root.type == bfd_link_hash_defined ++ || sym_hash->root.type == bfd_link_hash_defweak) ++ && sym_hash->root.u.def.section == sec) ++ { ++ if (addr <= sym_hash->root.u.def.value) ++ sym_hash->root.u.def.value += count; ++ } ++ } ++} ++ ++/* Perform a single relocation. By default we use the standard BFD ++ routines. */ ++ ++static bfd_reloc_status_type ++ubicom32_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; ++{ ++ bfd_reloc_status_type r = bfd_reloc_ok; ++ ++ switch (howto->type) ++ { ++ default: ++ r = _bfd_final_link_relocate (howto, input_bfd, input_section, ++ contents, rel->r_offset, ++ relocation, rel->r_addend); ++ } ++ ++ return r; ++} ++ ++/* Relocate a UBICOM32 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 relocatable ++ 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 relocatable 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 bfd_boolean ++ubicom32_elf_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; ++ struct debugLineInfoHeader *lh = NULL; ++ int cooked_size, discard_size; ++ bfd_byte *src, *dest, *content_end; ++ unsigned int i; ++ ++ 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_UBICOM32_GNU_VTINHERIT ++ || r_type == R_UBICOM32_GNU_VTENTRY) ++ continue; ++ ++ r_symndx = ELF32_R_SYM (rel->r_info); ++ ++ if (info->relocatable) ++ { ++ /* This is a relocatable 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 = ubicom32_elf_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, ++ (!info->shared )))) ++ return FALSE; ++ relocation = 0; ++ } ++ } ++ ++ switch (r_type) ++ { ++ case R_UBICOM32_LO16: ++ r = ubicom32_elf_relocate_lo16 (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_HI16: ++ r = ubicom32_elf_relocate_hi16 (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_HI24: ++ r = ubicom32_elf_relocate_hi24 (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_S: ++ r = ubicom32_elf_relocate_lo7_s (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_2_S: ++ r = ubicom32_elf_relocate_lo7_2_s (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_4_S: ++ r = ubicom32_elf_relocate_lo7_4_s (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_D: ++ r = ubicom32_elf_relocate_lo7_d (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_2_D: ++ r = ubicom32_elf_relocate_lo7_2_d (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_4_D: ++ r = ubicom32_elf_relocate_lo7_4_d (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_24_PCREL: ++ r = ubicom32_elf_relocate_pcrel24 (input_bfd, input_section, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_CALLI: ++ r = ubicom32_elf_relocate_lo_calli (input_bfd, rel, contents, relocation, 7); ++ break; ++ ++ case R_UBICOM32_LO16_CALLI: ++ r = ubicom32_elf_relocate_lo_calli (input_bfd, rel, contents, relocation, 18); ++ break; ++ ++ case R_UBICOM32_32: ++ /* relocation &= ~(0xff << 24); */ ++ /* FALLTHROUGH */ ++ ++ default: ++ r = ubicom32_final_link_relocate (howto, input_bfd, input_section, ++ contents, rel, relocation); ++ break; ++ } ++ ++ if (r != bfd_reloc_ok) ++ { ++ const char * msg = (const char *) NULL; ++ ++ switch (r) ++ { ++ case bfd_reloc_overflow: ++ r = info->callbacks->reloc_overflow ++ (info, NULL, 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; ++ } ++ } ++ ++ /* ++ * now we have to collapse the .debug_line section if it has a ++ * sec_info section ++ */ ++ ++ if(strcmp(input_section->name, ".debug_line")) ++ return TRUE; ++ ++ /* this is a .debug_line section. See it has a sec_info entry */ ++ if(elf_section_data(input_section)->sec_info == NULL) ++ return TRUE; ++ ++ lh = (struct debugLineInfoHeader *) elf_section_data(input_section)->sec_info; ++ ++ if(lh->numEntries == 0) ++ return TRUE; ++ ++ dest = contents + lh->linfo[0].startOffset; ++ ++ cooked_size = input_section->rawsize; ++ content_end = contents + cooked_size; ++ discard_size = 0; ++ ++ for(i=0; i< lh->numEntries; i++) ++ { ++ if(lh->linfo[i].discard) ++ discard_size += lh->linfo[i].length; ++ else ++ { ++ src = contents + lh->linfo[i].startOffset; ++ (void) memcpy(dest, src, lh->linfo[i].length); ++ dest += lh->linfo[i].length; ++ } ++ } ++ ++ src = contents + lh->linfo[lh->numEntries-1].startOffset + lh->linfo[lh->numEntries-1].length; ++ if(src < content_end) ++ (void) memcpy(dest, src, content_end - src); ++ ++ i = bfd_get_32(input_bfd, contents); ++ i -= discard_size; ++ bfd_put_32(input_bfd, i, contents); ++ //input_section->rawsize -= discard_size; ++ return TRUE; ++} ++ ++ ++/* Update the got entry reference counts for the section being ++ removed. */ ++ ++static bfd_boolean ++ubicom32_elf_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; ++} ++ ++/* Return the section that should be marked against GC for a given ++ relocation. */ ++ ++static asection * ++ubicom32_elf_gc_mark_hook (sec, info, rel, h, sym) ++ asection * sec; ++ 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_UBICOM32_GNU_VTINHERIT: ++ case R_UBICOM32_GNU_VTENTRY: ++ break; ++ ++ default: ++ switch (h->root.type) ++ { ++ 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; ++ ++ default: ++ break; ++ } ++ } ++ } ++ else ++ { ++ if (!(elf_bad_symtab (sec->owner) ++ && 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 (sec->owner, sym->st_shndx); ++ } ++ } ++ ++ return NULL; ++} ++ ++/* 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 bfd_boolean ++ubicom32_elf_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; ++ Elf_Internal_Rela *rel; ++ Elf_Internal_Rela *rel_end; ++ Elf_Internal_Rela *my_rel = ( Elf_Internal_Rela*)relocs; ++ if (info->relocatable) ++ 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 = my_rel + sec->reloc_count; ++ for (rel = my_rel; 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_UBICOM32_GNU_VTINHERIT: ++ if (!bfd_elf_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_UBICOM32_GNU_VTENTRY: ++ if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) ++ return FALSE; ++ break; ++ ++ case R_UBICOM32_32: ++ /* For debug section, change to harvard relocations */ ++ if (memcmp (sec->name, ".debug", 6) == 0 ++ || memcmp (sec->name, ".stab", 5) == 0) ++ rel->r_info = ELF32_R_INFO (ELF32_R_SYM (rel->r_info), R_UBICOM32_32_HARVARD); ++ break; ++ } ++ } ++ return TRUE; ++} ++ ++static bfd_boolean ++ubicom32_elf_object_p (abfd) ++ bfd *abfd; ++{ ++ flagword mach = elf_elfheader (abfd)->e_flags & 0xffff; ++ bfd_default_set_arch_mach (abfd, bfd_arch_ubicom32, mach); ++ return (((elf_elfheader (abfd)->e_flags & EF_UBICOM32_FDPIC) != 0) ++ == (IS_FDPIC (abfd))); ++} ++ ++ ++/* Function to set the ELF flag bits */ ++ ++static bfd_boolean ++ubicom32_elf_set_private_flags (abfd, flags) ++ bfd *abfd; ++ flagword flags; ++{ ++ elf_elfheader (abfd)->e_flags = flags; ++ elf_flags_init (abfd) = TRUE; ++ return TRUE; ++} ++ ++static bfd_boolean ++ubicom32_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 bfd_boolean ++ubicom32_elf_merge_private_bfd_data (ibfd, obfd) ++ bfd *ibfd; ++ bfd *obfd; ++{ ++ flagword old_flags, new_flags; ++ bfd_boolean error = FALSE; ++ ++ 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; ++ elf_elfheader (obfd)->e_flags = new_flags; ++ } ++ else ++ { ++ if (new_flags != old_flags) ++ { ++ /* Mismatched flags. */ ++ char *output_cpu_version = ((old_flags &0xffff) == 1) ? "V3" : (((old_flags &0xffff) == 2) ? "V4" : "unknown"); ++ char *input_cpu_version = ((new_flags &0xffff) == 1) ? "V3" : (((new_flags &0xffff) == 2) ? "V4" : "unknown"); ++ char *output_filename = bfd_get_filename (obfd); ++ char *input_filename = bfd_get_filename (ibfd); ++ char *output_pic = (old_flags & EF_UBICOM32_PIC_FLAGS) ? ((old_flags & EF_UBICOM32_PIC) ? "FPIC" : "FDPIC") : NULL; ++ char *input_pic = (new_flags & EF_UBICOM32_PIC_FLAGS) ? ((new_flags & EF_UBICOM32_PIC) ? "FPIC" : "FDPIC") : NULL; ++ ++ (*_bfd_error_handler) ("Linking mismatched file types. Output file = %s file type 0x%.8lx, input file = %s file type 0x%.8lx", ++ output_filename, old_flags, input_filename, new_flags); ++ ++ if (output_pic) ++ { ++ (*_bfd_error_handler)("Output file %s %s for cpu version %s", output_filename, output_pic, output_cpu_version); ++ } ++ else ++ { ++ (*_bfd_error_handler)("Output file %s for cpu version %s", output_filename, output_cpu_version); ++ } ++ ++ if (input_pic) ++ { ++ (*_bfd_error_handler)("Input file %s %s for cpu version %s", input_filename, input_pic, input_cpu_version); ++ } ++ else ++ { ++ (*_bfd_error_handler)("Input file %s for cpu version %s", input_filename, input_cpu_version); ++ } ++ ++ (*_bfd_error_handler) ("Link ABORTED."); ++ _exit(EXIT_FAILURE); ++ } ++ } ++ if (error) ++ bfd_set_error (bfd_error_bad_value); ++ ++ return !error; ++} ++ ++static bfd_boolean ++ubicom32_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); ++ ++ fputc ('\n', file); ++ ++ return TRUE; ++} ++ ++bfd_boolean ++ubicom32_elf_discard_info(abfd, cookie, info) ++ bfd *abfd; ++ struct elf_reloc_cookie *cookie ATTRIBUTE_UNUSED; ++ struct bfd_link_info *info; ++ ++{ ++ unsigned int hasDebugLine=0; ++ unsigned needExclude = 0; ++ asection *o; ++ asection *sec= NULL; ++ bfd_byte *contents = NULL; ++ bfd_byte *contentsEnd; ++ Elf_Internal_Rela *irel, *irelend, *irelbase; ++ Elf_Internal_Shdr *symtab_hdr; ++ Elf_Internal_Sym *isym; ++ Elf_Internal_Sym *isymbuf = NULL; ++ struct debugLineInfoHeader *lh = NULL; ++ unsigned int maxLineInfoEntries = 10; ++ unsigned int offset, contentLength; ++ unsigned char *ptr, *sequence_start; ++ unsigned int setupEntry=1; ++ unsigned int opcode_base, op_code; ++ unsigned int bytes_read; ++ ++ for (o = abfd->sections; o != NULL; o = o->next) ++ { ++ if(!hasDebugLine) ++ if(!strcmp(o->name, ".debug_line")) ++ { ++ hasDebugLine =1; ++ sec = o; ++ } ++ ++ /* Keep special sections. Keep .debug sections. */ ++ if (o->flags & SEC_EXCLUDE) ++ { ++ needExclude = 1; ++ } ++ } ++ ++ if(needExclude == 0 || hasDebugLine ==0) ++ return FALSE; ++ ++ /* ++ * you can be here only if we have .debug_line section and some ++ * section is being excudled ++ */ ++ ++ /* ++ * We need to extract .debug_line section contents and its ++ * relocation contents. ++ */ ++ ++ /* We don't have to do anything for a relocatable link, ++ if this section does not have relocs */ ++ if (info->relocatable ++ || (sec->flags & SEC_RELOC) == 0 ++ || sec->reloc_count == 0) ++ return FALSE; ++ ++ /* If this is the first time we have been called ++ for this section, initialise the cooked size. ++ if (sec->_cooked_size == 0) ++ sec->_cooked_size = sec->rawsize; ++ */ ++ ++ symtab_hdr = &elf_tdata (abfd)->symtab_hdr; ++ ++ irelbase = _bfd_elf_link_read_relocs (abfd, sec, NULL, ++ (Elf_Internal_Rela *)NULL, ++ info->keep_memory); ++ ++ if(irelbase == NULL) ++ return FALSE; ++ ++ irelend = irelbase +sec->reloc_count; ++ ++ /* Get section contents cached copy if it exists. */ ++ if (contents == NULL) ++ { ++ contents = section_contents(abfd, sec); ++ } ++ ++ if (isymbuf == NULL && symtab_hdr->sh_info != 0) ++ { ++ isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; ++ if (isymbuf == NULL) ++ isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, ++ symtab_hdr->sh_info, 0, ++ NULL, NULL, NULL); ++ if (isymbuf == NULL) ++ return FALSE; ++ } ++ ++ /* allocate the line header and initialize it */ ++ lh = (struct debugLineInfoHeader *) ++ realloc( (void *)lh, sizeof (struct debugLineInfo)*maxLineInfoEntries + ++ sizeof(unsigned int)); ++ ++ lh->numEntries = 0; ++ ++ /* the first 4 bytes contains the length */ ++ contentLength = bfd_get_32 (abfd, (bfd_byte *)contents); ++ contentsEnd = contents + contentLength + 4; ++ ++ ptr = (unsigned char *)contents; ++ ptr +=6; ++ /* read the header length */ ++ offset = bfd_get_32(abfd, (bfd_byte *)ptr); ++ ptr += 4; ++ ptr += offset; ++ ++ /* extract the base opcode */ ++ opcode_base = (unsigned char)contents[14]; ++ sequence_start = NULL; ++ while(ptr < (unsigned char *) contentsEnd) ++ { ++ if(setupEntry) ++ { ++ if(lh->numEntries == maxLineInfoEntries) ++ { ++ /* need to do some reallocing. Bump up the entries by 10 */ ++ maxLineInfoEntries += 10; ++ lh = (struct debugLineInfoHeader *) ++ realloc( (void *)lh, ++ sizeof (struct debugLineInfo)*maxLineInfoEntries + ++ sizeof(unsigned int)); ++ } ++ ++ /* zero out the entry */ ++ memset((void *) &lh->linfo[lh->numEntries], ++ 0, ++ sizeof(struct debugLineInfo)); ++ lh->linfo[lh->numEntries].startOffset = (bfd_byte *)ptr - contents; ++ setupEntry = 0; ++ sequence_start = ptr; ++ } ++ ++ /* We need to run the state machine */ ++ op_code = bfd_get_8 (abfd, (bfd_byte *)ptr); ++ ptr += 1; ++ ++ if(op_code >= opcode_base) ++ continue; ++ ++ switch(op_code) ++ { ++ case DW_LNS_extended_op: ++ ptr += 1; /* ignore length */ ++ op_code = bfd_get_8 (abfd, (bfd_byte *)ptr); ++ ptr += 1; ++ switch (op_code) ++ { ++ case DW_LNE_end_sequence: ++ /* end of sequence. Time to record stuff */ ++ lh->linfo[lh->numEntries++].length = ++ (bfd_byte *)ptr - sequence_start; ++ setupEntry = 1; ++ break; ++ case DW_LNE_set_address: ++ ptr += 4; ++ break; ++ case DW_LNE_define_file: ++ { ++ ptr += (strlen((char *)ptr) + 1); ++ (void) read_unsigned_leb128(abfd, ptr, &bytes_read); ++ ptr += bytes_read; ++ (void) read_unsigned_leb128(abfd, ptr, &bytes_read); ++ ptr += bytes_read; ++ (void) read_unsigned_leb128(abfd, ptr, &bytes_read); ++ ptr += bytes_read; ++ break; ++ } ++ } ++ case DW_LNS_negate_stmt: ++ case DW_LNS_set_basic_block: ++ case DW_LNS_const_add_pc: ++ case DW_LNS_copy: ++ break; ++ case DW_LNS_advance_pc: ++ case DW_LNS_set_file: ++ case DW_LNS_set_column: ++ (void) read_unsigned_leb128 (abfd, ptr, &bytes_read); ++ ptr += bytes_read; ++ break; ++ case DW_LNS_advance_line: ++ (void) read_signed_leb128 (abfd, ptr, &bytes_read); ++ ptr += bytes_read; ++ break; ++ case DW_LNS_fixed_advance_pc: ++ ptr += 2; ++ break; ++ } ++ } ++ ++ /* ++ * now scan through the relocations and match the ++ * lineinfo to a section name ++ */ ++ for(irel = irelbase; irel< irelend; irel++) ++ { ++ bfd_vma offset; ++ asection *sym_sec; ++ int i; ++ ++ offset = irel->r_offset; ++ isym = isymbuf + ELF32_R_SYM (irel->r_info); ++ ++ sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); ++ ++ /* find which line section this rel entry belongs to */ ++ for(i=0; i< (int) lh->numEntries; i++) ++ { ++ if(lh->linfo[i].startOffset <= offset && ++ offset < lh->linfo[i].startOffset + lh->linfo[i].length) ++ break; ++ } ++ ++ if(lh->linfo[i].sectionName == NULL) ++ lh->linfo[i].sectionName = strdup(sym_sec->name); ++ } ++ ++ /* now scan through and find the exclude sections */ ++ for (o = abfd->sections; o != NULL; o = o->next) ++ { ++ if (o->flags & SEC_EXCLUDE) ++ { ++ /* go through the lh entries and mark as discard */ ++ int i; ++ for(i=0; i< (int) lh->numEntries; i++) ++ { ++ if(!strcmp(o->name, lh->linfo[i].sectionName)) ++ lh->linfo[i].discard = 1; ++ } ++ } ++ } ++ ++ elf_section_data(sec)->sec_info = (PTR)(lh); ++ ++ return TRUE; ++} ++ ++ ++/* An extension of the elf hash table data structure, containing some ++ additional Blackfin-specific data. */ ++struct ubicom32fdpic_elf_link_hash_table ++{ ++ struct elf_link_hash_table elf; ++ ++ /* A pointer to the .got section. */ ++ asection *sgot; ++ /* A pointer to the .rel.got section. */ ++ asection *sgotrel; ++ /* A pointer to the .rofixup section. */ ++ asection *sgotfixup; ++ /* A pointer to the .plt section. */ ++ asection *splt; ++ /* A pointer to the .rel.plt section. */ ++ asection *spltrel; ++ /* GOT base offset. */ ++ bfd_vma got0; ++ /* Location of the first non-lazy PLT entry, i.e., the number of ++ bytes taken by lazy PLT entries. */ ++ bfd_vma plt0; ++ /* A hash table holding information about which symbols were ++ referenced with which PIC-related relocations. */ ++ struct htab *relocs_info; ++}; ++ ++/* Get the Ubicom32 ELF linker hash table from a link_info structure. */ ++ ++#define ubicom32fdpic_hash_table(info) \ ++ ((struct ubicom32fdpic_elf_link_hash_table *) ((info)->hash)) ++ ++#define ubicom32fdpic_got_section(info) \ ++ (ubicom32fdpic_hash_table (info)->sgot) ++#define ubicom32fdpic_gotrel_section(info) \ ++ (ubicom32fdpic_hash_table (info)->sgotrel) ++#define ubicom32fdpic_gotfixup_section(info) \ ++ (ubicom32fdpic_hash_table (info)->sgotfixup) ++#define ubicom32fdpic_plt_section(info) \ ++ (ubicom32fdpic_hash_table (info)->splt) ++#define ubicom32fdpic_pltrel_section(info) \ ++ (ubicom32fdpic_hash_table (info)->spltrel) ++#define ubicom32fdpic_relocs_info(info) \ ++ (ubicom32fdpic_hash_table (info)->relocs_info) ++#define ubicom32fdpic_got_initial_offset(info) \ ++ (ubicom32fdpic_hash_table (info)->got0) ++#define ubicom32fdpic_plt_initial_offset(info) \ ++ (ubicom32fdpic_hash_table (info)->plt0) ++ ++/* The name of the dynamic interpreter. This is put in the .interp ++ section. */ ++ ++#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1" ++ ++#define DEFAULT_STACK_SIZE 0x20000 ++ ++/* This structure is used to collect the number of entries present in ++ each addressable range of the got. */ ++struct _ubicom32fdpic_dynamic_got_info ++{ ++ /* Several bits of information about the current link. */ ++ struct bfd_link_info *info; ++ /* Total size needed for GOT entries. */ ++ bfd_vma gotoffset_lo, gotoffset_hi; ++ /* Total size needed for function descriptor entries. */ ++ bfd_vma fd_gotoffset_lo, fd_gotoffset_hi; ++ /* Total size needed function descriptor entries referenced in PLT ++ entries, that would be profitable to place in offsets close to ++ the PIC register. */ ++ bfd_vma fdplt, privfdplt; ++ /* Total size needed by lazy PLT entries. */ ++ bfd_vma lzplt; ++ bfd_vma num_plts; ++ ++ /* Number of relocations carried over from input object files. */ ++ unsigned long relocs; ++ /* Number of fixups introduced by relocations in input object files. */ ++ unsigned long fixups; ++}; ++ ++/* This structure is used to assign offsets to got entries, function ++ descriptors, plt entries and lazy plt entries. */ ++struct ubicom32fdpic_dynamic_got_plt_info ++{ ++ /* Summary information collected with _bfinfdpic_count_got_plt_entries. */ ++ struct _ubicom32fdpic_dynamic_got_info g; ++ ++ bfd_signed_vma current_got; /* This will be used during got entry allocation */ ++ bfd_signed_vma current_fd; /* This will be used for function descriptro allocation. The numbers will go negative */ ++ bfd_signed_vma current_privfd; /* This will be used for function descriptro allocation. The numbers will go negative */ ++ bfd_vma current_plt; /* This is the offset to the PLT entry. We will need this to resolve the call entries. */ ++ bfd_vma current_plt_trampoline; /* This is the offset to the PLT trampoline entry. */ ++ bfd_vma total_fdplt; /* Total size of function descriptors. This is the memory above GOT pointer. */ ++ bfd_vma total_got; /* This is the total of got entries for got_lo and got_funcdesc_lo references. */ ++ bfd_vma total_lzplt; /* This is the total area for the PLT entries. This does not have the trampoline entry. */ ++ bfd_vma total_trampoline; /* This is the total area for the PLT trampoline entries. */ ++}; ++ ++/* Decide whether a reference to a symbol can be resolved locally or ++ not. If the symbol is protected, we want the local address, but ++ its function descriptor must be assigned by the dynamic linker. */ ++#define UBICOM32FDPIC_SYM_LOCAL(INFO, H) \ ++ (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \ ++ || ! elf_hash_table (INFO)->dynamic_sections_created) ++#define UBICOM32FDPIC_FUNCDESC_LOCAL(INFO, H) \ ++ ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created) ++ ++/* This structure collects information on what kind of GOT, PLT or ++ function descriptors are required by relocations that reference a ++ certain symbol. */ ++struct ubicom32fdpic_relocs_info ++{ ++ /* The index of the symbol, as stored in the relocation r_info, if ++ we have a local symbol; -1 otherwise. */ ++ long symndx; ++ union ++ { ++ /* The input bfd in which the symbol is defined, if it's a local ++ symbol. */ ++ bfd *abfd; ++ /* If symndx == -1, the hash table entry corresponding to a global ++ symbol (even if it turns out to bind locally, in which case it ++ should ideally be replaced with section's symndx + addend). */ ++ struct elf_link_hash_entry *h; ++ } d; ++ /* The addend of the relocation that references the symbol. */ ++ bfd_vma addend; ++ ++ /* The fields above are used to identify an entry. The fields below ++ contain information on how an entry is used and, later on, which ++ locations it was assigned. */ ++ /* The following 2 fields record whether the symbol+addend above was ++ ever referenced with a GOT relocation. The 17M4 suffix indicates a ++ GOT17M4 relocation; hilo is used for GOTLO/GOTHI pairs. */ ++ unsigned gotoffset_lo; ++ unsigned gotoffset_hi; ++ /* Whether a FUNCDESC relocation references symbol+addend. */ ++ unsigned fd; ++ /* Whether a FUNCDESC_GOT relocation references symbol+addend. */ ++ unsigned fd_gotoffset_lo; ++ unsigned fd_gotoffset_hi; ++ /* Whether symbol+addend is referenced with GOTOFF17M4, GOTOFFLO or ++ GOTOFFHI relocations. The addend doesn't really matter, since we ++ envision that this will only be used to check whether the symbol ++ is mapped to the same segment as the got. */ ++ unsigned gotoff; ++ /* Whether symbol+addend is referenced by a LABEL24 relocation. */ ++ unsigned call; ++ /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE ++ relocation. */ ++ unsigned sym; ++ /* Whether we need a PLT entry for a symbol. Should be implied by ++ something like: ++ (call && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)) */ ++ unsigned plt:1; ++ /* Whether a function descriptor should be created in this link unit ++ for symbol+addend. Should be implied by something like: ++ (plt || fd_gotoffset_lo || fd_gotoffset_hi ++ || ((fd || fdgot17m4 || fdgothilo) ++ && (symndx != -1 || BFINFDPIC_FUNCDESC_LOCAL (info, d.h)))) */ ++ unsigned privfd:1; ++ /* Whether a lazy PLT entry is needed for this symbol+addend. ++ Should be implied by something like: ++ (privfd && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h) ++ && ! (info->flags & DF_BIND_NOW)) */ ++ unsigned lazyplt:1; ++ /* Whether we've already emitted GOT relocations and PLT entries as ++ needed for this symbol. */ ++ unsigned done:1; ++ ++ /* The number of R_byte4_data, R_BFIN_FUNCDESC and R_BFIN_FUNCDESC_VALUE ++ relocations referencing the symbol. */ ++ unsigned relocs32, relocsfd, relocsfdv; ++ ++ /* The number of .rofixups entries and dynamic relocations allocated ++ for this symbol, minus any that might have already been used. */ ++ unsigned fixups, dynrelocs; ++ ++ /* The offsets of the GOT entries assigned to symbol+addend, to the ++ function descriptor's address, and to a function descriptor, ++ respectively. Should be zero if unassigned. The offsets are ++ counted from the value that will be assigned to the PIC register, ++ not from the beginning of the .got section. */ ++ bfd_signed_vma got_entry, fdgot_entry, fd_entry; ++ /* The offsets of the PLT entries assigned to symbol+addend, ++ non-lazy and lazy, respectively. If unassigned, should be ++ (bfd_vma)-1. */ ++ bfd_vma plt_entry; ++ bfd_vma plt_trampoline_entry; ++ ++ /* plt_type is 1 for Sequence type 2 (0 - 255) it is 2 for > 255 */ ++ bfd_vma plt_type; ++ ++ /* rel_offset. Plt relocation offset need to be encoded into the plt entry. */ ++ bfd_vma rel_offset; ++ ++ /* bfd_vma lzplt_entry; not used in ubicom32 */ ++}; ++ ++/* Compute the total GOT size required by each symbol in each range. ++ Symbols may require up to 4 words in the GOT: an entry pointing to ++ the symbol, an entry pointing to its function descriptor, and a ++ private function descriptors taking two words. */ ++ ++#if 0 ++static bfd_vma plt_code[] = { ++ 0xc90f0000, //movei d15,#0 ++ 0x0123e30f, //lea.4 a3,(a0,d15) ++ 0x0124630f, //move.4 a4,(a0,d15) ++ 0x01206461, //move.4 a0,4(a3) ++ 0xf0800080, //calli a4,0(a4) ++}; ++#endif ++ ++static bfd_vma plt_trampoline[] = { ++ 0xc9280000, // movei mac_hi,#0 ++ 0x00002400, // ret (a0) ++}; ++ ++static bfd_vma plt_code_seq1[] = { ++ 0xc90fffe8, //movei d15,#-24 ++ 0x0123e30f, //lea.4 a3,(a0,d15) ++ 0x01206461, //move.4 a0,4(a3) ++ 0x00002460, //ret (a3) ++}; ++ ++static bfd_vma plt_code_seq2[] = { ++ 0x0123f71f, // pdec a3,4(a0) ++ 0x01206461, // move.4 a0,4(a3) ++ 0x00002460, // ret (a3) ++}; ++ ++#define NUM_PLT_CODE_WORDS (sizeof (plt_code) / sizeof (bfd_vma)) ++#define LZPLT_NORMAL_SIZE (sizeof(plt_code)) ++ ++#define NUM_PLT_CODE_WORDS_SEQ1 (sizeof (plt_code_seq1) / sizeof (bfd_vma)) ++#define LZPLT_SIZE_SEQ1 (sizeof(plt_code_seq1)) ++ ++#define NUM_PLT_CODE_WORDS_SEQ2 (sizeof (plt_code_seq2) / sizeof (bfd_vma)) ++#define LZPLT_SIZE_SEQ2 (sizeof(plt_code_seq2)) ++ ++#define NUM_PLT_TRAMPOLINE_WORDS (sizeof (plt_trampoline) / sizeof (bfd_vma)) ++#define PLT_TRAMPOLINE_SIZE (sizeof(plt_trampoline)) ++ ++//#define FUNCTION_DESCRIPTOR_SIZE 12 ++#define FUNCTION_DESCRIPTOR_SIZE 8 ++/* Decide whether a reference to a symbol can be resolved locally or ++ not. If the symbol is protected, we want the local address, but ++ its function descriptor must be assigned by the dynamic linker. */ ++#define UBICOM32FPIC_SYM_LOCAL(INFO, H) \ ++ (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \ ++ || ! elf_hash_table (INFO)->dynamic_sections_created) ++#define UBICOM32FPIC_FUNCDESC_LOCAL(INFO, H) \ ++ ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created) ++ ++ ++static int ++ubicom32fdpic_count_got_plt_entries (void **entryp, void *dinfo_) ++{ ++ struct ubicom32fdpic_relocs_info *entry = *entryp; ++ struct _ubicom32fdpic_dynamic_got_info *dinfo = dinfo_; ++ unsigned relocs = 0, fixups = 0; ++ ++ /* Allocate space for a GOT entry pointing to the symbol. */ ++ if (entry->gotoffset_lo) ++ { ++ dinfo->gotoffset_lo += 4; ++ entry->relocs32++; ++ } ++ ++ /* Allocate space for a GOT entry pointing to the function ++ descriptor. */ ++ if (entry->fd_gotoffset_lo) ++ { ++ dinfo->gotoffset_lo += 4; ++ entry->relocsfd++; ++ } ++ else if (entry->fd_gotoffset_hi) ++ { ++ dinfo->gotoffset_lo += 4; ++ entry->relocsfd++; ++ } ++ ++ /* Decide whether we need a PLT entry, a function descriptor in the ++ GOT, and a lazy PLT entry for this symbol. */ ++ entry->plt = entry->call ++ && entry->symndx == -1 && ! UBICOM32FPIC_SYM_LOCAL (dinfo->info, entry->d.h) ++ && elf_hash_table (dinfo->info)->dynamic_sections_created; ++ entry->privfd = entry->plt ++ || ((entry->fd_gotoffset_lo || entry->fd_gotoffset_hi || entry->fd) ++ && (entry->symndx != -1 ++ || UBICOM32FPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))); ++ entry->lazyplt = entry->privfd ++ && entry->symndx == -1 && ! UBICOM32FPIC_SYM_LOCAL (dinfo->info, entry->d.h) ++ && ! (dinfo->info->flags & DF_BIND_NOW) ++ && elf_hash_table (dinfo->info)->dynamic_sections_created; ++ ++ /* Allocate space for a function descriptor. */ ++ if (entry->privfd && entry->plt) ++ { ++ dinfo->fdplt += FUNCTION_DESCRIPTOR_SIZE; ++ entry->relocsfdv++; ++ } ++ else if (entry->privfd) ++ { ++ /* privfd with plt = 0 */ ++ //printf("Privfd set with plt 0 gotoff_lo = %d fd_gotoffset_lo = %d entry = 0x%x\n", entry->gotoffset_lo, entry->fd_gotoffset_lo, entry); ++ //printf("symnxd = 0x%x sym_local = %d funcdesc_local = %d\n", entry->symndx, ++ // UBICOM32FPIC_SYM_LOCAL (dinfo->info, entry->d.h), ++ // UBICOM32FPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)); ++ //printf("Name = %s\n\n", entry->d.h->root.root.string); ++ dinfo->privfdplt += FUNCTION_DESCRIPTOR_SIZE; ++ entry->relocsfdv++; ++ } ++ ++ ++ if (entry->lazyplt) ++ { ++ //dinfo->lzplt += LZPLT_NORMAL_SIZE; ++ dinfo->num_plts++; ++ ++#if 0 ++ if (dinfo->num_plts > 256) ++ dinfo->lzplt += LZPLT_SIZE_SEQ1; ++ else ++ dinfo->lzplt += LZPLT_SIZE_SEQ2; ++ ++ DPRINTF("lzplt %d num_plt %d\n", dinfo->lzplt, dinfo->num_plts); ++#endif ++ } ++ ++ if (!dinfo->info->executable || dinfo->info->pie) ++ relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv; ++ else ++ { ++ if (entry->symndx != -1 || UBICOM32FPIC_SYM_LOCAL (dinfo->info, entry->d.h)) ++ { ++ if (entry->symndx != -1 ++ || entry->d.h->root.type != bfd_link_hash_undefweak) ++ fixups += entry->relocs32 + 2 * entry->relocsfdv; ++ } ++ else ++ relocs += entry->relocs32 + entry->relocsfdv; ++ ++ if (entry->symndx != -1 ++ || UBICOM32FPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)) ++ { ++ if (entry->symndx != -1 ++ || entry->d.h->root.type != bfd_link_hash_undefweak) ++ fixups += entry->relocsfd; ++ } ++ else ++ relocs += entry->relocsfd; ++ } ++ ++ entry->dynrelocs += relocs; ++ entry->fixups += fixups; ++ dinfo->relocs += relocs; ++ dinfo->fixups += fixups; ++ ++ return 1; ++} ++ ++/* Create a Ubicom32 ELF linker hash table. */ ++static struct bfd_link_hash_table * ++ubicom32fdpic_elf_link_hash_table_create (bfd *abfd) ++{ ++ struct ubicom32fdpic_elf_link_hash_table *ret; ++ bfd_size_type amt = sizeof (struct ubicom32fdpic_elf_link_hash_table); ++ ++ ret = bfd_zalloc (abfd, amt); ++ if (ret == NULL) ++ return NULL; ++ ++ if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, ++ _bfd_elf_link_hash_newfunc, ++ sizeof (struct elf_link_hash_entry))) ++ { ++ free (ret); ++ return NULL; ++ } ++ ++ return &ret->elf.root; ++} ++ ++/* Compute a hash with the key fields of an ubicom32fdpic_relocs_info entry. */ ++static hashval_t ++ubicom32fdpic_relocs_info_hash (const void *entry_) ++{ ++ const struct ubicom32fdpic_relocs_info *entry = entry_; ++ ++ return (entry->symndx == -1 ++ ? (long) entry->d.h->root.root.hash ++ : entry->symndx + (long) entry->d.abfd->id * 257) + entry->addend; ++} ++ ++/* Test whether the key fields of two ubicom32fdpic_relocs_info entries are ++ identical. */ ++static int ++ubicom32fdpic_relocs_info_eq (const void *entry1, const void *entry2) ++{ ++ const struct ubicom32fdpic_relocs_info *e1 = entry1; ++ const struct ubicom32fdpic_relocs_info *e2 = entry2; ++ ++ return e1->symndx == e2->symndx && e1->addend == e2->addend ++ && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd); ++} ++ ++/* Find or create an entry in a hash table HT that matches the key ++ fields of the given ENTRY. If it's not found, memory for a new ++ entry is allocated in ABFD's obstack. */ ++static struct ubicom32fdpic_relocs_info * ++ubicom32fdpic_relocs_info_find (struct htab *ht, ++ bfd *abfd, ++ const struct ubicom32fdpic_relocs_info *entry, ++ enum insert_option insert) ++{ ++ struct ubicom32fdpic_relocs_info **loc = ++ (struct ubicom32fdpic_relocs_info **) htab_find_slot (ht, entry, insert); ++ ++ if (! loc) ++ return NULL; ++ ++ if (*loc) ++ return *loc; ++ ++ *loc = bfd_zalloc (abfd, sizeof (**loc)); ++ ++ if (! *loc) ++ return *loc; ++ ++ (*loc)->symndx = entry->symndx; ++ (*loc)->d = entry->d; ++ (*loc)->addend = entry->addend; ++ (*loc)->plt_entry = (bfd_vma)-1; ++ /* (*loc)->lzplt_entry = (bfd_vma)-1; */ ++ ++ return *loc; ++} ++ ++/* Obtain the address of the entry in HT associated with H's symbol + ++ addend, creating a new entry if none existed. ABFD is only used ++ for memory allocation purposes. */ ++inline static struct ubicom32fdpic_relocs_info * ++ubicom32fdpic_relocs_info_for_global (struct htab *ht, ++ bfd *abfd, ++ struct elf_link_hash_entry *h, ++ bfd_vma addend, ++ enum insert_option insert) ++{ ++ struct ubicom32fdpic_relocs_info entry; ++ ++ entry.symndx = -1; ++ entry.d.h = h; ++ entry.addend = addend; ++ ++ return ubicom32fdpic_relocs_info_find (ht, abfd, &entry, insert); ++} ++ ++/* Obtain the address of the entry in HT associated with the SYMNDXth ++ local symbol of the input bfd ABFD, plus the addend, creating a new ++ entry if none existed. */ ++inline static struct ubicom32fdpic_relocs_info * ++ubicom32fdpic_relocs_info_for_local (struct htab *ht, ++ bfd *abfd, ++ long symndx, ++ bfd_vma addend, ++ enum insert_option insert) ++{ ++ struct ubicom32fdpic_relocs_info entry; ++ ++ entry.symndx = symndx; ++ entry.d.abfd = abfd; ++ entry.addend = addend; ++ ++ return ubicom32fdpic_relocs_info_find (ht, abfd, &entry, insert); ++} ++ ++/* Merge fields set by check_relocs() of two entries that end up being ++ mapped to the same (presumably global) symbol. */ ++ ++inline static void ++ubicom32fdpic_pic_merge_early_relocs_info (struct ubicom32fdpic_relocs_info *e2, ++ struct ubicom32fdpic_relocs_info const *e1) ++{ ++ e2->gotoffset_lo |= e1->gotoffset_lo; ++ e2->gotoffset_hi |= e1->gotoffset_hi; ++ e2->fd_gotoffset_lo |= e1->fd_gotoffset_lo; ++ e2->fd_gotoffset_hi |= e1->fd_gotoffset_hi; ++ e2->fd |= e1->fd; ++ e2->gotoff |= e1->gotoff; ++ e2->call |= e1->call; ++ e2->sym |= e1->sym; ++} ++ ++/* Add a dynamic relocation to the SRELOC section. */ ++ ++inline static bfd_vma ++ubicom32fdpic_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset, ++ int reloc_type, long dynindx, bfd_vma addend, ++ struct ubicom32fdpic_relocs_info *entry) ++{ ++ Elf_Internal_Rela outrel; ++ bfd_vma reloc_offset; ++ ++ outrel.r_offset = offset; ++ outrel.r_info = ELF32_R_INFO (dynindx, reloc_type); ++ outrel.r_addend = addend; ++ ++ reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel); ++ BFD_ASSERT (reloc_offset < sreloc->size); ++ bfd_elf32_swap_reloc_out (output_bfd, &outrel, ++ sreloc->contents + reloc_offset); ++ sreloc->reloc_count++; ++ ++ /* If the entry's index is zero, this relocation was probably to a ++ linkonce section that got discarded. We reserved a dynamic ++ relocation, but it was for another entry than the one we got at ++ the time of emitting the relocation. Unfortunately there's no ++ simple way for us to catch this situation, since the relocation ++ is cleared right before calling relocate_section, at which point ++ we no longer know what the relocation used to point to. */ ++ if (entry->symndx) ++ { ++ BFD_ASSERT (entry->dynrelocs > 0); ++ entry->dynrelocs--; ++ } ++ ++ return reloc_offset; ++} ++ ++/* Add a fixup to the ROFIXUP section. */ ++ ++static bfd_vma ++ubicom32fdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset, ++ struct ubicom32fdpic_relocs_info *entry) ++{ ++ bfd_vma fixup_offset; ++ ++ if (rofixup->flags & SEC_EXCLUDE) ++ return -1; ++ ++ fixup_offset = rofixup->reloc_count * 4; ++ if (rofixup->contents) ++ { ++ BFD_ASSERT (fixup_offset < rofixup->size); ++ bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset); ++ } ++ rofixup->reloc_count++; ++ ++ if (entry && entry->symndx) ++ { ++ /* See discussion about symndx == 0 in _ubicom32fdpic_add_dyn_reloc ++ above. */ ++ BFD_ASSERT (entry->fixups > 0); ++ entry->fixups--; ++ } ++ ++ return fixup_offset; ++} ++ ++/* Find the segment number in which OSEC, and output section, is ++ located. */ ++ ++static unsigned ++ubicom32fdpic_osec_to_segment (bfd *output_bfd, asection *osec) ++{ ++ Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section (output_bfd, osec); ++ ++ return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1; ++} ++ ++inline static bfd_boolean ++ubicom32fdpic_osec_readonly_p (bfd *output_bfd, asection *osec) ++{ ++ unsigned seg = ubicom32fdpic_osec_to_segment (output_bfd, osec); ++ ++ return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W); ++} ++ ++#if 0 ++static bfd_vma plt_trampoline[] = { ++ 0x00002400, //ret (a0) ++}; ++#endif ++ ++/* Generate relocations for GOT entries, function descriptors, and ++ code for PLT and lazy PLT entries. */ ++ ++static bfd_boolean ++ubicom32fdpic_emit_got_relocs_plt_entries (struct ubicom32fdpic_relocs_info *entry, ++ bfd *output_bfd, ++ struct bfd_link_info *info, ++ asection *sec, ++ Elf_Internal_Sym *sym, ++ bfd_vma addend) ++ ++{ ++ bfd_vma fd_lazy_rel_offset = (bfd_vma)-1; ++ int dynindx = -1; ++ ++ if (entry->done) ++ return TRUE; ++ entry->done = 1; ++ ++ if (entry->got_entry || entry->fdgot_entry || entry->fd_entry) ++ { ++ DPRINTF(" emit %p got %d fdgot %d fd %d addend %d\n", entry, entry->got_entry, entry->fdgot_entry, entry->fd_entry, addend); ++ /* If the symbol is dynamic, consider it for dynamic ++ relocations, otherwise decay to section + offset. */ ++ if (entry->symndx == -1 && entry->d.h->dynindx != -1) ++ dynindx = entry->d.h->dynindx; ++ else ++ { ++ if (sec->output_section ++ && ! bfd_is_abs_section (sec->output_section) ++ && ! bfd_is_und_section (sec->output_section)) ++ dynindx = elf_section_data (sec->output_section)->dynindx; ++ else ++ dynindx = 0; ++ } ++ } ++ ++ /* Generate relocation for GOT entry pointing to the symbol. */ ++ if (entry->got_entry) ++ { ++ DPRINTF(" emit got entry %d:%p\n", entry->got_entry, entry); ++ ++ int idx = dynindx; ++ bfd_vma ad = addend; ++ ++ /* If the symbol is dynamic but binds locally, use ++ section+offset. */ ++ if (sec && (entry->symndx != -1 ++ || UBICOM32FDPIC_SYM_LOCAL (info, entry->d.h))) ++ { ++ if (entry->symndx == -1) ++ ad += entry->d.h->root.u.def.value; ++ else ++ ad += sym->st_value; ++ ad += sec->output_offset; ++ if (sec->output_section && elf_section_data (sec->output_section)) ++ idx = elf_section_data (sec->output_section)->dynindx; ++ else ++ idx = 0; ++ } ++ ++ /* If we're linking an executable at a fixed address, we can ++ omit the dynamic relocation as long as the symbol is local to ++ this module. */ ++ if (info->executable && !info->pie ++ && (entry->symndx != -1 ++ || UBICOM32FDPIC_SYM_LOCAL (info, entry->d.h))) ++ { ++ if (sec) ++ ad += sec->output_section->vma; ++ if (entry->symndx != -1 ++ || entry->d.h->root.type != bfd_link_hash_undefweak) ++ ubicom32fdpic_add_rofixup (output_bfd, ++ ubicom32fdpic_gotfixup_section (info), ++ ubicom32fdpic_got_section (info)->output_section->vma ++ + ubicom32fdpic_got_section (info)->output_offset ++ + ubicom32fdpic_got_initial_offset (info) ++ + entry->got_entry, entry); ++ } ++ else ++ ubicom32fdpic_add_dyn_reloc (output_bfd, ubicom32fdpic_gotrel_section (info), ++ _bfd_elf_section_offset ++ (output_bfd, info, ++ ubicom32fdpic_got_section (info), ++ ubicom32fdpic_got_initial_offset (info) ++ + entry->got_entry) ++ + ubicom32fdpic_got_section (info) ++ ->output_section->vma ++ + ubicom32fdpic_got_section (info)->output_offset, ++ R_UBICOM32_32, idx, ad, entry); ++ ++ bfd_put_32 (output_bfd, ad, ++ ubicom32fdpic_got_section (info)->contents ++ + ubicom32fdpic_got_initial_offset (info) ++ + entry->got_entry); ++ } ++ ++ /* Generate relocation for GOT entry pointing to a canonical ++ function descriptor. */ ++ if (entry->fdgot_entry) ++ { ++ DPRINTF(" emit got fdgot entry %d:%p\n", entry->fdgot_entry, entry); ++ ++ int reloc, idx; ++ bfd_vma ad = 0; ++ ++ if (! (entry->symndx == -1 ++ && entry->d.h->root.type == bfd_link_hash_undefweak ++ && UBICOM32FDPIC_SYM_LOCAL (info, entry->d.h))) ++ { ++ /* If the symbol is dynamic and there may be dynamic symbol ++ resolution because we are, or are linked with, a shared ++ library, emit a FUNCDESC relocation such that the dynamic ++ linker will allocate the function descriptor. If the ++ symbol needs a non-local function descriptor but binds ++ locally (e.g., its visibility is protected, emit a ++ dynamic relocation decayed to section+offset. */ ++ if (entry->symndx == -1 ++ && ! UBICOM32FDPIC_FUNCDESC_LOCAL (info, entry->d.h) ++ && UBICOM32FDPIC_SYM_LOCAL (info, entry->d.h) ++ && !(info->executable && !info->pie)) ++ { ++ reloc = R_UBICOM32_FUNCDESC; ++ idx = elf_section_data (entry->d.h->root.u.def.section ++ ->output_section)->dynindx; ++ ad = entry->d.h->root.u.def.section->output_offset ++ + entry->d.h->root.u.def.value; ++ } ++ else if (entry->symndx == -1 ++ && ! UBICOM32FDPIC_FUNCDESC_LOCAL (info, entry->d.h)) ++ { ++ reloc = R_UBICOM32_FUNCDESC; ++ idx = dynindx; ++ ad = addend; ++ if (ad) ++ return FALSE; ++ } ++ else ++ { ++ /* Otherwise, we know we have a private function descriptor, ++ so reference it directly. */ ++ if (elf_hash_table (info)->dynamic_sections_created) ++ BFD_ASSERT (entry->privfd); ++ reloc = R_UBICOM32_32; ++ idx = elf_section_data (ubicom32fdpic_got_section (info) ++ ->output_section)->dynindx; ++ ad = ubicom32fdpic_got_section (info)->output_offset ++ + ubicom32fdpic_got_initial_offset (info) + entry->fd_entry; ++ } ++ ++ /* If there is room for dynamic symbol resolution, emit the ++ dynamic relocation. However, if we're linking an ++ executable at a fixed location, we won't have emitted a ++ dynamic symbol entry for the got section, so idx will be ++ zero, which means we can and should compute the address ++ of the private descriptor ourselves. */ ++ if (info->executable && !info->pie ++ && (entry->symndx != -1 ++ || UBICOM32FDPIC_FUNCDESC_LOCAL (info, entry->d.h))) ++ { ++ ad += ubicom32fdpic_got_section (info)->output_section->vma; ++ ubicom32fdpic_add_rofixup (output_bfd, ++ ubicom32fdpic_gotfixup_section (info), ++ ubicom32fdpic_got_section (info) ++ ->output_section->vma ++ + ubicom32fdpic_got_section (info) ++ ->output_offset ++ + ubicom32fdpic_got_initial_offset (info) ++ + entry->fdgot_entry, entry); ++ } ++ else ++ ubicom32fdpic_add_dyn_reloc (output_bfd, ++ ubicom32fdpic_gotrel_section (info), ++ _bfd_elf_section_offset ++ (output_bfd, info, ++ ubicom32fdpic_got_section (info), ++ ubicom32fdpic_got_initial_offset (info) ++ + entry->fdgot_entry) ++ + ubicom32fdpic_got_section (info) ++ ->output_section->vma ++ + ubicom32fdpic_got_section (info) ++ ->output_offset, ++ reloc, idx, ad, entry); ++ } ++ ++ bfd_put_32 (output_bfd, ad, ++ ubicom32fdpic_got_section (info)->contents ++ + ubicom32fdpic_got_initial_offset (info) ++ + entry->fdgot_entry); ++ } ++ ++ /* Generate relocation to fill in a private function descriptor in ++ the GOT. */ ++ if (entry->fd_entry) ++ { ++ ++ int idx = dynindx; ++ bfd_vma ad = addend; ++ bfd_vma ofst; ++ long lowword, highword; ++ ++ /* If the symbol is dynamic but binds locally, use ++ section+offset. */ ++ if (sec && (entry->symndx != -1 ++ || UBICOM32FDPIC_SYM_LOCAL (info, entry->d.h))) ++ { ++ if (entry->symndx == -1) ++ ad += entry->d.h->root.u.def.value; ++ else ++ ad += sym->st_value; ++ ad += sec->output_offset; ++ if (sec->output_section && elf_section_data (sec->output_section)) ++ idx = elf_section_data (sec->output_section)->dynindx; ++ else ++ idx = 0; ++ } ++ ++ /* If we're linking an executable at a fixed address, we can ++ omit the dynamic relocation as long as the symbol is local to ++ this module. */ ++ if (info->executable && !info->pie ++ && (entry->symndx != -1 || UBICOM32FDPIC_SYM_LOCAL (info, entry->d.h))) ++ { ++ if (sec) ++ ad += sec->output_section->vma; ++ ofst = 0; ++ if (entry->symndx != -1 ++ || entry->d.h->root.type != bfd_link_hash_undefweak) ++ { ++ ubicom32fdpic_add_rofixup (output_bfd, ++ ubicom32fdpic_gotfixup_section (info), ++ ubicom32fdpic_got_section (info) ++ ->output_section->vma ++ + ubicom32fdpic_got_section (info) ++ ->output_offset ++ + ubicom32fdpic_got_initial_offset (info) ++ + entry->fd_entry, entry); ++ ubicom32fdpic_add_rofixup (output_bfd, ++ ubicom32fdpic_gotfixup_section (info), ++ ubicom32fdpic_got_section (info) ++ ->output_section->vma ++ + ubicom32fdpic_got_section (info) ++ ->output_offset ++ + ubicom32fdpic_got_initial_offset (info) ++ + entry->fd_entry + 4, entry); ++ } ++ } ++ else ++ { ++ ofst ++ = ubicom32fdpic_add_dyn_reloc (output_bfd, ++ entry->lazyplt ++ ? ubicom32fdpic_pltrel_section (info) ++ : ubicom32fdpic_gotrel_section (info), ++ _bfd_elf_section_offset ++ (output_bfd, info, ++ ubicom32fdpic_got_section (info), ++ ubicom32fdpic_got_initial_offset (info) ++ + entry->fd_entry) ++ + ubicom32fdpic_got_section (info) ++ ->output_section->vma ++ + ubicom32fdpic_got_section (info) ++ ->output_offset, ++ R_UBICOM32_FUNCDESC_VALUE, idx, ad, entry); ++ } ++ ++ /* If we've omitted the dynamic relocation, just emit the fixed ++ addresses of the symbol and of the local GOT base offset. */ ++ if (info->executable && !info->pie && sec && sec->output_section) ++ { ++ lowword = ad; ++ highword = ubicom32fdpic_got_section (info)->output_section->vma ++ + ubicom32fdpic_got_section (info)->output_offset ++ + ubicom32fdpic_got_initial_offset (info); ++ } ++ else if (entry->lazyplt) ++ { ++ if (ad) ++ return FALSE; ++ ++ fd_lazy_rel_offset = ofst; ++ ++ /* A function descriptor used for lazy or local resolving is ++ initialized such that its high word contains the output ++ section index in which the PLT entries are located, and ++ the low word contains the address to the base of the PLT. ++ That location contains the PLT trampoline instruction ret 0(a0). ++ assigned to that section. */ ++ lowword = ubicom32fdpic_plt_section (info)->output_offset ++ + ubicom32fdpic_plt_section (info)->output_section->vma + entry->plt_trampoline_entry; ++ highword = ubicom32fdpic_osec_to_segment ++ (output_bfd, ubicom32fdpic_plt_section (info)->output_section); ++ } ++ else ++ { ++ /* A function descriptor for a local function gets the index ++ of the section. For a non-local function, it's ++ disregarded. */ ++ lowword = ad; ++ if (entry->symndx == -1 && entry->d.h->dynindx != -1 ++ && entry->d.h->dynindx == idx) ++ highword = 0; ++ else ++ highword = ubicom32fdpic_osec_to_segment ++ (output_bfd, sec->output_section); ++ } ++ ++ DPRINTF(" emit got fd_entry %d:%p lw 0x%x hw 0x%x fd_l_r_off 0x%x\n", entry->fd_entry, entry, lowword, highword, fd_lazy_rel_offset); ++ ++ ++ bfd_put_32 (output_bfd, lowword, ++ ubicom32fdpic_got_section (info)->contents ++ + ubicom32fdpic_got_initial_offset (info) ++ + entry->fd_entry); ++ bfd_put_32 (output_bfd, highword, ++ ubicom32fdpic_got_section (info)->contents ++ + ubicom32fdpic_got_initial_offset (info) ++ + entry->fd_entry + 4); ++ ++#if 0 ++ /* Load the fixup offset here. */ ++ bfd_put_32 (output_bfd, fd_lazy_rel_offset, ++ ubicom32fdpic_got_section (info)->contents ++ + ubicom32fdpic_got_initial_offset (info) ++ + entry->fd_entry + 8); ++#endif ++ ++ entry->rel_offset = fd_lazy_rel_offset; ++ } ++ ++ /* Generate code for the PLT entry. */ ++ if (entry->plt_entry != (bfd_vma) -1) ++ { ++ static output_trampoline_code = 1; ++ bfd_byte *plt_output_code = ubicom32fdpic_plt_section (info)->contents; ++ int i; ++ bfd_vma *plt_code; ++ ++ DPRINTF(" emit fd entry %x:%p plt=%2x code=%p\n", entry->fd_entry, entry, entry->plt_entry, plt_output_code); ++ ++#if 0 ++ if (output_trampoline_code) ++ { ++ /* output the trampoline code.*/ ++ bfd_put_32 (output_bfd, plt_trampoline[0], plt_output_code); ++ } ++#endif ++ ++ /* output the trampoline entry. */ ++ ++ plt_output_code += entry->plt_trampoline_entry; ++ plt_code = plt_trampoline; ++ plt_code[0] = (plt_code[0] & 0xFFFF0000) | (entry->rel_offset &0xffff); ++ bfd_put_32 (output_bfd, plt_code[0], plt_output_code); ++ bfd_put_32 (output_bfd, plt_code[1], plt_output_code + 4); ++ ++ ++ /* output the plt itself. */ ++ plt_output_code = ubicom32fdpic_plt_section (info)->contents; ++ plt_output_code += entry->plt_entry; ++ BFD_ASSERT (entry->fd_entry); ++ ++ if (entry->plt_type == 2) ++ { ++ bfd_vma data_lo = (entry->fd_entry >> 2) & 0xff; ++ ++ /* Output seqence 2. */ ++ plt_code = plt_code_seq2; ++ ++ /* Code the entry into the PDEC instruction. */ ++ plt_code[0] &= 0xFFFFF8E0; ++ plt_code[0] |= (data_lo & 0x1F); ++ plt_code[0] |= (data_lo & 0xE0) << 3; ++ ++ /* Write out the sequence. */ ++ for (i = 0; i < NUM_PLT_CODE_WORDS_SEQ2; i++) ++ { ++ bfd_put_32 (output_bfd, plt_code[i], plt_output_code); ++ plt_output_code += 4; ++ } ++ } ++ else if (entry->plt_type == 1) ++ { ++ /* Outupt sequence 1 */ ++ plt_code = plt_code_seq1; ++ ++ /* Code the entry into the movei instruction. */ ++ plt_code[0] = (plt_code[0] & 0xFFFF0000) | ((entry->fd_entry >> 2) & 0xFFFF); ++ ++ /* Write out the sequence. */ ++ for (i = 0; i < NUM_PLT_CODE_WORDS_SEQ1; i++) ++ { ++ bfd_put_32 (output_bfd, plt_code[i], plt_output_code); ++ plt_output_code += 4; ++ } ++ } ++ else ++ BFD_ASSERT(0); ++ ++#if 0 ++ /* We have to output 5 words. The very first movei has to be modified with whatever is in fd_entry. */ ++ plt_code[0] = (plt_code[0] & 0xFFFF0000) | ((entry->fd_entry >> 2) & 0xFFFF); ++ ++ for (i = 0; i < NUM_PLT_CODE_WORDS; i++) ++ { ++ bfd_put_32 (output_bfd, plt_code[i], plt_output_code); ++ plt_output_code += 4; ++ } ++#endif ++ } ++ ++ return TRUE; ++} ++ ++ ++/* Create a .got section, as well as its additional info field. This ++ is almost entirely copied from ++ elflink.c:_bfd_elf_create_got_section(). */ ++ ++static bfd_boolean ++ubicom32fdpic_elf_create_got_section (bfd *abfd, struct bfd_link_info *info) ++{ ++ flagword flags, pltflags; ++ asection *s; ++ struct elf_link_hash_entry *h; ++ const struct elf_backend_data *bed = get_elf_backend_data (abfd); ++ int ptralign; ++ int offset; ++ ++ /* This function may be called more than once. */ ++ s = bfd_get_section_by_name (abfd, ".got"); ++ if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0) ++ return TRUE; ++ ++ /* Machine specific: although pointers are 32-bits wide, we want the ++ GOT to be aligned to a 64-bit boundary, such that function ++ descriptors in it can be accessed with 64-bit loads and ++ stores. */ ++ ptralign = 3; ++ ++ flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY ++ | SEC_LINKER_CREATED); ++ pltflags = flags; ++ ++ s = bfd_make_section_with_flags (abfd, ".got", flags); ++ if (s == NULL ++ || !bfd_set_section_alignment (abfd, s, ptralign)) ++ return FALSE; ++ ++ if (bed->want_got_plt) ++ { ++ s = bfd_make_section_with_flags (abfd, ".got.plt", flags); ++ if (s == NULL ++ || !bfd_set_section_alignment (abfd, s, ptralign)) ++ return FALSE; ++ } ++ ++ if (bed->want_got_sym) ++ { ++ /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got ++ (or .got.plt) section. We don't do this in the linker script ++ because we don't want to define the symbol if we are not creating ++ a global offset table. */ ++ h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_"); ++ elf_hash_table (info)->hgot = h; ++ if (h == NULL) ++ return FALSE; ++ ++ /* Machine-specific: we want the symbol for executables as ++ well. */ ++ if (! bfd_elf_link_record_dynamic_symbol (info, h)) ++ return FALSE; ++ } ++ ++ /* The first bit of the global offset table is the header. */ ++ s->size += bed->got_header_size; ++ ++ /* This is the machine-specific part. Create and initialize section ++ data for the got. */ ++ if (IS_FDPIC (abfd)) ++ { ++ ubicom32fdpic_got_section (info) = s; ++ ubicom32fdpic_relocs_info (info) = htab_try_create (1, ++ ubicom32fdpic_relocs_info_hash, ++ ubicom32fdpic_relocs_info_eq, ++ (htab_del) NULL); ++ if (! ubicom32fdpic_relocs_info (info)) ++ return FALSE; ++ ++ s = bfd_make_section_with_flags (abfd, ".rel.got", ++ (flags | SEC_READONLY)); ++ if (s == NULL ++ || ! bfd_set_section_alignment (abfd, s, 2)) ++ return FALSE; ++ ++ ubicom32fdpic_gotrel_section (info) = s; ++ ++ /* Machine-specific. */ ++ s = bfd_make_section_with_flags (abfd, ".rofixup", ++ (flags | SEC_READONLY)); ++ if (s == NULL ++ || ! bfd_set_section_alignment (abfd, s, 2)) ++ return FALSE; ++ ++ ubicom32fdpic_gotfixup_section (info) = s; ++ offset = -2048; ++ flags = BSF_GLOBAL; ++ } ++ else ++ { ++ offset = 2048; ++ flags = BSF_GLOBAL | BSF_WEAK; ++ } ++ ++ return TRUE; ++} ++ ++/* Make sure the got and plt sections exist, and that our pointers in ++ the link hash table point to them. */ ++ ++static bfd_boolean ++ubicom32fdpic_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) ++{ flagword flags, pltflags; ++ asection *s; ++ const struct elf_backend_data *bed = get_elf_backend_data (abfd); ++ ++ /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and ++ .rel[a].bss sections. */ ++ DPRINTF(" ubicom32fdpic_elf_create_dynamic_sections %p %p\n", abfd, info); ++ ++ flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY ++ | SEC_LINKER_CREATED); ++ ++ pltflags = flags; ++ pltflags |= SEC_CODE; ++ if (bed->plt_not_loaded) ++ pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS); ++ if (bed->plt_readonly) ++ pltflags |= SEC_READONLY; ++ ++ s = bfd_make_section_with_flags (abfd, ".plt", pltflags); ++ if (s == NULL ++ || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment)) ++ return FALSE; ++ /* Blackfin-specific: remember it. */ ++ ubicom32fdpic_plt_section (info) = s; ++ ++ if (bed->want_plt_sym) ++ { ++ /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the ++ .plt section. */ ++ struct elf_link_hash_entry *h; ++ struct bfd_link_hash_entry *bh = NULL; ++ ++ if (! (_bfd_generic_link_add_one_symbol ++ (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL, ++ FALSE, get_elf_backend_data (abfd)->collect, &bh))) ++ return FALSE; ++ h = (struct elf_link_hash_entry *) bh; ++ h->def_regular = 1; ++ h->type = STT_OBJECT; ++ ++ if (! info->executable ++ && ! bfd_elf_link_record_dynamic_symbol (info, h)) ++ return FALSE; ++ } ++ ++ /* Blackfin-specific: we want rel relocations for the plt. */ ++ s = bfd_make_section_with_flags (abfd, ".rel.plt", flags | SEC_READONLY); ++ if (s == NULL ++ || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) ++ return FALSE; ++ /* Blackfin-specific: remember it. */ ++ ubicom32fdpic_pltrel_section (info) = s; ++ ++ /* Blackfin-specific: we want to create the GOT in the Blackfin way. */ ++ if (! ubicom32fdpic_elf_create_got_section (abfd, info)) ++ return FALSE; ++ ++ /* Blackfin-specific: make sure we created everything we wanted. */ ++ BFD_ASSERT (ubicom32fdpic_got_section (info) && ubicom32fdpic_gotrel_section (info) ++ /* && ubicom32fdpic_gotfixup_section (info) */ ++ && ubicom32fdpic_plt_section (info) ++ && ubicom32fdpic_pltrel_section (info)); ++ ++ if (bed->want_dynbss) ++ { ++ /* The .dynbss section is a place to put symbols which are defined ++ by dynamic objects, are referenced by regular objects, and are ++ not functions. We must allocate space for them in the process ++ image and use a R_*_COPY reloc to tell the dynamic linker to ++ initialize them at run time. The linker script puts the .dynbss ++ section into the .bss section of the final image. */ ++ s = bfd_make_section_with_flags (abfd, ".dynbss", ++ SEC_ALLOC | SEC_LINKER_CREATED); ++ if (s == NULL) ++ return FALSE; ++ ++ /* The .rel[a].bss section holds copy relocs. This section is not ++ normally needed. We need to create it here, though, so that the ++ linker will map it to an output section. We can't just create it ++ only if we need it, because we will not know whether we need it ++ until we have seen all the input files, and the first time the ++ main linker code calls BFD after examining all the input files ++ (size_dynamic_sections) the input sections have already been ++ mapped to the output sections. If the section turns out not to ++ be needed, we can discard it later. We will never need this ++ section when generating a shared object, since they do not use ++ copy relocs. */ ++ if (! info->shared) ++ { ++ s = bfd_make_section_with_flags (abfd, ++ (bed->default_use_rela_p ++ ? ".rela.bss" : ".rel.bss"), ++ flags | SEC_READONLY); ++ if (s == NULL ++ || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) ++ return FALSE; ++ } ++ } ++ ++ return TRUE; ++} ++ ++/* We need dynamic symbols for every section, since segments can ++ relocate independently. */ ++static bfd_boolean ++ubicom32fdpic_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED, ++ struct bfd_link_info *info ++ ATTRIBUTE_UNUSED, ++ asection *p ATTRIBUTE_UNUSED) ++{ ++ switch (elf_section_data (p)->this_hdr.sh_type) ++ { ++ case SHT_PROGBITS: ++ case SHT_NOBITS: ++ /* If sh_type is yet undecided, assume it could be ++ SHT_PROGBITS/SHT_NOBITS. */ ++ case SHT_NULL: ++ return FALSE; ++ ++ /* There shouldn't be section relative relocations ++ against any other section. */ ++ default: ++ return TRUE; ++ } ++} ++ ++/* Look through the relocs for a section during the first phase. ++ ++ Besides handling virtual table relocs for gc, we have to deal with ++ all sorts of PIC-related relocations. We describe below the ++ general plan on how to handle such relocations, even though we only ++ collect information at this point, storing them in hash tables for ++ perusal of later passes. ++ ++*/ ++static bfd_boolean ++ubicom32fdpic_elf_check_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; ++ bfd *dynobj; ++ struct ubicom32fdpic_relocs_info *picrel; ++ ++ if (info->relocatable) ++ 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; ++ ++ dynobj = elf_hash_table (info)->dynobj; ++ 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)) ++ { ++ case R_UBICOM32_GOTOFFSET_HI: ++ case R_UBICOM32_GOTOFFSET_LO: ++ case R_UBICOM32_FUNCDESC_GOTOFFSET_HI: ++ case R_UBICOM32_FUNCDESC_GOTOFFSET_LO: ++ case R_UBICOM32_FUNCDESC: ++ case R_UBICOM32_FUNCDESC_VALUE: ++ if (! IS_FDPIC (abfd)) ++ goto bad_reloc; ++ /* Fall through. */ ++ case R_UBICOM32_24_PCREL: ++ case R_UBICOM32_32: ++ if (IS_FDPIC (abfd) && ! dynobj) ++ { ++ elf_hash_table (info)->dynobj = dynobj = abfd; ++ if (! ubicom32fdpic_elf_create_got_section (abfd, info)) ++ return FALSE; ++ } ++ if (! IS_FDPIC (abfd)) ++ { ++ picrel = NULL; ++ break; ++ } ++ if (h != NULL) ++ { ++ if (h->dynindx == -1) ++ switch (ELF_ST_VISIBILITY (h->other)) ++ { ++ case STV_INTERNAL: ++ case STV_HIDDEN: ++ break; ++ default: ++ bfd_elf_link_record_dynamic_symbol (info, h); ++ break; ++ } ++ picrel ++ = ubicom32fdpic_relocs_info_for_global (ubicom32fdpic_relocs_info (info), ++ abfd, h, ++ rel->r_addend, INSERT); ++ } ++ else ++ picrel = ubicom32fdpic_relocs_info_for_local (ubicom32fdpic_relocs_info (info), ++ abfd, r_symndx, ++ rel->r_addend, INSERT); ++ if (! picrel) ++ return FALSE; ++ break; ++ ++ default: ++ picrel = NULL; ++ break; ++ } ++ ++ switch (ELF32_R_TYPE (rel->r_info)) ++ { ++ case R_UBICOM32_24_PCREL: ++ if (IS_FDPIC (abfd)) ++ picrel->call++; ++ break; ++ ++ case R_UBICOM32_FUNCDESC_VALUE: ++ picrel->relocsfdv++; ++ picrel->sym++; ++ break; ++ ++ case R_UBICOM32_32: ++ if (! IS_FDPIC (abfd)) ++ break; ++ ++ picrel->sym++; ++ if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC) ++ picrel->relocs32++; ++ break; ++ ++ case R_UBICOM32_GOTOFFSET_HI: ++ picrel->gotoffset_hi++; ++ break; ++ ++ case R_UBICOM32_GOTOFFSET_LO: ++ picrel->gotoffset_lo++; ++ break; ++ ++ case R_UBICOM32_FUNCDESC_GOTOFFSET_HI: ++ picrel->fd_gotoffset_hi++; ++ break; ++ ++ case R_UBICOM32_FUNCDESC_GOTOFFSET_LO: ++ picrel->fd_gotoffset_lo++; ++ break; ++ ++ case R_UBICOM32_FUNCDESC: ++ picrel->fd++; ++ picrel->relocsfd++; ++ break; ++ ++ /* This relocation describes the C++ object vtable hierarchy. ++ Reconstruct it for later use during GC. */ ++ case R_UBICOM32_GNU_VTINHERIT: ++ if (!bfd_elf_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_UBICOM32_GNU_VTENTRY: ++ if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) ++ return FALSE; ++ break; ++ ++ case R_UBICOM32_21_PCREL: ++ case R_UBICOM32_HI24: ++ case R_UBICOM32_LO7_S: ++ break; ++ ++ default: ++ bad_reloc: ++ (*_bfd_error_handler) ++ (_("%B: unsupported (ubicom32) relocation type %i"), ++ abfd, ELF32_R_TYPE (rel->r_info)); ++ return FALSE; ++ } ++ } ++ ++ return TRUE; ++} ++ ++/* Follow indirect and warning hash entries so that each got entry ++ points to the final symbol definition. P must point to a pointer ++ to the hash table we're traversing. Since this traversal may ++ modify the hash table, we set this pointer to NULL to indicate ++ we've made a potentially-destructive change to the hash table, so ++ the traversal must be restarted. */ ++static int ++ubicom32fdpic_resolve_final_relocs_info (void **entryp, void *p) ++{ ++ struct ubicom32fdpic_relocs_info *entry = *entryp; ++ htab_t *htab = p; ++ ++ if (entry->symndx == -1) ++ { ++ struct elf_link_hash_entry *h = entry->d.h; ++ struct ubicom32fdpic_relocs_info *oentry; ++ ++ 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; ++ ++ if (entry->d.h == h) ++ return 1; ++ ++ oentry = ubicom32fdpic_relocs_info_for_global (*htab, 0, h, entry->addend, ++ NO_INSERT); ++ ++ if (oentry) ++ { ++ /* Merge the two entries. */ ++ ubicom32fdpic_pic_merge_early_relocs_info (oentry, entry); ++ htab_clear_slot (*htab, entryp); ++ return 1; ++ } ++ ++ entry->d.h = h; ++ ++ /* If we can't find this entry with the new bfd hash, re-insert ++ it, and get the traversal restarted. */ ++ if (! htab_find (*htab, entry)) ++ { ++ htab_clear_slot (*htab, entryp); ++ entryp = htab_find_slot (*htab, entry, INSERT); ++ if (! *entryp) ++ *entryp = entry; ++ /* Abort the traversal, since the whole table may have ++ moved, and leave it up to the parent to restart the ++ process. */ ++ *(htab_t *)p = NULL; ++ return 0; ++ } ++ } ++ ++ return 1; ++} ++ ++/* Assign GOT offsets to private function descriptors used by PLT ++ entries (or referenced by 32-bit offsets), as well as PLT entries ++ and lazy PLT entries. */ ++static int ++ubicom32fdpic_assign_plt_entries (void **entryp, void *info_) ++{ ++ struct ubicom32fdpic_relocs_info *entry = *entryp; ++ struct ubicom32fdpic_dynamic_got_plt_info *dinfo = info_; ++ ++ if (entry->privfd && entry->fd_entry == 0) ++ { ++ // dinfo->current_fd -= FUNCTION_DESCRIPTOR_SIZE; ++ // entry->fd_entry = dinfo->current_fd; ++ DPRINTF(" late assign fd % 5d:%p \n", entry->fd_entry, entry); ++ } ++ ++ if (entry->plt) ++ { ++ /* We use the section's raw size to mark the location of the ++ next PLT entry. */ ++ entry->plt_entry = dinfo->current_plt; ++ entry->plt_trampoline_entry = dinfo->current_plt_trampoline; ++ dinfo->current_plt_trampoline += PLT_TRAMPOLINE_SIZE; ++ ++ if (entry->fd_entry >= (-512)) ++ { ++ /* This entry is going to be of type seq2 */ ++ dinfo->current_plt += LZPLT_SIZE_SEQ2; ++ entry->plt_type = 2; ++ } ++ else ++ { ++ /* This entry is going to be of type seq1 */ ++ dinfo->current_plt += LZPLT_SIZE_SEQ1; ++ entry->plt_type = 1; ++ } ++ DPRINTF(" assign plt % 4d for fd=% 4d:%p next %d plttype %d\n", entry->plt_entry, entry->fd_entry, entry, dinfo->current_plt, entry->plt_type); ++ ++ } ++ ++ return 1; ++} ++ ++/* Assign GOT offsets for every GOT entry and function descriptor. ++ Doing everything in a single pass is tricky. */ ++static int ++ubicom32fdpic_assign_got_entries (void **entryp, void *info_) ++{ ++ struct ubicom32fdpic_relocs_info *entry = *entryp; ++ struct ubicom32fdpic_dynamic_got_plt_info *dinfo = info_; ++ ++ if (entry->gotoffset_lo || entry->gotoffset_hi) ++ { ++ entry->got_entry = dinfo->current_got; ++ DPRINTF(" assign got % 5d:%p \n", entry->got_entry, entry); ++ dinfo->current_got += 4; ++ } ++ ++ if (entry->fd_gotoffset_lo || entry->fd_gotoffset_hi) ++ { ++ entry->fdgot_entry = dinfo->current_got; ++ DPRINTF(" assign fdgot % 5d:%p \n", entry->fdgot_entry, entry); ++ dinfo->current_got += 4; ++ } ++ ++ if (entry->plt) ++ { ++ dinfo->current_fd -= FUNCTION_DESCRIPTOR_SIZE; ++ entry->fd_entry = dinfo->current_fd; ++ ++ dinfo->total_trampoline += PLT_TRAMPOLINE_SIZE; ++ ++ if (entry->fd_entry >= (-512)) ++ { ++ /* This entry is going to be of type seq2 */ ++ dinfo->total_lzplt += LZPLT_SIZE_SEQ2; ++ entry->plt_type = 2; ++ } ++ else ++ { ++ /* This entry is going to be of type seq1 */ ++ dinfo->total_lzplt += LZPLT_SIZE_SEQ1; ++ entry->plt_type = 1; ++ } ++ ++ DPRINTF(" assign fd % 5d:%p \n", entry->fd_entry, entry); ++ } ++ else if (entry->privfd) ++ { ++ dinfo->current_privfd -= FUNCTION_DESCRIPTOR_SIZE; ++ entry->fd_entry = dinfo->current_privfd; ++ DPRINTF(" assign private fd % 5d:%p %p \n", entry->fd_entry, entry, entry->plt); ++ } ++ ++ return 1; ++} ++ ++/* Set the sizes of the dynamic sections. */ ++ ++static bfd_boolean ++ubicom32fdpic_elf_size_dynamic_sections (bfd *output_bfd, ++ struct bfd_link_info *info) ++{ ++ bfd *dynobj; ++ asection *s; ++ struct ubicom32fdpic_dynamic_got_plt_info gpinfo; ++ bfd_vma total_plt_size; ++ ++ dynobj = elf_hash_table (info)->dynobj; ++ BFD_ASSERT (dynobj != NULL); ++ ++ if (elf_hash_table (info)->dynamic_sections_created) ++ { ++ /* Set the contents of the .interp section to the interpreter. */ ++ if (info->executable) ++ { ++ s = bfd_get_section_by_name (dynobj, ".interp"); ++ BFD_ASSERT (s != NULL); ++ s->size = sizeof ELF_DYNAMIC_INTERPRETER; ++ s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER; ++ } ++ } ++ ++ memset (&gpinfo, 0, sizeof (gpinfo)); ++ gpinfo.g.info = info; ++ ++ for (;;) ++ { ++ htab_t relocs = ubicom32fdpic_relocs_info (info); ++ ++ htab_traverse (relocs, ubicom32fdpic_resolve_final_relocs_info, &relocs); ++ ++ if (relocs == ubicom32fdpic_relocs_info (info)) ++ break; ++ } ++ ++ htab_traverse (ubicom32fdpic_relocs_info (info), ubicom32fdpic_count_got_plt_entries, ++ &gpinfo.g); ++ ++ /* At this point we know how many PLT entries we need. We know how many got entries we need and the total number of function descriptors in this link. */ ++ gpinfo.total_fdplt = gpinfo.g.fdplt + gpinfo.g.privfdplt; ++ gpinfo.total_got = gpinfo.g.gotoffset_lo; ++ gpinfo.total_lzplt = 0; ++ ++ gpinfo.current_got = 12; /* The first 12 bytes are reserved to get to resolver. */ ++ gpinfo.current_fd = 0; /* We will decrement this by FUNCTION_DESCRIPTOR_SIZE for each allocation. */ ++ gpinfo.current_privfd = -gpinfo.g.fdplt; /* We will decrement this by FUNCTION_DESCRIPTOR_SIZE for each allocation. */ ++ gpinfo.current_plt = 0; /* Initialize this to 0. The trampoline code is at the start of the plt section. ++ We will decrement this by LZPLT_NORMAL_SIZE each time we allocate. */ ++ gpinfo.current_plt_trampoline = 0; ++ ++ DPRINTF("Total plts = %d \n", gpinfo.g.num_plts); ++ ++ /* Now assign (most) GOT offsets. */ ++ htab_traverse (ubicom32fdpic_relocs_info (info), ubicom32fdpic_assign_got_entries, ++ &gpinfo); ++ ++ ++ ubicom32fdpic_got_section (info)->size = gpinfo.total_fdplt + gpinfo.total_got + 12; ++ ++ DPRINTF("GOT size = fd=%d, got=%d\n", gpinfo.total_fdplt, gpinfo.total_got); ++ ++ if (ubicom32fdpic_got_section (info)->size == 0) ++ ubicom32fdpic_got_section (info)->flags |= SEC_EXCLUDE; ++ else if (ubicom32fdpic_got_section (info)->size == 12 ++ && ! elf_hash_table (info)->dynamic_sections_created) ++ { ++ ubicom32fdpic_got_section (info)->flags |= SEC_EXCLUDE; ++ ubicom32fdpic_got_section (info)->size = 0; ++ } ++ else ++ { ++ DPRINTF(" Alloc GOT size = %d\n", ubicom32fdpic_got_section (info)->size); ++ ubicom32fdpic_got_section (info)->contents = ++ (bfd_byte *) bfd_zalloc (dynobj, ++ ubicom32fdpic_got_section (info)->size); ++ if (ubicom32fdpic_got_section (info)->contents == NULL) ++ return FALSE; ++ } ++ ++ if (elf_hash_table (info)->dynamic_sections_created) ++ /* Subtract the number of lzplt entries, since those will generate ++ relocations in the pltrel section. */ ++ ubicom32fdpic_gotrel_section (info)->size = ++ (gpinfo.g.relocs - gpinfo.g.num_plts) ++ * get_elf_backend_data (output_bfd)->s->sizeof_rel; ++ else ++ BFD_ASSERT (gpinfo.g.relocs == 0); ++ if (ubicom32fdpic_gotrel_section (info)->size == 0) ++ ubicom32fdpic_gotrel_section (info)->flags |= SEC_EXCLUDE; ++ else ++ { ++ ubicom32fdpic_gotrel_section (info)->contents = ++ (bfd_byte *) bfd_zalloc (dynobj, ++ ubicom32fdpic_gotrel_section (info)->size); ++ if (ubicom32fdpic_gotrel_section (info)->contents == NULL) ++ return FALSE; ++ } ++ ++ ubicom32fdpic_gotfixup_section (info)->size = (gpinfo.g.fixups + 1) * 4; ++ if (ubicom32fdpic_gotfixup_section (info)->size == 0) ++ ubicom32fdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE; ++ else ++ { ++ ubicom32fdpic_gotfixup_section (info)->contents = ++ (bfd_byte *) bfd_zalloc (dynobj, ++ ubicom32fdpic_gotfixup_section (info)->size); ++ if (ubicom32fdpic_gotfixup_section (info)->contents == NULL) ++ return FALSE; ++ } ++ ++ if (elf_hash_table (info)->dynamic_sections_created) ++ { ++ ubicom32fdpic_pltrel_section (info)->size = ++ gpinfo.g.num_plts * get_elf_backend_data (output_bfd)->s->sizeof_rel; ++ if (ubicom32fdpic_pltrel_section (info)->size == 0) ++ ubicom32fdpic_pltrel_section (info)->flags |= SEC_EXCLUDE; ++ else ++ { ++ ubicom32fdpic_pltrel_section (info)->contents = ++ (bfd_byte *) bfd_zalloc (dynobj, ++ ubicom32fdpic_pltrel_section (info)->size); ++ if (ubicom32fdpic_pltrel_section (info)->contents == NULL) ++ return FALSE; ++ } ++ } ++ ++ /* The Pltsection is g.lzplt . The 4 is for the trampoline code. */ ++ total_plt_size = gpinfo.total_lzplt + gpinfo.total_trampoline; ++ gpinfo.current_plt_trampoline = gpinfo.total_lzplt; ++ ++ if (elf_hash_table (info)->dynamic_sections_created) ++ { ++ DPRINTF(" PLT size = %d\n", (total_plt_size )); ++ ubicom32fdpic_plt_section (info)->size = (total_plt_size); ++ } ++ ++ /* Save information that we're going to need to generate GOT and PLT ++ entries. */ ++ ubicom32fdpic_got_initial_offset (info) = gpinfo.total_fdplt; ++ ++ if (get_elf_backend_data (output_bfd)->want_got_sym) ++ elf_hash_table (info)->hgot->root.u.def.value ++ += ubicom32fdpic_got_initial_offset (info); ++ ++ /* Allocate the PLT section contents. */ ++ if (elf_hash_table (info)->dynamic_sections_created) ++ { ++ if (ubicom32fdpic_plt_section (info)->size == 4) ++ { ++ ubicom32fdpic_plt_section (info)->flags |= SEC_EXCLUDE; ++ ubicom32fdpic_plt_section (info)->size = 0; ++ } ++ else ++ { ++ DPRINTF(" Alloc PLT size = %d\n", (total_plt_size)); ++ ubicom32fdpic_plt_section (info)->contents = ++ (bfd_byte *) bfd_zalloc (dynobj, ++ ubicom32fdpic_plt_section (info)->size); ++ if (ubicom32fdpic_plt_section (info)->contents == NULL) ++ return FALSE; ++ } ++ } ++ ++ ++ htab_traverse (ubicom32fdpic_relocs_info (info), ubicom32fdpic_assign_plt_entries, ++ &gpinfo); ++ ++ ++ if (elf_hash_table (info)->dynamic_sections_created) ++ { ++ if (ubicom32fdpic_got_section (info)->size) ++ if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)) ++ return FALSE; ++ ++ if (ubicom32fdpic_pltrel_section (info)->size) ++ if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0) ++ || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL) ++ || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0)) ++ return FALSE; ++ ++ if (ubicom32fdpic_gotrel_section (info)->size) ++ if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0) ++ || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0) ++ || !_bfd_elf_add_dynamic_entry (info, DT_RELENT, ++ sizeof (Elf32_External_Rel))) ++ return FALSE; ++ } ++ ++ s = bfd_get_section_by_name (dynobj, ".rela.bss"); ++ if (s && s->size == 0) ++ s->flags |= SEC_EXCLUDE; ++ ++ s = bfd_get_section_by_name (dynobj, ".rel.plt"); ++ if (s && s->size == 0) ++ s->flags |= SEC_EXCLUDE; ++ ++ return TRUE; ++} ++ ++ ++/* Adjust a symbol defined by a dynamic object and referenced by a ++ regular object. */ ++ ++static bfd_boolean ++ubicom32fdpic_elf_adjust_dynamic_symbol ++(struct bfd_link_info *info ATTRIBUTE_UNUSED, ++ struct elf_link_hash_entry *h ATTRIBUTE_UNUSED) ++{ ++ bfd * dynobj; ++ ++ dynobj = elf_hash_table (info)->dynobj; ++ ++ /* Make sure we know what is going on here. */ ++ BFD_ASSERT (dynobj != NULL ++ && (h->u.weakdef != NULL ++ || (h->def_dynamic ++ && h->ref_regular ++ && !h->def_regular))); ++ ++ /* If this is a weak symbol, and there is a real definition, the ++ processor independent code will have arranged for us to see the ++ real definition first, and we can just use the same value. */ ++ if (h->u.weakdef != NULL) ++ { ++ BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined ++ || h->u.weakdef->root.type == bfd_link_hash_defweak); ++ h->root.u.def.section = h->u.weakdef->root.u.def.section; ++ h->root.u.def.value = h->u.weakdef->root.u.def.value; ++ } ++ ++ return TRUE; ++} ++ ++static bfd_boolean ++ubicom32fdpic_elf_always_size_sections (bfd *output_bfd, ++ struct bfd_link_info *info) ++{ ++ if (!info->relocatable) ++ { ++ struct elf_link_hash_entry *h; ++ ++ /* Force a PT_GNU_STACK segment to be created. */ ++ if (! elf_tdata (output_bfd)->stack_flags) ++ elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X; ++ ++ /* Define __stacksize if it's not defined yet. */ ++ h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize", ++ FALSE, FALSE, FALSE); ++ if (! h || h->root.type != bfd_link_hash_defined ++ || h->type != STT_OBJECT ++ || !h->def_regular) ++ { ++ struct bfd_link_hash_entry *bh = NULL; ++ ++ if (!(_bfd_generic_link_add_one_symbol ++ (info, output_bfd, "__stacksize", ++ BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE, ++ (const char *) NULL, FALSE, ++ get_elf_backend_data (output_bfd)->collect, &bh))) ++ return FALSE; ++ ++ h = (struct elf_link_hash_entry *) bh; ++ h->def_regular = 1; ++ h->type = STT_OBJECT; ++ } ++ } ++ ++ return TRUE; ++} ++ ++static bfd_boolean ++ubicom32fdpic_elf_finish_dynamic_sections (bfd *output_bfd, ++ struct bfd_link_info *info) ++{ ++ bfd *dynobj; ++ asection *sdyn; ++ ++ dynobj = elf_hash_table (info)->dynobj; ++ ++ if (ubicom32fdpic_got_section (info)) ++ { ++ BFD_ASSERT (ubicom32fdpic_gotrel_section (info)->size ++ == (ubicom32fdpic_gotrel_section (info)->reloc_count ++ * sizeof (Elf32_External_Rel))); ++ ++ if (ubicom32fdpic_gotfixup_section (info)) ++ { ++ struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot; ++ bfd_vma got_value = hgot->root.u.def.value ++ + hgot->root.u.def.section->output_section->vma ++ + hgot->root.u.def.section->output_offset; ++ ++ ubicom32fdpic_add_rofixup (output_bfd, ubicom32fdpic_gotfixup_section (info), ++ got_value, 0); ++ ++ if (ubicom32fdpic_gotfixup_section (info)->size ++ != (ubicom32fdpic_gotfixup_section (info)->reloc_count * 4)) ++ { ++ (*_bfd_error_handler) ++ ("LINKER BUG: .rofixup section size mismatch Size %d, should be %d ", ++ ubicom32fdpic_gotfixup_section (info)->size, ubicom32fdpic_gotfixup_section (info)->reloc_count * 4); ++ return FALSE; ++ } ++ } ++ } ++ if (elf_hash_table (info)->dynamic_sections_created) ++ { ++ BFD_ASSERT (ubicom32fdpic_pltrel_section (info)->size ++ == (ubicom32fdpic_pltrel_section (info)->reloc_count ++ * sizeof (Elf32_External_Rel))); ++ } ++ ++ sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); ++ ++ if (elf_hash_table (info)->dynamic_sections_created) ++ { ++ Elf32_External_Dyn * dyncon; ++ Elf32_External_Dyn * dynconend; ++ ++ BFD_ASSERT (sdyn != NULL); ++ ++ dyncon = (Elf32_External_Dyn *) sdyn->contents; ++ dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); ++ ++ for (; dyncon < dynconend; dyncon++) ++ { ++ Elf_Internal_Dyn dyn; ++ ++ bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); ++ ++ switch (dyn.d_tag) ++ { ++ default: ++ break; ++ ++ case DT_PLTGOT: ++ dyn.d_un.d_ptr = ubicom32fdpic_got_section (info)->output_section->vma ++ + ubicom32fdpic_got_section (info)->output_offset ++ + ubicom32fdpic_got_initial_offset (info); ++ bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); ++ break; ++ ++ case DT_JMPREL: ++ dyn.d_un.d_ptr = ubicom32fdpic_pltrel_section (info) ++ ->output_section->vma ++ + ubicom32fdpic_pltrel_section (info)->output_offset; ++ bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); ++ break; ++ ++ case DT_PLTRELSZ: ++ dyn.d_un.d_val = ubicom32fdpic_pltrel_section (info)->size; ++ bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); ++ break; ++ } ++ } ++ } ++ ++ return TRUE; ++} ++ ++/* Perform any actions needed for dynamic symbols. */ ++static bfd_boolean ++ubicom32fdpic_elf_finish_dynamic_symbol ++(bfd *output_bfd ATTRIBUTE_UNUSED, ++ struct bfd_link_info *info ATTRIBUTE_UNUSED, ++ struct elf_link_hash_entry *h ATTRIBUTE_UNUSED, ++ Elf_Internal_Sym *sym ATTRIBUTE_UNUSED) ++{ ++ return TRUE; ++} ++ ++static bfd_boolean ++ubicom32fdpic_elf_modify_program_headers (bfd *output_bfd, ++ struct bfd_link_info *info) ++{ ++ struct elf_obj_tdata *tdata = elf_tdata (output_bfd); ++ struct elf_segment_map *m; ++ Elf_Internal_Phdr *p; ++ ++ if (! info) ++ return TRUE; ++ ++ for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++) ++ if (m->p_type == PT_GNU_STACK) ++ break; ++ ++ if (m) ++ { ++ struct elf_link_hash_entry *h; ++ ++ /* Obtain the pointer to the __stacksize symbol. */ ++ h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize", ++ FALSE, FALSE, FALSE); ++ if (h) ++ { ++ 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; ++ BFD_ASSERT (h->root.type == bfd_link_hash_defined); ++ } ++ ++ /* Set the header p_memsz from the symbol value. We ++ intentionally ignore the symbol section. */ ++ if (h && h->root.type == bfd_link_hash_defined) ++ p->p_memsz = h->root.u.def.value; ++ else ++ p->p_memsz = DEFAULT_STACK_SIZE; ++ ++ p->p_align = 8; ++ } ++ ++ return TRUE; ++} ++ ++static bfd_boolean ++ubicom32fdpic_elf_gc_sweep_hook (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; ++ struct ubicom32fdpic_relocs_info *picrel; ++ ++ BFD_ASSERT (IS_FDPIC (abfd)); ++ ++ 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]; ++ ++ if (h != NULL) ++ picrel = ubicom32fdpic_relocs_info_for_global (ubicom32fdpic_relocs_info (info), ++ abfd, h, ++ rel->r_addend, NO_INSERT); ++ else ++ picrel = ubicom32fdpic_relocs_info_for_local (ubicom32fdpic_relocs_info ++ (info), abfd, r_symndx, ++ rel->r_addend, NO_INSERT); ++ ++ if (!picrel) ++ continue; ++ ++ switch (ELF32_R_TYPE (rel->r_info)) ++ { ++ case R_UBICOM32_24_PCREL: ++ picrel->call--; ++ break; ++ ++ case R_UBICOM32_FUNCDESC_VALUE: ++ picrel->relocsfdv--; ++ picrel->sym--; ++ break; ++ ++ case R_UBICOM32_GOTOFFSET_LO: ++ picrel->gotoffset_lo--; ++ break; ++ ++ case R_UBICOM32_FUNCDESC_GOTOFFSET_LO: ++ picrel->fd_gotoffset_lo--; ++ break; ++ ++ case R_UBICOM32_FUNCDESC_GOTOFFSET_HI: ++ picrel->fd_gotoffset_hi--; ++ break; ++ ++ case R_UBICOM32_FUNCDESC: ++ picrel->fd--; ++ picrel->relocsfd--; ++ break; ++ ++ case R_UBICOM32_32: ++ if (! IS_FDPIC (abfd)) ++ break; ++ ++ if (picrel->sym) ++ picrel->relocs32--;; ++ ++ picrel->sym--; ++ break; ++ ++ default: ++ break; ++ } ++ } ++ ++ return TRUE; ++} ++/* Decide whether to attempt to turn absptr or lsda encodings in ++ shared libraries into pcrel within the given input section. */ ++ ++static bfd_boolean ++ubicom32fdpic_elf_use_relative_eh_frame ++(bfd *input_bfd ATTRIBUTE_UNUSED, ++ struct bfd_link_info *info ATTRIBUTE_UNUSED, ++ asection *eh_frame_section ATTRIBUTE_UNUSED) ++{ ++ /* We can't use PC-relative encodings in FDPIC binaries, in general. */ ++ return FALSE; ++} ++ ++/* Adjust the contents of an eh_frame_hdr section before they're output. */ ++ ++static bfd_byte ++ubicom32fdpic_elf_encode_eh_address (bfd *abfd, ++ struct bfd_link_info *info, ++ asection *osec, bfd_vma offset, ++ asection *loc_sec, bfd_vma loc_offset, ++ bfd_vma *encoded) ++{ ++ struct elf_link_hash_entry *h; ++ ++ h = elf_hash_table (info)->hgot; ++ BFD_ASSERT (h && h->root.type == bfd_link_hash_defined); ++ ++ if (! h || (ubicom32fdpic_osec_to_segment (abfd, osec) ++ == ubicom32fdpic_osec_to_segment (abfd, loc_sec->output_section))) ++ return _bfd_elf_encode_eh_address (abfd, info, osec, offset, ++ loc_sec, loc_offset, encoded); ++ ++ BFD_ASSERT (ubicom32fdpic_osec_to_segment (abfd, osec) ++ == (ubicom32fdpic_osec_to_segment ++ (abfd, h->root.u.def.section->output_section))); ++ ++ *encoded = osec->vma + offset ++ - (h->root.u.def.value ++ + h->root.u.def.section->output_section->vma ++ + h->root.u.def.section->output_offset); ++ ++ return DW_EH_PE_datarel | DW_EH_PE_sdata4; ++} ++static bfd_boolean ++ubicom32fdpic_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd) ++{ ++ unsigned i; ++ ++ if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour ++ || bfd_get_flavour (obfd) != bfd_target_elf_flavour) ++ return TRUE; ++ ++ if (! ubicom32_elf_copy_private_bfd_data (ibfd, obfd)) ++ return FALSE; ++ ++ if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr ++ || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr) ++ return TRUE; ++ ++ /* Copy the stack size. */ ++ for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++) ++ if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK) ++ { ++ Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i]; ++ ++ for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++) ++ if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK) ++ { ++ memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr)); ++ ++ /* Rewrite the phdrs, since we're only called after they ++ were first written. */ ++ if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd) ++ ->s->sizeof_ehdr, SEEK_SET) != 0 ++ || get_elf_backend_data (obfd)->s ++ ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr, ++ elf_elfheader (obfd)->e_phnum) != 0) ++ return FALSE; ++ break; ++ } ++ ++ break; ++ } ++ ++ return TRUE; ++} ++ ++static bfd_boolean ++ubicom32fdpic_elf_relocate_section (bfd * output_bfd, ++ 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; ++ unsigned isec_segment, got_segment, plt_segment, ++ check_segment[2]; ++ int silence_segment_error = !(info->shared || info->pie); ++ ++ if (info->relocatable) ++ return TRUE; ++ ++ symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; ++ sym_hashes = elf_sym_hashes (input_bfd); ++ relend = relocs + input_section->reloc_count; ++ ++ isec_segment = ubicom32fdpic_osec_to_segment (output_bfd, ++ input_section->output_section); ++ if (IS_FDPIC (output_bfd) && ubicom32fdpic_got_section (info)) ++ got_segment = ubicom32fdpic_osec_to_segment (output_bfd, ++ ubicom32fdpic_got_section (info) ++ ->output_section); ++ else ++ got_segment = -1; ++ if (IS_FDPIC (output_bfd) && elf_hash_table (info)->dynamic_sections_created) ++ plt_segment = ubicom32fdpic_osec_to_segment (output_bfd, ++ ubicom32fdpic_plt_section (info) ++ ->output_section); ++ else ++ plt_segment = -1; ++ ++ 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; ++ asection *osec; ++ struct ubicom32fdpic_relocs_info *picrel; ++ bfd_vma orig_addend = rel->r_addend; ++ ++ r_type = ELF32_R_TYPE (rel->r_info); ++ ++ if (r_type == R_UBICOM32_GNU_VTINHERIT ++ || r_type == R_UBICOM32_GNU_VTENTRY) ++ continue; ++ ++ /* This is a final link. */ ++ r_symndx = ELF32_R_SYM (rel->r_info); ++ ++ //howto = ubicom32_reloc_type_lookup (input_bfd, r_type); ++ howto = ubicom32_elf_howto_table + ELF32_R_TYPE (rel->r_info); ++ if (howto == NULL) ++ { ++ bfd_set_error (bfd_error_bad_value); ++ return FALSE; ++ } ++ ++ h = NULL; ++ sym = NULL; ++ sec = NULL; ++ ++ if (r_symndx < symtab_hdr->sh_info) ++ { ++ sym = local_syms + r_symndx; ++ osec = sec = local_sections [r_symndx]; ++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); ++ ++ 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) ++ && ! UBICOM32FDPIC_SYM_LOCAL (info, h)) ++ { ++ sec = NULL; ++ relocation = 0; ++ } ++ else ++ 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->unresolved_syms_in_objects == RM_IGNORE ++ && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) ++ relocation = 0; ++ else ++ { ++ if (! ((*info->callbacks->undefined_symbol) ++ (info, h->root.root.string, input_bfd, ++ input_section, rel->r_offset, ++ (info->unresolved_syms_in_objects == RM_GENERATE_ERROR ++ || ELF_ST_VISIBILITY (h->other))))) ++ return FALSE; ++ relocation = 0; ++ } ++ osec = sec; ++ } ++ ++ switch (r_type) ++ { ++ case R_UBICOM32_24_PCREL: ++ case R_UBICOM32_32: ++ if (! IS_FDPIC (output_bfd)) ++ goto non_fdpic; ++ ++ case R_UBICOM32_FUNCDESC_VALUE: ++ case R_UBICOM32_FUNCDESC: ++ case R_UBICOM32_GOTOFFSET_LO: ++ case R_UBICOM32_GOTOFFSET_HI: ++ case R_UBICOM32_FUNCDESC_GOTOFFSET_LO: ++ case R_UBICOM32_FUNCDESC_GOTOFFSET_HI: ++ if (h != NULL) ++ picrel = ubicom32fdpic_relocs_info_for_global (ubicom32fdpic_relocs_info ++ (info), input_bfd, h, ++ orig_addend, INSERT); ++ else ++ /* In order to find the entry we created before, we must ++ use the original addend, not the one that may have been ++ modified by _bfd_elf_rela_local_sym(). */ ++ picrel = ubicom32fdpic_relocs_info_for_local (ubicom32fdpic_relocs_info ++ (info), input_bfd, r_symndx, ++ orig_addend, INSERT); ++ if (! picrel) ++ return FALSE; ++ ++ if (!ubicom32fdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info, ++ osec, sym, ++ rel->r_addend)) ++ { ++ (*_bfd_error_handler) ++ (_("%B: relocation at `%A+0x%x' references symbol `%s' with nonzero addend"), ++ input_bfd, input_section, rel->r_offset, name); ++ return FALSE; ++ ++ } ++ ++ break; ++ case R_UBICOM32_21_PCREL: ++ case R_UBICOM32_HI24: ++ case R_UBICOM32_LO7_S: ++ //printf("Seeing this stuff Don;t know what to do. r_type %d r_symndx %d %s %s\n", r_type, r_symndx, input_bfd->filename, input_section->name); ++ break; ++ ++ default: ++ non_fdpic: ++ picrel = NULL; ++ //printf("h = 0x%x %d\n", h, UBICOM32FDPIC_SYM_LOCAL (info, h)); ++ if (h && ! UBICOM32FDPIC_SYM_LOCAL (info, h)) ++ { ++ printf("h = 0x%x %d\n", h, UBICOM32FDPIC_SYM_LOCAL (info, h)); ++ printf("Seeing this stuff. r_type %d r_symndx %d %s %s\n", r_type, r_symndx, input_bfd->filename, input_section->name); ++ info->callbacks->warning ++ (info, _("relocation references symbol not defined in the module"), ++ name, input_bfd, input_section, rel->r_offset); ++ return FALSE; ++ } ++ break; ++ } ++ ++ switch (r_type) ++ { ++ case R_UBICOM32_21_PCREL: ++ case R_UBICOM32_HI24: ++ case R_UBICOM32_LO7_S: ++ //printf("Seeing this stuff. r_type %d r_symndx %d %s %s\n", r_type, r_symndx, input_bfd->filename, input_section->name); ++ check_segment[0] = check_segment[1] = got_segment; ++ break; ++ ++ case R_UBICOM32_24_PCREL: ++ check_segment[0] = isec_segment; ++ if (! IS_FDPIC (output_bfd)) ++ check_segment[1] = isec_segment; ++ else if (picrel->plt) ++ { ++ relocation = ubicom32fdpic_plt_section (info)->output_section->vma ++ + ubicom32fdpic_plt_section (info)->output_offset ++ + picrel->plt_entry; ++ ++ /* subtract rel->addend. This will get added back in the 23pcrel howto routine. */ ++ relocation -= rel->r_addend; ++ ++ check_segment[1] = plt_segment; ++ } ++ /* We don't want to warn on calls to undefined weak symbols, ++ as calls to them must be protected by non-NULL tests ++ anyway, and unprotected calls would invoke undefined ++ behavior. */ ++ else if (picrel->symndx == -1 ++ && picrel->d.h->root.type == bfd_link_hash_undefweak) ++ check_segment[1] = check_segment[0]; ++ else ++ check_segment[1] = sec ++ ? ubicom32fdpic_osec_to_segment (output_bfd, sec->output_section) ++ : (unsigned)-1; ++ break; ++ ++ case R_UBICOM32_GOTOFFSET_LO: ++ relocation = picrel->got_entry >> 2; ++ check_segment[0] = check_segment[1] = got_segment; ++ break; ++ ++ case R_UBICOM32_FUNCDESC_GOTOFFSET_LO: ++ relocation = picrel->fdgot_entry >> 2; ++ check_segment[0] = check_segment[1] = got_segment; ++ break; ++ ++ case R_UBICOM32_FUNCDESC: ++ { ++ int dynindx; ++ bfd_vma addend = rel->r_addend; ++ ++ if (! (h && h->root.type == bfd_link_hash_undefweak ++ && UBICOM32FDPIC_SYM_LOCAL (info, h))) ++ { ++ /* If the symbol is dynamic and there may be dynamic ++ symbol resolution because we are or are linked with a ++ shared library, emit a FUNCDESC relocation such that ++ the dynamic linker will allocate the function ++ descriptor. If the symbol needs a non-local function ++ descriptor but binds locally (e.g., its visibility is ++ protected, emit a dynamic relocation decayed to ++ section+offset. */ ++ if (h && ! UBICOM32FDPIC_FUNCDESC_LOCAL (info, h) ++ && UBICOM32FDPIC_SYM_LOCAL (info, h) ++ && !(info->executable && !info->pie)) ++ { ++ dynindx = elf_section_data (h->root.u.def.section ++ ->output_section)->dynindx; ++ addend += h->root.u.def.section->output_offset ++ + h->root.u.def.value; ++ } ++ else if (h && ! UBICOM32FDPIC_FUNCDESC_LOCAL (info, h)) ++ { ++ if (addend) ++ { ++ info->callbacks->warning ++ (info, _("R_UBICOM32_FUNCDESC references dynamic symbol with nonzero addend"), ++ name, input_bfd, input_section, rel->r_offset); ++ return FALSE; ++ } ++ dynindx = h->dynindx; ++ } ++ else ++ { ++ /* Otherwise, we know we have a private function ++ descriptor, so reference it directly. */ ++ BFD_ASSERT (picrel->privfd); ++ r_type = R_UBICOM32_32; // was FUNCDESC but bfin uses 32 bit ++ dynindx = elf_section_data (ubicom32fdpic_got_section (info) ++ ->output_section)->dynindx; ++ addend = ubicom32fdpic_got_section (info)->output_offset ++ + ubicom32fdpic_got_initial_offset (info) ++ + picrel->fd_entry; ++ } ++ ++ /* If there is room for dynamic symbol resolution, emit ++ the dynamic relocation. However, if we're linking an ++ executable at a fixed location, we won't have emitted a ++ dynamic symbol entry for the got section, so idx will ++ be zero, which means we can and should compute the ++ address of the private descriptor ourselves. */ ++ if (info->executable && !info->pie ++ && (!h || UBICOM32FDPIC_FUNCDESC_LOCAL (info, h))) ++ { ++ addend += ubicom32fdpic_got_section (info)->output_section->vma; ++ if ((bfd_get_section_flags (output_bfd, ++ input_section->output_section) ++ & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) ++ { ++ if (ubicom32fdpic_osec_readonly_p (output_bfd, ++ input_section ++ ->output_section)) ++ { ++ info->callbacks->warning ++ (info, ++ _("cannot emit fixups in read-only section"), ++ name, input_bfd, input_section, rel->r_offset); ++ return FALSE; ++ } ++ ubicom32fdpic_add_rofixup (output_bfd, ++ ubicom32fdpic_gotfixup_section ++ (info), ++ _bfd_elf_section_offset ++ (output_bfd, info, ++ input_section, rel->r_offset) ++ + input_section ++ ->output_section->vma ++ + input_section->output_offset, ++ picrel); ++ } ++ } ++ else if ((bfd_get_section_flags (output_bfd, ++ input_section->output_section) ++ & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) ++ { ++ bfd_vma offset; ++ ++ if (ubicom32fdpic_osec_readonly_p (output_bfd, ++ input_section ++ ->output_section)) ++ { ++ info->callbacks->warning ++ (info, ++ _("cannot emit dynamic relocations in read-only section"), ++ name, input_bfd, input_section, rel->r_offset); ++ return FALSE; ++ } ++ offset = _bfd_elf_section_offset (output_bfd, info, ++ input_section, rel->r_offset); ++ /* Only output a reloc for a not deleted entry. */ ++ if (offset >= (bfd_vma) -2) ++ ubicom32fdpic_add_dyn_reloc (output_bfd, ++ ubicom32fdpic_gotrel_section (info), ++ 0, ++ R_UBICOM32_NONE, ++ dynindx, addend, picrel); ++ else ++ ubicom32fdpic_add_dyn_reloc (output_bfd, ++ ubicom32fdpic_gotrel_section (info), ++ offset + input_section ++ ->output_section->vma ++ + input_section->output_offset, ++ r_type, ++ dynindx, addend, picrel); ++ } ++ else ++ addend += ubicom32fdpic_got_section (info)->output_section->vma; ++ } ++ ++ /* We want the addend in-place because dynamic ++ relocations are REL. Setting relocation to it should ++ arrange for it to be installed. */ ++ relocation = addend - rel->r_addend; ++ } ++ check_segment[0] = check_segment[1] = got_segment; ++ break; ++ ++ case R_UBICOM32_32: ++ if (! IS_FDPIC (output_bfd)) ++ { ++ check_segment[0] = check_segment[1] = -1; ++ break; ++ } ++ /* Fall through. */ ++ case R_UBICOM32_FUNCDESC_VALUE: ++ { ++ int dynindx; ++ bfd_vma addend = rel->r_addend; ++ bfd_vma offset; ++ offset = _bfd_elf_section_offset (output_bfd, info, ++ input_section, rel->r_offset); ++ ++ /* If the symbol is dynamic but binds locally, use ++ section+offset. */ ++ if (h && ! UBICOM32FDPIC_SYM_LOCAL (info, h)) ++ { ++ if (addend && r_type == R_UBICOM32_FUNCDESC_VALUE) ++ { ++ info->callbacks->warning ++ (info, _("R_UBICOM32_FUNCDESC_VALUE references dynamic symbol with nonzero addend"), ++ name, input_bfd, input_section, rel->r_offset); ++ return FALSE; ++ } ++ dynindx = h->dynindx; ++ } ++ else ++ { ++ if (h) ++ addend += h->root.u.def.value; ++ else ++ addend += sym->st_value; ++ if (osec) ++ addend += osec->output_offset; ++ if (osec && osec->output_section ++ && ! bfd_is_abs_section (osec->output_section) ++ && ! bfd_is_und_section (osec->output_section)) ++ dynindx = elf_section_data (osec->output_section)->dynindx; ++ else ++ dynindx = 0; ++ } ++ ++ /* If we're linking an executable at a fixed address, we ++ can omit the dynamic relocation as long as the symbol ++ is defined in the current link unit (which is implied ++ by its output section not being NULL). */ ++ if (info->executable && !info->pie ++ && (!h || UBICOM32FDPIC_SYM_LOCAL (info, h))) ++ { ++ if (osec) ++ addend += osec->output_section->vma; ++ if (IS_FDPIC (input_bfd) ++ && (bfd_get_section_flags (output_bfd, ++ input_section->output_section) ++ & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) ++ { ++ if (ubicom32fdpic_osec_readonly_p (output_bfd, ++ input_section ++ ->output_section)) ++ { ++ info->callbacks->warning ++ (info, ++ _("cannot emit fixups in read-only section"), ++ name, input_bfd, input_section, rel->r_offset); ++ return FALSE; ++ } ++ if (!h || h->root.type != bfd_link_hash_undefweak) ++ { ++ /* Only output a reloc for a not deleted entry. */ ++ if (offset >= (bfd_vma)-2) ++ ubicom32fdpic_add_rofixup (output_bfd, ++ ubicom32fdpic_gotfixup_section ++ (info), -1, picrel); ++ else ++ ubicom32fdpic_add_rofixup (output_bfd, ++ ubicom32fdpic_gotfixup_section ++ (info), ++ offset + input_section ++ ->output_section->vma ++ + input_section->output_offset, ++ picrel); ++ ++ if (r_type == R_UBICOM32_FUNCDESC_VALUE) ++ { ++ if (offset >= (bfd_vma)-2) ++ ubicom32fdpic_add_rofixup ++ (output_bfd, ++ ubicom32fdpic_gotfixup_section (info), ++ -1, picrel); ++ else ++ ubicom32fdpic_add_rofixup ++ (output_bfd, ++ ubicom32fdpic_gotfixup_section (info), ++ offset + input_section->output_section->vma ++ + input_section->output_offset + 4, picrel); ++ } ++ } ++ } ++ } ++ else ++ { ++ if ((bfd_get_section_flags (output_bfd, ++ input_section->output_section) ++ & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) ++ { ++ if (ubicom32fdpic_osec_readonly_p (output_bfd, ++ input_section ++ ->output_section)) ++ { ++ info->callbacks->warning ++ (info, ++ _("cannot emit dynamic relocations in read-only section"), ++ name, input_bfd, input_section, rel->r_offset); ++ return FALSE; ++ } ++ /* Only output a reloc for a not deleted entry. */ ++ if (offset >= (bfd_vma)-2) ++ ubicom32fdpic_add_dyn_reloc (output_bfd, ++ ubicom32fdpic_gotrel_section (info), ++ 0, R_UBICOM32_NONE, dynindx, addend, picrel); ++ else ++ ubicom32fdpic_add_dyn_reloc (output_bfd, ++ ubicom32fdpic_gotrel_section (info), ++ offset ++ + input_section ++ ->output_section->vma ++ + input_section->output_offset, ++ r_type, dynindx, addend, picrel); ++ } ++ else if (osec) ++ addend += osec->output_section->vma; ++ /* We want the addend in-place because dynamic ++ relocations are REL. Setting relocation to it ++ should arrange for it to be installed. */ ++ relocation = addend - rel->r_addend; ++ } ++ ++ if (r_type == R_UBICOM32_FUNCDESC_VALUE && offset < (bfd_vma)-2) ++ { ++ /* If we've omitted the dynamic relocation, just emit ++ the fixed addresses of the symbol and of the local ++ GOT base offset. */ ++ if (info->executable && !info->pie ++ && (!h || UBICOM32FDPIC_SYM_LOCAL (info, h))) ++ bfd_put_32 (output_bfd, ++ ubicom32fdpic_got_section (info)->output_section->vma ++ + ubicom32fdpic_got_section (info)->output_offset ++ + ubicom32fdpic_got_initial_offset (info), ++ contents + rel->r_offset + 4); ++ else ++ /* A function descriptor used for lazy or local ++ resolving is initialized such that its high word ++ contains the output section index in which the ++ PLT entries are located, and the low word ++ contains the offset of the lazy PLT entry entry ++ point into that section. */ ++ bfd_put_32 (output_bfd, ++ h && ! UBICOM32FDPIC_SYM_LOCAL (info, h) ++ ? 0 ++ : ubicom32fdpic_osec_to_segment (output_bfd, ++ sec ++ ->output_section), ++ contents + rel->r_offset + 4); ++ } ++ } ++ check_segment[0] = check_segment[1] = got_segment; ++ break; ++ ++ default: ++ check_segment[0] = isec_segment; ++ check_segment[1] = sec ++ ? ubicom32fdpic_osec_to_segment (output_bfd, sec->output_section) ++ : (unsigned)-1; ++ break; ++ } ++ ++ if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd)) ++ { ++#if 1 /* If you take this out, remove the #error from fdpic-static-6.d ++ in the ld testsuite. */ ++ /* This helps catch problems in GCC while we can't do more ++ than static linking. The idea is to test whether the ++ input file basename is crt0.o only once. */ ++ if (silence_segment_error == 1) ++ silence_segment_error = ++ (strlen (input_bfd->filename) == 6 ++ && strcmp (input_bfd->filename, "crt0.o") == 0) ++ || (strlen (input_bfd->filename) > 6 ++ && strcmp (input_bfd->filename ++ + strlen (input_bfd->filename) - 7, ++ "/crt0.o") == 0) ++ ? -1 : 0; ++#endif ++ if (!silence_segment_error ++ /* We don't want duplicate errors for undefined ++ symbols. */ ++ && !(picrel && picrel->symndx == -1 ++ && picrel->d.h->root.type == bfd_link_hash_undefined)) ++ info->callbacks->warning ++ (info, ++ (info->shared || info->pie) ++ ? _("relocations between different segments are not supported") ++ : _("warning: relocation references a different segment"), ++ name, input_bfd, input_section, rel->r_offset); ++ if (!silence_segment_error && (info->shared || info->pie)) ++ return FALSE; ++ elf_elfheader (output_bfd)->e_flags |= 0x80000000; ++ } ++ ++ switch (r_type) ++ { ++ case R_UBICOM32_LO16: ++ r = ubicom32_elf_relocate_lo16 (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_HI16: ++ r = ubicom32_elf_relocate_hi16 (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_HI24: ++ r = ubicom32_elf_relocate_hi24 (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_S: ++ r = ubicom32_elf_relocate_lo7_s (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_2_S: ++ r = ubicom32_elf_relocate_lo7_2_s (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_4_S: ++ r = ubicom32_elf_relocate_lo7_4_s (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_D: ++ r = ubicom32_elf_relocate_lo7_d (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_2_D: ++ r = ubicom32_elf_relocate_lo7_2_d (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_4_D: ++ r = ubicom32_elf_relocate_lo7_4_d (input_bfd, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_24_PCREL: ++ r = ubicom32_elf_relocate_pcrel24 (input_bfd, input_section, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_LO7_CALLI: ++ r = ubicom32_elf_relocate_lo_calli (input_bfd, rel, contents, relocation, 7); ++ break; ++ ++ case R_UBICOM32_LO16_CALLI: ++ r = ubicom32_elf_relocate_lo_calli (input_bfd, rel, contents, relocation, 18); ++ break; ++ ++ case R_UBICOM32_GOTOFFSET_LO: ++ r = ubicom32_elf_relocate_gotoffset_lo(input_bfd, input_section, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_FUNCDESC_GOTOFFSET_LO: ++ r = ubicom32_elf_relocate_funcdesc_gotoffset_lo(input_bfd, input_section, rel, contents, relocation); ++ break; ++ ++ case R_UBICOM32_32: ++ case R_UBICOM32_FUNCDESC: ++ /* relocation &= ~(0xff << 24); */ ++ /* FALLTHROUGH */ ++ ++ default: ++ r = ubicom32_final_link_relocate (howto, input_bfd, input_section, ++ contents, rel, relocation); ++ break; ++ } ++ } ++ ++ return TRUE; ++} ++ ++#define elf_info_to_howto ubicom32_info_to_howto_rela ++#define elf_info_to_howto_rel NULL ++ ++#define bfd_elf32_bfd_reloc_type_lookup ubicom32_reloc_type_lookup ++#define bfd_elf32_bfd_reloc_name_lookup ubicom32_reloc_name_lookup ++#define bfd_elf32_bfd_relax_section ubicom32_elf_relax_section ++ ++#define elf_backend_relocate_section ubicom32_elf_relocate_section ++#define elf_backend_gc_mark_hook ubicom32_elf_gc_mark_hook ++#define elf_backend_gc_sweep_hook ubicom32_elf_gc_sweep_hook ++#define elf_backend_check_relocs ubicom32_elf_check_relocs ++#define elf_backend_object_p ubicom32_elf_object_p ++ ++#define elf_backend_discard_info ubicom32_elf_discard_info ++ ++#define elf_backend_can_gc_sections 1 ++ ++#define bfd_elf32_bfd_set_private_flags ubicom32_elf_set_private_flags ++#define bfd_elf32_bfd_copy_private_bfd_data ubicom32_elf_copy_private_bfd_data ++#define bfd_elf32_bfd_merge_private_bfd_data ubicom32_elf_merge_private_bfd_data ++#define bfd_elf32_bfd_print_private_bfd_data ubicom32_elf_print_private_bfd_data ++ ++#define bfd_elf32_bfd_extcode_relax NULL ++ ++#define TARGET_BIG_SYM bfd_elf32_ubicom32_vec ++#define TARGET_BIG_NAME "elf32-ubicom32" ++ ++#define ELF_ARCH bfd_arch_ubicom32 ++#define ELF_MACHINE_CODE EM_UBICOM32 ++#define ELF_MAXPAGESIZE 0x1000 ++ ++#include "elf32-target.h" ++ ++#undef TARGET_BIG_SYM ++#define TARGET_BIG_SYM bfd_elf32_ubicom32fdpic_vec ++#undef TARGET_BIG_NAME ++#define TARGET_BIG_NAME "elf32-ubicom32fdpic" ++#undef elf32_bed ++#define elf32_bed elf32_ubicom32fdpic_bed ++ ++#undef elf_backend_relocate_section ++#define elf_backend_relocate_section ubicom32fdpic_elf_relocate_section ++ ++#undef elf_backend_check_relocs ++#define elf_backend_check_relocs ubicom32fdpic_elf_check_relocs ++ ++#undef elf_backend_gc_sweep_hook ++#define elf_backend_gc_sweep_hook ubicom32fdpic_elf_gc_sweep_hook ++#undef bfd_elf32_bfd_link_hash_table_create ++#define bfd_elf32_bfd_link_hash_table_create \ ++ ubicom32fdpic_elf_link_hash_table_create ++#undef elf_backend_always_size_sections ++#define elf_backend_always_size_sections \ ++ ubicom32fdpic_elf_always_size_sections ++#undef elf_backend_modify_program_headers ++#define elf_backend_modify_program_headers \ ++ ubicom32fdpic_elf_modify_program_headers ++#undef bfd_elf32_bfd_copy_private_bfd_data ++#define bfd_elf32_bfd_copy_private_bfd_data \ ++ ubicom32fdpic_elf_copy_private_bfd_data ++ ++#undef elf_backend_create_dynamic_sections ++#define elf_backend_create_dynamic_sections \ ++ ubicom32fdpic_elf_create_dynamic_sections ++#undef elf_backend_adjust_dynamic_symbol ++#define elf_backend_adjust_dynamic_symbol \ ++ ubicom32fdpic_elf_adjust_dynamic_symbol ++#undef elf_backend_size_dynamic_sections ++#define elf_backend_size_dynamic_sections \ ++ ubicom32fdpic_elf_size_dynamic_sections ++#undef elf_backend_finish_dynamic_symbol ++#define elf_backend_finish_dynamic_symbol \ ++ ubicom32fdpic_elf_finish_dynamic_symbol ++#undef elf_backend_finish_dynamic_sections ++#define elf_backend_finish_dynamic_sections \ ++ ubicom32fdpic_elf_finish_dynamic_sections ++ ++#undef elf_backend_can_make_relative_eh_frame ++#define elf_backend_can_make_relative_eh_frame \ ++ ubicom32fdpic_elf_use_relative_eh_frame ++#undef elf_backend_can_make_lsda_relative_eh_frame ++#define elf_backend_can_make_lsda_relative_eh_frame \ ++ ubicom32fdpic_elf_use_relative_eh_frame ++#undef elf_backend_encode_eh_address ++#define elf_backend_encode_eh_address \ ++ ubicom32fdpic_elf_encode_eh_address ++ ++#undef elf_backend_may_use_rel_p ++#define elf_backend_may_use_rel_p 1 ++#undef elf_backend_may_use_rela_p ++#define elf_backend_may_use_rela_p 1 ++/* We use REL for dynamic relocations only. */ ++#undef elf_backend_default_use_rela_p ++#define elf_backend_default_use_rela_p 1 ++ ++#undef elf_backend_omit_section_dynsym ++#define elf_backend_omit_section_dynsym ubicom32fdpic_elf_link_omit_section_dynsym ++ ++#undef elf_backend_can_refcount ++#define elf_backend_can_refcount 1 ++ ++#undef elf_backend_want_got_plt ++#define elf_backend_want_got_plt 0 ++ ++#undef elf_backend_plt_readonly ++#define elf_backend_plt_readonly 1 ++ ++#undef elf_backend_want_plt_sym ++#define elf_backend_want_plt_sym 1 ++ ++#undef elf_backend_got_header_size ++#define elf_backend_got_header_size 12 ++ ++#undef elf_backend_rela_normal ++#define elf_backend_rela_normal 1 ++ ++#include "elf32-target.h" +--- a/bfd/libbfd.h ++++ b/bfd/libbfd.h +@@ -1689,6 +1689,39 @@ static const char *const bfd_reloc_code_ + "BFD_RELOC_IP2K_FR_OFFSET", + "BFD_RELOC_VPE4KMATH_DATA", + "BFD_RELOC_VPE4KMATH_INSN", ++ "BFD_RELOC_UBICOM32_21_PCREL", ++ "BFD_RELOC_UBICOM32_24_PCREL", ++ "BFD_RELOC_UBICOM32_HI24", ++ "BFD_RELOC_UBICOM32_LO7_S", ++ "BFD_RELOC_UBICOM32_LO7_2_S", ++ "BFD_RELOC_UBICOM32_LO7_4_S", ++ "BFD_RELOC_UBICOM32_LO7_D", ++ "BFD_RELOC_UBICOM32_LO7_2_D", ++ "BFD_RELOC_UBICOM32_LO7_4_D", ++ "BFD_RELOC_UBICOM32_LO7_CALLI", ++ "BFD_RELOC_UBICOM32_LO16_CALLI", ++ "BFD_RELOC_UBICOM32_GOT_HI24", ++ "BFD_RELOC_UBICOM32_GOT_LO7_S", ++ "BFD_RELOC_UBICOM32_GOT_LO7_2_S", ++ "BFD_RELOC_UBICOM32_GOT_LO7_4_S", ++ "BFD_RELOC_UBICOM32_GOT_LO7_D", ++ "BFD_RELOC_UBICOM32_GOT_LO7_2_D", ++ "BFD_RELOC_UBICOM32_GOT_LO7_4_D", ++ "BFD_RELOC_UBICOM32_FUNCDESC_GOT_HI24", ++ "BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_S", ++ "BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_2_S", ++ "BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_4_S", ++ "BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_D", ++ "BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_2_D", ++ "BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_4_D", ++ "BFD_RELOC_UBICOM32_GOT_LO7_CALLI", ++ "BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_CALLI", ++ "BFD_RELOC_UBICOM32_FUNCDESC_VALUE", ++ "BFD_RELOC_UBICOM32_FUNCDESC", ++ "BFD_RELOC_UBICOM32_GOTOFFSET_LO", ++ "BFD_RELOC_UBICOM32_GOTOFFSET_HI", ++ "BFD_RELOC_UBICOM32_FUNCDESC_GOTOFFSET_LO", ++ "BFD_RELOC_UBICOM32_FUNCDESC_GOTOFFSET_HI", + "BFD_RELOC_VTABLE_INHERIT", + "BFD_RELOC_VTABLE_ENTRY", + "BFD_RELOC_IA64_IMM14", +--- a/bfd/Makefile.am ++++ b/bfd/Makefile.am +@@ -114,6 +114,7 @@ ALL_MACHINES = \ + cpu-tic4x.lo \ + cpu-tic54x.lo \ + cpu-tic80.lo \ ++ cpu-ubicom32.lo \ + cpu-v850.lo \ + cpu-vax.lo \ + cpu-we32k.lo \ +@@ -180,6 +181,7 @@ ALL_MACHINES_CFILES = \ + cpu-tic4x.c \ + cpu-tic54x.c \ + cpu-tic80.c \ ++ cpu-ubicom32.c \ + cpu-v850.c \ + cpu-vax.c \ + cpu-we32k.c \ +@@ -292,6 +294,7 @@ BFD32_BACKENDS = \ + elfxx-sparc.lo \ + elf32-sparc.lo \ + elf32-spu.lo \ ++ elf32-ubicom32.lo \ + elf32-v850.lo \ + elf32-vax.lo \ + elf32-xstormy16.lo \ +@@ -473,6 +476,7 @@ BFD32_BACKENDS_CFILES = \ + elfxx-sparc.c \ + elf32-sparc.c \ + elf32-spu.c \ ++ elf32-ubicom32.c \ + elf32-v850.c \ + elf32-vax.c \ + elf32-xstormy16.c \ +@@ -1131,6 +1135,7 @@ cpu-tic30.lo: cpu-tic30.c $(INCDIR)/file + cpu-tic4x.lo: cpu-tic4x.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h + cpu-tic54x.lo: cpu-tic54x.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h + cpu-tic80.lo: cpu-tic80.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h ++cpu-ubicom32.lo: cpu-ubicom32.c $(INCDIR)/filenames.h + cpu-v850.lo: cpu-v850.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h \ + $(INCDIR)/safe-ctype.h + cpu-vax.lo: cpu-vax.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h +@@ -1556,6 +1561,10 @@ elf32-spu.lo: elf32-spu.c $(INCDIR)/file + $(INCDIR)/bfdlink.h $(INCDIR)/hashtab.h elf-bfd.h $(INCDIR)/elf/common.h \ + $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/spu.h \ + $(INCDIR)/elf/reloc-macros.h elf32-spu.h elf32-target.h ++elf32-ubicom32.lo: elf32-ubicom32.c $(INCDIR)/filenames.h elf-bfd.h \ ++ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \ ++ $(INCDIR)/bfdlink.h $(INCDIR)/elf/ubicom32.h $(INCDIR)/elf/reloc-macros.h \ ++ elf32-target.h + elf32-v850.lo: elf32-v850.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \ + $(INCDIR)/hashtab.h elf-bfd.h $(INCDIR)/elf/common.h \ + $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/v850.h \ +--- a/bfd/Makefile.in ++++ b/bfd/Makefile.in +@@ -367,6 +367,7 @@ ALL_MACHINES = \ + cpu-tic4x.lo \ + cpu-tic54x.lo \ + cpu-tic80.lo \ ++ cpu-ubicom32.lo \ + cpu-v850.lo \ + cpu-vax.lo \ + cpu-we32k.lo \ +@@ -433,6 +434,7 @@ ALL_MACHINES_CFILES = \ + cpu-tic4x.c \ + cpu-tic54x.c \ + cpu-tic80.c \ ++ cpu-ubicom32.c \ + cpu-v850.c \ + cpu-vax.c \ + cpu-we32k.c \ +@@ -546,6 +548,7 @@ BFD32_BACKENDS = \ + elfxx-sparc.lo \ + elf32-sparc.lo \ + elf32-spu.lo \ ++ elf32-ubicom32.lo \ + elf32-v850.lo \ + elf32-vax.lo \ + elf32-xstormy16.lo \ +@@ -727,6 +730,7 @@ BFD32_BACKENDS_CFILES = \ + elfxx-sparc.c \ + elf32-sparc.c \ + elf32-spu.c \ ++ elf32-ubicom32.c \ + elf32-v850.c \ + elf32-vax.c \ + elf32-xstormy16.c \ +@@ -1715,6 +1719,7 @@ cpu-tic30.lo: cpu-tic30.c $(INCDIR)/file + cpu-tic4x.lo: cpu-tic4x.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h + cpu-tic54x.lo: cpu-tic54x.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h + cpu-tic80.lo: cpu-tic80.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h ++cpu-ubicom32.lo: cpu-ubicom32.c $(INCDIR)/filenames.h + cpu-v850.lo: cpu-v850.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h \ + $(INCDIR)/safe-ctype.h + cpu-vax.lo: cpu-vax.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h +@@ -2140,6 +2145,10 @@ elf32-spu.lo: elf32-spu.c $(INCDIR)/file + $(INCDIR)/bfdlink.h $(INCDIR)/hashtab.h elf-bfd.h $(INCDIR)/elf/common.h \ + $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/spu.h \ + $(INCDIR)/elf/reloc-macros.h elf32-spu.h elf32-target.h ++elf32-ubicom32.lo: elf32-ubicom32.c $(INCDIR)/filenames.h elf-bfd.h \ ++ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \ ++ $(INCDIR)/bfdlink.h $(INCDIR)/elf/ubicom32.h $(INCDIR)/elf/reloc-macros.h \ ++ elf32-target.h + elf32-v850.lo: elf32-v850.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \ + $(INCDIR)/hashtab.h elf-bfd.h $(INCDIR)/elf/common.h \ + $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/v850.h \ +--- a/bfd/reloc.c ++++ b/bfd/reloc.c +@@ -4227,6 +4227,75 @@ ENUMDOC + Scenix VPE4K coprocessor - data/insn-space addressing + + ENUM ++ BFD_RELOC_UBICOM32_21_PCREL ++ENUMX ++ BFD_RELOC_UBICOM32_24_PCREL ++ENUMX ++ BFD_RELOC_UBICOM32_HI24 ++ENUMX ++ BFD_RELOC_UBICOM32_LO7_S ++ENUMX ++ BFD_RELOC_UBICOM32_LO7_2_S ++ENUMX ++ BFD_RELOC_UBICOM32_LO7_4_S ++ENUMX ++ BFD_RELOC_UBICOM32_LO7_D ++ENUMX ++ BFD_RELOC_UBICOM32_LO7_2_D ++ENUMX ++ BFD_RELOC_UBICOM32_LO7_4_D ++ENUMX ++ BFD_RELOC_UBICOM32_LO7_CALLI ++ENUMX ++ BFD_RELOC_UBICOM32_LO16_CALLI ++ENUMX ++ BFD_RELOC_UBICOM32_GOT_HI24 ++ENUMX ++ BFD_RELOC_UBICOM32_GOT_LO7_S ++ENUMX ++ BFD_RELOC_UBICOM32_GOT_LO7_2_S ++ENUMX ++ BFD_RELOC_UBICOM32_GOT_LO7_4_S ++ENUMX ++ BFD_RELOC_UBICOM32_GOT_LO7_D ++ENUMX ++ BFD_RELOC_UBICOM32_GOT_LO7_2_D ++ENUMX ++ BFD_RELOC_UBICOM32_GOT_LO7_4_D ++ENUMX ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_HI24 ++ENUMX ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_S ++ENUMX ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_2_S ++ENUMX ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_4_S ++ENUMX ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_D ++ENUMX ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_2_D ++ENUMX ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_4_D ++ENUMX ++ BFD_RELOC_UBICOM32_GOT_LO7_CALLI ++ENUMX ++ BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_CALLI ++ENUMX ++ BFD_RELOC_UBICOM32_FUNCDESC_VALUE ++ENUMX ++ BFD_RELOC_UBICOM32_FUNCDESC ++ENUMX ++ BFD_RELOC_UBICOM32_GOTOFFSET_LO ++ENUMX ++ BFD_RELOC_UBICOM32_GOTOFFSET_HI ++ENUMX ++ BFD_RELOC_UBICOM32_FUNCDESC_GOTOFFSET_LO ++ENUMX ++ BFD_RELOC_UBICOM32_FUNCDESC_GOTOFFSET_HI ++ENUMDOC ++ Ubicom UBICOM32 Relocations. ++ ++ENUM + BFD_RELOC_VTABLE_INHERIT + ENUMX + BFD_RELOC_VTABLE_ENTRY +--- a/bfd/targets.c ++++ b/bfd/targets.c +@@ -663,6 +663,8 @@ extern const bfd_target bfd_elf32_spu_ve + extern const bfd_target bfd_elf32_tradbigmips_vec; + extern const bfd_target bfd_elf32_tradlittlemips_vec; + extern const bfd_target bfd_elf32_us_cris_vec; ++extern const bfd_target bfd_elf32_ubicom32_vec; ++extern const bfd_target bfd_elf32_ubicom32fdpic_vec; + extern const bfd_target bfd_elf32_v850_vec; + extern const bfd_target bfd_elf32_vax_vec; + extern const bfd_target bfd_elf32_xc16x_vec; +@@ -1001,6 +1003,7 @@ static const bfd_target * const _bfd_tar + &bfd_elf32_tradbigmips_vec, + &bfd_elf32_tradlittlemips_vec, + &bfd_elf32_us_cris_vec, ++ &bfd_elf32_ubicom32_vec, + &bfd_elf32_v850_vec, + &bfd_elf32_vax_vec, + &bfd_elf32_xc16x_vec, +--- a/binutils/Makefile.am ++++ b/binutils/Makefile.am +@@ -584,7 +584,7 @@ readelf.o: readelf.c config.h sysdep.h $ + $(INCDIR)/elf/dlx.h $(INCDIR)/elf/fr30.h $(INCDIR)/elf/frv.h \ + $(INCDIR)/elf/hppa.h $(INCDIR)/elf/i386.h $(INCDIR)/elf/i370.h \ + $(INCDIR)/elf/i860.h $(INCDIR)/elf/i960.h $(INCDIR)/elf/ia64.h \ +- $(INCDIR)/elf/ip2k.h $(INCDIR)/elf/iq2000.h $(INCDIR)/elf/m32c.h \ ++ $(INCDIR)/elf/ip2k.h $(INCDIR)/elf/ubicom32.h $(INCDIR)/elf/iq2000.h $(INCDIR)/elf/m32c.h \ + $(INCDIR)/elf/m32r.h $(INCDIR)/elf/m68k.h $(INCDIR)/elf/m68hc11.h \ + $(INCDIR)/elf/mcore.h $(INCDIR)/elf/mep.h $(INCDIR)/elf/mips.h \ + $(INCDIR)/elf/mmix.h $(INCDIR)/elf/mn10200.h $(INCDIR)/elf/mn10300.h \ +--- a/binutils/Makefile.in ++++ b/binutils/Makefile.in +@@ -1338,7 +1338,7 @@ readelf.o: readelf.c config.h sysdep.h $ + $(INCDIR)/elf/dlx.h $(INCDIR)/elf/fr30.h $(INCDIR)/elf/frv.h \ + $(INCDIR)/elf/hppa.h $(INCDIR)/elf/i386.h $(INCDIR)/elf/i370.h \ + $(INCDIR)/elf/i860.h $(INCDIR)/elf/i960.h $(INCDIR)/elf/ia64.h \ +- $(INCDIR)/elf/ip2k.h $(INCDIR)/elf/iq2000.h $(INCDIR)/elf/m32c.h \ ++ $(INCDIR)/elf/ip2k.h $(INCDIR)/elf/ubicom32.h $(INCDIR)/elf/iq2000.h $(INCDIR)/elf/m32c.h \ + $(INCDIR)/elf/m32r.h $(INCDIR)/elf/m68k.h $(INCDIR)/elf/m68hc11.h \ + $(INCDIR)/elf/mcore.h $(INCDIR)/elf/mep.h $(INCDIR)/elf/mips.h \ + $(INCDIR)/elf/mmix.h $(INCDIR)/elf/mn10200.h $(INCDIR)/elf/mn10300.h \ +--- a/binutils/readelf.c ++++ b/binutils/readelf.c +@@ -152,6 +152,7 @@ + #include "elf/sh.h" + #include "elf/sparc.h" + #include "elf/spu.h" ++#include "elf/ubicom32.h" + #include "elf/v850.h" + #include "elf/vax.h" + #include "elf/x86-64.h" +@@ -612,6 +613,7 @@ guess_is_rela (unsigned int e_machine) + case EM_SPARC32PLUS: + case EM_SPARCV9: + case EM_SPU: ++ case EM_UBICOM32: + case EM_V850: + case EM_CYGNUS_V850: + case EM_VAX: +@@ -1159,6 +1161,10 @@ dump_relocations (FILE *file, + rtype = elf_crx_reloc_type (type); + break; + ++ case EM_UBICOM32: ++ rtype = elf_ubicom32_reloc_type (type); ++ break; ++ + case EM_VAX: + rtype = elf_vax_reloc_type (type); + break; +@@ -1812,6 +1818,7 @@ get_machine_name (unsigned e_machine) + case EM_DLX: return "OpenDLX"; + case EM_IP2K_OLD: + case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers"; ++ case EM_UBICOM32: return "Ubicom32 32-bit microcontrollers"; + case EM_IQ2000: return "Vitesse IQ2000"; + case EM_XTENSA_OLD: + case EM_XTENSA: return "Tensilica Xtensa Processor"; +--- a/config.sub ++++ b/config.sub +@@ -283,6 +283,7 @@ case $basic_machine in + | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ + | spu | strongarm \ + | tahoe | thumb | tic4x | tic80 | tron \ ++ | ubicom32 \ + | v850 | v850e \ + | ubicom32 \ + | we32k \ +@@ -367,6 +368,7 @@ case $basic_machine in + | tahoe-* | thumb-* \ + | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ + | tron-* \ ++ | ubicom32-* \ + | v850-* | v850e-* | vax-* \ + | ubicom32-* \ + | we32k-* \ +--- a/configure ++++ b/configure +@@ -2666,6 +2666,12 @@ case "${target}" in + xtensa*-*-*) + noconfigdirs="$noconfigdirs ${libgcj}" + ;; ++ ubicom32-*-*linux*) ++ noconfigdirs="$noconfigdirs target-libffi target-newlib" ++ ;; ++ ubicom32-*-*) ++ noconfigdirs="$noconfigdirs target-libffi target-newlib" ++ ;; + ip2k-*-*) + noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}" + ;; +--- a/configure.ac ++++ b/configure.ac +@@ -915,6 +915,12 @@ case "${target}" in + xtensa*-*-*) + noconfigdirs="$noconfigdirs ${libgcj}" + ;; ++ ubicom32-*-*linux*) ++ noconfigdirs="$noconfigdirs target-libffi target-newlib" ++ ;; ++ ubicom32-*-*) ++ noconfigdirs="$noconfigdirs target-libffi" ++ ;; + ip2k-*-*) + noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}" + ;; +--- /dev/null ++++ b/gas/config/tc-ubicom32.c +@@ -0,0 +1,609 @@ ++/* tc-ubicom32.c -- Assembler for the Ubicom32 ++ Copyright (C) 2000, 2002 Free Software Foundation. ++ ++ This file is part of GAS, the GNU Assembler. ++ ++ GAS 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. ++ ++ GAS 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 GAS; see the file COPYING. If not, write to ++ the Free Software Foundation, 59 Temple Place - Suite 330, ++ Boston, MA 02111-1307, USA. */ ++ ++#include ++#include ++ ++#include "as.h" ++#include "dwarf2dbg.h" ++#include "subsegs.h" ++#include "symcat.h" ++#include "opcodes/ubicom32-desc.h" ++#include "opcodes/ubicom32-opc.h" ++#include "cgen.h" ++#include "elf/common.h" ++#include "elf/ubicom32.h" ++#include "libbfd.h" ++ ++extern void gas_cgen_md_operand (expressionS *); ++ ++/* Structure to hold all of the different components describing ++ an individual instruction. */ ++typedef struct ++{ ++ const CGEN_INSN * insn; ++ const CGEN_INSN * orig_insn; ++ CGEN_FIELDS fields; ++#if CGEN_INT_INSN_P ++ CGEN_INSN_INT buffer [1]; ++#define INSN_VALUE(buf) (*(buf)) ++#else ++ unsigned char buffer [CGEN_MAX_INSN_SIZE]; ++#define INSN_VALUE(buf) (buf) ++#endif ++ char * addr; ++ fragS * frag; ++ int num_fixups; ++ fixS * fixups [GAS_CGEN_MAX_FIXUPS]; ++ int indices [MAX_OPERAND_INSTANCES]; ++} ++ubicom32_insn; ++ ++const char comment_chars[] = ";"; ++const char line_comment_chars[] = "#"; ++const char line_separator_chars[] = ""; ++const char EXP_CHARS[] = "eE"; ++const char FLT_CHARS[] = "dD"; ++ ++/* Ubicom32 specific function to handle FD-PIC pointer initializations. */ ++ ++static void ++ubicom32_pic_ptr (int nbytes) ++{ ++ expressionS exp; ++ char *p; ++ ++ if (nbytes != 4) ++ abort (); ++ ++#ifdef md_flush_pending_output ++ md_flush_pending_output (); ++#endif ++ ++ if (is_it_end_of_statement ()) ++ { ++ demand_empty_rest_of_line (); ++ return; ++ } ++ ++#ifdef md_cons_align ++ md_cons_align (nbytes); ++#endif ++ ++ do ++ { ++ bfd_reloc_code_real_type reloc_type = BFD_RELOC_UBICOM32_FUNCDESC; ++ ++ if (strncasecmp (input_line_pointer, "%funcdesc(", strlen("%funcdesc(")) == 0) ++ { ++ input_line_pointer += strlen("%funcdesc("); ++ expression (&exp); ++ if (*input_line_pointer == ')') ++ input_line_pointer++; ++ else ++ as_bad (_("missing ')'")); ++ } ++ else ++ as_bad ("missing funcdesc in picptr"); ++ ++ p = frag_more (4); ++ memset (p, 0, 4); ++ fix_new_exp (frag_now, p - frag_now->fr_literal, 4, &exp, 0, ++ reloc_type); ++ } ++ while (*input_line_pointer++ == ','); ++ ++ input_line_pointer--; /* Put terminator back into stream. */ ++ demand_empty_rest_of_line (); ++} ++ ++/* The target specific pseudo-ops which we support. */ ++const pseudo_typeS md_pseudo_table[] = ++{ ++ { "file", (void (*)(int))dwarf2_directive_file, 0 }, ++ { "loc", dwarf2_directive_loc, 0 }, ++ { "picptr", ubicom32_pic_ptr, 4 }, ++ { "word", cons, 4 }, ++ { NULL, NULL, 0 } ++}; ++ ++/* A table of the register symbols */ ++#if 0 ++static symbolS *ubicom32_register_table[40]; /* 32 data & 8 address */ ++#endif ++ ++ ++#define OPTION_CPU_IP3035 (OPTION_MD_BASE) ++#define OPTION_CPU_UBICOM32DSP (OPTION_MD_BASE+1) ++#define OPTION_CPU_UBICOM32VER4 (OPTION_MD_BASE+2) ++#define OPTION_CPU_UBICOM32VER3FDPIC (OPTION_MD_BASE+3) ++#define OPTION_CPU_UBICOM32VER4FDPIC (OPTION_MD_BASE+4) ++#define OPTION_CPU_UBICOM32_FDPIC (OPTION_MD_BASE+5) ++ ++struct option md_longopts[] = ++{ ++ { "mubicom32v1", no_argument, NULL, OPTION_CPU_IP3035 }, ++ { "mubicom32v2", no_argument, NULL, OPTION_CPU_UBICOM32DSP }, ++ { "mubicom32v3", no_argument, NULL, OPTION_CPU_UBICOM32DSP }, ++ { "mubicom32v4", no_argument, NULL, OPTION_CPU_UBICOM32VER4 }, ++ { "mubicom32v3fdpic", no_argument, NULL, OPTION_CPU_UBICOM32VER3FDPIC }, ++ { "mubicom32v4fdpic", no_argument, NULL, OPTION_CPU_UBICOM32VER4FDPIC }, ++ { "mfdpic", no_argument, NULL, OPTION_CPU_UBICOM32_FDPIC }, ++ { NULL, no_argument, NULL, 0 }, ++}; ++size_t md_longopts_size = sizeof (md_longopts); ++ ++const char * md_shortopts = ""; ++ ++/* Mach selected from command line. */ ++int ubicom32_mach = 0; ++unsigned ubicom32_mach_bitmask = 0; ++ ++int ++md_parse_option (c, arg) ++ int c ATTRIBUTE_UNUSED; ++ char * arg ATTRIBUTE_UNUSED; ++{ ++ int pic_state = ubicom32_mach & 0xffff0000; ++ switch (c) ++ { ++ case OPTION_CPU_IP3035: ++ ubicom32_mach = bfd_mach_ubicom32; ++ ubicom32_mach_bitmask = 1 << MACH_IP3035; ++ break; ++ ++ case OPTION_CPU_UBICOM32DSP: ++ ubicom32_mach = bfd_mach_ubicom32dsp; ++ ubicom32_mach_bitmask = (1 << MACH_UBICOM32DSP)| (1 << MACH_IP3023COMPATIBILITY); ++ break; ++ ++ case OPTION_CPU_UBICOM32VER4: ++ ubicom32_mach = bfd_mach_ubicom32ver4; ++ ubicom32_mach_bitmask = (1 << MACH_UBICOM32DSP)| (1 << MACH_IP3023COMPATIBILITY) | (1 << MACH_UBICOM32_VER4); ++ break; ++ ++ case OPTION_CPU_UBICOM32VER3FDPIC: ++ ubicom32_mach = bfd_mach_ubicom32dsp | EF_UBICOM32_FDPIC; ++ ubicom32_mach_bitmask = (1 << MACH_UBICOM32DSP)| (1 << MACH_IP3023COMPATIBILITY); ++ break; ++ ++ case OPTION_CPU_UBICOM32VER4FDPIC: ++ ubicom32_mach = bfd_mach_ubicom32ver4 | EF_UBICOM32_FDPIC; ++ ubicom32_mach_bitmask = (1 << MACH_UBICOM32DSP)| (1 << MACH_IP3023COMPATIBILITY) | (1 << MACH_UBICOM32_VER4); ++ break; ++ ++ case OPTION_CPU_UBICOM32_FDPIC: ++ ubicom32_mach |= EF_UBICOM32_FDPIC; ++ break; ++ ++ default: ++ return 0; ++ } ++ ubicom32_mach |= pic_state; ++ ++ return 1; ++} ++ ++ ++void ++md_show_usage (stream) ++ FILE * stream; ++{ ++ fprintf (stream, _("UBICOM32 specific command line options:\n")); ++ fprintf (stream, _(" -mubicom32v1 restrict to IP3023 insns \n")); ++ fprintf (stream, _(" -mubicom32v3 permit DSP extended insn\n")); ++ fprintf (stream, _(" -mubicom32v4 permit DSP extended insn and additional .1 instructions.\n")); ++ fprintf (stream, _(" -mfdpic This in addition to the v3 or v4 flags will produce a FDPIC .o.\n")); ++ ++} ++ ++ ++void ++md_begin () ++{ ++ /* Initialize the `cgen' interface. */ ++ if(ubicom32_mach_bitmask == 0) { ++ /* md_parse_option has not been called */ ++ ubicom32_mach_bitmask = 1<signed_overflow_ok_p=1; ++ ++ /* need a way to detect when we have multiple increments to same An register */ ++ insn.fields.f_s1_i4_1 = 0; ++ insn.fields.f_s1_i4_2 = 0; ++ insn.fields.f_s1_i4_4 = 0; ++ insn.fields.f_d_i4_1 = 0; ++ insn.fields.f_d_i4_2 = 0; ++ insn.fields.f_d_i4_4 = 0; ++ insn.fields.f_s1_direct = 0; ++ insn.fields.f_d_direct = 0; ++ ++ memset(&insn.fields, 0, sizeof(insn.fields)); ++ insn.insn = ubicom32_cgen_assemble_insn ++ (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg); ++ ++ if (!insn.insn) ++ { ++ as_bad ("%s", errmsg); ++ return; ++ } ++ ++ if (insn.fields.f_s1_An == insn.fields.f_d_An) ++ { ++ if ((insn.fields.f_s1_i4_1 != 0 && insn.fields.f_d_i4_1 != 0) || ++ (insn.fields.f_s1_i4_2 != 0 && insn.fields.f_d_i4_2 != 0) || ++ (insn.fields.f_s1_i4_4 != 0 && insn.fields.f_d_i4_4 != 0)) ++ { ++ /* user has tried to increment the same An register in both the s1 ++ and d operands which is illegal */ ++ static char errbuf[255]; ++ char *first_part; ++ first_part = _("s1 and d operands update same An register"); ++ if (strlen (str) > 50) ++ sprintf (errbuf, "%s `%.50s...'", first_part, str); ++ else ++ sprintf (errbuf, "%s `%.50s'", first_part, str); ++ ++ as_bad ("%s", errbuf); ++ return; ++ } ++ } ++ ++ if(insn.fields.f_d_direct && ++ insn.fields.f_d_An == 0 && ++ insn.fields.f_d_imm7_4 == 0 && ++ insn.fields.f_d_imm7_2 == 0 && ++ insn.fields.f_d_imm7_1 == 0 && ++ insn.fields.f_d_i4_1 == 0 && ++ insn.fields.f_d_i4_2 == 0 && ++ insn.fields.f_d_i4_4 == 0) ++ { ++ if (insn.fields.f_d_direct >= A0_ADDRESS && ++ insn.fields.f_d_direct <= A7_ADDRESS) ++ { ++ long d_direct = (insn.fields.f_d_direct - A0_ADDRESS) >> 2; ++ if (d_direct == insn.fields.f_s1_An && ++ (insn.fields.f_s1_i4_1 != 0 || ++ insn.fields.f_s1_i4_2 != 0 || ++ insn.fields.f_s1_i4_4 != 0)) ++ { ++ /* user has tried to increment an An register that is also the destination register */ ++ static char errbuf[255]; ++ char *first_part; ++ first_part = _("s1 and d operands update same An register"); ++ if (strlen (str) > 50) ++ sprintf (errbuf, "%s `%.50s...'", first_part, str); ++ else ++ sprintf (errbuf, "%s `%.50s'", first_part, str); ++ ++ as_bad ("%s", errbuf); ++ return; ++ } ++ } ++ } ++ ++ /* Doesn't really matter what we pass for RELAX_P here. */ ++ gas_cgen_finish_insn (insn.insn, insn.buffer, ++ CGEN_FIELDS_BITSIZE (& insn.fields), 1, NULL); ++ ++} ++ ++/* The syntax in the manual says constants begin with '#'. ++ We just ignore it. */ ++ ++void ++md_operand (expressionP) ++ expressionS * expressionP; ++{ ++ /* In case of a syntax error, escape back to try next syntax combo. */ ++ if (expressionP->X_op == O_absent) ++ gas_cgen_md_operand (expressionP); ++} ++ ++valueT ++md_section_align (segment, size) ++ segT segment; ++ valueT size; ++{ ++ int align = bfd_get_section_alignment (stdoutput, segment); ++ return ((size + (1 << align) - 1) & (-1 << align)); ++} ++ ++ ++/* Be sure to use our register symbols. */ ++symbolS * ++md_undefined_symbol (char * name ATTRIBUTE_UNUSED) ++{ ++#if 0 ++ char c; ++ unsigned int u; ++ ++ if (sscanf(name, "%c%u", &c, &u) == 2) ++ { ++ if (c == 'd' && u < 32) ++ return ubicom32_register_table[u]; ++ if (c == 'a' && u < 8) ++ return ubicom32_register_table[u + 32]; ++ } ++#endif ++ return (0); ++} ++ ++/* Interface to relax_segment. */ ++ ++/* Return an initial guess of the length by which a fragment must grow to ++ hold a branch to reach its destination. ++ Also updates fr_type/fr_subtype as necessary. ++ ++ Called just before doing relaxation. ++ Any symbol that is now undefined will not become defined. ++ The guess for fr_var is ACTUALLY the growth beyond fr_fix. ++ Whatever we do to grow fr_fix or fr_var contributes to our returned value. ++ Although it may not be explicit in the frag, pretend fr_var starts with a ++ 0 value. */ ++ ++int ++md_estimate_size_before_relax (fragP, segment) ++ fragS * fragP; ++ segT segment ATTRIBUTE_UNUSED; ++{ ++ int old_fr_fix = fragP->fr_fix; ++ ++ /* The only thing we have to handle here are symbols outside of the ++ current segment. They may be undefined or in a different segment in ++ which case linker scripts may place them anywhere. ++ However, we can't finish the fragment here and emit the reloc as insn ++ alignment requirements may move the insn about. */ ++ ++ return (fragP->fr_var + fragP->fr_fix - old_fr_fix); ++} ++ ++/* *fragP has been relaxed to its final size, and now needs to have ++ the bytes inside it modified to conform to the new size. ++ ++ Called after relaxation is finished. ++ fragP->fr_type == rs_machine_dependent. ++ fragP->fr_subtype is the subtype of what the address relaxed to. */ ++ ++void ++md_convert_frag (abfd, sec, fragP) ++ bfd * abfd ATTRIBUTE_UNUSED; ++ segT sec ATTRIBUTE_UNUSED; ++ fragS * fragP ATTRIBUTE_UNUSED; ++{ ++} ++ ++ ++/* Functions concerning relocs. */ ++ ++long ++md_pcrel_from_section (fixS *fixP ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED) ++{ ++ /* Leave it for the linker to figure out so relaxation can work*/ ++ return 0; ++} ++ ++/* Return the bfd reloc type for OPERAND of INSN at fixup FIXP. ++ Returns BFD_RELOC_NONE if no reloc type can be found. ++ *FIXP may be modified if desired. */ ++ ++bfd_reloc_code_real_type ++md_cgen_lookup_reloc (insn, operand, fixP) ++ const CGEN_INSN * insn ATTRIBUTE_UNUSED; ++ const CGEN_OPERAND * operand; ++ fixS * fixP; ++{ ++ switch (operand->type) ++ { ++ case UBICOM32_OPERAND_IMM16_2: ++ case UBICOM32_OPERAND_IMM24: ++ case UBICOM32_OPERAND_S1_IMM7_1: ++ case UBICOM32_OPERAND_S1_IMM7_2: ++ case UBICOM32_OPERAND_S1_IMM7_4: ++ case UBICOM32_OPERAND_D_IMM7_1: ++ case UBICOM32_OPERAND_D_IMM7_2: ++ case UBICOM32_OPERAND_D_IMM7_4: ++ case UBICOM32_OPERAND_OFFSET16: ++ /* The relocation type should be recorded in opinfo */ ++ if (fixP->fx_cgen.opinfo != 0) ++ return fixP->fx_cgen.opinfo; ++ ++ case UBICOM32_OPERAND_OFFSET21: ++ fixP->fx_pcrel = TRUE; ++ return BFD_RELOC_UBICOM32_21_PCREL; ++ ++ case UBICOM32_OPERAND_OFFSET24: ++ fixP->fx_pcrel = TRUE; ++ return BFD_RELOC_UBICOM32_24_PCREL; ++ ++ default: ++ /* Pacify gcc -Wall. */ ++ return BFD_RELOC_NONE; ++ } ++} ++ ++/* See whether we need to force a relocation into the output file. */ ++ ++int ++ubicom32_force_relocation (fix) ++ fixS * fix; ++{ ++ if (fix->fx_r_type == BFD_RELOC_UNUSED) ++ return 0; ++ ++ /* Force all relocations so linker relaxation can work. */ ++ return 1; ++} ++ ++/* Write a value out to the object file, using the appropriate endianness. */ ++ ++void ++md_number_to_chars (buf, val, n) ++ char * buf; ++ valueT val; ++ int n; ++{ ++ number_to_chars_bigendian (buf, val, n); ++} ++ ++/* Turn a string in input_line_pointer into a floating point constant of type ++ type, and store the appropriate bytes in *litP. The number of LITTLENUMS ++ emitted is stored in *sizeP . An error message is returned, or NULL on OK. ++*/ ++ ++/* Equal to MAX_PRECISION in atof-ieee.c */ ++#define MAX_LITTLENUMS 6 ++ ++char * ++md_atof (int type, ++ char * litP, ++ int * sizeP) ++{ ++ int prec; ++ LITTLENUM_TYPE words [MAX_LITTLENUMS]; ++ LITTLENUM_TYPE *wordP; ++ char * t; ++ //char * atof_ieee (void); ++ ++ switch (type) ++ { ++ case 'f': ++ case 'F': ++ case 's': ++ case 'S': ++ prec = 2; ++ break; ++ ++ case 'd': ++ case 'D': ++ case 'r': ++ case 'R': ++ prec = 4; ++ break; ++ ++ /* FIXME: Some targets allow other format chars for bigger sizes here. */ ++ ++ default: ++ * sizeP = 0; ++ return _("Bad call to md_atof()"); ++ } ++ ++ t = atof_ieee (input_line_pointer, type, words); ++ if (t) ++ input_line_pointer = t; ++ * sizeP = prec * sizeof (LITTLENUM_TYPE); ++ ++ /* This loops outputs the LITTLENUMs in REVERSE order; in accord with ++ the ubicom32 endianness. */ ++ for (wordP = words; prec--;) ++ { ++ md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE)); ++ litP += sizeof (LITTLENUM_TYPE); ++ } ++ ++ return 0; ++} ++ ++bfd_boolean ++ubicom32_fix_adjustable (fixP) ++ fixS * fixP; ++{ ++ bfd_reloc_code_real_type reloc_type; ++ ++ if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED) ++ { ++ const CGEN_INSN *insn = NULL; ++ int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED; ++ const CGEN_OPERAND *operand = cgen_operand_lookup_by_num(gas_cgen_cpu_desc, opindex); ++ reloc_type = md_cgen_lookup_reloc (insn, operand, fixP); ++ } ++ else ++ reloc_type = fixP->fx_r_type; ++ ++ if (fixP->fx_addsy == NULL) ++ return 1; ++ ++ if (!S_IS_LOCAL (fixP->fx_addsy)) ++ /* Let the linker resolve all symbols not within the local function ++ so the linker can relax correctly. */ ++ return 0; ++ ++ if (S_IS_WEAK (fixP->fx_addsy)) ++ return 0; ++ ++ /* We need the symbol name for the VTABLE entries */ ++ if ( reloc_type == BFD_RELOC_VTABLE_INHERIT ++ || reloc_type == BFD_RELOC_VTABLE_ENTRY) ++ return 0; ++ ++ return 1; ++} +--- /dev/null ++++ b/gas/config/tc-ubicom32.h +@@ -0,0 +1,74 @@ ++/* tc-ubicom32.h -- Header file for tc-ubicom32.c. ++ Copyright (C) 2000 Free Software Foundation, Inc. ++ ++ This file is part of GAS, the GNU Assembler. ++ ++ GAS 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. ++ ++ GAS 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 GAS; see the file COPYING. If not, write to ++ the Free Software Foundation, 59 Temple Place - Suite 330, ++ Boston, MA 02111-1307, USA. */ ++ ++#define TC_UBICOM32 ++ ++#if 0 ++#ifndef BFD_ASSEMBLER ++/* leading space so will compile with cc */ ++ #error UBICOM32 support requires BFD_ASSEMBLER ++#endif ++#endif ++ ++#define LISTING_HEADER "IP3xxx GAS " ++ ++/* The target BFD architecture. */ ++#define TARGET_ARCH bfd_arch_ubicom32 ++ ++#define TARGET_FORMAT "elf32-ubicom32" ++ ++#define TARGET_BYTES_BIG_ENDIAN 1 ++ ++/* Permit temporary numeric labels. */ ++#define LOCAL_LABELS_FB 1 ++ ++/* .-foo gets turned into PC relative relocs. */ ++#define DIFF_EXPR_OK ++ ++/* UBICOM32 uses '(' and ')' as punctuation in addressing mode syntax. */ ++#define RELAX_PAREN_GROUPING ++ ++/* We don't need to handle .word strangely. */ ++#define WORKING_DOT_WORD ++ ++#define MD_APPLY_FIX3 ++#define md_apply_fix gas_cgen_md_apply_fix ++ ++/* special characters for hex and bin literals */ ++#define LITERAL_PREFIXDOLLAR_HEX ++#define LITERAL_PREFIXPERCENT_BIN ++#define DOUBLESLASH_LINE_COMMENTS ++ ++/* call md_pcrel_from_section, not md_pcrel_from */ ++long md_pcrel_from_section PARAMS ((struct fix *, segT)); ++#define MD_PCREL_FROM_SECTION(FIXP, SEC) md_pcrel_from_section (FIXP, SEC) ++ ++#define obj_fix_adjustable(fixP) ubicom32_fix_adjustable (fixP) ++extern bfd_boolean ubicom32_fix_adjustable PARAMS ((struct fix *)); ++ ++/* Permit temporary numeric labels. */ ++#define LOCAL_LABELS_FB 1 ++ ++#define TC_HANDLES_FX_DONE ++ ++#define tc_gen_reloc gas_cgen_tc_gen_reloc ++ ++#define TC_FORCE_RELOCATION(fixp) ubicom32_force_relocation(fixp) ++extern int ubicom32_force_relocation PARAMS ((struct fix *)); +--- a/gas/configure ++++ b/gas/configure +@@ -11188,7 +11188,7 @@ _ACEOF + fi + ;; + +- fr30 | ip2k | iq2000 | m32r | openrisc) ++ fr30 | ubicom32 | ip2k | iq2000 | m32r | openrisc) + using_cgen=yes + ;; + +--- a/gas/configure.in ++++ b/gas/configure.in +@@ -307,7 +307,7 @@ changequote([,])dnl + fi + ;; + +- fr30 | ip2k | iq2000 | m32r | openrisc) ++ fr30 | ubicom32 | ip2k | iq2000 | m32r | openrisc) + using_cgen=yes + ;; + +--- a/gas/configure.tgt ++++ b/gas/configure.tgt +@@ -81,6 +81,7 @@ case ${cpu} in + strongarm*be) cpu_type=arm endian=big ;; + strongarm*b) cpu_type=arm endian=big ;; + strongarm*) cpu_type=arm endian=little ;; ++ ubicom32) cpu_type=ubicom32 endian=big ;; + v850*) cpu_type=v850 ;; + x86_64*) cpu_type=i386 arch=x86_64;; + xscale*be|xscale*b) cpu_type=arm endian=big ;; +@@ -384,6 +385,8 @@ case ${generic_target} in + tic4x-*-* | c4x-*-*) fmt=coff bfd_gas=yes ;; + tic54x-*-* | c54x*-*-*) fmt=coff bfd_gas=yes need_libm=yes;; + ++ ubicom32-*-*) fmt=elf ;; ++ + v850-*-*) fmt=elf ;; + v850e-*-*) fmt=elf ;; + v850ea-*-*) fmt=elf ;; +--- a/gas/Makefile.am ++++ b/gas/Makefile.am +@@ -92,6 +92,7 @@ CPU_TYPES = \ + tic30 \ + tic4x \ + tic54x \ ++ ubicom32 \ + v850 \ + vax \ + xc16x \ +@@ -287,6 +288,7 @@ TARGET_CPU_CFILES = \ + config/tc-tic30.c \ + config/tc-tic4x.c \ + config/tc-tic54x.c \ ++ config/tc-ubicom32.c \ + config/tc-vax.c \ + config/tc-v850.c \ + config/tc-xstormy16.c \ +@@ -1415,6 +1417,14 @@ DEPTC_tic54x_coff = $(srcdir)/config/obj + $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h $(INCDIR)/safe-ctype.h \ + sb.h macro.h subsegs.h $(INCDIR)/obstack.h struc-symbol.h \ + $(INCDIR)/opcode/tic54x.h ++DEPTC_ubicom32_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \ ++ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \ ++ $(INCDIR)/bfdlink.h $(srcdir)/config/tc-ubicom32.h dwarf2dbg.h \ ++ subsegs.h $(INCDIR)/obstack.h $(srcdir)/../opcodes/ubicom32-desc.h \ ++ $(INCDIR)/opcode/cgen-bitset.h $(INCDIR)/opcode/cgen.h \ ++ $(INCDIR)/opcode/cgen-bitset.h $(srcdir)/../opcodes/ubicom32-opc.h \ ++ cgen.h $(INCDIR)/elf/common.h $(INCDIR)/elf/ubicom32.h \ ++ $(INCDIR)/elf/reloc-macros.h $(BFDDIR)/libbfd.h $(INCDIR)/hashtab.h + DEPTC_v850_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \ + $(INCDIR)/elf/common.h $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h \ + $(INCDIR)/bfdlink.h $(srcdir)/config/tc-v850.h $(INCDIR)/elf/v850.h \ +@@ -1791,6 +1801,11 @@ DEPOBJ_tic54x_coff = $(srcdir)/config/ob + $(INCDIR)/coff/internal.h $(INCDIR)/coff/tic54x.h $(INCDIR)/coff/ti.h \ + $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h $(INCDIR)/obstack.h \ + subsegs.h ++DEPOBJ_ubicomm32_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \ ++ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \ ++ $(INCDIR)/bfdlink.h $(srcdir)/config/tc-ubicom32.h dwarf2dbg.h \ ++ $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \ ++ $(INCDIR)/obstack.h struc-symbol.h dwarf2dbg.h $(INCDIR)/aout/aout64.h + DEPOBJ_v850_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \ + $(INCDIR)/elf/common.h $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h \ + $(INCDIR)/bfdlink.h $(srcdir)/config/tc-v850.h $(INCDIR)/elf/v850.h \ +@@ -2106,6 +2121,11 @@ DEP_tic4x_coff = $(srcdir)/config/obj-co + DEP_tic54x_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-tic54x.h \ + $(INCDIR)/coff/internal.h $(INCDIR)/coff/tic54x.h $(INCDIR)/coff/ti.h \ + $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h ++DEP_ubicom32_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \ ++ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \ ++ $(INCDIR)/bfdlink.h $(srcdir)/config/tc-ubicom32.h dwarf2dbg.h \ ++ $(srcdir)/config/obj-coff.h $(INCDIR)/coff/internal.h \ ++ $(BFDDIR)/libcoff.h + DEP_v850_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \ + $(INCDIR)/elf/common.h $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h \ + $(INCDIR)/bfdlink.h $(srcdir)/config/tc-v850.h $(INCDIR)/elf/v850.h \ +--- a/gas/Makefile.in ++++ b/gas/Makefile.in +@@ -341,6 +341,7 @@ CPU_TYPES = \ + tic30 \ + tic4x \ + tic54x \ ++ ubicom32 \ + v850 \ + vax \ + xc16x \ +@@ -534,6 +535,7 @@ TARGET_CPU_CFILES = \ + config/tc-tic30.c \ + config/tc-tic4x.c \ + config/tc-tic54x.c \ ++ config/tc-ubicom32.c \ + config/tc-vax.c \ + config/tc-v850.c \ + config/tc-xstormy16.c \ +@@ -594,6 +596,7 @@ TARGET_CPU_HFILES = \ + config/tc-tic30.h \ + config/tc-tic4x.h \ + config/tc-tic54x.h \ ++ config/tc-ubicom32.h \ + config/tc-vax.h \ + config/tc-v850.h \ + config/tc-xstormy16.h \ +@@ -1244,6 +1247,13 @@ DEPTC_tic54x_coff = $(srcdir)/config/obj + $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h $(INCDIR)/safe-ctype.h \ + sb.h macro.h subsegs.h $(INCDIR)/obstack.h struc-symbol.h \ + $(INCDIR)/opcode/tic54x.h ++DEPTC_ubicom32_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \ ++ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \ ++ $(INCDIR)/bfdlink.h $(srcdir)/config/tc-ubicom32.h dwarf2dbg.h \ ++ subsegs.h $(INCDIR)/obstack.h $(srcdir)/../opcodes/ubicom32-desc.h \ ++ $(INCDIR)/opcode/cgen-bitset.h $(INCDIR)/opcode/cgen.h \ ++ $(srcdir)/../opcodes/ubicom32-opc.h cgen.h $(INCDIR)/elf/ubicom32.h \ ++ $(INCDIR)/elf/reloc-macros.h $(BFDDIR)/libbfd.h $(INCDIR)/hashtab.h + + DEPTC_v850_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \ + $(INCDIR)/elf/common.h $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h \ +@@ -1700,6 +1710,11 @@ DEPOBJ_tic54x_coff = $(srcdir)/config/ob + $(INCDIR)/coff/internal.h $(INCDIR)/coff/tic54x.h $(INCDIR)/coff/ti.h \ + $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h $(INCDIR)/obstack.h \ + subsegs.h ++DEPOBJ_ubicom32_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \ ++ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \ ++ $(INCDIR)/bfdlink.h $(srcdir)/config/tc-ubicom32.h dwarf2dbg.h \ ++ $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \ ++ struc-symbol.h $(INCDIR)/aout/aout64.h + + DEPOBJ_v850_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \ + $(INCDIR)/elf/common.h $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h \ +@@ -2096,6 +2111,11 @@ DEP_tic54x_coff = $(srcdir)/config/obj-c + $(INCDIR)/coff/internal.h $(INCDIR)/coff/tic54x.h $(INCDIR)/coff/ti.h \ + $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h + ++DEP_ubicom32_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \ ++ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \ ++ $(INCDIR)/bfdlink.h $(srcdir)/config/tc-ubicom32.h dwarf2dbg.h \ ++ $(srcdir)/config/obj-coff.h $(INCDIR)/coff/internal.h \ ++ $(BFDDIR)/libcoff.h + DEP_v850_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \ + $(INCDIR)/elf/common.h $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h \ + $(INCDIR)/bfdlink.h $(srcdir)/config/tc-v850.h $(INCDIR)/elf/v850.h \ +--- a/include/dis-asm.h ++++ b/include/dis-asm.h +@@ -275,6 +275,7 @@ extern int print_insn_tic30 (bfd_vma, d + extern int print_insn_tic4x (bfd_vma, disassemble_info *); + extern int print_insn_tic54x (bfd_vma, disassemble_info *); + extern int print_insn_tic80 (bfd_vma, disassemble_info *); ++extern int print_insn_ubicom32 (bfd_vma, disassemble_info *); + extern int print_insn_v850 (bfd_vma, disassemble_info *); + extern int print_insn_vax (bfd_vma, disassemble_info *); + extern int print_insn_w65 (bfd_vma, disassemble_info *); +--- /dev/null ++++ b/include/dis-asm_ubicom32.h +@@ -0,0 +1,339 @@ ++/* Interface between the opcode library and its callers. ++ ++ Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005 ++ Free Software Foundation, Inc. ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 2, or (at your option) ++ any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software ++ Foundation, Inc., 51 Franklin Street - Fifth Floor, ++ Boston, MA 02110-1301, USA. ++ ++ Written by Cygnus Support, 1993. ++ ++ The opcode library (libopcodes.a) provides instruction decoders for ++ a large variety of instruction sets, callable with an identical ++ interface, for making instruction-processing programs more independent ++ of the instruction set being processed. */ ++ ++#ifndef DIS_ASM_H ++#define DIS_ASM_H ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#include ++#include "bfd.h" ++ ++typedef int (*fprintf_ftype) (void *, const char*, ...) ATTRIBUTE_FPTR_PRINTF_2; ++ ++enum dis_insn_type { ++ dis_noninsn, /* Not a valid instruction */ ++ dis_nonbranch, /* Not a branch instruction */ ++ dis_branch, /* Unconditional branch */ ++ dis_condbranch, /* Conditional branch */ ++ dis_jsr, /* Jump to subroutine */ ++ dis_condjsr, /* Conditional jump to subroutine */ ++ dis_dref, /* Data reference instruction */ ++ dis_dref2 /* Two data references in instruction */ ++}; ++ ++/* This struct is passed into the instruction decoding routine, ++ and is passed back out into each callback. The various fields are used ++ for conveying information from your main routine into your callbacks, ++ for passing information into the instruction decoders (such as the ++ addresses of the callback functions), or for passing information ++ back from the instruction decoders to their callers. ++ ++ It must be initialized before it is first passed; this can be done ++ by hand, or using one of the initialization macros below. */ ++ ++typedef struct disassemble_info { ++ fprintf_ftype fprintf_func; ++ void *stream; ++ void *application_data; ++ ++ /* Target description. We could replace this with a pointer to the bfd, ++ but that would require one. There currently isn't any such requirement ++ so to avoid introducing one we record these explicitly. */ ++ /* The bfd_flavour. This can be bfd_target_unknown_flavour. */ ++ enum bfd_flavour flavour; ++ /* The bfd_arch value. */ ++ enum bfd_architecture arch; ++ /* The bfd_mach value. */ ++ unsigned long mach; ++ /* Endianness (for bi-endian cpus). Mono-endian cpus can ignore this. */ ++ enum bfd_endian endian; ++ /* An arch/mach-specific bitmask of selected instruction subsets, mainly ++ for processors with run-time-switchable instruction sets. The default, ++ zero, means that there is no constraint. CGEN-based opcodes ports ++ may use ISA_foo masks. */ ++ void *insn_sets; ++ ++ /* Some targets need information about the current section to accurately ++ display insns. If this is NULL, the target disassembler function ++ will have to make its best guess. */ ++ asection *section; ++ ++ /* An array of pointers to symbols either at the location being disassembled ++ or at the start of the function being disassembled. The array is sorted ++ so that the first symbol is intended to be the one used. The others are ++ present for any misc. purposes. This is not set reliably, but if it is ++ not NULL, it is correct. */ ++ asymbol **symbols; ++ /* Number of symbols in array. */ ++ int num_symbols; ++ ++ /* For use by the disassembler. ++ The top 16 bits are reserved for public use (and are documented here). ++ The bottom 16 bits are for the internal use of the disassembler. */ ++ unsigned long flags; ++#define INSN_HAS_RELOC 0x80000000 ++ void *private_data; ++ ++ /* Function used to get bytes to disassemble. MEMADDR is the ++ address of the stuff to be disassembled, MYADDR is the address to ++ put the bytes in, and LENGTH is the number of bytes to read. ++ INFO is a pointer to this struct. ++ Returns an errno value or 0 for success. */ ++ int (*read_memory_func) ++ (bfd_vma memaddr, bfd_byte *myaddr, unsigned int length, ++ struct disassemble_info *info); ++ ++ /* Function which should be called if we get an error that we can't ++ recover from. STATUS is the errno value from read_memory_func and ++ MEMADDR is the address that we were trying to read. INFO is a ++ pointer to this struct. */ ++ void (*memory_error_func) ++ (int status, bfd_vma memaddr, struct disassemble_info *info); ++ ++ /* Function called to print ADDR. */ ++ void (*print_address_func) ++ (bfd_vma addr, struct disassemble_info *info); ++ ++ /* Function called to determine if there is a symbol at the given ADDR. ++ If there is, the function returns 1, otherwise it returns 0. ++ This is used by ports which support an overlay manager where ++ the overlay number is held in the top part of an address. In ++ some circumstances we want to include the overlay number in the ++ address, (normally because there is a symbol associated with ++ that address), but sometimes we want to mask out the overlay bits. */ ++ int (* symbol_at_address_func) ++ (bfd_vma addr, struct disassemble_info * info); ++ ++ /* Function called to check if a SYMBOL is can be displayed to the user. ++ This is used by some ports that want to hide special symbols when ++ displaying debugging outout. */ ++ bfd_boolean (* symbol_is_valid) ++ (asymbol *, struct disassemble_info * info); ++ ++ /* These are for buffer_read_memory. */ ++ bfd_byte *buffer; ++ bfd_vma buffer_vma; ++ unsigned int buffer_length; ++ ++ /* This variable may be set by the instruction decoder. It suggests ++ the number of bytes objdump should display on a single line. If ++ the instruction decoder sets this, it should always set it to ++ the same value in order to get reasonable looking output. */ ++ int bytes_per_line; ++ ++ /* The next two variables control the way objdump displays the raw data. */ ++ /* For example, if bytes_per_line is 8 and bytes_per_chunk is 4, the */ ++ /* output will look like this: ++ 00: 00000000 00000000 ++ with the chunks displayed according to "display_endian". */ ++ int bytes_per_chunk; ++ enum bfd_endian display_endian; ++ ++ /* Number of octets per incremented target address ++ Normally one, but some DSPs have byte sizes of 16 or 32 bits. */ ++ unsigned int octets_per_byte; ++ ++ /* The number of zeroes we want to see at the end of a section before we ++ start skipping them. */ ++ unsigned int skip_zeroes; ++ ++ /* The number of zeroes to skip at the end of a section. If the number ++ of zeroes at the end is between SKIP_ZEROES_AT_END and SKIP_ZEROES, ++ they will be disassembled. If there are fewer than ++ SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic ++ attempt to avoid disassembling zeroes inserted by section ++ alignment. */ ++ unsigned int skip_zeroes_at_end; ++ ++ /* Whether the disassembler always needs the relocations. */ ++ bfd_boolean disassembler_needs_relocs; ++ ++ /* Results from instruction decoders. Not all decoders yet support ++ this information. This info is set each time an instruction is ++ decoded, and is only valid for the last such instruction. ++ ++ To determine whether this decoder supports this information, set ++ insn_info_valid to 0, decode an instruction, then check it. */ ++ ++ char insn_info_valid; /* Branch info has been set. */ ++ char branch_delay_insns; /* How many sequential insn's will run before ++ a branch takes effect. (0 = normal) */ ++ char data_size; /* Size of data reference in insn, in bytes */ ++ enum dis_insn_type insn_type; /* Type of instruction */ ++ bfd_vma target; /* Target address of branch or dref, if known; ++ zero if unknown. */ ++ bfd_vma target2; /* Second target address for dref2 */ ++ ++ /* Command line options specific to the target disassembler. */ ++ char * disassembler_options; ++ ++} disassemble_info; ++ ++ ++/* Standard disassemblers. Disassemble one instruction at the given ++ target address. Return number of octets processed. */ ++typedef int (*disassembler_ftype) (bfd_vma, disassemble_info *); ++ ++extern int print_insn_big_mips (bfd_vma, disassemble_info *); ++extern int print_insn_little_mips (bfd_vma, disassemble_info *); ++extern int print_insn_i386 (bfd_vma, disassemble_info *); ++extern int print_insn_i386_att (bfd_vma, disassemble_info *); ++extern int print_insn_i386_intel (bfd_vma, disassemble_info *); ++extern int print_insn_ia64 (bfd_vma, disassemble_info *); ++extern int print_insn_i370 (bfd_vma, disassemble_info *); ++extern int print_insn_m68hc11 (bfd_vma, disassemble_info *); ++extern int print_insn_m68hc12 (bfd_vma, disassemble_info *); ++extern int print_insn_m68k (bfd_vma, disassemble_info *); ++extern int print_insn_z80 (bfd_vma, disassemble_info *); ++extern int print_insn_z8001 (bfd_vma, disassemble_info *); ++extern int print_insn_z8002 (bfd_vma, disassemble_info *); ++extern int print_insn_h8300 (bfd_vma, disassemble_info *); ++extern int print_insn_h8300h (bfd_vma, disassemble_info *); ++extern int print_insn_h8300s (bfd_vma, disassemble_info *); ++extern int print_insn_h8500 (bfd_vma, disassemble_info *); ++extern int print_insn_alpha (bfd_vma, disassemble_info *); ++extern int print_insn_big_arm (bfd_vma, disassemble_info *); ++extern int print_insn_little_arm (bfd_vma, disassemble_info *); ++extern int print_insn_sparc (bfd_vma, disassemble_info *); ++extern int print_insn_avr (bfd_vma, disassemble_info *); ++extern int print_insn_bfin (bfd_vma, disassemble_info *); ++extern int print_insn_d10v (bfd_vma, disassemble_info *); ++extern int print_insn_d30v (bfd_vma, disassemble_info *); ++extern int print_insn_dlx (bfd_vma, disassemble_info *); ++extern int print_insn_fr30 (bfd_vma, disassemble_info *); ++extern int print_insn_hppa (bfd_vma, disassemble_info *); ++extern int print_insn_i860 (bfd_vma, disassemble_info *); ++extern int print_insn_i960 (bfd_vma, disassemble_info *); ++extern int print_insn_m32r (bfd_vma, disassemble_info *); ++extern int print_insn_m88k (bfd_vma, disassemble_info *); ++extern int print_insn_maxq_little (bfd_vma, disassemble_info *); ++extern int print_insn_maxq_big (bfd_vma, disassemble_info *); ++extern int print_insn_mcore (bfd_vma, disassemble_info *); ++extern int print_insn_mmix (bfd_vma, disassemble_info *); ++extern int print_insn_mn10200 (bfd_vma, disassemble_info *); ++extern int print_insn_mn10300 (bfd_vma, disassemble_info *); ++extern int print_insn_mt (bfd_vma, disassemble_info *); ++extern int print_insn_msp430 (bfd_vma, disassemble_info *); ++extern int print_insn_ns32k (bfd_vma, disassemble_info *); ++extern int print_insn_crx (bfd_vma, disassemble_info *); ++extern int print_insn_openrisc (bfd_vma, disassemble_info *); ++extern int print_insn_big_or32 (bfd_vma, disassemble_info *); ++extern int print_insn_little_or32 (bfd_vma, disassemble_info *); ++extern int print_insn_pdp11 (bfd_vma, disassemble_info *); ++extern int print_insn_pj (bfd_vma, disassemble_info *); ++extern int print_insn_big_powerpc (bfd_vma, disassemble_info *); ++extern int print_insn_little_powerpc (bfd_vma, disassemble_info *); ++extern int print_insn_rs6000 (bfd_vma, disassemble_info *); ++extern int print_insn_s390 (bfd_vma, disassemble_info *); ++extern int print_insn_sh (bfd_vma, disassemble_info *); ++extern int print_insn_tic30 (bfd_vma, disassemble_info *); ++extern int print_insn_tic4x (bfd_vma, disassemble_info *); ++extern int print_insn_tic54x (bfd_vma, disassemble_info *); ++extern int print_insn_tic80 (bfd_vma, disassemble_info *); ++extern int print_insn_ubicom32 (bfd_vma, disassemble_info *); ++extern int print_insn_v850 (bfd_vma, disassemble_info *); ++extern int print_insn_vax (bfd_vma, disassemble_info *); ++extern int print_insn_w65 (bfd_vma, disassemble_info *); ++extern int print_insn_xstormy16 (bfd_vma, disassemble_info *); ++extern int print_insn_xtensa (bfd_vma, disassemble_info *); ++extern int print_insn_sh64 (bfd_vma, disassemble_info *); ++extern int print_insn_sh64x_media (bfd_vma, disassemble_info *); ++extern int print_insn_frv (bfd_vma, disassemble_info *); ++extern int print_insn_iq2000 (bfd_vma, disassemble_info *); ++extern int print_insn_xc16x (bfd_vma, disassemble_info *); ++extern int print_insn_m32c (bfd_vma, disassemble_info *); ++ ++extern disassembler_ftype arc_get_disassembler (void *); ++extern disassembler_ftype cris_get_disassembler (bfd *); ++ ++extern void print_mips_disassembler_options (FILE *); ++extern void print_ppc_disassembler_options (FILE *); ++extern void print_arm_disassembler_options (FILE *); ++extern void parse_arm_disassembler_option (char *); ++extern int get_arm_regname_num_options (void); ++extern int set_arm_regname_option (int); ++extern int get_arm_regnames (int, const char **, const char **, const char *const **); ++extern bfd_boolean arm_symbol_is_valid (asymbol *, struct disassemble_info *); ++ ++/* Fetch the disassembler for a given BFD, if that support is available. */ ++extern disassembler_ftype disassembler (bfd *); ++ ++/* Amend the disassemble_info structure as necessary for the target architecture. ++ Should only be called after initialising the info->arch field. */ ++extern void disassemble_init_for_target (struct disassemble_info * info); ++ ++/* Document any target specific options available from the disassembler. */ ++extern void disassembler_usage (FILE *); ++ ++ ++/* This block of definitions is for particular callers who read instructions ++ into a buffer before calling the instruction decoder. */ ++ ++/* Here is a function which callers may wish to use for read_memory_func. ++ It gets bytes from a buffer. */ ++extern int buffer_read_memory ++ (bfd_vma, bfd_byte *, unsigned int, struct disassemble_info *); ++ ++/* This function goes with buffer_read_memory. ++ It prints a message using info->fprintf_func and info->stream. */ ++extern void perror_memory (int, bfd_vma, struct disassemble_info *); ++ ++ ++/* Just print the address in hex. This is included for completeness even ++ though both GDB and objdump provide their own (to print symbolic ++ addresses). */ ++extern void generic_print_address ++ (bfd_vma, struct disassemble_info *); ++ ++/* Always true. */ ++extern int generic_symbol_at_address ++ (bfd_vma, struct disassemble_info *); ++ ++/* Also always true. */ ++extern bfd_boolean generic_symbol_is_valid ++ (asymbol *, struct disassemble_info *); ++ ++/* Method to initialize a disassemble_info struct. This should be ++ called by all applications creating such a struct. */ ++extern void init_disassemble_info (struct disassemble_info *info, void *stream, ++ fprintf_ftype fprintf_func); ++ ++/* For compatibility with existing code. */ ++#define INIT_DISASSEMBLE_INFO(INFO, STREAM, FPRINTF_FUNC) \ ++ init_disassemble_info (&(INFO), (STREAM), (fprintf_ftype) (FPRINTF_FUNC)) ++#define INIT_DISASSEMBLE_INFO_NO_ARCH(INFO, STREAM, FPRINTF_FUNC) \ ++ init_disassemble_info (&(INFO), (STREAM), (fprintf_ftype) (FPRINTF_FUNC)) ++ ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* ! defined (DIS_ASM_H) */ +--- a/include/elf/common.h ++++ b/include/elf/common.h +@@ -318,6 +318,9 @@ + + #define EM_XSTORMY16 0xad45 + ++#define EM_UBICOM32 0xde3d /* Ubicom32; no ABI */ ++#define EM_UBICOM32MATH 0xde3e /* Ubicom32 co-processor; no ABI */ ++ + /* mn10200 and mn10300 backend magic numbers. + Written in the absense of an ABI. */ + #define EM_CYGNUS_MN10300 0xbeef +--- /dev/null ++++ b/include/elf/ubicom32.h +@@ -0,0 +1,79 @@ ++/* ubicom32 ELF support for BFD. ++ Copyright (C) 2000 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_UBICOM32_H ++#define _ELF_UBICOM32_H ++ ++#include "elf/reloc-macros.h" ++ ++/* Relocations. */ ++START_RELOC_NUMBERS (elf_ubicom32_reloc_type) ++ RELOC_NUMBER (R_UBICOM32_NONE, 0) ++ RELOC_NUMBER (R_UBICOM32_16, 1) ++ RELOC_NUMBER (R_UBICOM32_32, 2) ++ RELOC_NUMBER (R_UBICOM32_LO16, 3) ++ RELOC_NUMBER (R_UBICOM32_HI16, 4) ++ RELOC_NUMBER (R_UBICOM32_21_PCREL, 5) ++ RELOC_NUMBER (R_UBICOM32_24_PCREL, 6) ++ RELOC_NUMBER (R_UBICOM32_HI24, 7) ++ RELOC_NUMBER (R_UBICOM32_LO7_S, 8) ++ RELOC_NUMBER (R_UBICOM32_LO7_2_S, 9) ++ RELOC_NUMBER (R_UBICOM32_LO7_4_S, 10) ++ RELOC_NUMBER (R_UBICOM32_LO7_D, 11) ++ RELOC_NUMBER (R_UBICOM32_LO7_2_D, 12) ++ RELOC_NUMBER (R_UBICOM32_LO7_4_D, 13) ++ RELOC_NUMBER (R_UBICOM32_32_HARVARD, 14) ++ RELOC_NUMBER (R_UBICOM32_LO7_CALLI, 15) ++ RELOC_NUMBER (R_UBICOM32_LO16_CALLI, 16) ++ RELOC_NUMBER (R_UBICOM32_GOT_HI24, 17) ++ RELOC_NUMBER (R_UBICOM32_GOT_LO7_S, 18) ++ RELOC_NUMBER (R_UBICOM32_GOT_LO7_2_S, 19) ++ RELOC_NUMBER (R_UBICOM32_GOT_LO7_4_S, 20) ++ RELOC_NUMBER (R_UBICOM32_GOT_LO7_D, 21) ++ RELOC_NUMBER (R_UBICOM32_GOT_LO7_2_D, 22) ++ RELOC_NUMBER (R_UBICOM32_GOT_LO7_4_D, 23) ++ RELOC_NUMBER (R_UBICOM32_FUNCDESC_GOT_HI24, 24) ++ RELOC_NUMBER (R_UBICOM32_FUNCDESC_GOT_LO7_S, 25) ++ RELOC_NUMBER (R_UBICOM32_FUNCDESC_GOT_LO7_2_S, 26) ++ RELOC_NUMBER (R_UBICOM32_FUNCDESC_GOT_LO7_4_S, 27) ++ RELOC_NUMBER (R_UBICOM32_FUNCDESC_GOT_LO7_D, 28) ++ RELOC_NUMBER (R_UBICOM32_FUNCDESC_GOT_LO7_2_D, 29) ++ RELOC_NUMBER (R_UBICOM32_FUNCDESC_GOT_LO7_4_D, 30) ++ RELOC_NUMBER (R_UBICOM32_GOT_LO7_CALLI, 31) ++ RELOC_NUMBER (R_UBICOM32_FUNCDESC_GOT_LO7_CALLI, 32) ++ RELOC_NUMBER (R_UBICOM32_FUNCDESC_VALUE, 33) ++ RELOC_NUMBER (R_UBICOM32_FUNCDESC, 34) ++ RELOC_NUMBER (R_UBICOM32_GOTOFFSET_LO, 35) ++ RELOC_NUMBER (R_UBICOM32_GOTOFFSET_HI, 36) ++ RELOC_NUMBER (R_UBICOM32_FUNCDESC_GOTOFFSET_LO, 37) ++ RELOC_NUMBER (R_UBICOM32_FUNCDESC_GOTOFFSET_HI, 38) ++ RELOC_NUMBER (R_UBICOM32_GNU_VTINHERIT, 200) ++ RELOC_NUMBER (R_UBICOM32_GNU_VTENTRY, 201) ++END_RELOC_NUMBERS(R_UBICOM32_max) ++ ++ ++/* ++ * Processor specific flags for the ELF header e_flags field. ++ */ ++#define EF_UBICOM32_PIC 0x80000000 /* -fpic */ ++#define EF_UBICOM32_FDPIC 0x40000000 /* -mfdpic */ ++ ++#define EF_UBICOM32_PIC_FLAGS (EF_UBICOM32_PIC | EF_UBICOM32_FDPIC) ++ ++#endif /* _ELF_IP_H */ +--- a/ld/configure.tgt ++++ b/ld/configure.tgt +@@ -607,6 +607,15 @@ tic4x-*-* | c4x-*-*) targ_emul=tic4xc + tic54x-*-* | c54x*-*-*) targ_emul=tic54xcoff ;; + tic80-*-*) targ_emul=tic80coff + ;; ++ubicom32-*-linux-*) targ_emul=elf32ubicom32 ++ targ_extra_emuls=elf32ubicom32fdpic ++ targ_extra_libpath=$targ_extra_emuls ++ ;; ++ubicom32-*-*) targ_emul=elf32ubicom32 ++ targ_extra_emuls=elf32ubicom32fdpic ++ targ_extra_libpath=$targ_extra_emuls ++ ;; ++ + v850-*-*) targ_emul=v850 ;; + v850e-*-*) targ_emul=v850 ;; + v850ea-*-*) targ_emul=v850 +--- /dev/null ++++ b/ld/emulparams/elf32ubicom32fdpic.sh +@@ -0,0 +1,28 @@ ++MACHINE= ++SCRIPT_NAME=elf ++OUTPUT_FORMAT="elf32-ubicom32fdpic" ++TEXT_START_ADDR=0x000000 ++MAXPAGESIZE=0x1000 ++TARGET_PAGE_SIZE=0x1000 ++NONPAGED_TEXT_START_ADDR=${TEXT_START_ADDR} ++ARCH=ubicom32 ++TEMPLATE_NAME=elf32 ++ENTRY=_start ++EMBEDDED=yes ++GENERATE_SHLIB_SCRIPT=yes ++EMBEDDED= # This gets us program headers mapped as part of the text segment. ++OTHER_GOT_SYMBOLS= ++OTHER_READONLY_SECTIONS=" ++ .rofixup : { ++ ${RELOCATING+__ROFIXUP_LIST__ = .;} ++ *(.rofixup) ++ ${RELOCATING+__ROFIXUP_END__ = .;} ++ } ++" ++ELFSIZE=32 ++WRITABLE_RODATA="" ++DATA_START_SYMBOLS= ++CTOR_START='___ctors = .;' ++CTOR_END='___ctors_end = .;' ++DTOR_START='___dtors = .;' ++DTOR_END='___dtors_end = .;' +--- /dev/null ++++ b/ld/emulparams/elf32ubicom32.sh +@@ -0,0 +1,23 @@ ++MACHINE= ++SCRIPT_NAME=elf ++OUTPUT_FORMAT="elf32-ubicom32" ++DATA_ADDR=0x100000 ++EXT_DATA_START_ADDR=0x100000 ++EXT_DATA_SIZE=0x10000 ++TEXT_START_ADDR=0x40000000 ++EXT_PROGRAM_START_ADDR=0x40000000 ++EXT_PROGRAM_SIZE=0x80000 ++FLASHRAM_START_ADDR=0x20000000 ++COPROCESSOR_MEMORY=0x400000 ++COPROCESSOR_MEM_SIZE=0x100000 ++ARCH=ubicom32 ++TEMPLATE_NAME=elf32 ++ENTRY=_start ++EMBEDDED=yes ++ELFSIZE=32 ++MAXPAGESIZE=256 ++DATA_START_SYMBOLS= ++CTOR_START='___ctors = .;' ++CTOR_END='___ctors_end = .;' ++DTOR_START='___dtors = .;' ++DTOR_END='___dtors_end = .;' +--- a/ld/Makefile.am ++++ b/ld/Makefile.am +@@ -198,6 +198,8 @@ ALL_EMULATIONS = \ + eelf32ppcsim.o \ + eelf32ppcwindiss.o \ + eelf32ppcvxworks.o \ ++ eelf32ubicom32.o \ ++ eelf32ubicom32fdpic.o \ + eelf32vax.o \ + eelf32xc16x.o \ + eelf32xc16xl.o \ +@@ -927,6 +929,14 @@ eelf64lppc.c: $(srcdir)/emulparams/elf64 + eelf32i370.c: $(srcdir)/emulparams/elf32i370.sh \ + $(ELF_DEPS) $(srcdir)/scripttempl/elfi370.sc ${GEN_DEPENDS} + ${GENSCRIPTS} elf32i370 "$(tdir_elf32i370)" ++eelf32ubicom32.c: $(srcdir)/emulparams/elf32ubicom32.sh \ ++ $(ELF_DEPS) \ ++ $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS} ++ ${GENSCRIPTS} elf32ubicom32 "$(tdir_ubicom32)" ++eelf32ubicom32fdpic.c: $(srcdir)/emulparams/elf32ubicom32fdpic.sh \ ++ $(ELF_DEPS) \ ++ $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS} ++ ${GENSCRIPTS} elf32ubicom32fdpic "$(tdir_ubicom32fdpic)" + eelf32ip2k.c: $(srcdir)/emulparams/elf32ip2k.sh \ + $(ELF_DEPS) $(srcdir)/scripttempl/ip2k.sc ${GEN_DEPENDS} + ${GENSCRIPTS} elf32ip2k "$(tdir_ip2k)" +--- a/ld/Makefile.in ++++ b/ld/Makefile.in +@@ -449,6 +449,8 @@ ALL_EMULATIONS = \ + eelf32ppcsim.o \ + eelf32ppcwindiss.o \ + eelf32ppcvxworks.o \ ++ eelf32ubicom32.o \ ++ eelf32ubicom32fdpic.o \ + eelf32vax.o \ + eelf32xc16x.o \ + eelf32xc16xl.o \ +@@ -1759,6 +1761,14 @@ eelf64lppc.c: $(srcdir)/emulparams/elf64 + eelf32i370.c: $(srcdir)/emulparams/elf32i370.sh \ + $(ELF_DEPS) $(srcdir)/scripttempl/elfi370.sc ${GEN_DEPENDS} + ${GENSCRIPTS} elf32i370 "$(tdir_elf32i370)" ++eelf32ubicom32.c: $(srcdir)/emulparams/elf32ubicom32.sh \ ++ $(ELF_DEPS) \ ++ $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS} ++ ${GENSCRIPTS} elf32ubicom32 "$(tdir_ubicom32)" ++eelf32ubicom32fdpic.c: $(srcdir)/emulparams/elf32ubicom32fdpic.sh \ ++ $(ELF_DEPS) \ ++ $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS} ++ ${GENSCRIPTS} elf32ubicom32fdpic "$(tdir_ubicom32fdpic)" + eelf32ip2k.c: $(srcdir)/emulparams/elf32ip2k.sh \ + $(ELF_DEPS) $(srcdir)/scripttempl/ip2k.sc ${GEN_DEPENDS} + ${GENSCRIPTS} elf32ip2k "$(tdir_ip2k)" +--- /dev/null ++++ b/ld/scripttempl/ubicom32.sc +@@ -0,0 +1,395 @@ ++# ++# Unusual variables checked by this code: ++# EXT_DATA_START_ADDR - virtual address start of extended data storage ++# EXT_DATA_SIZE - size of extended data storage ++# EXT_PROGRAM_START_ADDR - virtual address start of extended prog storage ++# EXT_PROGRAM_SIZE - size of extended program storage ++# FLASHRAM1_START_ADDR - virtual address start of flash ram 1 storage ++# FLASHRAM2_START_ADDR - virtual address start of flash ram 2 storage ++# FLASHRAM3_START_ADDR - virtual address start of flash ram 3 storage ++# FLASHRAM4_START_ADDR - virtual address start of flash ram 4 storage ++# FLASHRAM5_START_ADDR - virtual address start of flash ram 5 storage ++# FLASHRAM6_START_ADDR - virtual address start of flash ram 6 storage ++# FLASHRAM7_START_ADDR - virtual address start of flash ram 7 storage ++# FLASHRAM8_START_ADDR - virtual address start of flash ram 8 storage ++# PROGRAM_SRAM_START_ADDR - virtual address start of program sram storage ++# NOP - two byte opcode for no-op (defaults to 0) ++# DATA_ADDR - if end-of-text-plus-one-page isn't right for data start ++# INITIAL_READONLY_SECTIONS - at start of text segment ++# OTHER_READONLY_SECTIONS - other than .text .init .rodata ... ++# (e.g., .PARISC.milli) ++# OTHER_TEXT_SECTIONS - these get put in .text when relocating ++# OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ... ++# (e.g., .PARISC.global) ++# OTHER_BSS_SECTIONS - other than .bss .sbss ... ++# OTHER_SECTIONS - at the end ++# EXECUTABLE_SYMBOLS - symbols that must be defined for an ++# executable (e.g., _DYNAMIC_LINK) ++# TEXT_START_SYMBOLS - symbols that appear at the start of the ++# .text section. ++# DATA_START_SYMBOLS - symbols that appear at the start of the ++# .data section. ++# OTHER_GOT_SYMBOLS - symbols defined just before .got. ++# OTHER_GOT_SECTIONS - sections just after .got and .sdata. ++# OTHER_BSS_SYMBOLS - symbols that appear at the start of the ++# .bss section besides __bss_start. ++# DATA_PLT - .plt should be in data segment, not text segment. ++# BSS_PLT - .plt should be in bss segment ++# TEXT_DYNAMIC - .dynamic in text segment, not data segment. ++# EMBEDDED - whether this is for an embedded system. ++# SHLIB_TEXT_START_ADDR - if set, add to SIZEOF_HEADERS to set ++# start address of shared library. ++# INPUT_FILES - INPUT command of files to always include ++# WRITABLE_RODATA - if set, the .rodata section should be writable ++# INIT_START, INIT_END - statements just before and just after ++# combination of .init sections. ++# FINI_START, FINI_END - statements just before and just after ++# combination of .fini sections. ++# ++# When adding sections, do note that the names of some sections are used ++# when specifying the start address of the next. ++# ++ ++test -z "$ENTRY" && ENTRY=_start ++test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT} ++test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT} ++if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi ++test -z "${ELFSIZE}" && ELFSIZE=32 ++test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8" ++test "$LD_FLAG" = "N" && DATA_ADDR=. ++INTERP=".interp ${RELOCATING-0} : { *(.interp) } ${RELOCATING+ > datamem}" ++PLT=".plt ${RELOCATING-0} : { *(.plt) } ${RELOCATING+ > datamem}" ++DYNAMIC=".dynamic ${RELOCATING-0} : { *(.dynamic) } ${RELOCATING+ > datamem}" ++RODATA=".rodata ${RELOCATING-0} : { *(.rodata) ${RELOCATING+*(.rodata.*)} ${RELOCATING+*(.gnu.linkonce.r*)} } ${RELOCATING+ > datamem}" ++SBSS2=".sbss2 ${RELOCATING-0} : { *(.sbss2) } ${RELOCATING+ > datamem}" ++SDATA2=".sdata2 ${RELOCATING-0} : { *(.sdata2) } ${RELOCATING+ >datamem}" ++CTOR=".ctors ${CONSTRUCTING-0} : ++ { ++ ${RELOCATING+. = ALIGN(${ALIGNMENT});} ++ ${CONSTRUCTING+${CTOR_START}} ++ LONG (-1) ++ /* gcc uses crtbegin.o to find the start of ++ the constructors, so we make sure it is ++ first. Because this is a wildcard, it ++ doesn't matter if the user does not ++ actually link against crtbegin.o; the ++ linker won't look for a file to match a ++ wildcard. The wildcard also means that it ++ doesn't matter which directory crtbegin.o ++ is in. */ ++ ++ KEEP (*crtbegin.o(.ctors)) ++ ++ /* We don't want to include the .ctor section from ++ from the crtend.o file until after the sorted ctors. ++ The .ctor section from the crtend file contains the ++ end of ctors marker and it must be last */ ++ ++ KEEP (*(EXCLUDE_FILE (*crtend.o $OTHER_EXCLUDE_FILES) .ctors)) ++ KEEP (*(SORT(.ctors.*))) ++ KEEP (*(.ctors)) ++ LONG (0) ++ ${CONSTRUCTING+${CTOR_END}} ++ } ${RELOCATING+ > datamem}" ++ ++DTOR=" .dtors ${CONSTRUCTING-0} : ++ { ++ ${RELOCATING+. = ALIGN(${ALIGNMENT});} ++ ${CONSTRUCTING+${DTOR_START}} ++ LONG (-1) ++ KEEP (*crtbegin.o(.dtors)) ++ KEEP (*(EXCLUDE_FILE (*crtend.o $OTHER_EXCLUDE_FILES) .dtors)) ++ KEEP (*(SORT(.dtors.*))) ++ KEEP (*(.dtors)) ++ LONG (0) ++ ${CONSTRUCTING+${DTOR_END}} ++ } ${RELOCATING+ > datamem}" ++ ++# if this is for an embedded system, don't add SIZEOF_HEADERS. ++if [ -z "$EMBEDDED" ]; then ++ test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS" ++else ++ test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}" ++fi ++ ++cat < flashram} ++ .copro ${RELOCATING-0} : {*(.copro) } ${RELOCATING+ > copromem} ++ ++ ${CREATE_SHLIB-${RELOCATING+. = ${TEXT_BASE_ADDRESS};}} ++ ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}} ++ .text ${RELOCATING-0} : ++ { ++ ${RELOCATING+${TEXT_START_SYMBOLS}} ++ *(.text) ++ ${RELOCATING+*(.text.*)} ++ *(.stub) ++ /* .gnu.warning sections are handled specially by elf32.em. */ ++ *(.gnu.warning) ++ ${RELOCATING+*(.gnu.linkonce.t*)} ++ ${RELOCATING+${OTHER_TEXT_SECTIONS}} ++ } ${RELOCATING+ > progmem} =${NOP-0} ++ ++ .rel.text ${RELOCATING-0} : ++ { ++ *(.rel.text) ++ ${RELOCATING+*(.rel.text.*)} ++ ${RELOCATING+*(.rel.gnu.linkonce.t*)} ++ } ${RELOCATING+ > progmem} ++ ++ .rela.text ${RELOCATING-0} : ++ { ++ *(.rela.text) ++ ${RELOCATING+*(.rela.text.*)} ++ ${RELOCATING+*(.rela.gnu.linkonce.t*)} ++ } ${RELOCATING+ > progmem} ++ ++ ${RELOCATING+PROVIDE (__etext = .);} ++ ${RELOCATING+PROVIDE (_etext = .);} ++ ${RELOCATING+PROVIDE (etext = .);} ++ ++ /* Adjust the address for the data segment. We want to adjust up to ++ the same address within the page on the next page up. */ ++ ${CREATE_SHLIB-${RELOCATING+. = ${DATA_ADDR-ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))};}} ++ ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))};}} ++ ++ /* Skip first word to ensure first data element can't end up having address ++ 0 in code (NULL pointer) */ ++ . = . + 4; ++ .data ${RELOCATING-0} : ++ { ++ ${RELOCATING+${DATA_START_SYMBOLS}} ++ *(.data) ++ ${RELOCATING+*(.data.*)} ++ ${RELOCATING+*(.gnu.linkonce.d*)} ++ ${CONSTRUCTING+SORT(CONSTRUCTORS)} ++ } ${RELOCATING+ > datamem} ++ .data1 ${RELOCATING-0} : { *(.data1) } ${RELOCATING+ > datamem} ++ .eh_frame ${RELOCATING-0} : ++ { ++ ${RELOCATING+PROVIDE (___eh_frame_begin = .);} ++ *(.eh_frame) ++ LONG (0); ++ ${RELOCATING+PROVIDE (___eh_frame_end = .);} ++ } ${RELOCATING+ > datamem} ++ .gcc_except_table : { *(.gcc_except_table) } ${RELOCATING+ > datamem} ++ ++ /* Read-only sections, placed in data space: */ ++ ${CREATE_SHLIB-${INTERP}} ++ ${INITIAL_READONLY_SECTIONS} ++ ${TEXT_DYNAMIC+${DYNAMIC}} ++ .hash ${RELOCATING-0} : { *(.hash) } ${RELOCATING+ > datamem} ++ .dynsym ${RELOCATING-0} : { *(.dynsym) } ${RELOCATING+ > datamem} ++ .dynstr ${RELOCATING-0} : { *(.dynstr) } ${RELOCATING+ > datamem} ++ .gnu.version ${RELOCATING-0} : { *(.gnu.version) } ${RELOCATING+ > datamem} ++ .gnu.version_d ${RELOCATING-0} : { *(.gnu.version_d) } ${RELOCATING+ > datamem} ++ .gnu.version_r ${RELOCATING-0} : { *(.gnu.version_r) } ${RELOCATING+ > datamem} ++ ++ .rel.init ${RELOCATING-0} : { *(.rel.init) } ${RELOCATING+ > datamem} ++ .rela.init ${RELOCATING-0} : { *(.rela.init) } ${RELOCATING+ > datamem} ++ .rel.fini ${RELOCATING-0} : { *(.rel.fini) } ${RELOCATING+ > datamem} ++ .rela.fini ${RELOCATING-0} : { *(.rela.fini) } ${RELOCATING+ > datamem} ++ .rel.rodata ${RELOCATING-0} : ++ { ++ *(.rel.rodata) ++ ${RELOCATING+*(.rel.rodata.*)} ++ ${RELOCATING+*(.rel.gnu.linkonce.r*)} ++ } ${RELOCATING+ > datamem} ++ .rela.rodata ${RELOCATING-0} : ++ { ++ *(.rela.rodata) ++ ${RELOCATING+*(.rela.rodata.*)} ++ ${RELOCATING+*(.rela.gnu.linkonce.r*)} ++ } ${RELOCATING+ > datamem} ++ ${OTHER_READONLY_RELOC_SECTIONS} ++ .rel.data ${RELOCATING-0} : ++ { ++ *(.rel.data) ++ ${RELOCATING+*(.rel.data.*)} ++ ${RELOCATING+*(.rel.gnu.linkonce.d*)} ++ } ${RELOCATING+ > datamem} ++ .rela.data ${RELOCATING-0} : ++ { ++ *(.rela.data) ++ ${RELOCATING+*(.rela.data.*)} ++ ${RELOCATING+*(.rela.gnu.linkonce.d*)} ++ } ${RELOCATING+ > datamem} ++ .rel.ctors ${RELOCATING-0} : { *(.rel.ctors) } ${RELOCATING+ > datamem} ++ .rela.ctors ${RELOCATING-0} : { *(.rela.ctors) } ${RELOCATING+ > datamem} ++ .rel.dtors ${RELOCATING-0} : { *(.rel.dtors) } ${RELOCATING+ > datamem} ++ .rela.dtors ${RELOCATING-0} : { *(.rela.dtors) } ${RELOCATING+ > datamem} ++ .rel.got ${RELOCATING-0} : { *(.rel.got) } ${RELOCATING+ > datamem} ++ .rela.got ${RELOCATING-0} : { *(.rela.got) } ${RELOCATING+ > datamem} ++ ${OTHER_GOT_RELOC_SECTIONS} ++ .rel.sdata ${RELOCATING-0} : ++ { ++ *(.rel.sdata) ++ ${RELOCATING+*(.rel.sdata.*)} ++ ${RELOCATING+*(.rel.gnu.linkonce.s*)} ++ } ${RELOCATING+ > datamem} ++ .rela.sdata ${RELOCATING-0} : ++ { ++ *(.rela.sdata) ++ ${RELOCATING+*(.rela.sdata.*)} ++ ${RELOCATING+*(.rela.gnu.linkonce.s*)} ++ } ${RELOCATING+ > datamem} ++ .rel.sbss ${RELOCATING-0} : { *(.rel.sbss) } ${RELOCATING+ > datamem} ++ .rela.sbss ${RELOCATING-0} : { *(.rela.sbss) } ${RELOCATING+ > datamem} ++ .rel.sdata2 ${RELOCATING-0} : { *(.rel.sdata2) } ${RELOCATING+ > datamem} ++ .rela.sdata2 ${RELOCATING-0} : { *(.rela.sdata2) } ${RELOCATING+ > datamem} ++ .rel.sbss2 ${RELOCATING-0} : { *(.rel.sbss2) } ${RELOCATING+ > datamem} ++ .rela.sbss2 ${RELOCATING-0} : { *(.rela.sbss2) } ${RELOCATING+ > datamem} ++ .rel.bss ${RELOCATING-0} : { *(.rel.bss) } ${RELOCATING+ > datamem} ++ .rela.bss ${RELOCATING-0} : { *(.rela.bss) } ${RELOCATING+ > datamem} ++ .rel.plt ${RELOCATING-0} : { *(.rel.plt) } ${RELOCATING+ > datamem} ++ .rela.plt ${RELOCATING-0} : { *(.rela.plt) } ${RELOCATING+ > datamem} ++ ${OTHER_PLT_RELOC_SECTIONS} ++ ++ .init ${RELOCATING-0} : ++ { ++ ${RELOCATING+${INIT_START}} ++ KEEP (*(.init)) ++ ${RELOCATING+${INIT_END}} ++ } ${RELOCATING+ > datamem} =${NOP-0} ++ ++ ${DATA_PLT-${BSS_PLT-${PLT}}} ++ ++ .fini ${RELOCATING-0} : ++ { ++ ${RELOCATING+${FINI_START}} ++ KEEP (*(.fini)) ++ ${RELOCATING+${FINI_END}} ++ } ${RELOCATING+ > datamem} =${NOP-0} ++ ++ ${WRITABLE_RODATA-${RODATA}} ++ .rodata1 ${RELOCATING-0} : { *(.rodata1) } ${RELOCATING+ > datamem} ++ ${CREATE_SHLIB-${SDATA2}} ++ ${CREATE_SHLIB-${SBSS2}} ++ ${RELOCATING+${OTHER_READONLY_SECTIONS}} ++ ${WRITABLE_RODATA+${RODATA}} ++ ${RELOCATING+${OTHER_READWRITE_SECTIONS}} ++ ${RELOCATING+. = ALIGN(${ALIGNMENT});} ++ ${RELOCATING+${CTOR}} ++ ${RELOCATING+${DTOR}} ++ ${DATA_PLT+${PLT}} ++ ${RELOCATING+${OTHER_GOT_SYMBOLS}} ++ .got ${RELOCATING-0} : { *(.got.plt) *(.got) } ${RELOCATING+ > datamem} ++ ${CREATE_SHLIB+${SDATA2}} ++ ${CREATE_SHLIB+${SBSS2}} ++ ${TEXT_DYNAMIC-${DYNAMIC}} ++ /* We want the small data sections together, so single-instruction offsets ++ can access them all, and initialized data all before uninitialized, so ++ we can shorten the on-disk segment size. */ ++ .sdata ${RELOCATING-0} : ++ { ++ ${RELOCATING+${SDATA_START_SYMBOLS}} ++ *(.sdata) ++ ${RELOCATING+*(.sdata.*)} ++ ${RELOCATING+*(.gnu.linkonce.s.*)} ++ } ${RELOCATING+ > datamem} ++ ${RELOCATING+${OTHER_GOT_SECTIONS}} ++ ${RELOCATING+_edata = .;} ++ ${RELOCATING+PROVIDE (edata = .);} ++ ${RELOCATING+__bss_start = .;} ++ ${RELOCATING+${OTHER_BSS_SYMBOLS}} ++ .sbss ${RELOCATING-0} : ++ { ++ ${RELOCATING+PROVIDE (__sbss_start = .);} ++ ${RELOCATING+PROVIDE (___sbss_start = .);} ++ *(.dynsbss) ++ *(.sbss) ++ ${RELOCATING+*(.sbss.*)} ++ *(.scommon) ++ ${RELOCATING+PROVIDE (__sbss_end = .);} ++ ${RELOCATING+PROVIDE (___sbss_end = .);} ++ } ${RELOCATING+ > datamem} ++ ${BSS_PLT+${PLT}} ++ .bss ${RELOCATING-0} : ++ { ++ *(.dynbss) ++ *(.bss) ++ ${RELOCATING+*(.bss.*)} ++ *(COMMON) ++ /* Align here to ensure that the .bss section occupies space up to ++ _end. Align after .bss to ensure correct alignment even if the ++ .bss section disappears because there are no input sections. */ ++ ${RELOCATING+. = ALIGN(${ALIGNMENT});} ++ } ${RELOCATING+ > datamem} ++ ${RELOCATING+${OTHER_BSS_SECTIONS}} ++ ${RELOCATING+. = ALIGN(${ALIGNMENT});} ++ ${RELOCATING+_end = .;} ++ ${RELOCATING+${OTHER_BSS_END_SYMBOLS}} ++ ${RELOCATING+PROVIDE (end = .);} ++ ++ /* Stabs debugging sections. */ ++ .stab 0 : { *(.stab) } ++ .stabstr 0 : { *(.stabstr) } ++ .stab.excl 0 : { *(.stab.excl) } ++ .stab.exclstr 0 : { *(.stab.exclstr) } ++ .stab.index 0 : { *(.stab.index) } ++ .stab.indexstr 0 : { *(.stab.indexstr) } ++ ++ .comment 0 : { *(.comment) } ++ ++ /* DWARF debug sections. ++ Symbols in the DWARF debugging sections are relative to the beginning ++ of the section so we begin them at 0. */ ++ ++ /* DWARF 1 */ ++ .debug 0 : { *(.debug) } ++ .line 0 : { *(.line) } ++ ++ /* GNU DWARF 1 extensions */ ++ .debug_srcinfo 0 : { *(.debug_srcinfo) } ++ .debug_sfnames 0 : { *(.debug_sfnames) } ++ ++ /* DWARF 1.1 and DWARF 2 */ ++ .debug_aranges 0 : { *(.debug_aranges) } ++ .debug_pubnames 0 : { *(.debug_pubnames) } ++ ++ /* DWARF 2 */ ++ .debug_info 0 : { *(.debug_info) } ++ .debug_abbrev 0 : { *(.debug_abbrev) } ++ .debug_line 0 : { *(.debug_line) } ++ .debug_frame 0 : { *(.debug_frame) } ++ .debug_str 0 : { *(.debug_str) } ++ .debug_loc 0 : { *(.debug_loc) } ++ .debug_macinfo 0 : { *(.debug_macinfo) } ++ ++ /* SGI/MIPS DWARF 2 extensions */ ++ .debug_weaknames 0 : { *(.debug_weaknames) } ++ .debug_funcnames 0 : { *(.debug_funcnames) } ++ .debug_typenames 0 : { *(.debug_typenames) } ++ .debug_varnames 0 : { *(.debug_varnames) } ++ ++ ${RELOCATING+${OTHER_RELOCATING_SECTIONS}} ++ ++ /* These must appear regardless of ${RELOCATING}. */ ++ ${OTHER_SECTIONS} ++} ++EOF +--- a/opcodes/configure ++++ b/opcodes/configure +@@ -11885,6 +11885,7 @@ if test x${all_targets} = xfalse ; then + bfd_tic4x_arch) ta="$ta tic4x-dis.lo" ;; + bfd_tic54x_arch) ta="$ta tic54x-dis.lo tic54x-opc.lo" ;; + bfd_tic80_arch) ta="$ta tic80-dis.lo tic80-opc.lo" ;; ++ bfd_ubicom32_arch) ta="$ta ubicom32-asm.lo ubicom32-desc.lo ubicom32-dis.lo ubicom32-ibld.lo ubicom32-opc.lo" using_cgen=yes ;; + bfd_v850_arch) ta="$ta v850-opc.lo v850-dis.lo" ;; + bfd_v850e_arch) ta="$ta v850-opc.lo v850-dis.lo" ;; + bfd_v850ea_arch) ta="$ta v850-opc.lo v850-dis.lo" ;; +--- a/opcodes/configure.in ++++ b/opcodes/configure.in +@@ -245,6 +245,7 @@ if test x${all_targets} = xfalse ; then + bfd_tic4x_arch) ta="$ta tic4x-dis.lo" ;; + bfd_tic54x_arch) ta="$ta tic54x-dis.lo tic54x-opc.lo" ;; + bfd_tic80_arch) ta="$ta tic80-dis.lo tic80-opc.lo" ;; ++ bfd_ubicom32_arch) ta="$ta ubicom32-asm.lo ubicom32-desc.lo ubicom32-dis.lo ubicom32-ibld.lo ubicom32-opc.lo" using_cgen=yes ;; + bfd_v850_arch) ta="$ta v850-opc.lo v850-dis.lo" ;; + bfd_v850e_arch) ta="$ta v850-opc.lo v850-dis.lo" ;; + bfd_v850ea_arch) ta="$ta v850-opc.lo v850-dis.lo" ;; +--- a/opcodes/disassemble.c ++++ b/opcodes/disassemble.c +@@ -77,6 +77,7 @@ + #define ARCH_tic4x + #define ARCH_tic54x + #define ARCH_tic80 ++#define ARCH_ubicom32 + #define ARCH_v850 + #define ARCH_vax + #define ARCH_w65 +@@ -386,6 +387,11 @@ disassembler (abfd) + disassemble = print_insn_tic80; + break; + #endif ++#ifdef ARCH_ubicom32 ++ case bfd_arch_ubicom32: ++ disassemble = print_insn_ubicom32; ++ break; ++#endif + #ifdef ARCH_v850 + case bfd_arch_v850: + disassemble = print_insn_v850; +--- a/opcodes/Makefile.am ++++ b/opcodes/Makefile.am +@@ -50,6 +50,7 @@ HFILES = \ + sh-opc.h \ + sh64-opc.h \ + sysdep.h \ ++ ubicom32-desc.h ubicom32-opc.h \ + w65-opc.h \ + xc16x-desc.h xc16x-opc.h \ + xstormy16-desc.h xstormy16-opc.h \ +@@ -191,6 +192,11 @@ CFILES = \ + tic54x-opc.c \ + tic80-dis.c \ + tic80-opc.c \ ++ ubicom32-asm.c \ ++ ubicom32-desc.c \ ++ ubicom32-dis.c \ ++ ubicom32-ibld.c \ ++ ubicom32-opc.c \ + v850-dis.c \ + v850-opc.c \ + vax-dis.c \ +@@ -333,6 +339,11 @@ ALL_MACHINES = \ + tic54x-opc.lo \ + tic80-dis.lo \ + tic80-opc.lo \ ++ ubicom32-asm.lo \ ++ ubicom32-desc.lo \ ++ ubicom32-dis.lo \ ++ ubicom32-ibld.lo \ ++ ubicom32-opc.lo \ + v850-dis.lo \ + v850-opc.lo \ + vax-dis.lo \ +@@ -421,7 +432,7 @@ uninstall_libopcodes: + rm -f $(DESTDIR)$(bfdincludedir)/dis-asm.h + + CLEANFILES = \ +- stamp-ip2k stamp-m32c stamp-m32r stamp-fr30 stamp-frv \ ++ stamp-ubicom32 stamp-ip2k stamp-m32c stamp-m32r stamp-fr30 stamp-frv \ + stamp-openrisc stamp-iq2000 stamp-mep stamp-mt stamp-xstormy16 stamp-xc16x\ + libopcodes.a stamp-lib dep.sed DEP DEPA DEP1 DEP2 + +@@ -438,10 +449,11 @@ CGENDEPS = \ + $(CGENDIR)/opc-opinst.scm \ + cgen-asm.in cgen-dis.in cgen-ibld.in + +-CGEN_CPUS = fr30 frv ip2k m32c m32r mep mt openrisc xc16x xstormy16 ++CGEN_CPUS = fr30 frv ip2k ubicom32 m32c m32r mep mt openrisc xc16x xstormy16 + + if CGEN_MAINT + IP2K_DEPS = stamp-ip2k ++UBICOM32_DEPS = stamp-ubicom32 + M32C_DEPS = stamp-m32c + M32R_DEPS = stamp-m32r + FR30_DEPS = stamp-fr30 +@@ -454,6 +466,7 @@ XC16X_DEPS = stamp-xc16x + XSTORMY16_DEPS = stamp-xstormy16 + else + IP2K_DEPS = ++UBICOM32_DEPS = + M32C_DEPS = + M32R_DEPS = + FR30_DEPS = +@@ -482,6 +495,10 @@ run-cgen-all: + .PHONY: run-cgen-all + + # For now, require developers to configure with --enable-cgen-maint. ++$(srcdir)/ubicom32-desc.h $(srcdir)/ubicom32-desc.c $(srcdir)/ubicom32-opc.h $(srcdir)/ubicom32-opc.c $(srcdir)/ubicom32-ibld.c $(srcdir)/ubicom32-asm.c $(srcdir)/ubicom32-dis.c: $(UBICOM32_DEPS) ++# @true ++stamp-ubicom32: $(CGENDEPS) $(CPUDIR)/ubicom32.cpu $(CPUDIR)/ubicom32.opc ++ $(MAKE) run-cgen arch=ubicom32 prefix=ubicom32 options= extrafiles= + $(srcdir)/ip2k-desc.h $(srcdir)/ip2k-desc.c $(srcdir)/ip2k-opc.h $(srcdir)/ip2k-opc.c $(srcdir)/ip2k-ibld.c $(srcdir)/ip2k-asm.c $(srcdir)/ip2k-dis.c: $(IP2K_DEPS) + @true + stamp-ip2k: $(CGENDEPS) $(CPUDIR)/ip2k.cpu $(CPUDIR)/ip2k.opc +@@ -823,6 +840,34 @@ ia64-gen.lo: ia64-gen.c $(INCDIR)/anside + ia64-opc-m.c ia64-opc-b.c ia64-opc-f.c ia64-opc-x.c \ + ia64-opc-d.c + ia64-asmtab.lo: ia64-asmtab.c ++ubicom32-asm.lo: ubicom32-asm.c sysdep.h config.h $(INCDIR)/ansidecl.h \ ++ $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h $(INCDIR)/symcat.h \ ++ ubicom32-desc.h $(INCDIR)/opcode/cgen-bitset.h $(INCDIR)/opcode/cgen.h \ ++ $(INCDIR)/symcat.h $(INCDIR)/opcode/cgen-bitset.h ubicom32-opc.h \ ++ opintl.h $(INCDIR)/xregex.h $(INCDIR)/xregex2.h $(INCDIR)/libiberty.h \ ++ $(INCDIR)/ansidecl.h $(INCDIR)/safe-ctype.h ++ubicom32-desc.lo: ubicom32-desc.c sysdep.h config.h $(INCDIR)/ansidecl.h \ ++ $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h $(INCDIR)/symcat.h \ ++ ubicom32-desc.h $(INCDIR)/opcode/cgen-bitset.h $(INCDIR)/opcode/cgen.h \ ++ $(INCDIR)/symcat.h $(INCDIR)/opcode/cgen-bitset.h ubicom32-opc.h \ ++ opintl.h $(INCDIR)/libiberty.h $(INCDIR)/ansidecl.h \ ++ $(INCDIR)/xregex.h $(INCDIR)/xregex2.h ++ubicom32-dis.lo: ubicom32-dis.c sysdep.h config.h $(INCDIR)/ansidecl.h \ ++ $(INCDIR)/dis-asm.h $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h \ ++ $(BFD_H) $(INCDIR)/symcat.h $(INCDIR)/libiberty.h $(INCDIR)/ansidecl.h \ ++ ubicom32-desc.h $(INCDIR)/opcode/cgen-bitset.h $(INCDIR)/opcode/cgen.h \ ++ $(INCDIR)/symcat.h $(INCDIR)/opcode/cgen-bitset.h ubicom32-opc.h \ ++ opintl.h ++ubicom32-ibld.lo: ubicom32-ibld.c sysdep.h config.h $(INCDIR)/ansidecl.h \ ++ $(INCDIR)/dis-asm.h $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h \ ++ $(BFD_H) $(INCDIR)/symcat.h ubicom32-desc.h $(INCDIR)/opcode/cgen-bitset.h \ ++ $(INCDIR)/opcode/cgen.h $(INCDIR)/symcat.h $(INCDIR)/opcode/cgen-bitset.h \ ++ ubicom32-opc.h opintl.h $(INCDIR)/safe-ctype.h ++ubicom32-opc.lo: ubicom32-opc.c sysdep.h config.h $(INCDIR)/ansidecl.h \ ++ $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h $(INCDIR)/symcat.h \ ++ ubicom32-desc.h $(INCDIR)/opcode/cgen-bitset.h $(INCDIR)/opcode/cgen.h \ ++ $(INCDIR)/symcat.h $(INCDIR)/opcode/cgen-bitset.h ubicom32-opc.h \ ++ $(INCDIR)/libiberty.h $(INCDIR)/ansidecl.h $(INCDIR)/safe-ctype.h + ip2k-asm.lo: ip2k-asm.c sysdep.h config.h $(INCDIR)/ansidecl.h \ + $(BFD_H) $(INCDIR)/symcat.h ip2k-desc.h $(INCDIR)/opcode/cgen-bitset.h \ + $(INCDIR)/opcode/cgen.h $(INCDIR)/opcode/cgen-bitset.h \ +--- a/opcodes/Makefile.in ++++ b/opcodes/Makefile.in +@@ -278,6 +278,7 @@ HFILES = \ + sh-opc.h \ + sh64-opc.h \ + sysdep.h \ ++ ubicom32-desc.h ubicom32-opc.h \ + w65-opc.h \ + xc16x-desc.h xc16x-opc.h \ + xstormy16-desc.h xstormy16-opc.h \ +@@ -420,6 +421,11 @@ CFILES = \ + tic54x-opc.c \ + tic80-dis.c \ + tic80-opc.c \ ++ ubicom32-asm.c \ ++ ubicom32-desc.c \ ++ ubicom32-dis.c \ ++ ubicom32-ibld.c \ ++ ubicom32-opc.c \ + v850-dis.c \ + v850-opc.c \ + vax-dis.c \ +@@ -562,6 +568,11 @@ ALL_MACHINES = \ + tic54x-opc.lo \ + tic80-dis.lo \ + tic80-opc.lo \ ++ ubicom32-asm.lo \ ++ ubicom32-desc.lo \ ++ ubicom32-dis.lo \ ++ ubicom32-ibld.lo \ ++ ubicom32-opc.lo \ + v850-dis.lo \ + v850-opc.lo \ + vax-dis.lo \ +@@ -604,7 +615,7 @@ libopcodes_la_LDFLAGS = -release `cat .. + noinst_LIBRARIES = libopcodes.a + POTFILES = $(HFILES) $(CFILES) + CLEANFILES = \ +- stamp-ip2k stamp-m32c stamp-m32r stamp-fr30 stamp-frv \ ++ stamp-ip2k stamp-ubicom32 stamp-m32c stamp-m32r stamp-fr30 stamp-frv \ + stamp-openrisc stamp-iq2000 stamp-mep stamp-mt stamp-xstormy16 stamp-xc16x\ + libopcodes.a stamp-lib dep.sed DEP DEPA DEP1 DEP2 + +@@ -619,9 +630,11 @@ CGENDEPS = \ + $(CGENDIR)/opc-opinst.scm \ + cgen-asm.in cgen-dis.in cgen-ibld.in + +-CGEN_CPUS = fr30 frv ip2k m32c m32r mep mt openrisc xc16x xstormy16 ++CGEN_CPUS = fr30 frv ip2k ubicom32 m32c m32r mep mt openrisc xc16x xstormy16 + @CGEN_MAINT_FALSE@IP2K_DEPS = + @CGEN_MAINT_TRUE@IP2K_DEPS = stamp-ip2k ++@CGEN_MAINT_FALSE@UBICOM32_DEPS = ++@CGEN_MAINT_TRUE@UBICOM32_DEPS = stamp-ubicom32 + @CGEN_MAINT_FALSE@M32C_DEPS = + @CGEN_MAINT_TRUE@M32C_DEPS = stamp-m32c + @CGEN_MAINT_FALSE@M32R_DEPS = +@@ -1035,6 +1048,11 @@ run-cgen-all: + .PHONY: run-cgen-all + + # For now, require developers to configure with --enable-cgen-maint. ++$(srcdir)/ubicom32-desc.h $(srcdir)/ubicom32-desc.c $(srcdir)/ubicom32-opc.h $(srcdir)/ubicom32-opc.c $(srcdir)/ubicom32-ibld.c $(srcdir)/ubicom32-asm.c $(srcdir)/ubicom32-dis.c: $(UBICOM32_DEPS) ++# @true ++stamp-ubicom32: $(CGENDEPS) $(CPUDIR)/ubicom32.cpu $(CPUDIR)/ubicom32.opc ++ $(MAKE) run-cgen arch=ubicom32 prefix=ubicom32 \ ++ archfile=$(CPUDIR)/ubicom32.cpu opcfile=$(CPUDIR)/ubicom32.opc options= extrafiles= + $(srcdir)/ip2k-desc.h $(srcdir)/ip2k-desc.c $(srcdir)/ip2k-opc.h $(srcdir)/ip2k-opc.c $(srcdir)/ip2k-ibld.c $(srcdir)/ip2k-asm.c $(srcdir)/ip2k-dis.c: $(IP2K_DEPS) + @true + stamp-ip2k: $(CGENDEPS) $(CPUDIR)/ip2k.cpu $(CPUDIR)/ip2k.opc +@@ -1375,6 +1393,34 @@ ia64-gen.lo: ia64-gen.c $(INCDIR)/anside + ia64-opc-m.c ia64-opc-b.c ia64-opc-f.c ia64-opc-x.c \ + ia64-opc-d.c + ia64-asmtab.lo: ia64-asmtab.c ++ubicom32-asm.lo: ubicom32-asm.c sysdep.h config.h $(INCDIR)/ansidecl.h \ ++ $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h $(INCDIR)/symcat.h \ ++ ubicom32-desc.h $(INCDIR)/opcode/cgen-bitset.h $(INCDIR)/opcode/cgen.h \ ++ $(INCDIR)/symcat.h $(INCDIR)/opcode/cgen-bitset.h ubicom32-opc.h \ ++ opintl.h $(INCDIR)/xregex.h $(INCDIR)/xregex2.h $(INCDIR)/libiberty.h \ ++ $(INCDIR)/ansidecl.h $(INCDIR)/safe-ctype.h ++ubicom32-desc.lo: ubicom32-desc.c sysdep.h config.h $(INCDIR)/ansidecl.h \ ++ $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h $(INCDIR)/symcat.h \ ++ ubicom32-desc.h $(INCDIR)/opcode/cgen-bitset.h $(INCDIR)/opcode/cgen.h \ ++ $(INCDIR)/symcat.h $(INCDIR)/opcode/cgen-bitset.h ubicom32-opc.h \ ++ opintl.h $(INCDIR)/libiberty.h $(INCDIR)/ansidecl.h \ ++ $(INCDIR)/xregex.h $(INCDIR)/xregex2.h ++ubicom32-dis.lo: ubicom32-dis.c sysdep.h config.h $(INCDIR)/ansidecl.h \ ++ $(INCDIR)/dis-asm.h $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h \ ++ $(BFD_H) $(INCDIR)/symcat.h $(INCDIR)/libiberty.h $(INCDIR)/ansidecl.h \ ++ ubicom32-desc.h $(INCDIR)/opcode/cgen-bitset.h $(INCDIR)/opcode/cgen.h \ ++ $(INCDIR)/symcat.h $(INCDIR)/opcode/cgen-bitset.h ubicom32-opc.h \ ++ opintl.h ++ubicom32-ibld.lo: ubicom32-ibld.c sysdep.h config.h $(INCDIR)/ansidecl.h \ ++ $(INCDIR)/dis-asm.h $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h \ ++ $(BFD_H) $(INCDIR)/symcat.h ubicom32-desc.h $(INCDIR)/opcode/cgen-bitset.h \ ++ $(INCDIR)/opcode/cgen.h $(INCDIR)/symcat.h $(INCDIR)/opcode/cgen-bitset.h \ ++ ubicom32-opc.h opintl.h $(INCDIR)/safe-ctype.h ++ubicom32-opc.lo: ubicom32-opc.c sysdep.h config.h $(INCDIR)/ansidecl.h \ ++ $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h $(INCDIR)/symcat.h \ ++ ubicom32-desc.h $(INCDIR)/opcode/cgen-bitset.h $(INCDIR)/opcode/cgen.h \ ++ $(INCDIR)/symcat.h $(INCDIR)/opcode/cgen-bitset.h ubicom32-opc.h \ ++ $(INCDIR)/libiberty.h $(INCDIR)/ansidecl.h $(INCDIR)/safe-ctype.h + ip2k-asm.lo: ip2k-asm.c sysdep.h config.h $(INCDIR)/ansidecl.h \ + $(BFD_H) $(INCDIR)/symcat.h ip2k-desc.h $(INCDIR)/opcode/cgen-bitset.h \ + $(INCDIR)/opcode/cgen.h $(INCDIR)/opcode/cgen-bitset.h \ +--- /dev/null ++++ b/opcodes/ubicom32-asm.c +@@ -0,0 +1,1863 @@ ++/* Assembler interface for targets using CGEN. -*- C -*- ++ CGEN: Cpu tools GENerator ++ ++ THIS FILE IS MACHINE GENERATED WITH CGEN. ++ - the resultant file is machine generated, cgen-asm.in isn't ++ ++ Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2005, 2007 ++ Free Software Foundation, Inc. ++ ++ This file is part of libopcodes. ++ ++ This library is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3, or (at your option) ++ any later version. ++ ++ It is distributed in the hope that it will be useful, but WITHOUT ++ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY ++ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public ++ License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ ++ ++ ++/* ??? Eventually more and more of this stuff can go to cpu-independent files. ++ Keep that in mind. */ ++ ++#include "sysdep.h" ++#include ++#include "ansidecl.h" ++#include "bfd.h" ++#include "symcat.h" ++#include "ubicom32-desc.h" ++#include "ubicom32-opc.h" ++#include "opintl.h" ++#include "xregex.h" ++#include "libiberty.h" ++#include "safe-ctype.h" ++ ++#undef min ++#define min(a,b) ((a) < (b) ? (a) : (b)) ++#undef max ++#define max(a,b) ((a) > (b) ? (a) : (b)) ++ ++static const char * parse_insn_normal ++ (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *); ++ ++/* -- assembler routines inserted here. */ ++ ++/* -- asm.c */ ++ ++/* Directly addressable registers on the UBICOM32. ++ */ ++ ++#define RW 0 /* read/write */ ++#define RO 1 /* read-only */ ++#define WO 2 /* write-only */ ++ ++struct ubicom32_cgen_data_space_map ubicom32_cgen_data_space_map_mercury[] = { ++ { 0x0, "d0", RW, }, /* data registers */ ++ /* d1, d2 and d3 are later */ ++ { 0x10, "d4", RW, }, ++ { 0x14, "d5", RW, }, ++ { 0x18, "d6", RW, }, ++ { 0x1c, "d7", RW, }, ++ { 0x20, "d8", RW, }, ++ { 0x24, "d9", RW, }, ++ { 0x28, "d10", RW, }, ++ { 0x2c, "d11", RW, }, ++ { 0x30, "d12", RW, }, ++ { 0x34, "d13", RW, }, ++ { 0x38, "d14", RW, }, ++ { 0x3c, "d15", RW, }, ++ { 0x4, "d1", RW, }, /* put them here where they work */ ++ { 0x8, "d2", RW, }, ++ { 0xc, "d3", RW, }, ++ { A0_ADDRESS, "a0", RW, }, /* address registers */ ++ { A1_ADDRESS, "a1", RW, }, ++ { A2_ADDRESS, "a2", RW, }, ++ { A3_ADDRESS, "a3", RW, }, ++ { A4_ADDRESS, "a4", RW, }, ++ { A5_ADDRESS, "a5", RW, }, ++ { A6_ADDRESS, "a6", RW, }, ++ { A7_ADDRESS, "sp", RW, }, /* sp is a7; first so we use it */ ++ { A7_ADDRESS, "a7", RW, }, ++ { 0xa0, "mac_hi", RW, }, ++ { 0xa4, "mac_lo", RW, }, ++ { 0xa8, "mac_rc16", RW, }, ++ { 0xac, "source3", RW, }, ++ { 0xac, "source_3", RW, }, ++ { 0xb0, "context_cnt", RO,}, ++ { 0xb0, "inst_cnt", RO,}, ++ { 0xb4, "csr", RW, }, ++ { 0xb8, "rosr", RO, }, ++ { 0xbc, "iread_data", RW, }, ++ { 0xc0, "int_mask0", RW, }, ++ { 0xc4, "int_mask1", RW, }, ++ /* 0xc8 - 0xcf reserved for future interrupt masks */ ++ { 0xd0, "pc", RW, }, ++ /* 0xd4 - ff reserved */ ++ { 0x100, "chip_id", RO, }, ++ { 0x104, "int_stat0", RO, }, ++ { 0x108, "int_stat1", RO, }, ++ /* 0x10c - 0x113 reserved for future interrupt masks */ ++ { 0x114, "int_set0", WO, }, ++ { 0x118, "int_set1", WO, }, ++ /* 0x11c - 0x123 reserved for future interrupt set */ ++ { 0x124, "int_clr0", WO, }, ++ { 0x128, "int_clr1", WO, }, ++ /* 0x13c - 0x133 reserved for future interrupt clear */ ++ { 0x134, "global_ctrl", RW, }, ++ { 0x13c, "mt_active_set", WO, }, ++ { 0x140, "mt_active_clr", WO, }, ++ { 0x138, "mt_active", RO, }, ++ { 0x148, "mt_dbg_active_set", WO, }, ++ { 0x144, "mt_dbg_active", RO, }, ++ { 0x14C, "mt_en", RW, }, ++ { 0x150, "mt_hpri", RW, }, ++ { 0x150, "mt_pri", RW, }, ++ { 0x154, "mt_hrt", RW, }, ++ { 0x154, "mt_sched", RW, }, ++ { 0x15C, "mt_break_clr", WO, }, ++ { 0x158, "mt_break", RO, }, ++ { 0x160, "mt_single_step", RW, }, ++ { 0x164, "mt_min_delay_en", RW, }, ++ { 0x164, "mt_min_del_en", RW, }, ++ ++ { 0x16c, "perr_addr", RO, }, ++ { 0x178, "dcapt_tnum", RO, }, ++ { 0x174, "dcapt_pc", RO, }, ++ { 0x170, "dcapt", RW, }, ++ /* 0x17c - 0x1ff reserved */ ++ { 0x17c, "mt_dbg_active_clr", WO, }, ++ { 0x180, "scratchpad0", RW, }, ++ { 0x184, "scratchpad1", RW, }, ++ { 0x188, "scratchpad2", RW, }, ++ { 0x18c, "scratchpad3", RW, }, ++ ++ { 0x0, 0, RW, }, ++}; ++ ++struct ubicom32_cgen_data_space_map ubicom32_cgen_data_space_map_mars[] = { ++ { 0x0, "d0", RW, }, /* data registers */ ++ /* d1, d2 and d3 are later */ ++ { 0x10, "d4", RW, }, ++ { 0x14, "d5", RW, }, ++ { 0x18, "d6", RW, }, ++ { 0x1c, "d7", RW, }, ++ { 0x20, "d8", RW, }, ++ { 0x24, "d9", RW, }, ++ { 0x28, "d10", RW, }, ++ { 0x2c, "d11", RW, }, ++ { 0x30, "d12", RW, }, ++ { 0x34, "d13", RW, }, ++ { 0x38, "d14", RW, }, ++ { 0x3c, "d15", RW, }, ++ { 0x4, "d1", RW, }, /* put them here where they work */ ++ { 0x8, "d2", RW, }, ++ { 0xc, "d3", RW, }, ++ { A0_ADDRESS, "a0", RW, }, /* address registers */ ++ { A1_ADDRESS, "a1", RW, }, ++ { A2_ADDRESS, "a2", RW, }, ++ { A3_ADDRESS, "a3", RW, }, ++ { A4_ADDRESS, "a4", RW, }, ++ { A5_ADDRESS, "a5", RW, }, ++ { A6_ADDRESS, "a6", RW, }, ++ { A7_ADDRESS, "sp", RW, }, /* sp is a7; first so we use it */ ++ { A7_ADDRESS, "a7", RW, }, ++ { 0xa0, "mac_hi", RW, }, ++ { 0xa0, "acc0_hi", RW, }, /* mac_hi and mac_lo are also known as acc0_hi and acc0_lo */ ++ { 0xa4, "mac_lo", RW, }, ++ { 0xa4, "acc0_lo", RW, }, ++ { 0xa8, "mac_rc16", RW, }, ++ { 0xac, "source3", RW, }, ++ { 0xac, "source_3", RW, }, ++ { 0xb0, "context_cnt", RO,}, ++ { 0xb0, "inst_cnt", RO,}, ++ { 0xb4, "csr", RW, }, ++ { 0xb8, "rosr", RO, }, ++ { 0xbc, "iread_data", RW, }, ++ { 0xc0, "int_mask0", RW, }, ++ { 0xc4, "int_mask1", RW, }, ++ /* 0xc8 - 0xcf reserved for future interrupt masks */ ++ { 0xd0, "pc", RW, }, ++ { 0xd4, "trap_cause", RW, }, ++ { 0xd8, "acc1_hi", RW, }, /* Defines for acc1 */ ++ { 0xdc, "acc1_lo", RW, }, ++ { 0xe0, "previous_pc", RO, }, ++ ++ /* 0xe4 - ff reserved */ ++ { 0x100, "chip_id", RO, }, ++ { 0x104, "int_stat0", RO, }, ++ { 0x108, "int_stat1", RO, }, ++ /* 0x10c - 0x113 reserved for future interrupt masks */ ++ { 0x114, "int_set0", WO, }, ++ { 0x118, "int_set1", WO, }, ++ /* 0x11c - 0x123 reserved for future interrupt set */ ++ { 0x124, "int_clr0", WO, }, ++ { 0x128, "int_clr1", WO, }, ++ /* 0x130 - 0x133 reserved for future interrupt clear */ ++ { 0x134, "global_ctrl", RW, }, ++ { 0x13c, "mt_active_set", WO, }, ++ { 0x140, "mt_active_clr", WO, }, ++ { 0x138, "mt_active", RO, }, ++ { 0x148, "mt_dbg_active_set", WO, }, ++ { 0x144, "mt_dbg_active", RO, }, ++ { 0x14C, "mt_en", RW, }, ++ { 0x150, "mt_hpri", RW, }, ++ { 0x150, "mt_pri", RW, }, ++ { 0x154, "mt_hrt", RW, }, ++ { 0x154, "mt_sched", RW, }, ++ { 0x15C, "mt_break_clr", WO, }, ++ { 0x158, "mt_break", RO, }, ++ { 0x160, "mt_single_step", RW, }, ++ { 0x164, "mt_min_delay_en", RW, }, ++ { 0x164, "mt_min_del_en", RW, }, ++ { 0x168, "mt_break_set", WO, }, ++ /* 0x16c - 0x16f reserved */ ++ { 0x170, "dcapt", RW, }, ++ /* 0x174 - 0x17b reserved */ ++ { 0x17c, "mt_dbg_active_clr", WO, }, ++ { 0x180, "scratchpad0", RW, }, ++ { 0x184, "scratchpad1", RW, }, ++ { 0x188, "scratchpad2", RW, }, ++ { 0x18c, "scratchpad3", RW, }, ++ ++ /* 0x190 - 0x19f Reserved */ ++ { 0x1a0, "chip_cfg", RW, }, ++ { 0x1a4, "mt_i_blocked", RO, }, ++ { 0x1a8, "mt_d_blocked", RO, }, ++ { 0x1ac, "mt_i_blocked_set", WO}, ++ { 0x1b0, "mt_d_blocked_set", WO}, ++ { 0x1b4, "mt_blocked_clr", WO}, ++ { 0x1b8, "mt_trap_en", RW, }, ++ { 0x1bc, "mt_trap", RO, }, ++ { 0x1c0, "mt_trap_set", WO, }, ++ { 0x1c4, "mt_trap_clr", WO, }, ++ /* 0x1c8-0x1FF Reserved */ ++ { 0x200, "i_range0_hi", RW}, ++ { 0x204, "i_range1_hi", RW}, ++ { 0x208, "i_range2_hi", RW}, ++ { 0x20c, "i_range3_hi", RW}, ++ ++ /* 0x210-0x21f Reserved */ ++ { 0x220, "i_range0_lo", RW}, ++ { 0x224, "i_range1_lo", RW}, ++ { 0x228, "i_range2_lo", RW}, ++ { 0x22c, "i_range3_lo", RW}, ++ ++ /* 0x230-0x23f Reserved */ ++ { 0x240, "i_range0_en", RW}, ++ { 0x244, "i_range1_en", RW}, ++ { 0x248, "i_range2_en", RW}, ++ { 0x24c, "i_range3_en", RW}, ++ ++ /* 0x250-0x25f Reserved */ ++ { 0x260, "d_range0_hi", RW}, ++ { 0x264, "d_range1_hi", RW}, ++ { 0x268, "d_range2_hi", RW}, ++ { 0x26c, "d_range3_hi", RW}, ++ { 0x270, "d_range4_hi", RW}, ++ ++ /* 0x274-0x27f Reserved */ ++ { 0x280, "d_range0_lo", RW}, ++ { 0x284, "d_range1_lo", RW}, ++ { 0x288, "d_range2_lo", RW}, ++ { 0x28c, "d_range3_lo", RW}, ++ { 0x290, "d_range4_lo", RW}, ++ ++ /* 0x294-0x29f Reserved */ ++ { 0x2a0, "d_range0_en", RW}, ++ { 0x2a4, "d_range1_en", RW}, ++ { 0x2a8, "d_range2_en", RW}, ++ { 0x2ac, "d_range3_en", RW}, ++ { 0x2b0, "d_range4_en", RW}, ++ ++ /* 0x2b4-0x3ff Reserved */ ++ ++ { 0x0, 0, RW, }, ++}; ++ ++/* t_is_set will be 1 if .t is set for the madd.2 and msub.2 instructions */ ++static unsigned char t_is_set =0; ++ ++static const char * ++parse_t_is_set_for_addsub ( ++ CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ const char **strp, ++ CGEN_KEYWORD *keyword_table, ++ long *valuep) ++{ ++ const char *errmsg; ++ ++ t_is_set = 0; ++ ++ errmsg = cgen_parse_keyword (cd, strp, keyword_table, valuep); ++ if (errmsg) ++ { ++ t_is_set = 0; ++ ++ return errmsg; ++ } ++ ++ if((int)*valuep) ++ t_is_set = 1; ++ ++ return NULL; ++} ++ ++char myerrmsg[128]; ++ ++/* ++ * If accumulator is selected for madd.2 and msub.2 instructions then ++ * the T bit should not be selected. Flag an assembler error in those ++ * cases. ++ */ ++static const char * ++parse_acc_for_addsub (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ const char **strp, ++ CGEN_KEYWORD *keyword_table, ++ long *valuep) ++{ ++ const char *errmsg; ++ ++ errmsg = cgen_parse_keyword (cd, strp, keyword_table, valuep); ++ if (errmsg) ++ { ++ t_is_set = 0; ++ ++ return errmsg; ++ } ++ ++ ++ if(t_is_set) ++ { ++ /* This is erroneous. */ ++ sprintf(myerrmsg, "Extenstion \".t\" is illegal when using acc%d as Source 2 register.", (int)*valuep); ++ t_is_set=0; ++ return (myerrmsg); ++ } ++ ++ t_is_set=0; ++ return NULL; ++} ++ ++/* ++ * For dsp madd/msub cases if S2 is a data register then t_is_set flag should be set to zero. ++ */ ++static const char * ++parse_dr_for_addsub (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ const char **strp, ++ CGEN_KEYWORD *keyword_table, ++ long *valuep) ++{ ++ const char *errmsg; ++ ++ errmsg = cgen_parse_keyword (cd, strp, keyword_table, valuep); ++ if (errmsg) ++ { ++ t_is_set = 0; ++ ++ return errmsg; ++ } ++ t_is_set=0; ++ return NULL; ++} ++ ++static const char * ++parse_bit5 (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ long *valuep) ++{ ++ const char *errmsg; ++ char mode = 0; ++ long count = 0; ++ unsigned long value; ++ ++ if (strncmp (*strp, "%bit", 4) == 0) ++ { ++ *strp += 4; ++ mode = 1; ++ } ++ else if (strncmp (*strp, "%msbbit", 7) == 0) ++ { ++ *strp += 7; ++ mode = 2; ++ } ++ else if (strncmp (*strp, "%lsbbit", 7) == 0) ++ { ++ *strp += 7; ++ mode = 3; ++ } ++ ++ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep); ++ if (errmsg) { ++ return errmsg; ++ } ++ ++ if (mode) { ++ value = (unsigned long) *valuep; ++ if (value == 0) { ++ errmsg = _("Attempt to find bit index of 0"); ++ return errmsg; ++ } ++ ++ if (mode == 1) { ++ count = 31; ++ while ((value & 0x80000000) == 0) { ++ count--; ++ value <<= 1; ++ } ++ if ((value & 0x7FFFFFFF) != 0) { ++ errmsg = _("More than one bit set in bitmask"); ++ return errmsg; ++ } ++ } else if (mode == 2) { ++ count = 31; ++ while ((value & 0x80000000) == 0) { ++ count--; ++ value <<= 1; ++ } ++ } else if (mode == 3) { ++ count = 0; ++ while ((value & 0x00000001) == 0) { ++ count++; ++ value >>= 1; ++ } ++ } ++ ++ *valuep = count; ++ } ++ ++ return errmsg; ++} ++ ++/* ++ * For dsp madd/msub cases if S2 is a #bit5 then t_is_set flag should be set to zero. ++ */ ++static const char * ++parse_bit5_for_addsub (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ const char **strp, ++ int opindex, ++ long *valuep) ++{ ++ const char *errmsg; ++ ++ errmsg = parse_bit5(cd, strp, opindex, valuep); ++ if (errmsg) ++ { ++ t_is_set = 0; ++ ++ return errmsg; ++ } ++ t_is_set=0; ++ return NULL; ++} ++ ++/* Parse signed 4 bit immediate value, being careful (hacky) to avoid ++ eating a `++' that might be present */ ++static const char * ++parse_imm4 (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ long *valuep, ++ int size) ++{ ++ const char *errmsg; ++ char *plusplus; ++ long value; ++ ++ plusplus = strstr(*strp, "++"); ++ if (plusplus) ++ *plusplus = 0; ++ errmsg = cgen_parse_signed_integer (cd, strp, opindex, &value); ++ if (plusplus) ++ *plusplus = '+'; ++ ++ if (errmsg == NULL) ++ { ++ if ((size == 2 && (value % 2)) || ++ (size == 4 && (value % 4))) ++ errmsg = _("unaligned increment"); ++ else if ((size == 1 && (value < -8 || value > 7)) || ++ (size == 2 && (value < -16 || value > 15)) || ++ (size == 4 && (value < -32 || value > 31))) ++ errmsg = _("out of bounds increment"); ++ else ++ *valuep = value; ++ } ++ return errmsg; ++} ++ ++/* as above, for single byte addresses */ ++static const char * ++parse_imm4_1 (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ long *valuep) ++{ ++ return parse_imm4 (cd, strp, opindex, valuep, 1); ++} ++ ++/* as above, for half-word addresses */ ++static const char * ++parse_imm4_2 (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ long *valuep) ++{ ++ return parse_imm4 (cd, strp, opindex, valuep, 2); ++} ++ ++/* as above, for word addresses */ ++static const char * ++parse_imm4_4 (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ long *valuep) ++{ ++ return parse_imm4 (cd, strp, opindex, valuep, 4); ++} ++ ++/* Parse a direct address. This can be either `$xx' or a Register ++ Mnemonic. ++ */ ++static const char * ++parse_direct_addr (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ long *valuep, ++ int isdest) ++{ ++ const char *errmsg = NULL; ++ bfd_vma value; ++ struct ubicom32_cgen_data_space_map *cur; ++ size_t len; ++ ++ if(cd->machs & (1<name; cur++) ++ if (strncasecmp(cur->name, *strp, (len = strlen(cur->name))) == 0 && ++ !ISALNUM((*strp)[len]) && (*strp)[len] != '_' ) ++ { ++ *strp += len; ++ /* fail if specifying a read-only register as a destination */ ++ if (isdest && cur->type == RO) ++ return _("attempt to write to read-only register"); ++ ++ /* fail if specifying a write-only register as a source */ ++ if ((isdest==0) && cur->type == WO) ++ return _("attempt to read a write-only register"); ++ value = cur->address; ++ errmsg = NULL; ++ break; ++ } ++ ++ /* Not found: try parsing it as a literal */ ++ if (cur->name == NULL) ++ { ++ char *plusplus; ++ if (**strp == '(') ++ { ++ return _("parentheses are reserved for indirect addressing"); ++ } ++ ++ if (strncasecmp(*strp, "%f", 2) == 0) ++ { ++ *valuep = 0; ++ return NULL; ++ } ++ ++ /* we want to avoid parsing a negative post-increment expression as a numeric ++ expression because the parser assumes zeroes exist between the pluses and ++ issues an extraneous warning message. */ ++ plusplus = strstr(*strp, "++"); ++ if (plusplus) ++ *plusplus = 0; ++ errmsg = cgen_parse_signed_integer (cd, strp, opindex, &value); ++ if (plusplus) ++ *plusplus = '+'; ++ ++ if (errmsg) ++ return errmsg; ++ } ++ ++ value &= 0x3ff; ++ *valuep = value; ++ return errmsg; ++} ++ ++static const char * ++parse_d_direct_addr (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ long *valuep) ++{ ++ return parse_direct_addr (cd, strp, opindex, valuep, 1); ++} ++ ++static const char * ++parse_s1_direct_addr (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ long *valuep) ++{ ++ return parse_direct_addr (cd, strp, opindex, valuep, 0); ++} ++ ++/* support for source-1 and destination operand 7-bit immediates for indirect addressing */ ++static const char *imm7_1_rangemsg = "7-bit byte immediate value out of range"; ++static const char *imm7_2_rangemsg = "7-bit halfword immediate value out of range"; ++static const char *imm7_4_rangemsg = "7-bit word immediate value out of range"; ++static const char *imm7_pdec_rangemsg = "Pdec offset out of range. Allowed range is >=4 and <=512."; ++static const char *imm7_2_maskmsg = "7-bit halfword immediate not a multiple of 2"; ++static const char *imm7_4_maskmsg = "7-bit word immediate not a multiple of 4"; ++ ++/* Parse 7-bit immediates, allow %lo() operator */ ++static const char * ++parse_imm7_basic (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep, ++ const char *rangemsg, ++ const char *maskmsg, ++ bfd_vma max, ++ int mask, ++ int reloc) ++{ ++ const char *errmsg; ++ enum cgen_parse_operand_result result_type = CGEN_PARSE_OPERAND_RESULT_NUMBER; ++ bfd_vma value; ++ int newreloc; ++ ++ /* in this case we want low 7-bits to accompany the 24-bit immediate of a moveai instruction */ ++ if (strncasecmp (*strp, "%lo(", 4) == 0) ++ { ++ *strp += 4; ++ errmsg = cgen_parse_address (cd, strp, opindex, reloc, ++ &result_type, &value); ++ if (**strp != ')') ++ return _("missing `)'"); ++ ++*strp; ++ if (errmsg == NULL ++ && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) ++ value &= 0x7f; /* always want 7 bits, regardless of imm7 type */ ++ *valuep = value; ++ return errmsg; ++ } ++ else if (strncasecmp (*strp, "%got_lo(", strlen("%got_lo(")) == 0) ++ { ++ *strp += strlen("%got_lo("); ++ ++ /* Switch the relocation to the GOT relocation. */ ++ switch(reloc) ++ { ++ case BFD_RELOC_UBICOM32_LO7_S: ++ reloc = BFD_RELOC_UBICOM32_GOT_LO7_S; ++ break; ++ case BFD_RELOC_UBICOM32_LO7_2_S: ++ reloc = BFD_RELOC_UBICOM32_GOT_LO7_2_S; ++ break; ++ case BFD_RELOC_UBICOM32_LO7_4_S: ++ reloc = BFD_RELOC_UBICOM32_GOT_LO7_4_S; ++ break; ++ case BFD_RELOC_UBICOM32_LO7_D: ++ reloc = BFD_RELOC_UBICOM32_GOT_LO7_D; ++ break; ++ case BFD_RELOC_UBICOM32_LO7_2_D: ++ reloc = BFD_RELOC_UBICOM32_GOT_LO7_2_D; ++ break; ++ case BFD_RELOC_UBICOM32_LO7_4_D: ++ reloc = BFD_RELOC_UBICOM32_GOT_LO7_4_D; ++ break; ++ } ++ errmsg = cgen_parse_address (cd, strp, opindex, reloc, ++ &result_type, &value); ++ if (**strp != ')') ++ return _("missing `)'"); ++ ++*strp; ++ if (errmsg == NULL ++ && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) ++ value &= 0x7f; /* always want 7 bits, regardless of imm7 type */ ++ *valuep = value; ++ return errmsg; ++ } ++ else if (strncasecmp (*strp, "%funcdesc_got_lo(", strlen("%funcdesc_got_lo(")) == 0) ++ { ++ *strp += strlen("%funcdesc_got_lo("); ++ ++ /* Switch the relocation to the GOT relocation. */ ++ switch(reloc) ++ { ++ case BFD_RELOC_UBICOM32_LO7_S: ++ reloc = BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_S; ++ break; ++ case BFD_RELOC_UBICOM32_LO7_2_S: ++ reloc = BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_2_S; ++ break; ++ case BFD_RELOC_UBICOM32_LO7_4_S: ++ reloc = BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_4_S; ++ break; ++ case BFD_RELOC_UBICOM32_LO7_D: ++ reloc = BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_D; ++ break; ++ case BFD_RELOC_UBICOM32_LO7_2_D: ++ reloc = BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_2_D; ++ break; ++ case BFD_RELOC_UBICOM32_LO7_4_D: ++ reloc = BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_4_D; ++ break; ++ } ++ errmsg = cgen_parse_address (cd, strp, opindex, reloc, ++ &result_type, &value); ++ if (**strp != ')') ++ return _("missing `)'"); ++ ++*strp; ++ if (errmsg == NULL ++ && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) ++ value &= 0x7f; /* always want 7 bits, regardless of imm7 type */ ++ *valuep = value; ++ return errmsg; ++ } ++ else ++ { ++ if (**strp == '(') ++ { ++ return _("parentheses are reserved for indirect addressing"); ++ } ++ ++ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, &value); ++ } ++ ++ if (errmsg == NULL) ++ { ++ if (value > max) ++ return rangemsg; ++ if (value & mask) ++ return maskmsg; ++ } ++ ++ *valuep = value & max; ++ return errmsg; ++} ++ ++/* Parse 7-bit immediates, allow %lo() operator */ ++static const char * ++parse_imm7_pdec (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep, ++ const char *rangemsg, ++ const char *maskmsg, ++ int reloc) ++{ ++ const char *errmsg; ++ enum cgen_parse_operand_result result_type = CGEN_PARSE_OPERAND_RESULT_NUMBER; ++ bfd_vma value; ++ ++ /* in this case we want low 7-bits to accompany the 24-bit immediate of a moveai instruction */ ++ if (strncasecmp (*strp, "%lo(", 4) == 0) ++ { ++ *strp += 4; ++ errmsg = cgen_parse_address (cd, strp, opindex, reloc, ++ &result_type, &value); ++ if (**strp != ')') ++ return _("missing `)'"); ++ ++*strp; ++ if (errmsg == NULL ++ && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) ++ value &= 0x7f; /* always want 7 bits, regardless of imm7 type */ ++ *valuep = value; ++ return errmsg; ++ } ++ else ++ { ++ if (**strp == '(') ++ { ++ return _("parentheses are reserved for indirect addressing"); ++ } ++ ++ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, &value); ++ } ++ ++ if (errmsg == NULL) ++ { ++ if (((long)value > 512) || ((long)value < 4)) ++ return rangemsg; ++ if (value & 0x3) ++ return maskmsg; ++ } ++ ++ *valuep = value; ++ return errmsg; ++} ++ ++/* single byte imm7 */ ++static const char * ++parse_imm7_1_s (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep) ++{ ++ return parse_imm7_basic (cd, strp, opindex, valuep, _(imm7_1_rangemsg), ++ NULL, 0x7f, 0, BFD_RELOC_UBICOM32_LO7_S); ++} ++ ++/* halfword imm7 */ ++static const char * ++parse_imm7_2_s (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep) ++{ ++ return parse_imm7_basic (cd, strp, opindex, valuep, ++ _(imm7_2_rangemsg), ++ _(imm7_2_maskmsg), ++ 0xfe, 0x1, BFD_RELOC_UBICOM32_LO7_2_S); ++} ++ ++/* word imm7 */ ++static const char * ++parse_imm7_4_s (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep) ++{ ++ return parse_imm7_basic (cd, strp, opindex, valuep, ++ _(imm7_4_rangemsg), ++ _(imm7_4_maskmsg), ++ 0x1fc, 0x3, BFD_RELOC_UBICOM32_LO7_4_S); ++} ++ ++/* word imm7 */ ++static const char * ++parse_pdec_imm7_4_s (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep) ++{ ++ unsigned long value; ++ const char *errmsg = parse_imm7_pdec (cd, strp, opindex, &value, ++ _(imm7_pdec_rangemsg), ++ _(imm7_4_maskmsg), ++ BFD_RELOC_UBICOM32_LO7_4_S); ++ ++ if(errmsg == NULL) ++ { ++ /* at this point we have a valid value. Take the 2's comp and truncate to 7 bits */ ++ if(value == 0) ++ return _("Offset for PDEC source cannot be 0"); ++ ++ value = ~value; ++ value ++; ++ value &= 0x1fc; ++ *valuep = value; ++ } ++ ++ return errmsg; ++} ++ ++/* single byte dest imm7 */ ++static const char * ++parse_imm7_1_d (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep) ++{ ++ return parse_imm7_basic (cd, strp, opindex, valuep, _(imm7_1_rangemsg), ++ NULL, 0x7f, 0, BFD_RELOC_UBICOM32_LO7_D); ++} ++ ++/* halfword dest imm7 */ ++static const char * ++parse_imm7_2_d (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep) ++{ ++ return parse_imm7_basic (cd, strp, opindex, valuep, ++ _(imm7_2_rangemsg), ++ _(imm7_2_maskmsg), ++ 0xfe, 0x1, BFD_RELOC_UBICOM32_LO7_2_D); ++} ++ ++/* word dest imm7 */ ++static const char * ++parse_imm7_4_d (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep) ++{ ++ return parse_imm7_basic (cd, strp, opindex, valuep, ++ _(imm7_4_rangemsg), ++ _(imm7_4_maskmsg), ++ 0x1fc, 0x3, BFD_RELOC_UBICOM32_LO7_4_D); ++} ++ ++/* Parse 16-bit immediate, allow %hi() or %lo() operators */ ++static const char * ++parse_imm16 (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep) ++{ ++ const char *errmsg; ++ enum cgen_parse_operand_result result_type = CGEN_PARSE_OPERAND_RESULT_NUMBER; ++ bfd_vma value; ++ ++ if (strncasecmp (*strp, "%hi(", 4) == 0) ++ { ++ *strp += 4; ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_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, "%got_hi(", strlen("%got_hi(")) == 0) ++ { ++ *strp += strlen("%got_hi("); ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_UBICOM32_GOTOFFSET_HI, ++ &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, "%got_funcdesc_hi(", strlen("%got_funcdesc_hi(")) == 0) ++ { ++ *strp += strlen("%got_funcdesc_hi("); ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_UBICOM32_FUNCDESC_GOTOFFSET_HI, ++ &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, "%lo(", 4) == 0) ++ { ++ *strp += 4; ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_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, "%got_lo(", strlen("%got_lo(")) == 0) ++ { ++ *strp += strlen("%got_lo("); ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_UBICOM32_GOTOFFSET_LO, ++ &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, "%got_funcdesc_lo(", strlen("%got_funcdesc_lo(")) == 0) ++ { ++ *strp += strlen("%got_funcdesc_lo("); ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_UBICOM32_FUNCDESC_GOTOFFSET_LO, ++ &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 ++ { ++ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, &value); ++ } ++ ++ if (errmsg == NULL ++ && ((long)value > 65535 || (long)value < -32768)) ++ return _("16-bit immediate value out of range"); ++ ++ *valuep = value & 0xffff; ++ return errmsg; ++} ++ ++/* Parse 24-bit immediate for moveai instruction and allow %hi() operator */ ++static const char * ++parse_imm24 (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep) ++{ ++ const char *errmsg; ++ enum cgen_parse_operand_result result_type = CGEN_PARSE_OPERAND_RESULT_NUMBER; ++ bfd_vma value; ++ ++ if (strncasecmp (*strp, "%hi(", 4) == 0) ++ { ++ *strp += 4; ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_UBICOM32_HI24, ++ &result_type, &value); ++ if (**strp != ')') ++ return _("missing `)'"); ++ ++*strp; ++ if (errmsg == NULL ++ && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) ++ value >>= 7; ++ *valuep = value; ++ return errmsg; ++ } ++ else if (strncasecmp (*strp, "%got_hi(", strlen("%got_hi(")) == 0) ++ { ++ *strp += strlen("%got_hi("); ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_UBICOM32_GOT_HI24, ++ &result_type, &value); ++ if (**strp != ')') ++ return _("missing `)'"); ++ ++*strp; ++ if (errmsg == NULL ++ && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) ++ value >>= 7; ++ *valuep = value; ++ return errmsg; ++ } ++ else if (strncasecmp (*strp, "%funcdesc_got_hi(", strlen("%funcdesc_got_hi(")) == 0) ++ { ++ *strp += strlen("%funcdesc_got_hi("); ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_UBICOM32_FUNCDESC_GOT_HI24, ++ &result_type, &value); ++ if (**strp != ')') ++ return _("missing `)'"); ++ ++*strp; ++ if (errmsg == NULL ++ && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) ++ value >>= 7; ++ *valuep = value; ++ return errmsg; ++ } ++ else ++ { ++ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, &value); ++ } ++ ++ if (errmsg == NULL ++ && ((long)value > 16777215 || (long)value < 0)) ++ return _("24-bit immediate value out of range"); ++ ++ *valuep = value; ++ return errmsg; ++} ++ ++static const char * ++parse_offset21 (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ int reloc ATTRIBUTE_UNUSED, ++ enum cgen_parse_operand_result *type_addr ATTRIBUTE_UNUSED, ++ unsigned long *valuep) ++{ ++ const char *errmsg; ++ enum cgen_parse_operand_result result_type = CGEN_PARSE_OPERAND_RESULT_NUMBER; ++ bfd_vma value; ++ ++ if (**strp == '#') ++ { ++ ++*strp; ++ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, &value); ++ } ++ else ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_UBICOM32_21_PCREL, ++ &result_type, &value); ++ ++ if (errmsg == NULL && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) ++ { ++ /* we treat jmp #constant as being jump to pc + constant * 4 */ ++ if ((long)value > 1048575 || (long)value < -1048576) ++ return _("21-bit relative offset out of range"); ++ } ++ ++ *valuep = value & 0x7fffff; /* address is actually 23 bits before shift */ ++ return errmsg; ++} ++ ++static const char * ++parse_offset16 (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep) ++{ ++ const char *errmsg; ++ enum cgen_parse_operand_result result_type = CGEN_PARSE_OPERAND_RESULT_NUMBER; ++ bfd_vma value; ++ ++ /* in this case we want low 7-bits to accompany the 24-bit immediate of a moveai instruction */ ++ if (strncasecmp (*strp, "%lo(", 4) == 0) ++ { ++ *strp += 4; ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_UBICOM32_LO7_CALLI, ++ &result_type, &value); ++ if (errmsg != NULL) ++ return errmsg; ++ ++ if (**strp != ')') ++ return _("missing `)'"); ++ ++*strp; ++ ++ if (result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) ++ *valuep = value & 0x7c; ++ ++ return NULL; ++ } ++ ++ if (strncasecmp (*strp, "%got_lo(", strlen("%got_lo(")) == 0) ++ { ++ *strp += strlen("%got_lo("); ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_UBICOM32_GOT_LO7_CALLI, ++ &result_type, &value); ++ if (errmsg != NULL) ++ return errmsg; ++ ++ if (**strp != ')') ++ return _("missing `)'"); ++ ++*strp; ++ ++ if (result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) ++ *valuep = value & 0x7c; ++ ++ return NULL; ++ } ++ ++ if (strncasecmp (*strp, "%funcdesc_got_lo(", strlen("%funcdesc_got_lo(")) == 0) ++ { ++ *strp += strlen("%funcdesc_got_lo("); ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_UBICOM32_FUNCDESC_GOT_LO7_CALLI, ++ &result_type, &value); ++ if (errmsg != NULL) ++ return errmsg; ++ ++ if (**strp != ')') ++ return _("missing `)'"); ++ ++*strp; ++ ++ if (result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) ++ *valuep = value & 0x7c; ++ ++ return NULL; ++ } ++ ++ if (strncasecmp (*strp, "%lo18(", 6) == 0) ++ { ++ *strp += 6; ++ errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_UBICOM32_LO16_CALLI, ++ &result_type, &value); ++ if (errmsg != NULL) ++ return errmsg; ++ ++ if (**strp != ')') ++ return _("missing `)'"); ++ ++*strp; ++ ++ if (result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) ++ *valuep = value & 0x0003fffc; ++ ++ return NULL; ++ } ++ ++ errmsg = cgen_parse_signed_integer (cd, strp, opindex, &value); ++ if (errmsg != NULL) ++ return errmsg; ++ ++ /* ensure calli constant within limits and is multiple of 4 */ ++ if (value & 0x3) ++ return _("calli offset must be multiple of 4"); ++ ++ if ((long)value > 131071 || (long)value < -131072) ++ return _("16-bit calli offset out of range"); ++ ++ *valuep = value & 0x0003fffc; /* address is actually 18 bits before shift */ ++ return NULL; ++} ++ ++static const char * ++parse_imm8 (CGEN_CPU_DESC cd, ++ const char **strp, ++ int opindex, ++ unsigned long *valuep) ++{ ++ const char *errmsg; ++ bfd_vma value; ++ int no_sign = 0; ++ ++ if (**strp == '0' && TOUPPER(*(*strp+1)) == 'X') ++ no_sign = 1; ++ ++ errmsg = cgen_parse_signed_integer (cd, strp, opindex, &value); ++ ++ if (errmsg == NULL) ++ { ++ if ((no_sign && ((long)value > 255)) || ++ (!no_sign && (((long)value > 127) || ((long)value < -128)))) ++ return _("8-bit immediate value out of range"); ++ } ++ ++ *valuep = value & 0xff; ++ return errmsg; ++} ++ ++/* -- dis.c */ ++ ++const char * ubicom32_cgen_parse_operand ++ (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *); ++ ++/* Main entry point for operand parsing. ++ ++ This function is basically just a big switch statement. Earlier versions ++ used tables to look up the function to use, but ++ - if the table contains both assembler and disassembler functions then ++ the disassembler contains much of the assembler and vice-versa, ++ - there's a lot of inlining possibilities as things grow, ++ - using a switch statement avoids the function call overhead. ++ ++ This function could be moved into `parse_insn_normal', but keeping it ++ separate makes clear the interface between `parse_insn_normal' and each of ++ the handlers. */ ++ ++const char * ++ubicom32_cgen_parse_operand (CGEN_CPU_DESC cd, ++ int opindex, ++ const char ** strp, ++ CGEN_FIELDS * fields) ++{ ++ const char * errmsg = NULL; ++ /* Used by scalar operands that still need to be parsed. */ ++ long junk ATTRIBUTE_UNUSED; ++ ++ switch (opindex) ++ { ++ case UBICOM32_OPERAND_AM : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_addr_names, & fields->f_Am); ++ break; ++ case UBICOM32_OPERAND_AN : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_addr_names, & fields->f_An); ++ break; ++ case UBICOM32_OPERAND_C : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_h_C, & fields->f_C); ++ break; ++ case UBICOM32_OPERAND_DN : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_data_names, & fields->f_Dn); ++ break; ++ case UBICOM32_OPERAND_P : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_h_P, & fields->f_P); ++ break; ++ case UBICOM32_OPERAND_ACC1HI : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_ACC1HI, (unsigned long *) (& junk)); ++ break; ++ case UBICOM32_OPERAND_ACC1LO : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_ACC1LO, (unsigned long *) (& junk)); ++ break; ++ case UBICOM32_OPERAND_BIT5 : ++ errmsg = parse_bit5 (cd, strp, UBICOM32_OPERAND_BIT5, (unsigned long *) (& fields->f_bit5)); ++ break; ++ case UBICOM32_OPERAND_BIT5_ADDSUB : ++ errmsg = parse_bit5_for_addsub (cd, strp, UBICOM32_OPERAND_BIT5_ADDSUB, (unsigned long *) (& fields->f_bit5)); ++ break; ++ case UBICOM32_OPERAND_CC : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_h_cc, & fields->f_cond); ++ break; ++ case UBICOM32_OPERAND_D_AN : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_addr_names, & fields->f_d_An); ++ break; ++ case UBICOM32_OPERAND_D_DIRECT_ADDR : ++ errmsg = parse_d_direct_addr (cd, strp, UBICOM32_OPERAND_D_DIRECT_ADDR, (unsigned long *) (& fields->f_d_direct)); ++ break; ++ case UBICOM32_OPERAND_D_I4_1 : ++ errmsg = parse_imm4_1 (cd, strp, UBICOM32_OPERAND_D_I4_1, (long *) (& fields->f_d_i4_1)); ++ break; ++ case UBICOM32_OPERAND_D_I4_2 : ++ errmsg = parse_imm4_2 (cd, strp, UBICOM32_OPERAND_D_I4_2, (long *) (& fields->f_d_i4_2)); ++ break; ++ case UBICOM32_OPERAND_D_I4_4 : ++ errmsg = parse_imm4_4 (cd, strp, UBICOM32_OPERAND_D_I4_4, (long *) (& fields->f_d_i4_4)); ++ break; ++ case UBICOM32_OPERAND_D_IMM7_1 : ++ errmsg = parse_imm7_1_d (cd, strp, UBICOM32_OPERAND_D_IMM7_1, (unsigned long *) (& fields->f_d_imm7_1)); ++ break; ++ case UBICOM32_OPERAND_D_IMM7_2 : ++ errmsg = parse_imm7_2_d (cd, strp, UBICOM32_OPERAND_D_IMM7_2, (unsigned long *) (& fields->f_d_imm7_2)); ++ break; ++ case UBICOM32_OPERAND_D_IMM7_4 : ++ errmsg = parse_imm7_4_d (cd, strp, UBICOM32_OPERAND_D_IMM7_4, (unsigned long *) (& fields->f_d_imm7_4)); ++ break; ++ case UBICOM32_OPERAND_D_IMM8 : ++ errmsg = parse_imm8 (cd, strp, UBICOM32_OPERAND_D_IMM8, (long *) (& fields->f_d_imm8)); ++ break; ++ case UBICOM32_OPERAND_D_R : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_data_names, & fields->f_d_r); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_ADDSUB : ++ errmsg = parse_acc_for_addsub (cd, strp, & ubicom32_cgen_opval_acc_names, & fields->f_dsp_S2); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_MUL : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_acc_names, & fields->f_dsp_S2); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_data_names, & fields->f_dsp_S2); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG_ADDSUB : ++ errmsg = parse_dr_for_addsub (cd, strp, & ubicom32_cgen_opval_data_names, & fields->f_dsp_S2); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_SEL : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_DSP_S2_SEL, (unsigned long *) (& fields->f_dsp_S2_sel)); ++ break; ++ case UBICOM32_OPERAND_DSP_C : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_h_DSP_C, & fields->f_dsp_C); ++ break; ++ case UBICOM32_OPERAND_DSP_DESTA : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_h_DSP_Dest_A, & fields->f_dsp_destA); ++ break; ++ case UBICOM32_OPERAND_DSP_T : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_h_DSP_T, & fields->f_dsp_T); ++ break; ++ case UBICOM32_OPERAND_DSP_T_ADDSUB : ++ errmsg = parse_t_is_set_for_addsub (cd, strp, & ubicom32_cgen_opval_h_DSP_T_addsub, & fields->f_dsp_T); ++ break; ++ case UBICOM32_OPERAND_IMM16_1 : ++ errmsg = cgen_parse_signed_integer (cd, strp, UBICOM32_OPERAND_IMM16_1, (long *) (& fields->f_imm16_1)); ++ break; ++ case UBICOM32_OPERAND_IMM16_2 : ++ errmsg = parse_imm16 (cd, strp, UBICOM32_OPERAND_IMM16_2, (long *) (& fields->f_imm16_2)); ++ break; ++ case UBICOM32_OPERAND_IMM24 : ++ errmsg = parse_imm24 (cd, strp, UBICOM32_OPERAND_IMM24, (unsigned long *) (& fields->f_imm24)); ++ break; ++ case UBICOM32_OPERAND_INTERRUPT : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_INTERRUPT, (unsigned long *) (& fields->f_int)); ++ break; ++ case UBICOM32_OPERAND_IREAD : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_IREAD, (unsigned long *) (& junk)); ++ break; ++ case UBICOM32_OPERAND_IRQ_0 : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_IRQ_0, (unsigned long *) (& junk)); ++ break; ++ case UBICOM32_OPERAND_IRQ_1 : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_IRQ_1, (unsigned long *) (& junk)); ++ break; ++ case UBICOM32_OPERAND_MACHI : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_MACHI, (unsigned long *) (& junk)); ++ break; ++ case UBICOM32_OPERAND_MACLO : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_MACLO, (unsigned long *) (& junk)); ++ break; ++ case UBICOM32_OPERAND_OFFSET16 : ++ errmsg = parse_offset16 (cd, strp, UBICOM32_OPERAND_OFFSET16, (long *) (& fields->f_o16)); ++ break; ++ case UBICOM32_OPERAND_OFFSET21 : ++ { ++ bfd_vma value = 0; ++ errmsg = parse_offset21 (cd, strp, UBICOM32_OPERAND_OFFSET21, 0, NULL, & value); ++ fields->f_o21 = value; ++ } ++ break; ++ case UBICOM32_OPERAND_OFFSET24 : ++ { ++ bfd_vma value = 0; ++ errmsg = cgen_parse_address (cd, strp, UBICOM32_OPERAND_OFFSET24, 0, NULL, & value); ++ fields->f_o24 = value; ++ } ++ break; ++ case UBICOM32_OPERAND_OPC1 : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_OPC1, (unsigned long *) (& fields->f_op1)); ++ break; ++ case UBICOM32_OPERAND_OPC2 : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_OPC2, (unsigned long *) (& fields->f_op2)); ++ break; ++ case UBICOM32_OPERAND_PDEC_S1_IMM7_4 : ++ errmsg = parse_pdec_imm7_4_s (cd, strp, UBICOM32_OPERAND_PDEC_S1_IMM7_4, (unsigned long *) (& fields->f_s1_imm7_4)); ++ break; ++ case UBICOM32_OPERAND_S1_AN : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_addr_names, & fields->f_s1_An); ++ break; ++ case UBICOM32_OPERAND_S1_DIRECT_ADDR : ++ errmsg = parse_s1_direct_addr (cd, strp, UBICOM32_OPERAND_S1_DIRECT_ADDR, (unsigned long *) (& fields->f_s1_direct)); ++ break; ++ case UBICOM32_OPERAND_S1_I4_1 : ++ errmsg = parse_imm4_1 (cd, strp, UBICOM32_OPERAND_S1_I4_1, (long *) (& fields->f_s1_i4_1)); ++ break; ++ case UBICOM32_OPERAND_S1_I4_2 : ++ errmsg = parse_imm4_2 (cd, strp, UBICOM32_OPERAND_S1_I4_2, (long *) (& fields->f_s1_i4_2)); ++ break; ++ case UBICOM32_OPERAND_S1_I4_4 : ++ errmsg = parse_imm4_4 (cd, strp, UBICOM32_OPERAND_S1_I4_4, (long *) (& fields->f_s1_i4_4)); ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_1 : ++ errmsg = parse_imm7_1_s (cd, strp, UBICOM32_OPERAND_S1_IMM7_1, (unsigned long *) (& fields->f_s1_imm7_1)); ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_2 : ++ errmsg = parse_imm7_2_s (cd, strp, UBICOM32_OPERAND_S1_IMM7_2, (unsigned long *) (& fields->f_s1_imm7_2)); ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_4 : ++ errmsg = parse_imm7_4_s (cd, strp, UBICOM32_OPERAND_S1_IMM7_4, (unsigned long *) (& fields->f_s1_imm7_4)); ++ break; ++ case UBICOM32_OPERAND_S1_IMM8 : ++ errmsg = parse_imm8 (cd, strp, UBICOM32_OPERAND_S1_IMM8, (long *) (& fields->f_s1_imm8)); ++ break; ++ case UBICOM32_OPERAND_S1_R : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_data_names, & fields->f_s1_r); ++ break; ++ case UBICOM32_OPERAND_S2 : ++ errmsg = cgen_parse_keyword (cd, strp, & ubicom32_cgen_opval_data_names, & fields->f_s2); ++ break; ++ case UBICOM32_OPERAND_SRC3 : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_SRC3, (unsigned long *) (& junk)); ++ break; ++ case UBICOM32_OPERAND_X_BIT26 : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_X_BIT26, (unsigned long *) (& fields->f_bit26)); ++ break; ++ case UBICOM32_OPERAND_X_D : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_X_D, (unsigned long *) (& fields->f_d)); ++ break; ++ case UBICOM32_OPERAND_X_DN : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_X_DN, (unsigned long *) (& fields->f_Dn)); ++ break; ++ case UBICOM32_OPERAND_X_OP2 : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_X_OP2, (unsigned long *) (& fields->f_op2)); ++ break; ++ case UBICOM32_OPERAND_X_S1 : ++ errmsg = cgen_parse_unsigned_integer (cd, strp, UBICOM32_OPERAND_X_S1, (unsigned long *) (& fields->f_s1)); ++ break; ++ ++ default : ++ /* xgettext:c-format */ ++ fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex); ++ abort (); ++ } ++ ++ return errmsg; ++} ++ ++cgen_parse_fn * const ubicom32_cgen_parse_handlers[] = ++{ ++ parse_insn_normal, ++}; ++ ++void ++ubicom32_cgen_init_asm (CGEN_CPU_DESC cd) ++{ ++ ubicom32_cgen_init_opcode_table (cd); ++ ubicom32_cgen_init_ibld_table (cd); ++ cd->parse_handlers = & ubicom32_cgen_parse_handlers[0]; ++ cd->parse_operand = ubicom32_cgen_parse_operand; ++#ifdef CGEN_ASM_INIT_HOOK ++CGEN_ASM_INIT_HOOK ++#endif ++} ++ ++ ++ ++/* Regex construction routine. ++ ++ This translates an opcode syntax string into a regex string, ++ by replacing any non-character syntax element (such as an ++ opcode) with the pattern '.*' ++ ++ It then compiles the regex and stores it in the opcode, for ++ later use by ubicom32_cgen_assemble_insn ++ ++ Returns NULL for success, an error message for failure. */ ++ ++char * ++ubicom32_cgen_build_insn_regex (CGEN_INSN *insn) ++{ ++ CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn); ++ const char *mnem = CGEN_INSN_MNEMONIC (insn); ++ char rxbuf[CGEN_MAX_RX_ELEMENTS]; ++ char *rx = rxbuf; ++ const CGEN_SYNTAX_CHAR_TYPE *syn; ++ int reg_err; ++ ++ syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc)); ++ ++ /* Mnemonics come first in the syntax string. */ ++ if (! CGEN_SYNTAX_MNEMONIC_P (* syn)) ++ return _("missing mnemonic in syntax string"); ++ ++syn; ++ ++ /* Generate a case sensitive regular expression that emulates case ++ insensitive matching in the "C" locale. We cannot generate a case ++ insensitive regular expression because in Turkish locales, 'i' and 'I' ++ are not equal modulo case conversion. */ ++ ++ /* Copy the literal mnemonic out of the insn. */ ++ for (; *mnem; mnem++) ++ { ++ char c = *mnem; ++ ++ if (ISALPHA (c)) ++ { ++ *rx++ = '['; ++ *rx++ = TOLOWER (c); ++ *rx++ = TOUPPER (c); ++ *rx++ = ']'; ++ } ++ else ++ *rx++ = c; ++ } ++ ++ /* Copy any remaining literals from the syntax string into the rx. */ ++ for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn) ++ { ++ if (CGEN_SYNTAX_CHAR_P (* syn)) ++ { ++ char c = CGEN_SYNTAX_CHAR (* syn); ++ ++ switch (c) ++ { ++ /* Escape any regex metacharacters in the syntax. */ ++ case '.': case '[': case '\\': ++ case '*': case '^': case '$': ++ ++#ifdef CGEN_ESCAPE_EXTENDED_REGEX ++ case '?': case '{': case '}': ++ case '(': case ')': case '*': ++ case '|': case '+': case ']': ++#endif ++ *rx++ = '\\'; ++ *rx++ = c; ++ break; ++ ++ default: ++ if (ISALPHA (c)) ++ { ++ *rx++ = '['; ++ *rx++ = TOLOWER (c); ++ *rx++ = TOUPPER (c); ++ *rx++ = ']'; ++ } ++ else ++ *rx++ = c; ++ break; ++ } ++ } ++ else ++ { ++ /* Replace non-syntax fields with globs. */ ++ *rx++ = '.'; ++ *rx++ = '*'; ++ } ++ } ++ ++ /* Trailing whitespace ok. */ ++ * rx++ = '['; ++ * rx++ = ' '; ++ * rx++ = '\t'; ++ * rx++ = ']'; ++ * rx++ = '*'; ++ ++ /* But anchor it after that. */ ++ * rx++ = '$'; ++ * rx = '\0'; ++ ++ CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t)); ++ reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB); ++ ++ if (reg_err == 0) ++ return NULL; ++ else ++ { ++ static char msg[80]; ++ ++ regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80); ++ regfree ((regex_t *) CGEN_INSN_RX (insn)); ++ free (CGEN_INSN_RX (insn)); ++ (CGEN_INSN_RX (insn)) = NULL; ++ return msg; ++ } ++} ++ ++ ++/* Default insn parser. ++ ++ The syntax string is scanned and operands are parsed and stored in FIELDS. ++ Relocs are queued as we go via other callbacks. ++ ++ ??? Note that this is currently an all-or-nothing parser. If we fail to ++ parse the instruction, we return 0 and the caller will start over from ++ the beginning. Backtracking will be necessary in parsing subexpressions, ++ but that can be handled there. Not handling backtracking here may get ++ expensive in the case of the m68k. Deal with later. ++ ++ Returns NULL for success, an error message for failure. */ ++ ++static const char * ++parse_insn_normal (CGEN_CPU_DESC cd, ++ const CGEN_INSN *insn, ++ const char **strp, ++ CGEN_FIELDS *fields) ++{ ++ /* ??? Runtime added insns not handled yet. */ ++ const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn); ++ const char *str = *strp; ++ const char *errmsg; ++ const char *p; ++ const CGEN_SYNTAX_CHAR_TYPE * syn; ++#ifdef CGEN_MNEMONIC_OPERANDS ++ /* FIXME: wip */ ++ int past_opcode_p; ++#endif ++ ++ /* For now we assume the mnemonic is first (there are no leading operands). ++ We can parse it without needing to set up operand parsing. ++ GAS's input scrubber will ensure mnemonics are lowercase, but we may ++ not be called from GAS. */ ++ p = CGEN_INSN_MNEMONIC (insn); ++ while (*p && TOLOWER (*p) == TOLOWER (*str)) ++ ++p, ++str; ++ ++ if (* p) ++ return _("unrecognized instruction"); ++ ++#ifndef CGEN_MNEMONIC_OPERANDS ++ if (* str && ! ISSPACE (* str)) ++ return _("unrecognized instruction"); ++#endif ++ ++ CGEN_INIT_PARSE (cd); ++ cgen_init_parse_operand (cd); ++#ifdef CGEN_MNEMONIC_OPERANDS ++ past_opcode_p = 0; ++#endif ++ ++ /* We don't check for (*str != '\0') here because we want to parse ++ any trailing fake arguments in the syntax string. */ ++ syn = CGEN_SYNTAX_STRING (syntax); ++ ++ /* Mnemonics come first for now, ensure valid string. */ ++ if (! CGEN_SYNTAX_MNEMONIC_P (* syn)) ++ abort (); ++ ++ ++syn; ++ ++ while (* syn != 0) ++ { ++ /* Non operand chars must match exactly. */ ++ if (CGEN_SYNTAX_CHAR_P (* syn)) ++ { ++ /* FIXME: While we allow for non-GAS callers above, we assume the ++ first char after the mnemonic part is a space. */ ++ /* FIXME: We also take inappropriate advantage of the fact that ++ GAS's input scrubber will remove extraneous blanks. */ ++ if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn))) ++ { ++#ifdef CGEN_MNEMONIC_OPERANDS ++ if (CGEN_SYNTAX_CHAR(* syn) == ' ') ++ past_opcode_p = 1; ++#endif ++ ++ syn; ++ ++ str; ++ } ++ else if (*str) ++ { ++ /* Syntax char didn't match. Can't be this insn. */ ++ static char msg [80]; ++ ++ /* xgettext:c-format */ ++ sprintf (msg, _("syntax error (expected char `%c', found `%c')"), ++ CGEN_SYNTAX_CHAR(*syn), *str); ++ return msg; ++ } ++ else ++ { ++ /* Ran out of input. */ ++ static char msg [80]; ++ ++ /* xgettext:c-format */ ++ sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"), ++ CGEN_SYNTAX_CHAR(*syn)); ++ return msg; ++ } ++ continue; ++ } ++ ++ /* We have an operand of some sort. */ ++ errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), ++ &str, fields); ++ if (errmsg) ++ return errmsg; ++ ++ /* Done with this operand, continue with next one. */ ++ ++ syn; ++ } ++ ++ /* If we're at the end of the syntax string, we're done. */ ++ if (* syn == 0) ++ { ++ /* FIXME: For the moment we assume a valid `str' can only contain ++ blanks now. IE: We needn't try again with a longer version of ++ the insn and it is assumed that longer versions of insns appear ++ before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */ ++ while (ISSPACE (* str)) ++ ++ str; ++ ++ if (* str != '\0') ++ return _("junk at end of line"); /* FIXME: would like to include `str' */ ++ ++ return NULL; ++ } ++ ++ /* We couldn't parse it. */ ++ return _("unrecognized instruction"); ++} ++ ++/* Main entry point. ++ This routine is called for each instruction to be assembled. ++ STR points to the insn to be assembled. ++ We assume all necessary tables have been initialized. ++ The assembled instruction, less any fixups, is stored in BUF. ++ Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value ++ still needs to be converted to target byte order, otherwise BUF is an array ++ of bytes in target byte order. ++ The result is a pointer to the insn's entry in the opcode table, ++ or NULL if an error occured (an error message will have already been ++ printed). ++ ++ Note that when processing (non-alias) macro-insns, ++ this function recurses. ++ ++ ??? It's possible to make this cpu-independent. ++ One would have to deal with a few minor things. ++ At this point in time doing so would be more of a curiosity than useful ++ [for example this file isn't _that_ big], but keeping the possibility in ++ mind helps keep the design clean. */ ++ ++const CGEN_INSN * ++ubicom32_cgen_assemble_insn (CGEN_CPU_DESC cd, ++ const char *str, ++ CGEN_FIELDS *fields, ++ CGEN_INSN_BYTES_PTR buf, ++ char **errmsg) ++{ ++ const char *start; ++ CGEN_INSN_LIST *ilist; ++ const char *parse_errmsg = NULL; ++ const char *insert_errmsg = NULL; ++ int recognized_mnemonic = 0; ++ ++ /* Skip leading white space. */ ++ while (ISSPACE (* str)) ++ ++ str; ++ ++ /* The instructions are stored in hashed lists. ++ Get the first in the list. */ ++ ilist = CGEN_ASM_LOOKUP_INSN (cd, str); ++ ++ /* Keep looking until we find a match. */ ++ start = str; ++ for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist)) ++ { ++ const CGEN_INSN *insn = ilist->insn; ++ recognized_mnemonic = 1; ++ ++#ifdef CGEN_VALIDATE_INSN_SUPPORTED ++ /* Not usually needed as unsupported opcodes ++ shouldn't be in the hash lists. */ ++ /* Is this insn supported by the selected cpu? */ ++ if (! ubicom32_cgen_insn_supported (cd, insn)) ++ continue; ++#endif ++ /* If the RELAXED attribute is set, this is an insn that shouldn't be ++ chosen immediately. Instead, it is used during assembler/linker ++ relaxation if possible. */ ++ if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0) ++ continue; ++ ++ str = start; ++ ++ /* Skip this insn if str doesn't look right lexically. */ ++ if (CGEN_INSN_RX (insn) != NULL && ++ regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH) ++ continue; ++ ++ /* Allow parse/insert handlers to obtain length of insn. */ ++ CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn); ++ ++ parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields); ++ if (parse_errmsg != NULL) ++ continue; ++ ++ /* ??? 0 is passed for `pc'. */ ++ insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf, ++ (bfd_vma) 0); ++ if (insert_errmsg != NULL) ++ continue; ++ ++ /* It is up to the caller to actually output the insn and any ++ queued relocs. */ ++ return insn; ++ } ++ ++ { ++ static char errbuf[150]; ++#ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS ++ const char *tmp_errmsg; ++ ++ /* If requesting verbose error messages, use insert_errmsg. ++ Failing that, use parse_errmsg. */ ++ tmp_errmsg = (insert_errmsg ? insert_errmsg : ++ parse_errmsg ? parse_errmsg : ++ recognized_mnemonic ? ++ _("unrecognized form of instruction") : ++ _("unrecognized instruction")); ++ ++ if (strlen (start) > 50) ++ /* xgettext:c-format */ ++ sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start); ++ else ++ /* xgettext:c-format */ ++ sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start); ++#else ++ if (strlen (start) > 50) ++ /* xgettext:c-format */ ++ sprintf (errbuf, _("bad instruction `%.50s...'"), start); ++ else ++ /* xgettext:c-format */ ++ sprintf (errbuf, _("bad instruction `%.50s'"), start); ++#endif ++ ++ *errmsg = errbuf; ++ return NULL; ++ } ++} +--- /dev/null ++++ b/opcodes/ubicom32-desc.c +@@ -0,0 +1,15137 @@ ++/* CPU data for ubicom32. ++ ++THIS FILE IS MACHINE GENERATED WITH CGEN. ++ ++Copyright 1996-2007 Free Software Foundation, Inc. ++ ++This file is part of the GNU Binutils and/or GDB, the GNU debugger. ++ ++ This file is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3, or (at your option) ++ any later version. ++ ++ It is distributed in the hope that it will be useful, but WITHOUT ++ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY ++ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public ++ License for more details. ++ ++ You should have received a copy of the GNU General Public License along ++ with this program; if not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. ++ ++*/ ++ ++#include "sysdep.h" ++#include ++#include ++#include "ansidecl.h" ++#include "bfd.h" ++#include "symcat.h" ++#include "ubicom32-desc.h" ++#include "ubicom32-opc.h" ++#include "opintl.h" ++#include "libiberty.h" ++#include "xregex.h" ++ ++/* Attributes. */ ++ ++static const CGEN_ATTR_ENTRY bool_attr[] = ++{ ++ { "#f", 0 }, ++ { "#t", 1 }, ++ { 0, 0 } ++}; ++ ++static const CGEN_ATTR_ENTRY MACH_attr[] ATTRIBUTE_UNUSED = ++{ ++ { "base", MACH_BASE }, ++ { "ip3035", MACH_IP3035 }, ++ { "ubicom32dsp", MACH_UBICOM32DSP }, ++ { "ip3023compatibility", MACH_IP3023COMPATIBILITY }, ++ { "ubicom32_ver4", MACH_UBICOM32_VER4 }, ++ { "max", MACH_MAX }, ++ { 0, 0 } ++}; ++ ++static const CGEN_ATTR_ENTRY ISA_attr[] ATTRIBUTE_UNUSED = ++{ ++ { "ubicom32", ISA_UBICOM32 }, ++ { "max", ISA_MAX }, ++ { 0, 0 } ++}; ++ ++const CGEN_ATTR_TABLE ubicom32_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 ubicom32_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 ubicom32_cgen_operand_attr_table[] = ++{ ++ { "MACH", & MACH_attr[0], & MACH_attr[0] }, ++ { "VIRTUAL", &bool_attr[0], &bool_attr[0] }, ++ { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] }, ++ { "ABS-ADDR", &bool_attr[0], &bool_attr[0] }, ++ { "SIGN-OPT", &bool_attr[0], &bool_attr[0] }, ++ { "SIGNED", &bool_attr[0], &bool_attr[0] }, ++ { "NEGATIVE", &bool_attr[0], &bool_attr[0] }, ++ { "RELAX", &bool_attr[0], &bool_attr[0] }, ++ { "SEM-ONLY", &bool_attr[0], &bool_attr[0] }, ++ { 0, 0, 0 } ++}; ++ ++const CGEN_ATTR_TABLE ubicom32_cgen_insn_attr_table[] = ++{ ++ { "MACH", & MACH_attr[0], & MACH_attr[0] }, ++ { "ALIAS", &bool_attr[0], &bool_attr[0] }, ++ { "VIRTUAL", &bool_attr[0], &bool_attr[0] }, ++ { "UNCOND-CTI", &bool_attr[0], &bool_attr[0] }, ++ { "COND-CTI", &bool_attr[0], &bool_attr[0] }, ++ { "SKIP-CTI", &bool_attr[0], &bool_attr[0] }, ++ { "DELAY-SLOT", &bool_attr[0], &bool_attr[0] }, ++ { "RELAXABLE", &bool_attr[0], &bool_attr[0] }, ++ { "RELAXED", &bool_attr[0], &bool_attr[0] }, ++ { "NO-DIS", &bool_attr[0], &bool_attr[0] }, ++ { "PBB", &bool_attr[0], &bool_attr[0] }, ++ { 0, 0, 0 } ++}; ++ ++/* Instruction set variants. */ ++ ++static const CGEN_ISA ubicom32_cgen_isa_table[] = { ++ { "ubicom32", 32, 32, 32, 32 }, ++ { 0, 0, 0, 0, 0 } ++}; ++ ++/* Machine variants. */ ++ ++static const CGEN_MACH ubicom32_cgen_mach_table[] = { ++ { "ip3035", "ubicom32", MACH_IP3035, 0 }, ++ { "ubicom32dsp", "ubicom32dsp", MACH_UBICOM32DSP, 0 }, ++ { "ip3023compatibility", "ubicom32dsp", MACH_IP3023COMPATIBILITY, 0 }, ++ { "ubicom32_ver4", "ubicom32ver4", MACH_UBICOM32_VER4, 0 }, ++ { 0, 0, 0, 0 } ++}; ++ ++static CGEN_KEYWORD_ENTRY ubicom32_cgen_opval_data_names_entries[] = ++{ ++ { "d0", 0, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d1", 1, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d2", 2, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d3", 3, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d4", 4, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d5", 5, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d6", 6, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d7", 7, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d8", 8, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d9", 9, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d10", 10, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d11", 11, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d12", 12, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d13", 13, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d14", 14, {0, {{{0, 0}}}}, 0, 0 }, ++ { "d15", 15, {0, {{{0, 0}}}}, 0, 0 } ++}; ++ ++CGEN_KEYWORD ubicom32_cgen_opval_data_names = ++{ ++ & ubicom32_cgen_opval_data_names_entries[0], ++ 16, ++ 0, 0, 0, 0, "" ++}; ++ ++static CGEN_KEYWORD_ENTRY ubicom32_cgen_opval_addr_names_entries[] = ++{ ++ { "sp", 7, {0, {{{0, 0}}}}, 0, 0 }, ++ { "a0", 0, {0, {{{0, 0}}}}, 0, 0 }, ++ { "a1", 1, {0, {{{0, 0}}}}, 0, 0 }, ++ { "a2", 2, {0, {{{0, 0}}}}, 0, 0 }, ++ { "a3", 3, {0, {{{0, 0}}}}, 0, 0 }, ++ { "a4", 4, {0, {{{0, 0}}}}, 0, 0 }, ++ { "a5", 5, {0, {{{0, 0}}}}, 0, 0 }, ++ { "a6", 6, {0, {{{0, 0}}}}, 0, 0 }, ++ { "a7", 7, {0, {{{0, 0}}}}, 0, 0 } ++}; ++ ++CGEN_KEYWORD ubicom32_cgen_opval_addr_names = ++{ ++ & ubicom32_cgen_opval_addr_names_entries[0], ++ 9, ++ 0, 0, 0, 0, "" ++}; ++ ++static CGEN_KEYWORD_ENTRY ubicom32_cgen_opval_acc_names_entries[] = ++{ ++ { "acc0", 0, {0, {{{0, 0}}}}, 0, 0 }, ++ { "acc1", 1, {0, {{{0, 0}}}}, 0, 0 } ++}; ++ ++CGEN_KEYWORD ubicom32_cgen_opval_acc_names = ++{ ++ & ubicom32_cgen_opval_acc_names_entries[0], ++ 2, ++ 0, 0, 0, 0, "" ++}; ++ ++static CGEN_KEYWORD_ENTRY ubicom32_cgen_opval_spad_names_entries[] = ++{ ++ { "scratchpad0", 0, {0, {{{0, 0}}}}, 0, 0 }, ++ { "scratchpad1", 0, {0, {{{0, 0}}}}, 0, 0 }, ++ { "scratchpad2", 0, {0, {{{0, 0}}}}, 0, 0 }, ++ { "scratchpad3", 0, {0, {{{0, 0}}}}, 0, 0 } ++}; ++ ++CGEN_KEYWORD ubicom32_cgen_opval_spad_names = ++{ ++ & ubicom32_cgen_opval_spad_names_entries[0], ++ 4, ++ 0, 0, 0, 0, "" ++}; ++ ++static CGEN_KEYWORD_ENTRY ubicom32_cgen_opval_h_cc_entries[] = ++{ ++ { "f", 0, {0, {{{0, 0}}}}, 0, 0 }, ++ { "lo", 1, {0, {{{0, 0}}}}, 0, 0 }, ++ { "cc", 1, {0, {{{0, 0}}}}, 0, 0 }, ++ { "hs", 2, {0, {{{0, 0}}}}, 0, 0 }, ++ { "cs", 2, {0, {{{0, 0}}}}, 0, 0 }, ++ { "eq", 3, {0, {{{0, 0}}}}, 0, 0 }, ++ { "ge", 4, {0, {{{0, 0}}}}, 0, 0 }, ++ { "gt", 5, {0, {{{0, 0}}}}, 0, 0 }, ++ { "hi", 6, {0, {{{0, 0}}}}, 0, 0 }, ++ { "le", 7, {0, {{{0, 0}}}}, 0, 0 }, ++ { "ls", 8, {0, {{{0, 0}}}}, 0, 0 }, ++ { "lt", 9, {0, {{{0, 0}}}}, 0, 0 }, ++ { "mi", 10, {0, {{{0, 0}}}}, 0, 0 }, ++ { "ne", 11, {0, {{{0, 0}}}}, 0, 0 }, ++ { "pl", 12, {0, {{{0, 0}}}}, 0, 0 }, ++ { "t", 13, {0, {{{0, 0}}}}, 0, 0 }, ++ { "vc", 14, {0, {{{0, 0}}}}, 0, 0 }, ++ { "vs", 15, {0, {{{0, 0}}}}, 0, 0 } ++}; ++ ++CGEN_KEYWORD ubicom32_cgen_opval_h_cc = ++{ ++ & ubicom32_cgen_opval_h_cc_entries[0], ++ 18, ++ 0, 0, 0, 0, "" ++}; ++ ++static CGEN_KEYWORD_ENTRY ubicom32_cgen_opval_h_C_entries[] = ++{ ++ { "", 1, {0, {{{0, 0}}}}, 0, 0 }, ++ { ".s", 0, {0, {{{0, 0}}}}, 0, 0 }, ++ { ".w", 1, {0, {{{0, 0}}}}, 0, 0 } ++}; ++ ++CGEN_KEYWORD ubicom32_cgen_opval_h_C = ++{ ++ & ubicom32_cgen_opval_h_C_entries[0], ++ 3, ++ 0, 0, 0, 0, "" ++}; ++ ++static CGEN_KEYWORD_ENTRY ubicom32_cgen_opval_h_P_entries[] = ++{ ++ { ".t", 1, {0, {{{0, 0}}}}, 0, 0 }, ++ { ".f", 0, {0, {{{0, 0}}}}, 0, 0 }, ++ { "", 1, {0, {{{0, 0}}}}, 0, 0 } ++}; ++ ++CGEN_KEYWORD ubicom32_cgen_opval_h_P = ++{ ++ & ubicom32_cgen_opval_h_P_entries[0], ++ 3, ++ 0, 0, 0, 0, "" ++}; ++ ++static CGEN_KEYWORD_ENTRY ubicom32_cgen_opval_h_DSP_C_entries[] = ++{ ++ { ".c", 1, {0, {{{0, 0}}}}, 0, 0 }, ++ { "", 0, {0, {{{0, 0}}}}, 0, 0 } ++}; ++ ++CGEN_KEYWORD ubicom32_cgen_opval_h_DSP_C = ++{ ++ & ubicom32_cgen_opval_h_DSP_C_entries[0], ++ 2, ++ 0, 0, 0, 0, "" ++}; ++ ++static CGEN_KEYWORD_ENTRY ubicom32_cgen_opval_h_DSP_Dest_A_entries[] = ++{ ++ { "acc0", 0, {0, {{{0, 0}}}}, 0, 0 }, ++ { "acc1", 1, {0, {{{0, 0}}}}, 0, 0 } ++}; ++ ++CGEN_KEYWORD ubicom32_cgen_opval_h_DSP_Dest_A = ++{ ++ & ubicom32_cgen_opval_h_DSP_Dest_A_entries[0], ++ 2, ++ 0, 0, 0, 0, "" ++}; ++ ++static CGEN_KEYWORD_ENTRY ubicom32_cgen_opval_h_DSP_T_entries[] = ++{ ++ { "", 0, {0, {{{0, 0}}}}, 0, 0 }, ++ { ".t", 1, {0, {{{0, 0}}}}, 0, 0 } ++}; ++ ++CGEN_KEYWORD ubicom32_cgen_opval_h_DSP_T = ++{ ++ & ubicom32_cgen_opval_h_DSP_T_entries[0], ++ 2, ++ 0, 0, 0, 0, "" ++}; ++ ++static CGEN_KEYWORD_ENTRY ubicom32_cgen_opval_h_DSP_T_addsub_entries[] = ++{ ++ { "", 0, {0, {{{0, 0}}}}, 0, 0 }, ++ { ".t", 1, {0, {{{0, 0}}}}, 0, 0 } ++}; ++ ++CGEN_KEYWORD ubicom32_cgen_opval_h_DSP_T_addsub = ++{ ++ & ubicom32_cgen_opval_h_DSP_T_addsub_entries[0], ++ 2, ++ 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 ubicom32_cgen_hw_table[] = ++{ ++ { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { { { (1<name) ++ { ++ if (strcmp (name, table->bfd_name) == 0) ++ return table; ++ ++table; ++ } ++ abort (); ++} ++ ++/* Subroutine of ubicom32_cgen_cpu_open to build the hardware table. */ ++ ++static void ++build_hw_table (CGEN_CPU_TABLE *cd) ++{ ++ int i; ++ int machs = cd->machs; ++ const CGEN_HW_ENTRY *init = & ubicom32_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 ubicom32_cgen_cpu_open to build the hardware table. */ ++ ++static void ++build_ifield_table (CGEN_CPU_TABLE *cd) ++{ ++ cd->ifld_table = & ubicom32_cgen_ifld_table[0]; ++} ++ ++/* Subroutine of ubicom32_cgen_cpu_open to build the hardware table. */ ++ ++static void ++build_operand_table (CGEN_CPU_TABLE *cd) ++{ ++ int i; ++ int machs = cd->machs; ++ const CGEN_OPERAND *init = & ubicom32_cgen_operand_table[0]; ++ /* MAX_OPERANDS is only an upper bound on the number of selected entries. ++ However each entry is indexed by it's enum so there can be holes in ++ the table. */ ++ const CGEN_OPERAND **selected = xmalloc (MAX_OPERANDS * sizeof (* selected)); ++ ++ cd->operand_table.init_entries = init; ++ cd->operand_table.entry_size = sizeof (CGEN_OPERAND); ++ memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *)); ++ /* ??? For now we just use mach to determine which ones we want. */ ++ for (i = 0; init[i].name != NULL; ++i) ++ if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH) ++ & machs) ++ selected[init[i].type] = &init[i]; ++ cd->operand_table.entries = selected; ++ cd->operand_table.num_entries = MAX_OPERANDS; ++} ++ ++/* Subroutine of ubicom32_cgen_cpu_open to build the hardware table. ++ ??? This could leave out insns not supported by the specified mach/isa, ++ but that would cause errors like "foo only supported by bar" to become ++ "unknown insn", so for now we include all insns and require the app to ++ do the checking later. ++ ??? On the other hand, parsing of such insns may require their hardware or ++ operand elements to be in the table [which they mightn't be]. */ ++ ++static void ++build_insn_table (CGEN_CPU_TABLE *cd) ++{ ++ int i; ++ const CGEN_IBASE *ib = & ubicom32_cgen_insn_table[0]; ++ CGEN_INSN *insns = xmalloc (MAX_INSNS * sizeof (CGEN_INSN)); ++ ++ memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN)); ++ for (i = 0; i < MAX_INSNS; ++i) ++ insns[i].base = &ib[i]; ++ cd->insn_table.init_entries = insns; ++ cd->insn_table.entry_size = sizeof (CGEN_IBASE); ++ cd->insn_table.num_init_entries = MAX_INSNS; ++} ++ ++/* Subroutine of ubicom32_cgen_cpu_open to rebuild the tables. */ ++ ++static void ++ubicom32_cgen_rebuild_tables (CGEN_CPU_TABLE *cd) ++{ ++ int i; ++ CGEN_BITSET *isas = cd->isas; ++ unsigned int machs = cd->machs; ++ ++ cd->int_insn_p = CGEN_INT_INSN_P; ++ ++ /* Data derived from the isa spec. */ ++#define UNSET (CGEN_SIZE_UNKNOWN + 1) ++ cd->default_insn_bitsize = UNSET; ++ cd->base_insn_bitsize = UNSET; ++ cd->min_insn_bitsize = 65535; /* Some ridiculously big number. */ ++ cd->max_insn_bitsize = 0; ++ for (i = 0; i < MAX_ISAS; ++i) ++ if (cgen_bitset_contains (isas, i)) ++ { ++ const CGEN_ISA *isa = & ubicom32_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 = & ubicom32_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, "ubicom32_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 ++ubicom32_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...) ++{ ++ CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE)); ++ static int init_p; ++ CGEN_BITSET *isas = 0; /* 0 = "unspecified" */ ++ unsigned int machs = 0; /* 0 = "unspecified" */ ++ enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN; ++ va_list ap; ++ ++ if (! init_p) ++ { ++ init_tables (); ++ init_p = 1; ++ } ++ ++ memset (cd, 0, sizeof (*cd)); ++ ++ va_start (ap, arg_type); ++ while (arg_type != CGEN_CPU_OPEN_END) ++ { ++ switch (arg_type) ++ { ++ case CGEN_CPU_OPEN_ISAS : ++ isas = va_arg (ap, CGEN_BITSET *); ++ break; ++ case CGEN_CPU_OPEN_MACHS : ++ machs = va_arg (ap, unsigned int); ++ break; ++ case CGEN_CPU_OPEN_BFDMACH : ++ { ++ const char *name = va_arg (ap, const char *); ++ const CGEN_MACH *mach = ++ lookup_mach_via_bfd_name (ubicom32_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, "ubicom32_cgen_cpu_open: unsupported argument `%d'\n", ++ arg_type); ++ abort (); /* ??? return NULL? */ ++ } ++ arg_type = va_arg (ap, enum cgen_cpu_open_arg); ++ } ++ va_end (ap); ++ ++ /* Mach unspecified means "all". */ ++ if (machs == 0) ++ machs = (1 << MAX_MACHS) - 1; ++ /* Base mach is always selected. */ ++ machs |= 1; ++ if (endian == CGEN_ENDIAN_UNKNOWN) ++ { ++ /* ??? If target has only one, could have a default. */ ++ fprintf (stderr, "ubicom32_cgen_cpu_open: no endianness specified\n"); ++ abort (); ++ } ++ ++ cd->isas = cgen_bitset_copy (isas); ++ cd->machs = machs; ++ cd->endian = endian; ++ /* FIXME: for the sparc case we can determine insn-endianness statically. ++ The worry here is where both data and insn endian can be independently ++ chosen, in which case this function will need another argument. ++ Actually, will want to allow for more arguments in the future anyway. */ ++ cd->insn_endian = endian; ++ ++ /* Table (re)builder. */ ++ cd->rebuild_tables = ubicom32_cgen_rebuild_tables; ++ ubicom32_cgen_rebuild_tables (cd); ++ ++ /* Default to not allowing signed overflow. */ ++ cd->signed_overflow_ok_p = 0; ++ ++ return (CGEN_CPU_DESC) cd; ++} ++ ++/* Cover fn to ubicom32_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 ++ubicom32_cgen_cpu_open_1 (const char *mach_name, enum cgen_endian endian) ++{ ++ return ubicom32_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 ++ubicom32_cgen_cpu_close (CGEN_CPU_DESC cd) ++{ ++ unsigned int i; ++ const CGEN_INSN *insns; ++ ++ if (cd->macro_insn_table.init_entries) ++ { ++ insns = cd->macro_insn_table.init_entries; ++ for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns) ++ if (CGEN_INSN_RX ((insns))) ++ regfree (CGEN_INSN_RX (insns)); ++ } ++ ++ if (cd->insn_table.init_entries) ++ { ++ insns = cd->insn_table.init_entries; ++ for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns) ++ if (CGEN_INSN_RX (insns)) ++ regfree (CGEN_INSN_RX (insns)); ++ } ++ ++ if (cd->macro_insn_table.init_entries) ++ free ((CGEN_INSN *) cd->macro_insn_table.init_entries); ++ ++ if (cd->insn_table.init_entries) ++ free ((CGEN_INSN *) cd->insn_table.init_entries); ++ ++ if (cd->hw_table.entries) ++ free ((CGEN_HW_ENTRY *) cd->hw_table.entries); ++ ++ if (cd->operand_table.entries) ++ free ((CGEN_HW_ENTRY *) cd->operand_table.entries); ++ ++ free (cd); ++} ++ +--- /dev/null ++++ b/opcodes/ubicom32-desc.h +@@ -0,0 +1,369 @@ ++/* CPU data header for ubicom32. ++ ++THIS FILE IS MACHINE GENERATED WITH CGEN. ++ ++Copyright 1996-2007 Free Software Foundation, Inc. ++ ++This file is part of the GNU Binutils and/or GDB, the GNU debugger. ++ ++ This file is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3, or (at your option) ++ any later version. ++ ++ It is distributed in the hope that it will be useful, but WITHOUT ++ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY ++ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public ++ License for more details. ++ ++ You should have received a copy of the GNU General Public License along ++ with this program; if not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. ++ ++*/ ++ ++#ifndef UBICOM32_CPU_H ++#define UBICOM32_CPU_H ++ ++#include "opcode/cgen-bitset.h" ++ ++#define CGEN_ARCH ubicom32 ++ ++/* Given symbol S, return ubicom32_cgen_. */ ++#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE) ++#define CGEN_SYM(s) ubicom32##_cgen_##s ++#else ++#define CGEN_SYM(s) ubicom32/**/_cgen_/**/s ++#endif ++ ++ ++/* Selected cpu families. */ ++#define HAVE_CPU_UBICOM32BF ++ ++#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 27 ++ ++/* 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 15 ++ ++/* Enums. */ ++ ++/* Enum declaration for insn format enums. */ ++typedef enum insn_op1 { ++ OP_X0, OP_UNUSED_01, OP_X2, OP_UNUSED_03 ++ , OP_BSET, OP_BCLR, OP_DSP, OP_UNUSED_07 ++ , OP_AND_2, OP_AND_4, OP_OR_2, OP_OR_4 ++ , OP_XOR_2, OP_XOR_4, OP_ADD_2, OP_ADD_4 ++ , OP_ADDC, OP_SUB_2, OP_SUB_4, OP_SUBC ++ , OP_PXBLEND, OP_PXVI, OP_PXADDS, OP_UNUSED_17 ++ , OP_CMPI, OP_MOVEI, OP_JMP, OP_CALL ++ , OP_MOVEAI, OP_UNUSED_1D, OP_CALLI, OP_UNUSED_1F ++} INSN_OP1; ++ ++/* Enum declaration for insn x0 opcode ext enums. */ ++typedef enum insn_op2 { ++ OPX0_UNUSED_00, OPX0_SUSPEND, OPX0_UNUSED_02, OPX0_UNUSED_03 ++ , OPX0_RET, OPX0_IERASE, OPX0_IREAD, OPX0_BKPT ++ , OPX0_UNUSED_08, OPX0_UNUSED_09, OPX0_NOT_4, OPX0_NOT_2 ++ , OPX0_MOVE_4, OPX0_MOVE_2, OPX0_MOVEA, OPX0_MOVE_1 ++ , OPX0_IWRITE, OPX0_UNUSED_11, OPX0_SETCSR, OPX0_UNUSED_13 ++ , OPX0_UNUSED_14, OPX0_EXT_2, OPX0_UNUSED_16, OPX0_EXT_1 ++ , OPX0_SWAPB_2, OPX0_SWAPB_4, OPX0_PXCNV, OPX0_PXCNV_T ++ , OPX0_LEA_4, OPX0_LEA_2, OPX0_PDEC, OPX0_LEA_1 ++} INSN_OP2; ++ ++/* Enum declaration for insn x2 opcode ext enums. */ ++typedef enum insn_opext { ++ OPX2_PXHI, OPX2_MULS, OPX2_PXHI_S, OPX2_MULU ++ , OPX2_UNUSED_04, OPX2_MULF, OPX2_BTST, OPX2_UNUSED_07 ++ , OPX2_CRCGEN, OPX2_MAC, OPX2_LSL_1, OPX2_LSR_1 ++ , OPX2_ASR_1, OPX2_UNUSED_0D, OPX2_UNUSED_0E, OPX2_UNUSED_0F ++ , OPX2_LSL_4, OPX2_LSL_2, OPX2_LSR_4, OPX2_LSR_2 ++ , OPX2_ASR_4, OPX2_ASR_2, OPX2_BFEXTU, OPX2_UNUSED_17 ++ , OPX2_BFRVRS, OPX2_UNUSED_19, OPX2_SHFTD, OPX2_UNUSED_1B ++ , OPX2_MERGE, OPX2_UNUSED_1D, OPX2_SHMRG_2, OPX2_SHMRG_1 ++} INSN_OPEXT; ++ ++/* Enum declaration for insn dsp opcode ext enums. */ ++typedef enum insn_dsp_subop { ++ OPDSP_MULS, OPDSP_MACS, OPDSP_MULU, OPDSP_MACU ++ , OPDSP_MULF, OPDSP_MACF, OPDSP_UNUSED_06, OPDSP_MACUS ++ , OPDSP_MULS_4, OPDSP_MSUF, OPDSP_MULU_4, OPDSP_UNUSED_0B ++ , OPDSP_UNUSED_0C, OPDSP_UNUSED_0D, OPDSP_UNUSED_0E, OPDSP_UNUSED_0F ++ , OPDSP_MADD_4, OPDSP_MADD_2, OPDSP_MSUB_4, OPDSP_MSUB_2 ++ , OPDSP_UNUSED_14, OPDSP_UNUSED_15, OPDSP_UNUSED_16, OPDSP_UNUSED_17 ++ , OPDSP_UNUSED_18, OPDSP_UNUSED_19, OPDSP_UNUSED_1A, OPDSP_UNUSED_1B ++ , OPDSP_UNUSED_1C, OPDSP_UNUSED_1D, OPDSP_UNUSED_1E, OPDSP_UNUSED_1F ++} INSN_DSP_SUBOP; ++ ++/* Enum declaration for . */ ++typedef enum data_names { ++ H_DR_D0, H_DR_D1, H_DR_D2, H_DR_D3 ++ , H_DR_D4, H_DR_D5, H_DR_D6, H_DR_D7 ++ , H_DR_D8, H_DR_D9, H_DR_D10, H_DR_D11 ++ , H_DR_D12, H_DR_D13, H_DR_D14, H_DR_D15 ++} DATA_NAMES; ++ ++/* Enum declaration for . */ ++typedef enum addr_names { ++ H_AR_SP = 7, H_AR_A0 = 0, H_AR_A1 = 1, H_AR_A2 = 2 ++ , H_AR_A3 = 3, H_AR_A4 = 4, H_AR_A5 = 5, H_AR_A6 = 6 ++ , H_AR_A7 = 7 ++} ADDR_NAMES; ++ ++/* Enum declaration for . */ ++typedef enum acc_names { ++ ACC_LOS_ACC0, ACC_LOS_ACC1 ++} ACC_NAMES; ++ ++/* Enum declaration for . */ ++typedef enum spad_names { ++ H_SP_SCRATCHPAD0 = 0, H_SP_SCRATCHPAD1 = 0, H_SP_SCRATCHPAD2 = 0, H_SP_SCRATCHPAD3 = 0 ++} SPAD_NAMES; ++ ++/* Attributes. */ ++ ++/* Enum declaration for machine type selection. */ ++typedef enum mach_attr { ++ MACH_BASE, MACH_IP3035, MACH_UBICOM32DSP, MACH_IP3023COMPATIBILITY ++ , MACH_UBICOM32_VER4, MACH_MAX ++} MACH_ATTR; ++ ++/* Enum declaration for instruction set selection. */ ++typedef enum isa_attr { ++ ISA_UBICOM32, ISA_MAX ++} ISA_ATTR; ++ ++/* Number of architecture variants. */ ++#define MAX_ISAS 1 ++#define MAX_MACHS ((int) MACH_MAX) ++ ++/* Ifield support. */ ++ ++/* Ifield attribute indices. */ ++ ++/* Enum declaration for cgen_ifld attrs. */ ++typedef enum cgen_ifld_attr { ++ CGEN_IFLD_VIRTUAL, CGEN_IFLD_PCREL_ADDR, CGEN_IFLD_ABS_ADDR, CGEN_IFLD_RESERVED ++ , CGEN_IFLD_SIGN_OPT, CGEN_IFLD_SIGNED, CGEN_IFLD_END_BOOLS, CGEN_IFLD_START_NBOOLS = 31 ++ , CGEN_IFLD_MACH, CGEN_IFLD_END_NBOOLS ++} CGEN_IFLD_ATTR; ++ ++/* Number of non-boolean elements in cgen_ifld_attr. */ ++#define CGEN_IFLD_NBOOL_ATTRS (CGEN_IFLD_END_NBOOLS - CGEN_IFLD_START_NBOOLS - 1) ++ ++/* cgen_ifld attribute accessor macros. */ ++#define CGEN_ATTR_CGEN_IFLD_MACH_VALUE(attrs) ((attrs)->nonbool[CGEN_IFLD_MACH-CGEN_IFLD_START_NBOOLS-1].nonbitset) ++#define CGEN_ATTR_CGEN_IFLD_VIRTUAL_VALUE(attrs) (((attrs)->bool & (1 << CGEN_IFLD_VIRTUAL)) != 0) ++#define CGEN_ATTR_CGEN_IFLD_PCREL_ADDR_VALUE(attrs) (((attrs)->bool & (1 << CGEN_IFLD_PCREL_ADDR)) != 0) ++#define CGEN_ATTR_CGEN_IFLD_ABS_ADDR_VALUE(attrs) (((attrs)->bool & (1 << CGEN_IFLD_ABS_ADDR)) != 0) ++#define CGEN_ATTR_CGEN_IFLD_RESERVED_VALUE(attrs) (((attrs)->bool & (1 << CGEN_IFLD_RESERVED)) != 0) ++#define CGEN_ATTR_CGEN_IFLD_SIGN_OPT_VALUE(attrs) (((attrs)->bool & (1 << CGEN_IFLD_SIGN_OPT)) != 0) ++#define CGEN_ATTR_CGEN_IFLD_SIGNED_VALUE(attrs) (((attrs)->bool & (1 << CGEN_IFLD_SIGNED)) != 0) ++ ++/* Enum declaration for ubicom32 ifield types. */ ++typedef enum ifield_type { ++ UBICOM32_F_NIL, UBICOM32_F_ANYOF, UBICOM32_F_D, UBICOM32_F_D_BIT10 ++ , UBICOM32_F_D_TYPE, UBICOM32_F_D_R, UBICOM32_F_D_M, UBICOM32_F_D_I4_1 ++ , UBICOM32_F_D_I4_2, UBICOM32_F_D_I4_4, UBICOM32_F_D_AN, UBICOM32_F_D_DIRECT ++ , UBICOM32_F_D_IMM8, UBICOM32_F_D_IMM7_T, UBICOM32_F_D_IMM7_B, UBICOM32_F_D_IMM7_1 ++ , UBICOM32_F_D_IMM7_2, UBICOM32_F_D_IMM7_4, UBICOM32_F_S1, UBICOM32_F_S1_BIT10 ++ , UBICOM32_F_S1_TYPE, UBICOM32_F_S1_R, UBICOM32_F_S1_M, UBICOM32_F_S1_I4_1 ++ , UBICOM32_F_S1_I4_2, UBICOM32_F_S1_I4_4, UBICOM32_F_S1_AN, UBICOM32_F_S1_DIRECT ++ , UBICOM32_F_S1_IMM8, UBICOM32_F_S1_IMM7_T, UBICOM32_F_S1_IMM7_B, UBICOM32_F_S1_IMM7_1 ++ , UBICOM32_F_S1_IMM7_2, UBICOM32_F_S1_IMM7_4, UBICOM32_F_OP1, UBICOM32_F_OP2 ++ , UBICOM32_F_BIT26, UBICOM32_F_OPEXT, UBICOM32_F_COND, UBICOM32_F_IMM16_1 ++ , UBICOM32_F_IMM16_2, UBICOM32_F_O21, UBICOM32_F_O23_21, UBICOM32_F_O20_0 ++ , UBICOM32_F_O24, UBICOM32_F_IMM23_21, UBICOM32_F_IMM24, UBICOM32_F_O15_13 ++ , UBICOM32_F_O12_8, UBICOM32_F_O7_5, UBICOM32_F_O4_0, UBICOM32_F_O16 ++ , UBICOM32_F_AN, UBICOM32_F_AM, UBICOM32_F_DN, UBICOM32_F_BIT5 ++ , UBICOM32_F_P, UBICOM32_F_C, UBICOM32_F_INT, UBICOM32_F_DSP_C ++ , UBICOM32_F_DSP_T, UBICOM32_F_DSP_S2_SEL, UBICOM32_F_DSP_R, UBICOM32_F_DSP_DESTA ++ , UBICOM32_F_DSP_B15, UBICOM32_F_DSP_S2, UBICOM32_F_DSP_J, UBICOM32_F_S2 ++ , UBICOM32_F_B15, UBICOM32_F_MAX ++} IFIELD_TYPE; ++ ++#define MAX_IFLD ((int) UBICOM32_F_MAX) ++ ++/* Hardware attribute indices. */ ++ ++/* Enum declaration for cgen_hw attrs. */ ++typedef enum cgen_hw_attr { ++ CGEN_HW_VIRTUAL, CGEN_HW_CACHE_ADDR, CGEN_HW_PC, CGEN_HW_PROFILE ++ , CGEN_HW_END_BOOLS, CGEN_HW_START_NBOOLS = 31, CGEN_HW_MACH, CGEN_HW_END_NBOOLS ++} CGEN_HW_ATTR; ++ ++/* Number of non-boolean elements in cgen_hw_attr. */ ++#define CGEN_HW_NBOOL_ATTRS (CGEN_HW_END_NBOOLS - CGEN_HW_START_NBOOLS - 1) ++ ++/* cgen_hw attribute accessor macros. */ ++#define CGEN_ATTR_CGEN_HW_MACH_VALUE(attrs) ((attrs)->nonbool[CGEN_HW_MACH-CGEN_HW_START_NBOOLS-1].nonbitset) ++#define CGEN_ATTR_CGEN_HW_VIRTUAL_VALUE(attrs) (((attrs)->bool & (1 << CGEN_HW_VIRTUAL)) != 0) ++#define CGEN_ATTR_CGEN_HW_CACHE_ADDR_VALUE(attrs) (((attrs)->bool & (1 << CGEN_HW_CACHE_ADDR)) != 0) ++#define CGEN_ATTR_CGEN_HW_PC_VALUE(attrs) (((attrs)->bool & (1 << CGEN_HW_PC)) != 0) ++#define CGEN_ATTR_CGEN_HW_PROFILE_VALUE(attrs) (((attrs)->bool & (1 << CGEN_HW_PROFILE)) != 0) ++ ++/* Enum declaration for ubicom32 hardware types. */ ++typedef enum cgen_hw_type { ++ HW_H_MEMORY, HW_H_SINT, HW_H_UINT, HW_H_ADDR ++ , HW_H_IADDR, HW_H_GLOBAL_CONTROL, HW_H_MT_BREAK, HW_H_MT_ACTIVE ++ , HW_H_MT_ENABLE, HW_H_MT_PRIORITY, HW_H_MT_SCHEDULE, HW_H_IRQ_STATUS_0 ++ , HW_H_IRQ_STATUS_1, HW_H_DR, HW_H_S1_DR, HW_H_AR ++ , HW_H_AR_INC, HW_H_AR_INC_FLAG, HW_H_MAC_HI, HW_H_MAC_LO ++ , HW_H_SRC_3, HW_H_CSR, HW_H_IREAD, HW_H_ACC1_HI ++ , HW_H_ACC1_LO, HW_H_PC, HW_H_NBIT_16, HW_H_ZBIT_16 ++ , HW_H_VBIT_16, HW_H_CBIT_16, HW_H_NBIT_32, HW_H_ZBIT_32 ++ , HW_H_VBIT_32, HW_H_CBIT_32, HW_H_CC, HW_H_C ++ , HW_H_P, HW_H_DSP_C, HW_H_DSP_DEST_A, HW_H_DSP_T ++ , HW_H_DSP_T_ADDSUB, HW_H_DSP_S2_ACC_REG_MUL, HW_H_DSP_S2_ACC_REG_ADDSUB, HW_H_SP ++ , HW_MAX ++} CGEN_HW_TYPE; ++ ++#define MAX_HW ((int) HW_MAX) ++ ++/* Operand attribute indices. */ ++ ++/* Enum declaration for cgen_operand attrs. */ ++typedef enum cgen_operand_attr { ++ CGEN_OPERAND_VIRTUAL, CGEN_OPERAND_PCREL_ADDR, CGEN_OPERAND_ABS_ADDR, CGEN_OPERAND_SIGN_OPT ++ , CGEN_OPERAND_SIGNED, CGEN_OPERAND_NEGATIVE, CGEN_OPERAND_RELAX, CGEN_OPERAND_SEM_ONLY ++ , CGEN_OPERAND_END_BOOLS, CGEN_OPERAND_START_NBOOLS = 31, CGEN_OPERAND_MACH, CGEN_OPERAND_END_NBOOLS ++} CGEN_OPERAND_ATTR; ++ ++/* Number of non-boolean elements in cgen_operand_attr. */ ++#define CGEN_OPERAND_NBOOL_ATTRS (CGEN_OPERAND_END_NBOOLS - CGEN_OPERAND_START_NBOOLS - 1) ++ ++/* cgen_operand attribute accessor macros. */ ++#define CGEN_ATTR_CGEN_OPERAND_MACH_VALUE(attrs) ((attrs)->nonbool[CGEN_OPERAND_MACH-CGEN_OPERAND_START_NBOOLS-1].nonbitset) ++#define CGEN_ATTR_CGEN_OPERAND_VIRTUAL_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_VIRTUAL)) != 0) ++#define CGEN_ATTR_CGEN_OPERAND_PCREL_ADDR_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_PCREL_ADDR)) != 0) ++#define CGEN_ATTR_CGEN_OPERAND_ABS_ADDR_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_ABS_ADDR)) != 0) ++#define CGEN_ATTR_CGEN_OPERAND_SIGN_OPT_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_SIGN_OPT)) != 0) ++#define CGEN_ATTR_CGEN_OPERAND_SIGNED_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_SIGNED)) != 0) ++#define CGEN_ATTR_CGEN_OPERAND_NEGATIVE_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_NEGATIVE)) != 0) ++#define CGEN_ATTR_CGEN_OPERAND_RELAX_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_RELAX)) != 0) ++#define CGEN_ATTR_CGEN_OPERAND_SEM_ONLY_VALUE(attrs) (((attrs)->bool & (1 << CGEN_OPERAND_SEM_ONLY)) != 0) ++ ++/* Enum declaration for ubicom32 operand types. */ ++typedef enum cgen_operand_type { ++ UBICOM32_OPERAND_PC, UBICOM32_OPERAND_S2, UBICOM32_OPERAND_SRC3, UBICOM32_OPERAND_OFFSET24 ++ , UBICOM32_OPERAND_AN, UBICOM32_OPERAND_CC, UBICOM32_OPERAND_C, UBICOM32_OPERAND_P ++ , UBICOM32_OPERAND_AM, UBICOM32_OPERAND_DN, UBICOM32_OPERAND_INTERRUPT, UBICOM32_OPERAND_IMM16_1 ++ , UBICOM32_OPERAND_X_OP2, UBICOM32_OPERAND_X_BIT26, UBICOM32_OPERAND_X_S1, UBICOM32_OPERAND_X_D ++ , UBICOM32_OPERAND_X_DN, UBICOM32_OPERAND_MACHI, UBICOM32_OPERAND_MACLO, UBICOM32_OPERAND_ACC1HI ++ , UBICOM32_OPERAND_ACC1LO, UBICOM32_OPERAND_IRQ_0, UBICOM32_OPERAND_IRQ_1, UBICOM32_OPERAND_IREAD ++ , UBICOM32_OPERAND_OPC1, UBICOM32_OPERAND_OPC2, UBICOM32_OPERAND_AN_INC, UBICOM32_OPERAND_DSP_C ++ , UBICOM32_OPERAND_DSP_T, UBICOM32_OPERAND_DSP_DESTA, UBICOM32_OPERAND_DSP_S2_SEL, UBICOM32_OPERAND_DSP_S2_DATA_REG ++ , UBICOM32_OPERAND_DSP_S2_ACC_REG_MUL, UBICOM32_OPERAND_DSP_S2_ACC_REG_ADDSUB, UBICOM32_OPERAND_DSP_S2_DATA_REG_ADDSUB, UBICOM32_OPERAND_DSP_T_ADDSUB ++ , UBICOM32_OPERAND_BIT5, UBICOM32_OPERAND_BIT5_ADDSUB, UBICOM32_OPERAND_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_OPERAND_DSP_SRC2_REG_ACC_REG_ADDSUB ++ , UBICOM32_OPERAND_DSP_SRC2_DATA_REG, UBICOM32_OPERAND_DSP_SRC2_DATA_REG_ADDSUB, UBICOM32_OPERAND_DSP_SRC2_DATA_REG_ADDSUB2, UBICOM32_OPERAND_DSP_IMM_BIT5 ++ , UBICOM32_OPERAND_DSP_IMM_BIT5_ADDSUB, UBICOM32_OPERAND_DSP_IMM_BIT5_ADDSUB2, UBICOM32_OPERAND_IMM_BIT5, UBICOM32_OPERAND_DYN_REG ++ , UBICOM32_OPERAND_OP3, UBICOM32_OPERAND_DSP_SRC2_MUL, UBICOM32_OPERAND_DSP_COMPATIBILITY_SRC2_MUL, UBICOM32_OPERAND_DSP_SRC2_ADDSUB ++ , UBICOM32_OPERAND_DSP_SRC2_ADDSUB2, UBICOM32_OPERAND_OFFSET21, UBICOM32_OPERAND_OFFSET16, UBICOM32_OPERAND_IMM24 ++ , UBICOM32_OPERAND_NBIT_16, UBICOM32_OPERAND_VBIT_16, UBICOM32_OPERAND_ZBIT_16, UBICOM32_OPERAND_CBIT_16 ++ , UBICOM32_OPERAND_NBIT_32, UBICOM32_OPERAND_VBIT_32, UBICOM32_OPERAND_ZBIT_32, UBICOM32_OPERAND_CBIT_32 ++ , UBICOM32_OPERAND_S1_IMM7_1, UBICOM32_OPERAND_S1_IMM7_2, UBICOM32_OPERAND_S1_IMM7_4, UBICOM32_OPERAND_PDEC_S1_IMM7_4 ++ , UBICOM32_OPERAND_S1_IMM8, UBICOM32_OPERAND_S1_AN, UBICOM32_OPERAND_S1_R, UBICOM32_OPERAND_S1_AN_INC ++ , UBICOM32_OPERAND_S1_I4_1, UBICOM32_OPERAND_S1_I4_2, UBICOM32_OPERAND_S1_I4_4, UBICOM32_OPERAND_S1_INDIRECT_1 ++ , UBICOM32_OPERAND_S1_INDIRECT_2, UBICOM32_OPERAND_S1_INDIRECT_4, UBICOM32_OPERAND_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_OPERAND_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_OPERAND_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_OPERAND_S1_INDIRECT_WITH_INDEX_1, UBICOM32_OPERAND_S1_INDIRECT_WITH_INDEX_2, UBICOM32_OPERAND_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_OPERAND_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_OPERAND_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_OPERAND_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_OPERAND_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_OPERAND_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_OPERAND_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_OPERAND_S1_DIRECT_ADDR, UBICOM32_OPERAND_S1_DIRECT ++ , UBICOM32_OPERAND_S1_IMMEDIATE, UBICOM32_OPERAND_S1_1, UBICOM32_OPERAND_S1_2, UBICOM32_OPERAND_S1_4 ++ , UBICOM32_OPERAND_S1_EA_INDIRECT, UBICOM32_OPERAND_S1_EA_INDIRECT_WITH_OFFSET_1, UBICOM32_OPERAND_S1_EA_INDIRECT_WITH_OFFSET_2, UBICOM32_OPERAND_S1_EA_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_OPERAND_S1_EA_INDIRECT_WITH_INDEX_1, UBICOM32_OPERAND_S1_EA_INDIRECT_WITH_INDEX_2, UBICOM32_OPERAND_S1_EA_INDIRECT_WITH_INDEX_4, UBICOM32_OPERAND_S1_EA_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_OPERAND_S1_EA_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_OPERAND_S1_EA_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_OPERAND_S1_EA_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_OPERAND_S1_EA_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_OPERAND_S1_EA_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_OPERAND_S1_EA_IMMEDIATE, UBICOM32_OPERAND_S1_EA_DIRECT, UBICOM32_OPERAND_S1_EA_1 ++ , UBICOM32_OPERAND_S1_EA_2, UBICOM32_OPERAND_S1_EA_4, UBICOM32_OPERAND_S1_PEA, UBICOM32_OPERAND_PDEC_S1_EA_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_OPERAND_PDEC_PEA_S1, UBICOM32_OPERAND_D_IMM7_1, UBICOM32_OPERAND_D_IMM7_2, UBICOM32_OPERAND_D_IMM7_4 ++ , UBICOM32_OPERAND_D_IMM8, UBICOM32_OPERAND_D_AN, UBICOM32_OPERAND_D_R, UBICOM32_OPERAND_D_AN_INC ++ , UBICOM32_OPERAND_D_I4_1, UBICOM32_OPERAND_D_I4_2, UBICOM32_OPERAND_D_I4_4, UBICOM32_OPERAND_D_INDIRECT_1 ++ , UBICOM32_OPERAND_D_INDIRECT_2, UBICOM32_OPERAND_D_INDIRECT_4, UBICOM32_OPERAND_D_INDIRECT_WITH_OFFSET_1, UBICOM32_OPERAND_D_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_OPERAND_D_INDIRECT_WITH_OFFSET_4, UBICOM32_OPERAND_D_INDIRECT_WITH_INDEX_1, UBICOM32_OPERAND_D_INDIRECT_WITH_INDEX_2, UBICOM32_OPERAND_D_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_OPERAND_D_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_OPERAND_D_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_OPERAND_D_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_OPERAND_D_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_OPERAND_D_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_OPERAND_D_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_OPERAND_D_DIRECT_ADDR, UBICOM32_OPERAND_D_DIRECT ++ , UBICOM32_OPERAND_D_IMMEDIATE_1, UBICOM32_OPERAND_D_IMMEDIATE_2, UBICOM32_OPERAND_D_IMMEDIATE_4, UBICOM32_OPERAND_D_1 ++ , UBICOM32_OPERAND_D_2, UBICOM32_OPERAND_D_4, UBICOM32_OPERAND_D_PEA_INDIRECT, UBICOM32_OPERAND_D_PEA_INDIRECT_WITH_OFFSET ++ , UBICOM32_OPERAND_D_PEA_INDIRECT_WITH_POST_INCREMENT, UBICOM32_OPERAND_D_PEA_INDIRECT_WITH_PRE_INCREMENT, UBICOM32_OPERAND_D_PEA_INDIRECT_WITH_INDEX, UBICOM32_OPERAND_D_PEA ++ , UBICOM32_OPERAND_IMM16_2, UBICOM32_OPERAND_MAX ++} CGEN_OPERAND_TYPE; ++ ++/* Number of operands types. */ ++#define MAX_OPERANDS 157 ++ ++/* 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_RELAXED ++ , CGEN_INSN_NO_DIS, CGEN_INSN_PBB, CGEN_INSN_END_BOOLS, CGEN_INSN_START_NBOOLS = 31 ++ , CGEN_INSN_MACH, CGEN_INSN_END_NBOOLS ++} CGEN_INSN_ATTR; ++ ++/* Number of non-boolean elements in cgen_insn_attr. */ ++#define CGEN_INSN_NBOOL_ATTRS (CGEN_INSN_END_NBOOLS - CGEN_INSN_START_NBOOLS - 1) ++ ++/* cgen_insn attribute accessor macros. */ ++#define CGEN_ATTR_CGEN_INSN_MACH_VALUE(attrs) ((attrs)->nonbool[CGEN_INSN_MACH-CGEN_INSN_START_NBOOLS-1].nonbitset) ++#define CGEN_ATTR_CGEN_INSN_ALIAS_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_ALIAS)) != 0) ++#define CGEN_ATTR_CGEN_INSN_VIRTUAL_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_VIRTUAL)) != 0) ++#define CGEN_ATTR_CGEN_INSN_UNCOND_CTI_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_UNCOND_CTI)) != 0) ++#define CGEN_ATTR_CGEN_INSN_COND_CTI_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_COND_CTI)) != 0) ++#define CGEN_ATTR_CGEN_INSN_SKIP_CTI_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_SKIP_CTI)) != 0) ++#define CGEN_ATTR_CGEN_INSN_DELAY_SLOT_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_DELAY_SLOT)) != 0) ++#define CGEN_ATTR_CGEN_INSN_RELAXABLE_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_RELAXABLE)) != 0) ++#define CGEN_ATTR_CGEN_INSN_RELAXED_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_RELAXED)) != 0) ++#define CGEN_ATTR_CGEN_INSN_NO_DIS_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_NO_DIS)) != 0) ++#define CGEN_ATTR_CGEN_INSN_PBB_VALUE(attrs) (((attrs)->bool & (1 << CGEN_INSN_PBB)) != 0) ++ ++/* cgen.h uses things we just defined. */ ++#include "opcode/cgen.h" ++ ++extern const struct cgen_ifld ubicom32_cgen_ifld_table[]; ++ ++/* Attributes. */ ++extern const CGEN_ATTR_TABLE ubicom32_cgen_hardware_attr_table[]; ++extern const CGEN_ATTR_TABLE ubicom32_cgen_ifield_attr_table[]; ++extern const CGEN_ATTR_TABLE ubicom32_cgen_operand_attr_table[]; ++extern const CGEN_ATTR_TABLE ubicom32_cgen_insn_attr_table[]; ++ ++/* Hardware decls. */ ++ ++extern CGEN_KEYWORD ubicom32_cgen_opval_data_names; ++extern CGEN_KEYWORD ubicom32_cgen_opval_data_names; ++extern CGEN_KEYWORD ubicom32_cgen_opval_addr_names; ++extern CGEN_KEYWORD ubicom32_cgen_opval_h_cc; ++extern CGEN_KEYWORD ubicom32_cgen_opval_h_C; ++extern CGEN_KEYWORD ubicom32_cgen_opval_h_P; ++extern CGEN_KEYWORD ubicom32_cgen_opval_h_DSP_C; ++extern CGEN_KEYWORD ubicom32_cgen_opval_h_DSP_Dest_A; ++extern CGEN_KEYWORD ubicom32_cgen_opval_h_DSP_T; ++extern CGEN_KEYWORD ubicom32_cgen_opval_h_DSP_T_addsub; ++extern CGEN_KEYWORD ubicom32_cgen_opval_acc_names; ++extern CGEN_KEYWORD ubicom32_cgen_opval_acc_names; ++extern CGEN_KEYWORD ubicom32_cgen_opval_spad_names; ++ ++extern const CGEN_HW_ENTRY ubicom32_cgen_hw_table[]; ++ ++ ++ ++#endif /* UBICOM32_CPU_H */ +--- /dev/null ++++ b/opcodes/ubicom32-dis.c +@@ -0,0 +1,809 @@ ++/* 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, 2002, 2003, 2005, 2007 ++ Free Software Foundation, Inc. ++ ++ This file is part of libopcodes. ++ ++ This library is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3, or (at your option) ++ any later version. ++ ++ It is distributed in the hope that it will be useful, but WITHOUT ++ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY ++ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public ++ License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ ++ ++/* ??? Eventually more and more of this stuff can go to cpu-independent files. ++ Keep that in mind. */ ++ ++#include "sysdep.h" ++#include ++#include "ansidecl.h" ++#include "dis-asm.h" ++#include "bfd.h" ++#include "symcat.h" ++#include "libiberty.h" ++#include "ubicom32-desc.h" ++#include "ubicom32-opc.h" ++#include "opintl.h" ++ ++/* Default text to print if an instruction isn't recognized. */ ++#define UNKNOWN_INSN_MSG _("*unknown*") ++ ++static void print_normal ++ (CGEN_CPU_DESC, void *, long, unsigned int, bfd_vma, int); ++static void print_address ++ (CGEN_CPU_DESC, void *, bfd_vma, unsigned int, bfd_vma, int) ATTRIBUTE_UNUSED; ++static void print_keyword ++ (CGEN_CPU_DESC, void *, CGEN_KEYWORD *, long, unsigned int) ATTRIBUTE_UNUSED; ++static void print_insn_normal ++ (CGEN_CPU_DESC, void *, const CGEN_INSN *, CGEN_FIELDS *, bfd_vma, int); ++static int print_insn ++ (CGEN_CPU_DESC, bfd_vma, disassemble_info *, bfd_byte *, unsigned); ++static int default_print_insn ++ (CGEN_CPU_DESC, bfd_vma, disassemble_info *) ATTRIBUTE_UNUSED; ++static int read_insn ++ (CGEN_CPU_DESC, bfd_vma, disassemble_info *, bfd_byte *, int, CGEN_EXTRACT_INFO *, ++ unsigned long *); ++ ++/* -- disassembler routines inserted here. */ ++ ++/* -- dis.c */ ++ ++/* Output a signed 4 bit integer */ ++static void ++print_imm4 (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; ++ (*info->fprintf_func) (info->stream, "%d", (int)value); ++} ++ ++/* Output an unsigned 7-bit integer */ ++static void ++print_imm7 (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 != 0) ++ (*info->fprintf_func) (info->stream, "%ld", value); ++} ++ ++/* Output an unsigned 7-bit integer */ ++static void ++print_pdec_imm7 (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 != 0) ++ { ++ value = ~value; ++ value ++; ++ value &= 0x1fc; ++ (*info->fprintf_func) (info->stream, "%ld", value); ++ } ++ else ++ { ++ (*info->fprintf_func) (info->stream, "%d", 512); ++ } ++} ++ ++/* Output either a register or a 11bit literal immediate value */ ++static void ++print_direct_addr (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; ++ struct ubicom32_cgen_data_space_map *cur; ++ ++ if(cd->machs & (1< 0x3ff) ++ /* XXX: some warning? */ ; ++ value &= 0x3ff; ++ for (; cur->name; cur++) ++ if (value == cur->address) ++ { ++ (*info->fprintf_func) (info->stream, "%s", cur->name); ++ return; ++ } ++ (*info->fprintf_func) (info->stream, "#%lx", value); ++} ++ ++static void ++print_imm24 (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; ++ (*info->fprintf_func) (info->stream, "%%hi(0x%08lx)", value << 7); ++} ++ ++/* -- */ ++ ++void ubicom32_cgen_print_operand ++ (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 ++ubicom32_cgen_print_operand (CGEN_CPU_DESC cd, ++ int opindex, ++ void * xinfo, ++ CGEN_FIELDS *fields, ++ void const *attrs ATTRIBUTE_UNUSED, ++ bfd_vma pc, ++ int length) ++{ ++ disassemble_info *info = (disassemble_info *) xinfo; ++ ++ switch (opindex) ++ { ++ case UBICOM32_OPERAND_AM : ++ print_keyword (cd, info, & ubicom32_cgen_opval_addr_names, fields->f_Am, 0); ++ break; ++ case UBICOM32_OPERAND_AN : ++ print_keyword (cd, info, & ubicom32_cgen_opval_addr_names, fields->f_An, 0); ++ break; ++ case UBICOM32_OPERAND_C : ++ print_keyword (cd, info, & ubicom32_cgen_opval_h_C, fields->f_C, 0); ++ break; ++ case UBICOM32_OPERAND_DN : ++ print_keyword (cd, info, & ubicom32_cgen_opval_data_names, fields->f_Dn, 0); ++ break; ++ case UBICOM32_OPERAND_P : ++ print_keyword (cd, info, & ubicom32_cgen_opval_h_P, fields->f_P, 0); ++ break; ++ case UBICOM32_OPERAND_ACC1HI : ++ print_normal (cd, info, 0, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_ACC1LO : ++ print_normal (cd, info, 0, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_BIT5 : ++ print_normal (cd, info, fields->f_bit5, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_BIT5_ADDSUB : ++ print_normal (cd, info, fields->f_bit5, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_CC : ++ print_keyword (cd, info, & ubicom32_cgen_opval_h_cc, fields->f_cond, 0); ++ break; ++ case UBICOM32_OPERAND_D_AN : ++ print_keyword (cd, info, & ubicom32_cgen_opval_addr_names, fields->f_d_An, 0); ++ break; ++ case UBICOM32_OPERAND_D_DIRECT_ADDR : ++ print_direct_addr (cd, info, fields->f_d_direct, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_D_I4_1 : ++ print_imm4 (cd, info, fields->f_d_i4_1, 0|(1<f_d_i4_2, 0|(1<f_d_i4_4, 0|(1<f_d_imm7_1, 0|(1<f_d_imm7_2, 0|(1<f_d_imm7_4, 0|(1<f_d_imm8, 0|(1<f_d_r, 0); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_ADDSUB : ++ print_keyword (cd, info, & ubicom32_cgen_opval_acc_names, fields->f_dsp_S2, 0); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_MUL : ++ print_keyword (cd, info, & ubicom32_cgen_opval_acc_names, fields->f_dsp_S2, 0); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG : ++ print_keyword (cd, info, & ubicom32_cgen_opval_data_names, fields->f_dsp_S2, 0); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG_ADDSUB : ++ print_keyword (cd, info, & ubicom32_cgen_opval_data_names, fields->f_dsp_S2, 0); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_SEL : ++ print_normal (cd, info, fields->f_dsp_S2_sel, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_DSP_C : ++ print_keyword (cd, info, & ubicom32_cgen_opval_h_DSP_C, fields->f_dsp_C, 0); ++ break; ++ case UBICOM32_OPERAND_DSP_DESTA : ++ print_keyword (cd, info, & ubicom32_cgen_opval_h_DSP_Dest_A, fields->f_dsp_destA, 0); ++ break; ++ case UBICOM32_OPERAND_DSP_T : ++ print_keyword (cd, info, & ubicom32_cgen_opval_h_DSP_T, fields->f_dsp_T, 0); ++ break; ++ case UBICOM32_OPERAND_DSP_T_ADDSUB : ++ print_keyword (cd, info, & ubicom32_cgen_opval_h_DSP_T_addsub, fields->f_dsp_T, 0); ++ break; ++ case UBICOM32_OPERAND_IMM16_1 : ++ print_normal (cd, info, fields->f_imm16_1, 0|(1<f_imm16_2, 0|(1<f_imm24, 0|(1<f_int, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_IREAD : ++ print_normal (cd, info, 0, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_IRQ_0 : ++ print_normal (cd, info, 0, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_IRQ_1 : ++ print_normal (cd, info, 0, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_MACHI : ++ print_normal (cd, info, 0, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_MACLO : ++ print_normal (cd, info, 0, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_OFFSET16 : ++ print_normal (cd, info, fields->f_o16, 0|(1<f_o21, 0|(1<f_o24, 0|(1<f_op1, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_OPC2 : ++ print_normal (cd, info, fields->f_op2, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_PDEC_S1_IMM7_4 : ++ print_pdec_imm7 (cd, info, fields->f_s1_imm7_4, 0|(1<f_s1_An, 0); ++ break; ++ case UBICOM32_OPERAND_S1_DIRECT_ADDR : ++ print_direct_addr (cd, info, fields->f_s1_direct, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_S1_I4_1 : ++ print_imm4 (cd, info, fields->f_s1_i4_1, 0|(1<f_s1_i4_2, 0|(1<f_s1_i4_4, 0|(1<f_s1_imm7_1, 0|(1<f_s1_imm7_2, 0|(1<f_s1_imm7_4, 0|(1<f_s1_imm8, 0|(1<f_s1_r, 0); ++ break; ++ case UBICOM32_OPERAND_S2 : ++ print_keyword (cd, info, & ubicom32_cgen_opval_data_names, fields->f_s2, 0); ++ break; ++ case UBICOM32_OPERAND_SRC3 : ++ print_normal (cd, info, 0, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_X_BIT26 : ++ print_normal (cd, info, fields->f_bit26, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_X_D : ++ print_normal (cd, info, fields->f_d, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_X_DN : ++ print_normal (cd, info, fields->f_Dn, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_X_OP2 : ++ print_normal (cd, info, fields->f_op2, 0, pc, length); ++ break; ++ case UBICOM32_OPERAND_X_S1 : ++ print_normal (cd, info, fields->f_s1, 0, pc, length); ++ break; ++ ++ default : ++ /* xgettext:c-format */ ++ fprintf (stderr, _("Unrecognized field %d while printing insn.\n"), ++ opindex); ++ abort (); ++ } ++} ++ ++cgen_print_fn * const ubicom32_cgen_print_handlers[] = ++{ ++ print_insn_normal, ++}; ++ ++ ++void ++ubicom32_cgen_init_dis (CGEN_CPU_DESC cd) ++{ ++ ubicom32_cgen_init_opcode_table (cd); ++ ubicom32_cgen_init_ibld_table (cd); ++ cd->print_handlers = & ubicom32_cgen_print_handlers[0]; ++ cd->print_operand = ubicom32_cgen_print_operand; ++} ++ ++ ++/* Default print handler. */ ++ ++static void ++print_normal (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ void *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 (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ void *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 (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ void *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 `void *' so the disassembler needn't know anything ++ about disassemble_info. */ ++ ++static void ++print_insn_normal (CGEN_CPU_DESC cd, ++ void *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. */ ++ ubicom32_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 (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ bfd_vma pc, ++ disassemble_info *info, ++ bfd_byte *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 (CGEN_CPU_DESC cd, ++ bfd_vma pc, ++ disassemble_info *info, ++ bfd_byte *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, (char *) 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 (! ubicom32_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 (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info) ++{ ++ bfd_byte 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; ++ CGEN_BITSET *isa; ++ int mach; ++ int endian; ++ CGEN_CPU_DESC cd; ++} cpu_desc_list; ++ ++int ++print_insn_ubicom32 (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 CGEN_BITSET *prev_isa; ++ static int prev_mach; ++ static int prev_endian; ++ int length; ++ CGEN_BITSET *isa; ++ int 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_ubicom32 ++#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 ++ { ++ static CGEN_BITSET *permanent_isa; ++ ++ if (!permanent_isa) ++ permanent_isa = cgen_bitset_create (MAX_ISAS); ++ isa = permanent_isa; ++ cgen_bitset_clear (isa); ++ cgen_bitset_add (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 ++ && (cgen_bitset_compare (isa, prev_isa) != 0 ++ || mach != prev_mach ++ || endian != prev_endian)) ++ { ++ cd = 0; ++ for (cl = cd_list; cl; cl = cl->next) ++ { ++ if (cgen_bitset_compare (cl->isa, isa) == 0 && ++ cl->mach == mach && ++ cl->endian == endian) ++ { ++ cd = cl->cd; ++ prev_isa = cd->isas; ++ 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 = cgen_bitset_copy (isa); ++ prev_mach = mach; ++ prev_endian = endian; ++ cd = ubicom32_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 = prev_isa; ++ cl->mach = mach; ++ cl->endian = endian; ++ cl->next = cd_list; ++ cd_list = cl; ++ ++ ubicom32_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; ++} +--- /dev/null ++++ b/opcodes/ubicom32-ibld.c +@@ -0,0 +1,2072 @@ ++/* Instruction building/extraction support for ubicom32. -*- C -*- ++ ++ THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator. ++ - the resultant file is machine generated, cgen-ibld.in isn't ++ ++ Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2005, 2006, 2007 ++ Free Software Foundation, Inc. ++ ++ This file is part of libopcodes. ++ ++ This library is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3, or (at your option) ++ any later version. ++ ++ It is distributed in the hope that it will be useful, but WITHOUT ++ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY ++ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public ++ License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ ++ ++/* ??? Eventually more and more of this stuff can go to cpu-independent files. ++ Keep that in mind. */ ++ ++#include "sysdep.h" ++#include ++#include "ansidecl.h" ++#include "dis-asm.h" ++#include "bfd.h" ++#include "symcat.h" ++#include "ubicom32-desc.h" ++#include "ubicom32-opc.h" ++#include "opintl.h" ++#include "safe-ctype.h" ++ ++#undef min ++#define min(a,b) ((a) < (b) ? (a) : (b)) ++#undef max ++#define max(a,b) ((a) > (b) ? (a) : (b)) ++ ++/* Used by the ifield rtx function. */ ++#define FLD(f) (fields->f) ++ ++static const char * insert_normal ++ (CGEN_CPU_DESC, long, unsigned int, unsigned int, unsigned int, ++ unsigned int, unsigned int, unsigned int, CGEN_INSN_BYTES_PTR); ++static const char * insert_insn_normal ++ (CGEN_CPU_DESC, const CGEN_INSN *, ++ CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma); ++static int extract_normal ++ (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, ++ unsigned int, unsigned int, unsigned int, unsigned int, ++ unsigned int, unsigned int, bfd_vma, long *); ++static int extract_insn_normal ++ (CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *, ++ CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma); ++#if CGEN_INT_INSN_P ++static void put_insn_int_value ++ (CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT); ++#endif ++#if ! CGEN_INT_INSN_P ++static CGEN_INLINE void insert_1 ++ (CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *); ++static CGEN_INLINE int fill_cache ++ (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, bfd_vma); ++static CGEN_INLINE long extract_1 ++ (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int, unsigned char *, bfd_vma); ++#endif ++ ++/* Operand insertion. */ ++ ++#if ! CGEN_INT_INSN_P ++ ++/* Subroutine of insert_normal. */ ++ ++static CGEN_INLINE void ++insert_1 (CGEN_CPU_DESC cd, ++ unsigned long value, ++ int start, ++ int length, ++ int word_length, ++ unsigned char *bufp) ++{ ++ unsigned long x,mask; ++ int shift; ++ ++ x = cgen_get_insn_value (cd, bufp, word_length); ++ ++ /* Written this way to avoid undefined behaviour. */ ++ mask = (((1L << (length - 1)) - 1) << 1) | 1; ++ if (CGEN_INSN_LSB0_P) ++ shift = (start + 1) - length; ++ else ++ shift = (word_length - (start + length)); ++ x = (x & ~(mask << shift)) | ((value & mask) << shift); ++ ++ cgen_put_insn_value (cd, bufp, word_length, (bfd_vma) x); ++} ++ ++#endif /* ! CGEN_INT_INSN_P */ ++ ++/* Default insertion routine. ++ ++ ATTRS is a mask of the boolean attributes. ++ WORD_OFFSET is the offset in bits from the start of the insn of the value. ++ WORD_LENGTH is the length of the word in bits in which the value resides. ++ START is the starting bit number in the word, architecture origin. ++ LENGTH is the length of VALUE in bits. ++ TOTAL_LENGTH is the total length of the insn in bits. ++ ++ The result is an error message or NULL if success. */ ++ ++/* ??? This duplicates functionality with bfd's howto table and ++ bfd_install_relocation. */ ++/* ??? This doesn't handle bfd_vma's. Create another function when ++ necessary. */ ++ ++static const char * ++insert_normal (CGEN_CPU_DESC cd, ++ long value, ++ unsigned int attrs, ++ unsigned int word_offset, ++ unsigned int start, ++ unsigned int length, ++ unsigned int word_length, ++ unsigned int total_length, ++ CGEN_INSN_BYTES_PTR buffer) ++{ ++ static char errbuf[100]; ++ /* Written this way to avoid undefined behaviour. */ ++ unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1; ++ ++ /* If LENGTH is zero, this operand doesn't contribute to the value. */ ++ if (length == 0) ++ return NULL; ++ ++ if (word_length > 32) ++ abort (); ++ ++ /* For architectures with insns smaller than the base-insn-bitsize, ++ word_length may be too big. */ ++ if (cd->min_insn_bitsize < cd->base_insn_bitsize) ++ { ++ if (word_offset == 0 ++ && word_length > total_length) ++ word_length = total_length; ++ } ++ ++ /* Ensure VALUE will fit. */ ++ if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT)) ++ { ++ long minval = - (1L << (length - 1)); ++ unsigned long maxval = mask; ++ ++ if ((value > 0 && (unsigned long) value > maxval) ++ || value < minval) ++ { ++ /* xgettext:c-format */ ++ sprintf (errbuf, ++ _("operand out of range (%ld not between %ld and %lu)"), ++ value, minval, maxval); ++ return errbuf; ++ } ++ } ++ else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)) ++ { ++ unsigned long maxval = mask; ++ unsigned long val = (unsigned long) value; ++ ++ /* For hosts with a word size > 32 check to see if value has been sign ++ extended beyond 32 bits. If so then ignore these higher sign bits ++ as the user is attempting to store a 32-bit signed value into an ++ unsigned 32-bit field which is allowed. */ ++ if (sizeof (unsigned long) > 4 && ((value >> 32) == -1)) ++ val &= 0xFFFFFFFF; ++ ++ if (val > maxval) ++ { ++ /* xgettext:c-format */ ++ sprintf (errbuf, ++ _("operand out of range (0x%lx not between 0 and 0x%lx)"), ++ val, maxval); ++ return errbuf; ++ } ++ } ++ else ++ { ++ if (! cgen_signed_overflow_ok_p (cd)) ++ { ++ long minval = - (1L << (length - 1)); ++ long maxval = (1L << (length - 1)) - 1; ++ ++ if (value < minval || value > maxval) ++ { ++ sprintf ++ /* xgettext:c-format */ ++ (errbuf, _("operand out of range (%ld not between %ld and %ld)"), ++ value, minval, maxval); ++ return errbuf; ++ } ++ } ++ } ++ ++#if CGEN_INT_INSN_P ++ ++ { ++ int shift; ++ ++ if (CGEN_INSN_LSB0_P) ++ shift = (word_offset + start + 1) - length; ++ else ++ shift = total_length - (word_offset + start + length); ++ *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift); ++ } ++ ++#else /* ! CGEN_INT_INSN_P */ ++ ++ { ++ unsigned char *bufp = (unsigned char *) buffer + word_offset / 8; ++ ++ insert_1 (cd, value, start, length, word_length, bufp); ++ } ++ ++#endif /* ! CGEN_INT_INSN_P */ ++ ++ return NULL; ++} ++ ++/* Default insn builder (insert handler). ++ The instruction is recorded in CGEN_INT_INSN_P byte order (meaning ++ that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is ++ recorded in host byte order, otherwise BUFFER is an array of bytes ++ and the value is recorded in target byte order). ++ The result is an error message or NULL if success. */ ++ ++static const char * ++insert_insn_normal (CGEN_CPU_DESC cd, ++ const CGEN_INSN * insn, ++ CGEN_FIELDS * fields, ++ CGEN_INSN_BYTES_PTR buffer, ++ bfd_vma pc) ++{ ++ const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn); ++ unsigned long value; ++ const CGEN_SYNTAX_CHAR_TYPE * syn; ++ ++ CGEN_INIT_INSERT (cd); ++ value = CGEN_INSN_BASE_VALUE (insn); ++ ++ /* If we're recording insns as numbers (rather than a string of bytes), ++ target byte order handling is deferred until later. */ ++ ++#if CGEN_INT_INSN_P ++ ++ put_insn_int_value (cd, buffer, cd->base_insn_bitsize, ++ CGEN_FIELDS_BITSIZE (fields), value); ++ ++#else ++ ++ cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize, ++ (unsigned) CGEN_FIELDS_BITSIZE (fields)), ++ value); ++ ++#endif /* ! CGEN_INT_INSN_P */ ++ ++ /* ??? It would be better to scan the format's fields. ++ Still need to be able to insert a value based on the operand though; ++ e.g. storing a branch displacement that got resolved later. ++ Needs more thought first. */ ++ ++ for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn) ++ { ++ const char *errmsg; ++ ++ if (CGEN_SYNTAX_CHAR_P (* syn)) ++ continue; ++ ++ errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn), ++ fields, buffer, pc); ++ if (errmsg) ++ return errmsg; ++ } ++ ++ return NULL; ++} ++ ++#if CGEN_INT_INSN_P ++/* Cover function to store an insn value into an integral insn. Must go here ++ because it needs -desc.h for CGEN_INT_INSN_P. */ ++ ++static void ++put_insn_int_value (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ CGEN_INSN_BYTES_PTR buf, ++ int length, ++ int insn_length, ++ CGEN_INSN_INT value) ++{ ++ /* For architectures with insns smaller than the base-insn-bitsize, ++ length may be too big. */ ++ if (length > insn_length) ++ *buf = value; ++ else ++ { ++ int shift = insn_length - length; ++ /* Written this way to avoid undefined behaviour. */ ++ CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1; ++ ++ *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift); ++ } ++} ++#endif ++ ++/* Operand extraction. */ ++ ++#if ! CGEN_INT_INSN_P ++ ++/* Subroutine of extract_normal. ++ Ensure sufficient bytes are cached in EX_INFO. ++ OFFSET is the offset in bytes from the start of the insn of the value. ++ BYTES is the length of the needed value. ++ Returns 1 for success, 0 for failure. */ ++ ++static CGEN_INLINE int ++fill_cache (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ CGEN_EXTRACT_INFO *ex_info, ++ int offset, ++ int bytes, ++ bfd_vma pc) ++{ ++ /* It's doubtful that the middle part has already been fetched so ++ we don't optimize that case. kiss. */ ++ unsigned int mask; ++ disassemble_info *info = (disassemble_info *) ex_info->dis_info; ++ ++ /* First do a quick check. */ ++ mask = (1 << bytes) - 1; ++ if (((ex_info->valid >> offset) & mask) == mask) ++ return 1; ++ ++ /* Search for the first byte we need to read. */ ++ for (mask = 1 << offset; bytes > 0; --bytes, ++offset, mask <<= 1) ++ if (! (mask & ex_info->valid)) ++ break; ++ ++ if (bytes) ++ { ++ int status; ++ ++ pc += offset; ++ status = (*info->read_memory_func) ++ (pc, ex_info->insn_bytes + offset, bytes, info); ++ ++ if (status != 0) ++ { ++ (*info->memory_error_func) (status, pc, info); ++ return 0; ++ } ++ ++ ex_info->valid |= ((1 << bytes) - 1) << offset; ++ } ++ ++ return 1; ++} ++ ++/* Subroutine of extract_normal. */ ++ ++static CGEN_INLINE long ++extract_1 (CGEN_CPU_DESC cd, ++ CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED, ++ int start, ++ int length, ++ int word_length, ++ unsigned char *bufp, ++ bfd_vma pc ATTRIBUTE_UNUSED) ++{ ++ unsigned long x; ++ int shift; ++ ++ x = cgen_get_insn_value (cd, bufp, word_length); ++ ++ if (CGEN_INSN_LSB0_P) ++ shift = (start + 1) - length; ++ else ++ shift = (word_length - (start + length)); ++ return x >> shift; ++} ++ ++#endif /* ! CGEN_INT_INSN_P */ ++ ++/* Default extraction routine. ++ ++ INSN_VALUE is the first base_insn_bitsize bits of the insn in host order, ++ or sometimes less for cases like the m32r where the base insn size is 32 ++ but some insns are 16 bits. ++ ATTRS is a mask of the boolean attributes. We only need `SIGNED', ++ but for generality we take a bitmask of all of them. ++ WORD_OFFSET is the offset in bits from the start of the insn of the value. ++ WORD_LENGTH is the length of the word in bits in which the value resides. ++ START is the starting bit number in the word, architecture origin. ++ LENGTH is the length of VALUE in bits. ++ TOTAL_LENGTH is the total length of the insn in bits. ++ ++ Returns 1 for success, 0 for failure. */ ++ ++/* ??? The return code isn't properly used. wip. */ ++ ++/* ??? This doesn't handle bfd_vma's. Create another function when ++ necessary. */ ++ ++static int ++extract_normal (CGEN_CPU_DESC cd, ++#if ! CGEN_INT_INSN_P ++ CGEN_EXTRACT_INFO *ex_info, ++#else ++ CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED, ++#endif ++ CGEN_INSN_INT insn_value, ++ unsigned int attrs, ++ unsigned int word_offset, ++ unsigned int start, ++ unsigned int length, ++ unsigned int word_length, ++ unsigned int total_length, ++#if ! CGEN_INT_INSN_P ++ bfd_vma pc, ++#else ++ bfd_vma pc ATTRIBUTE_UNUSED, ++#endif ++ long *valuep) ++{ ++ long value, mask; ++ ++ /* If LENGTH is zero, this operand doesn't contribute to the value ++ so give it a standard value of zero. */ ++ if (length == 0) ++ { ++ *valuep = 0; ++ return 1; ++ } ++ ++ if (word_length > 32) ++ abort (); ++ ++ /* For architectures with insns smaller than the insn-base-bitsize, ++ word_length may be too big. */ ++ if (cd->min_insn_bitsize < cd->base_insn_bitsize) ++ { ++ if (word_offset + word_length > total_length) ++ word_length = total_length - word_offset; ++ } ++ ++ /* Does the value reside in INSN_VALUE, and at the right alignment? */ ++ ++ if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length)) ++ { ++ if (CGEN_INSN_LSB0_P) ++ value = insn_value >> ((word_offset + start + 1) - length); ++ else ++ value = insn_value >> (total_length - ( word_offset + start + length)); ++ } ++ ++#if ! CGEN_INT_INSN_P ++ ++ else ++ { ++ unsigned char *bufp = ex_info->insn_bytes + word_offset / 8; ++ ++ if (word_length > 32) ++ abort (); ++ ++ if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0) ++ return 0; ++ ++ value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc); ++ } ++ ++#endif /* ! CGEN_INT_INSN_P */ ++ ++ /* Written this way to avoid undefined behaviour. */ ++ mask = (((1L << (length - 1)) - 1) << 1) | 1; ++ ++ value &= mask; ++ /* sign extend? */ ++ if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED) ++ && (value & (1L << (length - 1)))) ++ value |= ~mask; ++ ++ *valuep = value; ++ ++ return 1; ++} ++ ++/* Default insn extractor. ++ ++ INSN_VALUE is the first base_insn_bitsize bits, translated to host order. ++ The extracted fields are stored in FIELDS. ++ EX_INFO is used to handle reading variable length insns. ++ Return the length of the insn in bits, or 0 if no match, ++ or -1 if an error occurs fetching data (memory_error_func will have ++ been called). */ ++ ++static int ++extract_insn_normal (CGEN_CPU_DESC cd, ++ const CGEN_INSN *insn, ++ CGEN_EXTRACT_INFO *ex_info, ++ CGEN_INSN_INT insn_value, ++ CGEN_FIELDS *fields, ++ bfd_vma pc) ++{ ++ const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn); ++ const CGEN_SYNTAX_CHAR_TYPE *syn; ++ ++ CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn); ++ ++ CGEN_INIT_EXTRACT (cd); ++ ++ for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn) ++ { ++ int length; ++ ++ if (CGEN_SYNTAX_CHAR_P (*syn)) ++ continue; ++ ++ length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn), ++ ex_info, insn_value, fields, pc); ++ if (length <= 0) ++ return length; ++ } ++ ++ /* We recognized and successfully extracted this insn. */ ++ return CGEN_INSN_BITSIZE (insn); ++} ++ ++/* Machine generated code added here. */ ++ ++const char * ubicom32_cgen_insert_operand ++ (CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma); ++ ++/* Main entry point for operand insertion. ++ ++ This function is basically just a big switch statement. Earlier versions ++ used tables to look up the function to use, but ++ - if the table contains both assembler and disassembler functions then ++ the disassembler contains much of the assembler and vice-versa, ++ - there's a lot of inlining possibilities as things grow, ++ - using a switch statement avoids the function call overhead. ++ ++ This function could be moved into `parse_insn_normal', but keeping it ++ separate makes clear the interface between `parse_insn_normal' and each of ++ the handlers. It's also needed by GAS to insert operands that couldn't be ++ resolved during parsing. */ ++ ++const char * ++ubicom32_cgen_insert_operand (CGEN_CPU_DESC cd, ++ int opindex, ++ CGEN_FIELDS * fields, ++ CGEN_INSN_BYTES_PTR buffer, ++ bfd_vma pc ATTRIBUTE_UNUSED) ++{ ++ const char * errmsg = NULL; ++ unsigned int total_length = CGEN_FIELDS_BITSIZE (fields); ++ ++ switch (opindex) ++ { ++ case UBICOM32_OPERAND_AM : ++ errmsg = insert_normal (cd, fields->f_Am, 0, 0, 7, 3, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_AN : ++ errmsg = insert_normal (cd, fields->f_An, 0, 0, 23, 3, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_C : ++ errmsg = insert_normal (cd, fields->f_C, 0, 0, 21, 1, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_DN : ++ errmsg = insert_normal (cd, fields->f_Dn, 0, 0, 20, 5, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_P : ++ errmsg = insert_normal (cd, fields->f_P, 0, 0, 22, 1, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_ACC1HI : ++ break; ++ case UBICOM32_OPERAND_ACC1LO : ++ break; ++ case UBICOM32_OPERAND_BIT5 : ++ errmsg = insert_normal (cd, fields->f_bit5, 0, 0, 15, 5, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_BIT5_ADDSUB : ++ errmsg = insert_normal (cd, fields->f_bit5, 0, 0, 15, 5, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_CC : ++ errmsg = insert_normal (cd, fields->f_cond, 0, 0, 26, 4, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_D_AN : ++ errmsg = insert_normal (cd, fields->f_d_An, 0, 0, 23, 3, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_D_DIRECT_ADDR : ++ { ++ long value = fields->f_d_direct; ++ value = ((unsigned int) (value) >> (2)); ++ errmsg = insert_normal (cd, value, 0, 0, 23, 8, 32, total_length, buffer); ++ } ++ break; ++ case UBICOM32_OPERAND_D_I4_1 : ++ errmsg = insert_normal (cd, fields->f_d_i4_1, 0|(1<f_d_i4_2; ++ value = ((unsigned int) (value) >> (1)); ++ errmsg = insert_normal (cd, value, 0|(1<f_d_i4_4; ++ value = ((unsigned int) (value) >> (2)); ++ errmsg = insert_normal (cd, value, 0|(1<> (5))) & (3)); ++ FLD (f_d_imm7_b) = ((((unsigned int) (FLD (f_d_imm7_1)) >> (0))) & (31)); ++} ++ errmsg = insert_normal (cd, fields->f_d_imm7_t, 0, 0, 25, 2, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ errmsg = insert_normal (cd, fields->f_d_imm7_b, 0, 0, 20, 5, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ } ++ break; ++ case UBICOM32_OPERAND_D_IMM7_2 : ++ { ++{ ++ FLD (f_d_imm7_t) = ((((unsigned int) (FLD (f_d_imm7_2)) >> (6))) & (3)); ++ FLD (f_d_imm7_b) = ((((unsigned int) (FLD (f_d_imm7_2)) >> (1))) & (31)); ++} ++ errmsg = insert_normal (cd, fields->f_d_imm7_t, 0, 0, 25, 2, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ errmsg = insert_normal (cd, fields->f_d_imm7_b, 0, 0, 20, 5, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ } ++ break; ++ case UBICOM32_OPERAND_D_IMM7_4 : ++ { ++{ ++ FLD (f_d_imm7_t) = ((((unsigned int) (FLD (f_d_imm7_4)) >> (7))) & (3)); ++ FLD (f_d_imm7_b) = ((((unsigned int) (FLD (f_d_imm7_4)) >> (2))) & (31)); ++} ++ errmsg = insert_normal (cd, fields->f_d_imm7_t, 0, 0, 25, 2, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ errmsg = insert_normal (cd, fields->f_d_imm7_b, 0, 0, 20, 5, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ } ++ break; ++ case UBICOM32_OPERAND_D_IMM8 : ++ errmsg = insert_normal (cd, fields->f_d_imm8, 0|(1<f_d_r, 0, 0, 20, 5, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_ADDSUB : ++ errmsg = insert_normal (cd, fields->f_dsp_S2, 0, 0, 14, 4, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_MUL : ++ errmsg = insert_normal (cd, fields->f_dsp_S2, 0, 0, 14, 4, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG : ++ errmsg = insert_normal (cd, fields->f_dsp_S2, 0, 0, 14, 4, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG_ADDSUB : ++ errmsg = insert_normal (cd, fields->f_dsp_S2, 0, 0, 14, 4, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_SEL : ++ errmsg = insert_normal (cd, fields->f_dsp_S2_sel, 0, 0, 18, 1, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_DSP_C : ++ errmsg = insert_normal (cd, fields->f_dsp_C, 0, 0, 20, 1, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_DSP_DESTA : ++ errmsg = insert_normal (cd, fields->f_dsp_destA, 0, 0, 16, 1, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_DSP_T : ++ errmsg = insert_normal (cd, fields->f_dsp_T, 0, 0, 19, 1, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_DSP_T_ADDSUB : ++ errmsg = insert_normal (cd, fields->f_dsp_T, 0, 0, 19, 1, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_IMM16_1 : ++ errmsg = insert_normal (cd, fields->f_imm16_1, 0|(1<f_imm16_2, 0|(1<> (21))) & (7)); ++ FLD (f_o20_0) = ((FLD (f_imm24)) & (2097151)); ++} ++ errmsg = insert_normal (cd, fields->f_imm23_21, 0, 0, 26, 3, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ errmsg = insert_normal (cd, fields->f_o20_0, 0, 0, 20, 21, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ } ++ break; ++ case UBICOM32_OPERAND_INTERRUPT : ++ errmsg = insert_normal (cd, fields->f_int, 0, 0, 5, 6, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_IREAD : ++ break; ++ case UBICOM32_OPERAND_IRQ_0 : ++ break; ++ case UBICOM32_OPERAND_IRQ_1 : ++ break; ++ case UBICOM32_OPERAND_MACHI : ++ break; ++ case UBICOM32_OPERAND_MACLO : ++ break; ++ case UBICOM32_OPERAND_OFFSET16 : ++ { ++ fields->f_o16 = ((int) (fields->f_o16) >> (2)); ++{ ++ FLD (f_o15_13) = ((((unsigned int) (FLD (f_o16)) >> (13))) & (7)); ++ FLD (f_o12_8) = ((((unsigned int) (FLD (f_o16)) >> (8))) & (31)); ++ FLD (f_o7_5) = ((((unsigned int) (FLD (f_o16)) >> (5))) & (7)); ++ FLD (f_o4_0) = ((FLD (f_o16)) & (31)); ++} ++ errmsg = insert_normal (cd, fields->f_o15_13, 0|(1<f_o12_8, 0, 0, 20, 5, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ errmsg = insert_normal (cd, fields->f_o7_5, 0, 0, 10, 3, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ errmsg = insert_normal (cd, fields->f_o4_0, 0, 0, 4, 5, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ } ++ break; ++ case UBICOM32_OPERAND_OFFSET21 : ++ { ++ long value = fields->f_o21; ++ value = ((unsigned int) (((value) - (pc))) >> (2)); ++ errmsg = insert_normal (cd, value, 0|(1<f_o24 = ((int) (((fields->f_o24) - (pc))) >> (2)); ++{ ++ FLD (f_o23_21) = ((((unsigned int) (FLD (f_o24)) >> (21))) & (7)); ++ FLD (f_o20_0) = ((FLD (f_o24)) & (2097151)); ++} ++ errmsg = insert_normal (cd, fields->f_o23_21, 0|(1<f_o20_0, 0, 0, 20, 21, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ } ++ break; ++ case UBICOM32_OPERAND_OPC1 : ++ errmsg = insert_normal (cd, fields->f_op1, 0, 0, 31, 5, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_OPC2 : ++ errmsg = insert_normal (cd, fields->f_op2, 0, 0, 15, 5, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_PDEC_S1_IMM7_4 : ++ { ++{ ++ FLD (f_s1_imm7_t) = ((((unsigned int) (FLD (f_s1_imm7_4)) >> (7))) & (3)); ++ FLD (f_s1_imm7_b) = ((((unsigned int) (FLD (f_s1_imm7_4)) >> (2))) & (31)); ++} ++ errmsg = insert_normal (cd, fields->f_s1_imm7_t, 0, 0, 9, 2, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ errmsg = insert_normal (cd, fields->f_s1_imm7_b, 0, 0, 4, 5, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ } ++ break; ++ case UBICOM32_OPERAND_S1_AN : ++ errmsg = insert_normal (cd, fields->f_s1_An, 0, 0, 7, 3, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_S1_DIRECT_ADDR : ++ { ++ long value = fields->f_s1_direct; ++ value = ((unsigned int) (value) >> (2)); ++ errmsg = insert_normal (cd, value, 0, 0, 7, 8, 32, total_length, buffer); ++ } ++ break; ++ case UBICOM32_OPERAND_S1_I4_1 : ++ errmsg = insert_normal (cd, fields->f_s1_i4_1, 0|(1<f_s1_i4_2; ++ value = ((unsigned int) (value) >> (1)); ++ errmsg = insert_normal (cd, value, 0|(1<f_s1_i4_4; ++ value = ((unsigned int) (value) >> (2)); ++ errmsg = insert_normal (cd, value, 0|(1<> (5))) & (3)); ++ FLD (f_s1_imm7_b) = ((((unsigned int) (FLD (f_s1_imm7_1)) >> (0))) & (31)); ++} ++ errmsg = insert_normal (cd, fields->f_s1_imm7_t, 0, 0, 9, 2, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ errmsg = insert_normal (cd, fields->f_s1_imm7_b, 0, 0, 4, 5, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ } ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_2 : ++ { ++{ ++ FLD (f_s1_imm7_t) = ((((unsigned int) (FLD (f_s1_imm7_2)) >> (6))) & (3)); ++ FLD (f_s1_imm7_b) = ((((unsigned int) (FLD (f_s1_imm7_2)) >> (1))) & (31)); ++} ++ errmsg = insert_normal (cd, fields->f_s1_imm7_t, 0, 0, 9, 2, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ errmsg = insert_normal (cd, fields->f_s1_imm7_b, 0, 0, 4, 5, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ } ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_4 : ++ { ++{ ++ FLD (f_s1_imm7_t) = ((((unsigned int) (FLD (f_s1_imm7_4)) >> (7))) & (3)); ++ FLD (f_s1_imm7_b) = ((((unsigned int) (FLD (f_s1_imm7_4)) >> (2))) & (31)); ++} ++ errmsg = insert_normal (cd, fields->f_s1_imm7_t, 0, 0, 9, 2, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ errmsg = insert_normal (cd, fields->f_s1_imm7_b, 0, 0, 4, 5, 32, total_length, buffer); ++ if (errmsg) ++ break; ++ } ++ break; ++ case UBICOM32_OPERAND_S1_IMM8 : ++ errmsg = insert_normal (cd, fields->f_s1_imm8, 0|(1<f_s1_r, 0, 0, 4, 5, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_S2 : ++ errmsg = insert_normal (cd, fields->f_s2, 0, 0, 14, 4, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_SRC3 : ++ break; ++ case UBICOM32_OPERAND_X_BIT26 : ++ errmsg = insert_normal (cd, fields->f_bit26, 0, 0, 26, 1, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_X_D : ++ errmsg = insert_normal (cd, fields->f_d, 0, 0, 26, 11, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_X_DN : ++ errmsg = insert_normal (cd, fields->f_Dn, 0, 0, 20, 5, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_X_OP2 : ++ errmsg = insert_normal (cd, fields->f_op2, 0, 0, 15, 5, 32, total_length, buffer); ++ break; ++ case UBICOM32_OPERAND_X_S1 : ++ errmsg = insert_normal (cd, fields->f_s1, 0, 0, 10, 11, 32, total_length, buffer); ++ break; ++ ++ default : ++ /* xgettext:c-format */ ++ fprintf (stderr, _("Unrecognized field %d while building insn.\n"), ++ opindex); ++ abort (); ++ } ++ ++ return errmsg; ++} ++ ++int ubicom32_cgen_extract_operand ++ (CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma); ++ ++/* Main entry point for operand extraction. ++ The result is <= 0 for error, >0 for success. ++ ??? Actual values aren't well defined right now. ++ ++ This function is basically just a big switch statement. Earlier versions ++ used tables to look up the function to use, but ++ - if the table contains both assembler and disassembler functions then ++ the disassembler contains much of the assembler and vice-versa, ++ - there's a lot of inlining possibilities as things grow, ++ - using a switch statement avoids the function call overhead. ++ ++ This function could be moved into `print_insn_normal', but keeping it ++ separate makes clear the interface between `print_insn_normal' and each of ++ the handlers. */ ++ ++int ++ubicom32_cgen_extract_operand (CGEN_CPU_DESC cd, ++ int opindex, ++ CGEN_EXTRACT_INFO *ex_info, ++ CGEN_INSN_INT insn_value, ++ CGEN_FIELDS * fields, ++ bfd_vma pc) ++{ ++ /* Assume success (for those operands that are nops). */ ++ int length = 1; ++ unsigned int total_length = CGEN_FIELDS_BITSIZE (fields); ++ ++ switch (opindex) ++ { ++ case UBICOM32_OPERAND_AM : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 3, 32, total_length, pc, & fields->f_Am); ++ break; ++ case UBICOM32_OPERAND_AN : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 3, 32, total_length, pc, & fields->f_An); ++ break; ++ case UBICOM32_OPERAND_C : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 21, 1, 32, total_length, pc, & fields->f_C); ++ break; ++ case UBICOM32_OPERAND_DN : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 5, 32, total_length, pc, & fields->f_Dn); ++ break; ++ case UBICOM32_OPERAND_P : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 22, 1, 32, total_length, pc, & fields->f_P); ++ break; ++ case UBICOM32_OPERAND_ACC1HI : ++ break; ++ case UBICOM32_OPERAND_ACC1LO : ++ break; ++ case UBICOM32_OPERAND_BIT5 : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 5, 32, total_length, pc, & fields->f_bit5); ++ break; ++ case UBICOM32_OPERAND_BIT5_ADDSUB : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 5, 32, total_length, pc, & fields->f_bit5); ++ break; ++ case UBICOM32_OPERAND_CC : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 4, 32, total_length, pc, & fields->f_cond); ++ break; ++ case UBICOM32_OPERAND_D_AN : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 3, 32, total_length, pc, & fields->f_d_An); ++ break; ++ case UBICOM32_OPERAND_D_DIRECT_ADDR : ++ { ++ long value; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 8, 32, total_length, pc, & value); ++ value = ((value) << (2)); ++ fields->f_d_direct = value; ++ } ++ break; ++ case UBICOM32_OPERAND_D_I4_1 : ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_d_i4_1); ++ break; ++ case UBICOM32_OPERAND_D_I4_2 : ++ { ++ long value; ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_d_i4_2 = value; ++ } ++ break; ++ case UBICOM32_OPERAND_D_I4_4 : ++ { ++ long value; ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_d_i4_4 = value; ++ } ++ break; ++ case UBICOM32_OPERAND_D_IMM7_1 : ++ { ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 2, 32, total_length, pc, & fields->f_d_imm7_t); ++ if (length <= 0) break; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 5, 32, total_length, pc, & fields->f_d_imm7_b); ++ if (length <= 0) break; ++{ ++ FLD (f_d_imm7_1) = ((((((FLD (f_d_imm7_t)) << (5))) | (FLD (f_d_imm7_b)))) << (0)); ++} ++ } ++ break; ++ case UBICOM32_OPERAND_D_IMM7_2 : ++ { ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 2, 32, total_length, pc, & fields->f_d_imm7_t); ++ if (length <= 0) break; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 5, 32, total_length, pc, & fields->f_d_imm7_b); ++ if (length <= 0) break; ++{ ++ FLD (f_d_imm7_2) = ((((((FLD (f_d_imm7_t)) << (5))) | (FLD (f_d_imm7_b)))) << (1)); ++} ++ } ++ break; ++ case UBICOM32_OPERAND_D_IMM7_4 : ++ { ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 2, 32, total_length, pc, & fields->f_d_imm7_t); ++ if (length <= 0) break; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 5, 32, total_length, pc, & fields->f_d_imm7_b); ++ if (length <= 0) break; ++{ ++ FLD (f_d_imm7_4) = ((((((FLD (f_d_imm7_t)) << (5))) | (FLD (f_d_imm7_b)))) << (2)); ++} ++ } ++ break; ++ case UBICOM32_OPERAND_D_IMM8 : ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_d_imm8); ++ break; ++ case UBICOM32_OPERAND_D_R : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 5, 32, total_length, pc, & fields->f_d_r); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_ADDSUB : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 4, 32, total_length, pc, & fields->f_dsp_S2); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_MUL : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 4, 32, total_length, pc, & fields->f_dsp_S2); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 4, 32, total_length, pc, & fields->f_dsp_S2); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG_ADDSUB : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 4, 32, total_length, pc, & fields->f_dsp_S2); ++ break; ++ case UBICOM32_OPERAND_DSP_S2_SEL : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 18, 1, 32, total_length, pc, & fields->f_dsp_S2_sel); ++ break; ++ case UBICOM32_OPERAND_DSP_C : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 1, 32, total_length, pc, & fields->f_dsp_C); ++ break; ++ case UBICOM32_OPERAND_DSP_DESTA : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 1, 32, total_length, pc, & fields->f_dsp_destA); ++ break; ++ case UBICOM32_OPERAND_DSP_T : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 19, 1, 32, total_length, pc, & fields->f_dsp_T); ++ break; ++ case UBICOM32_OPERAND_DSP_T_ADDSUB : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 19, 1, 32, total_length, pc, & fields->f_dsp_T); ++ break; ++ case UBICOM32_OPERAND_IMM16_1 : ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_imm16_1); ++ break; ++ case UBICOM32_OPERAND_IMM16_2 : ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_imm16_2); ++ break; ++ case UBICOM32_OPERAND_IMM24 : ++ { ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 3, 32, total_length, pc, & fields->f_imm23_21); ++ if (length <= 0) break; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 21, 32, total_length, pc, & fields->f_o20_0); ++ if (length <= 0) break; ++{ ++ FLD (f_imm24) = ((FLD (f_o20_0)) | (((FLD (f_imm23_21)) << (21)))); ++} ++ } ++ break; ++ case UBICOM32_OPERAND_INTERRUPT : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_int); ++ break; ++ case UBICOM32_OPERAND_IREAD : ++ break; ++ case UBICOM32_OPERAND_IRQ_0 : ++ break; ++ case UBICOM32_OPERAND_IRQ_1 : ++ break; ++ case UBICOM32_OPERAND_MACHI : ++ break; ++ case UBICOM32_OPERAND_MACLO : ++ break; ++ case UBICOM32_OPERAND_OFFSET16 : ++ { ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_o15_13); ++ if (length <= 0) break; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 5, 32, total_length, pc, & fields->f_o12_8); ++ if (length <= 0) break; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 3, 32, total_length, pc, & fields->f_o7_5); ++ if (length <= 0) break; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 5, 32, total_length, pc, & fields->f_o4_0); ++ if (length <= 0) break; ++{ ++ FLD (f_o16) = ((FLD (f_o4_0)) | (((((FLD (f_o15_13)) << (13))) | (((((FLD (f_o12_8)) << (8))) | (((FLD (f_o7_5)) << (5)))))))); ++} ++ fields->f_o16 = ((fields->f_o16) << (2)); ++ } ++ break; ++ case UBICOM32_OPERAND_OFFSET21 : ++ { ++ long value; ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_o21 = value; ++ } ++ break; ++ case UBICOM32_OPERAND_OFFSET24 : ++ { ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_o23_21); ++ if (length <= 0) break; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 21, 32, total_length, pc, & fields->f_o20_0); ++ if (length <= 0) break; ++{ ++ FLD (f_o24) = ((FLD (f_o20_0)) | (((FLD (f_o23_21)) << (21)))); ++} ++ fields->f_o24 = ((((fields->f_o24) << (2))) + (pc)); ++ } ++ break; ++ case UBICOM32_OPERAND_OPC1 : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 5, 32, total_length, pc, & fields->f_op1); ++ break; ++ case UBICOM32_OPERAND_OPC2 : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 5, 32, total_length, pc, & fields->f_op2); ++ break; ++ case UBICOM32_OPERAND_PDEC_S1_IMM7_4 : ++ { ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 2, 32, total_length, pc, & fields->f_s1_imm7_t); ++ if (length <= 0) break; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 5, 32, total_length, pc, & fields->f_s1_imm7_b); ++ if (length <= 0) break; ++{ ++ FLD (f_s1_imm7_4) = ((((((FLD (f_s1_imm7_t)) << (5))) | (FLD (f_s1_imm7_b)))) << (2)); ++} ++ } ++ break; ++ case UBICOM32_OPERAND_S1_AN : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 3, 32, total_length, pc, & fields->f_s1_An); ++ break; ++ case UBICOM32_OPERAND_S1_DIRECT_ADDR : ++ { ++ long value; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 8, 32, total_length, pc, & value); ++ value = ((value) << (2)); ++ fields->f_s1_direct = value; ++ } ++ break; ++ case UBICOM32_OPERAND_S1_I4_1 : ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_s1_i4_1); ++ break; ++ case UBICOM32_OPERAND_S1_I4_2 : ++ { ++ long value; ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_s1_i4_2 = value; ++ } ++ break; ++ case UBICOM32_OPERAND_S1_I4_4 : ++ { ++ long value; ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_s1_i4_4 = value; ++ } ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_1 : ++ { ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 2, 32, total_length, pc, & fields->f_s1_imm7_t); ++ if (length <= 0) break; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 5, 32, total_length, pc, & fields->f_s1_imm7_b); ++ if (length <= 0) break; ++{ ++ FLD (f_s1_imm7_1) = ((((((FLD (f_s1_imm7_t)) << (5))) | (FLD (f_s1_imm7_b)))) << (0)); ++} ++ } ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_2 : ++ { ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 2, 32, total_length, pc, & fields->f_s1_imm7_t); ++ if (length <= 0) break; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 5, 32, total_length, pc, & fields->f_s1_imm7_b); ++ if (length <= 0) break; ++{ ++ FLD (f_s1_imm7_2) = ((((((FLD (f_s1_imm7_t)) << (5))) | (FLD (f_s1_imm7_b)))) << (1)); ++} ++ } ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_4 : ++ { ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 2, 32, total_length, pc, & fields->f_s1_imm7_t); ++ if (length <= 0) break; ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 5, 32, total_length, pc, & fields->f_s1_imm7_b); ++ if (length <= 0) break; ++{ ++ FLD (f_s1_imm7_4) = ((((((FLD (f_s1_imm7_t)) << (5))) | (FLD (f_s1_imm7_b)))) << (2)); ++} ++ } ++ break; ++ case UBICOM32_OPERAND_S1_IMM8 : ++ length = extract_normal (cd, ex_info, insn_value, 0|(1<f_s1_imm8); ++ break; ++ case UBICOM32_OPERAND_S1_R : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 5, 32, total_length, pc, & fields->f_s1_r); ++ break; ++ case UBICOM32_OPERAND_S2 : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 4, 32, total_length, pc, & fields->f_s2); ++ break; ++ case UBICOM32_OPERAND_SRC3 : ++ break; ++ case UBICOM32_OPERAND_X_BIT26 : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 1, 32, total_length, pc, & fields->f_bit26); ++ break; ++ case UBICOM32_OPERAND_X_D : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 11, 32, total_length, pc, & fields->f_d); ++ break; ++ case UBICOM32_OPERAND_X_DN : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 5, 32, total_length, pc, & fields->f_Dn); ++ break; ++ case UBICOM32_OPERAND_X_OP2 : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 5, 32, total_length, pc, & fields->f_op2); ++ break; ++ case UBICOM32_OPERAND_X_S1 : ++ length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 11, 32, total_length, pc, & fields->f_s1); ++ break; ++ ++ default : ++ /* xgettext:c-format */ ++ fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"), ++ opindex); ++ abort (); ++ } ++ ++ return length; ++} ++ ++cgen_insert_fn * const ubicom32_cgen_insert_handlers[] = ++{ ++ insert_insn_normal, ++}; ++ ++cgen_extract_fn * const ubicom32_cgen_extract_handlers[] = ++{ ++ extract_insn_normal, ++}; ++ ++int ubicom32_cgen_get_int_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *); ++bfd_vma ubicom32_cgen_get_vma_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *); ++ ++/* Getting values from cgen_fields is handled by a collection of functions. ++ They are distinguished by the type of the VALUE argument they return. ++ TODO: floating point, inlining support, remove cases where result type ++ not appropriate. */ ++ ++int ++ubicom32_cgen_get_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ int opindex, ++ const CGEN_FIELDS * fields) ++{ ++ int value; ++ ++ switch (opindex) ++ { ++ case UBICOM32_OPERAND_AM : ++ value = fields->f_Am; ++ break; ++ case UBICOM32_OPERAND_AN : ++ value = fields->f_An; ++ break; ++ case UBICOM32_OPERAND_C : ++ value = fields->f_C; ++ break; ++ case UBICOM32_OPERAND_DN : ++ value = fields->f_Dn; ++ break; ++ case UBICOM32_OPERAND_P : ++ value = fields->f_P; ++ break; ++ case UBICOM32_OPERAND_ACC1HI : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_ACC1LO : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_BIT5 : ++ value = fields->f_bit5; ++ break; ++ case UBICOM32_OPERAND_BIT5_ADDSUB : ++ value = fields->f_bit5; ++ break; ++ case UBICOM32_OPERAND_CC : ++ value = fields->f_cond; ++ break; ++ case UBICOM32_OPERAND_D_AN : ++ value = fields->f_d_An; ++ break; ++ case UBICOM32_OPERAND_D_DIRECT_ADDR : ++ value = fields->f_d_direct; ++ break; ++ case UBICOM32_OPERAND_D_I4_1 : ++ value = fields->f_d_i4_1; ++ break; ++ case UBICOM32_OPERAND_D_I4_2 : ++ value = fields->f_d_i4_2; ++ break; ++ case UBICOM32_OPERAND_D_I4_4 : ++ value = fields->f_d_i4_4; ++ break; ++ case UBICOM32_OPERAND_D_IMM7_1 : ++ value = fields->f_d_imm7_1; ++ break; ++ case UBICOM32_OPERAND_D_IMM7_2 : ++ value = fields->f_d_imm7_2; ++ break; ++ case UBICOM32_OPERAND_D_IMM7_4 : ++ value = fields->f_d_imm7_4; ++ break; ++ case UBICOM32_OPERAND_D_IMM8 : ++ value = fields->f_d_imm8; ++ break; ++ case UBICOM32_OPERAND_D_R : ++ value = fields->f_d_r; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_ADDSUB : ++ value = fields->f_dsp_S2; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_MUL : ++ value = fields->f_dsp_S2; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG : ++ value = fields->f_dsp_S2; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG_ADDSUB : ++ value = fields->f_dsp_S2; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_SEL : ++ value = fields->f_dsp_S2_sel; ++ break; ++ case UBICOM32_OPERAND_DSP_C : ++ value = fields->f_dsp_C; ++ break; ++ case UBICOM32_OPERAND_DSP_DESTA : ++ value = fields->f_dsp_destA; ++ break; ++ case UBICOM32_OPERAND_DSP_T : ++ value = fields->f_dsp_T; ++ break; ++ case UBICOM32_OPERAND_DSP_T_ADDSUB : ++ value = fields->f_dsp_T; ++ break; ++ case UBICOM32_OPERAND_IMM16_1 : ++ value = fields->f_imm16_1; ++ break; ++ case UBICOM32_OPERAND_IMM16_2 : ++ value = fields->f_imm16_2; ++ break; ++ case UBICOM32_OPERAND_IMM24 : ++ value = fields->f_imm24; ++ break; ++ case UBICOM32_OPERAND_INTERRUPT : ++ value = fields->f_int; ++ break; ++ case UBICOM32_OPERAND_IREAD : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_IRQ_0 : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_IRQ_1 : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_MACHI : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_MACLO : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_OFFSET16 : ++ value = fields->f_o16; ++ break; ++ case UBICOM32_OPERAND_OFFSET21 : ++ value = fields->f_o21; ++ break; ++ case UBICOM32_OPERAND_OFFSET24 : ++ value = fields->f_o24; ++ break; ++ case UBICOM32_OPERAND_OPC1 : ++ value = fields->f_op1; ++ break; ++ case UBICOM32_OPERAND_OPC2 : ++ value = fields->f_op2; ++ break; ++ case UBICOM32_OPERAND_PDEC_S1_IMM7_4 : ++ value = fields->f_s1_imm7_4; ++ break; ++ case UBICOM32_OPERAND_S1_AN : ++ value = fields->f_s1_An; ++ break; ++ case UBICOM32_OPERAND_S1_DIRECT_ADDR : ++ value = fields->f_s1_direct; ++ break; ++ case UBICOM32_OPERAND_S1_I4_1 : ++ value = fields->f_s1_i4_1; ++ break; ++ case UBICOM32_OPERAND_S1_I4_2 : ++ value = fields->f_s1_i4_2; ++ break; ++ case UBICOM32_OPERAND_S1_I4_4 : ++ value = fields->f_s1_i4_4; ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_1 : ++ value = fields->f_s1_imm7_1; ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_2 : ++ value = fields->f_s1_imm7_2; ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_4 : ++ value = fields->f_s1_imm7_4; ++ break; ++ case UBICOM32_OPERAND_S1_IMM8 : ++ value = fields->f_s1_imm8; ++ break; ++ case UBICOM32_OPERAND_S1_R : ++ value = fields->f_s1_r; ++ break; ++ case UBICOM32_OPERAND_S2 : ++ value = fields->f_s2; ++ break; ++ case UBICOM32_OPERAND_SRC3 : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_X_BIT26 : ++ value = fields->f_bit26; ++ break; ++ case UBICOM32_OPERAND_X_D : ++ value = fields->f_d; ++ break; ++ case UBICOM32_OPERAND_X_DN : ++ value = fields->f_Dn; ++ break; ++ case UBICOM32_OPERAND_X_OP2 : ++ value = fields->f_op2; ++ break; ++ case UBICOM32_OPERAND_X_S1 : ++ value = fields->f_s1; ++ break; ++ ++ default : ++ /* xgettext:c-format */ ++ fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"), ++ opindex); ++ abort (); ++ } ++ ++ return value; ++} ++ ++bfd_vma ++ubicom32_cgen_get_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ int opindex, ++ const CGEN_FIELDS * fields) ++{ ++ bfd_vma value; ++ ++ switch (opindex) ++ { ++ case UBICOM32_OPERAND_AM : ++ value = fields->f_Am; ++ break; ++ case UBICOM32_OPERAND_AN : ++ value = fields->f_An; ++ break; ++ case UBICOM32_OPERAND_C : ++ value = fields->f_C; ++ break; ++ case UBICOM32_OPERAND_DN : ++ value = fields->f_Dn; ++ break; ++ case UBICOM32_OPERAND_P : ++ value = fields->f_P; ++ break; ++ case UBICOM32_OPERAND_ACC1HI : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_ACC1LO : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_BIT5 : ++ value = fields->f_bit5; ++ break; ++ case UBICOM32_OPERAND_BIT5_ADDSUB : ++ value = fields->f_bit5; ++ break; ++ case UBICOM32_OPERAND_CC : ++ value = fields->f_cond; ++ break; ++ case UBICOM32_OPERAND_D_AN : ++ value = fields->f_d_An; ++ break; ++ case UBICOM32_OPERAND_D_DIRECT_ADDR : ++ value = fields->f_d_direct; ++ break; ++ case UBICOM32_OPERAND_D_I4_1 : ++ value = fields->f_d_i4_1; ++ break; ++ case UBICOM32_OPERAND_D_I4_2 : ++ value = fields->f_d_i4_2; ++ break; ++ case UBICOM32_OPERAND_D_I4_4 : ++ value = fields->f_d_i4_4; ++ break; ++ case UBICOM32_OPERAND_D_IMM7_1 : ++ value = fields->f_d_imm7_1; ++ break; ++ case UBICOM32_OPERAND_D_IMM7_2 : ++ value = fields->f_d_imm7_2; ++ break; ++ case UBICOM32_OPERAND_D_IMM7_4 : ++ value = fields->f_d_imm7_4; ++ break; ++ case UBICOM32_OPERAND_D_IMM8 : ++ value = fields->f_d_imm8; ++ break; ++ case UBICOM32_OPERAND_D_R : ++ value = fields->f_d_r; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_ADDSUB : ++ value = fields->f_dsp_S2; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_MUL : ++ value = fields->f_dsp_S2; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG : ++ value = fields->f_dsp_S2; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG_ADDSUB : ++ value = fields->f_dsp_S2; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_SEL : ++ value = fields->f_dsp_S2_sel; ++ break; ++ case UBICOM32_OPERAND_DSP_C : ++ value = fields->f_dsp_C; ++ break; ++ case UBICOM32_OPERAND_DSP_DESTA : ++ value = fields->f_dsp_destA; ++ break; ++ case UBICOM32_OPERAND_DSP_T : ++ value = fields->f_dsp_T; ++ break; ++ case UBICOM32_OPERAND_DSP_T_ADDSUB : ++ value = fields->f_dsp_T; ++ break; ++ case UBICOM32_OPERAND_IMM16_1 : ++ value = fields->f_imm16_1; ++ break; ++ case UBICOM32_OPERAND_IMM16_2 : ++ value = fields->f_imm16_2; ++ break; ++ case UBICOM32_OPERAND_IMM24 : ++ value = fields->f_imm24; ++ break; ++ case UBICOM32_OPERAND_INTERRUPT : ++ value = fields->f_int; ++ break; ++ case UBICOM32_OPERAND_IREAD : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_IRQ_0 : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_IRQ_1 : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_MACHI : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_MACLO : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_OFFSET16 : ++ value = fields->f_o16; ++ break; ++ case UBICOM32_OPERAND_OFFSET21 : ++ value = fields->f_o21; ++ break; ++ case UBICOM32_OPERAND_OFFSET24 : ++ value = fields->f_o24; ++ break; ++ case UBICOM32_OPERAND_OPC1 : ++ value = fields->f_op1; ++ break; ++ case UBICOM32_OPERAND_OPC2 : ++ value = fields->f_op2; ++ break; ++ case UBICOM32_OPERAND_PDEC_S1_IMM7_4 : ++ value = fields->f_s1_imm7_4; ++ break; ++ case UBICOM32_OPERAND_S1_AN : ++ value = fields->f_s1_An; ++ break; ++ case UBICOM32_OPERAND_S1_DIRECT_ADDR : ++ value = fields->f_s1_direct; ++ break; ++ case UBICOM32_OPERAND_S1_I4_1 : ++ value = fields->f_s1_i4_1; ++ break; ++ case UBICOM32_OPERAND_S1_I4_2 : ++ value = fields->f_s1_i4_2; ++ break; ++ case UBICOM32_OPERAND_S1_I4_4 : ++ value = fields->f_s1_i4_4; ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_1 : ++ value = fields->f_s1_imm7_1; ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_2 : ++ value = fields->f_s1_imm7_2; ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_4 : ++ value = fields->f_s1_imm7_4; ++ break; ++ case UBICOM32_OPERAND_S1_IMM8 : ++ value = fields->f_s1_imm8; ++ break; ++ case UBICOM32_OPERAND_S1_R : ++ value = fields->f_s1_r; ++ break; ++ case UBICOM32_OPERAND_S2 : ++ value = fields->f_s2; ++ break; ++ case UBICOM32_OPERAND_SRC3 : ++ value = 0; ++ break; ++ case UBICOM32_OPERAND_X_BIT26 : ++ value = fields->f_bit26; ++ break; ++ case UBICOM32_OPERAND_X_D : ++ value = fields->f_d; ++ break; ++ case UBICOM32_OPERAND_X_DN : ++ value = fields->f_Dn; ++ break; ++ case UBICOM32_OPERAND_X_OP2 : ++ value = fields->f_op2; ++ break; ++ case UBICOM32_OPERAND_X_S1 : ++ value = fields->f_s1; ++ break; ++ ++ default : ++ /* xgettext:c-format */ ++ fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"), ++ opindex); ++ abort (); ++ } ++ ++ return value; ++} ++ ++void ubicom32_cgen_set_int_operand (CGEN_CPU_DESC, int, CGEN_FIELDS *, int); ++void ubicom32_cgen_set_vma_operand (CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma); ++ ++/* Stuffing values in cgen_fields is handled by a collection of functions. ++ They are distinguished by the type of the VALUE argument they accept. ++ TODO: floating point, inlining support, remove cases where argument type ++ not appropriate. */ ++ ++void ++ubicom32_cgen_set_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ int opindex, ++ CGEN_FIELDS * fields, ++ int value) ++{ ++ switch (opindex) ++ { ++ case UBICOM32_OPERAND_AM : ++ fields->f_Am = value; ++ break; ++ case UBICOM32_OPERAND_AN : ++ fields->f_An = value; ++ break; ++ case UBICOM32_OPERAND_C : ++ fields->f_C = value; ++ break; ++ case UBICOM32_OPERAND_DN : ++ fields->f_Dn = value; ++ break; ++ case UBICOM32_OPERAND_P : ++ fields->f_P = value; ++ break; ++ case UBICOM32_OPERAND_ACC1HI : ++ break; ++ case UBICOM32_OPERAND_ACC1LO : ++ break; ++ case UBICOM32_OPERAND_BIT5 : ++ fields->f_bit5 = value; ++ break; ++ case UBICOM32_OPERAND_BIT5_ADDSUB : ++ fields->f_bit5 = value; ++ break; ++ case UBICOM32_OPERAND_CC : ++ fields->f_cond = value; ++ break; ++ case UBICOM32_OPERAND_D_AN : ++ fields->f_d_An = value; ++ break; ++ case UBICOM32_OPERAND_D_DIRECT_ADDR : ++ fields->f_d_direct = value; ++ break; ++ case UBICOM32_OPERAND_D_I4_1 : ++ fields->f_d_i4_1 = value; ++ break; ++ case UBICOM32_OPERAND_D_I4_2 : ++ fields->f_d_i4_2 = value; ++ break; ++ case UBICOM32_OPERAND_D_I4_4 : ++ fields->f_d_i4_4 = value; ++ break; ++ case UBICOM32_OPERAND_D_IMM7_1 : ++ fields->f_d_imm7_1 = value; ++ break; ++ case UBICOM32_OPERAND_D_IMM7_2 : ++ fields->f_d_imm7_2 = value; ++ break; ++ case UBICOM32_OPERAND_D_IMM7_4 : ++ fields->f_d_imm7_4 = value; ++ break; ++ case UBICOM32_OPERAND_D_IMM8 : ++ fields->f_d_imm8 = value; ++ break; ++ case UBICOM32_OPERAND_D_R : ++ fields->f_d_r = value; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_ADDSUB : ++ fields->f_dsp_S2 = value; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_MUL : ++ fields->f_dsp_S2 = value; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG : ++ fields->f_dsp_S2 = value; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG_ADDSUB : ++ fields->f_dsp_S2 = value; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_SEL : ++ fields->f_dsp_S2_sel = value; ++ break; ++ case UBICOM32_OPERAND_DSP_C : ++ fields->f_dsp_C = value; ++ break; ++ case UBICOM32_OPERAND_DSP_DESTA : ++ fields->f_dsp_destA = value; ++ break; ++ case UBICOM32_OPERAND_DSP_T : ++ fields->f_dsp_T = value; ++ break; ++ case UBICOM32_OPERAND_DSP_T_ADDSUB : ++ fields->f_dsp_T = value; ++ break; ++ case UBICOM32_OPERAND_IMM16_1 : ++ fields->f_imm16_1 = value; ++ break; ++ case UBICOM32_OPERAND_IMM16_2 : ++ fields->f_imm16_2 = value; ++ break; ++ case UBICOM32_OPERAND_IMM24 : ++ fields->f_imm24 = value; ++ break; ++ case UBICOM32_OPERAND_INTERRUPT : ++ fields->f_int = value; ++ break; ++ case UBICOM32_OPERAND_IREAD : ++ break; ++ case UBICOM32_OPERAND_IRQ_0 : ++ break; ++ case UBICOM32_OPERAND_IRQ_1 : ++ break; ++ case UBICOM32_OPERAND_MACHI : ++ break; ++ case UBICOM32_OPERAND_MACLO : ++ break; ++ case UBICOM32_OPERAND_OFFSET16 : ++ fields->f_o16 = value; ++ break; ++ case UBICOM32_OPERAND_OFFSET21 : ++ fields->f_o21 = value; ++ break; ++ case UBICOM32_OPERAND_OFFSET24 : ++ fields->f_o24 = value; ++ break; ++ case UBICOM32_OPERAND_OPC1 : ++ fields->f_op1 = value; ++ break; ++ case UBICOM32_OPERAND_OPC2 : ++ fields->f_op2 = value; ++ break; ++ case UBICOM32_OPERAND_PDEC_S1_IMM7_4 : ++ fields->f_s1_imm7_4 = value; ++ break; ++ case UBICOM32_OPERAND_S1_AN : ++ fields->f_s1_An = value; ++ break; ++ case UBICOM32_OPERAND_S1_DIRECT_ADDR : ++ fields->f_s1_direct = value; ++ break; ++ case UBICOM32_OPERAND_S1_I4_1 : ++ fields->f_s1_i4_1 = value; ++ break; ++ case UBICOM32_OPERAND_S1_I4_2 : ++ fields->f_s1_i4_2 = value; ++ break; ++ case UBICOM32_OPERAND_S1_I4_4 : ++ fields->f_s1_i4_4 = value; ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_1 : ++ fields->f_s1_imm7_1 = value; ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_2 : ++ fields->f_s1_imm7_2 = value; ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_4 : ++ fields->f_s1_imm7_4 = value; ++ break; ++ case UBICOM32_OPERAND_S1_IMM8 : ++ fields->f_s1_imm8 = value; ++ break; ++ case UBICOM32_OPERAND_S1_R : ++ fields->f_s1_r = value; ++ break; ++ case UBICOM32_OPERAND_S2 : ++ fields->f_s2 = value; ++ break; ++ case UBICOM32_OPERAND_SRC3 : ++ break; ++ case UBICOM32_OPERAND_X_BIT26 : ++ fields->f_bit26 = value; ++ break; ++ case UBICOM32_OPERAND_X_D : ++ fields->f_d = value; ++ break; ++ case UBICOM32_OPERAND_X_DN : ++ fields->f_Dn = value; ++ break; ++ case UBICOM32_OPERAND_X_OP2 : ++ fields->f_op2 = value; ++ break; ++ case UBICOM32_OPERAND_X_S1 : ++ fields->f_s1 = value; ++ break; ++ ++ default : ++ /* xgettext:c-format */ ++ fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"), ++ opindex); ++ abort (); ++ } ++} ++ ++void ++ubicom32_cgen_set_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, ++ int opindex, ++ CGEN_FIELDS * fields, ++ bfd_vma value) ++{ ++ switch (opindex) ++ { ++ case UBICOM32_OPERAND_AM : ++ fields->f_Am = value; ++ break; ++ case UBICOM32_OPERAND_AN : ++ fields->f_An = value; ++ break; ++ case UBICOM32_OPERAND_C : ++ fields->f_C = value; ++ break; ++ case UBICOM32_OPERAND_DN : ++ fields->f_Dn = value; ++ break; ++ case UBICOM32_OPERAND_P : ++ fields->f_P = value; ++ break; ++ case UBICOM32_OPERAND_ACC1HI : ++ break; ++ case UBICOM32_OPERAND_ACC1LO : ++ break; ++ case UBICOM32_OPERAND_BIT5 : ++ fields->f_bit5 = value; ++ break; ++ case UBICOM32_OPERAND_BIT5_ADDSUB : ++ fields->f_bit5 = value; ++ break; ++ case UBICOM32_OPERAND_CC : ++ fields->f_cond = value; ++ break; ++ case UBICOM32_OPERAND_D_AN : ++ fields->f_d_An = value; ++ break; ++ case UBICOM32_OPERAND_D_DIRECT_ADDR : ++ fields->f_d_direct = value; ++ break; ++ case UBICOM32_OPERAND_D_I4_1 : ++ fields->f_d_i4_1 = value; ++ break; ++ case UBICOM32_OPERAND_D_I4_2 : ++ fields->f_d_i4_2 = value; ++ break; ++ case UBICOM32_OPERAND_D_I4_4 : ++ fields->f_d_i4_4 = value; ++ break; ++ case UBICOM32_OPERAND_D_IMM7_1 : ++ fields->f_d_imm7_1 = value; ++ break; ++ case UBICOM32_OPERAND_D_IMM7_2 : ++ fields->f_d_imm7_2 = value; ++ break; ++ case UBICOM32_OPERAND_D_IMM7_4 : ++ fields->f_d_imm7_4 = value; ++ break; ++ case UBICOM32_OPERAND_D_IMM8 : ++ fields->f_d_imm8 = value; ++ break; ++ case UBICOM32_OPERAND_D_R : ++ fields->f_d_r = value; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_ADDSUB : ++ fields->f_dsp_S2 = value; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_ACC_REG_MUL : ++ fields->f_dsp_S2 = value; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG : ++ fields->f_dsp_S2 = value; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_DATA_REG_ADDSUB : ++ fields->f_dsp_S2 = value; ++ break; ++ case UBICOM32_OPERAND_DSP_S2_SEL : ++ fields->f_dsp_S2_sel = value; ++ break; ++ case UBICOM32_OPERAND_DSP_C : ++ fields->f_dsp_C = value; ++ break; ++ case UBICOM32_OPERAND_DSP_DESTA : ++ fields->f_dsp_destA = value; ++ break; ++ case UBICOM32_OPERAND_DSP_T : ++ fields->f_dsp_T = value; ++ break; ++ case UBICOM32_OPERAND_DSP_T_ADDSUB : ++ fields->f_dsp_T = value; ++ break; ++ case UBICOM32_OPERAND_IMM16_1 : ++ fields->f_imm16_1 = value; ++ break; ++ case UBICOM32_OPERAND_IMM16_2 : ++ fields->f_imm16_2 = value; ++ break; ++ case UBICOM32_OPERAND_IMM24 : ++ fields->f_imm24 = value; ++ break; ++ case UBICOM32_OPERAND_INTERRUPT : ++ fields->f_int = value; ++ break; ++ case UBICOM32_OPERAND_IREAD : ++ break; ++ case UBICOM32_OPERAND_IRQ_0 : ++ break; ++ case UBICOM32_OPERAND_IRQ_1 : ++ break; ++ case UBICOM32_OPERAND_MACHI : ++ break; ++ case UBICOM32_OPERAND_MACLO : ++ break; ++ case UBICOM32_OPERAND_OFFSET16 : ++ fields->f_o16 = value; ++ break; ++ case UBICOM32_OPERAND_OFFSET21 : ++ fields->f_o21 = value; ++ break; ++ case UBICOM32_OPERAND_OFFSET24 : ++ fields->f_o24 = value; ++ break; ++ case UBICOM32_OPERAND_OPC1 : ++ fields->f_op1 = value; ++ break; ++ case UBICOM32_OPERAND_OPC2 : ++ fields->f_op2 = value; ++ break; ++ case UBICOM32_OPERAND_PDEC_S1_IMM7_4 : ++ fields->f_s1_imm7_4 = value; ++ break; ++ case UBICOM32_OPERAND_S1_AN : ++ fields->f_s1_An = value; ++ break; ++ case UBICOM32_OPERAND_S1_DIRECT_ADDR : ++ fields->f_s1_direct = value; ++ break; ++ case UBICOM32_OPERAND_S1_I4_1 : ++ fields->f_s1_i4_1 = value; ++ break; ++ case UBICOM32_OPERAND_S1_I4_2 : ++ fields->f_s1_i4_2 = value; ++ break; ++ case UBICOM32_OPERAND_S1_I4_4 : ++ fields->f_s1_i4_4 = value; ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_1 : ++ fields->f_s1_imm7_1 = value; ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_2 : ++ fields->f_s1_imm7_2 = value; ++ break; ++ case UBICOM32_OPERAND_S1_IMM7_4 : ++ fields->f_s1_imm7_4 = value; ++ break; ++ case UBICOM32_OPERAND_S1_IMM8 : ++ fields->f_s1_imm8 = value; ++ break; ++ case UBICOM32_OPERAND_S1_R : ++ fields->f_s1_r = value; ++ break; ++ case UBICOM32_OPERAND_S2 : ++ fields->f_s2 = value; ++ break; ++ case UBICOM32_OPERAND_SRC3 : ++ break; ++ case UBICOM32_OPERAND_X_BIT26 : ++ fields->f_bit26 = value; ++ break; ++ case UBICOM32_OPERAND_X_D : ++ fields->f_d = value; ++ break; ++ case UBICOM32_OPERAND_X_DN : ++ fields->f_Dn = value; ++ break; ++ case UBICOM32_OPERAND_X_OP2 : ++ fields->f_op2 = value; ++ break; ++ case UBICOM32_OPERAND_X_S1 : ++ fields->f_s1 = 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 ++ubicom32_cgen_init_ibld_table (CGEN_CPU_DESC cd) ++{ ++ cd->insert_handlers = & ubicom32_cgen_insert_handlers[0]; ++ cd->extract_handlers = & ubicom32_cgen_extract_handlers[0]; ++ ++ cd->insert_operand = ubicom32_cgen_insert_operand; ++ cd->extract_operand = ubicom32_cgen_extract_operand; ++ ++ cd->get_int_operand = ubicom32_cgen_get_int_operand; ++ cd->set_int_operand = ubicom32_cgen_set_int_operand; ++ cd->get_vma_operand = ubicom32_cgen_get_vma_operand; ++ cd->set_vma_operand = ubicom32_cgen_set_vma_operand; ++} +--- /dev/null ++++ b/opcodes/ubicom32-opc.c +@@ -0,0 +1,20075 @@ ++/* Instruction opcode table for ubicom32. ++ ++THIS FILE IS MACHINE GENERATED WITH CGEN. ++ ++Copyright 1996-2007 Free Software Foundation, Inc. ++ ++This file is part of the GNU Binutils and/or GDB, the GNU debugger. ++ ++ This file is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3, or (at your option) ++ any later version. ++ ++ It is distributed in the hope that it will be useful, but WITHOUT ++ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY ++ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public ++ License for more details. ++ ++ You should have received a copy of the GNU General Public License along ++ with this program; if not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. ++ ++*/ ++ ++#include "sysdep.h" ++#include "ansidecl.h" ++#include "bfd.h" ++#include "symcat.h" ++#include "ubicom32-desc.h" ++#include "ubicom32-opc.h" ++#include "libiberty.h" ++ ++/* -- opc.c */ ++#include "safe-ctype.h" ++ ++unsigned int ++ubicom32_dis_hash (const char *buf, CGEN_INSN_INT value ATTRIBUTE_UNUSED) ++{ ++ unsigned int hash = (*buf >> 3); ++ return hash % CGEN_DIS_HASH_SIZE; ++} ++ ++ ++/* A better hash function for instruction mnemonics. */ ++unsigned int ++ubicom32_asm_hash (const char* insn) ++{ ++ unsigned int hash; ++ const char* m = insn; ++ ++ /* for certain instructions, the variations are coded as operands ++ and so only the mnemonic will have been used to seed the hash table. ++ Examples of this are the jmp family and the int instruction. ++ If we suspect we may have these instructions, just use the first 3 chars. ++ */ ++ if (*m == 'j' || *m == 'i' || *m=='m') ++ { ++ int i = 0; ++ for (hash = 0; *m && !ISSPACE(*m) && i < 3; m++, ++i) ++ hash = (hash * 23) ^ (0x1F & TOLOWER(*m)); ++ } ++ else ++ { ++ for (hash = 0; *m && !ISSPACE(*m); m++) ++ hash = (hash * 23) ^ (0x1F & TOLOWER(*m)); ++ } ++ ++ /* printf ("%s %d\n", insn, (hash % CGEN_ASM_HASH_SIZE)); */ ++ ++ return hash % CGEN_ASM_HASH_SIZE; ++} ++ ++/* Special check to ensure that instruction exists for given machine. */ ++int ++ubicom32_cgen_insn_supported (CGEN_CPU_DESC cd, ++ const CGEN_INSN *insn) ++{ ++ int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH); ++ ++ /* No mach attribute? Assume it's supported for all machs. */ ++ if (machs == 0) ++ return 1; ++ ++ return ((machs & cd->machs) != 0); ++} ++ ++/* -- asm.c */ ++/* The hash functions are recorded here to help keep assembler code out of ++ the disassembler and vice versa. */ ++ ++static int asm_hash_insn_p (const CGEN_INSN *); ++static unsigned int asm_hash_insn (const char *); ++static int dis_hash_insn_p (const CGEN_INSN *); ++static unsigned int dis_hash_insn (const char *, CGEN_INSN_INT); ++ ++/* Instruction formats. */ ++ ++#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE) ++#define F(f) & ubicom32_cgen_ifld_table[UBICOM32_##f] ++#else ++#define F(f) & ubicom32_cgen_ifld_table[UBICOM32_/**/f] ++#endif ++static const CGEN_IFMT ifmt_empty ATTRIBUTE_UNUSED = { ++ 0, 0, 0x0, { { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_direct_dsp_src2_data_reg_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_immediate_dsp_src2_data_reg_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_with_index_2_dsp_src2_data_reg_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_with_offset_2_dsp_src2_data_reg_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_2_dsp_src2_data_reg_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe6871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_with_post_increment_2_dsp_src2_data_reg_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_with_pre_increment_2_dsp_src2_data_reg_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_direct_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_immediate_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_2_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe6871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_direct_dsp_imm_bit5_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe60700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_immediate_dsp_imm_bit5_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe60700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_with_index_2_dsp_imm_bit5_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe60700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_with_offset_2_dsp_imm_bit5_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe60400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_2_dsp_imm_bit5_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe6071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_with_post_increment_2_dsp_imm_bit5_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe60710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_2_s1_indirect_with_pre_increment_2_dsp_imm_bit5_addsub2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe60710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_direct_dsp_src2_data_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_immediate_dsp_src2_data_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_with_index_4_dsp_src2_data_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_with_offset_4_dsp_src2_data_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee8400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_4_dsp_src2_data_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_with_post_increment_4_dsp_src2_data_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_with_pre_increment_4_dsp_src2_data_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_direct_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_immediate_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_with_index_4_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_with_offset_4_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee8400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_4_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_with_post_increment_4_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_with_pre_increment_4_dsp_src2_reg_acc_reg_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_direct_dsp_imm_bit5_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_immediate_dsp_imm_bit5_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_with_index_4_dsp_imm_bit5_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_with_offset_4_dsp_imm_bit5_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee0400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_4_dsp_imm_bit5_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_with_post_increment_4_dsp_imm_bit5_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee0710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msub_4_s1_indirect_with_pre_increment_4_dsp_imm_bit5_addsub ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffee0710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_direct_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_immediate_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe6871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_direct_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_immediate_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_2_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe6871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe68710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_direct_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe60700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_immediate_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe60700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe60700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe60400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe6071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe60710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe60710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_direct_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_immediate_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_with_index_4_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_with_offset_4_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe8400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_4_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_with_post_increment_4_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_with_pre_increment_4_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_direct_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_immediate_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_with_index_4_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_with_offset_4_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe8400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_4_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_with_post_increment_4_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_with_pre_increment_4_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_direct_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_immediate_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_with_index_4_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_with_offset_4_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe0400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_4_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_with_post_increment_4_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe0710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_4_s1_indirect_with_pre_increment_4_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffe0710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_direct_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_immediate_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_with_index_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_with_offset_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff68400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff6871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_with_post_increment_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff68710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_with_pre_increment_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff68710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_direct_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_immediate_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff68700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff68400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_2_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff6871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff68710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_mul ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff68710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_direct_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff60700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_immediate_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff60700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_with_index_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff60700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_with_offset_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff60400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff6071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_with_post_increment_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff60710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_mulu_s1_indirect_with_pre_increment_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfff60710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_ierase_d_pea_indirect_with_index ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ffff, { { F (F_OP1) }, { F (F_OP2) }, { F (F_S1) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_ierase_d_pea_indirect_with_offset ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ffff, { { F (F_OP1) }, { F (F_OP2) }, { F (F_S1) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_ierase_d_pea_indirect ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fffff, { { F (F_OP1) }, { F (F_OP2) }, { F (F_S1) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_ierase_d_pea_indirect_with_post_increment ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ffff, { { F (F_OP1) }, { F (F_OP2) }, { F (F_S1) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_ierase_d_pea_indirect_with_pre_increment ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ffff, { { F (F_OP1) }, { F (F_OP2) }, { F (F_S1) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iread_s1_ea_indirect ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffff1f, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iread_s1_ea_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffff00, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iread_s1_ea_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffff10, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iread_s1_ea_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffff10, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iread_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffffc00, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_index_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_offset_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_post_increment_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_index_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_offset_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_post_increment_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1ffc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_setcsr_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffff00, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_setcsr_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffff00, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_setcsr_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffff00, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_setcsr_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffffc00, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_setcsr_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffff1f, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_setcsr_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffff10, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_setcsr_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffff10, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_direct_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_immediate_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_index_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_offset_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_post_increment_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_pre_increment_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_direct_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_immediate_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_index_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_offset_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_post_increment_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_pre_increment_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_direct_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_immediate_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_index_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_direct_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_immediate_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_index_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1ffc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_direct_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_immediate_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_index_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_offset_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_direct_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_immediate_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_index_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_direct_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_immediate_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_index_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_immediate_2_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_index_2_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_offset_2_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_2_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_post_increment_2_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_pre_increment_2_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_immediate_2_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_index_2_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_offset_2_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_2_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_post_increment_2_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_pre_increment_2_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_direct_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_immediate_2_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_2_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_direct_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_immediate_2_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_2_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1ffc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_direct_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_immediate_2_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_index_2_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_offset_2_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_2_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_direct_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_immediate_2_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_2_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_direct_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_immediate_2_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_2_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_immediate_1_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_index_1_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_offset_1_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_1_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_post_increment_1_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_pre_increment_1_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_immediate_1_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_index_1_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_offset_1_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_1_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_post_increment_1_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_pre_increment_1_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_direct_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_immediate_1_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_index_1_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_offset_1_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_1_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_direct_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_immediate_1_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_index_1_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_offset_1_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_1_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1ffc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_direct_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_immediate_1_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_index_1_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_offset_1_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_1_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_direct_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_immediate_1_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_index_1_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_offset_1_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_1_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_direct_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_immediate_1_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_index_1_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_offset_1_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_1_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movei_d_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000000, { { F (F_OP1) }, { F (F_IMM16_2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movei_d_immediate_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000000, { { F (F_OP1) }, { F (F_IMM16_2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movei_d_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000000, { { F (F_OP1) }, { F (F_IMM16_2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movei_d_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc000000, { { F (F_OP1) }, { F (F_IMM16_2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movei_d_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f0000, { { F (F_OP1) }, { F (F_IMM16_2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movei_d_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100000, { { F (F_OP1) }, { F (F_IMM16_2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_movei_d_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100000, { { F (F_OP1) }, { F (F_IMM16_2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_direct_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_immediate_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_index_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_offset_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc000700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f0700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_post_increment_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_pre_increment_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_direct_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_immediate_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_index_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_offset_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc000700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f0700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_post_increment_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_pre_increment_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_direct_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_immediate_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_index_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_offset_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc000700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f0700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100700, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_direct_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000400, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_immediate_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000400, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_index_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000400, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_offset_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc000400, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f0400, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100400, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100400, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_direct_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00071f, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_immediate_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00071f, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_index_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00071f, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_offset_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00071f, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f071f, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10071f, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10071f, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_direct_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_immediate_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_index_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_offset_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc000710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f0710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_direct_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_immediate_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_index_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff000710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc000710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f0710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff100710, { { F (F_OP1) }, { F (F_BIT5) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_direct_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_immediate_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_indirect_with_index_4_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_indirect_with_offset_4_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_indirect_4_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_indirect_with_post_increment_4_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_indirect_with_pre_increment_4_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_direct_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_immediate_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_indirect_with_index_4_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_indirect_with_offset_4_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_indirect_4_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_indirect_with_post_increment_4_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_btst_s1_indirect_with_pre_increment_4_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_imm_bit5_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_dyn_reg_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_imm_bit5_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_dyn_reg_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_imm_bit5_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_dyn_reg_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_imm_bit5_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_dyn_reg_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_imm_bit5_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe0071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_dyn_reg_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe0871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_imm_bit5_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_dyn_reg_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_imm_bit5_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_2_dyn_reg_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_1_imm_bit5_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_1_dyn_reg_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_1_imm_bit5_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_1_dyn_reg_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_1_imm_bit5_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe0071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_1_dyn_reg_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe0871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_1_imm_bit5_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_1_dyn_reg_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_1_imm_bit5_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_shmrg_1_dyn_reg_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_crcgen_s1_indirect_with_index_1_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_crcgen_s1_indirect_with_offset_1_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_crcgen_s1_indirect_1_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_crcgen_s1_indirect_with_post_increment_1_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_crcgen_s1_indirect_with_pre_increment_1_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_crcgen_s1_indirect_with_index_1_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_crcgen_s1_indirect_with_offset_1_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_crcgen_s1_indirect_1_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_crcgen_s1_indirect_with_post_increment_1_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_crcgen_s1_indirect_with_pre_increment_1_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_direct_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_immediate_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_indirect_with_index_4_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_indirect_with_offset_4_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_indirect_4_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe0071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_indirect_with_post_increment_4_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_indirect_with_pre_increment_4_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_direct_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_immediate_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_indirect_with_index_4_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_indirect_with_offset_4_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_indirect_4_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe0871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_indirect_with_post_increment_4_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_bfextu_s1_indirect_with_pre_increment_4_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_asr_4_imm_bit5_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_asr_4_dyn_reg_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_asr_4_imm_bit5_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_asr_4_dyn_reg_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_asr_4_imm_bit5_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe0071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_asr_4_dyn_reg_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe0871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_asr_4_imm_bit5_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_asr_4_dyn_reg_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_asr_4_imm_bit5_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe00710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_BIT5) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_asr_4_dyn_reg_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_direct_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_immediate_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_indirect_with_index_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_indirect_with_offset_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_indirect_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_indirect_with_post_increment_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_indirect_with_pre_increment_2_dsp_src2_data_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_B15) }, { F (F_BIT26) }, { F (F_DSP_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_direct_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_immediate_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_indirect_with_index_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_indirect_with_offset_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_indirect_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_indirect_with_post_increment_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_compatibility_mac_s1_indirect_with_pre_increment_2_dsp_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_mac_s1_indirect_with_index_2_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_mac_s1_indirect_with_offset_2_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_mac_s1_indirect_2_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff071f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_mac_s1_indirect_with_post_increment_2_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_mac_s1_indirect_with_pre_increment_2_imm_bit5 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff0710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_BIT5) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_mac_s1_indirect_with_index_2_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8700, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_mac_s1_indirect_with_offset_2_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8400, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_mac_s1_indirect_2_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff871f, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_mac_s1_indirect_with_post_increment_2_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_mac_s1_indirect_with_pre_increment_2_dyn_reg ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffff8710, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { F (F_BIT26) }, { F (F_B15) }, { F (F_S2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pdec_d_direct_pdec_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pdec_d_immediate_4_pdec_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pdec_d_indirect_with_index_4_pdec_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pdec_d_indirect_with_offset_4_pdec_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pdec_d_indirect_4_pdec_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1ffc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pdec_d_indirect_with_post_increment_4_pdec_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pdec_d_indirect_with_pre_increment_4_pdec_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_direct_s1_ea_indirect ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_immediate_4_s1_ea_indirect ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_index_4_s1_ea_indirect ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_offset_4_s1_ea_indirect ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_4_s1_ea_indirect ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_indirect ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_indirect ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_direct_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_immediate_4_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_index_4_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_offset_4_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_4_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1ffc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_direct_s1_ea_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_immediate_4_s1_ea_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_index_4_s1_ea_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_offset_4_s1_ea_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_4_s1_ea_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_direct_s1_ea_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_immediate_4_s1_ea_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_index_4_s1_ea_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_offset_4_s1_ea_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_4_s1_ea_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_direct_s1_ea_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_immediate_4_s1_ea_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_index_4_s1_ea_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_offset_4_s1_ea_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_4_s1_ea_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_direct_s1_ea_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_immediate_4_s1_ea_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_index_4_s1_ea_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_offset_4_s1_ea_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_4_s1_ea_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_direct_s1_ea_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_immediate_4_s1_ea_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_index_4_s1_ea_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_offset_4_s1_ea_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_4_s1_ea_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1ffc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_post_increment_4_s1_ea_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_pre_increment_4_s1_ea_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_direct_s1_ea_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_immediate_4_s1_ea_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_index_4_s1_ea_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_offset_4_s1_ea_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_4_s1_ea_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_post_increment_4_s1_ea_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_pre_increment_4_s1_ea_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_direct_s1_ea_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_immediate_4_s1_ea_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_index_4_s1_ea_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_offset_4_s1_ea_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_4_s1_ea_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_post_increment_4_s1_ea_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_pre_increment_4_s1_ea_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_direct_s1_ea_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_immediate_4_s1_ea_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_index_4_s1_ea_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_offset_4_s1_ea_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_4_s1_ea_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_post_increment_4_s1_ea_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_2_d_indirect_with_pre_increment_4_s1_ea_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_direct_s1_ea_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_immediate_4_s1_ea_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_index_4_s1_ea_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_offset_4_s1_ea_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_4_s1_ea_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1ffc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_post_increment_4_s1_ea_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_pre_increment_4_s1_ea_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_direct_s1_ea_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_immediate_4_s1_ea_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_index_4_s1_ea_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_offset_4_s1_ea_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_4_s1_ea_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_post_increment_4_s1_ea_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_pre_increment_4_s1_ea_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_direct_s1_ea_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_immediate_4_s1_ea_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_index_4_s1_ea_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_offset_4_s1_ea_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_4_s1_ea_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_post_increment_4_s1_ea_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_pre_increment_4_s1_ea_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_direct_s1_ea_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_immediate_4_s1_ea_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_index_4_s1_ea_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_offset_4_s1_ea_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_4_s1_ea_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_post_increment_4_s1_ea_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_lea_1_d_indirect_with_pre_increment_4_s1_ea_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_cmpi_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf8000700, { { F (F_OP1) }, { F (F_IMM16_1) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_cmpi_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf8000700, { { F (F_OP1) }, { F (F_IMM16_1) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_cmpi_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf8000700, { { F (F_OP1) }, { F (F_IMM16_1) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_cmpi_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf8000400, { { F (F_OP1) }, { F (F_IMM16_1) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_cmpi_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf800071f, { { F (F_OP1) }, { F (F_IMM16_1) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_cmpi_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf8000710, { { F (F_OP1) }, { F (F_IMM16_1) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_cmpi_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf8000710, { { F (F_OP1) }, { F (F_IMM16_1) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_direct_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_immediate_2_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_index_2_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_offset_2_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_2_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_direct_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_immediate_2_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_index_2_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_offset_2_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_2_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_direct_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_immediate_2_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_2_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_immediate_2_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_2_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_direct_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_immediate_2_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_2_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_immediate_2_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_2_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_immediate_2_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_2_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxhi_s_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08700, { { F (F_OP1) }, { F (F_BIT26) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxhi_s_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08700, { { F (F_OP1) }, { F (F_BIT26) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxhi_s_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08700, { { F (F_OP1) }, { F (F_BIT26) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxhi_s_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08400, { { F (F_OP1) }, { F (F_BIT26) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxhi_s_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe0871f, { { F (F_OP1) }, { F (F_BIT26) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxhi_s_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08710, { { F (F_OP1) }, { F (F_BIT26) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxhi_s_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffe08710, { { F (F_OP1) }, { F (F_BIT26) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_B15) }, { F (F_S2) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_immediate_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_index_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_offset_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_immediate_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_index_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_offset_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_immediate_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_immediate_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_immediate_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_immediate_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_immediate_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_4) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_immediate_2_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_2_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_with_index_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_immediate_2_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_2_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1ffc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_with_offset_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10fc00, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_immediate_2_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_2_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff1f, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_immediate_2_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_2_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_immediate_2_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_2_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1fff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_4 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10ff10, { { F (F_OP1) }, { F (F_OP2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_4) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_immediate_1_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_index_1_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_offset_1_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_1_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_post_increment_1_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_pre_increment_1_s1_direct ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_DIRECT) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_immediate_1_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_index_1_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_offset_1_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_1_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_post_increment_1_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_pre_increment_1_s1_immediate ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_IMM8) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_direct_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_immediate_1_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_1_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_index_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_direct_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_immediate_1_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_1_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_offset_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_direct_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_immediate_1_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_index_1_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_1_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_direct_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_immediate_1_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_1_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_post_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_direct_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_immediate_1_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_1_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_pre_increment_1 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_1) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_1) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_direct_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_immediate_2_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_2_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_index_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108700, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_R) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_direct_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_immediate_2_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_2_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_offset_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108400, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_direct_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_immediate_2_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_index_2_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc00871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_2_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff10871f, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_IMM7_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_direct_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_immediate_2_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_2_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_direct_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_DIRECT) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_immediate_2_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_IMM8) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_R) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfc008710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_2_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff1f8710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_IMM7_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_2 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xff108710, { { F (F_OP1) }, { F (F_B15) }, { F (F_S2) }, { F (F_D_BIT10) }, { F (F_D_TYPE) }, { F (F_D_M) }, { F (F_D_I4_2) }, { F (F_D_AN) }, { F (F_S1_BIT10) }, { F (F_S1_TYPE) }, { F (F_S1_M) }, { F (F_S1_I4_2) }, { F (F_S1_AN) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_moveai ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf8000000, { { F (F_OP1) }, { F (F_AN) }, { F (F_IMM24) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_nop_insn ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffffff, { { F (F_OP1) }, { F (F_D) }, { F (F_IMM16_2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_jmpcc ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf8000000, { { F (F_OP1) }, { F (F_COND) }, { F (F_P) }, { F (F_C) }, { F (F_O21) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_call ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf8000000, { { F (F_OP1) }, { F (F_AN) }, { F (F_O24) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_calli ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf800f800, { { F (F_OP1) }, { F (F_AN) }, { F (F_BIT5) }, { F (F_AM) }, { F (F_O16) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_suspend ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffffff, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_clracc ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffeffff, { { F (F_OP1) }, { F (F_BIT26) }, { F (F_OPEXT) }, { F (F_DSP_C) }, { F (F_DSP_T) }, { F (F_DSP_S2_SEL) }, { F (F_DSP_R) }, { F (F_DSP_DESTA) }, { F (F_BIT5) }, { F (F_S1) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_unused_00_11 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf800f800, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_unused_02_04 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfbe00000, { { F (F_OP1) }, { F (F_BIT26) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_OP2) }, { F (F_S1) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_unused_01 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xf8000000, { { F (F_OP1) }, { F (F_D) }, { F (F_OP2) }, { F (F_S1) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_unused_DSP_06 ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfbe00000, { { F (F_OP1) }, { F (F_BIT26) }, { F (F_OPEXT) }, { F (F_DN) }, { F (F_OP2) }, { F (F_S1) }, { 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) UBICOM32_OPERAND_##op ++#else ++#define OPERAND(op) UBICOM32_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 ubicom32_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}}, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_direct_dsp_src2_data_reg_addsub2, { 0x36600100 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_immediate_dsp_src2_data_reg_addsub2, { 0x36600000 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_index_2_dsp_src2_data_reg_addsub2, { 0x36600300 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_offset_2_dsp_src2_data_reg_addsub2, { 0x36600400 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An}),${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_2_dsp_src2_data_reg_addsub2, { 0x36600400 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_post_increment_2_dsp_src2_data_reg_addsub2, { 0x36600200 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_pre_increment_2_dsp_src2_data_reg_addsub2, { 0x36600210 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_direct_dsp_src2_reg_acc_reg_addsub, { 0x36640100 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_immediate_dsp_src2_reg_acc_reg_addsub, { 0x36640000 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_addsub, { 0x36640300 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_addsub, { 0x36640400 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_2_dsp_src2_reg_acc_reg_addsub, { 0x36640400 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_addsub, { 0x36640200 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_addsub, { 0x36640210 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-direct-addr},#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_direct_dsp_imm_bit5_addsub2, { 0x32600100 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},#${s1-imm8},#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_immediate_dsp_imm_bit5_addsub2, { 0x32600000 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An},${s1-r}),#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_index_2_dsp_imm_bit5_addsub2, { 0x32600300 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-imm7-2}(${s1-An}),#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_offset_2_dsp_imm_bit5_addsub2, { 0x32600400 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An}),#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_2_dsp_imm_bit5_addsub2, { 0x32600400 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An})${s1-i4-2}++,#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_post_increment_2_dsp_imm_bit5_addsub2, { 0x32600200 } ++ }, ++/* msub.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-i4-2}(${s1-An})++,#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_pre_increment_2_dsp_imm_bit5_addsub2, { 0x32600210 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_direct_dsp_src2_data_reg_addsub, { 0x36400100 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_immediate_dsp_src2_data_reg_addsub, { 0x36400000 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_index_4_dsp_src2_data_reg_addsub, { 0x36400300 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},${s1-imm7-4}(${s1-An}),${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_offset_4_dsp_src2_data_reg_addsub, { 0x36400400 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},(${s1-An}),${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_4_dsp_src2_data_reg_addsub, { 0x36400400 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},(${s1-An})${s1-i4-4}++,${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_post_increment_4_dsp_src2_data_reg_addsub, { 0x36400200 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},${s1-i4-4}(${s1-An})++,${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_pre_increment_4_dsp_src2_data_reg_addsub, { 0x36400210 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_direct_dsp_src2_reg_acc_reg_addsub, { 0x36440100 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_immediate_dsp_src2_reg_acc_reg_addsub, { 0x36440000 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_index_4_dsp_src2_reg_acc_reg_addsub, { 0x36440300 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},${s1-imm7-4}(${s1-An}),${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_offset_4_dsp_src2_reg_acc_reg_addsub, { 0x36440400 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_4_dsp_src2_reg_acc_reg_addsub, { 0x36440400 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},(${s1-An})${s1-i4-4}++,${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_post_increment_4_dsp_src2_reg_acc_reg_addsub, { 0x36440200 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},${s1-i4-4}(${s1-An})++,${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_pre_increment_4_dsp_src2_reg_acc_reg_addsub, { 0x36440210 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},${s1-direct-addr},#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_direct_dsp_imm_bit5_addsub, { 0x32400100 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},#${s1-imm8},#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_immediate_dsp_imm_bit5_addsub, { 0x32400000 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},(${s1-An},${s1-r}),#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_index_4_dsp_imm_bit5_addsub, { 0x32400300 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},${s1-imm7-4}(${s1-An}),#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_offset_4_dsp_imm_bit5_addsub, { 0x32400400 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},(${s1-An}),#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_4_dsp_imm_bit5_addsub, { 0x32400400 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},(${s1-An})${s1-i4-4}++,#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_post_increment_4_dsp_imm_bit5_addsub, { 0x32400200 } ++ }, ++/* msub.4${dsp-c} ${dsp-destA},${s1-i4-4}(${s1-An})++,#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_pre_increment_4_dsp_imm_bit5_addsub, { 0x32400210 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_direct_dsp_src2_data_reg_addsub2, { 0x36200100 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_immediate_dsp_src2_data_reg_addsub2, { 0x36200000 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_index_2_dsp_src2_data_reg_addsub2, { 0x36200300 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_offset_2_dsp_src2_data_reg_addsub2, { 0x36200400 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An}),${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_2_dsp_src2_data_reg_addsub2, { 0x36200400 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_post_increment_2_dsp_src2_data_reg_addsub2, { 0x36200200 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_pre_increment_2_dsp_src2_data_reg_addsub2, { 0x36200210 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_direct_dsp_src2_reg_acc_reg_addsub, { 0x36240100 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_immediate_dsp_src2_reg_acc_reg_addsub, { 0x36240000 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_addsub, { 0x36240300 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_addsub, { 0x36240400 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_2_dsp_src2_reg_acc_reg_addsub, { 0x36240400 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_addsub, { 0x36240200 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_addsub, { 0x36240210 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-direct-addr},#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_direct_dsp_imm_bit5_addsub2, { 0x32200100 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},#${s1-imm8},#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_immediate_dsp_imm_bit5_addsub2, { 0x32200000 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An},${s1-r}),#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_index_2_dsp_imm_bit5_addsub2, { 0x32200300 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-imm7-2}(${s1-An}),#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_offset_2_dsp_imm_bit5_addsub2, { 0x32200400 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An}),#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_2_dsp_imm_bit5_addsub2, { 0x32200400 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},(${s1-An})${s1-i4-2}++,#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_post_increment_2_dsp_imm_bit5_addsub2, { 0x32200200 } ++ }, ++/* madd.2${dsp-c}${dsp-t-addsub} ${dsp-destA},${s1-i4-2}(${s1-An})++,#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T_ADDSUB), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_2_s1_indirect_with_pre_increment_2_dsp_imm_bit5_addsub2, { 0x32200210 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_direct_dsp_src2_data_reg_addsub, { 0x36000100 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_immediate_dsp_src2_data_reg_addsub, { 0x36000000 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_index_4_dsp_src2_data_reg_addsub, { 0x36000300 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},${s1-imm7-4}(${s1-An}),${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_offset_4_dsp_src2_data_reg_addsub, { 0x36000400 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},(${s1-An}),${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_4_dsp_src2_data_reg_addsub, { 0x36000400 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},(${s1-An})${s1-i4-4}++,${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_post_increment_4_dsp_src2_data_reg_addsub, { 0x36000200 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},${s1-i4-4}(${s1-An})++,${dsp-S2-data-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_pre_increment_4_dsp_src2_data_reg_addsub, { 0x36000210 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_direct_dsp_src2_reg_acc_reg_addsub, { 0x36040100 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_immediate_dsp_src2_reg_acc_reg_addsub, { 0x36040000 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_index_4_dsp_src2_reg_acc_reg_addsub, { 0x36040300 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},${s1-imm7-4}(${s1-An}),${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_offset_4_dsp_src2_reg_acc_reg_addsub, { 0x36040400 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_4_dsp_src2_reg_acc_reg_addsub, { 0x36040400 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},(${s1-An})${s1-i4-4}++,${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_post_increment_4_dsp_src2_reg_acc_reg_addsub, { 0x36040200 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},${s1-i4-4}(${s1-An})++,${dsp-S2-acc-reg-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_pre_increment_4_dsp_src2_reg_acc_reg_addsub, { 0x36040210 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},${s1-direct-addr},#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_direct_dsp_imm_bit5_addsub, { 0x32000100 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},#${s1-imm8},#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_immediate_dsp_imm_bit5_addsub, { 0x32000000 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},(${s1-An},${s1-r}),#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_index_4_dsp_imm_bit5_addsub, { 0x32000300 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},${s1-imm7-4}(${s1-An}),#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_offset_4_dsp_imm_bit5_addsub, { 0x32000400 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},(${s1-An}),#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_4_dsp_imm_bit5_addsub, { 0x32000400 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},(${s1-An})${s1-i4-4}++,#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_post_increment_4_dsp_imm_bit5_addsub, { 0x32000200 } ++ }, ++/* madd.4${dsp-c} ${dsp-destA},${s1-i4-4}(${s1-An})++,#${bit5-addsub} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), ' ', OP (DSP_DESTA), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5_ADDSUB), 0 } }, ++ & ifmt_dsp_msub_4_s1_indirect_with_pre_increment_4_dsp_imm_bit5_addsub, { 0x32000210 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_src2_data_reg, { 0x35200100 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_src2_data_reg, { 0x35200000 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_data_reg, { 0x35200300 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_data_reg, { 0x35200400 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_src2_data_reg, { 0x35200400 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_data_reg, { 0x35200200 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_data_reg, { 0x35200210 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_src2_reg_acc_reg_mul, { 0x35240100 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_src2_reg_acc_reg_mul, { 0x35240000 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_mul, { 0x35240300 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_mul, { 0x35240400 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_src2_reg_acc_reg_mul, { 0x35240400 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_mul, { 0x35240200 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_mul, { 0x35240210 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_imm_bit5, { 0x31200100 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_imm_bit5, { 0x31200000 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_imm_bit5, { 0x31200300 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_imm_bit5, { 0x31200400 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_imm_bit5, { 0x31200400 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_imm_bit5, { 0x31200200 } ++ }, ++/* msuf${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_imm_bit5, { 0x31200210 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_src2_data_reg, { 0x34e00100 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_src2_data_reg, { 0x34e00000 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_data_reg, { 0x34e00300 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_data_reg, { 0x34e00400 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_src2_data_reg, { 0x34e00400 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_data_reg, { 0x34e00200 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_data_reg, { 0x34e00210 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_src2_reg_acc_reg_mul, { 0x34e40100 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_src2_reg_acc_reg_mul, { 0x34e40000 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_mul, { 0x34e40300 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_mul, { 0x34e40400 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_src2_reg_acc_reg_mul, { 0x34e40400 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34e40200 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34e40210 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_imm_bit5, { 0x30e00100 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_imm_bit5, { 0x30e00000 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_imm_bit5, { 0x30e00300 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_imm_bit5, { 0x30e00400 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_imm_bit5, { 0x30e00400 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_imm_bit5, { 0x30e00200 } ++ }, ++/* macus${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_imm_bit5, { 0x30e00210 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_src2_data_reg, { 0x34a00100 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_src2_data_reg, { 0x34a00000 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_data_reg, { 0x34a00300 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_data_reg, { 0x34a00400 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_src2_data_reg, { 0x34a00400 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_data_reg, { 0x34a00200 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_data_reg, { 0x34a00210 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_src2_reg_acc_reg_mul, { 0x34a40100 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_src2_reg_acc_reg_mul, { 0x34a40000 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_mul, { 0x34a40300 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_mul, { 0x34a40400 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_src2_reg_acc_reg_mul, { 0x34a40400 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34a40200 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34a40210 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_imm_bit5, { 0x30a00100 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_imm_bit5, { 0x30a00000 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_imm_bit5, { 0x30a00300 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_imm_bit5, { 0x30a00400 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_imm_bit5, { 0x30a00400 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_imm_bit5, { 0x30a00200 } ++ }, ++/* macf${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_imm_bit5, { 0x30a00210 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_src2_data_reg, { 0x34800100 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_src2_data_reg, { 0x34800000 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_data_reg, { 0x34800300 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_data_reg, { 0x34800400 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_src2_data_reg, { 0x34800400 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_data_reg, { 0x34800200 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_data_reg, { 0x34800210 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_src2_reg_acc_reg_mul, { 0x34840100 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_src2_reg_acc_reg_mul, { 0x34840000 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_mul, { 0x34840300 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_mul, { 0x34840400 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_src2_reg_acc_reg_mul, { 0x34840400 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34840200 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34840210 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_imm_bit5, { 0x30800100 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_imm_bit5, { 0x30800000 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_imm_bit5, { 0x30800300 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_imm_bit5, { 0x30800400 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_imm_bit5, { 0x30800400 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_imm_bit5, { 0x30800200 } ++ }, ++/* mulf${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_imm_bit5, { 0x30800210 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_src2_data_reg, { 0x34600100 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_src2_data_reg, { 0x34600000 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_data_reg, { 0x34600300 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_data_reg, { 0x34600400 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_src2_data_reg, { 0x34600400 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_data_reg, { 0x34600200 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_data_reg, { 0x34600210 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_src2_reg_acc_reg_mul, { 0x34640100 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_src2_reg_acc_reg_mul, { 0x34640000 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_mul, { 0x34640300 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_mul, { 0x34640400 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_src2_reg_acc_reg_mul, { 0x34640400 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34640200 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34640210 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_imm_bit5, { 0x30600100 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_imm_bit5, { 0x30600000 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_imm_bit5, { 0x30600300 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_imm_bit5, { 0x30600400 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_imm_bit5, { 0x30600400 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_imm_bit5, { 0x30600200 } ++ }, ++/* macu${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_imm_bit5, { 0x30600210 } ++ }, ++/* mulu.4 ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_direct_dsp_src2_data_reg, { 0x35400100 } ++ }, ++/* mulu.4 ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_immediate_dsp_src2_data_reg, { 0x35400000 } ++ }, ++/* mulu.4 ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_index_4_dsp_src2_data_reg, { 0x35400300 } ++ }, ++/* mulu.4 ${dsp-destA},${s1-imm7-4}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_offset_4_dsp_src2_data_reg, { 0x35400400 } ++ }, ++/* mulu.4 ${dsp-destA},(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_4_dsp_src2_data_reg, { 0x35400400 } ++ }, ++/* mulu.4 ${dsp-destA},(${s1-An})${s1-i4-4}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_post_increment_4_dsp_src2_data_reg, { 0x35400200 } ++ }, ++/* mulu.4 ${dsp-destA},${s1-i4-4}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_pre_increment_4_dsp_src2_data_reg, { 0x35400210 } ++ }, ++/* mulu.4 ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_direct_dsp_src2_reg_acc_reg_mul, { 0x35440100 } ++ }, ++/* mulu.4 ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_immediate_dsp_src2_reg_acc_reg_mul, { 0x35440000 } ++ }, ++/* mulu.4 ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_index_4_dsp_src2_reg_acc_reg_mul, { 0x35440300 } ++ }, ++/* mulu.4 ${dsp-destA},${s1-imm7-4}(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_offset_4_dsp_src2_reg_acc_reg_mul, { 0x35440400 } ++ }, ++/* mulu.4 ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_4_dsp_src2_reg_acc_reg_mul, { 0x35440400 } ++ }, ++/* mulu.4 ${dsp-destA},(${s1-An})${s1-i4-4}++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_post_increment_4_dsp_src2_reg_acc_reg_mul, { 0x35440200 } ++ }, ++/* mulu.4 ${dsp-destA},${s1-i4-4}(${s1-An})++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_pre_increment_4_dsp_src2_reg_acc_reg_mul, { 0x35440210 } ++ }, ++/* mulu.4 ${dsp-destA},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_direct_dsp_imm_bit5, { 0x31400100 } ++ }, ++/* mulu.4 ${dsp-destA},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_immediate_dsp_imm_bit5, { 0x31400000 } ++ }, ++/* mulu.4 ${dsp-destA},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_index_4_dsp_imm_bit5, { 0x31400300 } ++ }, ++/* mulu.4 ${dsp-destA},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_offset_4_dsp_imm_bit5, { 0x31400400 } ++ }, ++/* mulu.4 ${dsp-destA},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_4_dsp_imm_bit5, { 0x31400400 } ++ }, ++/* mulu.4 ${dsp-destA},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_post_increment_4_dsp_imm_bit5, { 0x31400200 } ++ }, ++/* mulu.4 ${dsp-destA},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_pre_increment_4_dsp_imm_bit5, { 0x31400210 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_direct_dsp_src2_data_reg, { 0x34400100 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_immediate_dsp_src2_data_reg, { 0x34400000 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_index_2_dsp_src2_data_reg, { 0x34400300 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_offset_2_dsp_src2_data_reg, { 0x34400400 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_2_dsp_src2_data_reg, { 0x34400400 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_post_increment_2_dsp_src2_data_reg, { 0x34400200 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_pre_increment_2_dsp_src2_data_reg, { 0x34400210 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_direct_dsp_src2_reg_acc_reg_mul, { 0x34440100 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_immediate_dsp_src2_reg_acc_reg_mul, { 0x34440000 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_mul, { 0x34440300 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_mul, { 0x34440400 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_2_dsp_src2_reg_acc_reg_mul, { 0x34440400 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34440200 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34440210 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_direct_dsp_imm_bit5, { 0x30400100 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_immediate_dsp_imm_bit5, { 0x30400000 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_index_2_dsp_imm_bit5, { 0x30400300 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_offset_2_dsp_imm_bit5, { 0x30400400 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_2_dsp_imm_bit5, { 0x30400400 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_post_increment_2_dsp_imm_bit5, { 0x30400200 } ++ }, ++/* mulu${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_pre_increment_2_dsp_imm_bit5, { 0x30400210 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_src2_data_reg, { 0x34200100 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_src2_data_reg, { 0x34200000 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_data_reg, { 0x34200300 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_data_reg, { 0x34200400 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_src2_data_reg, { 0x34200400 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_data_reg, { 0x34200200 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_data_reg, { 0x34200210 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_src2_reg_acc_reg_mul, { 0x34240100 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_src2_reg_acc_reg_mul, { 0x34240000 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_mul, { 0x34240300 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_mul, { 0x34240400 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_src2_reg_acc_reg_mul, { 0x34240400 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34240200 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34240210 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_direct_dsp_imm_bit5, { 0x30200100 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_immediate_dsp_imm_bit5, { 0x30200000 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_index_2_dsp_imm_bit5, { 0x30200300 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_offset_2_dsp_imm_bit5, { 0x30200400 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_2_dsp_imm_bit5, { 0x30200400 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_post_increment_2_dsp_imm_bit5, { 0x30200200 } ++ }, ++/* macs${dsp-c}${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_C), OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_msuf_s1_indirect_with_pre_increment_2_dsp_imm_bit5, { 0x30200210 } ++ }, ++/* muls.4 ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_direct_dsp_src2_data_reg, { 0x35000100 } ++ }, ++/* muls.4 ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_immediate_dsp_src2_data_reg, { 0x35000000 } ++ }, ++/* muls.4 ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_index_4_dsp_src2_data_reg, { 0x35000300 } ++ }, ++/* muls.4 ${dsp-destA},${s1-imm7-4}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_offset_4_dsp_src2_data_reg, { 0x35000400 } ++ }, ++/* muls.4 ${dsp-destA},(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_4_dsp_src2_data_reg, { 0x35000400 } ++ }, ++/* muls.4 ${dsp-destA},(${s1-An})${s1-i4-4}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_post_increment_4_dsp_src2_data_reg, { 0x35000200 } ++ }, ++/* muls.4 ${dsp-destA},${s1-i4-4}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_pre_increment_4_dsp_src2_data_reg, { 0x35000210 } ++ }, ++/* muls.4 ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_direct_dsp_src2_reg_acc_reg_mul, { 0x35040100 } ++ }, ++/* muls.4 ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_immediate_dsp_src2_reg_acc_reg_mul, { 0x35040000 } ++ }, ++/* muls.4 ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_index_4_dsp_src2_reg_acc_reg_mul, { 0x35040300 } ++ }, ++/* muls.4 ${dsp-destA},${s1-imm7-4}(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_offset_4_dsp_src2_reg_acc_reg_mul, { 0x35040400 } ++ }, ++/* muls.4 ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_4_dsp_src2_reg_acc_reg_mul, { 0x35040400 } ++ }, ++/* muls.4 ${dsp-destA},(${s1-An})${s1-i4-4}++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_post_increment_4_dsp_src2_reg_acc_reg_mul, { 0x35040200 } ++ }, ++/* muls.4 ${dsp-destA},${s1-i4-4}(${s1-An})++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_pre_increment_4_dsp_src2_reg_acc_reg_mul, { 0x35040210 } ++ }, ++/* muls.4 ${dsp-destA},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_direct_dsp_imm_bit5, { 0x31000100 } ++ }, ++/* muls.4 ${dsp-destA},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_immediate_dsp_imm_bit5, { 0x31000000 } ++ }, ++/* muls.4 ${dsp-destA},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_index_4_dsp_imm_bit5, { 0x31000300 } ++ }, ++/* muls.4 ${dsp-destA},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_offset_4_dsp_imm_bit5, { 0x31000400 } ++ }, ++/* muls.4 ${dsp-destA},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_4_dsp_imm_bit5, { 0x31000400 } ++ }, ++/* muls.4 ${dsp-destA},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_post_increment_4_dsp_imm_bit5, { 0x31000200 } ++ }, ++/* muls.4 ${dsp-destA},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_4_s1_indirect_with_pre_increment_4_dsp_imm_bit5, { 0x31000210 } ++ }, ++/* muls${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_direct_dsp_src2_data_reg, { 0x34000100 } ++ }, ++/* muls${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_immediate_dsp_src2_data_reg, { 0x34000000 } ++ }, ++/* muls${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_index_2_dsp_src2_data_reg, { 0x34000300 } ++ }, ++/* muls${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_offset_2_dsp_src2_data_reg, { 0x34000400 } ++ }, ++/* muls${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_2_dsp_src2_data_reg, { 0x34000400 } ++ }, ++/* muls${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_post_increment_2_dsp_src2_data_reg, { 0x34000200 } ++ }, ++/* muls${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_pre_increment_2_dsp_src2_data_reg, { 0x34000210 } ++ }, ++/* muls${dsp-t} ${dsp-destA},${s1-direct-addr},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_direct_dsp_src2_reg_acc_reg_mul, { 0x34040100 } ++ }, ++/* muls${dsp-t} ${dsp-destA},#${s1-imm8},${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_immediate_dsp_src2_reg_acc_reg_mul, { 0x34040000 } ++ }, ++/* muls${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_index_2_dsp_src2_reg_acc_reg_mul, { 0x34040300 } ++ }, ++/* muls${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_offset_2_dsp_src2_reg_acc_reg_mul, { 0x34040400 } ++ }, ++/* muls${dsp-t} ${dsp-destA},(${s1-An}),${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_2_dsp_src2_reg_acc_reg_mul, { 0x34040400 } ++ }, ++/* muls${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_post_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34040200 } ++ }, ++/* muls${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,${dsp-S2-acc-reg-mul} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_ACC_REG_MUL), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_pre_increment_2_dsp_src2_reg_acc_reg_mul, { 0x34040210 } ++ }, ++/* muls${dsp-t} ${dsp-destA},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_direct_dsp_imm_bit5, { 0x30000100 } ++ }, ++/* muls${dsp-t} ${dsp-destA},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_immediate_dsp_imm_bit5, { 0x30000000 } ++ }, ++/* muls${dsp-t} ${dsp-destA},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_index_2_dsp_imm_bit5, { 0x30000300 } ++ }, ++/* muls${dsp-t} ${dsp-destA},${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_offset_2_dsp_imm_bit5, { 0x30000400 } ++ }, ++/* muls${dsp-t} ${dsp-destA},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_2_dsp_imm_bit5, { 0x30000400 } ++ }, ++/* muls${dsp-t} ${dsp-destA},(${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_post_increment_2_dsp_imm_bit5, { 0x30000200 } ++ }, ++/* muls${dsp-t} ${dsp-destA},${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (DSP_T), ' ', OP (DSP_DESTA), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_dsp_mulu_s1_indirect_with_pre_increment_2_dsp_imm_bit5, { 0x30000210 } ++ }, ++/* ierase (${d-An},${d-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', 0 } }, ++ & ifmt_ierase_d_pea_indirect_with_index, { 0x3002800 } ++ }, ++/* ierase ${d-imm7-4}(${d-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', 0 } }, ++ & ifmt_ierase_d_pea_indirect_with_offset, { 0x4002800 } ++ }, ++/* ierase (${d-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', 0 } }, ++ & ifmt_ierase_d_pea_indirect, { 0x4002800 } ++ }, ++/* ierase (${d-An})${d-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', 0 } }, ++ & ifmt_ierase_d_pea_indirect_with_post_increment, { 0x2002800 } ++ }, ++/* ierase ${d-i4-4}(${d-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', 0 } }, ++ & ifmt_ierase_d_pea_indirect_with_pre_increment, { 0x2102800 } ++ }, ++/* iread (${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iread_s1_ea_indirect, { 0x3400 } ++ }, ++/* iread (${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_iread_s1_ea_indirect_with_index_4, { 0x3300 } ++ }, ++/* iread (${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_iread_s1_ea_indirect_with_post_increment_4, { 0x3200 } ++ }, ++/* iread ${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_iread_s1_ea_indirect_with_pre_increment_4, { 0x3210 } ++ }, ++/* iread ${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iread_s1_ea_indirect_with_offset_4, { 0x3400 } ++ }, ++/* iwrite (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_direct, { 0x3008100 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_direct, { 0x4008100 } ++ }, ++/* iwrite (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_direct, { 0x4008100 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_direct, { 0x2008100 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_direct, { 0x2108100 } ++ }, ++/* iwrite (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_immediate, { 0x3008000 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_immediate, { 0x4008000 } ++ }, ++/* iwrite (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_immediate, { 0x4008000 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_immediate, { 0x2008000 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_immediate, { 0x2108000 } ++ }, ++/* iwrite (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_with_index_4, { 0x3008300 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_with_index_4, { 0x4008300 } ++ }, ++/* iwrite (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_indirect_with_index_4, { 0x4008300 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_with_index_4, { 0x2008300 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_with_index_4, { 0x2108300 } ++ }, ++/* iwrite (${d-An},${d-r}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_with_offset_4, { 0x3008400 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_with_offset_4, { 0x4008400 } ++ }, ++/* iwrite (${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_indirect_with_offset_4, { 0x4008400 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_with_offset_4, { 0x2008400 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_with_offset_4, { 0x2108400 } ++ }, ++/* iwrite (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_4, { 0x3008400 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_4, { 0x4008400 } ++ }, ++/* iwrite (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_indirect_4, { 0x4008400 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_4, { 0x2008400 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_4, { 0x2108400 } ++ }, ++/* iwrite (${d-An},${d-r}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_with_post_increment_4, { 0x3008200 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_with_post_increment_4, { 0x4008200 } ++ }, ++/* iwrite (${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_indirect_with_post_increment_4, { 0x4008200 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_with_post_increment_4, { 0x2008200 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_with_post_increment_4, { 0x2108200 } ++ }, ++/* iwrite (${d-An},${d-r}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_with_pre_increment_4, { 0x3008210 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_with_pre_increment_4, { 0x4008210 } ++ }, ++/* iwrite (${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_indirect_with_pre_increment_4, { 0x4008210 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_with_pre_increment_4, { 0x2008210 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_with_pre_increment_4, { 0x2108210 } ++ }, ++/* setcsr ${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_setcsr_s1_direct, { 0x12d9100 } ++ }, ++/* setcsr #${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_setcsr_s1_immediate, { 0x12d9000 } ++ }, ++/* setcsr (${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_setcsr_s1_indirect_with_index_4, { 0x12d9300 } ++ }, ++/* setcsr ${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_setcsr_s1_indirect_with_offset_4, { 0x12d9400 } ++ }, ++/* setcsr (${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_setcsr_s1_indirect_4, { 0x12d9400 } ++ }, ++/* setcsr (${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_setcsr_s1_indirect_with_post_increment_4, { 0x12d9200 } ++ }, ++/* setcsr ${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_setcsr_s1_indirect_with_pre_increment_4, { 0x12d9210 } ++ }, ++/* bkpt ${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_setcsr_s1_direct, { 0x3900 } ++ }, ++/* bkpt #${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_setcsr_s1_immediate, { 0x3800 } ++ }, ++/* bkpt (${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_setcsr_s1_indirect_with_index_4, { 0x3b00 } ++ }, ++/* bkpt ${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_setcsr_s1_indirect_with_offset_4, { 0x3c00 } ++ }, ++/* bkpt (${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_setcsr_s1_indirect_4, { 0x3c00 } ++ }, ++/* bkpt (${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_setcsr_s1_indirect_with_post_increment_4, { 0x3a00 } ++ }, ++/* bkpt ${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_setcsr_s1_indirect_with_pre_increment_4, { 0x3a10 } ++ }, ++/* ret ${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_setcsr_s1_direct, { 0x2100 } ++ }, ++/* ret #${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_setcsr_s1_immediate, { 0x2000 } ++ }, ++/* ret (${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_setcsr_s1_indirect_with_index_4, { 0x2300 } ++ }, ++/* ret ${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_setcsr_s1_indirect_with_offset_4, { 0x2400 } ++ }, ++/* ret (${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_setcsr_s1_indirect_4, { 0x2400 } ++ }, ++/* ret (${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_setcsr_s1_indirect_with_post_increment_4, { 0x2200 } ++ }, ++/* ret ${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_setcsr_s1_indirect_with_pre_increment_4, { 0x2210 } ++ }, ++/* movea ${d-direct-addr},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_direct_s1_direct, { 0x1007100 } ++ }, ++/* movea #${d-imm8},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_immediate_4_s1_direct, { 0x7100 } ++ }, ++/* movea (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_direct, { 0x3007100 } ++ }, ++/* movea ${d-imm7-4}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_direct, { 0x4007100 } ++ }, ++/* movea (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_4_s1_direct, { 0x4007100 } ++ }, ++/* movea (${d-An})${d-i4-4}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_direct, { 0x2007100 } ++ }, ++/* movea ${d-i4-4}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_direct, { 0x2107100 } ++ }, ++/* movea ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_direct_s1_immediate, { 0x1007000 } ++ }, ++/* movea #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_immediate_4_s1_immediate, { 0x7000 } ++ }, ++/* movea (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_immediate, { 0x3007000 } ++ }, ++/* movea ${d-imm7-4}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_immediate, { 0x4007000 } ++ }, ++/* movea (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_4_s1_immediate, { 0x4007000 } ++ }, ++/* movea (${d-An})${d-i4-4}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_immediate, { 0x2007000 } ++ }, ++/* movea ${d-i4-4}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_immediate, { 0x2107000 } ++ }, ++/* movea ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_index_4, { 0x1007300 } ++ }, ++/* movea #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_index_4, { 0x7300 } ++ }, ++/* movea (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x3007300 } ++ }, ++/* movea ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x4007300 } ++ }, ++/* movea (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_index_4, { 0x4007300 } ++ }, ++/* movea (${d-An})${d-i4-4}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x2007300 } ++ }, ++/* movea ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x2107300 } ++ }, ++/* movea ${d-direct-addr},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_offset_4, { 0x1007400 } ++ }, ++/* movea #${d-imm8},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_offset_4, { 0x7400 } ++ }, ++/* movea (${d-An},${d-r}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x3007400 } ++ }, ++/* movea ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x4007400 } ++ }, ++/* movea (${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_offset_4, { 0x4007400 } ++ }, ++/* movea (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x2007400 } ++ }, ++/* movea ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x2107400 } ++ }, ++/* movea ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_4, { 0x1007400 } ++ }, ++/* movea #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_4, { 0x7400 } ++ }, ++/* movea (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_4, { 0x3007400 } ++ }, ++/* movea ${d-imm7-4}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_4, { 0x4007400 } ++ }, ++/* movea (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_4, { 0x4007400 } ++ }, ++/* movea (${d-An})${d-i4-4}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_4, { 0x2007400 } ++ }, ++/* movea ${d-i4-4}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x2107400 } ++ }, ++/* movea ${d-direct-addr},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_post_increment_4, { 0x1007200 } ++ }, ++/* movea #${d-imm8},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_post_increment_4, { 0x7200 } ++ }, ++/* movea (${d-An},${d-r}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x3007200 } ++ }, ++/* movea ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x4007200 } ++ }, ++/* movea (${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_post_increment_4, { 0x4007200 } ++ }, ++/* movea (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x2007200 } ++ }, ++/* movea ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x2107200 } ++ }, ++/* movea ${d-direct-addr},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_pre_increment_4, { 0x1007210 } ++ }, ++/* movea #${d-imm8},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_pre_increment_4, { 0x7210 } ++ }, ++/* movea (${d-An},${d-r}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x3007210 } ++ }, ++/* movea ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x4007210 } ++ }, ++/* movea (${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x4007210 } ++ }, ++/* movea (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x2007210 } ++ }, ++/* movea ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x2107210 } ++ }, ++/* move.4 ${d-direct-addr},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_direct_s1_direct, { 0x1006100 } ++ }, ++/* move.4 #${d-imm8},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_immediate_4_s1_direct, { 0x6100 } ++ }, ++/* move.4 (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_direct, { 0x3006100 } ++ }, ++/* move.4 ${d-imm7-4}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_direct, { 0x4006100 } ++ }, ++/* move.4 (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_4_s1_direct, { 0x4006100 } ++ }, ++/* move.4 (${d-An})${d-i4-4}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_direct, { 0x2006100 } ++ }, ++/* move.4 ${d-i4-4}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_direct, { 0x2106100 } ++ }, ++/* move.4 ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_direct_s1_immediate, { 0x1006000 } ++ }, ++/* move.4 #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_immediate_4_s1_immediate, { 0x6000 } ++ }, ++/* move.4 (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_immediate, { 0x3006000 } ++ }, ++/* move.4 ${d-imm7-4}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_immediate, { 0x4006000 } ++ }, ++/* move.4 (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_4_s1_immediate, { 0x4006000 } ++ }, ++/* move.4 (${d-An})${d-i4-4}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_immediate, { 0x2006000 } ++ }, ++/* move.4 ${d-i4-4}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_immediate, { 0x2106000 } ++ }, ++/* move.4 ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_index_4, { 0x1006300 } ++ }, ++/* move.4 #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_index_4, { 0x6300 } ++ }, ++/* move.4 (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x3006300 } ++ }, ++/* move.4 ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x4006300 } ++ }, ++/* move.4 (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_index_4, { 0x4006300 } ++ }, ++/* move.4 (${d-An})${d-i4-4}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x2006300 } ++ }, ++/* move.4 ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x2106300 } ++ }, ++/* move.4 ${d-direct-addr},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_offset_4, { 0x1006400 } ++ }, ++/* move.4 #${d-imm8},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_offset_4, { 0x6400 } ++ }, ++/* move.4 (${d-An},${d-r}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x3006400 } ++ }, ++/* move.4 ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x4006400 } ++ }, ++/* move.4 (${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_offset_4, { 0x4006400 } ++ }, ++/* move.4 (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x2006400 } ++ }, ++/* move.4 ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x2106400 } ++ }, ++/* move.4 ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_4, { 0x1006400 } ++ }, ++/* move.4 #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_4, { 0x6400 } ++ }, ++/* move.4 (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_4, { 0x3006400 } ++ }, ++/* move.4 ${d-imm7-4}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_4, { 0x4006400 } ++ }, ++/* move.4 (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_4, { 0x4006400 } ++ }, ++/* move.4 (${d-An})${d-i4-4}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_4, { 0x2006400 } ++ }, ++/* move.4 ${d-i4-4}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x2106400 } ++ }, ++/* move.4 ${d-direct-addr},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_post_increment_4, { 0x1006200 } ++ }, ++/* move.4 #${d-imm8},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_post_increment_4, { 0x6200 } ++ }, ++/* move.4 (${d-An},${d-r}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x3006200 } ++ }, ++/* move.4 ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x4006200 } ++ }, ++/* move.4 (${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_post_increment_4, { 0x4006200 } ++ }, ++/* move.4 (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x2006200 } ++ }, ++/* move.4 ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x2106200 } ++ }, ++/* move.4 ${d-direct-addr},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_pre_increment_4, { 0x1006210 } ++ }, ++/* move.4 #${d-imm8},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_pre_increment_4, { 0x6210 } ++ }, ++/* move.4 (${d-An},${d-r}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x3006210 } ++ }, ++/* move.4 ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x4006210 } ++ }, ++/* move.4 (${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x4006210 } ++ }, ++/* move.4 (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x2006210 } ++ }, ++/* move.4 ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x2106210 } ++ }, ++/* iread (${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iread_s1_ea_indirect, { 0x12f6400 } ++ }, ++/* iread (${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_iread_s1_ea_indirect_with_index_4, { 0x12f6300 } ++ }, ++/* iread (${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_iread_s1_ea_indirect_with_post_increment_4, { 0x12f6200 } ++ }, ++/* iread ${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_iread_s1_ea_indirect_with_pre_increment_4, { 0x12f6210 } ++ }, ++/* iread ${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iread_s1_ea_indirect_with_offset_4, { 0x12f6400 } ++ }, ++/* iwrite (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_direct, { 0x3006100 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_direct, { 0x4006100 } ++ }, ++/* iwrite (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_direct, { 0x4006100 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_direct, { 0x2006100 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_direct, { 0x2106100 } ++ }, ++/* iwrite (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_immediate, { 0x3006000 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_immediate, { 0x4006000 } ++ }, ++/* iwrite (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_immediate, { 0x4006000 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_immediate, { 0x2006000 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_immediate, { 0x2106000 } ++ }, ++/* iwrite (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_with_index_4, { 0x3006300 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_with_index_4, { 0x4006300 } ++ }, ++/* iwrite (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_indirect_with_index_4, { 0x4006300 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_with_index_4, { 0x2006300 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_with_index_4, { 0x2106300 } ++ }, ++/* iwrite (${d-An},${d-r}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_with_offset_4, { 0x3006400 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_with_offset_4, { 0x4006400 } ++ }, ++/* iwrite (${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_indirect_with_offset_4, { 0x4006400 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_with_offset_4, { 0x2006400 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_with_offset_4, { 0x2106400 } ++ }, ++/* iwrite (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_4, { 0x3006400 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_4, { 0x4006400 } ++ }, ++/* iwrite (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_indirect_4, { 0x4006400 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_4, { 0x2006400 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_4, { 0x2106400 } ++ }, ++/* iwrite (${d-An},${d-r}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_with_post_increment_4, { 0x3006200 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_with_post_increment_4, { 0x4006200 } ++ }, ++/* iwrite (${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_indirect_with_post_increment_4, { 0x4006200 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_with_post_increment_4, { 0x2006200 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_with_post_increment_4, { 0x2106200 } ++ }, ++/* iwrite (${d-An},${d-r}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_index_s1_indirect_with_pre_increment_4, { 0x3006210 } ++ }, ++/* iwrite ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_offset_s1_indirect_with_pre_increment_4, { 0x4006210 } ++ }, ++/* iwrite (${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_s1_indirect_with_pre_increment_4, { 0x4006210 } ++ }, ++/* iwrite (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_post_increment_s1_indirect_with_pre_increment_4, { 0x2006210 } ++ }, ++/* iwrite ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_iwrite_d_pea_indirect_with_pre_increment_s1_indirect_with_pre_increment_4, { 0x2106210 } ++ }, ++/* move.2 ${d-direct-addr},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_direct_s1_direct, { 0x1006900 } ++ }, ++/* move.2 #${d-imm8},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_direct, { 0x6900 } ++ }, ++/* move.2 (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_direct, { 0x3006900 } ++ }, ++/* move.2 ${d-imm7-2}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_direct, { 0x4006900 } ++ }, ++/* move.2 (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_direct, { 0x4006900 } ++ }, ++/* move.2 (${d-An})${d-i4-2}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_direct, { 0x2006900 } ++ }, ++/* move.2 ${d-i4-2}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_direct, { 0x2106900 } ++ }, ++/* move.2 ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_direct_s1_immediate, { 0x1006800 } ++ }, ++/* move.2 #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_immediate, { 0x6800 } ++ }, ++/* move.2 (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_immediate, { 0x3006800 } ++ }, ++/* move.2 ${d-imm7-2}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_immediate, { 0x4006800 } ++ }, ++/* move.2 (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_immediate, { 0x4006800 } ++ }, ++/* move.2 (${d-An})${d-i4-2}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_immediate, { 0x2006800 } ++ }, ++/* move.2 ${d-i4-2}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_immediate, { 0x2106800 } ++ }, ++/* move.2 ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_index_2, { 0x1006b00 } ++ }, ++/* move.2 #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_index_2, { 0x6b00 } ++ }, ++/* move.2 (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_index_2, { 0x3006b00 } ++ }, ++/* move.2 ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_index_2, { 0x4006b00 } ++ }, ++/* move.2 (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_index_2, { 0x4006b00 } ++ }, ++/* move.2 (${d-An})${d-i4-2}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_index_2, { 0x2006b00 } ++ }, ++/* move.2 ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_index_2, { 0x2106b00 } ++ }, ++/* move.2 ${d-direct-addr},${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_offset_2, { 0x1006c00 } ++ }, ++/* move.2 #${d-imm8},${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_offset_2, { 0x6c00 } ++ }, ++/* move.2 (${d-An},${d-r}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_offset_2, { 0x3006c00 } ++ }, ++/* move.2 ${d-imm7-2}(${d-An}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_offset_2, { 0x4006c00 } ++ }, ++/* move.2 (${d-An}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_offset_2, { 0x4006c00 } ++ }, ++/* move.2 (${d-An})${d-i4-2}++,${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_offset_2, { 0x2006c00 } ++ }, ++/* move.2 ${d-i4-2}(${d-An})++,${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_offset_2, { 0x2106c00 } ++ }, ++/* move.2 ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_2, { 0x1006c00 } ++ }, ++/* move.2 #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_2, { 0x6c00 } ++ }, ++/* move.2 (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_2, { 0x3006c00 } ++ }, ++/* move.2 ${d-imm7-2}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_2, { 0x4006c00 } ++ }, ++/* move.2 (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_2, { 0x4006c00 } ++ }, ++/* move.2 (${d-An})${d-i4-2}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_2, { 0x2006c00 } ++ }, ++/* move.2 ${d-i4-2}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_2, { 0x2106c00 } ++ }, ++/* move.2 ${d-direct-addr},(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_post_increment_2, { 0x1006a00 } ++ }, ++/* move.2 #${d-imm8},(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_post_increment_2, { 0x6a00 } ++ }, ++/* move.2 (${d-An},${d-r}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_post_increment_2, { 0x3006a00 } ++ }, ++/* move.2 ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_post_increment_2, { 0x4006a00 } ++ }, ++/* move.2 (${d-An}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_post_increment_2, { 0x4006a00 } ++ }, ++/* move.2 (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_2, { 0x2006a00 } ++ }, ++/* move.2 ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_2, { 0x2106a00 } ++ }, ++/* move.2 ${d-direct-addr},${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_pre_increment_2, { 0x1006a10 } ++ }, ++/* move.2 #${d-imm8},${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_pre_increment_2, { 0x6a10 } ++ }, ++/* move.2 (${d-An},${d-r}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_pre_increment_2, { 0x3006a10 } ++ }, ++/* move.2 ${d-imm7-2}(${d-An}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_pre_increment_2, { 0x4006a10 } ++ }, ++/* move.2 (${d-An}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_pre_increment_2, { 0x4006a10 } ++ }, ++/* move.2 (${d-An})${d-i4-2}++,${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_2, { 0x2006a10 } ++ }, ++/* move.2 ${d-i4-2}(${d-An})++,${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_2, { 0x2106a10 } ++ }, ++/* move.1 ${d-direct-addr},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_direct_s1_direct, { 0x1007900 } ++ }, ++/* move.1 #${d-imm8},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_direct, { 0x7900 } ++ }, ++/* move.1 (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_direct, { 0x3007900 } ++ }, ++/* move.1 ${d-imm7-1}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_direct, { 0x4007900 } ++ }, ++/* move.1 (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_direct, { 0x4007900 } ++ }, ++/* move.1 (${d-An})${d-i4-1}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_direct, { 0x2007900 } ++ }, ++/* move.1 ${d-i4-1}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_direct, { 0x2107900 } ++ }, ++/* move.1 ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_direct_s1_immediate, { 0x1007800 } ++ }, ++/* move.1 #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_immediate, { 0x7800 } ++ }, ++/* move.1 (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_immediate, { 0x3007800 } ++ }, ++/* move.1 ${d-imm7-1}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_immediate, { 0x4007800 } ++ }, ++/* move.1 (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_immediate, { 0x4007800 } ++ }, ++/* move.1 (${d-An})${d-i4-1}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_immediate, { 0x2007800 } ++ }, ++/* move.1 ${d-i4-1}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_immediate, { 0x2107800 } ++ }, ++/* move.1 ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_direct_s1_indirect_with_index_1, { 0x1007b00 } ++ }, ++/* move.1 #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_indirect_with_index_1, { 0x7b00 } ++ }, ++/* move.1 (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_indirect_with_index_1, { 0x3007b00 } ++ }, ++/* move.1 ${d-imm7-1}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_indirect_with_index_1, { 0x4007b00 } ++ }, ++/* move.1 (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_indirect_with_index_1, { 0x4007b00 } ++ }, ++/* move.1 (${d-An})${d-i4-1}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_with_index_1, { 0x2007b00 } ++ }, ++/* move.1 ${d-i4-1}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_with_index_1, { 0x2107b00 } ++ }, ++/* move.1 ${d-direct-addr},${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_direct_s1_indirect_with_offset_1, { 0x1007c00 } ++ }, ++/* move.1 #${d-imm8},${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_indirect_with_offset_1, { 0x7c00 } ++ }, ++/* move.1 (${d-An},${d-r}),${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_indirect_with_offset_1, { 0x3007c00 } ++ }, ++/* move.1 ${d-imm7-1}(${d-An}),${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_indirect_with_offset_1, { 0x4007c00 } ++ }, ++/* move.1 (${d-An}),${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_indirect_with_offset_1, { 0x4007c00 } ++ }, ++/* move.1 (${d-An})${d-i4-1}++,${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_with_offset_1, { 0x2007c00 } ++ }, ++/* move.1 ${d-i4-1}(${d-An})++,${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_with_offset_1, { 0x2107c00 } ++ }, ++/* move.1 ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_direct_s1_indirect_1, { 0x1007c00 } ++ }, ++/* move.1 #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_indirect_1, { 0x7c00 } ++ }, ++/* move.1 (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_indirect_1, { 0x3007c00 } ++ }, ++/* move.1 ${d-imm7-1}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_indirect_1, { 0x4007c00 } ++ }, ++/* move.1 (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_indirect_1, { 0x4007c00 } ++ }, ++/* move.1 (${d-An})${d-i4-1}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_1, { 0x2007c00 } ++ }, ++/* move.1 ${d-i4-1}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_1, { 0x2107c00 } ++ }, ++/* move.1 ${d-direct-addr},(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_direct_s1_indirect_with_post_increment_1, { 0x1007a00 } ++ }, ++/* move.1 #${d-imm8},(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_indirect_with_post_increment_1, { 0x7a00 } ++ }, ++/* move.1 (${d-An},${d-r}),(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_indirect_with_post_increment_1, { 0x3007a00 } ++ }, ++/* move.1 ${d-imm7-1}(${d-An}),(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_indirect_with_post_increment_1, { 0x4007a00 } ++ }, ++/* move.1 (${d-An}),(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_indirect_with_post_increment_1, { 0x4007a00 } ++ }, ++/* move.1 (${d-An})${d-i4-1}++,(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_with_post_increment_1, { 0x2007a00 } ++ }, ++/* move.1 ${d-i4-1}(${d-An})++,(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_with_post_increment_1, { 0x2107a00 } ++ }, ++/* move.1 ${d-direct-addr},${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_direct_s1_indirect_with_pre_increment_1, { 0x1007a10 } ++ }, ++/* move.1 #${d-imm8},${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_indirect_with_pre_increment_1, { 0x7a10 } ++ }, ++/* move.1 (${d-An},${d-r}),${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_indirect_with_pre_increment_1, { 0x3007a10 } ++ }, ++/* move.1 ${d-imm7-1}(${d-An}),${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_indirect_with_pre_increment_1, { 0x4007a10 } ++ }, ++/* move.1 (${d-An}),${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_indirect_with_pre_increment_1, { 0x4007a10 } ++ }, ++/* move.1 (${d-An})${d-i4-1}++,${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_with_pre_increment_1, { 0x2007a10 } ++ }, ++/* move.1 ${d-i4-1}(${d-An})++,${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_with_pre_increment_1, { 0x2107a10 } ++ }, ++/* ext.2 ${d-direct-addr},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_direct_s1_direct, { 0x100a900 } ++ }, ++/* ext.2 #${d-imm8},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_direct, { 0xa900 } ++ }, ++/* ext.2 (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_direct, { 0x300a900 } ++ }, ++/* ext.2 ${d-imm7-2}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_direct, { 0x400a900 } ++ }, ++/* ext.2 (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_direct, { 0x400a900 } ++ }, ++/* ext.2 (${d-An})${d-i4-2}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_direct, { 0x200a900 } ++ }, ++/* ext.2 ${d-i4-2}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_direct, { 0x210a900 } ++ }, ++/* ext.2 ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_direct_s1_immediate, { 0x100a800 } ++ }, ++/* ext.2 #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_immediate, { 0xa800 } ++ }, ++/* ext.2 (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_immediate, { 0x300a800 } ++ }, ++/* ext.2 ${d-imm7-2}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_immediate, { 0x400a800 } ++ }, ++/* ext.2 (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_immediate, { 0x400a800 } ++ }, ++/* ext.2 (${d-An})${d-i4-2}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_immediate, { 0x200a800 } ++ }, ++/* ext.2 ${d-i4-2}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_immediate, { 0x210a800 } ++ }, ++/* ext.2 ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_index_2, { 0x100ab00 } ++ }, ++/* ext.2 #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_index_2, { 0xab00 } ++ }, ++/* ext.2 (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_index_2, { 0x300ab00 } ++ }, ++/* ext.2 ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_index_2, { 0x400ab00 } ++ }, ++/* ext.2 (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_index_2, { 0x400ab00 } ++ }, ++/* ext.2 (${d-An})${d-i4-2}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_index_2, { 0x200ab00 } ++ }, ++/* ext.2 ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_index_2, { 0x210ab00 } ++ }, ++/* ext.2 ${d-direct-addr},${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_offset_2, { 0x100ac00 } ++ }, ++/* ext.2 #${d-imm8},${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_offset_2, { 0xac00 } ++ }, ++/* ext.2 (${d-An},${d-r}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_offset_2, { 0x300ac00 } ++ }, ++/* ext.2 ${d-imm7-2}(${d-An}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_offset_2, { 0x400ac00 } ++ }, ++/* ext.2 (${d-An}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_offset_2, { 0x400ac00 } ++ }, ++/* ext.2 (${d-An})${d-i4-2}++,${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_offset_2, { 0x200ac00 } ++ }, ++/* ext.2 ${d-i4-2}(${d-An})++,${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_offset_2, { 0x210ac00 } ++ }, ++/* ext.2 ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_2, { 0x100ac00 } ++ }, ++/* ext.2 #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_2, { 0xac00 } ++ }, ++/* ext.2 (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_2, { 0x300ac00 } ++ }, ++/* ext.2 ${d-imm7-2}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_2, { 0x400ac00 } ++ }, ++/* ext.2 (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_2, { 0x400ac00 } ++ }, ++/* ext.2 (${d-An})${d-i4-2}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_2, { 0x200ac00 } ++ }, ++/* ext.2 ${d-i4-2}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_2, { 0x210ac00 } ++ }, ++/* ext.2 ${d-direct-addr},(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_post_increment_2, { 0x100aa00 } ++ }, ++/* ext.2 #${d-imm8},(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_post_increment_2, { 0xaa00 } ++ }, ++/* ext.2 (${d-An},${d-r}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_post_increment_2, { 0x300aa00 } ++ }, ++/* ext.2 ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_post_increment_2, { 0x400aa00 } ++ }, ++/* ext.2 (${d-An}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_post_increment_2, { 0x400aa00 } ++ }, ++/* ext.2 (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_2, { 0x200aa00 } ++ }, ++/* ext.2 ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_2, { 0x210aa00 } ++ }, ++/* ext.2 ${d-direct-addr},${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_pre_increment_2, { 0x100aa10 } ++ }, ++/* ext.2 #${d-imm8},${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_pre_increment_2, { 0xaa10 } ++ }, ++/* ext.2 (${d-An},${d-r}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_pre_increment_2, { 0x300aa10 } ++ }, ++/* ext.2 ${d-imm7-2}(${d-An}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_pre_increment_2, { 0x400aa10 } ++ }, ++/* ext.2 (${d-An}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_pre_increment_2, { 0x400aa10 } ++ }, ++/* ext.2 (${d-An})${d-i4-2}++,${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_2, { 0x200aa10 } ++ }, ++/* ext.2 ${d-i4-2}(${d-An})++,${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_2, { 0x210aa10 } ++ }, ++/* ext.1 ${d-direct-addr},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_direct_s1_direct, { 0x100b900 } ++ }, ++/* ext.1 #${d-imm8},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_direct, { 0xb900 } ++ }, ++/* ext.1 (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_direct, { 0x300b900 } ++ }, ++/* ext.1 ${d-imm7-1}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_direct, { 0x400b900 } ++ }, ++/* ext.1 (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_direct, { 0x400b900 } ++ }, ++/* ext.1 (${d-An})${d-i4-1}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_direct, { 0x200b900 } ++ }, ++/* ext.1 ${d-i4-1}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_direct, { 0x210b900 } ++ }, ++/* ext.1 ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_direct_s1_immediate, { 0x100b800 } ++ }, ++/* ext.1 #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_immediate, { 0xb800 } ++ }, ++/* ext.1 (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_immediate, { 0x300b800 } ++ }, ++/* ext.1 ${d-imm7-1}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_immediate, { 0x400b800 } ++ }, ++/* ext.1 (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_immediate, { 0x400b800 } ++ }, ++/* ext.1 (${d-An})${d-i4-1}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_immediate, { 0x200b800 } ++ }, ++/* ext.1 ${d-i4-1}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_immediate, { 0x210b800 } ++ }, ++/* ext.1 ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_direct_s1_indirect_with_index_1, { 0x100bb00 } ++ }, ++/* ext.1 #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_indirect_with_index_1, { 0xbb00 } ++ }, ++/* ext.1 (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_indirect_with_index_1, { 0x300bb00 } ++ }, ++/* ext.1 ${d-imm7-1}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_indirect_with_index_1, { 0x400bb00 } ++ }, ++/* ext.1 (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_indirect_with_index_1, { 0x400bb00 } ++ }, ++/* ext.1 (${d-An})${d-i4-1}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_with_index_1, { 0x200bb00 } ++ }, ++/* ext.1 ${d-i4-1}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_with_index_1, { 0x210bb00 } ++ }, ++/* ext.1 ${d-direct-addr},${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_direct_s1_indirect_with_offset_1, { 0x100bc00 } ++ }, ++/* ext.1 #${d-imm8},${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_indirect_with_offset_1, { 0xbc00 } ++ }, ++/* ext.1 (${d-An},${d-r}),${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_indirect_with_offset_1, { 0x300bc00 } ++ }, ++/* ext.1 ${d-imm7-1}(${d-An}),${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_indirect_with_offset_1, { 0x400bc00 } ++ }, ++/* ext.1 (${d-An}),${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_indirect_with_offset_1, { 0x400bc00 } ++ }, ++/* ext.1 (${d-An})${d-i4-1}++,${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_with_offset_1, { 0x200bc00 } ++ }, ++/* ext.1 ${d-i4-1}(${d-An})++,${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_with_offset_1, { 0x210bc00 } ++ }, ++/* ext.1 ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_direct_s1_indirect_1, { 0x100bc00 } ++ }, ++/* ext.1 #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_indirect_1, { 0xbc00 } ++ }, ++/* ext.1 (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_indirect_1, { 0x300bc00 } ++ }, ++/* ext.1 ${d-imm7-1}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_indirect_1, { 0x400bc00 } ++ }, ++/* ext.1 (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_indirect_1, { 0x400bc00 } ++ }, ++/* ext.1 (${d-An})${d-i4-1}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_1, { 0x200bc00 } ++ }, ++/* ext.1 ${d-i4-1}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_1, { 0x210bc00 } ++ }, ++/* ext.1 ${d-direct-addr},(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_direct_s1_indirect_with_post_increment_1, { 0x100ba00 } ++ }, ++/* ext.1 #${d-imm8},(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_indirect_with_post_increment_1, { 0xba00 } ++ }, ++/* ext.1 (${d-An},${d-r}),(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_indirect_with_post_increment_1, { 0x300ba00 } ++ }, ++/* ext.1 ${d-imm7-1}(${d-An}),(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_indirect_with_post_increment_1, { 0x400ba00 } ++ }, ++/* ext.1 (${d-An}),(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_indirect_with_post_increment_1, { 0x400ba00 } ++ }, ++/* ext.1 (${d-An})${d-i4-1}++,(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_with_post_increment_1, { 0x200ba00 } ++ }, ++/* ext.1 ${d-i4-1}(${d-An})++,(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_with_post_increment_1, { 0x210ba00 } ++ }, ++/* ext.1 ${d-direct-addr},${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_direct_s1_indirect_with_pre_increment_1, { 0x100ba10 } ++ }, ++/* ext.1 #${d-imm8},${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_immediate_1_s1_indirect_with_pre_increment_1, { 0xba10 } ++ }, ++/* ext.1 (${d-An},${d-r}),${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_index_1_s1_indirect_with_pre_increment_1, { 0x300ba10 } ++ }, ++/* ext.1 ${d-imm7-1}(${d-An}),${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_offset_1_s1_indirect_with_pre_increment_1, { 0x400ba10 } ++ }, ++/* ext.1 (${d-An}),${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_1_s1_indirect_with_pre_increment_1, { 0x400ba10 } ++ }, ++/* ext.1 (${d-An})${d-i4-1}++,${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_post_increment_1_s1_indirect_with_pre_increment_1, { 0x200ba10 } ++ }, ++/* ext.1 ${d-i4-1}(${d-An})++,${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_1_d_indirect_with_pre_increment_1_s1_indirect_with_pre_increment_1, { 0x210ba10 } ++ }, ++/* movei ${d-direct-addr},#${imm16-2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (IMM16_2), 0 } }, ++ & ifmt_movei_d_direct, { 0xc9000000 } ++ }, ++/* movei #${d-imm8},#${imm16-2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (IMM16_2), 0 } }, ++ & ifmt_movei_d_immediate_2, { 0xc8000000 } ++ }, ++/* movei (${d-An},${d-r}),#${imm16-2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (IMM16_2), 0 } }, ++ & ifmt_movei_d_indirect_with_index_2, { 0xcb000000 } ++ }, ++/* movei ${d-imm7-2}(${d-An}),#${imm16-2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (IMM16_2), 0 } }, ++ & ifmt_movei_d_indirect_with_offset_2, { 0xcc000000 } ++ }, ++/* movei (${d-An}),#${imm16-2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (IMM16_2), 0 } }, ++ & ifmt_movei_d_indirect_2, { 0xcc000000 } ++ }, ++/* movei (${d-An})${d-i4-2}++,#${imm16-2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (IMM16_2), 0 } }, ++ & ifmt_movei_d_indirect_with_post_increment_2, { 0xca000000 } ++ }, ++/* movei ${d-i4-2}(${d-An})++,#${imm16-2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (IMM16_2), 0 } }, ++ & ifmt_movei_d_indirect_with_pre_increment_2, { 0xca100000 } ++ }, ++/* bclr ${d-direct-addr},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_direct, { 0x29000100 } ++ }, ++/* bclr #${d-imm8},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_direct, { 0x28000100 } ++ }, ++/* bclr (${d-An},${d-r}),${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_direct, { 0x2b000100 } ++ }, ++/* bclr ${d-imm7-4}(${d-An}),${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_direct, { 0x2c000100 } ++ }, ++/* bclr (${d-An}),${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_direct, { 0x2c000100 } ++ }, ++/* bclr (${d-An})${d-i4-4}++,${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_direct, { 0x2a000100 } ++ }, ++/* bclr ${d-i4-4}(${d-An})++,${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_direct, { 0x2a100100 } ++ }, ++/* bclr ${d-direct-addr},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_immediate, { 0x29000000 } ++ }, ++/* bclr #${d-imm8},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_immediate, { 0x28000000 } ++ }, ++/* bclr (${d-An},${d-r}),#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_immediate, { 0x2b000000 } ++ }, ++/* bclr ${d-imm7-4}(${d-An}),#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_immediate, { 0x2c000000 } ++ }, ++/* bclr (${d-An}),#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_immediate, { 0x2c000000 } ++ }, ++/* bclr (${d-An})${d-i4-4}++,#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_immediate, { 0x2a000000 } ++ }, ++/* bclr ${d-i4-4}(${d-An})++,#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_immediate, { 0x2a100000 } ++ }, ++/* bclr ${d-direct-addr},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_indirect_with_index_4, { 0x29000300 } ++ }, ++/* bclr #${d-imm8},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_indirect_with_index_4, { 0x28000300 } ++ }, ++/* bclr (${d-An},${d-r}),(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x2b000300 } ++ }, ++/* bclr ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x2c000300 } ++ }, ++/* bclr (${d-An}),(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_indirect_with_index_4, { 0x2c000300 } ++ }, ++/* bclr (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x2a000300 } ++ }, ++/* bclr ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x2a100300 } ++ }, ++/* bclr ${d-direct-addr},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_indirect_with_offset_4, { 0x29000400 } ++ }, ++/* bclr #${d-imm8},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_indirect_with_offset_4, { 0x28000400 } ++ }, ++/* bclr (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x2b000400 } ++ }, ++/* bclr ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x2c000400 } ++ }, ++/* bclr (${d-An}),${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_indirect_with_offset_4, { 0x2c000400 } ++ }, ++/* bclr (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x2a000400 } ++ }, ++/* bclr ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x2a100400 } ++ }, ++/* bclr ${d-direct-addr},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_indirect_4, { 0x29000400 } ++ }, ++/* bclr #${d-imm8},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_indirect_4, { 0x28000400 } ++ }, ++/* bclr (${d-An},${d-r}),(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_indirect_4, { 0x2b000400 } ++ }, ++/* bclr ${d-imm7-4}(${d-An}),(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_indirect_4, { 0x2c000400 } ++ }, ++/* bclr (${d-An}),(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_indirect_4, { 0x2c000400 } ++ }, ++/* bclr (${d-An})${d-i4-4}++,(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_4, { 0x2a000400 } ++ }, ++/* bclr ${d-i4-4}(${d-An})++,(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x2a100400 } ++ }, ++/* bclr ${d-direct-addr},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_indirect_with_post_increment_4, { 0x29000200 } ++ }, ++/* bclr #${d-imm8},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_indirect_with_post_increment_4, { 0x28000200 } ++ }, ++/* bclr (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x2b000200 } ++ }, ++/* bclr ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x2c000200 } ++ }, ++/* bclr (${d-An}),(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_indirect_with_post_increment_4, { 0x2c000200 } ++ }, ++/* bclr (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x2a000200 } ++ }, ++/* bclr ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x2a100200 } ++ }, ++/* bclr ${d-direct-addr},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_indirect_with_pre_increment_4, { 0x29000210 } ++ }, ++/* bclr #${d-imm8},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_indirect_with_pre_increment_4, { 0x28000210 } ++ }, ++/* bclr (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x2b000210 } ++ }, ++/* bclr ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x2c000210 } ++ }, ++/* bclr (${d-An}),${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x2c000210 } ++ }, ++/* bclr (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x2a000210 } ++ }, ++/* bclr ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x2a100210 } ++ }, ++/* bset ${d-direct-addr},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_direct, { 0x21000100 } ++ }, ++/* bset #${d-imm8},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_direct, { 0x20000100 } ++ }, ++/* bset (${d-An},${d-r}),${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_direct, { 0x23000100 } ++ }, ++/* bset ${d-imm7-4}(${d-An}),${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_direct, { 0x24000100 } ++ }, ++/* bset (${d-An}),${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_direct, { 0x24000100 } ++ }, ++/* bset (${d-An})${d-i4-4}++,${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_direct, { 0x22000100 } ++ }, ++/* bset ${d-i4-4}(${d-An})++,${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_direct, { 0x22100100 } ++ }, ++/* bset ${d-direct-addr},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_immediate, { 0x21000000 } ++ }, ++/* bset #${d-imm8},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_immediate, { 0x20000000 } ++ }, ++/* bset (${d-An},${d-r}),#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_immediate, { 0x23000000 } ++ }, ++/* bset ${d-imm7-4}(${d-An}),#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_immediate, { 0x24000000 } ++ }, ++/* bset (${d-An}),#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_immediate, { 0x24000000 } ++ }, ++/* bset (${d-An})${d-i4-4}++,#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_immediate, { 0x22000000 } ++ }, ++/* bset ${d-i4-4}(${d-An})++,#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_immediate, { 0x22100000 } ++ }, ++/* bset ${d-direct-addr},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_indirect_with_index_4, { 0x21000300 } ++ }, ++/* bset #${d-imm8},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_indirect_with_index_4, { 0x20000300 } ++ }, ++/* bset (${d-An},${d-r}),(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x23000300 } ++ }, ++/* bset ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x24000300 } ++ }, ++/* bset (${d-An}),(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_indirect_with_index_4, { 0x24000300 } ++ }, ++/* bset (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x22000300 } ++ }, ++/* bset ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x22100300 } ++ }, ++/* bset ${d-direct-addr},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_indirect_with_offset_4, { 0x21000400 } ++ }, ++/* bset #${d-imm8},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_indirect_with_offset_4, { 0x20000400 } ++ }, ++/* bset (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x23000400 } ++ }, ++/* bset ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x24000400 } ++ }, ++/* bset (${d-An}),${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_indirect_with_offset_4, { 0x24000400 } ++ }, ++/* bset (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x22000400 } ++ }, ++/* bset ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x22100400 } ++ }, ++/* bset ${d-direct-addr},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_indirect_4, { 0x21000400 } ++ }, ++/* bset #${d-imm8},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_indirect_4, { 0x20000400 } ++ }, ++/* bset (${d-An},${d-r}),(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_indirect_4, { 0x23000400 } ++ }, ++/* bset ${d-imm7-4}(${d-An}),(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_indirect_4, { 0x24000400 } ++ }, ++/* bset (${d-An}),(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_indirect_4, { 0x24000400 } ++ }, ++/* bset (${d-An})${d-i4-4}++,(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_4, { 0x22000400 } ++ }, ++/* bset ${d-i4-4}(${d-An})++,(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x22100400 } ++ }, ++/* bset ${d-direct-addr},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_indirect_with_post_increment_4, { 0x21000200 } ++ }, ++/* bset #${d-imm8},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_indirect_with_post_increment_4, { 0x20000200 } ++ }, ++/* bset (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x23000200 } ++ }, ++/* bset ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x24000200 } ++ }, ++/* bset (${d-An}),(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_indirect_with_post_increment_4, { 0x24000200 } ++ }, ++/* bset (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x22000200 } ++ }, ++/* bset ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x22100200 } ++ }, ++/* bset ${d-direct-addr},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_direct_s1_indirect_with_pre_increment_4, { 0x21000210 } ++ }, ++/* bset #${d-imm8},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_immediate_4_s1_indirect_with_pre_increment_4, { 0x20000210 } ++ }, ++/* bset (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x23000210 } ++ }, ++/* bset ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x24000210 } ++ }, ++/* bset (${d-An}),${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x24000210 } ++ }, ++/* bset (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x22000210 } ++ }, ++/* bset ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bclr_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x22100210 } ++ }, ++/* btst ${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_direct_imm_bit5, { 0x10c00100 } ++ }, ++/* btst #${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_immediate_imm_bit5, { 0x10c00000 } ++ }, ++/* btst (${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_indirect_with_index_4_imm_bit5, { 0x10c00300 } ++ }, ++/* btst ${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_indirect_with_offset_4_imm_bit5, { 0x10c00400 } ++ }, ++/* btst (${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_indirect_4_imm_bit5, { 0x10c00400 } ++ }, ++/* btst (${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_indirect_with_post_increment_4_imm_bit5, { 0x10c00200 } ++ }, ++/* btst ${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_indirect_with_pre_increment_4_imm_bit5, { 0x10c00210 } ++ }, ++/* btst ${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_direct_dyn_reg, { 0x14c00100 } ++ }, ++/* btst #${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_immediate_dyn_reg, { 0x14c00000 } ++ }, ++/* btst (${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_indirect_with_index_4_dyn_reg, { 0x14c00300 } ++ }, ++/* btst ${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_indirect_with_offset_4_dyn_reg, { 0x14c00400 } ++ }, ++/* btst (${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_indirect_4_dyn_reg, { 0x14c00400 } ++ }, ++/* btst (${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_indirect_with_post_increment_4_dyn_reg, { 0x14c00200 } ++ }, ++/* btst ${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_indirect_with_pre_increment_4_dyn_reg, { 0x14c00210 } ++ }, ++/* shmrg.2 ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_direct, { 0x13c00100 } ++ }, ++/* shmrg.2 ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_direct, { 0x17c00100 } ++ }, ++/* shmrg.2 ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_immediate, { 0x13c00000 } ++ }, ++/* shmrg.2 ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_immediate, { 0x17c00000 } ++ }, ++/* shmrg.2 ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_index_2, { 0x13c00300 } ++ }, ++/* shmrg.2 ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_index_2, { 0x17c00300 } ++ }, ++/* shmrg.2 ${Dn},${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_offset_2, { 0x13c00400 } ++ }, ++/* shmrg.2 ${Dn},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_offset_2, { 0x17c00400 } ++ }, ++/* shmrg.2 ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_2, { 0x13c00400 } ++ }, ++/* shmrg.2 ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_2, { 0x17c00400 } ++ }, ++/* shmrg.2 ${Dn},(${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_post_increment_2, { 0x13c00200 } ++ }, ++/* shmrg.2 ${Dn},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_post_increment_2, { 0x17c00200 } ++ }, ++/* shmrg.2 ${Dn},${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_pre_increment_2, { 0x13c00210 } ++ }, ++/* shmrg.2 ${Dn},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_pre_increment_2, { 0x17c00210 } ++ }, ++/* shmrg.1 ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_direct, { 0x13e00100 } ++ }, ++/* shmrg.1 ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_direct, { 0x17e00100 } ++ }, ++/* shmrg.1 ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_immediate, { 0x13e00000 } ++ }, ++/* shmrg.1 ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_immediate, { 0x17e00000 } ++ }, ++/* shmrg.1 ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_index_1, { 0x13e00300 } ++ }, ++/* shmrg.1 ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_index_1, { 0x17e00300 } ++ }, ++/* shmrg.1 ${Dn},${s1-imm7-1}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_offset_1, { 0x13e00400 } ++ }, ++/* shmrg.1 ${Dn},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_offset_1, { 0x17e00400 } ++ }, ++/* shmrg.1 ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_1, { 0x13e00400 } ++ }, ++/* shmrg.1 ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_1, { 0x17e00400 } ++ }, ++/* shmrg.1 ${Dn},(${s1-An})${s1-i4-1}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_post_increment_1, { 0x13e00200 } ++ }, ++/* shmrg.1 ${Dn},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_post_increment_1, { 0x17e00200 } ++ }, ++/* shmrg.1 ${Dn},${s1-i4-1}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_pre_increment_1, { 0x13e00210 } ++ }, ++/* shmrg.1 ${Dn},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_pre_increment_1, { 0x17e00210 } ++ }, ++/* crcgen ${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_direct_imm_bit5, { 0x11000100 } ++ }, ++/* crcgen #${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_immediate_imm_bit5, { 0x11000000 } ++ }, ++/* crcgen (${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_crcgen_s1_indirect_with_index_1_imm_bit5, { 0x11000300 } ++ }, ++/* crcgen ${s1-imm7-1}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_crcgen_s1_indirect_with_offset_1_imm_bit5, { 0x11000400 } ++ }, ++/* crcgen (${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_crcgen_s1_indirect_1_imm_bit5, { 0x11000400 } ++ }, ++/* crcgen (${s1-An})${s1-i4-1}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_crcgen_s1_indirect_with_post_increment_1_imm_bit5, { 0x11000200 } ++ }, ++/* crcgen ${s1-i4-1}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_crcgen_s1_indirect_with_pre_increment_1_imm_bit5, { 0x11000210 } ++ }, ++/* crcgen ${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_direct_dyn_reg, { 0x15000100 } ++ }, ++/* crcgen #${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_immediate_dyn_reg, { 0x15000000 } ++ }, ++/* crcgen (${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_crcgen_s1_indirect_with_index_1_dyn_reg, { 0x15000300 } ++ }, ++/* crcgen ${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_crcgen_s1_indirect_with_offset_1_dyn_reg, { 0x15000400 } ++ }, ++/* crcgen (${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_crcgen_s1_indirect_1_dyn_reg, { 0x15000400 } ++ }, ++/* crcgen (${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_crcgen_s1_indirect_with_post_increment_1_dyn_reg, { 0x15000200 } ++ }, ++/* crcgen ${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_crcgen_s1_indirect_with_pre_increment_1_dyn_reg, { 0x15000210 } ++ }, ++/* bfextu ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_direct_imm_bit5, { 0x12c00100 } ++ }, ++/* bfextu ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_immediate_imm_bit5, { 0x12c00000 } ++ }, ++/* bfextu ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_index_4_imm_bit5, { 0x12c00300 } ++ }, ++/* bfextu ${Dn},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_offset_4_imm_bit5, { 0x12c00400 } ++ }, ++/* bfextu ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_4_imm_bit5, { 0x12c00400 } ++ }, ++/* bfextu ${Dn},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_post_increment_4_imm_bit5, { 0x12c00200 } ++ }, ++/* bfextu ${Dn},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_pre_increment_4_imm_bit5, { 0x12c00210 } ++ }, ++/* bfextu ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_direct_dyn_reg, { 0x16c00100 } ++ }, ++/* bfextu ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_immediate_dyn_reg, { 0x16c00000 } ++ }, ++/* bfextu ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_index_4_dyn_reg, { 0x16c00300 } ++ }, ++/* bfextu ${Dn},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_offset_4_dyn_reg, { 0x16c00400 } ++ }, ++/* bfextu ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_4_dyn_reg, { 0x16c00400 } ++ }, ++/* bfextu ${Dn},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_post_increment_4_dyn_reg, { 0x16c00200 } ++ }, ++/* bfextu ${Dn},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_pre_increment_4_dyn_reg, { 0x16c00210 } ++ }, ++/* bfrvrs ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_direct_imm_bit5, { 0x13000100 } ++ }, ++/* bfrvrs ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_immediate_imm_bit5, { 0x13000000 } ++ }, ++/* bfrvrs ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_index_4_imm_bit5, { 0x13000300 } ++ }, ++/* bfrvrs ${Dn},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_offset_4_imm_bit5, { 0x13000400 } ++ }, ++/* bfrvrs ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_4_imm_bit5, { 0x13000400 } ++ }, ++/* bfrvrs ${Dn},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_post_increment_4_imm_bit5, { 0x13000200 } ++ }, ++/* bfrvrs ${Dn},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_pre_increment_4_imm_bit5, { 0x13000210 } ++ }, ++/* bfrvrs ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_direct_dyn_reg, { 0x17000100 } ++ }, ++/* bfrvrs ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_immediate_dyn_reg, { 0x17000000 } ++ }, ++/* bfrvrs ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_index_4_dyn_reg, { 0x17000300 } ++ }, ++/* bfrvrs ${Dn},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_offset_4_dyn_reg, { 0x17000400 } ++ }, ++/* bfrvrs ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_4_dyn_reg, { 0x17000400 } ++ }, ++/* bfrvrs ${Dn},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_post_increment_4_dyn_reg, { 0x17000200 } ++ }, ++/* bfrvrs ${Dn},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_pre_increment_4_dyn_reg, { 0x17000210 } ++ }, ++/* merge ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_direct_imm_bit5, { 0x13800100 } ++ }, ++/* merge ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_immediate_imm_bit5, { 0x13800000 } ++ }, ++/* merge ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_index_4_imm_bit5, { 0x13800300 } ++ }, ++/* merge ${Dn},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_offset_4_imm_bit5, { 0x13800400 } ++ }, ++/* merge ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_4_imm_bit5, { 0x13800400 } ++ }, ++/* merge ${Dn},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_post_increment_4_imm_bit5, { 0x13800200 } ++ }, ++/* merge ${Dn},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_pre_increment_4_imm_bit5, { 0x13800210 } ++ }, ++/* merge ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_direct_dyn_reg, { 0x17800100 } ++ }, ++/* merge ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_immediate_dyn_reg, { 0x17800000 } ++ }, ++/* merge ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_index_4_dyn_reg, { 0x17800300 } ++ }, ++/* merge ${Dn},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_offset_4_dyn_reg, { 0x17800400 } ++ }, ++/* merge ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_4_dyn_reg, { 0x17800400 } ++ }, ++/* merge ${Dn},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_post_increment_4_dyn_reg, { 0x17800200 } ++ }, ++/* merge ${Dn},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_pre_increment_4_dyn_reg, { 0x17800210 } ++ }, ++/* shftd ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_direct_imm_bit5, { 0x13400100 } ++ }, ++/* shftd ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_immediate_imm_bit5, { 0x13400000 } ++ }, ++/* shftd ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_index_4_imm_bit5, { 0x13400300 } ++ }, ++/* shftd ${Dn},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_offset_4_imm_bit5, { 0x13400400 } ++ }, ++/* shftd ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_4_imm_bit5, { 0x13400400 } ++ }, ++/* shftd ${Dn},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_post_increment_4_imm_bit5, { 0x13400200 } ++ }, ++/* shftd ${Dn},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_pre_increment_4_imm_bit5, { 0x13400210 } ++ }, ++/* shftd ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_direct_dyn_reg, { 0x17400100 } ++ }, ++/* shftd ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_immediate_dyn_reg, { 0x17400000 } ++ }, ++/* shftd ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_index_4_dyn_reg, { 0x17400300 } ++ }, ++/* shftd ${Dn},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_offset_4_dyn_reg, { 0x17400400 } ++ }, ++/* shftd ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_4_dyn_reg, { 0x17400400 } ++ }, ++/* shftd ${Dn},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_post_increment_4_dyn_reg, { 0x17400200 } ++ }, ++/* shftd ${Dn},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_bfextu_s1_indirect_with_pre_increment_4_dyn_reg, { 0x17400210 } ++ }, ++/* asr.1 ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_direct, { 0x11800100 } ++ }, ++/* asr.1 ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_direct, { 0x15800100 } ++ }, ++/* asr.1 ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_immediate, { 0x11800000 } ++ }, ++/* asr.1 ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_immediate, { 0x15800000 } ++ }, ++/* asr.1 ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_index_1, { 0x11800300 } ++ }, ++/* asr.1 ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_index_1, { 0x15800300 } ++ }, ++/* asr.1 ${Dn},${s1-imm7-1}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_offset_1, { 0x11800400 } ++ }, ++/* asr.1 ${Dn},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_offset_1, { 0x15800400 } ++ }, ++/* asr.1 ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_1, { 0x11800400 } ++ }, ++/* asr.1 ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_1, { 0x15800400 } ++ }, ++/* asr.1 ${Dn},(${s1-An})${s1-i4-1}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_post_increment_1, { 0x11800200 } ++ }, ++/* asr.1 ${Dn},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_post_increment_1, { 0x15800200 } ++ }, ++/* asr.1 ${Dn},${s1-i4-1}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_pre_increment_1, { 0x11800210 } ++ }, ++/* asr.1 ${Dn},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_pre_increment_1, { 0x15800210 } ++ }, ++/* lsl.1 ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_direct, { 0x11400100 } ++ }, ++/* lsl.1 ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_direct, { 0x15400100 } ++ }, ++/* lsl.1 ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_immediate, { 0x11400000 } ++ }, ++/* lsl.1 ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_immediate, { 0x15400000 } ++ }, ++/* lsl.1 ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_index_1, { 0x11400300 } ++ }, ++/* lsl.1 ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_index_1, { 0x15400300 } ++ }, ++/* lsl.1 ${Dn},${s1-imm7-1}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_offset_1, { 0x11400400 } ++ }, ++/* lsl.1 ${Dn},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_offset_1, { 0x15400400 } ++ }, ++/* lsl.1 ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_1, { 0x11400400 } ++ }, ++/* lsl.1 ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_1, { 0x15400400 } ++ }, ++/* lsl.1 ${Dn},(${s1-An})${s1-i4-1}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_post_increment_1, { 0x11400200 } ++ }, ++/* lsl.1 ${Dn},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_post_increment_1, { 0x15400200 } ++ }, ++/* lsl.1 ${Dn},${s1-i4-1}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_pre_increment_1, { 0x11400210 } ++ }, ++/* lsl.1 ${Dn},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_pre_increment_1, { 0x15400210 } ++ }, ++/* lsr.1 ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_direct, { 0x11600100 } ++ }, ++/* lsr.1 ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_direct, { 0x15600100 } ++ }, ++/* lsr.1 ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_immediate, { 0x11600000 } ++ }, ++/* lsr.1 ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_immediate, { 0x15600000 } ++ }, ++/* lsr.1 ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_index_1, { 0x11600300 } ++ }, ++/* lsr.1 ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_index_1, { 0x15600300 } ++ }, ++/* lsr.1 ${Dn},${s1-imm7-1}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_offset_1, { 0x11600400 } ++ }, ++/* lsr.1 ${Dn},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_offset_1, { 0x15600400 } ++ }, ++/* lsr.1 ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_1, { 0x11600400 } ++ }, ++/* lsr.1 ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_1, { 0x15600400 } ++ }, ++/* lsr.1 ${Dn},(${s1-An})${s1-i4-1}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_post_increment_1, { 0x11600200 } ++ }, ++/* lsr.1 ${Dn},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_post_increment_1, { 0x15600200 } ++ }, ++/* lsr.1 ${Dn},${s1-i4-1}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_1_imm_bit5_s1_indirect_with_pre_increment_1, { 0x11600210 } ++ }, ++/* lsr.1 ${Dn},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_1_dyn_reg_s1_indirect_with_pre_increment_1, { 0x15600210 } ++ }, ++/* asr.2 ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_direct, { 0x12a00100 } ++ }, ++/* asr.2 ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_direct, { 0x16a00100 } ++ }, ++/* asr.2 ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_immediate, { 0x12a00000 } ++ }, ++/* asr.2 ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_immediate, { 0x16a00000 } ++ }, ++/* asr.2 ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_index_2, { 0x12a00300 } ++ }, ++/* asr.2 ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_index_2, { 0x16a00300 } ++ }, ++/* asr.2 ${Dn},${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_offset_2, { 0x12a00400 } ++ }, ++/* asr.2 ${Dn},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_offset_2, { 0x16a00400 } ++ }, ++/* asr.2 ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_2, { 0x12a00400 } ++ }, ++/* asr.2 ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_2, { 0x16a00400 } ++ }, ++/* asr.2 ${Dn},(${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_post_increment_2, { 0x12a00200 } ++ }, ++/* asr.2 ${Dn},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_post_increment_2, { 0x16a00200 } ++ }, ++/* asr.2 ${Dn},${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_pre_increment_2, { 0x12a00210 } ++ }, ++/* asr.2 ${Dn},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_pre_increment_2, { 0x16a00210 } ++ }, ++/* lsl.2 ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_direct, { 0x12200100 } ++ }, ++/* lsl.2 ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_direct, { 0x16200100 } ++ }, ++/* lsl.2 ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_immediate, { 0x12200000 } ++ }, ++/* lsl.2 ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_immediate, { 0x16200000 } ++ }, ++/* lsl.2 ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_index_2, { 0x12200300 } ++ }, ++/* lsl.2 ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_index_2, { 0x16200300 } ++ }, ++/* lsl.2 ${Dn},${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_offset_2, { 0x12200400 } ++ }, ++/* lsl.2 ${Dn},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_offset_2, { 0x16200400 } ++ }, ++/* lsl.2 ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_2, { 0x12200400 } ++ }, ++/* lsl.2 ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_2, { 0x16200400 } ++ }, ++/* lsl.2 ${Dn},(${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_post_increment_2, { 0x12200200 } ++ }, ++/* lsl.2 ${Dn},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_post_increment_2, { 0x16200200 } ++ }, ++/* lsl.2 ${Dn},${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_pre_increment_2, { 0x12200210 } ++ }, ++/* lsl.2 ${Dn},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_pre_increment_2, { 0x16200210 } ++ }, ++/* lsr.2 ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_direct, { 0x12600100 } ++ }, ++/* lsr.2 ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_direct, { 0x16600100 } ++ }, ++/* lsr.2 ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_immediate, { 0x12600000 } ++ }, ++/* lsr.2 ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_immediate, { 0x16600000 } ++ }, ++/* lsr.2 ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_index_2, { 0x12600300 } ++ }, ++/* lsr.2 ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_index_2, { 0x16600300 } ++ }, ++/* lsr.2 ${Dn},${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_offset_2, { 0x12600400 } ++ }, ++/* lsr.2 ${Dn},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_offset_2, { 0x16600400 } ++ }, ++/* lsr.2 ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_2, { 0x12600400 } ++ }, ++/* lsr.2 ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_2, { 0x16600400 } ++ }, ++/* lsr.2 ${Dn},(${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_post_increment_2, { 0x12600200 } ++ }, ++/* lsr.2 ${Dn},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_post_increment_2, { 0x16600200 } ++ }, ++/* lsr.2 ${Dn},${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_indirect_with_pre_increment_2, { 0x12600210 } ++ }, ++/* lsr.2 ${Dn},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_indirect_with_pre_increment_2, { 0x16600210 } ++ }, ++/* asr.4 ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_direct, { 0x12800100 } ++ }, ++/* asr.4 ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_direct, { 0x16800100 } ++ }, ++/* asr.4 ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_immediate, { 0x12800000 } ++ }, ++/* asr.4 ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_immediate, { 0x16800000 } ++ }, ++/* asr.4 ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_with_index_4, { 0x12800300 } ++ }, ++/* asr.4 ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_with_index_4, { 0x16800300 } ++ }, ++/* asr.4 ${Dn},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_with_offset_4, { 0x12800400 } ++ }, ++/* asr.4 ${Dn},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_with_offset_4, { 0x16800400 } ++ }, ++/* asr.4 ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_4, { 0x12800400 } ++ }, ++/* asr.4 ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_4, { 0x16800400 } ++ }, ++/* asr.4 ${Dn},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_with_post_increment_4, { 0x12800200 } ++ }, ++/* asr.4 ${Dn},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_with_post_increment_4, { 0x16800200 } ++ }, ++/* asr.4 ${Dn},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_with_pre_increment_4, { 0x12800210 } ++ }, ++/* asr.4 ${Dn},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_with_pre_increment_4, { 0x16800210 } ++ }, ++/* lsl.4 ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_direct, { 0x12000100 } ++ }, ++/* lsl.4 ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_direct, { 0x16000100 } ++ }, ++/* lsl.4 ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_immediate, { 0x12000000 } ++ }, ++/* lsl.4 ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_immediate, { 0x16000000 } ++ }, ++/* lsl.4 ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_with_index_4, { 0x12000300 } ++ }, ++/* lsl.4 ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_with_index_4, { 0x16000300 } ++ }, ++/* lsl.4 ${Dn},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_with_offset_4, { 0x12000400 } ++ }, ++/* lsl.4 ${Dn},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_with_offset_4, { 0x16000400 } ++ }, ++/* lsl.4 ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_4, { 0x12000400 } ++ }, ++/* lsl.4 ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_4, { 0x16000400 } ++ }, ++/* lsl.4 ${Dn},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_with_post_increment_4, { 0x12000200 } ++ }, ++/* lsl.4 ${Dn},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_with_post_increment_4, { 0x16000200 } ++ }, ++/* lsl.4 ${Dn},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_with_pre_increment_4, { 0x12000210 } ++ }, ++/* lsl.4 ${Dn},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_with_pre_increment_4, { 0x16000210 } ++ }, ++/* lsr.4 ${Dn},${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_direct, { 0x12400100 } ++ }, ++/* lsr.4 ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_direct, { 0x16400100 } ++ }, ++/* lsr.4 ${Dn},#${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_shmrg_2_imm_bit5_s1_immediate, { 0x12400000 } ++ }, ++/* lsr.4 ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_shmrg_2_dyn_reg_s1_immediate, { 0x16400000 } ++ }, ++/* lsr.4 ${Dn},(${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_with_index_4, { 0x12400300 } ++ }, ++/* lsr.4 ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_with_index_4, { 0x16400300 } ++ }, ++/* lsr.4 ${Dn},${s1-imm7-4}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_with_offset_4, { 0x12400400 } ++ }, ++/* lsr.4 ${Dn},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_with_offset_4, { 0x16400400 } ++ }, ++/* lsr.4 ${Dn},(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_4, { 0x12400400 } ++ }, ++/* lsr.4 ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_4, { 0x16400400 } ++ }, ++/* lsr.4 ${Dn},(${s1-An})${s1-i4-4}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_with_post_increment_4, { 0x12400200 } ++ }, ++/* lsr.4 ${Dn},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_with_post_increment_4, { 0x16400200 } ++ }, ++/* lsr.4 ${Dn},${s1-i4-4}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_asr_4_imm_bit5_s1_indirect_with_pre_increment_4, { 0x12400210 } ++ }, ++/* lsr.4 ${Dn},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_asr_4_dyn_reg_s1_indirect_with_pre_increment_4, { 0x16400210 } ++ }, ++/* mac ${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_direct_dsp_src2_data_reg, { 0x34200100 } ++ }, ++/* mac #${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_immediate_dsp_src2_data_reg, { 0x34200000 } ++ }, ++/* mac (${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_index_2_dsp_src2_data_reg, { 0x34200300 } ++ }, ++/* mac ${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_offset_2_dsp_src2_data_reg, { 0x34200400 } ++ }, ++/* mac (${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_2_dsp_src2_data_reg, { 0x34200400 } ++ }, ++/* mac (${s1-An})${s1-i4-2}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_post_increment_2_dsp_src2_data_reg, { 0x34200200 } ++ }, ++/* mac ${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_pre_increment_2_dsp_src2_data_reg, { 0x34200210 } ++ }, ++/* mac ${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_direct_dsp_imm_bit5, { 0x30200100 } ++ }, ++/* mac #${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_immediate_dsp_imm_bit5, { 0x30200000 } ++ }, ++/* mac (${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_index_2_dsp_imm_bit5, { 0x30200300 } ++ }, ++/* mac ${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_offset_2_dsp_imm_bit5, { 0x30200400 } ++ }, ++/* mac (${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_2_dsp_imm_bit5, { 0x30200400 } ++ }, ++/* mac (${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_post_increment_2_dsp_imm_bit5, { 0x30200200 } ++ }, ++/* mac ${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_pre_increment_2_dsp_imm_bit5, { 0x30200210 } ++ }, ++/* mac ${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_direct_imm_bit5, { 0x11200100 } ++ }, ++/* mac #${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_immediate_imm_bit5, { 0x11200000 } ++ }, ++/* mac (${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_index_2_imm_bit5, { 0x11200300 } ++ }, ++/* mac ${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_offset_2_imm_bit5, { 0x11200400 } ++ }, ++/* mac (${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_2_imm_bit5, { 0x11200400 } ++ }, ++/* mac (${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_post_increment_2_imm_bit5, { 0x11200200 } ++ }, ++/* mac ${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_pre_increment_2_imm_bit5, { 0x11200210 } ++ }, ++/* mac ${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_direct_dyn_reg, { 0x15200100 } ++ }, ++/* mac #${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_immediate_dyn_reg, { 0x15200000 } ++ }, ++/* mac (${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_index_2_dyn_reg, { 0x15200300 } ++ }, ++/* mac ${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_offset_2_dyn_reg, { 0x15200400 } ++ }, ++/* mac (${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_2_dyn_reg, { 0x15200400 } ++ }, ++/* mac (${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_post_increment_2_dyn_reg, { 0x15200200 } ++ }, ++/* mac ${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_pre_increment_2_dyn_reg, { 0x15200210 } ++ }, ++/* mulf ${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_direct_dsp_src2_data_reg, { 0x34800100 } ++ }, ++/* mulf #${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_immediate_dsp_src2_data_reg, { 0x34800000 } ++ }, ++/* mulf (${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_index_2_dsp_src2_data_reg, { 0x34800300 } ++ }, ++/* mulf ${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_offset_2_dsp_src2_data_reg, { 0x34800400 } ++ }, ++/* mulf (${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_2_dsp_src2_data_reg, { 0x34800400 } ++ }, ++/* mulf (${s1-An})${s1-i4-2}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_post_increment_2_dsp_src2_data_reg, { 0x34800200 } ++ }, ++/* mulf ${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_pre_increment_2_dsp_src2_data_reg, { 0x34800210 } ++ }, ++/* mulf ${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_direct_dsp_imm_bit5, { 0x30800100 } ++ }, ++/* mulf #${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_immediate_dsp_imm_bit5, { 0x30800000 } ++ }, ++/* mulf (${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_index_2_dsp_imm_bit5, { 0x30800300 } ++ }, ++/* mulf ${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_offset_2_dsp_imm_bit5, { 0x30800400 } ++ }, ++/* mulf (${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_2_dsp_imm_bit5, { 0x30800400 } ++ }, ++/* mulf (${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_post_increment_2_dsp_imm_bit5, { 0x30800200 } ++ }, ++/* mulf ${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_pre_increment_2_dsp_imm_bit5, { 0x30800210 } ++ }, ++/* mulf ${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_direct_imm_bit5, { 0x10a00100 } ++ }, ++/* mulf #${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_immediate_imm_bit5, { 0x10a00000 } ++ }, ++/* mulf (${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_index_2_imm_bit5, { 0x10a00300 } ++ }, ++/* mulf ${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_offset_2_imm_bit5, { 0x10a00400 } ++ }, ++/* mulf (${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_2_imm_bit5, { 0x10a00400 } ++ }, ++/* mulf (${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_post_increment_2_imm_bit5, { 0x10a00200 } ++ }, ++/* mulf ${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_pre_increment_2_imm_bit5, { 0x10a00210 } ++ }, ++/* mulf ${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_direct_dyn_reg, { 0x14a00100 } ++ }, ++/* mulf #${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_immediate_dyn_reg, { 0x14a00000 } ++ }, ++/* mulf (${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_index_2_dyn_reg, { 0x14a00300 } ++ }, ++/* mulf ${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_offset_2_dyn_reg, { 0x14a00400 } ++ }, ++/* mulf (${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_2_dyn_reg, { 0x14a00400 } ++ }, ++/* mulf (${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_post_increment_2_dyn_reg, { 0x14a00200 } ++ }, ++/* mulf ${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_pre_increment_2_dyn_reg, { 0x14a00210 } ++ }, ++/* mulu ${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_direct_dsp_src2_data_reg, { 0x34400100 } ++ }, ++/* mulu #${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_immediate_dsp_src2_data_reg, { 0x34400000 } ++ }, ++/* mulu (${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_index_2_dsp_src2_data_reg, { 0x34400300 } ++ }, ++/* mulu ${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_offset_2_dsp_src2_data_reg, { 0x34400400 } ++ }, ++/* mulu (${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_2_dsp_src2_data_reg, { 0x34400400 } ++ }, ++/* mulu (${s1-An})${s1-i4-2}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_post_increment_2_dsp_src2_data_reg, { 0x34400200 } ++ }, ++/* mulu ${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_pre_increment_2_dsp_src2_data_reg, { 0x34400210 } ++ }, ++/* mulu ${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_direct_dsp_imm_bit5, { 0x30400100 } ++ }, ++/* mulu #${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_immediate_dsp_imm_bit5, { 0x30400000 } ++ }, ++/* mulu (${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_index_2_dsp_imm_bit5, { 0x30400300 } ++ }, ++/* mulu ${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_offset_2_dsp_imm_bit5, { 0x30400400 } ++ }, ++/* mulu (${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_2_dsp_imm_bit5, { 0x30400400 } ++ }, ++/* mulu (${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_post_increment_2_dsp_imm_bit5, { 0x30400200 } ++ }, ++/* mulu ${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_pre_increment_2_dsp_imm_bit5, { 0x30400210 } ++ }, ++/* mulu ${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_direct_imm_bit5, { 0x10600100 } ++ }, ++/* mulu #${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_immediate_imm_bit5, { 0x10600000 } ++ }, ++/* mulu (${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_index_2_imm_bit5, { 0x10600300 } ++ }, ++/* mulu ${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_offset_2_imm_bit5, { 0x10600400 } ++ }, ++/* mulu (${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_2_imm_bit5, { 0x10600400 } ++ }, ++/* mulu (${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_post_increment_2_imm_bit5, { 0x10600200 } ++ }, ++/* mulu ${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_pre_increment_2_imm_bit5, { 0x10600210 } ++ }, ++/* mulu ${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_direct_dyn_reg, { 0x14600100 } ++ }, ++/* mulu #${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_immediate_dyn_reg, { 0x14600000 } ++ }, ++/* mulu (${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_index_2_dyn_reg, { 0x14600300 } ++ }, ++/* mulu ${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_offset_2_dyn_reg, { 0x14600400 } ++ }, ++/* mulu (${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_2_dyn_reg, { 0x14600400 } ++ }, ++/* mulu (${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_post_increment_2_dyn_reg, { 0x14600200 } ++ }, ++/* mulu ${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_pre_increment_2_dyn_reg, { 0x14600210 } ++ }, ++/* muls ${s1-direct-addr},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_direct_dsp_src2_data_reg, { 0x34000100 } ++ }, ++/* muls #${s1-imm8},${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_immediate_dsp_src2_data_reg, { 0x34000000 } ++ }, ++/* muls (${s1-An},${s1-r}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_index_2_dsp_src2_data_reg, { 0x34000300 } ++ }, ++/* muls ${s1-imm7-2}(${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_offset_2_dsp_src2_data_reg, { 0x34000400 } ++ }, ++/* muls (${s1-An}),${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_2_dsp_src2_data_reg, { 0x34000400 } ++ }, ++/* muls (${s1-An})${s1-i4-2}++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_post_increment_2_dsp_src2_data_reg, { 0x34000200 } ++ }, ++/* muls ${s1-i4-2}(${s1-An})++,${dsp-S2-data-reg} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (DSP_S2_DATA_REG), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_pre_increment_2_dsp_src2_data_reg, { 0x34000210 } ++ }, ++/* muls ${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_direct_dsp_imm_bit5, { 0x30000100 } ++ }, ++/* muls #${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_immediate_dsp_imm_bit5, { 0x30000000 } ++ }, ++/* muls (${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_index_2_dsp_imm_bit5, { 0x30000300 } ++ }, ++/* muls ${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_offset_2_dsp_imm_bit5, { 0x30000400 } ++ }, ++/* muls (${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_2_dsp_imm_bit5, { 0x30000400 } ++ }, ++/* muls (${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_post_increment_2_dsp_imm_bit5, { 0x30000200 } ++ }, ++/* muls ${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_compatibility_mac_s1_indirect_with_pre_increment_2_dsp_imm_bit5, { 0x30000210 } ++ }, ++/* muls ${s1-direct-addr},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_direct_imm_bit5, { 0x10200100 } ++ }, ++/* muls #${s1-imm8},#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', '#', OP (BIT5), 0 } }, ++ & ifmt_btst_s1_immediate_imm_bit5, { 0x10200000 } ++ }, ++/* muls (${s1-An},${s1-r}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_index_2_imm_bit5, { 0x10200300 } ++ }, ++/* muls ${s1-imm7-2}(${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_offset_2_imm_bit5, { 0x10200400 } ++ }, ++/* muls (${s1-An}),#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_2_imm_bit5, { 0x10200400 } ++ }, ++/* muls (${s1-An})${s1-i4-2}++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_post_increment_2_imm_bit5, { 0x10200200 } ++ }, ++/* muls ${s1-i4-2}(${s1-An})++,#${bit5} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (BIT5), 0 } }, ++ & ifmt_mac_s1_indirect_with_pre_increment_2_imm_bit5, { 0x10200210 } ++ }, ++/* muls ${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_direct_dyn_reg, { 0x14200100 } ++ }, ++/* muls #${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_btst_s1_immediate_dyn_reg, { 0x14200000 } ++ }, ++/* muls (${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_index_2_dyn_reg, { 0x14200300 } ++ }, ++/* muls ${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_offset_2_dyn_reg, { 0x14200400 } ++ }, ++/* muls (${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_2_dyn_reg, { 0x14200400 } ++ }, ++/* muls (${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_post_increment_2_dyn_reg, { 0x14200200 } ++ }, ++/* muls ${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_mac_s1_indirect_with_pre_increment_2_dyn_reg, { 0x14200210 } ++ }, ++/* swapb.4 ${d-direct-addr},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_direct_s1_direct, { 0x100c900 } ++ }, ++/* swapb.4 #${d-imm8},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_immediate_4_s1_direct, { 0xc900 } ++ }, ++/* swapb.4 (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_direct, { 0x300c900 } ++ }, ++/* swapb.4 ${d-imm7-4}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_direct, { 0x400c900 } ++ }, ++/* swapb.4 (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_4_s1_direct, { 0x400c900 } ++ }, ++/* swapb.4 (${d-An})${d-i4-4}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_direct, { 0x200c900 } ++ }, ++/* swapb.4 ${d-i4-4}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_direct, { 0x210c900 } ++ }, ++/* swapb.4 ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_direct_s1_immediate, { 0x100c800 } ++ }, ++/* swapb.4 #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_immediate_4_s1_immediate, { 0xc800 } ++ }, ++/* swapb.4 (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_immediate, { 0x300c800 } ++ }, ++/* swapb.4 ${d-imm7-4}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_immediate, { 0x400c800 } ++ }, ++/* swapb.4 (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_4_s1_immediate, { 0x400c800 } ++ }, ++/* swapb.4 (${d-An})${d-i4-4}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_immediate, { 0x200c800 } ++ }, ++/* swapb.4 ${d-i4-4}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_immediate, { 0x210c800 } ++ }, ++/* swapb.4 ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_index_4, { 0x100cb00 } ++ }, ++/* swapb.4 #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_index_4, { 0xcb00 } ++ }, ++/* swapb.4 (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x300cb00 } ++ }, ++/* swapb.4 ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x400cb00 } ++ }, ++/* swapb.4 (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_index_4, { 0x400cb00 } ++ }, ++/* swapb.4 (${d-An})${d-i4-4}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x200cb00 } ++ }, ++/* swapb.4 ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x210cb00 } ++ }, ++/* swapb.4 ${d-direct-addr},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_offset_4, { 0x100cc00 } ++ }, ++/* swapb.4 #${d-imm8},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_offset_4, { 0xcc00 } ++ }, ++/* swapb.4 (${d-An},${d-r}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x300cc00 } ++ }, ++/* swapb.4 ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x400cc00 } ++ }, ++/* swapb.4 (${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_offset_4, { 0x400cc00 } ++ }, ++/* swapb.4 (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x200cc00 } ++ }, ++/* swapb.4 ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x210cc00 } ++ }, ++/* swapb.4 ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_4, { 0x100cc00 } ++ }, ++/* swapb.4 #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_4, { 0xcc00 } ++ }, ++/* swapb.4 (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_4, { 0x300cc00 } ++ }, ++/* swapb.4 ${d-imm7-4}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_4, { 0x400cc00 } ++ }, ++/* swapb.4 (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_4, { 0x400cc00 } ++ }, ++/* swapb.4 (${d-An})${d-i4-4}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_4, { 0x200cc00 } ++ }, ++/* swapb.4 ${d-i4-4}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x210cc00 } ++ }, ++/* swapb.4 ${d-direct-addr},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_post_increment_4, { 0x100ca00 } ++ }, ++/* swapb.4 #${d-imm8},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_post_increment_4, { 0xca00 } ++ }, ++/* swapb.4 (${d-An},${d-r}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x300ca00 } ++ }, ++/* swapb.4 ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x400ca00 } ++ }, ++/* swapb.4 (${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_post_increment_4, { 0x400ca00 } ++ }, ++/* swapb.4 (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x200ca00 } ++ }, ++/* swapb.4 ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x210ca00 } ++ }, ++/* swapb.4 ${d-direct-addr},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_pre_increment_4, { 0x100ca10 } ++ }, ++/* swapb.4 #${d-imm8},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_pre_increment_4, { 0xca10 } ++ }, ++/* swapb.4 (${d-An},${d-r}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x300ca10 } ++ }, ++/* swapb.4 ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x400ca10 } ++ }, ++/* swapb.4 (${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x400ca10 } ++ }, ++/* swapb.4 (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x200ca10 } ++ }, ++/* swapb.4 ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x210ca10 } ++ }, ++/* swapb.2 ${d-direct-addr},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_direct_s1_direct, { 0x100c100 } ++ }, ++/* swapb.2 #${d-imm8},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_direct, { 0xc100 } ++ }, ++/* swapb.2 (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_direct, { 0x300c100 } ++ }, ++/* swapb.2 ${d-imm7-2}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_direct, { 0x400c100 } ++ }, ++/* swapb.2 (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_direct, { 0x400c100 } ++ }, ++/* swapb.2 (${d-An})${d-i4-2}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_direct, { 0x200c100 } ++ }, ++/* swapb.2 ${d-i4-2}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_direct, { 0x210c100 } ++ }, ++/* swapb.2 ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_direct_s1_immediate, { 0x100c000 } ++ }, ++/* swapb.2 #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_immediate, { 0xc000 } ++ }, ++/* swapb.2 (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_immediate, { 0x300c000 } ++ }, ++/* swapb.2 ${d-imm7-2}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_immediate, { 0x400c000 } ++ }, ++/* swapb.2 (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_immediate, { 0x400c000 } ++ }, ++/* swapb.2 (${d-An})${d-i4-2}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_immediate, { 0x200c000 } ++ }, ++/* swapb.2 ${d-i4-2}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_immediate, { 0x210c000 } ++ }, ++/* swapb.2 ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_index_2, { 0x100c300 } ++ }, ++/* swapb.2 #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_index_2, { 0xc300 } ++ }, ++/* swapb.2 (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_index_2, { 0x300c300 } ++ }, ++/* swapb.2 ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_index_2, { 0x400c300 } ++ }, ++/* swapb.2 (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_index_2, { 0x400c300 } ++ }, ++/* swapb.2 (${d-An})${d-i4-2}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_index_2, { 0x200c300 } ++ }, ++/* swapb.2 ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_index_2, { 0x210c300 } ++ }, ++/* swapb.2 ${d-direct-addr},${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_offset_2, { 0x100c400 } ++ }, ++/* swapb.2 #${d-imm8},${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_offset_2, { 0xc400 } ++ }, ++/* swapb.2 (${d-An},${d-r}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_offset_2, { 0x300c400 } ++ }, ++/* swapb.2 ${d-imm7-2}(${d-An}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_offset_2, { 0x400c400 } ++ }, ++/* swapb.2 (${d-An}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_offset_2, { 0x400c400 } ++ }, ++/* swapb.2 (${d-An})${d-i4-2}++,${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_offset_2, { 0x200c400 } ++ }, ++/* swapb.2 ${d-i4-2}(${d-An})++,${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_offset_2, { 0x210c400 } ++ }, ++/* swapb.2 ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_2, { 0x100c400 } ++ }, ++/* swapb.2 #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_2, { 0xc400 } ++ }, ++/* swapb.2 (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_2, { 0x300c400 } ++ }, ++/* swapb.2 ${d-imm7-2}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_2, { 0x400c400 } ++ }, ++/* swapb.2 (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_2, { 0x400c400 } ++ }, ++/* swapb.2 (${d-An})${d-i4-2}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_2, { 0x200c400 } ++ }, ++/* swapb.2 ${d-i4-2}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_2, { 0x210c400 } ++ }, ++/* swapb.2 ${d-direct-addr},(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_post_increment_2, { 0x100c200 } ++ }, ++/* swapb.2 #${d-imm8},(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_post_increment_2, { 0xc200 } ++ }, ++/* swapb.2 (${d-An},${d-r}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_post_increment_2, { 0x300c200 } ++ }, ++/* swapb.2 ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_post_increment_2, { 0x400c200 } ++ }, ++/* swapb.2 (${d-An}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_post_increment_2, { 0x400c200 } ++ }, ++/* swapb.2 (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_2, { 0x200c200 } ++ }, ++/* swapb.2 ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_2, { 0x210c200 } ++ }, ++/* swapb.2 ${d-direct-addr},${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_pre_increment_2, { 0x100c210 } ++ }, ++/* swapb.2 #${d-imm8},${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_pre_increment_2, { 0xc210 } ++ }, ++/* swapb.2 (${d-An},${d-r}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_pre_increment_2, { 0x300c210 } ++ }, ++/* swapb.2 ${d-imm7-2}(${d-An}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_pre_increment_2, { 0x400c210 } ++ }, ++/* swapb.2 (${d-An}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_pre_increment_2, { 0x400c210 } ++ }, ++/* swapb.2 (${d-An})${d-i4-2}++,${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_2, { 0x200c210 } ++ }, ++/* swapb.2 ${d-i4-2}(${d-An})++,${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_2, { 0x210c210 } ++ }, ++/* pdec ${d-direct-addr},${pdec-s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (PDEC_S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pdec_d_direct_pdec_s1_ea_indirect_with_offset_4, { 0x100f400 } ++ }, ++/* pdec #${d-imm8},${pdec-s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (PDEC_S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pdec_d_immediate_4_pdec_s1_ea_indirect_with_offset_4, { 0xf400 } ++ }, ++/* pdec (${d-An},${d-r}),${pdec-s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (PDEC_S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pdec_d_indirect_with_index_4_pdec_s1_ea_indirect_with_offset_4, { 0x300f400 } ++ }, ++/* pdec ${d-imm7-4}(${d-An}),${pdec-s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (PDEC_S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pdec_d_indirect_with_offset_4_pdec_s1_ea_indirect_with_offset_4, { 0x400f400 } ++ }, ++/* pdec (${d-An}),${pdec-s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (PDEC_S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pdec_d_indirect_4_pdec_s1_ea_indirect_with_offset_4, { 0x400f400 } ++ }, ++/* pdec (${d-An})${d-i4-4}++,${pdec-s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (PDEC_S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pdec_d_indirect_with_post_increment_4_pdec_s1_ea_indirect_with_offset_4, { 0x200f400 } ++ }, ++/* pdec ${d-i4-4}(${d-An})++,${pdec-s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (PDEC_S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pdec_d_indirect_with_pre_increment_4_pdec_s1_ea_indirect_with_offset_4, { 0x210f400 } ++ }, ++/* lea.4 ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_direct_s1_ea_indirect, { 0x100e400 } ++ }, ++/* lea.4 #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_immediate_4_s1_ea_indirect, { 0xe400 } ++ }, ++/* lea.4 (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_index_4_s1_ea_indirect, { 0x300e400 } ++ }, ++/* lea.4 ${d-imm7-4}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_offset_4_s1_ea_indirect, { 0x400e400 } ++ }, ++/* lea.4 (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_4_s1_ea_indirect, { 0x400e400 } ++ }, ++/* lea.4 (${d-An})${d-i4-4}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_indirect, { 0x200e400 } ++ }, ++/* lea.4 ${d-i4-4}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_indirect, { 0x210e400 } ++ }, ++/* lea.4 ${d-direct-addr},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_direct_s1_ea_indirect_with_offset_4, { 0x100e400 } ++ }, ++/* lea.4 #${d-imm8},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_immediate_4_s1_ea_indirect_with_offset_4, { 0xe400 } ++ }, ++/* lea.4 (${d-An},${d-r}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_index_4_s1_ea_indirect_with_offset_4, { 0x300e400 } ++ }, ++/* lea.4 ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_offset_4_s1_ea_indirect_with_offset_4, { 0x400e400 } ++ }, ++/* lea.4 (${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_4_s1_ea_indirect_with_offset_4, { 0x400e400 } ++ }, ++/* lea.4 (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_indirect_with_offset_4, { 0x200e400 } ++ }, ++/* lea.4 ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_indirect_with_offset_4, { 0x210e400 } ++ }, ++/* lea.4 ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_4_d_direct_s1_ea_indirect_with_index_4, { 0x100e300 } ++ }, ++/* lea.4 #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_4_d_immediate_4_s1_ea_indirect_with_index_4, { 0xe300 } ++ }, ++/* lea.4 (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_index_4_s1_ea_indirect_with_index_4, { 0x300e300 } ++ }, ++/* lea.4 ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_offset_4_s1_ea_indirect_with_index_4, { 0x400e300 } ++ }, ++/* lea.4 (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_4_s1_ea_indirect_with_index_4, { 0x400e300 } ++ }, ++/* lea.4 (${d-An})${d-i4-4}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_indirect_with_index_4, { 0x200e300 } ++ }, ++/* lea.4 ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_indirect_with_index_4, { 0x210e300 } ++ }, ++/* lea.4 ${d-direct-addr},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_lea_4_d_direct_s1_ea_indirect_with_post_increment_4, { 0x100e200 } ++ }, ++/* lea.4 #${d-imm8},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_lea_4_d_immediate_4_s1_ea_indirect_with_post_increment_4, { 0xe200 } ++ }, ++/* lea.4 (${d-An},${d-r}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_lea_4_d_indirect_with_index_4_s1_ea_indirect_with_post_increment_4, { 0x300e200 } ++ }, ++/* lea.4 ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_lea_4_d_indirect_with_offset_4_s1_ea_indirect_with_post_increment_4, { 0x400e200 } ++ }, ++/* lea.4 (${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_lea_4_d_indirect_4_s1_ea_indirect_with_post_increment_4, { 0x400e200 } ++ }, ++/* lea.4 (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_indirect_with_post_increment_4, { 0x200e200 } ++ }, ++/* lea.4 ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_indirect_with_post_increment_4, { 0x210e200 } ++ }, ++/* lea.4 ${d-direct-addr},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_4_d_direct_s1_ea_indirect_with_pre_increment_4, { 0x100e210 } ++ }, ++/* lea.4 #${d-imm8},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_4_d_immediate_4_s1_ea_indirect_with_pre_increment_4, { 0xe210 } ++ }, ++/* lea.4 (${d-An},${d-r}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_4_d_indirect_with_index_4_s1_ea_indirect_with_pre_increment_4, { 0x300e210 } ++ }, ++/* lea.4 ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_4_d_indirect_with_offset_4_s1_ea_indirect_with_pre_increment_4, { 0x400e210 } ++ }, ++/* lea.4 (${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_4_d_indirect_4_s1_ea_indirect_with_pre_increment_4, { 0x400e210 } ++ }, ++/* lea.4 (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_indirect_with_pre_increment_4, { 0x200e210 } ++ }, ++/* lea.4 ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_indirect_with_pre_increment_4, { 0x210e210 } ++ }, ++/* lea.4 ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_direct_s1_ea_immediate, { 0x100e000 } ++ }, ++/* lea.4 #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_immediate_4_s1_ea_immediate, { 0xe000 } ++ }, ++/* lea.4 (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_with_index_4_s1_ea_immediate, { 0x300e000 } ++ }, ++/* lea.4 ${d-imm7-4}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_with_offset_4_s1_ea_immediate, { 0x400e000 } ++ }, ++/* lea.4 (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_4_s1_ea_immediate, { 0x400e000 } ++ }, ++/* lea.4 (${d-An})${d-i4-4}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_immediate, { 0x200e000 } ++ }, ++/* lea.4 ${d-i4-4}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_immediate, { 0x210e000 } ++ }, ++/* lea.2 ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_direct_s1_ea_indirect, { 0x100ec00 } ++ }, ++/* lea.2 #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_immediate_4_s1_ea_indirect, { 0xec00 } ++ }, ++/* lea.2 (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_index_4_s1_ea_indirect, { 0x300ec00 } ++ }, ++/* lea.2 ${d-imm7-4}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_offset_4_s1_ea_indirect, { 0x400ec00 } ++ }, ++/* lea.2 (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_4_s1_ea_indirect, { 0x400ec00 } ++ }, ++/* lea.2 (${d-An})${d-i4-4}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_indirect, { 0x200ec00 } ++ }, ++/* lea.2 ${d-i4-4}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_indirect, { 0x210ec00 } ++ }, ++/* lea.2 ${d-direct-addr},${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_2_d_direct_s1_ea_indirect_with_offset_2, { 0x100ec00 } ++ }, ++/* lea.2 #${d-imm8},${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_2_d_immediate_4_s1_ea_indirect_with_offset_2, { 0xec00 } ++ }, ++/* lea.2 (${d-An},${d-r}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_2_d_indirect_with_index_4_s1_ea_indirect_with_offset_2, { 0x300ec00 } ++ }, ++/* lea.2 ${d-imm7-4}(${d-An}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_2_d_indirect_with_offset_4_s1_ea_indirect_with_offset_2, { 0x400ec00 } ++ }, ++/* lea.2 (${d-An}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_2_d_indirect_4_s1_ea_indirect_with_offset_2, { 0x400ec00 } ++ }, ++/* lea.2 (${d-An})${d-i4-4}++,${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_2_d_indirect_with_post_increment_4_s1_ea_indirect_with_offset_2, { 0x200ec00 } ++ }, ++/* lea.2 ${d-i4-4}(${d-An})++,${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_2_d_indirect_with_pre_increment_4_s1_ea_indirect_with_offset_2, { 0x210ec00 } ++ }, ++/* lea.2 ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_2_d_direct_s1_ea_indirect_with_index_2, { 0x100eb00 } ++ }, ++/* lea.2 #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_2_d_immediate_4_s1_ea_indirect_with_index_2, { 0xeb00 } ++ }, ++/* lea.2 (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_2_d_indirect_with_index_4_s1_ea_indirect_with_index_2, { 0x300eb00 } ++ }, ++/* lea.2 ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_2_d_indirect_with_offset_4_s1_ea_indirect_with_index_2, { 0x400eb00 } ++ }, ++/* lea.2 (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_2_d_indirect_4_s1_ea_indirect_with_index_2, { 0x400eb00 } ++ }, ++/* lea.2 (${d-An})${d-i4-4}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_2_d_indirect_with_post_increment_4_s1_ea_indirect_with_index_2, { 0x200eb00 } ++ }, ++/* lea.2 ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_2_d_indirect_with_pre_increment_4_s1_ea_indirect_with_index_2, { 0x210eb00 } ++ }, ++/* lea.2 ${d-direct-addr},(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_lea_2_d_direct_s1_ea_indirect_with_post_increment_2, { 0x100ea00 } ++ }, ++/* lea.2 #${d-imm8},(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_lea_2_d_immediate_4_s1_ea_indirect_with_post_increment_2, { 0xea00 } ++ }, ++/* lea.2 (${d-An},${d-r}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_lea_2_d_indirect_with_index_4_s1_ea_indirect_with_post_increment_2, { 0x300ea00 } ++ }, ++/* lea.2 ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_lea_2_d_indirect_with_offset_4_s1_ea_indirect_with_post_increment_2, { 0x400ea00 } ++ }, ++/* lea.2 (${d-An}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_lea_2_d_indirect_4_s1_ea_indirect_with_post_increment_2, { 0x400ea00 } ++ }, ++/* lea.2 (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_lea_2_d_indirect_with_post_increment_4_s1_ea_indirect_with_post_increment_2, { 0x200ea00 } ++ }, ++/* lea.2 ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_lea_2_d_indirect_with_pre_increment_4_s1_ea_indirect_with_post_increment_2, { 0x210ea00 } ++ }, ++/* lea.2 ${d-direct-addr},${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_2_d_direct_s1_ea_indirect_with_pre_increment_2, { 0x100ea10 } ++ }, ++/* lea.2 #${d-imm8},${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_2_d_immediate_4_s1_ea_indirect_with_pre_increment_2, { 0xea10 } ++ }, ++/* lea.2 (${d-An},${d-r}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_2_d_indirect_with_index_4_s1_ea_indirect_with_pre_increment_2, { 0x300ea10 } ++ }, ++/* lea.2 ${d-imm7-4}(${d-An}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_2_d_indirect_with_offset_4_s1_ea_indirect_with_pre_increment_2, { 0x400ea10 } ++ }, ++/* lea.2 (${d-An}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_2_d_indirect_4_s1_ea_indirect_with_pre_increment_2, { 0x400ea10 } ++ }, ++/* lea.2 (${d-An})${d-i4-4}++,${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_2_d_indirect_with_post_increment_4_s1_ea_indirect_with_pre_increment_2, { 0x200ea10 } ++ }, ++/* lea.2 ${d-i4-4}(${d-An})++,${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_2_d_indirect_with_pre_increment_4_s1_ea_indirect_with_pre_increment_2, { 0x210ea10 } ++ }, ++/* lea.2 ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_direct_s1_ea_immediate, { 0x100e800 } ++ }, ++/* lea.2 #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_immediate_4_s1_ea_immediate, { 0xe800 } ++ }, ++/* lea.2 (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_with_index_4_s1_ea_immediate, { 0x300e800 } ++ }, ++/* lea.2 ${d-imm7-4}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_with_offset_4_s1_ea_immediate, { 0x400e800 } ++ }, ++/* lea.2 (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_4_s1_ea_immediate, { 0x400e800 } ++ }, ++/* lea.2 (${d-An})${d-i4-4}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_immediate, { 0x200e800 } ++ }, ++/* lea.2 ${d-i4-4}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_immediate, { 0x210e800 } ++ }, ++/* lea.1 ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_direct_s1_ea_indirect, { 0x100fc00 } ++ }, ++/* lea.1 #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_immediate_4_s1_ea_indirect, { 0xfc00 } ++ }, ++/* lea.1 (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_index_4_s1_ea_indirect, { 0x300fc00 } ++ }, ++/* lea.1 ${d-imm7-4}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_offset_4_s1_ea_indirect, { 0x400fc00 } ++ }, ++/* lea.1 (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_4_s1_ea_indirect, { 0x400fc00 } ++ }, ++/* lea.1 (${d-An})${d-i4-4}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_indirect, { 0x200fc00 } ++ }, ++/* lea.1 ${d-i4-4}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_indirect, { 0x210fc00 } ++ }, ++/* lea.1 ${d-direct-addr},${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_1_d_direct_s1_ea_indirect_with_offset_1, { 0x100fc00 } ++ }, ++/* lea.1 #${d-imm8},${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_1_d_immediate_4_s1_ea_indirect_with_offset_1, { 0xfc00 } ++ }, ++/* lea.1 (${d-An},${d-r}),${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_1_d_indirect_with_index_4_s1_ea_indirect_with_offset_1, { 0x300fc00 } ++ }, ++/* lea.1 ${d-imm7-4}(${d-An}),${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_1_d_indirect_with_offset_4_s1_ea_indirect_with_offset_1, { 0x400fc00 } ++ }, ++/* lea.1 (${d-An}),${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_1_d_indirect_4_s1_ea_indirect_with_offset_1, { 0x400fc00 } ++ }, ++/* lea.1 (${d-An})${d-i4-4}++,${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_1_d_indirect_with_post_increment_4_s1_ea_indirect_with_offset_1, { 0x200fc00 } ++ }, ++/* lea.1 ${d-i4-4}(${d-An})++,${s1-imm7-1}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_lea_1_d_indirect_with_pre_increment_4_s1_ea_indirect_with_offset_1, { 0x210fc00 } ++ }, ++/* lea.1 ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_1_d_direct_s1_ea_indirect_with_index_1, { 0x100fb00 } ++ }, ++/* lea.1 #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_1_d_immediate_4_s1_ea_indirect_with_index_1, { 0xfb00 } ++ }, ++/* lea.1 (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_1_d_indirect_with_index_4_s1_ea_indirect_with_index_1, { 0x300fb00 } ++ }, ++/* lea.1 ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_1_d_indirect_with_offset_4_s1_ea_indirect_with_index_1, { 0x400fb00 } ++ }, ++/* lea.1 (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_1_d_indirect_4_s1_ea_indirect_with_index_1, { 0x400fb00 } ++ }, ++/* lea.1 (${d-An})${d-i4-4}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_1_d_indirect_with_post_increment_4_s1_ea_indirect_with_index_1, { 0x200fb00 } ++ }, ++/* lea.1 ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_lea_1_d_indirect_with_pre_increment_4_s1_ea_indirect_with_index_1, { 0x210fb00 } ++ }, ++/* lea.1 ${d-direct-addr},(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_lea_1_d_direct_s1_ea_indirect_with_post_increment_1, { 0x100fa00 } ++ }, ++/* lea.1 #${d-imm8},(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_lea_1_d_immediate_4_s1_ea_indirect_with_post_increment_1, { 0xfa00 } ++ }, ++/* lea.1 (${d-An},${d-r}),(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_lea_1_d_indirect_with_index_4_s1_ea_indirect_with_post_increment_1, { 0x300fa00 } ++ }, ++/* lea.1 ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_lea_1_d_indirect_with_offset_4_s1_ea_indirect_with_post_increment_1, { 0x400fa00 } ++ }, ++/* lea.1 (${d-An}),(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_lea_1_d_indirect_4_s1_ea_indirect_with_post_increment_1, { 0x400fa00 } ++ }, ++/* lea.1 (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_lea_1_d_indirect_with_post_increment_4_s1_ea_indirect_with_post_increment_1, { 0x200fa00 } ++ }, ++/* lea.1 ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-1}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', 0 } }, ++ & ifmt_lea_1_d_indirect_with_pre_increment_4_s1_ea_indirect_with_post_increment_1, { 0x210fa00 } ++ }, ++/* lea.1 ${d-direct-addr},${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_1_d_direct_s1_ea_indirect_with_pre_increment_1, { 0x100fa10 } ++ }, ++/* lea.1 #${d-imm8},${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_1_d_immediate_4_s1_ea_indirect_with_pre_increment_1, { 0xfa10 } ++ }, ++/* lea.1 (${d-An},${d-r}),${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_1_d_indirect_with_index_4_s1_ea_indirect_with_pre_increment_1, { 0x300fa10 } ++ }, ++/* lea.1 ${d-imm7-4}(${d-An}),${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_1_d_indirect_with_offset_4_s1_ea_indirect_with_pre_increment_1, { 0x400fa10 } ++ }, ++/* lea.1 (${d-An}),${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_1_d_indirect_4_s1_ea_indirect_with_pre_increment_1, { 0x400fa10 } ++ }, ++/* lea.1 (${d-An})${d-i4-4}++,${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_1_d_indirect_with_post_increment_4_s1_ea_indirect_with_pre_increment_1, { 0x200fa10 } ++ }, ++/* lea.1 ${d-i4-4}(${d-An})++,${s1-i4-1}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_lea_1_d_indirect_with_pre_increment_4_s1_ea_indirect_with_pre_increment_1, { 0x210fa10 } ++ }, ++/* lea.1 ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_direct_s1_ea_immediate, { 0x100f800 } ++ }, ++/* lea.1 #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_immediate_4_s1_ea_immediate, { 0xf800 } ++ }, ++/* lea.1 (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_with_index_4_s1_ea_immediate, { 0x300f800 } ++ }, ++/* lea.1 ${d-imm7-4}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_with_offset_4_s1_ea_immediate, { 0x400f800 } ++ }, ++/* lea.1 (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_4_s1_ea_immediate, { 0x400f800 } ++ }, ++/* lea.1 (${d-An})${d-i4-4}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_with_post_increment_4_s1_ea_immediate, { 0x200f800 } ++ }, ++/* lea.1 ${d-i4-4}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_lea_4_d_indirect_with_pre_increment_4_s1_ea_immediate, { 0x210f800 } ++ }, ++/* cmpi ${s1-direct-addr},#${imm16-1} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_DIRECT_ADDR), ',', '#', OP (IMM16_1), 0 } }, ++ & ifmt_cmpi_s1_direct, { 0xc0000100 } ++ }, ++/* cmpi #${s1-imm8},#${imm16-1} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (S1_IMM8), ',', '#', OP (IMM16_1), 0 } }, ++ & ifmt_cmpi_s1_immediate, { 0xc0000000 } ++ }, ++/* cmpi (${s1-An},${s1-r}),#${imm16-1} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', '#', OP (IMM16_1), 0 } }, ++ & ifmt_cmpi_s1_indirect_with_index_2, { 0xc0000300 } ++ }, ++/* cmpi ${s1-imm7-2}(${s1-An}),#${imm16-1} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', '#', OP (IMM16_1), 0 } }, ++ & ifmt_cmpi_s1_indirect_with_offset_2, { 0xc0000400 } ++ }, ++/* cmpi (${s1-An}),#${imm16-1} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', ',', '#', OP (IMM16_1), 0 } }, ++ & ifmt_cmpi_s1_indirect_2, { 0xc0000400 } ++ }, ++/* cmpi (${s1-An})${s1-i4-2}++,#${imm16-1} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', '#', OP (IMM16_1), 0 } }, ++ & ifmt_cmpi_s1_indirect_with_post_increment_2, { 0xc0000200 } ++ }, ++/* cmpi ${s1-i4-2}(${s1-An})++,#${imm16-1} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', '#', OP (IMM16_1), 0 } }, ++ & ifmt_cmpi_s1_indirect_with_pre_increment_2, { 0xc0000210 } ++ }, ++/* pxadds.u ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0xb1008100 } ++ }, ++/* pxadds.u #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_direct, { 0xb0008100 } ++ }, ++/* pxadds.u (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_direct, { 0xb3008100 } ++ }, ++/* pxadds.u ${d-imm7-2}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_direct, { 0xb4008100 } ++ }, ++/* pxadds.u (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_direct, { 0xb4008100 } ++ }, ++/* pxadds.u (${d-An})${d-i4-2}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_direct, { 0xb2008100 } ++ }, ++/* pxadds.u ${d-i4-2}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_direct, { 0xb2108100 } ++ }, ++/* pxadds.u ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0xb1008000 } ++ }, ++/* pxadds.u #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_immediate, { 0xb0008000 } ++ }, ++/* pxadds.u (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_immediate, { 0xb3008000 } ++ }, ++/* pxadds.u ${d-imm7-2}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_immediate, { 0xb4008000 } ++ }, ++/* pxadds.u (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_immediate, { 0xb4008000 } ++ }, ++/* pxadds.u (${d-An})${d-i4-2}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_immediate, { 0xb2008000 } ++ }, ++/* pxadds.u ${d-i4-2}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_immediate, { 0xb2108000 } ++ }, ++/* pxadds.u ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0xb1008300 } ++ }, ++/* pxadds.u #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_indirect_with_index_4, { 0xb0008300 } ++ }, ++/* pxadds.u (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_with_index_4, { 0xb3008300 } ++ }, ++/* pxadds.u ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_with_index_4, { 0xb4008300 } ++ }, ++/* pxadds.u (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_indirect_with_index_4, { 0xb4008300 } ++ }, ++/* pxadds.u (${d-An})${d-i4-2}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_with_index_4, { 0xb2008300 } ++ }, ++/* pxadds.u ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_with_index_4, { 0xb2108300 } ++ }, ++/* pxadds.u ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0xb1008400 } ++ }, ++/* pxadds.u #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_indirect_with_offset_4, { 0xb0008400 } ++ }, ++/* pxadds.u (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_with_offset_4, { 0xb3008400 } ++ }, ++/* pxadds.u ${d-imm7-2}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_with_offset_4, { 0xb4008400 } ++ }, ++/* pxadds.u (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_indirect_with_offset_4, { 0xb4008400 } ++ }, ++/* pxadds.u (${d-An})${d-i4-2}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_with_offset_4, { 0xb2008400 } ++ }, ++/* pxadds.u ${d-i4-2}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_with_offset_4, { 0xb2108400 } ++ }, ++/* pxadds.u ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0xb1008400 } ++ }, ++/* pxadds.u #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_indirect_4, { 0xb0008400 } ++ }, ++/* pxadds.u (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_4, { 0xb3008400 } ++ }, ++/* pxadds.u ${d-imm7-2}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_4, { 0xb4008400 } ++ }, ++/* pxadds.u (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_indirect_4, { 0xb4008400 } ++ }, ++/* pxadds.u (${d-An})${d-i4-2}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_4, { 0xb2008400 } ++ }, ++/* pxadds.u ${d-i4-2}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_4, { 0xb2108400 } ++ }, ++/* pxadds.u ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0xb1008200 } ++ }, ++/* pxadds.u #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_indirect_with_post_increment_4, { 0xb0008200 } ++ }, ++/* pxadds.u (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_with_post_increment_4, { 0xb3008200 } ++ }, ++/* pxadds.u ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_with_post_increment_4, { 0xb4008200 } ++ }, ++/* pxadds.u (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_indirect_with_post_increment_4, { 0xb4008200 } ++ }, ++/* pxadds.u (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_4, { 0xb2008200 } ++ }, ++/* pxadds.u ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_4, { 0xb2108200 } ++ }, ++/* pxadds.u ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0xb1008210 } ++ }, ++/* pxadds.u #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_indirect_with_pre_increment_4, { 0xb0008210 } ++ }, ++/* pxadds.u (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_with_pre_increment_4, { 0xb3008210 } ++ }, ++/* pxadds.u ${d-imm7-2}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_with_pre_increment_4, { 0xb4008210 } ++ }, ++/* pxadds.u (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_indirect_with_pre_increment_4, { 0xb4008210 } ++ }, ++/* pxadds.u (${d-An})${d-i4-2}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_4, { 0xb2008210 } ++ }, ++/* pxadds.u ${d-i4-2}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_4, { 0xb2108210 } ++ }, ++/* pxadds ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0xb1000100 } ++ }, ++/* pxadds #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_direct, { 0xb0000100 } ++ }, ++/* pxadds (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_direct, { 0xb3000100 } ++ }, ++/* pxadds ${d-imm7-2}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_direct, { 0xb4000100 } ++ }, ++/* pxadds (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_direct, { 0xb4000100 } ++ }, ++/* pxadds (${d-An})${d-i4-2}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_direct, { 0xb2000100 } ++ }, ++/* pxadds ${d-i4-2}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_direct, { 0xb2100100 } ++ }, ++/* pxadds ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0xb1000000 } ++ }, ++/* pxadds #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_immediate, { 0xb0000000 } ++ }, ++/* pxadds (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_immediate, { 0xb3000000 } ++ }, ++/* pxadds ${d-imm7-2}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_immediate, { 0xb4000000 } ++ }, ++/* pxadds (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_immediate, { 0xb4000000 } ++ }, ++/* pxadds (${d-An})${d-i4-2}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_immediate, { 0xb2000000 } ++ }, ++/* pxadds ${d-i4-2}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_immediate, { 0xb2100000 } ++ }, ++/* pxadds ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0xb1000300 } ++ }, ++/* pxadds #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_indirect_with_index_4, { 0xb0000300 } ++ }, ++/* pxadds (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_with_index_4, { 0xb3000300 } ++ }, ++/* pxadds ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_with_index_4, { 0xb4000300 } ++ }, ++/* pxadds (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_indirect_with_index_4, { 0xb4000300 } ++ }, ++/* pxadds (${d-An})${d-i4-2}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_with_index_4, { 0xb2000300 } ++ }, ++/* pxadds ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_with_index_4, { 0xb2100300 } ++ }, ++/* pxadds ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0xb1000400 } ++ }, ++/* pxadds #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_indirect_with_offset_4, { 0xb0000400 } ++ }, ++/* pxadds (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_with_offset_4, { 0xb3000400 } ++ }, ++/* pxadds ${d-imm7-2}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_with_offset_4, { 0xb4000400 } ++ }, ++/* pxadds (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_indirect_with_offset_4, { 0xb4000400 } ++ }, ++/* pxadds (${d-An})${d-i4-2}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_with_offset_4, { 0xb2000400 } ++ }, ++/* pxadds ${d-i4-2}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_with_offset_4, { 0xb2100400 } ++ }, ++/* pxadds ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0xb1000400 } ++ }, ++/* pxadds #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_indirect_4, { 0xb0000400 } ++ }, ++/* pxadds (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_4, { 0xb3000400 } ++ }, ++/* pxadds ${d-imm7-2}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_4, { 0xb4000400 } ++ }, ++/* pxadds (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_indirect_4, { 0xb4000400 } ++ }, ++/* pxadds (${d-An})${d-i4-2}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_4, { 0xb2000400 } ++ }, ++/* pxadds ${d-i4-2}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_4, { 0xb2100400 } ++ }, ++/* pxadds ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0xb1000200 } ++ }, ++/* pxadds #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_indirect_with_post_increment_4, { 0xb0000200 } ++ }, ++/* pxadds (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_with_post_increment_4, { 0xb3000200 } ++ }, ++/* pxadds ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_with_post_increment_4, { 0xb4000200 } ++ }, ++/* pxadds (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_indirect_with_post_increment_4, { 0xb4000200 } ++ }, ++/* pxadds (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_4, { 0xb2000200 } ++ }, ++/* pxadds ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_4, { 0xb2100200 } ++ }, ++/* pxadds ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0xb1000210 } ++ }, ++/* pxadds #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_indirect_with_pre_increment_4, { 0xb0000210 } ++ }, ++/* pxadds (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_indirect_with_pre_increment_4, { 0xb3000210 } ++ }, ++/* pxadds ${d-imm7-2}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_indirect_with_pre_increment_4, { 0xb4000210 } ++ }, ++/* pxadds (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_indirect_with_pre_increment_4, { 0xb4000210 } ++ }, ++/* pxadds (${d-An})${d-i4-2}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_4, { 0xb2000210 } ++ }, ++/* pxadds ${d-i4-2}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_4, { 0xb2100210 } ++ }, ++/* pxhi.s ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_direct, { 0x14408100 } ++ }, ++/* pxhi.s ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_immediate, { 0x14408000 } ++ }, ++/* pxhi.s ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_indirect_with_index_4, { 0x14408300 } ++ }, ++/* pxhi.s ${Dn},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_indirect_with_offset_4, { 0x14408400 } ++ }, ++/* pxhi.s ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_indirect_4, { 0x14408400 } ++ }, ++/* pxhi.s ${Dn},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_indirect_with_post_increment_4, { 0x14408200 } ++ }, ++/* pxhi.s ${Dn},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_indirect_with_pre_increment_4, { 0x14408210 } ++ }, ++/* pxhi ${Dn},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_direct, { 0x14000100 } ++ }, ++/* pxhi ${Dn},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_immediate, { 0x14000000 } ++ }, ++/* pxhi ${Dn},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_indirect_with_index_4, { 0x14000300 } ++ }, ++/* pxhi ${Dn},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_indirect_with_offset_4, { 0x14000400 } ++ }, ++/* pxhi ${Dn},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_indirect_4, { 0x14000400 } ++ }, ++/* pxhi ${Dn},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_indirect_with_post_increment_4, { 0x14000200 } ++ }, ++/* pxhi ${Dn},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DN), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxhi_s_s1_indirect_with_pre_increment_4, { 0x14000210 } ++ }, ++/* pxvi.s ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0xa9008100 } ++ }, ++/* pxvi.s #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_direct, { 0xa8008100 } ++ }, ++/* pxvi.s (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_direct, { 0xab008100 } ++ }, ++/* pxvi.s ${d-imm7-4}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_direct, { 0xac008100 } ++ }, ++/* pxvi.s (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_direct, { 0xac008100 } ++ }, ++/* pxvi.s (${d-An})${d-i4-4}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_direct, { 0xaa008100 } ++ }, ++/* pxvi.s ${d-i4-4}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_direct, { 0xaa108100 } ++ }, ++/* pxvi.s ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0xa9008000 } ++ }, ++/* pxvi.s #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_immediate, { 0xa8008000 } ++ }, ++/* pxvi.s (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_immediate, { 0xab008000 } ++ }, ++/* pxvi.s ${d-imm7-4}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_immediate, { 0xac008000 } ++ }, ++/* pxvi.s (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_immediate, { 0xac008000 } ++ }, ++/* pxvi.s (${d-An})${d-i4-4}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_immediate, { 0xaa008000 } ++ }, ++/* pxvi.s ${d-i4-4}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_immediate, { 0xaa108000 } ++ }, ++/* pxvi.s ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0xa9008300 } ++ }, ++/* pxvi.s #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_index_4, { 0xa8008300 } ++ }, ++/* pxvi.s (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_index_4, { 0xab008300 } ++ }, ++/* pxvi.s ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0xac008300 } ++ }, ++/* pxvi.s (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_index_4, { 0xac008300 } ++ }, ++/* pxvi.s (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0xaa008300 } ++ }, ++/* pxvi.s ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0xaa108300 } ++ }, ++/* pxvi.s ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0xa9008400 } ++ }, ++/* pxvi.s #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_offset_4, { 0xa8008400 } ++ }, ++/* pxvi.s (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0xab008400 } ++ }, ++/* pxvi.s ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0xac008400 } ++ }, ++/* pxvi.s (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_offset_4, { 0xac008400 } ++ }, ++/* pxvi.s (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0xaa008400 } ++ }, ++/* pxvi.s ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0xaa108400 } ++ }, ++/* pxvi.s ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0xa9008400 } ++ }, ++/* pxvi.s #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_4, { 0xa8008400 } ++ }, ++/* pxvi.s (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_4, { 0xab008400 } ++ }, ++/* pxvi.s ${d-imm7-4}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_4, { 0xac008400 } ++ }, ++/* pxvi.s (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_4, { 0xac008400 } ++ }, ++/* pxvi.s (${d-An})${d-i4-4}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_4, { 0xaa008400 } ++ }, ++/* pxvi.s ${d-i4-4}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_4, { 0xaa108400 } ++ }, ++/* pxvi.s ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0xa9008200 } ++ }, ++/* pxvi.s #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_post_increment_4, { 0xa8008200 } ++ }, ++/* pxvi.s (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0xab008200 } ++ }, ++/* pxvi.s ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0xac008200 } ++ }, ++/* pxvi.s (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_post_increment_4, { 0xac008200 } ++ }, ++/* pxvi.s (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0xaa008200 } ++ }, ++/* pxvi.s ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0xaa108200 } ++ }, ++/* pxvi.s ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0xa9008210 } ++ }, ++/* pxvi.s #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_pre_increment_4, { 0xa8008210 } ++ }, ++/* pxvi.s (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0xab008210 } ++ }, ++/* pxvi.s ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0xac008210 } ++ }, ++/* pxvi.s (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_pre_increment_4, { 0xac008210 } ++ }, ++/* pxvi.s (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0xaa008210 } ++ }, ++/* pxvi.s ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0xaa108210 } ++ }, ++/* pxvi ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0xa9000100 } ++ }, ++/* pxvi #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_direct, { 0xa8000100 } ++ }, ++/* pxvi (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_direct, { 0xab000100 } ++ }, ++/* pxvi ${d-imm7-4}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_direct, { 0xac000100 } ++ }, ++/* pxvi (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_direct, { 0xac000100 } ++ }, ++/* pxvi (${d-An})${d-i4-4}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_direct, { 0xaa000100 } ++ }, ++/* pxvi ${d-i4-4}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_direct, { 0xaa100100 } ++ }, ++/* pxvi ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0xa9000000 } ++ }, ++/* pxvi #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_immediate, { 0xa8000000 } ++ }, ++/* pxvi (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_immediate, { 0xab000000 } ++ }, ++/* pxvi ${d-imm7-4}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_immediate, { 0xac000000 } ++ }, ++/* pxvi (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_immediate, { 0xac000000 } ++ }, ++/* pxvi (${d-An})${d-i4-4}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_immediate, { 0xaa000000 } ++ }, ++/* pxvi ${d-i4-4}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_immediate, { 0xaa100000 } ++ }, ++/* pxvi ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0xa9000300 } ++ }, ++/* pxvi #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_index_4, { 0xa8000300 } ++ }, ++/* pxvi (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_index_4, { 0xab000300 } ++ }, ++/* pxvi ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0xac000300 } ++ }, ++/* pxvi (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_index_4, { 0xac000300 } ++ }, ++/* pxvi (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0xaa000300 } ++ }, ++/* pxvi ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0xaa100300 } ++ }, ++/* pxvi ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0xa9000400 } ++ }, ++/* pxvi #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_offset_4, { 0xa8000400 } ++ }, ++/* pxvi (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0xab000400 } ++ }, ++/* pxvi ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0xac000400 } ++ }, ++/* pxvi (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_offset_4, { 0xac000400 } ++ }, ++/* pxvi (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0xaa000400 } ++ }, ++/* pxvi ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0xaa100400 } ++ }, ++/* pxvi ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0xa9000400 } ++ }, ++/* pxvi #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_4, { 0xa8000400 } ++ }, ++/* pxvi (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_4, { 0xab000400 } ++ }, ++/* pxvi ${d-imm7-4}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_4, { 0xac000400 } ++ }, ++/* pxvi (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_4, { 0xac000400 } ++ }, ++/* pxvi (${d-An})${d-i4-4}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_4, { 0xaa000400 } ++ }, ++/* pxvi ${d-i4-4}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_4, { 0xaa100400 } ++ }, ++/* pxvi ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0xa9000200 } ++ }, ++/* pxvi #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_post_increment_4, { 0xa8000200 } ++ }, ++/* pxvi (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0xab000200 } ++ }, ++/* pxvi ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0xac000200 } ++ }, ++/* pxvi (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_post_increment_4, { 0xac000200 } ++ }, ++/* pxvi (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0xaa000200 } ++ }, ++/* pxvi ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0xaa100200 } ++ }, ++/* pxvi ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0xa9000210 } ++ }, ++/* pxvi #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_pre_increment_4, { 0xa8000210 } ++ }, ++/* pxvi (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0xab000210 } ++ }, ++/* pxvi ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0xac000210 } ++ }, ++/* pxvi (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_pre_increment_4, { 0xac000210 } ++ }, ++/* pxvi (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0xaa000210 } ++ }, ++/* pxvi ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0xaa100210 } ++ }, ++/* pxblend.t ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0xa1008100 } ++ }, ++/* pxblend.t #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_direct, { 0xa0008100 } ++ }, ++/* pxblend.t (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_direct, { 0xa3008100 } ++ }, ++/* pxblend.t ${d-imm7-4}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_direct, { 0xa4008100 } ++ }, ++/* pxblend.t (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_direct, { 0xa4008100 } ++ }, ++/* pxblend.t (${d-An})${d-i4-4}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_direct, { 0xa2008100 } ++ }, ++/* pxblend.t ${d-i4-4}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_direct, { 0xa2108100 } ++ }, ++/* pxblend.t ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0xa1008000 } ++ }, ++/* pxblend.t #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_immediate, { 0xa0008000 } ++ }, ++/* pxblend.t (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_immediate, { 0xa3008000 } ++ }, ++/* pxblend.t ${d-imm7-4}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_immediate, { 0xa4008000 } ++ }, ++/* pxblend.t (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_immediate, { 0xa4008000 } ++ }, ++/* pxblend.t (${d-An})${d-i4-4}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_immediate, { 0xa2008000 } ++ }, ++/* pxblend.t ${d-i4-4}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_immediate, { 0xa2108000 } ++ }, ++/* pxblend.t ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0xa1008300 } ++ }, ++/* pxblend.t #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_index_4, { 0xa0008300 } ++ }, ++/* pxblend.t (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_index_4, { 0xa3008300 } ++ }, ++/* pxblend.t ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0xa4008300 } ++ }, ++/* pxblend.t (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_index_4, { 0xa4008300 } ++ }, ++/* pxblend.t (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0xa2008300 } ++ }, ++/* pxblend.t ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0xa2108300 } ++ }, ++/* pxblend.t ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0xa1008400 } ++ }, ++/* pxblend.t #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_offset_4, { 0xa0008400 } ++ }, ++/* pxblend.t (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0xa3008400 } ++ }, ++/* pxblend.t ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0xa4008400 } ++ }, ++/* pxblend.t (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_offset_4, { 0xa4008400 } ++ }, ++/* pxblend.t (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0xa2008400 } ++ }, ++/* pxblend.t ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0xa2108400 } ++ }, ++/* pxblend.t ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0xa1008400 } ++ }, ++/* pxblend.t #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_4, { 0xa0008400 } ++ }, ++/* pxblend.t (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_4, { 0xa3008400 } ++ }, ++/* pxblend.t ${d-imm7-4}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_4, { 0xa4008400 } ++ }, ++/* pxblend.t (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_4, { 0xa4008400 } ++ }, ++/* pxblend.t (${d-An})${d-i4-4}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_4, { 0xa2008400 } ++ }, ++/* pxblend.t ${d-i4-4}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_4, { 0xa2108400 } ++ }, ++/* pxblend.t ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0xa1008200 } ++ }, ++/* pxblend.t #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_post_increment_4, { 0xa0008200 } ++ }, ++/* pxblend.t (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0xa3008200 } ++ }, ++/* pxblend.t ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0xa4008200 } ++ }, ++/* pxblend.t (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_post_increment_4, { 0xa4008200 } ++ }, ++/* pxblend.t (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0xa2008200 } ++ }, ++/* pxblend.t ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0xa2108200 } ++ }, ++/* pxblend.t ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0xa1008210 } ++ }, ++/* pxblend.t #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_pre_increment_4, { 0xa0008210 } ++ }, ++/* pxblend.t (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0xa3008210 } ++ }, ++/* pxblend.t ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0xa4008210 } ++ }, ++/* pxblend.t (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_pre_increment_4, { 0xa4008210 } ++ }, ++/* pxblend.t (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0xa2008210 } ++ }, ++/* pxblend.t ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0xa2108210 } ++ }, ++/* pxblend ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0xa1000100 } ++ }, ++/* pxblend #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_direct, { 0xa0000100 } ++ }, ++/* pxblend (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_direct, { 0xa3000100 } ++ }, ++/* pxblend ${d-imm7-4}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_direct, { 0xa4000100 } ++ }, ++/* pxblend (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_direct, { 0xa4000100 } ++ }, ++/* pxblend (${d-An})${d-i4-4}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_direct, { 0xa2000100 } ++ }, ++/* pxblend ${d-i4-4}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_direct, { 0xa2100100 } ++ }, ++/* pxblend ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0xa1000000 } ++ }, ++/* pxblend #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_immediate, { 0xa0000000 } ++ }, ++/* pxblend (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_immediate, { 0xa3000000 } ++ }, ++/* pxblend ${d-imm7-4}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_immediate, { 0xa4000000 } ++ }, ++/* pxblend (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_immediate, { 0xa4000000 } ++ }, ++/* pxblend (${d-An})${d-i4-4}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_immediate, { 0xa2000000 } ++ }, ++/* pxblend ${d-i4-4}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_immediate, { 0xa2100000 } ++ }, ++/* pxblend ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0xa1000300 } ++ }, ++/* pxblend #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_index_4, { 0xa0000300 } ++ }, ++/* pxblend (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_index_4, { 0xa3000300 } ++ }, ++/* pxblend ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0xa4000300 } ++ }, ++/* pxblend (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_index_4, { 0xa4000300 } ++ }, ++/* pxblend (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0xa2000300 } ++ }, ++/* pxblend ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0xa2100300 } ++ }, ++/* pxblend ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0xa1000400 } ++ }, ++/* pxblend #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_offset_4, { 0xa0000400 } ++ }, ++/* pxblend (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0xa3000400 } ++ }, ++/* pxblend ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0xa4000400 } ++ }, ++/* pxblend (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_offset_4, { 0xa4000400 } ++ }, ++/* pxblend (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0xa2000400 } ++ }, ++/* pxblend ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0xa2100400 } ++ }, ++/* pxblend ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0xa1000400 } ++ }, ++/* pxblend #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_4, { 0xa0000400 } ++ }, ++/* pxblend (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_4, { 0xa3000400 } ++ }, ++/* pxblend ${d-imm7-4}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_4, { 0xa4000400 } ++ }, ++/* pxblend (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_4, { 0xa4000400 } ++ }, ++/* pxblend (${d-An})${d-i4-4}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_4, { 0xa2000400 } ++ }, ++/* pxblend ${d-i4-4}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_4, { 0xa2100400 } ++ }, ++/* pxblend ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0xa1000200 } ++ }, ++/* pxblend #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_post_increment_4, { 0xa0000200 } ++ }, ++/* pxblend (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0xa3000200 } ++ }, ++/* pxblend ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0xa4000200 } ++ }, ++/* pxblend (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_post_increment_4, { 0xa4000200 } ++ }, ++/* pxblend (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0xa2000200 } ++ }, ++/* pxblend ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0xa2100200 } ++ }, ++/* pxblend ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0xa1000210 } ++ }, ++/* pxblend #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_pre_increment_4, { 0xa0000210 } ++ }, ++/* pxblend (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0xa3000210 } ++ }, ++/* pxblend ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0xa4000210 } ++ }, ++/* pxblend (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_pre_increment_4, { 0xa4000210 } ++ }, ++/* pxblend (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0xa2000210 } ++ }, ++/* pxblend ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0xa2100210 } ++ }, ++/* pxcnv.t ${d-direct-addr},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_direct_s1_direct, { 0x100d900 } ++ }, ++/* pxcnv.t #${d-imm8},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_direct, { 0xd900 } ++ }, ++/* pxcnv.t (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_direct, { 0x300d900 } ++ }, ++/* pxcnv.t ${d-imm7-2}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_direct, { 0x400d900 } ++ }, ++/* pxcnv.t (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_direct, { 0x400d900 } ++ }, ++/* pxcnv.t (${d-An})${d-i4-2}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_direct, { 0x200d900 } ++ }, ++/* pxcnv.t ${d-i4-2}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_direct, { 0x210d900 } ++ }, ++/* pxcnv.t ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_direct_s1_immediate, { 0x100d800 } ++ }, ++/* pxcnv.t #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_immediate, { 0xd800 } ++ }, ++/* pxcnv.t (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_immediate, { 0x300d800 } ++ }, ++/* pxcnv.t ${d-imm7-2}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_immediate, { 0x400d800 } ++ }, ++/* pxcnv.t (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_immediate, { 0x400d800 } ++ }, ++/* pxcnv.t (${d-An})${d-i4-2}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_immediate, { 0x200d800 } ++ }, ++/* pxcnv.t ${d-i4-2}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_immediate, { 0x210d800 } ++ }, ++/* pxcnv.t ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_index_4, { 0x100db00 } ++ }, ++/* pxcnv.t #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_pxcnv_t_d_immediate_2_s1_indirect_with_index_4, { 0xdb00 } ++ }, ++/* pxcnv.t (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_with_index_4, { 0x300db00 } ++ }, ++/* pxcnv.t ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_with_index_4, { 0x400db00 } ++ }, ++/* pxcnv.t (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_2_s1_indirect_with_index_4, { 0x400db00 } ++ }, ++/* pxcnv.t (${d-An})${d-i4-2}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_with_index_4, { 0x200db00 } ++ }, ++/* pxcnv.t ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_with_index_4, { 0x210db00 } ++ }, ++/* pxcnv.t ${d-direct-addr},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_offset_4, { 0x100dc00 } ++ }, ++/* pxcnv.t #${d-imm8},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_immediate_2_s1_indirect_with_offset_4, { 0xdc00 } ++ }, ++/* pxcnv.t (${d-An},${d-r}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_with_offset_4, { 0x300dc00 } ++ }, ++/* pxcnv.t ${d-imm7-2}(${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_with_offset_4, { 0x400dc00 } ++ }, ++/* pxcnv.t (${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_2_s1_indirect_with_offset_4, { 0x400dc00 } ++ }, ++/* pxcnv.t (${d-An})${d-i4-2}++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_with_offset_4, { 0x200dc00 } ++ }, ++/* pxcnv.t ${d-i4-2}(${d-An})++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_with_offset_4, { 0x210dc00 } ++ }, ++/* pxcnv.t ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_4, { 0x100dc00 } ++ }, ++/* pxcnv.t #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_immediate_2_s1_indirect_4, { 0xdc00 } ++ }, ++/* pxcnv.t (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_4, { 0x300dc00 } ++ }, ++/* pxcnv.t ${d-imm7-2}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_4, { 0x400dc00 } ++ }, ++/* pxcnv.t (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_2_s1_indirect_4, { 0x400dc00 } ++ }, ++/* pxcnv.t (${d-An})${d-i4-2}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_4, { 0x200dc00 } ++ }, ++/* pxcnv.t ${d-i4-2}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_4, { 0x210dc00 } ++ }, ++/* pxcnv.t ${d-direct-addr},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_post_increment_4, { 0x100da00 } ++ }, ++/* pxcnv.t #${d-imm8},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_immediate_2_s1_indirect_with_post_increment_4, { 0xda00 } ++ }, ++/* pxcnv.t (${d-An},${d-r}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_with_post_increment_4, { 0x300da00 } ++ }, ++/* pxcnv.t ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_with_post_increment_4, { 0x400da00 } ++ }, ++/* pxcnv.t (${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_2_s1_indirect_with_post_increment_4, { 0x400da00 } ++ }, ++/* pxcnv.t (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_4, { 0x200da00 } ++ }, ++/* pxcnv.t ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_4, { 0x210da00 } ++ }, ++/* pxcnv.t ${d-direct-addr},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_pre_increment_4, { 0x100da10 } ++ }, ++/* pxcnv.t #${d-imm8},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_immediate_2_s1_indirect_with_pre_increment_4, { 0xda10 } ++ }, ++/* pxcnv.t (${d-An},${d-r}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_with_pre_increment_4, { 0x300da10 } ++ }, ++/* pxcnv.t ${d-imm7-2}(${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_with_pre_increment_4, { 0x400da10 } ++ }, ++/* pxcnv.t (${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_2_s1_indirect_with_pre_increment_4, { 0x400da10 } ++ }, ++/* pxcnv.t (${d-An})${d-i4-2}++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_4, { 0x200da10 } ++ }, ++/* pxcnv.t ${d-i4-2}(${d-An})++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_4, { 0x210da10 } ++ }, ++/* pxcnv ${d-direct-addr},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_direct_s1_direct, { 0x100d100 } ++ }, ++/* pxcnv #${d-imm8},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_direct, { 0xd100 } ++ }, ++/* pxcnv (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_direct, { 0x300d100 } ++ }, ++/* pxcnv ${d-imm7-2}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_direct, { 0x400d100 } ++ }, ++/* pxcnv (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_direct, { 0x400d100 } ++ }, ++/* pxcnv (${d-An})${d-i4-2}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_direct, { 0x200d100 } ++ }, ++/* pxcnv ${d-i4-2}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_direct, { 0x210d100 } ++ }, ++/* pxcnv ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_direct_s1_immediate, { 0x100d000 } ++ }, ++/* pxcnv #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_immediate, { 0xd000 } ++ }, ++/* pxcnv (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_immediate, { 0x300d000 } ++ }, ++/* pxcnv ${d-imm7-2}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_immediate, { 0x400d000 } ++ }, ++/* pxcnv (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_immediate, { 0x400d000 } ++ }, ++/* pxcnv (${d-An})${d-i4-2}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_immediate, { 0x200d000 } ++ }, ++/* pxcnv ${d-i4-2}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_immediate, { 0x210d000 } ++ }, ++/* pxcnv ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_index_4, { 0x100d300 } ++ }, ++/* pxcnv #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_pxcnv_t_d_immediate_2_s1_indirect_with_index_4, { 0xd300 } ++ }, ++/* pxcnv (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_with_index_4, { 0x300d300 } ++ }, ++/* pxcnv ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_with_index_4, { 0x400d300 } ++ }, ++/* pxcnv (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_2_s1_indirect_with_index_4, { 0x400d300 } ++ }, ++/* pxcnv (${d-An})${d-i4-2}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_with_index_4, { 0x200d300 } ++ }, ++/* pxcnv ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_with_index_4, { 0x210d300 } ++ }, ++/* pxcnv ${d-direct-addr},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_offset_4, { 0x100d400 } ++ }, ++/* pxcnv #${d-imm8},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_immediate_2_s1_indirect_with_offset_4, { 0xd400 } ++ }, ++/* pxcnv (${d-An},${d-r}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_with_offset_4, { 0x300d400 } ++ }, ++/* pxcnv ${d-imm7-2}(${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_with_offset_4, { 0x400d400 } ++ }, ++/* pxcnv (${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_2_s1_indirect_with_offset_4, { 0x400d400 } ++ }, ++/* pxcnv (${d-An})${d-i4-2}++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_with_offset_4, { 0x200d400 } ++ }, ++/* pxcnv ${d-i4-2}(${d-An})++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_with_offset_4, { 0x210d400 } ++ }, ++/* pxcnv ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_4, { 0x100d400 } ++ }, ++/* pxcnv #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_immediate_2_s1_indirect_4, { 0xd400 } ++ }, ++/* pxcnv (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_4, { 0x300d400 } ++ }, ++/* pxcnv ${d-imm7-2}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_4, { 0x400d400 } ++ }, ++/* pxcnv (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_2_s1_indirect_4, { 0x400d400 } ++ }, ++/* pxcnv (${d-An})${d-i4-2}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_4, { 0x200d400 } ++ }, ++/* pxcnv ${d-i4-2}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_4, { 0x210d400 } ++ }, ++/* pxcnv ${d-direct-addr},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_post_increment_4, { 0x100d200 } ++ }, ++/* pxcnv #${d-imm8},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_immediate_2_s1_indirect_with_post_increment_4, { 0xd200 } ++ }, ++/* pxcnv (${d-An},${d-r}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_with_post_increment_4, { 0x300d200 } ++ }, ++/* pxcnv ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_with_post_increment_4, { 0x400d200 } ++ }, ++/* pxcnv (${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_2_s1_indirect_with_post_increment_4, { 0x400d200 } ++ }, ++/* pxcnv (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_4, { 0x200d200 } ++ }, ++/* pxcnv ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_4, { 0x210d200 } ++ }, ++/* pxcnv ${d-direct-addr},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_pre_increment_4, { 0x100d210 } ++ }, ++/* pxcnv #${d-imm8},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_immediate_2_s1_indirect_with_pre_increment_4, { 0xd210 } ++ }, ++/* pxcnv (${d-An},${d-r}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_index_2_s1_indirect_with_pre_increment_4, { 0x300d210 } ++ }, ++/* pxcnv ${d-imm7-2}(${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_offset_2_s1_indirect_with_pre_increment_4, { 0x400d210 } ++ }, ++/* pxcnv (${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_2_s1_indirect_with_pre_increment_4, { 0x400d210 } ++ }, ++/* pxcnv (${d-An})${d-i4-2}++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_4, { 0x200d210 } ++ }, ++/* pxcnv ${d-i4-2}(${d-An})++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_pxcnv_t_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_4, { 0x210d210 } ++ }, ++/* subc ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x99000100 } ++ }, ++/* subc #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_direct, { 0x98000100 } ++ }, ++/* subc (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_direct, { 0x9b000100 } ++ }, ++/* subc ${d-imm7-4}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_direct, { 0x9c000100 } ++ }, ++/* subc (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_direct, { 0x9c000100 } ++ }, ++/* subc (${d-An})${d-i4-4}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_direct, { 0x9a000100 } ++ }, ++/* subc ${d-i4-4}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_direct, { 0x9a100100 } ++ }, ++/* subc ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x99000000 } ++ }, ++/* subc #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_immediate, { 0x98000000 } ++ }, ++/* subc (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_immediate, { 0x9b000000 } ++ }, ++/* subc ${d-imm7-4}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_immediate, { 0x9c000000 } ++ }, ++/* subc (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_immediate, { 0x9c000000 } ++ }, ++/* subc (${d-An})${d-i4-4}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_immediate, { 0x9a000000 } ++ }, ++/* subc ${d-i4-4}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_immediate, { 0x9a100000 } ++ }, ++/* subc ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0x99000300 } ++ }, ++/* subc #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_index_4, { 0x98000300 } ++ }, ++/* subc (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x9b000300 } ++ }, ++/* subc ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x9c000300 } ++ }, ++/* subc (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_index_4, { 0x9c000300 } ++ }, ++/* subc (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x9a000300 } ++ }, ++/* subc ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x9a100300 } ++ }, ++/* subc ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0x99000400 } ++ }, ++/* subc #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_offset_4, { 0x98000400 } ++ }, ++/* subc (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x9b000400 } ++ }, ++/* subc ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x9c000400 } ++ }, ++/* subc (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_offset_4, { 0x9c000400 } ++ }, ++/* subc (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x9a000400 } ++ }, ++/* subc ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x9a100400 } ++ }, ++/* subc ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0x99000400 } ++ }, ++/* subc #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_4, { 0x98000400 } ++ }, ++/* subc (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_4, { 0x9b000400 } ++ }, ++/* subc ${d-imm7-4}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_4, { 0x9c000400 } ++ }, ++/* subc (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_4, { 0x9c000400 } ++ }, ++/* subc (${d-An})${d-i4-4}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_4, { 0x9a000400 } ++ }, ++/* subc ${d-i4-4}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x9a100400 } ++ }, ++/* subc ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0x99000200 } ++ }, ++/* subc #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_post_increment_4, { 0x98000200 } ++ }, ++/* subc (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x9b000200 } ++ }, ++/* subc ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x9c000200 } ++ }, ++/* subc (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_post_increment_4, { 0x9c000200 } ++ }, ++/* subc (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x9a000200 } ++ }, ++/* subc ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x9a100200 } ++ }, ++/* subc ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0x99000210 } ++ }, ++/* subc #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_pre_increment_4, { 0x98000210 } ++ }, ++/* subc (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x9b000210 } ++ }, ++/* subc ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x9c000210 } ++ }, ++/* subc (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x9c000210 } ++ }, ++/* subc (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x9a000210 } ++ }, ++/* subc ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x9a100210 } ++ }, ++/* addc ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x81000100 } ++ }, ++/* addc #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_direct, { 0x80000100 } ++ }, ++/* addc (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_direct, { 0x83000100 } ++ }, ++/* addc ${d-imm7-4}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_direct, { 0x84000100 } ++ }, ++/* addc (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_direct, { 0x84000100 } ++ }, ++/* addc (${d-An})${d-i4-4}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_direct, { 0x82000100 } ++ }, ++/* addc ${d-i4-4}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_direct, { 0x82100100 } ++ }, ++/* addc ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x81000000 } ++ }, ++/* addc #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_immediate, { 0x80000000 } ++ }, ++/* addc (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_immediate, { 0x83000000 } ++ }, ++/* addc ${d-imm7-4}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_immediate, { 0x84000000 } ++ }, ++/* addc (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_immediate, { 0x84000000 } ++ }, ++/* addc (${d-An})${d-i4-4}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_immediate, { 0x82000000 } ++ }, ++/* addc ${d-i4-4}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_immediate, { 0x82100000 } ++ }, ++/* addc ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0x81000300 } ++ }, ++/* addc #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_index_4, { 0x80000300 } ++ }, ++/* addc (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x83000300 } ++ }, ++/* addc ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x84000300 } ++ }, ++/* addc (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_index_4, { 0x84000300 } ++ }, ++/* addc (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x82000300 } ++ }, ++/* addc ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x82100300 } ++ }, ++/* addc ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0x81000400 } ++ }, ++/* addc #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_offset_4, { 0x80000400 } ++ }, ++/* addc (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x83000400 } ++ }, ++/* addc ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x84000400 } ++ }, ++/* addc (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_offset_4, { 0x84000400 } ++ }, ++/* addc (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x82000400 } ++ }, ++/* addc ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x82100400 } ++ }, ++/* addc ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0x81000400 } ++ }, ++/* addc #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_4, { 0x80000400 } ++ }, ++/* addc (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_4, { 0x83000400 } ++ }, ++/* addc ${d-imm7-4}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_4, { 0x84000400 } ++ }, ++/* addc (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_4, { 0x84000400 } ++ }, ++/* addc (${d-An})${d-i4-4}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_4, { 0x82000400 } ++ }, ++/* addc ${d-i4-4}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x82100400 } ++ }, ++/* addc ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0x81000200 } ++ }, ++/* addc #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_post_increment_4, { 0x80000200 } ++ }, ++/* addc (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x83000200 } ++ }, ++/* addc ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x84000200 } ++ }, ++/* addc (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_post_increment_4, { 0x84000200 } ++ }, ++/* addc (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x82000200 } ++ }, ++/* addc ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x82100200 } ++ }, ++/* addc ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0x81000210 } ++ }, ++/* addc #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_pre_increment_4, { 0x80000210 } ++ }, ++/* addc (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x83000210 } ++ }, ++/* addc ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x84000210 } ++ }, ++/* addc (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x84000210 } ++ }, ++/* addc (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x82000210 } ++ }, ++/* addc ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x82100210 } ++ }, ++/* sub.1 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x89008100 } ++ }, ++/* sub.1 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_direct, { 0x88008100 } ++ }, ++/* sub.1 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_direct, { 0x8b008100 } ++ }, ++/* sub.1 ${d-imm7-1}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_direct, { 0x8c008100 } ++ }, ++/* sub.1 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_direct, { 0x8c008100 } ++ }, ++/* sub.1 (${d-An})${d-i4-1}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_direct, { 0x8a008100 } ++ }, ++/* sub.1 ${d-i4-1}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_direct, { 0x8a108100 } ++ }, ++/* sub.1 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x89008000 } ++ }, ++/* sub.1 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_immediate, { 0x88008000 } ++ }, ++/* sub.1 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_immediate, { 0x8b008000 } ++ }, ++/* sub.1 ${d-imm7-1}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_immediate, { 0x8c008000 } ++ }, ++/* sub.1 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_immediate, { 0x8c008000 } ++ }, ++/* sub.1 (${d-An})${d-i4-1}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_immediate, { 0x8a008000 } ++ }, ++/* sub.1 ${d-i4-1}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_immediate, { 0x8a108000 } ++ }, ++/* sub.1 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_index_1, { 0x89008300 } ++ }, ++/* sub.1 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_index_1, { 0x88008300 } ++ }, ++/* sub.1 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_index_1, { 0x8b008300 } ++ }, ++/* sub.1 ${d-imm7-1}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_index_1, { 0x8c008300 } ++ }, ++/* sub.1 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_index_1, { 0x8c008300 } ++ }, ++/* sub.1 (${d-An})${d-i4-1}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_index_1, { 0x8a008300 } ++ }, ++/* sub.1 ${d-i4-1}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_index_1, { 0x8a108300 } ++ }, ++/* sub.1 ${d-direct-addr},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_offset_1, { 0x89008400 } ++ }, ++/* sub.1 #${d-imm8},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_offset_1, { 0x88008400 } ++ }, ++/* sub.1 (${d-An},${d-r}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_offset_1, { 0x8b008400 } ++ }, ++/* sub.1 ${d-imm7-1}(${d-An}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_offset_1, { 0x8c008400 } ++ }, ++/* sub.1 (${d-An}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_offset_1, { 0x8c008400 } ++ }, ++/* sub.1 (${d-An})${d-i4-1}++,${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_offset_1, { 0x8a008400 } ++ }, ++/* sub.1 ${d-i4-1}(${d-An})++,${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_offset_1, { 0x8a108400 } ++ }, ++/* sub.1 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_1, { 0x89008400 } ++ }, ++/* sub.1 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_1, { 0x88008400 } ++ }, ++/* sub.1 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_1, { 0x8b008400 } ++ }, ++/* sub.1 ${d-imm7-1}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_1, { 0x8c008400 } ++ }, ++/* sub.1 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_1, { 0x8c008400 } ++ }, ++/* sub.1 (${d-An})${d-i4-1}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_1, { 0x8a008400 } ++ }, ++/* sub.1 ${d-i4-1}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_1, { 0x8a108400 } ++ }, ++/* sub.1 ${d-direct-addr},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_post_increment_1, { 0x89008200 } ++ }, ++/* sub.1 #${d-imm8},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_post_increment_1, { 0x88008200 } ++ }, ++/* sub.1 (${d-An},${d-r}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_post_increment_1, { 0x8b008200 } ++ }, ++/* sub.1 ${d-imm7-1}(${d-An}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_post_increment_1, { 0x8c008200 } ++ }, ++/* sub.1 (${d-An}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_post_increment_1, { 0x8c008200 } ++ }, ++/* sub.1 (${d-An})${d-i4-1}++,(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_post_increment_1, { 0x8a008200 } ++ }, ++/* sub.1 ${d-i4-1}(${d-An})++,(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_post_increment_1, { 0x8a108200 } ++ }, ++/* sub.1 ${d-direct-addr},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_pre_increment_1, { 0x89008210 } ++ }, ++/* sub.1 #${d-imm8},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_pre_increment_1, { 0x88008210 } ++ }, ++/* sub.1 (${d-An},${d-r}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_pre_increment_1, { 0x8b008210 } ++ }, ++/* sub.1 ${d-imm7-1}(${d-An}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_pre_increment_1, { 0x8c008210 } ++ }, ++/* sub.1 (${d-An}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_pre_increment_1, { 0x8c008210 } ++ }, ++/* sub.1 (${d-An})${d-i4-1}++,${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_pre_increment_1, { 0x8a008210 } ++ }, ++/* sub.1 ${d-i4-1}(${d-An})++,${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_pre_increment_1, { 0x8a108210 } ++ }, ++/* sub.4 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x91000100 } ++ }, ++/* sub.4 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_direct, { 0x90000100 } ++ }, ++/* sub.4 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_direct, { 0x93000100 } ++ }, ++/* sub.4 ${d-imm7-4}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_direct, { 0x94000100 } ++ }, ++/* sub.4 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_direct, { 0x94000100 } ++ }, ++/* sub.4 (${d-An})${d-i4-4}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_direct, { 0x92000100 } ++ }, ++/* sub.4 ${d-i4-4}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_direct, { 0x92100100 } ++ }, ++/* sub.4 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x91000000 } ++ }, ++/* sub.4 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_immediate, { 0x90000000 } ++ }, ++/* sub.4 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_immediate, { 0x93000000 } ++ }, ++/* sub.4 ${d-imm7-4}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_immediate, { 0x94000000 } ++ }, ++/* sub.4 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_immediate, { 0x94000000 } ++ }, ++/* sub.4 (${d-An})${d-i4-4}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_immediate, { 0x92000000 } ++ }, ++/* sub.4 ${d-i4-4}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_immediate, { 0x92100000 } ++ }, ++/* sub.4 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0x91000300 } ++ }, ++/* sub.4 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_index_4, { 0x90000300 } ++ }, ++/* sub.4 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x93000300 } ++ }, ++/* sub.4 ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x94000300 } ++ }, ++/* sub.4 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_index_4, { 0x94000300 } ++ }, ++/* sub.4 (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x92000300 } ++ }, ++/* sub.4 ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x92100300 } ++ }, ++/* sub.4 ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0x91000400 } ++ }, ++/* sub.4 #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_offset_4, { 0x90000400 } ++ }, ++/* sub.4 (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x93000400 } ++ }, ++/* sub.4 ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x94000400 } ++ }, ++/* sub.4 (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_offset_4, { 0x94000400 } ++ }, ++/* sub.4 (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x92000400 } ++ }, ++/* sub.4 ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x92100400 } ++ }, ++/* sub.4 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0x91000400 } ++ }, ++/* sub.4 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_4, { 0x90000400 } ++ }, ++/* sub.4 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_4, { 0x93000400 } ++ }, ++/* sub.4 ${d-imm7-4}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_4, { 0x94000400 } ++ }, ++/* sub.4 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_4, { 0x94000400 } ++ }, ++/* sub.4 (${d-An})${d-i4-4}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_4, { 0x92000400 } ++ }, ++/* sub.4 ${d-i4-4}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x92100400 } ++ }, ++/* sub.4 ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0x91000200 } ++ }, ++/* sub.4 #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_post_increment_4, { 0x90000200 } ++ }, ++/* sub.4 (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x93000200 } ++ }, ++/* sub.4 ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x94000200 } ++ }, ++/* sub.4 (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_post_increment_4, { 0x94000200 } ++ }, ++/* sub.4 (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x92000200 } ++ }, ++/* sub.4 ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x92100200 } ++ }, ++/* sub.4 ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0x91000210 } ++ }, ++/* sub.4 #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_pre_increment_4, { 0x90000210 } ++ }, ++/* sub.4 (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x93000210 } ++ }, ++/* sub.4 ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x94000210 } ++ }, ++/* sub.4 (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x94000210 } ++ }, ++/* sub.4 (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x92000210 } ++ }, ++/* sub.4 ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x92100210 } ++ }, ++/* sub.2 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x89000100 } ++ }, ++/* sub.2 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_direct, { 0x88000100 } ++ }, ++/* sub.2 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_direct, { 0x8b000100 } ++ }, ++/* sub.2 ${d-imm7-2}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_direct, { 0x8c000100 } ++ }, ++/* sub.2 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_direct, { 0x8c000100 } ++ }, ++/* sub.2 (${d-An})${d-i4-2}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_direct, { 0x8a000100 } ++ }, ++/* sub.2 ${d-i4-2}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_direct, { 0x8a100100 } ++ }, ++/* sub.2 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x89000000 } ++ }, ++/* sub.2 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_immediate, { 0x88000000 } ++ }, ++/* sub.2 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_immediate, { 0x8b000000 } ++ }, ++/* sub.2 ${d-imm7-2}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_immediate, { 0x8c000000 } ++ }, ++/* sub.2 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_immediate, { 0x8c000000 } ++ }, ++/* sub.2 (${d-An})${d-i4-2}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_immediate, { 0x8a000000 } ++ }, ++/* sub.2 ${d-i4-2}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_immediate, { 0x8a100000 } ++ }, ++/* sub.2 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_index_2, { 0x89000300 } ++ }, ++/* sub.2 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_index_2, { 0x88000300 } ++ }, ++/* sub.2 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_index_2, { 0x8b000300 } ++ }, ++/* sub.2 ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_index_2, { 0x8c000300 } ++ }, ++/* sub.2 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_index_2, { 0x8c000300 } ++ }, ++/* sub.2 (${d-An})${d-i4-2}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_index_2, { 0x8a000300 } ++ }, ++/* sub.2 ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_index_2, { 0x8a100300 } ++ }, ++/* sub.2 ${d-direct-addr},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_offset_2, { 0x89000400 } ++ }, ++/* sub.2 #${d-imm8},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_offset_2, { 0x88000400 } ++ }, ++/* sub.2 (${d-An},${d-r}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_offset_2, { 0x8b000400 } ++ }, ++/* sub.2 ${d-imm7-2}(${d-An}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_offset_2, { 0x8c000400 } ++ }, ++/* sub.2 (${d-An}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_offset_2, { 0x8c000400 } ++ }, ++/* sub.2 (${d-An})${d-i4-2}++,${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_offset_2, { 0x8a000400 } ++ }, ++/* sub.2 ${d-i4-2}(${d-An})++,${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_offset_2, { 0x8a100400 } ++ }, ++/* sub.2 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_2, { 0x89000400 } ++ }, ++/* sub.2 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_2, { 0x88000400 } ++ }, ++/* sub.2 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_2, { 0x8b000400 } ++ }, ++/* sub.2 ${d-imm7-2}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_2, { 0x8c000400 } ++ }, ++/* sub.2 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_2, { 0x8c000400 } ++ }, ++/* sub.2 (${d-An})${d-i4-2}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_2, { 0x8a000400 } ++ }, ++/* sub.2 ${d-i4-2}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_2, { 0x8a100400 } ++ }, ++/* sub.2 ${d-direct-addr},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_post_increment_2, { 0x89000200 } ++ }, ++/* sub.2 #${d-imm8},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_post_increment_2, { 0x88000200 } ++ }, ++/* sub.2 (${d-An},${d-r}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_post_increment_2, { 0x8b000200 } ++ }, ++/* sub.2 ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_post_increment_2, { 0x8c000200 } ++ }, ++/* sub.2 (${d-An}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_post_increment_2, { 0x8c000200 } ++ }, ++/* sub.2 (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_2, { 0x8a000200 } ++ }, ++/* sub.2 ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_2, { 0x8a100200 } ++ }, ++/* sub.2 ${d-direct-addr},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_pre_increment_2, { 0x89000210 } ++ }, ++/* sub.2 #${d-imm8},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_pre_increment_2, { 0x88000210 } ++ }, ++/* sub.2 (${d-An},${d-r}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_pre_increment_2, { 0x8b000210 } ++ }, ++/* sub.2 ${d-imm7-2}(${d-An}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_pre_increment_2, { 0x8c000210 } ++ }, ++/* sub.2 (${d-An}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_pre_increment_2, { 0x8c000210 } ++ }, ++/* sub.2 (${d-An})${d-i4-2}++,${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_2, { 0x8a000210 } ++ }, ++/* sub.2 ${d-i4-2}(${d-An})++,${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_2, { 0x8a100210 } ++ }, ++/* add.1 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x71008100 } ++ }, ++/* add.1 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_direct, { 0x70008100 } ++ }, ++/* add.1 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_direct, { 0x73008100 } ++ }, ++/* add.1 ${d-imm7-1}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_direct, { 0x74008100 } ++ }, ++/* add.1 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_direct, { 0x74008100 } ++ }, ++/* add.1 (${d-An})${d-i4-1}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_direct, { 0x72008100 } ++ }, ++/* add.1 ${d-i4-1}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_direct, { 0x72108100 } ++ }, ++/* add.1 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x71008000 } ++ }, ++/* add.1 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_immediate, { 0x70008000 } ++ }, ++/* add.1 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_immediate, { 0x73008000 } ++ }, ++/* add.1 ${d-imm7-1}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_immediate, { 0x74008000 } ++ }, ++/* add.1 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_immediate, { 0x74008000 } ++ }, ++/* add.1 (${d-An})${d-i4-1}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_immediate, { 0x72008000 } ++ }, ++/* add.1 ${d-i4-1}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_immediate, { 0x72108000 } ++ }, ++/* add.1 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_index_1, { 0x71008300 } ++ }, ++/* add.1 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_index_1, { 0x70008300 } ++ }, ++/* add.1 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_index_1, { 0x73008300 } ++ }, ++/* add.1 ${d-imm7-1}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_index_1, { 0x74008300 } ++ }, ++/* add.1 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_index_1, { 0x74008300 } ++ }, ++/* add.1 (${d-An})${d-i4-1}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_index_1, { 0x72008300 } ++ }, ++/* add.1 ${d-i4-1}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_index_1, { 0x72108300 } ++ }, ++/* add.1 ${d-direct-addr},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_offset_1, { 0x71008400 } ++ }, ++/* add.1 #${d-imm8},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_offset_1, { 0x70008400 } ++ }, ++/* add.1 (${d-An},${d-r}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_offset_1, { 0x73008400 } ++ }, ++/* add.1 ${d-imm7-1}(${d-An}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_offset_1, { 0x74008400 } ++ }, ++/* add.1 (${d-An}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_offset_1, { 0x74008400 } ++ }, ++/* add.1 (${d-An})${d-i4-1}++,${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_offset_1, { 0x72008400 } ++ }, ++/* add.1 ${d-i4-1}(${d-An})++,${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_offset_1, { 0x72108400 } ++ }, ++/* add.1 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_1, { 0x71008400 } ++ }, ++/* add.1 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_1, { 0x70008400 } ++ }, ++/* add.1 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_1, { 0x73008400 } ++ }, ++/* add.1 ${d-imm7-1}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_1, { 0x74008400 } ++ }, ++/* add.1 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_1, { 0x74008400 } ++ }, ++/* add.1 (${d-An})${d-i4-1}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_1, { 0x72008400 } ++ }, ++/* add.1 ${d-i4-1}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_1, { 0x72108400 } ++ }, ++/* add.1 ${d-direct-addr},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_post_increment_1, { 0x71008200 } ++ }, ++/* add.1 #${d-imm8},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_post_increment_1, { 0x70008200 } ++ }, ++/* add.1 (${d-An},${d-r}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_post_increment_1, { 0x73008200 } ++ }, ++/* add.1 ${d-imm7-1}(${d-An}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_post_increment_1, { 0x74008200 } ++ }, ++/* add.1 (${d-An}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_post_increment_1, { 0x74008200 } ++ }, ++/* add.1 (${d-An})${d-i4-1}++,(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_post_increment_1, { 0x72008200 } ++ }, ++/* add.1 ${d-i4-1}(${d-An})++,(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_post_increment_1, { 0x72108200 } ++ }, ++/* add.1 ${d-direct-addr},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_pre_increment_1, { 0x71008210 } ++ }, ++/* add.1 #${d-imm8},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_pre_increment_1, { 0x70008210 } ++ }, ++/* add.1 (${d-An},${d-r}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_pre_increment_1, { 0x73008210 } ++ }, ++/* add.1 ${d-imm7-1}(${d-An}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_pre_increment_1, { 0x74008210 } ++ }, ++/* add.1 (${d-An}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_pre_increment_1, { 0x74008210 } ++ }, ++/* add.1 (${d-An})${d-i4-1}++,${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_pre_increment_1, { 0x72008210 } ++ }, ++/* add.1 ${d-i4-1}(${d-An})++,${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_pre_increment_1, { 0x72108210 } ++ }, ++/* add.4 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x79000100 } ++ }, ++/* add.4 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_direct, { 0x78000100 } ++ }, ++/* add.4 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_direct, { 0x7b000100 } ++ }, ++/* add.4 ${d-imm7-4}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_direct, { 0x7c000100 } ++ }, ++/* add.4 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_direct, { 0x7c000100 } ++ }, ++/* add.4 (${d-An})${d-i4-4}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_direct, { 0x7a000100 } ++ }, ++/* add.4 ${d-i4-4}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_direct, { 0x7a100100 } ++ }, ++/* add.4 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x79000000 } ++ }, ++/* add.4 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_immediate, { 0x78000000 } ++ }, ++/* add.4 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_immediate, { 0x7b000000 } ++ }, ++/* add.4 ${d-imm7-4}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_immediate, { 0x7c000000 } ++ }, ++/* add.4 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_immediate, { 0x7c000000 } ++ }, ++/* add.4 (${d-An})${d-i4-4}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_immediate, { 0x7a000000 } ++ }, ++/* add.4 ${d-i4-4}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_immediate, { 0x7a100000 } ++ }, ++/* add.4 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0x79000300 } ++ }, ++/* add.4 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_index_4, { 0x78000300 } ++ }, ++/* add.4 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x7b000300 } ++ }, ++/* add.4 ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x7c000300 } ++ }, ++/* add.4 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_index_4, { 0x7c000300 } ++ }, ++/* add.4 (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x7a000300 } ++ }, ++/* add.4 ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x7a100300 } ++ }, ++/* add.4 ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0x79000400 } ++ }, ++/* add.4 #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_offset_4, { 0x78000400 } ++ }, ++/* add.4 (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x7b000400 } ++ }, ++/* add.4 ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x7c000400 } ++ }, ++/* add.4 (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_offset_4, { 0x7c000400 } ++ }, ++/* add.4 (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x7a000400 } ++ }, ++/* add.4 ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x7a100400 } ++ }, ++/* add.4 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0x79000400 } ++ }, ++/* add.4 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_4, { 0x78000400 } ++ }, ++/* add.4 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_4, { 0x7b000400 } ++ }, ++/* add.4 ${d-imm7-4}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_4, { 0x7c000400 } ++ }, ++/* add.4 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_4, { 0x7c000400 } ++ }, ++/* add.4 (${d-An})${d-i4-4}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_4, { 0x7a000400 } ++ }, ++/* add.4 ${d-i4-4}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x7a100400 } ++ }, ++/* add.4 ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0x79000200 } ++ }, ++/* add.4 #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_post_increment_4, { 0x78000200 } ++ }, ++/* add.4 (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x7b000200 } ++ }, ++/* add.4 ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x7c000200 } ++ }, ++/* add.4 (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_post_increment_4, { 0x7c000200 } ++ }, ++/* add.4 (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x7a000200 } ++ }, ++/* add.4 ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x7a100200 } ++ }, ++/* add.4 ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0x79000210 } ++ }, ++/* add.4 #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_pre_increment_4, { 0x78000210 } ++ }, ++/* add.4 (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x7b000210 } ++ }, ++/* add.4 ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x7c000210 } ++ }, ++/* add.4 (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x7c000210 } ++ }, ++/* add.4 (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x7a000210 } ++ }, ++/* add.4 ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x7a100210 } ++ }, ++/* add.2 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x71000100 } ++ }, ++/* add.2 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_direct, { 0x70000100 } ++ }, ++/* add.2 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_direct, { 0x73000100 } ++ }, ++/* add.2 ${d-imm7-2}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_direct, { 0x74000100 } ++ }, ++/* add.2 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_direct, { 0x74000100 } ++ }, ++/* add.2 (${d-An})${d-i4-2}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_direct, { 0x72000100 } ++ }, ++/* add.2 ${d-i4-2}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_direct, { 0x72100100 } ++ }, ++/* add.2 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x71000000 } ++ }, ++/* add.2 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_immediate, { 0x70000000 } ++ }, ++/* add.2 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_immediate, { 0x73000000 } ++ }, ++/* add.2 ${d-imm7-2}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_immediate, { 0x74000000 } ++ }, ++/* add.2 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_immediate, { 0x74000000 } ++ }, ++/* add.2 (${d-An})${d-i4-2}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_immediate, { 0x72000000 } ++ }, ++/* add.2 ${d-i4-2}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_immediate, { 0x72100000 } ++ }, ++/* add.2 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_index_2, { 0x71000300 } ++ }, ++/* add.2 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_index_2, { 0x70000300 } ++ }, ++/* add.2 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_index_2, { 0x73000300 } ++ }, ++/* add.2 ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_index_2, { 0x74000300 } ++ }, ++/* add.2 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_index_2, { 0x74000300 } ++ }, ++/* add.2 (${d-An})${d-i4-2}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_index_2, { 0x72000300 } ++ }, ++/* add.2 ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_index_2, { 0x72100300 } ++ }, ++/* add.2 ${d-direct-addr},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_offset_2, { 0x71000400 } ++ }, ++/* add.2 #${d-imm8},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_offset_2, { 0x70000400 } ++ }, ++/* add.2 (${d-An},${d-r}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_offset_2, { 0x73000400 } ++ }, ++/* add.2 ${d-imm7-2}(${d-An}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_offset_2, { 0x74000400 } ++ }, ++/* add.2 (${d-An}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_offset_2, { 0x74000400 } ++ }, ++/* add.2 (${d-An})${d-i4-2}++,${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_offset_2, { 0x72000400 } ++ }, ++/* add.2 ${d-i4-2}(${d-An})++,${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_offset_2, { 0x72100400 } ++ }, ++/* add.2 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_2, { 0x71000400 } ++ }, ++/* add.2 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_2, { 0x70000400 } ++ }, ++/* add.2 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_2, { 0x73000400 } ++ }, ++/* add.2 ${d-imm7-2}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_2, { 0x74000400 } ++ }, ++/* add.2 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_2, { 0x74000400 } ++ }, ++/* add.2 (${d-An})${d-i4-2}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_2, { 0x72000400 } ++ }, ++/* add.2 ${d-i4-2}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_2, { 0x72100400 } ++ }, ++/* add.2 ${d-direct-addr},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_post_increment_2, { 0x71000200 } ++ }, ++/* add.2 #${d-imm8},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_post_increment_2, { 0x70000200 } ++ }, ++/* add.2 (${d-An},${d-r}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_post_increment_2, { 0x73000200 } ++ }, ++/* add.2 ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_post_increment_2, { 0x74000200 } ++ }, ++/* add.2 (${d-An}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_post_increment_2, { 0x74000200 } ++ }, ++/* add.2 (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_2, { 0x72000200 } ++ }, ++/* add.2 ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_2, { 0x72100200 } ++ }, ++/* add.2 ${d-direct-addr},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_pre_increment_2, { 0x71000210 } ++ }, ++/* add.2 #${d-imm8},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_pre_increment_2, { 0x70000210 } ++ }, ++/* add.2 (${d-An},${d-r}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_pre_increment_2, { 0x73000210 } ++ }, ++/* add.2 ${d-imm7-2}(${d-An}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_pre_increment_2, { 0x74000210 } ++ }, ++/* add.2 (${d-An}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_pre_increment_2, { 0x74000210 } ++ }, ++/* add.2 (${d-An})${d-i4-2}++,${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_2, { 0x72000210 } ++ }, ++/* add.2 ${d-i4-2}(${d-An})++,${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_2, { 0x72100210 } ++ }, ++/* not.4 ${d-direct-addr},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_direct_s1_direct, { 0x1005100 } ++ }, ++/* not.4 #${d-imm8},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_immediate_4_s1_direct, { 0x5100 } ++ }, ++/* not.4 (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_direct, { 0x3005100 } ++ }, ++/* not.4 ${d-imm7-4}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_direct, { 0x4005100 } ++ }, ++/* not.4 (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_4_s1_direct, { 0x4005100 } ++ }, ++/* not.4 (${d-An})${d-i4-4}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_direct, { 0x2005100 } ++ }, ++/* not.4 ${d-i4-4}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_direct, { 0x2105100 } ++ }, ++/* not.4 ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_direct_s1_immediate, { 0x1005000 } ++ }, ++/* not.4 #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_immediate_4_s1_immediate, { 0x5000 } ++ }, ++/* not.4 (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_immediate, { 0x3005000 } ++ }, ++/* not.4 ${d-imm7-4}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_immediate, { 0x4005000 } ++ }, ++/* not.4 (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_4_s1_immediate, { 0x4005000 } ++ }, ++/* not.4 (${d-An})${d-i4-4}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_immediate, { 0x2005000 } ++ }, ++/* not.4 ${d-i4-4}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_immediate, { 0x2105000 } ++ }, ++/* not.4 ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_index_4, { 0x1005300 } ++ }, ++/* not.4 #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_index_4, { 0x5300 } ++ }, ++/* not.4 (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x3005300 } ++ }, ++/* not.4 ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x4005300 } ++ }, ++/* not.4 (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_index_4, { 0x4005300 } ++ }, ++/* not.4 (${d-An})${d-i4-4}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x2005300 } ++ }, ++/* not.4 ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x2105300 } ++ }, ++/* not.4 ${d-direct-addr},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_offset_4, { 0x1005400 } ++ }, ++/* not.4 #${d-imm8},${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_offset_4, { 0x5400 } ++ }, ++/* not.4 (${d-An},${d-r}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x3005400 } ++ }, ++/* not.4 ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x4005400 } ++ }, ++/* not.4 (${d-An}),${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_offset_4, { 0x4005400 } ++ }, ++/* not.4 (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x2005400 } ++ }, ++/* not.4 ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x2105400 } ++ }, ++/* not.4 ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_4, { 0x1005400 } ++ }, ++/* not.4 #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_4, { 0x5400 } ++ }, ++/* not.4 (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_4, { 0x3005400 } ++ }, ++/* not.4 ${d-imm7-4}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_4, { 0x4005400 } ++ }, ++/* not.4 (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_4, { 0x4005400 } ++ }, ++/* not.4 (${d-An})${d-i4-4}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_4, { 0x2005400 } ++ }, ++/* not.4 ${d-i4-4}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x2105400 } ++ }, ++/* not.4 ${d-direct-addr},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_post_increment_4, { 0x1005200 } ++ }, ++/* not.4 #${d-imm8},(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_post_increment_4, { 0x5200 } ++ }, ++/* not.4 (${d-An},${d-r}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x3005200 } ++ }, ++/* not.4 ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x4005200 } ++ }, ++/* not.4 (${d-An}),(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_post_increment_4, { 0x4005200 } ++ }, ++/* not.4 (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x2005200 } ++ }, ++/* not.4 ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x2105200 } ++ }, ++/* not.4 ${d-direct-addr},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_direct_s1_indirect_with_pre_increment_4, { 0x1005210 } ++ }, ++/* not.4 #${d-imm8},${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_immediate_4_s1_indirect_with_pre_increment_4, { 0x5210 } ++ }, ++/* not.4 (${d-An},${d-r}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x3005210 } ++ }, ++/* not.4 ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x4005210 } ++ }, ++/* not.4 (${d-An}),${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x4005210 } ++ }, ++/* not.4 (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x2005210 } ++ }, ++/* not.4 ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_movea_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x2105210 } ++ }, ++/* not.2 ${d-direct-addr},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_movea_d_direct_s1_direct, { 0x1005900 } ++ }, ++/* not.2 #${d-imm8},${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_direct, { 0x5900 } ++ }, ++/* not.2 (${d-An},${d-r}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_direct, { 0x3005900 } ++ }, ++/* not.2 ${d-imm7-2}(${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_direct, { 0x4005900 } ++ }, ++/* not.2 (${d-An}),${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_direct, { 0x4005900 } ++ }, ++/* not.2 (${d-An})${d-i4-2}++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_direct, { 0x2005900 } ++ }, ++/* not.2 ${d-i4-2}(${d-An})++,${s1-direct-addr} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_direct, { 0x2105900 } ++ }, ++/* not.2 ${d-direct-addr},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_movea_d_direct_s1_immediate, { 0x1005800 } ++ }, ++/* not.2 #${d-imm8},#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_immediate, { 0x5800 } ++ }, ++/* not.2 (${d-An},${d-r}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_immediate, { 0x3005800 } ++ }, ++/* not.2 ${d-imm7-2}(${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_immediate, { 0x4005800 } ++ }, ++/* not.2 (${d-An}),#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_immediate, { 0x4005800 } ++ }, ++/* not.2 (${d-An})${d-i4-2}++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_immediate, { 0x2005800 } ++ }, ++/* not.2 ${d-i4-2}(${d-An})++,#${s1-imm8} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_immediate, { 0x2105800 } ++ }, ++/* not.2 ${d-direct-addr},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_index_2, { 0x1005b00 } ++ }, ++/* not.2 #${d-imm8},(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_index_2, { 0x5b00 } ++ }, ++/* not.2 (${d-An},${d-r}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_index_2, { 0x3005b00 } ++ }, ++/* not.2 ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_index_2, { 0x4005b00 } ++ }, ++/* not.2 (${d-An}),(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_index_2, { 0x4005b00 } ++ }, ++/* not.2 (${d-An})${d-i4-2}++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_index_2, { 0x2005b00 } ++ }, ++/* not.2 ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_index_2, { 0x2105b00 } ++ }, ++/* not.2 ${d-direct-addr},${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_offset_2, { 0x1005c00 } ++ }, ++/* not.2 #${d-imm8},${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_offset_2, { 0x5c00 } ++ }, ++/* not.2 (${d-An},${d-r}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_offset_2, { 0x3005c00 } ++ }, ++/* not.2 ${d-imm7-2}(${d-An}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_offset_2, { 0x4005c00 } ++ }, ++/* not.2 (${d-An}),${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_offset_2, { 0x4005c00 } ++ }, ++/* not.2 (${d-An})${d-i4-2}++,${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_offset_2, { 0x2005c00 } ++ }, ++/* not.2 ${d-i4-2}(${d-An})++,${s1-imm7-2}(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_offset_2, { 0x2105c00 } ++ }, ++/* not.2 ${d-direct-addr},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_2, { 0x1005c00 } ++ }, ++/* not.2 #${d-imm8},(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_2, { 0x5c00 } ++ }, ++/* not.2 (${d-An},${d-r}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_2, { 0x3005c00 } ++ }, ++/* not.2 ${d-imm7-2}(${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_2, { 0x4005c00 } ++ }, ++/* not.2 (${d-An}),(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_2, { 0x4005c00 } ++ }, ++/* not.2 (${d-An})${d-i4-2}++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_2, { 0x2005c00 } ++ }, ++/* not.2 ${d-i4-2}(${d-An})++,(${s1-An}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_2, { 0x2105c00 } ++ }, ++/* not.2 ${d-direct-addr},(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_post_increment_2, { 0x1005a00 } ++ }, ++/* not.2 #${d-imm8},(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_post_increment_2, { 0x5a00 } ++ }, ++/* not.2 (${d-An},${d-r}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_post_increment_2, { 0x3005a00 } ++ }, ++/* not.2 ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_post_increment_2, { 0x4005a00 } ++ }, ++/* not.2 (${d-An}),(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_post_increment_2, { 0x4005a00 } ++ }, ++/* not.2 (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_2, { 0x2005a00 } ++ }, ++/* not.2 ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-2}++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_2, { 0x2105a00 } ++ }, ++/* not.2 ${d-direct-addr},${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_direct_s1_indirect_with_pre_increment_2, { 0x1005a10 } ++ }, ++/* not.2 #${d-imm8},${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_immediate_2_s1_indirect_with_pre_increment_2, { 0x5a10 } ++ }, ++/* not.2 (${d-An},${d-r}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_index_2_s1_indirect_with_pre_increment_2, { 0x3005a10 } ++ }, ++/* not.2 ${d-imm7-2}(${d-An}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_offset_2_s1_indirect_with_pre_increment_2, { 0x4005a10 } ++ }, ++/* not.2 (${d-An}),${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_2_s1_indirect_with_pre_increment_2, { 0x4005a10 } ++ }, ++/* not.2 (${d-An})${d-i4-2}++,${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_2, { 0x2005a10 } ++ }, ++/* not.2 ${d-i4-2}(${d-An})++,${s1-i4-2}(${s1-An})++ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', 0 } }, ++ & ifmt_move_2_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_2, { 0x2105a10 } ++ }, ++/* xor.1 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x61008100 } ++ }, ++/* xor.1 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_direct, { 0x60008100 } ++ }, ++/* xor.1 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_direct, { 0x63008100 } ++ }, ++/* xor.1 ${d-imm7-1}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_direct, { 0x64008100 } ++ }, ++/* xor.1 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_direct, { 0x64008100 } ++ }, ++/* xor.1 (${d-An})${d-i4-1}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_direct, { 0x62008100 } ++ }, ++/* xor.1 ${d-i4-1}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_direct, { 0x62108100 } ++ }, ++/* xor.1 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x61008000 } ++ }, ++/* xor.1 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_immediate, { 0x60008000 } ++ }, ++/* xor.1 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_immediate, { 0x63008000 } ++ }, ++/* xor.1 ${d-imm7-1}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_immediate, { 0x64008000 } ++ }, ++/* xor.1 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_immediate, { 0x64008000 } ++ }, ++/* xor.1 (${d-An})${d-i4-1}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_immediate, { 0x62008000 } ++ }, ++/* xor.1 ${d-i4-1}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_immediate, { 0x62108000 } ++ }, ++/* xor.1 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_index_1, { 0x61008300 } ++ }, ++/* xor.1 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_index_1, { 0x60008300 } ++ }, ++/* xor.1 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_index_1, { 0x63008300 } ++ }, ++/* xor.1 ${d-imm7-1}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_index_1, { 0x64008300 } ++ }, ++/* xor.1 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_index_1, { 0x64008300 } ++ }, ++/* xor.1 (${d-An})${d-i4-1}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_index_1, { 0x62008300 } ++ }, ++/* xor.1 ${d-i4-1}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_index_1, { 0x62108300 } ++ }, ++/* xor.1 ${d-direct-addr},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_offset_1, { 0x61008400 } ++ }, ++/* xor.1 #${d-imm8},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_offset_1, { 0x60008400 } ++ }, ++/* xor.1 (${d-An},${d-r}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_offset_1, { 0x63008400 } ++ }, ++/* xor.1 ${d-imm7-1}(${d-An}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_offset_1, { 0x64008400 } ++ }, ++/* xor.1 (${d-An}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_offset_1, { 0x64008400 } ++ }, ++/* xor.1 (${d-An})${d-i4-1}++,${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_offset_1, { 0x62008400 } ++ }, ++/* xor.1 ${d-i4-1}(${d-An})++,${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_offset_1, { 0x62108400 } ++ }, ++/* xor.1 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_1, { 0x61008400 } ++ }, ++/* xor.1 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_1, { 0x60008400 } ++ }, ++/* xor.1 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_1, { 0x63008400 } ++ }, ++/* xor.1 ${d-imm7-1}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_1, { 0x64008400 } ++ }, ++/* xor.1 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_1, { 0x64008400 } ++ }, ++/* xor.1 (${d-An})${d-i4-1}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_1, { 0x62008400 } ++ }, ++/* xor.1 ${d-i4-1}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_1, { 0x62108400 } ++ }, ++/* xor.1 ${d-direct-addr},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_post_increment_1, { 0x61008200 } ++ }, ++/* xor.1 #${d-imm8},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_post_increment_1, { 0x60008200 } ++ }, ++/* xor.1 (${d-An},${d-r}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_post_increment_1, { 0x63008200 } ++ }, ++/* xor.1 ${d-imm7-1}(${d-An}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_post_increment_1, { 0x64008200 } ++ }, ++/* xor.1 (${d-An}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_post_increment_1, { 0x64008200 } ++ }, ++/* xor.1 (${d-An})${d-i4-1}++,(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_post_increment_1, { 0x62008200 } ++ }, ++/* xor.1 ${d-i4-1}(${d-An})++,(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_post_increment_1, { 0x62108200 } ++ }, ++/* xor.1 ${d-direct-addr},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_pre_increment_1, { 0x61008210 } ++ }, ++/* xor.1 #${d-imm8},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_pre_increment_1, { 0x60008210 } ++ }, ++/* xor.1 (${d-An},${d-r}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_pre_increment_1, { 0x63008210 } ++ }, ++/* xor.1 ${d-imm7-1}(${d-An}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_pre_increment_1, { 0x64008210 } ++ }, ++/* xor.1 (${d-An}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_pre_increment_1, { 0x64008210 } ++ }, ++/* xor.1 (${d-An})${d-i4-1}++,${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_pre_increment_1, { 0x62008210 } ++ }, ++/* xor.1 ${d-i4-1}(${d-An})++,${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_pre_increment_1, { 0x62108210 } ++ }, ++/* or.1 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x51008100 } ++ }, ++/* or.1 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_direct, { 0x50008100 } ++ }, ++/* or.1 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_direct, { 0x53008100 } ++ }, ++/* or.1 ${d-imm7-1}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_direct, { 0x54008100 } ++ }, ++/* or.1 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_direct, { 0x54008100 } ++ }, ++/* or.1 (${d-An})${d-i4-1}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_direct, { 0x52008100 } ++ }, ++/* or.1 ${d-i4-1}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_direct, { 0x52108100 } ++ }, ++/* or.1 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x51008000 } ++ }, ++/* or.1 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_immediate, { 0x50008000 } ++ }, ++/* or.1 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_immediate, { 0x53008000 } ++ }, ++/* or.1 ${d-imm7-1}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_immediate, { 0x54008000 } ++ }, ++/* or.1 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_immediate, { 0x54008000 } ++ }, ++/* or.1 (${d-An})${d-i4-1}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_immediate, { 0x52008000 } ++ }, ++/* or.1 ${d-i4-1}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_immediate, { 0x52108000 } ++ }, ++/* or.1 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_index_1, { 0x51008300 } ++ }, ++/* or.1 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_index_1, { 0x50008300 } ++ }, ++/* or.1 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_index_1, { 0x53008300 } ++ }, ++/* or.1 ${d-imm7-1}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_index_1, { 0x54008300 } ++ }, ++/* or.1 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_index_1, { 0x54008300 } ++ }, ++/* or.1 (${d-An})${d-i4-1}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_index_1, { 0x52008300 } ++ }, ++/* or.1 ${d-i4-1}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_index_1, { 0x52108300 } ++ }, ++/* or.1 ${d-direct-addr},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_offset_1, { 0x51008400 } ++ }, ++/* or.1 #${d-imm8},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_offset_1, { 0x50008400 } ++ }, ++/* or.1 (${d-An},${d-r}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_offset_1, { 0x53008400 } ++ }, ++/* or.1 ${d-imm7-1}(${d-An}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_offset_1, { 0x54008400 } ++ }, ++/* or.1 (${d-An}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_offset_1, { 0x54008400 } ++ }, ++/* or.1 (${d-An})${d-i4-1}++,${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_offset_1, { 0x52008400 } ++ }, ++/* or.1 ${d-i4-1}(${d-An})++,${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_offset_1, { 0x52108400 } ++ }, ++/* or.1 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_1, { 0x51008400 } ++ }, ++/* or.1 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_1, { 0x50008400 } ++ }, ++/* or.1 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_1, { 0x53008400 } ++ }, ++/* or.1 ${d-imm7-1}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_1, { 0x54008400 } ++ }, ++/* or.1 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_1, { 0x54008400 } ++ }, ++/* or.1 (${d-An})${d-i4-1}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_1, { 0x52008400 } ++ }, ++/* or.1 ${d-i4-1}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_1, { 0x52108400 } ++ }, ++/* or.1 ${d-direct-addr},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_post_increment_1, { 0x51008200 } ++ }, ++/* or.1 #${d-imm8},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_post_increment_1, { 0x50008200 } ++ }, ++/* or.1 (${d-An},${d-r}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_post_increment_1, { 0x53008200 } ++ }, ++/* or.1 ${d-imm7-1}(${d-An}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_post_increment_1, { 0x54008200 } ++ }, ++/* or.1 (${d-An}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_post_increment_1, { 0x54008200 } ++ }, ++/* or.1 (${d-An})${d-i4-1}++,(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_post_increment_1, { 0x52008200 } ++ }, ++/* or.1 ${d-i4-1}(${d-An})++,(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_post_increment_1, { 0x52108200 } ++ }, ++/* or.1 ${d-direct-addr},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_pre_increment_1, { 0x51008210 } ++ }, ++/* or.1 #${d-imm8},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_pre_increment_1, { 0x50008210 } ++ }, ++/* or.1 (${d-An},${d-r}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_pre_increment_1, { 0x53008210 } ++ }, ++/* or.1 ${d-imm7-1}(${d-An}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_pre_increment_1, { 0x54008210 } ++ }, ++/* or.1 (${d-An}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_pre_increment_1, { 0x54008210 } ++ }, ++/* or.1 (${d-An})${d-i4-1}++,${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_pre_increment_1, { 0x52008210 } ++ }, ++/* or.1 ${d-i4-1}(${d-An})++,${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_pre_increment_1, { 0x52108210 } ++ }, ++/* and.1 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x41008100 } ++ }, ++/* and.1 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_direct, { 0x40008100 } ++ }, ++/* and.1 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_direct, { 0x43008100 } ++ }, ++/* and.1 ${d-imm7-1}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_direct, { 0x44008100 } ++ }, ++/* and.1 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_direct, { 0x44008100 } ++ }, ++/* and.1 (${d-An})${d-i4-1}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_direct, { 0x42008100 } ++ }, ++/* and.1 ${d-i4-1}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_direct, { 0x42108100 } ++ }, ++/* and.1 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x41008000 } ++ }, ++/* and.1 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_immediate, { 0x40008000 } ++ }, ++/* and.1 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_immediate, { 0x43008000 } ++ }, ++/* and.1 ${d-imm7-1}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_immediate, { 0x44008000 } ++ }, ++/* and.1 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_immediate, { 0x44008000 } ++ }, ++/* and.1 (${d-An})${d-i4-1}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_immediate, { 0x42008000 } ++ }, ++/* and.1 ${d-i4-1}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_immediate, { 0x42108000 } ++ }, ++/* and.1 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_index_1, { 0x41008300 } ++ }, ++/* and.1 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_index_1, { 0x40008300 } ++ }, ++/* and.1 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_index_1, { 0x43008300 } ++ }, ++/* and.1 ${d-imm7-1}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_index_1, { 0x44008300 } ++ }, ++/* and.1 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_index_1, { 0x44008300 } ++ }, ++/* and.1 (${d-An})${d-i4-1}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_index_1, { 0x42008300 } ++ }, ++/* and.1 ${d-i4-1}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_index_1, { 0x42108300 } ++ }, ++/* and.1 ${d-direct-addr},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_offset_1, { 0x41008400 } ++ }, ++/* and.1 #${d-imm8},${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_offset_1, { 0x40008400 } ++ }, ++/* and.1 (${d-An},${d-r}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_offset_1, { 0x43008400 } ++ }, ++/* and.1 ${d-imm7-1}(${d-An}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_offset_1, { 0x44008400 } ++ }, ++/* and.1 (${d-An}),${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_offset_1, { 0x44008400 } ++ }, ++/* and.1 (${d-An})${d-i4-1}++,${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_offset_1, { 0x42008400 } ++ }, ++/* and.1 ${d-i4-1}(${d-An})++,${s1-imm7-1}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_1), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_offset_1, { 0x42108400 } ++ }, ++/* and.1 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_1, { 0x41008400 } ++ }, ++/* and.1 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_1, { 0x40008400 } ++ }, ++/* and.1 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_1, { 0x43008400 } ++ }, ++/* and.1 ${d-imm7-1}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_1, { 0x44008400 } ++ }, ++/* and.1 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_1, { 0x44008400 } ++ }, ++/* and.1 (${d-An})${d-i4-1}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_1, { 0x42008400 } ++ }, ++/* and.1 ${d-i4-1}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_1, { 0x42108400 } ++ }, ++/* and.1 ${d-direct-addr},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_post_increment_1, { 0x41008200 } ++ }, ++/* and.1 #${d-imm8},(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_post_increment_1, { 0x40008200 } ++ }, ++/* and.1 (${d-An},${d-r}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_post_increment_1, { 0x43008200 } ++ }, ++/* and.1 ${d-imm7-1}(${d-An}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_post_increment_1, { 0x44008200 } ++ }, ++/* and.1 (${d-An}),(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_post_increment_1, { 0x44008200 } ++ }, ++/* and.1 (${d-An})${d-i4-1}++,(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_post_increment_1, { 0x42008200 } ++ }, ++/* and.1 ${d-i4-1}(${d-An})++,(${s1-An})${s1-i4-1}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_1), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_post_increment_1, { 0x42108200 } ++ }, ++/* and.1 ${d-direct-addr},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_direct_s1_indirect_with_pre_increment_1, { 0x41008210 } ++ }, ++/* and.1 #${d-imm8},${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_immediate_1_s1_indirect_with_pre_increment_1, { 0x40008210 } ++ }, ++/* and.1 (${d-An},${d-r}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_index_1_s1_indirect_with_pre_increment_1, { 0x43008210 } ++ }, ++/* and.1 ${d-imm7-1}(${d-An}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_1), '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_offset_1_s1_indirect_with_pre_increment_1, { 0x44008210 } ++ }, ++/* and.1 (${d-An}),${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_1_s1_indirect_with_pre_increment_1, { 0x44008210 } ++ }, ++/* and.1 (${d-An})${d-i4-1}++,${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_1), '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_post_increment_1_s1_indirect_with_pre_increment_1, { 0x42008210 } ++ }, ++/* and.1 ${d-i4-1}(${d-An})++,${s1-i4-1}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_1), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_1), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_1_d_indirect_with_pre_increment_1_s1_indirect_with_pre_increment_1, { 0x42108210 } ++ }, ++/* xor.4 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x69000100 } ++ }, ++/* xor.4 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_direct, { 0x68000100 } ++ }, ++/* xor.4 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_direct, { 0x6b000100 } ++ }, ++/* xor.4 ${d-imm7-4}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_direct, { 0x6c000100 } ++ }, ++/* xor.4 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_direct, { 0x6c000100 } ++ }, ++/* xor.4 (${d-An})${d-i4-4}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_direct, { 0x6a000100 } ++ }, ++/* xor.4 ${d-i4-4}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_direct, { 0x6a100100 } ++ }, ++/* xor.4 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x69000000 } ++ }, ++/* xor.4 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_immediate, { 0x68000000 } ++ }, ++/* xor.4 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_immediate, { 0x6b000000 } ++ }, ++/* xor.4 ${d-imm7-4}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_immediate, { 0x6c000000 } ++ }, ++/* xor.4 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_immediate, { 0x6c000000 } ++ }, ++/* xor.4 (${d-An})${d-i4-4}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_immediate, { 0x6a000000 } ++ }, ++/* xor.4 ${d-i4-4}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_immediate, { 0x6a100000 } ++ }, ++/* xor.4 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0x69000300 } ++ }, ++/* xor.4 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_index_4, { 0x68000300 } ++ }, ++/* xor.4 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x6b000300 } ++ }, ++/* xor.4 ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x6c000300 } ++ }, ++/* xor.4 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_index_4, { 0x6c000300 } ++ }, ++/* xor.4 (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x6a000300 } ++ }, ++/* xor.4 ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x6a100300 } ++ }, ++/* xor.4 ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0x69000400 } ++ }, ++/* xor.4 #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_offset_4, { 0x68000400 } ++ }, ++/* xor.4 (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x6b000400 } ++ }, ++/* xor.4 ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x6c000400 } ++ }, ++/* xor.4 (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_offset_4, { 0x6c000400 } ++ }, ++/* xor.4 (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x6a000400 } ++ }, ++/* xor.4 ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x6a100400 } ++ }, ++/* xor.4 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0x69000400 } ++ }, ++/* xor.4 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_4, { 0x68000400 } ++ }, ++/* xor.4 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_4, { 0x6b000400 } ++ }, ++/* xor.4 ${d-imm7-4}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_4, { 0x6c000400 } ++ }, ++/* xor.4 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_4, { 0x6c000400 } ++ }, ++/* xor.4 (${d-An})${d-i4-4}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_4, { 0x6a000400 } ++ }, ++/* xor.4 ${d-i4-4}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x6a100400 } ++ }, ++/* xor.4 ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0x69000200 } ++ }, ++/* xor.4 #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_post_increment_4, { 0x68000200 } ++ }, ++/* xor.4 (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x6b000200 } ++ }, ++/* xor.4 ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x6c000200 } ++ }, ++/* xor.4 (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_post_increment_4, { 0x6c000200 } ++ }, ++/* xor.4 (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x6a000200 } ++ }, ++/* xor.4 ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x6a100200 } ++ }, ++/* xor.4 ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0x69000210 } ++ }, ++/* xor.4 #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_pre_increment_4, { 0x68000210 } ++ }, ++/* xor.4 (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x6b000210 } ++ }, ++/* xor.4 ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x6c000210 } ++ }, ++/* xor.4 (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x6c000210 } ++ }, ++/* xor.4 (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x6a000210 } ++ }, ++/* xor.4 ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x6a100210 } ++ }, ++/* xor.2 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x61000100 } ++ }, ++/* xor.2 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_direct, { 0x60000100 } ++ }, ++/* xor.2 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_direct, { 0x63000100 } ++ }, ++/* xor.2 ${d-imm7-2}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_direct, { 0x64000100 } ++ }, ++/* xor.2 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_direct, { 0x64000100 } ++ }, ++/* xor.2 (${d-An})${d-i4-2}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_direct, { 0x62000100 } ++ }, ++/* xor.2 ${d-i4-2}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_direct, { 0x62100100 } ++ }, ++/* xor.2 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x61000000 } ++ }, ++/* xor.2 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_immediate, { 0x60000000 } ++ }, ++/* xor.2 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_immediate, { 0x63000000 } ++ }, ++/* xor.2 ${d-imm7-2}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_immediate, { 0x64000000 } ++ }, ++/* xor.2 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_immediate, { 0x64000000 } ++ }, ++/* xor.2 (${d-An})${d-i4-2}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_immediate, { 0x62000000 } ++ }, ++/* xor.2 ${d-i4-2}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_immediate, { 0x62100000 } ++ }, ++/* xor.2 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_index_2, { 0x61000300 } ++ }, ++/* xor.2 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_index_2, { 0x60000300 } ++ }, ++/* xor.2 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_index_2, { 0x63000300 } ++ }, ++/* xor.2 ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_index_2, { 0x64000300 } ++ }, ++/* xor.2 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_index_2, { 0x64000300 } ++ }, ++/* xor.2 (${d-An})${d-i4-2}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_index_2, { 0x62000300 } ++ }, ++/* xor.2 ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_index_2, { 0x62100300 } ++ }, ++/* xor.2 ${d-direct-addr},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_offset_2, { 0x61000400 } ++ }, ++/* xor.2 #${d-imm8},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_offset_2, { 0x60000400 } ++ }, ++/* xor.2 (${d-An},${d-r}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_offset_2, { 0x63000400 } ++ }, ++/* xor.2 ${d-imm7-2}(${d-An}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_offset_2, { 0x64000400 } ++ }, ++/* xor.2 (${d-An}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_offset_2, { 0x64000400 } ++ }, ++/* xor.2 (${d-An})${d-i4-2}++,${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_offset_2, { 0x62000400 } ++ }, ++/* xor.2 ${d-i4-2}(${d-An})++,${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_offset_2, { 0x62100400 } ++ }, ++/* xor.2 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_2, { 0x61000400 } ++ }, ++/* xor.2 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_2, { 0x60000400 } ++ }, ++/* xor.2 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_2, { 0x63000400 } ++ }, ++/* xor.2 ${d-imm7-2}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_2, { 0x64000400 } ++ }, ++/* xor.2 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_2, { 0x64000400 } ++ }, ++/* xor.2 (${d-An})${d-i4-2}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_2, { 0x62000400 } ++ }, ++/* xor.2 ${d-i4-2}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_2, { 0x62100400 } ++ }, ++/* xor.2 ${d-direct-addr},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_post_increment_2, { 0x61000200 } ++ }, ++/* xor.2 #${d-imm8},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_post_increment_2, { 0x60000200 } ++ }, ++/* xor.2 (${d-An},${d-r}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_post_increment_2, { 0x63000200 } ++ }, ++/* xor.2 ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_post_increment_2, { 0x64000200 } ++ }, ++/* xor.2 (${d-An}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_post_increment_2, { 0x64000200 } ++ }, ++/* xor.2 (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_2, { 0x62000200 } ++ }, ++/* xor.2 ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_2, { 0x62100200 } ++ }, ++/* xor.2 ${d-direct-addr},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_pre_increment_2, { 0x61000210 } ++ }, ++/* xor.2 #${d-imm8},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_pre_increment_2, { 0x60000210 } ++ }, ++/* xor.2 (${d-An},${d-r}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_pre_increment_2, { 0x63000210 } ++ }, ++/* xor.2 ${d-imm7-2}(${d-An}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_pre_increment_2, { 0x64000210 } ++ }, ++/* xor.2 (${d-An}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_pre_increment_2, { 0x64000210 } ++ }, ++/* xor.2 (${d-An})${d-i4-2}++,${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_2, { 0x62000210 } ++ }, ++/* xor.2 ${d-i4-2}(${d-An})++,${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_2, { 0x62100210 } ++ }, ++/* or.4 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x59000100 } ++ }, ++/* or.4 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_direct, { 0x58000100 } ++ }, ++/* or.4 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_direct, { 0x5b000100 } ++ }, ++/* or.4 ${d-imm7-4}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_direct, { 0x5c000100 } ++ }, ++/* or.4 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_direct, { 0x5c000100 } ++ }, ++/* or.4 (${d-An})${d-i4-4}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_direct, { 0x5a000100 } ++ }, ++/* or.4 ${d-i4-4}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_direct, { 0x5a100100 } ++ }, ++/* or.4 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x59000000 } ++ }, ++/* or.4 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_immediate, { 0x58000000 } ++ }, ++/* or.4 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_immediate, { 0x5b000000 } ++ }, ++/* or.4 ${d-imm7-4}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_immediate, { 0x5c000000 } ++ }, ++/* or.4 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_immediate, { 0x5c000000 } ++ }, ++/* or.4 (${d-An})${d-i4-4}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_immediate, { 0x5a000000 } ++ }, ++/* or.4 ${d-i4-4}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_immediate, { 0x5a100000 } ++ }, ++/* or.4 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0x59000300 } ++ }, ++/* or.4 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_index_4, { 0x58000300 } ++ }, ++/* or.4 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x5b000300 } ++ }, ++/* or.4 ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x5c000300 } ++ }, ++/* or.4 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_index_4, { 0x5c000300 } ++ }, ++/* or.4 (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x5a000300 } ++ }, ++/* or.4 ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x5a100300 } ++ }, ++/* or.4 ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0x59000400 } ++ }, ++/* or.4 #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_offset_4, { 0x58000400 } ++ }, ++/* or.4 (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x5b000400 } ++ }, ++/* or.4 ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x5c000400 } ++ }, ++/* or.4 (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_offset_4, { 0x5c000400 } ++ }, ++/* or.4 (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x5a000400 } ++ }, ++/* or.4 ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x5a100400 } ++ }, ++/* or.4 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0x59000400 } ++ }, ++/* or.4 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_4, { 0x58000400 } ++ }, ++/* or.4 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_4, { 0x5b000400 } ++ }, ++/* or.4 ${d-imm7-4}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_4, { 0x5c000400 } ++ }, ++/* or.4 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_4, { 0x5c000400 } ++ }, ++/* or.4 (${d-An})${d-i4-4}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_4, { 0x5a000400 } ++ }, ++/* or.4 ${d-i4-4}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x5a100400 } ++ }, ++/* or.4 ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0x59000200 } ++ }, ++/* or.4 #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_post_increment_4, { 0x58000200 } ++ }, ++/* or.4 (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x5b000200 } ++ }, ++/* or.4 ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x5c000200 } ++ }, ++/* or.4 (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_post_increment_4, { 0x5c000200 } ++ }, ++/* or.4 (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x5a000200 } ++ }, ++/* or.4 ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x5a100200 } ++ }, ++/* or.4 ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0x59000210 } ++ }, ++/* or.4 #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_pre_increment_4, { 0x58000210 } ++ }, ++/* or.4 (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x5b000210 } ++ }, ++/* or.4 ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x5c000210 } ++ }, ++/* or.4 (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x5c000210 } ++ }, ++/* or.4 (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x5a000210 } ++ }, ++/* or.4 ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x5a100210 } ++ }, ++/* or.2 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x51000100 } ++ }, ++/* or.2 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_direct, { 0x50000100 } ++ }, ++/* or.2 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_direct, { 0x53000100 } ++ }, ++/* or.2 ${d-imm7-2}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_direct, { 0x54000100 } ++ }, ++/* or.2 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_direct, { 0x54000100 } ++ }, ++/* or.2 (${d-An})${d-i4-2}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_direct, { 0x52000100 } ++ }, ++/* or.2 ${d-i4-2}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_direct, { 0x52100100 } ++ }, ++/* or.2 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x51000000 } ++ }, ++/* or.2 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_immediate, { 0x50000000 } ++ }, ++/* or.2 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_immediate, { 0x53000000 } ++ }, ++/* or.2 ${d-imm7-2}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_immediate, { 0x54000000 } ++ }, ++/* or.2 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_immediate, { 0x54000000 } ++ }, ++/* or.2 (${d-An})${d-i4-2}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_immediate, { 0x52000000 } ++ }, ++/* or.2 ${d-i4-2}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_immediate, { 0x52100000 } ++ }, ++/* or.2 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_index_2, { 0x51000300 } ++ }, ++/* or.2 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_index_2, { 0x50000300 } ++ }, ++/* or.2 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_index_2, { 0x53000300 } ++ }, ++/* or.2 ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_index_2, { 0x54000300 } ++ }, ++/* or.2 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_index_2, { 0x54000300 } ++ }, ++/* or.2 (${d-An})${d-i4-2}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_index_2, { 0x52000300 } ++ }, ++/* or.2 ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_index_2, { 0x52100300 } ++ }, ++/* or.2 ${d-direct-addr},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_offset_2, { 0x51000400 } ++ }, ++/* or.2 #${d-imm8},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_offset_2, { 0x50000400 } ++ }, ++/* or.2 (${d-An},${d-r}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_offset_2, { 0x53000400 } ++ }, ++/* or.2 ${d-imm7-2}(${d-An}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_offset_2, { 0x54000400 } ++ }, ++/* or.2 (${d-An}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_offset_2, { 0x54000400 } ++ }, ++/* or.2 (${d-An})${d-i4-2}++,${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_offset_2, { 0x52000400 } ++ }, ++/* or.2 ${d-i4-2}(${d-An})++,${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_offset_2, { 0x52100400 } ++ }, ++/* or.2 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_2, { 0x51000400 } ++ }, ++/* or.2 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_2, { 0x50000400 } ++ }, ++/* or.2 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_2, { 0x53000400 } ++ }, ++/* or.2 ${d-imm7-2}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_2, { 0x54000400 } ++ }, ++/* or.2 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_2, { 0x54000400 } ++ }, ++/* or.2 (${d-An})${d-i4-2}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_2, { 0x52000400 } ++ }, ++/* or.2 ${d-i4-2}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_2, { 0x52100400 } ++ }, ++/* or.2 ${d-direct-addr},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_post_increment_2, { 0x51000200 } ++ }, ++/* or.2 #${d-imm8},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_post_increment_2, { 0x50000200 } ++ }, ++/* or.2 (${d-An},${d-r}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_post_increment_2, { 0x53000200 } ++ }, ++/* or.2 ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_post_increment_2, { 0x54000200 } ++ }, ++/* or.2 (${d-An}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_post_increment_2, { 0x54000200 } ++ }, ++/* or.2 (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_2, { 0x52000200 } ++ }, ++/* or.2 ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_2, { 0x52100200 } ++ }, ++/* or.2 ${d-direct-addr},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_pre_increment_2, { 0x51000210 } ++ }, ++/* or.2 #${d-imm8},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_pre_increment_2, { 0x50000210 } ++ }, ++/* or.2 (${d-An},${d-r}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_pre_increment_2, { 0x53000210 } ++ }, ++/* or.2 ${d-imm7-2}(${d-An}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_pre_increment_2, { 0x54000210 } ++ }, ++/* or.2 (${d-An}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_pre_increment_2, { 0x54000210 } ++ }, ++/* or.2 (${d-An})${d-i4-2}++,${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_2, { 0x52000210 } ++ }, ++/* or.2 ${d-i4-2}(${d-An})++,${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_2, { 0x52100210 } ++ }, ++/* and.4 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x49000100 } ++ }, ++/* and.4 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_direct, { 0x48000100 } ++ }, ++/* and.4 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_direct, { 0x4b000100 } ++ }, ++/* and.4 ${d-imm7-4}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_direct, { 0x4c000100 } ++ }, ++/* and.4 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_direct, { 0x4c000100 } ++ }, ++/* and.4 (${d-An})${d-i4-4}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_direct, { 0x4a000100 } ++ }, ++/* and.4 ${d-i4-4}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_direct, { 0x4a100100 } ++ }, ++/* and.4 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x49000000 } ++ }, ++/* and.4 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_immediate, { 0x48000000 } ++ }, ++/* and.4 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_immediate, { 0x4b000000 } ++ }, ++/* and.4 ${d-imm7-4}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_immediate, { 0x4c000000 } ++ }, ++/* and.4 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_immediate, { 0x4c000000 } ++ }, ++/* and.4 (${d-An})${d-i4-4}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_immediate, { 0x4a000000 } ++ }, ++/* and.4 ${d-i4-4}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_immediate, { 0x4a100000 } ++ }, ++/* and.4 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_index_4, { 0x49000300 } ++ }, ++/* and.4 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_index_4, { 0x48000300 } ++ }, ++/* and.4 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_index_4, { 0x4b000300 } ++ }, ++/* and.4 ${d-imm7-4}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_index_4, { 0x4c000300 } ++ }, ++/* and.4 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_index_4, { 0x4c000300 } ++ }, ++/* and.4 (${d-An})${d-i4-4}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_index_4, { 0x4a000300 } ++ }, ++/* and.4 ${d-i4-4}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_index_4, { 0x4a100300 } ++ }, ++/* and.4 ${d-direct-addr},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_offset_4, { 0x49000400 } ++ }, ++/* and.4 #${d-imm8},${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_offset_4, { 0x48000400 } ++ }, ++/* and.4 (${d-An},${d-r}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_offset_4, { 0x4b000400 } ++ }, ++/* and.4 ${d-imm7-4}(${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_offset_4, { 0x4c000400 } ++ }, ++/* and.4 (${d-An}),${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_offset_4, { 0x4c000400 } ++ }, ++/* and.4 (${d-An})${d-i4-4}++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_offset_4, { 0x4a000400 } ++ }, ++/* and.4 ${d-i4-4}(${d-An})++,${s1-imm7-4}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_4), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_offset_4, { 0x4a100400 } ++ }, ++/* and.4 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_4, { 0x49000400 } ++ }, ++/* and.4 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_4, { 0x48000400 } ++ }, ++/* and.4 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_4, { 0x4b000400 } ++ }, ++/* and.4 ${d-imm7-4}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_4, { 0x4c000400 } ++ }, ++/* and.4 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_4, { 0x4c000400 } ++ }, ++/* and.4 (${d-An})${d-i4-4}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_4, { 0x4a000400 } ++ }, ++/* and.4 ${d-i4-4}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_4, { 0x4a100400 } ++ }, ++/* and.4 ${d-direct-addr},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_post_increment_4, { 0x49000200 } ++ }, ++/* and.4 #${d-imm8},(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_post_increment_4, { 0x48000200 } ++ }, ++/* and.4 (${d-An},${d-r}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_post_increment_4, { 0x4b000200 } ++ }, ++/* and.4 ${d-imm7-4}(${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_post_increment_4, { 0x4c000200 } ++ }, ++/* and.4 (${d-An}),(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_post_increment_4, { 0x4c000200 } ++ }, ++/* and.4 (${d-An})${d-i4-4}++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_post_increment_4, { 0x4a000200 } ++ }, ++/* and.4 ${d-i4-4}(${d-An})++,(${s1-An})${s1-i4-4}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_4), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_post_increment_4, { 0x4a100200 } ++ }, ++/* and.4 ${d-direct-addr},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_indirect_with_pre_increment_4, { 0x49000210 } ++ }, ++/* and.4 #${d-imm8},${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_immediate_4_s1_indirect_with_pre_increment_4, { 0x48000210 } ++ }, ++/* and.4 (${d-An},${d-r}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_index_4_s1_indirect_with_pre_increment_4, { 0x4b000210 } ++ }, ++/* and.4 ${d-imm7-4}(${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_4), '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_offset_4_s1_indirect_with_pre_increment_4, { 0x4c000210 } ++ }, ++/* and.4 (${d-An}),${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_4_s1_indirect_with_pre_increment_4, { 0x4c000210 } ++ }, ++/* and.4 (${d-An})${d-i4-4}++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_4), '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_post_increment_4_s1_indirect_with_pre_increment_4, { 0x4a000210 } ++ }, ++/* and.4 ${d-i4-4}(${d-An})++,${s1-i4-4}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_4), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_4), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_pxvi_s_d_indirect_with_pre_increment_4_s1_indirect_with_pre_increment_4, { 0x4a100210 } ++ }, ++/* and.2 ${d-direct-addr},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_direct, { 0x41000100 } ++ }, ++/* and.2 #${d-imm8},${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_direct, { 0x40000100 } ++ }, ++/* and.2 (${d-An},${d-r}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_direct, { 0x43000100 } ++ }, ++/* and.2 ${d-imm7-2}(${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_direct, { 0x44000100 } ++ }, ++/* and.2 (${d-An}),${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_direct, { 0x44000100 } ++ }, ++/* and.2 (${d-An})${d-i4-2}++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_direct, { 0x42000100 } ++ }, ++/* and.2 ${d-i4-2}(${d-An})++,${s1-direct-addr},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_DIRECT_ADDR), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_direct, { 0x42100100 } ++ }, ++/* and.2 ${d-direct-addr},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_direct_s1_immediate, { 0x41000000 } ++ }, ++/* and.2 #${d-imm8},#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_immediate_2_s1_immediate, { 0x40000000 } ++ }, ++/* and.2 (${d-An},${d-r}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_index_2_s1_immediate, { 0x43000000 } ++ }, ++/* and.2 ${d-imm7-2}(${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_offset_2_s1_immediate, { 0x44000000 } ++ }, ++/* and.2 (${d-An}),#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_2_s1_immediate, { 0x44000000 } ++ }, ++/* and.2 (${d-An})${d-i4-2}++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_post_increment_2_s1_immediate, { 0x42000000 } ++ }, ++/* and.2 ${d-i4-2}(${d-An})++,#${s1-imm8},${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '#', OP (S1_IMM8), ',', OP (S2), 0 } }, ++ & ifmt_pxadds_u_d_indirect_with_pre_increment_2_s1_immediate, { 0x42100000 } ++ }, ++/* and.2 ${d-direct-addr},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_index_2, { 0x41000300 } ++ }, ++/* and.2 #${d-imm8},(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_index_2, { 0x40000300 } ++ }, ++/* and.2 (${d-An},${d-r}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_index_2, { 0x43000300 } ++ }, ++/* and.2 ${d-imm7-2}(${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_index_2, { 0x44000300 } ++ }, ++/* and.2 (${d-An}),(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_index_2, { 0x44000300 } ++ }, ++/* and.2 (${d-An})${d-i4-2}++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_index_2, { 0x42000300 } ++ }, ++/* and.2 ${d-i4-2}(${d-An})++,(${s1-An},${s1-r}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ',', OP (S1_R), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_index_2, { 0x42100300 } ++ }, ++/* and.2 ${d-direct-addr},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_offset_2, { 0x41000400 } ++ }, ++/* and.2 #${d-imm8},${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_offset_2, { 0x40000400 } ++ }, ++/* and.2 (${d-An},${d-r}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_offset_2, { 0x43000400 } ++ }, ++/* and.2 ${d-imm7-2}(${d-An}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_offset_2, { 0x44000400 } ++ }, ++/* and.2 (${d-An}),${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_offset_2, { 0x44000400 } ++ }, ++/* and.2 (${d-An})${d-i4-2}++,${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_offset_2, { 0x42000400 } ++ }, ++/* and.2 ${d-i4-2}(${d-An})++,${s1-imm7-2}(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_IMM7_2), '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_offset_2, { 0x42100400 } ++ }, ++/* and.2 ${d-direct-addr},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_2, { 0x41000400 } ++ }, ++/* and.2 #${d-imm8},(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_2, { 0x40000400 } ++ }, ++/* and.2 (${d-An},${d-r}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_2, { 0x43000400 } ++ }, ++/* and.2 ${d-imm7-2}(${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_2, { 0x44000400 } ++ }, ++/* and.2 (${d-An}),(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_2, { 0x44000400 } ++ }, ++/* and.2 (${d-An})${d-i4-2}++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_2, { 0x42000400 } ++ }, ++/* and.2 ${d-i4-2}(${d-An})++,(${s1-An}),${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_2, { 0x42100400 } ++ }, ++/* and.2 ${d-direct-addr},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_post_increment_2, { 0x41000200 } ++ }, ++/* and.2 #${d-imm8},(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_post_increment_2, { 0x40000200 } ++ }, ++/* and.2 (${d-An},${d-r}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_post_increment_2, { 0x43000200 } ++ }, ++/* and.2 ${d-imm7-2}(${d-An}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_post_increment_2, { 0x44000200 } ++ }, ++/* and.2 (${d-An}),(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_post_increment_2, { 0x44000200 } ++ }, ++/* and.2 (${d-An})${d-i4-2}++,(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_post_increment_2, { 0x42000200 } ++ }, ++/* and.2 ${d-i4-2}(${d-An})++,(${s1-An})${s1-i4-2}++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', '(', OP (S1_AN), ')', OP (S1_I4_2), '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_post_increment_2, { 0x42100200 } ++ }, ++/* and.2 ${d-direct-addr},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_DIRECT_ADDR), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_direct_s1_indirect_with_pre_increment_2, { 0x41000210 } ++ }, ++/* and.2 #${d-imm8},${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '#', OP (D_IMM8), ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_immediate_2_s1_indirect_with_pre_increment_2, { 0x40000210 } ++ }, ++/* and.2 (${d-An},${d-r}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ',', OP (D_R), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_index_2_s1_indirect_with_pre_increment_2, { 0x43000210 } ++ }, ++/* and.2 ${d-imm7-2}(${d-An}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_IMM7_2), '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_offset_2_s1_indirect_with_pre_increment_2, { 0x44000210 } ++ }, ++/* and.2 (${d-An}),${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_2_s1_indirect_with_pre_increment_2, { 0x44000210 } ++ }, ++/* and.2 (${d-An})${d-i4-2}++,${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', '(', OP (D_AN), ')', OP (D_I4_2), '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_post_increment_2_s1_indirect_with_pre_increment_2, { 0x42000210 } ++ }, ++/* and.2 ${d-i4-2}(${d-An})++,${s1-i4-2}(${s1-An})++,${s2} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (D_I4_2), '(', OP (D_AN), ')', '+', '+', ',', OP (S1_I4_2), '(', OP (S1_AN), ')', '+', '+', ',', OP (S2), 0 } }, ++ & ifmt_sub_2_d_indirect_with_pre_increment_2_s1_indirect_with_pre_increment_2, { 0x42100210 } ++ }, ++/* moveai ${An},#${imm24} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (AN), ',', '#', OP (IMM24), 0 } }, ++ & ifmt_moveai, { 0xe0000000 } ++ }, ++/* __nop__ */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_nop_insn, { 0xc8000000 } ++ }, ++/* jmp${cc}${C}${P} $offset21 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, OP (CC), OP (C), OP (P), ' ', OP (OFFSET21), 0 } }, ++ & ifmt_jmpcc, { 0xd0000000 } ++ }, ++/* call $An,$offset24 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (AN), ',', OP (OFFSET24), 0 } }, ++ & ifmt_call, { 0xd8000000 } ++ }, ++/* calli ${An},${offset16}(${Am}) */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (AN), ',', OP (OFFSET16), '(', OP (AM), ')', 0 } }, ++ & ifmt_calli, { 0xf0000000 } ++ }, ++/* suspend */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_suspend, { 0x800 } ++ }, ++/* __clracc__ ${dsp-destA} */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, ' ', OP (DSP_DESTA), 0 } }, ++ & ifmt_dsp_clracc, { 0x36400100 } ++ }, ++/* __unused__00_11 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_00_11, { 0x8800 } ++ }, ++/* __unused__00_13 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_00_11, { 0x9800 } ++ }, ++/* __unused__00_14 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_00_11, { 0xa000 } ++ }, ++/* __unused__00_16 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_00_11, { 0xb000 } ++ }, ++/* __unused__02_04 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_02_04, { 0x10800000 } ++ }, ++/* __unused__02_07 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_02_04, { 0x10e00000 } ++ }, ++/* __unused__02_0D */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_02_04, { 0x11a00000 } ++ }, ++/* __unused__02_0E */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_02_04, { 0x11c00000 } ++ }, ++/* __unused__02_0F */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_02_04, { 0x11e00000 } ++ }, ++/* __unused__02_17 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_02_04, { 0x12e00000 } ++ }, ++/* __unused__02_19 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_02_04, { 0x13200000 } ++ }, ++/* __unused__02_1B */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_02_04, { 0x13600000 } ++ }, ++/* __unused__02_1D */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_02_04, { 0x13a00000 } ++ }, ++/* __unused__01 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_01, { 0x8000000 } ++ }, ++/* __unused__03 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_01, { 0x18000000 } ++ }, ++/* __unused__07 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_01, { 0x38000000 } ++ }, ++/* __unused__17 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_01, { 0xb8000000 } ++ }, ++/* __unused__1D */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_01, { 0xe8000000 } ++ }, ++/* __unused__1F */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_01, { 0xf8000000 } ++ }, ++/* __unused__DSP_06 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x30c00000 } ++ }, ++/* __unused__DSP_0b */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x31600000 } ++ }, ++/* __unused__DSP_0c */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x31800000 } ++ }, ++/* __unused__DSP_0d */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x31a00000 } ++ }, ++/* __unused__DSP_0e */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x31c00000 } ++ }, ++/* __unused__DSP_0f */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x31e00000 } ++ }, ++/* __unused__DSP_14 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x32800000 } ++ }, ++/* __unused__DSP_15 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x32a00000 } ++ }, ++/* __unused__DSP_16 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x32c00000 } ++ }, ++/* __unused__DSP_17 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x32e00000 } ++ }, ++/* __unused__DSP_18 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x33000000 } ++ }, ++/* __unused__DSP_19 */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x33200000 } ++ }, ++/* __unused__DSP_1a */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x33400000 } ++ }, ++/* __unused__DSP_1b */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x33600000 } ++ }, ++/* __unused__DSP_1c */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x33800000 } ++ }, ++/* __unused__DSP_1d */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x33a00000 } ++ }, ++/* __unused__DSP_1e */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x33c00000 } ++ }, ++/* __unused__DSP_1f */ ++ { ++ { 0, 0, 0, 0 }, ++ { { MNEM, 0 } }, ++ & ifmt_unused_DSP_06, { 0x33e00000 } ++ }, ++}; ++ ++#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) & ubicom32_cgen_ifld_table[UBICOM32_##f] ++#else ++#define F(f) & ubicom32_cgen_ifld_table[UBICOM32_/**/f] ++#endif ++static const CGEN_IFMT ifmt_nop ATTRIBUTE_UNUSED = { ++ 32, 32, 0xffffffff, { { F (F_OP1) }, { F (F_D) }, { F (F_IMM16_2) }, { 0 } } ++}; ++ ++static const CGEN_IFMT ifmt_dsp_clracc_macro ATTRIBUTE_UNUSED = { ++ 32, 32, 0xfffeffff, { { F (F_OP1) }, { F (F_OPEXT) }, { F (F_DSP_DESTA) }, { F (F_S1) }, { F (F_DSP_S2_SEL) }, { F (F_BIT5) }, { F (F_DSP_T) }, { F (F_DSP_C) }, { F (F_BIT26) }, { F (F_DSP_R) }, { 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) UBICOM32_OPERAND_##op ++#else ++#define OPERAND(op) UBICOM32_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 ubicom32_cgen_macro_insn_table[] = ++{ ++/* nop */ ++ { ++ -1, "nop", "nop", 32, ++ { 0|A(ALIAS), { { { (1<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 = & ubicom32_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]; ++ ubicom32_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; ++} +--- /dev/null ++++ b/opcodes/ubicom32-opc.h +@@ -0,0 +1,868 @@ ++/* Instruction opcode header for ubicom32. ++ ++THIS FILE IS MACHINE GENERATED WITH CGEN. ++ ++Copyright 1996-2007 Free Software Foundation, Inc. ++ ++This file is part of the GNU Binutils and/or GDB, the GNU debugger. ++ ++ This file is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3, or (at your option) ++ any later version. ++ ++ It is distributed in the hope that it will be useful, but WITHOUT ++ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY ++ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public ++ License for more details. ++ ++ You should have received a copy of the GNU General Public License along ++ with this program; if not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. ++ ++*/ ++ ++#ifndef UBICOM32_OPC_H ++#define UBICOM32_OPC_H ++ ++/* -- opc.h */ ++ ++/* Check applicability of instructions against machines. */ ++#define CGEN_VALIDATE_INSN_SUPPORTED ++extern int ubicom32_cgen_insn_supported ++ PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *)); ++ ++/* Allows reason codes to be output when assembler errors occur. */ ++#define CGEN_VERBOSE_ASSEMBLER_ERRORS ++ ++/* Override disassembly hashing */ ++ ++#define CGEN_DIS_HASH_SIZE 32 ++#define CGEN_DIS_HASH(buf,value) ubicom32_dis_hash(buf,value) ++ ++#define CGEN_ASM_HASH_SIZE 509 ++#define CGEN_ASM_HASH(insn) ubicom32_asm_hash(insn) ++ ++extern unsigned int ubicom32_dis_hash (const char *buf, CGEN_INSN_INT value); ++extern unsigned int ubicom32_asm_hash (const char *insn); ++ ++/* Structure used to map between directly addressable registers and ++ their human-readable names. Used by both the assembler and the ++ disassembler. ++*/ ++struct ubicom32_cgen_data_space_map { ++ long address; ++ char *name; ++ int type; ++}; ++ ++extern struct ubicom32_cgen_data_space_map ubicom32_cgen_data_space_map_mars[]; ++extern struct ubicom32_cgen_data_space_map ubicom32_cgen_data_space_map_mercury[]; ++ ++#define A0_ADDRESS 0x80 ++#define A1_ADDRESS (A0_ADDRESS + 4) ++#define A2_ADDRESS (A0_ADDRESS + 8) ++#define A3_ADDRESS (A0_ADDRESS + 12) ++#define A4_ADDRESS (A0_ADDRESS + 16) ++#define A5_ADDRESS (A0_ADDRESS + 20) ++#define A6_ADDRESS (A0_ADDRESS + 24) ++#define A7_ADDRESS (A0_ADDRESS + 28) ++ ++/* XXX */ ++typedef unsigned char UQI; ++ ++ ++/* -- opc.c */ ++/* Enum declaration for ubicom32 instruction types. */ ++typedef enum cgen_insn_type { ++ UBICOM32_INSN_INVALID, UBICOM32_INSN_DSP_MSUB_2_S1_DIRECT_DSP_SRC2_DATA_REG_ADDSUB2, UBICOM32_INSN_DSP_MSUB_2_S1_IMMEDIATE_DSP_SRC2_DATA_REG_ADDSUB2, UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG_ADDSUB2 ++ , UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG_ADDSUB2, UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_2_DSP_SRC2_DATA_REG_ADDSUB2, UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG_ADDSUB2, UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG_ADDSUB2 ++ , UBICOM32_INSN_DSP_MSUB_2_S1_DIRECT_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_2_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_REG_ACC_REG_ADDSUB ++ , UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_2_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_2_S1_DIRECT_DSP_IMM_BIT5_ADDSUB2 ++ , UBICOM32_INSN_DSP_MSUB_2_S1_IMMEDIATE_DSP_IMM_BIT5_ADDSUB2, UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5_ADDSUB2, UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5_ADDSUB2, UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_2_DSP_IMM_BIT5_ADDSUB2 ++ , UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5_ADDSUB2, UBICOM32_INSN_DSP_MSUB_2_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5_ADDSUB2, UBICOM32_INSN_DSP_MSUB_4_S1_DIRECT_DSP_SRC2_DATA_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_IMMEDIATE_DSP_SRC2_DATA_REG_ADDSUB ++ , UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_WITH_INDEX_4_DSP_SRC2_DATA_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_WITH_OFFSET_4_DSP_SRC2_DATA_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_4_DSP_SRC2_DATA_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_WITH_POST_INCREMENT_4_DSP_SRC2_DATA_REG_ADDSUB ++ , UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_WITH_PRE_INCREMENT_4_DSP_SRC2_DATA_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_DIRECT_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_WITH_INDEX_4_DSP_SRC2_REG_ACC_REG_ADDSUB ++ , UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_WITH_OFFSET_4_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_4_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_WITH_POST_INCREMENT_4_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_WITH_PRE_INCREMENT_4_DSP_SRC2_REG_ACC_REG_ADDSUB ++ , UBICOM32_INSN_DSP_MSUB_4_S1_DIRECT_DSP_IMM_BIT5_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_IMMEDIATE_DSP_IMM_BIT5_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_WITH_INDEX_4_DSP_IMM_BIT5_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_WITH_OFFSET_4_DSP_IMM_BIT5_ADDSUB ++ , UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_4_DSP_IMM_BIT5_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_WITH_POST_INCREMENT_4_DSP_IMM_BIT5_ADDSUB, UBICOM32_INSN_DSP_MSUB_4_S1_INDIRECT_WITH_PRE_INCREMENT_4_DSP_IMM_BIT5_ADDSUB, UBICOM32_INSN_DSP_MADD_2_S1_DIRECT_DSP_SRC2_DATA_REG_ADDSUB2 ++ , UBICOM32_INSN_DSP_MADD_2_S1_IMMEDIATE_DSP_SRC2_DATA_REG_ADDSUB2, UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG_ADDSUB2, UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG_ADDSUB2, UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_2_DSP_SRC2_DATA_REG_ADDSUB2 ++ , UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG_ADDSUB2, UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG_ADDSUB2, UBICOM32_INSN_DSP_MADD_2_S1_DIRECT_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_2_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_ADDSUB ++ , UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_2_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_REG_ACC_REG_ADDSUB ++ , UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_2_S1_DIRECT_DSP_IMM_BIT5_ADDSUB2, UBICOM32_INSN_DSP_MADD_2_S1_IMMEDIATE_DSP_IMM_BIT5_ADDSUB2, UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5_ADDSUB2 ++ , UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5_ADDSUB2, UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_2_DSP_IMM_BIT5_ADDSUB2, UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5_ADDSUB2, UBICOM32_INSN_DSP_MADD_2_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5_ADDSUB2 ++ , UBICOM32_INSN_DSP_MADD_4_S1_DIRECT_DSP_SRC2_DATA_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_IMMEDIATE_DSP_SRC2_DATA_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_WITH_INDEX_4_DSP_SRC2_DATA_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_WITH_OFFSET_4_DSP_SRC2_DATA_REG_ADDSUB ++ , UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_4_DSP_SRC2_DATA_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_WITH_POST_INCREMENT_4_DSP_SRC2_DATA_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_WITH_PRE_INCREMENT_4_DSP_SRC2_DATA_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_DIRECT_DSP_SRC2_REG_ACC_REG_ADDSUB ++ , UBICOM32_INSN_DSP_MADD_4_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_WITH_INDEX_4_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_WITH_OFFSET_4_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_4_DSP_SRC2_REG_ACC_REG_ADDSUB ++ , UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_WITH_POST_INCREMENT_4_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_WITH_PRE_INCREMENT_4_DSP_SRC2_REG_ACC_REG_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_DIRECT_DSP_IMM_BIT5_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_IMMEDIATE_DSP_IMM_BIT5_ADDSUB ++ , UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_WITH_INDEX_4_DSP_IMM_BIT5_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_WITH_OFFSET_4_DSP_IMM_BIT5_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_4_DSP_IMM_BIT5_ADDSUB, UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_WITH_POST_INCREMENT_4_DSP_IMM_BIT5_ADDSUB ++ , UBICOM32_INSN_DSP_MADD_4_S1_INDIRECT_WITH_PRE_INCREMENT_4_DSP_IMM_BIT5_ADDSUB, UBICOM32_INSN_DSP_MSUF_S1_DIRECT_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MSUF_S1_IMMEDIATE_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MSUF_S1_DIRECT_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MSUF_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MSUF_S1_DIRECT_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MSUF_S1_IMMEDIATE_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MSUF_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACUS_S1_DIRECT_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACUS_S1_IMMEDIATE_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACUS_S1_DIRECT_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACUS_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MACUS_S1_DIRECT_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACUS_S1_IMMEDIATE_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACUS_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACF_S1_DIRECT_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MACF_S1_IMMEDIATE_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACF_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACF_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACF_S1_INDIRECT_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MACF_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACF_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACF_S1_DIRECT_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACF_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MACF_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACF_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACF_S1_INDIRECT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACF_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MACF_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACF_S1_DIRECT_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACF_S1_IMMEDIATE_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACF_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MACF_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACF_S1_INDIRECT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACF_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACF_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MULF_S1_DIRECT_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULF_S1_IMMEDIATE_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULF_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULF_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MULF_S1_INDIRECT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULF_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULF_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULF_S1_DIRECT_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MULF_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULF_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULF_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULF_S1_INDIRECT_2_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MULF_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULF_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULF_S1_DIRECT_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULF_S1_IMMEDIATE_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MULF_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULF_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULF_S1_INDIRECT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULF_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MULF_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACU_S1_DIRECT_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACU_S1_IMMEDIATE_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACU_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MACU_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACU_S1_INDIRECT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACU_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACU_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MACU_S1_DIRECT_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACU_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACU_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACU_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MACU_S1_INDIRECT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACU_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACU_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACU_S1_DIRECT_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MACU_S1_IMMEDIATE_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACU_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACU_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACU_S1_INDIRECT_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MACU_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACU_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULU_4_S1_DIRECT_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULU_4_S1_IMMEDIATE_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_WITH_INDEX_4_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_WITH_OFFSET_4_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_4_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_WITH_POST_INCREMENT_4_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_WITH_PRE_INCREMENT_4_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULU_4_S1_DIRECT_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULU_4_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_WITH_INDEX_4_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_WITH_OFFSET_4_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_4_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_WITH_POST_INCREMENT_4_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_WITH_PRE_INCREMENT_4_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MULU_4_S1_DIRECT_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULU_4_S1_IMMEDIATE_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_WITH_INDEX_4_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_WITH_OFFSET_4_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_4_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_WITH_POST_INCREMENT_4_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULU_4_S1_INDIRECT_WITH_PRE_INCREMENT_4_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULU_S1_DIRECT_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MULU_S1_IMMEDIATE_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULU_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULU_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULU_S1_INDIRECT_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MULU_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULU_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULU_S1_DIRECT_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULU_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MULU_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULU_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULU_S1_INDIRECT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULU_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MULU_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULU_S1_DIRECT_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULU_S1_IMMEDIATE_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULU_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MULU_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULU_S1_INDIRECT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULU_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULU_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MACS_S1_DIRECT_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACS_S1_IMMEDIATE_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACS_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACS_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MACS_S1_INDIRECT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACS_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACS_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MACS_S1_DIRECT_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MACS_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACS_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACS_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACS_S1_INDIRECT_2_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MACS_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACS_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MACS_S1_DIRECT_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACS_S1_IMMEDIATE_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MACS_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACS_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACS_S1_INDIRECT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MACS_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MACS_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULS_4_S1_DIRECT_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULS_4_S1_IMMEDIATE_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_WITH_INDEX_4_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_WITH_OFFSET_4_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_4_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_WITH_POST_INCREMENT_4_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_WITH_PRE_INCREMENT_4_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MULS_4_S1_DIRECT_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULS_4_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_WITH_INDEX_4_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_WITH_OFFSET_4_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_4_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_WITH_POST_INCREMENT_4_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_WITH_PRE_INCREMENT_4_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULS_4_S1_DIRECT_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MULS_4_S1_IMMEDIATE_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_WITH_INDEX_4_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_WITH_OFFSET_4_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_4_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_WITH_POST_INCREMENT_4_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULS_4_S1_INDIRECT_WITH_PRE_INCREMENT_4_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULS_S1_DIRECT_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULS_S1_IMMEDIATE_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MULS_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULS_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULS_S1_INDIRECT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULS_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_DSP_MULS_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_DSP_MULS_S1_DIRECT_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULS_S1_IMMEDIATE_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULS_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MULS_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULS_S1_INDIRECT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULS_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL, UBICOM32_INSN_DSP_MULS_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_REG_ACC_REG_MUL ++ , UBICOM32_INSN_DSP_MULS_S1_DIRECT_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULS_S1_IMMEDIATE_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULS_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULS_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_DSP_MULS_S1_INDIRECT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULS_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_DSP_MULS_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_IERASE_D_PEA_INDIRECT_WITH_INDEX ++ , UBICOM32_INSN_IERASE_D_PEA_INDIRECT_WITH_OFFSET, UBICOM32_INSN_IERASE_D_PEA_INDIRECT, UBICOM32_INSN_IERASE_D_PEA_INDIRECT_WITH_POST_INCREMENT, UBICOM32_INSN_IERASE_D_PEA_INDIRECT_WITH_PRE_INCREMENT ++ , UBICOM32_INSN_IREAD_S1_EA_INDIRECT, UBICOM32_INSN_IREAD_S1_EA_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_IREAD_S1_EA_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_IREAD_S1_EA_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_IREAD_S1_EA_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_DIRECT, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_DIRECT, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_S1_DIRECT ++ , UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_DIRECT, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_DIRECT, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_IMMEDIATE, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_IMMEDIATE ++ , UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_S1_IMMEDIATE, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_IMMEDIATE, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_IMMEDIATE, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_INDIRECT_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_INDIRECT_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_S1_INDIRECT_4 ++ , UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_INDIRECT_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_INDIRECT_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_SETCSR_S1_DIRECT, UBICOM32_INSN_SETCSR_S1_IMMEDIATE, UBICOM32_INSN_SETCSR_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SETCSR_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_SETCSR_S1_INDIRECT_4, UBICOM32_INSN_SETCSR_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SETCSR_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_BKPT_S1_DIRECT ++ , UBICOM32_INSN_BKPT_S1_IMMEDIATE, UBICOM32_INSN_BKPT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_BKPT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_BKPT_S1_INDIRECT_4 ++ , UBICOM32_INSN_BKPT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_BKPT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_RET_S1_DIRECT, UBICOM32_INSN_RET_S1_IMMEDIATE ++ , UBICOM32_INSN_RET_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_RET_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_RET_S1_INDIRECT_4, UBICOM32_INSN_RET_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_RET_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_MOVEA_D_DIRECT_S1_DIRECT, UBICOM32_INSN_MOVEA_D_IMMEDIATE_4_S1_DIRECT, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_INDEX_4_S1_DIRECT ++ , UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_MOVEA_D_INDIRECT_4_S1_DIRECT, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT ++ , UBICOM32_INSN_MOVEA_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_MOVEA_D_IMMEDIATE_4_S1_IMMEDIATE, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE ++ , UBICOM32_INSN_MOVEA_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_MOVEA_D_DIRECT_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_MOVEA_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_MOVEA_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_MOVEA_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_MOVEA_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_MOVEA_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_MOVEA_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_MOVEA_D_IMMEDIATE_4_S1_INDIRECT_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_MOVEA_D_INDIRECT_4_S1_INDIRECT_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_MOVEA_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_MOVEA_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_MOVEA_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_MOVEA_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_MOVEA_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_MOVEA_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_MOVEA_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_MOVE_4_D_DIRECT_S1_DIRECT, UBICOM32_INSN_MOVE_4_D_IMMEDIATE_4_S1_DIRECT ++ , UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_MOVE_4_D_INDIRECT_4_S1_DIRECT, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT ++ , UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_MOVE_4_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_MOVE_4_D_IMMEDIATE_4_S1_IMMEDIATE, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE ++ , UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_MOVE_4_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_MOVE_4_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_MOVE_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_MOVE_4_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_MOVE_4_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_MOVE_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_MOVE_4_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_MOVE_4_D_IMMEDIATE_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_4_S1_INDIRECT_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_MOVE_4_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_MOVE_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_MOVE_4_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_MOVE_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_MOVE_4_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_MOVE_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_COMPATIBILITY_IREAD_S1_EA_INDIRECT ++ , UBICOM32_INSN_COMPATIBILITY_IREAD_S1_EA_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_COMPATIBILITY_IREAD_S1_EA_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_COMPATIBILITY_IREAD_S1_EA_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_COMPATIBILITY_IREAD_S1_EA_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_DIRECT, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_DIRECT, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_S1_DIRECT, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_DIRECT ++ , UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_DIRECT, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_IMMEDIATE, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_IMMEDIATE, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_S1_IMMEDIATE ++ , UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_IMMEDIATE, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_IMMEDIATE, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_INDIRECT_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_INDIRECT_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_S1_INDIRECT_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_INDIRECT_4 ++ , UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_INDIRECT_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_INDEX_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_OFFSET_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_POST_INCREMENT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_COMPATIBILITY_IWRITE_D_PEA_INDIRECT_WITH_PRE_INCREMENT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_MOVE_2_D_DIRECT_S1_DIRECT ++ , UBICOM32_INSN_MOVE_2_D_IMMEDIATE_2_S1_DIRECT, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_INDEX_2_S1_DIRECT, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT, UBICOM32_INSN_MOVE_2_D_INDIRECT_2_S1_DIRECT ++ , UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_MOVE_2_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_MOVE_2_D_IMMEDIATE_2_S1_IMMEDIATE ++ , UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE, UBICOM32_INSN_MOVE_2_D_INDIRECT_2_S1_IMMEDIATE, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE ++ , UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_MOVE_2_D_DIRECT_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_MOVE_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_MOVE_2_D_DIRECT_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_MOVE_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_MOVE_2_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_MOVE_2_D_DIRECT_S1_INDIRECT_2 ++ , UBICOM32_INSN_MOVE_2_D_IMMEDIATE_2_S1_INDIRECT_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_MOVE_2_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_MOVE_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_MOVE_2_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_MOVE_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_MOVE_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_MOVE_1_D_DIRECT_S1_DIRECT, UBICOM32_INSN_MOVE_1_D_IMMEDIATE_1_S1_DIRECT, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_INDEX_1_S1_DIRECT, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_OFFSET_1_S1_DIRECT ++ , UBICOM32_INSN_MOVE_1_D_INDIRECT_1_S1_DIRECT, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_DIRECT, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_DIRECT, UBICOM32_INSN_MOVE_1_D_DIRECT_S1_IMMEDIATE ++ , UBICOM32_INSN_MOVE_1_D_IMMEDIATE_1_S1_IMMEDIATE, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_INDEX_1_S1_IMMEDIATE, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_OFFSET_1_S1_IMMEDIATE, UBICOM32_INSN_MOVE_1_D_INDIRECT_1_S1_IMMEDIATE ++ , UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_IMMEDIATE, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_IMMEDIATE, UBICOM32_INSN_MOVE_1_D_DIRECT_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_MOVE_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_MOVE_1_D_DIRECT_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_MOVE_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_MOVE_1_D_DIRECT_S1_INDIRECT_1, UBICOM32_INSN_MOVE_1_D_IMMEDIATE_1_S1_INDIRECT_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_1 ++ , UBICOM32_INSN_MOVE_1_D_INDIRECT_1_S1_INDIRECT_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_1, UBICOM32_INSN_MOVE_1_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_MOVE_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_1_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_MOVE_1_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_MOVE_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_MOVE_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_EXT_2_D_DIRECT_S1_DIRECT, UBICOM32_INSN_EXT_2_D_IMMEDIATE_2_S1_DIRECT, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_INDEX_2_S1_DIRECT ++ , UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT, UBICOM32_INSN_EXT_2_D_INDIRECT_2_S1_DIRECT, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT ++ , UBICOM32_INSN_EXT_2_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_EXT_2_D_IMMEDIATE_2_S1_IMMEDIATE, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE ++ , UBICOM32_INSN_EXT_2_D_INDIRECT_2_S1_IMMEDIATE, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_EXT_2_D_DIRECT_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_EXT_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_EXT_2_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_EXT_2_D_DIRECT_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_EXT_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_EXT_2_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_EXT_2_D_DIRECT_S1_INDIRECT_2, UBICOM32_INSN_EXT_2_D_IMMEDIATE_2_S1_INDIRECT_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_2, UBICOM32_INSN_EXT_2_D_INDIRECT_2_S1_INDIRECT_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_EXT_2_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_EXT_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_EXT_2_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_EXT_2_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_EXT_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_EXT_2_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_EXT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_EXT_1_D_DIRECT_S1_DIRECT, UBICOM32_INSN_EXT_1_D_IMMEDIATE_1_S1_DIRECT ++ , UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_INDEX_1_S1_DIRECT, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_OFFSET_1_S1_DIRECT, UBICOM32_INSN_EXT_1_D_INDIRECT_1_S1_DIRECT, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_DIRECT ++ , UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_DIRECT, UBICOM32_INSN_EXT_1_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_EXT_1_D_IMMEDIATE_1_S1_IMMEDIATE, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_INDEX_1_S1_IMMEDIATE ++ , UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_OFFSET_1_S1_IMMEDIATE, UBICOM32_INSN_EXT_1_D_INDIRECT_1_S1_IMMEDIATE, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_IMMEDIATE, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_IMMEDIATE ++ , UBICOM32_INSN_EXT_1_D_DIRECT_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_EXT_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_EXT_1_D_INDIRECT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_EXT_1_D_DIRECT_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_EXT_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_EXT_1_D_INDIRECT_1_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_EXT_1_D_DIRECT_S1_INDIRECT_1, UBICOM32_INSN_EXT_1_D_IMMEDIATE_1_S1_INDIRECT_1 ++ , UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_1, UBICOM32_INSN_EXT_1_D_INDIRECT_1_S1_INDIRECT_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_1 ++ , UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_1, UBICOM32_INSN_EXT_1_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_EXT_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_EXT_1_D_INDIRECT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_EXT_1_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_EXT_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_EXT_1_D_INDIRECT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_EXT_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_MOVEI_D_DIRECT ++ , UBICOM32_INSN_MOVEI_D_IMMEDIATE_2, UBICOM32_INSN_MOVEI_D_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_MOVEI_D_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_MOVEI_D_INDIRECT_2 ++ , UBICOM32_INSN_MOVEI_D_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_MOVEI_D_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_BCLR_D_DIRECT_S1_DIRECT, UBICOM32_INSN_BCLR_D_IMMEDIATE_4_S1_DIRECT ++ , UBICOM32_INSN_BCLR_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_BCLR_D_INDIRECT_4_S1_DIRECT, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT ++ , UBICOM32_INSN_BCLR_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_BCLR_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_BCLR_D_IMMEDIATE_4_S1_IMMEDIATE, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE ++ , UBICOM32_INSN_BCLR_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_BCLR_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_BCLR_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_BCLR_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_BCLR_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_BCLR_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_BCLR_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_BCLR_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_BCLR_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_BCLR_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_BCLR_D_IMMEDIATE_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_BCLR_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_BCLR_D_INDIRECT_4_S1_INDIRECT_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_BCLR_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_BCLR_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_BCLR_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_BCLR_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_BCLR_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_BCLR_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_BCLR_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_BCLR_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_BCLR_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_BSET_D_DIRECT_S1_DIRECT ++ , UBICOM32_INSN_BSET_D_IMMEDIATE_4_S1_DIRECT, UBICOM32_INSN_BSET_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_BSET_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_BSET_D_INDIRECT_4_S1_DIRECT ++ , UBICOM32_INSN_BSET_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_BSET_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_BSET_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_BSET_D_IMMEDIATE_4_S1_IMMEDIATE ++ , UBICOM32_INSN_BSET_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE, UBICOM32_INSN_BSET_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_BSET_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_BSET_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_BSET_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_BSET_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_BSET_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_BSET_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_BSET_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_BSET_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_BSET_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_BSET_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_BSET_D_DIRECT_S1_INDIRECT_4 ++ , UBICOM32_INSN_BSET_D_IMMEDIATE_4_S1_INDIRECT_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_BSET_D_INDIRECT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_BSET_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_BSET_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_BSET_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_BSET_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_BSET_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_BSET_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_BSET_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_BSET_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_BSET_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_BSET_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_BSET_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_BTST_S1_DIRECT_IMM_BIT5, UBICOM32_INSN_BTST_S1_IMMEDIATE_IMM_BIT5, UBICOM32_INSN_BTST_S1_INDIRECT_WITH_INDEX_4_IMM_BIT5, UBICOM32_INSN_BTST_S1_INDIRECT_WITH_OFFSET_4_IMM_BIT5 ++ , UBICOM32_INSN_BTST_S1_INDIRECT_4_IMM_BIT5, UBICOM32_INSN_BTST_S1_INDIRECT_WITH_POST_INCREMENT_4_IMM_BIT5, UBICOM32_INSN_BTST_S1_INDIRECT_WITH_PRE_INCREMENT_4_IMM_BIT5, UBICOM32_INSN_BTST_S1_DIRECT_DYN_REG ++ , UBICOM32_INSN_BTST_S1_IMMEDIATE_DYN_REG, UBICOM32_INSN_BTST_S1_INDIRECT_WITH_INDEX_4_DYN_REG, UBICOM32_INSN_BTST_S1_INDIRECT_WITH_OFFSET_4_DYN_REG, UBICOM32_INSN_BTST_S1_INDIRECT_4_DYN_REG ++ , UBICOM32_INSN_BTST_S1_INDIRECT_WITH_POST_INCREMENT_4_DYN_REG, UBICOM32_INSN_BTST_S1_INDIRECT_WITH_PRE_INCREMENT_4_DYN_REG, UBICOM32_INSN_SHMRG_2_IMM_BIT5_S1_DIRECT, UBICOM32_INSN_SHMRG_2_DYN_REG_S1_DIRECT ++ , UBICOM32_INSN_SHMRG_2_IMM_BIT5_S1_IMMEDIATE, UBICOM32_INSN_SHMRG_2_DYN_REG_S1_IMMEDIATE, UBICOM32_INSN_SHMRG_2_IMM_BIT5_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_SHMRG_2_DYN_REG_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_SHMRG_2_IMM_BIT5_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SHMRG_2_DYN_REG_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SHMRG_2_IMM_BIT5_S1_INDIRECT_2, UBICOM32_INSN_SHMRG_2_DYN_REG_S1_INDIRECT_2 ++ , UBICOM32_INSN_SHMRG_2_IMM_BIT5_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_SHMRG_2_DYN_REG_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_SHMRG_2_IMM_BIT5_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_SHMRG_2_DYN_REG_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_SHMRG_1_IMM_BIT5_S1_DIRECT, UBICOM32_INSN_SHMRG_1_DYN_REG_S1_DIRECT, UBICOM32_INSN_SHMRG_1_IMM_BIT5_S1_IMMEDIATE, UBICOM32_INSN_SHMRG_1_DYN_REG_S1_IMMEDIATE ++ , UBICOM32_INSN_SHMRG_1_IMM_BIT5_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_SHMRG_1_DYN_REG_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_SHMRG_1_IMM_BIT5_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_SHMRG_1_DYN_REG_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_SHMRG_1_IMM_BIT5_S1_INDIRECT_1, UBICOM32_INSN_SHMRG_1_DYN_REG_S1_INDIRECT_1, UBICOM32_INSN_SHMRG_1_IMM_BIT5_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_SHMRG_1_DYN_REG_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_SHMRG_1_IMM_BIT5_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_SHMRG_1_DYN_REG_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_CRCGEN_S1_DIRECT_IMM_BIT5, UBICOM32_INSN_CRCGEN_S1_IMMEDIATE_IMM_BIT5 ++ , UBICOM32_INSN_CRCGEN_S1_INDIRECT_WITH_INDEX_1_IMM_BIT5, UBICOM32_INSN_CRCGEN_S1_INDIRECT_WITH_OFFSET_1_IMM_BIT5, UBICOM32_INSN_CRCGEN_S1_INDIRECT_1_IMM_BIT5, UBICOM32_INSN_CRCGEN_S1_INDIRECT_WITH_POST_INCREMENT_1_IMM_BIT5 ++ , UBICOM32_INSN_CRCGEN_S1_INDIRECT_WITH_PRE_INCREMENT_1_IMM_BIT5, UBICOM32_INSN_CRCGEN_S1_DIRECT_DYN_REG, UBICOM32_INSN_CRCGEN_S1_IMMEDIATE_DYN_REG, UBICOM32_INSN_CRCGEN_S1_INDIRECT_WITH_INDEX_1_DYN_REG ++ , UBICOM32_INSN_CRCGEN_S1_INDIRECT_WITH_OFFSET_1_DYN_REG, UBICOM32_INSN_CRCGEN_S1_INDIRECT_1_DYN_REG, UBICOM32_INSN_CRCGEN_S1_INDIRECT_WITH_POST_INCREMENT_1_DYN_REG, UBICOM32_INSN_CRCGEN_S1_INDIRECT_WITH_PRE_INCREMENT_1_DYN_REG ++ , UBICOM32_INSN_BFEXTU_S1_DIRECT_IMM_BIT5, UBICOM32_INSN_BFEXTU_S1_IMMEDIATE_IMM_BIT5, UBICOM32_INSN_BFEXTU_S1_INDIRECT_WITH_INDEX_4_IMM_BIT5, UBICOM32_INSN_BFEXTU_S1_INDIRECT_WITH_OFFSET_4_IMM_BIT5 ++ , UBICOM32_INSN_BFEXTU_S1_INDIRECT_4_IMM_BIT5, UBICOM32_INSN_BFEXTU_S1_INDIRECT_WITH_POST_INCREMENT_4_IMM_BIT5, UBICOM32_INSN_BFEXTU_S1_INDIRECT_WITH_PRE_INCREMENT_4_IMM_BIT5, UBICOM32_INSN_BFEXTU_S1_DIRECT_DYN_REG ++ , UBICOM32_INSN_BFEXTU_S1_IMMEDIATE_DYN_REG, UBICOM32_INSN_BFEXTU_S1_INDIRECT_WITH_INDEX_4_DYN_REG, UBICOM32_INSN_BFEXTU_S1_INDIRECT_WITH_OFFSET_4_DYN_REG, UBICOM32_INSN_BFEXTU_S1_INDIRECT_4_DYN_REG ++ , UBICOM32_INSN_BFEXTU_S1_INDIRECT_WITH_POST_INCREMENT_4_DYN_REG, UBICOM32_INSN_BFEXTU_S1_INDIRECT_WITH_PRE_INCREMENT_4_DYN_REG, UBICOM32_INSN_BFRVRS_S1_DIRECT_IMM_BIT5, UBICOM32_INSN_BFRVRS_S1_IMMEDIATE_IMM_BIT5 ++ , UBICOM32_INSN_BFRVRS_S1_INDIRECT_WITH_INDEX_4_IMM_BIT5, UBICOM32_INSN_BFRVRS_S1_INDIRECT_WITH_OFFSET_4_IMM_BIT5, UBICOM32_INSN_BFRVRS_S1_INDIRECT_4_IMM_BIT5, UBICOM32_INSN_BFRVRS_S1_INDIRECT_WITH_POST_INCREMENT_4_IMM_BIT5 ++ , UBICOM32_INSN_BFRVRS_S1_INDIRECT_WITH_PRE_INCREMENT_4_IMM_BIT5, UBICOM32_INSN_BFRVRS_S1_DIRECT_DYN_REG, UBICOM32_INSN_BFRVRS_S1_IMMEDIATE_DYN_REG, UBICOM32_INSN_BFRVRS_S1_INDIRECT_WITH_INDEX_4_DYN_REG ++ , UBICOM32_INSN_BFRVRS_S1_INDIRECT_WITH_OFFSET_4_DYN_REG, UBICOM32_INSN_BFRVRS_S1_INDIRECT_4_DYN_REG, UBICOM32_INSN_BFRVRS_S1_INDIRECT_WITH_POST_INCREMENT_4_DYN_REG, UBICOM32_INSN_BFRVRS_S1_INDIRECT_WITH_PRE_INCREMENT_4_DYN_REG ++ , UBICOM32_INSN_MERGE_S1_DIRECT_IMM_BIT5, UBICOM32_INSN_MERGE_S1_IMMEDIATE_IMM_BIT5, UBICOM32_INSN_MERGE_S1_INDIRECT_WITH_INDEX_4_IMM_BIT5, UBICOM32_INSN_MERGE_S1_INDIRECT_WITH_OFFSET_4_IMM_BIT5 ++ , UBICOM32_INSN_MERGE_S1_INDIRECT_4_IMM_BIT5, UBICOM32_INSN_MERGE_S1_INDIRECT_WITH_POST_INCREMENT_4_IMM_BIT5, UBICOM32_INSN_MERGE_S1_INDIRECT_WITH_PRE_INCREMENT_4_IMM_BIT5, UBICOM32_INSN_MERGE_S1_DIRECT_DYN_REG ++ , UBICOM32_INSN_MERGE_S1_IMMEDIATE_DYN_REG, UBICOM32_INSN_MERGE_S1_INDIRECT_WITH_INDEX_4_DYN_REG, UBICOM32_INSN_MERGE_S1_INDIRECT_WITH_OFFSET_4_DYN_REG, UBICOM32_INSN_MERGE_S1_INDIRECT_4_DYN_REG ++ , UBICOM32_INSN_MERGE_S1_INDIRECT_WITH_POST_INCREMENT_4_DYN_REG, UBICOM32_INSN_MERGE_S1_INDIRECT_WITH_PRE_INCREMENT_4_DYN_REG, UBICOM32_INSN_SHFTD_S1_DIRECT_IMM_BIT5, UBICOM32_INSN_SHFTD_S1_IMMEDIATE_IMM_BIT5 ++ , UBICOM32_INSN_SHFTD_S1_INDIRECT_WITH_INDEX_4_IMM_BIT5, UBICOM32_INSN_SHFTD_S1_INDIRECT_WITH_OFFSET_4_IMM_BIT5, UBICOM32_INSN_SHFTD_S1_INDIRECT_4_IMM_BIT5, UBICOM32_INSN_SHFTD_S1_INDIRECT_WITH_POST_INCREMENT_4_IMM_BIT5 ++ , UBICOM32_INSN_SHFTD_S1_INDIRECT_WITH_PRE_INCREMENT_4_IMM_BIT5, UBICOM32_INSN_SHFTD_S1_DIRECT_DYN_REG, UBICOM32_INSN_SHFTD_S1_IMMEDIATE_DYN_REG, UBICOM32_INSN_SHFTD_S1_INDIRECT_WITH_INDEX_4_DYN_REG ++ , UBICOM32_INSN_SHFTD_S1_INDIRECT_WITH_OFFSET_4_DYN_REG, UBICOM32_INSN_SHFTD_S1_INDIRECT_4_DYN_REG, UBICOM32_INSN_SHFTD_S1_INDIRECT_WITH_POST_INCREMENT_4_DYN_REG, UBICOM32_INSN_SHFTD_S1_INDIRECT_WITH_PRE_INCREMENT_4_DYN_REG ++ , UBICOM32_INSN_ASR_1_IMM_BIT5_S1_DIRECT, UBICOM32_INSN_ASR_1_DYN_REG_S1_DIRECT, UBICOM32_INSN_ASR_1_IMM_BIT5_S1_IMMEDIATE, UBICOM32_INSN_ASR_1_DYN_REG_S1_IMMEDIATE ++ , UBICOM32_INSN_ASR_1_IMM_BIT5_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_ASR_1_DYN_REG_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_ASR_1_IMM_BIT5_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_ASR_1_DYN_REG_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_ASR_1_IMM_BIT5_S1_INDIRECT_1, UBICOM32_INSN_ASR_1_DYN_REG_S1_INDIRECT_1, UBICOM32_INSN_ASR_1_IMM_BIT5_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_ASR_1_DYN_REG_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_ASR_1_IMM_BIT5_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_ASR_1_DYN_REG_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_LSL_1_IMM_BIT5_S1_DIRECT, UBICOM32_INSN_LSL_1_DYN_REG_S1_DIRECT ++ , UBICOM32_INSN_LSL_1_IMM_BIT5_S1_IMMEDIATE, UBICOM32_INSN_LSL_1_DYN_REG_S1_IMMEDIATE, UBICOM32_INSN_LSL_1_IMM_BIT5_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_LSL_1_DYN_REG_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_LSL_1_IMM_BIT5_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_LSL_1_DYN_REG_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_LSL_1_IMM_BIT5_S1_INDIRECT_1, UBICOM32_INSN_LSL_1_DYN_REG_S1_INDIRECT_1 ++ , UBICOM32_INSN_LSL_1_IMM_BIT5_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_LSL_1_DYN_REG_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_LSL_1_IMM_BIT5_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_LSL_1_DYN_REG_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_LSR_1_IMM_BIT5_S1_DIRECT, UBICOM32_INSN_LSR_1_DYN_REG_S1_DIRECT, UBICOM32_INSN_LSR_1_IMM_BIT5_S1_IMMEDIATE, UBICOM32_INSN_LSR_1_DYN_REG_S1_IMMEDIATE ++ , UBICOM32_INSN_LSR_1_IMM_BIT5_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_LSR_1_DYN_REG_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_LSR_1_IMM_BIT5_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_LSR_1_DYN_REG_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_LSR_1_IMM_BIT5_S1_INDIRECT_1, UBICOM32_INSN_LSR_1_DYN_REG_S1_INDIRECT_1, UBICOM32_INSN_LSR_1_IMM_BIT5_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_LSR_1_DYN_REG_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_LSR_1_IMM_BIT5_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_LSR_1_DYN_REG_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_ASR_2_IMM_BIT5_S1_DIRECT, UBICOM32_INSN_ASR_2_DYN_REG_S1_DIRECT ++ , UBICOM32_INSN_ASR_2_IMM_BIT5_S1_IMMEDIATE, UBICOM32_INSN_ASR_2_DYN_REG_S1_IMMEDIATE, UBICOM32_INSN_ASR_2_IMM_BIT5_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_ASR_2_DYN_REG_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_ASR_2_IMM_BIT5_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_ASR_2_DYN_REG_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_ASR_2_IMM_BIT5_S1_INDIRECT_2, UBICOM32_INSN_ASR_2_DYN_REG_S1_INDIRECT_2 ++ , UBICOM32_INSN_ASR_2_IMM_BIT5_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_ASR_2_DYN_REG_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_ASR_2_IMM_BIT5_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_ASR_2_DYN_REG_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_LSL_2_IMM_BIT5_S1_DIRECT, UBICOM32_INSN_LSL_2_DYN_REG_S1_DIRECT, UBICOM32_INSN_LSL_2_IMM_BIT5_S1_IMMEDIATE, UBICOM32_INSN_LSL_2_DYN_REG_S1_IMMEDIATE ++ , UBICOM32_INSN_LSL_2_IMM_BIT5_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_LSL_2_DYN_REG_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_LSL_2_IMM_BIT5_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_LSL_2_DYN_REG_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_LSL_2_IMM_BIT5_S1_INDIRECT_2, UBICOM32_INSN_LSL_2_DYN_REG_S1_INDIRECT_2, UBICOM32_INSN_LSL_2_IMM_BIT5_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_LSL_2_DYN_REG_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_LSL_2_IMM_BIT5_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_LSL_2_DYN_REG_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_LSR_2_IMM_BIT5_S1_DIRECT, UBICOM32_INSN_LSR_2_DYN_REG_S1_DIRECT ++ , UBICOM32_INSN_LSR_2_IMM_BIT5_S1_IMMEDIATE, UBICOM32_INSN_LSR_2_DYN_REG_S1_IMMEDIATE, UBICOM32_INSN_LSR_2_IMM_BIT5_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_LSR_2_DYN_REG_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_LSR_2_IMM_BIT5_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_LSR_2_DYN_REG_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_LSR_2_IMM_BIT5_S1_INDIRECT_2, UBICOM32_INSN_LSR_2_DYN_REG_S1_INDIRECT_2 ++ , UBICOM32_INSN_LSR_2_IMM_BIT5_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_LSR_2_DYN_REG_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_LSR_2_IMM_BIT5_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_LSR_2_DYN_REG_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_ASR_4_IMM_BIT5_S1_DIRECT, UBICOM32_INSN_ASR_4_DYN_REG_S1_DIRECT, UBICOM32_INSN_ASR_4_IMM_BIT5_S1_IMMEDIATE, UBICOM32_INSN_ASR_4_DYN_REG_S1_IMMEDIATE ++ , UBICOM32_INSN_ASR_4_IMM_BIT5_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_ASR_4_DYN_REG_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_ASR_4_IMM_BIT5_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_ASR_4_DYN_REG_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_ASR_4_IMM_BIT5_S1_INDIRECT_4, UBICOM32_INSN_ASR_4_DYN_REG_S1_INDIRECT_4, UBICOM32_INSN_ASR_4_IMM_BIT5_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_ASR_4_DYN_REG_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_ASR_4_IMM_BIT5_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_ASR_4_DYN_REG_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_LSL_4_IMM_BIT5_S1_DIRECT, UBICOM32_INSN_LSL_4_DYN_REG_S1_DIRECT ++ , UBICOM32_INSN_LSL_4_IMM_BIT5_S1_IMMEDIATE, UBICOM32_INSN_LSL_4_DYN_REG_S1_IMMEDIATE, UBICOM32_INSN_LSL_4_IMM_BIT5_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_LSL_4_DYN_REG_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_LSL_4_IMM_BIT5_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_LSL_4_DYN_REG_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_LSL_4_IMM_BIT5_S1_INDIRECT_4, UBICOM32_INSN_LSL_4_DYN_REG_S1_INDIRECT_4 ++ , UBICOM32_INSN_LSL_4_IMM_BIT5_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_LSL_4_DYN_REG_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_LSL_4_IMM_BIT5_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_LSL_4_DYN_REG_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_LSR_4_IMM_BIT5_S1_DIRECT, UBICOM32_INSN_LSR_4_DYN_REG_S1_DIRECT, UBICOM32_INSN_LSR_4_IMM_BIT5_S1_IMMEDIATE, UBICOM32_INSN_LSR_4_DYN_REG_S1_IMMEDIATE ++ , UBICOM32_INSN_LSR_4_IMM_BIT5_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_LSR_4_DYN_REG_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_LSR_4_IMM_BIT5_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_LSR_4_DYN_REG_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_LSR_4_IMM_BIT5_S1_INDIRECT_4, UBICOM32_INSN_LSR_4_DYN_REG_S1_INDIRECT_4, UBICOM32_INSN_LSR_4_IMM_BIT5_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_LSR_4_DYN_REG_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_LSR_4_IMM_BIT5_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_LSR_4_DYN_REG_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_COMPATIBILITY_MAC_S1_DIRECT_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MAC_S1_IMMEDIATE_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_COMPATIBILITY_MAC_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MAC_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MAC_S1_INDIRECT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MAC_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_COMPATIBILITY_MAC_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MAC_S1_DIRECT_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MAC_S1_IMMEDIATE_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MAC_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_COMPATIBILITY_MAC_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MAC_S1_INDIRECT_2_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MAC_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MAC_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_MAC_S1_DIRECT_IMM_BIT5, UBICOM32_INSN_MAC_S1_IMMEDIATE_IMM_BIT5, UBICOM32_INSN_MAC_S1_INDIRECT_WITH_INDEX_2_IMM_BIT5, UBICOM32_INSN_MAC_S1_INDIRECT_WITH_OFFSET_2_IMM_BIT5 ++ , UBICOM32_INSN_MAC_S1_INDIRECT_2_IMM_BIT5, UBICOM32_INSN_MAC_S1_INDIRECT_WITH_POST_INCREMENT_2_IMM_BIT5, UBICOM32_INSN_MAC_S1_INDIRECT_WITH_PRE_INCREMENT_2_IMM_BIT5, UBICOM32_INSN_MAC_S1_DIRECT_DYN_REG ++ , UBICOM32_INSN_MAC_S1_IMMEDIATE_DYN_REG, UBICOM32_INSN_MAC_S1_INDIRECT_WITH_INDEX_2_DYN_REG, UBICOM32_INSN_MAC_S1_INDIRECT_WITH_OFFSET_2_DYN_REG, UBICOM32_INSN_MAC_S1_INDIRECT_2_DYN_REG ++ , UBICOM32_INSN_MAC_S1_INDIRECT_WITH_POST_INCREMENT_2_DYN_REG, UBICOM32_INSN_MAC_S1_INDIRECT_WITH_PRE_INCREMENT_2_DYN_REG, UBICOM32_INSN_COMPATIBILITY_MULF_S1_DIRECT_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULF_S1_IMMEDIATE_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_COMPATIBILITY_MULF_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULF_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULF_S1_INDIRECT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULF_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_COMPATIBILITY_MULF_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULF_S1_DIRECT_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULF_S1_IMMEDIATE_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULF_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_COMPATIBILITY_MULF_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULF_S1_INDIRECT_2_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULF_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULF_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_MULF_S1_DIRECT_IMM_BIT5, UBICOM32_INSN_MULF_S1_IMMEDIATE_IMM_BIT5, UBICOM32_INSN_MULF_S1_INDIRECT_WITH_INDEX_2_IMM_BIT5, UBICOM32_INSN_MULF_S1_INDIRECT_WITH_OFFSET_2_IMM_BIT5 ++ , UBICOM32_INSN_MULF_S1_INDIRECT_2_IMM_BIT5, UBICOM32_INSN_MULF_S1_INDIRECT_WITH_POST_INCREMENT_2_IMM_BIT5, UBICOM32_INSN_MULF_S1_INDIRECT_WITH_PRE_INCREMENT_2_IMM_BIT5, UBICOM32_INSN_MULF_S1_DIRECT_DYN_REG ++ , UBICOM32_INSN_MULF_S1_IMMEDIATE_DYN_REG, UBICOM32_INSN_MULF_S1_INDIRECT_WITH_INDEX_2_DYN_REG, UBICOM32_INSN_MULF_S1_INDIRECT_WITH_OFFSET_2_DYN_REG, UBICOM32_INSN_MULF_S1_INDIRECT_2_DYN_REG ++ , UBICOM32_INSN_MULF_S1_INDIRECT_WITH_POST_INCREMENT_2_DYN_REG, UBICOM32_INSN_MULF_S1_INDIRECT_WITH_PRE_INCREMENT_2_DYN_REG, UBICOM32_INSN_COMPATIBILITY_MULU_S1_DIRECT_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULU_S1_IMMEDIATE_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_COMPATIBILITY_MULU_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULU_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULU_S1_INDIRECT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULU_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_COMPATIBILITY_MULU_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULU_S1_DIRECT_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULU_S1_IMMEDIATE_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULU_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_COMPATIBILITY_MULU_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULU_S1_INDIRECT_2_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULU_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULU_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_MULU_S1_DIRECT_IMM_BIT5, UBICOM32_INSN_MULU_S1_IMMEDIATE_IMM_BIT5, UBICOM32_INSN_MULU_S1_INDIRECT_WITH_INDEX_2_IMM_BIT5, UBICOM32_INSN_MULU_S1_INDIRECT_WITH_OFFSET_2_IMM_BIT5 ++ , UBICOM32_INSN_MULU_S1_INDIRECT_2_IMM_BIT5, UBICOM32_INSN_MULU_S1_INDIRECT_WITH_POST_INCREMENT_2_IMM_BIT5, UBICOM32_INSN_MULU_S1_INDIRECT_WITH_PRE_INCREMENT_2_IMM_BIT5, UBICOM32_INSN_MULU_S1_DIRECT_DYN_REG ++ , UBICOM32_INSN_MULU_S1_IMMEDIATE_DYN_REG, UBICOM32_INSN_MULU_S1_INDIRECT_WITH_INDEX_2_DYN_REG, UBICOM32_INSN_MULU_S1_INDIRECT_WITH_OFFSET_2_DYN_REG, UBICOM32_INSN_MULU_S1_INDIRECT_2_DYN_REG ++ , UBICOM32_INSN_MULU_S1_INDIRECT_WITH_POST_INCREMENT_2_DYN_REG, UBICOM32_INSN_MULU_S1_INDIRECT_WITH_PRE_INCREMENT_2_DYN_REG, UBICOM32_INSN_COMPATIBILITY_MULS_S1_DIRECT_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULS_S1_IMMEDIATE_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_COMPATIBILITY_MULS_S1_INDIRECT_WITH_INDEX_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULS_S1_INDIRECT_WITH_OFFSET_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULS_S1_INDIRECT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULS_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_SRC2_DATA_REG ++ , UBICOM32_INSN_COMPATIBILITY_MULS_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_SRC2_DATA_REG, UBICOM32_INSN_COMPATIBILITY_MULS_S1_DIRECT_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULS_S1_IMMEDIATE_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULS_S1_INDIRECT_WITH_INDEX_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_COMPATIBILITY_MULS_S1_INDIRECT_WITH_OFFSET_2_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULS_S1_INDIRECT_2_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULS_S1_INDIRECT_WITH_POST_INCREMENT_2_DSP_IMM_BIT5, UBICOM32_INSN_COMPATIBILITY_MULS_S1_INDIRECT_WITH_PRE_INCREMENT_2_DSP_IMM_BIT5 ++ , UBICOM32_INSN_MULS_S1_DIRECT_IMM_BIT5, UBICOM32_INSN_MULS_S1_IMMEDIATE_IMM_BIT5, UBICOM32_INSN_MULS_S1_INDIRECT_WITH_INDEX_2_IMM_BIT5, UBICOM32_INSN_MULS_S1_INDIRECT_WITH_OFFSET_2_IMM_BIT5 ++ , UBICOM32_INSN_MULS_S1_INDIRECT_2_IMM_BIT5, UBICOM32_INSN_MULS_S1_INDIRECT_WITH_POST_INCREMENT_2_IMM_BIT5, UBICOM32_INSN_MULS_S1_INDIRECT_WITH_PRE_INCREMENT_2_IMM_BIT5, UBICOM32_INSN_MULS_S1_DIRECT_DYN_REG ++ , UBICOM32_INSN_MULS_S1_IMMEDIATE_DYN_REG, UBICOM32_INSN_MULS_S1_INDIRECT_WITH_INDEX_2_DYN_REG, UBICOM32_INSN_MULS_S1_INDIRECT_WITH_OFFSET_2_DYN_REG, UBICOM32_INSN_MULS_S1_INDIRECT_2_DYN_REG ++ , UBICOM32_INSN_MULS_S1_INDIRECT_WITH_POST_INCREMENT_2_DYN_REG, UBICOM32_INSN_MULS_S1_INDIRECT_WITH_PRE_INCREMENT_2_DYN_REG, UBICOM32_INSN_SWAPB_4_D_DIRECT_S1_DIRECT, UBICOM32_INSN_SWAPB_4_D_IMMEDIATE_4_S1_DIRECT ++ , UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_SWAPB_4_D_INDIRECT_4_S1_DIRECT, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT ++ , UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_SWAPB_4_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_SWAPB_4_D_IMMEDIATE_4_S1_IMMEDIATE, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE ++ , UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_SWAPB_4_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_SWAPB_4_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SWAPB_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_SWAPB_4_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SWAPB_4_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_SWAPB_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SWAPB_4_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_SWAPB_4_D_IMMEDIATE_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_4_S1_INDIRECT_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_SWAPB_4_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SWAPB_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_SWAPB_4_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SWAPB_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_SWAPB_4_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SWAPB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SWAPB_2_D_DIRECT_S1_DIRECT ++ , UBICOM32_INSN_SWAPB_2_D_IMMEDIATE_2_S1_DIRECT, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_INDEX_2_S1_DIRECT, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT, UBICOM32_INSN_SWAPB_2_D_INDIRECT_2_S1_DIRECT ++ , UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_SWAPB_2_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_SWAPB_2_D_IMMEDIATE_2_S1_IMMEDIATE ++ , UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE, UBICOM32_INSN_SWAPB_2_D_INDIRECT_2_S1_IMMEDIATE, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE ++ , UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_SWAPB_2_D_DIRECT_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_SWAPB_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_SWAPB_2_D_DIRECT_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SWAPB_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_SWAPB_2_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SWAPB_2_D_DIRECT_S1_INDIRECT_2 ++ , UBICOM32_INSN_SWAPB_2_D_IMMEDIATE_2_S1_INDIRECT_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_SWAPB_2_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_SWAPB_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_SWAPB_2_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_SWAPB_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_SWAPB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_PDEC_D_DIRECT_PDEC_S1_EA_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PDEC_D_IMMEDIATE_4_PDEC_S1_EA_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PDEC_D_INDIRECT_WITH_INDEX_4_PDEC_S1_EA_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PDEC_D_INDIRECT_WITH_OFFSET_4_PDEC_S1_EA_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PDEC_D_INDIRECT_4_PDEC_S1_EA_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PDEC_D_INDIRECT_WITH_POST_INCREMENT_4_PDEC_S1_EA_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PDEC_D_INDIRECT_WITH_PRE_INCREMENT_4_PDEC_S1_EA_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_LEA_4_D_DIRECT_S1_EA_INDIRECT ++ , UBICOM32_INSN_LEA_4_D_IMMEDIATE_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_4_D_INDIRECT_4_S1_EA_INDIRECT ++ , UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_4_D_DIRECT_S1_EA_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_LEA_4_D_IMMEDIATE_4_S1_EA_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_LEA_4_D_INDIRECT_4_S1_EA_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_LEA_4_D_DIRECT_S1_EA_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_LEA_4_D_IMMEDIATE_4_S1_EA_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_LEA_4_D_INDIRECT_4_S1_EA_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_LEA_4_D_DIRECT_S1_EA_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_LEA_4_D_IMMEDIATE_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_LEA_4_D_INDIRECT_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_LEA_4_D_DIRECT_S1_EA_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_LEA_4_D_IMMEDIATE_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_LEA_4_D_INDIRECT_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_LEA_4_D_DIRECT_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_4_D_IMMEDIATE_4_S1_EA_IMMEDIATE ++ , UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_INDEX_4_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_OFFSET_4_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_4_D_INDIRECT_4_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_IMMEDIATE ++ , UBICOM32_INSN_LEA_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_2_D_DIRECT_S1_EA_INDIRECT, UBICOM32_INSN_LEA_2_D_IMMEDIATE_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT ++ , UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_2_D_INDIRECT_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT ++ , UBICOM32_INSN_LEA_2_D_DIRECT_S1_EA_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_LEA_2_D_IMMEDIATE_4_S1_EA_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_LEA_2_D_INDIRECT_4_S1_EA_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_LEA_2_D_DIRECT_S1_EA_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_LEA_2_D_IMMEDIATE_4_S1_EA_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_LEA_2_D_INDIRECT_4_S1_EA_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_LEA_2_D_DIRECT_S1_EA_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_LEA_2_D_IMMEDIATE_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_LEA_2_D_INDIRECT_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_LEA_2_D_DIRECT_S1_EA_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_LEA_2_D_IMMEDIATE_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_LEA_2_D_INDIRECT_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_LEA_2_D_DIRECT_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_2_D_IMMEDIATE_4_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_INDEX_4_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_OFFSET_4_S1_EA_IMMEDIATE ++ , UBICOM32_INSN_LEA_2_D_INDIRECT_4_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_2_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_1_D_DIRECT_S1_EA_INDIRECT ++ , UBICOM32_INSN_LEA_1_D_IMMEDIATE_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_1_D_INDIRECT_4_S1_EA_INDIRECT ++ , UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT, UBICOM32_INSN_LEA_1_D_DIRECT_S1_EA_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_LEA_1_D_IMMEDIATE_4_S1_EA_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_LEA_1_D_INDIRECT_4_S1_EA_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_LEA_1_D_DIRECT_S1_EA_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_LEA_1_D_IMMEDIATE_4_S1_EA_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_LEA_1_D_INDIRECT_4_S1_EA_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_LEA_1_D_DIRECT_S1_EA_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_LEA_1_D_IMMEDIATE_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_LEA_1_D_INDIRECT_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_LEA_1_D_DIRECT_S1_EA_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_LEA_1_D_IMMEDIATE_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_INDEX_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_OFFSET_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_LEA_1_D_INDIRECT_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_LEA_1_D_DIRECT_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_1_D_IMMEDIATE_4_S1_EA_IMMEDIATE ++ , UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_INDEX_4_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_OFFSET_4_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_1_D_INDIRECT_4_S1_EA_IMMEDIATE, UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_POST_INCREMENT_4_S1_EA_IMMEDIATE ++ , UBICOM32_INSN_LEA_1_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_EA_IMMEDIATE, UBICOM32_INSN_CMPI_S1_DIRECT, UBICOM32_INSN_CMPI_S1_IMMEDIATE, UBICOM32_INSN_CMPI_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_CMPI_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_CMPI_S1_INDIRECT_2, UBICOM32_INSN_CMPI_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_CMPI_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_PXADDS_U_D_DIRECT_S1_DIRECT, UBICOM32_INSN_PXADDS_U_D_IMMEDIATE_2_S1_DIRECT, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_INDEX_2_S1_DIRECT, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT ++ , UBICOM32_INSN_PXADDS_U_D_INDIRECT_2_S1_DIRECT, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_PXADDS_U_D_DIRECT_S1_IMMEDIATE ++ , UBICOM32_INSN_PXADDS_U_D_IMMEDIATE_2_S1_IMMEDIATE, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE, UBICOM32_INSN_PXADDS_U_D_INDIRECT_2_S1_IMMEDIATE ++ , UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_PXADDS_U_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXADDS_U_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXADDS_U_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXADDS_U_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXADDS_U_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_PXADDS_U_D_IMMEDIATE_2_S1_INDIRECT_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXADDS_U_D_INDIRECT_2_S1_INDIRECT_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_4, UBICOM32_INSN_PXADDS_U_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXADDS_U_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXADDS_U_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXADDS_U_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXADDS_U_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXADDS_D_DIRECT_S1_DIRECT, UBICOM32_INSN_PXADDS_D_IMMEDIATE_2_S1_DIRECT, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_INDEX_2_S1_DIRECT ++ , UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT, UBICOM32_INSN_PXADDS_D_INDIRECT_2_S1_DIRECT, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT ++ , UBICOM32_INSN_PXADDS_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_PXADDS_D_IMMEDIATE_2_S1_IMMEDIATE, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE ++ , UBICOM32_INSN_PXADDS_D_INDIRECT_2_S1_IMMEDIATE, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_PXADDS_D_DIRECT_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXADDS_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXADDS_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXADDS_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXADDS_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXADDS_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXADDS_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_PXADDS_D_IMMEDIATE_2_S1_INDIRECT_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_4, UBICOM32_INSN_PXADDS_D_INDIRECT_2_S1_INDIRECT_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXADDS_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXADDS_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXADDS_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXADDS_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXADDS_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXADDS_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXADDS_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXHI_S_S1_DIRECT, UBICOM32_INSN_PXHI_S_S1_IMMEDIATE ++ , UBICOM32_INSN_PXHI_S_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXHI_S_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXHI_S_S1_INDIRECT_4, UBICOM32_INSN_PXHI_S_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXHI_S_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXHI_S1_DIRECT, UBICOM32_INSN_PXHI_S1_IMMEDIATE, UBICOM32_INSN_PXHI_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXHI_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXHI_S1_INDIRECT_4, UBICOM32_INSN_PXHI_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXHI_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXVI_S_D_DIRECT_S1_DIRECT, UBICOM32_INSN_PXVI_S_D_IMMEDIATE_4_S1_DIRECT, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT ++ , UBICOM32_INSN_PXVI_S_D_INDIRECT_4_S1_DIRECT, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_PXVI_S_D_DIRECT_S1_IMMEDIATE ++ , UBICOM32_INSN_PXVI_S_D_IMMEDIATE_4_S1_IMMEDIATE, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_PXVI_S_D_INDIRECT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_PXVI_S_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXVI_S_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXVI_S_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXVI_S_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXVI_S_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_PXVI_S_D_IMMEDIATE_4_S1_INDIRECT_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXVI_S_D_INDIRECT_4_S1_INDIRECT_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_PXVI_S_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXVI_S_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXVI_S_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXVI_S_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXVI_S_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXVI_D_DIRECT_S1_DIRECT, UBICOM32_INSN_PXVI_D_IMMEDIATE_4_S1_DIRECT, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_INDEX_4_S1_DIRECT ++ , UBICOM32_INSN_PXVI_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_PXVI_D_INDIRECT_4_S1_DIRECT, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT ++ , UBICOM32_INSN_PXVI_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_PXVI_D_IMMEDIATE_4_S1_IMMEDIATE, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE ++ , UBICOM32_INSN_PXVI_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_PXVI_D_DIRECT_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXVI_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXVI_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXVI_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXVI_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXVI_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXVI_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXVI_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXVI_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXVI_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_PXVI_D_IMMEDIATE_4_S1_INDIRECT_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXVI_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_PXVI_D_INDIRECT_4_S1_INDIRECT_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXVI_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXVI_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXVI_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXVI_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXVI_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXVI_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXVI_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXVI_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXBLEND_T_D_DIRECT_S1_DIRECT, UBICOM32_INSN_PXBLEND_T_D_IMMEDIATE_4_S1_DIRECT ++ , UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_4_S1_DIRECT, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT ++ , UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_PXBLEND_T_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_PXBLEND_T_D_IMMEDIATE_4_S1_IMMEDIATE, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE ++ , UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_PXBLEND_T_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXBLEND_T_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXBLEND_T_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXBLEND_T_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXBLEND_T_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXBLEND_T_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_PXBLEND_T_D_IMMEDIATE_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_4_S1_INDIRECT_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_PXBLEND_T_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXBLEND_T_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXBLEND_T_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXBLEND_T_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXBLEND_T_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXBLEND_T_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXBLEND_D_DIRECT_S1_DIRECT ++ , UBICOM32_INSN_PXBLEND_D_IMMEDIATE_4_S1_DIRECT, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_PXBLEND_D_INDIRECT_4_S1_DIRECT ++ , UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_PXBLEND_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_PXBLEND_D_IMMEDIATE_4_S1_IMMEDIATE ++ , UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_PXBLEND_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_PXBLEND_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXBLEND_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXBLEND_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXBLEND_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXBLEND_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXBLEND_D_DIRECT_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXBLEND_D_IMMEDIATE_4_S1_INDIRECT_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_PXBLEND_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXBLEND_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXBLEND_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXBLEND_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXBLEND_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXCNV_T_D_DIRECT_S1_DIRECT, UBICOM32_INSN_PXCNV_T_D_IMMEDIATE_2_S1_DIRECT, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_INDEX_2_S1_DIRECT, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT ++ , UBICOM32_INSN_PXCNV_T_D_INDIRECT_2_S1_DIRECT, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_PXCNV_T_D_DIRECT_S1_IMMEDIATE ++ , UBICOM32_INSN_PXCNV_T_D_IMMEDIATE_2_S1_IMMEDIATE, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE, UBICOM32_INSN_PXCNV_T_D_INDIRECT_2_S1_IMMEDIATE ++ , UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_PXCNV_T_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXCNV_T_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXCNV_T_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXCNV_T_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXCNV_T_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_PXCNV_T_D_IMMEDIATE_2_S1_INDIRECT_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXCNV_T_D_INDIRECT_2_S1_INDIRECT_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_4, UBICOM32_INSN_PXCNV_T_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXCNV_T_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXCNV_T_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXCNV_T_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXCNV_T_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXCNV_D_DIRECT_S1_DIRECT, UBICOM32_INSN_PXCNV_D_IMMEDIATE_2_S1_DIRECT, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_INDEX_2_S1_DIRECT ++ , UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT, UBICOM32_INSN_PXCNV_D_INDIRECT_2_S1_DIRECT, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT ++ , UBICOM32_INSN_PXCNV_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_PXCNV_D_IMMEDIATE_2_S1_IMMEDIATE, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE ++ , UBICOM32_INSN_PXCNV_D_INDIRECT_2_S1_IMMEDIATE, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_PXCNV_D_DIRECT_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXCNV_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXCNV_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_PXCNV_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXCNV_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXCNV_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_PXCNV_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_PXCNV_D_IMMEDIATE_2_S1_INDIRECT_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_4, UBICOM32_INSN_PXCNV_D_INDIRECT_2_S1_INDIRECT_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_4 ++ , UBICOM32_INSN_PXCNV_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXCNV_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_PXCNV_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_PXCNV_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXCNV_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXCNV_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_PXCNV_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SUBC_D_DIRECT_S1_DIRECT, UBICOM32_INSN_SUBC_D_IMMEDIATE_4_S1_DIRECT ++ , UBICOM32_INSN_SUBC_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_SUBC_D_INDIRECT_4_S1_DIRECT, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT ++ , UBICOM32_INSN_SUBC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_SUBC_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_SUBC_D_IMMEDIATE_4_S1_IMMEDIATE, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE ++ , UBICOM32_INSN_SUBC_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_SUBC_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_SUBC_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SUBC_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_SUBC_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SUBC_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_SUBC_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SUBC_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_SUBC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SUBC_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_SUBC_D_IMMEDIATE_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_SUBC_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_SUBC_D_INDIRECT_4_S1_INDIRECT_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_SUBC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_SUBC_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SUBC_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_SUBC_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SUBC_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_SUBC_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SUBC_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_SUBC_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SUBC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_ADDC_D_DIRECT_S1_DIRECT ++ , UBICOM32_INSN_ADDC_D_IMMEDIATE_4_S1_DIRECT, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_ADDC_D_INDIRECT_4_S1_DIRECT ++ , UBICOM32_INSN_ADDC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_ADDC_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_ADDC_D_IMMEDIATE_4_S1_IMMEDIATE ++ , UBICOM32_INSN_ADDC_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_ADDC_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_ADDC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_ADDC_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_ADDC_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_ADDC_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_ADDC_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_ADDC_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_ADDC_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_ADDC_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_ADDC_D_DIRECT_S1_INDIRECT_4 ++ , UBICOM32_INSN_ADDC_D_IMMEDIATE_4_S1_INDIRECT_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_ADDC_D_INDIRECT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_ADDC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_ADDC_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_ADDC_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_ADDC_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_ADDC_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_ADDC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_ADDC_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_ADDC_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_ADDC_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_ADDC_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_ADDC_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_SUB_1_D_DIRECT_S1_DIRECT, UBICOM32_INSN_SUB_1_D_IMMEDIATE_1_S1_DIRECT, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_INDEX_1_S1_DIRECT, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_OFFSET_1_S1_DIRECT ++ , UBICOM32_INSN_SUB_1_D_INDIRECT_1_S1_DIRECT, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_DIRECT, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_DIRECT, UBICOM32_INSN_SUB_1_D_DIRECT_S1_IMMEDIATE ++ , UBICOM32_INSN_SUB_1_D_IMMEDIATE_1_S1_IMMEDIATE, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_INDEX_1_S1_IMMEDIATE, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_OFFSET_1_S1_IMMEDIATE, UBICOM32_INSN_SUB_1_D_INDIRECT_1_S1_IMMEDIATE ++ , UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_IMMEDIATE, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_IMMEDIATE, UBICOM32_INSN_SUB_1_D_DIRECT_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_SUB_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_SUB_1_D_INDIRECT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_SUB_1_D_DIRECT_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_SUB_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_SUB_1_D_INDIRECT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_SUB_1_D_DIRECT_S1_INDIRECT_1, UBICOM32_INSN_SUB_1_D_IMMEDIATE_1_S1_INDIRECT_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_1 ++ , UBICOM32_INSN_SUB_1_D_INDIRECT_1_S1_INDIRECT_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_1, UBICOM32_INSN_SUB_1_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_SUB_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_SUB_1_D_INDIRECT_1_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_SUB_1_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_SUB_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_SUB_1_D_INDIRECT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_SUB_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_SUB_4_D_DIRECT_S1_DIRECT, UBICOM32_INSN_SUB_4_D_IMMEDIATE_4_S1_DIRECT, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_INDEX_4_S1_DIRECT ++ , UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_SUB_4_D_INDIRECT_4_S1_DIRECT, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT ++ , UBICOM32_INSN_SUB_4_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_SUB_4_D_IMMEDIATE_4_S1_IMMEDIATE, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE ++ , UBICOM32_INSN_SUB_4_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_SUB_4_D_DIRECT_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_SUB_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SUB_4_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_SUB_4_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SUB_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SUB_4_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_SUB_4_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_SUB_4_D_IMMEDIATE_4_S1_INDIRECT_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_SUB_4_D_INDIRECT_4_S1_INDIRECT_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_SUB_4_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SUB_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_SUB_4_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_SUB_4_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_SUB_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SUB_4_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SUB_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_SUB_2_D_DIRECT_S1_DIRECT, UBICOM32_INSN_SUB_2_D_IMMEDIATE_2_S1_DIRECT ++ , UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_INDEX_2_S1_DIRECT, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT, UBICOM32_INSN_SUB_2_D_INDIRECT_2_S1_DIRECT, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT ++ , UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_SUB_2_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_SUB_2_D_IMMEDIATE_2_S1_IMMEDIATE, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE ++ , UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE, UBICOM32_INSN_SUB_2_D_INDIRECT_2_S1_IMMEDIATE, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE ++ , UBICOM32_INSN_SUB_2_D_DIRECT_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_SUB_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_SUB_2_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_SUB_2_D_DIRECT_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_SUB_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SUB_2_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_SUB_2_D_DIRECT_S1_INDIRECT_2, UBICOM32_INSN_SUB_2_D_IMMEDIATE_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_2, UBICOM32_INSN_SUB_2_D_INDIRECT_2_S1_INDIRECT_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_SUB_2_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_SUB_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_SUB_2_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_SUB_2_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_SUB_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_SUB_2_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_SUB_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_ADD_1_D_DIRECT_S1_DIRECT ++ , UBICOM32_INSN_ADD_1_D_IMMEDIATE_1_S1_DIRECT, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_INDEX_1_S1_DIRECT, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_OFFSET_1_S1_DIRECT, UBICOM32_INSN_ADD_1_D_INDIRECT_1_S1_DIRECT ++ , UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_DIRECT, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_DIRECT, UBICOM32_INSN_ADD_1_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_ADD_1_D_IMMEDIATE_1_S1_IMMEDIATE ++ , UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_INDEX_1_S1_IMMEDIATE, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_OFFSET_1_S1_IMMEDIATE, UBICOM32_INSN_ADD_1_D_INDIRECT_1_S1_IMMEDIATE, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_IMMEDIATE ++ , UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_IMMEDIATE, UBICOM32_INSN_ADD_1_D_DIRECT_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_ADD_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_ADD_1_D_INDIRECT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_ADD_1_D_DIRECT_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_ADD_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_ADD_1_D_INDIRECT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_ADD_1_D_DIRECT_S1_INDIRECT_1 ++ , UBICOM32_INSN_ADD_1_D_IMMEDIATE_1_S1_INDIRECT_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_1, UBICOM32_INSN_ADD_1_D_INDIRECT_1_S1_INDIRECT_1 ++ , UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_1, UBICOM32_INSN_ADD_1_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_ADD_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_ADD_1_D_INDIRECT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_ADD_1_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_ADD_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_ADD_1_D_INDIRECT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_ADD_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_ADD_4_D_DIRECT_S1_DIRECT, UBICOM32_INSN_ADD_4_D_IMMEDIATE_4_S1_DIRECT, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT ++ , UBICOM32_INSN_ADD_4_D_INDIRECT_4_S1_DIRECT, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_ADD_4_D_DIRECT_S1_IMMEDIATE ++ , UBICOM32_INSN_ADD_4_D_IMMEDIATE_4_S1_IMMEDIATE, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_ADD_4_D_INDIRECT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_ADD_4_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_ADD_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_ADD_4_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_ADD_4_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_ADD_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_ADD_4_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_ADD_4_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_ADD_4_D_IMMEDIATE_4_S1_INDIRECT_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_ADD_4_D_INDIRECT_4_S1_INDIRECT_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_ADD_4_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_ADD_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_ADD_4_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_ADD_4_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_ADD_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_ADD_4_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_ADD_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_ADD_2_D_DIRECT_S1_DIRECT, UBICOM32_INSN_ADD_2_D_IMMEDIATE_2_S1_DIRECT, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_INDEX_2_S1_DIRECT ++ , UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT, UBICOM32_INSN_ADD_2_D_INDIRECT_2_S1_DIRECT, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT ++ , UBICOM32_INSN_ADD_2_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_ADD_2_D_IMMEDIATE_2_S1_IMMEDIATE, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE ++ , UBICOM32_INSN_ADD_2_D_INDIRECT_2_S1_IMMEDIATE, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_ADD_2_D_DIRECT_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_ADD_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_ADD_2_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_ADD_2_D_DIRECT_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_ADD_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_ADD_2_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_ADD_2_D_DIRECT_S1_INDIRECT_2, UBICOM32_INSN_ADD_2_D_IMMEDIATE_2_S1_INDIRECT_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_2, UBICOM32_INSN_ADD_2_D_INDIRECT_2_S1_INDIRECT_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_ADD_2_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_ADD_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_ADD_2_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_ADD_2_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_ADD_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_ADD_2_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_ADD_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_NOT_4_D_DIRECT_S1_DIRECT, UBICOM32_INSN_NOT_4_D_IMMEDIATE_4_S1_DIRECT ++ , UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_NOT_4_D_INDIRECT_4_S1_DIRECT, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT ++ , UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_NOT_4_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_NOT_4_D_IMMEDIATE_4_S1_IMMEDIATE, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE ++ , UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_NOT_4_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_NOT_4_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_NOT_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_NOT_4_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_NOT_4_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_NOT_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_NOT_4_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_NOT_4_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_NOT_4_D_IMMEDIATE_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_NOT_4_D_INDIRECT_4_S1_INDIRECT_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_NOT_4_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_NOT_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_NOT_4_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_NOT_4_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_NOT_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_NOT_4_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_NOT_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_NOT_2_D_DIRECT_S1_DIRECT ++ , UBICOM32_INSN_NOT_2_D_IMMEDIATE_2_S1_DIRECT, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_INDEX_2_S1_DIRECT, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT, UBICOM32_INSN_NOT_2_D_INDIRECT_2_S1_DIRECT ++ , UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_NOT_2_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_NOT_2_D_IMMEDIATE_2_S1_IMMEDIATE ++ , UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE, UBICOM32_INSN_NOT_2_D_INDIRECT_2_S1_IMMEDIATE, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE ++ , UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_NOT_2_D_DIRECT_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_NOT_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_NOT_2_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_NOT_2_D_DIRECT_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_NOT_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_NOT_2_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_NOT_2_D_DIRECT_S1_INDIRECT_2 ++ , UBICOM32_INSN_NOT_2_D_IMMEDIATE_2_S1_INDIRECT_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_2, UBICOM32_INSN_NOT_2_D_INDIRECT_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_NOT_2_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_NOT_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_NOT_2_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_NOT_2_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_NOT_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_NOT_2_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_NOT_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_XOR_1_D_DIRECT_S1_DIRECT, UBICOM32_INSN_XOR_1_D_IMMEDIATE_1_S1_DIRECT, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_INDEX_1_S1_DIRECT, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_OFFSET_1_S1_DIRECT ++ , UBICOM32_INSN_XOR_1_D_INDIRECT_1_S1_DIRECT, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_DIRECT, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_DIRECT, UBICOM32_INSN_XOR_1_D_DIRECT_S1_IMMEDIATE ++ , UBICOM32_INSN_XOR_1_D_IMMEDIATE_1_S1_IMMEDIATE, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_INDEX_1_S1_IMMEDIATE, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_OFFSET_1_S1_IMMEDIATE, UBICOM32_INSN_XOR_1_D_INDIRECT_1_S1_IMMEDIATE ++ , UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_IMMEDIATE, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_IMMEDIATE, UBICOM32_INSN_XOR_1_D_DIRECT_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_XOR_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_XOR_1_D_INDIRECT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_XOR_1_D_DIRECT_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_XOR_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_XOR_1_D_INDIRECT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_XOR_1_D_DIRECT_S1_INDIRECT_1, UBICOM32_INSN_XOR_1_D_IMMEDIATE_1_S1_INDIRECT_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_1 ++ , UBICOM32_INSN_XOR_1_D_INDIRECT_1_S1_INDIRECT_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_1, UBICOM32_INSN_XOR_1_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_XOR_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_XOR_1_D_INDIRECT_1_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_XOR_1_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_XOR_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_XOR_1_D_INDIRECT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_XOR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_OR_1_D_DIRECT_S1_DIRECT, UBICOM32_INSN_OR_1_D_IMMEDIATE_1_S1_DIRECT, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_INDEX_1_S1_DIRECT ++ , UBICOM32_INSN_OR_1_D_INDIRECT_WITH_OFFSET_1_S1_DIRECT, UBICOM32_INSN_OR_1_D_INDIRECT_1_S1_DIRECT, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_DIRECT, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_DIRECT ++ , UBICOM32_INSN_OR_1_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_OR_1_D_IMMEDIATE_1_S1_IMMEDIATE, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_INDEX_1_S1_IMMEDIATE, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_OFFSET_1_S1_IMMEDIATE ++ , UBICOM32_INSN_OR_1_D_INDIRECT_1_S1_IMMEDIATE, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_IMMEDIATE, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_IMMEDIATE, UBICOM32_INSN_OR_1_D_DIRECT_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_OR_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_OR_1_D_INDIRECT_1_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_OR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_OR_1_D_DIRECT_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_OR_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_OR_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_OR_1_D_INDIRECT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_OR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_OR_1_D_DIRECT_S1_INDIRECT_1, UBICOM32_INSN_OR_1_D_IMMEDIATE_1_S1_INDIRECT_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_1 ++ , UBICOM32_INSN_OR_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_1, UBICOM32_INSN_OR_1_D_INDIRECT_1_S1_INDIRECT_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_1 ++ , UBICOM32_INSN_OR_1_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_OR_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_OR_1_D_INDIRECT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_OR_1_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_OR_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_OR_1_D_INDIRECT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_OR_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_OR_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_AND_1_D_DIRECT_S1_DIRECT, UBICOM32_INSN_AND_1_D_IMMEDIATE_1_S1_DIRECT ++ , UBICOM32_INSN_AND_1_D_INDIRECT_WITH_INDEX_1_S1_DIRECT, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_OFFSET_1_S1_DIRECT, UBICOM32_INSN_AND_1_D_INDIRECT_1_S1_DIRECT, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_DIRECT ++ , UBICOM32_INSN_AND_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_DIRECT, UBICOM32_INSN_AND_1_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_AND_1_D_IMMEDIATE_1_S1_IMMEDIATE, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_INDEX_1_S1_IMMEDIATE ++ , UBICOM32_INSN_AND_1_D_INDIRECT_WITH_OFFSET_1_S1_IMMEDIATE, UBICOM32_INSN_AND_1_D_INDIRECT_1_S1_IMMEDIATE, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_IMMEDIATE, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_IMMEDIATE ++ , UBICOM32_INSN_AND_1_D_DIRECT_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_AND_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_INDEX_1 ++ , UBICOM32_INSN_AND_1_D_INDIRECT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_INDEX_1, UBICOM32_INSN_AND_1_D_DIRECT_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_AND_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_AND_1_D_INDIRECT_1_S1_INDIRECT_WITH_OFFSET_1 ++ , UBICOM32_INSN_AND_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_OFFSET_1, UBICOM32_INSN_AND_1_D_DIRECT_S1_INDIRECT_1, UBICOM32_INSN_AND_1_D_IMMEDIATE_1_S1_INDIRECT_1 ++ , UBICOM32_INSN_AND_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_1, UBICOM32_INSN_AND_1_D_INDIRECT_1_S1_INDIRECT_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_1 ++ , UBICOM32_INSN_AND_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_1, UBICOM32_INSN_AND_1_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_AND_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_AND_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_AND_1_D_INDIRECT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_POST_INCREMENT_1 ++ , UBICOM32_INSN_AND_1_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_AND_1_D_IMMEDIATE_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_INDEX_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_OFFSET_1_S1_INDIRECT_WITH_PRE_INCREMENT_1 ++ , UBICOM32_INSN_AND_1_D_INDIRECT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_POST_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_AND_1_D_INDIRECT_WITH_PRE_INCREMENT_1_S1_INDIRECT_WITH_PRE_INCREMENT_1, UBICOM32_INSN_XOR_4_D_DIRECT_S1_DIRECT ++ , UBICOM32_INSN_XOR_4_D_IMMEDIATE_4_S1_DIRECT, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_XOR_4_D_INDIRECT_4_S1_DIRECT ++ , UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_XOR_4_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_XOR_4_D_IMMEDIATE_4_S1_IMMEDIATE ++ , UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_XOR_4_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_XOR_4_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_XOR_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_XOR_4_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_XOR_4_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_XOR_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_XOR_4_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_XOR_4_D_DIRECT_S1_INDIRECT_4 ++ , UBICOM32_INSN_XOR_4_D_IMMEDIATE_4_S1_INDIRECT_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_XOR_4_D_INDIRECT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_XOR_4_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_XOR_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_XOR_4_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_XOR_4_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_XOR_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_XOR_4_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_XOR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_XOR_2_D_DIRECT_S1_DIRECT, UBICOM32_INSN_XOR_2_D_IMMEDIATE_2_S1_DIRECT, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_INDEX_2_S1_DIRECT, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT ++ , UBICOM32_INSN_XOR_2_D_INDIRECT_2_S1_DIRECT, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_XOR_2_D_DIRECT_S1_IMMEDIATE ++ , UBICOM32_INSN_XOR_2_D_IMMEDIATE_2_S1_IMMEDIATE, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE, UBICOM32_INSN_XOR_2_D_INDIRECT_2_S1_IMMEDIATE ++ , UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_XOR_2_D_DIRECT_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_XOR_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_XOR_2_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_XOR_2_D_DIRECT_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_XOR_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_XOR_2_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_XOR_2_D_DIRECT_S1_INDIRECT_2, UBICOM32_INSN_XOR_2_D_IMMEDIATE_2_S1_INDIRECT_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_XOR_2_D_INDIRECT_2_S1_INDIRECT_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_XOR_2_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_XOR_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_XOR_2_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_XOR_2_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_XOR_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_XOR_2_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_XOR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_OR_4_D_DIRECT_S1_DIRECT, UBICOM32_INSN_OR_4_D_IMMEDIATE_4_S1_DIRECT, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_INDEX_4_S1_DIRECT ++ , UBICOM32_INSN_OR_4_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_OR_4_D_INDIRECT_4_S1_DIRECT, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT ++ , UBICOM32_INSN_OR_4_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_OR_4_D_IMMEDIATE_4_S1_IMMEDIATE, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE ++ , UBICOM32_INSN_OR_4_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_OR_4_D_DIRECT_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_OR_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_OR_4_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_OR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_OR_4_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_OR_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_OR_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_OR_4_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_OR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_OR_4_D_DIRECT_S1_INDIRECT_4, UBICOM32_INSN_OR_4_D_IMMEDIATE_4_S1_INDIRECT_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_OR_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_OR_4_D_INDIRECT_4_S1_INDIRECT_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_OR_4_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_OR_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_OR_4_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_OR_4_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_OR_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_OR_4_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_OR_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_OR_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_OR_2_D_DIRECT_S1_DIRECT, UBICOM32_INSN_OR_2_D_IMMEDIATE_2_S1_DIRECT ++ , UBICOM32_INSN_OR_2_D_INDIRECT_WITH_INDEX_2_S1_DIRECT, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT, UBICOM32_INSN_OR_2_D_INDIRECT_2_S1_DIRECT, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT ++ , UBICOM32_INSN_OR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_OR_2_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_OR_2_D_IMMEDIATE_2_S1_IMMEDIATE, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE ++ , UBICOM32_INSN_OR_2_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE, UBICOM32_INSN_OR_2_D_INDIRECT_2_S1_IMMEDIATE, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE ++ , UBICOM32_INSN_OR_2_D_DIRECT_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_OR_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_OR_2_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_OR_2_D_DIRECT_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_OR_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_OR_2_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_OR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_OR_2_D_DIRECT_S1_INDIRECT_2, UBICOM32_INSN_OR_2_D_IMMEDIATE_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_OR_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_2, UBICOM32_INSN_OR_2_D_INDIRECT_2_S1_INDIRECT_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_OR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_OR_2_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_OR_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_OR_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_OR_2_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_OR_2_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_OR_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_OR_2_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_OR_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_AND_4_D_DIRECT_S1_DIRECT ++ , UBICOM32_INSN_AND_4_D_IMMEDIATE_4_S1_DIRECT, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_INDEX_4_S1_DIRECT, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_OFFSET_4_S1_DIRECT, UBICOM32_INSN_AND_4_D_INDIRECT_4_S1_DIRECT ++ , UBICOM32_INSN_AND_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_DIRECT, UBICOM32_INSN_AND_4_D_DIRECT_S1_IMMEDIATE, UBICOM32_INSN_AND_4_D_IMMEDIATE_4_S1_IMMEDIATE ++ , UBICOM32_INSN_AND_4_D_INDIRECT_WITH_INDEX_4_S1_IMMEDIATE, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_OFFSET_4_S1_IMMEDIATE, UBICOM32_INSN_AND_4_D_INDIRECT_4_S1_IMMEDIATE, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_IMMEDIATE ++ , UBICOM32_INSN_AND_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_IMMEDIATE, UBICOM32_INSN_AND_4_D_DIRECT_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_AND_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_AND_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_AND_4_D_INDIRECT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_INDEX_4 ++ , UBICOM32_INSN_AND_4_D_DIRECT_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_AND_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_OFFSET_4 ++ , UBICOM32_INSN_AND_4_D_INDIRECT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_OFFSET_4, UBICOM32_INSN_AND_4_D_DIRECT_S1_INDIRECT_4 ++ , UBICOM32_INSN_AND_4_D_IMMEDIATE_4_S1_INDIRECT_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_4, UBICOM32_INSN_AND_4_D_INDIRECT_4_S1_INDIRECT_4 ++ , UBICOM32_INSN_AND_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_4, UBICOM32_INSN_AND_4_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_AND_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_AND_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_AND_4_D_INDIRECT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4 ++ , UBICOM32_INSN_AND_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_POST_INCREMENT_4, UBICOM32_INSN_AND_4_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_AND_4_D_IMMEDIATE_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_INDEX_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_AND_4_D_INDIRECT_WITH_OFFSET_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_AND_4_D_INDIRECT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_POST_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4, UBICOM32_INSN_AND_4_D_INDIRECT_WITH_PRE_INCREMENT_4_S1_INDIRECT_WITH_PRE_INCREMENT_4 ++ , UBICOM32_INSN_AND_2_D_DIRECT_S1_DIRECT, UBICOM32_INSN_AND_2_D_IMMEDIATE_2_S1_DIRECT, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_INDEX_2_S1_DIRECT, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_OFFSET_2_S1_DIRECT ++ , UBICOM32_INSN_AND_2_D_INDIRECT_2_S1_DIRECT, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_DIRECT, UBICOM32_INSN_AND_2_D_DIRECT_S1_IMMEDIATE ++ , UBICOM32_INSN_AND_2_D_IMMEDIATE_2_S1_IMMEDIATE, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_INDEX_2_S1_IMMEDIATE, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_OFFSET_2_S1_IMMEDIATE, UBICOM32_INSN_AND_2_D_INDIRECT_2_S1_IMMEDIATE ++ , UBICOM32_INSN_AND_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_IMMEDIATE, UBICOM32_INSN_AND_2_D_DIRECT_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_AND_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_AND_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_AND_2_D_INDIRECT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2 ++ , UBICOM32_INSN_AND_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_INDEX_2, UBICOM32_INSN_AND_2_D_DIRECT_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_AND_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_AND_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_AND_2_D_INDIRECT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_OFFSET_2 ++ , UBICOM32_INSN_AND_2_D_DIRECT_S1_INDIRECT_2, UBICOM32_INSN_AND_2_D_IMMEDIATE_2_S1_INDIRECT_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_2 ++ , UBICOM32_INSN_AND_2_D_INDIRECT_2_S1_INDIRECT_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_2, UBICOM32_INSN_AND_2_D_DIRECT_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_AND_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_AND_2_D_INDIRECT_2_S1_INDIRECT_WITH_POST_INCREMENT_2 ++ , UBICOM32_INSN_AND_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_POST_INCREMENT_2, UBICOM32_INSN_AND_2_D_DIRECT_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_AND_2_D_IMMEDIATE_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_AND_2_D_INDIRECT_WITH_INDEX_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_OFFSET_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_AND_2_D_INDIRECT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_AND_2_D_INDIRECT_WITH_POST_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2 ++ , UBICOM32_INSN_AND_2_D_INDIRECT_WITH_PRE_INCREMENT_2_S1_INDIRECT_WITH_PRE_INCREMENT_2, UBICOM32_INSN_MOVEAI, UBICOM32_INSN_NOP_INSN, UBICOM32_INSN_JMPCC ++ , UBICOM32_INSN_CALL, UBICOM32_INSN_CALLI, UBICOM32_INSN_SUSPEND, UBICOM32_INSN_DSP_CLRACC ++ , UBICOM32_INSN_UNUSED_00_11, UBICOM32_INSN_UNUSED_00_13, UBICOM32_INSN_UNUSED_00_14, UBICOM32_INSN_UNUSED_00_16 ++ , UBICOM32_INSN_UNUSED_02_04, UBICOM32_INSN_UNUSED_02_07, UBICOM32_INSN_UNUSED_02_0D, UBICOM32_INSN_UNUSED_02_0E ++ , UBICOM32_INSN_UNUSED_02_0F, UBICOM32_INSN_UNUSED_02_17, UBICOM32_INSN_UNUSED_02_19, UBICOM32_INSN_UNUSED_02_1B ++ , UBICOM32_INSN_UNUSED_02_1D, UBICOM32_INSN_UNUSED_01, UBICOM32_INSN_UNUSED_03, UBICOM32_INSN_UNUSED_07 ++ , UBICOM32_INSN_UNUSED_17, UBICOM32_INSN_UNUSED_1D, UBICOM32_INSN_UNUSED_1F, UBICOM32_INSN_UNUSED_DSP_06 ++ , UBICOM32_INSN_UNUSED_DSP_0B, UBICOM32_INSN_UNUSED_DSP_0C, UBICOM32_INSN_UNUSED_DSP_0D, UBICOM32_INSN_UNUSED_DSP_0E ++ , UBICOM32_INSN_UNUSED_DSP_0F, UBICOM32_INSN_UNUSED_DSP_14, UBICOM32_INSN_UNUSED_DSP_15, UBICOM32_INSN_UNUSED_DSP_16 ++ , UBICOM32_INSN_UNUSED_DSP_17, UBICOM32_INSN_UNUSED_DSP_18, UBICOM32_INSN_UNUSED_DSP_19, UBICOM32_INSN_UNUSED_DSP_1A ++ , UBICOM32_INSN_UNUSED_DSP_1B, UBICOM32_INSN_UNUSED_DSP_1C, UBICOM32_INSN_UNUSED_DSP_1D, UBICOM32_INSN_UNUSED_DSP_1E ++ , UBICOM32_INSN_UNUSED_DSP_1F ++} CGEN_INSN_TYPE; ++ ++/* Index of `invalid' insn place holder. */ ++#define CGEN_INSN_INVALID UBICOM32_INSN_INVALID ++ ++/* Total number of insns in table. */ ++#define MAX_INSNS ((int) UBICOM32_INSN_UNUSED_DSP_1F + 1) ++ ++/* This struct records data prior to insertion or after extraction. */ ++struct cgen_fields ++{ ++ int length; ++ long f_nil; ++ long f_anyof; ++ long f_d; ++ long f_d_bit10; ++ long f_d_type; ++ long f_d_r; ++ long f_d_M; ++ long f_d_i4_1; ++ long f_d_i4_2; ++ long f_d_i4_4; ++ long f_d_An; ++ long f_d_direct; ++ long f_d_imm8; ++ long f_d_imm7_t; ++ long f_d_imm7_b; ++ long f_d_imm7_1; ++ long f_d_imm7_2; ++ long f_d_imm7_4; ++ long f_s1; ++ long f_s1_bit10; ++ long f_s1_type; ++ long f_s1_r; ++ long f_s1_M; ++ long f_s1_i4_1; ++ long f_s1_i4_2; ++ long f_s1_i4_4; ++ long f_s1_An; ++ long f_s1_direct; ++ long f_s1_imm8; ++ long f_s1_imm7_t; ++ long f_s1_imm7_b; ++ long f_s1_imm7_1; ++ long f_s1_imm7_2; ++ long f_s1_imm7_4; ++ long f_op1; ++ long f_op2; ++ long f_bit26; ++ long f_opext; ++ long f_cond; ++ long f_imm16_1; ++ long f_imm16_2; ++ long f_o21; ++ long f_o23_21; ++ long f_o20_0; ++ long f_o24; ++ long f_imm23_21; ++ long f_imm24; ++ long f_o15_13; ++ long f_o12_8; ++ long f_o7_5; ++ long f_o4_0; ++ long f_o16; ++ long f_An; ++ long f_Am; ++ long f_Dn; ++ long f_bit5; ++ long f_P; ++ long f_C; ++ long f_int; ++ long f_dsp_C; ++ long f_dsp_T; ++ long f_dsp_S2_sel; ++ long f_dsp_R; ++ long f_dsp_destA; ++ long f_dsp_b15; ++ long f_dsp_S2; ++ long f_dsp_J; ++ long f_s2; ++ long f_b15; ++}; ++ ++#define CGEN_INIT_PARSE(od) \ ++{\ ++} ++#define CGEN_INIT_INSERT(od) \ ++{\ ++} ++#define CGEN_INIT_EXTRACT(od) \ ++{\ ++} ++#define CGEN_INIT_PRINT(od) \ ++{\ ++} ++ ++ ++#endif /* UBICOM32_OPC_H */ +--- /dev/null ++++ b/ubicom32.exp +@@ -0,0 +1,45 @@ ++# Expect control file for DEJAGNU test system and ubicom32 ++# ++ ++# Needed for isnative. ++load_lib "framework.exp" ++ ++# Turn off plum-hall testing ++# ++set PLUMHALL no ++set PLUMHALL_99b no ++ ++# And Perennial too ++set PERENNIAL_C no ++set PERENNIAL_CLASSIC_C yes ++ ++set UNDERSCORES yes ++ ++if ![info exists tool] { ++ set run_multiple_targets 0; ++} elseif { $tool == "g++" || $tool == "gcc" || $tool == "gdb"} { ++ set run_multiple_targets 1; ++} else { ++ set run_multiple_targets 0; ++} ++ ++verbose "Global Config FIle: target_triplet is $target_triplet" 2 ++global target_list ++case "$target_triplet" in { ++ { "ubicom32-*" } { ++ set target_list "ubicom32-sid" ++ } ++ ++ { "ip3k-*" } { ++ set target_list "ip3k-sid" ++ } ++ ++ default { ++ set target_list { "unix" } ++ } ++} ++ ++if { ! $run_multiple_targets } { ++ set target_list [lindex $target_list 0]; ++} ++ diff --git a/toolchain/gcc/Config.in b/toolchain/gcc/Config.in index 4148d66197..e034c3860f 100644 --- a/toolchain/gcc/Config.in +++ b/toolchain/gcc/Config.in @@ -9,6 +9,7 @@ choice default GCC_VERSION_4_3_3 if powerpc64 default GCC_VERSION_4_3_3 if TARGET_etrax default GCC_VERSION_4_3_3 if TARGET_coldfire + default GCC_VERSION_4_4_0 if ubicom32 default GCC_VERSION_4_1_2 help Select the version of gcc you wish to use. diff --git a/toolchain/gcc/Config.version b/toolchain/gcc/Config.version index 8bd77add55..c99b14c27e 100644 --- a/toolchain/gcc/Config.version +++ b/toolchain/gcc/Config.version @@ -55,4 +55,7 @@ if !TOOLCHAINOPTS default y if powerpc64 default y if TARGET_etrax default y if TARGET_coldfire + + config GCC_VERSION_4_4_0 + default y if ubicom32 endif diff --git a/toolchain/gcc/patches/4.4.0/600-ubicom_support.patch b/toolchain/gcc/patches/4.4.0/600-ubicom_support.patch new file mode 100644 index 0000000000..b788c70f9c --- /dev/null +++ b/toolchain/gcc/patches/4.4.0/600-ubicom_support.patch @@ -0,0 +1,9386 @@ +--- a/config.sub ++++ b/config.sub +@@ -283,6 +283,7 @@ case $basic_machine in + | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ + | spu | strongarm \ + | tahoe | thumb | tic4x | tic80 | tron \ ++ | ubicom32 \ + | v850 | v850e \ + | ubicom32 \ + | we32k \ +@@ -367,6 +368,7 @@ case $basic_machine in + | tahoe-* | thumb-* \ + | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ + | tron-* \ ++ | ubicom32-* \ + | v850-* | v850e-* | vax-* \ + | ubicom32-* \ + | we32k-* \ +--- a/configure ++++ b/configure +@@ -2688,6 +2688,9 @@ case "${target}" in + ip2k-*-*) + noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}" + ;; ++ ubicom32-*-*) ++ noconfigdirs="$noconfigdirs target-libffi" ++ ;; + *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu) + noconfigdirs="$noconfigdirs target-newlib target-libgloss" + ;; +--- /dev/null ++++ b/gcc/config/ubicom32/constraints.md +@@ -0,0 +1,149 @@ ++; Constraint definitions for Ubicom32 ++ ++; Copyright (C) 2009 Free Software Foundation, Inc. ++; Contributed by Ubicom, Inc. ++ ++; This file is part of GCC. ++ ++; GCC is free software; you can redistribute it and/or modify it ++; under the terms of the GNU General Public License as published ++; by the Free Software Foundation; either version 3, or (at your ++; option) any later version. ++ ++; GCC 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 GCC; see the file COPYING3. If not see ++; . ++ ++(define_register_constraint "a" "ALL_ADDRESS_REGS" ++ "An An register.") ++ ++(define_register_constraint "d" "DATA_REGS" ++ "A Dn register.") ++ ++(define_register_constraint "h" "ACC_REGS" ++ "An accumulator register.") ++ ++(define_register_constraint "l" "ACC_LO_REGS" ++ "An accn_lo register.") ++ ++(define_register_constraint "Z" "FDPIC_REG" ++ "The FD-PIC GOT pointer: A0.") ++ ++(define_constraint "I" ++ "An 8-bit signed constant value." ++ (and (match_code "const_int") ++ (match_test "(ival >= -128) && (ival <= 127)"))) ++ ++(define_constraint "Q" ++ "An 8-bit signed constant value represented as unsigned." ++ (and (match_code "const_int") ++ (match_test "(ival >= 0x00) && (ival <= 0xff)"))) ++ ++(define_constraint "R" ++ "An 8-bit signed constant value represented as unsigned." ++ (and (match_code "const_int") ++ (match_test "((ival >= 0x0000) && (ival <= 0x007f)) || ((ival >= 0xff80) && (ival <= 0xffff))"))) ++ ++(define_constraint "J" ++ "A 7-bit unsigned constant value." ++ (and (match_code "const_int") ++ (match_test "(ival >= 0) && (ival <= 127)"))) ++ ++(define_constraint "K" ++ "A 7-bit unsigned constant value shifted << 1." ++ (and (match_code "const_int") ++ (match_test "(ival >= 0) && (ival <= 254) && ((ival & 1) == 0)"))) ++ ++(define_constraint "L" ++ "A 7-bit unsigned constant value shifted << 2." ++ (and (match_code "const_int") ++ (match_test "(ival >= 0) && (ival <= 508) && ((ival & 3) == 0)"))) ++ ++(define_constraint "M" ++ "A 5-bit unsigned constant value." ++ (and (match_code "const_int") ++ (match_test "(ival >= 0) && (ival <= 31)"))) ++ ++(define_constraint "N" ++ "A signed 16 bit constant value." ++ (and (match_code "const_int") ++ (match_test "(ival >= -32768) && (ival <= 32767)"))) ++ ++(define_constraint "O" ++ "An exact bitmask of contiguous 1 bits starting at bit 0." ++ (and (match_code "const_int") ++ (match_test "exact_log2 (ival + 1) != -1"))) ++ ++(define_constraint "P" ++ "A 7-bit negative constant value shifted << 2." ++ (and (match_code "const_int") ++ (match_test "(ival >= -504) && (ival <= 0) && ((ival & 3) == 0)"))) ++ ++(define_constraint "S" ++ "A symbolic reference." ++ (match_code "symbol_ref")) ++ ++(define_constraint "Y" ++ "An FD-PIC symbolic reference." ++ (and (match_test "TARGET_FDPIC") ++ (match_test "GET_CODE (op) == UNSPEC") ++ (ior (match_test "XINT (op, 1) == UNSPEC_FDPIC_GOT") ++ (match_test "XINT (op, 1) == UNSPEC_FDPIC_GOT_FUNCDESC")))) ++ ++(define_memory_constraint "T1" ++ "A memory operand that can be used for .1 instruction." ++ (and (match_test "memory_operand (op, GET_MODE(op))") ++ (match_test "GET_MODE (op) == QImode"))) ++ ++(define_memory_constraint "T2" ++ "A memory operand that can be used for .2 instruction." ++ (and (match_test "memory_operand (op, GET_MODE(op))") ++ (match_test "GET_MODE (op) == HImode"))) ++ ++(define_memory_constraint "T4" ++ "A memory operand that can be used for .4 instruction." ++ (and (match_test "memory_operand (op, GET_MODE(op))") ++ (ior (match_test "GET_MODE (op) == SImode") ++ (match_test "GET_MODE (op) == DImode") ++ (match_test "GET_MODE (op) == SFmode")))) ++ ++(define_memory_constraint "U1" ++ "An offsettable memory operand that can be used for .1 instruction." ++ (and (match_test "memory_operand (op, GET_MODE(op))") ++ (match_test "GET_MODE (op) == QImode") ++ (match_test "GET_CODE (XEXP (op, 0)) != POST_INC") ++ (match_test "GET_CODE (XEXP (op, 0)) != PRE_INC") ++ (match_test "GET_CODE (XEXP (op, 0)) != POST_DEC") ++ (match_test "GET_CODE (XEXP (op, 0)) != PRE_DEC") ++ (match_test "GET_CODE (XEXP (op, 0)) != POST_MODIFY") ++ (match_test "GET_CODE (XEXP (op, 0)) != PRE_MODIFY"))) ++ ++(define_memory_constraint "U2" ++ "An offsettable memory operand that can be used for .2 instruction." ++ (and (match_test "memory_operand (op, GET_MODE(op))") ++ (match_test "GET_MODE (op) == HImode") ++ (match_test "GET_CODE (XEXP (op, 0)) != POST_INC") ++ (match_test "GET_CODE (XEXP (op, 0)) != PRE_INC") ++ (match_test "GET_CODE (XEXP (op, 0)) != POST_DEC") ++ (match_test "GET_CODE (XEXP (op, 0)) != PRE_DEC") ++ (match_test "GET_CODE (XEXP (op, 0)) != POST_MODIFY") ++ (match_test "GET_CODE (XEXP (op, 0)) != PRE_MODIFY"))) ++ ++(define_memory_constraint "U4" ++ "An offsettable memory operand that can be used for .4 instruction." ++ (and (match_test "memory_operand (op, GET_MODE(op))") ++ (ior (match_test "GET_MODE (op) == SImode") ++ (match_test "GET_MODE (op) == DImode") ++ (match_test "GET_MODE (op) == SFmode")) ++ (match_test "GET_CODE (XEXP (op, 0)) != POST_INC") ++ (match_test "GET_CODE (XEXP (op, 0)) != PRE_INC") ++ (match_test "GET_CODE (XEXP (op, 0)) != POST_DEC") ++ (match_test "GET_CODE (XEXP (op, 0)) != PRE_DEC") ++ (match_test "GET_CODE (XEXP (op, 0)) != POST_MODIFY") ++ (match_test "GET_CODE (XEXP (op, 0)) != PRE_MODIFY"))) ++ +--- /dev/null ++++ b/gcc/config/ubicom32/crti.S +@@ -0,0 +1,54 @@ ++/* Specialized code needed to support construction and destruction of ++ file-scope objects in C++ and Java code, and to support exception handling. ++ Copyright (C) 1999 Free Software Foundation, Inc. ++ Contributed by Charles-Antoine Gauthier (charles.gauthier@iit.nrc.ca). ++ ++This file is part of GCC. ++ ++GCC 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. ++ ++GCC 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 GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++/* As a special exception, if you link this library with files ++ compiled with GCC to produce an executable, this does not cause ++ the resulting executable to be covered by the GNU General Public License. ++ This exception does not however invalidate any other reasons why ++ the executable file might be covered by the GNU General Public License. */ ++ ++/* ++ * This file just supplies function prologues for the .init and .fini ++ * sections. It is linked in before crtbegin.o. ++ */ ++ .file "crti.o" ++ .ident "GNU C crti.o" ++ ++ .section .init ++ .align 2 ++ .globl _init ++ .type _init, @function ++_init: ++ move.4 -4(sp)++, a5 ++#ifdef __UBICOM32_FDPIC__ ++ move.4 -4(sp)++, a0 ++#endif ++ ++ .section .fini ++ .align 2 ++ .globl _fini ++ .type _fini, @function ++_fini: ++ move.4 -4(sp)++, a5 ++#ifdef __UBICOM32_FDPIC__ ++ move.4 -4(sp)++, a0 ++#endif +--- /dev/null ++++ b/gcc/config/ubicom32/crtn.S +@@ -0,0 +1,47 @@ ++/* Specialized code needed to support construction and destruction of ++ file-scope objects in C++ and Java code, and to support exception handling. ++ Copyright (C) 1999 Free Software Foundation, Inc. ++ Contributed by Charles-Antoine Gauthier (charles.gauthier@iit.nrc.ca). ++ ++This file is part of GCC. ++ ++GCC 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. ++ ++GCC 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 GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++/* As a special exception, if you link this library with files ++ compiled with GCC to produce an executable, this does not cause ++ the resulting executable to be covered by the GNU General Public License. ++ This exception does not however invalidate any other reasons why ++ the executable file might be covered by the GNU General Public License. */ ++ ++/* ++ * This file supplies function epilogues for the .init and .fini sections. ++ * It is linked in after all other files. ++ */ ++ ++ .file "crtn.o" ++ .ident "GNU C crtn.o" ++ ++ .section .init ++#ifdef __UBICOM32_FDPIC__ ++ move.4 a0, (sp)4++ ++#endif ++ ret (sp)4++ ++ ++ .section .fini ++#ifdef __UBICOM32_FDPIC__ ++ move.4 a0, (sp)4++ ++#endif ++ ret (sp)4++ +--- /dev/null ++++ b/gcc/config/ubicom32/elf.h +@@ -0,0 +1,29 @@ ++#undef STARTFILE_SPEC ++#define STARTFILE_SPEC "\ ++%{msim:%{!shared:crt0%O%s}} \ ++crti%O%s crtbegin%O%s" ++ ++#undef ENDFILE_SPEC ++#define ENDFILE_SPEC "crtend%O%s crtn%O%s" ++ ++#ifdef __UBICOM32_FDPIC__ ++#define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC) \ ++ asm (SECTION_OP); \ ++ asm ("move.4 a0, 0(sp);\n\t" \ ++ "call a5," USER_LABEL_PREFIX #FUNC ";"); \ ++ asm (TEXT_SECTION_ASM_OP); ++#endif ++ ++#undef SUBTARGET_DRIVER_SELF_SPECS ++#define SUBTARGET_DRIVER_SELF_SPECS \ ++ "%{mfdpic:-msim} " ++ ++#define NO_IMPLICIT_EXTERN_C ++ ++/* ++ * We need this to compile crtbegin/crtend. This should really be picked ++ * up from elfos.h but at the moment including elfos.h causes other more ++ * serous linker issues. ++ */ ++#define INIT_SECTION_ASM_OP "\t.section\t.init" ++#define FINI_SECTION_ASM_OP "\t.section\t.fini" +--- /dev/null ++++ b/gcc/config/ubicom32/linux.h +@@ -0,0 +1,80 @@ ++/* Definitions of target machine for Ubicom32-uclinux ++ ++ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, ++ 2009 Free Software Foundation, Inc. ++ Contributed by Ubicom, Inc. ++ ++ This file is part of GCC. ++ ++ GCC is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published ++ by the Free Software Foundation; either version 3, or (at your ++ option) any later version. ++ ++ GCC 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 GCC; see the file COPYING3. If not see ++ . */ ++ ++/* Don't assume anything about the header files. */ ++#define NO_IMPLICIT_EXTERN_C ++ ++#undef LIB_SPEC ++#define LIB_SPEC \ ++ "%{pthread:-lpthread} " \ ++ "-lc" ++ ++#undef LINK_GCC_C_SEQUENCE_SPEC ++#define LINK_GCC_C_SEQUENCE_SPEC \ ++ "%{static:--start-group} %G %L %{static:--end-group} " \ ++ "%{!static: %G}" ++ ++#undef STARTFILE_SPEC ++#define STARTFILE_SPEC \ ++ "%{!shared: %{pg|p|profile:gcrt1%O%s;pie:Scrt1%O%s;:crt1%O%s}} " \ ++ "crtreloc%O%s crti%O%s %{shared|pie:crtbeginS%O%s;:crtbegin%O%s}" ++ ++#undef ENDFILE_SPEC ++#define ENDFILE_SPEC \ ++ "%{shared|pie:crtendS%O%s;:crtend%O%s} crtn%O%s" ++ ++/* taken from linux.h */ ++/* The GNU C++ standard library requires that these macros be defined. */ ++#undef CPLUSPLUS_CPP_SPEC ++#define CPLUSPLUS_CPP_SPEC "-D_GNU_SOURCE %(cpp)" ++ ++#define TARGET_OS_CPP_BUILTINS() \ ++ do { \ ++ builtin_define_std ("__UBICOM32__"); \ ++ builtin_define_std ("__ubicom32__"); \ ++ builtin_define ("__gnu_linux__"); \ ++ builtin_define_std ("linux"); \ ++ builtin_define_std ("unix"); \ ++ builtin_assert ("system=linux"); \ ++ builtin_assert ("system=unix"); \ ++ builtin_assert ("system=posix"); \ ++ } while (0) ++ ++#define OBJECT_FORMAT_ELF ++ ++ ++#undef DRIVER_SELF_SPECS ++#define DRIVER_SELF_SPECS \ ++ "%{!mno-fdpic:-mfdpic}" ++ ++#undef LINK_SPEC ++#define LINK_SPEC "%{mfdpic: -m elf32ubicom32fdpic -z text } %{shared} %{pie} \ ++ %{static:-dn -Bstatic} \ ++ %{shared:-G -Bdynamic} \ ++ %{!shared: %{!static: \ ++ %{rdynamic:-export-dynamic} \ ++ %{!dynamic-linker:-dynamic-linker /lib/ld-uClibc.so.0}} \ ++ %{static}} " ++ ++/* ++#define MD_UNWIND_SUPPORT "config/bfin/linux-unwind.h" ++*/ +--- /dev/null ++++ b/gcc/config/ubicom32/predicates.md +@@ -0,0 +1,327 @@ ++; Predicate definitions for Ubicom32. ++ ++; Copyright (C) 2009 Free Software Foundation, Inc. ++; Contributed by Ubicom, Inc. ++ ++; This file is part of GCC. ++ ++; GCC is free software; you can redistribute it and/or modify it ++; under the terms of the GNU General Public License as published ++; by the Free Software Foundation; either version 3, or (at your ++; option) any later version. ++ ++; GCC 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 GCC; see the file COPYING3. If not see ++; . ++ ++(define_predicate "ubicom32_move_operand" ++ (match_code "const_int, const_double, const, mem, subreg, reg, lo_sum") ++{ ++ if (CONST_INT_P (op)) ++ return true; ++ ++ if (GET_CODE (op) == CONST_DOUBLE) ++ return true; ++ ++ if (GET_CODE (op) == CONST) ++ return memory_address_p (mode, op); ++ ++ if (GET_MODE (op) != mode) ++ return false; ++ ++ if (MEM_P (op)) ++ return memory_address_p (mode, XEXP (op, 0)); ++ ++ if (GET_CODE (op) == SUBREG) { ++ op = SUBREG_REG (op); ++ ++ if (REG_P (op)) ++ return true; ++ ++ if (! MEM_P (op)) ++ return false; ++ ++ /* Paradoxical SUBREG. */ ++ if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (op))) ++ return false; ++ ++ return memory_address_p (GET_MODE (op), XEXP (op, 0)); ++ } ++ ++ return register_operand (op, mode); ++}) ++ ++;; Returns true if OP is either a symbol reference or a sum of a ++;; symbol reference and a constant. ++ ++(define_predicate "ubicom32_symbolic_address_operand" ++ (match_code "symbol_ref, label_ref, const") ++{ ++ switch (GET_CODE (op)) ++ { ++ case SYMBOL_REF: ++ case LABEL_REF: ++ return true; ++ ++ case CONST: ++ op = XEXP (op, 0); ++ return ((GET_CODE (XEXP (op, 0)) == SYMBOL_REF ++ || GET_CODE (XEXP (op, 0)) == LABEL_REF) ++ && CONST_INT_P (XEXP (op, 1))); ++ ++ default: ++ return false; ++ } ++}) ++ ++;; Return true if operand is the uClinux FD-PIC register. ++ ++(define_predicate "ubicom32_fdpic_operand" ++ (match_code "reg") ++{ ++ if (! TARGET_FDPIC) ++ return false; ++ ++ if (!REG_P (op)) ++ return false; ++ ++ if (GET_MODE (op) != mode && mode != VOIDmode) ++ return false; ++ ++ if (REGNO (op) != FDPIC_REGNUM && REGNO (op) < FIRST_PSEUDO_REGISTER) ++ return false; ++ ++ return true; ++}) ++ ++(define_predicate "ubicom32_fdpic_got_offset_operand" ++ (match_code "unspec") ++{ ++ if (! TARGET_FDPIC) ++ return false; ++ ++ if (GET_CODE (op) != UNSPEC) ++ return false; ++ ++ if (XINT (op, 1) != UNSPEC_FDPIC_GOT ++ && XINT (op, 1) != UNSPEC_FDPIC_GOT_FUNCDESC) ++ return false; ++ ++ return true; ++}) ++ ++(define_predicate "ubicom32_arith_operand" ++ (match_code "subreg, reg, const_int, lo_sum, mem") ++{ ++ return (ubicom32_move_operand (op, mode) ++ && ! ubicom32_symbolic_address_operand (op, mode) ++ && (! CONST_INT_P (op) ++ || satisfies_constraint_I (op))); ++}) ++ ++(define_predicate "ubicom32_arith_operand_dot1" ++ (match_code "subreg, reg, const_int, lo_sum, mem") ++{ ++ return (ubicom32_move_operand (op, mode) ++ && ! ubicom32_symbolic_address_operand (op, mode) ++ && (! CONST_INT_P (op) ++ || satisfies_constraint_Q (op))); ++}) ++ ++(define_predicate "ubicom32_arith_operand_dot2" ++ (match_code "subreg, reg, const_int, lo_sum, mem") ++{ ++ return (ubicom32_move_operand (op, mode) ++ && ! ubicom32_symbolic_address_operand (op, mode) ++ && (! CONST_INT_P (op) ++ || satisfies_constraint_R (op))); ++}) ++ ++(define_predicate "ubicom32_compare_operand" ++ (match_code "subreg, reg, const_int, lo_sum, mem") ++{ ++ return (ubicom32_move_operand (op, mode) ++ && ! ubicom32_symbolic_address_operand (op, mode) ++ && (! CONST_INT_P (op) ++ || satisfies_constraint_N (op))); ++}) ++ ++(define_predicate "ubicom32_compare_operator" ++ (match_code "compare")) ++ ++(define_predicate "ubicom32_and_or_si3_operand" ++ (match_code "subreg, reg, const_int, lo_sum, mem") ++{ ++ return (ubicom32_arith_operand (op, mode) ++ || (CONST_INT_P (op) ++ && ((exact_log2 (INTVAL (op) + 1) != -1 ++ && exact_log2 (INTVAL (op) + 1) <= 31) ++ || (exact_log2 (INTVAL (op)) != -1 ++ && exact_log2 (INTVAL (op)) <= 31) ++ || (exact_log2 (~INTVAL (op)) != -1 ++ && exact_log2 (~INTVAL (op)) <= 31)))); ++}) ++ ++(define_predicate "ubicom32_and_or_hi3_operand" ++ (match_code "subreg, reg, const_int, lo_sum, mem") ++{ ++ return (ubicom32_arith_operand (op, mode) ++ || (CONST_INT_P (op) ++ && exact_log2 (INTVAL (op) + 1) != -1 ++ && exact_log2 (INTVAL (op) + 1) <= 15)); ++}) ++ ++(define_predicate "ubicom32_mem_or_address_register_operand" ++ (match_code "subreg, reg, mem") ++{ ++ unsigned int regno; ++ ++ if (MEM_P (op) ++ && memory_operand (op, mode)) ++ return true; ++ ++ if (REG_P (op)) ++ regno = REGNO (op); ++ else if (GET_CODE (op) == SUBREG && REG_P (SUBREG_REG (op))) ++ { ++ int offset; ++ if (REGNO (SUBREG_REG (op)) >= FIRST_PSEUDO_REGISTER) ++ offset = SUBREG_BYTE (op) / (GET_MODE_SIZE (GET_MODE (op))); ++ else ++ offset = subreg_regno_offset (REGNO (SUBREG_REG (op)), ++ GET_MODE (SUBREG_REG (op)), ++ SUBREG_BYTE (op), ++ GET_MODE (op)); ++ regno = REGNO (SUBREG_REG (op)) + offset; ++ } ++ else ++ return false; ++ ++ return (regno >= FIRST_PSEUDO_REGISTER ++ || REGNO_REG_CLASS (regno) == FDPIC_REG ++ || REGNO_REG_CLASS (regno) == ADDRESS_REGS); ++}) ++ ++(define_predicate "ubicom32_data_register_operand" ++ (match_code "subreg, reg") ++{ ++ unsigned int regno; ++ ++ if (REG_P (op)) ++ regno = REGNO (op); ++ else if (GET_CODE (op) == SUBREG && REG_P (SUBREG_REG (op))) ++ { ++ int offset; ++ if (REGNO (SUBREG_REG (op)) >= FIRST_PSEUDO_REGISTER) ++ offset = SUBREG_BYTE (op) / (GET_MODE_SIZE (GET_MODE (op))); ++ else ++ offset = subreg_regno_offset (REGNO (SUBREG_REG (op)), ++ GET_MODE (SUBREG_REG (op)), ++ SUBREG_BYTE (op), ++ GET_MODE (op)); ++ regno = REGNO (SUBREG_REG (op)) + offset; ++ } ++ else ++ return false; ++ ++ return ((regno >= FIRST_PSEUDO_REGISTER ++ && regno != REGNO (virtual_stack_vars_rtx)) ++ || REGNO_REG_CLASS (regno) == DATA_REGS); ++}) ++ ++(define_predicate "ubicom32_address_register_operand" ++ (match_code "subreg, reg") ++{ ++ unsigned int regno; ++ ++ if (REG_P (op)) ++ regno = REGNO (op); ++ else if (GET_CODE (op) == SUBREG && REG_P (SUBREG_REG (op))) ++ { ++ int offset; ++ if (REGNO (SUBREG_REG (op)) >= FIRST_PSEUDO_REGISTER) ++ offset = SUBREG_BYTE (op) / (GET_MODE_SIZE (GET_MODE (op))); ++ else ++ offset = subreg_regno_offset (REGNO (SUBREG_REG (op)), ++ GET_MODE (SUBREG_REG (op)), ++ SUBREG_BYTE (op), ++ GET_MODE (op)); ++ regno = REGNO (SUBREG_REG (op)) + offset; ++ } ++ else ++ return false; ++ ++ return (regno >= FIRST_PSEUDO_REGISTER ++ || REGNO_REG_CLASS (regno) == FDPIC_REG ++ || REGNO_REG_CLASS (regno) == ADDRESS_REGS); ++}) ++ ++(define_predicate "ubicom32_acc_lo_register_operand" ++ (match_code "subreg, reg") ++{ ++ unsigned int regno; ++ ++ if (REG_P (op)) ++ regno = REGNO (op); ++ else if (GET_CODE (op) == SUBREG && REG_P (SUBREG_REG (op))) ++ { ++ int offset; ++ if (REGNO (SUBREG_REG (op)) >= FIRST_PSEUDO_REGISTER) ++ offset = SUBREG_BYTE (op) / (GET_MODE_SIZE (GET_MODE (op))); ++ else ++ offset = subreg_regno_offset (REGNO (SUBREG_REG (op)), ++ GET_MODE (SUBREG_REG (op)), ++ SUBREG_BYTE (op), ++ GET_MODE (op)); ++ regno = REGNO (SUBREG_REG (op)) + offset; ++ } ++ else ++ return false; ++ ++ return ((regno >= FIRST_PSEUDO_REGISTER ++ && regno != REGNO (virtual_stack_vars_rtx)) ++ || REGNO_REG_CLASS (regno) == ACC_LO_REGS); ++}) ++ ++(define_predicate "ubicom32_acc_hi_register_operand" ++ (match_code "subreg, reg") ++{ ++ unsigned int regno; ++ ++ if (REG_P (op)) ++ regno = REGNO (op); ++ else if (GET_CODE (op) == SUBREG && REG_P (SUBREG_REG (op))) ++ { ++ int offset; ++ if (REGNO (SUBREG_REG (op)) >= FIRST_PSEUDO_REGISTER) ++ offset = SUBREG_BYTE (op) / (GET_MODE_SIZE (GET_MODE (op))); ++ else ++ offset = subreg_regno_offset (REGNO (SUBREG_REG (op)), ++ GET_MODE (SUBREG_REG (op)), ++ SUBREG_BYTE (op), ++ GET_MODE (op)); ++ regno = REGNO (SUBREG_REG (op)) + offset; ++ } ++ else ++ return false; ++ ++ return ((regno >= FIRST_PSEUDO_REGISTER ++ && regno != REGNO (virtual_stack_vars_rtx)) ++ || REGNO_REG_CLASS (regno) == ACC_REGS); ++}) ++ ++(define_predicate "ubicom32_call_address_operand" ++ (match_code "symbol_ref, subreg, reg") ++{ ++ return (GET_CODE (op) == SYMBOL_REF || REG_P (op)); ++}) ++ ++(define_special_predicate "ubicom32_cc_register_operand" ++ (and (match_code "reg") ++ (match_test "REGNO (op) == CC_REGNUM"))) ++ +--- /dev/null ++++ b/gcc/config/ubicom32/t-ubicom32 +@@ -0,0 +1,52 @@ ++# Name of assembly file containing libgcc1 functions. ++# This entry must be present, but it can be empty if the target does ++# not need any assembler functions to support its code generation. ++CROSS_LIBGCC1 = ++ ++# Alternatively if assembler functions *are* needed then define the ++# entries below: ++# CROSS_LIBGCC1 = libgcc1-asm.a ++ ++LIB2FUNCS_EXTRA = \ ++ $(srcdir)/config/udivmodsi4.c \ ++ $(srcdir)/config/divmod.c \ ++ $(srcdir)/config/udivmod.c ++ ++# If any special flags are necessary when building libgcc2 put them here. ++# ++# TARGET_LIBGCC2_CFLAGS = ++ ++# We want fine grained libraries, so use the new code to build the ++# floating point emulation libraries. ++FPBIT = fp-bit.c ++DPBIT = dp-bit.c ++ ++fp-bit.c: $(srcdir)/config/fp-bit.c ++ echo '#define FLOAT' > fp-bit.c ++ cat $(srcdir)/config/fp-bit.c >> fp-bit.c ++ ++dp-bit.c: $(srcdir)/config/fp-bit.c ++ cat $(srcdir)/config/fp-bit.c > dp-bit.c ++ ++# Commented out to speed up compiler development! ++# ++# MULTILIB_OPTIONS = march=ubicom32v1/march=ubicom32v2/march=ubicom32v3/march=ubicom32v4 ++# MULTILIB_DIRNAMES = ubicom32v1 ubicom32v2 ubicom32v3 ubicom32v4 ++ ++MULTILIB_OPTIONS = march=ubicom32v3/march=ubicom32v4 ++MULTILIB_OPTIONS += mfdpic ++MULTILIB_OPTIONS += mno-ipos-abi/mipos-abi ++MULTILIB_OPTIONS += fno-leading-underscore/fleading-underscore ++ ++# Assemble startup files. ++$(T)crti.o: $(srcdir)/config/ubicom32/crti.S $(GCC_PASSES) ++ $(GCC_FOR_TARGET) $(GCC_CFLAGS) $(MULTILIB_CFLAGS) $(INCLUDES) \ ++ -c -o $(T)crti.o -x assembler-with-cpp $(srcdir)/config/ubicom32/crti.S ++ ++$(T)crtn.o: $(srcdir)/config/ubicom32/crtn.S $(GCC_PASSES) ++ $(GCC_FOR_TARGET) $(GCC_CFLAGS) $(MULTILIB_CFLAGS) $(INCLUDES) \ ++ -c -o $(T)crtn.o -x assembler-with-cpp $(srcdir)/config/ubicom32/crtn.S ++ ++# these parts are required because uClibc ldso needs them to link. ++# they are not in the specfile so they will not be included automatically. ++EXTRA_MULTILIB_PARTS = crtbegin.o crtend.o crtbeginS.o crtendS.o crti.o crtn.o +--- /dev/null ++++ b/gcc/config/ubicom32/t-ubicom32-linux +@@ -0,0 +1,35 @@ ++# Name of assembly file containing libgcc1 functions. ++# This entry must be present, but it can be empty if the target does ++# not need any assembler functions to support its code generation. ++CROSS_LIBGCC1 = ++ ++# Alternatively if assembler functions *are* needed then define the ++# entries below: ++# CROSS_LIBGCC1 = libgcc1-asm.a ++ ++LIB2FUNCS_EXTRA = \ ++ $(srcdir)/config/udivmodsi4.c \ ++ $(srcdir)/config/divmod.c \ ++ $(srcdir)/config/udivmod.c ++ ++# If any special flags are necessary when building libgcc2 put them here. ++# ++# TARGET_LIBGCC2_CFLAGS = ++ ++# We want fine grained libraries, so use the new code to build the ++# floating point emulation libraries. ++FPBIT = fp-bit.c ++DPBIT = dp-bit.c ++ ++fp-bit.c: $(srcdir)/config/fp-bit.c ++ echo '#define FLOAT' > fp-bit.c ++ cat $(srcdir)/config/fp-bit.c >> fp-bit.c ++ ++dp-bit.c: $(srcdir)/config/fp-bit.c ++ cat $(srcdir)/config/fp-bit.c > dp-bit.c ++ ++# We only support v3 and v4 ISAs for uClinux. ++ ++MULTILIB_OPTIONS = march=ubicom32v3/march=ubicom32v4 ++ ++#EXTRA_MULTILIB_PARTS = crtbegin.o crtend.o crtbeginS.o crtendS.o +--- /dev/null ++++ b/gcc/config/ubicom32/t-ubicom32-uclinux +@@ -0,0 +1,35 @@ ++# Name of assembly file containing libgcc1 functions. ++# This entry must be present, but it can be empty if the target does ++# not need any assembler functions to support its code generation. ++CROSS_LIBGCC1 = ++ ++# Alternatively if assembler functions *are* needed then define the ++# entries below: ++# CROSS_LIBGCC1 = libgcc1-asm.a ++ ++LIB2FUNCS_EXTRA = \ ++ $(srcdir)/config/udivmodsi4.c \ ++ $(srcdir)/config/divmod.c \ ++ $(srcdir)/config/udivmod.c ++ ++# If any special flags are necessary when building libgcc2 put them here. ++# ++# TARGET_LIBGCC2_CFLAGS = ++ ++# We want fine grained libraries, so use the new code to build the ++# floating point emulation libraries. ++FPBIT = fp-bit.c ++DPBIT = dp-bit.c ++ ++fp-bit.c: $(srcdir)/config/fp-bit.c ++ echo '#define FLOAT' > fp-bit.c ++ cat $(srcdir)/config/fp-bit.c >> fp-bit.c ++ ++dp-bit.c: $(srcdir)/config/fp-bit.c ++ cat $(srcdir)/config/fp-bit.c > dp-bit.c ++ ++# We only support v3 and v4 ISAs for uClinux. ++ ++MULTILIB_OPTIONS = march=ubicom32v3/march=ubicom32v4 ++ ++EXTRA_MULTILIB_PARTS = crtbegin.o crtend.o # crtbeginS.o crtendS.o +--- /dev/null ++++ b/gcc/config/ubicom32/ubicom32-modes.def +@@ -0,0 +1,30 @@ ++/* Definitions of target machine for GNU compiler, Ubicom32 architecture. ++ Copyright (C) 2009 Free Software Foundation, Inc. ++ Contributed by Ubicom, Inc. ++ ++ This file is part of GCC. ++ ++ GCC is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published ++ by the Free Software Foundation; either version 3, or (at your ++ option) any later version. ++ ++ GCC 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 GCC; see the file COPYING3. If not see ++ . */ ++ ++/* Some insns set all condition code flags, some only set the Z and N flags, and ++ some only set the Z flag. */ ++ ++CC_MODE (CCW); ++CC_MODE (CCWZN); ++CC_MODE (CCWZ); ++CC_MODE (CCS); ++CC_MODE (CCSZN); ++CC_MODE (CCSZ); ++ +--- /dev/null ++++ b/gcc/config/ubicom32/ubicom32-protos.h +@@ -0,0 +1,84 @@ ++/* Function prototypes for Ubicom IP3000. ++ ++ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, ++ 2009 Free Software Foundation, Inc. ++ Contributed by Ubicom, Inc. ++ ++ This file is part of GNU CC. ++ ++ GNU CC 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. ++ ++ GNU CC 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 GNU CC; see the file COPYING. If not, write to the Free Software ++ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ ++ ++#ifdef RTX_CODE ++ ++#ifdef TREE_CODE ++extern void ubicom32_va_start (tree, rtx); ++#endif /* TREE_CODE */ ++ ++extern void ubicom32_print_operand (FILE *, rtx, int); ++extern void ubicom32_print_operand_address (FILE *, rtx); ++ ++extern void ubicom32_conditional_register_usage (void); ++extern enum reg_class ubicom32_preferred_reload_class (rtx, enum reg_class); ++extern int ubicom32_regno_ok_for_index_p (int, int); ++extern void ubicom32_expand_movsi (rtx *); ++extern void ubicom32_expand_addsi3 (rtx *); ++extern int ubicom32_emit_mult_sequence (rtx *); ++extern void ubicom32_emit_move_const_int (rtx, rtx); ++extern bool ubicom32_legitimate_constant_p (rtx); ++extern bool ubicom32_legitimate_address_p (enum machine_mode, rtx, int); ++extern rtx ubicom32_legitimize_address (rtx, rtx, enum machine_mode); ++extern rtx ubicom32_legitimize_reload_address (rtx, enum machine_mode, int, int); ++extern void ubicom32_canonicalize_comparison (enum rtx_code *code, rtx *op0, rtx *op1); ++extern int ubicom32_mode_dependent_address_p (rtx); ++extern void ubicom32_output_cond_jump (rtx, rtx, rtx); ++extern void ubicom32_expand_eh_return (rtx *); ++extern void ubicom32_expand_call_fdpic (rtx *); ++extern void ubicom32_expand_call_value_fdpic (rtx *); ++extern enum machine_mode ubicom32_select_cc_mode (RTX_CODE, rtx, rtx); ++extern rtx ubicom32_gen_compare_reg (RTX_CODE, rtx, rtx); ++extern int ubicom32_shiftable_const_int (int); ++#endif /* RTX_CODE */ ++ ++#ifdef TREE_CODE ++extern void init_cumulative_args (CUMULATIVE_ARGS *cum, ++ tree fntype, ++ struct rtx_def *libname, ++ int indirect); ++extern struct rtx_def *function_arg (CUMULATIVE_ARGS *, ++ enum machine_mode, tree, int); ++extern struct rtx_def *function_incoming_arg (CUMULATIVE_ARGS *, ++ enum machine_mode, ++ tree, int); ++extern int function_arg_partial_nregs (CUMULATIVE_ARGS *, ++ enum machine_mode, tree, int); ++extern struct rtx_def *ubicom32_va_arg (tree, tree); ++extern int ubicom32_reg_parm_stack_space (tree); ++#endif /* TREE_CODE */ ++ ++extern struct rtx_def * ubicom32_builtin_saveregs (void); ++extern void asm_file_start (FILE *); ++extern void ubicom32_expand_prologue (void); ++extern void ubicom32_expand_epilogue (void); ++extern int ubicom32_initial_elimination_offset (int, int); ++extern int ubicom32_regno_ok_for_base_p (int, int); ++extern bool ubicom32_hard_regno_mode_ok (unsigned int, enum machine_mode); ++extern int ubicom32_can_use_return_insn_p (void); ++extern rtx ubicom32_return_addr_rtx (int, rtx); ++extern void ubicom32_optimization_options (int, int); ++extern void ubicom32_override_options (void); ++extern bool ubicom32_match_cc_mode (rtx, enum machine_mode); ++ ++extern int ubicom32_reorg_completed; ++ +--- /dev/null ++++ b/gcc/config/ubicom32/ubicom32.c +@@ -0,0 +1,2881 @@ ++/* Subroutines for insn-output.c for Ubicom32 ++ ++ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, ++ 2009 Free Software Foundation, Inc. ++ Contributed by Ubicom, Inc. ++ ++ This file is part of GCC. ++ ++ GCC is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published ++ by the Free Software Foundation; either version 3, or (at your ++ option) any later version. ++ ++ GCC 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 GCC; see the file COPYING3. If not see ++ . */ ++ ++#include "config.h" ++#include "system.h" ++#include "coretypes.h" ++#include "tm.h" ++#include "rtl.h" ++#include "tree.h" ++#include "regs.h" ++#include "hard-reg-set.h" ++#include "real.h" ++#include "insn-config.h" ++#include "conditions.h" ++#include "insn-flags.h" ++#include "output.h" ++#include "insn-attr.h" ++#include "insn-codes.h" ++#include "flags.h" ++#include "recog.h" ++#include "expr.h" ++#include "function.h" ++#include "obstack.h" ++#include "toplev.h" ++#include "tm_p.h" ++#include "tm-constrs.h" ++#include "basic-block.h" ++#include "integrate.h" ++#include "target.h" ++#include "target-def.h" ++#include "reload.h" ++#include "df.h" ++#include "langhooks.h" ++#include "optabs.h" ++ ++static tree ubicom32_handle_fndecl_attribute (tree *, tree, tree, int, bool *); ++static void ubicom32_layout_frame (void); ++static void ubicom32_function_prologue (FILE *, HOST_WIDE_INT); ++static void ubicom32_function_epilogue (FILE *, HOST_WIDE_INT); ++static bool ubicom32_rtx_costs (rtx, int, int, int *, bool speed); ++static bool ubicom32_fixed_condition_code_regs (unsigned int *, ++ unsigned int *); ++static enum machine_mode ubicom32_cc_modes_compatible (enum machine_mode, ++ enum machine_mode); ++static int ubicom32_naked_function_p (void); ++static void ubicom32_machine_dependent_reorg (void); ++static bool ubicom32_assemble_integer (rtx, unsigned int, int); ++static void ubicom32_asm_init_sections (void); ++static int ubicom32_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,tree, ++ bool); ++static bool ubicom32_pass_by_reference (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, ++ enum machine_mode mode, const_tree type, ++ bool named ATTRIBUTE_UNUSED); ++static bool ubicom32_callee_copies (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, ++ enum machine_mode mode, const_tree type, ++ bool named ATTRIBUTE_UNUSED); ++ ++static bool ubicom32_return_in_memory (const_tree type, ++ const_tree fntype ATTRIBUTE_UNUSED); ++static bool ubicom32_is_base_reg (rtx, int); ++static void ubicom32_init_builtins (void); ++static rtx ubicom32_expand_builtin (tree, rtx, rtx, enum machine_mode, int); ++static tree ubicom32_fold_builtin (tree, tree, bool); ++static int ubicom32_get_valid_offset_mask (enum machine_mode); ++static bool ubicom32_cannot_force_const_mem (rtx); ++ ++/* Case values threshold */ ++int ubicom32_case_values_threshold = 6; ++ ++/* Nonzero if this chip supports the Ubicom32 v3 ISA. */ ++int ubicom32_v3 = 1; ++ ++/* Nonzero if this chip supports the Ubicom32 v4 ISA. */ ++int ubicom32_v4 = 1; ++ ++/* Valid attributes: ++ naked - don't generate function prologue/epilogue and `ret' command. */ ++const struct attribute_spec ubicom32_attribute_table[] = ++{ ++ /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */ ++ { "naked", 0, 0, true, false, false, ubicom32_handle_fndecl_attribute }, ++ { NULL, 0, 0, false, false, false, NULL } ++}; ++ ++#undef TARGET_ASM_FUNCTION_PROLOGUE ++#define TARGET_ASM_FUNCTION_PROLOGUE ubicom32_function_prologue ++ ++#undef TARGET_ASM_FUNCTION_EPILOGUE ++#define TARGET_ASM_FUNCTION_EPILOGUE ubicom32_function_epilogue ++ ++#undef TARGET_ATTRIBUTE_TABLE ++#define TARGET_ATTRIBUTE_TABLE ubicom32_attribute_table ++ ++/* All addresses cost the same amount. */ ++#undef TARGET_ADDRESS_COST ++#define TARGET_ADDRESS_COST hook_int_rtx_bool_0 ++ ++#undef TARGET_RTX_COSTS ++#define TARGET_RTX_COSTS ubicom32_rtx_costs ++ ++#undef TARGET_FIXED_CONDITION_CODE_REGS ++#define TARGET_FIXED_CONDITION_CODE_REGS ubicom32_fixed_condition_code_regs ++ ++#undef TARGET_CC_MODES_COMPATIBLE ++#define TARGET_CC_MODES_COMPATIBLE ubicom32_cc_modes_compatible ++ ++#undef TARGET_MACHINE_DEPENDENT_REORG ++#define TARGET_MACHINE_DEPENDENT_REORG ubicom32_machine_dependent_reorg ++ ++#undef TARGET_ASM_INTEGER ++#define TARGET_ASM_INTEGER ubicom32_assemble_integer ++ ++#undef TARGET_ASM_INIT_SECTIONS ++#define TARGET_ASM_INIT_SECTIONS ubicom32_asm_init_sections ++ ++#undef TARGET_ARG_PARTIAL_BYTES ++#define TARGET_ARG_PARTIAL_BYTES ubicom32_arg_partial_bytes ++ ++#undef TARGET_PASS_BY_REFERENCE ++#define TARGET_PASS_BY_REFERENCE ubicom32_pass_by_reference ++ ++#undef TARGET_CALLEE_COPIES ++#define TARGET_CALLEE_COPIES ubicom32_callee_copies ++ ++#undef TARGET_RETURN_IN_MEMORY ++#define TARGET_RETURN_IN_MEMORY ubicom32_return_in_memory ++ ++#undef TARGET_INIT_BUILTINS ++#define TARGET_INIT_BUILTINS ubicom32_init_builtins ++ ++#undef TARGET_EXPAND_BUILTIN ++#define TARGET_EXPAND_BUILTIN ubicom32_expand_builtin ++ ++#undef TARGET_FOLD_BUILTIN ++#define TARGET_FOLD_BUILTIN ubicom32_fold_builtin ++ ++#undef TARGET_CANNOT_FORCE_CONST_MEM ++#define TARGET_CANNOT_FORCE_CONST_MEM ubicom32_cannot_force_const_mem ++ ++struct gcc_target targetm = TARGET_INITIALIZER; ++ ++static char save_regs[FIRST_PSEUDO_REGISTER]; ++static int nregs; ++static int frame_size; ++int ubicom32_stack_size = 0; /* size of allocated stack (including frame) */ ++int ubicom32_can_use_calli_to_ret; ++ ++#define STACK_UNIT_BOUNDARY (STACK_BOUNDARY / BITS_PER_UNIT) ++#define ROUND_CALL_BLOCK_SIZE(BYTES) \ ++ (((BYTES) + (STACK_UNIT_BOUNDARY - 1)) & ~(STACK_UNIT_BOUNDARY - 1)) ++ ++/* In case of a PRE_INC, POST_INC, PRE_DEC, POST_DEC memory reference, we ++ must report the mode of the memory reference from PRINT_OPERAND to ++ PRINT_OPERAND_ADDRESS. */ ++enum machine_mode output_memory_reference_mode; ++ ++/* Flag for some split insns from the ubicom32.md. */ ++int ubicom32_reorg_completed; ++ ++enum reg_class const ubicom32_regclass_map[FIRST_PSEUDO_REGISTER] = ++{ ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ DATA_REGS, ++ FDPIC_REG, ++ ADDRESS_REGS, ++ ADDRESS_REGS, ++ ADDRESS_REGS, ++ ADDRESS_REGS, ++ ADDRESS_REGS, ++ ADDRESS_REGS, ++ ADDRESS_REGS, ++ ACC_REGS, ++ ACC_LO_REGS, ++ ACC_REGS, ++ ACC_LO_REGS, ++ SOURCE3_REG, ++ ADDRESS_REGS, ++ NO_REGS, /* CC_REG must be NO_REGS */ ++ SPECIAL_REGS, ++ SPECIAL_REGS, ++ SPECIAL_REGS, ++ SPECIAL_REGS, ++ SPECIAL_REGS, ++ SPECIAL_REGS, ++ SPECIAL_REGS, ++ SPECIAL_REGS ++}; ++ ++rtx ubicom32_compare_op0; ++rtx ubicom32_compare_op1; ++ ++/* Handle command line option overrides. */ ++ ++void ++ubicom32_override_options (void) ++{ ++ flag_pic = 0; ++ ++ if (strcmp (ubicom32_arch_name, "ubicom32v1") == 0) { ++ /* If we have a version 1 architecture then we want to avoid using jump ++ tables. */ ++ ubicom32_case_values_threshold = 30000; ++ ubicom32_v3 = 0; ++ ubicom32_v4 = 0; ++ } else if (strcmp (ubicom32_arch_name, "ubicom32v2") == 0) { ++ ubicom32_v3 = 0; ++ ubicom32_v4 = 0; ++ } else if (strcmp (ubicom32_arch_name, "ubicom32v3") == 0) { ++ ubicom32_v3 = 1; ++ ubicom32_v4 = 0; ++ } else if (strcmp (ubicom32_arch_name, "ubicom32v4") == 0) { ++ ubicom32_v3 = 1; ++ ubicom32_v4 = 1; ++ } ++ ++ /* There is no single unaligned SI op for PIC code. Sometimes we ++ need to use ".4byte" and sometimes we need to use ".picptr". ++ See ubicom32_assemble_integer for details. */ ++ if (TARGET_FDPIC) ++ targetm.asm_out.unaligned_op.si = 0; ++} ++ ++void ++ubicom32_conditional_register_usage (void) ++{ ++ /* If we're using the old ipOS ABI we need to make D10 through D13 ++ caller-clobbered. */ ++ if (TARGET_IPOS_ABI) ++ { ++ call_used_regs[D10_REGNUM] = 1; ++ call_used_regs[D11_REGNUM] = 1; ++ call_used_regs[D12_REGNUM] = 1; ++ call_used_regs[D13_REGNUM] = 1; ++ } ++} ++ ++/* We have some number of optimizations that don't really work for the Ubicom32 ++ architecture so we deal with them here. */ ++ ++void ++ubicom32_optimization_options (int level ATTRIBUTE_UNUSED, ++ int size ATTRIBUTE_UNUSED) ++{ ++ /* The tree IVOPTs pass seems to do really bad things for the Ubicom32 ++ architecture - it tends to turn things that would happily use pre/post ++ increment/decrement into operations involving unecessary loop ++ indicies. */ ++ flag_ivopts = 0; ++ ++ /* We have problems where DSE at the RTL level misses partial stores ++ to the stack. For now we disable it to avoid this. */ ++ flag_dse = 0; ++} ++ ++/* Print operand X using operand code CODE to assembly language output file ++ FILE. */ ++ ++void ++ubicom32_print_operand (FILE *file, rtx x, int code) ++{ ++ switch (code) ++ { ++ case 'A': ++ /* Identify the correct accumulator to use. */ ++ if (REGNO (x) == ACC0_HI_REGNUM || REGNO (x) == ACC0_LO_REGNUM) ++ fprintf (file, "acc0"); ++ else if (REGNO (x) == ACC1_HI_REGNUM || REGNO (x) == ACC1_LO_REGNUM) ++ fprintf (file, "acc1"); ++ else ++ abort (); ++ break; ++ ++ case 'b': ++ case 'B': ++ { ++ enum machine_mode mode; ++ ++ mode = GET_MODE (XEXP (x, 0)); ++ ++ /* These are normal and reversed branches. */ ++ switch (code == 'b' ? GET_CODE (x) : reverse_condition (GET_CODE (x))) ++ { ++ case NE: ++ fprintf (file, "ne"); ++ break; ++ ++ case EQ: ++ fprintf (file, "eq"); ++ break; ++ ++ case GE: ++ if (mode == CCSZNmode || mode == CCWZNmode) ++ fprintf (file, "pl"); ++ else ++ fprintf (file, "ge"); ++ break; ++ ++ case GT: ++ fprintf (file, "gt"); ++ break; ++ ++ case LE: ++ fprintf (file, "le"); ++ break; ++ ++ case LT: ++ if (mode == CCSZNmode || mode == CCWZNmode) ++ fprintf (file, "mi"); ++ else ++ fprintf (file, "lt"); ++ break; ++ ++ case GEU: ++ fprintf (file, "cs"); ++ break; ++ ++ case GTU: ++ fprintf (file, "hi"); ++ break; ++ ++ case LEU: ++ fprintf (file, "ls"); ++ break; ++ ++ case LTU: ++ fprintf (file, "cc"); ++ break; ++ ++ default: ++ abort (); ++ } ++ } ++ break; ++ ++ case 'C': ++ /* This is used for the operand to a call instruction; ++ if it's a REG, enclose it in parens, else output ++ the operand normally. */ ++ if (REG_P (x)) ++ { ++ fputc ('(', file); ++ ubicom32_print_operand (file, x, 0); ++ fputc (')', file); ++ } ++ else ++ ubicom32_print_operand (file, x, 0); ++ break; ++ ++ case 'd': ++ /* Bit operations we need bit numbers. */ ++ fprintf (file, "%d", exact_log2 (INTVAL (x))); ++ break; ++ ++ case 'D': ++ /* Bit operations we need bit numbers. */ ++ fprintf (file, "%d", exact_log2 (~ INTVAL (x))); ++ break; ++ ++ case 'E': ++ /* For lea, which we use to add address registers. ++ We don't want the '#' on a constant. */ ++ if (CONST_INT_P (x)) ++ { ++ fprintf (file, "%ld", INTVAL (x)); ++ break; ++ } ++ /* FALL THROUGH */ ++ ++ default: ++ switch (GET_CODE (x)) ++ { ++ case MEM: ++ output_memory_reference_mode = GET_MODE (x); ++ output_address (XEXP (x, 0)); ++ break; ++ ++ case PLUS: ++ output_address (x); ++ break; ++ ++ case REG: ++ fprintf (file, "%s", reg_names[REGNO (x)]); ++ break; ++ ++ case SUBREG: ++ fprintf (file, "%s", reg_names[subreg_regno (x)]); ++ break; ++ ++ /* This will only be single precision.... */ ++ case CONST_DOUBLE: ++ { ++ unsigned long val; ++ REAL_VALUE_TYPE rv; ++ ++ REAL_VALUE_FROM_CONST_DOUBLE (rv, x); ++ REAL_VALUE_TO_TARGET_SINGLE (rv, val); ++ fprintf (file, "0x%lx", val); ++ break; ++ } ++ ++ case CONST_INT: ++ case SYMBOL_REF: ++ case CONST: ++ case LABEL_REF: ++ case CODE_LABEL: ++ case LO_SUM: ++ ubicom32_print_operand_address (file, x); ++ break; ++ ++ case HIGH: ++ fprintf (file, "#%%hi("); ++ ubicom32_print_operand_address (file, XEXP (x, 0)); ++ fprintf (file, ")"); ++ break; ++ ++ case UNSPEC: ++ switch (XINT (x, 1)) ++ { ++ case UNSPEC_FDPIC_GOT: ++ fprintf (file, "#%%got_lo("); ++ ubicom32_print_operand_address (file, XVECEXP (x, 0, 0)); ++ fprintf (file, ")"); ++ break; ++ ++ case UNSPEC_FDPIC_GOT_FUNCDESC: ++ fprintf (file, "#%%got_funcdesc_lo("); ++ ubicom32_print_operand_address (file, XVECEXP (x, 0, 0)); ++ fprintf (file, ")"); ++ break; ++ ++ default: ++ abort (); ++ } ++ break; ++ ++ default: ++ abort (); ++ } ++ break; ++ } ++} ++ ++/* Output assembly language output for the address ADDR to FILE. */ ++ ++void ++ubicom32_print_operand_address (FILE *file, rtx addr) ++{ ++ switch (GET_CODE (addr)) ++ { ++ case POST_INC: ++ ubicom32_print_operand_address (file, XEXP (addr, 0)); ++ fprintf (file, "%d++", GET_MODE_SIZE (output_memory_reference_mode)); ++ break; ++ ++ case PRE_INC: ++ fprintf (file, "%d", GET_MODE_SIZE (output_memory_reference_mode)); ++ ubicom32_print_operand_address (file, XEXP (addr, 0)); ++ fprintf (file, "++"); ++ break; ++ ++ case POST_DEC: ++ ubicom32_print_operand_address (file, XEXP (addr, 0)); ++ fprintf (file, "%d++", -GET_MODE_SIZE (output_memory_reference_mode)); ++ break; ++ ++ case PRE_DEC: ++ fprintf (file, "%d", -GET_MODE_SIZE (output_memory_reference_mode)); ++ ubicom32_print_operand_address (file, XEXP (addr, 0)); ++ fprintf (file, "++"); ++ break; ++ ++ case POST_MODIFY: ++ ubicom32_print_operand_address (file, XEXP (addr, 0)); ++ fprintf (file, "%ld++", INTVAL (XEXP (XEXP (addr,1), 1))); ++ break; ++ ++ case PRE_MODIFY: ++ fprintf (file, "%ld", INTVAL (XEXP (XEXP (addr,1), 1))); ++ ubicom32_print_operand_address (file, XEXP (addr, 0)); ++ fprintf (file, "++"); ++ break; ++ ++ case REG: ++ fputc ('(', file); ++ fprintf (file, "%s", reg_names[REGNO (addr)]); ++ fputc (')', file); ++ break; ++ ++ case PLUS: ++ { ++ rtx base = XEXP (addr, 0); ++ rtx index = XEXP (addr, 1); ++ ++ /* Switch around addresses of the form index * scaling + base. */ ++ if (! ubicom32_is_base_reg (base, 1)) ++ { ++ rtx tmp = base; ++ base = index; ++ index = tmp; ++ } ++ ++ if (CONST_INT_P (index)) ++ { ++ fprintf (file, "%ld", INTVAL (index)); ++ fputc ('(', file); ++ fputs (reg_names[REGNO (base)], file); ++ } ++ else if (GET_CODE (index) == MULT ++ || REG_P (index)) ++ { ++ if (GET_CODE (index) == MULT) ++ index = XEXP (index, 0); ++ fputc ('(', file); ++ fputs (reg_names[REGNO (base)], file); ++ fputc (',', file); ++ fputs (reg_names[REGNO (index)], file); ++ } ++ else ++ abort (); ++ ++ fputc (')', file); ++ break; ++ } ++ ++ case LO_SUM: ++ fprintf (file, "%%lo("); ++ ubicom32_print_operand (file, XEXP (addr, 1), 'L'); ++ fprintf (file, ")("); ++ ubicom32_print_operand (file, XEXP (addr, 0), 0); ++ fprintf (file, ")"); ++ break; ++ ++ case CONST_INT: ++ fputc ('#', file); ++ output_addr_const (file, addr); ++ break; ++ ++ default: ++ output_addr_const (file, addr); ++ break; ++ } ++} ++ ++/* X and Y are two things to compare using CODE. Emit the compare insn and ++ return the rtx for the cc reg in the proper mode. */ ++ ++rtx ++ubicom32_gen_compare_reg (enum rtx_code code, rtx x, rtx y) ++{ ++ enum machine_mode mode = SELECT_CC_MODE (code, x, y); ++ rtx cc_reg; ++ ++ cc_reg = gen_rtx_REG (mode, CC_REGNUM); ++ ++ emit_insn (gen_rtx_SET (VOIDmode, cc_reg, ++ gen_rtx_COMPARE (mode, x, y))); ++ ++ return cc_reg; ++} ++ ++/* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE, ++ return the mode to be used for the comparison. */ ++ ++enum machine_mode ++ubicom32_select_cc_mode (enum rtx_code op, rtx x, rtx y) ++{ ++ /* Is this a short compare? */ ++ if (GET_MODE (x) == QImode ++ || GET_MODE (x) == HImode ++ || GET_MODE (y) == QImode ++ || GET_MODE (y) == HImode) ++ { ++ switch (op) ++ { ++ case EQ : ++ case NE : ++ return CCSZmode; ++ ++ case GE: ++ case LT: ++ if (y == const0_rtx) ++ return CCSZNmode; ++ ++ default : ++ return CCSmode; ++ } ++ } ++ ++ /* We have a word compare. */ ++ switch (op) ++ { ++ case EQ : ++ case NE : ++ return CCWZmode; ++ ++ case GE : ++ case LT : ++ if (y == const0_rtx) ++ return CCWZNmode; ++ ++ default : ++ return CCWmode; ++ } ++} ++ ++/* Return TRUE or FALSE depending on whether the first SET in INSN ++ has source and destination with matching CC modes, and that the ++ CC mode is at least as constrained as REQ_MODE. */ ++bool ++ubicom32_match_cc_mode (rtx insn, enum machine_mode req_mode) ++{ ++ rtx set; ++ enum machine_mode set_mode; ++ ++ set = PATTERN (insn); ++ if (GET_CODE (set) == PARALLEL) ++ set = XVECEXP (set, 0, 0); ++ gcc_assert (GET_CODE (set) == SET); ++ gcc_assert (GET_CODE (SET_SRC (set)) == COMPARE); ++ ++ /* SET_MODE is the mode we have in the instruction. This must either ++ be the same or less restrictive that the required mode REQ_MODE. */ ++ set_mode = GET_MODE (SET_DEST (set)); ++ ++ switch (req_mode) ++ { ++ case CCSZmode: ++ if (set_mode != CCSZmode) ++ return 0; ++ break; ++ ++ case CCSZNmode: ++ if (set_mode != CCSZmode ++ && set_mode != CCSZNmode) ++ return 0; ++ break; ++ ++ case CCSmode: ++ if (set_mode != CCSmode ++ && set_mode != CCSZmode ++ && set_mode != CCSZNmode) ++ return 0; ++ break; ++ ++ case CCWZmode: ++ if (set_mode != CCWZmode) ++ return 0; ++ break; ++ ++ case CCWZNmode: ++ if (set_mode != CCWZmode ++ && set_mode != CCWZNmode) ++ return 0; ++ break; ++ ++ case CCWmode: ++ if (set_mode != CCWmode ++ && set_mode != CCWZmode ++ && set_mode != CCWZNmode) ++ return 0; ++ break; ++ ++ default: ++ gcc_unreachable (); ++ } ++ ++ return (GET_MODE (SET_SRC (set)) == set_mode); ++} ++ ++/* Replace the comparison OP0 CODE OP1 by a semantically equivalent one ++ that we can implement more efficiently. */ ++ ++void ++ubicom32_canonicalize_comparison (enum rtx_code *code, rtx *op0, rtx *op1) ++{ ++ /* If we have a REG and a MEM then compare the MEM with the REG and not ++ the other way round. */ ++ if (REG_P (*op0) && MEM_P (*op1)) ++ { ++ rtx tem = *op0; ++ *op0 = *op1; ++ *op1 = tem; ++ *code = swap_condition (*code); ++ return; ++ } ++ ++ /* If we have a REG and a CONST_INT then we may want to reverse things ++ if the constant can be represented as an "I" constraint. */ ++ if (REG_P (*op0) && CONST_INT_P (*op1) && satisfies_constraint_I (*op1)) ++ { ++ rtx tem = *op0; ++ *op0 = *op1; ++ *op1 = tem; ++ *code = swap_condition (*code); ++ return; ++ } ++} ++ ++/* Return the fixed registers used for condition codes. */ ++ ++static bool ++ubicom32_fixed_condition_code_regs (unsigned int *p1, unsigned int *p2) ++{ ++ *p1 = CC_REGNUM; ++ *p2 = INVALID_REGNUM; ++ ++ return true; ++} ++ ++/* If two condition code modes are compatible, return a condition code ++ mode which is compatible with both. Otherwise, return ++ VOIDmode. */ ++ ++static enum machine_mode ++ubicom32_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2) ++{ ++ if (m1 == m2) ++ return m1; ++ ++ if (GET_MODE_CLASS (m1) != MODE_CC || GET_MODE_CLASS (m2) != MODE_CC) ++ return VOIDmode; ++ ++ switch (m1) ++ { ++ case CCWmode: ++ if (m2 == CCWZNmode || m2 == CCWZmode) ++ return m1; ++ ++ return VOIDmode; ++ ++ case CCWZNmode: ++ if (m2 == CCWmode) ++ return m2; ++ ++ if (m2 == CCWZmode) ++ return m1; ++ ++ return VOIDmode; ++ ++ case CCWZmode: ++ if (m2 == CCWmode || m2 == CCWZNmode) ++ return m2; ++ ++ return VOIDmode; ++ ++ case CCSmode: ++ if (m2 == CCSZNmode || m2 == CCSZmode) ++ return m1; ++ ++ return VOIDmode; ++ ++ case CCSZNmode: ++ if (m2 == CCSmode) ++ return m2; ++ ++ if (m2 == CCSZmode) ++ return m1; ++ ++ return VOIDmode; ++ ++ case CCSZmode: ++ if (m2 == CCSmode || m2 == CCSZNmode) ++ return m2; ++ ++ return VOIDmode; ++ ++ default: ++ gcc_unreachable (); ++ } ++} ++ ++static rtx ++ubicom32_legitimize_fdpic_address_symbol (rtx orig, rtx reg, rtx fdpic_reg) ++{ ++ int unspec; ++ rtx got_offs; ++ rtx got_offs_scaled; ++ rtx plus_scaled; ++ rtx tmp; ++ rtx new_rtx; ++ ++ gcc_assert (reg != 0); ++ ++ if (GET_CODE (orig) == SYMBOL_REF ++ && SYMBOL_REF_FUNCTION_P (orig)) ++ unspec = UNSPEC_FDPIC_GOT_FUNCDESC; ++ else ++ unspec = UNSPEC_FDPIC_GOT; ++ ++ got_offs = gen_reg_rtx (SImode); ++ tmp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, orig), unspec); ++ emit_move_insn (got_offs, tmp); ++ ++ got_offs_scaled = gen_rtx_MULT (SImode, got_offs, GEN_INT (4)); ++ plus_scaled = gen_rtx_PLUS (Pmode, fdpic_reg, got_offs_scaled); ++ new_rtx = gen_const_mem (Pmode, plus_scaled); ++ emit_move_insn (reg, new_rtx); ++ ++ return reg; ++} ++ ++static rtx ++ubicom32_legitimize_fdpic_address (rtx orig, rtx reg, rtx fdpic_reg) ++{ ++ rtx addr = orig; ++ rtx new_rtx = orig; ++ ++ if (GET_CODE (addr) == CONST || GET_CODE (addr) == PLUS) ++ { ++ rtx base; ++ ++ if (GET_CODE (addr) == CONST) ++ { ++ addr = XEXP (addr, 0); ++ gcc_assert (GET_CODE (addr) == PLUS); ++ } ++ ++ base = ubicom32_legitimize_fdpic_address_symbol (XEXP (addr, 0), reg, fdpic_reg); ++ return gen_rtx_PLUS (Pmode, base, XEXP (addr, 1)); ++ } ++ ++ return new_rtx; ++} ++ ++/* Code generation. */ ++ ++void ++ubicom32_expand_movsi (rtx *operands) ++{ ++ if (GET_CODE (operands[1]) == SYMBOL_REF ++ || (GET_CODE (operands[1]) == CONST ++ && GET_CODE (XEXP (operands[1], 0)) == PLUS ++ && GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == SYMBOL_REF) ++ || CONSTANT_ADDRESS_P (operands[1])) ++ { ++ if (TARGET_FDPIC) ++ { ++ rtx tmp; ++ rtx fdpic_reg; ++ ++ gcc_assert (can_create_pseudo_p ()); ++ tmp = gen_reg_rtx (Pmode); ++ fdpic_reg = get_hard_reg_initial_val (SImode, FDPIC_REGNUM); ++ if (GET_CODE (operands[1]) == SYMBOL_REF ++ || GET_CODE (operands[1]) == LABEL_REF) ++ operands[1] = ubicom32_legitimize_fdpic_address_symbol (operands[1], tmp, fdpic_reg); ++ else ++ operands[1] = ubicom32_legitimize_fdpic_address (operands[1], tmp, fdpic_reg); ++ } ++ else ++ { ++ rtx tmp; ++ enum machine_mode mode; ++ ++ /* We want to avoid reusing operand 0 if we can because it limits ++ our ability to optimize later. */ ++ tmp = ! can_create_pseudo_p () ? operands[0] : gen_reg_rtx (Pmode); ++ ++ mode = GET_MODE (operands[0]); ++ emit_insn (gen_rtx_SET (VOIDmode, tmp, ++ gen_rtx_HIGH (mode, operands[1]))); ++ operands[1] = gen_rtx_LO_SUM (mode, tmp, operands[1]); ++ if (can_create_pseudo_p() && ! REG_P (operands[0])) ++ { ++ tmp = gen_reg_rtx (mode); ++ emit_insn (gen_rtx_SET (VOIDmode, tmp, operands[1])); ++ operands[1] = tmp; ++ } ++ } ++ } ++} ++ ++/* Emit code for addsi3. */ ++ ++void ++ubicom32_expand_addsi3 (rtx *operands) ++{ ++ rtx op, clob; ++ ++ if (can_create_pseudo_p ()) ++ { ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (SImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (SImode, operands[2]); ++ } ++ ++ /* Emit the instruction. */ ++ ++ op = gen_rtx_SET (VOIDmode, operands[0], ++ gen_rtx_PLUS (SImode, operands[1], operands[2])); ++ ++ if (! can_create_pseudo_p ()) ++ { ++ /* Reload doesn't know about the flags register, and doesn't know that ++ it doesn't want to clobber it. We can only do this with PLUS. */ ++ emit_insn (op); ++ } ++ else ++ { ++ clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, CC_REGNUM)); ++ emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob))); ++ } ++} ++ ++/* Emit code for mulsi3. Return 1 if we have generated all the code ++ necessary to do the multiplication. */ ++ ++int ++ubicom32_emit_mult_sequence (rtx *operands) ++{ ++ if (! ubicom32_v4) ++ { ++ rtx a1, a1_1, a2; ++ rtx b1, b1_1, b2; ++ rtx mac_lo_rtx; ++ rtx t1, t2, t3; ++ ++ /* Give up if we cannot create new pseudos. */ ++ if (!can_create_pseudo_p()) ++ return 0; ++ ++ /* Synthesize 32-bit multiplication using 16-bit operations: ++ ++ a1 = highpart (a) ++ a2 = lowpart (a) ++ ++ b1 = highpart (b) ++ b2 = lowpart (b) ++ ++ c = (a1 * b1) << 32 + (a1 * b2) << 16 + (a2 * b1) << 16 + a2 * b2 ++ = 0 + (a1 * b2) << 16 + (a2 * b1) << 16 + a2 * b2 ++ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^ ++ Signed Signed Unsigned */ ++ ++ if (!ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))) ++ { ++ rtx op1; ++ ++ op1 = gen_reg_rtx (SImode); ++ emit_move_insn (op1, operands[1]); ++ operands[1] = op1; ++ } ++ ++ if (!ubicom32_data_register_operand (operands[2], GET_MODE (operands[2]))) ++ { ++ rtx op2; ++ ++ op2 = gen_reg_rtx (SImode); ++ emit_move_insn (op2, operands[2]); ++ operands[2] = op2; ++ } ++ ++ /* a1 = highpart (a) */ ++ a1 = gen_reg_rtx (HImode); ++ a1_1 = gen_reg_rtx (SImode); ++ emit_insn (gen_ashrsi3 (a1_1, operands[1], GEN_INT (16))); ++ emit_move_insn (a1, gen_lowpart (HImode, a1_1)); ++ ++ /* a2 = lowpart (a) */ ++ a2 = gen_reg_rtx (HImode); ++ emit_move_insn (a2, gen_lowpart (HImode, operands[1])); ++ ++ /* b1 = highpart (b) */ ++ b1 = gen_reg_rtx (HImode); ++ b1_1 = gen_reg_rtx (SImode); ++ emit_insn (gen_ashrsi3 (b1_1, operands[2], GEN_INT (16))); ++ emit_move_insn (b1, gen_lowpart (HImode, b1_1)); ++ ++ /* b2 = lowpart (b) */ ++ b2 = gen_reg_rtx (HImode); ++ emit_move_insn (b2, gen_lowpart (HImode, operands[2])); ++ ++ /* t1 = (a1 * b2) << 16 */ ++ t1 = gen_reg_rtx (SImode); ++ mac_lo_rtx = gen_rtx_REG (SImode, ACC0_LO_REGNUM); ++ emit_insn (gen_mulhisi3 (mac_lo_rtx, a1, b2)); ++ emit_insn (gen_ashlsi3 (t1, mac_lo_rtx, GEN_INT (16))); ++ ++ /* t2 = (a2 * b1) << 16 */ ++ t2 = gen_reg_rtx (SImode); ++ emit_insn (gen_mulhisi3 (mac_lo_rtx, a2, b1)); ++ emit_insn (gen_ashlsi3 (t2, mac_lo_rtx, GEN_INT (16))); ++ ++ /* mac_lo = a2 * b2 */ ++ emit_insn (gen_umulhisi3 (mac_lo_rtx, a2, b2)); ++ ++ /* t3 = t1 + t2 */ ++ t3 = gen_reg_rtx (SImode); ++ emit_insn (gen_addsi3 (t3, t1, t2)); ++ ++ /* c = t3 + mac_lo_rtx */ ++ emit_insn (gen_addsi3 (operands[0], mac_lo_rtx, t3)); ++ ++ return 1; ++ } ++ else ++ { ++ rtx acc_rtx; ++ ++ /* Give up if we cannot create new pseudos. */ ++ if (!can_create_pseudo_p()) ++ return 0; ++ ++ if (!ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))) ++ { ++ rtx op1; ++ ++ op1 = gen_reg_rtx (SImode); ++ emit_move_insn (op1, operands[1]); ++ operands[1] = op1; ++ } ++ ++ if (!ubicom32_data_register_operand (operands[2], GET_MODE (operands[2]))) ++ { ++ rtx op2; ++ ++ op2 = gen_reg_rtx (SImode); ++ emit_move_insn (op2, operands[2]); ++ operands[2] = op2; ++ } ++ ++ acc_rtx = gen_reg_rtx (DImode); ++ emit_insn (gen_umulsidi3 (acc_rtx, operands[1], operands[2])); ++ emit_move_insn (operands[0], gen_lowpart (SImode, acc_rtx)); ++ ++ return 1; ++ } ++} ++ ++/* Move the integer value VAL into OPERANDS[0]. */ ++ ++void ++ubicom32_emit_move_const_int (rtx dest, rtx imm) ++{ ++ rtx xoperands[2]; ++ ++ xoperands[0] = dest; ++ xoperands[1] = imm; ++ ++ /* Treat mem destinations separately. Values must be explicitly sign ++ extended. */ ++ if (MEM_P (dest)) ++ { ++ rtx low_hword_mem; ++ rtx low_hword_addr; ++ ++ /* Emit shorter sequence for signed 7-bit quantities. */ ++ if (satisfies_constraint_I (imm)) ++ { ++ output_asm_insn ("move.4\t%0, %1", xoperands); ++ return; ++ } ++ ++ /* Special case for pushing constants. */ ++ if (GET_CODE (XEXP (dest, 0)) == PRE_DEC ++ && XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx) ++ { ++ output_asm_insn ("movei\t-4(sp)++, #%%hi(%E1)", xoperands); ++ output_asm_insn ("movei\t2(sp), #%%lo(%E1)", xoperands); ++ return; ++ } ++ ++ /* See if we can add 2 to the original address. This is only ++ possible if the original address is of the form REG or ++ REG+const. */ ++ low_hword_addr = plus_constant (XEXP (dest, 0), 2); ++ if (ubicom32_legitimate_address_p (HImode, low_hword_addr, 1)) ++ { ++ low_hword_mem = gen_rtx_MEM (HImode, low_hword_addr); ++ MEM_COPY_ATTRIBUTES (low_hword_mem, dest); ++ output_asm_insn ("movei\t%0, #%%hi(%E1)", xoperands); ++ xoperands[0] = low_hword_mem; ++ output_asm_insn ("movei\t%0, #%%lo(%E1)", xoperands); ++ return; ++ } ++ ++ /* The original address is too complex. We need to use a ++ scratch memory by (sp) and move that to the original ++ destination. */ ++ if (! reg_mentioned_p (stack_pointer_rtx, dest)) ++ { ++ output_asm_insn ("movei\t-4(sp)++, #%%hi(%E1)", xoperands); ++ output_asm_insn ("movei\t2(sp), #%%lo(%E1)", xoperands); ++ output_asm_insn ("move.4\t%0, (sp)4++", xoperands); ++ return; ++ } ++ ++ /* Our address mentions the stack pointer so we need to ++ use our scratch data register here as well as scratch ++ memory. */ ++ output_asm_insn ("movei\t-4(sp)++, #%%hi(%E1)", xoperands); ++ output_asm_insn ("movei\t2(sp), #%%lo(%E1)", xoperands); ++ output_asm_insn ("move.4\td15, (sp)4++", xoperands); ++ output_asm_insn ("move.4\t%0, d15", xoperands); ++ return; ++ } ++ ++ /* Move into registers are zero extended by default. */ ++ if (! REG_P (dest)) ++ abort (); ++ ++ if (satisfies_constraint_N (imm)) ++ { ++ output_asm_insn ("movei\t%0, %1", xoperands); ++ return; ++ } ++ ++ if (INTVAL (xoperands[1]) >= 0xff80 ++ && INTVAL (xoperands[1]) < 0x10000) ++ { ++ xoperands[1] = GEN_INT (INTVAL (xoperands[1]) - 0x10000); ++ output_asm_insn ("move.2\t%0, %1", xoperands); ++ return; ++ } ++ ++ if ((REGNO_REG_CLASS (REGNO (xoperands[0])) == ADDRESS_REGS ++ || REGNO_REG_CLASS (REGNO (xoperands[0])) == FDPIC_REG) ++ && ((INTVAL (xoperands[1]) & 0x80000000) == 0)) ++ { ++ output_asm_insn ("moveai\t%0, #%%hi(%E1)", xoperands); ++ if ((INTVAL (xoperands[1]) & 0x7f) != 0) ++ output_asm_insn ("lea.1\t%0, %%lo(%E1)(%0)", xoperands); ++ return; ++ } ++ ++ if ((INTVAL (xoperands[1]) & 0xffff0000) == 0) ++ { ++ output_asm_insn ("movei\t%0, #%%lo(%E1)", xoperands); ++ output_asm_insn ("move.2\t%0, %0", xoperands); ++ return; ++ } ++ ++ /* This is very expensive. The constant is so large that we ++ need to use the stack to do the load. */ ++ output_asm_insn ("movei\t-4(sp)++, #%%hi(%E1)", xoperands); ++ output_asm_insn ("movei\t2(sp), #%%lo(%E1)", xoperands); ++ output_asm_insn ("move.4\t%0, (sp)4++", xoperands); ++} ++ ++/* Stack layout. Prologue/Epilogue. */ ++ ++static int save_regs_size; ++ ++static void ++ubicom32_layout_frame (void) ++{ ++ int regno; ++ ++ memset ((char *) &save_regs[0], 0, sizeof (save_regs)); ++ nregs = 0; ++ frame_size = get_frame_size (); ++ ++ if (frame_pointer_needed || df_regs_ever_live_p (FRAME_POINTER_REGNUM)) ++ { ++ save_regs[FRAME_POINTER_REGNUM] = 1; ++ ++nregs; ++ } ++ ++ if (current_function_is_leaf && ! df_regs_ever_live_p (LINK_REGNO)) ++ ubicom32_can_use_calli_to_ret = 1; ++ else ++ { ++ ubicom32_can_use_calli_to_ret = 0; ++ save_regs[LINK_REGNO] = 1; ++ ++nregs; ++ } ++ ++ /* Figure out which register(s) needs to be saved. */ ++ for (regno = 0; regno <= LAST_ADDRESS_REGNUM; regno++) ++ if (df_regs_ever_live_p(regno) ++ && ! call_used_regs[regno] ++ && ! fixed_regs[regno] ++ && ! save_regs[regno]) ++ { ++ save_regs[regno] = 1; ++ ++nregs; ++ } ++ ++ save_regs_size = 4 * nregs; ++} ++ ++static void ++ubicom32_emit_add_movsi (int regno, int adj) ++{ ++ rtx x; ++ rtx reg = gen_rtx_REG (SImode, regno); ++ ++ adj += 4; ++ if (adj > 8 * 4) ++ { ++ x = emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, ++ GEN_INT (-adj))); ++ RTX_FRAME_RELATED_P (x) = 1; ++ x = emit_move_insn (gen_rtx_MEM (SImode, stack_pointer_rtx), reg); ++ } ++ else ++ { ++ rtx addr = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx, ++ gen_rtx_PLUS (Pmode, stack_pointer_rtx, ++ GEN_INT (-adj))); ++ x = emit_move_insn (gen_rtx_MEM (SImode, addr), reg); ++ } ++ RTX_FRAME_RELATED_P (x) = 1; ++} ++ ++void ++ubicom32_expand_prologue (void) ++{ ++ rtx x; ++ int regno; ++ int outgoing_args_size = crtl->outgoing_args_size; ++ int adj; ++ ++ if (ubicom32_naked_function_p ()) ++ return; ++ ++ ubicom32_builtin_saveregs (); ++ ++ ubicom32_layout_frame (); ++ adj = (outgoing_args_size + get_frame_size () + save_regs_size ++ + crtl->args.pretend_args_size); ++ ++ if (!adj) ++ ; ++ else if (outgoing_args_size + save_regs_size < 508 ++ && get_frame_size () + save_regs_size > 508) ++ { ++ int i = 0; ++ x = gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, ++ GEN_INT (-adj)); ++ x = emit_insn (x); ++ RTX_FRAME_RELATED_P (x) = 1; ++ ++ for (regno = LAST_ADDRESS_REGNUM; regno >= 0; --regno) ++ if (save_regs[regno] && regno != LINK_REGNO) ++ { ++ x = gen_rtx_MEM (SImode, ++ gen_rtx_PLUS (Pmode, ++ stack_pointer_rtx, ++ GEN_INT (i * 4 + outgoing_args_size))); ++ x = emit_move_insn (x, gen_rtx_REG (SImode, regno)); ++ RTX_FRAME_RELATED_P (x) = 1; ++ ++i; ++ } ++ if (save_regs[LINK_REGNO]) ++ { ++ x = gen_rtx_MEM (SImode, ++ gen_rtx_PLUS (Pmode, ++ stack_pointer_rtx, ++ GEN_INT (i * 4 + outgoing_args_size))); ++ x = emit_move_insn (x, gen_rtx_REG (SImode, LINK_REGNO)); ++ RTX_FRAME_RELATED_P (x) = 1; ++ } ++ } ++ else ++ { ++ int regno; ++ int adj = get_frame_size () + crtl->args.pretend_args_size; ++ int i = 0; ++ ++ if (save_regs[LINK_REGNO]) ++ { ++ ubicom32_emit_add_movsi (LINK_REGNO, adj); ++ ++i; ++ } ++ ++ for (regno = 0; regno <= LAST_ADDRESS_REGNUM; ++regno) ++ if (save_regs[regno] && regno != LINK_REGNO) ++ { ++ if (i) ++ { ++ rtx mem = gen_rtx_MEM (SImode, ++ gen_rtx_PRE_DEC (Pmode, ++ stack_pointer_rtx)); ++ x = emit_move_insn (mem, gen_rtx_REG (SImode, regno)); ++ RTX_FRAME_RELATED_P (x) = 1; ++ } ++ else ++ ubicom32_emit_add_movsi (regno, adj); ++ ++i; ++ } ++ ++ if (outgoing_args_size || (!i && adj)) ++ { ++ x = gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, ++ GEN_INT (-outgoing_args_size - (i ? 0 : adj))); ++ x = emit_insn (x); ++ RTX_FRAME_RELATED_P (x) = 1; ++ } ++ } ++ ++ if (frame_pointer_needed) ++ { ++ int fp_adj = save_regs_size + outgoing_args_size; ++ x = gen_addsi3 (frame_pointer_rtx, stack_pointer_rtx, ++ GEN_INT (fp_adj)); ++ x = emit_insn (x); ++ RTX_FRAME_RELATED_P (x) = 1; ++ } ++} ++ ++void ++ubicom32_expand_epilogue (void) ++{ ++ rtx x; ++ int regno; ++ int outgoing_args_size = crtl->outgoing_args_size; ++ int adj; ++ int i; ++ ++ if (ubicom32_naked_function_p ()) ++ { ++ emit_jump_insn (gen_return_internal (gen_rtx_REG (SImode, ++ LINK_REGNO))); ++ return; ++ } ++ ++ if (cfun->calls_alloca) ++ { ++ x = gen_addsi3 (stack_pointer_rtx, frame_pointer_rtx, ++ GEN_INT (-save_regs_size)); ++ emit_insn (x); ++ outgoing_args_size = 0; ++ } ++ ++ if (outgoing_args_size) ++ { ++ x = gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, ++ GEN_INT (outgoing_args_size)); ++ emit_insn (x); ++ } ++ ++ i = 0; ++ for (regno = LAST_ADDRESS_REGNUM; regno >= 0; --regno) ++ if (save_regs[regno] && regno != LINK_REGNO) ++ { ++ x = gen_rtx_MEM (SImode, gen_rtx_POST_INC (Pmode, stack_pointer_rtx)); ++ emit_move_insn (gen_rtx_REG (SImode, regno), x); ++ ++i; ++ } ++ ++ /* Do we have to adjust the stack after we've finished restoring regs? */ ++ adj = get_frame_size() + crtl->args.pretend_args_size; ++ if (cfun->stdarg) ++ adj += UBICOM32_FUNCTION_ARG_REGS * UNITS_PER_WORD; ++ ++#if 0 ++ if (crtl->calls_eh_return && 0) ++ { ++ if (save_regs[LINK_REGNO]) ++ { ++ x = gen_rtx_MEM (SImode, gen_rtx_POST_INC (Pmode, stack_pointer_rtx)); ++ emit_move_insn (gen_rtx_REG (SImode, LINK_REGNO), x); ++ } ++ ++ if (adj) ++ { ++ x = gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, ++ GEN_INT (adj)); ++ x = emit_insn (x); ++ } ++ ++ /* Perform the additional bump for __throw. */ ++ emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, ++ EH_RETURN_STACKADJ_RTX)); ++ emit_jump_insn (gen_eh_return_internal ()); ++ return; ++ } ++#endif ++ ++ if (save_regs[LINK_REGNO]) ++ { ++ if (adj >= 4 && adj <= (6 * 4)) ++ { ++ x = GEN_INT (adj + 4); ++ emit_jump_insn (gen_return_from_post_modify_sp (x)); ++ return; ++ } ++ ++ if (adj == 0) ++ { ++ x = gen_rtx_MEM (SImode, gen_rtx_POST_INC (Pmode, stack_pointer_rtx)); ++ emit_jump_insn (gen_return_internal (x)); ++ return; ++ } ++ ++ x = gen_rtx_MEM (SImode, gen_rtx_POST_INC (Pmode, stack_pointer_rtx)); ++ emit_move_insn (gen_rtx_REG (SImode, LINK_REGNO), x); ++ } ++ ++ if (adj) ++ { ++ x = gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, ++ GEN_INT (adj)); ++ x = emit_insn (x); ++ adj = 0; ++ } ++ ++ /* Given that we've just done all the hard work here we may as well use ++ a calli to return. */ ++ ubicom32_can_use_calli_to_ret = 1; ++ emit_jump_insn (gen_return_internal (gen_rtx_REG (SImode, LINK_REGNO))); ++} ++ ++void ++ubicom32_expand_call_fdpic (rtx *operands) ++{ ++ rtx c; ++ rtx addr; ++ rtx fdpic_reg = get_hard_reg_initial_val (SImode, FDPIC_REGNUM); ++ ++ addr = XEXP (operands[0], 0); ++ ++ c = gen_call_fdpic (addr, operands[1], fdpic_reg); ++ emit_call_insn (c); ++} ++ ++void ++ubicom32_expand_call_value_fdpic (rtx *operands) ++{ ++ rtx c; ++ rtx addr; ++ rtx fdpic_reg = get_hard_reg_initial_val (SImode, FDPIC_REGNUM); ++ ++ addr = XEXP (operands[1], 0); ++ ++ c = gen_call_value_fdpic (operands[0], addr, operands[2], fdpic_reg); ++ emit_call_insn (c); ++} ++ ++void ++ubicom32_expand_eh_return (rtx *operands) ++{ ++ if (REG_P (operands[0]) ++ || REGNO (operands[0]) != EH_RETURN_STACKADJ_REGNO) ++ { ++ rtx sp = EH_RETURN_STACKADJ_RTX; ++ emit_move_insn (sp, operands[0]); ++ operands[0] = sp; ++ } ++ ++ if (REG_P (operands[1]) ++ || REGNO (operands[1]) != EH_RETURN_HANDLER_REGNO) ++ { ++ rtx ra = EH_RETURN_HANDLER_RTX; ++ emit_move_insn (ra, operands[1]); ++ operands[1] = ra; ++ } ++} ++ ++/* Compute the offsets between eliminable registers. */ ++ ++int ++ubicom32_initial_elimination_offset (int from, int to) ++{ ++ ubicom32_layout_frame (); ++ if (from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM) ++ return save_regs_size + crtl->outgoing_args_size; ++ ++ if (from == ARG_POINTER_REGNUM && to == FRAME_POINTER_REGNUM) ++ return get_frame_size ()/* + save_regs_size */; ++ ++ if (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM) ++ return get_frame_size () ++ + crtl->outgoing_args_size ++ + save_regs_size; ++ ++ return 0; ++} ++ ++/* Return 1 if it is appropriate to emit `ret' instructions in the ++ body of a function. Do this only if the epilogue is simple, needing a ++ couple of insns. Prior to reloading, we can't tell how many registers ++ must be saved, so return 0 then. Return 0 if there is no frame ++ marker to de-allocate. ++ ++ If NON_SAVING_SETJMP is defined and true, then it is not possible ++ for the epilogue to be simple, so return 0. This is a special case ++ since NON_SAVING_SETJMP will not cause regs_ever_live to change ++ until final, but jump_optimize may need to know sooner if a ++ `return' is OK. */ ++ ++int ++ubicom32_can_use_return_insn_p (void) ++{ ++ if (! reload_completed || frame_pointer_needed) ++ return 0; ++ ++ return 1; ++} ++ ++/* Attributes and CC handling. */ ++ ++/* Handle an attribute requiring a FUNCTION_DECL; arguments as in ++ struct attribute_spec.handler. */ ++static tree ++ubicom32_handle_fndecl_attribute (tree *node, tree name, ++ tree args ATTRIBUTE_UNUSED, ++ int flags ATTRIBUTE_UNUSED, ++ bool *no_add_attrs) ++{ ++ if (TREE_CODE (*node) != FUNCTION_DECL) ++ { ++ warning ("'%s' attribute only applies to functions", ++ IDENTIFIER_POINTER (name)); ++ *no_add_attrs = true; ++ } ++ ++ return NULL_TREE; ++} ++ ++/* A C expression that places additional restrictions on the register class to ++ use when it is necessary to copy value X into a register in class CLASS. ++ The value is a register class; perhaps CLASS, or perhaps another, smaller ++ class. On many machines, the following definition is safe: ++ ++ #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS ++ ++ Sometimes returning a more restrictive class makes better code. For ++ example, on the 68000, when X is an integer constant that is in range for a ++ `moveq' instruction, the value of this macro is always `DATA_REGS' as long ++ as CLASS includes the data registers. Requiring a data register guarantees ++ that a `moveq' will be used. ++ ++ If X is a `const_double', by returning `NO_REGS' you can force X into a ++ memory constant. This is useful on certain machines where immediate ++ floating values cannot be loaded into certain kinds of registers. */ ++ ++enum reg_class ++ubicom32_preferred_reload_class (rtx x, enum reg_class class) ++{ ++ /* If a symbolic constant, HIGH or a PLUS is reloaded, ++ it is most likely being used as an address, so ++ prefer ADDRESS_REGS. If 'class' is not a superset ++ of ADDRESS_REGS, e.g. DATA_REGS, then reject this reload. */ ++ if (GET_CODE (x) == PLUS ++ || GET_CODE (x) == HIGH ++ || GET_CODE (x) == LABEL_REF ++ || GET_CODE (x) == SYMBOL_REF ++ || GET_CODE (x) == CONST) ++ { ++ if (reg_class_subset_p (ALL_ADDRESS_REGS, class)) ++ return ALL_ADDRESS_REGS; ++ ++ return NO_REGS; ++ } ++ ++ return class; ++} ++ ++/* Function arguments and varargs. */ ++ ++int ++ubicom32_reg_parm_stack_space (tree fndecl) ++{ ++ return 0; ++ ++ if (fndecl ++ && TYPE_ARG_TYPES (TREE_TYPE (fndecl)) != 0 ++ && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))) ++ != void_type_node)) ++ return UBICOM32_FUNCTION_ARG_REGS * UNITS_PER_WORD; ++ ++ return 0; ++} ++ ++/* Flush the argument registers to the stack for a stdarg function; ++ return the new argument pointer. */ ++ ++rtx ++ubicom32_builtin_saveregs (void) ++{ ++ int regno; ++ ++ if (! cfun->stdarg) ++ return 0; ++ ++ for (regno = UBICOM32_FUNCTION_ARG_REGS - 1; regno >= 0; --regno) ++ emit_move_insn (gen_rtx_MEM (SImode, ++ gen_rtx_PRE_DEC (SImode, ++ stack_pointer_rtx)), ++ gen_rtx_REG (SImode, regno)); ++ ++ return stack_pointer_rtx; ++} ++ ++void ++ubicom32_va_start (tree valist, rtx nextarg) ++{ ++ std_expand_builtin_va_start (valist, nextarg); ++} ++ ++rtx ++ubicom32_va_arg (tree valist, tree type) ++{ ++ HOST_WIDE_INT size, rsize; ++ tree addr, incr, tmp; ++ rtx addr_rtx; ++ int indirect = 0; ++ ++ /* Round up sizeof(type) to a word. */ ++ size = int_size_in_bytes (type); ++ rsize = (size + UNITS_PER_WORD - 1) & -UNITS_PER_WORD; ++ ++ /* Large types are passed by reference. */ ++ if (size > 8) ++ { ++ indirect = 1; ++ size = rsize = UNITS_PER_WORD; ++ } ++ ++ incr = valist; ++ addr = incr = save_expr (incr); ++ ++ /* FIXME Nat's version - is it correct? */ ++ tmp = fold_convert (ptr_type_node, size_int (rsize)); ++ tmp = build2 (PLUS_EXPR, ptr_type_node, incr, tmp); ++ incr = fold (tmp); ++ ++ /* FIXME Nat's version - is it correct? */ ++ incr = build2 (MODIFY_EXPR, ptr_type_node, valist, incr); ++ ++ TREE_SIDE_EFFECTS (incr) = 1; ++ expand_expr (incr, const0_rtx, VOIDmode, EXPAND_NORMAL); ++ ++ addr_rtx = expand_expr (addr, NULL, Pmode, EXPAND_NORMAL); ++ ++ if (size < UNITS_PER_WORD) ++ emit_insn (gen_addsi3 (addr_rtx, addr_rtx, ++ GEN_INT (UNITS_PER_WORD - size))); ++ ++ if (indirect) ++ { ++ addr_rtx = force_reg (Pmode, addr_rtx); ++ addr_rtx = gen_rtx_MEM (Pmode, addr_rtx); ++ set_mem_alias_set (addr_rtx, get_varargs_alias_set ()); ++ } ++ ++ return addr_rtx; ++} ++ ++void ++init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype, rtx libname, ++ int indirect ATTRIBUTE_UNUSED) ++{ ++ cum->nbytes = 0; ++ ++ if (!libname) ++ { ++ cum->stdarg = (TYPE_ARG_TYPES (fntype) != 0 ++ && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype))) ++ != void_type_node)); ++ } ++} ++ ++/* Return an RTX to represent where a value in mode MODE will be passed ++ to a function. If the result is 0, the argument will be pushed. */ ++ ++rtx ++function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type, ++ int named ATTRIBUTE_UNUSED) ++{ ++ rtx result = 0; ++ int size, align; ++ int nregs = UBICOM32_FUNCTION_ARG_REGS; ++ ++ /* Figure out the size of the object to be passed. */ ++ if (mode == BLKmode) ++ size = int_size_in_bytes (type); ++ else ++ size = GET_MODE_SIZE (mode); ++ ++ /* Figure out the alignment of the object to be passed. */ ++ align = size; ++ ++ cum->nbytes = (cum->nbytes + 3) & ~3; ++ ++ /* Don't pass this arg via a register if all the argument registers ++ are used up. */ ++ if (cum->nbytes >= nregs * UNITS_PER_WORD) ++ return 0; ++ ++ /* Don't pass this arg via a register if it would be split between ++ registers and memory. */ ++ result = gen_rtx_REG (mode, cum->nbytes / UNITS_PER_WORD); ++ ++ return result; ++} ++ ++rtx ++function_incoming_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type, ++ int named ATTRIBUTE_UNUSED) ++{ ++ if (cfun->stdarg) ++ return 0; ++ ++ return function_arg (cum, mode, type, named); ++} ++ ++ ++/* Implement hook TARGET_ARG_PARTIAL_BYTES. ++ ++ Returns the number of bytes at the beginning of an argument that ++ must be put in registers. The value must be zero for arguments ++ that are passed entirely in registers or that are entirely pushed ++ on the stack. */ ++static int ++ubicom32_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode, ++ tree type, bool named ATTRIBUTE_UNUSED) ++{ ++ int size, diff; ++ ++ int nregs = UBICOM32_FUNCTION_ARG_REGS; ++ ++ /* round up to full word */ ++ cum->nbytes = (cum->nbytes + 3) & ~3; ++ ++ if (targetm.calls.pass_by_reference (cum, mode, type, named)) ++ return 0; ++ ++ /* number of bytes left in registers */ ++ diff = nregs*UNITS_PER_WORD - cum->nbytes; ++ ++ /* regs all used up */ ++ if (diff <= 0) ++ return 0; ++ ++ /* Figure out the size of the object to be passed. */ ++ if (mode == BLKmode) ++ size = int_size_in_bytes (type); ++ else ++ size = GET_MODE_SIZE (mode); ++ ++ /* enough space left in regs for size */ ++ if (size <= diff) ++ return 0; ++ ++ /* put diff bytes in regs and rest on stack */ ++ return diff; ++ ++} ++ ++static bool ++ubicom32_pass_by_reference (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, ++ enum machine_mode mode, const_tree type, ++ bool named ATTRIBUTE_UNUSED) ++{ ++ int size; ++ ++ if (type) ++ size = int_size_in_bytes (type); ++ else ++ size = GET_MODE_SIZE (mode); ++ ++ return size <= 0 || size > 8; ++} ++ ++static bool ++ubicom32_callee_copies (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, ++ enum machine_mode mode, const_tree type, ++ bool named ATTRIBUTE_UNUSED) ++{ ++ int size; ++ ++ if (type) ++ size = int_size_in_bytes (type); ++ else ++ size = GET_MODE_SIZE (mode); ++ ++ return size <= 0 || size > 8; ++} ++ ++static bool ++ubicom32_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED) ++{ ++ int size, mode; ++ ++ if (!type) ++ return true; ++ ++ size = int_size_in_bytes(type); ++ if (size > 8) ++ return true; ++ ++ mode = TYPE_MODE(type); ++ if (mode == BLKmode) ++ return true; ++ ++ return false; ++} ++ ++/* Return true if a given register number REGNO is acceptable for machine ++ mode MODE. */ ++bool ++ubicom32_hard_regno_mode_ok (unsigned int regno, enum machine_mode mode) ++{ ++ /* If we're not at least a v3 ISA then ACC0_HI is only 16 bits. */ ++ if (! ubicom32_v3) ++ { ++ if (regno == ACC0_HI_REGNUM) ++ return (mode == QImode || mode == HImode); ++ } ++ ++ /* Only the flags reg can hold CCmode. */ ++ if (GET_MODE_CLASS (mode) == MODE_CC) ++ return regno == CC_REGNUM; ++ ++ /* We restrict the choice of DImode registers to only being address, ++ data or accumulator regs. We also restrict them to only start on ++ even register numbers so we never have to worry about partial ++ overlaps between operands in instructions. */ ++ if (GET_MODE_SIZE (mode) > 4) ++ { ++ switch (REGNO_REG_CLASS (regno)) ++ { ++ case ADDRESS_REGS: ++ case DATA_REGS: ++ case ACC_REGS: ++ return (regno & 1) == 0; ++ ++ default: ++ return false; ++ } ++ } ++ ++ return true; ++} ++ ++/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx ++ and check its validity for a certain class. ++ We have two alternate definitions for each of them. ++ The usual definition accepts all pseudo regs; the other rejects ++ them unless they have been allocated suitable hard regs. ++ The symbol REG_OK_STRICT causes the latter definition to be used. ++ ++ Most source files want to accept pseudo regs in the hope that ++ they will get allocated to the class that the insn wants them to be in. ++ Source files for reload pass need to be strict. ++ After reload, it makes no difference, since pseudo regs have ++ been eliminated by then. ++ ++ These assume that REGNO is a hard or pseudo reg number. ++ They give nonzero only if REGNO is a hard reg of the suitable class ++ or a pseudo reg currently allocated to a suitable hard reg. ++ Since they use reg_renumber, they are safe only once reg_renumber ++ has been allocated, which happens in local-alloc.c. */ ++ ++int ++ubicom32_regno_ok_for_base_p (int regno, int strict) ++{ ++ if ((regno >= FIRST_ADDRESS_REGNUM && regno <= STACK_POINTER_REGNUM) ++ || (!strict ++ && (regno >= FIRST_PSEUDO_REGISTER ++ || regno == ARG_POINTER_REGNUM)) ++ || (strict && (reg_renumber ++ && reg_renumber[regno] >= FIRST_ADDRESS_REGNUM ++ && reg_renumber[regno] <= STACK_POINTER_REGNUM))) ++ return 1; ++ ++ return 0; ++} ++ ++int ++ubicom32_regno_ok_for_index_p (int regno, int strict) ++{ ++ if ((regno >= FIRST_DATA_REGNUM && regno <= LAST_DATA_REGNUM) ++ || (!strict && regno >= FIRST_PSEUDO_REGISTER) ++ || (strict && (reg_renumber ++ && reg_renumber[regno] >= FIRST_DATA_REGNUM ++ && reg_renumber[regno] <= LAST_DATA_REGNUM))) ++ return 1; ++ ++ return 0; ++} ++ ++/* Returns 1 if X is a valid index register. STRICT is 1 if only hard ++ registers should be accepted. Accept either REG or SUBREG where a ++ register is valid. */ ++ ++static bool ++ubicom32_is_index_reg (rtx x, int strict) ++{ ++ if ((REG_P (x) && ubicom32_regno_ok_for_index_p (REGNO (x), strict)) ++ || (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x)) ++ && ubicom32_regno_ok_for_index_p (REGNO (SUBREG_REG (x)), strict))) ++ return true; ++ ++ return false; ++} ++ ++/* Return 1 if X is a valid index for a memory address. */ ++ ++static bool ++ubicom32_is_index_expr (enum machine_mode mode, rtx x, int strict) ++{ ++ /* Immediate index must be an unsigned 7-bit offset multiple of 1, 2 ++ or 4 depending on mode. */ ++ if (CONST_INT_P (x)) ++ { ++ switch (mode) ++ { ++ case QImode: ++ return satisfies_constraint_J (x); ++ ++ case HImode: ++ return satisfies_constraint_K (x); ++ ++ case SImode: ++ case SFmode: ++ return satisfies_constraint_L (x); ++ ++ case DImode: ++ return satisfies_constraint_L (x) ++ && satisfies_constraint_L (GEN_INT (INTVAL (x) + 4)); ++ ++ default: ++ return false; ++ } ++ } ++ ++ if (mode != SImode && mode != HImode && mode != QImode) ++ return false; ++ ++ /* Register index scaled by mode of operand: REG + REG * modesize. ++ Valid scaled index registers are: ++ ++ SImode (mult (dreg) 4)) ++ HImode (mult (dreg) 2)) ++ QImode (mult (dreg) 1)) */ ++ if (GET_CODE (x) == MULT ++ && ubicom32_is_index_reg (XEXP (x, 0), strict) ++ && CONST_INT_P (XEXP (x, 1)) ++ && INTVAL (XEXP (x, 1)) == (HOST_WIDE_INT)GET_MODE_SIZE (mode)) ++ return true; ++ ++ /* REG + REG addressing is allowed for QImode. */ ++ if (ubicom32_is_index_reg (x, strict) && mode == QImode) ++ return true; ++ ++ return false; ++} ++ ++static bool ++ubicom32_is_valid_offset (enum machine_mode mode, HOST_WIDE_INT offs) ++{ ++ if (offs < 0) ++ return false; ++ ++ switch (mode) ++ { ++ case QImode: ++ return offs <= 127; ++ ++ case HImode: ++ return offs <= 254; ++ ++ case SImode: ++ case SFmode: ++ return offs <= 508; ++ ++ case DImode: ++ return offs <= 504; ++ ++ default: ++ return false; ++ } ++} ++ ++static int ++ubicom32_get_valid_offset_mask (enum machine_mode mode) ++{ ++ switch (mode) ++ { ++ case QImode: ++ return 127; ++ ++ case HImode: ++ return 255; ++ ++ case SImode: ++ case SFmode: ++ return 511; ++ ++ case DImode: ++ return 255; ++ ++ default: ++ return 0; ++ } ++} ++ ++/* Returns 1 if X is a valid base register. STRICT is 1 if only hard ++ registers should be accepted. Accept either REG or SUBREG where a ++ register is valid. */ ++ ++static bool ++ubicom32_is_base_reg (rtx x, int strict) ++{ ++ if ((REG_P (x) && ubicom32_regno_ok_for_base_p (REGNO (x), strict)) ++ || (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x)) ++ && ubicom32_regno_ok_for_base_p (REGNO (SUBREG_REG (x)), strict))) ++ return true; ++ ++ return false; ++} ++ ++static bool ++ubicom32_cannot_force_const_mem (rtx x ATTRIBUTE_UNUSED) ++{ ++ return TARGET_FDPIC; ++} ++ ++/* Determine if X is a legitimate constant. */ ++ ++bool ++ubicom32_legitimate_constant_p (rtx x) ++{ ++ /* Among its other duties, LEGITIMATE_CONSTANT_P decides whether ++ a constant can be entered into reg_equiv_constant[]. If we return true, ++ reload can create new instances of the constant whenever it likes. ++ ++ The idea is therefore to accept as many constants as possible (to give ++ reload more freedom) while rejecting constants that can only be created ++ at certain times. In particular, anything with a symbolic component will ++ require use of the pseudo FDPIC register, which is only available before ++ reload. */ ++ if (TARGET_FDPIC) ++ { ++ if (GET_CODE (x) == SYMBOL_REF ++ || (GET_CODE (x) == CONST ++ && GET_CODE (XEXP (x, 0)) == PLUS ++ && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF) ++ || CONSTANT_ADDRESS_P (x)) ++ return false; ++ ++ return true; ++ } ++ ++ /* For non-PIC code anything goes! */ ++ return true; ++} ++ ++/* Address validation. */ ++ ++bool ++ubicom32_legitimate_address_p (enum machine_mode mode, rtx x, int strict) ++{ ++ if (TARGET_DEBUG_ADDRESS) ++ { ++ fprintf (stderr, "\n==> GO_IF_LEGITIMATE_ADDRESS%s\n", ++ (strict) ? " (STRICT)" : ""); ++ debug_rtx (x); ++ } ++ ++ if (CONSTANT_ADDRESS_P (x)) ++ return false; ++ ++ if (ubicom32_is_base_reg (x, strict)) ++ return true; ++ ++ if ((GET_CODE (x) == POST_INC ++ || GET_CODE (x) == PRE_INC ++ || GET_CODE (x) == POST_DEC ++ || GET_CODE (x) == PRE_DEC) ++ && REG_P (XEXP (x, 0)) ++ && ubicom32_is_base_reg (XEXP (x, 0), strict) ++ && mode != DImode) ++ return true; ++ ++ if ((GET_CODE (x) == PRE_MODIFY || GET_CODE (x) == POST_MODIFY) ++ && ubicom32_is_base_reg (XEXP (x, 0), strict) ++ && GET_CODE (XEXP (x, 1)) == PLUS ++ && rtx_equal_p (XEXP (x, 0), XEXP (XEXP (x, 1), 0)) ++ && CONST_INT_P (XEXP (XEXP (x, 1), 1)) ++ && mode != DImode) ++ { ++ HOST_WIDE_INT disp = INTVAL (XEXP (XEXP (x, 1), 1)); ++ switch (mode) ++ { ++ case QImode: ++ return disp >= -8 && disp <= 7; ++ ++ case HImode: ++ return disp >= -16 && disp <= 14 && ! (disp & 1); ++ ++ case SImode: ++ return disp >= -32 && disp <= 28 && ! (disp & 3); ++ ++ default: ++ return false; ++ } ++ } ++ ++ /* Accept base + index * scale. */ ++ if (GET_CODE (x) == PLUS ++ && ubicom32_is_base_reg (XEXP (x, 0), strict) ++ && ubicom32_is_index_expr (mode, XEXP (x, 1), strict)) ++ return true; ++ ++ /* Accept index * scale + base. */ ++ if (GET_CODE (x) == PLUS ++ && ubicom32_is_base_reg (XEXP (x, 1), strict) ++ && ubicom32_is_index_expr (mode, XEXP (x, 0), strict)) ++ return true; ++ ++ if (! TARGET_FDPIC) ++ { ++ /* Accept (lo_sum (reg) (symbol_ref)) that can be used as a mem+7bits ++ displacement operand: ++ ++ moveai a1, #%hi(SYM) ++ move.4 d3, %lo(SYM)(a1) */ ++ if (GET_CODE (x) == LO_SUM ++ && ubicom32_is_base_reg (XEXP (x, 0), strict) ++ && (GET_CODE (XEXP (x, 1)) == SYMBOL_REF ++ || GET_CODE (XEXP (x, 1)) == LABEL_REF /* FIXME: wrong */) ++ && mode != DImode) ++ return true; ++ } ++ ++ if (TARGET_DEBUG_ADDRESS) ++ fprintf (stderr, "\nNot a legitimate address.\n"); ++ ++ return false; ++} ++ ++rtx ++ubicom32_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED, ++ enum machine_mode mode) ++{ ++ if (mode == BLKmode) ++ return NULL_RTX; ++ ++ if (GET_CODE (x) == PLUS ++ && REG_P (XEXP (x, 0)) ++ && ! REGNO_PTR_FRAME_P (REGNO (XEXP (x, 0))) ++ && CONST_INT_P (XEXP (x, 1)) ++ && ! ubicom32_is_valid_offset (mode, INTVAL (XEXP (x, 1)))) ++ { ++ rtx base; ++ rtx plus; ++ rtx new_rtx; ++ HOST_WIDE_INT val = INTVAL (XEXP (x, 1)); ++ HOST_WIDE_INT low = val & ubicom32_get_valid_offset_mask (mode); ++ HOST_WIDE_INT high = val ^ low; ++ ++ if (val < 0) ++ return NULL_RTX; ++ ++ if (! low) ++ return NULL_RTX; ++ ++ /* Reload the high part into a base reg; leave the low part ++ in the mem directly. */ ++ base = XEXP (x, 0); ++ if (! ubicom32_is_base_reg (base, 0)) ++ base = copy_to_mode_reg (Pmode, base); ++ ++ plus = expand_simple_binop (Pmode, PLUS, ++ gen_int_mode (high, Pmode), ++ base, NULL, 0, OPTAB_WIDEN); ++ new_rtx = plus_constant (plus, low); ++ ++ return new_rtx; ++ } ++ ++ return NULL_RTX; ++} ++ ++/* Try a machine-dependent way of reloading an illegitimate address AD ++ operand. If we find one, push the reload and and return the new address. ++ ++ MODE is the mode of the enclosing MEM. OPNUM is the operand number ++ and TYPE is the reload type of the current reload. */ ++ ++rtx ++ubicom32_legitimize_reload_address (rtx ad, enum machine_mode mode, ++ int opnum, int type) ++{ ++ /* Is this an address that we've already fixed up? If it is then ++ recognize it and move on. */ ++ if (GET_CODE (ad) == PLUS ++ && GET_CODE (XEXP (ad, 0)) == PLUS ++ && REG_P (XEXP (XEXP (ad, 0), 0)) ++ && CONST_INT_P (XEXP (XEXP (ad, 0), 1)) ++ && CONST_INT_P (XEXP (ad, 1))) ++ { ++ push_reload (XEXP (ad, 0), NULL_RTX, &XEXP (ad, 0), NULL, ++ BASE_REG_CLASS, Pmode, VOIDmode, 0, 0, ++ opnum, (enum reload_type) type); ++ return ad; ++ } ++ ++ /* Have we got an address where the offset is simply out of range? If ++ yes then reload the range as a high part and smaller offset. */ ++ if (GET_CODE (ad) == PLUS ++ && REG_P (XEXP (ad, 0)) ++ && REGNO (XEXP (ad, 0)) < FIRST_PSEUDO_REGISTER ++ && REGNO_OK_FOR_BASE_P (REGNO (XEXP (ad, 0))) ++ && CONST_INT_P (XEXP (ad, 1)) ++ && ! ubicom32_is_valid_offset (mode, INTVAL (XEXP (ad, 1)))) ++ { ++ rtx temp; ++ rtx new_rtx; ++ ++ HOST_WIDE_INT val = INTVAL (XEXP (ad, 1)); ++ HOST_WIDE_INT low = val & ubicom32_get_valid_offset_mask (mode); ++ HOST_WIDE_INT high = val ^ low; ++ ++ /* Reload the high part into a base reg; leave the low part ++ in the mem directly. */ ++ temp = gen_rtx_PLUS (Pmode, XEXP (ad, 0), GEN_INT (high)); ++ new_rtx = gen_rtx_PLUS (Pmode, temp, GEN_INT (low)); ++ ++ push_reload (XEXP (new_rtx, 0), NULL_RTX, &XEXP (new_rtx, 0), NULL, ++ BASE_REG_CLASS, Pmode, VOIDmode, 0, 0, ++ opnum, (enum reload_type) type); ++ return new_rtx; ++ } ++ ++ /* If we're presented with an pre/post inc/dec then we must force this ++ to be done in an address register. The register allocator should ++ work this out for itself but at times ends up trying to use the wrong ++ class. If we get the wrong class then reload will end up generating ++ at least 3 instructions whereas this way we can hopefully keep it to ++ just 2. */ ++ if ((GET_CODE (ad) == POST_INC ++ || GET_CODE (ad) == PRE_INC ++ || GET_CODE (ad) == POST_DEC ++ || GET_CODE (ad) == PRE_DEC) ++ && REG_P (XEXP (ad, 0)) ++ && REGNO (XEXP (ad, 0)) < FIRST_PSEUDO_REGISTER ++ && ! REGNO_OK_FOR_BASE_P (REGNO (XEXP (ad, 0)))) ++ { ++ push_reload (XEXP (ad, 0), XEXP (ad, 0), &XEXP (ad, 0), &XEXP (ad, 0), ++ BASE_REG_CLASS, GET_MODE (XEXP (ad, 0)), GET_MODE (XEXP (ad, 0)), 0, 0, ++ opnum, RELOAD_OTHER); ++ return ad; ++ } ++ ++ return NULL_RTX; ++} ++ ++/* Compute a (partial) cost for rtx X. Return true if the complete ++ cost has been computed, and false if subexpressions should be ++ scanned. In either case, *TOTAL contains the cost result. */ ++ ++static bool ++ubicom32_rtx_costs (rtx x, int code, int outer_code, int *total, ++ bool speed ATTRIBUTE_UNUSED) ++{ ++ enum machine_mode mode = GET_MODE (x); ++ ++ switch (code) ++ { ++ case CONST_INT: ++ /* Very short constants often fold into instructions so ++ we pretend that they don't cost anything! This is ++ really important as regards zero values as otherwise ++ the compiler has a nasty habit of wanting to reuse ++ zeroes that are in regs but that tends to pessimize ++ the code. */ ++ if (satisfies_constraint_I (x)) ++ { ++ *total = 0; ++ return true; ++ } ++ ++ /* Bit clearing costs nothing */ ++ if (outer_code == AND ++ && exact_log2 (~INTVAL (x)) != -1) ++ { ++ *total = 0; ++ return true; ++ } ++ ++ /* Masking the lower set of bits costs nothing. */ ++ if (outer_code == AND ++ && exact_log2 (INTVAL (x) + 1) != -1) ++ { ++ *total = 0; ++ return true; ++ } ++ ++ /* Bit setting costs nothing. */ ++ if (outer_code == IOR ++ && exact_log2 (INTVAL (x)) != -1) ++ { ++ *total = 0; ++ return true; ++ } ++ ++ /* Larger constants that can be loaded via movei aren't too ++ bad. If we're just doing a set they cost nothing extra. */ ++ if (satisfies_constraint_N (x)) ++ { ++ if (mode == DImode) ++ *total = COSTS_N_INSNS (2); ++ else ++ *total = COSTS_N_INSNS (1); ++ return true; ++ } ++ ++ if (mode == DImode) ++ *total = COSTS_N_INSNS (5); ++ else ++ *total = COSTS_N_INSNS (3); ++ return true; ++ ++ case CONST_DOUBLE: ++ /* We don't optimize CONST_DOUBLEs well nor do we relax them well, ++ so their cost is very high. */ ++ *total = COSTS_N_INSNS (6); ++ return true; ++ ++ case CONST: ++ case SYMBOL_REF: ++ case MEM: ++ *total = 0; ++ return true; ++ ++ case IF_THEN_ELSE: ++ *total = COSTS_N_INSNS (1); ++ return true; ++ ++ case LABEL_REF: ++ case HIGH: ++ case LO_SUM: ++ case BSWAP: ++ case PLUS: ++ case MINUS: ++ case AND: ++ case IOR: ++ case XOR: ++ case ASHIFT: ++ case ASHIFTRT: ++ case LSHIFTRT: ++ case NEG: ++ case NOT: ++ case SIGN_EXTEND: ++ case ZERO_EXTEND: ++ case ZERO_EXTRACT: ++ if (outer_code == SET) ++ { ++ if (mode == DImode) ++ *total = COSTS_N_INSNS (2); ++ else ++ *total = COSTS_N_INSNS (1); ++ } ++ return true; ++ ++ case COMPARE: ++ if (outer_code == SET) ++ { ++ if (GET_MODE (XEXP (x, 0)) == DImode ++ || GET_MODE (XEXP (x, 1)) == DImode) ++ *total = COSTS_N_INSNS (2); ++ else ++ *total = COSTS_N_INSNS (1); ++ } ++ return true; ++ ++ case UMOD: ++ case UDIV: ++ case MOD: ++ case DIV: ++ if (outer_code == SET) ++ { ++ if (mode == DImode) ++ *total = COSTS_N_INSNS (600); ++ else ++ *total = COSTS_N_INSNS (200); ++ } ++ return true; ++ ++ case MULT: ++ if (outer_code == SET) ++ { ++ if (! ubicom32_v4) ++ { ++ if (mode == DImode) ++ *total = COSTS_N_INSNS (15); ++ else ++ *total = COSTS_N_INSNS (5); ++ } ++ else ++ { ++ if (mode == DImode) ++ *total = COSTS_N_INSNS (6); ++ else ++ *total = COSTS_N_INSNS (2); ++ } ++ } ++ return true; ++ ++ case UNSPEC: ++ if (XINT (x, 1) == UNSPEC_FDPIC_GOT ++ || XINT (x, 1) == UNSPEC_FDPIC_GOT_FUNCDESC) ++ *total = 0; ++ return true; ++ ++ default: ++ return false; ++ } ++} ++ ++/* Return 1 if ADDR can have different meanings depending on the machine ++ mode of the memory reference it is used for or if the address is ++ valid for some modes but not others. ++ ++ Autoincrement and autodecrement addresses typically have ++ mode-dependent effects because the amount of the increment or ++ decrement is the size of the operand being addressed. Some machines ++ have other mode-dependent addresses. Many RISC machines have no ++ mode-dependent addresses. ++ ++ You may assume that ADDR is a valid address for the machine. */ ++ ++int ++ubicom32_mode_dependent_address_p (rtx addr) ++{ ++ if (GET_CODE (addr) == POST_INC ++ || GET_CODE (addr) == PRE_INC ++ || GET_CODE (addr) == POST_DEC ++ || GET_CODE (addr) == PRE_DEC ++ || GET_CODE (addr) == POST_MODIFY ++ || GET_CODE (addr) == PRE_MODIFY) ++ return 1; ++ ++ return 0; ++} ++ ++static void ++ubicom32_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED) ++{ ++ fprintf (file, "/* frame/pretend: %ld/%d save_regs: %d out_args: %d %s */\n", ++ get_frame_size (), crtl->args.pretend_args_size, ++ save_regs_size, crtl->outgoing_args_size, ++ current_function_is_leaf ? "leaf" : "nonleaf"); ++} ++ ++static void ++ubicom32_function_epilogue (FILE *file ATTRIBUTE_UNUSED, ++ HOST_WIDE_INT size ATTRIBUTE_UNUSED) ++{ ++ ubicom32_reorg_completed = 0; ++} ++ ++static void ++ubicom32_machine_dependent_reorg (void) ++{ ++#if 0 /* Commenting out this optimization until it is fixed */ ++ if (optimize) ++ { ++ compute_bb_for_insn (); ++ ++ /* Do a very simple CSE pass over just the hard registers. */ ++ reload_cse_regs (get_insns ()); ++ ++ /* Reload_cse_regs can eliminate potentially-trapping MEMs. ++ Remove any EH edges associated with them. */ ++ if (flag_non_call_exceptions) ++ purge_all_dead_edges (); ++ } ++#endif ++ ubicom32_reorg_completed = 1; ++} ++ ++void ++ubicom32_output_cond_jump (rtx insn, rtx cond, rtx target) ++{ ++ rtx note; ++ int mostly_false_jump; ++ rtx xoperands[2]; ++ rtx cc_reg; ++ ++ note = find_reg_note (insn, REG_BR_PROB, 0); ++ mostly_false_jump = !note || (INTVAL (XEXP (note, 0)) ++ <= REG_BR_PROB_BASE / 2); ++ ++ xoperands[0] = target; ++ xoperands[1] = cond; ++ cc_reg = XEXP (cond, 0); ++ ++ if (GET_MODE (cc_reg) == CCWmode ++ || GET_MODE (cc_reg) == CCWZmode ++ || GET_MODE (cc_reg) == CCWZNmode) ++ { ++ if (mostly_false_jump) ++ output_asm_insn ("jmp%b1.w.f\t%0", xoperands); ++ else ++ output_asm_insn ("jmp%b1.w.t\t%0", xoperands); ++ return; ++ } ++ ++ if (GET_MODE (cc_reg) == CCSmode ++ || GET_MODE (cc_reg) == CCSZmode ++ || GET_MODE (cc_reg) == CCSZNmode) ++ { ++ if (mostly_false_jump) ++ output_asm_insn ("jmp%b1.s.f\t%0", xoperands); ++ else ++ output_asm_insn ("jmp%b1.s.t\t%0", xoperands); ++ return; ++ } ++ ++ abort (); ++} ++ ++/* Return non-zero if FUNC is a naked function. */ ++ ++static int ++ubicom32_naked_function_p (void) ++{ ++ return lookup_attribute ("naked", DECL_ATTRIBUTES (current_function_decl)) != NULL_TREE; ++} ++ ++/* Return an RTX indicating where the return address to the ++ calling function can be found. */ ++rtx ++ubicom32_return_addr_rtx (int count, rtx frame ATTRIBUTE_UNUSED) ++{ ++ if (count != 0) ++ return NULL_RTX; ++ ++ return get_hard_reg_initial_val (Pmode, LINK_REGNO); ++} ++ ++/* ++ * ubicom32_readonly_data_section: This routtine handles code ++ * at the start of readonly data sections ++ */ ++static void ++ubicom32_readonly_data_section (const void *data ATTRIBUTE_UNUSED) ++{ ++ static int num = 0; ++ if (in_section == readonly_data_section){ ++ fprintf (asm_out_file, "%s", DATA_SECTION_ASM_OP); ++ if (flag_data_sections){ ++ fprintf (asm_out_file, ".rodata%d", num); ++ fprintf (asm_out_file, ",\"a\""); ++ } ++ fprintf (asm_out_file, "\n"); ++ } ++ num++; ++} ++ ++/* ++ * ubicom32_text_section: not in readonly section ++ */ ++static void ++ubicom32_text_section(const void *data ATTRIBUTE_UNUSED) ++{ ++ fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP); ++} ++ ++/* ++ * ubicom32_data_section: not in readonly section ++ */ ++static void ++ubicom32_data_section(const void *data ATTRIBUTE_UNUSED) ++{ ++ fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP); ++} ++ ++/* ++ * ubicom32_asm_init_sections: This routine implements special ++ * section handling ++ */ ++static void ++ubicom32_asm_init_sections(void) ++{ ++ text_section = get_unnamed_section(SECTION_CODE, ubicom32_text_section, NULL); ++ ++ data_section = get_unnamed_section(SECTION_WRITE, ubicom32_data_section, NULL); ++ ++ readonly_data_section = get_unnamed_section(0, ubicom32_readonly_data_section, NULL); ++} ++ ++/* ++ * ubicom32_profiler: This routine would call ++ * mcount to support prof and gprof if mcount ++ * was supported. Currently, do nothing. ++ */ ++void ++ubicom32_profiler(void) ++{ ++} ++ ++/* Initialise the builtin functions. Start by initialising ++ descriptions of different types of functions (e.g., void fn(int), ++ int fn(void)), and then use these to define the builtins. */ ++static void ++ubicom32_init_builtins (void) ++{ ++ tree endlink; ++ tree short_unsigned_endlink; ++ tree unsigned_endlink; ++ tree short_unsigned_ftype_short_unsigned; ++ tree unsigned_ftype_unsigned; ++ ++ endlink = void_list_node; ++ ++ short_unsigned_endlink ++ = tree_cons (NULL_TREE, short_unsigned_type_node, endlink); ++ ++ unsigned_endlink ++ = tree_cons (NULL_TREE, unsigned_type_node, endlink); ++ ++ short_unsigned_ftype_short_unsigned ++ = build_function_type (short_unsigned_type_node, short_unsigned_endlink); ++ ++ unsigned_ftype_unsigned ++ = build_function_type (unsigned_type_node, unsigned_endlink); ++ ++ /* Initialise the byte swap function. */ ++ add_builtin_function ("__builtin_ubicom32_swapb_2", ++ short_unsigned_ftype_short_unsigned, ++ UBICOM32_BUILTIN_UBICOM32_SWAPB_2, ++ BUILT_IN_MD, NULL, ++ NULL_TREE); ++ ++ /* Initialise the byte swap function. */ ++ add_builtin_function ("__builtin_ubicom32_swapb_4", ++ unsigned_ftype_unsigned, ++ UBICOM32_BUILTIN_UBICOM32_SWAPB_4, ++ BUILT_IN_MD, NULL, ++ NULL_TREE); ++} ++ ++/* Given a builtin function taking 2 operands (i.e., target + source), ++ emit the RTL for the underlying instruction. */ ++static rtx ++ubicom32_expand_builtin_2op (enum insn_code icode, tree arglist, rtx target) ++{ ++ tree arg0; ++ rtx op0, pat; ++ enum machine_mode tmode, mode0; ++ ++ /* Grab the incoming argument and emit its RTL. */ ++ arg0 = TREE_VALUE (arglist); ++ op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0); ++ ++ /* Determine the modes of the instruction operands. */ ++ tmode = insn_data[icode].operand[0].mode; ++ mode0 = insn_data[icode].operand[1].mode; ++ ++ /* Ensure that the incoming argument RTL is in a register of the ++ correct mode. */ ++ if (!(*insn_data[icode].operand[1].predicate) (op0, mode0)) ++ op0 = copy_to_mode_reg (mode0, op0); ++ ++ /* If there isn't a suitable target, emit a target register. */ ++ if (target == 0 ++ || GET_MODE (target) != tmode ++ || !(*insn_data[icode].operand[0].predicate) (target, tmode)) ++ target = gen_reg_rtx (tmode); ++ ++ /* Emit and return the new instruction. */ ++ pat = GEN_FCN (icode) (target, op0); ++ if (!pat) ++ return 0; ++ emit_insn (pat); ++ ++ return target; ++} ++ ++/* Expand a call to a builtin function. */ ++static rtx ++ubicom32_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED, ++ enum machine_mode mode ATTRIBUTE_UNUSED, ++ int ignore ATTRIBUTE_UNUSED) ++{ ++ tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0); ++ tree arglist = CALL_EXPR_ARGS(exp); ++ int fcode = DECL_FUNCTION_CODE (fndecl); ++ ++ switch (fcode) ++ { ++ case UBICOM32_BUILTIN_UBICOM32_SWAPB_2: ++ return ubicom32_expand_builtin_2op (CODE_FOR_bswaphi, arglist, target); ++ ++ case UBICOM32_BUILTIN_UBICOM32_SWAPB_4: ++ return ubicom32_expand_builtin_2op (CODE_FOR_bswapsi, arglist, target); ++ ++ default: ++ gcc_unreachable(); ++ } ++ ++ /* Should really do something sensible here. */ ++ return NULL_RTX; ++} ++ ++/* Fold any constant argument for a swapb.2 instruction. */ ++static tree ++ubicom32_fold_builtin_ubicom32_swapb_2 (tree fndecl, tree arglist) ++{ ++ tree arg0; ++ ++ arg0 = TREE_VALUE (arglist); ++ ++ /* Optimize constant value. */ ++ if (TREE_CODE (arg0) == INTEGER_CST) ++ { ++ HOST_WIDE_INT v; ++ HOST_WIDE_INT res; ++ ++ v = TREE_INT_CST_LOW (arg0); ++ res = ((v >> 8) & 0xff) ++ | ((v & 0xff) << 8); ++ ++ return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), res); ++ } ++ ++ return NULL_TREE; ++} ++ ++/* Fold any constant argument for a swapb.4 instruction. */ ++static tree ++ubicom32_fold_builtin_ubicom32_swapb_4 (tree fndecl, tree arglist) ++{ ++ tree arg0; ++ ++ arg0 = TREE_VALUE (arglist); ++ ++ /* Optimize constant value. */ ++ if (TREE_CODE (arg0) == INTEGER_CST) ++ { ++ unsigned HOST_WIDE_INT v; ++ unsigned HOST_WIDE_INT res; ++ ++ v = TREE_INT_CST_LOW (arg0); ++ res = ((v >> 24) & 0xff) ++ | (((v >> 16) & 0xff) << 8) ++ | (((v >> 8) & 0xff) << 16) ++ | ((v & 0xff) << 24); ++ ++ return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), res, 0); ++ } ++ ++ return NULL_TREE; ++} ++ ++/* Fold any constant arguments for builtin functions. */ ++static tree ++ubicom32_fold_builtin (tree fndecl, tree arglist, bool ignore ATTRIBUTE_UNUSED) ++{ ++ switch (DECL_FUNCTION_CODE (fndecl)) ++ { ++ case UBICOM32_BUILTIN_UBICOM32_SWAPB_2: ++ return ubicom32_fold_builtin_ubicom32_swapb_2 (fndecl, arglist); ++ ++ case UBICOM32_BUILTIN_UBICOM32_SWAPB_4: ++ return ubicom32_fold_builtin_ubicom32_swapb_4 (fndecl, arglist); ++ ++ default: ++ return NULL; ++ } ++} ++ ++/* Implementation of TARGET_ASM_INTEGER. When using FD-PIC, we need to ++ tell the assembler to generate pointers to function descriptors in ++ some cases. */ ++static bool ++ubicom32_assemble_integer (rtx value, unsigned int size, int aligned_p) ++{ ++ if (TARGET_FDPIC && size == UNITS_PER_WORD) ++ { ++ if (GET_CODE (value) == SYMBOL_REF ++ && SYMBOL_REF_FUNCTION_P (value)) ++ { ++ fputs ("\t.picptr\t%funcdesc(", asm_out_file); ++ output_addr_const (asm_out_file, value); ++ fputs (")\n", asm_out_file); ++ return true; ++ } ++ ++ if (!aligned_p) ++ { ++ /* We've set the unaligned SI op to NULL, so we always have to ++ handle the unaligned case here. */ ++ assemble_integer_with_op ("\t.4byte\t", value); ++ return true; ++ } ++ } ++ ++ return default_assemble_integer (value, size, aligned_p); ++} ++ ++/* If the constant I can be constructed by shifting a source-1 immediate ++ by a constant number of bits then return the bit count. If not ++ return 0. */ ++ ++int ++ubicom32_shiftable_const_int (int i) ++{ ++ int shift = 0; ++ ++ /* Note that any constant that can be represented as an immediate to ++ a movei instruction is automatically ignored here in the interests ++ of the clarity of the output asm code. */ ++ if (i >= -32768 && i <= 32767) ++ return 0; ++ ++ /* Find the number of trailing zeroes. We could use __builtin_ctz ++ here but it's not obvious if this is supported on all build ++ compilers so we err on the side of caution. */ ++ if ((i & 0xffff) == 0) ++ { ++ shift += 16; ++ i >>= 16; ++ } ++ ++ if ((i & 0xff) == 0) ++ { ++ shift += 8; ++ i >>= 8; ++ } ++ ++ if ((i & 0xf) == 0) ++ { ++ shift += 4; ++ i >>= 4; ++ } ++ ++ if ((i & 0x3) == 0) ++ { ++ shift += 2; ++ i >>= 2; ++ } ++ ++ if ((i & 0x1) == 0) ++ { ++ shift += 1; ++ i >>= 1; ++ } ++ ++ if (i >= -128 && i <= 127) ++ return shift; ++ ++ return 0; ++} ++ +--- /dev/null ++++ b/gcc/config/ubicom32/ubicom32.h +@@ -0,0 +1,1564 @@ ++/* Definitions of target machine for Ubicom32 ++ ++ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, ++ 2009 Free Software Foundation, Inc. ++ Contributed by Ubicom, Inc. ++ ++ This file is part of GCC. ++ ++ GCC is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published ++ by the Free Software Foundation; either version 3, or (at your ++ option) any later version. ++ ++ GCC 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 GCC; see the file COPYING3. If not see ++ . */ ++ ++ ++ ++#define OBJECT_FORMAT_ELF ++ ++/* Run-time target specifications. */ ++ ++/* Target CPU builtins. */ ++#define TARGET_CPU_CPP_BUILTINS() \ ++ do \ ++ { \ ++ builtin_define_std ("__UBICOM32__"); \ ++ builtin_define_std ("__ubicom32__"); \ ++ \ ++ if (TARGET_FDPIC) \ ++ { \ ++ builtin_define ("__UBICOM32_FDPIC__"); \ ++ builtin_define ("__FDPIC__"); \ ++ } \ ++ } \ ++ while (0) ++ ++#ifndef TARGET_DEFAULT ++#define TARGET_DEFAULT 0 ++#endif ++ ++extern int ubicom32_case_values_threshold; ++ ++/* Nonzero if this chip supports the Ubicom32 v3 ISA. */ ++extern int ubicom32_v3; ++ ++/* Nonzero if this chip supports the Ubicom32 v4 ISA. */ ++extern int ubicom32_v4; ++ ++extern int ubicom32_stack_size; ++ ++/* Flag for whether we can use calli instead of ret in returns. */ ++extern int ubicom32_can_use_calli_to_ret; ++ ++/* This macro is a C statement to print on `stderr' a string describing the ++ particular machine description choice. Every machine description should ++ define `TARGET_VERSION'. */ ++#define TARGET_VERSION fprintf (stderr, " (UBICOM32)"); ++ ++/* We don't need a frame pointer to debug things. Doing this means ++ that gcc can turn on -fomit-frame-pointer when '-O' is specified. */ ++#define CAN_DEBUG_WITHOUT_FP ++ ++/* We need to handle processor-specific options. */ ++#define OVERRIDE_OPTIONS ubicom32_override_options () ++ ++#define OPTIMIZATION_OPTIONS(LEVEL, SIZE) \ ++ ubicom32_optimization_options (LEVEL, SIZE) ++ ++/* For Ubicom32 the least significant bit has the lowest bit number ++ so we define this to be 0. */ ++#define BITS_BIG_ENDIAN 0 ++ ++/* For Ubicom32 the most significant byte in a word has the lowest ++ number. */ ++#define BYTES_BIG_ENDIAN 1 ++ ++/* For Ubicom32, in a multiword object, the most signifant word has the ++ lowest number. */ ++#define WORDS_BIG_ENDIAN 1 ++ ++/* Ubicom32 has 8 bits per byte. */ ++#define BITS_PER_UNIT 8 ++ ++/* Ubicom32 has 32 bits per word. */ ++#define BITS_PER_WORD 32 ++ ++/* Width of a word, in units (bytes). */ ++#define UNITS_PER_WORD 4 ++ ++/* Width of a pointer, in bits. */ ++#define POINTER_SIZE 32 ++ ++/* Alias for pointers. Ubicom32 is a 32-bit architecture so we use ++ SImode. */ ++#define Pmode SImode ++ ++/* Normal alignment required for function parameters on the stack, in ++ bits. */ ++#define PARM_BOUNDARY 32 ++ ++/* We need to maintain the stack on a 32-bit boundary. */ ++#define STACK_BOUNDARY 32 ++ ++/* Alignment required for a function entry point, in bits. */ ++#define FUNCTION_BOUNDARY 32 ++ ++/* Alias for the machine mode used for memory references to functions being ++ called, in `call' RTL expressions. We use byte-oriented addresses ++ here. */ ++#define FUNCTION_MODE QImode ++ ++/* Biggest alignment that any data type can require on this machine, ++ in bits. */ ++#define BIGGEST_ALIGNMENT 32 ++ ++/* this default to BIGGEST_ALIGNMENT unless defined */ ++/* ART: What's the correct value here? Default is (((unsigned int)1<<28)*8)*/ ++#undef MAX_OFILE_ALIGNMENT ++#define MAX_OFILE_ALIGNMENT (128 * 8) ++ ++/* Alignment in bits to be given to a structure bit field that follows an empty ++ field such as `int : 0;'. */ ++#define EMPTY_FIELD_BOUNDARY 32 ++ ++/* All structures must be a multiple of 32 bits in size. */ ++#define STRUCTURE_SIZE_BOUNDARY 32 ++ ++/* A bit-field declared as `int' forces `int' alignment for the struct. */ ++#define PCC_BITFIELD_TYPE_MATTERS 1 ++ ++/* For Ubicom32 we absolutely require that data be aligned with nominal ++ alignment. */ ++#define STRICT_ALIGNMENT 1 ++ ++/* Make strcpy of constants fast. */ ++#define CONSTANT_ALIGNMENT(EXP, ALIGN) \ ++ (TREE_CODE (EXP) == STRING_CST \ ++ && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN)) ++ ++/* Define this macro as an expression for the alignment of a structure ++ (given by STRUCT as a tree node) if the alignment computed in the ++ usual way is COMPUTED and the alignment explicitly specified was ++ SPECIFIED. */ ++#define DATA_ALIGNMENT(TYPE, ALIGN) \ ++ ((((ALIGN) < BITS_PER_WORD) \ ++ && (TREE_CODE (TYPE) == ARRAY_TYPE \ ++ || TREE_CODE (TYPE) == UNION_TYPE \ ++ || TREE_CODE (TYPE) == RECORD_TYPE)) ? BITS_PER_WORD : (ALIGN)) ++ ++#define LOCAL_ALIGNMENT(TYPE,ALIGN) DATA_ALIGNMENT(TYPE,ALIGN) ++ ++/* For Ubicom32 we default to unsigned chars. */ ++#define DEFAULT_SIGNED_CHAR 0 ++ ++/* Machine-specific data register numbers. */ ++#define FIRST_DATA_REGNUM 0 ++#define D10_REGNUM 10 ++#define D11_REGNUM 11 ++#define D12_REGNUM 12 ++#define D13_REGNUM 13 ++#define LAST_DATA_REGNUM 15 ++ ++/* Machine-specific address register numbers. */ ++#define FIRST_ADDRESS_REGNUM 16 ++#define LAST_ADDRESS_REGNUM 22 ++ ++/* Register numbers used for passing a function's static chain pointer. If ++ register windows are used, the register number as seen by the called ++ function is `STATIC_CHAIN_INCOMING_REGNUM', while the register number as ++ seen by the calling function is `STATIC_CHAIN_REGNUM'. If these registers ++ are the same, `STATIC_CHAIN_INCOMING_REGNUM' need not be defined. ++ ++ The static chain register need not be a fixed register. ++ ++ If the static chain is passed in memory, these macros should not be defined; ++ instead, the next two macros should be defined. */ ++#define STATIC_CHAIN_REGNUM (FIRST_ADDRESS_REGNUM + 1) ++ ++/* The register number of the frame pointer register, which is used to access ++ automatic variables in the stack frame. We generally eliminate this anyway ++ for Ubicom32 but we make it A6 by default. */ ++#define FRAME_POINTER_REGNUM (LAST_ADDRESS_REGNUM) ++ ++/* The register number of the stack pointer register, which is also be a ++ fixed register according to `FIXED_REGISTERS'. For Ubicom32 we don't ++ have a hardware requirement about which register this is, but by convention ++ we use A7. */ ++#define STACK_POINTER_REGNUM (LAST_ADDRESS_REGNUM + 1) ++ ++/* Machine-specific accumulator register numbers. */ ++#define ACC0_HI_REGNUM 24 ++#define ACC0_LO_REGNUM 25 ++#define ACC1_HI_REGNUM 26 ++#define ACC1_LO_REGNUM 27 ++ ++/* source3 register number */ ++#define SOURCE3_REGNUM 28 ++ ++/* The register number of the arg pointer register, which is used to access the ++ function's argument list. On some machines, this is the same as the frame ++ pointer register. On some machines, the hardware determines which register ++ this is. On other machines, you can choose any register you wish for this ++ purpose. If this is not the same register as the frame pointer register, ++ then you must mark it as a fixed register according to `FIXED_REGISTERS', or ++ arrange to be able to eliminate it. */ ++#define ARG_POINTER_REGNUM 29 ++ ++/* Pseudo-reg for condition code. */ ++#define CC_REGNUM 30 ++ ++/* Interrupt set/clear registers. */ ++#define INT_SET0_REGNUM 31 ++#define INT_SET1_REGNUM 32 ++#define INT_CLR0_REGNUM 33 ++#define INT_CLR1_REGNUM 34 ++ ++/* Scratchpad registers. */ ++#define SCRATCHPAD0_REGNUM 35 ++#define SCRATCHPAD1_REGNUM 36 ++#define SCRATCHPAD2_REGNUM 37 ++#define SCRATCHPAD3_REGNUM 38 ++ ++/* FDPIC register. */ ++#define FDPIC_REGNUM 16 ++ ++/* Number of hardware registers known to the compiler. They receive numbers 0 ++ through `FIRST_PSEUDO_REGISTER-1'; thus, the first pseudo register's number ++ really is assigned the number `FIRST_PSEUDO_REGISTER'. */ ++#define FIRST_PSEUDO_REGISTER 39 ++ ++/* An initializer that says which registers are used for fixed purposes all ++ throughout the compiled code and are therefore not available for general ++ allocation. These would include the stack pointer, the frame pointer ++ (except on machines where that can be used as a general register when no ++ frame pointer is needed), the program counter on machines where that is ++ considered one of the addressable registers, and any other numbered register ++ with a standard use. ++ ++ This information is expressed as a sequence of numbers, separated by commas ++ and surrounded by braces. The Nth number is 1 if register N is fixed, 0 ++ otherwise. ++ ++ The table initialized from this macro, and the table initialized by the ++ following one, may be overridden at run time either automatically, by the ++ actions of the macro `CONDITIONAL_REGISTER_USAGE', or by the user with the ++ command options `-ffixed-REG', `-fcall-used-REG' and `-fcall-saved-REG'. */ ++#define FIXED_REGISTERS \ ++ { \ ++ 0, 0, 0, 0, 0, 0, 0, 0, /* d0 - d7 */ \ ++ 0, 0, 0, 0, 0, 0, 0, 1, /* d8 - d15 */ \ ++ 0, 0, 0, 0, 0, 0, 0, 1, /* a0 - a7 */ \ ++ 0, 0, /* acc0 hi/lo */ \ ++ 0, 0, /* acc1 hi/lo */ \ ++ 0, /* source3 */ \ ++ 1, /* arg */ \ ++ 1, /* cc */ \ ++ 1, 1, /* int_set[01] */ \ ++ 1, 1, /* int_clr[01] */ \ ++ 1, 1, 1, 1 /* scratchpad[0123] */ \ ++ } ++ ++/* Like `FIXED_REGISTERS' but has 1 for each register that is clobbered (in ++ general) by function calls as well as for fixed registers. This macro ++ therefore identifies the registers that are not available for general ++ allocation of values that must live across function calls. ++ ++ If a register has 0 in `CALL_USED_REGISTERS', the compiler automatically ++ saves it on function entry and restores it on function exit, if the register ++ is used within the function. */ ++#define CALL_USED_REGISTERS \ ++ { \ ++ 1, 1, 1, 1, 1, 1, 1, 1, /* d0 - d7 */ \ ++ 1, 1, 0, 0, 0, 0, 1, 1, /* d8 - d15 */ \ ++ 1, 0, 0, 1, 1, 1, 0, 1, /* a0 - a7 */ \ ++ 1, 1, /* acc0 hi/lo */ \ ++ 1, 1, /* acc1 hi/lo */ \ ++ 1, /* source3 */ \ ++ 1, /* arg */ \ ++ 1, /* cc */ \ ++ 1, 1, /* int_set[01] */ \ ++ 1, 1, /* int_clr[01] */ \ ++ 1, 1, 1, 1 /* scratchpad[0123] */ \ ++ } ++ ++/* How to refer to registers in assembler output. ++ This sequence is indexed by compiler's hard-register-number (see above). */ ++ ++/* A C initializer containing the assembler's names for the machine registers, ++ each one as a C string constant. This is what translates register numbers ++ in the compiler into assembler language. */ ++#define REGISTER_NAMES \ ++ { \ ++ "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", \ ++ "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15", \ ++ "a0", "a1", "a2", "a3", "a4", "a5", "a6", "sp", \ ++ "acc0_hi", "acc0_lo", \ ++ "acc1_hi", "acc1_lo", \ ++ "source3", \ ++ "arg", \ ++ "cc", \ ++ "int_set0", "int_set1", \ ++ "int_clr0", "int_clr1", \ ++ "scratchpad0", "scratchpad1", "scratchpad2", "scratchpad3" \ ++ } ++ ++#define CONDITIONAL_REGISTER_USAGE \ ++ ubicom32_conditional_register_usage (); ++ ++/* Order of allocation of registers. */ ++ ++/* If defined, an initializer for a vector of integers, containing the numbers ++ of hard registers in the order in which GNU CC should prefer to use them ++ (from most preferred to least). ++ ++ For Ubicom32 we try using caller-clobbered data registers first, then ++ callee-saved data registers, then caller-clobbered address registers, ++ then callee-saved address registers and finally everything else. ++ ++ The caller-clobbered registers are usually slightly cheaper to use because ++ there's no need to save/restore. */ ++#define REG_ALLOC_ORDER \ ++ { \ ++ 0, 1, 2, 3, 4, /* d0 - d4 */ \ ++ 5, 6, 7, 8, 9, /* d5 - d9 */ \ ++ 14, /* d14 */ \ ++ 10, 11, 12, 13, /* d10 - d13 */ \ ++ 19, 20, 16, 21, /* a3, a4, a0, a5 */ \ ++ 17, 18, 22, /* a1, a2, a6 */ \ ++ 24, 25, /* acc0 hi/lo */ \ ++ 26, 27, /* acc0 hi/lo */ \ ++ 28 /* source3 */ \ ++ } ++ ++/* C expression for the number of consecutive hard registers, starting at ++ register number REGNO, required to hold a value of mode MODE. */ ++#define HARD_REGNO_NREGS(REGNO, MODE) \ ++ ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) ++ ++/* Most registers can hold QImode, HImode and SImode values but we have to ++ be able to indicate any hard registers that cannot hold values with some ++ modes. */ ++#define HARD_REGNO_MODE_OK(REGNO, MODE) \ ++ ubicom32_hard_regno_mode_ok(REGNO, MODE) ++ ++/* We can rename most registers aside from the FDPIC register if we're using ++ FDPIC. */ ++#define HARD_REGNO_RENAME_OK(from, to) (TARGET_FDPIC ? ((to) != FDPIC_REGNUM) : 1) ++ ++/* A C expression that is nonzero if it is desirable to choose register ++ allocation so as to avoid move instructions between a value of mode MODE1 ++ and a value of mode MODE2. ++ ++ If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R, MODE2)' are ++ ever different for any R, then `MODES_TIEABLE_P (MODE1, MODE2)' must be ++ zero. */ ++#define MODES_TIEABLE_P(MODE1, MODE2) 1 ++ ++/* An enumeral type that must be defined with all the register class names as ++ enumeral values. `NO_REGS' must be first. `ALL_REGS' must be the last ++ register class, followed by one more enumeral value, `LIM_REG_CLASSES', ++ which is not a register class but rather tells how many classes there are. ++ ++ Each register class has a number, which is the value of casting the class ++ name to type `int'. The number serves as an index in many of the tables ++ described below. */ ++ ++enum reg_class ++{ ++ NO_REGS, ++ DATA_REGS, ++ FDPIC_REG, ++ ADDRESS_REGS, ++ ALL_ADDRESS_REGS, ++ ACC_LO_REGS, ++ ACC_REGS, ++ CC_REG, ++ DATA_ACC_REGS, ++ SOURCE3_REG, ++ SPECIAL_REGS, ++ GENERAL_REGS, ++ ALL_REGS, ++ LIM_REG_CLASSES ++}; ++ ++/* The number of distinct register classes. */ ++#define N_REG_CLASSES (int) LIM_REG_CLASSES ++ ++/* An initializer containing the names of the register classes as C string ++ constants. These names are used in writing some of the debugging dumps. */ ++ ++#define REG_CLASS_NAMES \ ++{ \ ++ "NO_REGS", \ ++ "DATA_REGS", \ ++ "FDPIC_REG", \ ++ "ADDRESS_REGS", \ ++ "ALL_ADDRESS_REGS", \ ++ "ACC_LO_REGS", \ ++ "ACC_REGS", \ ++ "CC_REG", \ ++ "DATA_ACC_REGS", \ ++ "SOURCE3_REG", \ ++ "SPECIAL_REGS", \ ++ "GENERAL_REGS", \ ++ "ALL_REGS", \ ++ "LIM_REGS" \ ++} ++ ++/* An initializer containing the contents of the register classes, as integers ++ which are bit masks. The Nth integer specifies the contents of class N. ++ The way the integer MASK is interpreted is that register R is in the class ++ if `MASK & (1 << R)' is 1. ++ ++ When the machine has more than 32 registers, an integer does not suffice. ++ Then the integers are replaced by sub-initializers, braced groupings ++ containing several integers. Each sub-initializer must be suitable as an ++ initializer for the type `HARD_REG_SET' which is defined in ++ `hard-reg-set.h'. */ ++#define REG_CLASS_CONTENTS \ ++{ \ ++ {0x00000000, 0x00000000}, /* No regs */ \ ++ {0x0000ffff, 0x00000000}, /* DATA_REGS */ \ ++ {0x00010000, 0x00000000}, /* FDPIC_REG */ \ ++ {0x20fe0000, 0x00000000}, /* ADDRESS_REGS */ \ ++ {0x20ff0000, 0x00000000}, /* ALL_ADDRESS_REGS */ \ ++ {0x0a000000, 0x00000000}, /* ACC_LO_REGS */ \ ++ {0x0f000000, 0x00000000}, /* ACC_REGS */ \ ++ {0x40000000, 0x00000000}, /* CC_REG */ \ ++ {0x0f00ffff, 0x00000000}, /* DATA_ACC_REGS */ \ ++ {0x10000000, 0x00000000}, /* SOURGE3_REG */ \ ++ {0x80000000, 0x0000007f}, /* SPECIAL_REGS */ \ ++ {0xbfffffff, 0x0000007f}, /* GENERAL_REGS */ \ ++ {0xbfffffff, 0x0000007f} /* ALL_REGS */ \ ++} ++ ++extern enum reg_class const ubicom32_regclass_map[FIRST_PSEUDO_REGISTER]; ++ ++/* A C expression whose value is a register class containing hard register ++ REGNO. In general there is more than one such class; choose a class which ++ is "minimal", meaning that no smaller class also contains the register. */ ++#define REGNO_REG_CLASS(REGNO) (ubicom32_regclass_map[REGNO]) ++ ++#define IRA_COVER_CLASSES \ ++{ \ ++ GENERAL_REGS, \ ++ LIM_REG_CLASSES \ ++} ++ ++/* Ubicom32 base registers must be address registers since addresses can ++ only be reached via address registers. */ ++#define BASE_REG_CLASS ALL_ADDRESS_REGS ++ ++/* Ubicom32 index registers must be data registers since we cannot add ++ two address registers together to form an address. */ ++#define INDEX_REG_CLASS DATA_REGS ++ ++/* A C expression which is nonzero if register number NUM is suitable for use ++ as a base register in operand addresses. It may be either a suitable hard ++ register or a pseudo register that has been allocated such a hard register. */ ++ ++#ifndef REG_OK_STRICT ++#define REGNO_OK_FOR_BASE_P(regno) \ ++ ubicom32_regno_ok_for_base_p (regno, 0) ++#else ++#define REGNO_OK_FOR_BASE_P(regno) \ ++ ubicom32_regno_ok_for_base_p (regno, 1) ++#endif ++ ++/* A C expression which is nonzero if register number NUM is suitable for use ++ as an index register in operand addresses. It may be either a suitable hard ++ register or a pseudo register that has been allocated such a hard register. ++ ++ The difference between an index register and a base register is that the ++ index register may be scaled. If an address involves the sum of two ++ registers, neither one of them scaled, then either one may be labeled the ++ "base" and the other the "index"; but whichever labeling is used must fit ++ the machine's constraints of which registers may serve in each capacity. ++ The compiler will try both labelings, looking for one that is valid, and ++ will reload one or both registers only if neither labeling works. */ ++#ifndef REG_OK_STRICT ++#define REGNO_OK_FOR_INDEX_P(regno) \ ++ ubicom32_regno_ok_for_index_p (regno, 0) ++#else ++#define REGNO_OK_FOR_INDEX_P(regno) \ ++ ubicom32_regno_ok_for_index_p (regno, 1) ++#endif ++ ++/* Attempt to restrict the register class we need to copy value X intoto the ++ would-be register class CLASS. Most things are fine for Ubicom32 but we ++ have to restrict certain types of address loads. */ ++#define PREFERRED_RELOAD_CLASS(X, CLASS) \ ++ ubicom32_preferred_reload_class (X, CLASS) ++ ++/* A C expression for the maximum number of consecutive registers of ++ class CLASS needed to hold a value of mode MODE. For Ubicom32 this ++ is pretty much identical to HARD_REGNO_NREGS. */ ++#define CLASS_MAX_NREGS(CLASS, MODE) \ ++ ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) ++ ++/* For Ubicom32 the stack grows downwards when we push a word onto the stack ++ - i.e. it moves to a smaller address. */ ++#define STACK_GROWS_DOWNWARD 1 ++ ++/* Offset from the frame pointer to the first local variable slot to ++ be allocated. */ ++#define STARTING_FRAME_OFFSET 0 ++ ++/* Offset from the argument pointer register to the first argument's ++ address. */ ++#define FIRST_PARM_OFFSET(FNDECL) 0 ++ ++/* A C expression whose value is RTL representing the value of the return ++ address for the frame COUNT steps up from the current frame, after the ++ prologue. FRAMEADDR is the frame pointer of the COUNT frame, or the frame ++ pointer of the COUNT - 1 frame if `RETURN_ADDR_IN_PREVIOUS_FRAME' is ++ defined. ++ ++ The value of the expression must always be the correct address when COUNT is ++ zero, but may be `NULL_RTX' if there is not way to determine the return ++ address of other frames. */ ++#define RETURN_ADDR_RTX(COUNT, FRAME) \ ++ ubicom32_return_addr_rtx (COUNT, FRAME) ++ ++/* Register That Address the Stack Frame. */ ++ ++/* We don't actually require a frame pointer in most functions with the ++ Ubicom32 architecture so we allow it to be eliminated. */ ++#define FRAME_POINTER_REQUIRED 0 ++ ++/* Macro that defines a table of register pairs used to eliminate unecessary ++ registers that point into the stack frame. ++ ++ For Ubicom32 we don't generally need an arg pointer of a frame pointer ++ so we allow the arg pointer to be replaced by either the frame pointer or ++ the stack pointer. We also allow the frame pointer to be replaced by ++ the stack pointer. */ ++#define ELIMINABLE_REGS \ ++{ \ ++ {ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ ++ {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \ ++ {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM} \ ++} ++ ++/* Let the compiler know that we want to use the ELIMINABLE_REGS macro ++ above. */ ++#define CAN_ELIMINATE(FROM, TO) 1 ++ ++/* This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'. It specifies the ++ initial difference between the specified pair of registers. This macro must ++ be defined if `ELIMINABLE_REGS' is defined. */ ++#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ ++ (OFFSET) = ubicom32_initial_elimination_offset (FROM, TO) ++ ++/* If defined, the maximum amount of space required for outgoing arguments will ++ be computed and placed into the variable ++ `current_function_outgoing_args_size'. No space will be pushed onto the ++ stack for each call; instead, the function prologue should increase the ++ stack frame size by this amount. ++ ++ Defining both `PUSH_ROUNDING' and `ACCUMULATE_OUTGOING_ARGS' is not ++ proper. */ ++#define ACCUMULATE_OUTGOING_ARGS 1 ++ ++/* Define this macro if functions should assume that stack space has been ++ allocated for arguments even when their values are passed in registers. ++ ++ The value of this macro is the size, in bytes, of the area reserved for ++ arguments passed in registers for the function represented by FNDECL. ++ ++ This space can be allocated by the caller, or be a part of the ++ machine-dependent stack frame: `OUTGOING_REG_PARM_STACK_SPACE' says ++ which. */ ++#define REG_PARM_STACK_SPACE(FNDECL) ubicom32_reg_parm_stack_space(FNDECL) ++ ++/* A C expression that should indicate the number of bytes of its own arguments ++ that a function pops on returning, or 0 if the function pops no arguments ++ and the caller must therefore pop them all after the function returns. ++ ++ FUNDECL is a C variable whose value is a tree node that describes the ++ function in question. Normally it is a node of type `FUNCTION_DECL' that ++ describes the declaration of the function. From this it is possible to ++ obtain the DECL_MACHINE_ATTRIBUTES of the function. ++ ++ FUNTYPE is a C variable whose value is a tree node that describes the ++ function in question. Normally it is a node of type `FUNCTION_TYPE' that ++ describes the data type of the function. From this it is possible to obtain ++ the data types of the value and arguments (if known). ++ ++ When a call to a library function is being considered, FUNTYPE will contain ++ an identifier node for the library function. Thus, if you need to ++ distinguish among various library functions, you can do so by their names. ++ Note that "library function" in this context means a function used to ++ perform arithmetic, whose name is known specially in the compiler and was ++ not mentioned in the C code being compiled. ++ ++ STACK-SIZE is the number of bytes of arguments passed on the stack. If a ++ variable number of bytes is passed, it is zero, and argument popping will ++ always be the responsibility of the calling function. ++ ++ On the Vax, all functions always pop their arguments, so the definition of ++ this macro is STACK-SIZE. On the 68000, using the standard calling ++ convention, no functions pop their arguments, so the value of the macro is ++ always 0 in this case. But an alternative calling convention is available ++ in which functions that take a fixed number of arguments pop them but other ++ functions (such as `printf') pop nothing (the caller pops all). When this ++ convention is in use, FUNTYPE is examined to determine whether a function ++ takes a fixed number of arguments. */ ++#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0 ++ ++/* A C expression that controls whether a function argument is passed in a ++ register, and which register. ++ ++ The arguments are CUM, of type CUMULATIVE_ARGS, which summarizes (in a way ++ defined by INIT_CUMULATIVE_ARGS and FUNCTION_ARG_ADVANCE) all of the previous ++ arguments so far passed in registers; MODE, the machine mode of the argument; ++ TYPE, the data type of the argument as a tree node or 0 if that is not known ++ (which happens for C support library functions); and NAMED, which is 1 for an ++ ordinary argument and 0 for nameless arguments that correspond to `...' in the ++ called function's prototype. ++ ++ The value of the expression should either be a `reg' RTX for the hard ++ register in which to pass the argument, or zero to pass the argument on the ++ stack. ++ ++ For machines like the Vax and 68000, where normally all arguments are ++ pushed, zero suffices as a definition. ++ ++ The usual way to make the ANSI library `stdarg.h' work on a machine where ++ some arguments are usually passed in registers, is to cause nameless ++ arguments to be passed on the stack instead. This is done by making ++ `FUNCTION_ARG' return 0 whenever NAMED is 0. ++ ++ You may use the macro `MUST_PASS_IN_STACK (MODE, TYPE)' in the definition of ++ this macro to determine if this argument is of a type that must be passed in ++ the stack. If `REG_PARM_STACK_SPACE' is not defined and `FUNCTION_ARG' ++ returns non-zero for such an argument, the compiler will abort. If ++ `REG_PARM_STACK_SPACE' is defined, the argument will be computed in the ++ stack and then loaded into a register. */ ++#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \ ++ function_arg (&CUM, MODE, TYPE, NAMED) ++ ++#define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) \ ++ function_incoming_arg (&CUM, MODE, TYPE, NAMED) ++ ++/* A C expression for the number of words, at the beginning of an argument, ++ must be put in registers. The value must be zero for arguments that are ++ passed entirely in registers or that are entirely pushed on the stack. ++ ++ On some machines, certain arguments must be passed partially in registers ++ and partially in memory. On these machines, typically the first N words of ++ arguments are passed in registers, and the rest on the stack. If a ++ multi-word argument (a `double' or a structure) crosses that boundary, its ++ first few words must be passed in registers and the rest must be pushed. ++ This macro tells the compiler when this occurs, and how many of the words ++ should go in registers. ++ ++ `FUNCTION_ARG' for these arguments should return the first register to be ++ used by the caller for this argument; likewise `FUNCTION_INCOMING_ARG', for ++ the called function. */ ++ ++/* A C expression that indicates when an argument must be passed by reference. ++ If nonzero for an argument, a copy of that argument is made in memory and a ++ pointer to the argument is passed instead of the argument itself. The ++ pointer is passed in whatever way is appropriate for passing a pointer to ++ that type. ++ ++ On machines where `REG_PARM_STACK_SPACE' is not defined, a suitable ++ definition of this macro might be ++ #define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) \ ++ MUST_PASS_IN_STACK (MODE, TYPE) */ ++ ++/* If defined, a C expression that indicates when it is the called function's ++ responsibility to make a copy of arguments passed by invisible reference. ++ Normally, the caller makes a copy and passes the address of the copy to the ++ routine being called. When FUNCTION_ARG_CALLEE_COPIES is defined and is ++ nonzero, the caller does not make a copy. Instead, it passes a pointer to ++ the "live" value. The called function must not modify this value. If it ++ can be determined that the value won't be modified, it need not make a copy; ++ otherwise a copy must be made. */ ++ ++/* A C type for declaring a variable that is used as the first argument of ++ `FUNCTION_ARG' and other related values. For some target machines, the type ++ `int' suffices and can hold the number of bytes of argument so far. ++ ++ There is no need to record in `CUMULATIVE_ARGS' anything about the arguments ++ that have been passed on the stack. The compiler has other variables to ++ keep track of that. For target machines on which all arguments are passed ++ on the stack, there is no need to store anything in `CUMULATIVE_ARGS'; ++ however, the data structure must exist and should not be empty, so use ++ `int'. */ ++struct cum_arg ++{ ++ int nbytes; ++ int reg; ++ int stdarg; ++}; ++#define CUMULATIVE_ARGS struct cum_arg ++ ++/* A C statement (sans semicolon) for initializing the variable CUM for the ++ state at the beginning of the argument list. The variable has type ++ `CUMULATIVE_ARGS'. The value of FNTYPE is the tree node for the data type ++ of the function which will receive the args, or 0 if the args are to a ++ compiler support library function. The value of INDIRECT is nonzero when ++ processing an indirect call, for example a call through a function pointer. ++ The value of INDIRECT is zero for a call to an explicitly named function, a ++ library function call, or when `INIT_CUMULATIVE_ARGS' is used to find ++ arguments for the function being compiled. ++ ++ When processing a call to a compiler support library function, LIBNAME ++ identifies which one. It is a `symbol_ref' rtx which contains the name of ++ the function, as a string. LIBNAME is 0 when an ordinary C function call is ++ being processed. Thus, each time this macro is called, either LIBNAME or ++ FNTYPE is nonzero, but never both of them at once. */ ++ ++#define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT, NAMED_ARGS) \ ++ init_cumulative_args (&(CUM), FNTYPE, LIBNAME, INDIRECT); ++ ++/* A C statement (sans semicolon) to update the summarizer variable CUM to ++ advance past an argument in the argument list. The values MODE, TYPE and ++ NAMED describe that argument. Once this is done, the variable CUM is ++ suitable for analyzing the *following* argument with `FUNCTION_ARG', etc. ++ ++ This macro need not do anything if the argument in question was passed on ++ the stack. The compiler knows how to track the amount of stack space used ++ for arguments without any special help. */ ++#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \ ++ ((CUM).nbytes += ((MODE) != BLKmode \ ++ ? (GET_MODE_SIZE (MODE) + 3) & ~3 \ ++ : (int_size_in_bytes (TYPE) + 3) & ~3)) ++ ++/* For the Ubicom32 we define the upper function argument register here. */ ++#define UBICOM32_FUNCTION_ARG_REGS 10 ++ ++/* A C expression that is nonzero if REGNO is the number of a hard register in ++ which function arguments are sometimes passed. This does *not* include ++ implicit arguments such as the static chain and the structure-value address. ++ On many machines, no registers can be used for this purpose since all ++ function arguments are pushed on the stack. */ ++#define FUNCTION_ARG_REGNO_P(N) ((N) < UBICOM32_FUNCTION_ARG_REGS) ++ ++ ++/* How Scalar Function Values are Returned. */ ++ ++/* The number of the hard register that is used to return a scalar value from a ++ function call. */ ++#define RETURN_VALUE_REGNUM 0 ++ ++/* A C expression to create an RTX representing the place where a function ++ returns a value of data type VALTYPE. VALTYPE is a tree node representing a ++ data type. Write `TYPE_MODE (VALTYPE)' to get the machine mode used to ++ represent that type. On many machines, only the mode is relevant. ++ (Actually, on most machines, scalar values are returned in the same place ++ regardless of mode). ++ ++ If `PROMOTE_FUNCTION_RETURN' is defined, you must apply the same promotion ++ rules specified in `PROMOTE_MODE' if VALTYPE is a scalar type. ++ ++ If the precise function being called is known, FUNC is a tree node ++ (`FUNCTION_DECL') for it; otherwise, FUNC is a null pointer. This makes it ++ possible to use a different value-returning convention for specific ++ functions when all their calls are known. ++ ++ `FUNCTION_VALUE' is not used for return vales with aggregate data types, ++ because these are returned in another way. See `STRUCT_VALUE_REGNUM' and ++ related macros, below. */ ++#define FUNCTION_VALUE(VALTYPE, FUNC) \ ++ gen_rtx_REG (TYPE_MODE (VALTYPE), FIRST_DATA_REGNUM) ++ ++/* A C expression to create an RTX representing the place where a library ++ function returns a value of mode MODE. ++ ++ Note that "library function" in this context means a compiler support ++ routine, used to perform arithmetic, whose name is known specially by the ++ compiler and was not mentioned in the C code being compiled. ++ ++ The definition of `LIBRARY_VALUE' need not be concerned aggregate data ++ types, because none of the library functions returns such types. */ ++#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, FIRST_DATA_REGNUM) ++ ++/* A C expression that is nonzero if REGNO is the number of a hard register in ++ which the values of called function may come back. ++ ++ A register whose use for returning values is limited to serving as the ++ second of a pair (for a value of type `double', say) need not be recognized ++ by this macro. So for most machines, this definition suffices: ++ ++ #define FUNCTION_VALUE_REGNO_P(N) ((N) == RETURN) ++ ++ If the machine has register windows, so that the caller and the called ++ function use different registers for the return value, this macro should ++ recognize only the caller's register numbers. */ ++#define FUNCTION_VALUE_REGNO_P(N) ((N) == FIRST_DATA_REGNUM) ++ ++ ++/* How Large Values are Returned. */ ++ ++/* A C expression which can inhibit the returning of certain function values in ++ registers, based on the type of value. A nonzero value says to return the ++ function value in memory, just as large structures are always returned. ++ Here TYPE will be a C expression of type `tree', representing the data type ++ of the value. ++ ++ Note that values of mode `BLKmode' must be explicitly handled by this macro. ++ Also, the option `-fpcc-struct-return' takes effect regardless of this ++ macro. On most systems, it is possible to leave the macro undefined; this ++ causes a default definition to be used, whose value is the constant 1 for ++ `BLKmode' values, and 0 otherwise. ++ ++ Do not use this macro to indicate that structures and unions should always ++ be returned in memory. You should instead use `DEFAULT_PCC_STRUCT_RETURN' ++ to indicate this. */ ++#define RETURN_IN_MEMORY(TYPE) \ ++ (int_size_in_bytes (TYPE) > 8 || TYPE_MODE (TYPE) == BLKmode) ++ ++/* Define this macro to be 1 if all structure and union return values must be ++ in memory. Since this results in slower code, this should be defined only ++ if needed for compatibility with other compilers or with an ABI. If you ++ define this macro to be 0, then the conventions used for structure and union ++ return values are decided by the `RETURN_IN_MEMORY' macro. ++ ++ If not defined, this defaults to the value 1. */ ++#define DEFAULT_PCC_STRUCT_RETURN 0 ++ ++/* If the structure value address is not passed in a register, define ++ `STRUCT_VALUE' as an expression returning an RTX for the place ++ where the address is passed. If it returns 0, the address is ++ passed as an "invisible" first argument. */ ++#define STRUCT_VALUE 0 ++ ++/* Define this macro as a C expression that is nonzero if the return ++ instruction or the function epilogue ignores the value of the stack pointer; ++ in other words, if it is safe to delete an instruction to adjust the stack ++ pointer before a return from the function. ++ ++ Note that this macro's value is relevant only for functions for which frame ++ pointers are maintained. It is never safe to delete a final stack ++ adjustment in a function that has no frame pointer, and the compiler knows ++ this regardless of `EXIT_IGNORE_STACK'. */ ++#define EXIT_IGNORE_STACK 1 ++ ++/* A C statement or compound statement to output to FILE some assembler code to ++ call the profiling subroutine `mcount'. Before calling, the assembler code ++ must load the address of a counter variable into a register where `mcount' ++ expects to find the address. The name of this variable is `LP' followed by ++ the number LABELNO, so you would generate the name using `LP%d' in a ++ `fprintf'. ++ ++ The details of how the address should be passed to `mcount' are determined ++ by your operating system environment, not by GNU CC. To figure them out, ++ compile a small program for profiling using the system's installed C ++ compiler and look at the assembler code that results. ++ ++ This declaration must be present, but it can be an abort if profiling is ++ not implemented. */ ++ ++#define FUNCTION_PROFILER(file, labelno) ubicom32_profiler(file, labelno) ++ ++/* A C statement to output, on the stream FILE, assembler code for a block of ++ data that contains the constant parts of a trampoline. This code should not ++ include a label--the label is taken care of automatically. */ ++#if 0 ++#define TRAMPOLINE_TEMPLATE(FILE) \ ++ do { \ ++ fprintf (FILE, "\tadd -4,sp\n"); \ ++ fprintf (FILE, "\t.long 0x0004fffa\n"); \ ++ fprintf (FILE, "\tmov (0,sp),a0\n"); \ ++ fprintf (FILE, "\tadd 4,sp\n"); \ ++ fprintf (FILE, "\tmov (13,a0),a1\n"); \ ++ fprintf (FILE, "\tmov (17,a0),a0\n"); \ ++ fprintf (FILE, "\tjmp (a0)\n"); \ ++ fprintf (FILE, "\t.long 0\n"); \ ++ fprintf (FILE, "\t.long 0\n"); \ ++ } while (0) ++#endif ++ ++/* A C expression for the size in bytes of the trampoline, as an integer. */ ++#define TRAMPOLINE_SIZE 0x1b ++ ++/* Alignment required for trampolines, in bits. ++ ++ If you don't define this macro, the value of `BIGGEST_ALIGNMENT' is used for ++ aligning trampolines. */ ++#define TRAMPOLINE_ALIGNMENT 32 ++ ++/* A C statement to initialize the variable parts of a trampoline. ADDR is an ++ RTX for the address of the trampoline; FNADDR is an RTX for the address of ++ the nested function; STATIC_CHAIN is an RTX for the static chain value that ++ should be passed to the function when it is called. */ ++#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \ ++{ \ ++ emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 0x14)), \ ++ (CXT)); \ ++ emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 0x18)), \ ++ (FNADDR)); \ ++} ++ ++/* Ubicom32 supports pre and post increment/decrement addressing. */ ++#define HAVE_POST_INCREMENT 1 ++#define HAVE_PRE_INCREMENT 1 ++#define HAVE_POST_DECREMENT 1 ++#define HAVE_PRE_DECREMENT 1 ++ ++/* Ubicom32 supports pre and post address side-effects with constants ++ other than the size of the memory operand. */ ++#define HAVE_PRE_MODIFY_DISP 1 ++#define HAVE_POST_MODIFY_DISP 1 ++ ++/* A C expression that is 1 if the RTX X is a constant which is a valid ++ address. On most machines, this can be defined as `CONSTANT_P (X)', ++ but a few machines are more restrictive in which constant addresses ++ are supported. ++ ++ `CONSTANT_P' accepts integer-values expressions whose values are not ++ explicitly known, such as `symbol_ref', `label_ref', and `high' ++ expressions and `const' arithmetic expressions, in addition to ++ `const_int' and `const_double' expressions. */ ++#define CONSTANT_ADDRESS_P(X) \ ++ (GET_CODE (X) == LABEL_REF \ ++ || (GET_CODE (X) == CONST \ ++ && GET_CODE (XEXP (X, 0)) == PLUS \ ++ && GET_CODE (XEXP (XEXP (X, 0), 0)) == LABEL_REF)) ++ ++/* Ubicom32 supports a maximum of 2 registers in a valid memory address. ++ One is always an address register while a second, optional, one may be a ++ data register. */ ++#define MAX_REGS_PER_ADDRESS 2 ++ ++/* A C compound statement with a conditional `goto LABEL;' executed if X (an ++ RTX) is a legitimate memory address on the target machine for a memory ++ operand of mode MODE. ++ ++ It usually pays to define several simpler macros to serve as subroutines for ++ this one. Otherwise it may be too complicated to understand. ++ ++ This macro must exist in two variants: a strict variant and a non-strict ++ one. The strict variant is used in the reload pass. It must be defined so ++ that any pseudo-register that has not been allocated a hard register is ++ considered a memory reference. In contexts where some kind of register is ++ required, a pseudo-register with no hard register must be rejected. ++ ++ The non-strict variant is used in other passes. It must be defined to ++ accept all pseudo-registers in every context where some kind of register is ++ required. ++ ++ Compiler source files that want to use the strict variant of this macro ++ define the macro `REG_OK_STRICT'. You should use an `#ifdef REG_OK_STRICT' ++ conditional to define the strict variant in that case and the non-strict ++ variant otherwise. ++ ++ Subroutines to check for acceptable registers for various purposes (one for ++ base registers, one for index registers, and so on) are typically among the ++ subroutines used to define `GO_IF_LEGITIMATE_ADDRESS'. Then only these ++ subroutine macros need have two variants; the higher levels of macros may be ++ the same whether strict or not. ++ ++ Normally, constant addresses which are the sum of a `symbol_ref' and an ++ integer are stored inside a `const' RTX to mark them as constant. ++ Therefore, there is no need to recognize such sums specifically as ++ legitimate addresses. Normally you would simply recognize any `const' as ++ legitimate. ++ ++ Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle constant sums that ++ are not marked with `const'. It assumes that a naked `plus' indicates ++ indexing. If so, then you *must* reject such naked constant sums as ++ illegitimate addresses, so that none of them will be given to ++ `PRINT_OPERAND_ADDRESS'. ++ ++ On some machines, whether a symbolic address is legitimate depends on the ++ section that the address refers to. On these machines, define the macro ++ `ENCODE_SECTION_INFO' to store the information into the `symbol_ref', and ++ then check for it here. When you see a `const', you will have to look ++ inside it to find the `symbol_ref' in order to determine the section. ++ ++ The best way to modify the name string is by adding text to the beginning, ++ with suitable punctuation to prevent any ambiguity. Allocate the new name ++ in `saveable_obstack'. You will have to modify `ASM_OUTPUT_LABELREF' to ++ remove and decode the added text and output the name accordingly, and define ++ `STRIP_NAME_ENCODING' to access the original name string. ++ ++ You can check the information stored here into the `symbol_ref' in the ++ definitions of the macros `GO_IF_LEGITIMATE_ADDRESS' and ++ `PRINT_OPERAND_ADDRESS'. */ ++/* On the ubicom32, the value in the address register must be ++ in the same memory space/segment as the effective address. ++ ++ This is problematical for reload since it does not understand ++ that base+index != index+base in a memory reference. */ ++ ++#ifdef REG_OK_STRICT ++#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ ++ if (ubicom32_legitimate_address_p (MODE, X, 1)) goto ADDR; ++#else ++#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ ++ if (ubicom32_legitimate_address_p (MODE, X, 0)) goto ADDR; ++#endif ++ ++/* Try machine-dependent ways of modifying an illegitimate address ++ to be legitimate. If we find one, return the new, valid address. ++ This macro is used in only one place: `memory_address' in explow.c. ++ ++ OLDX is the address as it was before break_out_memory_refs was called. ++ In some cases it is useful to look at this to decide what needs to be done. ++ ++ MODE and WIN are passed so that this macro can use ++ GO_IF_LEGITIMATE_ADDRESS. ++ ++ It is always safe for this macro to do nothing. It exists to recognize ++ opportunities to optimize the output. ++ ++ On RS/6000, first check for the sum of a register with a constant ++ integer that is out of range. If so, generate code to add the ++ constant with the low-order 16 bits masked to the register and force ++ this result into another register (this can be done with `cau'). ++ Then generate an address of REG+(CONST&0xffff), allowing for the ++ possibility of bit 16 being a one. ++ ++ Then check for the sum of a register and something not constant, try to ++ load the other things into a register and return the sum. */ ++ ++#define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \ ++{ \ ++ rtx result = ubicom32_legitimize_address ((X), (OLDX), (MODE)); \ ++ if (result != NULL_RTX) \ ++ { \ ++ (X) = result; \ ++ goto WIN; \ ++ } \ ++} ++ ++/* Try a machine-dependent way of reloading an illegitimate address ++ operand. If we find one, push the reload and jump to WIN. This ++ macro is used in only one place: `find_reloads_address' in reload.c. */ ++#define LEGITIMIZE_RELOAD_ADDRESS(AD, MODE, OPNUM, TYPE, IND, WIN) \ ++{ \ ++ rtx new_rtx = ubicom32_legitimize_reload_address ((AD), (MODE), (OPNUM), (int)(TYPE)); \ ++ if (new_rtx) \ ++ { \ ++ (AD) = new_rtx; \ ++ goto WIN; \ ++ } \ ++} ++ ++/* A C statement or compound statement with a conditional `goto LABEL;' ++ executed if memory address X (an RTX) can have different meanings depending ++ on the machine mode of the memory reference it is used for or if the address ++ is valid for some modes but not others. ++ ++ Autoincrement and autodecrement addresses typically have mode-dependent ++ effects because the amount of the increment or decrement is the size of the ++ operand being addressed. Some machines have other mode-dependent addresses. ++ Many RISC machines have no mode-dependent addresses. ++ ++ You may assume that ADDR is a valid address for the machine. */ ++#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL) \ ++ if (ubicom32_mode_dependent_address_p (ADDR)) \ ++ goto LABEL; ++ ++/* A C expression that is nonzero if X is a legitimate constant for an ++ immediate operand on the target machine. You can assume that X ++ satisfies `CONSTANT_P', so you need not check this. In fact, `1' is ++ a suitable definition for this macro on machines where anything ++ `CONSTANT_P' is valid. */ ++#define LEGITIMATE_CONSTANT_P(X) \ ++ ubicom32_legitimate_constant_p ((X)) ++ ++/* Moves between registers are pretty-much single instructions for ++ Ubicom32. We make this the default "2" that gcc likes. */ ++#define REGISTER_MOVE_COST(MODE, FROM, TO) 2 ++ ++/* This is a little bit of magic from the S390 port that wins 2% on code ++ size when building the Linux kernel! Unfortunately while it wins on ++ that size the user-space apps built using FD-PIC don't improve and the ++ performance is lower because we put more pressure on the caches. We may ++ want this back on some future CPU that has higher cache performance. */ ++/* #define IRA_HARD_REGNO_ADD_COST_MULTIPLIER(regno) 0.5 */ ++ ++/* Moves between registers and memory are more expensive than between ++ registers because we have caches and write buffers that slow things ++ down! */ ++#define MEMORY_MOVE_COST(MODE, CLASS, IN) 2 ++ ++/* A fall-through branch is very low cost but anything that changes the PC ++ incurs a major pipeline hazard. We don't make the full extent of this ++ hazard visible because we hope that multiple threads will absorb much ++ of the cost and so we don't want a jump being replaced with, say, 7 ++ instructions. */ ++#define BRANCH_COST(SPEED_P, PREDICTABLE_P) \ ++ ((PREDICTABLE_P) ? 1 : 3) ++ ++/* Define this macro as a C expression which is nonzero if accessing less than ++ a word of memory (i.e. a `char' or a `short') is no faster than accessing a ++ word of memory, i.e., if such access require more than one instruction or if ++ there is no difference in cost between byte and (aligned) word loads. ++ ++ When this macro is not defined, the compiler will access a field by finding ++ the smallest containing object; when it is defined, a fullword load will be ++ used if alignment permits. Unless bytes accesses are faster than word ++ accesses, using word accesses is preferable since it may eliminate ++ subsequent memory access if subsequent accesses occur to other fields in the ++ same word of the structure, but to different bytes. */ ++#define SLOW_BYTE_ACCESS 0 ++ ++/* The number of scalar move insns which should be generated instead of a ++ string move insn or a library call. Increasing the value will always make ++ code faster, but eventually incurs high cost in increased code size. ++ ++ If you don't define this, a reasonable default is used. */ ++/* According to expr.c, a value of around 6 should minimize code size. */ ++#define MOVE_RATIO(SPEED) 6 ++ ++/* We're much better off calling a constant function address with the ++ Ubicom32 architecture because we have an opcode for doing so. Don't ++ let the compiler extract function addresses as common subexpressions ++ into an address register. */ ++#define NO_FUNCTION_CSE ++ ++#define SELECT_CC_MODE(OP, X, Y) ubicom32_select_cc_mode (OP, X, Y) ++ ++#define REVERSIBLE_CC_MODE(MODE) 1 ++ ++/* Canonicalize a comparison from one we don't have to one we do have. */ ++#define CANONICALIZE_COMPARISON(CODE, OP0, OP1) \ ++ ubicom32_canonicalize_comparison (&(CODE), &(OP0), &(OP1)) ++ ++/* Dividing the output into sections. */ ++ ++/* A C expression whose value is a string containing the assembler operation ++ that should precede instructions and read-only data. Normally `".text"' is ++ right. */ ++#define TEXT_SECTION_ASM_OP "\t.section .text" ++ ++/* A C expression whose value is a string containing the assembler operation to ++ identify the following data as writable initialized data. Normally ++ `".data"' is right. */ ++#define DATA_SECTION_ASM_OP "\t.section .data" ++ ++ ++/* If defined, a C expression whose value is a string containing the ++ assembler operation to identify the following data as ++ uninitialized global data. If not defined, and neither ++ `ASM_OUTPUT_BSS' nor `ASM_OUTPUT_ALIGNED_BSS' are defined, ++ uninitialized global data will be output in the data section if ++ `-fno-common' is passed, otherwise `ASM_OUTPUT_COMMON' will be ++ used. */ ++#define BSS_SECTION_ASM_OP "\t.section .bss" ++ ++/* This is how we tell the assembler that a symbol is weak. */ ++ ++#define ASM_WEAKEN_LABEL(FILE, NAME) \ ++ do \ ++ { \ ++ fputs ("\t.weak\t", (FILE)); \ ++ assemble_name ((FILE), (NAME)); \ ++ fputc ('\n', (FILE)); \ ++ } \ ++ while (0) ++ ++/* The Overall Framework of an Assembler File. */ ++ ++#undef SET_ASM_OP ++#define SET_ASM_OP "\t.set\t" ++ ++/* A C string constant describing how to begin a comment in the target ++ assembler language. The compiler assumes that the comment will end at the ++ end of the line. */ ++#define ASM_COMMENT_START ";" ++ ++/* A C string constant for text to be output before each `asm' statement or ++ group of consecutive ones. Normally this is `"#APP"', which is a comment ++ that has no effect on most assemblers but tells the GNU assembler that it ++ must check the lines that follow for all valid assembler constructs. */ ++#define ASM_APP_ON "#APP\n" ++ ++/* A C string constant for text to be output after each `asm' statement or ++ group of consecutive ones. Normally this is `"#NO_APP"', which tells the ++ GNU assembler to resume making the time-saving assumptions that are valid ++ for ordinary compiler output. */ ++#define ASM_APP_OFF "#NO_APP\n" ++ ++/* Like `ASM_OUTPUT_BSS' except takes the required alignment as a separate, ++ explicit argument. If you define this macro, it is used in place of ++ `ASM_OUTPUT_BSS', and gives you more flexibility in handling the required ++ alignment of the variable. The alignment is specified as the number of ++ bits. ++ ++ Try to use function `asm_output_aligned_bss' defined in file `varasm.c' when ++ defining this macro. */ ++#define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN) \ ++ asm_output_aligned_bss ((FILE), (DECL), (NAME), (SIZE), (ALIGN)) ++ ++/* A C expression to assign to OUTVAR (which is a variable of type `char *') a ++ newly allocated string made from the string NAME and the number NUMBER, with ++ some suitable punctuation added. Use `alloca' to get space for the string. ++ ++ The string will be used as an argument to `ASM_OUTPUT_LABELREF' to produce ++ an assembler label for an internal static variable whose name is NAME. ++ Therefore, the string must be such as to result in valid assembler code. ++ The argument NUMBER is different each time this macro is executed; it ++ prevents conflicts between similarly-named internal static variables in ++ different scopes. ++ ++ Ideally this string should not be a valid C identifier, to prevent any ++ conflict with the user's own symbols. Most assemblers allow periods or ++ percent signs in assembler symbols; putting at least one of these between ++ the name and the number will suffice. */ ++#define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \ ++ ((OUTPUT) = (char *) alloca (strlen ((NAME)) + 10), \ ++ sprintf ((OUTPUT), "%s___%d", (NAME), (LABELNO))) ++ ++#define ASM_GENERATE_INTERNAL_LABEL(STRING, PREFIX, NUM) \ ++ sprintf (STRING, "*.%s%ld", PREFIX, (long)(NUM)) ++/* A C statement to store into the string STRING a label whose name ++ is made from the string PREFIX and the number NUM. ++ ++ This string, when output subsequently by `assemble_name', should ++ produce the output that `(*targetm.asm_out.internal_label)' would produce ++ with the same PREFIX and NUM. ++ ++ If the string begins with `*', then `assemble_name' will output ++ the rest of the string unchanged. It is often convenient for ++ `ASM_GENERATE_INTERNAL_LABEL' to use `*' in this way. If the ++ string doesn't start with `*', then `ASM_OUTPUT_LABELREF' gets to ++ output the string, and may change it. (Of course, ++ `ASM_OUTPUT_LABELREF' is also part of your machine description, so ++ you should know what it does on your machine.) */ ++ ++/* This says how to output assembler code to declare an ++ uninitialized external linkage data object. Under SVR4, ++ the linker seems to want the alignment of data objects ++ to depend on their types. We do exactly that here. */ ++ ++#define COMMON_ASM_OP "\t.comm\t" ++ ++#undef ASM_OUTPUT_COMMON ++#define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \ ++ do \ ++ { \ ++ fprintf ((FILE), "%s", COMMON_ASM_OP); \ ++ assemble_name ((FILE), (NAME)); \ ++ fprintf ((FILE), ", %u\n", (SIZE)); \ ++ } \ ++ while (0) ++ ++/* This says how to output assembler code to declare an ++ uninitialized internal linkage data object. Under SVR4, ++ the linker seems to want the alignment of data objects ++ to depend on their types. We do exactly that here. */ ++#define LOCAL_ASM_OP "\t.lcomm\t" ++ ++#undef ASM_OUTPUT_LOCAL ++#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \ ++ do \ ++ { \ ++ fprintf ((FILE), "%s", LOCAL_ASM_OP); \ ++ assemble_name ((FILE), (NAME)); \ ++ fprintf ((FILE), ", %u\n", (SIZE)); \ ++ } \ ++ while (0) ++ ++/* Globalizing directive for a label. */ ++#define GLOBAL_ASM_OP ".global\t" ++ ++/* Output the operand of an instruction. */ ++#define PRINT_OPERAND(FILE, X, CODE) \ ++ ubicom32_print_operand(FILE, X, CODE) ++ ++/* Output the address of an operand. */ ++#define PRINT_OPERAND_ADDRESS(FILE, ADDR) \ ++ ubicom32_print_operand_address (FILE, ADDR) ++ ++/* A C expression to output to STREAM some assembler code which will push hard ++ register number REGNO onto the stack. The code need not be optimal, since ++ this macro is used only when profiling. */ ++#define ASM_OUTPUT_REG_PUSH(FILE, REGNO) ++ ++/* A C expression to output to STREAM some assembler code which will pop hard ++ register number REGNO off of the stack. The code need not be optimal, since ++ this macro is used only when profiling. */ ++#define ASM_OUTPUT_REG_POP(FILE, REGNO) ++ ++/* This macro should be provided on machines where the addresses in a dispatch ++ table are relative to the table's own address. ++ ++ The definition should be a C statement to output to the stdio stream STREAM ++ an assembler pseudo-instruction to generate a difference between two labels. ++ VALUE and REL are the numbers of two internal labels. The definitions of ++ these labels are output using `ASM_OUTPUT_INTERNAL_LABEL', and they must be ++ printed in the same way here. For example, ++ ++ fprintf (STREAM, "\t.word L%d-L%d\n", VALUE, REL) */ ++#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \ ++ fprintf (FILE, "\t%s .L%d-.L%d\n", ".long", VALUE, REL) ++ ++/* This macro should be provided on machines where the addresses in a dispatch ++ table are absolute. ++ ++ The definition should be a C statement to output to the stdio stream STREAM ++ an assembler pseudo-instruction to generate a reference to a label. VALUE ++ is the number of an internal label whose definition is output using ++ `ASM_OUTPUT_INTERNAL_LABEL'. For example, ++ ++ fprintf (STREAM, "\t.word L%d\n", VALUE) */ ++#define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \ ++ fprintf (STREAM, "\t.word .L%d\n", VALUE) ++ ++/* Switch into a generic section. */ ++#define TARGET_ASM_NAMED_SECTION default_elf_asm_named_section ++ ++/* Assembler Commands for Alignment. */ ++ ++#define ASM_OUTPUT_SKIP(STREAM, N) fprintf (STREAM, "\t.skip %d,0\n", N) ++/* A C statement to output to the stdio stream STREAM an assembler ++ instruction to advance the location counter by NBYTES bytes. ++ Those bytes should be zero when loaded. NBYTES will be a C ++ expression of type `int'. */ ++ ++/* A C statement to output to the stdio stream STREAM an assembler command to ++ advance the location counter to a multiple of 2 to the POWER bytes. POWER ++ will be a C expression of type `int'. */ ++#define ASM_OUTPUT_ALIGN(FILE, LOG) \ ++ if ((LOG) != 0) \ ++ fprintf (FILE, "\t.align %d\n", (LOG)) ++ ++/* A C expression that returns the DBX register number for the compiler ++ register number REGNO. In simple cases, the value of this expression may be ++ REGNO itself. But sometimes there are some registers that the compiler ++ knows about and DBX does not, or vice versa. In such cases, some register ++ may need to have one number in the compiler and another for DBX. ++ ++ If two registers have consecutive numbers inside GNU CC, and they can be ++ used as a pair to hold a multiword value, then they *must* have consecutive ++ numbers after renumbering with `DBX_REGISTER_NUMBER'. Otherwise, debuggers ++ will be unable to access such a pair, because they expect register pairs to ++ be consecutive in their own numbering scheme. ++ ++ If you find yourself defining `DBX_REGISTER_NUMBER' in way that does not ++ preserve register pairs, then what you must do instead is redefine the ++ actual register numbering scheme. ++ ++ This declaration is required. */ ++#define DBX_REGISTER_NUMBER(REGNO) REGNO ++ ++/* A C expression that returns the integer offset value for an automatic ++ variable having address X (an RTL expression). The default computation ++ assumes that X is based on the frame-pointer and gives the offset from the ++ frame-pointer. This is required for targets that produce debugging output ++ for DBX or COFF-style debugging output for SDB and allow the frame-pointer ++ to be eliminated when the `-g' options is used. */ ++#define DEBUGGER_AUTO_OFFSET(X) \ ++ ((GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) \ ++ + (frame_pointer_needed \ ++ ? 0 : -initial_elimination_offset (FRAME_POINTER_REGNUM, \ ++ STACK_POINTER_REGNUM))) ++ ++/* A C expression that returns the integer offset value for an argument having ++ address X (an RTL expression). The nominal offset is OFFSET. */ ++#define DEBUGGER_ARG_OFFSET(OFFSET, X) \ ++ ((GET_CODE (X) == PLUS ? OFFSET : 0) \ ++ + (frame_pointer_needed \ ++ ? 0 : -initial_elimination_offset (ARG_POINTER_REGNUM, \ ++ STACK_POINTER_REGNUM))) ++ ++/* A C expression that returns the type of debugging output GNU CC produces ++ when the user specifies `-g' or `-ggdb'. Define this if you have arranged ++ for GNU CC to support more than one format of debugging output. Currently, ++ the allowable values are `DBX_DEBUG', `SDB_DEBUG', `DWARF_DEBUG', ++ `DWARF2_DEBUG', and `XCOFF_DEBUG'. ++ ++ The value of this macro only affects the default debugging output; the user ++ can always get a specific type of output by using `-gstabs', `-gcoff', ++ `-gdwarf-1', `-gdwarf-2', or `-gxcoff'. ++ ++ Defined in svr4.h. ++*/ ++#undef PREFERRED_DEBUGGING_TYPE ++#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG ++ ++/* Define this macro if GNU CC should produce dwarf version 2 format debugging ++ output in response to the `-g' option. ++ ++ To support optional call frame debugging information, you must also define ++ `INCOMING_RETURN_ADDR_RTX' and either set `RTX_FRAME_RELATED_P' on the ++ prologue insns if you use RTL for the prologue, or call `dwarf2out_def_cfa' ++ and `dwarf2out_reg_save' as appropriate from `FUNCTION_PROLOGUE' if you ++ don't. ++ ++ Defined in svr4.h. */ ++ ++#define DWARF2_DEBUGGING_INFO 1 ++/*#define DWARF2_UNWIND_INFO 1*/ ++#define DWARF2_UNWIND_INFO 0 ++#define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, LINK_REGNO) ++#define INCOMING_FRAME_SP_OFFSET 0 ++#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (LINK_REGNO) ++#define EH_RETURN_FIRST 9 ++#define EH_RETURN_DATA_REGNO(N) ((N) < 2 ? (N) + EH_RETURN_FIRST : INVALID_REGNUM) ++ ++/* The EH_RETURN_STACKADJ_RTX macro returns RTL which describes the ++ location used to store the amount to ajdust the stack. This is ++ usually a registers that is available from end of the function's body ++ to the end of the epilogue. Thus, this cannot be a register used as a ++ temporary by the epilogue. ++ ++ This must be an integer register. */ ++#define EH_RETURN_STACKADJ_REGNO 11 ++#define EH_RETURN_STACKADJ_RTX \ ++ gen_rtx_REG (Pmode, EH_RETURN_STACKADJ_REGNO) ++ ++/* The EH_RETURN_HANDLER_RTX macro returns RTL which describes the ++ location used to store the address the processor should jump to ++ catch exception. This is usually a registers that is available from ++ end of the function's body to the end of the epilogue. Thus, this ++ cannot be a register used as a temporary by the epilogue. ++ ++ This must be an address register. */ ++#define EH_RETURN_HANDLER_REGNO 18 ++#define EH_RETURN_HANDLER_RTX \ ++ gen_rtx_REG (Pmode, EH_RETURN_HANDLER_REGNO) ++ ++/* #define DWARF2_DEBUGGING_INFO */ ++ ++/* Define this macro if GNU CC should produce dwarf version 2-style ++ line numbers. This usually requires extending the assembler to ++ support them, and #defining DWARF2_LINE_MIN_INSN_LENGTH in the ++ assembler configuration header files. */ ++/* #define DWARF2_ASM_LINE_DEBUG_INFO 1 */ ++ ++ ++/* An alias for a machine mode name. This is the machine mode that elements ++ of a jump-table have. */ ++#define CASE_VECTOR_MODE Pmode ++ ++/* Smallest number of different values for which it is best to use a ++ jump-table instead of a tree of conditional branches. For most Ubicom32 ++ targets this is quite small, but for the v1 architecture implementations ++ we had very little data memory and so heavily prefer the tree approach ++ rather than the jump tables. */ ++#define CASE_VALUES_THRESHOLD ubicom32_case_values_threshold ++ ++/* Register operations within the Ubicom32 architecture always operate on ++ the whole register word and not just the sub-bits required for the opcode ++ mode size. */ ++#define WORD_REGISTER_OPERATIONS ++ ++/* The maximum number of bytes that a single instruction can move quickly from ++ memory to memory. */ ++#define MOVE_MAX 4 ++ ++/* A C expression that is nonzero if on this machine the number of bits ++ actually used for the count of a shift operation is equal to the number of ++ bits needed to represent the size of the object being shifted. When this ++ macro is non-zero, the compiler will assume that it is safe to omit a ++ sign-extend, zero-extend, and certain bitwise `and' instructions that ++ truncates the count of a shift operation. On machines that have ++ instructions that act on bitfields at variable positions, which may include ++ `bit test' instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables ++ deletion of truncations of the values that serve as arguments to bitfield ++ instructions. ++ ++ If both types of instructions truncate the count (for shifts) and position ++ (for bitfield operations), or if no variable-position bitfield instructions ++ exist, you should define this macro. ++ ++ However, on some machines, such as the 80386 and the 680x0, truncation only ++ applies to shift operations and not the (real or pretended) bitfield ++ operations. Define `SHIFT_COUNT_TRUNCATED' to be zero on such machines. ++ Instead, add patterns to the `md' file that include the implied truncation ++ of the shift instructions. ++ ++ You need not define this macro if it would always have the value of zero. */ ++#define SHIFT_COUNT_TRUNCATED 1 ++ ++/* A C expression which is nonzero if on this machine it is safe to "convert" ++ an integer of INPREC bits to one of OUTPREC bits (where OUTPREC is smaller ++ than INPREC) by merely operating on it as if it had only OUTPREC bits. ++ ++ On many machines, this expression can be 1. ++ ++ When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for modes for ++ which `MODES_TIEABLE_P' is 0, suboptimal code can result. If this is the ++ case, making `TRULY_NOOP_TRUNCATION' return 0 in such cases may improve ++ things. */ ++#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 ++ ++/* A C string constant that tells the GNU CC driver program options to pass ++ to the assembler. It can also specify how to translate options you give ++ to GNU CC into options for GNU CC to pass to the assembler. See the ++ file `sun3.h' for an example of this. ++ ++ Defined in svr4.h. */ ++#undef ASM_SPEC ++#define ASM_SPEC \ ++ "%{march=*:-m%*} %{!march=*:-mubicom32v4} %{mfdpic:-mfdpic}" ++ ++#define LINK_SPEC "\ ++%{h*} %{v:-V} \ ++%{b} \ ++%{mfdpic:-melf32ubicom32fdpic -z text} \ ++%{static:-dn -Bstatic} \ ++%{shared:-G -Bdynamic} \ ++%{symbolic:-Bsymbolic} \ ++%{G*} \ ++%{YP,*} \ ++%{Qy:} %{!Qn:-Qy}" ++ ++#undef STARTFILE_SPEC ++#undef ENDFILE_SPEC ++ ++/* The svr4.h LIB_SPEC with -leval and --*group tacked on */ ++ ++#undef LIB_SPEC ++#define LIB_SPEC "%{!shared:%{!symbolic:--start-group -lc -leval -lgcc --end-group}}" ++ ++#undef HAVE_GAS_SHF_MERGE ++#define HAVE_GAS_SHF_MERGE 0 ++ ++#define HANDLE_SYSV_PRAGMA 1 ++#undef HANDLE_PRAGMA_PACK ++ ++typedef void (*ubicom32_func_ptr) (void); ++ ++/* Define builtins for selected special-purpose instructions. */ ++enum ubicom32_builtins ++{ ++ UBICOM32_BUILTIN_UBICOM32_SWAPB_2, ++ UBICOM32_BUILTIN_UBICOM32_SWAPB_4 ++}; ++ ++extern rtx ubicom32_compare_op0; ++extern rtx ubicom32_compare_op1; ++ ++#define TYPE_ASM_OP "\t.type\t" ++#define TYPE_OPERAND_FMT "@%s" ++ ++#ifndef ASM_DECLARE_RESULT ++#define ASM_DECLARE_RESULT(FILE, RESULT) ++#endif ++ ++/* These macros generate the special .type and .size directives which ++ are used to set the corresponding fields of the linker symbol table ++ entries in an ELF object file under SVR4. These macros also output ++ the starting labels for the relevant functions/objects. */ ++ ++/* Write the extra assembler code needed to declare a function properly. ++ Some svr4 assemblers need to also have something extra said about the ++ function's return value. We allow for that here. */ ++ ++#ifndef ASM_DECLARE_FUNCTION_NAME ++#define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \ ++ do \ ++ { \ ++ ASM_OUTPUT_TYPE_DIRECTIVE (FILE, NAME, "function"); \ ++ ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL)); \ ++ ASM_OUTPUT_LABEL (FILE, NAME); \ ++ } \ ++ while (0) ++#endif +--- /dev/null ++++ b/gcc/config/ubicom32/ubicom32.md +@@ -0,0 +1,3753 @@ ++; GCC machine description for Ubicom32 ++; ++; Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Free Software ++; Foundation, Inc. ++; Contributed by Ubicom, Inc. ++; ++; This file is part of GCC. ++; ++; GCC is free software; you can redistribute it and/or modify ++; it under the terms of the GNU General Public License as published by ++; the Free Software Foundation; either version 3, or (at your option) ++; any later version. ++; ++; GCC 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 GCC; see the file COPYING3. If not see ++; . ++ ++(define_constants ++ [(AUX_DATA_REGNO 15) ++ (LINK_REGNO 21) ++ (SP_REGNO 23) ++ (ACC0_HI_REGNO 24) ++ (ACC1_HI_REGNO 26) ++ (CC_REGNO 30)]) ++ ++(define_constants ++ [(UNSPEC_FDPIC_GOT 0) ++ (UNSPEC_FDPIC_GOT_FUNCDESC 1)]) ++ ++(define_constants ++ [(UNSPEC_VOLATILE_LOAD_FDPIC_FUNCDESC 0)]) ++ ++;; Types of instructions (for scheduling purposes). ++ ++(define_attr "type" "mul,addr,other" ++ (const_string "other")) ++ ++; Define instruction scheduling characteristics. We can only issue ++; one instruction per clock so we don't need to define CPU units. ++; ++(define_automaton "ubicom32") ++ ++(define_cpu_unit "i_pipeline" "ubicom32"); ++ ++; We have a 4 cycle hazard associated with address calculations which ++; seems rather tricky to avoid so we go with a defensive assumption ++; that almost anything can be used to generate addresses. ++; ++;(define_insn_reservation "ubicom32_other" 4 ++; (eq_attr "type" "other") ++; "i_pipeline") ++ ++; Some moves don't generate hazards. ++; ++;(define_insn_reservation "ubicom32_addr" 1 ++; (eq_attr "type" "addr") ++; "i_pipeline") ++ ++; We need 3 cycles between a multiply instruction and any use of the ++; matching accumulator register(s). ++; ++(define_insn_reservation "ubicom32_mul" 4 ++ (eq_attr "type" "mul") ++ "i_pipeline") ++ ++(define_attr "length" "" ++ (const_int 4)) ++ ++(include "predicates.md") ++(include "constraints.md") ++ ++; 8-bit move with no change to the flags reg. ++; ++(define_insn "movqi" ++ [(set (match_operand:QI 0 "nonimmediate_operand" "=rm") ++ (match_operand:QI 1 "ubicom32_move_operand" "g"))] ++ "" ++ "move.1\\t%0, %1") ++ ++; Combiner-generated 8-bit move with the zero flag set accordingly. ++; ++(define_insn "movqi_ccszn" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:QI 0 "nonimmediate_operand" "rm") ++ (const_int 0))) ++ (set (match_operand:QI 1 "nonimmediate_operand" "=rm") ++ (match_dup 0))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "ext.1\\t%1, %0") ++ ++; Combine isn't very good at merging some types of operations so we ++; have to make do with a peephole. It's not as effective but it's better ++; than doing nothing. ++; ++(define_peephole2 ++ [(set (match_operand:QI 0 "nonimmediate_operand" "") ++ (match_operand:QI 1 "nonimmediate_operand" "")) ++ (set (match_operand 2 "ubicom32_cc_register_operand" "") ++ (match_operator 3 "ubicom32_compare_operator" ++ [(match_dup 0) ++ (const_int 0)]))] ++ "(GET_MODE (operands[2]) == CCSZNmode ++ || GET_MODE (operands[2]) == CCSZmode)" ++ [(parallel ++ [(set (match_dup 2) ++ (match_op_dup 3 ++ [(match_dup 1) ++ (const_int 0)])) ++ (set (match_dup 0) ++ (match_dup 1))])] ++ "") ++ ++; Combine isn't very good at merging some types of operations so we ++; have to make do with a peephole. It's not as effective but it's better ++; than doing nothing. ++; ++(define_peephole2 ++ [(set (match_operand:QI 0 "nonimmediate_operand" "") ++ (match_operand:QI 1 "nonimmediate_operand" "")) ++ (set (match_operand 2 "ubicom32_cc_register_operand" "") ++ (match_operator 3 "ubicom32_compare_operator" ++ [(match_dup 1) ++ (const_int 0)]))] ++ "(GET_MODE (operands[2]) == CCSZNmode ++ || GET_MODE (operands[2]) == CCSZmode)" ++ [(parallel ++ [(set (match_dup 2) ++ (match_op_dup 3 ++ [(match_dup 1) ++ (const_int 0)])) ++ (set (match_dup 0) ++ (match_dup 1))])] ++ "") ++ ++; 16-bit move with no change to the flags reg. ++; ++(define_insn "movhi" ++ [(set (match_operand:HI 0 "nonimmediate_operand" "=rm") ++ (match_operand:HI 1 "ubicom32_move_operand" "g"))] ++ "" ++ "* ++ { ++ if (CONST_INT_P (operands[1])) ++ return \"movei\\t%0, %1\"; ++ ++ return \"move.2\\t%0, %1\"; ++ }") ++ ++; Combiner-generated 16-bit move with the zero flag set accordingly. ++; ++(define_insn "movhi_ccszn" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:HI 0 "nonimmediate_operand" "rm") ++ (const_int 0))) ++ (set (match_operand:HI 1 "nonimmediate_operand" "=rm") ++ (match_dup 0))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "ext.2\\t%1, %0") ++ ++; Combine isn't very good at merging some types of operations so we ++; have to make do with a peephole. It's not as effective but it's better ++; than doing nothing. ++; ++(define_peephole2 ++ [(set (match_operand:HI 0 "nonimmediate_operand" "") ++ (match_operand:HI 1 "nonimmediate_operand" "")) ++ (set (match_operand 2 "ubicom32_cc_register_operand" "") ++ (match_operator 3 "ubicom32_compare_operator" ++ [(match_dup 0) ++ (const_int 0)]))] ++ "(GET_MODE (operands[2]) == CCSZNmode ++ || GET_MODE (operands[2]) == CCSZmode)" ++ [(parallel ++ [(set (match_dup 2) ++ (match_op_dup 3 ++ [(match_dup 1) ++ (const_int 0)])) ++ (set (match_dup 0) ++ (match_dup 1))])] ++ "") ++ ++; Combine isn't very good at merging some types of operations so we ++; have to make do with a peephole. It's not as effective but it's better ++; than doing nothing. ++; ++(define_peephole2 ++ [(set (match_operand:HI 0 "nonimmediate_operand" "") ++ (match_operand:HI 1 "nonimmediate_operand" "")) ++ (set (match_operand 2 "ubicom32_cc_register_operand" "") ++ (match_operator 3 "ubicom32_compare_operator" ++ [(match_dup 1) ++ (const_int 0)]))] ++ "(GET_MODE (operands[2]) == CCSZNmode ++ || GET_MODE (operands[2]) == CCSZmode)" ++ [(parallel ++ [(set (match_dup 2) ++ (match_op_dup 3 ++ [(match_dup 1) ++ (const_int 0)])) ++ (set (match_dup 0) ++ (match_dup 1))])] ++ "") ++ ++; 32-bit move with no change to the flags reg. ++; ++(define_expand "movsi" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "") ++ (match_operand:SI 1 "general_operand" ""))] ++ "" ++ "{ ++ /* Convert any complexities in operand 1 into something that can just ++ fall into the default expander code. */ ++ ubicom32_expand_movsi (operands); ++ }") ++ ++(define_insn "movsi_high" ++ [(set (match_operand:SI 0 "ubicom32_address_register_operand" "=a") ++ (high:SI (match_operand:SI 1 "ubicom32_symbolic_address_operand" "s")))] ++ "" ++ "moveai\\t%0, #%%hi(%E1)") ++ ++(define_insn "movsi_lo_sum" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm") ++ (lo_sum:SI (match_operand:SI 1 "ubicom32_address_register_operand" "a") ++ (match_operand:SI 2 "immediate_operand" "s")))] ++ "" ++ "lea.1\\t%0, %%lo(%E2)(%1)") ++ ++(define_insn "movsi_internal" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm") ++ (match_operand:SI 1 "ubicom32_move_operand" "rmnY"))] ++ "" ++ "* ++ { ++ if (CONST_INT_P (operands[1])) ++ { ++ ubicom32_emit_move_const_int (operands[0], operands[1]); ++ return \"\"; ++ } ++ ++ if (GET_CODE (operands[1]) == CONST_DOUBLE) ++ { ++ HOST_WIDE_INT i = CONST_DOUBLE_LOW (operands[1]); ++ ++ ubicom32_emit_move_const_int (operands[0], GEN_INT (i)); ++ return \"\"; ++ } ++ ++ if (ubicom32_address_register_operand (operands[0], VOIDmode) ++ && register_operand (operands[1], VOIDmode)) ++ { ++ if (ubicom32_address_register_operand (operands[1], VOIDmode)) ++ return \"lea.1\\t%0, 0(%1)\"; ++ ++ /* Use movea here to utilize the hazard bypass in the >= v4 ISA. */ ++ if (ubicom32_v4) ++ return \"movea\\t%0, %1\"; ++ ++ return \"move.4\\t%0, %1\"; ++ } ++ ++ return \"move.4\\t%0, %1\"; ++ }") ++ ++; If we're not dependent on the state of the condition codes we can construct ++; constants of value 2^n by using a bset. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "nonimmediate_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "(exact_log2 (INTVAL (operands[1])) > 14 ++ && peep2_regno_dead_p (0, CC_REGNO))" ++ [(parallel ++ [(set (match_dup 0) ++ (ior:SI (const_int 0) ++ (match_dup 1))) ++ (clobber (reg:CC CC_REGNO))])] ++ "") ++ ++; If we're not dependent on the state of the condition codes we can construct ++; constants of value ~(2^n) by using a bclr. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "nonimmediate_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "(exact_log2 (~INTVAL (operands[1])) > 14 ++ && peep2_regno_dead_p (0, CC_REGNO))" ++ [(parallel ++ [(set (match_dup 0) ++ (and:SI (const_int -1) ++ (match_dup 1))) ++ (clobber (reg:CC CC_REGNO))])] ++ "") ++ ++; For 32-bit constants that have bits 0 through 24 and bit 31 set the same ++; we can use swapb.4! ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "nonimmediate_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "(ubicom32_v4 ++ && (INTVAL (operands[1]) & 0xffffffff) != 0xffffffff ++ && (INTVAL (operands[1]) & 0xffffffff) != 0 ++ && ((INTVAL (operands[1]) & 0x80ffffff) == 0 ++ || (INTVAL (operands[1]) & 0x80ffffff) == 0x80ffffff))" ++ [(set (match_dup 0) ++ (bswap:SI (match_dup 2)))] ++ "{ ++ operands[2] = GEN_INT (INTVAL (operands[1]) >> 24); ++ }") ++ ++; If this is a write of a constant to memory look to see if we can usefully ++; transform this into 2 smaller writes. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "memory_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "! satisfies_constraint_I (operands[1]) ++ && ubicom32_legitimate_address_p (HImode, plus_constant (XEXP (operands[0], 0), 2), 1)" ++ [(set (match_dup 4) (match_dup 2)) ++ (set (match_dup 5) (match_dup 3))] ++ "{ ++ rtx low_hword_addr; ++ ++ operands[2] = gen_highpart_mode (HImode, SImode, operands[1]); ++ operands[3] = gen_lowpart (HImode, operands[1]); ++ ++ operands[4] = gen_rtx_MEM (HImode, XEXP (operands[0], 0)); ++ MEM_COPY_ATTRIBUTES (operands[4], operands[0]); ++ ++ low_hword_addr = plus_constant (XEXP (operands[0], 0), 2); ++ operands[5] = gen_rtx_MEM (HImode, low_hword_addr); ++ MEM_COPY_ATTRIBUTES (operands[5], operands[0]); ++ }") ++ ++; If we're writing memory and we've not found a better way to do this then ++; try loading into a D register and then copying to memory. This will ++; perform the fewest possible memory read/writes. ++; ++(define_peephole2 ++ [(match_scratch:SI 2 "d") ++ (set (match_operand:SI 0 "memory_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "! satisfies_constraint_I (operands[1])" ++ [(set (match_dup 2) (match_dup 1)) ++ (set (match_dup 0) (match_dup 2))] ++ "") ++ ++; If we're not dependent on the state of the condition codes we can construct ++; constants of value (2^n - 1) by using an lsr.4. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "(exact_log2 (INTVAL (operands[1]) + 1) > 14 ++ && peep2_regno_dead_p (0, CC_REGNO))" ++ [(parallel ++ [(set (match_dup 0) ++ (lshiftrt:SI (const_int -1) ++ (match_dup 2))) ++ (clobber (reg:CC CC_REGNO))])] ++ "{ ++ operands[2] = GEN_INT (32 - exact_log2 (INTVAL (operands[1]) + 1)); ++ }") ++ ++; If we're not dependent on the state of the condition codes we can construct ++; constants of value (2^n - 1) by using an lsr.4. ++; ++(define_peephole2 ++ [(match_scratch:SI 2 "d") ++ (set (match_operand:SI 0 "nonimmediate_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "(exact_log2 (INTVAL (operands[1]) + 1) > 14 ++ && peep2_regno_dead_p (0, CC_REGNO))" ++ [(parallel ++ [(set (match_dup 2) ++ (lshiftrt:SI (const_int -1) ++ (match_dup 3))) ++ (clobber (reg:CC CC_REGNO))]) ++ (set (match_dup 0) ++ (match_dup 2))] ++ "{ ++ operands[3] = GEN_INT (32 - exact_log2 (INTVAL (operands[1]) + 1)); ++ }") ++ ++; If we're not dependent on the state of the condition codes we can construct ++; some other constants by using an lsl.4 to shift 7 bits left by some ++; constant. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "(ubicom32_shiftable_const_int (INTVAL (operands[1])) ++ && peep2_regno_dead_p (0, CC_REGNO))" ++ [(parallel ++ [(set (match_dup 0) ++ (ashift:SI (match_dup 2) ++ (match_dup 3))) ++ (clobber (reg:CC CC_REGNO))])] ++ "{ ++ int shift = ubicom32_shiftable_const_int (INTVAL (operands[1])); ++ operands[2] = GEN_INT (INTVAL (operands[1]) >> shift); ++ operands[3] = GEN_INT (shift); ++ }") ++ ++; If we're not dependent on the state of the condition codes we can construct ++; some other constants by using an lsl.4 to shift 7 bits left by some ++; constant. ++; ++(define_peephole2 ++ [(match_scratch:SI 2 "d") ++ (set (match_operand:SI 0 "nonimmediate_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "(ubicom32_shiftable_const_int (INTVAL (operands[1])) ++ && peep2_regno_dead_p (0, CC_REGNO))" ++ [(parallel ++ [(set (match_dup 2) ++ (ashift:SI (match_dup 3) ++ (match_dup 4))) ++ (clobber (reg:CC CC_REGNO))]) ++ (set (match_dup 0) ++ (match_dup 2))] ++ "{ ++ int shift = ubicom32_shiftable_const_int (INTVAL (operands[1])); ++ operands[3] = GEN_INT (INTVAL (operands[1]) >> shift); ++ operands[4] = GEN_INT (shift); ++ }") ++ ++; For some 16-bit unsigned constants that have bit 15 set we can use ++; swapb.2! ++; ++; Note that the movsi code emits the same sequence but by using a peephole2 ++; we split the pattern early enough to allow instruction scheduling to ++; occur. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "(ubicom32_v4 ++ && (INTVAL (operands[1]) & 0xffff80ff) == 0x80ff)" ++ [(set (match_dup 0) ++ (zero_extend:SI (bswap:HI (match_dup 2))))] ++ "{ ++ HOST_WIDE_INT i = INTVAL (operands[1]) >> 8; ++ if (i >= 0x80) ++ i -= 0x100; ++ operands[2] = GEN_INT (i); ++ }") ++ ++; In general for a 16-bit unsigned constant that has bit 15 set ++; then we need a movei/move.2 pair unless we can represent it ++; via just a move.2. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "(INTVAL (operands[1]) & 0xffff8000) == 0x8000 ++ && (INTVAL (operands[1]) & 0xffff) < 0xff80" ++ [(set (match_dup 2) ++ (match_dup 1)) ++ (set (match_dup 0) ++ (zero_extend:SI (match_dup 2)))] ++ "{ ++ operands[2] = gen_rtx_REG (HImode, REGNO (operands[0])); ++ }") ++ ++; If we're not dependent on the state of the condition codes we can construct ++; 32-bit constants that have bits 16 through 31 set to arbitrary values ++; and have bits 0 through 15 set to something representable as a default ++; source-1 immediate - we use movei/shmrg.2 ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "(((INTVAL (operands[1]) >= 0x8000 ++ && INTVAL (operands[1]) < 0xff80) ++ || INTVAL (operands[1]) >= 0x10000 ++ || INTVAL (operands[1]) < -0x8000) ++ && ((INTVAL (operands[1]) & 0xffff) >= 0xff80 ++ || (INTVAL (operands[1]) & 0xffff) < 0x80) ++ && peep2_regno_dead_p (0, CC_REGNO))" ++ [(set (match_dup 0) ++ (match_dup 2)) ++ (parallel ++ [(set (match_dup 0) ++ (ior:SI ++ (ashift:SI (match_dup 0) ++ (const_int 16)) ++ (zero_extend:SI ++ (match_dup 3)))) ++ (clobber (reg:CC CC_REGNO))])] ++ "{ ++ operands[2] = gen_highpart_mode (HImode, SImode, operands[1]); ++ operands[3] = gen_lowpart (HImode, operands[1]); ++ }") ++ ++; Exactly the same as the peephole2 preceding except that this targets a ++; general register instead of D register. Hopefully the later optimization ++; passes will notice that the value ended up in a D register first here ++; and eliminate away the other register! ++; ++(define_peephole2 ++ [(match_scratch:SI 2 "d") ++ (set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "(((INTVAL (operands[1]) >= 0x8000 ++ && INTVAL (operands[1]) < 0xff80) ++ || INTVAL (operands[1]) >= 0x10000 ++ || INTVAL (operands[1]) < -0x8000) ++ && ((INTVAL (operands[1]) & 0xffff) >= 0xff80 ++ || (INTVAL (operands[1]) & 0xffff) < 0x80) ++ && peep2_regno_dead_p (0, CC_REGNO))" ++ [(set (match_dup 2) ++ (match_dup 3)) ++ (parallel ++ [(set (match_dup 2) ++ (ior:SI ++ (ashift:SI (match_dup 2) ++ (const_int 16)) ++ (zero_extend:SI ++ (match_dup 4)))) ++ (clobber (reg:CC CC_REGNO))]) ++ (set (match_dup 0) ++ (match_dup 2))] ++ "{ ++ operands[3] = gen_highpart_mode (HImode, SImode, operands[1]); ++ operands[4] = gen_lowpart (HImode, operands[1]); ++ }") ++ ++; If we have a load of a large integer constant which does not have bit 31 ++; set and we have a spare A reg then construct it with a moveai/lea.1 pair ++; instead. This avoids constructing it in 3 instructions on the stack. ++; ++; Note that we have to be careful not to match anything that matches ++; something we can do in a single instruction! There aren't many such ++; constants but there are some. ++; ++(define_peephole2 ++ [(match_scratch:SI 2 "a") ++ (set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "const_int_operand" ""))] ++ "(! (INTVAL (operands[1]) & 0x80000000) ++ && ((INTVAL (operands[1]) >= 0x8000 ++ && INTVAL (operands[1]) < 0xff80) ++ || INTVAL (operands[1]) >= 0x10000))" ++ [(set (match_dup 2) ++ (match_dup 3)) ++ (set (match_dup 0) ++ (plus:SI (match_dup 2) ++ (match_dup 4)))] ++ "{ ++ HOST_WIDE_INT i = INTVAL (operands[1]); ++ operands[3] = GEN_INT (i & 0xffffff80); ++ operands[4] = GEN_INT (i & 0x7f); ++ }") ++ ++; If we're not dependent on the state of the condition codes we can construct ++; a 32-bit constant with a movei/movei/shmrg.2 sequence if possible. ++; ++(define_peephole2 ++ [(match_scratch:HI 2 "d") ++ (set (match_operand:SI 0 "ubicom32_data_register_operand" "") ++ (match_operand:SI 1 "const_int_operand" "")) ++ (match_dup 2)] ++ "(INTVAL (operands[1]) & 0x80000000 ++ && INTVAL (operands[1]) < -0x8000 ++ && peep2_regno_dead_p (0, CC_REGNO))" ++ [(set (match_dup 0) ++ (match_dup 3)) ++ (set (match_dup 2) ++ (match_dup 4)) ++ (parallel ++ [(set (match_dup 0) ++ (ior:SI ++ (ashift:SI (match_dup 0) ++ (const_int 16)) ++ (zero_extend:SI ++ (match_dup 2)))) ++ (clobber (reg:CC CC_REGNO))])] ++ "{ ++ operands[3] = gen_highpart_mode (HImode, SImode, operands[1]); ++ operands[4] = gen_lowpart (HImode, operands[1]); ++ }") ++ ++; Exactly the same as the peephole2 preceding except that this targets a ++; general register instead of D register. Hopefully the later optimization ++; passes will notice that the value ended up in a D register first here ++; and eliminate away the other register! ++; ++(define_peephole2 ++ [(match_scratch:SI 2 "d") ++ (match_scratch:HI 3 "d") ++ (set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "const_int_operand" "")) ++ (match_dup 3)] ++ "(INTVAL (operands[1]) & 0x80000000 ++ && INTVAL (operands[1]) < -0x8000 ++ && peep2_regno_dead_p (0, CC_REGNO))" ++ [(set (match_dup 2) ++ (match_dup 4)) ++ (set (match_dup 3) ++ (match_dup 5)) ++ (parallel ++ [(set (match_dup 2) ++ (ior:SI ++ (ashift:SI (match_dup 2) ++ (const_int 16)) ++ (zero_extend:SI ++ (match_dup 3)))) ++ (clobber (reg:CC CC_REGNO))]) ++ (set (match_dup 0) ++ (match_dup 2))] ++ "{ ++ operands[4] = gen_highpart_mode (HImode, SImode, operands[1]); ++ operands[5] = gen_lowpart (HImode, operands[1]); ++ }") ++ ++(define_insn "movsi_fdpic_got_offset" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (match_operand:SI 1 "ubicom32_fdpic_got_offset_operand" "Y"))] ++ "" ++ "movei\\t%0, %1") ++ ++; The explicit MEM inside the UNSPEC prevents the compiler from moving ++; the load before a branch after a NULL test, or before a store that ++; initializes a function descriptor. ++ ++(define_insn_and_split "load_fdpic_funcdesc" ++ [(set (match_operand:SI 0 "ubicom32_address_register_operand" "=a") ++ (unspec_volatile:SI [(mem:SI (match_operand:SI 1 "address_operand" "p"))] ++ UNSPEC_VOLATILE_LOAD_FDPIC_FUNCDESC))] ++ "" ++ "#" ++ "reload_completed" ++ [(set (match_dup 0) ++ (mem:SI (match_dup 1)))]) ++ ++; Combiner-generated 32-bit move with the zero flag set accordingly. ++; ++(define_insn "movsi_ccwzn" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:SI 0 "nonimmediate_operand" "rm, d") ++ (const_int 0))) ++ (set (match_operand:SI 1 "nonimmediate_operand" "=d,rm") ++ (match_dup 0))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "@ ++ lsl.4\\t%1, %0, #0 ++ add.4\\t%1, #0, %0") ++ ++; Combiner-generated 32-bit move with all flags set accordingly. ++; ++(define_insn "movsi_ccw" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:SI 0 "ubicom32_data_register_operand" "d") ++ (const_int 0))) ++ (set (match_operand:SI 1 "nonimmediate_operand" "=rm") ++ (match_dup 0))] ++ "ubicom32_match_cc_mode(insn, CCWmode)" ++ "add.4\\t%1, #0, %0") ++ ++; Combine isn't very good at merging some types of operations so we ++; have to make do with a peephole. It's not as effective but it's better ++; than doing nothing. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "") ++ (match_operand:SI 1 "nonimmediate_operand" "")) ++ (parallel ++ [(set (match_operand 2 "ubicom32_cc_register_operand" "") ++ (match_operator 3 "ubicom32_compare_operator" ++ [(match_dup 0) ++ (const_int 0)])) ++ (clobber (match_operand:SI 4 "ubicom32_data_register_operand" ""))])] ++ "(GET_MODE (operands[2]) == CCWZNmode ++ || GET_MODE (operands[2]) == CCWZmode)" ++ [(parallel ++ [(set (match_dup 2) ++ (match_op_dup 3 ++ [(match_dup 1) ++ (const_int 0)])) ++ (set (match_dup 0) ++ (match_dup 1))])] ++ "") ++ ++; Combine isn't very good at merging some types of operations so we ++; have to make do with a peephole. It's not as effective but it's better ++; than doing nothing. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "nonimmediate_operand" "") ++ (match_operand:SI 1 "ubicom32_data_register_operand" "")) ++ (parallel ++ [(set (match_operand 2 "ubicom32_cc_register_operand" "") ++ (match_operator 3 "ubicom32_compare_operator" ++ [(match_dup 1) ++ (const_int 0)])) ++ (clobber (match_operand:SI 4 "ubicom32_data_register_operand" ""))])] ++ "(GET_MODE (operands[2]) == CCWZNmode ++ || GET_MODE (operands[2]) == CCWZmode)" ++ [(parallel ++ [(set (match_dup 2) ++ (match_op_dup 3 ++ [(match_dup 1) ++ (const_int 0)])) ++ (set (match_dup 0) ++ (match_dup 1))])] ++ "") ++ ++; Combine isn't very good at merging some types of operations so we ++; have to make do with a peephole. It's not as effective but it's better ++; than doing nothing. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "nonimmediate_operand" "")) ++ (parallel ++ [(set (match_operand 2 "ubicom32_cc_register_operand" "") ++ (match_operator 3 "ubicom32_compare_operator" ++ [(match_dup 0) ++ (const_int 0)])) ++ (set (match_operand:SI 4 "ubicom32_data_register_operand" "") ++ (match_dup 0))])] ++ "(peep2_reg_dead_p (2, operands[0]) ++ && (GET_MODE (operands[2]) == CCWZNmode ++ || GET_MODE (operands[2]) == CCWZmode))" ++ [(parallel ++ [(set (match_dup 2) ++ (match_op_dup 3 ++ [(match_dup 1) ++ (const_int 0)])) ++ (set (match_dup 4) ++ (match_dup 1))])] ++ "") ++ ++; Register renaming may make a general reg into a D reg in which case ++; we may be able to simplify a compare. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "nonimmediate_operand" "")) ++ (parallel ++ [(set (match_operand 2 "ubicom32_cc_register_operand" "") ++ (match_operator 3 "ubicom32_compare_operator" ++ [(match_dup 0) ++ (const_int 0)])) ++ (clobber (match_operand:SI 4 "ubicom32_data_register_operand" ""))])] ++ "(peep2_reg_dead_p (2, operands[0]) ++ && (GET_MODE (operands[2]) == CCWZNmode ++ || GET_MODE (operands[2]) == CCWZmode))" ++ [(parallel ++ [(set (match_dup 2) ++ (match_op_dup 3 ++ [(match_dup 1) ++ (const_int 0)])) ++ (clobber (match_dup 4))])] ++ "") ++ ++(define_insn_and_split "movdi" ++ [(set (match_operand:DI 0 "nonimmediate_operand" "=r,rm") ++ (match_operand:DI 1 "general_operand" "rmi,ri"))] ++ "" ++ "#" ++ "reload_completed" ++ [(set (match_dup 2) (match_dup 3)) ++ (set (match_dup 4) (match_dup 5))] ++ "{ ++ rtx dest_low; ++ rtx src_low; ++ ++ dest_low = gen_lowpart (SImode, operands[0]); ++ src_low = gen_lowpart (SImode, operands[1]); ++ ++ if (REG_P (operands[0]) ++ && REG_P (operands[1]) ++ && REGNO (operands[0]) < REGNO (operands[1])) ++ { ++ operands[2] = gen_highpart (SImode, operands[0]); ++ operands[3] = gen_highpart_mode (SImode, DImode, operands[1]); ++ operands[4] = dest_low; ++ operands[5] = src_low; ++ } ++ else if (reg_mentioned_p (dest_low, src_low)) ++ { ++ operands[2] = gen_highpart (SImode, operands[0]); ++ operands[3] = gen_highpart_mode (SImode, DImode, operands[1]); ++ operands[4] = dest_low; ++ operands[5] = src_low; ++ } ++ else ++ { ++ operands[2] = dest_low; ++ operands[3] = src_low; ++ operands[4] = gen_highpart (SImode, operands[0]); ++ operands[5] = gen_highpart_mode (SImode, DImode, operands[1]); ++ } ++ }" ++ [(set_attr "length" "8")]) ++ ++; Combiner-generated 64-bit move with all flags set accordingly. ++; ++(define_insn "movdi_ccwzn" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:DI 0 "nonimmediate_operand" "d, m, r") ++ (const_int 0))) ++ (set (match_operand:DI 1 "nonimmediate_operand" "=&rm,rm,!&rm") ++ (match_dup 0)) ++ (clobber (match_scratch:SI 2 "=X, d, d"))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "* ++ { ++ operands[3] = gen_lowpart (SImode, operands[0]); ++ operands[4] = gen_lowpart (SImode, operands[1]); ++ operands[5] = gen_highpart (SImode, operands[0]); ++ operands[6] = gen_highpart (SImode, operands[1]); ++ ++ if (ubicom32_data_register_operand (operands[0], VOIDmode)) ++ return \"add.4\\t%4, #0, %3\;addc\\t%6, #0, %5\"; ++ ++ return \"movei\\t%2, #0\;add.4\\t%4, %3, %2\;addc\\t%6, %5, %2\"; ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_insn "movdi_ccw" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:DI 0 "nonimmediate_operand" "d, m, r") ++ (const_int 0))) ++ (set (match_operand:DI 1 "nonimmediate_operand" "=&rm,rm,!&rm") ++ (match_dup 0)) ++ (clobber (match_scratch:SI 2 "=X, d, d"))] ++ "ubicom32_match_cc_mode(insn, CCWmode)" ++ "* ++ { ++ operands[3] = gen_lowpart (SImode, operands[0]); ++ operands[4] = gen_lowpart (SImode, operands[1]); ++ operands[5] = gen_highpart (SImode, operands[0]); ++ operands[6] = gen_highpart (SImode, operands[1]); ++ ++ if (ubicom32_data_register_operand (operands[0], VOIDmode)) ++ return \"add.4\\t%4, #0, %3\;addc\\t%6, #0, %5\"; ++ ++ return \"movei\\t%2, #0\;add.4\\t%4, %3, %2\;addc\\t%6, %5, %2\"; ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_insn "movsf" ++ [(set (match_operand:SF 0 "nonimmediate_operand" "=!d,*rm") ++ (match_operand:SF 1 "ubicom32_move_operand" "rmF,rmF"))] ++ "" ++ "* ++ { ++ if (GET_CODE (operands[1]) == CONST_DOUBLE) ++ { ++ HOST_WIDE_INT val; ++ REAL_VALUE_TYPE rv; ++ ++ REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]); ++ REAL_VALUE_TO_TARGET_SINGLE (rv, val); ++ ++ ubicom32_emit_move_const_int (operands[0], GEN_INT (val)); ++ return \"\"; ++ } ++ ++ return \"move.4\\t%0, %1\"; ++ }") ++ ++(define_insn "zero_extendqihi2" ++ [(set (match_operand:HI 0 "register_operand" "=r") ++ (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "rm")))] ++ "" ++ "move.1\\t%0, %1") ++ ++(define_insn "zero_extendqisi2" ++ [(set (match_operand:SI 0 "register_operand" "=r") ++ (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "rm")))] ++ "" ++ "move.1\\t%0, %1") ++ ++(define_insn "zero_extendqisi2_ccwz_1" ++ [(set (reg CC_REGNO) ++ (compare ++ (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "rm")) ++ (const_int 0))) ++ (set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (zero_extend:SI (match_dup 1)))] ++ "ubicom32_match_cc_mode(insn, CCWZmode)" ++ "shmrg.1\\t%0, %1, #0") ++ ++(define_insn "zero_extendhisi2" ++ [(set (match_operand:SI 0 "register_operand" "=r") ++ (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "rm")))] ++ "" ++ "move.2\\t%0, %1") ++ ++(define_insn "zero_extendhisi2_ccwz_1" ++ [(set (reg CC_REGNO) ++ (compare ++ (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "rm")) ++ (const_int 0))) ++ (set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (zero_extend:SI (match_dup 1)))] ++ "ubicom32_match_cc_mode(insn, CCWZmode)" ++ "shmrg.2\\t%0, %1, #0") ++ ++(define_insn_and_split "zero_extendqidi2" ++ [(set (match_operand:DI 0 "register_operand" "=r") ++ (zero_extend:DI (match_operand:QI 1 "nonimmediate_operand" "rm")))] ++ "" ++ "#" ++ "reload_completed" ++ [(set (match_dup 2) ++ (zero_extend:SI (match_dup 1))) ++ (set (match_dup 3) ++ (const_int 0))] ++ "{ ++ operands[2] = gen_lowpart (SImode, operands[0]); ++ operands[3] = gen_highpart (SImode, operands[0]); ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_insn_and_split "zero_extendhidi2" ++ [(set (match_operand:DI 0 "register_operand" "=r") ++ (zero_extend:DI (match_operand:HI 1 "nonimmediate_operand" "rm")))] ++ "" ++ "#" ++ "reload_completed" ++ [(set (match_dup 2) ++ (zero_extend:SI (match_dup 1))) ++ (set (match_dup 3) ++ (const_int 0))] ++ "{ ++ operands[2] = gen_lowpart (SImode, operands[0]); ++ operands[3] = gen_highpart (SImode, operands[0]); ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_insn_and_split "zero_extendsidi2" ++ [(set (match_operand:DI 0 "nonimmediate_operand" "=rm") ++ (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "rm")))] ++ "" ++ "#" ++ "reload_completed" ++ [(set (match_dup 2) ++ (match_dup 1)) ++ (set (match_dup 3) ++ (const_int 0))] ++ "{ ++ operands[2] = gen_lowpart (SImode, operands[0]); ++ operands[3] = gen_highpart (SImode, operands[0]); ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_insn "extendqihi2" ++ [(set (match_operand:HI 0 "register_operand" "=r") ++ (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "rm"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "ext.1\\t%0, %1") ++ ++(define_insn "extendqisi2" ++ [(set (match_operand:SI 0 "register_operand" "=r") ++ (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "rm"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "ext.1\\t%0, %1") ++ ++(define_insn "extendhisi2" ++ [(set (match_operand:SI 0 "register_operand" "=r") ++ (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "rm"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "ext.2\\t%0, %1") ++ ++(define_insn_and_split "extendsidi2" ++ [(set (match_operand:DI 0 "nonimmediate_operand" "=d") ++ (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "rm"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "#" ++ "reload_completed" ++ [(set (match_dup 2) ++ (match_dup 1)) ++ (parallel ++ [(set (match_dup 3) ++ (ashiftrt:SI (match_dup 2) ++ (const_int 31))) ++ (clobber (reg:CC CC_REGNO))])] ++ "{ ++ operands[2] = gen_lowpart (SImode, operands[0]); ++ operands[3] = gen_highpart (SImode, operands[0]); ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_insn "bswaphi" ++ [(set (match_operand:HI 0 "nonimmediate_operand" "=rm") ++ (bswap:HI (match_operand:HI 1 "ubicom32_arith_operand" "rmI")))] ++ "(ubicom32_v4)" ++ "swapb.2\\t%0, %1"); ++ ++(define_insn "bswaphisi" ++ [(set (match_operand:SI 0 "register_operand" "=r") ++ (zero_extend:SI ++ (bswap:HI (match_operand:HI 1 "ubicom32_arith_operand" "rmI"))))] ++ "(ubicom32_v4)" ++ "swapb.2\\t%0, %1"); ++ ++(define_insn "bswapsi" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm") ++ (bswap:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI")))] ++ "(ubicom32_v4)" ++ "swapb.4\\t%0, %1"); ++ ++(define_insn "tstqi_ext1" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:QI 0 "nonimmediate_operand" "rm") ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "ext.1\\t#0, %0") ++ ++(define_expand "cmpqi" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:QI 0 "ubicom32_arith_operand" "") ++ (match_operand:QI 1 "ubicom32_data_register_operand" "")))] ++ "(ubicom32_v4)" ++ "{ ++ ubicom32_compare_op0 = operands[0]; ++ ubicom32_compare_op1 = operands[1]; ++ DONE; ++ }") ++ ++(define_insn "sub1_ccs" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:QI 0 "ubicom32_arith_operand" "rmI") ++ (match_operand:QI 1 "ubicom32_data_register_operand" "d")))] ++ "(ubicom32_v4)" ++ "sub.1\\t#0, %0, %1") ++ ++; If we're testing for equality we don't have to worry about reversing conditions. ++; ++(define_insn "sub1_ccsz_1" ++ [(set (reg:CCSZ CC_REGNO) ++ (compare:CCSZ (match_operand:QI 0 "nonimmediate_operand" "rm") ++ (match_operand:QI 1 "ubicom32_data_register_operand" "d")))] ++ "(ubicom32_v4)" ++ "sub.1\\t#0, %0, %1") ++ ++(define_insn "sub1_ccsz_2" ++ [(set (reg:CCSZ CC_REGNO) ++ (compare:CCSZ (match_operand:QI 0 "ubicom32_data_register_operand" "d") ++ (match_operand:QI 1 "ubicom32_arith_operand" "rmI")))] ++ "(ubicom32_v4)" ++ "sub.1\\t#0, %1, %0") ++ ++; When the combiner runs it doesn't have any insight into whether or not an argument ++; to a compare is spilled to the stack and therefore can't swap the comparison in ++; an attempt to use sub.1 more effectively. We peephole this case here. ++; ++(define_peephole2 ++ [(set (match_operand:QI 0 "register_operand" "") ++ (match_operand:QI 1 "ubicom32_arith_operand" "")) ++ (set (match_operand 2 "ubicom32_cc_register_operand" "") ++ (compare (match_operand:QI 3 "ubicom32_data_register_operand" "") ++ (match_dup 0))) ++ (set (pc) ++ (if_then_else (match_operator 4 "comparison_operator" ++ [(match_dup 2) ++ (const_int 0)]) ++ (label_ref (match_operand 5 "" "")) ++ (pc)))] ++ "(peep2_reg_dead_p (2, operands[0]) ++ && peep2_regno_dead_p (3, CC_REGNO))" ++ [(set (match_dup 2) ++ (compare (match_dup 1) ++ (match_dup 3))) ++ (set (pc) ++ (if_then_else (match_op_dup 6 ++ [(match_dup 2) ++ (const_int 0)]) ++ (label_ref (match_dup 5)) ++ (pc)))] ++ "{ ++ rtx cc_reg; ++ ++ cc_reg = gen_rtx_REG (GET_MODE (operands[2]), CC_REGNO); ++ operands[6] = gen_rtx_fmt_ee (swap_condition (GET_CODE (operands[4])), ++ GET_MODE (operands[4]), ++ cc_reg, ++ const0_rtx); ++ }") ++ ++(define_insn "tsthi_ext2" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:HI 0 "nonimmediate_operand" "rm") ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "ext.2\\t#0, %0") ++ ++(define_expand "cmphi" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:HI 0 "ubicom32_arith_operand" "") ++ (match_operand:HI 1 "ubicom32_compare_operand" "")))] ++ "" ++ "{ ++ do ++ { ++ /* Is this a cmpi? */ ++ if (CONST_INT_P (operands[1])) ++ break; ++ ++ /* Must be a sub.2 - if necessary copy an operand into a reg. */ ++ if (! ubicom32_data_register_operand (operands[1], HImode)) ++ operands[1] = copy_to_mode_reg (HImode, operands[1]); ++ } ++ while (0); ++ ++ ubicom32_compare_op0 = operands[0]; ++ ubicom32_compare_op1 = operands[1]; ++ DONE; ++ }") ++ ++(define_insn "cmpi" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:HI 0 "nonimmediate_operand" "rm") ++ (match_operand 1 "const_int_operand" "N")))] ++ "" ++ "cmpi\\t%0, %1") ++ ++(define_insn "sub2_ccs" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:HI 0 "ubicom32_arith_operand" "rmI") ++ (match_operand:HI 1 "ubicom32_data_register_operand" "d")))] ++ "" ++ "sub.2\\t#0, %0, %1") ++ ++; If we're testing for equality we don't have to worry about reversing conditions. ++; ++(define_insn "sub2_ccsz_1" ++ [(set (reg:CCSZ CC_REGNO) ++ (compare:CCSZ (match_operand:HI 0 "nonimmediate_operand" "rm") ++ (match_operand:HI 1 "ubicom32_data_register_operand" "d")))] ++ "" ++ "sub.2\\t#0, %0, %1") ++ ++(define_insn "sub2_ccsz_2" ++ [(set (reg:CCSZ CC_REGNO) ++ (compare:CCSZ (match_operand:HI 0 "ubicom32_data_register_operand" "d") ++ (match_operand:HI 1 "ubicom32_arith_operand" "rmI")))] ++ "" ++ "sub.2\\t#0, %1, %0") ++ ++; When the combiner runs it doesn't have any insight into whether or not an argument ++; to a compare is spilled to the stack and therefore can't swap the comparison in ++; an attempt to use sub.2 more effectively. We peephole this case here. ++; ++(define_peephole2 ++ [(set (match_operand:HI 0 "register_operand" "") ++ (match_operand:HI 1 "ubicom32_arith_operand" "")) ++ (set (match_operand 2 "ubicom32_cc_register_operand" "") ++ (compare (match_operand:HI 3 "ubicom32_data_register_operand" "") ++ (match_dup 0))) ++ (set (pc) ++ (if_then_else (match_operator 4 "comparison_operator" ++ [(match_dup 2) ++ (const_int 0)]) ++ (label_ref (match_operand 5 "" "")) ++ (pc)))] ++ "(peep2_reg_dead_p (2, operands[0]) ++ && peep2_regno_dead_p (3, CC_REGNO))" ++ [(set (match_dup 2) ++ (compare (match_dup 1) ++ (match_dup 3))) ++ (set (pc) ++ (if_then_else (match_op_dup 6 ++ [(match_dup 2) ++ (const_int 0)]) ++ (label_ref (match_dup 5)) ++ (pc)))] ++ "{ ++ rtx cc_reg; ++ ++ cc_reg = gen_rtx_REG (GET_MODE (operands[2]), CC_REGNO); ++ operands[6] = gen_rtx_fmt_ee (swap_condition (GET_CODE (operands[4])), ++ GET_MODE (operands[4]), ++ cc_reg, ++ const0_rtx); ++ }") ++ ++(define_insn_and_split "tstsi_lsl4" ++ [(set (match_operand 0 "ubicom32_cc_register_operand" "=r") ++ (match_operator 1 "ubicom32_compare_operator" ++ [(match_operand:SI 2 "nonimmediate_operand" "rm") ++ (const_int 0)]))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "#" ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ [(parallel ++ [(set (match_dup 0) ++ (match_op_dup 1 ++ [(match_dup 2) ++ (const_int 0)])) ++ (clobber (match_dup 3))])] ++ "{ ++ operands[3] = gen_reg_rtx (SImode); ++ }") ++ ++(define_insn "tstsi_lsl4_d" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:SI 0 "nonimmediate_operand" "rm") ++ (const_int 0))) ++ (clobber (match_operand:SI 1 "ubicom32_data_register_operand" "=d"))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "lsl.4\\t%1, %0, #0") ++ ++; Comparison for equality with -1. ++; ++(define_insn "cmpsi_not4_ccwz" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:SI 0 "nonimmediate_operand" "rm") ++ (const_int -1)))] ++ "ubicom32_match_cc_mode(insn, CCWZmode)" ++ "not.4\\t#0, %0") ++ ++(define_expand "cmpsi" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:SI 0 "ubicom32_arith_operand" "") ++ (match_operand:SI 1 "ubicom32_compare_operand" "")))] ++ "" ++ "{ ++ do ++ { ++ /* Is this a cmpi? We can't take a memory address as cmpi takes ++ 16-bit operands. */ ++ if (register_operand (operands[0], SImode) ++ && CONST_INT_P (operands[1]) ++ && satisfies_constraint_N (operands[1])) ++ break; ++ ++ /* Must be a sub.4 - if necessary copy an operand into a reg. */ ++ if (! ubicom32_data_register_operand (operands[1], SImode)) ++ operands[1] = copy_to_mode_reg (SImode, operands[1]); ++ } ++ while (0); ++ ++ ubicom32_compare_op0 = operands[0]; ++ ubicom32_compare_op1 = operands[1]; ++ DONE; ++ }") ++ ++(define_insn "cmpsi_cmpi" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:SI 0 "register_operand" "r") ++ (match_operand 1 "const_int_operand" "N")))] ++ "(satisfies_constraint_N (operands[1]))" ++ "cmpi\\t%0, %1") ++ ++(define_insn "cmpsi_sub4" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:SI 0 "ubicom32_arith_operand" "rmI") ++ (match_operand:SI 1 "ubicom32_data_register_operand" "d")))] ++ "" ++ "sub.4\\t#0, %0, %1") ++ ++; If we're testing for equality we don't have to worry about reversing conditions. ++; ++(define_insn "cmpsi_sub4_ccwz_1" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:SI 0 "nonimmediate_operand" "rm") ++ (match_operand:SI 1 "ubicom32_data_register_operand" "d")))] ++ "ubicom32_match_cc_mode(insn, CCWZmode)" ++ "sub.4\\t#0, %0, %1") ++ ++(define_insn "cmpsi_sub4_ccwz_2" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:SI 0 "ubicom32_data_register_operand" "d") ++ (match_operand:SI 1 "nonimmediate_operand" "rm")))] ++ "ubicom32_match_cc_mode(insn, CCWZmode)" ++ "sub.4\\t#0, %1, %0") ++ ++; When the combiner runs it doesn't have any insight into whether or not an argument ++; to a compare is spilled to the stack and therefore can't swap the comparison in ++; an attempt to use sub.4 more effectively. We peephole this case here. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "ubicom32_arith_operand" "")) ++ (set (match_operand 2 "ubicom32_cc_register_operand" "") ++ (compare (match_operand:SI 3 "ubicom32_data_register_operand" "") ++ (match_dup 0))) ++ (set (pc) ++ (if_then_else (match_operator 4 "comparison_operator" ++ [(match_dup 2) ++ (const_int 0)]) ++ (label_ref (match_operand 5 "" "")) ++ (pc)))] ++ "(peep2_reg_dead_p (2, operands[0]) ++ && peep2_regno_dead_p (3, CC_REGNO))" ++ [(set (match_dup 2) ++ (compare (match_dup 1) ++ (match_dup 3))) ++ (set (pc) ++ (if_then_else (match_op_dup 6 ++ [(match_dup 2) ++ (const_int 0)]) ++ (label_ref (match_dup 5)) ++ (pc)))] ++ "{ ++ rtx cc_reg; ++ ++ cc_reg = gen_rtx_REG (GET_MODE (operands[2]), CC_REGNO); ++ operands[6] = gen_rtx_fmt_ee (swap_condition (GET_CODE (operands[4])), ++ GET_MODE (operands[4]), ++ cc_reg, ++ const0_rtx); ++ }") ++ ++(define_insn_and_split "tstdi_or4" ++ [(set (reg:CCWZ CC_REGNO) ++ (compare:CCWZ (match_operand:DI 0 "nonimmediate_operand" "rm") ++ (const_int 0)))] ++ "" ++ "#" ++ "" ++ [(parallel ++ [(set (reg:CCWZ CC_REGNO) ++ (compare:CCWZ (match_dup 0) ++ (const_int 0))) ++ (clobber (match_dup 1))])] ++ "{ ++ operands[1] = gen_reg_rtx (SImode); ++ }") ++ ++(define_insn "tstdi_or4_d" ++ [(set (reg:CCWZ CC_REGNO) ++ (compare:CCWZ (match_operand:DI 0 "nonimmediate_operand" "rm") ++ (const_int 0))) ++ (clobber (match_operand:SI 1 "ubicom32_data_register_operand" "=d"))] ++ "" ++ "* ++ { ++ operands[2] = gen_lowpart (SImode, operands[0]); ++ operands[3] = gen_highpart_mode (SImode, DImode, operands[0]); ++ ++ if (ubicom32_data_register_operand (operands[0], GET_MODE (operands[0]))) ++ return \"or.4\\t#0, %2, %3\"; ++ ++ return \"move.4\\t%1, %2\;or.4\\t%1, %3, %1\"; ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_expand "cmpdi" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:DI 0 "ubicom32_arith_operand" "") ++ (match_operand:DI 1 "ubicom32_data_register_operand" "")))] ++ "" ++ "{ ++ ubicom32_compare_op0 = operands[0]; ++ ubicom32_compare_op1 = operands[1]; ++ DONE; ++ }") ++ ++(define_insn "cmpdi_sub4subc" ++ [(set (reg CC_REGNO) ++ (compare (match_operand:DI 0 "ubicom32_arith_operand" "rmI") ++ (match_operand:DI 1 "ubicom32_data_register_operand" "d")))] ++ "" ++ "* ++ { ++ operands[2] = gen_lowpart (SImode, operands[0]); ++ operands[3] = gen_lowpart (SImode, operands[1]); ++ operands[4] = gen_highpart_mode (SImode, DImode, operands[0]); ++ operands[5] = gen_highpart_mode (SImode, DImode, operands[1]); ++ ++ return \"sub.4\\t#0, %2, %3\;subc\\t#0, %4, %5\"; ++ }" ++ [(set_attr "length" "8")]) ++ ++; When the combiner runs it doesn't have any insight into whether or not an argument ++; to a compare is spilled to the stack and therefore can't swap the comparison in ++; an attempt to use sub.4/subc more effectively. We peephole this case here. ++; ++(define_peephole2 ++ [(set (match_operand:DI 0 "register_operand" "") ++ (match_operand:DI 1 "ubicom32_arith_operand" "")) ++ (set (match_operand 2 "ubicom32_cc_register_operand" "") ++ (compare (match_operand:DI 3 "ubicom32_data_register_operand" "") ++ (match_dup 0))) ++ (set (pc) ++ (if_then_else (match_operator 4 "comparison_operator" ++ [(match_dup 2) ++ (const_int 0)]) ++ (label_ref (match_operand 5 "" "")) ++ (pc)))] ++ "(peep2_reg_dead_p (2, operands[0]) ++ && peep2_regno_dead_p (3, CC_REGNO))" ++ [(set (match_dup 2) ++ (compare (match_dup 1) ++ (match_dup 3))) ++ (set (pc) ++ (if_then_else (match_op_dup 6 ++ [(match_dup 2) ++ (const_int 0)]) ++ (label_ref (match_dup 5)) ++ (pc)))] ++ "{ ++ rtx cc_reg; ++ ++ cc_reg = gen_rtx_REG (GET_MODE (operands[2]), CC_REGNO); ++ operands[6] = gen_rtx_fmt_ee (swap_condition (GET_CODE (operands[4])), ++ GET_MODE (operands[4]), ++ cc_reg, ++ const0_rtx); ++ }") ++ ++(define_insn "btst" ++ [(set (reg:CCWZ CC_REGNO) ++ (compare:CCWZ ++ (zero_extract:SI ++ (match_operand:SI 0 "nonimmediate_operand" "rm") ++ (const_int 1) ++ (match_operand:SI 1 "ubicom32_arith_operand" "dM")) ++ (const_int 0)))] ++ "" ++ "btst\\t%0, %1") ++ ++(define_insn "bfextu_ccwz_null" ++ [(set (reg:CCWZ CC_REGNO) ++ (compare:CCWZ ++ (zero_extract:SI ++ (match_operand:SI 0 "nonimmediate_operand" "rm") ++ (match_operand 1 "const_int_operand" "M") ++ (const_int 0)) ++ (const_int 0))) ++ (clobber (match_scratch:SI 2 "=d"))] ++ "" ++ "bfextu\\t%2, %0, %1") ++ ++(define_expand "addqi3" ++ [(parallel ++ [(set (match_operand:QI 0 "memory_operand" "") ++ (plus:QI (match_operand:QI 1 "nonimmediate_operand" "") ++ (match_operand:QI 2 "ubicom32_arith_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "(ubicom32_v4)" ++ "{ ++ if (!memory_operand (operands[0], QImode)) ++ FAIL; ++ ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (QImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (QImode, operands[2]); ++ }") ++ ++(define_insn "addqi3_add1" ++ [(set (match_operand:QI 0 "memory_operand" "=m, m") ++ (plus:QI (match_operand:QI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:QI 2 "ubicom32_arith_operand" "rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4)" ++ "@ ++ add.1\\t%0, %2, %1 ++ add.1\\t%0, %1, %2") ++ ++(define_insn "addqi3_add1_ccszn_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (neg:QI (match_operand:QI 0 "nonimmediate_operand" "%d,rm")) ++ (match_operand:QI 1 "ubicom32_arith_operand" "rmI, d")))] ++ "(ubicom32_v4 ++ && ubicom32_match_cc_mode(insn, CCSZNmode))" ++ "@ ++ add.1\\t#0, %1, %0 ++ add.1\\t#0, %0, %1") ++ ++(define_expand "addhi3" ++ [(parallel ++ [(set (match_operand:HI 0 "memory_operand" "") ++ (plus:HI (match_operand:HI 1 "nonimmediate_operand" "") ++ (match_operand:HI 2 "ubicom32_arith_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "" ++ "{ ++ if (!memory_operand (operands[0], HImode)) ++ FAIL; ++ ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (HImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (HImode, operands[2]); ++ }") ++ ++(define_insn "addhi3_add2" ++ [(set (match_operand:HI 0 "memory_operand" "=m, m") ++ (plus:HI (match_operand:HI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:HI 2 "ubicom32_arith_operand" "rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "@ ++ add.2\\t%0, %2, %1 ++ add.2\\t%0, %1, %2") ++ ++(define_insn "addhi3_add2_ccszn_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (neg:HI (match_operand:HI 0 "nonimmediate_operand" "%d,rm")) ++ (match_operand:HI 1 "ubicom32_arith_operand" "rmI, d")))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "@ ++ add.2\\t#0, %1, %0 ++ add.2\\t#0, %0, %1") ++ ++(define_expand "addsi3" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "") ++ (plus:SI (match_operand:SI 1 "nonimmediate_operand" "") ++ (match_operand:SI 2 "ubicom32_move_operand" "")))] ++ "" ++ "{ ++ ubicom32_expand_addsi3 (operands); ++ DONE; ++ }") ++ ++; We start with an instruction pattern that can do all sorts of interesting ++; things but we split out any uses of lea or pdec instructions because ++; those instructions don't clobber the condition codes. ++; ++(define_insn_and_split "addsi3_1" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm,rm,rm,rm,rm, rm,rm") ++ (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%a, a, a, a, a, d,rm") ++ (match_operand:SI 2 "ubicom32_move_operand" "L, K, J, P, d,rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "@ ++ # ++ # ++ # ++ # ++ # ++ add.4\\t%0, %2, %1 ++ add.4\\t%0, %1, %2" ++ "(reload_completed ++ && ubicom32_address_register_operand (operands[1], GET_MODE (operands[1])))" ++ [(set (match_dup 0) ++ (plus:SI (match_dup 1) ++ (match_dup 2)))] ++ "" ++) ++ ++(define_insn "addsi3_1_ccwzn" ++ [(set (reg CC_REGNO) ++ (compare ++ (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0))) ++ (set (match_operand:SI 0 "nonimmediate_operand" "=rm,rm") ++ (plus:SI (match_dup 1) ++ (match_dup 2)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "@ ++ add.4\\t%0, %2, %1 ++ add.4\\t%0, %1, %2") ++ ++(define_insn "addsi3_1_ccwzn_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (neg:SI (match_operand:SI 0 "nonimmediate_operand" "%d,rm")) ++ (match_operand:SI 1 "ubicom32_arith_operand" "rmI, d")))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "@ ++ add.4\\t#0, %1, %0 ++ add.4\\t#0, %0, %1") ++ ++(define_insn_and_split "addsi3_2" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm,rm,rm,rm,rm,rm") ++ (plus:SI (match_operand:SI 1 "ubicom32_address_register_operand" "%a, a, a, a, a, a") ++ (match_operand:SI 2 "ubicom32_move_operand" "L, K, J, P, d, n")))] ++ "" ++ "@ ++ lea.4\\t%0, %E2(%1) ++ lea.2\\t%0, %E2(%1) ++ lea.1\\t%0, %E2(%1) ++ pdec\\t%0, %n2(%1) ++ lea.1\\t%0, (%1,%2) ++ #" ++ "(reload_completed ++ && ! satisfies_constraint_L (operands[2]) ++ && ! satisfies_constraint_K (operands[2]) ++ && ! satisfies_constraint_J (operands[2]) ++ && ! satisfies_constraint_P (operands[2]) ++ && ! ubicom32_data_register_operand (operands[2], GET_MODE (operands[2])))" ++ [(set (reg:SI AUX_DATA_REGNO) ++ (match_dup 2)) ++ (set (match_dup 0) ++ (plus:SI (match_dup 1) ++ (reg:SI AUX_DATA_REGNO)))] ++ "" ++) ++ ++(define_insn "lea_2" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm") ++ (plus:SI (mult:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d") ++ (const_int 2)) ++ (match_operand:SI 2 "ubicom32_address_register_operand" "a")))] ++ "" ++ "lea.2\\t%0, (%2,%1)") ++ ++(define_insn "lea_4" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm") ++ (plus:SI (mult:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d") ++ (const_int 4)) ++ (match_operand:SI 2 "ubicom32_address_register_operand" "a")))] ++ "" ++ "lea.4\\t%0, (%2,%1)") ++ ++(define_expand "adddi3" ++ [(parallel ++ [(set (match_operand:DI 0 "nonimmediate_operand" "") ++ (plus:DI (match_operand:DI 1 "nonimmediate_operand" "") ++ (match_operand:DI 2 "ubicom32_arith_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "" ++ "{ ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (DImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (DImode, operands[2]); ++ }") ++ ++; We construct a 64-bit add from 32-bit operations. Note that we use the ++; & constraint to prevent overlapping registers being allocated. We do ++; allow identical registers though as that won't break anything. ++; ++(define_insn "adddi3_add4addc" ++ [(set (match_operand:DI 0 "nonimmediate_operand" "=&r,&r,rm, d, m, m") ++ (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%d,rm, 0, 0, d,rm") ++ (match_operand:DI 2 "ubicom32_arith_operand" "rmI, d, d,rmI,rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "* ++ { ++ operands[3] = gen_lowpart (SImode, operands[0]); ++ operands[4] = gen_lowpart (SImode, operands[1]); ++ operands[5] = gen_lowpart (SImode, operands[2]); ++ operands[6] = gen_highpart (SImode, operands[0]); ++ operands[7] = gen_highpart (SImode, operands[1]); ++ operands[8] = gen_highpart_mode (SImode, DImode, operands[2]); ++ ++ if (ubicom32_data_register_operand (operands[2], GET_MODE (operands[2]))) ++ return \"add.4\\t%3, %4, %5\;addc\\t%6, %7, %8\"; ++ ++ return \"add.4\\t%3, %5, %4\;addc\\t%6, %8, %7\"; ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_insn "adddi3_ccwz" ++ [(set (reg CC_REGNO) ++ (compare ++ (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%d,rm, 0, 0, d,rm") ++ (match_operand:DI 2 "ubicom32_arith_operand" "rmI, d, d,rmI,rmI, d")) ++ (const_int 0))) ++ (set (match_operand:DI 0 "nonimmediate_operand" "=&r,&r,rm, d, m, m") ++ (plus:DI (match_dup 1) ++ (match_dup 2)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "* ++ { ++ operands[3] = gen_lowpart (SImode, operands[0]); ++ operands[6] = gen_highpart (SImode, operands[0]); ++ ++ if (ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))) ++ { ++ operands[4] = gen_lowpart (SImode, operands[1]); ++ operands[5] = gen_lowpart (SImode, operands[2]); ++ operands[7] = gen_highpart (SImode, operands[1]); ++ operands[8] = gen_highpart_mode (SImode, DImode, operands[2]); ++ } ++ else ++ { ++ operands[4] = gen_lowpart (SImode, operands[2]); ++ operands[5] = gen_lowpart (SImode, operands[1]); ++ operands[7] = gen_highpart (SImode, operands[2]); ++ operands[8] = gen_highpart (SImode, operands[1]); ++ } ++ ++ return \"add.4\\t%3, %5, %4\;addc\\t%6, %8, %7\"; ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_insn "adddi3_ccwz_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (neg:DI (match_operand:DI 0 "nonimmediate_operand" "%d,rm")) ++ (match_operand:DI 1 "ubicom32_arith_operand" "rmI, d")))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "* ++ { ++ if (ubicom32_data_register_operand (operands[0], GET_MODE (operands[0]))) ++ { ++ operands[2] = gen_lowpart (SImode, operands[0]); ++ operands[3] = gen_lowpart (SImode, operands[1]); ++ operands[4] = gen_highpart (SImode, operands[0]); ++ operands[5] = gen_highpart_mode (SImode, DImode, operands[1]); ++ } ++ else ++ { ++ operands[2] = gen_lowpart (SImode, operands[1]); ++ operands[3] = gen_lowpart (SImode, operands[0]); ++ operands[4] = gen_highpart (SImode, operands[1]); ++ operands[5] = gen_highpart (SImode, operands[0]); ++ } ++ ++ return \"add.4\\t#0, %3, %2\;addc\\t#0, %5, %4\"; ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_expand "subqi3" ++ [(parallel ++ [(set (match_operand:QI 0 "memory_operand" "") ++ (minus:QI (match_operand:QI 1 "ubicom32_arith_operand" "") ++ (match_operand:QI 2 "ubicom32_data_register_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "(ubicom32_v4)" ++ "{ ++ if (!memory_operand (operands[0], QImode)) ++ FAIL; ++ }") ++ ++(define_insn "subqi3_sub1" ++ [(set (match_operand:QI 0 "memory_operand" "=m") ++ (minus:QI (match_operand:QI 1 "ubicom32_arith_operand" "rmI") ++ (match_operand:QI 2 "ubicom32_data_register_operand" "d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4)" ++ "sub.1\\t%0, %1, %2") ++ ++(define_expand "subhi3" ++ [(parallel ++ [(set (match_operand:HI 0 "memory_operand" "") ++ (minus:HI (match_operand:HI 1 "ubicom32_arith_operand" "") ++ (match_operand:HI 2 "ubicom32_data_register_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "(ubicom32_v4)" ++ "{ ++ if (!memory_operand (operands[0], HImode)) ++ FAIL; ++ }") ++ ++(define_insn "subhi3_sub2" ++ [(set (match_operand:HI 0 "memory_operand" "=m") ++ (minus:HI (match_operand:HI 1 "ubicom32_arith_operand" "rmI") ++ (match_operand:HI 2 "ubicom32_data_register_operand" "d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "sub.2\\t%0, %1, %2") ++ ++(define_insn "subsi3" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm") ++ (minus:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI") ++ (match_operand:SI 2 "ubicom32_data_register_operand" "d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "sub.4\\t%0, %1, %2") ++ ++(define_insn "subsi3_ccwz" ++ [(set (reg CC_REGNO) ++ (compare ++ (minus:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI") ++ (match_operand:SI 2 "ubicom32_data_register_operand" "d")) ++ (const_int 0))) ++ (set (match_operand:SI 0 "nonimmediate_operand" "=rm") ++ (minus:SI (match_dup 1) ++ (match_dup 2)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "sub.4\\t%0, %1, %2") ++ ++; We construct a 64-bit add from 32-bit operations. Note that we use the ++; & constraint to prevent overlapping registers being allocated. We do ++; allow identical registers though as that won't break anything. ++; ++(define_insn "subdi3" ++ [(set (match_operand:DI 0 "nonimmediate_operand" "=&r,r, d, m") ++ (minus:DI (match_operand:DI 1 "ubicom32_arith_operand" "rmI,0,rmI,rmI") ++ (match_operand:DI 2 "ubicom32_data_register_operand" "d,d, 0, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "* ++ { ++ operands[3] = gen_lowpart (SImode, operands[0]); ++ operands[4] = gen_lowpart (SImode, operands[1]); ++ operands[5] = gen_lowpart (SImode, operands[2]); ++ operands[6] = gen_highpart (SImode, operands[0]); ++ operands[7] = gen_highpart_mode (SImode, DImode, operands[1]); ++ operands[8] = gen_highpart (SImode, operands[2]); ++ ++ return \"sub.4\\t%3, %4, %5\;subc\\t%6, %7, %8\"; ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_insn "subdi3_ccwz" ++ [(set (reg CC_REGNO) ++ (compare ++ (minus:DI (match_operand:DI 1 "ubicom32_arith_operand" "rmI,rmI") ++ (match_operand:DI 2 "ubicom32_data_register_operand" "d, d")) ++ (const_int 0))) ++ (set (match_operand:DI 0 "nonimmediate_operand" "=&r, m") ++ (minus:DI (match_dup 1) ++ (match_dup 2)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "* ++ { ++ operands[3] = gen_lowpart (SImode, operands[0]); ++ operands[4] = gen_lowpart (SImode, operands[1]); ++ operands[5] = gen_lowpart (SImode, operands[2]); ++ operands[6] = gen_highpart (SImode, operands[0]); ++ operands[7] = gen_highpart_mode (SImode, DImode, operands[1]); ++ operands[8] = gen_highpart (SImode, operands[2]); ++ ++ return \"sub.4\\t%3, %4, %5\;subc\\t%6, %7, %8\"; ++ }" ++ [(set_attr "length" "8")]) ++ ++;(define_insn "negqi2" ++; [(set (match_operand:QI 0 "nonimmediate_operand" "=rm") ++; (neg:QI (match_operand:QI 1 "ubicom32_data_register_operand" "d"))) ++; (clobber (reg:CC CC_REGNO))] ++; "(ubicom32_v4)" ++; "sub.1\\t%0, #0, %1") ++ ++;(define_insn "neghi2" ++; [(set (match_operand:HI 0 "nonimmediate_operand" "=rm") ++; (neg:HI (match_operand:HI 1 "ubicom32_data_register_operand" "d"))) ++; (clobber (reg:CC CC_REGNO))] ++; "" ++; "sub.2\\t%0, #0, %1") ++ ++(define_insn "negsi2" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm") ++ (neg:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "sub.4\\t%0, #0, %1") ++ ++(define_insn_and_split "negdi2" ++ [(set (match_operand:DI 0 "nonimmediate_operand" "=&rm") ++ (neg:DI (match_operand:DI 1 "ubicom32_data_register_operand" "d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "#" ++ "reload_completed" ++ [(parallel [(set (match_dup 0) ++ (minus:DI (const_int 0) ++ (match_dup 1))) ++ (clobber (reg:CC CC_REGNO))])] ++ "" ++ [(set_attr "length" "8")]) ++ ++(define_insn "umulhisi3" ++ [(set (match_operand:SI 0 "ubicom32_acc_lo_register_operand" "=l, l") ++ (mult:SI ++ (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "%d,rm")) ++ (zero_extend:SI (match_operand:HI 2 "nonimmediate_operand" "rm, d")))) ++ (clobber (reg:HI ACC0_HI_REGNO)) ++ (clobber (reg:HI ACC1_HI_REGNO))] ++ "" ++ "@ ++ mulu\\t%A0, %2, %1 ++ mulu\\t%A0, %1, %2" ++ [(set_attr "type" "mul,mul")]) ++ ++(define_insn "mulhisi3" ++ [(set (match_operand:SI 0 "ubicom32_acc_lo_register_operand" "=l, l") ++ (mult:SI ++ (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "%d,rm")) ++ (sign_extend:SI (match_operand:HI 2 "nonimmediate_operand" "rm, d")))) ++ (clobber (reg:HI ACC0_HI_REGNO)) ++ (clobber (reg:HI ACC1_HI_REGNO))] ++ "" ++ "@ ++ muls\\t%A0, %2, %1 ++ muls\\t%A0, %1, %2" ++ [(set_attr "type" "mul,mul")]) ++ ++(define_expand "mulsi3" ++ [(set (match_operand:SI 0 "ubicom32_acc_hi_register_operand" "") ++ (mult:SI (match_operand:SI 1 "ubicom32_arith_operand" "") ++ (match_operand:SI 2 "ubicom32_arith_operand" "")))] ++ "" ++ "{ ++ if (ubicom32_emit_mult_sequence (operands)) ++ DONE; ++ }") ++ ++(define_insn "umulsidi3" ++ [(set (match_operand:DI 0 "ubicom32_acc_hi_register_operand" "=h, h") ++ (mult:DI ++ (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "%d,rm")) ++ (zero_extend:DI (match_operand:SI 2 "nonimmediate_operand" "rm, d"))))] ++ "(ubicom32_v4)" ++ "@ ++ mulu.4\\t%A0, %2, %1 ++ mulu.4\\t%A0, %1, %2" ++ [(set_attr "type" "mul,mul")]) ++ ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "nonimmediate_operand" "")) ++ (set (match_operand:DI 2 "ubicom32_acc_hi_register_operand" "") ++ (mult:DI ++ (zero_extend:DI (match_dup 0)) ++ (zero_extend:DI (match_operand:SI 3 "ubicom32_data_register_operand" ""))))] ++ "(peep2_reg_dead_p (2, operands[0]) ++ || REGNO (operands[0]) == REGNO (operands[2]) ++ || REGNO (operands[0]) == REGNO (operands[2]) + 1) ++ && ! rtx_equal_p (operands[0], operands[3])" ++ [(set (match_dup 2) ++ (mult:DI ++ (zero_extend:DI (match_dup 1)) ++ (zero_extend:DI (match_dup 3))))] ++ "") ++ ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "nonimmediate_operand" "")) ++ (set (match_operand:DI 2 "ubicom32_acc_hi_register_operand" "") ++ (mult:DI ++ (zero_extend:DI (match_operand:SI 3 "ubicom32_data_register_operand" "")) ++ (zero_extend:DI (match_dup 0))))] ++ "(peep2_reg_dead_p (2, operands[0]) ++ || REGNO (operands[0]) == REGNO (operands[2]) ++ || REGNO (operands[0]) == REGNO (operands[2]) + 1) ++ && ! rtx_equal_p (operands[0], operands[3])" ++ [(set (match_dup 2) ++ (mult:DI ++ (zero_extend:DI (match_dup 1)) ++ (zero_extend:DI (match_dup 3))))] ++ "") ++ ++(define_insn "umulsidi3_const" ++ [(set (match_operand:DI 0 "ubicom32_acc_hi_register_operand" "=h") ++ (mult:DI ++ (zero_extend:DI (match_operand:SI 1 "ubicom32_data_register_operand" "%d")) ++ (match_operand 2 "const_int_operand" "I")))] ++ "(ubicom32_v4 && satisfies_constraint_I (operands[2]))" ++ "mulu.4\\t%A0, %2, %1" ++ [(set_attr "type" "mul")]) ++ ++(define_insn "mulsidi3" ++ [(set (match_operand:DI 0 "ubicom32_acc_hi_register_operand" "=h, h") ++ (mult:DI ++ (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "%d,rm")) ++ (sign_extend:DI (match_operand:SI 2 "nonimmediate_operand" "rm, d"))))] ++ "(ubicom32_v4)" ++ "@ ++ muls.4\\t%A0, %2, %1 ++ muls.4\\t%A0, %1, %2" ++ [(set_attr "type" "mul,mul")]) ++ ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "nonimmediate_operand" "")) ++ (set (match_operand:DI 2 "ubicom32_acc_hi_register_operand" "") ++ (mult:DI ++ (sign_extend:DI (match_dup 0)) ++ (sign_extend:DI (match_operand:SI 3 "ubicom32_data_register_operand" ""))))] ++ "(peep2_reg_dead_p (2, operands[0]) ++ || REGNO (operands[0]) == REGNO (operands[2]) ++ || REGNO (operands[0]) == REGNO (operands[2]) + 1) ++ && ! rtx_equal_p (operands[0], operands[3])" ++ [(set (match_dup 2) ++ (mult:DI ++ (sign_extend:DI (match_dup 1)) ++ (sign_extend:DI (match_dup 3))))] ++ "") ++ ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "nonimmediate_operand" "")) ++ (set (match_operand:DI 2 "ubicom32_acc_hi_register_operand" "") ++ (mult:DI ++ (sign_extend:DI (match_operand:SI 3 "ubicom32_data_register_operand" "")) ++ (sign_extend:DI (match_dup 0))))] ++ "(peep2_reg_dead_p (2, operands[0]) ++ || REGNO (operands[0]) == REGNO (operands[2]) ++ || REGNO (operands[0]) == REGNO (operands[2]) + 1) ++ && ! rtx_equal_p (operands[0], operands[3])" ++ [(set (match_dup 2) ++ (mult:DI ++ (sign_extend:DI (match_dup 1)) ++ (sign_extend:DI (match_dup 3))))] ++ "") ++ ++(define_insn "mulsidi3_const" ++ [(set (match_operand:DI 0 "ubicom32_acc_hi_register_operand" "=h") ++ (mult:DI ++ (sign_extend:DI (match_operand:SI 1 "ubicom32_data_register_operand" "%d")) ++ (match_operand 2 "const_int_operand" "I")))] ++ "(ubicom32_v4 && satisfies_constraint_I (operands[2]))" ++ "muls.4\\t%A0, %2, %1" ++ [(set_attr "type" "mul")]) ++ ++(define_expand "andqi3" ++ [(parallel ++ [(set (match_operand:QI 0 "memory_operand" "") ++ (and:QI (match_operand:QI 1 "nonimmediate_operand" "") ++ (match_operand:QI 2 "ubicom32_arith_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "(ubicom32_v4)" ++ "{ ++ if (!memory_operand (operands[0], QImode)) ++ FAIL; ++ ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (QImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (QImode, operands[2]); ++ }") ++ ++(define_insn "andqi3_and1" ++ [(set (match_operand:QI 0 "memory_operand" "=m, m") ++ (and:QI (match_operand:QI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:QI 2 "ubicom32_arith_operand" "rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4)" ++ "@ ++ and.1\\t%0, %2, %1 ++ and.1\\t%0, %1, %2") ++ ++(define_insn "andqi3_and1_ccszn" ++ [(set (reg CC_REGNO) ++ (compare ++ (and:QI (match_operand:QI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:QI 2 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0))) ++ (set (match_operand:QI 0 "memory_operand" "=m, m") ++ (and:QI (match_dup 1) ++ (match_dup 2)))] ++ "(ubicom32_v4 ++ && ubicom32_match_cc_mode(insn, CCSZNmode))" ++ "@ ++ and.1\\t%0, %2, %1 ++ and.1\\t%0, %1, %2") ++ ++(define_insn "andqi3_and1_ccszn_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (and:QI (match_operand:QI 0 "nonimmediate_operand" "%d,rm") ++ (match_operand:QI 1 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0)))] ++ "(ubicom32_v4 ++ && ubicom32_match_cc_mode(insn, CCSZNmode))" ++ "@ ++ and.1\\t#0, %1, %0 ++ and.1\\t#0, %0, %1") ++ ++(define_insn "and1_ccszn_null_1" ++ [(set (reg CC_REGNO) ++ (compare ++ (subreg:QI ++ (and:SI (match_operand:SI 0 "ubicom32_data_register_operand" "%d") ++ (match_operand:SI 1 "ubicom32_arith_operand" "rI")) ++ 3) ++ (const_int 0)))] ++ "(ubicom32_v4 ++ && ubicom32_match_cc_mode(insn, CCSZNmode))" ++ "and.1\\t#0, %1, %0") ++ ++(define_insn "and1_ccszn_null_2" ++ [(set (reg CC_REGNO) ++ (compare ++ (subreg:QI ++ (and:SI (match_operand:SI 0 "ubicom32_data_register_operand" "d") ++ (subreg:SI ++ (match_operand:QI 1 "memory_operand" "m") ++ 0)) ++ 3) ++ (const_int 0)))] ++ "(ubicom32_v4 ++ && ubicom32_match_cc_mode(insn, CCSZNmode))" ++ "and.1\\t#0, %1, %0") ++ ++(define_insn "and1_ccszn_null_3" ++ [(set (reg CC_REGNO) ++ (compare ++ (subreg:QI ++ (and:SI (subreg:SI ++ (match_operand:QI 0 "memory_operand" "m") ++ 0) ++ (match_operand:SI 1 "ubicom32_data_register_operand" "d")) ++ 3) ++ (const_int 0)))] ++ "(ubicom32_v4 ++ && ubicom32_match_cc_mode(insn, CCSZNmode))" ++ "and.1\\t#0, %0, %1") ++ ++(define_expand "andhi3" ++ [(parallel ++ [(set (match_operand:HI 0 "memory_operand" "") ++ (and:HI (match_operand:HI 1 "nonimmediate_operand" "") ++ (match_operand:HI 2 "ubicom32_arith_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "" ++ "{ ++ if (!memory_operand (operands[0], HImode)) ++ FAIL; ++ ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (HImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (HImode, operands[2]); ++ }") ++ ++(define_insn "andhi3_and2" ++ [(set (match_operand:HI 0 "memory_operand" "=m, m") ++ (and:HI (match_operand:HI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:HI 2 "ubicom32_arith_operand" "rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "@ ++ and.2\\t%0, %2, %1 ++ and.2\\t%0, %1, %2") ++ ++(define_insn "andhi3_and2_ccszn" ++ [(set (reg CC_REGNO) ++ (compare ++ (and:HI (match_operand:HI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:HI 2 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0))) ++ (set (match_operand:HI 0 "memory_operand" "=m, m") ++ (and:HI (match_dup 1) ++ (match_dup 2)))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "@ ++ and.2\\t%0, %2, %1 ++ and.2\\t%0, %1, %2") ++ ++(define_insn "andhi3_and2_ccszn_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (and:HI (match_operand:HI 0 "nonimmediate_operand" "%d,rm") ++ (match_operand:HI 1 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "@ ++ and.2\\t#0, %1, %0 ++ and.2\\t#0, %0, %1") ++ ++(define_insn "and2_ccszn_null_1" ++ [(set (reg CC_REGNO) ++ (compare ++ (subreg:HI ++ (and:SI (match_operand:SI 0 "ubicom32_data_register_operand" "%d") ++ (match_operand:SI 1 "ubicom32_arith_operand" "rI")) ++ 2) ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "and.2\\t#0, %1, %0") ++ ++(define_insn "and2_ccszn_null_2" ++ [(set (reg CC_REGNO) ++ (compare ++ (subreg:HI ++ (and:SI (match_operand:SI 0 "ubicom32_data_register_operand" "d") ++ (subreg:SI ++ (match_operand:HI 1 "memory_operand" "m") ++ 0)) ++ 2) ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "and.2\\t#0, %1, %0") ++ ++(define_insn "and2_ccszn_null_3" ++ [(set (reg CC_REGNO) ++ (compare ++ (subreg:HI ++ (and:SI (subreg:SI ++ (match_operand:HI 0 "memory_operand" "m") ++ 0) ++ (match_operand:SI 1 "ubicom32_data_register_operand" "d")) ++ 2) ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "and.2\\t#0, %0, %1") ++ ++(define_expand "andsi3" ++ [(parallel ++ [(set (match_operand:SI 0 "nonimmediate_operand" "") ++ (and:SI (match_operand:SI 1 "nonimmediate_operand" "") ++ (match_operand:SI 2 "ubicom32_and_or_si3_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "" ++ "{ ++ do ++ { ++ /* Is this a bfextu? */ ++ if (ubicom32_data_register_operand (operands[0], SImode) ++ && CONST_INT_P (operands[2]) ++ && exact_log2 (INTVAL (operands[2]) + 1) != -1) ++ break; ++ ++ /* Is this a bclr? */ ++ if (CONST_INT_P (operands[2]) ++ && exact_log2 (~INTVAL (operands[2])) != -1) ++ break; ++ ++ /* Must be an and.4 */ ++ if (!ubicom32_data_register_operand (operands[1], SImode)) ++ operands[1] = copy_to_mode_reg (SImode, operands[1]); ++ ++ if (!ubicom32_arith_operand (operands[2], SImode)) ++ operands[2] = copy_to_mode_reg (SImode, operands[2]); ++ } ++ while (0); ++ }") ++ ++(define_insn "andsi3_bfextu" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (and:SI (match_operand:SI 1 "nonimmediate_operand" "%rm") ++ (match_operand:SI 2 "const_int_operand" "O"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(satisfies_constraint_O (operands[2]))" ++ "* ++ { ++ operands[3] = GEN_INT (exact_log2 (INTVAL (operands[2]) + 1)); ++ ++ return \"bfextu\\t%0, %1, %3\"; ++ }") ++ ++(define_insn "andsi3_bfextu_ccwz" ++ [(set (reg CC_REGNO) ++ (compare ++ (and:SI (match_operand:SI 1 "nonimmediate_operand" "%rm") ++ (match_operand:SI 2 "const_int_operand" "O")) ++ (const_int 0))) ++ (set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (and:SI (match_dup 1) ++ (match_dup 2)))] ++ "(satisfies_constraint_O (operands[2]) ++ && ubicom32_match_cc_mode(insn, CCWZmode))" ++ "* ++ { ++ operands[3] = GEN_INT (exact_log2 (INTVAL (operands[2]) + 1)); ++ ++ return \"bfextu\\t%0, %1, %3\"; ++ }") ++ ++(define_insn "andsi3_bfextu_ccwz_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (and:SI (match_operand:SI 0 "nonimmediate_operand" "%rm") ++ (match_operand:SI 1 "const_int_operand" "O")) ++ (const_int 0))) ++ (clobber (match_scratch:SI 2 "=d"))] ++ "(satisfies_constraint_O (operands[1]) ++ && ubicom32_match_cc_mode(insn, CCWZmode))" ++ "* ++ { ++ operands[3] = GEN_INT (exact_log2 (INTVAL (operands[1]) + 1)); ++ ++ return \"bfextu\\t%2, %0, %3\"; ++ }") ++ ++(define_insn "andsi3_bclr" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm") ++ (and:SI (match_operand:SI 1 "ubicom32_arith_operand" "%rmI") ++ (match_operand:SI 2 "const_int_operand" "n"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(exact_log2 (~INTVAL (operands[2])) != -1)" ++ "bclr\\t%0, %1, #%D2") ++ ++(define_insn "andsi3_and4" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm,rm") ++ (and:SI (match_operand:SI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "@ ++ and.4\\t%0, %2, %1 ++ and.4\\t%0, %1, %2") ++ ++(define_insn "andsi3_and4_ccwzn" ++ [(set (reg CC_REGNO) ++ (compare ++ (and:SI (match_operand:SI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0))) ++ (set (match_operand:SI 0 "nonimmediate_operand" "=rm,rm") ++ (and:SI (match_dup 1) ++ (match_dup 2)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "@ ++ and.4\\t%0, %2, %1 ++ and.4\\t%0, %1, %2") ++ ++(define_insn "andsi3_and4_ccwzn_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (and:SI (match_operand:SI 0 "nonimmediate_operand" "%d,rm") ++ (match_operand:SI 1 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "@ ++ and.4\\t#0, %1, %0 ++ and.4\\t#0, %0, %1") ++ ++(define_insn "andsi3_lsr4_ccwz_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (and:SI (match_operand:SI 0 "nonimmediate_operand" "%rm") ++ (match_operand:SI 1 "const_int_operand" "n")) ++ (const_int 0))) ++ (clobber (match_scratch:SI 2 "=d"))] ++ "(exact_log2 ((~(INTVAL (operands[1]))) + 1) != -1 ++ && ubicom32_match_cc_mode(insn, CCWZmode))" ++ "* ++ { ++ operands[3] = GEN_INT (exact_log2 ((~(INTVAL (operands[1]))) + 1)); ++ ++ return \"lsr.4\\t%2, %0, %3\"; ++ }") ++ ++; We really would like the combiner to recognize this scenario and deal with ++; it but unfortunately it tries to canonicalize zero_extract ops on MEMs ++; into QImode operations and we can't match them in any useful way. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (match_operand:SI 1 "const_int_operand" "")) ++ (set (reg:CCWZ CC_REGNO) ++ (compare:CCWZ ++ (and:SI (match_operand:SI 2 "nonimmediate_operand" "") ++ (match_dup 0)) ++ (const_int 0)))] ++ "(exact_log2 (INTVAL (operands[1])) != -1 ++ && peep2_reg_dead_p (2, operands[0]))" ++ [(set (reg:CCWZ CC_REGNO) ++ (compare:CCWZ ++ (zero_extract:SI ++ (match_dup 2) ++ (const_int 1) ++ (match_dup 3)) ++ (const_int 0)))] ++ "{ ++ operands[3] = GEN_INT (exact_log2 (INTVAL (operands[1]))); ++ }") ++ ++(define_expand "anddi3" ++ [(parallel ++ [(set (match_operand:DI 0 "nonimmediate_operand" "") ++ (and:DI (match_operand:DI 1 "nonimmediate_operand" "") ++ (match_operand:DI 2 "ubicom32_arith_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "" ++ "{ ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (DImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (DImode, operands[2]); ++ }") ++ ++(define_insn_and_split "anddi3_and4" ++ [(set (match_operand:DI 0 "nonimmediate_operand" "=&r,&r, d,rm, m, m") ++ (and:DI (match_operand:DI 1 "nonimmediate_operand" "%d,rm, 0, 0, d,rm") ++ (match_operand:DI 2 "ubicom32_arith_operand" "rmI, d,rmI, d,rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "#" ++ "reload_completed" ++ [(parallel [(set (match_dup 3) ++ (and:SI (match_dup 4) ++ (match_dup 5))) ++ (clobber (reg:CC CC_REGNO))]) ++ (parallel [(set (match_dup 6) ++ (and:SI (match_dup 7) ++ (match_dup 8))) ++ (clobber (reg:CC CC_REGNO))])] ++ "{ ++ operands[3] = gen_lowpart (SImode, operands[0]); ++ operands[4] = gen_lowpart (SImode, operands[1]); ++ operands[5] = gen_lowpart (SImode, operands[2]); ++ operands[6] = gen_highpart (SImode, operands[0]); ++ operands[7] = gen_highpart (SImode, operands[1]); ++ operands[8] = gen_highpart_mode (SImode, DImode, operands[2]); ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_expand "iorqi3" ++ [(parallel ++ [(set (match_operand:QI 0 "memory_operand" "") ++ (ior:QI (match_operand:QI 1 "nonimmediate_operand" "") ++ (match_operand:QI 2 "ubicom32_arith_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "(ubicom32_v4)" ++ "{ ++ if (!memory_operand (operands[0], QImode)) ++ FAIL; ++ ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (QImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (QImode, operands[2]); ++ }") ++ ++(define_insn "iorqi3_or1" ++ [(set (match_operand:QI 0 "memory_operand" "=m, m") ++ (ior:QI (match_operand:QI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:QI 2 "ubicom32_arith_operand" "rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4)" ++ "@ ++ or.1\\t%0, %2, %1 ++ or.1\\t%0, %1, %2") ++ ++(define_expand "iorhi3" ++ [(parallel ++ [(set (match_operand:HI 0 "memory_operand" "") ++ (ior:HI (match_operand:HI 1 "nonimmediate_operand" "") ++ (match_operand:HI 2 "ubicom32_arith_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "" ++ "{ ++ if (!memory_operand (operands[0], HImode)) ++ FAIL; ++ ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (HImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (HImode, operands[2]); ++ }") ++ ++(define_insn "iorhi3_or2" ++ [(set (match_operand:HI 0 "memory_operand" "=m, m") ++ (ior:HI (match_operand:HI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:HI 2 "ubicom32_arith_operand" "rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "@ ++ or.2\\t%0, %2, %1 ++ or.2\\t%0, %1, %2") ++ ++(define_expand "iorsi3" ++ [(parallel ++ [(set (match_operand:SI 0 "nonimmediate_operand" "") ++ (ior:SI (match_operand:SI 1 "nonimmediate_operand" "") ++ (match_operand:SI 2 "ubicom32_and_or_si3_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "" ++ "{ ++ do ++ { ++ /* Is this a bset? */ ++ if (CONST_INT_P (operands[2]) ++ && exact_log2 (INTVAL (operands[2])) != -1) ++ break; ++ ++ /* Must be an or.4 */ ++ if (!ubicom32_data_register_operand (operands[1], SImode)) ++ operands[1] = copy_to_mode_reg (SImode, operands[1]); ++ ++ if (!ubicom32_arith_operand (operands[2], SImode)) ++ operands[2] = copy_to_mode_reg (SImode, operands[2]); ++ } ++ while (0); ++ }") ++ ++(define_insn "iorsi3_bset" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm") ++ (ior:SI (match_operand:SI 1 "ubicom32_arith_operand" "%rmI") ++ (match_operand 2 "const_int_operand" "n"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(exact_log2 (INTVAL (operands[2])) != -1)" ++ "bset\\t%0, %1, #%d2") ++ ++(define_insn "iorsi3_or4" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm,rm") ++ (ior:SI (match_operand:SI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "@ ++ or.4\\t%0, %2, %1 ++ or.4\\t%0, %1, %2") ++ ++(define_insn "iorsi3_ccwzn" ++ [(set (reg CC_REGNO) ++ (compare ++ (ior:SI (match_operand:SI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0))) ++ (set (match_operand:SI 0 "nonimmediate_operand" "=rm,rm") ++ (ior:SI (match_dup 1) ++ (match_dup 2)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "@ ++ or.4\\t%0, %2, %1 ++ or.4\\t%0, %1, %2") ++ ++(define_insn "iorsi3_ccwzn_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (ior:SI (match_operand:SI 0 "nonimmediate_operand" "%d,rm") ++ (match_operand:SI 1 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "@ ++ or.4\\t#0, %1, %0 ++ or.4\\t#0, %0, %1") ++ ++(define_expand "iordi3" ++ [(parallel ++ [(set (match_operand:DI 0 "nonimmediate_operand" "") ++ (ior:DI (match_operand:DI 1 "nonimmediate_operand" "") ++ (match_operand:DI 2 "ubicom32_arith_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "" ++ "{ ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (DImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (DImode, operands[2]); ++ }") ++ ++(define_insn_and_split "iordi3_or4" ++ [(set (match_operand:DI 0 "nonimmediate_operand" "=&r,&r, d,rm, m, m") ++ (ior:DI (match_operand:DI 1 "nonimmediate_operand" "%d,rm, 0, 0, d,rm") ++ (match_operand:DI 2 "ubicom32_arith_operand" "rmI, d,rmI, d,rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "#" ++ "reload_completed" ++ [(parallel [(set (match_dup 3) ++ (ior:SI (match_dup 4) ++ (match_dup 5))) ++ (clobber (reg:CC CC_REGNO))]) ++ (parallel [(set (match_dup 6) ++ (ior:SI (match_dup 7) ++ (match_dup 8))) ++ (clobber (reg:CC CC_REGNO))])] ++ "{ ++ operands[3] = gen_lowpart (SImode, operands[0]); ++ operands[4] = gen_lowpart (SImode, operands[1]); ++ operands[5] = gen_lowpart (SImode, operands[2]); ++ operands[6] = gen_highpart (SImode, operands[0]); ++ operands[7] = gen_highpart (SImode, operands[1]); ++ operands[8] = gen_highpart_mode (SImode, DImode, operands[2]); ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_expand "xorqi3" ++ [(parallel ++ [(set (match_operand:QI 0 "memory_operand" "") ++ (xor:QI (match_operand:QI 1 "nonimmediate_operand" "") ++ (match_operand:QI 2 "ubicom32_arith_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "(ubicom32_v4)" ++ "{ ++ if (!memory_operand (operands[0], QImode)) ++ FAIL; ++ ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (QImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (QImode, operands[2]); ++ }") ++ ++(define_insn "xorqi3_xor1" ++ [(set (match_operand:QI 0 "memory_operand" "=m, m") ++ (xor:QI (match_operand:QI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:QI 2 "ubicom32_arith_operand" "rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4)" ++ "@ ++ xor.1\\t%0, %2, %1 ++ xor.1\\t%0, %1, %2") ++ ++(define_insn "xorqi3_xor1_ccszn" ++ [(set (reg CC_REGNO) ++ (compare ++ (xor:QI (match_operand:QI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:QI 2 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0))) ++ (set (match_operand:QI 0 "memory_operand" "=m, m") ++ (xor:QI (match_dup 1) ++ (match_dup 2)))] ++ "(ubicom32_v4 ++ && ubicom32_match_cc_mode(insn, CCSZNmode))" ++ "@ ++ xor.1\\t%0, %2, %1 ++ xor.1\\t%0, %1, %2") ++ ++(define_insn "xorqi3_xor1_ccszn_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (xor:QI (match_operand:QI 0 "nonimmediate_operand" "%d,rm") ++ (match_operand:QI 1 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0)))] ++ "(ubicom32_v4 ++ && ubicom32_match_cc_mode(insn, CCSZNmode))" ++ "@ ++ xor.1\\t#0, %1, %0 ++ xor.1\\t#0, %0, %1") ++ ++(define_insn "xor1_ccszn_null_1" ++ [(set (reg CC_REGNO) ++ (compare ++ (subreg:QI ++ (xor:SI (match_operand:SI 0 "ubicom32_data_register_operand" "%d") ++ (match_operand:SI 1 "ubicom32_arith_operand" "rI")) ++ 3) ++ (const_int 0)))] ++ "(ubicom32_v4 ++ && ubicom32_match_cc_mode(insn, CCSZNmode))" ++ "xor.1\\t#0, %1, %0") ++ ++(define_insn "xor1_ccszn_null_2" ++ [(set (reg CC_REGNO) ++ (compare ++ (subreg:QI ++ (xor:SI (match_operand:SI 0 "ubicom32_data_register_operand" "d") ++ (subreg:SI ++ (match_operand:QI 1 "memory_operand" "m") ++ 0)) ++ 3) ++ (const_int 0)))] ++ "(ubicom32_v4 ++ && ubicom32_match_cc_mode(insn, CCSZNmode))" ++ "xor.1\\t#0, %1, %0") ++ ++(define_insn "xor1_ccwzn_null_3" ++ [(set (reg CC_REGNO) ++ (compare ++ (subreg:QI ++ (xor:SI (subreg:SI ++ (match_operand:QI 0 "memory_operand" "m") ++ 0) ++ (match_operand:SI 1 "ubicom32_data_register_operand" "d")) ++ 3) ++ (const_int 0)))] ++ "(ubicom32_v4 ++ && ubicom32_match_cc_mode(insn, CCSZNmode))" ++ "xor.1\\t#0, %0, %1") ++ ++(define_expand "xorhi3" ++ [(parallel ++ [(set (match_operand:HI 0 "memory_operand" "") ++ (xor:HI (match_operand:HI 1 "nonimmediate_operand" "") ++ (match_operand:HI 2 "ubicom32_arith_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "" ++ "{ ++ if (!memory_operand (operands[0], HImode)) ++ FAIL; ++ ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (HImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (HImode, operands[2]); ++ }") ++ ++(define_insn "xorhi3_xor2" ++ [(set (match_operand:HI 0 "memory_operand" "=m, m") ++ (xor:HI (match_operand:HI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:HI 2 "ubicom32_arith_operand" "rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "@ ++ xor.2\\t%0, %2, %1 ++ xor.2\\t%0, %1, %2") ++ ++(define_insn "xorhi3_xor2_ccszn" ++ [(set (reg CC_REGNO) ++ (compare ++ (xor:HI (match_operand:HI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:HI 2 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0))) ++ (set (match_operand:HI 0 "memory_operand" "=m, m") ++ (xor:HI (match_dup 1) ++ (match_dup 2)))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "@ ++ xor.2\\t%0, %2, %1 ++ xor.2\\t%0, %1, %2") ++ ++(define_insn "xorhi3_xor2_ccszn_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (xor:HI (match_operand:HI 0 "nonimmediate_operand" "%d,rm") ++ (match_operand:HI 1 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "@ ++ xor.2\\t#0, %1, %0 ++ xor.2\\t#0, %0, %1") ++ ++(define_insn "xor2_ccszn_null_1" ++ [(set (reg CC_REGNO) ++ (compare ++ (subreg:HI ++ (xor:SI (match_operand:SI 0 "ubicom32_data_register_operand" "%d") ++ (match_operand:SI 1 "ubicom32_arith_operand" "rI")) ++ 2) ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "xor.2\\t#0, %1, %0") ++ ++(define_insn "xor2_ccszn_null_2" ++ [(set (reg CC_REGNO) ++ (compare ++ (subreg:HI ++ (xor:SI (match_operand:SI 0 "ubicom32_data_register_operand" "d") ++ (subreg:SI ++ (match_operand:HI 1 "memory_operand" "m") ++ 0)) ++ 2) ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "xor.2\\t#0, %1, %0") ++ ++(define_insn "xor2_ccszn_null_3" ++ [(set (reg CC_REGNO) ++ (compare ++ (subreg:HI ++ (xor:SI (subreg:SI ++ (match_operand:HI 0 "memory_operand" "m") ++ 0) ++ (match_operand:SI 1 "ubicom32_data_register_operand" "d")) ++ 2) ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCSZNmode)" ++ "xor.2\\t#0, %0, %1") ++ ++(define_insn "xorsi3" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm,rm") ++ (xor:SI (match_operand:SI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "@ ++ xor.4\\t%0, %2, %1 ++ xor.4\\t%0, %1, %2") ++ ++(define_insn "xorsi3_ccwzn" ++ [(set (reg CC_REGNO) ++ (compare ++ (xor:SI (match_operand:SI 1 "nonimmediate_operand" "%d,rm") ++ (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0))) ++ (set (match_operand:SI 0 "nonimmediate_operand" "=rm,rm") ++ (xor:SI (match_dup 1) ++ (match_dup 2)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "@ ++ xor.4\\t%0, %2, %1 ++ xor.4\\t%0, %1, %2") ++ ++(define_insn "xorsi3_ccwzn_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (xor:SI (match_operand:SI 0 "nonimmediate_operand" "%d,rm") ++ (match_operand:SI 1 "ubicom32_arith_operand" "rmI, d")) ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "@ ++ xor.4\\t#0, %1, %0 ++ xor.4\\t#0, %0, %1") ++ ++(define_expand "xordi3" ++ [(parallel ++ [(set (match_operand:DI 0 "nonimmediate_operand" "") ++ (xor:DI (match_operand:DI 1 "nonimmediate_operand" "") ++ (match_operand:DI 2 "ubicom32_arith_operand" ""))) ++ (clobber (reg:CC CC_REGNO))])] ++ "" ++ "{ ++ /* If we have a non-data reg for operand 1 then prefer that over ++ a CONST_INT in operand 2. */ ++ if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])) ++ && CONST_INT_P (operands[2])) ++ operands[2] = copy_to_mode_reg (DImode, operands[2]); ++ ++ if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2])) ++ operands[2] = copy_to_mode_reg (DImode, operands[2]); ++ }") ++ ++(define_insn_and_split "xordi3_xor4" ++ [(set (match_operand:DI 0 "nonimmediate_operand" "=&r,&r, d,rm, m, m") ++ (xor:DI (match_operand:DI 1 "nonimmediate_operand" "%d,rm, 0, 0, d,rm") ++ (match_operand:DI 2 "ubicom32_arith_operand" "rmI, d,rmI, d,rmI, d"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "#" ++ "reload_completed" ++ [(parallel [(set (match_dup 3) ++ (xor:SI (match_dup 4) ++ (match_dup 5))) ++ (clobber (reg:CC CC_REGNO))]) ++ (parallel [(set (match_dup 6) ++ (xor:SI (match_dup 7) ++ (match_dup 8))) ++ (clobber (reg:CC CC_REGNO))])] ++ "{ ++ operands[3] = gen_lowpart (SImode, operands[0]); ++ operands[4] = gen_lowpart (SImode, operands[1]); ++ operands[5] = gen_lowpart (SImode, operands[2]); ++ operands[6] = gen_highpart (SImode, operands[0]); ++ operands[7] = gen_highpart (SImode, operands[1]); ++ operands[8] = gen_highpart_mode (SImode, DImode, operands[2]); ++ }" ++ [(set_attr "length" "8")]) ++ ++(define_insn "not2_2" ++ [(set (match_operand:HI 0 "memory_operand" "=m") ++ (subreg:HI ++ (not:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI")) ++ 2)) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "not.2\\t%0, %1") ++ ++(define_insn "one_cmplsi2" ++ [(set (match_operand:SI 0 "nonimmediate_operand" "=rm") ++ (not:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "not.4\\t%0, %1") ++ ++(define_insn "one_cmplsi2_ccwzn" ++ [(set (reg CC_REGNO) ++ (compare ++ (not:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI")) ++ (const_int 0))) ++ (set (match_operand:SI 0 "nonimmediate_operand" "=rm") ++ (not:SI (match_dup 1)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "not.4\\t%0, %1") ++ ++(define_insn "one_cmplsi2_ccwzn_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (not:SI (match_operand:SI 0 "ubicom32_arith_operand" "rmI")) ++ (const_int 0)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "not.4\\t#0, %0") ++ ++(define_insn_and_split "one_cmpldi2" ++ [(set (match_operand:DI 0 "nonimmediate_operand" "=&rm") ++ (not:DI (match_operand:DI 1 "nonimmediate_operand" "rmI0"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "#" ++ "" ++ [(parallel [(set (match_dup 2) ++ (not:SI (match_dup 3))) ++ (clobber (reg:CC CC_REGNO))]) ++ (parallel [(set (match_dup 4) ++ (not:SI (match_dup 5))) ++ (clobber (reg:CC CC_REGNO))])] ++ "{ ++ operands[2] = gen_lowpart (SImode, operands[0]); ++ operands[3] = gen_lowpart (SImode, operands[1]); ++ operands[4] = gen_highpart (SImode, operands[0]); ++ operands[5] = gen_highpart (SImode, operands[1]); ++ }" ++ [(set_attr "length" "8")]) ++ ++; Conditional jump instructions ++ ++(define_expand "beq" ++ [(set (pc) ++ (if_then_else (eq (match_dup 1) ++ (const_int 0)) ++ (label_ref (match_operand 0 "" "")) ++ (pc)))] ++ "" ++ "{ ++ operands[1] = ubicom32_gen_compare_reg (EQ, ubicom32_compare_op0, ++ ubicom32_compare_op1); ++ }") ++ ++(define_expand "bne" ++ [(set (pc) ++ (if_then_else (ne (match_dup 1) ++ (const_int 0)) ++ (label_ref (match_operand 0 "" "")) ++ (pc)))] ++ "" ++ "{ ++ operands[1] = ubicom32_gen_compare_reg (NE, ubicom32_compare_op0, ++ ubicom32_compare_op1); ++ }") ++ ++(define_expand "bgt" ++ [(set (pc) ++ (if_then_else (gt (match_dup 1) ++ (const_int 0)) ++ (label_ref (match_operand 0 "" "")) ++ (pc)))] ++ "" ++ "{ ++ operands[1] = ubicom32_gen_compare_reg (GT, ubicom32_compare_op0, ++ ubicom32_compare_op1); ++ }") ++ ++(define_expand "ble" ++ [(set (pc) ++ (if_then_else (le (match_dup 1) ++ (const_int 0)) ++ (label_ref (match_operand 0 "" "")) ++ (pc)))] ++ "" ++ "{ ++ operands[1] = ubicom32_gen_compare_reg (LE, ubicom32_compare_op0, ++ ubicom32_compare_op1); ++ }") ++ ++(define_expand "bge" ++ [(set (pc) ++ (if_then_else (ge (match_dup 1) ++ (const_int 0)) ++ (label_ref (match_operand 0 "" "")) ++ (pc)))] ++ "" ++ "{ ++ operands[1] = ubicom32_gen_compare_reg (GE, ubicom32_compare_op0, ++ ubicom32_compare_op1); ++ }") ++ ++(define_expand "blt" ++ [(set (pc) ++ (if_then_else (lt (match_dup 1) ++ (const_int 0)) ++ (label_ref (match_operand 0 "" "")) ++ (pc)))] ++ "" ++ "{ ++ operands[1] = ubicom32_gen_compare_reg (LT, ubicom32_compare_op0, ++ ubicom32_compare_op1); ++ }") ++ ++(define_expand "bgtu" ++ [(set (pc) ++ (if_then_else (gtu (match_dup 1) ++ (const_int 0)) ++ (label_ref (match_operand 0 "" "")) ++ (pc)))] ++ "" ++ "{ ++ operands[1] = ubicom32_gen_compare_reg (GTU, ubicom32_compare_op0, ++ ubicom32_compare_op1); ++ }") ++ ++(define_expand "bleu" ++ [(set (pc) ++ (if_then_else (leu (match_dup 1) ++ (const_int 0)) ++ (label_ref (match_operand 0 "" "")) ++ (pc)))] ++ "" ++ "{ ++ operands[1] = ubicom32_gen_compare_reg (LEU, ubicom32_compare_op0, ++ ubicom32_compare_op1); ++ }") ++ ++(define_expand "bgeu" ++ [(set (pc) ++ (if_then_else (geu (match_dup 1) ++ (const_int 0)) ++ (label_ref (match_operand 0 "" "")) ++ (pc)))] ++ "" ++ "{ ++ operands[1] = ubicom32_gen_compare_reg (GEU, ubicom32_compare_op0, ++ ubicom32_compare_op1); ++ }") ++ ++(define_expand "bltu" ++ [(set (pc) ++ (if_then_else (ltu (match_dup 1) ++ (const_int 0)) ++ (label_ref (match_operand 0 "" "")) ++ (pc)))] ++ "" ++ "{ ++ operands[1] = ubicom32_gen_compare_reg (LTU, ubicom32_compare_op0, ++ ubicom32_compare_op1); ++ }") ++ ++(define_insn "jcc" ++ [(set (pc) ++ (if_then_else (match_operator 1 "comparison_operator" ++ [(match_operand 2 "ubicom32_cc_register_operand" "") ++ (const_int 0)]) ++ (label_ref (match_operand 0 "" "")) ++ (pc)))] ++ "" ++ "* ++ { ++ ubicom32_output_cond_jump (insn, operands[1], operands[0]); ++ return \"\"; ++ }") ++ ++; Reverse branch - reverse our comparison condition so that we can ++; branch in the opposite sense. ++; ++(define_insn_and_split "jcc_reverse" ++ [(set (pc) ++ (if_then_else (match_operator 1 "comparison_operator" ++ [(match_operand 2 "ubicom32_cc_register_operand" "") ++ (const_int 0)]) ++ (pc) ++ (label_ref (match_operand 0 "" ""))))] ++ "" ++ "#" ++ "reload_completed" ++ [(set (pc) ++ (if_then_else (match_dup 3) ++ (label_ref (match_dup 0)) ++ (pc)))] ++ "{ ++ rtx cc_reg; ++ ++ cc_reg = gen_rtx_REG (GET_MODE (operands[2]), CC_REGNO); ++ operands[3] = gen_rtx_fmt_ee (reverse_condition (GET_CODE (operands[1])), ++ GET_MODE (operands[1]), ++ cc_reg, ++ const0_rtx); ++ }") ++ ++(define_insn "jump" ++ [(set (pc) ++ (label_ref (match_operand 0 "" "")))] ++ "" ++ "jmpt\\t%l0") ++ ++(define_expand "indirect_jump" ++ [(parallel [(set (pc) ++ (match_operand:SI 0 "register_operand" "")) ++ (clobber (match_dup 0))])] ++ "" ++ "") ++ ++(define_insn "indirect_jump_internal" ++ [(set (pc) ++ (match_operand:SI 0 "register_operand" "a")) ++ (clobber (match_dup 0))] ++ "" ++ "calli\\t%0,0(%0)") ++ ++; Program Space: The table contains instructions, typically jumps. ++; CALL An,TABLE_SIZE(PC) ;An = Jump Table Base Address. ++; ;An -> Here. ++; LEA Ak, (An,Dn) ;Ak -> Table Entry ++; JMP/CALL (Ak) ++ ++(define_expand "tablejump" ++ [(parallel [(set (pc) ++ (match_operand:SI 0 "nonimmediate_operand" "")) ++ (use (label_ref (match_operand 1 "" "")))])] ++ "" ++ "") ++ ++(define_insn "tablejump_internal" ++ [(set (pc) ++ (match_operand:SI 0 "nonimmediate_operand" "rm")) ++ (use (label_ref (match_operand 1 "" "")))] ++ "" ++ "ret\\t%0") ++ ++; Call subroutine with no return value. ++; ++(define_expand "call" ++ [(call (match_operand:QI 0 "general_operand" "") ++ (match_operand:SI 1 "general_operand" ""))] ++ "" ++ "{ ++ if (TARGET_FDPIC) ++ { ++ ubicom32_expand_call_fdpic (operands); ++ DONE; ++ } ++ ++ if (! ubicom32_call_address_operand (XEXP (operands[0], 0), VOIDmode)) ++ XEXP (operands[0], 0) = force_reg (SImode, XEXP (operands[0], 0)); ++ }") ++ ++; We expand to a simple form that doesn't clobber the link register and ++; then split to a form that does. This allows the RTL optimizers that ++; run before the splitter to have the opportunity to eliminate the call ++; without marking A5 as being clobbered and this in turn avoids saves ++; and returns in a number of cases. ++; ++(define_insn_and_split "call_1" ++ [(call (mem:QI (match_operand:SI 0 "ubicom32_call_address_operand" "a,S")) ++ (match_operand:SI 1 "general_operand" "g,g"))] ++ "! TARGET_FDPIC" ++ "#" ++ "" ++ [(parallel ++ [(call (mem:QI (match_dup 0)) ++ (match_dup 1)) ++ (clobber (reg:SI LINK_REGNO))])] ++ "") ++ ++(define_insn "call_slow" ++ [(call (mem:QI (match_operand:SI 0 "ubicom32_call_address_operand" "a,S")) ++ (match_operand:SI 1 "general_operand" "g,g")) ++ (clobber (reg:SI LINK_REGNO))] ++ "(! TARGET_FDPIC && ! TARGET_FASTCALL)" ++ "@ ++ calli\\ta5, 0(%0) ++ moveai\\ta5, #%%hi(%C0)\;calli\\ta5, %%lo(%C0)(a5)") ++ ++(define_insn "call_fast" ++ [(call (mem:QI (match_operand:SI 0 "ubicom32_call_address_operand" "a,S")) ++ (match_operand:SI 1 "general_operand" "g,g")) ++ (clobber (reg:SI LINK_REGNO))] ++ "(! TARGET_FDPIC && TARGET_FASTCALL)" ++ "@ ++ calli\\ta5, 0(%0) ++ call\\ta5, %C0") ++ ++; We expand to a simple form that doesn't clobber the link register and ++; then split to a form that does. This allows the RTL optimizers that ++; run before the splitter to have the opportunity to eliminate the call ++; without marking A5 as being clobbered and this in turn avoids saves ++; and returns in a number of cases. ++; ++(define_insn_and_split "call_fdpic" ++ [(call (mem:QI (match_operand:SI 0 "ubicom32_call_address_operand" "a,S")) ++ (match_operand:SI 1 "general_operand" "g,g")) ++ (use (match_operand:SI 2 "ubicom32_fdpic_operand" "Z,Z"))] ++ "TARGET_FDPIC" ++ "#" ++ "" ++ [(parallel ++ [(call (mem:QI (match_dup 0)) ++ (match_dup 1)) ++ (use (match_dup 2)) ++ (clobber (reg:SI LINK_REGNO))])] ++ "") ++ ++(define_insn "call_fdpic_clobber" ++ [(call (mem:QI (match_operand:SI 0 "ubicom32_call_address_operand" "a,S")) ++ (match_operand:SI 1 "general_operand" "g,g")) ++ (use (match_operand:SI 2 "ubicom32_fdpic_operand" "Z,Z")) ++ (clobber (reg:SI LINK_REGNO))] ++ "TARGET_FDPIC" ++ "@ ++ move.4\\ta5, 0(%0)\;move.4\\t%2, 4(%0)\;calli\\ta5, 0(a5) ++ call\\ta5, %C0") ++ ++; Call subroutine, returning value in operand 0 ++; (which must be a hard register). ++; ++(define_expand "call_value" ++ [(set (match_operand 0 "" "") ++ (call (match_operand:QI 1 "general_operand" "") ++ (match_operand:SI 2 "general_operand" "")))] ++ "" ++ "{ ++ if (TARGET_FDPIC) ++ { ++ ubicom32_expand_call_value_fdpic (operands); ++ DONE; ++ } ++ ++ if (! ubicom32_call_address_operand (XEXP (operands[1], 0), VOIDmode)) ++ XEXP (operands[1], 0) = force_reg (SImode, XEXP (operands[1], 0)); ++ }") ++ ++; We expand to a simple form that doesn't clobber the link register and ++; then split to a form that does. This allows the RTL optimizers that ++; run before the splitter to have the opportunity to eliminate the call ++; without marking A5 as being clobbered and this in turn avoids saves ++; and returns in a number of cases. ++; ++(define_insn_and_split "call_value_1" ++ [(set (match_operand 0 "register_operand" "=r,r") ++ (call (mem:QI (match_operand:SI 1 "ubicom32_call_address_operand" "a,S")) ++ (match_operand:SI 2 "general_operand" "g,g")))] ++ "! TARGET_FDPIC" ++ "#" ++ "" ++ [(parallel ++ [(set (match_dup 0) ++ (call (mem:QI (match_dup 1)) ++ (match_dup 2))) ++ (clobber (reg:SI LINK_REGNO))])] ++ "") ++ ++(define_insn "call_value_slow" ++ [(set (match_operand 0 "register_operand" "=r,r") ++ (call (mem:QI (match_operand:SI 1 "ubicom32_call_address_operand" "a,S")) ++ (match_operand:SI 2 "general_operand" "g,g"))) ++ (clobber (reg:SI LINK_REGNO))] ++ "(! TARGET_FDPIC && ! TARGET_FASTCALL)" ++ "@ ++ calli\\ta5, 0(%1) ++ moveai\\ta5, #%%hi(%C1)\;calli\\ta5, %%lo(%C1)(a5)") ++ ++(define_insn "call_value_fast" ++ [(set (match_operand 0 "register_operand" "=r,r") ++ (call (mem:QI (match_operand:SI 1 "ubicom32_call_address_operand" "a,S")) ++ (match_operand:SI 2 "general_operand" "g,g"))) ++ (clobber (reg:SI LINK_REGNO))] ++ "(! TARGET_FDPIC && TARGET_FASTCALL)" ++ "@ ++ calli\\ta5, 0(%1) ++ call\\ta5, %C1") ++ ++; We expand to a simple form that doesn't clobber the link register and ++; then split to a form that does. This allows the RTL optimizers that ++; run before the splitter to have the opportunity to eliminate the call ++; without marking A5 as being clobbered and this in turn avoids saves ++; and returns in a number of cases. ++; ++(define_insn_and_split "call_value_fdpic" ++ [(set (match_operand 0 "register_operand" "=r,r") ++ (call (mem:QI (match_operand:SI 1 "ubicom32_call_address_operand" "a,S")) ++ (match_operand:SI 2 "general_operand" "g,g"))) ++ (use (match_operand:SI 3 "ubicom32_fdpic_operand" "Z,Z"))] ++ "TARGET_FDPIC" ++ "#" ++ "" ++ [(parallel ++ [(set (match_dup 0) ++ (call (mem:QI (match_dup 1)) ++ (match_dup 2))) ++ (use (match_dup 3)) ++ (clobber (reg:SI LINK_REGNO))])] ++ "") ++ ++(define_insn "call_value_fdpic_clobber" ++ [(set (match_operand 0 "register_operand" "=r,r") ++ (call (mem:QI (match_operand:SI 1 "ubicom32_call_address_operand" "a,S")) ++ (match_operand:SI 2 "general_operand" "g,g"))) ++ (use (match_operand:SI 3 "ubicom32_fdpic_operand" "Z,Z")) ++ (clobber (reg:SI LINK_REGNO))] ++ "TARGET_FDPIC" ++ "@ ++ move.4\\ta5, 0(%1)\;move.4\\t%3, 4(%1)\;calli\\ta5, 0(a5) ++ call\\ta5, %C1") ++ ++(define_expand "untyped_call" ++ [(parallel [(call (match_operand 0 "" "") ++ (const_int 0)) ++ (match_operand 1 "" "") ++ (match_operand 2 "" "")])] ++ "" ++ "{ ++ int i; ++ ++ emit_call_insn (gen_call (operands[0], const0_rtx)); ++ ++ for (i = 0; i < XVECLEN (operands[2], 0); i++) ++ { ++ rtx set = XVECEXP (operands[2], 0, i); ++ emit_move_insn (SET_DEST (set), SET_SRC (set)); ++ } ++ DONE; ++ }") ++ ++(define_insn "lsl1_1" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (ashift:SI (subreg:SI ++ (match_operand:QI 1 "memory_operand" "m") ++ 0) ++ (match_operand:SI 2 "ubicom32_arith_operand" "dM"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4)" ++ "lsl.1\\t%0, %1, %2") ++ ++; The combiner gets rather creative about left shifts of sub-word memory ++; operands because it's uncertain about whether the memory is sign or ++; zero extended. It only wants zero-extended behaviour and so throws ++; in an extra and operation. ++; ++(define_insn "lsl1_2" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (and:SI ++ (ashift:SI (subreg:SI ++ (match_operand:QI 1 "memory_operand" "m") ++ 0) ++ (match_operand:SI 2 "const_int_operand" "M")) ++ (match_operand:SI 3 "const_int_operand" "n"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4 ++ && INTVAL (operands[3]) == (0xff << INTVAL (operands[2])))" ++ "lsl.1\\t%0, %1, %2") ++ ++(define_insn "lsl2_1" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (ashift:SI (subreg:SI ++ (match_operand:HI 1 "memory_operand" "m") ++ 0) ++ (match_operand:SI 2 "ubicom32_arith_operand" "dM"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4)" ++ "lsl.2\\t%0, %1, %2") ++ ++; The combiner gets rather creative about left shifts of sub-word memory ++; operands because it's uncertain about whether the memory is sign or ++; zero extended. It only wants zero-extended behaviour and so throws ++; in an extra and operation. ++; ++(define_insn "lsl2_2" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (and:SI ++ (ashift:SI (subreg:SI ++ (match_operand:HI 1 "memory_operand" "m") ++ 0) ++ (match_operand:SI 2 "const_int_operand" "M")) ++ (match_operand:SI 3 "const_int_operand" "n"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4 ++ && INTVAL (operands[3]) == (0xffff << INTVAL (operands[2])))" ++ "lsl.2\\t%0, %1, %2") ++ ++(define_insn "ashlsi3" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (ashift:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI") ++ (match_operand:SI 2 "ubicom32_arith_operand" "dM"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "lsl.4\\t%0, %1, %2") ++ ++(define_insn "lshlsi3_ccwz" ++ [(set (reg CC_REGNO) ++ (compare ++ (ashift:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI") ++ (match_operand:SI 2 "ubicom32_arith_operand" "dM")) ++ (const_int 0))) ++ (set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (ashift:SI (match_dup 1) ++ (match_dup 2)))] ++ "ubicom32_match_cc_mode(insn, CCWZmode)" ++ "lsl.4\\t%0, %1, %2") ++ ++(define_insn "lshlsi3_ccwz_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (ashift:SI (match_operand:SI 0 "ubicom32_arith_operand" "rmI") ++ (match_operand:SI 1 "ubicom32_arith_operand" "dM")) ++ (const_int 0))) ++ (clobber (match_scratch:SI 2 "=d"))] ++ "ubicom32_match_cc_mode(insn, CCWZmode)" ++ "lsl.4\\t%2, %0, %1") ++ ++; The combiner finds this canonical form for what is in essence a right ++; shift. ++; ++(define_insn "asr1_2" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (sign_extract:SI (match_operand:QI 1 "memory_operand" "m") ++ (match_operand:SI 2 "const_int_operand" "M") ++ (match_operand:SI 3 "const_int_operand" "M"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4 ++ && (INTVAL (operands[2]) + INTVAL (operands[3]) == 8))" ++ "asr.1\\t%0, %1, %3") ++ ++; The combiner finds this canonical form for what is in essence a right ++; shift. ++; ++(define_insn "asr2_2" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (sign_extract:SI (match_operand:HI 1 "memory_operand" "m") ++ (match_operand:SI 2 "const_int_operand" "M") ++ (match_operand:SI 3 "const_int_operand" "M"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4 ++ && (INTVAL (operands[2]) + INTVAL (operands[3]) == 16))" ++ "asr.2\\t%0, %1, %3") ++ ++(define_insn "ashrsi3" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (ashiftrt:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmJ") ++ (match_operand:SI 2 "ubicom32_arith_operand" "dM"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "asr.4\\t%0, %1, %2") ++ ++(define_insn "ashrsi3_ccwzn" ++ [(set (reg CC_REGNO) ++ (compare ++ (ashiftrt:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmJ") ++ (match_operand:SI 2 "ubicom32_arith_operand" "dM")) ++ (const_int 0))) ++ (set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (ashiftrt:SI (match_dup 1) ++ (match_dup 2)))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "asr.4\\t%0, %1, %2") ++ ++(define_insn "ashrsi3_ccwzn_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (ashiftrt:SI (match_operand:SI 0 "ubicom32_arith_operand" "rmJ") ++ (match_operand:SI 1 "ubicom32_arith_operand" "dM")) ++ (const_int 0))) ++ (clobber (match_scratch:SI 2 "=d"))] ++ "ubicom32_match_cc_mode(insn, CCWZNmode)" ++ "asr.4\\t%2, %0, %1") ++ ++(define_insn "lsr1_1" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (lshiftrt:SI (subreg:SI ++ (match_operand:QI 1 "memory_operand" "m") ++ 0) ++ (match_operand:SI 2 "ubicom32_arith_operand" "dM"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4)" ++ "lsr.1\\t%0, %1, %2") ++ ++; The combiner finds this canonical form for what is in essence a right ++; shift. ++; ++(define_insn "lsr1_2" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (zero_extract:SI (match_operand:QI 1 "memory_operand" "m") ++ (match_operand:SI 2 "const_int_operand" "M") ++ (match_operand:SI 3 "const_int_operand" "M"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4 ++ && (INTVAL (operands[2]) + INTVAL (operands[3]) == 8))" ++ "lsr.1\\t%0, %1, %3") ++ ++(define_insn "lsr2_1" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (lshiftrt:SI (subreg:SI ++ (match_operand:HI 1 "memory_operand" "m") ++ 0) ++ (match_operand:SI 2 "ubicom32_arith_operand" "dM"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4)" ++ "lsr.2\\t%0, %1, %2") ++ ++; The combiner finds this canonical form for what is in essence a right ++; shift. ++; ++(define_insn "lsr2_2" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (zero_extract:SI (match_operand:HI 1 "memory_operand" "m") ++ (match_operand:SI 2 "const_int_operand" "M") ++ (match_operand:SI 3 "const_int_operand" "M"))) ++ (clobber (reg:CC CC_REGNO))] ++ "(ubicom32_v4 ++ && (INTVAL (operands[2]) + INTVAL (operands[3]) == 16))" ++ "lsr.2\\t%0, %1, %3") ++ ++(define_insn "lshrsi3" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (lshiftrt:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI") ++ (match_operand:SI 2 "ubicom32_arith_operand" "dM"))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "lsr.4\\t%0, %1, %2") ++ ++(define_insn "lshrsi3_ccwz" ++ [(set (reg CC_REGNO) ++ (compare ++ (lshiftrt:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI") ++ (match_operand:SI 2 "ubicom32_arith_operand" "dM")) ++ (const_int 0))) ++ (set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (lshiftrt:SI (match_dup 1) ++ (match_dup 2)))] ++ "ubicom32_match_cc_mode(insn, CCWZmode)" ++ "lsr.4\\t%0, %1, %2") ++ ++(define_insn "lshrsi3_ccwz_null" ++ [(set (reg CC_REGNO) ++ (compare ++ (lshiftrt:SI (match_operand:SI 0 "ubicom32_arith_operand" "rmI") ++ (match_operand:SI 1 "ubicom32_arith_operand" "dM")) ++ (const_int 0))) ++ (clobber (match_scratch:SI 2 "=d"))] ++ "ubicom32_match_cc_mode(insn, CCWZmode)" ++ "lsr.4\\t%2, %0, %1") ++ ++(define_expand "prologue" ++ [(const_int 0)] ++ "" ++ "{ ++ ubicom32_expand_prologue (); ++ DONE; ++ }") ++ ++(define_expand "epilogue" ++ [(return)] ++ "" ++ "{ ++ ubicom32_expand_epilogue (); ++ DONE; ++ }") ++ ++(define_expand "return" ++ [(return)] ++ "" ++ "{ ++ ubicom32_expand_epilogue (); ++ DONE; ++ }") ++ ++(define_expand "_eh_return" ++ [(use (match_operand:SI 0 "register_operand" "r")) ++ (use (match_operand:SI 1 "register_operand" "r"))] ++ "" ++ "{ ++ ubicom32_expand_eh_return (operands); ++ DONE; ++ }") ++ ++; XXX - it looks almost certain that we could make return_internal use a Dn ++; register too. In that instance we'd have to use a ret instruction ++; rather than a calli but it might save cycles. ++; ++(define_insn "return_internal" ++ [(const_int 2) ++ (return) ++ (use (match_operand:SI 0 "ubicom32_mem_or_address_register_operand" "rm"))] ++ "" ++ "* ++ { ++ if (REG_P (operands[0]) && REGNO (operands[0]) == LINK_REGNO ++ && ubicom32_can_use_calli_to_ret) ++ return \"calli\\t%0, 0(%0)\"; ++ ++ return \"ret\\t%0\"; ++ }") ++ ++(define_insn "return_from_post_modify_sp" ++ [(parallel ++ [(const_int 2) ++ (return) ++ (use (mem:SI (post_modify:SI ++ (reg:SI SP_REGNO) ++ (plus:SI (reg:SI SP_REGNO) ++ (match_operand:SI 0 "const_int_operand" "n")))))])] ++ "INTVAL (operands[0]) >= 4 && INTVAL (operands[0]) <= 7 * 4" ++ "ret\\t(sp)%E0++") ++ ++;(define_insn "eh_return_internal" ++; [(const_int 4) ++; (return) ++; (use (reg:SI 34))] ++; "" ++; "ret\\ta2") ++ ++; No operation, needed in case the user uses -g but not -O. ++(define_expand "nop" ++ [(const_int 0)] ++ "" ++ "") ++ ++(define_insn "nop_internal" ++ [(const_int 0)] ++ "" ++ "nop") ++ ++; The combiner will generate this pattern given shift and add operations. ++; The canonical form that the combiner wants to use appears to be multiplies ++; instead of shifts even if the compiled sources use shifts. ++; ++(define_insn "shmrg1_add" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (plus:SI ++ (mult:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d") ++ (const_int 256)) ++ (zero_extend:SI ++ (match_operand:QI 2 "ubicom32_arith_operand" "rmI")))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "shmrg.1\\t%0, %2, %1") ++ ++; The combiner will generate this pattern given shift and or operations. ++; ++(define_insn "shmrg1_ior" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (ior:SI ++ (ashift:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d") ++ (const_int 8)) ++ (zero_extend:SI ++ (match_operand:QI 2 "ubicom32_arith_operand" "rmI")))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "shmrg.1\\t%0, %2, %1") ++ ++; The combiner will generate this pattern given shift and add operations. ++; The canonical form that the combiner wants to use appears to be multiplies ++; instead of shifts even if the compiled sources use shifts. ++; ++(define_insn "shmrg2_add" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (plus:SI ++ (mult:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d") ++ (const_int 65536)) ++ (zero_extend:SI ++ (match_operand:HI 2 "ubicom32_arith_operand" "rmI")))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "shmrg.2\\t%0, %2, %1") ++ ++; The combiner will generate this pattern given shift and or operations. ++; ++(define_insn "shmrg2_ior" ++ [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d") ++ (ior:SI ++ (ashift:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d") ++ (const_int 16)) ++ (zero_extend:SI ++ (match_operand:HI 2 "ubicom32_arith_operand" "rmI")))) ++ (clobber (reg:CC CC_REGNO))] ++ "" ++ "shmrg.2\\t%0, %2, %1") ++ ++; Match the case where we load a word from the stack but then discard the ++; upper 16 bits. We turn this into a zero-extended load of that useful ++; 16 bits direct from the stack where possible. ++; ++ ++; XXX - do these peephole2 ops actually work after the CCmode conversion? ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (mem:SI (plus:SI (reg:SI SP_REGNO) ++ (match_operand:SI 1 "const_int_operand" "")))) ++ (set (match_operand:SI 2 "nonimmediate_operand" "") ++ (zero_extend:SI (match_operand:HI 3 "register_operand" "")))] ++ "(INTVAL (operands[1]) <= 252 ++ && REGNO (operands[3]) == REGNO (operands[0]) ++ && ((peep2_reg_dead_p (2, operands[0]) ++ && ! reg_mentioned_p (operands[0], operands[2])) ++ || rtx_equal_p (operands[0], operands[2])))" ++ [(set (match_dup 2) ++ (zero_extend:SI (mem:HI (plus:SI (reg:SI SP_REGNO) ++ (match_dup 4)))))] ++ "{ ++ operands[4] = GEN_INT (INTVAL (operands[1]) + 2); ++ }") ++ ++; Match the case where we load a word from the stack but then discard the ++; upper 16 bits. We turn this into a 16-bit load of that useful ++; 16 bits direct from the stack where possible. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (mem:SI (plus:SI (reg:SI SP_REGNO) ++ (match_operand:SI 1 "const_int_operand" "")))) ++ (set (match_operand:HI 2 "nonimmediate_operand" "") ++ (match_operand:HI 3 "register_operand" ""))] ++ "(INTVAL (operands[1]) <= 252 ++ && REGNO (operands[3]) == REGNO (operands[0]) ++ && ((peep2_reg_dead_p (2, operands[0]) ++ && ! reg_mentioned_p (operands[0], operands[2])) ++ || rtx_equal_p (operands[0], operands[2])))" ++ [(set (match_dup 2) ++ (mem:HI (plus:SI (reg:SI SP_REGNO) ++ (match_dup 4))))] ++ "{ ++ operands[4] = GEN_INT (INTVAL (operands[1]) + 2); ++ }") ++ ++; Match the case where we load a word from the stack but then discard the ++; upper 24 bits. We turn this into a zero-extended load of that useful ++; 8 bits direct from the stack where possible. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (mem:SI (plus:SI (reg:SI SP_REGNO) ++ (match_operand:SI 1 "const_int_operand" "")))) ++ (set (match_operand:SI 2 "nonimmediate_operand" "") ++ (zero_extend:SI (match_operand:QI 3 "register_operand" "")))] ++ "(INTVAL (operands[1]) <= 124 ++ && REGNO (operands[3]) == REGNO (operands[0]) ++ && ((peep2_reg_dead_p (2, operands[0]) ++ && ! reg_mentioned_p (operands[0], operands[2])) ++ || rtx_equal_p (operands[0], operands[2])))" ++ [(set (match_dup 2) ++ (zero_extend:SI (mem:QI (plus:SI (reg:SI SP_REGNO) ++ (match_dup 4)))))] ++ "{ ++ operands[4] = GEN_INT (INTVAL (operands[1]) + 3); ++ }") ++ ++; Match the case where we load a word from the stack but then discard the ++; upper 24 bits. We turn this into an 8-bit load of that useful ++; 8 bits direct from the stack where possible. ++; ++(define_peephole2 ++ [(set (match_operand:SI 0 "register_operand" "") ++ (mem:SI (plus:SI (reg:SI SP_REGNO) ++ (match_operand:SI 1 "const_int_operand" "")))) ++ (set (match_operand:QI 2 "nonimmediate_operand" "") ++ (match_operand:QI 3 "register_operand" ""))] ++ "(INTVAL (operands[1]) <= 124 ++ && REGNO (operands[3]) == REGNO (operands[0]) ++ && ((peep2_reg_dead_p (2, operands[0]) ++ && ! reg_mentioned_p (operands[0], operands[2])) ++ || rtx_equal_p (operands[0], operands[2])))" ++ [(set (match_dup 2) ++ (mem:QI (plus:SI (reg:SI SP_REGNO) ++ (match_dup 4))))] ++ "{ ++ operands[4] = GEN_INT (INTVAL (operands[1]) + 3); ++ }") ++ +--- /dev/null ++++ b/gcc/config/ubicom32/ubicom32.opt +@@ -0,0 +1,27 @@ ++mdebug-address ++Target RejectNegative Report Undocumented Mask(DEBUG_ADDRESS) ++Debug addresses ++ ++mdebug-context ++Target RejectNegative Report Undocumented Mask(DEBUG_CONTEXT) ++Debug contexts ++ ++march= ++Target Report Var(ubicom32_arch_name) Init("ubicom32v4") Joined ++Specify the name of the target architecture ++ ++mfdpic ++Target Report Mask(FDPIC) ++Enable Function Descriptor PIC mode ++ ++minline-plt ++Target Report Mask(INLINE_PLT) ++Enable inlining of PLT in function calls ++ ++mfastcall ++Target Report Mask(FASTCALL) ++Enable default fast (call) calling sequence for smaller applications ++ ++mipos-abi ++Target Report Mask(IPOS_ABI) ++Enable the ipOS ABI in which D10-D13 are caller-clobbered +--- /dev/null ++++ b/gcc/config/ubicom32/uclinux.h +@@ -0,0 +1,67 @@ ++/* Definitions of target machine for Ubicom32-uclinux ++ ++ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, ++ 2009 Free Software Foundation, Inc. ++ Contributed by Ubicom, Inc. ++ ++ This file is part of GCC. ++ ++ GCC is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published ++ by the Free Software Foundation; either version 3, or (at your ++ option) any later version. ++ ++ GCC 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 GCC; see the file COPYING3. If not see ++ . */ ++ ++/* Don't assume anything about the header files. */ ++#define NO_IMPLICIT_EXTERN_C ++ ++#undef LIB_SPEC ++#define LIB_SPEC \ ++ "%{pthread:-lpthread} " \ ++ "%{!shared:%{!symbolic: -lc}} " ++ ++ ++#undef LINK_GCC_C_SEQUENCE_SPEC ++#define LINK_GCC_C_SEQUENCE_SPEC \ ++ "%{!shared:--start-group} %G %L %{!shared:--end-group}%{shared:%G} " ++ ++#undef STARTFILE_SPEC ++#define STARTFILE_SPEC \ ++ "%{!shared: crt1%O%s}" \ ++ " crti%O%s crtbegin%O%s" ++ ++#undef ENDFILE_SPEC ++#define ENDFILE_SPEC "crtend%O%s crtn%O%s" ++ ++/* This macro applies on top of OBJECT_FORMAT_ELF and indicates that ++ we want to support both flat and ELF output. */ ++#define OBJECT_FORMAT_FLAT ++ ++#undef DRIVER_SELF_SPECS ++#define DRIVER_SELF_SPECS \ ++ "%{!mno-fastcall:-mfastcall}" ++ ++/* taken from linux.h */ ++/* The GNU C++ standard library requires that these macros be defined. */ ++#undef CPLUSPLUS_CPP_SPEC ++#define CPLUSPLUS_CPP_SPEC "-D_GNU_SOURCE %(cpp)" ++ ++#define TARGET_OS_CPP_BUILTINS() \ ++ do { \ ++ builtin_define_std ("__UBICOM32__"); \ ++ builtin_define_std ("__ubicom32__"); \ ++ builtin_define ("__gnu_linux__"); \ ++ builtin_define_std ("linux"); \ ++ builtin_define_std ("unix"); \ ++ builtin_assert ("system=linux"); \ ++ builtin_assert ("system=unix"); \ ++ builtin_assert ("system=posix"); \ ++ } while (0) +--- /dev/null ++++ b/gcc/config/ubicom32/xm-ubicom32.h +@@ -0,0 +1,36 @@ ++/* Configuration for Ubicom's Ubicom32 architecture. ++ Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Free Software ++ Foundation, Inc. ++ Contributed by Ubicom Inc. ++ ++This file is part of GNU CC. ++ ++GNU CC 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. ++ ++GNU CC 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 GNU CC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++/* #defines that need visibility everywhere. */ ++#define FALSE 0 ++#define TRUE 1 ++ ++/* This describes the machine the compiler is hosted on. */ ++#define HOST_BITS_PER_CHAR 8 ++#define HOST_BITS_PER_SHORT 16 ++#define HOST_BITS_PER_INT 32 ++#define HOST_BITS_PER_LONG 32 ++#define HOST_BITS_PER_LONGLONG 64 ++ ++/* Arguments to use with `exit'. */ ++#define SUCCESS_EXIT_CODE 0 ++#define FATAL_EXIT_CODE 33 +--- a/gcc/config.gcc ++++ b/gcc/config.gcc +@@ -2314,6 +2314,34 @@ spu-*-elf*) + c_target_objs="${c_target_objs} spu-c.o" + cxx_target_objs="${cxx_target_objs} spu-c.o" + ;; ++ubicom32-*-elf) ++ xm_file=ubicom32/xm-ubicom32.h ++ tm_file="${tm_file} ubicom32/elf.h" # still need dbxelf.h elfos.h ++ tmake_file=ubicom32/t-ubicom32 ++ ;; ++ubicom32-*-uclinux*) ++ xm_file=ubicom32/xm-ubicom32.h ++ tm_file="${tm_file} ubicom32/elf.h ubicom32/uclinux.h" # still need dbxelf.h elfos.h linux.h ++ tm_defines="${tm_defines} UCLIBC_DEFAULT=1" ++ extra_options="${extra_options} linux.opt" ++ tmake_file=ubicom32/t-ubicom32-uclinux ++ use_collect2=no ++ ;; ++ubicom32-*-linux-uclibc) ++ xm_file=ubicom32/xm-ubicom32.h ++ tm_file="${tm_file} ubicom32/elf.h linux.h ubicom32/linux.h" # still need dbxelf.h elfos.h ++ tmake_file="t-slibgcc-elf-ver ubicom32/t-ubicom32-linux" ++ extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o" ++ use_collect2=no ++ ;; ++ubicom32-*-linux*) ++ xm_file=ubicom32/xm-ubicom32.h ++ tm_file="${tm_file} ubicom32/elf.h linux.h ubicom32/linux.h" # still need dbxelf.h elfos.h ++ tmake_file="t-slibgcc-elf-ver ubicom32/t-ubicom32-linux" ++ tm_defines="${tm_defines} UCLIBC_DEFAULT=1" ++ extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o" ++ use_collect2=no ++ ;; + v850e1-*-*) + target_cpu_default="TARGET_CPU_v850e1" + tm_file="dbxelf.h elfos.h svr4.h v850/v850.h" +--- a/libgcc/config.host ++++ b/libgcc/config.host +@@ -551,6 +551,15 @@ sparc64-*-netbsd*) + ;; + spu-*-elf*) + ;; ++ubicom32*-*-elf*) ++ ;; ++ubicom32*-*-uclinux*) ++ ;; ++ubicom32*-*-linux*) ++ # No need to build crtbeginT.o on uClibc systems. Should probably ++ # be moved to the OS specific section above. ++ extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o" ++ ;; + v850e1-*-*) + ;; + v850e-*-*) diff --git a/toolchain/kernel-headers/Makefile b/toolchain/kernel-headers/Makefile index ff2ce2331a..e82a4c8104 100644 --- a/toolchain/kernel-headers/Makefile +++ b/toolchain/kernel-headers/Makefile @@ -115,6 +115,15 @@ else endef endif +define Host/Prepare/post/ubicom32 + $(CP) \ + $(HOST_BUILD_DIR)/arch/ubicom32/include/asm/elf.h \ + $(HOST_BUILD_DIR)/arch/ubicom32/include/asm/user.h \ + $(HOST_BUILD_DIR)/arch/ubicom32/include/asm/page.h \ + $(HOST_BUILD_DIR)/arch/ubicom32/include/asm/page_offset.h \ + $(BUILD_DIR_TOOLCHAIN)/linux-dev/usr/include/asm/ +endef + define Host/Prepare/post/mips $(call Host/Prepare/lzma) endef diff --git a/toolchain/kernel-headers/patches-2.6.28/100-ubicom_headers.patch b/toolchain/kernel-headers/patches-2.6.28/100-ubicom_headers.patch new file mode 100644 index 0000000000..ab8dfc6f20 --- /dev/null +++ b/toolchain/kernel-headers/patches-2.6.28/100-ubicom_headers.patch @@ -0,0 +1,14723 @@ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/configs/IP5160EVAL_defconfig linux-2.6.28.10/arch/ubicom32/configs/IP5160EVAL_defconfig +--- linux-2.6.28.10_o/arch/ubicom32/configs/IP5160EVAL_defconfig 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/configs/IP5160EVAL_defconfig 2009-08-12 13:08:37.000000000 +0300 +@@ -0,0 +1,524 @@ ++# ++# Automatically generated make config: don't edit ++# Linux kernel version: 2.6.28.10 ++# ++CONFIG_RAMBASE=0x40000000 ++CONFIG_UBICOM32=y ++CONFIG_RAMKERNEL=y ++CONFIG_CPU_BIG_ENDIAN=y ++CONFIG_FORCE_MAX_ZONEORDER=14 ++CONFIG_HAVE_CLK=y ++# CONFIG_MMU is not set ++# CONFIG_FPU is not set ++CONFIG_ZONE_DMA=y ++CONFIG_RWSEM_GENERIC_SPINLOCK=y ++# CONFIG_RWSEM_XCHGADD_ALGORITHM is not set ++# CONFIG_ARCH_HAS_ILOG2_U32 is not set ++# CONFIG_ARCH_HAS_ILOG2_U64 is not set ++CONFIG_GENERIC_FIND_NEXT_BIT=y ++CONFIG_GENERIC_GPIO=y ++CONFIG_GPIOLIB=y ++CONFIG_GENERIC_HWEIGHT=y ++CONFIG_GENERIC_HARDIRQS=y ++CONFIG_STACKTRACE_SUPPORT=y ++CONFIG_LOCKDEP_SUPPORT=y ++CONFIG_GENERIC_CALIBRATE_DELAY=y ++CONFIG_GENERIC_TIME=y ++CONFIG_TIME_LOW_RES=y ++CONFIG_GENERIC_CLOCKEVENTS=y ++CONFIG_NO_IOPORT=y ++CONFIG_ARCH_SUPPORTS_AOUT=y ++CONFIG_IRQ_PER_CPU=y ++CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y ++ ++# ++# Processor type and features ++# ++CONFIG_BRD_32MB=y ++ ++# ++# Processor type will be selected by Board ++# ++CONFIG_UBICOM32_V3=y ++ ++# ++# Board ++# ++# CONFIG_NOBOARD is not set ++# CONFIG_IP5170DPF is not set ++# CONFIG_IP5160DEV is not set ++CONFIG_IP5160EVAL=y ++# CONFIG_IP7145DPF is not set ++# CONFIG_IP7160RGW is not set ++# CONFIG_IP7160BRINGUP is not set ++# CONFIG_IP7160DPF is not set ++# CONFIG_IP7500MODULE is not set ++# CONFIG_IP7500AV is not set ++# CONFIG_IP7500MEDIA is not set ++ ++# ++# Kernel Options ++# ++# CONFIG_SMP is not set ++CONFIG_TIMER_EXTRA_ALLOC=0 ++# CONFIG_IRQSTACKS is not set ++CONFIG_UBICOM32_OCM_MODULES=y ++CONFIG_OCM_MODULES_RESERVATION=41 ++CONFIG_OCM_MODULES_MAY_CONSUME_REMAINING_CODESPACE=y ++CONFIG_HZ=1000 ++ ++# ++# RAM configuration ++# ++CONFIG_RAMSIZE=0x02000000 ++CONFIG_KERNELBASE=0x40400000 ++ ++# ++# Build options ++# ++CONFIG_LINKER_RELAXATION=y ++ ++# ++# Driver options ++# ++ ++# ++# PCI Bus ++# ++# CONFIG_PCI is not set ++# CONFIG_ARCH_SUPPORTS_MSI is not set ++ ++# ++# Input devices ++# ++# CONFIG_UBICOM_INPUT is not set ++# CONFIG_UBICOM_INPUT_I2C is not set ++CONFIG_UBICOM_SWITCH=y ++ ++# ++# Misc devices ++# ++# CONFIG_UBICOM_HID is not set ++CONFIG_CMDLINE_BOOL=y ++CONFIG_CMDLINE="console=ttyUM0" ++# CONFIG_CMDLINE_OVERRIDE is not set ++ ++# ++# Kernel hacking ++# ++CONFIG_TRACE_IRQFLAGS_SUPPORT=y ++CONFIG_PROTECT_KERNEL=y ++# CONFIG_NO_KERNEL_MSG is not set ++# CONFIG_EARLY_PRINTK is not set ++# CONFIG_STOP_ON_TRAP is not set ++# CONFIG_STOP_ON_BUG is not set ++# CONFIG_DEBUG_IRQMEASURE is not set ++# CONFIG_DEBUG_PCIMEASURE is not set ++# CONFIG_ACCESS_OK_CHECKS_ENABLED is not set ++CONFIG_UNALIGNED_ACCESS_ENABLED=y ++# CONFIG_UNALIGNED_ACCESS_USERSPACE_ONLY is not set ++# CONFIG_UNALIGNED_ACCESS_DISABLED is not set ++# CONFIG_DEBUG_STACKOVERFLOW is not set ++# CONFIG_DEBUG_STACK_USAGE is not set ++# CONFIG_PRINTK_TIME is not set ++CONFIG_ENABLE_WARN_DEPRECATED=y ++CONFIG_ENABLE_MUST_CHECK=y ++CONFIG_FRAME_WARN=1024 ++# CONFIG_MAGIC_SYSRQ is not set ++# CONFIG_UNUSED_SYMBOLS is not set ++# CONFIG_HEADERS_CHECK is not set ++CONFIG_DEBUG_KERNEL=y ++# CONFIG_DEBUG_SHIRQ is not set ++CONFIG_DETECT_SOFTLOCKUP=y ++# CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set ++CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0 ++CONFIG_SCHED_DEBUG=y ++# CONFIG_SCHEDSTATS is not set ++# CONFIG_TIMER_STATS is not set ++# CONFIG_DEBUG_OBJECTS is not set ++# CONFIG_DEBUG_SLAB is not set ++# CONFIG_DEBUG_SPINLOCK is not set ++# CONFIG_DEBUG_MUTEXES is not set ++# CONFIG_DEBUG_LOCK_ALLOC is not set ++# CONFIG_PROVE_LOCKING is not set ++# CONFIG_LOCK_STAT is not set ++# CONFIG_DEBUG_SPINLOCK_SLEEP is not set ++# CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set ++# CONFIG_DEBUG_KOBJECT is not set ++CONFIG_DEBUG_INFO=y ++# CONFIG_DEBUG_VM is not set ++# CONFIG_DEBUG_WRITECOUNT is not set ++# CONFIG_DEBUG_MEMORY_INIT is not set ++# CONFIG_DEBUG_LIST is not set ++# CONFIG_DEBUG_SG is not set ++# CONFIG_FRAME_POINTER is not set ++# CONFIG_BOOT_PRINTK_DELAY is not set ++# CONFIG_RCU_TORTURE_TEST is not set ++# CONFIG_RCU_CPU_STALL_DETECTOR is not set ++# CONFIG_BACKTRACE_SELF_TEST is not set ++# CONFIG_DEBUG_BLOCK_EXT_DEVT is not set ++# CONFIG_FAULT_INJECTION is not set ++# CONFIG_SYSCTL_SYSCALL_CHECK is not set ++ ++# ++# Tracers ++# ++# CONFIG_IRQSOFF_TRACER is not set ++# CONFIG_SCHED_TRACER is not set ++# CONFIG_CONTEXT_SWITCH_TRACER is not set ++# CONFIG_BOOT_TRACER is not set ++# CONFIG_DYNAMIC_PRINTK_DEBUG is not set ++# CONFIG_SAMPLES is not set ++ ++# ++# Executable file formats ++# ++CONFIG_BINFMT_ELF_FDPIC=y ++CONFIG_BINFMT_FLAT=y ++# CONFIG_BINFMT_ZFLAT is not set ++# CONFIG_BINFMT_SHARED_FLAT is not set ++# CONFIG_HAVE_AOUT is not set ++# CONFIG_BINFMT_MISC is not set ++CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config" ++ ++# ++# General setup ++# ++CONFIG_EXPERIMENTAL=y ++CONFIG_BROKEN_ON_SMP=y ++CONFIG_INIT_ENV_ARG_LIMIT=32 ++CONFIG_LOCALVERSION="" ++CONFIG_LOCALVERSION_AUTO=y ++# CONFIG_SYSVIPC is not set ++# CONFIG_BSD_PROCESS_ACCT is not set ++# CONFIG_IKCONFIG is not set ++CONFIG_LOG_BUF_SHIFT=14 ++# CONFIG_CGROUPS is not set ++# CONFIG_GROUP_SCHED is not set ++# CONFIG_RELAY is not set ++# CONFIG_NAMESPACES is not set ++CONFIG_BLK_DEV_INITRD=y ++CONFIG_INITRAMFS_SOURCE="" ++CONFIG_INITRAMFS_ROOT_UID=0 ++CONFIG_INITRAMFS_ROOT_GID=0 ++CONFIG_CC_OPTIMIZE_FOR_SIZE=y ++CONFIG_SYSCTL=y ++CONFIG_EMBEDDED=y ++CONFIG_SYSCTL_SYSCALL=y ++# CONFIG_KALLSYMS is not set ++# CONFIG_HOTPLUG is not set ++CONFIG_PRINTK=y ++CONFIG_BUG=y ++# CONFIG_ELF_CORE is not set ++CONFIG_BASE_FULL=y ++# CONFIG_FUTEX is not set ++# CONFIG_EPOLL is not set ++# CONFIG_SIGNALFD is not set ++# CONFIG_TIMERFD is not set ++# CONFIG_EVENTFD is not set ++CONFIG_AIO=y ++# CONFIG_VM_EVENT_COUNTERS is not set ++# CONFIG_COMPAT_BRK is not set ++CONFIG_SLAB=y ++# CONFIG_SLUB is not set ++# CONFIG_SLOB is not set ++# CONFIG_PROFILING is not set ++# CONFIG_MARKERS is not set ++CONFIG_HAVE_OPROFILE=y ++# CONFIG_HAVE_GENERIC_DMA_COHERENT is not set ++CONFIG_SLABINFO=y ++CONFIG_TINY_SHMEM=y ++CONFIG_BASE_SMALL=0 ++# CONFIG_MODULES is not set ++CONFIG_BLOCK=y ++# CONFIG_LBD is not set ++# CONFIG_LSF is not set ++# CONFIG_BLK_DEV_BSG is not set ++# CONFIG_BLK_DEV_INTEGRITY is not set ++ ++# ++# IO Schedulers ++# ++CONFIG_IOSCHED_NOOP=y ++# CONFIG_IOSCHED_AS is not set ++# CONFIG_IOSCHED_DEADLINE is not set ++# CONFIG_IOSCHED_CFQ is not set ++# CONFIG_DEFAULT_AS is not set ++# CONFIG_DEFAULT_DEADLINE is not set ++# CONFIG_DEFAULT_CFQ is not set ++CONFIG_DEFAULT_NOOP=y ++CONFIG_DEFAULT_IOSCHED="noop" ++CONFIG_CLASSIC_RCU=y ++CONFIG_PREEMPT_NONE=y ++# CONFIG_PREEMPT_VOLUNTARY is not set ++# CONFIG_PREEMPT is not set ++# CONFIG_NO_HZ is not set ++# CONFIG_HIGH_RES_TIMERS is not set ++CONFIG_GENERIC_CLOCKEVENTS_BUILD=y ++CONFIG_SELECT_MEMORY_MODEL=y ++CONFIG_FLATMEM_MANUAL=y ++# CONFIG_DISCONTIGMEM_MANUAL is not set ++# CONFIG_SPARSEMEM_MANUAL is not set ++CONFIG_FLATMEM=y ++CONFIG_FLAT_NODE_MEM_MAP=y ++CONFIG_PAGEFLAGS_EXTENDED=y ++CONFIG_SPLIT_PTLOCK_CPUS=4 ++# CONFIG_RESOURCES_64BIT is not set ++# CONFIG_PHYS_ADDR_T_64BIT is not set ++CONFIG_ZONE_DMA_FLAG=1 ++CONFIG_VIRT_TO_BUS=y ++# CONFIG_NET is not set ++ ++# ++# Device Drivers ++# ++ ++# ++# Generic Driver Options ++# ++CONFIG_STANDALONE=y ++CONFIG_PREVENT_FIRMWARE_BUILD=y ++CONFIG_DEBUG_DRIVER=y ++CONFIG_DEBUG_DEVRES=y ++# CONFIG_SYS_HYPERVISOR is not set ++# CONFIG_MTD is not set ++# CONFIG_PARPORT is not set ++CONFIG_BLK_DEV=y ++# CONFIG_BLK_DEV_COW_COMMON is not set ++# CONFIG_BLK_DEV_LOOP is not set ++CONFIG_BLK_DEV_RAM=y ++CONFIG_BLK_DEV_RAM_COUNT=16 ++CONFIG_BLK_DEV_RAM_SIZE=4096 ++# CONFIG_BLK_DEV_XIP is not set ++# CONFIG_CDROM_PKTCDVD is not set ++# CONFIG_MISC_DEVICES is not set ++ ++# ++# SCSI device support ++# ++# CONFIG_RAID_ATTRS is not set ++# CONFIG_SCSI is not set ++# CONFIG_SCSI_DMA is not set ++# CONFIG_SCSI_NETLINK is not set ++# CONFIG_ATA is not set ++# CONFIG_MD is not set ++# CONFIG_PHONE is not set ++ ++# ++# Input device support ++# ++# CONFIG_INPUT is not set ++ ++# ++# Hardware I/O ports ++# ++# CONFIG_SERIO is not set ++# CONFIG_GAMEPORT is not set ++ ++# ++# Character devices ++# ++# CONFIG_VT is not set ++CONFIG_DEVKMEM=y ++# CONFIG_SERIAL_NONSTANDARD is not set ++ ++# ++# Serial drivers ++# ++# CONFIG_SERIAL_8250 is not set ++ ++# ++# Non-8250 serial port support ++# ++CONFIG_SERIAL_UBI32_SERDES=y ++CONFIG_SERIAL_UBI32_SERDES_CONSOLE=y ++# CONFIG_SERIAL_UBI32_MAILBOX is not set ++CONFIG_SERIAL_CORE=y ++CONFIG_SERIAL_CORE_CONSOLE=y ++# CONFIG_UNIX98_PTYS is not set ++CONFIG_LEGACY_PTYS=y ++CONFIG_LEGACY_PTY_COUNT=256 ++# CONFIG_IPMI_HANDLER is not set ++# CONFIG_HW_RANDOM is not set ++# CONFIG_RTC is not set ++# CONFIG_GEN_RTC is not set ++# CONFIG_R3964 is not set ++# CONFIG_RAW_DRIVER is not set ++# CONFIG_TCG_TPM is not set ++# CONFIG_I2C is not set ++# CONFIG_SPI is not set ++# CONFIG_DEBUG_GPIO is not set ++ ++# ++# Memory mapped GPIO expanders: ++# ++ ++# ++# I2C GPIO expanders: ++# ++ ++# ++# PCI GPIO expanders: ++# ++ ++# ++# SPI GPIO expanders: ++# ++# CONFIG_W1 is not set ++# CONFIG_POWER_SUPPLY is not set ++# CONFIG_HWMON is not set ++# CONFIG_THERMAL is not set ++# CONFIG_THERMAL_HWMON is not set ++# CONFIG_WATCHDOG is not set ++CONFIG_SSB_POSSIBLE=y ++ ++# ++# Sonics Silicon Backplane ++# ++# CONFIG_SSB is not set ++ ++# ++# Multifunction device drivers ++# ++# CONFIG_MFD_CORE is not set ++# CONFIG_MFD_SM501 is not set ++# CONFIG_HTC_PASIC3 is not set ++# CONFIG_MFD_TMIO is not set ++# CONFIG_REGULATOR is not set ++ ++# ++# Multimedia devices ++# ++ ++# ++# Multimedia core support ++# ++# CONFIG_VIDEO_DEV is not set ++# CONFIG_VIDEO_MEDIA is not set ++ ++# ++# Multimedia drivers ++# ++# CONFIG_DAB is not set ++ ++# ++# Graphics support ++# ++# CONFIG_VGASTATE is not set ++# CONFIG_VIDEO_OUTPUT_CONTROL is not set ++# CONFIG_FB is not set ++# CONFIG_BACKLIGHT_LCD_SUPPORT is not set ++ ++# ++# Display device support ++# ++# CONFIG_DISPLAY_SUPPORT is not set ++# CONFIG_SOUND is not set ++# CONFIG_USB_SUPPORT is not set ++# CONFIG_MMC is not set ++# CONFIG_MEMSTICK is not set ++# CONFIG_NEW_LEDS is not set ++# CONFIG_ACCESSIBILITY is not set ++# CONFIG_RTC_CLASS is not set ++# CONFIG_DMADEVICES is not set ++# CONFIG_UIO is not set ++# CONFIG_STAGING is not set ++ ++# ++# File systems ++# ++# CONFIG_EXT2_FS is not set ++# CONFIG_EXT3_FS is not set ++# CONFIG_EXT4_FS is not set ++# CONFIG_REISERFS_FS is not set ++# CONFIG_JFS_FS is not set ++# CONFIG_FS_POSIX_ACL is not set ++CONFIG_FILE_LOCKING=y ++# CONFIG_XFS_FS is not set ++# CONFIG_DNOTIFY is not set ++# CONFIG_INOTIFY is not set ++# CONFIG_QUOTA is not set ++# CONFIG_AUTOFS_FS is not set ++# CONFIG_AUTOFS4_FS is not set ++# CONFIG_FUSE_FS is not set ++ ++# ++# CD-ROM/DVD Filesystems ++# ++# CONFIG_ISO9660_FS is not set ++# CONFIG_UDF_FS is not set ++ ++# ++# DOS/FAT/NT Filesystems ++# ++# CONFIG_MSDOS_FS is not set ++# CONFIG_VFAT_FS is not set ++# CONFIG_NTFS_FS is not set ++ ++# ++# Pseudo filesystems ++# ++CONFIG_PROC_FS=y ++CONFIG_PROC_SYSCTL=y ++# CONFIG_SYSFS is not set ++# CONFIG_TMPFS is not set ++# CONFIG_HUGETLB_PAGE is not set ++ ++# ++# Layered filesystems ++# ++# CONFIG_UNION_FS is not set ++ ++# ++# Miscellaneous filesystems ++# ++# CONFIG_ADFS_FS is not set ++# CONFIG_AFFS_FS is not set ++# CONFIG_HFS_FS is not set ++# CONFIG_HFSPLUS_FS is not set ++# CONFIG_BEFS_FS is not set ++# CONFIG_BFS_FS is not set ++# CONFIG_EFS_FS is not set ++# CONFIG_CRAMFS is not set ++# CONFIG_VXFS_FS is not set ++# CONFIG_MINIX_FS is not set ++# CONFIG_OMFS_FS is not set ++# CONFIG_HPFS_FS is not set ++# CONFIG_QNX4FS_FS is not set ++CONFIG_ROMFS_FS=y ++# CONFIG_SYSV_FS is not set ++# CONFIG_UFS_FS is not set ++ ++# ++# Partition Types ++# ++# CONFIG_PARTITION_ADVANCED is not set ++CONFIG_MSDOS_PARTITION=y ++# CONFIG_NLS is not set ++ ++# ++# Security options ++# ++# CONFIG_KEYS is not set ++# CONFIG_SECURITYFS is not set ++# CONFIG_SECURITY_FILE_CAPABILITIES is not set ++# CONFIG_CRYPTO is not set ++ ++# ++# OCF Configuration ++# ++# CONFIG_OCF_OCF is not set ++ ++# ++# Library routines ++# ++CONFIG_BITREVERSE=y ++# CONFIG_CRC_CCITT is not set ++# CONFIG_CRC16 is not set ++# CONFIG_CRC_T10DIF is not set ++# CONFIG_CRC_ITU_T is not set ++CONFIG_CRC32=y ++# CONFIG_CRC7 is not set ++# CONFIG_LIBCRC32C is not set ++CONFIG_HAS_IOMEM=y ++CONFIG_HAS_DMA=y +diff -ruN linux-2.6.28.10_o/arch/ubicom32/configs/IP7160RGW_defconfig linux-2.6.28.10/arch/ubicom32/configs/IP7160RGW_defconfig +--- linux-2.6.28.10_o/arch/ubicom32/configs/IP7160RGW_defconfig 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/configs/IP7160RGW_defconfig 2009-08-12 13:08:37.000000000 +0300 +@@ -0,0 +1,1301 @@ ++# ++# Automatically generated make config: don't edit ++# Linux kernel version: 2.6.28.10 ++# ++CONFIG_RAMBASE=0x40000000 ++CONFIG_UBICOM32=y ++CONFIG_RAMKERNEL=y ++CONFIG_CPU_BIG_ENDIAN=y ++CONFIG_FORCE_MAX_ZONEORDER=14 ++CONFIG_HAVE_CLK=y ++# CONFIG_MMU is not set ++# CONFIG_FPU is not set ++CONFIG_ZONE_DMA=y ++CONFIG_RWSEM_GENERIC_SPINLOCK=y ++# CONFIG_RWSEM_XCHGADD_ALGORITHM is not set ++# CONFIG_ARCH_HAS_ILOG2_U32 is not set ++# CONFIG_ARCH_HAS_ILOG2_U64 is not set ++CONFIG_GENERIC_FIND_NEXT_BIT=y ++CONFIG_GENERIC_GPIO=y ++CONFIG_GPIOLIB=y ++CONFIG_GENERIC_HWEIGHT=y ++CONFIG_GENERIC_HARDIRQS=y ++CONFIG_STACKTRACE_SUPPORT=y ++CONFIG_LOCKDEP_SUPPORT=y ++CONFIG_GENERIC_CALIBRATE_DELAY=y ++CONFIG_GENERIC_TIME=y ++CONFIG_TIME_LOW_RES=y ++CONFIG_GENERIC_CLOCKEVENTS=y ++CONFIG_NO_IOPORT=y ++CONFIG_ARCH_SUPPORTS_AOUT=y ++CONFIG_IRQ_PER_CPU=y ++CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y ++ ++# ++# Processor type and features ++# ++CONFIG_BRD_64MB=y ++ ++# ++# Processor type will be selected by Board ++# ++CONFIG_UBICOM32_V4=y ++ ++# ++# Board ++# ++# CONFIG_NOBOARD is not set ++# CONFIG_IP5170DPF is not set ++# CONFIG_IP5160DEV is not set ++# CONFIG_IP5160EVAL is not set ++# CONFIG_IP7145DPF is not set ++CONFIG_IP7160RGW=y ++# CONFIG_IP7160BRINGUP is not set ++# CONFIG_IP7160DPF is not set ++# CONFIG_IP7500MODULE is not set ++# CONFIG_IP7500AV is not set ++# CONFIG_IP7500MEDIA is not set ++ ++# ++# Kernel Options ++# ++# CONFIG_SMP is not set ++CONFIG_TIMER_EXTRA_ALLOC=0 ++# CONFIG_IRQSTACKS is not set ++CONFIG_UBICOM32_OCM_MODULES=y ++CONFIG_OCM_MODULES_RESERVATION=41 ++CONFIG_OCM_MODULES_MAY_CONSUME_REMAINING_CODESPACE=y ++CONFIG_HZ=100 ++ ++# ++# RAM configuration ++# ++CONFIG_RAMSIZE=0x04000000 ++CONFIG_KERNELBASE=0x40400000 ++ ++# ++# Build options ++# ++# CONFIG_LINKER_RELAXATION is not set ++ ++# ++# Driver options ++# ++ ++# ++# PCI Bus ++# ++CONFIG_PCI=y ++# CONFIG_ARCH_SUPPORTS_MSI is not set ++# CONFIG_PCI_LEGACY is not set ++# CONFIG_PCI_DEBUG is not set ++CONFIG_PCI_DEV0_IDSEL=0x001000000 ++CONFIG_PCI_DEV1_IDSEL=0x002000000 ++ ++# ++# Input devices ++# ++CONFIG_UBICOM_INPUT=y ++# CONFIG_UBICOM_INPUT_I2C is not set ++CONFIG_UBICOM_SWITCH=y ++CONFIG_UBICOM_SWITCH_BCM539X=y ++ ++# ++# Misc devices ++# ++# CONFIG_UBICOM_HID is not set ++CONFIG_CMDLINE_BOOL=y ++CONFIG_CMDLINE="console=ttyUM0 console=ttyUS0 serdes=0x02004000,61,250000000" ++# CONFIG_CMDLINE_OVERRIDE is not set ++ ++# ++# Kernel hacking ++# ++CONFIG_TRACE_IRQFLAGS_SUPPORT=y ++CONFIG_PROTECT_KERNEL=y ++# CONFIG_NO_KERNEL_MSG is not set ++CONFIG_EARLY_PRINTK=y ++# CONFIG_STOP_ON_TRAP is not set ++# CONFIG_STOP_ON_BUG is not set ++# CONFIG_DEBUG_IRQMEASURE is not set ++# CONFIG_DEBUG_PCIMEASURE is not set ++# CONFIG_ACCESS_OK_CHECKS_ENABLED is not set ++CONFIG_UNALIGNED_ACCESS_ENABLED=y ++# CONFIG_UNALIGNED_ACCESS_USERSPACE_ONLY is not set ++# CONFIG_UNALIGNED_ACCESS_DISABLED is not set ++# CONFIG_DEBUG_STACKOVERFLOW is not set ++# CONFIG_DEBUG_STACK_USAGE is not set ++CONFIG_PRINTK_TIME=y ++CONFIG_ENABLE_WARN_DEPRECATED=y ++CONFIG_ENABLE_MUST_CHECK=y ++CONFIG_FRAME_WARN=1024 ++# CONFIG_MAGIC_SYSRQ is not set ++# CONFIG_UNUSED_SYMBOLS is not set ++# CONFIG_DEBUG_FS is not set ++# CONFIG_HEADERS_CHECK is not set ++CONFIG_DEBUG_KERNEL=y ++# CONFIG_DEBUG_SHIRQ is not set ++# CONFIG_DETECT_SOFTLOCKUP is not set ++# CONFIG_SCHED_DEBUG is not set ++# CONFIG_SCHEDSTATS is not set ++# CONFIG_TIMER_STATS is not set ++# CONFIG_DEBUG_OBJECTS is not set ++# CONFIG_DEBUG_SLAB is not set ++# CONFIG_DEBUG_SPINLOCK is not set ++# CONFIG_DEBUG_MUTEXES is not set ++# CONFIG_DEBUG_LOCK_ALLOC is not set ++# CONFIG_PROVE_LOCKING is not set ++# CONFIG_LOCK_STAT is not set ++# CONFIG_DEBUG_SPINLOCK_SLEEP is not set ++# CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set ++# CONFIG_DEBUG_KOBJECT is not set ++CONFIG_DEBUG_INFO=y ++# CONFIG_DEBUG_VM is not set ++# CONFIG_DEBUG_WRITECOUNT is not set ++# CONFIG_DEBUG_MEMORY_INIT is not set ++# CONFIG_DEBUG_LIST is not set ++# CONFIG_DEBUG_SG is not set ++# CONFIG_FRAME_POINTER is not set ++# CONFIG_BOOT_PRINTK_DELAY is not set ++# CONFIG_RCU_TORTURE_TEST is not set ++# CONFIG_RCU_CPU_STALL_DETECTOR is not set ++# CONFIG_BACKTRACE_SELF_TEST is not set ++# CONFIG_DEBUG_BLOCK_EXT_DEVT is not set ++# CONFIG_FAULT_INJECTION is not set ++# CONFIG_SYSCTL_SYSCALL_CHECK is not set ++ ++# ++# Tracers ++# ++# CONFIG_IRQSOFF_TRACER is not set ++# CONFIG_SCHED_TRACER is not set ++# CONFIG_CONTEXT_SWITCH_TRACER is not set ++# CONFIG_BOOT_TRACER is not set ++# CONFIG_DYNAMIC_PRINTK_DEBUG is not set ++# CONFIG_SAMPLES is not set ++ ++# ++# Executable file formats ++# ++CONFIG_BINFMT_ELF_FDPIC=y ++CONFIG_BINFMT_FLAT=y ++CONFIG_BINFMT_ZFLAT=y ++# CONFIG_BINFMT_SHARED_FLAT is not set ++# CONFIG_HAVE_AOUT is not set ++# CONFIG_BINFMT_MISC is not set ++CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config" ++ ++# ++# General setup ++# ++CONFIG_EXPERIMENTAL=y ++CONFIG_BROKEN_ON_SMP=y ++CONFIG_INIT_ENV_ARG_LIMIT=32 ++CONFIG_LOCALVERSION="" ++# CONFIG_LOCALVERSION_AUTO is not set ++CONFIG_SYSVIPC=y ++CONFIG_SYSVIPC_SYSCTL=y ++# CONFIG_POSIX_MQUEUE is not set ++# CONFIG_BSD_PROCESS_ACCT is not set ++# CONFIG_TASKSTATS is not set ++# CONFIG_AUDIT is not set ++# CONFIG_IKCONFIG is not set ++CONFIG_LOG_BUF_SHIFT=14 ++# CONFIG_CGROUPS is not set ++# CONFIG_GROUP_SCHED is not set ++CONFIG_SYSFS_DEPRECATED=y ++CONFIG_SYSFS_DEPRECATED_V2=y ++# CONFIG_RELAY is not set ++# CONFIG_NAMESPACES is not set ++CONFIG_BLK_DEV_INITRD=y ++CONFIG_INITRAMFS_SOURCE="" ++CONFIG_INITRAMFS_ROOT_UID=0 ++CONFIG_INITRAMFS_ROOT_GID=0 ++CONFIG_CC_OPTIMIZE_FOR_SIZE=y ++CONFIG_SYSCTL=y ++CONFIG_EMBEDDED=y ++CONFIG_SYSCTL_SYSCALL=y ++# CONFIG_KALLSYMS is not set ++# CONFIG_HOTPLUG is not set ++CONFIG_PRINTK=y ++CONFIG_BUG=y ++# CONFIG_ELF_CORE is not set ++CONFIG_BASE_FULL=y ++# CONFIG_FUTEX is not set ++# CONFIG_EPOLL is not set ++# CONFIG_SIGNALFD is not set ++# CONFIG_TIMERFD is not set ++# CONFIG_EVENTFD is not set ++CONFIG_AIO=y ++# CONFIG_VM_EVENT_COUNTERS is not set ++CONFIG_PCI_QUIRKS=y ++# CONFIG_COMPAT_BRK is not set ++CONFIG_SLAB=y ++# CONFIG_SLUB is not set ++# CONFIG_SLOB is not set ++# CONFIG_PROFILING is not set ++# CONFIG_MARKERS is not set ++CONFIG_HAVE_OPROFILE=y ++# CONFIG_HAVE_GENERIC_DMA_COHERENT is not set ++CONFIG_SLABINFO=y ++CONFIG_TINY_SHMEM=y ++CONFIG_BASE_SMALL=0 ++CONFIG_MODULES=y ++CONFIG_MODULE_FORCE_LOAD=y ++# CONFIG_MODULE_UNLOAD is not set ++# CONFIG_MODVERSIONS is not set ++# CONFIG_MODULE_SRCVERSION_ALL is not set ++CONFIG_KMOD=y ++CONFIG_BLOCK=y ++# CONFIG_LBD is not set ++# CONFIG_BLK_DEV_IO_TRACE is not set ++# CONFIG_LSF is not set ++# CONFIG_BLK_DEV_BSG is not set ++# CONFIG_BLK_DEV_INTEGRITY is not set ++ ++# ++# IO Schedulers ++# ++CONFIG_IOSCHED_NOOP=y ++# CONFIG_IOSCHED_AS is not set ++# CONFIG_IOSCHED_DEADLINE is not set ++# CONFIG_IOSCHED_CFQ is not set ++# CONFIG_DEFAULT_AS is not set ++# CONFIG_DEFAULT_DEADLINE is not set ++# CONFIG_DEFAULT_CFQ is not set ++CONFIG_DEFAULT_NOOP=y ++CONFIG_DEFAULT_IOSCHED="noop" ++CONFIG_CLASSIC_RCU=y ++CONFIG_PREEMPT_NONE=y ++# CONFIG_PREEMPT_VOLUNTARY is not set ++# CONFIG_PREEMPT is not set ++CONFIG_TICK_ONESHOT=y ++CONFIG_NO_HZ=y ++CONFIG_HIGH_RES_TIMERS=y ++CONFIG_GENERIC_CLOCKEVENTS_BUILD=y ++CONFIG_SELECT_MEMORY_MODEL=y ++CONFIG_FLATMEM_MANUAL=y ++# CONFIG_DISCONTIGMEM_MANUAL is not set ++# CONFIG_SPARSEMEM_MANUAL is not set ++CONFIG_FLATMEM=y ++CONFIG_FLAT_NODE_MEM_MAP=y ++CONFIG_PAGEFLAGS_EXTENDED=y ++CONFIG_SPLIT_PTLOCK_CPUS=4 ++# CONFIG_RESOURCES_64BIT is not set ++# CONFIG_PHYS_ADDR_T_64BIT is not set ++CONFIG_ZONE_DMA_FLAG=1 ++CONFIG_VIRT_TO_BUS=y ++CONFIG_NET=y ++ ++# ++# Networking options ++# ++CONFIG_PACKET=y ++# CONFIG_PACKET_MMAP is not set ++CONFIG_UNIX=y ++# CONFIG_NET_KEY is not set ++CONFIG_INET=y ++CONFIG_IP_MULTICAST=y ++CONFIG_IP_ADVANCED_ROUTER=y ++CONFIG_ASK_IP_FIB_HASH=y ++# CONFIG_IP_FIB_TRIE is not set ++CONFIG_IP_FIB_HASH=y ++# CONFIG_IP_MULTIPLE_TABLES is not set ++# CONFIG_IP_ROUTE_MULTIPATH is not set ++CONFIG_IP_ROUTE_VERBOSE=y ++CONFIG_IP_PNP=y ++CONFIG_IP_PNP_DHCP=y ++CONFIG_IP_PNP_BOOTP=y ++CONFIG_IP_PNP_RARP=y ++CONFIG_NET_IPIP=y ++CONFIG_NET_IPGRE=y ++# CONFIG_NET_IPGRE_BROADCAST is not set ++# CONFIG_IP_MROUTE is not set ++# CONFIG_ARPD is not set ++# CONFIG_SYN_COOKIES is not set ++# CONFIG_INET_AH is not set ++# CONFIG_INET_ESP is not set ++# CONFIG_INET_IPCOMP is not set ++# CONFIG_INET_XFRM_TUNNEL is not set ++CONFIG_INET_TUNNEL=y ++# CONFIG_INET_XFRM_MODE_TRANSPORT is not set ++# CONFIG_INET_XFRM_MODE_TUNNEL is not set ++# CONFIG_INET_XFRM_MODE_BEET is not set ++# CONFIG_INET_LRO is not set ++CONFIG_INET_DIAG=y ++CONFIG_INET_TCP_DIAG=y ++# CONFIG_TCP_CONG_ADVANCED is not set ++CONFIG_TCP_CONG_CUBIC=y ++CONFIG_DEFAULT_TCP_CONG="cubic" ++# CONFIG_TCP_MD5SIG is not set ++# CONFIG_IPV6 is not set ++# CONFIG_NETWORK_SECMARK is not set ++CONFIG_NETFILTER=y ++# CONFIG_NETFILTER_DEBUG is not set ++CONFIG_NETFILTER_ADVANCED=y ++# CONFIG_BRIDGE_NETFILTER is not set ++ ++# ++# Core Netfilter Configuration ++# ++# CONFIG_NETFILTER_NETLINK_QUEUE is not set ++# CONFIG_NETFILTER_NETLINK_LOG is not set ++CONFIG_NF_CONNTRACK=y ++# CONFIG_NF_CT_ACCT is not set ++# CONFIG_NF_CONNTRACK_MARK is not set ++# CONFIG_NF_CONNTRACK_EVENTS is not set ++# CONFIG_NF_CT_PROTO_DCCP is not set ++CONFIG_NF_CT_PROTO_GRE=y ++# CONFIG_NF_CT_PROTO_SCTP is not set ++# CONFIG_NF_CT_PROTO_UDPLITE is not set ++# CONFIG_NF_CONNTRACK_AMANDA is not set ++# CONFIG_NF_CONNTRACK_FTP is not set ++# CONFIG_NF_CONNTRACK_H323 is not set ++# CONFIG_NF_CONNTRACK_IRC is not set ++# CONFIG_NF_CONNTRACK_NETBIOS_NS is not set ++CONFIG_NF_CONNTRACK_PPTP=y ++# CONFIG_NF_CONNTRACK_SANE is not set ++# CONFIG_NF_CONNTRACK_SIP is not set ++# CONFIG_NF_CONNTRACK_TFTP is not set ++# CONFIG_NF_CT_NETLINK is not set ++# CONFIG_NETFILTER_TPROXY is not set ++CONFIG_NETFILTER_XTABLES=y ++# CONFIG_NETFILTER_XT_TARGET_CLASSIFY is not set ++# CONFIG_NETFILTER_XT_TARGET_CONNMARK is not set ++# CONFIG_NETFILTER_XT_TARGET_DSCP is not set ++# CONFIG_NETFILTER_XT_TARGET_MARK is not set ++# CONFIG_NETFILTER_XT_TARGET_NFLOG is not set ++# CONFIG_NETFILTER_XT_TARGET_NFQUEUE is not set ++# CONFIG_NETFILTER_XT_TARGET_RATEEST is not set ++CONFIG_NETFILTER_XT_TARGET_TCPMSS=y ++# CONFIG_NETFILTER_XT_TARGET_TCPOPTSTRIP is not set ++# CONFIG_NETFILTER_XT_MATCH_COMMENT is not set ++# CONFIG_NETFILTER_XT_MATCH_CONNBYTES is not set ++# CONFIG_NETFILTER_XT_MATCH_CONNLIMIT is not set ++# CONFIG_NETFILTER_XT_MATCH_CONNMARK is not set ++# CONFIG_NETFILTER_XT_MATCH_CONNTRACK is not set ++# CONFIG_NETFILTER_XT_MATCH_DCCP is not set ++# CONFIG_NETFILTER_XT_MATCH_DSCP is not set ++CONFIG_NETFILTER_XT_MATCH_ESP=y ++# CONFIG_NETFILTER_XT_MATCH_HASHLIMIT is not set ++# CONFIG_NETFILTER_XT_MATCH_HELPER is not set ++CONFIG_NETFILTER_XT_MATCH_IPRANGE=y ++# CONFIG_NETFILTER_XT_MATCH_LENGTH is not set ++CONFIG_NETFILTER_XT_MATCH_LIMIT=y ++CONFIG_NETFILTER_XT_MATCH_MAC=y ++# CONFIG_NETFILTER_XT_MATCH_MARK is not set ++CONFIG_NETFILTER_XT_MATCH_MULTIPORT=y ++# CONFIG_NETFILTER_XT_MATCH_OWNER is not set ++# CONFIG_NETFILTER_XT_MATCH_PKTTYPE is not set ++# CONFIG_NETFILTER_XT_MATCH_QUOTA is not set ++# CONFIG_NETFILTER_XT_MATCH_RATEEST is not set ++# CONFIG_NETFILTER_XT_MATCH_REALM is not set ++# CONFIG_NETFILTER_XT_MATCH_RECENT is not set ++# CONFIG_NETFILTER_XT_MATCH_SCTP is not set ++CONFIG_NETFILTER_XT_MATCH_STATE=y ++# CONFIG_NETFILTER_XT_MATCH_STATISTIC is not set ++CONFIG_NETFILTER_XT_MATCH_STRING=y ++CONFIG_NETFILTER_XT_MATCH_TCPMSS=y ++# CONFIG_NETFILTER_XT_MATCH_TIME is not set ++# CONFIG_NETFILTER_XT_MATCH_U32 is not set ++# CONFIG_IP_VS is not set ++ ++# ++# IP: Netfilter Configuration ++# ++CONFIG_NF_DEFRAG_IPV4=y ++CONFIG_NF_CONNTRACK_IPV4=y ++CONFIG_NF_CONNTRACK_PROC_COMPAT=y ++# CONFIG_IP_NF_QUEUE is not set ++CONFIG_IP_NF_IPTABLES=y ++# CONFIG_IP_NF_MATCH_ADDRTYPE is not set ++CONFIG_IP_NF_MATCH_AH=y ++# CONFIG_IP_NF_MATCH_ECN is not set ++CONFIG_IP_NF_MATCH_TTL=y ++CONFIG_IP_NF_FILTER=y ++CONFIG_IP_NF_TARGET_REJECT=y ++CONFIG_IP_NF_TARGET_LOG=y ++# CONFIG_IP_NF_TARGET_ULOG is not set ++# CONFIG_NF_QOS_UBICOM_STREAMENGINE_DEFAULT_CLASSIFIER is not set ++CONFIG_NF_NAT=y ++CONFIG_NF_NAT_NEEDED=y ++CONFIG_IP_NF_TARGET_MASQUERADE=y ++CONFIG_IP_NF_TARGET_NETMAP=y ++CONFIG_IP_NF_TARGET_REDIRECT=y ++CONFIG_NF_NAT_SNMP_BASIC=y ++CONFIG_NF_NAT_PROTO_GRE=y ++# CONFIG_NF_NAT_FTP is not set ++# CONFIG_NF_NAT_IRC is not set ++# CONFIG_NF_NAT_TFTP is not set ++# CONFIG_NF_NAT_AMANDA is not set ++CONFIG_NF_NAT_PPTP=y ++# CONFIG_NF_NAT_H323 is not set ++# CONFIG_NF_NAT_SIP is not set ++CONFIG_IP_NF_MANGLE=y ++# CONFIG_IP_NF_TARGET_CLUSTERIP is not set ++# CONFIG_IP_NF_TARGET_ECN is not set ++CONFIG_IP_NF_TARGET_TTL=y ++# CONFIG_IP_NF_RAW is not set ++# CONFIG_IP_NF_ARPTABLES is not set ++# CONFIG_IP_DCCP is not set ++# CONFIG_IP_SCTP is not set ++# CONFIG_TIPC is not set ++# CONFIG_ATM is not set ++CONFIG_STP=y ++CONFIG_BRIDGE=y ++# CONFIG_NET_DSA is not set ++CONFIG_VLAN_8021Q=y ++# CONFIG_VLAN_8021Q_GVRP is not set ++# CONFIG_DECNET is not set ++CONFIG_LLC=y ++# CONFIG_LLC2 is not set ++# CONFIG_IPX is not set ++# CONFIG_ATALK is not set ++# CONFIG_X25 is not set ++# CONFIG_LAPB is not set ++# CONFIG_ECONET is not set ++# CONFIG_WAN_ROUTER is not set ++# CONFIG_NET_SCHED is not set ++ ++# ++# Network testing ++# ++# CONFIG_NET_PKTGEN is not set ++# CONFIG_HAMRADIO is not set ++# CONFIG_CAN is not set ++# CONFIG_IRDA is not set ++# CONFIG_BT is not set ++# CONFIG_AF_RXRPC is not set ++# CONFIG_PHONET is not set ++CONFIG_WIRELESS=y ++# CONFIG_CFG80211 is not set ++# CONFIG_WIRELESS_OLD_REGULATORY is not set ++CONFIG_WIRELESS_EXT=y ++CONFIG_WIRELESS_EXT_SYSFS=y ++# CONFIG_MAC80211 is not set ++# CONFIG_IEEE80211 is not set ++# CONFIG_RFKILL is not set ++# CONFIG_NET_9P is not set ++ ++# ++# Device Drivers ++# ++ ++# ++# Generic Driver Options ++# ++CONFIG_STANDALONE=y ++CONFIG_PREVENT_FIRMWARE_BUILD=y ++# CONFIG_DEBUG_DRIVER is not set ++# CONFIG_DEBUG_DEVRES is not set ++# CONFIG_SYS_HYPERVISOR is not set ++# CONFIG_CONNECTOR is not set ++CONFIG_MTD=y ++# CONFIG_MTD_DEBUG is not set ++# CONFIG_MTD_CONCAT is not set ++CONFIG_MTD_PARTITIONS=y ++# CONFIG_MTD_REDBOOT_PARTS is not set ++CONFIG_MTD_CMDLINE_PARTS=y ++# CONFIG_MTD_AR7_PARTS is not set ++ ++# ++# User Modules And Translation Layers ++# ++CONFIG_MTD_CHAR=y ++CONFIG_MTD_BLKDEVS=y ++CONFIG_MTD_BLOCK=y ++# CONFIG_FTL is not set ++# CONFIG_NFTL is not set ++# CONFIG_INFTL is not set ++# CONFIG_RFD_FTL is not set ++# CONFIG_SSFDC is not set ++# CONFIG_MTD_OOPS is not set ++ ++# ++# RAM/ROM/Flash chip drivers ++# ++# CONFIG_MTD_CFI is not set ++# CONFIG_MTD_JEDECPROBE is not set ++CONFIG_MTD_MAP_BANK_WIDTH_1=y ++CONFIG_MTD_MAP_BANK_WIDTH_2=y ++CONFIG_MTD_MAP_BANK_WIDTH_4=y ++# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set ++# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set ++# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set ++CONFIG_MTD_CFI_I1=y ++CONFIG_MTD_CFI_I2=y ++# CONFIG_MTD_CFI_I4 is not set ++# CONFIG_MTD_CFI_I8 is not set ++# CONFIG_MTD_RAM is not set ++# CONFIG_MTD_ROM is not set ++# CONFIG_MTD_ABSENT is not set ++ ++# ++# Mapping drivers for chip access ++# ++# CONFIG_MTD_COMPLEX_MAPPINGS is not set ++# CONFIG_MTD_INTEL_VR_NOR is not set ++# CONFIG_MTD_PLATRAM is not set ++ ++# ++# Self-contained MTD device drivers ++# ++# CONFIG_MTD_PMC551 is not set ++# CONFIG_MTD_DATAFLASH is not set ++# CONFIG_MTD_M25P80 is not set ++CONFIG_MTD_UBI32_M25P80=y ++# CONFIG_MTD_SLRAM is not set ++# CONFIG_MTD_PHRAM is not set ++# CONFIG_MTD_MTDRAM is not set ++# CONFIG_MTD_BLOCK2MTD is not set ++ ++# ++# Disk-On-Chip Device Drivers ++# ++# CONFIG_MTD_DOC2000 is not set ++# CONFIG_MTD_DOC2001 is not set ++# CONFIG_MTD_DOC2001PLUS is not set ++# CONFIG_MTD_NAND is not set ++# CONFIG_MTD_ONENAND is not set ++ ++# ++# UBI - Unsorted block images ++# ++# CONFIG_MTD_UBI is not set ++# CONFIG_PARPORT is not set ++CONFIG_BLK_DEV=y ++# CONFIG_BLK_CPQ_DA is not set ++# CONFIG_BLK_CPQ_CISS_DA is not set ++# CONFIG_BLK_DEV_DAC960 is not set ++# CONFIG_BLK_DEV_UMEM is not set ++# CONFIG_BLK_DEV_COW_COMMON is not set ++# CONFIG_BLK_DEV_LOOP is not set ++# CONFIG_BLK_DEV_NBD is not set ++# CONFIG_BLK_DEV_SX8 is not set ++# CONFIG_BLK_DEV_UB is not set ++CONFIG_BLK_DEV_RAM=y ++CONFIG_BLK_DEV_RAM_COUNT=16 ++CONFIG_BLK_DEV_RAM_SIZE=4096 ++# CONFIG_BLK_DEV_XIP is not set ++# CONFIG_CDROM_PKTCDVD is not set ++# CONFIG_ATA_OVER_ETH is not set ++# CONFIG_MISC_DEVICES is not set ++ ++# ++# SCSI device support ++# ++# CONFIG_RAID_ATTRS is not set ++CONFIG_SCSI=y ++CONFIG_SCSI_DMA=y ++# CONFIG_SCSI_TGT is not set ++# CONFIG_SCSI_NETLINK is not set ++CONFIG_SCSI_PROC_FS=y ++ ++# ++# SCSI support type (disk, tape, CD-ROM) ++# ++CONFIG_BLK_DEV_SD=y ++# CONFIG_CHR_DEV_ST is not set ++# CONFIG_CHR_DEV_OSST is not set ++# CONFIG_BLK_DEV_SR is not set ++CONFIG_CHR_DEV_SG=y ++# CONFIG_CHR_DEV_SCH is not set ++ ++# ++# Some SCSI devices (e.g. CD jukebox) support multiple LUNs ++# ++CONFIG_SCSI_MULTI_LUN=y ++# CONFIG_SCSI_CONSTANTS is not set ++# CONFIG_SCSI_LOGGING is not set ++# CONFIG_SCSI_SCAN_ASYNC is not set ++CONFIG_SCSI_WAIT_SCAN=m ++ ++# ++# SCSI Transports ++# ++# CONFIG_SCSI_SPI_ATTRS is not set ++# CONFIG_SCSI_FC_ATTRS is not set ++# CONFIG_SCSI_ISCSI_ATTRS is not set ++# CONFIG_SCSI_SAS_LIBSAS is not set ++# CONFIG_SCSI_SRP_ATTRS is not set ++# CONFIG_SCSI_LOWLEVEL is not set ++# CONFIG_SCSI_LOWLEVEL_PCMCIA is not set ++# CONFIG_SCSI_DH is not set ++# CONFIG_ATA is not set ++# CONFIG_MD is not set ++# CONFIG_FUSION is not set ++ ++# ++# IEEE 1394 (FireWire) support ++# ++ ++# ++# Enable only one of the two stacks, unless you know what you are doing ++# ++# CONFIG_FIREWIRE is not set ++# CONFIG_IEEE1394 is not set ++# CONFIG_I2O is not set ++CONFIG_NETDEVICES=y ++# CONFIG_DUMMY is not set ++# CONFIG_BONDING is not set ++# CONFIG_MACVLAN is not set ++# CONFIG_EQUALIZER is not set ++# CONFIG_TUN is not set ++# CONFIG_VETH is not set ++# CONFIG_ARCNET is not set ++# CONFIG_NET_ETHERNET is not set ++CONFIG_MII=y ++CONFIG_NETDEV_1000=y ++# CONFIG_ACENIC is not set ++# CONFIG_DL2K is not set ++# CONFIG_E1000 is not set ++# CONFIG_E1000E is not set ++# CONFIG_IP1000 is not set ++# CONFIG_IGB is not set ++# CONFIG_NS83820 is not set ++# CONFIG_HAMACHI is not set ++# CONFIG_YELLOWFIN is not set ++# CONFIG_R8169 is not set ++# CONFIG_SIS190 is not set ++# CONFIG_SKGE is not set ++# CONFIG_SKY2 is not set ++# CONFIG_VIA_VELOCITY is not set ++# CONFIG_TIGON3 is not set ++# CONFIG_BNX2 is not set ++# CONFIG_QLA3XXX is not set ++# CONFIG_ATL1 is not set ++# CONFIG_ATL1E is not set ++# CONFIG_JME is not set ++CONFIG_UBICOM32_GMAC=y ++CONFIG_UBICOM32_NAPI=y ++CONFIG_UBICOM32_OCM_FOR_SKB=y ++# CONFIG_NETDEV_10000 is not set ++# CONFIG_TR is not set ++ ++# ++# Wireless LAN ++# ++# CONFIG_WLAN_PRE80211 is not set ++# CONFIG_WLAN_80211 is not set ++# CONFIG_IWLWIFI_LEDS is not set ++ ++# ++# USB Network Adapters ++# ++# CONFIG_USB_CATC is not set ++# CONFIG_USB_KAWETH is not set ++# CONFIG_USB_PEGASUS is not set ++# CONFIG_USB_RTL8150 is not set ++CONFIG_USB_USBNET=y ++CONFIG_USB_NET_AX8817X=y ++CONFIG_USB_NET_CDCETHER=y ++# CONFIG_USB_NET_DM9601 is not set ++# CONFIG_USB_NET_SMSC95XX is not set ++# CONFIG_USB_NET_GL620A is not set ++# CONFIG_USB_NET_NET1080 is not set ++# CONFIG_USB_NET_PLUSB is not set ++# CONFIG_USB_NET_MCS7830 is not set ++# CONFIG_USB_NET_RNDIS_HOST is not set ++# CONFIG_USB_NET_CDC_SUBSET is not set ++# CONFIG_USB_NET_ZAURUS is not set ++# CONFIG_WAN is not set ++# CONFIG_FDDI is not set ++# CONFIG_HIPPI is not set ++CONFIG_PPP=y ++# CONFIG_PPP_MULTILINK is not set ++# CONFIG_PPP_FILTER is not set ++CONFIG_PPP_ASYNC=y ++# CONFIG_PPP_SYNC_TTY is not set ++# CONFIG_PPP_DEFLATE is not set ++# CONFIG_PPP_BSDCOMP is not set ++# CONFIG_PPP_MPPE is not set ++# CONFIG_PPPOE is not set ++# CONFIG_PPPOL2TP is not set ++# CONFIG_SLIP is not set ++CONFIG_SLHC=y ++# CONFIG_NET_FC is not set ++# CONFIG_NETCONSOLE is not set ++# CONFIG_NETPOLL is not set ++# CONFIG_NET_POLL_CONTROLLER is not set ++# CONFIG_ISDN is not set ++# CONFIG_PHONE is not set ++ ++# ++# Input device support ++# ++CONFIG_INPUT=y ++# CONFIG_INPUT_FF_MEMLESS is not set ++CONFIG_INPUT_POLLDEV=y ++ ++# ++# Userland interfaces ++# ++# CONFIG_INPUT_MOUSEDEV is not set ++# CONFIG_INPUT_JOYDEV is not set ++# CONFIG_INPUT_EVDEV is not set ++# CONFIG_INPUT_EVBUG is not set ++ ++# ++# Input Device Drivers ++# ++# CONFIG_INPUT_KEYBOARD is not set ++# CONFIG_INPUT_MOUSE is not set ++# CONFIG_INPUT_JOYSTICK is not set ++# CONFIG_INPUT_TABLET is not set ++# CONFIG_INPUT_TOUCHSCREEN is not set ++# CONFIG_INPUT_MISC is not set ++ ++# ++# Hardware I/O ports ++# ++# CONFIG_SERIO is not set ++# CONFIG_GAMEPORT is not set ++ ++# ++# Character devices ++# ++# CONFIG_VT is not set ++CONFIG_DEVKMEM=y ++# CONFIG_SERIAL_NONSTANDARD is not set ++# CONFIG_NOZOMI is not set ++ ++# ++# Serial drivers ++# ++# CONFIG_SERIAL_8250 is not set ++ ++# ++# Non-8250 serial port support ++# ++# CONFIG_SERIAL_UBI32_SERDES is not set ++CONFIG_SERIAL_UBI32_MAILBOX=y ++CONFIG_SERIAL_UBI32_MAILBOX_CONSOLE=y ++CONFIG_SERIAL_CORE=y ++CONFIG_SERIAL_CORE_CONSOLE=y ++# CONFIG_SERIAL_JSM is not set ++CONFIG_UNIX98_PTYS=y ++CONFIG_LEGACY_PTYS=y ++CONFIG_LEGACY_PTY_COUNT=256 ++# CONFIG_IPMI_HANDLER is not set ++CONFIG_HW_RANDOM=y ++CONFIG_HW_RANDOM_UBICOM32=y ++# CONFIG_RTC is not set ++# CONFIG_GEN_RTC is not set ++# CONFIG_R3964 is not set ++# CONFIG_APPLICOM is not set ++# CONFIG_RAW_DRIVER is not set ++# CONFIG_TCG_TPM is not set ++CONFIG_DEVPORT=y ++# CONFIG_I2C is not set ++CONFIG_SPI=y ++# CONFIG_SPI_DEBUG is not set ++CONFIG_SPI_MASTER=y ++ ++# ++# SPI Master Controller Drivers ++# ++CONFIG_SPI_BITBANG=y ++CONFIG_SPI_UBICOM32_GPIO=y ++ ++# ++# SPI Protocol Masters ++# ++# CONFIG_SPI_AT25 is not set ++# CONFIG_SPI_SPIDEV is not set ++# CONFIG_SPI_TLE62X0 is not set ++# CONFIG_DEBUG_GPIO is not set ++# CONFIG_GPIO_SYSFS is not set ++ ++# ++# Memory mapped GPIO expanders: ++# ++ ++# ++# I2C GPIO expanders: ++# ++ ++# ++# PCI GPIO expanders: ++# ++# CONFIG_GPIO_BT8XX is not set ++ ++# ++# SPI GPIO expanders: ++# ++# CONFIG_GPIO_MAX7301 is not set ++# CONFIG_GPIO_MCP23S08 is not set ++# CONFIG_W1 is not set ++# CONFIG_POWER_SUPPLY is not set ++# CONFIG_HWMON is not set ++# CONFIG_THERMAL is not set ++# CONFIG_THERMAL_HWMON is not set ++CONFIG_WATCHDOG=y ++# CONFIG_WATCHDOG_NOWAYOUT is not set ++ ++# ++# Watchdog Device Drivers ++# ++# CONFIG_SOFT_WATCHDOG is not set ++# CONFIG_ALIM7101_WDT is not set ++CONFIG_UBI32_WDT=y ++ ++# ++# PCI-based Watchdog Cards ++# ++# CONFIG_PCIPCWATCHDOG is not set ++# CONFIG_WDTPCI is not set ++ ++# ++# USB-based Watchdog Cards ++# ++# CONFIG_USBPCWATCHDOG is not set ++CONFIG_SSB_POSSIBLE=y ++ ++# ++# Sonics Silicon Backplane ++# ++# CONFIG_SSB is not set ++ ++# ++# Multifunction device drivers ++# ++# CONFIG_MFD_CORE is not set ++# CONFIG_MFD_SM501 is not set ++# CONFIG_HTC_PASIC3 is not set ++# CONFIG_MFD_TMIO is not set ++# CONFIG_REGULATOR is not set ++ ++# ++# Multimedia devices ++# ++ ++# ++# Multimedia core support ++# ++# CONFIG_VIDEO_DEV is not set ++# CONFIG_DVB_CORE is not set ++# CONFIG_VIDEO_MEDIA is not set ++ ++# ++# Multimedia drivers ++# ++# CONFIG_DAB is not set ++ ++# ++# Graphics support ++# ++# CONFIG_VGASTATE is not set ++# CONFIG_VIDEO_OUTPUT_CONTROL is not set ++# CONFIG_FB is not set ++# CONFIG_BACKLIGHT_LCD_SUPPORT is not set ++ ++# ++# Display device support ++# ++# CONFIG_DISPLAY_SUPPORT is not set ++# CONFIG_SOUND is not set ++# CONFIG_HID_SUPPORT is not set ++CONFIG_USB_SUPPORT=y ++CONFIG_USB_ARCH_HAS_HCD=y ++CONFIG_USB_ARCH_HAS_OHCI=y ++CONFIG_USB_ARCH_HAS_EHCI=y ++CONFIG_USB=y ++# CONFIG_USB_DEBUG is not set ++# CONFIG_USB_ANNOUNCE_NEW_DEVICES is not set ++ ++# ++# Miscellaneous USB options ++# ++CONFIG_USB_DEVICEFS=y ++# CONFIG_USB_DEVICE_CLASS is not set ++# CONFIG_USB_DYNAMIC_MINORS is not set ++# CONFIG_USB_OTG is not set ++# CONFIG_USB_OTG_WHITELIST is not set ++# CONFIG_USB_OTG_BLACKLIST_HUB is not set ++# CONFIG_USB_MON is not set ++# CONFIG_USB_WUSB is not set ++# CONFIG_USB_WUSB_CBAF is not set ++ ++# ++# USB Host Controller Drivers ++# ++# CONFIG_USB_C67X00_HCD is not set ++# CONFIG_USB_EHCI_HCD is not set ++# CONFIG_USB_ISP116X_HCD is not set ++# CONFIG_USB_ISP1760_HCD is not set ++# CONFIG_USB_OHCI_HCD is not set ++# CONFIG_USB_UHCI_HCD is not set ++# CONFIG_USB_SL811_HCD is not set ++# CONFIG_USB_R8A66597_HCD is not set ++# CONFIG_USB_WHCI_HCD is not set ++# CONFIG_USB_HWA_HCD is not set ++CONFIG_USB_MUSB_HDRC=y ++# CONFIG_USB_TUSB6010 is not set ++CONFIG_USB_MUSB_HOST=y ++# CONFIG_USB_MUSB_PERIPHERAL is not set ++# CONFIG_USB_MUSB_OTG is not set ++CONFIG_USB_MUSB_HDRC_HCD=y ++CONFIG_MUSB_PIO_ONLY=y ++# CONFIG_USB_MUSB_DEBUG is not set ++ ++# ++# USB Device Class drivers ++# ++# CONFIG_USB_ACM is not set ++# CONFIG_USB_PRINTER is not set ++# CONFIG_USB_WDM is not set ++# CONFIG_USB_TMC is not set ++ ++# ++# NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may also be needed; ++# ++ ++# ++# see USB_STORAGE Help for more information ++# ++CONFIG_USB_STORAGE=y ++# CONFIG_USB_STORAGE_DEBUG is not set ++# CONFIG_USB_STORAGE_DATAFAB is not set ++# CONFIG_USB_STORAGE_FREECOM is not set ++# CONFIG_USB_STORAGE_ISD200 is not set ++# CONFIG_USB_STORAGE_DPCM is not set ++# CONFIG_USB_STORAGE_USBAT is not set ++# CONFIG_USB_STORAGE_SDDR09 is not set ++# CONFIG_USB_STORAGE_SDDR55 is not set ++# CONFIG_USB_STORAGE_JUMPSHOT is not set ++# CONFIG_USB_STORAGE_ALAUDA is not set ++# CONFIG_USB_STORAGE_ONETOUCH is not set ++# CONFIG_USB_STORAGE_KARMA is not set ++# CONFIG_USB_STORAGE_CYPRESS_ATACB is not set ++CONFIG_USB_LIBUSUAL=y ++ ++# ++# USB Imaging devices ++# ++# CONFIG_USB_MDC800 is not set ++# CONFIG_USB_MICROTEK is not set ++ ++# ++# USB port drivers ++# ++# CONFIG_USB_SERIAL is not set ++ ++# ++# USB Miscellaneous drivers ++# ++# CONFIG_USB_EMI62 is not set ++# CONFIG_USB_EMI26 is not set ++# CONFIG_USB_ADUTUX is not set ++# CONFIG_USB_SEVSEG is not set ++# CONFIG_USB_RIO500 is not set ++# CONFIG_USB_LEGOTOWER is not set ++# CONFIG_USB_LCD is not set ++# CONFIG_USB_BERRY_CHARGE is not set ++# CONFIG_USB_LED is not set ++# CONFIG_USB_CYPRESS_CY7C63 is not set ++# CONFIG_USB_CYTHERM is not set ++# CONFIG_USB_PHIDGET is not set ++# CONFIG_USB_IDMOUSE is not set ++# CONFIG_USB_FTDI_ELAN is not set ++# CONFIG_USB_APPLEDISPLAY is not set ++# CONFIG_USB_LD is not set ++# CONFIG_USB_TRANCEVIBRATOR is not set ++# CONFIG_USB_IOWARRIOR is not set ++# CONFIG_USB_TEST is not set ++# CONFIG_USB_ISIGHTFW is not set ++# CONFIG_USB_VST is not set ++# CONFIG_USB_GADGET is not set ++# CONFIG_UWB is not set ++# CONFIG_MMC is not set ++# CONFIG_MEMSTICK is not set ++CONFIG_NEW_LEDS=y ++CONFIG_LEDS_CLASS=y ++ ++# ++# LED drivers ++# ++CONFIG_LEDS_GPIO=y ++ ++# ++# LED Triggers ++# ++# CONFIG_LEDS_TRIGGERS is not set ++# CONFIG_ACCESSIBILITY is not set ++# CONFIG_INFINIBAND is not set ++# CONFIG_RTC_CLASS is not set ++# CONFIG_DMADEVICES is not set ++# CONFIG_UIO is not set ++# CONFIG_STAGING is not set ++ ++# ++# File systems ++# ++# CONFIG_EXT2_FS is not set ++# CONFIG_EXT3_FS is not set ++# CONFIG_EXT4_FS is not set ++# CONFIG_REISERFS_FS is not set ++# CONFIG_JFS_FS is not set ++# CONFIG_FS_POSIX_ACL is not set ++CONFIG_FILE_LOCKING=y ++# CONFIG_XFS_FS is not set ++# CONFIG_OCFS2_FS is not set ++# CONFIG_DNOTIFY is not set ++# CONFIG_INOTIFY is not set ++# CONFIG_QUOTA is not set ++CONFIG_AUTOFS_FS=y ++# CONFIG_AUTOFS4_FS is not set ++# CONFIG_FUSE_FS is not set ++ ++# ++# CD-ROM/DVD Filesystems ++# ++# CONFIG_ISO9660_FS is not set ++# CONFIG_UDF_FS is not set ++ ++# ++# DOS/FAT/NT Filesystems ++# ++CONFIG_FAT_FS=y ++CONFIG_MSDOS_FS=y ++CONFIG_VFAT_FS=y ++CONFIG_FAT_DEFAULT_CODEPAGE=437 ++CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1" ++# CONFIG_NTFS_FS is not set ++ ++# ++# Pseudo filesystems ++# ++CONFIG_PROC_FS=y ++CONFIG_PROC_SYSCTL=y ++CONFIG_SYSFS=y ++# CONFIG_TMPFS is not set ++# CONFIG_HUGETLB_PAGE is not set ++# CONFIG_CONFIGFS_FS is not set ++ ++# ++# Layered filesystems ++# ++CONFIG_UNION_FS=y ++# CONFIG_UNION_FS_XATTR is not set ++# CONFIG_UNION_FS_DEBUG is not set ++ ++# ++# Miscellaneous filesystems ++# ++# CONFIG_ADFS_FS is not set ++# CONFIG_AFFS_FS is not set ++# CONFIG_HFS_FS is not set ++# CONFIG_HFSPLUS_FS is not set ++# CONFIG_BEFS_FS is not set ++# CONFIG_BFS_FS is not set ++# CONFIG_EFS_FS is not set ++CONFIG_JFFS2_FS=y ++CONFIG_JFFS2_FS_DEBUG=0 ++CONFIG_JFFS2_FS_WRITEBUFFER=y ++# CONFIG_JFFS2_FS_WBUF_VERIFY is not set ++# CONFIG_JFFS2_SUMMARY is not set ++# CONFIG_JFFS2_FS_XATTR is not set ++# CONFIG_JFFS2_COMPRESSION_OPTIONS is not set ++CONFIG_JFFS2_ZLIB=y ++# CONFIG_JFFS2_LZO is not set ++CONFIG_JFFS2_RTIME=y ++# CONFIG_JFFS2_RUBIN is not set ++# CONFIG_CRAMFS is not set ++# CONFIG_VXFS_FS is not set ++# CONFIG_MINIX_FS is not set ++# CONFIG_OMFS_FS is not set ++# CONFIG_HPFS_FS is not set ++# CONFIG_QNX4FS_FS is not set ++CONFIG_ROMFS_FS=y ++# CONFIG_SYSV_FS is not set ++# CONFIG_UFS_FS is not set ++# CONFIG_NETWORK_FILESYSTEMS is not set ++ ++# ++# Partition Types ++# ++CONFIG_PARTITION_ADVANCED=y ++# CONFIG_ACORN_PARTITION is not set ++# CONFIG_OSF_PARTITION is not set ++# CONFIG_AMIGA_PARTITION is not set ++# CONFIG_ATARI_PARTITION is not set ++# CONFIG_MAC_PARTITION is not set ++CONFIG_MSDOS_PARTITION=y ++# CONFIG_BSD_DISKLABEL is not set ++# CONFIG_MINIX_SUBPARTITION is not set ++# CONFIG_SOLARIS_X86_PARTITION is not set ++# CONFIG_UNIXWARE_DISKLABEL is not set ++CONFIG_LDM_PARTITION=y ++CONFIG_LDM_DEBUG=y ++# CONFIG_SGI_PARTITION is not set ++# CONFIG_ULTRIX_PARTITION is not set ++# CONFIG_SUN_PARTITION is not set ++# CONFIG_KARMA_PARTITION is not set ++# CONFIG_EFI_PARTITION is not set ++# CONFIG_SYSV68_PARTITION is not set ++CONFIG_NLS=y ++CONFIG_NLS_DEFAULT="iso8859-1" ++CONFIG_NLS_CODEPAGE_437=y ++# CONFIG_NLS_CODEPAGE_737 is not set ++# CONFIG_NLS_CODEPAGE_775 is not set ++# CONFIG_NLS_CODEPAGE_850 is not set ++# CONFIG_NLS_CODEPAGE_852 is not set ++# CONFIG_NLS_CODEPAGE_855 is not set ++# CONFIG_NLS_CODEPAGE_857 is not set ++# CONFIG_NLS_CODEPAGE_860 is not set ++# CONFIG_NLS_CODEPAGE_861 is not set ++# CONFIG_NLS_CODEPAGE_862 is not set ++# CONFIG_NLS_CODEPAGE_863 is not set ++# CONFIG_NLS_CODEPAGE_864 is not set ++# CONFIG_NLS_CODEPAGE_865 is not set ++# CONFIG_NLS_CODEPAGE_866 is not set ++# CONFIG_NLS_CODEPAGE_869 is not set ++# CONFIG_NLS_CODEPAGE_936 is not set ++# CONFIG_NLS_CODEPAGE_950 is not set ++# CONFIG_NLS_CODEPAGE_932 is not set ++# CONFIG_NLS_CODEPAGE_949 is not set ++# CONFIG_NLS_CODEPAGE_874 is not set ++# CONFIG_NLS_ISO8859_8 is not set ++# CONFIG_NLS_CODEPAGE_1250 is not set ++# CONFIG_NLS_CODEPAGE_1251 is not set ++CONFIG_NLS_ASCII=y ++CONFIG_NLS_ISO8859_1=y ++# CONFIG_NLS_ISO8859_2 is not set ++# CONFIG_NLS_ISO8859_3 is not set ++# CONFIG_NLS_ISO8859_4 is not set ++# CONFIG_NLS_ISO8859_5 is not set ++# CONFIG_NLS_ISO8859_6 is not set ++# CONFIG_NLS_ISO8859_7 is not set ++# CONFIG_NLS_ISO8859_9 is not set ++# CONFIG_NLS_ISO8859_13 is not set ++# CONFIG_NLS_ISO8859_14 is not set ++CONFIG_NLS_ISO8859_15=y ++# CONFIG_NLS_KOI8_R is not set ++# CONFIG_NLS_KOI8_U is not set ++CONFIG_NLS_UTF8=y ++# CONFIG_DLM is not set ++ ++# ++# Security options ++# ++# CONFIG_KEYS is not set ++# CONFIG_SECURITY is not set ++# CONFIG_SECURITYFS is not set ++# CONFIG_SECURITY_FILE_CAPABILITIES is not set ++CONFIG_CRYPTO=y ++ ++# ++# Crypto core or helper ++# ++# CONFIG_CRYPTO_FIPS is not set ++CONFIG_CRYPTO_ALGAPI=y ++CONFIG_CRYPTO_ALGAPI2=y ++CONFIG_CRYPTO_AEAD2=y ++CONFIG_CRYPTO_BLKCIPHER=y ++CONFIG_CRYPTO_BLKCIPHER2=y ++CONFIG_CRYPTO_HASH2=y ++CONFIG_CRYPTO_RNG2=y ++CONFIG_CRYPTO_MANAGER=y ++CONFIG_CRYPTO_MANAGER2=y ++# CONFIG_CRYPTO_GF128MUL is not set ++# CONFIG_CRYPTO_NULL is not set ++# CONFIG_CRYPTO_CRYPTD is not set ++# CONFIG_CRYPTO_AUTHENC is not set ++# CONFIG_CRYPTO_TEST is not set ++ ++# ++# Authenticated Encryption with Associated Data ++# ++# CONFIG_CRYPTO_CCM is not set ++# CONFIG_CRYPTO_GCM is not set ++# CONFIG_CRYPTO_SEQIV is not set ++ ++# ++# Block modes ++# ++# CONFIG_CRYPTO_CBC is not set ++# CONFIG_CRYPTO_CTR is not set ++# CONFIG_CRYPTO_CTS is not set ++CONFIG_CRYPTO_ECB=y ++# CONFIG_CRYPTO_LRW is not set ++# CONFIG_CRYPTO_PCBC is not set ++# CONFIG_CRYPTO_XTS is not set ++ ++# ++# Hash modes ++# ++# CONFIG_CRYPTO_HMAC is not set ++# CONFIG_CRYPTO_XCBC is not set ++ ++# ++# Digest ++# ++# CONFIG_CRYPTO_CRC32C is not set ++# CONFIG_CRYPTO_MD4 is not set ++# CONFIG_CRYPTO_MD5 is not set ++# CONFIG_CRYPTO_MICHAEL_MIC is not set ++# CONFIG_CRYPTO_RMD128 is not set ++# CONFIG_CRYPTO_RMD160 is not set ++# CONFIG_CRYPTO_RMD256 is not set ++# CONFIG_CRYPTO_RMD320 is not set ++# CONFIG_CRYPTO_SHA1 is not set ++# CONFIG_CRYPTO_SHA256 is not set ++# CONFIG_CRYPTO_SHA512 is not set ++# CONFIG_CRYPTO_TGR192 is not set ++# CONFIG_CRYPTO_WP512 is not set ++ ++# ++# Ciphers ++# ++CONFIG_CRYPTO_AES=y ++# CONFIG_CRYPTO_ANUBIS is not set ++CONFIG_CRYPTO_ARC4=y ++# CONFIG_CRYPTO_BLOWFISH is not set ++# CONFIG_CRYPTO_CAMELLIA is not set ++# CONFIG_CRYPTO_CAST5 is not set ++# CONFIG_CRYPTO_CAST6 is not set ++# CONFIG_CRYPTO_DES is not set ++# CONFIG_CRYPTO_FCRYPT is not set ++# CONFIG_CRYPTO_KHAZAD is not set ++# CONFIG_CRYPTO_SALSA20 is not set ++# CONFIG_CRYPTO_SEED is not set ++# CONFIG_CRYPTO_SERPENT is not set ++# CONFIG_CRYPTO_TEA is not set ++# CONFIG_CRYPTO_TWOFISH is not set ++ ++# ++# Compression ++# ++# CONFIG_CRYPTO_DEFLATE is not set ++# CONFIG_CRYPTO_LZO is not set ++ ++# ++# Random Number Generation ++# ++# CONFIG_CRYPTO_ANSI_CPRNG is not set ++# CONFIG_CRYPTO_HW is not set ++ ++# ++# OCF Configuration ++# ++# CONFIG_OCF_OCF is not set ++ ++# ++# Library routines ++# ++CONFIG_BITREVERSE=y ++CONFIG_CRC_CCITT=y ++# CONFIG_CRC16 is not set ++# CONFIG_CRC_T10DIF is not set ++# CONFIG_CRC_ITU_T is not set ++CONFIG_CRC32=y ++# CONFIG_CRC7 is not set ++# CONFIG_LIBCRC32C is not set ++CONFIG_ZLIB_INFLATE=y ++CONFIG_ZLIB_DEFLATE=y ++CONFIG_TEXTSEARCH=y ++CONFIG_TEXTSEARCH_KMP=y ++CONFIG_TEXTSEARCH_BM=y ++CONFIG_TEXTSEARCH_FSM=y ++CONFIG_HAS_IOMEM=y ++CONFIG_HAS_DMA=y +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/a.out.h linux-2.6.28.10/arch/ubicom32/include/asm/a.out.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/a.out.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/a.out.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,47 @@ ++/* ++ * arch/ubicom32/include/asm/a.out.h ++ * Definitions for Ubicom32 a.out executable format. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_A_OUT_H ++#define _ASM_UBICOM32_A_OUT_H ++ ++struct exec ++{ ++ unsigned long a_info; /* Use macros N_MAGIC, etc for access */ ++ unsigned a_text; /* length of text, in bytes */ ++ unsigned a_data; /* length of data, in bytes */ ++ unsigned a_bss; /* length of uninitialized data area for file, in bytes */ ++ unsigned a_syms; /* length of symbol table data in file, in bytes */ ++ unsigned a_entry; /* start address */ ++ unsigned a_trsize; /* length of relocation info for text, in bytes */ ++ unsigned a_drsize; /* length of relocation info for data, in bytes */ ++}; ++ ++#define N_TRSIZE(a) ((a).a_trsize) ++#define N_DRSIZE(a) ((a).a_drsize) ++#define N_SYMSIZE(a) ((a).a_syms) ++ ++#endif /* _ASM_UBICOM32_A_OUT_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/atomic.h linux-2.6.28.10/arch/ubicom32/include/asm/atomic.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/atomic.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/atomic.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,352 @@ ++/* ++ * arch/ubicom32/include/asm/atomic.h ++ * Atomic operations definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_ATOMIC_H ++#define _ASM_UBICOM32_ATOMIC_H ++ ++#include ++#include ++#include ++ ++/* ++ * Most instructions on the Ubicom32 processor are atomic in that they ++ * execute in one clock cycle. However, Linux has several operations ++ * (e.g. compare and swap) which will require more than a single instruction ++ * to perform. To achieve this, the Ubicom32 processor uses a single ++ * global bit in a scratchpad register as a critical section lock. All ++ * atomic operations acquire this lock. ++ * ++ * NOTE: To AVOID DEADLOCK(s), the atomic lock must only be used for atomic ++ * operations or by the ldsr to avoid disabling a thread performing an atomic ++ * operation. ++ * ++ * Do not attempt to disable interrupts while holding the atomic operations ++ * lock or you will DEADLOCK the system. ++ */ ++ ++typedef struct { ++ volatile int counter; ++} atomic_t; ++ ++#define ATOMIC_INIT(i) { (i) } ++ ++/* ++ * __atomic_add() ++ * Add i to v and return the result. ++ */ ++static inline void __atomic_add(int i, atomic_t *v) ++{ ++ atomic_t *vt = v; ++ ++ __atomic_lock_acquire(); ++ vt->counter += i; ++ __atomic_lock_release(); ++} ++ ++/* ++ * __atomic_sub() ++ * Subtract i from v and return the result. ++ */ ++static inline void __atomic_sub(int i, atomic_t *v) ++{ ++ atomic_t *vt = v; ++ ++ __atomic_lock_acquire(); ++ vt->counter -= i; ++ __atomic_lock_release(); ++} ++ ++/* ++ * __atomic_add_return() ++ * Add i to v and return the result. ++ * ++ * The implementation here looks rather odd because we appear to be doing ++ * the addition twice. In fact that's exactly what we're doing but with ++ * the ubicom32 instruction set we can do the inner load and add with two ++ * instructions whereas generating both the atomic result and the "ret" ++ * result requires three instructions. The second add is generally only as ++ * costly as a move instruction and in cases where we compare the result ++ * with a constant the compiler can fold two constant values and do a ++ * single instruction, thus saving an instruction overall! ++ * ++ * At the worst we save one instruction inside the atomic lock. ++ */ ++static inline int __atomic_add_return(int i, atomic_t *v) ++{ ++ int ret; ++ atomic_t *vt = v; ++ ++ __atomic_lock_acquire(); ++ ret = vt->counter; ++ vt->counter = ret + i; ++ __atomic_lock_release(); ++ ++ return ret + i; ++} ++ ++/* ++ * __atomic_sub_return() ++ * Subtract i from v and return the result. ++ * ++ * The implementation here looks rather odd because we appear to be doing ++ * the subtraction twice. In fact that's exactly what we're doing but with ++ * the ubicom32 instruction set we can do the inner load and sub with two ++ * instructions whereas generating both the atomic result and the "ret" ++ * result requires three instructions. The second sub is generally only as ++ * costly as a move instruction and in cases where we compare the result ++ * with a constant the compiler can fold two constant values and do a ++ * single instruction, thus saving an instruction overall! ++ * ++ * At the worst we save one instruction inside the atomic lock. ++ */ ++static inline int __atomic_sub_return(int i, atomic_t *v) ++{ ++ int ret; ++ atomic_t *vt = v; ++ ++ __atomic_lock_acquire(); ++ ret = vt->counter; ++ vt->counter = ret - i; ++ __atomic_lock_release(); ++ ++ return ret - i; ++} ++ ++/* ++ * PUBLIC API FOR ATOMIC! ++ */ ++#define atomic_add(i,v) (__atomic_add( ((int)i),(v))) ++#define atomic_sub(i,v) (__atomic_sub( ((int)i),(v))) ++#define atomic_inc(v) (__atomic_add( 1,(v))) ++#define atomic_dec(v) (__atomic_sub( 1,(v))) ++#define atomic_add_return(i,v) (__atomic_add_return( ((int)i),(v))) ++#define atomic_sub_return(i,v) (__atomic_sub_return( ((int)i),(v))) ++#define atomic_inc_return(v) (__atomic_add_return( 1,(v))) ++#define atomic_dec_return(v) (__atomic_sub_return( 1,(v))) ++#define atomic_inc_and_test(v) (atomic_inc_return(v) == 0) ++#define atomic_dec_and_test(v) (atomic_dec_return(v) == 0) ++#define atomic_add_negative(a, v) (atomic_add_return((a), (v)) < 0) ++#define atomic_sub_and_test(i,v) (atomic_sub_return((i),(v)) == 0) ++ ++/* ++ * atomic_read() ++ * Acquire the atomic lock and read the variable. ++ */ ++static inline int atomic_read(const atomic_t *v) ++{ ++ int ret; ++ const atomic_t *vt = v; ++ ++ __atomic_lock_acquire(); ++ ret = vt->counter; ++ __atomic_lock_release(); ++ ++ return ret; ++} ++ ++/* ++ * atomic_set() ++ * Acquire the atomic lock and set the variable. ++ */ ++static inline void atomic_set(atomic_t *v, int i) ++{ ++ atomic_t *vt = v; ++ ++ __atomic_lock_acquire(); ++ vt->counter = i; ++ __atomic_lock_release(); ++} ++ ++/* ++ * atomic_cmpxchg ++ * Acquire the atomic lock and exchange if current == old. ++ */ ++static inline int atomic_cmpxchg(atomic_t *v, int old, int new) ++{ ++ int prev; ++ atomic_t *vt = v; ++ ++ __atomic_lock_acquire(); ++ prev = vt->counter; ++ if (prev == old) { ++ vt->counter = new; ++ } ++ __atomic_lock_release(); ++ ++ return prev; ++} ++ ++/* ++ * atomic_xchg() ++ * Acquire the atomic lock and exchange values. ++ */ ++static inline int atomic_xchg(atomic_t *v, int new) ++{ ++ int prev; ++ atomic_t *vt = v; ++ ++ __atomic_lock_acquire(); ++ prev = vt->counter; ++ vt->counter = new; ++ __atomic_lock_release(); ++ ++ return prev; ++} ++ ++/* ++ * atomic_add_unless() ++ * Acquire the atomic lock and add a unless the value is u. ++ */ ++static inline int atomic_add_unless(atomic_t *v, int a, int u) ++{ ++ int prev; ++ atomic_t *vt = v; ++ ++ __atomic_lock_acquire(); ++ prev = vt->counter; ++ if (prev != u) { ++ vt->counter += a; ++ __atomic_lock_release(); ++ return 1; ++ } ++ ++ __atomic_lock_release(); ++ return 0; ++} ++ ++#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0) ++ ++#include ++ ++/* ++ * The following is not a real function. The compiler should remove the function ++ * call as long as the user does not pass in a size that __xchg and __cmpxchg ++ * are not prepared for. If the user does pass in an unknown size, the user ++ * will get a link time error. ++ * ++ * The no return is to prevent a compiler error that can occur when dealing with ++ * uninitialized variables. Given that the function doesn't exist there is no ++ * net effect (and if it did it would not return). ++ */ ++extern void __xchg_called_with_bad_pointer(void) __attribute__((noreturn)); ++ ++/* ++ * __xchg() ++ * Xchange *ptr for x atomically. ++ * ++ * Must be both locally atomic and atomic on SMP. Ubicom32 does not have an ++ * atomic exchange instruction so we use the global atomic_lock. ++ */ ++static inline unsigned long __xchg(unsigned long x, volatile void *ptr, int size) ++{ ++ unsigned long ret; ++ ++ __atomic_lock_acquire(); ++ ++ switch (size) { ++ case 1: ++ ret = *(volatile unsigned char *)ptr; ++ *(volatile unsigned char *)ptr = x; ++ break; ++ ++ case 2: ++ ret = *(volatile unsigned short *)ptr; ++ *(volatile unsigned short *)ptr = x; ++ break; ++ ++ case 4: ++ ret = *(volatile unsigned int *)ptr; ++ *(volatile unsigned int *)ptr = x; ++ break; ++ ++ default: ++ __xchg_called_with_bad_pointer(); ++ break; ++ } ++ __atomic_lock_release(); ++ return ret; ++} ++ ++#define xchg(ptr,x) ((__typeof__(*(ptr)))__xchg((unsigned long)(x),(ptr),sizeof(*(ptr)))) ++ ++/* ++ * __cmpxchg() ++ * Compare and Xchange *ptr for x atomically. ++ * ++ * Must be both locally atomic and atomic on SMP. Ubicom32 does not have an ++ * atomic exchange instruction so we use the global atomic_lock. ++ */ ++static inline unsigned long __cmpxchg(volatile void *ptr, unsigned long old, unsigned long next, int size) ++{ ++ unsigned long prev; ++ ++ __atomic_lock_acquire(); ++ switch (size) { ++ case 1: ++ prev = *(u8 *)ptr; ++ if (prev == old) { ++ *(u8 *)ptr = (u8)next; ++ } ++ break; ++ ++ case 2: ++ prev = *(u16 *)ptr; ++ if (prev == old) { ++ *(u16 *)ptr = (u16)next; ++ } ++ break; ++ ++ case 4: ++ prev = *(u32 *)ptr; ++ if (prev == old) { ++ *(u32 *)ptr = (u32)next; ++ } ++ break; ++ ++ default: ++ __xchg_called_with_bad_pointer(); ++ break; ++ } ++ __atomic_lock_release(); ++ return prev; ++} ++ ++/* ++ * cmpxchg_local and cmpxchg64_local are atomic wrt current CPU. Always make ++ * them available. ++ */ ++#define cmpxchg_local(ptr, o, n) \ ++ ((__typeof__(*(ptr)))__cmpxchg((ptr), (unsigned long)(o), (unsigned long)(n), sizeof(*(ptr)))) ++ ++#define cmpxchg(ptr, o, n) __cmpxchg((ptr), (o), (n), sizeof(*(ptr))) ++ ++#define smp_mb__before_atomic_inc() asm volatile ("" : : : "memory") ++#define smp_mb__after_atomic_inc() asm volatile ("" : : : "memory") ++#define smp_mb__before_atomic_dec() asm volatile ("" : : : "memory") ++#define smp_mb__after_atomic_dec() asm volatile ("" : : : "memory") ++ ++#endif /* _ASM_UBICOM32_ATOMIC_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/audio_tio.h linux-2.6.28.10/arch/ubicom32/include/asm/audio_tio.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/audio_tio.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/audio_tio.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,124 @@ ++/* ++ * arch/ubicom32/include/asm/audio_tio.h ++ * AudioTIO include file ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ */ ++ ++#ifndef _AUDIO_TIO_H ++#define _AUDIO_TIO_H ++ ++#include ++#include ++ ++#define UBI32_AUDIO_INT_FLAG_MORE_SAMPLES 0x00000001 ++#define UBI32_AUDIO_INT_FLAG_COMMAND 0x00000002 ++ ++/* ++ * Commands the Primary OS sends to the audio device ++ */ ++enum ubi32_audio_command { ++ UBI32_AUDIO_CMD_NONE, ++ UBI32_AUDIO_CMD_START, ++ UBI32_AUDIO_CMD_STOP, ++ UBI32_AUDIO_CMD_PAUSE, ++ UBI32_AUDIO_CMD_RESUME, ++ UBI32_AUDIO_CMD_MUTE, ++ UBI32_AUDIO_CMD_UNMUTE, ++ UBI32_AUDIO_CMD_SETUP, ++ UBI32_AUDIO_CMD_ENABLE, ++ UBI32_AUDIO_CMD_DISABLE, ++}; ++ ++/* ++ * Flag bits passed in the registers ++ */ ++#define UBI32_CMD_SETUP_FLAG_LE (1 << 0) /* Use Little Endian Mode */ ++ ++/* ++ * Status bits that audio device can set to indicate reason ++ * for interrupting the Primary OS ++ */ ++#define UBI32_AUDIO_STATUS_PLAY_DMA0_REQUEST (1 << 0) /* Audio device needs samples in DMA0 for playback */ ++#define UBI32_AUDIO_STATUS_PLAY_DMA1_REQUEST (1 << 1) /* Audio device needs samples in DMA1 for playback */ ++ ++struct ubi32_audio_dma { ++ /* ++ * NOTE: The active flag shall only be SET by the producer and CLEARED ++ * by the consumer, NEVER the other way around. For playback, the ++ * Primary OS sets this flag and ipAudioTIO clears it. ++ * ++ * The producer shall not modify the ptr or ctr fields when the transfer ++ * is marked as active, as these are used by the consumer to do the ++ * transfer. ++ */ ++ volatile uint32_t active; /* Nonzero if data in ptr/ctr ready to be transferred */ ++ //volatile u32_t active; /* Nonzero if data in ptr/ctr ready to be transferred */ ++ volatile void *ptr; /* Pointer to data to be transferred */ ++ volatile uint32_t ctr; /* Counter: number of data units to transfer */ ++ //volatile u32_t ctr; /* Counter: number of data units to transfer */ ++}; ++ ++#define AUDIOTIONODE_CAP_BE (1 << 0) ++#define AUDIOTIONODE_CAP_LE (1 << 1) ++ ++/* ++ * Resource indices used to access IRQs via platform_get_resource ++ */ ++#define AUDIOTIO_MEM_RESOURCE 0 ++#define AUDIOTIO_TX_IRQ_RESOURCE 0 ++#define AUDIOTIO_RX_IRQ_RESOURCE 1 ++ ++#define AUDIOTIONODE_VERSION 5 ++struct audiotionode { ++ struct devtree_node dn; ++ uint32_t version; /* Version of this node */ ++ struct audiotioregs *regs; ++}; ++ ++#define AUDIOTIOREGS_VERSION 3 ++struct audiotioregs { ++ uint32_t version; ++ uint32_t caps; /* Capabilities of the driver */ ++ u32_t *sample_rates; /* Sample Rates supported by this driver */ ++ u32_t n_sample_rates; /* Number of sample rates supported by this driver */ ++ u32_t channel_mask; /* The channel configs supported by this driver (bit 1 = 1 channel, etc) */ ++ volatile uint32_t int_flags; /* Reason for interrupting audio device */ ++ volatile enum ubi32_audio_command command; /* Command from Primary OS */ ++ volatile uint32_t flags; /* Flag bits for this command */ ++ volatile uint32_t channels; /* Number of channels in stream */ ++ volatile uint32_t sample_rate; /* Sample rate */ ++ volatile uint32_t status; /* Status bits sent from AudioTIO to Primary OS */ ++ volatile void *current_read_pos; /* Position of next sample to be removed from Primary OS sample buffer */ ++ ++ /* ++ * These are the transfer requests. They are used in alternating ++ * order so that when ipAudioTIO is processing one request, the ++ * Primary OS can fill in the other one. ++ * ++ * NOTE: The active bit shall always be SET by the producer and ++ * CLEARED by the consumer, NEVER the other way around. ++ */ ++ struct ubi32_audio_dma playback_xfer_requests[2]; ++}; ++ ++extern struct platform_device * __init audio_tio_alloc(const char *driver_name, const char *node_name, int priv_size); ++ ++#define audio_tio_priv(pdev) (((struct ubi32pcm_platform_data *)(((struct platform_device *)(pdev))->dev.platform_data))->priv_data) ++#endif +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/auxvec.h linux-2.6.28.10/arch/ubicom32/include/asm/auxvec.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/auxvec.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/auxvec.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,32 @@ ++/* ++ * arch/ubicom32/include/asm/auxvec.h ++ * Symbolic values for the entries in the auxiliary table ++ * put on the initial stack. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_AUXVEC_H ++#define _ASM_UBICOM32_AUXVEC_H ++ ++#endif /* _ASM_UBICOM32_AUXVEC_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/bitops.h linux-2.6.28.10/arch/ubicom32/include/asm/bitops.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/bitops.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/bitops.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,171 @@ ++/* ++ * arch/ubicom32/include/asm/bitops.h ++ * Bit manipulation definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_BITOPS_H ++#define _ASM_UBICOM32_BITOPS_H ++ ++/* ++ * Copyright 1992, Linus Torvalds. ++ */ ++ ++#include ++#include /* swab32 */ ++ ++#ifdef __KERNEL__ ++ ++#ifndef _LINUX_BITOPS_H ++#error only can be included directly ++#endif ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++ ++static inline void set_bit(int bit, volatile unsigned long *p) ++{ ++ unsigned long mask = 1UL << (bit & 31); ++ ++ p += bit >> 5; ++ ++ __atomic_lock_acquire(); ++ *p |= mask; ++ __atomic_lock_release(); ++} ++ ++static inline void clear_bit(int bit, volatile unsigned long *p) ++{ ++ unsigned long mask = 1UL << (bit & 31); ++ ++ p += bit >> 5; ++ ++ __atomic_lock_acquire(); ++ *p &= ~mask; ++ __atomic_lock_release(); ++} ++ ++/* ++ * clear_bit() doesn't provide any barrier for the compiler. ++ */ ++#define smp_mb__before_clear_bit() barrier() ++#define smp_mb__after_clear_bit() barrier() ++ ++static inline void change_bit(int bit, volatile unsigned long *p) ++{ ++ unsigned long mask = 1UL << (bit & 31); ++ ++ p += bit >> 5; ++ ++ __atomic_lock_acquire(); ++ *p ^= mask; ++ __atomic_lock_release(); ++} ++ ++static inline int test_and_set_bit(int bit, volatile unsigned long *p) ++{ ++ unsigned int res; ++ unsigned long mask = 1UL << (bit & 31); ++ ++ p += bit >> 5; ++ ++ __atomic_lock_acquire(); ++ res = *p; ++ *p = res | mask; ++ __atomic_lock_release(); ++ ++ return res & mask; ++} ++ ++static inline int test_and_clear_bit(int bit, volatile unsigned long *p) ++{ ++ unsigned int res; ++ unsigned long mask = 1UL << (bit & 31); ++ ++ p += bit >> 5; ++ ++ __atomic_lock_acquire(); ++ res = *p; ++ *p = res & ~mask; ++ __atomic_lock_release(); ++ ++ return res & mask; ++} ++ ++static inline int test_and_change_bit(int bit, volatile unsigned long *p) ++{ ++ unsigned int res; ++ unsigned long mask = 1UL << (bit & 31); ++ ++ p += bit >> 5; ++ ++ __atomic_lock_acquire(); ++ res = *p; ++ *p = res ^ mask; ++ __atomic_lock_release(); ++ ++ return res & mask; ++} ++ ++#include ++ ++/* ++ * This routine doesn't need to be atomic. ++ */ ++static inline int __constant_test_bit(int nr, const volatile unsigned long *addr) ++{ ++ return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0; ++} ++ ++static inline int __test_bit(int nr, const volatile unsigned long *addr) ++{ ++ int * a = (int *) addr; ++ int mask; ++ ++ a += nr >> 5; ++ mask = 1 << (nr & 0x1f); ++ return ((mask & *a) != 0); ++} ++ ++#define test_bit(nr,addr) (__builtin_constant_p(nr) ? __constant_test_bit((nr),(addr)) : __test_bit((nr),(addr))) ++ ++#include ++#include ++#include ++ ++#include ++#include ++#include ++ ++#endif /* __KERNEL__ */ ++ ++#include ++#include ++ ++#endif /* _ASM_UBICOM32_BITOPS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/board.h linux-2.6.28.10/arch/ubicom32/include/asm/board.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/board.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/board.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,34 @@ ++/* ++ * arch/ubicom32/include/asm/board.h ++ * Board init and revision definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_BOARD_H ++#define _ASM_UBICOM32_BOARD_H ++ ++extern const char *board_get_revision(void); ++extern void __init board_init(void); ++ ++#endif /* _ASM_UBICOM32_BOARD_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/bootargs.h linux-2.6.28.10/arch/ubicom32/include/asm/bootargs.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/bootargs.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/bootargs.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,34 @@ ++/* ++ * arch/ubicom32/include/asm/bootargs.h ++ * Kernel command line via the devtree API. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_BOOTARGS_H ++#define _ASM_UBICOM32_BOOTARGS_H ++ ++extern const char *bootargs_get_cmdline(void); ++extern void __init bootargs_init(void); ++ ++#endif /* _ASM_UBICOM32_BOOTARGS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/bootinfo.h linux-2.6.28.10/arch/ubicom32/include/asm/bootinfo.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/bootinfo.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/bootinfo.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,34 @@ ++/* ++ * arch/ubicom32/include/asm/bootinfo.h ++ * Definitions of firmware boot parameters passed to the kernel. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_BOOTINFO_H ++#define _ASM_UBICOM32_BOOTINFO_H ++ ++/* Nothing for ubicom32 */ ++ ++#endif /* _ASM_UBICOM32_BOOTINFO_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/bug.h linux-2.6.28.10/arch/ubicom32/include/asm/bug.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/bug.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/bug.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,53 @@ ++/* ++ * arch/ubicom32/include/asm/bug.h ++ * Generic bug.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_BUG_H ++#define _ASM_UBICOM32_BUG_H ++ ++#include ++#include ++ ++#if defined(CONFIG_STOP_ON_BUG) ++/* ++ * __BUG_ON() ++ * Stall all threads to enable debugging. ++ */ ++static inline void __BUG_ON(unsigned long c) ++{ ++ if (unlikely(c)) { ++ THREAD_STALL; ++ } ++ return; ++} ++ ++#define BUG_ON(c) __BUG_ON((unsigned long)(c)) ++#define HAVE_ARCH_BUG_ON ++#endif ++ ++#include ++ ++#endif /* _ASM_UBICOM32_BUG_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/bugs.h linux-2.6.28.10/arch/ubicom32/include/asm/bugs.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/bugs.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/bugs.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,44 @@ ++/* ++ * arch/ubicom32/include/asm/bugs.h ++ * Definition of check_bugs() for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * Copyright (C) 1994 Linus Torvalds ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++/* ++ * This is included by init/main.c to check for architecture-dependent bugs. ++ * ++ * Needs: ++ * void check_bugs(void); ++ */ ++ ++#ifndef _ASM_UBICOM32_BUGS_H ++#define _ASM_UBICOM32_BUGS_H ++ ++static void check_bugs(void) ++{ ++} ++ ++#endif /* _ASM_UBICOM32_BUGS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/byteorder.h linux-2.6.28.10/arch/ubicom32/include/asm/byteorder.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/byteorder.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/byteorder.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,48 @@ ++/* ++ * arch/ubicom32/include/asm/byteorder.h ++ * Byte order swapping utility routines. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_BYTEORDER_H ++#define _ASM_UBICOM32_BYTEORDER_H ++ ++#include ++ ++#if defined(__GNUC__) && !defined(__STRICT_ANSI__) || defined(__KERNEL__) ++# define __BYTEORDER_HAS_U64__ ++# define __SWAB_64_THRU_32__ ++#endif ++ ++#if defined(IP7000) || defined(IP7000_REV2) ++ ++#define __arch__swab16 __builtin_ubicom32_swapb_2 ++#define __arch__swab32 __builtin_ubicom32_swapb_4 ++ ++#endif /* IP7000 */ ++ ++#include ++ ++#endif /* _ASM_UBICOM32_BYTEORDER_H */ ++ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/cachectl.h linux-2.6.28.10/arch/ubicom32/include/asm/cachectl.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/cachectl.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/cachectl.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,39 @@ ++/* ++ * arch/ubicom32/include/asm/cachectl.h ++ * Ubicom32 cache control definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_CACHECTL_H ++#define _ASM_UBICOM32_CACHECTL_H ++ ++#include ++ ++/* ++ * mem_cache_control() ++ * Special cache control operation ++ */ ++extern void mem_cache_control(unsigned long cc, unsigned long begin_addr, unsigned long end_addr, unsigned long op); ++ ++#endif /* _ASM_UBICOM32_CACHECTL_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/cacheflush.h linux-2.6.28.10/arch/ubicom32/include/asm/cacheflush.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/cacheflush.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/cacheflush.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,104 @@ ++/* ++ * arch/ubicom32/include/asm/cacheflush.h ++ * Cache flushing definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_CACHEFLUSH_H ++#define _ASM_UBICOM32_CACHEFLUSH_H ++ ++/* ++ * (C) Copyright 2000-2004, Greg Ungerer ++ */ ++#include ++#include ++#include ++ ++#define flush_cache_all() __flush_cache_all() ++#define flush_cache_mm(mm) do { } while (0) ++#define flush_cache_dup_mm(mm) do { } while (0) ++#define flush_cache_range(vma, start, end) __flush_cache_all() ++#define flush_cache_page(vma, vmaddr) do { } while (0) ++#define flush_dcache_page(page) do { } while (0) ++#define flush_dcache_mmap_lock(mapping) do { } while (0) ++#define flush_dcache_mmap_unlock(mapping) do { } while (0) ++ ++#define flush_dcache_range(start, end) \ ++do { \ ++ /* Flush the data cache and invalidate the I cache. */ \ ++ local_irq_disable(); \ ++ mem_cache_control(DCCR_BASE, start, end, CCR_CTRL_FLUSH_ADDR); \ ++ mem_cache_control(ICCR_BASE, start, end, CCR_CTRL_INV_ADDR); \ ++ local_irq_enable(); \ ++} while (0) ++ ++#define flush_icache_range(start, end) \ ++do { \ ++ /* Flush the data cache and invalidate the I cache. */ \ ++ local_irq_disable(); \ ++ mem_cache_control(DCCR_BASE, start, end, CCR_CTRL_FLUSH_ADDR); \ ++ mem_cache_control(ICCR_BASE, start, end, CCR_CTRL_INV_ADDR); \ ++ local_irq_enable(); \ ++} while (0) ++ ++#define flush_icache_page(vma,pg) do { } while (0) ++#define flush_icache_user_range(vma,pg,adr,len) do { } while (0) ++#define flush_cache_vmap(start, end) do { } while (0) ++#define flush_cache_vunmap(start, end) do { } while (0) ++ ++#define copy_to_user_page(vma, page, vaddr, dst, src, len) \ ++ memcpy(dst, src, len) ++#define copy_from_user_page(vma, page, vaddr, dst, src, len) \ ++ memcpy(dst, src, len) ++ ++/* ++ * Cache handling for IP5000 ++ */ ++extern inline void mem_cache_invalidate_all(unsigned long cc) ++{ ++ asm volatile ( ++ " bset "D(CCR_CTRL)"(%0), "D(CCR_CTRL)"(%0), #"D(CCR_CTRL_RESET)" \n\t" ++ " nop \n\t" ++ " bclr "D(CCR_CTRL)"(%0), "D(CCR_CTRL)"(%0), #"D(CCR_CTRL_RESET)" \n\t" ++ " pipe_flush 0 \n\t" ++ : ++ : "a"(cc) ++ : "cc" ++ ); ++} ++ ++static inline void __flush_cache_all(void) ++{ ++ /* ++ * Flush Icache ++ */ ++ mem_cache_invalidate_all(ICCR_BASE); ++ ++ /* ++ * Flush Dcache ++ */ ++ mem_cache_invalidate_all(DCCR_BASE); ++} ++ ++#endif /* _ASM_UBICOM32_CACHEFLUSH_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/cache.h linux-2.6.28.10/arch/ubicom32/include/asm/cache.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/cache.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/cache.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,40 @@ ++/* ++ * arch/ubicom32/include/asm/cache.h ++ * Cache line definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_CACHE_H ++#define _ASM_UBICOM32_CACHE_H ++ ++/* ++ * bytes per L1 cache line ++ */ ++#define L1_CACHE_SHIFT 5 ++#define L1_CACHE_BYTES (1 << L1_CACHE_SHIFT) ++ ++#define __cacheline_aligned ++#define ____cacheline_aligned ++ ++#endif /* _ASM_UBICOM32_CACHE_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/checksum.h linux-2.6.28.10/arch/ubicom32/include/asm/checksum.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/checksum.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/checksum.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,149 @@ ++/* ++ * arch/ubicom32/include/asm/checksum.h ++ * Checksum utilities for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_CHECKSUM_H ++#define _ASM_UBICOM32_CHECKSUM_H ++ ++#include ++ ++/* ++ * computes the checksum of a memory block at buff, length len, ++ * and adds in "sum" (32-bit) ++ * ++ * returns a 32-bit number suitable for feeding into itself ++ * or csum_tcpudp_magic ++ * ++ * this function must be called with even lengths, except ++ * for the last fragment, which may be odd ++ * ++ * it's best to have buff aligned on a 32-bit boundary ++ */ ++__wsum csum_partial(const void *buff, int len, __wsum sum); ++ ++/* ++ * the same as csum_partial, but copies from src while it ++ * checksums ++ * ++ * here even more important to align src and dst on a 32-bit (or even ++ * better 64-bit) boundary ++ */ ++ ++__wsum csum_partial_copy_nocheck(const void *src, void *dst, ++ int len, __wsum sum); ++ ++ ++/* ++ * the same as csum_partial_copy, but copies from user space. ++ * ++ * here even more important to align src and dst on a 32-bit (or even ++ * better 64-bit) boundary ++ */ ++ ++extern __wsum csum_partial_copy_from_user(const void __user *src, ++ void *dst, int len, __wsum sum, int *csum_err); ++ ++__sum16 ip_fast_csum(const void *iph, unsigned int ihl); ++ ++/* ++ * Fold a partial checksum ++ */ ++ ++static inline __sum16 csum_fold(__wsum sum) ++{ ++ asm volatile ( ++ " lsr.4 d15, %0, #16 \n\t" ++ " bfextu %0, %0, #16 \n\t" ++ " add.4 %0, d15, %0 \n\t" ++ " lsr.4 d15, %0, #16 \n\t" ++ " bfextu %0, %0, #16 \n\t" ++ " add.4 %0, d15, %0 \n\t" ++ : "=&d" (sum) ++ : "0"(sum) ++ : "d15" ++ ); ++ return (__force __sum16)~sum; ++} ++ ++ ++/* ++ * computes the checksum of the TCP/UDP pseudo-header ++ * returns a 16-bit checksum, already complemented ++ */ ++ ++static inline __wsum ++csum_tcpudp_nofold(__be32 saddr, __be32 daddr, unsigned short len, ++ unsigned short proto, __wsum sum) ++{ ++ asm volatile ( ++ " add.4 %0, %2, %0 \n\t" ++ " addc %0, %3, %0 \n\t" ++ " addc %0, %4, %0 \n\t" ++ " addc %0, %5, %0 \n\t" ++ " addc %0, #0, %0 \n\t" ++ : "=&d" (sum) ++ : "0"(sum), "r" (saddr), "r" (daddr), "r" (len), "r"(proto) ++ ); ++ return sum; ++} ++ ++static inline __sum16 ++csum_tcpudp_magic(__be32 saddr, __be32 daddr, unsigned short len, ++ unsigned short proto, __wsum sum) ++{ ++ return csum_fold(csum_tcpudp_nofold(saddr,daddr,len,proto,sum)); ++} ++ ++/* ++ * this routine is used for miscellaneous IP-like checksums, mainly ++ * in icmp.c ++ */ ++extern __sum16 ip_compute_csum(const void *buff, int len); ++ ++#define _HAVE_ARCH_IPV6_CSUM ++ ++static __inline__ __sum16 ++csum_ipv6_magic(const struct in6_addr *saddr, const struct in6_addr *daddr, ++ __u32 len, unsigned short proto, __wsum sum) ++{ ++ asm volatile ( ++ " add.4 %0, 0(%2), %0 \n\t" ++ " addc %0, 4(%2), %0 \n\t" ++ " addc %0, 8(%2), %0 \n\t" ++ " addc %0, 12(%2), %0 \n\t" ++ " addc %0, 0(%3), %0 \n\t" ++ " addc %0, 4(%3), %0 \n\t" ++ " addc %0, 8(%3), %0 \n\t" ++ " addc %0, 12(%3), %0 \n\t" ++ " addc %0, %4, %0 \n\t" ++ " addc %0, #0, %0 \n\t" ++ : "=&d" (sum) ++ : "0" (sum), "a" (saddr), "a" (daddr), "d" (len + proto) ++ ); ++ return csum_fold(sum); ++} ++ ++#endif /* _ASM_UBICOM32_CHECKSUM_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/cpu.h linux-2.6.28.10/arch/ubicom32/include/asm/cpu.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/cpu.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/cpu.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,45 @@ ++/* ++ * arch/ubicom32/include/asm/cpu.h ++ * CPU definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * Copyright (C) 2004-2005 ARM Ltd. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_CPU_H ++#define _ASM_UBICOM32_CPU_H ++ ++#include ++ ++struct cpuinfo_ubicom32 { ++ unsigned long tid; /* Hardware thread number */ ++ ++#ifdef CONFIG_SMP ++ volatile unsigned long ipi_pending; /* Bit map of operations to execute */ ++ unsigned long ipi_count; /* Number of IPI(s) taken on this cpu */ ++#endif ++}; ++ ++DECLARE_PER_CPU(struct cpuinfo_ubicom32, cpu_data); ++ ++#endif /* _ASM_UBICOM32_CPU_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/cputime.h linux-2.6.28.10/arch/ubicom32/include/asm/cputime.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/cputime.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/cputime.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/cputime.h ++ * Generic cputime.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_CPUTIME_H ++#define _ASM_UBICOM32_CPUTIME_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_CPUTIME_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/current.h linux-2.6.28.10/arch/ubicom32/include/asm/current.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/current.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/current.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,44 @@ ++/* ++ * arch/ubicom32/include/asm/current.h ++ * Definition of get_current() for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * (C) Copyright 2000, Lineo, David McCullough ++ * (C) Copyright 2002, Greg Ungerer (gerg@snapgear.com) ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_CURRENT_H ++#define _ASM_UBICOM32_CURRENT_H ++ ++#include ++ ++struct task_struct; ++ ++static inline struct task_struct *get_current(void) ++{ ++ return(current_thread_info()->task); ++} ++ ++#define current get_current() ++ ++#endif /* _ASM_UBICOM32_CURRENT_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/delay.h linux-2.6.28.10/arch/ubicom32/include/asm/delay.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/delay.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/delay.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,75 @@ ++/* ++ * arch/ubicom32/include/asm/delay.h ++ * Definition of delay routines for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_DELAY_H ++#define _ASM_UBICOM32_DELAY_H ++ ++#include ++#include ++ ++static inline void __delay(unsigned long loops) ++{ ++ if (loops == 0) { ++ return; ++ } ++ ++ asm volatile ( ++ "1: add.4 %0, #-1, %0 \n\t" ++ " jmpne.t 1b \n\t" ++ : "+d" (loops) ++ ); ++} ++ ++/* ++ * Ubicom32 processor uses fixed 12MHz external OSC. ++ * So we use that as reference to count 12 cycles/us ++ */ ++ ++extern unsigned long loops_per_jiffy; ++ ++static inline void _udelay(unsigned long usecs) ++{ ++#if defined(CONFIG_UBICOM32_V4) || defined(CONFIG_UBICOM32_V3) ++ asm volatile ( ++ " add.4 d15, 0(%0), %1 \n\t" ++ " sub.4 #0, 0(%0), d15 \n\t" ++ " jmpmi.w.f .-4 \n\t" ++ : ++ : "a"(TIMER_BASE + TIMER_MPTVAL), "d"(usecs * (12000000/1000000)) ++ : "d15" ++ ); ++#else ++ BUG(); ++#endif ++} ++ ++/* ++ * Moved the udelay() function into library code, no longer inlined. ++ */ ++extern void udelay(unsigned long usecs); ++ ++#endif /* _ASM_UBICOM32_DELAY_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/device.h linux-2.6.28.10/arch/ubicom32/include/asm/device.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/device.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/device.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,35 @@ ++/* ++ * arch/ubicom32/include/asm/device.h ++ * Generic device.h for Ubicom32 architecture. ++ * ++ * Used for arch specific extensions to struct device ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_DEVICE_H ++#define _ASM_UBICOM32_DEVICE_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_DEVICE_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/devtree.h linux-2.6.28.10/arch/ubicom32/include/asm/devtree.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/devtree.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/devtree.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,52 @@ ++/* ++ * arch/ubicom32/include/asm/devtree.h ++ * Device Tree Header File (Shared between ultra and the Host OS) ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_DEVTREE_H ++#define _ASM_UBICOM32_DEVTREE_H ++ ++#define DEVTREE_MAX_NAME 32 ++#define DEVTREE_IRQ_NONE 0xff ++#define DEVTREE_IRQ_DONTCARE 0xff ++#define DEVTREE_NODE_MAGIC 0x10203040 ++ ++struct devtree_node { ++ struct devtree_node *next; ++ unsigned char sendirq; ++ unsigned char recvirq; ++ char name[DEVTREE_MAX_NAME]; ++ unsigned int magic; ++}; ++ ++extern struct devtree_node *devtree; ++extern struct devtree_node *devtree_find_by_irq(uint8_t sendirq, uint8_t recvirq); ++extern struct devtree_node *devtree_find_node(const char *str); ++extern struct devtree_node *devtree_find_next(struct devtree_node **cur); ++extern int devtree_irq(struct devtree_node *dn, unsigned char *sendirq, unsigned char *recvirq); ++extern void devtree_print(void); ++ ++#endif /* _ASM_UBICOM32_DEVTREE_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/div64.h linux-2.6.28.10/arch/ubicom32/include/asm/div64.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/div64.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/div64.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/div64.h ++ * Generic div64.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_DIV64_H ++#define _ASM_UBICOM32_DIV64_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_DIV64_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/dma.h linux-2.6.28.10/arch/ubicom32/include/asm/dma.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/dma.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/dma.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,34 @@ ++/* ++ * arch/ubicom32/include/asm/dma.h ++ * DMA definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_DMA_H ++#define _ASM_UBICOM32_DMA_H ++ ++/* Nothing so far */ ++#define MAX_DMA_ADDRESS 0x00 /* This is quite suspicious */ ++ ++#endif /* _ASM_UBICOM32_DMA_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/dma-mapping.h linux-2.6.28.10/arch/ubicom32/include/asm/dma-mapping.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/dma-mapping.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/dma-mapping.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,34 @@ ++/* ++ * arch/ubicom32/include/asm/dma-mapping.h ++ * Generic dma-mapping.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_DMA_MAPPING_H ++#define _ASM_UBICOM32_DMA_MAPPING_H ++ ++#include ++#include ++ ++#endif /* _ASM_UBICOM32_DMA_MAPPING_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/elf.h linux-2.6.28.10/arch/ubicom32/include/asm/elf.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/elf.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/elf.h 2009-08-18 22:35:42.571202890 +0300 +@@ -0,0 +1,167 @@ ++/* ++ * arch/ubicom32/include/asm/elf.h ++ * Definitions for elf executable format for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_ELF_H ++#define _ASM_UBICOM32_ELF_H ++ ++/* ++ * ELF register definitions.. ++ */ ++ ++#include ++#include ++ ++/* ++ * Processor specific flags for the ELF header e_flags field. ++ */ ++#define EF_UBICOM32_V3 0x00000001 /* -fmarch=ubicom32v3 */ ++#define EF_UBICOM32_V4 0x00000002 /* -fmarch=ubicom32v4 */ ++#define EF_UBICOM32_PIC 0x80000000 /* -fpic */ ++#define EF_UBICOM32_FDPIC 0x40000000 /* -mfdpic */ ++ ++/* ++ * Ubicom32 ELF relocation types ++ */ ++#define R_UBICOM32_NONE 0 ++#define R_UBICOM32_16 1 ++#define R_UBICOM32_32 2 ++#define R_UBICOM32_LO16 3 ++#define R_UBICOM32_HI16 4 ++#define R_UBICOM32_21_PCREL 5 ++#define R_UBICOM32_24_PCREL 6 ++#define R_UBICOM32_HI24 7 ++#define R_UBICOM32_LO7_S 8 ++#define R_UBICOM32_LO7_2_S 9 ++#define R_UBICOM32_LO7_4_S 10 ++#define R_UBICOM32_LO7_D 11 ++#define R_UBICOM32_LO7_2_D 12 ++#define R_UBICOM32_LO7_4_D 13 ++#define R_UBICOM32_32_HARVARD 14 ++#define R_UBICOM32_LO7_CALLI 15 ++#define R_UBICOM32_LO16_CALLI 16 ++#define R_UBICOM32_GOT_HI24 17 ++#define R_UBICOM32_GOT_LO7_S 18 ++#define R_UBICOM32_GOT_LO7_2_S 19 ++#define R_UBICOM32_GOT_LO7_4_S 20 ++#define R_UBICOM32_GOT_LO7_D 21 ++#define R_UBICOM32_GOT_LO7_2_D 22 ++#define R_UBICOM32_GOT_LO7_4_D 23 ++#define R_UBICOM32_FUNCDESC_GOT_HI24 24 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_S 25 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_2_S 26 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_4_S 27 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_D 28 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_2_D 29 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_4_D 30 ++#define R_UBICOM32_GOT_LO7_CALLI 31 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_CALLI 32 ++#define R_UBICOM32_FUNCDESC_VALUE 33 ++#define R_UBICOM32_FUNCDESC 34 ++#define R_UBICOM32_GOTOFFSET_LO 35 ++#define R_UBICOM32_GOTOFFSET_HI 36 ++#define R_UBICOM32_FUNCDESC_GOTOFFSET_LO 37 ++#define R_UBICOM32_FUNCDESC_GOTOFFSET_HI 38 ++#define R_UBICOM32_GNU_VTINHERIT 200 ++#define R_UBICOM32_GNU_VTENTRY 201 ++ ++typedef unsigned long elf_greg_t; ++ ++#define ELF_NGREG (sizeof(struct pt_regs) / sizeof(elf_greg_t)) ++typedef elf_greg_t elf_gregset_t[ELF_NGREG]; ++ ++typedef struct user_ubicom32fp_struct elf_fpregset_t; ++ ++/* ++ * This is used to ensure we don't load something for the wrong architecture. ++ */ ++#define elf_check_arch(x) ((x)->e_machine == EM_UBICOM32) ++ ++#define elf_check_fdpic(x) ((x)->e_flags & EF_UBICOM32_FDPIC) ++ ++#define elf_check_const_displacement(x) ((x)->e_flags & EF_UBICOM32_PIC) ++ ++/* ++ * These are used to set parameters in the core dumps. ++ */ ++#define ELF_CLASS ELFCLASS32 ++#define ELF_DATA ELFDATA2MSB ++#define ELF_ARCH EM_UBICOM32 ++ ++/* For SVR4/m68k the function pointer to be registered with `atexit' is ++ passed in %a1. Although my copy of the ABI has no such statement, it ++ is actually used on ASV. */ ++#define ELF_PLAT_INIT(_r, load_addr) _r->a1 = 0 ++ ++#define ELF_FDPIC_PLAT_INIT(_regs, _exec_map_addr, _interp_map_addr, \ ++ _dynamic_addr) \ ++ do { \ ++ _regs->dn[1] = _exec_map_addr; \ ++ _regs->dn[2] = _interp_map_addr; \ ++ _regs->dn[3] = _dynamic_addr; \ ++ _regs->an[1] = 0; /* dl_fini will be set by ldso */ \ ++ } while (0) ++ ++#define USE_ELF_CORE_DUMP ++#define ELF_EXEC_PAGESIZE 4096 ++ ++#ifdef __KERNEL__ ++#ifdef CONFIG_UBICOM32_V4 ++#define ELF_FDPIC_CORE_EFLAGS (EF_UBICOM32_FDPIC | EF_UBICOM32_V4) ++#elif defined CONFIG_UBICOM32_V3 ++#define ELF_FDPIC_CORE_EFLAGS (EF_UBICOM32_FDPIC | EF_UBICOM32_V3) ++#else ++#error Unknown/Unsupported ubicom32 architecture. ++#endif ++#endif ++ ++/* This is the location that an ET_DYN program is loaded if exec'ed. Typical ++ use of this is to invoke "./ld.so someprog" to test out a new version of ++ the loader. We need to make sure that it is out of the way of the program ++ that it will "exec", and that there is sufficient room for the brk. */ ++ ++#define ELF_ET_DYN_BASE 0xD0000000UL ++ ++/* ++ * For Ubicom32, the elf_gregset_t and struct pt_regs are the same size ++ * data structure so a copy is performed instead of providing the ++ * ELF_CORE_COPY_REGS macro. ++ */ ++ ++/* This yields a mask that user programs can use to figure out what ++ instruction set this cpu supports. */ ++ ++#define ELF_HWCAP (0) ++ ++/* This yields a string that ld.so will use to load implementation ++ specific libraries for optimization. This is more specific in ++ intent than poking at uname or /proc/cpuinfo. */ ++ ++#define ELF_PLATFORM (NULL) ++ ++#define SET_PERSONALITY(ex, ibcs2) set_personality((ibcs2)?PER_SVR4:PER_LINUX) ++ ++#endif /* _ASM_UBICOM32_ELF_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/emergency-restart.h linux-2.6.28.10/arch/ubicom32/include/asm/emergency-restart.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/emergency-restart.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/emergency-restart.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/emergency-restart.h ++ * Generic emergency-restart.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_EMERGENCY_RESTART_H ++#define _ASM_UBICOM32_EMERGENCY_RESTART_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_EMERGENCY_RESTART_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/entry.h linux-2.6.28.10/arch/ubicom32/include/asm/entry.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/entry.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/entry.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,34 @@ ++/* ++ * arch/ubicom32/include/asm/entry.h ++ * Entry register/stack definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_ENTRY_H ++#define _ASM_UBICOM32_ENTRY_H ++ ++#include ++#include ++ ++#endif /* _ASM_UBICOM32_ENTRY_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/errno.h linux-2.6.28.10/arch/ubicom32/include/asm/errno.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/errno.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/errno.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/errno.h ++ * Generic errno.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_ERRNO_H ++#define _ASM_UBICOM32_ERRNO_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_ERRNO_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/fb.h linux-2.6.28.10/arch/ubicom32/include/asm/fb.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/fb.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/fb.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,39 @@ ++/* ++ * arch/ubicom32/include/asm/fb.h ++ * Definition of fb_is_primary_device() for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_FB_H ++#define _ASM_UBICOM32_FB_H ++#include ++ ++#define fb_pgprotect(...) do {} while (0) ++ ++static inline int fb_is_primary_device(struct fb_info *info) ++{ ++ return 0; ++} ++ ++#endif /* _ASM_UBICOM32_FB_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/fcntl.h linux-2.6.28.10/arch/ubicom32/include/asm/fcntl.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/fcntl.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/fcntl.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,38 @@ ++/* ++ * arch/ubicom32/include/asm/fcntl.h ++ * File control bit definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_FCNTL_H ++#define _ASM_UBICOM32_FCNTL_H ++ ++#define O_DIRECTORY 040000 /* must be a directory */ ++#define O_NOFOLLOW 0100000 /* don't follow links */ ++#define O_DIRECT 0200000 /* direct disk access hint - currently ignored */ ++#define O_LARGEFILE 0400000 ++ ++#include ++ ++#endif /* _ASM_UBICOM32_FCNTL_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/flat.h linux-2.6.28.10/arch/ubicom32/include/asm/flat.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/flat.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/flat.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,73 @@ ++/* ++ * arch/ubicom32/include/asm/flat.h ++ * Definitions to support flat-format executables. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_FLAT_H ++#define _ASM_UBICOM32_FLAT_H ++ ++#define ARCH_FLAT_ALIGN 0x80 ++#define ARCH_FLAT_ALIGN_TEXT 1 ++ ++#define R_UBICOM32_32 2 ++#define R_UBICOM32_HI24 7 ++#define R_UBICOM32_LO7_S 8 ++#define R_UBICOM32_LO7_2_S 9 ++#define R_UBICOM32_LO7_4_S 10 ++#define R_UBICOM32_LO7_D 11 ++#define R_UBICOM32_LO7_2_D 12 ++#define R_UBICOM32_LO7_4_D 13 ++#define R_UBICOM32_LO7_CALLI 15 ++#define R_UBICOM32_LO16_CALLI 16 ++ ++extern void ubicom32_flat_put_addr_at_rp(unsigned long *rp, u32_t val, u32_t rval, unsigned long *p); ++extern unsigned long ubicom32_flat_get_addr_from_rp(unsigned long *rp, u32_t relval, u32_t flags, unsigned long *p); ++ ++#define flat_stack_align(sp) /* nothing needed */ ++#define flat_argvp_envp_on_stack() 1 ++#define flat_old_ram_flag(flags) (flags) ++#define flat_reloc_valid(reloc, size) ((reloc) <= (size)) ++#define flat_get_addr_from_rp(rp, relval, flags, p) (ubicom32_flat_get_addr_from_rp(rp, relval,flags, p)) ++#define flat_put_addr_at_rp(rp, val, relval) do {ubicom32_flat_put_addr_at_rp(rp, val, relval, &persistent);} while(0) ++#define flat_get_relocate_addr(rel) ((persistent) ? (persistent & 0x07ffffff) : (rel & 0x07ffffff)) ++ ++static inline int flat_set_persistent(unsigned int relval, unsigned long *p) ++{ ++ if (*p) { ++ return 0; ++ } else { ++ if ((relval >> 27) != R_UBICOM32_32) { ++ /* ++ * Something other than UBICOM32_32. The next entry has the relocation. ++ */ ++ *p = relval; ++ return 1; ++ } ++ } ++ return 0; ++} ++ ++#endif /* _ASM_UBICOM32_FLAT_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/fpu.h linux-2.6.28.10/arch/ubicom32/include/asm/fpu.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/fpu.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/fpu.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,37 @@ ++/* ++ * arch/ubicom32/include/asm/fpu.h ++ * Floating point state definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_FPU_H ++#define _ASM_UBICOM32_FPU_H ++ ++/* ++ * MAX floating point unit state size (FSAVE/FRESTORE) ++ */ ++/* No FP unit present then... */ ++#define FPSTATESIZE (2) /* dummy size */ ++ ++#endif /* _ASM_UBICOM32_FPU_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/futex.h linux-2.6.28.10/arch/ubicom32/include/asm/futex.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/futex.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/futex.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/futex.h ++ * Generic futex.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_FUTEX_H ++#define _ASM_UBICOM32_FUTEX_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_FUTEX_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/gpio.h linux-2.6.28.10/arch/ubicom32/include/asm/gpio.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/gpio.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/gpio.h 2009-08-12 13:08:37.000000000 +0300 +@@ -0,0 +1,451 @@ ++/* ++ * arch/ubicom32/include/asm/gpio.h ++ * Definitions for GPIO operations on Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_GPIO_H ++#define _ASM_UBICOM32_GPIO_H ++ ++#include ++#include ++ ++#include ++ ++#define ARCH_NR_GPIOS 512 ++#define MAX_UBICOM_ONCHIP_GPIO (9 * 32) ++ ++/* ++ * Macros for manipulating GPIO numbers ++ */ ++#define gpio_bit(gn) (1 << (gn & 0x1f)) ++#define gpio_bank(gn) (gn >> 5) ++ ++#define gpio_pin_index(gn) (gn & 0x1f) ++#define gpio_port_index(gn) (gn >> 5) ++ ++#define GPIO_RA_0 ((32 * 0) + 0) ++#define GPIO_RA_1 ((32 * 0) + 1) ++#define GPIO_RA_2 ((32 * 0) + 2) ++#define GPIO_RA_3 ((32 * 0) + 3) ++#define GPIO_RA_4 ((32 * 0) + 4) ++#define GPIO_RA_5 ((32 * 0) + 5) ++#define GPIO_RA_6 ((32 * 0) + 6) ++#define GPIO_RA_7 ((32 * 0) + 7) ++ ++#define GPIO_RB_0 ((32 * 1) + 0) ++#define GPIO_RB_1 ((32 * 1) + 1) ++#define GPIO_RB_2 ((32 * 1) + 2) ++#define GPIO_RB_3 ((32 * 1) + 3) ++#define GPIO_RB_4 ((32 * 1) + 4) ++#define GPIO_RB_5 ((32 * 1) + 5) ++#define GPIO_RB_6 ((32 * 1) + 6) ++#define GPIO_RB_7 ((32 * 1) + 7) ++#define GPIO_RB_8 ((32 * 1) + 8) ++#define GPIO_RB_9 ((32 * 1) + 9) ++#define GPIO_RB_10 ((32 * 1) + 10) ++#define GPIO_RB_11 ((32 * 1) + 11) ++#define GPIO_RB_12 ((32 * 1) + 12) ++#define GPIO_RB_13 ((32 * 1) + 13) ++#define GPIO_RB_14 ((32 * 1) + 14) ++#define GPIO_RB_15 ((32 * 1) + 15) ++#define GPIO_RB_16 ((32 * 1) + 16) ++#define GPIO_RB_17 ((32 * 1) + 17) ++#define GPIO_RB_18 ((32 * 1) + 18) ++#define GPIO_RB_19 ((32 * 1) + 19) ++ ++#define GPIO_RC_0 ((32 * 2) + 0) ++#define GPIO_RC_1 ((32 * 2) + 1) ++#define GPIO_RC_2 ((32 * 2) + 2) ++#define GPIO_RC_3 ((32 * 2) + 3) ++#define GPIO_RC_4 ((32 * 2) + 4) ++#define GPIO_RC_5 ((32 * 2) + 5) ++#define GPIO_RC_6 ((32 * 2) + 6) ++#define GPIO_RC_7 ((32 * 2) + 7) ++#define GPIO_RC_8 ((32 * 2) + 8) ++#define GPIO_RC_9 ((32 * 2) + 9) ++#define GPIO_RC_10 ((32 * 2) + 10) ++#define GPIO_RC_11 ((32 * 2) + 11) ++#define GPIO_RC_12 ((32 * 2) + 12) ++#define GPIO_RC_13 ((32 * 2) + 13) ++#define GPIO_RC_14 ((32 * 2) + 14) ++#define GPIO_RC_15 ((32 * 2) + 15) ++#define GPIO_RC_16 ((32 * 2) + 16) ++#define GPIO_RC_17 ((32 * 2) + 17) ++#define GPIO_RC_18 ((32 * 2) + 18) ++#define GPIO_RC_19 ((32 * 2) + 19) ++#define GPIO_RC_20 ((32 * 2) + 20) ++#define GPIO_RC_21 ((32 * 2) + 21) ++#define GPIO_RC_22 ((32 * 2) + 22) ++#define GPIO_RC_23 ((32 * 2) + 23) ++#define GPIO_RC_24 ((32 * 2) + 24) ++#define GPIO_RC_25 ((32 * 2) + 25) ++#define GPIO_RC_26 ((32 * 2) + 26) ++#define GPIO_RC_27 ((32 * 2) + 27) ++#define GPIO_RC_28 ((32 * 2) + 28) ++#define GPIO_RC_29 ((32 * 2) + 29) ++#define GPIO_RC_30 ((32 * 2) + 30) ++#define GPIO_RC_31 ((32 * 2) + 31) ++ ++#define GPIO_RD_0 ((32 * 3) + 0) ++#define GPIO_RD_1 ((32 * 3) + 1) ++#define GPIO_RD_2 ((32 * 3) + 2) ++#define GPIO_RD_3 ((32 * 3) + 3) ++#define GPIO_RD_4 ((32 * 3) + 4) ++#define GPIO_RD_5 ((32 * 3) + 5) ++#define GPIO_RD_6 ((32 * 3) + 6) ++#define GPIO_RD_7 ((32 * 3) + 7) ++#define GPIO_RD_8 ((32 * 3) + 8) ++#define GPIO_RD_9 ((32 * 3) + 9) ++#define GPIO_RD_10 ((32 * 3) + 10) ++#define GPIO_RD_11 ((32 * 3) + 11) ++ ++#define GPIO_RE_0 ((32 * 4) + 0) ++#define GPIO_RE_1 ((32 * 4) + 1) ++#define GPIO_RE_2 ((32 * 4) + 2) ++#define GPIO_RE_3 ((32 * 4) + 3) ++#define GPIO_RE_4 ((32 * 4) + 4) ++#define GPIO_RE_5 ((32 * 4) + 5) ++#define GPIO_RE_6 ((32 * 4) + 6) ++#define GPIO_RE_7 ((32 * 4) + 7) ++ ++#define GPIO_RF_0 ((32 * 5) + 0) ++#define GPIO_RF_1 ((32 * 5) + 1) ++#define GPIO_RF_2 ((32 * 5) + 2) ++#define GPIO_RF_3 ((32 * 5) + 3) ++#define GPIO_RF_4 ((32 * 5) + 4) ++#define GPIO_RF_5 ((32 * 5) + 5) ++#define GPIO_RF_6 ((32 * 5) + 6) ++#define GPIO_RF_7 ((32 * 5) + 7) ++#define GPIO_RF_8 ((32 * 5) + 8) ++#define GPIO_RF_9 ((32 * 5) + 9) ++#define GPIO_RF_10 ((32 * 5) + 10) ++#define GPIO_RF_11 ((32 * 5) + 11) ++#define GPIO_RF_12 ((32 * 5) + 12) ++#define GPIO_RF_13 ((32 * 5) + 13) ++#define GPIO_RF_14 ((32 * 5) + 14) ++#define GPIO_RF_15 ((32 * 5) + 15) ++ ++#define GPIO_RG_0 ((32 * 6) + 0) ++#define GPIO_RG_1 ((32 * 6) + 1) ++#define GPIO_RG_2 ((32 * 6) + 2) ++#define GPIO_RG_3 ((32 * 6) + 3) ++#define GPIO_RG_4 ((32 * 6) + 4) ++#define GPIO_RG_5 ((32 * 6) + 5) ++#define GPIO_RG_6 ((32 * 6) + 6) ++#define GPIO_RG_7 ((32 * 6) + 7) ++#define GPIO_RG_8 ((32 * 6) + 8) ++#define GPIO_RG_9 ((32 * 6) + 9) ++#define GPIO_RG_10 ((32 * 6) + 10) ++#define GPIO_RG_11 ((32 * 6) + 11) ++#define GPIO_RG_12 ((32 * 6) + 12) ++#define GPIO_RG_13 ((32 * 6) + 13) ++#define GPIO_RG_14 ((32 * 6) + 14) ++#define GPIO_RG_15 ((32 * 6) + 15) ++#define GPIO_RG_16 ((32 * 6) + 16) ++#define GPIO_RG_17 ((32 * 6) + 17) ++#define GPIO_RG_18 ((32 * 6) + 18) ++#define GPIO_RG_19 ((32 * 6) + 19) ++#define GPIO_RG_20 ((32 * 6) + 20) ++#define GPIO_RG_21 ((32 * 6) + 21) ++#define GPIO_RG_22 ((32 * 6) + 22) ++#define GPIO_RG_23 ((32 * 6) + 23) ++#define GPIO_RG_24 ((32 * 6) + 24) ++#define GPIO_RG_25 ((32 * 6) + 25) ++#define GPIO_RG_26 ((32 * 6) + 26) ++#define GPIO_RG_27 ((32 * 6) + 27) ++#define GPIO_RG_28 ((32 * 6) + 28) ++#define GPIO_RG_29 ((32 * 6) + 29) ++#define GPIO_RG_30 ((32 * 6) + 30) ++#define GPIO_RG_31 ((32 * 6) + 31) ++ ++#define GPIO_RH_0 ((32 * 7) + 0) ++#define GPIO_RH_1 ((32 * 7) + 1) ++#define GPIO_RH_2 ((32 * 7) + 2) ++#define GPIO_RH_3 ((32 * 7) + 3) ++#define GPIO_RH_4 ((32 * 7) + 4) ++#define GPIO_RH_5 ((32 * 7) + 5) ++#define GPIO_RH_6 ((32 * 7) + 6) ++#define GPIO_RH_7 ((32 * 7) + 7) ++#define GPIO_RH_8 ((32 * 7) + 8) ++#define GPIO_RH_9 ((32 * 7) + 9) ++ ++#define GPIO_RI_0 ((32 * 8) + 0) ++#define GPIO_RI_1 ((32 * 8) + 1) ++#define GPIO_RI_2 ((32 * 8) + 2) ++#define GPIO_RI_3 ((32 * 8) + 3) ++#define GPIO_RI_4 ((32 * 8) + 4) ++#define GPIO_RI_5 ((32 * 8) + 5) ++#define GPIO_RI_6 ((32 * 8) + 6) ++#define GPIO_RI_7 ((32 * 8) + 7) ++#define GPIO_RI_8 ((32 * 8) + 8) ++#define GPIO_RI_9 ((32 * 8) + 9) ++#define GPIO_RI_10 ((32 * 8) + 10) ++#define GPIO_RI_11 ((32 * 8) + 11) ++#define GPIO_RI_12 ((32 * 8) + 12) ++#define GPIO_RI_13 ((32 * 8) + 13) ++ ++/* ++ * The following section defines extra GPIO available to some boards. ++ * These GPIO are generally external to the processor (i.e. SPI/I2C ++ * expander chips). ++ * ++ * Note that these defines show all possible GPIO available, however, ++ * depending on the actual board configuration, some GPIO are not ++ * available for use. ++ */ ++#ifdef CONFIG_IP7500MEDIA ++/* ++ * U15 ++ */ ++#define IP7500MEDIA_U15_BASE (32 * 10) ++#define IP7500MEDIA_IO0 (IP7500MEDIA_U15_BASE + 0) ++#define IP7500MEDIA_IO1 (IP7500MEDIA_U15_BASE + 1) ++#define IP7500MEDIA_IO2 (IP7500MEDIA_U15_BASE + 2) ++#define IP7500MEDIA_IO3 (IP7500MEDIA_U15_BASE + 3) ++#define IP7500MEDIA_IO4 (IP7500MEDIA_U15_BASE + 4) ++#define IP7500MEDIA_IO5 (IP7500MEDIA_U15_BASE + 5) ++#define IP7500MEDIA_IO6 (IP7500MEDIA_U15_BASE + 6) ++#define IP7500MEDIA_IO7 (IP7500MEDIA_U15_BASE + 7) ++ ++/* ++ * U16 ++ */ ++#define IP7500MEDIA_U16_BASE (32 * 11) ++#define IP7500MEDIA_IO8 (IP7500MEDIA_U16_BASE + 0) ++#define IP7500MEDIA_IO9 (IP7500MEDIA_U16_BASE + 1) ++#define IP7500MEDIA_IO10 (IP7500MEDIA_U16_BASE + 2) ++#define IP7500MEDIA_IO11 (IP7500MEDIA_U16_BASE + 3) ++#define IP7500MEDIA_IO12 (IP7500MEDIA_U16_BASE + 4) ++#define IP7500MEDIA_IO13 (IP7500MEDIA_U16_BASE + 5) ++#define IP7500MEDIA_IO14 (IP7500MEDIA_U16_BASE + 6) ++#define IP7500MEDIA_IO15 (IP7500MEDIA_U16_BASE + 7) ++ ++/* ++ * U17 ++ */ ++#define IP7500MEDIA_U17_BASE (32 * 12) ++#define IP7500MEDIA_IO16 (IP7500MEDIA_U17_BASE + 0) ++#define IP7500MEDIA_IO17 (IP7500MEDIA_U17_BASE + 1) ++#define IP7500MEDIA_IO18 (IP7500MEDIA_U17_BASE + 2) ++#define IP7500MEDIA_IO19 (IP7500MEDIA_U17_BASE + 3) ++#define IP7500MEDIA_IO20 (IP7500MEDIA_U17_BASE + 4) ++#define IP7500MEDIA_IO21 (IP7500MEDIA_U17_BASE + 5) ++#define IP7500MEDIA_IO22 (IP7500MEDIA_U17_BASE + 6) ++#define IP7500MEDIA_IO23 (IP7500MEDIA_U17_BASE + 7) ++ ++/* ++ * U18 ++ */ ++#define IP7500MEDIA_U18_BASE (32 * 13) ++#define IP7500MEDIA_IO24 (IP7500MEDIA_U18_BASE + 0) ++#define IP7500MEDIA_IO25 (IP7500MEDIA_U18_BASE + 1) ++#define IP7500MEDIA_IO26 (IP7500MEDIA_U18_BASE + 2) ++#define IP7500MEDIA_IO27 (IP7500MEDIA_U18_BASE + 3) ++#define IP7500MEDIA_IO28 (IP7500MEDIA_U18_BASE + 4) ++#define IP7500MEDIA_IO29 (IP7500MEDIA_U18_BASE + 5) ++#define IP7500MEDIA_IO30 (IP7500MEDIA_U18_BASE + 6) ++#define IP7500MEDIA_IO31 (IP7500MEDIA_U18_BASE + 7) ++#endif ++ ++#ifdef CONFIG_IP7145DPF ++/* ++ * U48 ++ */ ++#define IP7145DPF_U48_BASE (32 * 10) ++#define IP7145DPF_IO0 (IP7145DPF_U48_BASE + 0) ++#define IP7145DPF_IO1 (IP7145DPF_U48_BASE + 1) ++#define IP7145DPF_IO2 (IP7145DPF_U48_BASE + 2) ++#define IP7145DPF_IO3 (IP7145DPF_U48_BASE + 3) ++#define IP7145DPF_IO4 (IP7145DPF_U48_BASE + 4) ++#define IP7145DPF_IO5 (IP7145DPF_U48_BASE + 5) ++#define IP7145DPF_IO6 (IP7145DPF_U48_BASE + 6) ++#define IP7145DPF_IO7 (IP7145DPF_U48_BASE + 7) ++ ++/* ++ * U72 ++ */ ++#define IP7145DPF_U72_BASE (32 * 11) ++#define IP7145DPF_IOB0 (IP7145DPF_U72_BASE + 0) ++#define IP7145DPF_IOB1 (IP7145DPF_U72_BASE + 1) ++#define IP7145DPF_IOB2 (IP7145DPF_U72_BASE + 2) ++#define IP7145DPF_IOB3 (IP7145DPF_U72_BASE + 3) ++#define IP7145DPF_IOB4 (IP7145DPF_U72_BASE + 4) ++#define IP7145DPF_IOB5 (IP7145DPF_U72_BASE + 5) ++#define IP7145DPF_IOB6 (IP7145DPF_U72_BASE + 6) ++#define IP7145DPF_IOB7 (IP7145DPF_U72_BASE + 7) ++#endif ++ ++#include ++ ++/* ++ * The following macros bypass gpiolib to generate direct references ++ * to the port registers. These assume, minimally, that either ++ * gpio_direction_input() or gpio_direction_output() have already been ++ * called to setup the pin direction and to enable the pin function to ++ * be gpio. These macros generate the hardware port address based on ++ * the assumption that all ports are 32 bits wide (even though we know ++ * they are not). This is so we can efficiently turn pin numbers into ++ * port addresses without a lookup. ++ * ++ * These operations must be done in one instruction to prevent clobbering ++ * other thread's accesses to the same port. ++ */ ++#define UBICOM32_GPIO_ENABLE(pin) \ ++ do { \ ++ asm volatile ("or.4 (%[port]), (%[port]), %[mask]\n\t" \ ++ : \ ++ : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_mask), \ ++ [mask] "d" (gpio_bit(pin)) \ ++ : "cc", "memory" \ ++ ); \ ++ } while (0); ++ ++#define UBICOM32_GPIO_DISABLE(pin) \ ++ do { \ ++ asm volatile ("and.4 (%[port]), (%[port]), %[mask]\n\t" \ ++ : \ ++ : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_mask), \ ++ [mask] "d" (~gpio_bit(pin)) \ ++ : "cc", "memory" \ ++ ); \ ++ } while (0); ++ ++#define UBICOM32_GPIO_SET_PIN_INPUT(pin) \ ++ do { \ ++ asm volatile ("and.4 (%[port]), (%[port]), %[mask]\n\t" \ ++ : \ ++ : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_ctl), \ ++ [mask] "d" (~gpio_bit(pin)) \ ++ : "cc", "memory" \ ++ ); \ ++ } while (0); ++ ++#define UBICOM32_GPIO_SET_PIN_OUTPUT(pin) \ ++ do { \ ++ asm volatile ("or.4 (%[port]), (%[port]), %[mask]\n\t" \ ++ : \ ++ : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_ctl), \ ++ [mask] "d" (gpio_bit(pin)) \ ++ : "cc", "memory" \ ++ ); \ ++ } while (0); ++ ++#define UBICOM32_GPIO_SET_PIN_TOGGLE(pin) \ ++ do { \ ++ asm volatile ("xor.4 (%[port]), (%[port]), %[mask]\n\t" \ ++ : \ ++ : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_out), \ ++ [mask] "d" (gpio_bit(pin)) \ ++ : "cc", "memory" \ ++ ); \ ++ } while (0); ++ ++#define UBICOM32_GPIO_SET_PIN_HIGH(pin) \ ++ do { \ ++ asm volatile ("or.4 (%[port]), (%[port]), %[mask]\n\t" \ ++ : \ ++ : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_out), \ ++ [mask] "d" (gpio_bit(pin)) \ ++ : "cc", "memory" \ ++ ); \ ++ } while (0); ++ ++#define UBICOM32_GPIO_SET_PIN_LOW(pin) \ ++ do { \ ++ asm volatile ("and.4 (%[port]), (%[port]), %[mask]\n\t" \ ++ : \ ++ : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_out), \ ++ [mask] "d" (~gpio_bit(pin)) \ ++ : "cc", "memory" \ ++ ); \ ++ } while (0); ++ ++#define UBICOM32_GPIO_SET_PIN(pin, val) \ ++ if ( val ) { \ ++ UBICOM32_GPIO_SET_PIN_HIGH(pin); \ ++ } else { \ ++ UBICOM32_GPIO_SET_PIN_LOW(pin); \ ++ } ++ ++#define UBICOM32_GPIO_GET_PIN(pin) \ ++ (0 != (UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_in \ ++ & gpio_bit(pin))) ++ ++ ++static inline int gpio_get_value(unsigned gpio) ++{ ++ if (gpio <= MAX_UBICOM_ONCHIP_GPIO) ++ return UBICOM32_GPIO_GET_PIN(gpio); ++ else ++ return __gpio_get_value(gpio); ++} ++ ++static inline void gpio_set_value(unsigned gpio, int value) ++{ ++ if (gpio <= MAX_UBICOM_ONCHIP_GPIO) ++ { ++ UBICOM32_GPIO_SET_PIN(gpio, value); ++ } ++ else ++ { ++ __gpio_set_value(gpio, value); ++ } ++} ++ ++static inline int gpio_cansleep(unsigned gpio) ++{ ++ return __gpio_cansleep(gpio); ++} ++ ++static inline int gpio_to_irq(unsigned gpio) ++{ ++#if defined(IP5000) || defined(IP5000_REV2) ++ if ((gpio >= GPIO_RA_4) && (gpio <= GPIO_RA_6)) ++ return 25; ++ else ++ return -ENXIO; ++ ++#elif defined(IP7000) || defined(IP7000_REV2) ++ if ((gpio >= GPIO_RA_4) && (gpio <= GPIO_RA_6)) ++ return 44 + (gpio - GPIO_RA_4); ++ else ++ return -ENXIO; ++ ++#else ++ return -ENXIO; ++ ++#endif ++} ++ ++static inline int irq_to_gpio(unsigned gpio) ++{ ++ return -ENXIO; ++} ++ ++extern struct ubicom32_io_port *ubi_gpio_get_port(unsigned gpio); ++ ++extern int __init ubi_gpio_init(void); ++ ++#endif /* _ASM_UBICOM32_GPIO_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/hardirq.h linux-2.6.28.10/arch/ubicom32/include/asm/hardirq.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/hardirq.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/hardirq.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,55 @@ ++/* ++ * arch/ubicom32/include/asm/hardirq.h ++ * Definition of ack_bad_irq() for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * Copyright (C) 1997, 98, 99, 2000, 01, 05 Ralf Baechle (ralf@linux-mips.org) ++ * Copyright (C) 1999, 2000 Silicon Graphics, Inc. ++ * Copyright (C) 2001 MIPS Technologies, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_HARDIRQ_H ++#define _ASM_UBICOM32_HARDIRQ_H ++ ++#include ++#include ++ ++/* ++ * The hardirq mask has to be large enough to have space ++ * for potentially all IRQ sources in the system nesting ++ * on a single CPU. For Ubicom32, we have 64 IRQ sources. ++ */ ++#define HARDIRQ_BITS 6 ++#if (1 << HARDIRQ_BITS) < NR_IRQS ++# error HARDIRQ_BITS is too low! ++#endif ++ ++typedef struct { ++ unsigned int __softirq_pending; ++} ____cacheline_aligned irq_cpustat_t; ++ ++#include /* Standard mappings for irq_cpustat_t above */ ++ ++extern void ack_bad_irq(unsigned int irq); ++ ++#endif /* _ASM_UBICOM32_HARDIRQ_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/hw_irq.h linux-2.6.28.10/arch/ubicom32/include/asm/hw_irq.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/hw_irq.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/hw_irq.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,31 @@ ++/* ++ * arch/ubicom32/include/asm/hw_irq.h ++ * Ubicom32 architecture APIC support. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_HW_IRQ_H ++#define _ASM_UBICOM32_HW_IRQ_H ++ ++#endif /* _ASM_UBICOM32_HW_IRQ_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ioctl.h linux-2.6.28.10/arch/ubicom32/include/asm/ioctl.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ioctl.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ioctl.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/ioctl.h ++ * Generic ioctl.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_IOCTL_H ++#define _ASM_UBICOM32_IOCTL_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_IOCTL_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ioctls.h linux-2.6.28.10/arch/ubicom32/include/asm/ioctls.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ioctls.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ioctls.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,111 @@ ++/* ++ * arch/ubicom32/include/asm/ioctls.h ++ * Definitions of ioctls for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_IOCTLS_H ++#define _ASM_UBICOM32_IOCTLS_H ++ ++#include ++ ++/* 0x54 is just a magic number to make these relatively unique ('T') */ ++ ++#define TCGETS 0x5401 ++#define TCSETS 0x5402 ++#define TCSETSW 0x5403 ++#define TCSETSF 0x5404 ++#define TCGETA 0x5405 ++#define TCSETA 0x5406 ++#define TCSETAW 0x5407 ++#define TCSETAF 0x5408 ++#define TCSBRK 0x5409 ++#define TCXONC 0x540A ++#define TCFLSH 0x540B ++#define TIOCEXCL 0x540C ++#define TIOCNXCL 0x540D ++#define TIOCSCTTY 0x540E ++#define TIOCGPGRP 0x540F ++#define TIOCSPGRP 0x5410 ++#define TIOCOUTQ 0x5411 ++#define TIOCSTI 0x5412 ++#define TIOCGWINSZ 0x5413 ++#define TIOCSWINSZ 0x5414 ++#define TIOCMGET 0x5415 ++#define TIOCMBIS 0x5416 ++#define TIOCMBIC 0x5417 ++#define TIOCMSET 0x5418 ++#define TIOCGSOFTCAR 0x5419 ++#define TIOCSSOFTCAR 0x541A ++#define FIONREAD 0x541B ++#define TIOCINQ FIONREAD ++#define TIOCLINUX 0x541C ++#define TIOCCONS 0x541D ++#define TIOCGSERIAL 0x541E ++#define TIOCSSERIAL 0x541F ++#define TIOCPKT 0x5420 ++#define FIONBIO 0x5421 ++#define TIOCNOTTY 0x5422 ++#define TIOCSETD 0x5423 ++#define TIOCGETD 0x5424 ++#define TCSBRKP 0x5425 /* Needed for POSIX tcsendbreak() */ ++#define TIOCSBRK 0x5427 /* BSD compatibility */ ++#define TIOCCBRK 0x5428 /* BSD compatibility */ ++#define TIOCGSID 0x5429 /* Return the session ID of FD */ ++#define TCGETS2 _IOR('T',0x2A, struct termios2) ++#define TCSETS2 _IOW('T',0x2B, struct termios2) ++#define TCSETSW2 _IOW('T',0x2C, struct termios2) ++#define TCSETSF2 _IOW('T',0x2D, struct termios2) ++#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */ ++#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */ ++ ++#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */ ++#define FIOCLEX 0x5451 ++#define FIOASYNC 0x5452 ++#define TIOCSERCONFIG 0x5453 ++#define TIOCSERGWILD 0x5454 ++#define TIOCSERSWILD 0x5455 ++#define TIOCGLCKTRMIOS 0x5456 ++#define TIOCSLCKTRMIOS 0x5457 ++#define TIOCSERGSTRUCT 0x5458 /* For debugging only */ ++#define TIOCSERGETLSR 0x5459 /* Get line status register */ ++#define TIOCSERGETMULTI 0x545A /* Get multiport config */ ++#define TIOCSERSETMULTI 0x545B /* Set multiport config */ ++ ++#define TIOCMIWAIT 0x545C /* wait for a change on serial input line(s) */ ++#define TIOCGICOUNT 0x545D /* read serial port inline interrupt counts */ ++#define FIOQSIZE 0x545E ++ ++/* Used for packet mode */ ++#define TIOCPKT_DATA 0 ++#define TIOCPKT_FLUSHREAD 1 ++#define TIOCPKT_FLUSHWRITE 2 ++#define TIOCPKT_STOP 4 ++#define TIOCPKT_START 8 ++#define TIOCPKT_NOSTOP 16 ++#define TIOCPKT_DOSTOP 32 ++ ++#define TIOCSER_TEMT 0x01 /* Transmitter physically empty */ ++ ++#endif /* _ASM_UBICOM32_IOCTLS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/io.h linux-2.6.28.10/arch/ubicom32/include/asm/io.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/io.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/io.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,313 @@ ++/* ++ * arch/ubicom32/include/asm/io.h ++ * I/O memory accessor functions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_IO_H ++#define _ASM_UBICOM32_IO_H ++ ++#ifdef __KERNEL__ ++#include ++#include ++ ++static inline unsigned short _swapw(volatile unsigned short v) ++{ ++ return ((v << 8) | (v >> 8)); ++} ++ ++static inline unsigned int _swapl(volatile unsigned long v) ++{ ++ return ((v << 24) | ((v & 0xff00) << 8) | ((v & 0xff0000) >> 8) | (v >> 24)); ++} ++ ++#ifndef CONFIG_PCI ++#define readb(addr) \ ++ ({ unsigned char __v = (*(volatile unsigned char *) (addr)); __v; }) ++#define readw(addr) \ ++ ({ unsigned short __v = (*(volatile unsigned short *) (addr)); __v; }) ++#define readl(addr) \ ++ ({ unsigned int __v = (*(volatile unsigned int *) (addr)); __v; }) ++ ++#define writeb(b,addr) (void)((*(volatile unsigned char *) (addr)) = (b)) ++#define writew(b,addr) (void)((*(volatile unsigned short *) (addr)) = (b)) ++#define writel(b,addr) (void)((*(volatile unsigned int *) (addr)) = (b)) ++#else /*CONFIG_PCI */ ++ ++#define PCI_CPU_REG_BASE (0x00000000UL) /* taking lower 2GB space */ ++#define PCI_DEV_REG_BASE (0x80000000UL) ++ ++#if PCI_CPU_REG_BASE > PCI_DEV_REG_BASE ++#define IS_PCI_ADDRESS(x) (((unsigned int)(x)&(PCI_CPU_REG_BASE)) == 0) ++#else ++#define IS_PCI_ADDRESS(x) ((unsigned int)(x)&(PCI_DEV_REG_BASE)) ++#endif ++ ++extern unsigned int ubi32_pci_read_u32(const volatile void __iomem *addr); ++extern unsigned short ubi32_pci_read_u16(const volatile void __iomem *addr); ++extern unsigned char ubi32_pci_read_u8(const volatile void __iomem *addr); ++extern void ubi32_pci_write_u32(unsigned int val, const volatile void __iomem *addr); ++extern void ubi32_pci_write_u16(unsigned short val, const volatile void __iomem *addr); ++extern void ubi32_pci_write_u8(unsigned char val, const volatile void __iomem *addr); ++ ++static inline unsigned char readb(const volatile void __iomem *addr) ++{ ++ if (IS_PCI_ADDRESS(addr)) ++ return ubi32_pci_read_u8(addr); ++ else ++ return (unsigned char)(*(volatile unsigned char *)addr); ++} ++static inline unsigned short readw(const volatile void __iomem *addr) ++{ ++ if (IS_PCI_ADDRESS(addr)) ++ return ubi32_pci_read_u16(addr); ++ else ++ return (unsigned short)(*(volatile unsigned short *)addr); ++} ++ ++static inline unsigned int readl(const volatile void __iomem *addr) ++{ ++ if (IS_PCI_ADDRESS(addr)) ++ return ubi32_pci_read_u32(addr); ++ else ++ return (unsigned int)(*(volatile unsigned int *)addr); ++} ++ ++static inline void writel(unsigned int val, volatile void __iomem *addr) ++{ ++ if (IS_PCI_ADDRESS(addr)) ++ ubi32_pci_write_u32(val, addr); ++ else ++ *(volatile unsigned int *)addr = val; ++} ++ ++static inline void writew(unsigned short val, volatile void __iomem *addr) ++{ ++ if (IS_PCI_ADDRESS(addr)) ++ ubi32_pci_write_u16(val, addr); ++ else ++ *(volatile unsigned short *)addr = val; ++} ++ ++static inline void writeb(unsigned char val, volatile void __iomem *addr) ++{ ++ if (IS_PCI_ADDRESS(addr)) ++ ubi32_pci_write_u8(val, addr); ++ else ++ *(volatile unsigned char *)addr = val; ++} ++#endif ++ ++#define readb_relaxed(addr) readb(addr) ++#define readw_relaxed(addr) readw(addr) ++#define readl_relaxed(addr) readl(addr) ++ ++ ++#define __raw_readb readb ++#define __raw_readw readw ++#define __raw_readl readl ++#define __raw_writeb writeb ++#define __raw_writew writew ++#define __raw_writel writel ++ ++static inline void io_outsb(unsigned int addr, const void *buf, int len) ++{ ++ volatile unsigned char *ap = (volatile unsigned char *) addr; ++ unsigned char *bp = (unsigned char *) buf; ++ while (len--) ++ *ap = *bp++; ++} ++ ++static inline void io_outsw(unsigned int addr, const void *buf, int len) ++{ ++ volatile unsigned short *ap = (volatile unsigned short *) addr; ++ unsigned short *bp = (unsigned short *) buf; ++ while (len--) ++ *ap = _swapw(*bp++); ++} ++ ++static inline void io_outsl(unsigned int addr, const void *buf, int len) ++{ ++ volatile unsigned int *ap = (volatile unsigned int *) addr; ++ unsigned int *bp = (unsigned int *) buf; ++ while (len--) ++ *ap = _swapl(*bp++); ++} ++ ++static inline void io_insb(unsigned int addr, void *buf, int len) ++{ ++ volatile unsigned char *ap = (volatile unsigned char *) addr; ++ unsigned char *bp = (unsigned char *) buf; ++ while (len--) ++ *bp++ = *ap; ++} ++ ++static inline void io_insw(unsigned int addr, void *buf, int len) ++{ ++ volatile unsigned short *ap = (volatile unsigned short *) addr; ++ unsigned short *bp = (unsigned short *) buf; ++ while (len--) ++ *bp++ = _swapw(*ap); ++} ++ ++static inline void io_insl(unsigned int addr, void *buf, int len) ++{ ++ volatile unsigned int *ap = (volatile unsigned int *) addr; ++ unsigned int *bp = (unsigned int *) buf; ++ while (len--) ++ *bp++ = _swapl(*ap); ++} ++ ++#define mmiowb() ++ ++/* ++ * make the short names macros so specific devices ++ * can override them as required ++ */ ++#ifndef CONFIG_PCI ++#define memset_io(a,b,c) memset((void *)(a),(b),(c)) ++#define memcpy_fromio(a,b,c) memcpy((a),(void *)(b),(c)) ++#define memcpy_toio(a,b,c) memcpy((void *)(a),(b),(c)) ++#else ++extern void memcpy_fromio(void *to, const volatile void __iomem *from, unsigned len); ++extern void memcpy_toio(volatile void __iomem *to, const void *from, unsigned len); ++extern void memset_io(volatile void __iomem *addr, int val, size_t count); ++#endif ++ ++#define inb(addr) readb(addr) ++#define inw(addr) readw(addr) ++#define inl(addr) readl(addr) ++#define outb(x,addr) ((void) writeb(x,addr)) ++#define outw(x,addr) ((void) writew(x,addr)) ++#define outl(x,addr) ((void) writel(x,addr)) ++ ++#define inb_p(addr) inb(addr) ++#define inw_p(addr) inw(addr) ++#define inl_p(addr) inl(addr) ++#define outb_p(x,addr) outb(x,addr) ++#define outw_p(x,addr) outw(x,addr) ++#define outl_p(x,addr) outl(x,addr) ++ ++#define outsb(a,b,l) io_outsb(a,b,l) ++#define outsw(a,b,l) io_outsw(a,b,l) ++#define outsl(a,b,l) io_outsl(a,b,l) ++ ++#define insb(a,b,l) io_insb(a,b,l) ++#define insw(a,b,l) io_insw(a,b,l) ++#define insl(a,b,l) io_insl(a,b,l) ++ ++#ifndef CONFIG_PCI ++#define ioread8_rep(a,d,c) insb(a,d,c) ++#define ioread16_rep(a,d,c) insw(a,d,c) ++#define ioread32_rep(a,d,c) insl(a,d,c) ++#define iowrite8_rep(a,s,c) outsb(a,s,c) ++#define iowrite16_rep(a,s,c) outsw(a,s,c) ++#define iowrite32_rep(a,s,c) outsl(a,s,c) ++#else ++extern void ioread8_rep(void __iomem *port, void *buf, unsigned long count); ++extern void ioread16_rep(void __iomem *port, void *buf, unsigned long count); ++extern void ioread32_rep(void __iomem *port, void *buf, unsigned long count); ++extern void iowrite8_rep(void __iomem *port, const void *buf, unsigned long count); ++extern void iowrite16_rep(void __iomem *port, const void *buf, unsigned long count); ++extern void iowrite32_rep(void __iomem *port, const void *buf, unsigned long count); ++#endif ++ ++ ++#ifndef CONFIG_PCI ++#define ioread8(X) readb(X) ++#define ioread16(X) readw(X) ++#define ioread32(X) readl(X) ++#define iowrite8(val,X) writeb(val,X) ++#define iowrite16(val,X) writew(val,X) ++#define iowrite32(val,X) writel(val,X) ++#else /*CONFIG_PCI */ ++extern unsigned char ioread8(void __iomem *addr); ++extern unsigned short ioread16(void __iomem *addr); ++extern unsigned int ioread32(void __iomem *addr); ++extern void iowrite8(unsigned char val, void __iomem *addr); ++extern void iowrite16(unsigned short val, void __iomem *addr); ++extern void iowrite32(unsigned int val, void __iomem *addr); ++#endif /* CONFIG_PCI */ ++ ++#define IO_SPACE_LIMIT 0xffff ++ ++/* Values for nocacheflag and cmode */ ++#define IOMAP_FULL_CACHING 0 ++#define IOMAP_NOCACHE_SER 1 ++#define IOMAP_NOCACHE_NONSER 2 ++#define IOMAP_WRITETHROUGH 3 ++ ++extern void *__ioremap(unsigned long physaddr, unsigned long size, int cacheflag); ++extern void __iounmap(void *addr, unsigned long size); ++ ++static inline void *ioremap(unsigned long physaddr, unsigned long size) ++{ ++ return __ioremap(physaddr, size, IOMAP_NOCACHE_SER); ++} ++static inline void *ioremap_nocache(unsigned long physaddr, unsigned long size) ++{ ++ return __ioremap(physaddr, size, IOMAP_NOCACHE_SER); ++} ++static inline void *ioremap_writethrough(unsigned long physaddr, unsigned long size) ++{ ++ return __ioremap(physaddr, size, IOMAP_WRITETHROUGH); ++} ++static inline void *ioremap_fullcache(unsigned long physaddr, unsigned long size) ++{ ++ return __ioremap(physaddr, size, IOMAP_FULL_CACHING); ++} ++ ++extern void iounmap(void *addr); ++ ++#define ioport_map(port, nr) ((void __iomem*)(port)) ++#define ioport_unmap(addr) ++ ++ ++/* Pages to physical address... */ ++#define page_to_phys(page) ((page - mem_map) << PAGE_SHIFT) ++#define page_to_bus(page) ((page - mem_map) << PAGE_SHIFT) ++ ++/* ++ * Macros used for converting between virtual and physical mappings. ++ */ ++#define phys_to_virt(vaddr) ((void *) (vaddr)) ++#define virt_to_phys(vaddr) ((unsigned long) (vaddr)) ++ ++#define virt_to_bus virt_to_phys ++#define bus_to_virt phys_to_virt ++ ++/* ++ * Convert a physical pointer to a virtual kernel pointer for /dev/mem ++ * access ++ */ ++#define xlate_dev_mem_ptr(p) __va(p) ++ ++/* ++ * Convert a virtual cached pointer to an uncached pointer ++ */ ++#define xlate_dev_kmem_ptr(p) p ++ ++#endif /* __KERNEL__ */ ++ ++#endif /* _ASM_UBICOM32_IO_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ip5000-asm.h linux-2.6.28.10/arch/ubicom32/include/asm/ip5000-asm.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ip5000-asm.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ip5000-asm.h 2009-08-12 13:08:37.000000000 +0300 +@@ -0,0 +1,156 @@ ++/* ++ * arch/ubicom32/include/asm/ip5000-asm.h ++ * Instruction macros for the IP5000. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_IP5000_ASM_H ++#define _ASM_UBICOM32_IP5000_ASM_H ++ ++#if !defined(__LINKER__) ++ ++#if defined(__ASSEMBLY__) ++.macro cycles quant ++.if (\quant) == 1 ++ nop ++.else ++.if (((\quant) + 3) / 8) > 0 ++.rept (((\quant) + 3) / 8) ++ jmpt.f .+4 ++.endr ++.endif ++.if ((((\quant) + 3) % 8) / 4) > 0 ++ jmpt.t .+4 ++.endif ++.endif ++.endm ++#else ++/* ++ * Same macro as above just in C inline asm ++ */ ++asm (" \n\ ++.macro cycles quant \n\ ++.if (\\quant) == 1 \n\ ++ nop \n\ ++.else \n\ ++.if (((\\quant) + 3) / 8) > 0 \n\ ++.rept (((\\quant) + 3) / 8) \n\ ++ jmpt.f .+4 \n\ ++.endr \n\ ++.endif \n\ ++.if ((((\\quant) + 3) % 8) / 4) > 0 \n\ ++ jmpt.t .+4 \n\ ++.endif \n\ ++.endif \n\ ++.endm \n\ ++"); ++#endif ++ ++ ++#if defined(__ASSEMBLY__) ++.macro pipe_flush cyc ++ cycles 11 - (\cyc) ++.endm ++#else ++/* ++ * Same macro as above just in C inline asm ++ */ ++asm (" \n\ ++.macro pipe_flush cyc \n\ ++ cycles 11 - (\\cyc) \n\ ++.endm \n\ ++"); ++ ++#endif ++ ++#if defined(__ASSEMBLY__) ++.macro setcsr_flush cyc ++ cycles 5 - (\cyc) ++.endm ++#else ++/* ++ * Same macro as above just in C inline asm ++ */ ++asm (" \n\ ++.macro setcsr_flush cyc \n\ ++ cycles 5 - (\\cyc) \n\ ++.endm \n\ ++"); ++#endif ++ ++/* ++ * Macros for prefetch (using miss-aligned memory write) ++ */ ++#if defined(__ASSEMBLY__) ++ ++.macro pre_fetch_macro thread_num, Ascratch, Aaddress length ++ bclr MT_TRAP_EN, MT_TRAP_EN, #(\thread_num) ++ bset \Ascratch, \Aaddress, #0 ; force a miss-aligned address ++ jmpt.t .+4 ; delay for both address setup and trap disable ++ move.4 (\Ascratch), #0 ++ .if (\length > 32) ++ move.4 32(\Ascratch), #0 ++ .endif ++ .if (\length > 64) ++ move.4 64(\Ascratch), #0 ++ .endif ++ .if (\length > 96) ++ move.4 96(\Ascratch), #0 ++ .endif ++ .if (\length > 128) ++ invalid_instruction ; maximum pre-fetch size is 4 cache lines ++ .endif ++ bset MT_TRAP_EN, MT_TRAP_EN, #(\thread_num) ++.endm ++ ++#else ++/* ++ * Same macro as above just in C inline asm ++ */ ++asm (" \n\ ++.macro pre_fetch_macro thread_num, Ascratch, Aaddress length \n\ ++ bclr MT_TRAP_EN, MT_TRAP_EN, #(\thread_num) \n\ ++ bset \\Ascratch, \\Aaddress, #0 ; force a miss-aligned address \n\ ++ jmpt.t .+4 ; delay for both address setup and trap disable \n\ ++ move.4 (\\Ascratch), #0 \n\ ++ .if (\\length > 32) \n\ ++ move.4 32(\\Ascratch), #0 \n\ ++ .endif \n\ ++ .if (\\length > 64) \n\ ++ move.4 64(\\Ascratch), #0 \n\ ++ .endif \n\ ++ .if (\\length > 96) \n\ ++ move.4 96(\\Ascratch), #0 \n\ ++ .endif \n\ ++ .if (\\length > 128) \n\ ++ invalid_instruction ; maximum pre-fetch size is 4 cache lines \n\ ++ .endif \n\ ++ bset MT_TRAP_EN, MT_TRAP_EN, #(\\thread_num) \n\ ++.endm \n\ ++"); ++#endif ++ ++#endif /* !defined(__LINKER__) */ ++#endif /* defined _ASM_UBICOM32_IP5000_ASM_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ip5000.h linux-2.6.28.10/arch/ubicom32/include/asm/ip5000.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ip5000.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ip5000.h 2009-08-12 13:08:37.000000000 +0300 +@@ -0,0 +1,860 @@ ++/* ++ * arch/ubicom32/include/asm/ip5000.h ++ * Specific details for the Ubicom IP5000 processor. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_IP5000_H ++#define _ASM_UBICOM32_IP5000_H ++ ++/* ++ * Inline assembly define ++ */ ++#define S(arg) #arg ++#define D(arg) S(arg) ++ ++/* ++ * Assembler include file ++ */ ++#include ++ ++/* ++ * Timing ++ */ ++#define JMPT_PENALTY 3 ++#define JMPF_PENALTY 7 ++#define RET_PENALTY 7 ++ ++/* ++ * Threads ++ */ ++#if defined(IP5000) || defined(IP5000_REV2) ++#define THREAD_COUNT 10 ++#elif defined(IP7000) || defined(IP7000_REV2) ++#define THREAD_COUNT 12 ++#else ++#error "Unknown IP5K silicon" ++#endif ++ ++/* ++ * Arch ++ */ ++#if defined(IP5000) || defined(IP5000_REV2) ++#define UBICOM32_ARCH_VERSION 3 ++#elif defined(IP7000) || defined(IP7000_REV2) ++#define UBICOM32_ARCH_VERSION 4 ++#else ++#error "Unknown IP5K silicon" ++#endif ++ ++/* ++ * Memory Size ++ */ ++#define OCM_SECTOR_SIZE 0x00008000 /* 32K */ ++ ++#if defined(IP5000) || defined(IP5000_REV2) ++#define OCMSIZE 0x00030000 /* 192K on-chip RAM for both program and data */ ++#elif defined(IP7000) || defined(IP7000_REV2) ++#define OCMSIZE 0x0003C000 /* 240K on-chip RAM for both program and data */ ++#else ++#error "Unknown IP5K silicon" ++#endif ++ ++#define OCMSTART 0x3ffc0000 /* alias from 0x03000000 for easy jump to/from SDRAM */ ++#define OCMEND (OCMSTART + OCMSIZE) ++#define SDRAMSTART 0x40000000 ++#define FLASHSTART 0x60000000 ++ ++/* ++ * Registers ++ */ ++#define ROSR_INT (1 << 0) ++ ++/* Interrupts */ ++#define INT_CHIP(reg, bit) (((reg) << 5) | (bit)) ++#define INT_REG(interrupt) (((interrupt) >> 5) * 4) ++#define INT_SET(interrupt) 0x0114 + INT_REG(interrupt) ++#define INT_CLR(interrupt) 0x0124 + INT_REG(interrupt) ++#define INT_STAT(interrupt) 0x0104 + INT_REG(interrupt) ++#define INT_MASK(interrupt) 0x00C0 + INT_REG(interrupt) ++#define INT_BIT(interrupt) ((interrupt) & 0x1F) ++#define INT_BIT_MASK(interrupt) (1 << INT_BIT(interrupt)) ++ ++/* ++ * The LOCK_INT and THREAD_INT are used to wake up corresponding thread. They are sharing ++ * the same set of SW interrupt resource. ++ * ++ * LOCK_INT(n): One SW INT per NRT thread that can participate lock operation. ++ * The threads that can participate lock are application threads and DSR thread. ++ * (Lock locks - numbers are hard-coded in lock.h) ++ * THREAD_INT(n): One SW INT per HRT thread for wake up trigger. ++ */ ++#define LOCK_INT(thread) INT_CHIP(0, (thread)) ++#define THREAD_INT(thread) INT_CHIP(0, (thread)) ++ ++/* ++ * The SYSTEM_INT and DSR_INT are sharing the same set of SW interrupt resource. ++ * ++ * SYSTEM_INT(n): One SW INT per NRT threads (application threads) as system queue interrupt, ++ * and for DSR as self-trigger interrupt. ++ * (The application threads include at least thread 0) ++ * DSR_INT(n): One SW INT per HRT thread to request DSR service. ++ */ ++#define SYSTEM_INT(thread) INT_CHIP(0, THREAD_COUNT + (thread)) ++#define DSR_INT(thread) INT_CHIP(0, THREAD_COUNT + (thread)) ++ ++/* GLOBAL_CTRL */ ++#define GLOBAL_CTRL_TRAP_RST_EN (1 << 9) ++#define GLOBAL_CTRL_AERROR_RST_EN (1 << 8) ++#define GLOBAL_CTRL_MT_MIN_DELAY(x) ((x) << 3) ++#define GLOBAL_CTRL_HRT_BANK_SELECT (1 << 2) ++#define GLOBAL_CTRL_INT_EN (1 << 0) ++ ++/* ++ * HRT Tables ++ */ ++#define HRT_TABLE0_BASE 0x0800 ++#define HRT_TABLE1_BASE 0x0900 ++#define HRT_TABLE_SIZE 64 ++ ++/* ++ * Break Point Trap Register ++ */ ++#define ASYNCERROR_INT INT_CHIP(0, 31) ++#define BREAKPOINT_INT INT_CHIP(1, 31) ++ ++/* ++ * Port interrupts ++ * The non-existing FIFO INTs are mapped to INT2 for the ports. ++ */ ++#define IO_PORT_PTR_TO_NUM(port) (((port) & 0x0000ffff) >> 12) ++#define RX_FIFO_INT(port) \ ++ ((IO_PORT_PTR_TO_NUM(port) == 0) ? INT_CHIP(0, 25) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 1) ? INT_CHIP(0, 26) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 2) ? INT_CHIP(0, 29) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 3) ? INT_CHIP(1, 24) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 4) ? INT_CHIP(1, 27) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 5) ? INT_CHIP(1, 16) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 6) ? INT_CHIP(1, 19) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 7) ? INT_CHIP(1, 20) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 8) ? INT_CHIP(1, 21) : \ ++ INT_CHIP(1, 15)))))))))) ++#define TX_FIFO_INT(port) \ ++ ((IO_PORT_PTR_TO_NUM(port) == 0) ? INT_CHIP(0, 24) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 1) ? INT_CHIP(0, 27) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 2) ? INT_CHIP(0, 29) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 3) ? INT_CHIP(1, 25) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 4) ? INT_CHIP(1, 28) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 5) ? INT_CHIP(1, 17) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 6) ? INT_CHIP(1, 19) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 7) ? INT_CHIP(1, 20) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 8) ? INT_CHIP(1, 22) : \ ++ INT_CHIP(1, 15)))))))))) ++#define PORT_OTHER_INT(port) \ ++ ((IO_PORT_PTR_TO_NUM(port) == 0) ? INT_CHIP(0, 25) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 1) ? INT_CHIP(0, 28) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 2) ? INT_CHIP(0, 29) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 3) ? INT_CHIP(1, 26) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 4) ? INT_CHIP(1, 29) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 5) ? INT_CHIP(1, 18) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 6) ? INT_CHIP(1, 19) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 7) ? INT_CHIP(1, 20) : \ ++ ((IO_PORT_PTR_TO_NUM(port) == 8) ? INT_CHIP(1, 23) : \ ++ INT_CHIP(1, 15)))))))))) ++ ++/* ++ * On Chip Peripherals Base. ++ */ ++#define OCP_BASE 0x01000000 ++#define OCP_GENERAL 0x000 ++#define OCP_TIMERS 0x100 ++#define OCP_TRNG 0x200 /* True Random Number Generator Control Reigsters */ ++#define OCP_DEBUG 0x300 ++#define OCP_SECURITY 0x400 ++#define OCP_ICCR 0x500 /* I-Cache Control Registers */ ++#define OCP_DCCR 0x600 /* D-Cache Control Registers */ ++#define OCP_OCMC 0x700 /* On Chip Memory Control Registers */ ++#define OCP_STATISTICS 0x800 /* Statistics Counters */ ++#define OCP_MTEST 0x900 /* Memory Test Registers */ ++#define OCP_MCFG 0xa00 /* Memory Configuration Registers -- IP7000 only */ ++#define OCP_DEBUG_INST 0x000 /* Up to 16M */ ++ ++/* ++ * General Configuration Registers (PLL) ++ */ ++#define GENERAL_CFG_BASE (OCP_BASE + OCP_GENERAL) ++#define GEN_CLK_CORE_CFG 0x00 ++#define GEN_CLK_IO_CFG 0x04 ++#define GEN_CLK_DDR_CFG 0x08 ++#define GEN_CLK_DDRDS_CFG 0x0c ++#define GEN_CLK_SLIP_CLR 0x10 ++#define GEN_CLK_SLIP_START 0x14 ++#define GEN_CLK_SERDES_SEL 0x18 /* IP7000 only */ ++#define GEN_CLK_DDR_CFG2 0x1c /* IP7000 only */ ++#define GEN_DDR_CAL_CTRL 0x30 /* IP5000 only */ ++#define GEN_DDR_CAL_STAT 0x34 /* IP5000 only */ ++#define GEN_USB_DFT_CTRL 0x38 /* IP5000 only */ ++#define GEN_USB_DFT_STAT 0x3c /* IP5000 only */ ++#define GEN_USB_PHY_CFG 0x40 /* IP7000 only */ ++#define GEN_USB_PHY_TEST 0x44 /* IP7000 only */ ++#define GEN_USB_PHY_STAT 0x48 /* IP7000 only */ ++#define GEN_SW_RESET 0x80 ++#define GEN_RESET_REASON 0x84 ++#define GEN_BOND_CFG 0x88 ++#define GEN_IO_PU_CFG 0x8c ++#define GEN_MEM_RM_CFG 0x90 ++#define GEN_IO_CONFIG 0x94 ++ ++#define GEN_CLK_PLL_SECURITY_BIT_NO 31 ++#define GEN_CLK_PLL_SECURITY (1 << GEN_CLK_PLL_SECURITY_BIT_NO) ++#define GEN_CLK_PLL_ENSAT (1 << 30) ++#define GEN_CLK_PLL_FASTEN (1 << 29) ++#define GEN_CLK_PLL_NR(v) (((v) - 1) << 23) ++#define GEN_CLK_PLL_NF(v) (((v) - 1) << 11) ++#define GEN_CLK_PLL_OD(v) (((v) - 1) << 8) ++#define GEN_CLK_PLL_RESET (1 << 7) ++#define GEN_CLK_PLL_BYPASS (1 << 6) ++#define GEN_CLK_PLL_POWERDOWN (1 << 5) ++#define GEN_CLK_PLL_SELECT (1 << 4) ++ ++#define GEN_GET_CLK_PLL_NR(v) ((((v) >> 23) & 0x003f) + 1) ++#define GEN_GET_CLK_PLL_NF(v) ((((v) >> 11) & 0x0fff) + 1) ++#define GEN_GET_CLK_PLL_OD(v) ((((v) >> 8) & 0x7) + 1) ++ ++ ++#define RESET_FLAG_DST_MEM_ERROR (1 << 18) ++#define RESET_FLAG_SRC1_MEM_ERROR (1 << 17) ++#define RESET_FLAG_WRITE_ADDR (1 << 16) ++#define RESET_FLAG_DST_SYNC_ERROR (1 << 15) ++#define RESET_FLAG_SRC1_SYNC_ERROR (1 << 14) ++#define RESET_FLAG_DST_ALGN_ERROR (1 << 13) ++#define RESET_FLAG_SRC1_ALGN_ERROR (1 << 12) ++#define RESET_FLAG_DST_ADDR_ERROR (1 << 11) ++#define RESET_FLAG_SRC1_ADDR_ERROR (1 << 10) ++#define RESET_FLAG_ILLEGAL_INST (1 << 9) ++#define RESET_FLAG_INST_SYNC_ERROR (1 << 8) ++#define RESET_FLAG_INST_ADDR_ERROR (1 << 7) ++#define RESET_FLAG_DATA_PORT_ERROR (1 << 6) ++#define RESET_FLAG_INST_PORT_ERROR (1 << 5) ++#define RESET_FLAG_SW_RESET (1 << 4) ++#define RESET_FLAG_DEBUG (1 << 3) ++#define RESET_FLAG_WATCHDOG (1 << 2) ++#define RESET_FLAG_POWER_ON (1 << 1) ++#define RESET_FLAG_EXTERNAL (1 << 0) ++ ++/* ++ * Timer block ++ */ ++#define TIMER_BASE (OCP_BASE + OCP_TIMERS) ++#define TIMER_MPTVAL 0x00 ++#define TIMER_RTCOM 0x04 ++#define TIMER_TKEY 0x08 ++#define TIMER_WDCOM 0x0c ++#define TIMER_WDCFG 0x10 ++#define TIMER_SYSVAL 0x14 ++#define TIMER_SYSCOM(tmr) (0x18 + (tmr) * 4) ++#define TIMER_TRN_CFG 0x100 ++#define TIMER_TRN 0x104 ++ ++#define TIMER_COUNT 10 ++#define TIMER_INT(tmr) INT_CHIP(1, (tmr)) ++#define TIMER_TKEYVAL 0xa1b2c3d4 ++#define TIMER_WATCHDOG_DISABLE 0x4d3c2b1a ++#define TIMER_TRN_CFG_ENABLE_OSC 0x00000007 ++ ++#ifndef __ASSEMBLY__ ++/* ++ * ubicom32_io_timer ++ */ ++struct ubicom32_io_timer { ++ volatile u32_t mptval; ++ volatile u32_t rtcom; ++ volatile u32_t tkey; ++ volatile u32_t wdcom; ++ volatile u32_t wdcfg; ++ volatile u32_t sysval; ++ volatile u32_t syscom[TIMER_COUNT]; ++ volatile u32_t reserved[64 - 6 - TIMER_COUNT]; // skip all the way to OCP-TRNG section ++ volatile u32_t rsgcfg; ++ volatile u32_t trn; ++}; ++ ++#define UBICOM32_IO_TIMER ((struct ubicom32_io_timer *)TIMER_BASE) ++#endif ++ ++#define UBICOM32_VECTOR_TO_TIMER_INDEX(vector) (vector - TIMER_INT(0)) ++ ++/* ++ * OCP-Debug Module (Mailbox) ++ */ ++#define ISD_MAILBOX_BASE (OCP_BASE + OCP_DEBUG) ++#define ISD_MAILBOX_IN 0x00 ++#define ISD_MAILBOX_OUT 0x04 ++#define ISD_MAILBOX_STATUS 0x08 ++ ++#define ISD_MAILBOX_INT INT_CHIP(1, 30) ++ ++#define ISD_MAILBOX_STATUS_IN_FULL (1 << 31) ++#define ISD_MAILBOX_STATUS_IN_EMPTY (1 << 30) ++#define ISD_MAILBOX_STATUS_OUT_FULL (1 << 29) ++#define ISD_MAILBOX_STATUS_OUT_EMPTY (1 << 28) ++ ++/* ++ * OCP-Security ++ */ ++#define SECURITY_BASE (OCP_BASE + OCP_SECURITY) ++#define SECURITY_BASE_EFFECTIVE_ADDRESS (SECURITY_BASE >> 7) // To load the base address in a single instruction ++#define SECURITY_CTRL 0x00 ++#define SECURITY_CTRL_BYTE_OFFSET(x) ((x) << 16) ++#define SECURITY_CTRL_KEY_SIZE(x) ((x) << 8) ++#define SECURITY_CTRL_HASH_ALG_NONE (0 << 4) ++#define SECURITY_CTRL_HASH_ALG_MD5 (1 << 4) ++#define SECURITY_CTRL_HASH_ALG_SHA1 (2 << 4) ++#define SECURITY_CTRL_CBC (1 << 3) ++#define SECURITY_CTRL_CIPHER_ALG_AES (0 << 1) ++#define SECURITY_CTRL_CIPHER_ALG_NONE (1 << 1) ++#define SECURITY_CTRL_CIPHER_ALG_DES (2 << 1) ++#define SECURITY_CTRL_CIPHER_ALG_3DES (3 << 1) ++#define SECURITY_CTRL_ENCIPHER (1 << 0) ++#define SECURITY_CTRL_DECIPHER (0 << 0) ++#define SECURITY_STAT 0x04 ++#define SECURITY_STAT_BUSY (1 << 0) ++#define SECURITY_KEY_VALUE(x) (0x10 + (x) * 4) ++#define SECURITY_KEY_IN(x) (0x30 + (x) * 4) ++#define SECURITY_KEY_OUT(x) (0x50 + (x) * 4) ++#define SECURITY_KEY_HASH(x) (0x70 + (x) * 4) ++ ++/* ++ * OCP-ICCR ++ */ ++#define ICCR_BASE (OCP_BASE + OCP_ICCR) ++#define ICACHE_TOTAL_SIZE 16384 /* in bytes */ ++ ++/* ++ * OCP-DCCR ++ */ ++#define DCCR_BASE (OCP_BASE + OCP_DCCR) ++#if defined(IP5000) || defined(IP5000_REV2) ++#define DCACHE_TOTAL_SIZE 8192 /* in bytes */ ++#elif defined(IP7000) || defined(IP7000_REV2) ++#define DCACHE_TOTAL_SIZE 16384 /* in bytes */ ++#endif ++ ++#if defined(IP5000) || defined(IP5000_REV2) || defined(IP7000) || defined(IP7000_REV2) ++#define DCACHE_WRITE_QUEUE_LENGTH 6 ++#else ++#error "Unknown IP5K silicon" ++#endif ++ ++#define CACHE_LINE_SIZE 32 /* in bytes */ ++ ++#define CCR_ADDR 0x00 ++#define CCR_RDD 0x04 ++#define CCR_WRD 0x08 ++#define CCR_STAT 0x0c ++#define CCR_CTRL 0x10 ++ ++#define CCR_STAT_MCBE 0 ++#define CCR_STAT_WIDEL 1 /* D-cache only */ ++ ++#define CCR_CTRL_DONE 0 ++#define CCR_CTRL_RESET 2 ++#define CCR_CTRL_VALID 3 ++#define CCR_CTRL_RD_DATA (1 << 4) ++#define CCR_CTRL_RD_TAG (2 << 4) ++#define CCR_CTRL_WR_DATA (3 << 4) ++#define CCR_CTRL_WR_TAG (4 << 4) ++#define CCR_CTRL_INV_INDEX (5 << 4) ++#define CCR_CTRL_INV_ADDR (6 << 4) ++#define CCR_CTRL_FLUSH_INDEX (7 << 4) /* D-cache only */ ++#define CCR_CTRL_FLUSH_INV_INDEX (8 << 4) /* D-cache only */ ++#define CCR_CTRL_FLUSH_ADDR (9 << 4) /* D-cache only */ ++#define CCR_CTRL_FLUSH_INV_ADDR (10 << 4) /* D-cache only */ ++ ++/* ++ * OCP-OCMC ++ */ ++#define OCMC_BASE (OCP_BASE + OCP_OCMC) ++#define OCMC_BANK_MASK 0x00 ++#define OCMC_BIST_CNTL 0x04 /* IP5000 only */ ++#define OCMC_BIST_STAT 0x08 /* IP5000 only */ ++ ++#define OCMC_BANK_PROG(n) ((1<<(n))-1) ++ ++#define OCMC_BIST_WRCK (1 << 7) ++#define OCMC_BIST_RESET (1 << 5) ++#define OCMC_BIST_SMART (1 << 4) ++#define OCMC_BIST_RUN (1 << 3) ++#define OCMC_BIST_REPAIR (1 << 2) ++ ++#define OCMC_BIST_READY (1 << 3) ++#define OCMC_BIST_FAIL (1 << 2) ++ ++/* ++ * OCP-STATISTICS ++ */ ++#define STATISTICS_BASE (OCP_BASE + OCP_STATISTICS) ++#define STAT_COUNTER_CTRL(n) ((n)*8) ++#define STAT_COUNTER(n) ((n)*8 + 4) ++ ++#define STAT_EVENT_MP_INST 0 ++#define STAT_EVENT_OCM_ACCESS 4 ++#define STAT_EVENT_OCM_REQ 5 ++#define STAT_EVENT_IC_REQ_INVAL 13 ++#define STAT_EVENT_IC_MISS_INVAL 14 ++#define STAT_EVENT_IC_REQ_INVAL_NACK 15 ++#define STAT_EVENT_IC_REQ_VAL 16 ++#define STAT_EVENT_IC_MISS_VAL 17 ++#define STAT_EVENT_IC_REQ_VAL_NACK 18 ++#define STAT_EVENT_IC_MISS_Q 19 ++#define STAT_EVENT_DC_RD_REQ 20 ++#define STAT_EVENT_DC_RD_MISS 21 ++#define STAT_EVENT_DC_WR_REQ 22 ++#define STAT_EVENT_DC_WR_MISS 23 ++#define STAT_EVENT_DC_MISS_Q 24 ++#define STAT_EVENT_DC_WB_FULL 25 ++#define STAT_EVENT_DC_REQ_NACK 26 ++#define STAT_EVENT_DC_CORE_REQ 27 ++#define STAT_EVENT_DC_MISS 28 ++#define STAT_EVENT_DC_EVICT 29 ++#define STAT_EVENT_TRUE 30 ++#define STAT_EVENT_FALSE 31 ++ ++/* ++ * OCP_MTEST ++ */ ++#define MTEST_BASE (OCP_BASE + OCP_MTEST) ++#define MTEST_ADDR 0x00 ++#define MTEST_WR 0x04 ++#define MTEST_RD 0x08 ++#define MTEST_CTRL 0x0c ++ ++/* ++ * OCP_MCFG (IP7000 only) ++ */ ++#define MCFG_BASE (OCP_BASE + OCP_MCFG) ++#define MCFG_CTRL 0x00 ++#define MCFG_WCFG 0x04 ++#define MCFG_RCFG 0x08 ++ ++/* ++ * Port registers ++ */ ++#define IO_BASE 0x02000000 ++#define RA (IO_BASE + 0x00000000) ++#define RB (IO_BASE + 0x00001000) ++#define RC (IO_BASE + 0x00002000) ++#define RD (IO_BASE + 0x00003000) ++#define RE (IO_BASE + 0x00004000) ++#define RF (IO_BASE + 0x00005000) ++#define RG (IO_BASE + 0x00006000) ++#define RH (IO_BASE + 0x00007000) ++#define RI (IO_BASE + 0x00008000) ++#define RJ (IO_BASE + 0x00009000) ++#define RLATCH (IO_BASE + 0x00ff0000) // For latched output only ++#define IO_PORT_BR_OFFSET 0x00000800 ++ ++/* ++ * General I/O Register Map (per port) ++ */ ++#define IO_FUNC 0x00 ++#define IO_GPIO_CTL 0x04 ++#define IO_GPIO_OUT 0x08 ++#define IO_GPIO_IN 0x0C ++#define IO_INT_STATUS 0x10 ++#define IO_INT_MASK 0x14 ++#define IO_INT_SET 0x18 ++#define IO_INT_CLR 0x1C ++#define IO_TX_FIFO 0x20 ++#define IO_TX_FIFO_HI 0x24 ++#define IO_RX_FIFO 0x28 ++#define IO_RX_FIFO_HI 0x2c ++#define IO_CTL0 0x30 ++#define IO_CTL1 0x34 ++#define IO_CTL2 0x38 ++#define IO_STATUS0 0x3c ++#define IO_STATUS1 0x40 ++#define IO_STATUS2 0x44 ++#define IO_FIFO_WATER 0x48 ++#define IO_FIFO_LEVEL 0x4c ++#define IO_GPIO_MASK 0x50 ++ ++#define IO_FUNC_FUNCTION_RESET(func) ((1 << ((func) - 1)) << 4) /* Function 0 doesn't need reset */ ++#define IO_FUNC_RX_FIFO (1 << 3) ++#define IO_FUNC_SELECT(func) ((func) << 0) ++ ++/* ++ * External interrupt pins. ++ */ ++#define EXT_INT_IO_BIT(pin) ((pin) + 5) // Interrupt pin number -> I/O INT bit ++#define EXT_INT_RISING_EDGE(pin) (0x2 << (2*(pin) + 7)) ++#define EXT_INT_FALLING_EDGE(pin) (0x1 << (2*(pin) + 7)) ++ ++/* ++ * Flash ++ */ ++#define IO_XFL_BASE RA ++ ++#define IO_XFL_INT_START (1 << 16) ++#define IO_XFL_INT_ERR (1 << 8) ++#define IO_XFL_INT_DONE (1 << 0) ++ ++#define IO_XFL_CTL0_MASK (0xffe07fff) ++#define IO_XFL_CTL0_RD_CMD(cmd) (((cmd) & 0xff) << 24) ++#define IO_XFL_CTL0_RD_DUMMY(n) (((n) & 0x7) << 21) ++#define IO_XFL_CTL0_CLK_WIDTH(core_cycles) ((((core_cycles) + 1) & 0x7e) << 8) /* must be even number */ ++#define IO_XFL_CTL0_CE_WAIT(spi_cycles) (((spi_cycles) & 0x3f) << 2) ++#define IO_XFL_CTL0_MCB_LOCK (1 << 1) ++#define IO_XFL_CTL0_ENABLE (1 << 0) ++#define IO_XFL_CTL0_FAST_VALUE(div, wait) (IO_XFL_CTL0_RD_CMD(0xb) | IO_XFL_CTL0_RD_DUMMY(1) | IO_XFL_CTL0_CLK_WIDTH(div) | IO_XFL_CTL0_CE_WAIT(wait) | IO_XFL_CTL0_ENABLE) ++#define IO_XFL_CTL0_VALUE(div, wait) (IO_XFL_CTL0_RD_CMD(3) | IO_XFL_CTL0_CLK_WIDTH(div) | IO_XFL_CTL0_CE_WAIT(wait) | IO_XFL_CTL0_ENABLE) ++ ++#define IO_XFL_CTL1_MASK (0xc0003fff) ++#define IO_XFL_CTL1_FC_INST(inst) (((inst) & 0x3) << 30) ++#define IO_XFL_CTL1_FC_DATA(n) (((n) & 0x3ff) << 4) ++#define IO_XFL_CTL1_FC_DUMMY(n) (((n) & 0x7) << 1) ++#define IO_XFL_CTL1_FC_ADDR (1 << 0) ++ ++#define IO_XFL_CTL2_FC_CMD(cmd) (((cmd) & 0xff) << 24) ++#define IO_XFL_CTL2_FC_ADDR(addr) ((addr) & 0x00ffffff) /* Only up to 24 bits */ ++ ++#define IO_XFL_STATUS0_MCB_ACTIVE (1 << 0) ++#define IO_XFL_STATUS0_IOPCS_ACTIVE (1 << 1) ++ ++/* ++ * SDRAM ++ */ ++#define IO_SDRAM_DATA_BASE RG ++#define IO_SDRAM_CNTL_BASE RH ++ ++#define IO_SDRAM_CTRL0_EN_REF (1 << 0) ++ ++/* ++ * Port function code (common fucntion codes for all I/O ports) ++ */ ++#define IO_PORTX_FUNC_GPIO 0x00 ++#define IO_PORTX_FUNC_XFL 0x01 ++#define IO_PORTX_FUNC_PCI 0x01 ++#define IO_PORTX_FUNC_SERDES 0x01 ++#define IO_PORTX_FUNC_GMII 0x01 ++#define IO_PORTX_FUNC_DDR 0x01 ++#define IO_PORTX_FUNC_PCIX 0x01 ++#define IO_PORTX_FUNC_USB2_0 0x01 ++#define IO_PORTX_FUNC_GPIO_INT_CLK 0x02 ++#define IO_PORTX_FUNC_PLIO 0x02 ++#define IO_PORTX_FUNC_GPIO_INT 0x03 ++#define IO_PORTX_FUNC_MII 0x03 ++ ++/* ++ * Port 0 ++ */ ++#define IO_PORT0_FUNC_GPIO IO_PORTX_FUNC_GPIO ++#define IO_PORT0_FUNC_XFL_INT_CLK IO_PORTX_FUNC_XFL // Default mode after reset ++#define IO_PORT0_FUNC_GPIO_INT_CLK IO_PORTX_FUNC_GPIO_INT_CLK ++#define IO_PORT0_FUNC_GPIO_INT IO_PORTX_FUNC_GPIO_INT ++ ++/* ++ * Port 1 ++ */ ++#define IO_PORT1_FUNC_GPIO IO_PORTX_FUNC_GPIO ++#define IO_PORT1_FUNC_PCI IO_PORTX_FUNC_PCI // PCI control ++#define IO_PORT1_FUNC_MII IO_PORTX_FUNC_MII // port 4 MII extension ++ ++/* ++ * Port 2 ++ */ ++#define IO_PORT2_FUNC_GPIO IO_PORTX_FUNC_GPIO ++#define IO_PORT2_FUNC_PCI IO_PORTX_FUNC_PCI // PCI data I/O ++#define IO_PORT2_FUNC_PLIO IO_PORTX_FUNC_PLIO // Extended LM ++ ++/* ++ * Port 3 ++ */ ++#define IO_PORT3_FUNC_GPIO IO_PORTX_FUNC_GPIO ++#define IO_PORT3_FUNC_SERDES IO_PORTX_FUNC_SERDES ++#define IO_PORT3_FUNC_PLIO IO_PORTX_FUNC_PLIO ++ ++/* ++ * Port 4 ++ */ ++#define IO_PORT4_FUNC_GPIO IO_PORTX_FUNC_GPIO ++#define IO_PORT4_FUNC_SERDES IO_PORTX_FUNC_SERDES ++#define IO_PORT4_FUNC_PLIO IO_PORTX_FUNC_PLIO // Extended LM ++#define IO_PORT4_FUNC_MII IO_PORTX_FUNC_MII ++ ++/* ++ * Port 5 ++ */ ++#define IO_PORT5_FUNC_GPIO IO_PORTX_FUNC_GPIO ++#define IO_PORT5_FUNC_GMII IO_PORTX_FUNC_GMII ++ ++/* ++ * Port 6 ++ */ ++#define IO_PORT6_FUNC_GPIO IO_PORTX_FUNC_GPIO ++#define IO_PORT6_FUNC_DDR IO_PORTX_FUNC_DDR ++ ++/* ++ * Port 7 ++ */ ++#define IO_PORT7_FUNC_GPIO IO_PORTX_FUNC_GPIO ++#define IO_PORT7_FUNC_DDR IO_PORTX_FUNC_DDR ++ ++/* ++ * Port 8 ++ */ ++#define IO_PORT8_FUNC_GPIO IO_PORTX_FUNC_GPIO ++#define IO_PORT8_FUNC_PCIX IO_PORTX_FUNC_PCIX ++#define IO_PORT8_FUNC_PLIO IO_PORTX_FUNC_PLIO // Extended LM ++#define IO_PORT8_FUNC_MII IO_PORTX_FUNC_MII // port 4 MII extension ++ ++/* ++ * Port 9 ++ */ ++#define IO_PORT9_FUNC_USB2_0 IO_PORTX_FUNC_USB2_0 ++ ++/* ++ * FIFO ++ */ ++#define IO_PORTX_INT_FIFO_TX_RESET (1 << 31) ++#define IO_PORTX_INT_FIFO_RX_RESET (1 << 30) ++#define IO_PORTX_INT_FIFO_TX_UF (1 << 15) ++#define IO_PORTX_INT_FIFO_TX_WM (1 << 14) ++#define IO_PORTX_INT_FIFO_RX_OF (1 << 13) ++#define IO_PORTX_INT_FIFO_RX_WM (1 << 12) ++ ++#define IO_PORTX_FUNC_FIFO_TX_WM(n) ((n) << 16) ++#define IO_PORTX_FUNC_FIFO_RX_WM(n) ((n) << 0) ++ ++/* ++ * MII ++ */ ++#define IO_PORTX_INT_MII_TX_ERR_SEND (1 << 18) ++#define IO_PORTX_INT_MII_TX_HALT (1 << 17) ++#define IO_PORTX_INT_MII_TX_START (1 << 16) ++#define IO_PORTX_INT_MII_THRESHOLD (1 << 8) ++#define IO_PORTX_INT_MII_RX_EOP (1 << 7) ++#define IO_PORTX_INT_MII_RX_SFD (1 << 6) ++#define IO_PORTX_INT_MII_RX_ERR (1 << 5) ++#define IO_PORTX_INT_MII_TX_EOP (1 << 4) ++#define IO_PORTX_INT_MII_COL (1 << 3) ++#define IO_PORTX_INT_MII_CRS (1 << 2) ++#define IO_PORTX_INT_MII_ODD_NIB_ERR (1 << 1) ++#define IO_PORTX_INT_MII_FALSE_CARRIER (1 << 0) ++ ++/* ++ * SerDes ++ */ ++#define IO_PORTX_INT_SERDES_TXBUF_VALID (1 << 16) ++#define IO_PORTX_INT_SERDES_RXERR (1 << 7) ++#define IO_PORTX_INT_SERDES_RXEOP (1 << 6) ++#define IO_PORTX_INT_SERDES_SYND (1 << 5) ++#define IO_PORTX_INT_SERDES_TXBE (1 << 4) ++#define IO_PORTX_INT_SERDES_TXEOP (1 << 3) ++#define IO_PORTX_INT_SERDES_SXLP (1 << 2) ++#define IO_PORTX_INT_SERDES_RXBF (1 << 1) ++#define IO_PORTX_INT_SERDES_RXCRS (1 << 0) ++ ++#ifndef __ASSEMBLY__ ++struct ubicom32_io_port { ++ volatile u32_t function; ++ volatile u32_t gpio_ctl; ++ volatile u32_t gpio_out; ++ volatile u32_t gpio_in; ++ volatile u32_t int_status; ++ volatile u32_t int_mask; ++ volatile u32_t int_set; ++ volatile u32_t int_clr; ++ volatile u32_t tx_fifo; ++ volatile u32_t tx_fifo_hi; ++ volatile u32_t rx_fifo; ++ volatile u32_t rx_fifo_hi; ++ volatile u32_t ctl0; ++ volatile u32_t ctl1; ++ volatile u32_t ctl2; ++ volatile u32_t status0; ++ volatile u32_t status1; ++ volatile u32_t status2; ++ volatile u32_t fifo_watermark; ++ volatile u32_t fifo_level; ++ volatile u32_t gpio_mask; ++}; ++ ++#define UBICOM32_IO_PORT(port) ((struct ubicom32_io_port *)((port))) ++#endif ++ ++#ifndef __ASSEMBLY__ ++/* ++ * ubicom32_set_interrupt() ++ */ ++extern inline void ubicom32_set_interrupt(u8_t interrupt) ++{ ++ u32_t ibit = INT_BIT_MASK(interrupt); ++ ++ if (INT_REG(interrupt) == INT_REG(INT_CHIP(0, 0))) { ++ asm volatile ( ++ "move.4 "D(INT_SET(INT_CHIP(0, 0)))", %0\n\t" ++ : ++ : "r" (ibit) ++ ); ++ ++ return; ++ } ++ ++ asm volatile ( ++ "move.4 "D(INT_SET(INT_CHIP(1, 0)))", %0\n\t" ++ : ++ : "r" (ibit) ++ ); ++} ++ ++/* ++ * ubicom32_clear_interrupt() ++ */ ++extern inline void ubicom32_clear_interrupt(u8_t interrupt) ++{ ++ u32_t ibit = INT_BIT_MASK(interrupt); ++ ++ if (INT_REG(interrupt) == INT_REG(INT_CHIP(0, 0))) { ++ asm volatile ( ++ "move.4 "D(INT_CLR(INT_CHIP(0, 0)))", %0\n\t" ++ : ++ : "r" (ibit) ++ ); ++ ++ return; ++ } ++ ++ asm volatile ( ++ "move.4 "D(INT_CLR(INT_CHIP(1, 0)))", %0\n\t" ++ : ++ : "r" (ibit) ++ ); ++} ++ ++/* ++ * ubicom32_enable_interrupt() ++ */ ++extern inline void ubicom32_enable_interrupt(u8_t interrupt) ++{ ++ u32_t ibit = INT_BIT_MASK(interrupt); ++ ++ if (INT_REG(interrupt) == INT_REG(INT_CHIP(0, 0))) { ++ asm volatile ( ++ "or.4 "D(INT_MASK(INT_CHIP(0, 0)))", "D(INT_MASK(INT_CHIP(0, 0)))", %0\n\t" ++ : ++ : "d" (ibit) ++ ); ++ ++ return; ++ } ++ ++ asm volatile ( ++ "or.4 "D(INT_MASK(INT_CHIP(1, 0)))", "D(INT_MASK(INT_CHIP(1, 0)))", %0\n\t" ++ : ++ : "d" (ibit) ++ ); ++} ++ ++/* ++ * ubicom32_disable_interrupt() ++ */ ++extern inline void ubicom32_disable_interrupt(u8_t interrupt) ++{ ++ u32_t ibit = ~INT_BIT_MASK(interrupt); ++ ++ if (INT_REG(interrupt) == INT_REG(INT_CHIP(0, 0))) { ++ asm volatile ( ++ "and.4 "D(INT_MASK(INT_CHIP(0, 0)))", "D(INT_MASK(INT_CHIP(0, 0)))", %0\n\t" ++ : ++ : "d" (ibit) ++ ); ++ ++ return; ++ } ++ ++ asm volatile ( ++ "and.4 "D(INT_MASK(INT_CHIP(1, 0)))", "D(INT_MASK(INT_CHIP(1, 0)))", %0\n\t" ++ : ++ : "d" (ibit) ++ ); ++} ++ ++/* ++ * ubicom32_enable_global_interrupts() ++ */ ++extern inline void ubicom32_enable_global_interrupts(void) ++{ ++ asm volatile( ++ "bset GLOBAL_CTRL, GLOBAL_CTRL, #%bit("D(GLOBAL_CTRL_INT_EN)")" ++ ); ++} ++ ++/* ++ * ubicom32_disable_global_interrupts() ++ */ ++extern inline void ubicom32_disable_global_interrupts(void) ++{ ++ asm volatile( ++ "bclr GLOBAL_CTRL, GLOBAL_CTRL, #%bit("D(GLOBAL_CTRL_INT_EN)")" ++ ); ++} ++ ++/* ++ * ubicom32_get_reset_reason() ++ */ ++extern inline u32_t ubicom32_get_reset_reason(void) ++{ ++ return *(u32_t *)(GENERAL_CFG_BASE + GEN_RESET_REASON); ++} ++ ++/* ++ * ubicom32_read_reg() ++ */ ++extern inline u32_t ubicom32_read_reg(volatile void *reg) ++{ ++ u32_t v; ++ asm volatile ( ++ "move.4 %[dest], %[src] \n\t" ++ : [dest] "=r" (v) ++ : [src] "m" (*(u32_t *)reg) ++ ); ++ return v; ++} ++ ++/* ++ * ubicom32_write_reg() ++ */ ++extern inline void ubicom32_write_reg(volatile void *reg, u32_t v) ++{ ++ asm volatile ( ++ "move.4 %[dest], %[src] \n\t" ++ : ++ : [src] "r" (v), [dest] "m" (*(u32_t *)reg) ++ ); ++} ++ ++#endif /* __ASSEMBLY__ */ ++#endif /* _ASM_UBICOM32_IP5000_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ipcbuf.h linux-2.6.28.10/arch/ubicom32/include/asm/ipcbuf.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ipcbuf.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ipcbuf.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,55 @@ ++/* ++ * arch/ubicom32/include/asm/ipcbuf.h ++ * Definition of ipc64_perm struct for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_IPCBUF_H ++#define _ASM_UBICOM32_IPCBUF_H ++ ++/* ++ * The user_ipc_perm structure for m68k architecture. ++ * Note extra padding because this structure is passed back and forth ++ * between kernel and user space. ++ * ++ * Pad space is left for: ++ * - 32-bit mode_t and seq ++ * - 2 miscellaneous 32-bit values ++ */ ++struct ipc64_perm ++{ ++ __kernel_key_t key; ++ __kernel_uid32_t uid; ++ __kernel_gid32_t gid; ++ __kernel_uid32_t cuid; ++ __kernel_gid32_t cgid; ++ __kernel_mode_t mode; ++ unsigned short __pad1; ++ unsigned short seq; ++ unsigned short __pad2; ++ unsigned long __unused1; ++ unsigned long __unused2; ++}; ++ ++#endif /* _ASM_UBICOM32_IPCBUF_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/irqflags.h linux-2.6.28.10/arch/ubicom32/include/asm/irqflags.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/irqflags.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/irqflags.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,94 @@ ++/* ++ * arch/ubicom32/include/asm/irqflags.h ++ * Raw implementation of local IRQ functions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_IRQFLAGS_H ++#define _ASM_UBICOM32_IRQFLAGS_H ++ ++#include ++#include ++#include ++#include ++ ++#if defined(CONFIG_PREEMPT) ++#error Not supported by Ubicom32 irq handling, yet! ++#endif ++ ++/* ++ * raw_local_irq_enable() ++ * Enable interrupts for this thread. ++ */ ++static inline void raw_local_irq_enable(void) ++{ ++ ldsr_local_irq_enable(); ++} ++ ++/* ++ * raw_local_irq_disable() ++ * Disable interrupts for this thread. ++ */ ++static inline void raw_local_irq_disable(void) ++{ ++ ldsr_local_irq_disable(); ++} ++ ++/* ++ * raw_local_save_flags() ++ * Get the current IRQ state. ++ */ ++#define raw_local_save_flags(flags) \ ++do { \ ++ (flags) = ldsr_local_irq_is_disabled(); \ ++} while (0) ++ ++/* ++ * raw_local_irq_save() ++ * Save the current interrupt state and disable interrupts. ++ */ ++#define raw_local_irq_save(flags) \ ++do { \ ++ (flags) = ldsr_local_irq_save(); \ ++} while (0) ++ ++/* ++ * raw_local_irq_restore() ++ * Restore the IRQ state back to flags. ++ */ ++static inline void raw_local_irq_restore(unsigned long flags) ++{ ++ ldsr_local_irq_restore(flags); ++} ++ ++/* ++ * raw_irqs_disabled_flags() ++ * Return true if the flags indicate that IRQ(s) are disabled. ++ */ ++static inline int raw_irqs_disabled_flags(unsigned long flags) ++{ ++ return (flags); ++} ++ ++#endif /* _ASM_UBICOM32_IRQFLAGS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/irq.h linux-2.6.28.10/arch/ubicom32/include/asm/irq.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/irq.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/irq.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,45 @@ ++/* ++ * arch/ubicom32/include/asm/irq.h ++ * IRQ definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_IRQ_H ++#define _ASM_UBICOM32_IRQ_H ++ ++#include ++ ++/* ++ * We setup the IRQS to cover the full range of interrupt registers in ++ * processor. ++ */ ++#define NR_IRQS 64 ++ ++#define irq_canonicalize(irq) (irq) ++ ++extern int irq_soft_alloc(unsigned int *soft); ++extern void ack_bad_irq(unsigned int irq); ++extern void do_IRQ(int irq, struct pt_regs *fp); ++ ++#endif /* _ASM_UBICOM32_IRQ_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/irq_regs.h linux-2.6.28.10/arch/ubicom32/include/asm/irq_regs.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/irq_regs.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/irq_regs.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/irq_regs.h ++ * Generic irq_regs.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_IRQ_REGS_H ++#define _ASM_UBICOM32_IRQ_REGS_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_IRQ_REGS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/Kbuild linux-2.6.28.10/arch/ubicom32/include/asm/Kbuild +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/Kbuild 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/Kbuild 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1 @@ ++include include/asm-generic/Kbuild.asm +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/kdebug.h linux-2.6.28.10/arch/ubicom32/include/asm/kdebug.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/kdebug.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/kdebug.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/kdebug.h ++ * Generic kdebug.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_KDEBUG_H ++#define _ASM_UBICOM32_KDEBUG_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_KDEBUG_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/kmap_types.h linux-2.6.28.10/arch/ubicom32/include/asm/kmap_types.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/kmap_types.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/kmap_types.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,48 @@ ++/* ++ * arch/ubicom32/include/asm/kmap_types.h ++ * Definition of km_type's for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_KMAP_TYPES_H ++#define _ASM_UBICOM32_KMAP_TYPES_H ++ ++enum km_type { ++ KM_BOUNCE_READ, ++ KM_SKB_SUNRPC_DATA, ++ KM_SKB_DATA_SOFTIRQ, ++ KM_USER0, ++ KM_USER1, ++ KM_BIO_SRC_IRQ, ++ KM_BIO_DST_IRQ, ++ KM_PTE0, ++ KM_PTE1, ++ KM_IRQ0, ++ KM_IRQ1, ++ KM_SOFTIRQ0, ++ KM_SOFTIRQ1, ++ KM_TYPE_NR ++}; ++ ++#endif /* _ASM_UBICOM32_KMAP_TYPES_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ldsr.h linux-2.6.28.10/arch/ubicom32/include/asm/ldsr.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ldsr.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ldsr.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,186 @@ ++/* ++ * arch/ubicom32/include/asm/ldsr.h ++ * Ubicom32 LDSR interface definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_LDSR_H ++#define _ASM_UBICOM32_LDSR_H ++ ++#include ++#include ++#include ++ ++extern unsigned int ldsr_soft_irq_mask; ++ ++/* ++ * ldsr_local_irq_is_disabled() ++ * Test if interrupts are disabled for this thread? ++ */ ++static inline int ldsr_local_irq_is_disabled(void) ++{ ++ int ret; ++ thread_t self = thread_get_self(); ++ unsigned int mask = (1 << self); ++ ++ asm volatile ( ++ " and.4 %0, scratchpad1, %1 \n\t" ++ : "=r" (ret) ++ : "d" (mask) ++ : "cc" ++ ); ++ ++ /* ++ * We return a simple 1 == disabled, 0 == enabled ++ * losing which tid this is for, because Linux ++ * can restore interrupts on a different thread. ++ */ ++ return ret >> self; ++} ++ ++/* ++ * ldsr_local_irq_save() ++ * Get the current interrupt state and disable interrupts. ++ */ ++static inline unsigned int ldsr_local_irq_save(void) ++{ ++ int ret; ++ thread_t self = thread_get_self(); ++ unsigned int mask = (1 << self); ++ ++ /* ++ * Ensure the compiler can not optimize out the code ++ * (volatile) and that it does not "cache" values around ++ * the interrupt state change (memory). This ensures ++ * that interrupt changes are treated as a critical ++ * section. ++ */ ++ asm volatile ( ++ " and.4 %0, scratchpad1, %1 \n\t" ++ " or.4 scratchpad1, scratchpad1, %1 \n\t" ++ : "=&r" (ret) ++ : "d" (mask) ++ : "cc", "memory" ++ ); ++ ++ /* ++ * We return a simple 1 == disabled, 0 == enabled ++ * losing which tid this is for, because Linux ++ * can restore interrupts on a different thread. ++ */ ++ return ret >> self; ++} ++ ++/* ++ * ldsr_local_irq_restore() ++ * Restore this cpu's interrupt enable/disable state. ++ * ++ * Note: flags is either 0 or 1. ++ */ ++static inline void ldsr_local_irq_restore(unsigned int flags) ++{ ++ unsigned int temp; ++ thread_t self = thread_get_self(); ++ unsigned int mask = (1 << self); ++ flags = (flags << self); ++ ++ /* ++ * Ensure the compiler can not optimize out the code ++ * (volatile) and that it does not "cache" values around ++ * the interrupt state change (memory). This ensures ++ * that interrupt changes are treated as a critical ++ * section. ++ * ++ * Atomic change to our bit in scratchpad1 without ++ * causing any temporary glitch in the value and ++ * without effecting other values. Also this uses ++ * no branches so no penalties. ++ */ ++ asm volatile ( ++ " xor.4 %0, scratchpad1, %1 \n\t" ++ " and.4 %0, %2, %0 \n\t" ++ " xor.4 scratchpad1, scratchpad1, %0 \n\t" ++ " move.4 int_set0, %3 \n\t" ++ : "=&d"(temp) ++ : "d"(flags), "r"(mask), "r"(ldsr_soft_irq_mask) ++ : "cc", "memory" ++ ); ++} ++ ++/* ++ * ldsr_local_irq_disable_interrupt() ++ * Disable ints for this thread. ++ */ ++static inline void ldsr_local_irq_disable(void) ++{ ++ unsigned int mask = (1 << thread_get_self()); ++ ++ /* ++ * Ensure the compiler can not optimize out the code ++ * (volatile) and that it does not "cache" values around ++ * the interrupt state change (memory). This ensures ++ * that interrupt changes are treated as a critical ++ * section. ++ */ ++ asm volatile ( ++ " or.4 scratchpad1, scratchpad1, %0 \n\t" ++ : ++ : "d" (mask) ++ : "cc", "memory" ++ ); ++} ++ ++/* ++ * ldsr_local_irq_enable_interrupt ++ * Enable ints for this thread. ++ */ ++static inline void ldsr_local_irq_enable(void) ++{ ++ unsigned int mask = (1 << thread_get_self()); ++ ++ /* ++ * Ensure the compiler can not optimize out the code ++ * (volatile) and that it does not "cache" values around ++ * the interrupt state change (memory). This ensures ++ * that interrupt changes are treated as a critical ++ * section. ++ */ ++ asm volatile ( ++ " and.4 scratchpad1, scratchpad1, %0 \n\t" ++ " move.4 int_set0, %1 \n\t" ++ : ++ : "d" (~mask), "r" (ldsr_soft_irq_mask) ++ : "cc", "memory" ++ ); ++} ++ ++extern void ldsr_init(void); ++extern void ldsr_set_trap_irq(unsigned int irq); ++extern void ldsr_mask_vector(unsigned int vector); ++extern void ldsr_unmask_vector(unsigned int vector); ++extern void ldsr_enable_vector(unsigned int vector); ++extern void ldsr_disable_vector(unsigned int vector); ++extern thread_t ldsr_get_threadid(void); ++ ++#endif /* _ASM_UBICOM32_LDSR_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/linkage.h linux-2.6.28.10/arch/ubicom32/include/asm/linkage.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/linkage.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/linkage.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,34 @@ ++/* ++ * arch/ubicom32/include/asm/linkage.h ++ * Definition of Ubicom32 architecture specific linkage types. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_LINKAGE_H ++#define _ASM_UBICOM32_LINKAGE_H ++ ++#define __ocm_text __section(.ocm_text) ++#define __ocm_data __section(.ocm_data) ++ ++#endif /* _ASM_UBICOM32_LINKAGE_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/local.h linux-2.6.28.10/arch/ubicom32/include/asm/local.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/local.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/local.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/local.h ++ * Generic local.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_LOCAL_H ++#define _ASM_UBICOM32_LOCAL_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_LOCAL_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/machdep.h linux-2.6.28.10/arch/ubicom32/include/asm/machdep.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/machdep.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/machdep.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,43 @@ ++/* ++ * arch/ubicom32/include/asm/machdep.h ++ * Machine dependent utility routines. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_MACHDEP_H ++#define _ASM_UBICOM32_MACHDEP_H ++ ++#include ++ ++/* Hardware clock functions */ ++extern unsigned long hw_timer_offset(void); ++ ++/* machine dependent power off functions */ ++extern void (*mach_reset)(void); ++extern void (*mach_halt)(void); ++extern void (*mach_power_off)(void); ++ ++extern void config_BSP(char *command, int len); ++ ++#endif /* _ASM_UBICOM32_MACHDEP_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/mc146818rtc.h linux-2.6.28.10/arch/ubicom32/include/asm/mc146818rtc.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/mc146818rtc.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/mc146818rtc.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,36 @@ ++/* ++ * arch/ubicom32/include/asm/mc146818rtc.h ++ * Generic mc146818rtc.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++/* ++ * Machine dependent access functions for RTC registers. ++ */ ++#ifndef _ASM_UBICOM32_MC146818RTC_H ++#define _ASM_UBICOM32_MC146818RTC_H ++ ++/* empty include file to satisfy the include in genrtc.c/ide-geometry.c */ ++ ++#endif /* _ASM_UBICOM32_MC146818RTC_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/mman.h linux-2.6.28.10/arch/ubicom32/include/asm/mman.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/mman.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/mman.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,44 @@ ++/* ++ * arch/ubicom32/include/asm/mman.h ++ * Memory mapping definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_MMAN_H ++#define _ASM_UBICOM32_MMAN_H ++ ++#include ++ ++#define MAP_GROWSDOWN 0x0100 /* stack-like segment */ ++#define MAP_DENYWRITE 0x0800 /* ETXTBSY */ ++#define MAP_EXECUTABLE 0x1000 /* mark it as an executable */ ++#define MAP_LOCKED 0x2000 /* pages are locked */ ++#define MAP_NORESERVE 0x4000 /* don't check for reservations */ ++#define MAP_POPULATE 0x8000 /* populate (prefault) pagetables */ ++#define MAP_NONBLOCK 0x10000 /* do not block on IO */ ++ ++#define MCL_CURRENT 1 /* lock all current mappings */ ++#define MCL_FUTURE 2 /* lock all future mappings */ ++ ++#endif /* _ASM_UBICOM32_MMAN_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/mmu_context.h linux-2.6.28.10/arch/ubicom32/include/asm/mmu_context.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/mmu_context.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/mmu_context.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,60 @@ ++/* ++ * arch/ubicom32/include/asm/mmu_context.h ++ * MMU context definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * Copyright (C) 2004, Microtronix Datacom Ltd., All rights reserved. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_MMU_CONTEXT_H ++#define _ASM_UBICOM32_MMU_CONTEXT_H ++ ++#include ++#include ++#include ++ ++static inline void enter_lazy_tlb(struct mm_struct *mm, struct task_struct *tsk) ++{ ++} ++ ++extern inline int ++init_new_context(struct task_struct *tsk, struct mm_struct *mm) ++{ ++ // mm->context = virt_to_phys(mm->pgd); ++ return(0); ++} ++ ++#define destroy_context(mm) do { } while(0) ++ ++static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next, struct task_struct *tsk) ++{ ++} ++ ++#define deactivate_mm(tsk,mm) do { } while (0) ++ ++extern inline void activate_mm(struct mm_struct *prev_mm, struct mm_struct *next_mm) ++{ ++} ++ ++#endif /* _ASM_UBICOM32_MMU_CONTEXT_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/mmu.h linux-2.6.28.10/arch/ubicom32/include/asm/mmu.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/mmu.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/mmu.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,41 @@ ++/* ++ * arch/ubicom32/include/asm/mmu.h ++ * Definition of mm_context_t struct for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * Copyright (C) 2002, David McCullough ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_MMU_H ++#define _ASM_UBICOM32_MMU_H ++ ++typedef struct { ++ struct vm_list_struct *vmlist; ++ unsigned long end_brk; ++#ifdef CONFIG_BINFMT_ELF_FDPIC ++ unsigned long exec_fdpic_loadmap; ++ unsigned long interp_fdpic_loadmap; ++#endif ++} mm_context_t; ++ ++#endif /* _ASM_UBICOM32_MMU_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/module.h linux-2.6.28.10/arch/ubicom32/include/asm/module.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/module.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/module.h 2009-08-12 13:08:37.000000000 +0300 +@@ -0,0 +1,44 @@ ++/* ++ * arch/ubicom32/include/asm/module.h ++ * Ubicom32 architecture specific module definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_MODULE_H ++#define _ASM_UBICOM32_MODULE_H ++ ++struct mod_arch_specific { ++ void *ocm_inst; ++ int ocm_inst_size; ++}; ++ ++#define Elf_Shdr Elf32_Shdr ++#define Elf_Sym Elf32_Sym ++#define Elf_Ehdr Elf32_Ehdr ++ ++#define ARCH_PROC_MODULES_EXTRA(m,mod) \ ++ seq_printf(m, " OCM(%d bytes @ 0x%p)", \ ++ (mod)->arch.ocm_inst_size, (mod)->arch.ocm_inst) ++ ++#endif /* _ASM_UBICOM32_MODULE_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/msgbuf.h linux-2.6.28.10/arch/ubicom32/include/asm/msgbuf.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/msgbuf.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/msgbuf.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,58 @@ ++/* ++ * arch/ubicom32/include/asm/msgbuf.h ++ * Definition of msqid64_ds struct for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_MSGBUF_H ++#define _ASM_UBICOM32_MSGBUF_H ++ ++/* ++ * The msqid64_ds structure for ubicom32 architecture. ++ * Note extra padding because this structure is passed back and forth ++ * between kernel and user space. ++ * ++ * Pad space is left for: ++ * - 64-bit time_t to solve y2038 problem ++ * - 2 miscellaneous 32-bit values ++ */ ++ ++struct msqid64_ds { ++ struct ipc64_perm msg_perm; ++ __kernel_time_t msg_stime; /* last msgsnd time */ ++ unsigned long __unused1; ++ __kernel_time_t msg_rtime; /* last msgrcv time */ ++ unsigned long __unused2; ++ __kernel_time_t msg_ctime; /* last change time */ ++ unsigned long __unused3; ++ unsigned long msg_cbytes; /* current number of bytes on queue */ ++ unsigned long msg_qnum; /* number of messages in queue */ ++ unsigned long msg_qbytes; /* max number of bytes on queue */ ++ __kernel_pid_t msg_lspid; /* pid of last msgsnd */ ++ __kernel_pid_t msg_lrpid; /* last receive pid */ ++ unsigned long __unused4; ++ unsigned long __unused5; ++}; ++ ++#endif /* _ASM_UBICOM32_MSGBUF_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/mutex.h linux-2.6.28.10/arch/ubicom32/include/asm/mutex.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/mutex.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/mutex.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,41 @@ ++/* ++ * arch/ubicom32/include/asm/mutex.h ++ * Generic mutex.h for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++/* ++ * Pull in the generic implementation for the mutex fastpath. ++ * ++ * TODO: implement optimized primitives instead, or leave the generic ++ * implementation in place, or pick the atomic_xchg() based generic ++ * implementation. (see asm-generic/mutex-xchg.h for details) ++ */ ++ ++#ifndef _ASM_UBICOM32_MUTEX_H ++#define _ASM_UBICOM32_MUTEX_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_MUTEX_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/namei.h linux-2.6.28.10/arch/ubicom32/include/asm/namei.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/namei.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/namei.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,38 @@ ++/* ++ * arch/ubicom32/include/asm/namei.h ++ * Definition of __emul_prefix() for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_NAMEI_H ++#define _ASM_UBICOM32_NAMEI_H ++ ++/* This dummy routine maybe changed to something useful ++ * for /usr/gnemul/ emulation stuff. ++ * Look at asm-sparc/namei.h for details. ++ */ ++ ++#define __emul_prefix() NULL ++ ++#endif /* _ASM_UBICOM32_NAMEI_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ocm-alloc.h linux-2.6.28.10/arch/ubicom32/include/asm/ocm-alloc.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ocm-alloc.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ocm-alloc.h 2009-08-12 13:08:37.000000000 +0300 +@@ -0,0 +1,36 @@ ++/* ++ * arch/ubicom32/include/asm/ocm-alloc.h ++ * Ubicom32 architecture specific ocm definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_OCM_ALLOC_H ++#define _ASM_UBICOM32_OCM_ALLOC_H ++ ++ ++extern void *ocm_inst_alloc(size_t size, pid_t pid); ++extern int ocm_free(const void *ptr); ++extern int ocm_inst_free(const void *ptr); ++ ++#endif /* _ASM_UBICOM32_OCM_ALLOC_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ocm_size.h linux-2.6.28.10/arch/ubicom32/include/asm/ocm_size.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ocm_size.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ocm_size.h 2009-08-06 11:15:34.000000000 +0300 +@@ -0,0 +1,2 @@ ++#define APP_OCM_CODE_SIZE (0x3ffc2e00-0x3ffc0000) ++#define APP_OCM_DATA_SIZE (0x3ffd3500-0x3ffc8000) +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ocm_text.lds.inc linux-2.6.28.10/arch/ubicom32/include/asm/ocm_text.lds.inc +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ocm_text.lds.inc 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ocm_text.lds.inc 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,175 @@ ++/* ++ * arch/ubicom32/include/asm/ocm_text.lds.inc ++ * ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++*(.text.do_csum) ++*(.text.tcp_packet) ++*(.text.ipt_do_table) ++*(.text.nf_conntrack_in) ++*(.text.ip_forward) ++*(.text.dev_queue_xmit) ++*(.text.netif_receive_skb) ++*(.text.ip_route_input) ++*(.text.ip_finish_output) ++*(.text.nf_iterate) ++*(.text.__hash_conntrack) ++*(.text.memset) ++*(.text.memcpy) ++*(.text.ip_rcv) ++*(.text.__nf_conntrack_find) ++*(.text.dev_hard_start_xmit) ++*(.text.vlan_dev_hard_start_xmit) ++*(.text.vlan_dev_hard_header) ++*(.text.__nf_ct_refresh_acct) ++*(.text.tcp_error) ++*(.text.pfifo_fast_enqueue) ++*(.text.ipv4_confirm) ++*(.text.ip_output) ++*(.text.neigh_connected_output) ++*(.text.nf_hook_slow) ++*(.text.nf_nat_packet) ++*(.text.local_bh_enable) ++*(.text.pfifo_fast_dequeue) ++*(.text.ubi32_eth_receive) ++*(.text.nf_nat_fn) ++*(.text.skb_checksum) ++*(.text.memmove) ++*(.text.ubi32_eth_tx_done) ++*(.text.eth_header) ++*(.text.skb_release_data) ++*(.text.nf_conntrack_find_get) ++*(.text.process_backlog) ++*(.text.vlan_skb_recv) ++*(.text.ip_rcv_finish) ++*(.text.__qdisc_run) ++*(.text.skb_push) ++*(.text.eth_type_trans) ++*(.text.__alloc_skb) ++*(.text.netif_rx) ++*(.text.nf_ip_checksum) ++*(.text.__skb_checksum_complete_head) ++*(.text.ipv4_conntrack_defrag) ++*(.text.tcp_pkt_to_tuple) ++*(.text.kfree) ++*(.text.tcp_manip_pkt) ++*(.text.skb_put) ++*(.text.nf_ct_get_tuple) ++*(.text.__kmalloc) ++*(.text.ubi32_eth_start_xmit) ++*(.text.free_block) ++*(.text.ipt_hook) ++*(.text.kmem_cache_free) ++*(.text.skb_pull_rcsum) ++*(.text.cache_alloc_refill) ++*(.text.skb_release_head_state) ++*(.text.manip_pkt) ++*(.text.ip_sabotage_in) ++*(.text.ip_forward_finish) ++*(.text.kmem_cache_alloc) ++*(.text.local_bh_disable) ++*(.text.ipv4_pkt_to_tuple) ++*(.text.inet_proto_csum_replace4) ++*(.text.__nf_ct_l4proto_find) ++*(.text.csum_partial) ++*(.text.neigh_resolve_output) ++*(.text.__kfree_skb) ++*(.text.kfree_skb) ++*(.text.__find_vlan_dev) ++*(.text.ldsr_ctxsw_thread) ++*(.text.__do_IRQ) ++*(.text.skb_pull) ++*(.text.ipv4_invert_tuple) ++*(.text.nf_ct_invert_tuplepr) ++*(.text.skb_make_writable) ++*(.text.ipv4_get_l4proto) ++*(.text.handle_IRQ_event) ++*(.text.net_rx_action) ++*(.text.__do_softirq) ++*(.text.nf_nat_in) ++*(.text.note_interrupt) ++*(.text.ipv4_conntrack_in) ++*(.text.dst_release) ++*(.text.tasklet_action) ++*(.text.nf_nat_out) ++*(.text.nf_ct_invert_tuple) ++*(.text.do_IRQ) ++*(.text.__tasklet_schedule) ++*(.text.__skb_checksum_complete) ++*(.text.ubi32_eth_interrupt) ++*(.text.dev_kfree_skb_any) ++*(.text.ret_from_interrupt_to_kernel) ++*(.text.preemptive_context_save) ++*(.text.irq_ack_vector) ++*(.text.update_wall_time) ++*(.text.ldsr_thread) ++*(.text.irq_exit) ++*(.text.ubi32_eth_do_tasklet) ++*(.text.__napi_schedule) ++*(.text.idle_cpu) ++*(.text.run_timer_softirq) ++*(.text.ldsr_mask_vector) ++*(.text.irq_enter) ++*(.text.ldsr_get_lsb) ++*(.text.ldsr_unmask_vector) ++*(.text.ip_fast_csum) ++*(.text.hrtimer_run_queues) ++*(.text.tcp_invert_tuple) ++*(.text.T___705) ++*(.text.run_posix_cpu_timers) ++*(.text.free_hot_cold_page) ++*(.text.lock_timer_base) ++*(.text.calc_delta_mine) ++*(.text.slab_destroy) ++*(.text.rcu_pending) ++*(.text.scheduler_tick) ++*(.text.hrtimer_run_pending) ++*(.text.do_softirq) ++*(.text.del_timer) ++*(.text.irq_end_vector) ++*(.text.pci_read_u32) ++*(.text.udivmodsi4) ++*(.text.memcmp) ++*(.text.memset) ++*(.text.__slab_alloc) ++*(.text.br_handle_frame) ++*(.text.br_fdb_update) ++*(.text.__br_fdb_get) ++*(.text.br_forward) ++*(.text.br_handle_frame_finish) ++*(.text.pci_write_u32) ++*(.text.kmem_freepages) ++*(.text.br_dev_queue_push_xmit) ++*(.text.ioread32) ++*(.text.next_zones_zonelist) ++*(.text.ubi32_pci_read_u32) ++*(.text.zone_watermark_ok) ++*(.text.__rmqueue_smallest) ++*(.text.ubi32_eth_napi_poll) ++*(.text.ubi32_pci_write_u32) ++*(.text.ubi32_pci_read_u32) ++*(.text._local_bh_enable) ++*(.text._local_bh_disable) ++*(.text.get_slab) +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/page.h linux-2.6.28.10/arch/ubicom32/include/asm/page.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/page.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/page.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,106 @@ ++/* ++ * arch/ubicom32/include/asm/page.h ++ * Memory page related operations and definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_PAGE_H ++#define _ASM_UBICOM32_PAGE_H ++ ++/* PAGE_SHIFT determines the page size */ ++ ++#define PAGE_SHIFT 12 ++#define PAGE_SIZE (1 << PAGE_SHIFT) ++#define PAGE_MASK (~(PAGE_SIZE-1)) ++ ++#include ++ ++#ifndef __ASSEMBLY__ ++ ++#define get_user_page(vaddr) __get_free_page(GFP_KERNEL) ++#define free_user_page(page, addr) free_page(addr) ++ ++#define clear_page(page) memset((page), 0, PAGE_SIZE) ++#define copy_page(to,from) memcpy((to), (from), PAGE_SIZE) ++ ++#define clear_user_page(page, vaddr, pg) clear_page(page) ++#define copy_user_page(to, from, vaddr, pg) copy_page(to, from) ++ ++#define __alloc_zeroed_user_highpage(movableflags, vma, vaddr) \ ++ alloc_page_vma(GFP_HIGHUSER | __GFP_ZERO | movableflags, vma, vaddr) ++#define __HAVE_ARCH_ALLOC_ZEROED_USER_HIGHPAGE ++ ++/* ++ * These are used to make use of C type-checking.. ++ */ ++typedef struct { unsigned long pte; } pte_t; ++typedef struct { unsigned long pmd[16]; } pmd_t; ++typedef struct { unsigned long pgd; } pgd_t; ++typedef struct { unsigned long pgprot; } pgprot_t; ++typedef struct page *pgtable_t; ++ ++#define pte_val(x) ((x).pte) ++#define pmd_val(x) ((&x)->pmd[0]) ++#define pgd_val(x) ((x).pgd) ++#define pgprot_val(x) ((x).pgprot) ++ ++#define __pte(x) ((pte_t) { (x) } ) ++#define __pmd(x) ((pmd_t) { (x) } ) ++#define __pgd(x) ((pgd_t) { (x) } ) ++#define __pgprot(x) ((pgprot_t) { (x) } ) ++ ++extern unsigned long memory_start; ++extern unsigned long memory_end; ++ ++#endif /* !__ASSEMBLY__ */ ++ ++#include ++ ++#define PAGE_OFFSET (PAGE_OFFSET_RAW) ++ ++#ifndef __ASSEMBLY__ ++ ++#define __pa(vaddr) virt_to_phys((void *)(vaddr)) ++#define __va(paddr) phys_to_virt((unsigned long)(paddr)) ++ ++#define virt_to_pfn(kaddr) (__pa(kaddr) >> PAGE_SHIFT) ++#define pfn_to_virt(pfn) __va((pfn) << PAGE_SHIFT) ++ ++#define virt_to_page(addr) (mem_map + (((unsigned long)(addr)-PAGE_OFFSET) >> PAGE_SHIFT)) ++#define page_to_virt(page) ((((page) - mem_map) << PAGE_SHIFT) + PAGE_OFFSET) ++ ++#define pfn_to_page(pfn) virt_to_page(pfn_to_virt(pfn)) ++#define page_to_pfn(page) virt_to_pfn(page_to_virt(page)) ++#define pfn_valid(pfn) ((pfn) < max_mapnr) ++ ++#define virt_addr_valid(kaddr) (((void *)(kaddr) >= (void *)PAGE_OFFSET) && \ ++ ((void *)(kaddr) < (void *)memory_end)) ++ ++#endif /* __ASSEMBLY__ */ ++ ++#ifdef __KERNEL__ ++#include ++#endif ++ ++#endif /* _ASM_UBICOM32_PAGE_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/page_offset.h linux-2.6.28.10/arch/ubicom32/include/asm/page_offset.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/page_offset.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/page_offset.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,35 @@ ++/* ++ * arch/ubicom32/include/asm/page_offset.h ++ * Definition of PAGE_OFFSET_RAW for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_PAGE_OFFSET_H ++#define _ASM_UBICOM32_PAGE_OFFSET_H ++ ++/* This handles the memory map.. */ ++#define PAGE_OFFSET_RAW 0x3ffc0000 ++ ++#endif /* _ASM_UBICOM32_PAGE_OFFSET_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/param.h linux-2.6.28.10/arch/ubicom32/include/asm/param.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/param.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/param.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,49 @@ ++/* ++ * arch/ubicom32/include/asm/param.h ++ * Definition of miscellaneous constants, including HZ. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_PARAM_H ++#define _ASM_UBICOM32_PARAM_H ++ ++#ifdef __KERNEL__ ++#define HZ CONFIG_HZ ++#define USER_HZ HZ ++#define CLOCKS_PER_SEC (USER_HZ) ++#endif ++ ++#ifndef HZ ++#define HZ 100 ++#endif ++ ++#define EXEC_PAGESIZE 4096 ++ ++#ifndef NOGROUP ++#define NOGROUP (-1) ++#endif ++ ++#define MAXHOSTNAMELEN 64 /* max length of hostname */ ++ ++#endif /* _ASM_UBICOM32_PARAM_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/pci.h linux-2.6.28.10/arch/ubicom32/include/asm/pci.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/pci.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/pci.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,210 @@ ++/* ++ * arch/ubicom32/include/asm/pci.h ++ * Definitions of PCI operations for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_PCI_H ++#define _ASM_UBICOM32_PCI_H ++ ++#include ++ ++/* The PCI address space does equal the physical memory ++ * address space. The networking and block device layers use ++ * this boolean for bounce buffer decisions. ++ */ ++#define PCI_DMA_BUS_IS_PHYS (1) ++ ++ ++ ++/* ++ * Perform a master read/write to the PCI bus. ++ * These functions return a PCI_RESP_xxx code. ++ */ ++extern u8 pci_read_u32(u8 pci_cmd, u32 address, u32 *data); ++extern u8 pci_write_u32(u8 pci_cmd, u32 address, u32 data); ++extern u8 pci_read_u16(u8 pci_cmd, u32 address, u16 *data); ++extern u8 pci_write_u16(u8 pci_cmd, u32 address, u16 data); ++extern u8 pci_read_u8(u8 pci_cmd, u32 address, u8 *data); ++extern u8 pci_write_u8(u8 pci_cmd, u32 address, u8 data); ++ ++ ++#define PCIBIOS_MIN_IO 0x100 ++#define PCIBIOS_MIN_MEM 0x10000000 ++ ++#define pcibios_assign_all_busses() 0 ++#define pcibios_scan_all_fns(a, b) 0 ++extern void pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region, ++ struct resource *res); ++ ++extern void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res, ++ struct pci_bus_region *region); ++ ++struct pci_sys_data; ++struct pci_bus; ++ ++struct hw_pci { ++ struct list_head buses; ++ int nr_controllers; ++ int (*setup)(int nr, struct pci_sys_data *); ++ struct pci_bus *(*scan)(int nr, struct pci_sys_data *); ++ void (*preinit)(void); ++ void (*postinit)(void); ++ u8 (*swizzle)(struct pci_dev *dev, u8 *pin); ++ int (*map_irq)(struct pci_dev *dev, u8 slot, u8 pin); ++}; ++ ++/* ++ * Per-controller structure ++ */ ++struct pci_sys_data { ++ struct list_head node; ++ int busnr; /* primary bus number */ ++ u64 mem_offset; /* bus->cpu memory mapping offset */ ++ unsigned long io_offset; /* bus->cpu IO mapping offset */ ++ struct pci_bus *bus; /* PCI bus */ ++ struct resource *resource[3]; /* Primary PCI bus resources */ ++ /* Bridge swizzling */ ++ u8 (*swizzle)(struct pci_dev *, u8 *); ++ /* IRQ mapping */ ++ int (*map_irq)(struct pci_dev *, u8, u8); ++ struct hw_pci *hw; ++}; ++ ++static inline struct resource * ++pcibios_select_root(struct pci_dev *pdev, struct resource *res) ++{ ++ struct resource *root = NULL; ++ ++ if (res->flags & IORESOURCE_IO) ++ root = &ioport_resource; ++ if (res->flags & IORESOURCE_MEM) ++ root = &iomem_resource; ++ ++ return root; ++} ++ ++static inline void pcibios_set_master(struct pci_dev *dev) ++{ ++ /* No special bus mastering setup handling */ ++} ++#define HAVE_ARCH_PCI_SET_DMA_MAX_SEGMENT_SIZE 1 ++#define HAVE_ARCH_PCI_SET_DMA_SEGMENT_BOUNDARY 1 ++ ++#ifdef CONFIG_PCI ++static inline void * pci_alloc_consistent(struct pci_dev *hwdev, size_t size, ++ dma_addr_t *dma_handle) ++{ ++ void *vaddr = kmalloc(size, GFP_KERNEL); ++ if(vaddr != NULL) { ++ *dma_handle = virt_to_phys(vaddr); ++ } ++ return vaddr; ++} ++ ++static inline int pci_dma_supported(struct pci_dev *hwdev, dma_addr_t mask) ++{ ++ return 1; ++} ++ ++static inline void pci_free_consistent(struct pci_dev *hwdev, size_t size, ++ void *cpu_addr, dma_addr_t dma_handle) ++{ ++ kfree(cpu_addr); ++ return; ++} ++ ++static inline dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, ++ size_t size, int direction) ++{ ++ return virt_to_phys(ptr); ++} ++ ++static inline void pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr, ++ size_t size, int direction) ++{ ++ return; ++} ++ ++static inline dma_addr_t ++pci_map_page(struct pci_dev *hwdev, struct page *page, ++ unsigned long offset, size_t size, int direction) ++{ ++ return pci_map_single(hwdev, page_address(page) + offset, size, (int)direction); ++} ++ ++static inline void ++pci_unmap_page(struct pci_dev *hwdev, dma_addr_t dma_address, ++ size_t size, int direction) ++{ ++ pci_unmap_single(hwdev, dma_address, size, direction); ++} ++ ++static inline int ++pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg, ++ int nents, int direction) ++{ ++ return nents; ++} ++ ++static inline void ++pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg, ++ int nents, int direction) ++{ ++} ++ ++static inline void ++pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg, ++ int nelems, int direction) ++{ ++} ++ ++static inline void ++pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg, ++ int nelems, int direction) ++{ ++} ++ ++static inline void ++pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle, ++ size_t size, int direction) ++{ ++} ++ ++static inline void ++pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle, ++ size_t size, int direction) ++{ ++} ++ ++static inline int ++pci_dma_mapping_error(struct pci_dev *hwdev, dma_addr_t dma_addr) ++{ ++ return dma_addr == 0; ++} ++extern void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max); ++extern void pci_iounmap(struct pci_dev *dev, void __iomem *); ++#endif ++ ++#endif /* _ASM_UBICOM32_PCI_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/percpu.h linux-2.6.28.10/arch/ubicom32/include/asm/percpu.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/percpu.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/percpu.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/percpu.h ++ * Generic percpu.h for the Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_PERCPU_H ++#define _ASM_UBICOM32_PERCPU_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_PERCPU_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/pgalloc.h linux-2.6.28.10/arch/ubicom32/include/asm/pgalloc.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/pgalloc.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/pgalloc.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,36 @@ ++/* ++ * arch/ubicom32/include/asm/pgalloc.h ++ * Page table allocation definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_PGALLOC_H ++#define _ASM_UBICOM32_PGALLOC_H ++ ++#include ++#include ++ ++#define check_pgt_cache() do { } while (0) ++ ++#endif /* _ASM_UBICOM32_PGALLOC_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/pgtable.h linux-2.6.28.10/arch/ubicom32/include/asm/pgtable.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/pgtable.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/pgtable.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,124 @@ ++/* ++ * arch/ubicom32/include/asm/pgtable.h ++ * Ubicom32 pseudo page table definitions and operations. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * Copyright (C) 2004 Microtronix Datacom Ltd ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ * and various works, Alpha, ix86, M68K, Sparc, ...et al ++ */ ++#ifndef _ASM_UBICOM32_PGTABLE_H ++#define _ASM_UBICOM32_PGTABLE_H ++ ++#include ++ ++//vic - this bit copied from m68knommu version ++#include ++#include ++#include ++ ++typedef pte_t *pte_addr_t; ++ ++#define pgd_present(pgd) (1) /* pages are always present on NO_MM */ ++#define pgd_none(pgd) (0) ++#define pgd_bad(pgd) (0) ++#define pgd_clear(pgdp) ++#define kern_addr_valid(addr) (1) ++#define pmd_offset(a, b) ((void *)0) ++ ++#define PAGE_NONE __pgprot(0) /* these mean nothing to NO_MM */ ++#define PAGE_SHARED __pgprot(0) /* these mean nothing to NO_MM */ ++#define PAGE_COPY __pgprot(0) /* these mean nothing to NO_MM */ ++#define PAGE_READONLY __pgprot(0) /* these mean nothing to NO_MM */ ++#define PAGE_KERNEL __pgprot(0) /* these mean nothing to NO_MM */ ++//vic - this bit copied from m68knommu version ++ ++extern void paging_init(void); ++#define swapper_pg_dir ((pgd_t *) 0) ++ ++#define __swp_type(x) (0) ++#define __swp_offset(x) (0) ++#define __swp_entry(typ,off) ((swp_entry_t) { ((typ) | ((off) << 7)) }) ++#define __pte_to_swp_entry(pte) ((swp_entry_t) { pte_val(pte) }) ++#define __swp_entry_to_pte(x) ((pte_t) { (x).val }) ++ ++/* ++ * pgprot_noncached() is only for infiniband pci support, and a real ++ * implementation for RAM would be more complicated. ++ */ ++#define pgprot_noncached(prot) (prot) ++ ++static inline int pte_file(pte_t pte) { return 0; } ++ ++/* ++ * ZERO_PAGE is a global shared page that is always zero: used ++ * for zero-mapped memory areas etc.. ++ */ ++#define ZERO_PAGE(vaddr) (virt_to_page(0)) ++ ++extern unsigned int kobjsize(const void *objp); ++extern int is_in_rom(unsigned long); ++ ++/* ++ * No page table caches to initialise ++ */ ++#define pgtable_cache_init() do { } while (0) ++ ++#define io_remap_pfn_range(vma, vaddr, pfn, size, prot) \ ++ remap_pfn_range(vma, vaddr, pfn, size, prot) ++ ++extern inline void flush_cache_mm(struct mm_struct *mm) ++{ ++} ++ ++extern inline void flush_cache_range(struct mm_struct *mm, ++ unsigned long start, ++ unsigned long end) ++{ ++} ++ ++/* Push the page at kernel virtual address and clear the icache */ ++extern inline void flush_page_to_ram (unsigned long address) ++{ ++} ++ ++/* Push n pages at kernel virtual address and clear the icache */ ++extern inline void flush_pages_to_ram (unsigned long address, int n) ++{ ++} ++ ++/* ++ * All 32bit addresses are effectively valid for vmalloc... ++ * Sort of meaningless for non-VM targets. ++ */ ++#define VMALLOC_START 0 ++#define VMALLOC_END 0xffffffff ++ ++#define arch_enter_lazy_mmu_mode() do {} while (0) ++#define arch_leave_lazy_mmu_mode() do {} while (0) ++#define arch_flush_lazy_mmu_mode() do {} while (0) ++#define arch_enter_lazy_cpu_mode() do {} while (0) ++#define arch_leave_lazy_cpu_mode() do {} while (0) ++#define arch_flush_lazy_cpu_mode() do {} while (0) ++ ++#endif /* _ASM_UBICOM32_PGTABLE_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/poll.h linux-2.6.28.10/arch/ubicom32/include/asm/poll.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/poll.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/poll.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,36 @@ ++/* ++ * arch/ubicom32/include/asm/poll.h ++ * Ubicom32 specific poll() related flags definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_POLL_H ++#define _ASM_UBICOM32_POLL_H ++ ++#define POLLWRNORM POLLOUT ++#define POLLWRBAND 0x0100 ++ ++#include ++ ++#endif /* _ASM_UBICOM32_POLL_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/posix_types.h linux-2.6.28.10/arch/ubicom32/include/asm/posix_types.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/posix_types.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/posix_types.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,93 @@ ++/* ++ * arch/ubicom32/include/asm/posix_types.h ++ * Ubicom32 architecture posix types. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * Copyright (C) 2004 Microtronix Datacom Ltd ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef __ARCH_UBICOM32_POSIX_TYPES_H ++#define __ARCH_UBICOM32_POSIX_TYPES_H ++ ++/* ++ * This file is generally used by user-level software, so you need to ++ * be a little careful about namespace pollution etc. Also, we cannot ++ * assume GCC is being used. ++ */ ++ ++typedef unsigned long __kernel_ino_t; ++typedef unsigned short __kernel_mode_t; ++typedef unsigned short __kernel_nlink_t; ++typedef long __kernel_off_t; ++typedef int __kernel_pid_t; ++typedef unsigned short __kernel_ipc_pid_t; ++typedef unsigned short __kernel_uid_t; ++typedef unsigned short __kernel_gid_t; ++typedef unsigned int __kernel_size_t; ++typedef int __kernel_ssize_t; ++typedef int __kernel_ptrdiff_t; ++typedef long __kernel_time_t; ++typedef long __kernel_suseconds_t; ++typedef long __kernel_clock_t; ++typedef int __kernel_timer_t; ++typedef int __kernel_clockid_t; ++typedef int __kernel_daddr_t; ++typedef char * __kernel_caddr_t; ++typedef unsigned short __kernel_uid16_t; ++typedef unsigned short __kernel_gid16_t; ++typedef unsigned int __kernel_uid32_t; ++typedef unsigned int __kernel_gid32_t; ++ ++typedef unsigned short __kernel_old_uid_t; ++typedef unsigned short __kernel_old_gid_t; ++typedef unsigned short __kernel_old_dev_t; ++ ++#ifdef __GNUC__ ++typedef long long __kernel_loff_t; ++#endif ++ ++typedef struct { ++#if defined(__KERNEL__) || defined(__USE_ALL) ++ int val[2]; ++#else /* !defined(__KERNEL__) && !defined(__USE_ALL) */ ++ int __val[2]; ++#endif /* !defined(__KERNEL__) && !defined(__USE_ALL) */ ++} __kernel_fsid_t; ++ ++#if defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2) ++ ++#undef __FD_SET ++#define __FD_SET(d, set) ((set)->fds_bits[__FDELT(d)] |= __FDMASK(d)) ++ ++#undef __FD_CLR ++#define __FD_CLR(d, set) ((set)->fds_bits[__FDELT(d)] &= ~__FDMASK(d)) ++ ++#undef __FD_ISSET ++#define __FD_ISSET(d, set) ((set)->fds_bits[__FDELT(d)] & __FDMASK(d)) ++ ++#undef __FD_ZERO ++#define __FD_ZERO(fdsetp) (memset (fdsetp, 0, sizeof(*(fd_set *)fdsetp))) ++ ++#endif /* defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2) */ ++ ++#endif +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/processor.h linux-2.6.28.10/arch/ubicom32/include/asm/processor.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/processor.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/processor.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,163 @@ ++/* ++ * arch/ubicom32/include/asm/processor.h ++ * Thread related definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * Copyright (C) 1995 Hamish Macdonald ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_PROCESSOR_H ++#define _ASM_UBICOM32_PROCESSOR_H ++ ++/* ++ * Default implementation of macro that returns current ++ * instruction pointer ("program counter"). ++ */ ++#define current_text_addr() ({ __label__ _l; _l: &&_l;}) ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#if defined(CONFIG_UBICOM32_V3) ++ #define CPU "IP5K" ++#endif ++#if defined(CONFIG_UBICOM32_V4) ++ #define CPU "IP7K" ++#endif ++#ifndef CPU ++ #define CPU "UNKNOWN" ++#endif ++ ++/* ++ * User space process size: 1st byte beyond user address space. ++ */ ++extern unsigned long memory_end; ++#define TASK_SIZE (memory_end) ++ ++/* ++ * This decides where the kernel will search for a free chunk of vm ++ * space during mmap's. We won't be using it ++ */ ++#define TASK_UNMAPPED_BASE 0 ++ ++/* ++ * This is the structure where we are going to save callee-saved registers. ++ * A5 is the return address, A7 is the stack pointer, A6 is the frame ++ * pointer. This is the frame that is created because of switch_to. This ++ * is not the frame due to interrupt preemption or because of syscall entry. ++ */ ++ ++struct thread_struct { ++ unsigned long d10; /* D10 */ ++ unsigned long d11; /* D11 */ ++ unsigned long d12; /* D12 */ ++ unsigned long d13; /* D13 */ ++ unsigned long a1; /* A1 */ ++ unsigned long a2; /* A2 */ ++ unsigned long a5; /* A5 return address. */ ++ unsigned long a6; /* A6 */ ++ unsigned long sp; /* A7 kernel stack pointer. */ ++}; ++ ++#define INIT_THREAD { \ ++ 0, 0, 0, 0, 0, 0, 0, 0, \ ++ sizeof(init_stack) + (unsigned long) init_stack - 8, \ ++} ++ ++/* ++ * Do necessary setup to start up a newly executed thread. ++ * ++ * pass the data segment into user programs if it exists, ++ * it can't hurt anything as far as I can tell ++ */ ++/* ++ * Do necessary setup to start up a newly executed thread. ++ */ ++#define start_thread(regs, new_pc, new_sp) \ ++ do { \ ++ regs->pc = new_pc & ~3; \ ++ regs->an[5] = new_pc & ~3; \ ++ regs->an[7] = new_sp; \ ++ regs->nesting_level = -1; \ ++ regs->frame_type = UBICOM32_FRAME_TYPE_NEW_THREAD; \ ++ regs->thread_type = NORMAL_THREAD; \ ++ } while(0) ++ ++/* Forward declaration, a strange C thing */ ++struct task_struct; ++ ++/* Free all resources held by a thread. */ ++static inline void release_thread(struct task_struct *dead_task) ++{ ++} ++ ++/* Prepare to copy thread state - unlazy all lazy status */ ++#define prepare_to_copy(tsk) do { } while (0) ++ ++extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags); ++ ++/* ++ * Free current thread data structures etc.. ++ */ ++static inline void exit_thread(void) ++{ ++} ++ ++unsigned long thread_saved_pc(struct task_struct *tsk); ++unsigned long get_wchan(struct task_struct *p); ++ ++#define KSTK_EIP(tsk) (tsk->thread.a5) ++#define KSTK_ESP(tsk) (tsk->thread.sp) ++ ++#define cpu_relax() barrier() ++ ++extern void processor_init(void); ++extern unsigned int processor_timers(void); ++extern unsigned int processor_threads(void); ++extern unsigned int processor_frequency(void); ++extern int processor_interrupts(unsigned int *int0, unsigned int *int1); ++extern int processor_ocm(void **socm, void **eocm); ++extern int processor_dram(void **sdram, void **edram); ++ ++#define THREAD_SIZE_LONGS (THREAD_SIZE/sizeof(unsigned long)) ++#define KSTK_TOP(info) \ ++({ \ ++ unsigned long *__ptr = (unsigned long *)(info); \ ++ (unsigned long)(&__ptr[THREAD_SIZE_LONGS]); \ ++}) ++ ++#define task_pt_regs(task) \ ++({ \ ++ struct pt_regs *__regs__; \ ++ __regs__ = (struct pt_regs *)(KSTK_TOP(task_stack_page(task))-8); \ ++ __regs__ - 1; \ ++}) ++ ++#endif /* _ASM_UBICOM32_PROCESSOR_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ptrace.h linux-2.6.28.10/arch/ubicom32/include/asm/ptrace.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ptrace.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ptrace.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,177 @@ ++/* ++ * arch/ubicom32/include/asm/ptrace.h ++ * Ubicom32 architecture ptrace support. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_PTRACE_H ++#define _ASM_UBICOM32_PTRACE_H ++ ++#ifndef __ASSEMBLY__ ++ ++/* ++ * We use hard coded constants because this is shared with user ++ * space and the values are NOT allowed to change. Only fields ++ * that are intended to be exposed get values. ++ */ ++#define PT_D0 0 ++#define PT_D1 4 ++#define PT_D2 8 ++#define PT_D3 12 ++#define PT_D4 16 ++#define PT_D5 20 ++#define PT_D6 24 ++#define PT_D7 28 ++#define PT_D8 32 ++#define PT_D9 36 ++#define PT_D10 40 ++#define PT_D11 44 ++#define PT_D12 48 ++#define PT_D13 52 ++#define PT_D14 56 ++#define PT_D15 60 ++#define PT_A0 64 ++#define PT_A1 68 ++#define PT_A2 72 ++#define PT_A3 76 ++#define PT_A4 80 ++#define PT_A5 84 ++#define PT_A6 88 ++#define PT_A7 92 ++#define PT_SP 92 ++#define PT_ACC0HI 96 ++#define PT_ACC0LO 100 ++#define PT_MAC_RC16 104 ++#define PT_ACC1HI 108 ++#define PT_ACC1LO 112 ++#define PT_SOURCE3 116 ++#define PT_INST_CNT 120 ++#define PT_CSR 124 ++#define PT_DUMMY_UNUSED 128 ++#define PT_INT_MASK0 132 ++#define PT_INT_MASK1 136 ++#define PT_TRAP_CAUSE 140 ++#define PT_PC 144 ++#define PT_ORIGINAL_D0 148 ++#define PT_FRAME_TYPE 152 ++ ++/* ++ * The following 'registers' are not registers at all but are used ++ * locate the relocated sections. ++ */ ++#define PT_TEXT_ADDR 200 ++#define PT_TEXT_END_ADDR 204 ++#define PT_DATA_ADDR 208 ++#define PT_EXEC_FDPIC_LOADMAP 212 ++#define PT_INTERP_FDPIC_LOADMAP 216 ++ ++/* ++ * This struct defines the way the registers are stored on the ++ * stack during a system call. ++ */ ++enum thread_type { ++ NORMAL_THREAD, ++ KERNEL_THREAD, ++}; ++ ++#define UBICOM32_FRAME_TYPE_SYSCALL -1 /* System call frame */ ++#define UBICOM32_FRAME_TYPE_INVALID 0 /* Invalid frame, no longer in use */ ++#define UBICOM32_FRAME_TYPE_INTERRUPT 1 /* Interrupt frame */ ++#define UBICOM32_FRAME_TYPE_TRAP 2 /* Trap frame */ ++#define UBICOM32_FRAME_TYPE_SIGTRAMP 3 /* Signal trampoline frame. */ ++#define UBICOM32_FRAME_TYPE_NEW_THREAD 4 /* New Thread. */ ++ ++struct pt_regs { ++ /* ++ * Data Registers ++ */ ++ unsigned long dn[16]; ++ ++ /* ++ * Address Registers ++ */ ++ unsigned long an[8]; ++ ++ /* ++ * Per thread misc registers. ++ */ ++ unsigned long acc0[2]; ++ unsigned long mac_rc16; ++ unsigned long acc1[2]; ++ unsigned long source3; ++ unsigned long inst_cnt; ++ unsigned long csr; ++ unsigned long dummy_unused; ++ unsigned long int_mask0; ++ unsigned long int_mask1; ++ unsigned long trap_cause; ++ unsigned long pc; ++ unsigned long original_dn_0; ++ ++ /* ++ * Frame type. Syscall frames are -1. For other types look above. ++ */ ++ unsigned long frame_type; ++ ++ /* ++ * These fields are not exposed to ptrace. ++ */ ++ unsigned long previous_pc; ++ long nesting_level; /* When the kernel in in user space this ++ * will be -1. */ ++ unsigned long thread_type; /* This indicates if this is a kernel ++ * thread. */ ++}; ++ ++/* ++ * This is the extended stack used by signal handlers and the context ++ * switcher: it's pushed after the normal "struct pt_regs". ++ */ ++struct switch_stack { ++ unsigned long dummy; ++}; ++ ++#ifdef __KERNEL__ ++ ++/* Arbitrarily choose the same ptrace numbers as used by the Sparc code. */ ++#define PTRACE_GETREGS 12 ++#define PTRACE_SETREGS 13 ++ ++#ifndef PS_S ++#define PS_S (0x2000) ++#define PS_M (0x1000) ++#endif ++ ++extern int __user_mode(unsigned long sp); ++ ++#define user_mode(regs) (__user_mode((regs->an[7]))) ++#define user_stack(regs) ((regs)->an[7]) ++#define instruction_pointer(regs) ((regs)->pc) ++#define profile_pc(regs) instruction_pointer(regs) ++extern void show_regs(struct pt_regs *); ++#endif /* __KERNEL__ */ ++ ++#endif /* __ASSEMBLY__ */ ++ ++#endif /* _ASM_UBICOM32_PTRACE_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/range-protect-asm.h linux-2.6.28.10/arch/ubicom32/include/asm/range-protect-asm.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/range-protect-asm.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/range-protect-asm.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,91 @@ ++/* ++ * arch/ubicom32/include/asm/range-protect-asm.h ++ * Assembly macros for enabling memory protection. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_RANGE_PROTECT_ASM_H ++#define _ASM_UBICOM32_RANGE_PROTECT_ASM_H ++ ++#if defined(__ASSEMBLY__) ++ ++#include ++ ++/* ++ * You should only use the enable/disable ranges when you have the atomic lock, ++ * if you do not there will be problems. ++ */ ++ ++/* ++ * enable_kernel_ranges ++ * Enable the kernel ranges (disabling protection) for thread, ++ * where thread == (1 << thread number) ++ */ ++.macro enable_kernel_ranges thread ++#ifdef CONFIG_PROTECT_KERNEL ++ or.4 I_RANGE0_EN, I_RANGE0_EN, \thread /* Enable Range Register */ ++ or.4 D_RANGE0_EN, D_RANGE0_EN, \thread ++ or.4 D_RANGE1_EN, D_RANGE1_EN, \thread ++#endif ++.endm ++ ++/* ++ * enable_kernel_ranges_for_current ++ * Enable the kernel ranges (disabling protection) for this thread ++ */ ++.macro enable_kernel_ranges_for_current scratch_reg ++#ifdef CONFIG_PROTECT_KERNEL ++ thread_get_self_mask \scratch_reg ++ enable_kernel_ranges \scratch_reg ++#endif ++.endm ++ ++/* ++ * disable_kernel_ranges ++ * Disables the kernel ranges (enabling protection) for thread ++ * where thread == (1 << thread number) ++ */ ++.macro disable_kernel_ranges thread ++#ifdef CONFIG_PROTECT_KERNEL ++ not.4 \thread, \thread ++ and.4 I_RANGE0_EN, I_RANGE0_EN, \thread /* Disable Range Register */ ++ and.4 D_RANGE0_EN, D_RANGE0_EN, \thread ++ and.4 D_RANGE1_EN, D_RANGE1_EN, \thread ++#endif ++.endm ++ ++/* ++ * disable_kernel_ranges_for_current ++ * Disable kernel ranges (enabling protection) for this thread ++ */ ++.macro disable_kernel_ranges_for_current scratch_reg ++#ifdef CONFIG_PROTECT_KERNEL ++ thread_get_self_mask \scratch_reg ++ disable_kernel_ranges \scratch_reg ++#endif ++.endm ++#endif ++ ++#endif /* _ASM_UBICOM32_RANGE_PROTECT_ASM_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/range-protect.h linux-2.6.28.10/arch/ubicom32/include/asm/range-protect.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/range-protect.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/range-protect.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,62 @@ ++/* ++ * arch/ubicom32/include/asm/range-protect.h ++ * Assembly macros declared in C for enabling memory protection. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_RANGE_PROTECT_H ++#define _ASM_UBICOM32_RANGE_PROTECT_H ++ ++#if !defined(__ASSEMBLY__) ++#include ++/* ++ * The following macros should be the identical to the ones in ++ * range-protect-asm.h ++ * ++ * You should only use the enable/disable ranges when you have the atomic lock, ++ * if you do not there will be problems. ++ */ ++ ++/* ++ * enable_kernel_ranges ++ * Enable the kernel ranges (disabling protection) for thread, ++ * where thread == (1 << thread number) ++ */ ++asm ( ++ ".macro enable_kernel_ranges thread \n\t" ++#ifdef CONFIG_PROTECT_KERNEL ++ " or.4 I_RANGE0_EN, I_RANGE0_EN, \\thread \n\t" /* Enable Range Register */ ++ " or.4 D_RANGE0_EN, D_RANGE0_EN, \\thread \n\t" ++ " or.4 D_RANGE1_EN, D_RANGE1_EN, \\thread \n\t" ++#endif ++ ".endm \n\t" ++); ++ ++#else /* __ASSEMBLY__ */ ++ ++#include ++ ++#endif ++#endif /* _ASM_UBICOM32_RANGE_PROTECT_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/resource.h linux-2.6.28.10/arch/ubicom32/include/asm/resource.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/resource.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/resource.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/resource.h ++ * Generic definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_RESOURCE_H ++#define _ASM_UBICOM32_RESOURCE_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_RESOURCE_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ring_tio.h linux-2.6.28.10/arch/ubicom32/include/asm/ring_tio.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ring_tio.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ring_tio.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,42 @@ ++/* ++ * arch/ubicom32/include/asm/ring_tio.h ++ * Ubicom32 architecture Ring TIO definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ */ ++#ifndef _ASM_UBICOM32_RING_TIO_H ++#define _ASM_UBICOM32_RING_TIO_H ++ ++#include ++ ++#define RING_TIO_NODE_VERSION 2 ++ ++/* ++ * Devtree node for ring ++ */ ++struct ring_tio_node { ++ struct devtree_node dn; ++ ++ u32_t version; ++ void *regs; ++}; ++ ++extern void ring_tio_init(const char *node_name); ++ ++#endif /* _ASM_UBICOM32_RING_TIO_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/scatterlist.h linux-2.6.28.10/arch/ubicom32/include/asm/scatterlist.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/scatterlist.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/scatterlist.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,49 @@ ++/* ++ * arch/ubicom32/include/asm/scatterlist.h ++ * Definitions of struct scatterlist for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SCATTERLIST_H ++#define _ASM_UBICOM32_SCATTERLIST_H ++ ++#include ++#include ++ ++struct scatterlist { ++#ifdef CONFIG_DEBUG_SG ++ unsigned long sg_magic; ++#endif ++ unsigned long page_link; ++ unsigned int offset; ++ dma_addr_t dma_address; ++ unsigned int length; ++}; ++ ++#define sg_dma_address(sg) ((sg)->dma_address) ++#define sg_dma_len(sg) ((sg)->length) ++ ++#define ISA_DMA_THRESHOLD (0xffffffff) ++ ++#endif /* _ASM_UBICOM32_SCATTERLIST_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/sections.h linux-2.6.28.10/arch/ubicom32/include/asm/sections.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/sections.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/sections.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/sections.h ++ * Generic sections.h definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SECTIONS_H ++#define _ASM_UBICOM32_SECTIONS_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_SECTIONS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/segment.h linux-2.6.28.10/arch/ubicom32/include/asm/segment.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/segment.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/segment.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,78 @@ ++/* ++ * arch/ubicom32/include/asm/segment.h ++ * Memory segment definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SEGMENT_H ++#define _ASM_UBICOM32_SEGMENT_H ++ ++/* define constants */ ++/* Address spaces (FC0-FC2) */ ++#define USER_DATA (1) ++#ifndef __USER_DS ++#define __USER_DS (USER_DATA) ++#endif ++#define USER_PROGRAM (2) ++#define SUPER_DATA (5) ++#ifndef __KERNEL_DS ++#define __KERNEL_DS (SUPER_DATA) ++#endif ++#define SUPER_PROGRAM (6) ++#define CPU_SPACE (7) ++ ++#ifndef __ASSEMBLY__ ++ ++typedef struct { ++ unsigned long seg; ++} mm_segment_t; ++ ++#define MAKE_MM_SEG(s) ((mm_segment_t) { (s) }) ++#define USER_DS MAKE_MM_SEG(__USER_DS) ++#define KERNEL_DS MAKE_MM_SEG(__KERNEL_DS) ++ ++/* ++ * Get/set the SFC/DFC registers for MOVES instructions ++ */ ++ ++static inline mm_segment_t get_fs(void) ++{ ++ return USER_DS; ++} ++ ++static inline mm_segment_t get_ds(void) ++{ ++ /* return the supervisor data space code */ ++ return KERNEL_DS; ++} ++ ++static inline void set_fs(mm_segment_t val) ++{ ++} ++ ++#define segment_eq(a,b) ((a).seg == (b).seg) ++ ++#endif /* __ASSEMBLY__ */ ++ ++#endif /* _ASM_UBICOM32_SEGMENT_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/semaphore.h linux-2.6.28.10/arch/ubicom32/include/asm/semaphore.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/semaphore.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/semaphore.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,140 @@ ++/* ++ * arch/ubicom32/include/asm/semaphore.h ++ * Interrupt-safe semaphores for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * (C) Copyright 1996 Linus Torvalds ++ * m68k version by Andreas Schwab ++ * Copyright (C) 2004 Microtronix Datacom Ltd ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SEMAPHORE_H ++#define _ASM_UBICOM32_SEMAPHORE_H ++ ++#define RW_LOCK_BIAS 0x01000000 ++ ++#ifndef __ASSEMBLY__ ++ ++#include ++#include ++#include ++#include ++ ++#include ++#include ++ ++struct semaphore { ++ atomic_t count; ++ atomic_t waking; ++ wait_queue_head_t wait; ++}; ++ ++#define __SEMAPHORE_INITIALIZER(name, n) \ ++{ \ ++ .count = ATOMIC_INIT(n), \ ++ .waking = ATOMIC_INIT(0), \ ++ .wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \ ++} ++ ++#define __DECLARE_SEMAPHORE_GENERIC(name,count) \ ++ struct semaphore name = __SEMAPHORE_INITIALIZER(name,count) ++ ++#define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1) ++#define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0) ++ ++static inline void sema_init (struct semaphore *sem, int val) ++{ ++ *sem = (struct semaphore)__SEMAPHORE_INITIALIZER(*sem, val); ++} ++ ++static inline void init_MUTEX (struct semaphore *sem) ++{ ++ sema_init(sem, 1); ++} ++ ++static inline void init_MUTEX_LOCKED (struct semaphore *sem) ++{ ++ sema_init(sem, 0); ++} ++ ++asmlinkage void __down_failed(void /* special register calling convention */); ++asmlinkage int __down_failed_interruptible(void /* params in registers */); ++asmlinkage int __down_failed_trylock(void /* params in registers */); ++asmlinkage void __up_wakeup(void /* special register calling convention */); ++ ++asmlinkage void __down(struct semaphore * sem); ++asmlinkage int __down_interruptible(struct semaphore * sem); ++asmlinkage int __down_trylock(struct semaphore * sem); ++asmlinkage void __up(struct semaphore * sem); ++ ++extern spinlock_t semaphore_wake_lock; ++ ++/* ++ * This is ugly, but we want the default case to fall through. ++ * "down_failed" is a special asm handler that calls the C ++ * routine that actually waits. ++ */ ++static inline void down(struct semaphore * sem) ++{ ++ might_sleep(); ++ ++ if (atomic_dec_return(&sem->count) < 0) ++ __down(sem); ++} ++ ++static inline int down_interruptible(struct semaphore * sem) ++{ ++ int ret = 0; ++ ++ ++ might_sleep(); ++ ++ if(atomic_dec_return(&sem->count) < 0) ++ ret = __down_interruptible(sem); ++ return ret; ++} ++ ++static inline int down_trylock(struct semaphore * sem) ++{ ++ int ret = 0; ++ ++ if (atomic_dec_return (&sem->count) < 0) ++ ret = __down_trylock(sem); ++ return ret; ++} ++ ++/* ++ * Note! This is subtle. We jump to wake people up only if ++ * the semaphore was negative (== somebody was waiting on it). ++ * The default case (no contention) will result in NO ++ * jumps for both down() and up(). ++ */ ++static inline void up(struct semaphore * sem) ++{ ++ if (atomic_inc_return(&sem->count) <= 0) ++ __up(sem); ++} ++ ++#endif /* __ASSEMBLY__ */ ++ ++#endif /* _ASM_UBICOM32_SEMAPHORE_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/semaphore-helper.h linux-2.6.28.10/arch/ubicom32/include/asm/semaphore-helper.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/semaphore-helper.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/semaphore-helper.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,109 @@ ++/* ++ * arch/ubicom32/include/asm/semaphore-helper.h ++ * Semaphore related definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SEMAPHORE_HELPER_H ++#define _ASM_UBICOM32_SEMAPHORE_HELPER_H ++ ++/* ++ * SMP- and interrupt-safe semaphores helper functions. ++ * ++ * (C) Copyright 1996 Linus Torvalds ++ * ++ * m68k version by Andreas Schwab ++ */ ++ ++ ++/* ++ * These two _must_ execute atomically wrt each other. ++ */ ++static inline void wake_one_more(struct semaphore * sem) ++{ ++ atomic_inc(&sem->waking); ++} ++ ++static inline int waking_non_zero(struct semaphore *sem) ++{ ++ int ret; ++ unsigned long flags; ++ ++ spin_lock_irqsave(&semaphore_wake_lock, flags); ++ ret = 0; ++ if (atomic_read(&sem->waking) > 0) { ++ atomic_dec(&sem->waking); ++ ret = 1; ++ } ++ spin_unlock_irqrestore(&semaphore_wake_lock, flags); ++ return ret; ++} ++ ++/* ++ * waking_non_zero_interruptible: ++ * 1 got the lock ++ * 0 go to sleep ++ * -EINTR interrupted ++ */ ++static inline int waking_non_zero_interruptible(struct semaphore *sem, ++ struct task_struct *tsk) ++{ ++ int ret; ++ unsigned long flags; ++ ++ spin_lock_irqsave(&semaphore_wake_lock, flags); ++ ret = 0; ++ if (atomic_read(&sem->waking) > 0) { ++ atomic_dec(&sem->waking); ++ ret = 1; ++ } else if (signal_pending(tsk)) { ++ atomic_inc(&sem->count); ++ ret = -EINTR; ++ } ++ spin_unlock_irqrestore(&semaphore_wake_lock, flags); ++ return ret; ++} ++ ++/* ++ * waking_non_zero_trylock: ++ * 1 failed to lock ++ * 0 got the lock ++ */ ++static inline int waking_non_zero_trylock(struct semaphore *sem) ++{ ++ int ret; ++ unsigned long flags; ++ ++ spin_lock_irqsave(&semaphore_wake_lock, flags); ++ ret = 1; ++ if (atomic_read(&sem->waking) > 0) { ++ atomic_dec(&sem->waking); ++ ret = 0; ++ } else ++ atomic_inc(&sem->count); ++ spin_unlock_irqrestore(&semaphore_wake_lock, flags); ++ return ret; ++} ++ ++#endif /* _ASM_UBICOM32_SEMAPHORE_HELPER_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/sembuf.h linux-2.6.28.10/arch/ubicom32/include/asm/sembuf.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/sembuf.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/sembuf.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,52 @@ ++/* ++ * arch/ubicom32/include/asm/sembuf.h ++ * The semid64_ds structure for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SEMBUF_H ++#define _ASM_UBICOM32_SEMBUF_H ++ ++/* ++ * The semid64_ds structure for ubicom32 architecture. ++ * Note extra padding because this structure is passed back and forth ++ * between kernel and user space. ++ * ++ * Pad space is left for: ++ * - 64-bit time_t to solve y2038 problem ++ * - 2 miscellaneous 32-bit values ++ */ ++ ++struct semid64_ds { ++ struct ipc64_perm sem_perm; /* permissions .. see ipc.h */ ++ __kernel_time_t sem_otime; /* last semop time */ ++ unsigned long __unused1; ++ __kernel_time_t sem_ctime; /* last change time */ ++ unsigned long __unused2; ++ unsigned long sem_nsems; /* no. of semaphores in array */ ++ unsigned long __unused3; ++ unsigned long __unused4; ++}; ++ ++#endif /* _ASM_UBICOM32_SEMBUF_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/setup.h linux-2.6.28.10/arch/ubicom32/include/asm/setup.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/setup.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/setup.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,35 @@ ++/* ++ * arch/ubicom32/include/asm/setup.h ++ * Kernel command line length definition. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * Copyright (C) 2004, Microtronix Datacom Ltd., All rights reserved. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_SETUP_H ++#define _ASM_UBICOM32_SETUP_H ++ ++#define COMMAND_LINE_SIZE 512 ++ ++#endif /* _ASM_UBICOM32_SETUP_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/shmbuf.h linux-2.6.28.10/arch/ubicom32/include/asm/shmbuf.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/shmbuf.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/shmbuf.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,69 @@ ++/* ++ * arch/ubicom32/include/asm/shmbuf.h ++ * The shmid64_ds structure for the Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SHMBUF_H ++#define _ASM_UBICOM32_SHMBUF_H ++ ++/* ++ * The shmid64_ds structure for m68k architecture. ++ * Note extra padding because this structure is passed back and forth ++ * between kernel and user space. ++ * ++ * Pad space is left for: ++ * - 64-bit time_t to solve y2038 problem ++ * - 2 miscellaneous 32-bit values ++ */ ++ ++struct shmid64_ds { ++ struct ipc64_perm shm_perm; /* operation perms */ ++ size_t shm_segsz; /* size of segment (bytes) */ ++ __kernel_time_t shm_atime; /* last attach time */ ++ unsigned long __unused1; ++ __kernel_time_t shm_dtime; /* last detach time */ ++ unsigned long __unused2; ++ __kernel_time_t shm_ctime; /* last change time */ ++ unsigned long __unused3; ++ __kernel_pid_t shm_cpid; /* pid of creator */ ++ __kernel_pid_t shm_lpid; /* pid of last operator */ ++ unsigned long shm_nattch; /* no. of current attaches */ ++ unsigned long __unused4; ++ unsigned long __unused5; ++}; ++ ++struct shminfo64 { ++ unsigned long shmmax; ++ unsigned long shmmin; ++ unsigned long shmmni; ++ unsigned long shmseg; ++ unsigned long shmall; ++ unsigned long __unused1; ++ unsigned long __unused2; ++ unsigned long __unused3; ++ unsigned long __unused4; ++}; ++ ++#endif /* _ASM_UBICOM32_SHMBUF_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/shmparam.h linux-2.6.28.10/arch/ubicom32/include/asm/shmparam.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/shmparam.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/shmparam.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,35 @@ ++/* ++ * arch/ubicom32/include/asm/shmparam.h ++ * Shared memory definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * Copyright (C) 2004 Microtronix Datacom Ltd ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ * Alpha, ix86, M68K, Sparc, ...et al ++ */ ++#ifndef _ASM_UBICOM32_SHMPARAM_H ++#define _ASM_UBICOM32_SHMPARAM_H ++ ++#define SHMLBA PAGE_SIZE /* attach addr a multiple of this */ ++ ++#endif /* _ASM_UBICOM32_SHMPARAM_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/sigcontext.h linux-2.6.28.10/arch/ubicom32/include/asm/sigcontext.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/sigcontext.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/sigcontext.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,37 @@ ++/* ++ * arch/ubicom32/include/asm/sigcontext.h ++ * Definition of sigcontext struct for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SIGCONTEXT_H ++#define _ASM_UBICOM32_SIGCONTEXT_H ++ ++#include ++ ++struct sigcontext { ++ struct pt_regs sc_regs; ++}; ++ ++#endif /* _ASM_UBICOM32_SIGCONTEXT_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/siginfo.h linux-2.6.28.10/arch/ubicom32/include/asm/siginfo.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/siginfo.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/siginfo.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/siginfo.h ++ * Generic siginfo.h definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SIGINFO_H ++#define _ASM_UBICOM32_SIGINFO_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_SIGINFO_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/signal.h linux-2.6.28.10/arch/ubicom32/include/asm/signal.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/signal.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/signal.h 2009-08-12 13:08:37.000000000 +0300 +@@ -0,0 +1,180 @@ ++/* ++ * arch/ubicom32/include/asm/signal.h ++ * Signal related definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SIGNAL_H ++#define _ASM_UBICOM32_SIGNAL_H ++ ++#include ++ ++/* Avoid too many header ordering problems. */ ++struct siginfo; ++ ++#ifdef __KERNEL__ ++/* Most things should be clean enough to redefine this at will, if care ++ is taken to make libc match. */ ++ ++#define _NSIG 64 ++#define _NSIG_BPW 32 ++#define _NSIG_WORDS (_NSIG / _NSIG_BPW) ++ ++typedef unsigned long old_sigset_t; /* at least 32 bits */ ++ ++typedef struct { ++ unsigned long sig[_NSIG_WORDS]; ++} sigset_t; ++ ++#endif /* __KERNEL__ */ ++ ++#define SIGHUP 1 ++#define SIGINT 2 ++#define SIGQUIT 3 ++#define SIGILL 4 ++#define SIGTRAP 5 ++#define SIGABRT 6 ++#define SIGIOT 6 ++#define SIGBUS 7 ++#define SIGFPE 8 ++#define SIGKILL 9 ++#define SIGUSR1 10 ++#define SIGSEGV 11 ++#define SIGUSR2 12 ++#define SIGPIPE 13 ++#define SIGALRM 14 ++#define SIGTERM 15 ++#define SIGSTKFLT 16 ++#define SIGCHLD 17 ++#define SIGCONT 18 ++#define SIGSTOP 19 ++#define SIGTSTP 20 ++#define SIGTTIN 21 ++#define SIGTTOU 22 ++#define SIGURG 23 ++#define SIGXCPU 24 ++#define SIGXFSZ 25 ++#define SIGVTALRM 26 ++#define SIGPROF 27 ++#define SIGWINCH 28 ++#define SIGIO 29 ++#define SIGPOLL SIGIO ++/* ++#define SIGLOST 29 ++*/ ++#define SIGPWR 30 ++#define SIGSYS 31 ++#define SIGUNUSED 31 ++ ++/* These should not be considered constants from userland. */ ++#define SIGRTMIN 32 ++#define SIGRTMAX _NSIG ++ ++/* ++ * SA_FLAGS values: ++ * ++ * SA_ONSTACK indicates that a registered stack_t will be used. ++ * SA_RESTART flag to get restarting signals (which were the default long ago) ++ * SA_NOCLDSTOP flag to turn off SIGCHLD when children stop. ++ * SA_RESETHAND clears the handler when the signal is delivered. ++ * SA_NOCLDWAIT flag on SIGCHLD to inhibit zombies. ++ * SA_NODEFER prevents the current signal from being masked in the handler. ++ * ++ * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single ++ * Unix names RESETHAND and NODEFER respectively. ++ */ ++#define SA_NOCLDSTOP 0x00000001 ++#define SA_NOCLDWAIT 0x00000002 ++#define SA_SIGINFO 0x00000004 ++#define SA_ONSTACK 0x08000000 ++#define SA_RESTART 0x10000000 ++#define SA_NODEFER 0x40000000 ++#define SA_RESETHAND 0x80000000 ++ ++#define SA_NOMASK SA_NODEFER ++#define SA_ONESHOT SA_RESETHAND ++ ++/* ++ * sigaltstack controls ++ */ ++#define SS_ONSTACK 1 ++#define SS_DISABLE 2 ++ ++#define MINSIGSTKSZ 2048 ++#define SIGSTKSZ 8192 ++ ++#include ++ ++#ifdef __KERNEL__ ++struct old_sigaction { ++ __sighandler_t sa_handler; ++ old_sigset_t sa_mask; ++ unsigned long sa_flags; ++ void (*sa_restorer)(void); ++}; ++ ++struct sigaction { ++ __sighandler_t sa_handler; ++ unsigned long sa_flags; ++ void (*sa_restorer)(void); ++ sigset_t sa_mask; /* mask last for extensibility */ ++}; ++ ++struct k_sigaction { ++ struct sigaction sa; ++}; ++#else ++/* Here we must cater to libcs that poke about in kernel headers. */ ++ ++struct sigaction { ++ union { ++ __sighandler_t _sa_handler; ++ void (*_sa_sigaction)(int, struct siginfo *, void *); ++ } _u; ++ sigset_t sa_mask; ++ unsigned long sa_flags; ++ void (*sa_restorer)(void); ++}; ++ ++#define sa_handler _u._sa_handler ++#define sa_sigaction _u._sa_sigaction ++ ++#endif /* __KERNEL__ */ ++ ++typedef struct sigaltstack { ++ void *ss_sp; ++ int ss_flags; ++ size_t ss_size; ++} stack_t; ++ ++#ifdef __KERNEL__ ++ ++#include ++#undef __HAVE_ARCH_SIG_BITOPS ++ ++#define ptrace_signal_deliver(regs, cookie) do { } while (0) ++ ++#endif /* __KERNEL__ */ ++ ++#endif /* _ASM_UBICOM32_SIGNAL_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/smp.h linux-2.6.28.10/arch/ubicom32/include/asm/smp.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/smp.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/smp.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,83 @@ ++/* ++ * arch/ubicom32/include/asm/smp.h ++ * SMP definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SMP_H ++#define _ASM_UBICOM32_SMP_H ++ ++#ifndef ASSEMBLY ++#include ++#include ++#include ++#include ++ ++typedef unsigned long address_t; ++extern cpumask_t cpu_online_map; ++extern unsigned int smp_ipi_irq; ++ ++/* ++ * This magic constant controls our willingness to transfer ++ * a process across CPUs. ++ * ++ * Such a transfer incurs cache and tlb ++ * misses. The current value is inherited from i386. Still needs ++ * to be tuned for parisc. ++ */ ++#define PROC_CHANGE_PENALTY 15 /* Schedule penalty */ ++#define NO_PROC_ID 0xFF /* No processor magic marker */ ++#define ANY_PROC_ID 0xFF /* Any processor magic marker */ ++ ++#ifdef CONFIG_SMP ++#define raw_smp_processor_id() (current_thread_info()->cpu) ++#endif /* CONFIG_SMP */ ++ ++static inline int __cpu_disable (void) ++{ ++ return 0; ++} ++ ++static inline void __cpu_die (unsigned int cpu) ++{ ++ while(1) { ++ }; ++} ++ ++extern int __cpu_up(unsigned int cpu); ++extern void smp_send_timer_all(void); ++extern void smp_timer_broadcast(cpumask_t mask); ++extern void smp_set_affinity(unsigned int irq, cpumask_t dest); ++extern void arch_send_call_function_single_ipi(int cpu); ++extern void arch_send_call_function_ipi(cpumask_t mask); ++ ++/* ++ * TODO: Once these are fully tested, we should turn them into ++ * inline macros for performance. ++ */ ++extern unsigned long smp_get_affinity(unsigned int irq, int *all); ++extern void smp_reset_ipi(unsigned long mask); ++ ++#endif /* !ASSEMBLY */ ++#endif /* _ASM_UBICOM32_SMP_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/socket.h linux-2.6.28.10/arch/ubicom32/include/asm/socket.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/socket.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/socket.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,84 @@ ++/* ++ * arch/ubicom32/include/asm/socket.h ++ * Socket options definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SOCKET_H ++#define _ASM_UBICOM32_SOCKET_H ++ ++#include ++ ++/* For setsockopt(2) */ ++#define SOL_SOCKET 1 ++ ++#define SO_DEBUG 1 ++#define SO_REUSEADDR 2 ++#define SO_TYPE 3 ++#define SO_ERROR 4 ++#define SO_DONTROUTE 5 ++#define SO_BROADCAST 6 ++#define SO_SNDBUF 7 ++#define SO_RCVBUF 8 ++#define SO_SNDBUFFORCE 32 ++#define SO_RCVBUFFORCE 33 ++#define SO_KEEPALIVE 9 ++#define SO_OOBINLINE 10 ++#define SO_NO_CHECK 11 ++#define SO_PRIORITY 12 ++#define SO_LINGER 13 ++#define SO_BSDCOMPAT 14 ++/* To add :#define SO_REUSEPORT 15 */ ++#define SO_PASSCRED 16 ++#define SO_PEERCRED 17 ++#define SO_RCVLOWAT 18 ++#define SO_SNDLOWAT 19 ++#define SO_RCVTIMEO 20 ++#define SO_SNDTIMEO 21 ++ ++/* Security levels - as per NRL IPv6 - don't actually do anything */ ++#define SO_SECURITY_AUTHENTICATION 22 ++#define SO_SECURITY_ENCRYPTION_TRANSPORT 23 ++#define SO_SECURITY_ENCRYPTION_NETWORK 24 ++ ++#define SO_BINDTODEVICE 25 ++ ++/* Socket filtering */ ++#define SO_ATTACH_FILTER 26 ++#define SO_DETACH_FILTER 27 ++ ++#define SO_PEERNAME 28 ++#define SO_TIMESTAMP 29 ++#define SCM_TIMESTAMP SO_TIMESTAMP ++ ++#define SO_ACCEPTCONN 30 ++ ++#define SO_PEERSEC 31 ++#define SO_PASSSEC 34 ++#define SO_TIMESTAMPNS 35 ++#define SCM_TIMESTAMPNS SO_TIMESTAMPNS ++ ++#define SO_MARK 36 ++ ++#endif /* _ASM_UBICOM32_SOCKET_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/sockios.h linux-2.6.28.10/arch/ubicom32/include/asm/sockios.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/sockios.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/sockios.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,40 @@ ++/* ++ * arch/ubicom32/include/asm/sockios.h ++ * Socket-level ioctl definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SOCKIOS_H ++#define _ASM_UBICOM32_SOCKIOS_H ++ ++/* Socket-level I/O control calls. */ ++#define FIOSETOWN 0x8901 ++#define SIOCSPGRP 0x8902 ++#define FIOGETOWN 0x8903 ++#define SIOCGPGRP 0x8904 ++#define SIOCATMARK 0x8905 ++#define SIOCGSTAMP 0x8906 /* Get stamp (timeval) */ ++#define SIOCGSTAMPNS 0x8907 /* Get stamp (timespec) */ ++ ++#endif /* _ASM_UBICOM32_SOCKIOS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/spinlock.h linux-2.6.28.10/arch/ubicom32/include/asm/spinlock.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/spinlock.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/spinlock.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,293 @@ ++/* ++ * arch/ubicom32/include/asm/spinlock.h ++ * Spinlock related definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SPINLOCK_H ++#define _ASM_UBICOM32_SPINLOCK_H ++ ++#include ++#include ++#include ++ ++/* ++ * __raw_spin_lock() ++ * Lock the lock. ++ */ ++static inline void __raw_spin_lock(raw_spinlock_t *x) ++{ ++ asm volatile ( ++ "1: bset %0, %0, #0 \n\t" ++ " jmpne.f 1b \n\t" ++ : "+U4" (x->lock) ++ : ++ : "memory", "cc" ++ ); ++} ++ ++/* ++ * __raw_spin_unlock() ++ * Unlock the lock. ++ */ ++static inline void __raw_spin_unlock(raw_spinlock_t *x) ++{ ++ asm volatile ( ++ " bclr %0, %0, #0 \n\t" ++ : "+U4" (x->lock) ++ : ++ : "memory", "cc" ++ ); ++} ++ ++/* ++ * __raw_spin_is_locked() ++ * Test if the lock is locked. ++ */ ++static inline int __raw_spin_is_locked(raw_spinlock_t *x) ++{ ++ return x->lock; ++} ++ ++/* ++ * __raw_spin_unlock_wait() ++ * Wait for the lock to be unlocked. ++ * ++ * Note: the caller has not guarantee that the lock will not ++ * be acquired before they get to it. ++ */ ++static inline void __raw_spin_unlock_wait(raw_spinlock_t *x) ++{ ++ do { ++ cpu_relax(); ++ } while (__raw_spin_is_locked(x)); ++} ++ ++/* ++ * __raw_spin_trylock() ++ * Try the lock, return 0 on failure, 1 on success. ++ */ ++static inline int __raw_spin_trylock(raw_spinlock_t *x) ++{ ++ int ret = 0; ++ ++ asm volatile ( ++ " bset %1, %1, #0 \n\t" ++ " jmpne.f 1f \n\t" ++ " move.4 %0, #1 \n\t" ++ "1: \n\t" ++ : "+r" (ret), "+U4" (x->lock) ++ : ++ : "memory", "cc" ++ ); ++ ++ return ret; ++} ++ ++/* ++ * __raw_spin_lock_flags() ++ * Spin waiting for the lock (enabling IRQ(s)) ++ */ ++static inline void __raw_spin_lock_flags(raw_spinlock_t *x, unsigned long flags) ++{ ++ mb(); ++ while (!__raw_spin_trylock(x)) { ++ /* ++ * If the flags from the IRQ are set, interrupts are disabled and we ++ * need to re-enable them. ++ */ ++ if (!flags) { ++ cpu_relax(); ++ } else { ++ raw_local_irq_enable(); ++ cpu_relax(); ++ raw_local_irq_disable(); ++ } ++ } ++ mb(); ++} ++ ++/* ++ * Read-write spinlocks, allowing multiple readers but only one writer. ++ * Linux rwlocks are unfair to writers; they can be starved for an indefinite ++ * time by readers. With care, they can also be taken in interrupt context. ++ * ++ * In Ubicom32 architecture implementation, we have a spinlock and a counter. ++ * Readers use the lock to serialise their access to the counter (which ++ * records how many readers currently hold the lock). ++ * Writers hold the spinlock, preventing any readers or other writers from ++ * grabbing the rwlock. ++ */ ++ ++/* ++ * __raw_read_lock() ++ * Increment the counter in the rwlock. ++ * ++ * Note that we have to ensure interrupts are disabled in case we're ++ * interrupted by some other code that wants to grab the same read lock ++ */ ++static inline void __raw_read_lock(raw_rwlock_t *rw) ++{ ++ unsigned long flags; ++ raw_local_irq_save(flags); ++ __raw_spin_lock_flags(&rw->lock, flags); ++ rw->counter++; ++ __raw_spin_unlock(&rw->lock); ++ raw_local_irq_restore(flags); ++} ++ ++/* ++ * __raw_read_unlock() ++ * Decrement the counter. ++ * ++ * Note that we have to ensure interrupts are disabled in case we're ++ * interrupted by some other code that wants to grab the same read lock ++ */ ++static inline void __raw_read_unlock(raw_rwlock_t *rw) ++{ ++ unsigned long flags; ++ raw_local_irq_save(flags); ++ __raw_spin_lock_flags(&rw->lock, flags); ++ rw->counter--; ++ __raw_spin_unlock(&rw->lock); ++ raw_local_irq_restore(flags); ++} ++ ++/* ++ * __raw_read_trylock() ++ * Increment the counter if we can. ++ * ++ * Note that we have to ensure interrupts are disabled in case we're ++ * interrupted by some other code that wants to grab the same read lock ++ */ ++static inline int __raw_read_trylock(raw_rwlock_t *rw) ++{ ++ unsigned long flags; ++ retry: ++ raw_local_irq_save(flags); ++ if (__raw_spin_trylock(&rw->lock)) { ++ rw->counter++; ++ __raw_spin_unlock(&rw->lock); ++ raw_local_irq_restore(flags); ++ return 1; ++ } ++ ++ raw_local_irq_restore(flags); ++ ++ /* ++ * If write-locked, we fail to acquire the lock ++ */ ++ if (rw->counter < 0) { ++ return 0; ++ } ++ ++ /* ++ * Wait until we have a realistic chance at the lock ++ */ ++ while (__raw_spin_is_locked(&rw->lock) && rw->counter >= 0) { ++ cpu_relax(); ++ } ++ ++ goto retry; ++} ++ ++/* ++ * __raw_write_lock() ++ * ++ * Note that we have to ensure interrupts are disabled in case we're ++ * interrupted by some other code that wants to read_trylock() this lock ++ */ ++static inline void __raw_write_lock(raw_rwlock_t *rw) ++{ ++ unsigned long flags; ++retry: ++ raw_local_irq_save(flags); ++ __raw_spin_lock_flags(&rw->lock, flags); ++ ++ if (rw->counter != 0) { ++ __raw_spin_unlock(&rw->lock); ++ raw_local_irq_restore(flags); ++ ++ while (rw->counter != 0) ++ cpu_relax(); ++ ++ goto retry; ++ } ++ ++ rw->counter = -1; /* mark as write-locked */ ++ mb(); ++ raw_local_irq_restore(flags); ++} ++ ++static inline void __raw_write_unlock(raw_rwlock_t *rw) ++{ ++ rw->counter = 0; ++ __raw_spin_unlock(&rw->lock); ++} ++ ++/* Note that we have to ensure interrupts are disabled in case we're ++ * interrupted by some other code that wants to read_trylock() this lock */ ++static inline int __raw_write_trylock(raw_rwlock_t *rw) ++{ ++ unsigned long flags; ++ int result = 0; ++ ++ raw_local_irq_save(flags); ++ if (__raw_spin_trylock(&rw->lock)) { ++ if (rw->counter == 0) { ++ rw->counter = -1; ++ result = 1; ++ } else { ++ /* Read-locked. Oh well. */ ++ __raw_spin_unlock(&rw->lock); ++ } ++ } ++ raw_local_irq_restore(flags); ++ ++ return result; ++} ++ ++/* ++ * read_can_lock - would read_trylock() succeed? ++ * @lock: the rwlock in question. ++ */ ++static inline int __raw_read_can_lock(raw_rwlock_t *rw) ++{ ++ return rw->counter >= 0; ++} ++ ++/* ++ * write_can_lock - would write_trylock() succeed? ++ * @lock: the rwlock in question. ++ */ ++static inline int __raw_write_can_lock(raw_rwlock_t *rw) ++{ ++ return !rw->counter; ++} ++ ++#define _raw_spin_relax(lock) cpu_relax() ++#define _raw_read_relax(lock) cpu_relax() ++#define _raw_write_relax(lock) cpu_relax() ++ ++#endif /* _ASM_UBICOM32_SPINLOCK_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/spinlock_types.h linux-2.6.28.10/arch/ubicom32/include/asm/spinlock_types.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/spinlock_types.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/spinlock_types.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,43 @@ ++/* ++ * arch/ubicom32/include/asm/spinlock_types.h ++ * Spinlock related structure definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SPINLOCK_TYPES_H ++#define _ASM_UBICOM32_SPINLOCK_TYPES_H ++ ++typedef struct { ++ volatile unsigned int lock; ++} raw_spinlock_t; ++ ++typedef struct { ++ raw_spinlock_t lock; ++ volatile int counter; ++} raw_rwlock_t; ++ ++#define __RAW_SPIN_LOCK_UNLOCKED { 0 } ++#define __RAW_RW_LOCK_UNLOCKED { __RAW_SPIN_LOCK_UNLOCKED, 0 } ++ ++#endif /* _ASM_UBICOM32_SPINLOCK_TYPES_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/stacktrace.h linux-2.6.28.10/arch/ubicom32/include/asm/stacktrace.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/stacktrace.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/stacktrace.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,72 @@ ++/* ++ * arch/ubicom32/include/asm/stacktrace.h ++ * Stacktrace functions for the Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_STACKTRACE_H ++#define _ASM_UBICOM32_STACKTRACE_H ++ ++#define between(a, b, c) (( \ ++ ((unsigned long) a) >= ((unsigned long) b)) && \ ++ (((unsigned long)a) <= ((unsigned long)c))) ++ ++/* ++ * These symbols are filled in by the linker. ++ */ ++extern unsigned long _stext; ++extern unsigned long _etext; ++ ++/* OCM text goes from __ocm_text_run_begin to __data_begin */ ++extern unsigned long __ocm_text_run_begin; ++extern unsigned long __data_begin; ++ ++/* Account for OCM case - see stacktrace.c maybe combine(also trap.c) */ ++/* ++ * ubicom32_is_kernel() ++ * ++ * Check to see if the given address belongs to the kernel. ++ * NOMMU does not permit any other means. ++ */ ++static inline int ubicom32_is_kernel(unsigned long addr) ++{ ++ int is_kernel = between(addr, &_stext, &_etext) || \ ++ between(addr, &__ocm_text_run_begin, &__data_begin); ++ ++#ifdef CONFIG_MODULES ++ if (!is_kernel) ++ is_kernel = is_module_address(addr); ++#endif ++ return is_kernel; ++} ++ ++extern unsigned long stacktrace_iterate( ++ unsigned long **trace, ++ unsigned long stext, unsigned long etext, ++ unsigned long ocm_stext, unsigned long ocm_etext, ++ unsigned long sstack, unsigned long estack); ++#ifdef CONFIG_STACKTRACE ++void stacktrace_save_entries(struct task_struct *tsk, struct stack_trace *trace, unsigned long sp); ++#endif ++#endif /* _ASM_UBICOM32_STACKTRACE_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/statfs.h linux-2.6.28.10/arch/ubicom32/include/asm/statfs.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/statfs.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/statfs.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/statfs.h ++ * Generic statfs.h definitions ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_STATFS_H ++#define _ASM_UBICOM32_STATFS_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_STATFS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/stat.h linux-2.6.28.10/arch/ubicom32/include/asm/stat.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/stat.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/stat.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,104 @@ ++/* ++ * arch/ubicom32/include/asm/stat.h ++ * File status definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_STAT_H ++#define _ASM_UBICOM32_STAT_H ++ ++struct __old_kernel_stat { ++ unsigned short st_dev; ++ unsigned short st_ino; ++ unsigned short st_mode; ++ unsigned short st_nlink; ++ unsigned short st_uid; ++ unsigned short st_gid; ++ unsigned short st_rdev; ++ unsigned long st_size; ++ unsigned long st_atime; ++ unsigned long st_mtime; ++ unsigned long st_ctime; ++}; ++ ++struct stat { ++ unsigned short st_dev; ++ unsigned short __pad1; ++ unsigned long st_ino; ++ unsigned short st_mode; ++ unsigned short st_nlink; ++ unsigned short st_uid; ++ unsigned short st_gid; ++ unsigned short st_rdev; ++ unsigned short __pad2; ++ unsigned long st_size; ++ unsigned long st_blksize; ++ unsigned long st_blocks; ++ unsigned long st_atime; ++ unsigned long __unused1; ++ unsigned long st_mtime; ++ unsigned long __unused2; ++ unsigned long st_ctime; ++ unsigned long __unused3; ++ unsigned long __unused4; ++ unsigned long __unused5; ++}; ++ ++/* This matches struct stat64 in glibc2.1, hence the absolutely ++ * insane amounts of padding around dev_t's. ++ */ ++struct stat64 { ++ unsigned long long st_dev; ++ unsigned char __pad1[2]; ++ ++#define STAT64_HAS_BROKEN_ST_INO 1 ++ unsigned long __st_ino; ++ ++ unsigned int st_mode; ++ unsigned int st_nlink; ++ ++ unsigned long st_uid; ++ unsigned long st_gid; ++ ++ unsigned long long st_rdev; ++ unsigned char __pad3[2]; ++ ++ long long st_size; ++ unsigned long st_blksize; ++ ++ unsigned long long st_blocks; /* Number 512-byte blocks allocated. */ ++ ++ unsigned long st_atime; ++ unsigned long st_atime_nsec; ++ ++ unsigned long st_mtime; ++ unsigned long st_mtime_nsec; ++ ++ unsigned long st_ctime; ++ unsigned long st_ctime_nsec; ++ ++ unsigned long long st_ino; ++}; ++ ++#endif /* _ASM_UBICOM32_STAT_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/string.h linux-2.6.28.10/arch/ubicom32/include/asm/string.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/string.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/string.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,37 @@ ++/* ++ * arch/ubicom32/include/asm/string.h ++ * String operation definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_STRING_H ++#define _ASM_UBICOM32_STRING_H ++ ++#define __HAVE_ARCH_MEMSET ++extern void *memset(void *b, int c, size_t len); ++ ++#define __HAVE_ARCH_MEMCPY ++extern void *memcpy(void *to, const void *from, size_t len); ++ ++#endif /* _ASM_UBICOM32_STRING_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/system.h linux-2.6.28.10/arch/ubicom32/include/asm/system.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/system.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/system.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,101 @@ ++/* ++ * arch/ubicom32/include/asm/system.h ++ * Low level switching definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_SYSTEM_H ++#define _ASM_UBICOM32_SYSTEM_H ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++/* ++ * switch_to(n) should switch tasks to task ptr, first checking that ++ * ptr isn't the current task, in which case it does nothing. ++ */ ++asmlinkage void resume(void); ++extern void *__switch_to(struct task_struct *prev, ++ struct thread_struct *prev_switch, ++ struct thread_struct *next_switch); ++ ++/* ++ * We will need a per linux thread sw_ksp for the switch_to macro to ++ * track the kernel stack pointer for the current thread on that linux thread. ++ */ ++#define switch_to(prev,next,last) \ ++({ \ ++ void *_last; \ ++ _last = (void *) \ ++ __switch_to(prev, &prev->thread, &next->thread); \ ++ (last) = _last; \ ++}) ++ ++/* ++ * Force strict CPU ordering. ++ * Not really required on ubicom32... ++ */ ++#define nop() asm volatile ("nop"::) ++#define mb() asm volatile ("" : : :"memory") ++#define rmb() asm volatile ("" : : :"memory") ++#define wmb() asm volatile ("" : : :"memory") ++#define set_mb(var, value) ({ (var) = (value); wmb(); }) ++ ++#ifdef CONFIG_SMP ++#define smp_mb() mb() ++#define smp_rmb() rmb() ++#define smp_wmb() wmb() ++#define smp_read_barrier_depends() read_barrier_depends() ++#else ++#define smp_mb() mb() ++#define smp_rmb() rmb() ++#define smp_wmb() wmb() ++#define smp_read_barrier_depends() do { } while(0) ++#endif ++ ++#define read_barrier_depends() ((void)0) ++ ++/* ++ * The following defines change how the scheduler calls the switch_to() ++ * macro. ++ * ++ * 1) The first causes the runqueue to be unlocked on entry to ++ * switch_to(). Since our ctx code does not play with the runqueue ++ * we do not need it unlocked. ++ * ++ * 2) The later turns interrupts on during a ctxsw to reduce the latency of ++ * interrupts during ctx. At this point in the port, we believe that this ++ * latency is not a problem since we have very little code to perform a ctxsw. ++ */ ++// #define __ARCH_WANT_UNLOCKED_CTXSW ++// #define __ARCH_WANT_INTERRUPTS_ON_CTXSW ++ ++#endif /* _ASM_UBICOM32_SYSTEM_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/termbits.h linux-2.6.28.10/arch/ubicom32/include/asm/termbits.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/termbits.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/termbits.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,227 @@ ++/* ++ * arch/ubicom32/include/asm/termbits.h ++ * Terminal/serial port definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_TERMBITS_H ++#define _ASM_UBICOM32_TERMBITS_H ++ ++#include ++ ++typedef unsigned char cc_t; ++typedef unsigned int speed_t; ++typedef unsigned int tcflag_t; ++ ++#define NCCS 19 ++struct termios { ++ tcflag_t c_iflag; /* input mode flags */ ++ tcflag_t c_oflag; /* output mode flags */ ++ tcflag_t c_cflag; /* control mode flags */ ++ tcflag_t c_lflag; /* local mode flags */ ++ cc_t c_line; /* line discipline */ ++ cc_t c_cc[NCCS]; /* control characters */ ++}; ++ ++struct termios2 { ++ tcflag_t c_iflag; /* input mode flags */ ++ tcflag_t c_oflag; /* output mode flags */ ++ tcflag_t c_cflag; /* control mode flags */ ++ tcflag_t c_lflag; /* local mode flags */ ++ cc_t c_line; /* line discipline */ ++ cc_t c_cc[NCCS]; /* control characters */ ++ speed_t c_ispeed; /* input speed */ ++ speed_t c_ospeed; /* output speed */ ++}; ++ ++struct ktermios { ++ tcflag_t c_iflag; /* input mode flags */ ++ tcflag_t c_oflag; /* output mode flags */ ++ tcflag_t c_cflag; /* control mode flags */ ++ tcflag_t c_lflag; /* local mode flags */ ++ cc_t c_line; /* line discipline */ ++ cc_t c_cc[NCCS]; /* control characters */ ++ speed_t c_ispeed; /* input speed */ ++ speed_t c_ospeed; /* output speed */ ++}; ++ ++/* c_cc characters */ ++#define VINTR 0 ++#define VQUIT 1 ++#define VERASE 2 ++#define VKILL 3 ++#define VEOF 4 ++#define VTIME 5 ++#define VMIN 6 ++#define VSWTC 7 ++#define VSTART 8 ++#define VSTOP 9 ++#define VSUSP 10 ++#define VEOL 11 ++#define VREPRINT 12 ++#define VDISCARD 13 ++#define VWERASE 14 ++#define VLNEXT 15 ++#define VEOL2 16 ++ ++ ++/* c_iflag bits */ ++#define IGNBRK 0000001 ++#define BRKINT 0000002 ++#define IGNPAR 0000004 ++#define PARMRK 0000010 ++#define INPCK 0000020 ++#define ISTRIP 0000040 ++#define INLCR 0000100 ++#define IGNCR 0000200 ++#define ICRNL 0000400 ++#define IUCLC 0001000 ++#define IXON 0002000 ++#define IXANY 0004000 ++#define IXOFF 0010000 ++#define IMAXBEL 0020000 ++#define IUTF8 0040000 ++ ++/* c_oflag bits */ ++#define OPOST 0000001 ++#define OLCUC 0000002 ++#define ONLCR 0000004 ++#define OCRNL 0000010 ++#define ONOCR 0000020 ++#define ONLRET 0000040 ++#define OFILL 0000100 ++#define OFDEL 0000200 ++#define NLDLY 0000400 ++#define NL0 0000000 ++#define NL1 0000400 ++#define CRDLY 0003000 ++#define CR0 0000000 ++#define CR1 0001000 ++#define CR2 0002000 ++#define CR3 0003000 ++#define TABDLY 0014000 ++#define TAB0 0000000 ++#define TAB1 0004000 ++#define TAB2 0010000 ++#define TAB3 0014000 ++#define XTABS 0014000 ++#define BSDLY 0020000 ++#define BS0 0000000 ++#define BS1 0020000 ++#define VTDLY 0040000 ++#define VT0 0000000 ++#define VT1 0040000 ++#define FFDLY 0100000 ++#define FF0 0000000 ++#define FF1 0100000 ++ ++/* c_cflag bit meaning */ ++#define CBAUD 0010017 ++#define B0 0000000 /* hang up */ ++#define B50 0000001 ++#define B75 0000002 ++#define B110 0000003 ++#define B134 0000004 ++#define B150 0000005 ++#define B200 0000006 ++#define B300 0000007 ++#define B600 0000010 ++#define B1200 0000011 ++#define B1800 0000012 ++#define B2400 0000013 ++#define B4800 0000014 ++#define B9600 0000015 ++#define B19200 0000016 ++#define B38400 0000017 ++#define EXTA B19200 ++#define EXTB B38400 ++#define CSIZE 0000060 ++#define CS5 0000000 ++#define CS6 0000020 ++#define CS7 0000040 ++#define CS8 0000060 ++#define CSTOPB 0000100 ++#define CREAD 0000200 ++#define PARENB 0000400 ++#define PARODD 0001000 ++#define HUPCL 0002000 ++#define CLOCAL 0004000 ++#define CBAUDEX 0010000 ++#define BOTHER 0010000 ++#define B57600 0010001 ++#define B115200 0010002 ++#define B230400 0010003 ++#define B460800 0010004 ++#define B500000 0010005 ++#define B576000 0010006 ++#define B921600 0010007 ++#define B1000000 0010010 ++#define B1152000 0010011 ++#define B1500000 0010012 ++#define B2000000 0010013 ++#define B2500000 0010014 ++#define B3000000 0010015 ++#define B3500000 0010016 ++#define B4000000 0010017 ++#define CIBAUD 002003600000 /* input baud rate */ ++#define CMSPAR 010000000000 /* mark or space (stick) parity */ ++#define CRTSCTS 020000000000 /* flow control */ ++ ++#define IBSHIFT 16 /* Shift from CBAUD to CIBAUD */ ++ ++/* c_lflag bits */ ++#define ISIG 0000001 ++#define ICANON 0000002 ++#define XCASE 0000004 ++#define ECHO 0000010 ++#define ECHOE 0000020 ++#define ECHOK 0000040 ++#define ECHONL 0000100 ++#define NOFLSH 0000200 ++#define TOSTOP 0000400 ++#define ECHOCTL 0001000 ++#define ECHOPRT 0002000 ++#define ECHOKE 0004000 ++#define FLUSHO 0010000 ++#define PENDIN 0040000 ++#define IEXTEN 0100000 ++ ++ ++/* tcflow() and TCXONC use these */ ++#define TCOOFF 0 ++#define TCOON 1 ++#define TCIOFF 2 ++#define TCION 3 ++ ++/* tcflush() and TCFLSH use these */ ++#define TCIFLUSH 0 ++#define TCOFLUSH 1 ++#define TCIOFLUSH 2 ++ ++/* tcsetattr uses these */ ++#define TCSANOW 0 ++#define TCSADRAIN 1 ++#define TCSAFLUSH 2 ++ ++#endif /* _ASM_UBICOM32_TERMBITS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/termios.h linux-2.6.28.10/arch/ubicom32/include/asm/termios.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/termios.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/termios.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,119 @@ ++/* ++ * arch/ubicom32/include/asm/termios.h ++ * Ubicom32 termio definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_TERMIOS_H ++#define _ASM_UBICOM32_TERMIOS_H ++ ++#include ++#include ++ ++struct winsize { ++ unsigned short ws_row; ++ unsigned short ws_col; ++ unsigned short ws_xpixel; ++ unsigned short ws_ypixel; ++}; ++ ++#define NCC 8 ++struct termio { ++ unsigned short c_iflag; /* input mode flags */ ++ unsigned short c_oflag; /* output mode flags */ ++ unsigned short c_cflag; /* control mode flags */ ++ unsigned short c_lflag; /* local mode flags */ ++ unsigned char c_line; /* line discipline */ ++ unsigned char c_cc[NCC]; /* control characters */ ++}; ++ ++#ifdef __KERNEL__ ++/* intr=^C quit=^| erase=del kill=^U ++ eof=^D vtime=\0 vmin=\1 sxtc=\0 ++ start=^Q stop=^S susp=^Z eol=\0 ++ reprint=^R discard=^U werase=^W lnext=^V ++ eol2=\0 ++*/ ++#define INIT_C_CC "\003\034\177\025\004\0\1\0\021\023\032\0\022\017\027\026\0" ++#endif ++ ++/* modem lines */ ++#define TIOCM_LE 0x001 ++#define TIOCM_DTR 0x002 ++#define TIOCM_RTS 0x004 ++#define TIOCM_ST 0x008 ++#define TIOCM_SR 0x010 ++#define TIOCM_CTS 0x020 ++#define TIOCM_CAR 0x040 ++#define TIOCM_RNG 0x080 ++#define TIOCM_DSR 0x100 ++#define TIOCM_CD TIOCM_CAR ++#define TIOCM_RI TIOCM_RNG ++#define TIOCM_OUT1 0x2000 ++#define TIOCM_OUT2 0x4000 ++#define TIOCM_LOOP 0x8000 ++ ++/* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */ ++ ++#ifdef __KERNEL__ ++ ++/* ++ * Translate a "termio" structure into a "termios". Ugh. ++ */ ++#define user_termio_to_kernel_termios(termios, termio) \ ++({ \ ++ unsigned short tmp; \ ++ get_user(tmp, &(termio)->c_iflag); \ ++ (termios)->c_iflag = (0xffff0000 & ((termios)->c_iflag)) | tmp; \ ++ get_user(tmp, &(termio)->c_oflag); \ ++ (termios)->c_oflag = (0xffff0000 & ((termios)->c_oflag)) | tmp; \ ++ get_user(tmp, &(termio)->c_cflag); \ ++ (termios)->c_cflag = (0xffff0000 & ((termios)->c_cflag)) | tmp; \ ++ get_user(tmp, &(termio)->c_lflag); \ ++ (termios)->c_lflag = (0xffff0000 & ((termios)->c_lflag)) | tmp; \ ++ get_user((termios)->c_line, &(termio)->c_line); \ ++ copy_from_user((termios)->c_cc, (termio)->c_cc, NCC); \ ++}) ++ ++/* ++ * Translate a "termios" structure into a "termio". Ugh. ++ */ ++#define kernel_termios_to_user_termio(termio, termios) \ ++({ \ ++ put_user((termios)->c_iflag, &(termio)->c_iflag); \ ++ put_user((termios)->c_oflag, &(termio)->c_oflag); \ ++ put_user((termios)->c_cflag, &(termio)->c_cflag); \ ++ put_user((termios)->c_lflag, &(termio)->c_lflag); \ ++ put_user((termios)->c_line, &(termio)->c_line); \ ++ copy_to_user((termio)->c_cc, (termios)->c_cc, NCC); \ ++}) ++ ++#define user_termios_to_kernel_termios(k, u) copy_from_user(k, u, sizeof(struct termios2)) ++#define kernel_termios_to_user_termios(u, k) copy_to_user(u, k, sizeof(struct termios2)) ++#define user_termios_to_kernel_termios_1(k, u) copy_from_user(k, u, sizeof(struct termios)) ++#define kernel_termios_to_user_termios_1(u, k) copy_to_user(u, k, sizeof(struct termios)) ++ ++#endif /* __KERNEL__ */ ++ ++#endif /* _ASM_UBICOM32_TERMIOS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/thread-asm.h linux-2.6.28.10/arch/ubicom32/include/asm/thread-asm.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/thread-asm.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/thread-asm.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,49 @@ ++/* ++ * arch/ubicom32/include/asm/thread-asm.h ++ * Ubicom32 architecture specific thread definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_THREAD_ASM_H ++#define _ASM_UBICOM32_THREAD_ASM_H ++ ++/* ++ * thread_get_self ++ * Read and shift the current thread into reg ++ */ ++.macro thread_get_self reg ++ lsr.4 \reg, ROSR, #2 ++ and.4 \reg, #31, \reg /* Mask to get thread number into register */ ++.endm ++ ++/* ++ * thread_get_self_mask ++ * Read and shift the current thread mask into reg ++ */ ++.macro thread_get_self_mask reg ++ lsr.4 \reg, ROSR, #2 ++ lsl.4 \reg, #1, \reg /* Thread bit */ ++.endm ++ ++#endif /* _ASM_UBICOM32_THREAD_ASM_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/thread.h linux-2.6.28.10/arch/ubicom32/include/asm/thread.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/thread.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/thread.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,313 @@ ++/* ++ * arch/ubicom32/include/asm/thread.h ++ * Ubicom32 architecture specific thread definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_THREAD_H ++#define _ASM_UBICOM32_THREAD_H ++ ++#if !defined(__ASSEMBLY__) ++ ++#include ++#include ++ ++typedef int thread_t; ++typedef unsigned char thread_type_t; ++typedef void (*thread_exec_fn_t)(void *arg); ++ ++#define THREAD_NULL 0x40 ++#define THREAD_TYPE_HRT (1 << 0) ++#define THREAD_TYPE_SPECIAL 0 ++#define THREAD_TYPE_NORMAL 0 ++#define THREAD_TYPE_BACKGROUND (1 << 1) ++ ++/* ++ * This is the upper bound on the maximum hardware threads that one will find ++ * on a Ubicom processor. It is used to size per hardware thread data structures. ++ */ ++#define THREAD_ARCHITECTURAL_MAX 16 ++ ++/* ++ * TODO: Rename this at some point to be thread_ ++ */ ++extern unsigned int sw_ksp[THREAD_ARCHITECTURAL_MAX]; ++ ++ ++/* ++ * thread_get_self() ++ */ ++static inline thread_t thread_get_self(void) ++{ ++ thread_t result; ++ asm ( ++ "lsr.4 %0, ROSR, #2 \n\t" ++ : "=d" (result) ++ : ++ : "cc" ++ ); ++ return result & 31; ++} ++ ++/* ++ * thread_suspend() ++ */ ++static inline void thread_suspend(void) ++{ ++ asm volatile ( ++ "suspend\n\t" ++ : ++ : ++ ); ++} ++ ++/* ++ * thread_resume() ++ */ ++static inline void thread_resume(thread_t thread) ++{ ++ asm volatile ( ++ "move.4 MT_ACTIVE_SET, %0 \n\t" ++ "pipe_flush 0 \n\t" ++ "pipe_flush 0 \n\t" ++ : ++ : "d" (1 << thread) ++ ); ++} ++ ++ ++ ++/* ++ * thread_enable_mask() ++ * Enable all threads in the mask. ++ * ++ * All writes to MT_EN must be protected by the MT_EN_LOCK bit ++ */ ++static inline void thread_enable_mask(unsigned int mask) ++{ ++ /* ++ * must flush the pipeline twice. ++ * first pipe_flush is to ensure write to MT_EN is completed ++ * second one is to ensure any new instructions from ++ * the targeted thread (the one being disabled), that ++ * are issued while the write to MT_EN is being executed, ++ * are completed. ++ */ ++ UBICOM32_LOCK(MT_EN_LOCK_BIT); ++ asm volatile ( ++ "or.4 MT_EN, MT_EN, %0 \n\t" ++ "pipe_flush 0 \n\t" ++ "pipe_flush 0 \n\t" ++ : ++ : "d" (mask) ++ : "cc" ++ ); ++ UBICOM32_UNLOCK(MT_EN_LOCK_BIT); ++} ++ ++/* ++ * thread_enable() ++ */ ++static inline void thread_enable(thread_t thread) ++{ ++ thread_enable_mask(1 << thread); ++} ++ ++/* ++ * thread_disable_mask() ++ * Disable all threads in the mask. ++ * ++ * All writes to MT_EN must be protected by the MT_EN_LOCK bit ++ */ ++static inline void thread_disable_mask(unsigned int mask) ++{ ++ /* ++ * must flush the pipeline twice. ++ * first pipe_flush is to ensure write to MT_EN is completed ++ * second one is to ensure any new instructions from ++ * the targeted thread (the one being disabled), that ++ * are issued while the write to MT_EN is being executed, ++ * are completed. ++ */ ++ UBICOM32_LOCK(MT_EN_LOCK_BIT); ++ asm volatile ( ++ "and.4 MT_EN, MT_EN, %0 \n\t" ++ "pipe_flush 0 \n\t" ++ "pipe_flush 0 \n\t" ++ : ++ : "d" (~mask) ++ : "cc" ++ ); ++ UBICOM32_UNLOCK(MT_EN_LOCK_BIT); ++} ++ ++/* ++ * thread_disable() ++ */ ++static inline void thread_disable(thread_t thread) ++{ ++ thread_disable_mask(1 << thread); ++} ++ ++/* ++ * thread_disable_others() ++ * Disable all other threads ++ */ ++static inline void thread_disable_others(void) ++{ ++ thread_t self = thread_get_self(); ++ thread_disable_mask(~(1 << self)); ++} ++ ++/* ++ * thread_is_trapped() ++ * Is the specified tid trapped? ++ */ ++static inline int thread_is_trapped(thread_t tid) ++{ ++ int thread_mask = (1 << tid); ++ int trap_thread; ++ ++ asm ( ++ "move.4 %0, MT_TRAP \n\t" ++ : "=d" (trap_thread) ++ : ++ ); ++ return (trap_thread & thread_mask); ++} ++ ++/* ++ * thread_is_enabled() ++ * Is the specified tid enabled? ++ */ ++static inline int thread_is_enabled(thread_t tid) ++{ ++ int thread_mask = (1 << tid); ++ int enabled_threads; ++ ++ asm ( ++ "move.4 %0, MT_EN \n\t" ++ : "=d" (enabled_threads) ++ : ++ ); ++ return (enabled_threads & thread_mask); ++} ++ ++/* ++ * thread_get_instruction_count() ++ */ ++static inline unsigned int thread_get_instruction_count(void) ++{ ++ unsigned int result; ++ asm ( ++ "move.4 %0, INST_CNT \n\t" ++ : "=r" (result) ++ ); ++ return result; ++} ++ ++/* ++ * thread_get_pc() ++ * pc could point to a speculative and cancelled instruction unless thread is disabled ++ */ ++static inline void *thread_get_pc(thread_t thread) ++{ ++ void *result; ++ asm ( ++ "move.4 csr, %1 \n\t" ++ "setcsr_flush 0 \n\t" ++ "move.4 %0, pc \n\t" ++ "move.4 csr, #0 \n\t" ++ "setcsr_flush 0 \n\t" ++ : "=r" (result) ++ : "r" ((thread << 9) | (1 << 8)) ++ ); ++ return result; ++} ++ ++/* ++ * thread_get_trap_cause() ++ * This should be called only when the thread is not running ++ */ ++static inline unsigned int thread_get_trap_cause(thread_t thread) ++{ ++ unsigned int result; ++ asm ( ++ "move.4 csr, %1 \n\t" ++ "setcsr_flush 0 \n\t" ++ "move.4 %0, trap_cause \n\t" ++ "move.4 csr, #0 \n\t" ++ "setcsr_flush 0 \n\t" ++ : "=r" (result) ++ : "r" ((thread << 9) | (1 << 8)) ++ ); ++ return result; ++} ++ ++/* ++ * THREAD_STALL macro. ++ */ ++#define THREAD_STALL \ ++ asm volatile ( \ ++ "move.4 mt_dbg_active_clr, #-1 \n\t" \ ++ "pipe_flush 0 \n\t" \ ++ : \ ++ : \ ++ ) ++ ++extern unsigned int thread_get_mainline(void); ++extern void thread_set_mainline(thread_t tid); ++extern thread_t thread_alloc(void); ++extern thread_t thread_start(thread_t thread, thread_exec_fn_t exec, void *arg, unsigned int *sp_high, thread_type_t type); ++ ++/* ++ * asm macros ++ */ ++asm ( ++/* ++ * thread_get_self ++ * Read and shift the current thread into reg ++ */ ++".macro thread_get_self reg \n\t" ++" lsr.4 \\reg, ROSR, #2 \n\t" ++" and.4 \\reg, #31, \\reg \n\t"/* Mask to get thread number into ++ * register */ ++".endm \n\t" ++ ++/* ++ * thread_get_self_mask ++ * Read and shift the current thread mask into reg ++ */ ++".macro thread_get_self_mask reg \n\t" ++" lsr.4 \\reg, ROSR, #2 \n\t" ++" lsl.4 \\reg, #1, \\reg \n\t" /* Thread bit */ ++".endm \n\t" ++ ); ++ ++#else /* __ASSEMBLY__ */ ++ ++#include ++ ++#endif /* __ASSEMBLY__ */ ++#endif /* _ASM_UBICOM32_THREAD_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/thread_info.h linux-2.6.28.10/arch/ubicom32/include/asm/thread_info.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/thread_info.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/thread_info.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,134 @@ ++/* ++ * arch/ubicom32/include/asm/thread_info.h ++ * Ubicom32 architecture low-level thread information. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * Adapted from the i386 and PPC versions by Greg Ungerer (gerg@snapgear.com) ++ * Copyright (C) 2002 David Howells (dhowells@redhat.com) ++ * - Incorporating suggestions made by Linus Torvalds and Dave Miller ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_THREAD_INFO_H ++#define _ASM_UBICOM32_THREAD_INFO_H ++ ++#include ++ ++/* ++ * Size of kernel stack for each process. This must be a power of 2... ++ */ ++#ifdef CONFIG_4KSTACKS ++#define THREAD_SIZE_ORDER (0) ++#else ++#define THREAD_SIZE_ORDER (1) ++#endif ++ ++/* ++ * for asm files, THREAD_SIZE is now generated by asm-offsets.c ++ */ ++#define THREAD_SIZE (PAGE_SIZE< preemptable, <0 => BUG */ ++ int interrupt_nesting; /* Interrupt nesting level. */ ++ struct restart_block restart_block; ++}; ++ ++/* ++ * macros/functions for gaining access to the thread information structure ++ */ ++#define INIT_THREAD_INFO(tsk) \ ++{ \ ++ .task = &tsk, \ ++ .exec_domain = &default_exec_domain, \ ++ .flags = 0, \ ++ .cpu = 0, \ ++ .interrupt_nesting = 0, \ ++ .restart_block = { \ ++ .fn = do_no_restart_syscall, \ ++ }, \ ++} ++ ++#define init_thread_info (init_thread_union.thread_info) ++#define init_stack (init_thread_union.stack) ++ ++ ++/* how to get the thread information struct from C */ ++static inline struct thread_info *current_thread_info(void) ++{ ++ struct thread_info *ti; ++ ++ asm ( ++ "and.4 %0, sp, %1\n\t" ++ : "=&r" (ti) ++ : "d" (~(THREAD_SIZE-1)) ++ : "cc" ++ ); ++ ++ return ti; ++} ++ ++#define STACK_WARN (THREAD_SIZE / 8) ++ ++#define __HAVE_ARCH_THREAD_INFO_ALLOCATOR 1 ++ ++/* thread information allocation */ ++#define alloc_thread_info(tsk) ((struct thread_info *) \ ++ __get_free_pages(GFP_KERNEL, THREAD_SIZE_ORDER)) ++#define free_thread_info(ti) free_pages((unsigned long) (ti), THREAD_SIZE_ORDER) ++#endif /* __ASSEMBLY__ */ ++ ++#define PREEMPT_ACTIVE 0x4000000 ++ ++/* ++ * thread information flag bit numbers ++ */ ++#define TIF_SYSCALL_TRACE 0 /* syscall trace active */ ++#define TIF_SIGPENDING 1 /* signal pending */ ++#define TIF_NEED_RESCHED 2 /* rescheduling necessary */ ++#define TIF_POLLING_NRFLAG 3 /* true if poll_idle() is polling ++ TIF_NEED_RESCHED */ ++#define TIF_MEMDIE 4 ++ ++/* as above, but as bit values */ ++#define _TIF_SYSCALL_TRACE (1<. ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_TIMEX_H ++#define _ASM_UBICOM32_TIMEX_H ++ ++#define CLOCK_TICK_RATE 266000000 ++ ++// #define ARCH_HAS_READ_CURRENT_TIMER ++ ++typedef unsigned long cycles_t; ++ ++static inline cycles_t get_cycles(void) ++{ ++ return 0; ++} ++ ++extern int timer_alloc(void); ++extern void timer_set(int timervector, unsigned int cycles); ++extern int timer_reset(int timervector, unsigned int cycles); ++extern void timer_tick_init(void); ++extern void timer_device_init(void); ++ ++#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) ++extern void local_timer_interrupt(void); ++#endif ++ ++#if defined(CONFIG_LOCAL_TIMERS) || defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) ++extern int local_timer_setup(unsigned int cpu); ++#endif ++ ++#endif /* _ASM_UBICOM32_TIMEX_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/tlbflush.h linux-2.6.28.10/arch/ubicom32/include/asm/tlbflush.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/tlbflush.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/tlbflush.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,79 @@ ++/* ++ * arch/ubicom32/include/asm/tlbflush.h ++ * TLB operations for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * Copyright (C) 2000 Lineo, David McCullough ++ * Copyright (C) 2000-2002, Greg Ungerer ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_TLB_FLUSH_H ++#define _ASM_UBICOM32_TLB_FLUSH_H ++ ++#include ++ ++/* ++ * flush all user-space atc entries. ++ */ ++static inline void __flush_tlb(void) ++{ ++ BUG(); ++} ++ ++static inline void __flush_tlb_one(unsigned long addr) ++{ ++ BUG(); ++} ++ ++#define flush_tlb() __flush_tlb() ++ ++/* ++ * flush all atc entries (both kernel and user-space entries). ++ */ ++static inline void flush_tlb_all(void) ++{ ++ BUG(); ++} ++ ++static inline void flush_tlb_mm(struct mm_struct *mm) ++{ ++ BUG(); ++} ++ ++static inline void flush_tlb_page(struct vm_area_struct *vma, unsigned long addr) ++{ ++ BUG(); ++} ++ ++static inline void flush_tlb_range(struct mm_struct *mm, ++ unsigned long start, unsigned long end) ++{ ++ BUG(); ++} ++ ++static inline void flush_tlb_kernel_page(unsigned long addr) ++{ ++ BUG(); ++} ++ ++#endif /* _ASM_UBICOM32_TLB_FLUSH_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/tlb.h linux-2.6.28.10/arch/ubicom32/include/asm/tlb.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/tlb.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/tlb.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,47 @@ ++/* ++ * arch/ubicom32/include/asm/tlb.h ++ * Ubicom32 architecture TLB operations. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_TLB_H ++#define _ASM_UBICOM32_TLB_H ++ ++/* ++ * ubicom32 doesn't need any special per-pte or ++ * per-vma handling.. ++ */ ++#define tlb_start_vma(tlb, vma) do { } while (0) ++#define tlb_end_vma(tlb, vma) do { } while (0) ++#define __tlb_remove_tlb_entry(tlb, ptep, address) do { } while (0) ++ ++/* ++ * .. because we flush the whole mm when it ++ * fills up. ++ */ ++#define tlb_flush(tlb) ++ ++#include ++ ++#endif /* _ASM_UBICOM32_TLB_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/topology.h linux-2.6.28.10/arch/ubicom32/include/asm/topology.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/topology.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/topology.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/topology.h ++ * Generic topology.h definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_TOPOLOGY_H ++#define _ASM_UBICOM32_TOPOLOGY_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_TOPOLOGY_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/traps.h linux-2.6.28.10/arch/ubicom32/include/asm/traps.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/traps.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/traps.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,55 @@ ++/* ++ * arch/ubicom32/include/asm/traps.h ++ * Trap related definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_TRAPS_H ++#define _ASM_UBICOM32_TRAPS_H ++ ++/* ++ * Trap causes passed from ultra to Host OS ++ */ ++#define TRAP_CAUSE_TOTAL 13 ++#define TRAP_CAUSE_DST_RANGE_ERR 12 ++#define TRAP_CAUSE_SRC1_RANGE_ERR 11 ++#define TRAP_CAUSE_I_RANGE_ERR 10 ++#define TRAP_CAUSE_DCAPT 9 ++#define TRAP_CAUSE_DST_SERROR 8 ++#define TRAP_CAUSE_SRC1_SERROR 7 ++#define TRAP_CAUSE_DST_MISALIGNED 6 ++#define TRAP_CAUSE_SRC1_MISALIGNED 5 ++#define TRAP_CAUSE_DST_DECODE_ERR 4 ++#define TRAP_CAUSE_SRC1_DECODE_ERR 3 ++#define TRAP_CAUSE_ILLEGAL_INST 2 ++#define TRAP_CAUSE_I_SERROR 1 ++#define TRAP_CAUSE_I_DECODE_ERR 0 ++ ++extern void trap_handler(int irq, struct pt_regs *regs); ++extern void trap_init_interrupt(void); ++extern void unaligned_emulate(unsigned int thread); ++extern int unaligned_only(unsigned int cause); ++ ++#endif /* _ASM_UBICOM32_TRAPS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/types.h linux-2.6.28.10/arch/ubicom32/include/asm/types.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/types.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/types.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,75 @@ ++/* ++ * arch/ubicom32/include/asm/types.h ++ * Date type definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_TYPES_H ++#define _ASM_UBICOM32_TYPES_H ++ ++/* ++ * This file is never included by application software unless ++ * explicitly requested (e.g., via linux/types.h) in which case the ++ * application is Linux specific so (user-) name space pollution is ++ * not a major issue. However, for interoperability, libraries still ++ * need to be careful to avoid a name clashes. ++ */ ++ ++#include ++ ++#ifndef __ASSEMBLY__ ++ ++typedef unsigned short umode_t; ++ ++#endif /* __ASSEMBLY__ */ ++ ++/* ++ * These aren't exported outside the kernel to avoid name space clashes ++ */ ++#ifdef __KERNEL__ ++ ++#define BITS_PER_LONG 32 ++ ++#ifndef __ASSEMBLY__ ++ ++/* DMA addresses are always 32-bits wide */ ++ ++typedef u32 dma_addr_t; ++typedef u32 dma64_addr_t; ++ ++/* ++ * XXX These are "Ubicom style" typedefs. They should be removed in all files used by linux. ++ */ ++typedef u32 u32_t; ++typedef s32 s32_t; ++typedef u16 u16_t; ++typedef s16 s16_t; ++typedef u8 u8_t; ++typedef s8 s8_t; ++ ++#endif /* __ASSEMBLY__ */ ++ ++#endif /* __KERNEL__ */ ++ ++#endif /* _ASM_UBICOM32_TYPES_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/uaccess.h linux-2.6.28.10/arch/ubicom32/include/asm/uaccess.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/uaccess.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/uaccess.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,347 @@ ++/* ++ * arch/ubicom32/include/asm/uaccess.h ++ * User space memory access functions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ * arch/alpha ++ */ ++#ifndef _ASM_UBICOM32_UACCESS_H ++#define _ASM_UBICOM32_UACCESS_H ++ ++/* ++ * User space memory access functions ++ */ ++#include ++#include ++#include ++ ++#include ++ ++#define VERIFY_READ 0 ++#define VERIFY_WRITE 1 ++ ++/* ++ * The exception table consists of pairs of addresses: the first is the ++ * address of an instruction that is allowed to fault, and the second is ++ * the address at which the program should continue. No registers are ++ * modified, so it is entirely up to the continuation code to figure out ++ * what to do. ++ * ++ * All the routines below use bits of fixup code that are out of line ++ * with the main instruction path. This means when everything is well, ++ * we don't even have to jump over them. Further, they do not intrude ++ * on our cache or tlb entries. ++ */ ++struct exception_table_entry ++{ ++ unsigned long insn, fixup; ++}; ++ ++/* ++ * Ubicom32 does not currently support the exception table handling. ++ */ ++extern unsigned long search_exception_table(unsigned long); ++ ++ ++#if defined(CONFIG_ACCESS_OK_CHECKS_ENABLED) ++extern int __access_ok(unsigned long addr, unsigned long size); ++#else ++static inline int __access_ok(unsigned long addr, unsigned long size) ++{ ++ return 1; ++} ++#endif ++#define access_ok(type, addr, size) \ ++ likely(__access_ok((unsigned long)(addr), (size))) ++ ++/* ++ * The following functions do not exist. They keep callers ++ * of put_user and get_user from passing unsupported argument ++ * types. They result in a link time error. ++ */ ++extern int __put_user_bad(void); ++extern int __get_user_bad(void); ++ ++/* ++ * __put_user_no_check() ++ * Put the requested data into the user space verifying the address ++ * ++ * Careful to not ++ * (a) re-use the arguments for side effects (sizeof/typeof is ok) ++ * (b) require any knowledge of processes at this stage ++ */ ++#define __put_user_no_check(x, ptr, size) \ ++({ \ ++ int __pu_err = 0; \ ++ __typeof__(*(ptr)) __user *__pu_addr = (ptr); \ ++ switch (size) { \ ++ case 1: \ ++ case 2: \ ++ case 4: \ ++ case 8: \ ++ *__pu_addr = (__typeof__(*(ptr)))x; \ ++ break; \ ++ default: \ ++ __pu_err = __put_user_bad(); \ ++ break; \ ++ } \ ++ __pu_err; \ ++}) ++ ++/* ++ * __put_user_check() ++ * Put the requested data into the user space verifying the address ++ * ++ * Careful to not ++ * (a) re-use the arguments for side effects (sizeof/typeof is ok) ++ * (b) require any knowledge of processes at this stage ++ * ++ * If requested, access_ok() will verify that ptr is a valid user ++ * pointer. ++ */ ++#define __put_user_check(x, ptr, size) \ ++({ \ ++ int __pu_err = -EFAULT; \ ++ __typeof__(*(ptr)) __user *__pu_addr = (ptr); \ ++ if (access_ok(VERIFY_WRITE, __pu_addr, size)) { \ ++ __pu_err = 0; \ ++ switch (size) { \ ++ case 1: \ ++ case 2: \ ++ case 4: \ ++ case 8: \ ++ *__pu_addr = (__typeof__(*(ptr)))x; \ ++ break; \ ++ default: \ ++ __pu_err = __put_user_bad(); \ ++ break; \ ++ } \ ++ } \ ++ __pu_err; \ ++}) ++ ++/* ++ * __get_user_no_check() ++ * Read the value at ptr into x. ++ * ++ * If requested, access_ok() will verify that ptr is a valid user ++ * pointer. If the caller passes a modifying argument for ptr (e.g. x++) ++ * this macro will not work. ++ */ ++#define __get_user_no_check(x, ptr, size) \ ++({ \ ++ int __gu_err = 0; \ ++ __typeof__((x)) __gu_val = 0; \ ++ const __typeof__(*(ptr)) __user *__gu_addr = (ptr); \ ++ switch (size) { \ ++ case 1: \ ++ case 2: \ ++ case 4: \ ++ case 8: \ ++ __gu_val = (__typeof__((x)))*(__gu_addr); \ ++ break; \ ++ default: \ ++ __gu_err = __get_user_bad(); \ ++ (x) = 0; \ ++ break; \ ++ } \ ++ (x) = __gu_val; \ ++ __gu_err; \ ++}) ++ ++/* ++ * __get_user_check() ++ * Read the value at ptr into x. ++ * ++ * If requested, access_ok() will verify that ptr is a valid user ++ * pointer. ++ */ ++#define __get_user_check(x, ptr, size) \ ++({ \ ++ int __gu_err = -EFAULT; \ ++ __typeof__(x) __gu_val = 0; \ ++ const __typeof__(*(ptr)) __user *__gu_addr = (ptr); \ ++ if (access_ok(VERIFY_READ, __gu_addr, size)) { \ ++ __gu_err = 0; \ ++ switch (size) { \ ++ case 1: \ ++ case 2: \ ++ case 4: \ ++ case 8: \ ++ __gu_val = (__typeof__((x)))*(__gu_addr); \ ++ break; \ ++ default: \ ++ __gu_err = __get_user_bad(); \ ++ (x) = 0; \ ++ break; \ ++ } \ ++ } \ ++ (x) = __gu_val; \ ++ __gu_err; \ ++}) ++ ++/* ++ * The "xxx" versions are allowed to perform some amount of address ++ * space checking. See access_ok(). ++ */ ++#define put_user(x,ptr) \ ++ __put_user_check((__typeof__(*(ptr)))(x),(ptr), sizeof(*(ptr))) ++#define get_user(x,ptr) \ ++ __get_user_check((x), (ptr), sizeof(*(ptr))) ++ ++/* ++ * The "__xxx" versions do not do address space checking, useful when ++ * doing multiple accesses to the same area (the programmer has to do the ++ * checks by hand with "access_ok()") ++ */ ++#define __put_user(x,ptr) \ ++ __put_user_no_check((__typeof__(*(ptr)))(x),(ptr), sizeof(*(ptr))) ++#define __get_user(x,ptr) \ ++ __get_user_no_check((x), (ptr), sizeof(*(ptr))) ++ ++/* ++ * __copy_tofrom_user_no_check() ++ * Copy the data either to or from user space. ++ * ++ * Return the number of bytes NOT copied. ++ */ ++static inline unsigned long ++__copy_tofrom_user_no_check(void *to, const void *from, unsigned long n) ++{ ++ memcpy(to, from, n); ++ return 0; ++} ++ ++/* ++ * copy_to_user() ++ * Copy the kernel data to user space. ++ * ++ * Return the number of bytes that were copied. ++ */ ++static inline unsigned long ++copy_to_user(void __user *to, const void *from, unsigned long n) ++{ ++ if (!access_ok(VERIFY_WRITE, to, n)) { ++ return n; ++ } ++ return __copy_tofrom_user_no_check((__force void *)to, from, n); ++} ++ ++/* ++ * copy_from_user() ++ * Copy the user data to kernel space. ++ * ++ * Return the number of bytes that were copied. On error, we zero ++ * out the destination. ++ */ ++static inline unsigned long ++copy_from_user(void *to, const void __user *from, unsigned long n) ++{ ++ if (!access_ok(VERIFY_READ, from, n)) { ++ return n; ++ } ++ return __copy_tofrom_user_no_check(to, (__force void *)from, n); ++} ++ ++#define __copy_to_user(to, from, n) \ ++ __copy_tofrom_user_no_check((__force void *)to, from, n) ++#define __copy_from_user(to, from, n) \ ++ __copy_tofrom_user_no_check(to, (__force void *)from, n) ++#define __copy_to_user_inatomic(to, from, n) \ ++ __copy_tofrom_user_no_check((__force void *)to, from, n) ++#define __copy_from_user_inatomic(to, from, n) \ ++ __copy_tofrom_user_no_check(to, (__force void *)from, n) ++ ++#define copy_to_user_ret(to, from, n, retval) \ ++ ({ if (copy_to_user(to, from, n)) return retval; }) ++ ++#define copy_from_user_ret(to, from, n, retval) \ ++ ({ if (copy_from_user(to, from, n)) return retval; }) ++ ++/* ++ * strncpy_from_user() ++ * Copy a null terminated string from userspace. ++ * ++ * dst - Destination in kernel space. The buffer must be at least count. ++ * src - Address of string in user space. ++ * count - Maximum number of bytes to copy (including the trailing NULL). ++ * ++ * Returns the length of the string (not including the trailing NULL. If ++ * count is smaller than the length of the string, we copy count bytes ++ * and return count. ++ * ++ */ ++static inline long strncpy_from_user(char *dst, const __user char *src, long count) ++{ ++ char *tmp; ++ if (!access_ok(VERIFY_READ, src, 1)) { ++ return -EFAULT; ++ } ++ ++ strncpy(dst, src, count); ++ for (tmp = dst; *tmp && count > 0; tmp++, count--) { ++ ; ++ } ++ return(tmp - dst); ++} ++ ++/* ++ * strnlen_user() ++ * Return the size of a string (including the ending 0) ++ * ++ * Return -EFAULT on exception, a value greater than if too long ++ */ ++static inline long strnlen_user(const __user char *src, long n) ++{ ++ if (!access_ok(VERIFY_READ, src, 1)) { ++ return -EFAULT; ++ } ++ return(strlen(src) + 1); ++} ++ ++#define strlen_user(str) strnlen_user(str, 32767) ++ ++/* ++ * __clear_user() ++ * Zero Userspace ++ */ ++static inline unsigned long __clear_user(__user void *to, unsigned long n) ++{ ++ memset(to, 0, n); ++ return 0; ++} ++ ++/* ++ * clear_user() ++ * Zero user space (check for valid addresses) ++ */ ++static inline unsigned long clear_user(__user void *to, unsigned long n) ++{ ++ if (!access_ok(VERIFY_WRITE, to, n)) { ++ return -EFAULT; ++ } ++ return __clear_user(to, n); ++} ++ ++#endif /* _ASM_UBICOM32_UACCESS_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ubicom32-common-asm.h linux-2.6.28.10/arch/ubicom32/include/asm/ubicom32-common-asm.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ubicom32-common-asm.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ubicom32-common-asm.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,49 @@ ++/* ++ * arch/ubicom32/include/asm/ubicom32-common-asm.h ++ * Ubicom32 atomic lock operations. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_UBICOM32_COMMON_ASM_H ++#define _ASM_UBICOM32_UBICOM32_COMMON_ASM_H ++ ++/* ++ * atomic_lock_acquire macro ++ * Equivalent to __atomic_lock_acquire() ++ */ ++.macro atomic_lock_acquire ++ bset scratchpad1, scratchpad1, #ATOMIC_LOCK_BIT ++ jmpne.f .-4 ++.endm ++ ++/* ++ * atomic_lock_release macro ++ * Equivalent to __atomic_lock_release() ++ */ ++.macro atomic_lock_release ++ bclr scratchpad1, scratchpad1, #ATOMIC_LOCK_BIT ++.endm ++ ++#endif /* _ASM_UBICOM32_UBICOM32_COMMON_ASM_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ubicom32-common.h linux-2.6.28.10/arch/ubicom32/include/asm/ubicom32-common.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ubicom32-common.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ubicom32-common.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,124 @@ ++/* ++ * arch/ubicom32/include/asm/ubicom32-common.h ++ * Ubicom32 atomic lock operations. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++ ++#ifndef _ASM_UBICOM32_UBICOM32_COMMON_H ++#define _ASM_UBICOM32_UBICOM32_COMMON_H ++ ++#define S(arg) #arg ++#define D(arg) S(arg) ++/* ++ * scratchpad1 is owned by the LDSR. ++ * ++ * The upper bits provide 16 global spinlocks. Acquiring one of these ++ * global spinlocks synchornizes across multiple threads and prevents ++ * the LDSR from delivering any interrupts while the lock is held. ++ * Use these locks only when absolutely required. ++ * ++ * The lower 16 bits of scratchpad1 are used as per thread interrupt ++ * enable/disable bits. These bits will prevent a thread from receiving ++ * any interrupts. ++ * ++ * Bit Usage: ++ * - MT_EN_LOCK_BIT - Protects writes to MT_EN, so code can read current value ++ * then write a new value atomically (profiler for example) ++ * - ATOMIC_LOCK_BIT - Used to provide general purpose atomic handling. ++ * - LDSR_LOCK_BIT - Used by the LDSR exclusively to provide protection. ++ * - LSB 16 bits - Used by the LDSR to represent thread enable/disable bits. ++ */ ++#define MT_EN_LOCK_BIT 31 ++#define ATOMIC_LOCK_BIT 30 ++#define LDSR_LOCK_BIT 29 ++#define PCI_LOCK_BIT 28 ++ ++#if !defined(__ASSEMBLY__) ++ ++#define UBICOM32_TRYLOCK(bit) \ ++ asm volatile ( \ ++ " move.4 %0, #0 \n\t" \ ++ " bset scratchpad1, scratchpad1, #"D(bit)" \n\t" \ ++ " jmpne.f 1f \n\t" \ ++ " move.4 %0, #1 \n\t" \ ++ "1: \n\t" \ ++ : "=r" (ret) \ ++ : \ ++ : "cc", "memory" \ ++ ); \ ++ ++#define UBICOM32_UNLOCK(bit) \ ++ asm volatile ( \ ++ " bclr scratchpad1, scratchpad1, #"D(bit)" \n\t" \ ++ : \ ++ : \ ++ : "cc", "memory" \ ++ ); \ ++ ++#define UBICOM32_LOCK(bit) \ ++ asm volatile ( \ ++ "1: bset scratchpad1, scratchpad1, #"D(bit)" \n\t" \ ++ " jmpne.f 1b \n\t" \ ++ : \ ++ : \ ++ : "cc", "memory" \ ++ ); \ ++ ++/* ++ * __atomic_lock_trylock() ++ * Attempt to acquire the lock, return TRUE if acquired. ++ */ ++static inline int __atomic_lock_trylock(void) ++{ ++ int ret; ++ UBICOM32_TRYLOCK(ATOMIC_LOCK_BIT); ++ return ret; ++} ++ ++/* ++ * __atomic_lock_release() ++ * Release the global atomic lock. ++ * ++ * Note: no one is suspended waiting since this lock is a spinning lock. ++ */ ++static inline void __atomic_lock_release(void) ++{ ++ UBICOM32_UNLOCK(ATOMIC_LOCK_BIT); ++} ++ ++/* ++ * __atomic_lock_acquire() ++ * Acquire the global atomic lock, spin if not available. ++ */ ++static inline void __atomic_lock_acquire(void) ++{ ++ UBICOM32_LOCK(ATOMIC_LOCK_BIT); ++} ++#else /* __ASSEMBLY__ */ ++ ++#include ++ ++#endif /* __ASSEMBLY__ */ ++#endif /* _ASM_UBICOM32_UBICOM32_COMMON_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/ucontext.h linux-2.6.28.10/arch/ubicom32/include/asm/ucontext.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/ucontext.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/ucontext.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,39 @@ ++/* ++ * arch/ubicom32/include/asm/ucontext.h ++ * Definition of ucontext structure for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_UCONTEXT_H ++#define _ASM_UBICOM32_UCONTEXT_H ++ ++struct ucontext { ++ unsigned long uc_flags; ++ struct ucontext *uc_link; ++ stack_t uc_stack; ++ struct sigcontext uc_mcontext; ++ sigset_t uc_sigmask; /* mask last for extensibility */ ++}; ++ ++#endif /* _ASM_UBICOM32_UCONTEXT_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/unaligned.h linux-2.6.28.10/arch/ubicom32/include/asm/unaligned.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/unaligned.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/unaligned.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,44 @@ ++/* ++ * arch/ubicom32/include/asm/unaligned.h ++ * Ubicom32 architecture unaligned memory access definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ * ++ * TODO: This is a copy of arm unaligned handling that probably needs ++ * to be optimized for UBICOM32, but it works for now. ++ */ ++ ++#ifndef _ASM_UBICOM32_UNALIGNED_H ++#define _ASM_UBICOM32_UNALIGNED_H ++ ++#include ++ ++#include ++#include ++#include ++ ++#define get_unaligned __get_unaligned_be ++#define put_unaligned __put_unaligned_be ++ ++#endif /* _ASM_UBICOM32_UNALIGNED_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/unistd.h linux-2.6.28.10/arch/ubicom32/include/asm/unistd.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/unistd.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/unistd.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,400 @@ ++/* ++ * arch/ubicom32/include/asm/unistd.h ++ * Ubicom32 architecture syscall definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_UNISTD_H ++#define _ASM_UBICOM32_UNISTD_H ++ ++/* ++ * This file contains the system call numbers. ++ */ ++ ++#define __NR_restart_syscall 0 ++#define __NR_exit 1 ++#define __NR_fork 2 ++#define __NR_read 3 ++#define __NR_write 4 ++#define __NR_open 5 ++#define __NR_close 6 ++#define __NR_waitpid 7 ++#define __NR_creat 8 ++#define __NR_link 9 ++#define __NR_unlink 10 ++#define __NR_execve 11 ++#define __NR_chdir 12 ++#define __NR_time 13 ++#define __NR_mknod 14 ++#define __NR_chmod 15 ++#define __NR_chown 16 ++#define __NR_break 17 ++#define __NR_oldstat 18 ++#define __NR_lseek 19 ++#define __NR_getpid 20 ++#define __NR_mount 21 ++#define __NR_umount 22 ++#define __NR_setuid 23 ++#define __NR_getuid 24 ++#define __NR_stime 25 ++#define __NR_ptrace 26 ++#define __NR_alarm 27 ++#define __NR_oldfstat 28 ++#define __NR_pause 29 ++#define __NR_utime 30 ++#define __NR_stty 31 ++#define __NR_gtty 32 ++#define __NR_access 33 ++#define __NR_nice 34 ++#define __NR_ftime 35 ++#define __NR_sync 36 ++#define __NR_kill 37 ++#define __NR_rename 38 ++#define __NR_mkdir 39 ++#define __NR_rmdir 40 ++#define __NR_dup 41 ++#define __NR_pipe 42 ++#define __NR_times 43 ++#define __NR_prof 44 ++#define __NR_brk 45 ++#define __NR_setgid 46 ++#define __NR_getgid 47 ++#define __NR_signal 48 ++#define __NR_geteuid 49 ++#define __NR_getegid 50 ++#define __NR_acct 51 ++#define __NR_umount2 52 ++#define __NR_lock 53 ++#define __NR_ioctl 54 ++#define __NR_fcntl 55 ++#define __NR_mpx 56 ++#define __NR_setpgid 57 ++#define __NR_ulimit 58 ++#define __NR_oldolduname 59 ++#define __NR_umask 60 ++#define __NR_chroot 61 ++#define __NR_ustat 62 ++#define __NR_dup2 63 ++#define __NR_getppid 64 ++#define __NR_getpgrp 65 ++#define __NR_setsid 66 ++#define __NR_sigaction 67 ++#define __NR_sgetmask 68 ++#define __NR_ssetmask 69 ++#define __NR_setreuid 70 ++#define __NR_setregid 71 ++#define __NR_sigsuspend 72 ++#define __NR_sigpending 73 ++#define __NR_sethostname 74 ++#define __NR_setrlimit 75 ++#define __NR_getrlimit 76 ++#define __NR_getrusage 77 ++#define __NR_gettimeofday 78 ++#define __NR_settimeofday 79 ++#define __NR_getgroups 80 ++#define __NR_setgroups 81 ++#define __NR_select 82 ++#define __NR_symlink 83 ++#define __NR_oldlstat 84 ++#define __NR_readlink 85 ++#define __NR_uselib 86 ++#define __NR_swapon 87 ++#define __NR_reboot 88 ++#define __NR_readdir 89 ++#define __NR_mmap 90 ++#define __NR_munmap 91 ++#define __NR_truncate 92 ++#define __NR_ftruncate 93 ++#define __NR_fchmod 94 ++#define __NR_fchown 95 ++#define __NR_getpriority 96 ++#define __NR_setpriority 97 ++#define __NR_profil 98 ++#define __NR_statfs 99 ++#define __NR_fstatfs 100 ++#define __NR_ioperm 101 ++#define __NR_socketcall 102 ++#define __NR_syslog 103 ++#define __NR_setitimer 104 ++#define __NR_getitimer 105 ++#define __NR_stat 106 ++#define __NR_lstat 107 ++#define __NR_fstat 108 ++#define __NR_olduname 109 ++#define __NR_iopl /* 110 */ not supported ++#define __NR_vhangup 111 ++#define __NR_idle /* 112 */ Obsolete ++#define __NR_vm86 /* 113 */ not supported ++#define __NR_wait4 114 ++#define __NR_swapoff 115 ++#define __NR_sysinfo 116 ++#define __NR_ipc 117 ++#define __NR_fsync 118 ++#define __NR_sigreturn 119 ++#define __NR_clone 120 ++#define __NR_setdomainname 121 ++#define __NR_uname 122 ++#define __NR_cacheflush 123 ++#define __NR_adjtimex 124 ++#define __NR_mprotect 125 ++#define __NR_sigprocmask 126 ++#define __NR_create_module 127 ++#define __NR_init_module 128 ++#define __NR_delete_module 129 ++#define __NR_get_kernel_syms 130 ++#define __NR_quotactl 131 ++#define __NR_getpgid 132 ++#define __NR_fchdir 133 ++#define __NR_bdflush 134 ++#define __NR_sysfs 135 ++#define __NR_personality 136 ++#define __NR_afs_syscall 137 /* Syscall for Andrew File System */ ++#define __NR_setfsuid 138 ++#define __NR_setfsgid 139 ++#define __NR__llseek 140 ++#define __NR_getdents 141 ++#define __NR__newselect 142 ++#define __NR_flock 143 ++#define __NR_msync 144 ++#define __NR_readv 145 ++#define __NR_writev 146 ++#define __NR_getsid 147 ++#define __NR_fdatasync 148 ++#define __NR__sysctl 149 ++#define __NR_mlock 150 ++#define __NR_munlock 151 ++#define __NR_mlockall 152 ++#define __NR_munlockall 153 ++#define __NR_sched_setparam 154 ++#define __NR_sched_getparam 155 ++#define __NR_sched_setscheduler 156 ++#define __NR_sched_getscheduler 157 ++#define __NR_sched_yield 158 ++#define __NR_sched_get_priority_max 159 ++#define __NR_sched_get_priority_min 160 ++#define __NR_sched_rr_get_interval 161 ++#define __NR_nanosleep 162 ++#define __NR_mremap 163 ++#define __NR_setresuid 164 ++#define __NR_getresuid 165 ++#define __NR_getpagesize 166 ++#define __NR_query_module 167 ++#define __NR_poll 168 ++#define __NR_nfsservctl 169 ++#define __NR_setresgid 170 ++#define __NR_getresgid 171 ++#define __NR_prctl 172 ++#define __NR_rt_sigreturn 173 ++#define __NR_rt_sigaction 174 ++#define __NR_rt_sigprocmask 175 ++#define __NR_rt_sigpending 176 ++#define __NR_rt_sigtimedwait 177 ++#define __NR_rt_sigqueueinfo 178 ++#define __NR_rt_sigsuspend 179 ++#define __NR_pread64 180 ++#define __NR_pwrite64 181 ++#define __NR_lchown 182 ++#define __NR_getcwd 183 ++#define __NR_capget 184 ++#define __NR_capset 185 ++#define __NR_sigaltstack 186 ++#define __NR_sendfile 187 ++#define __NR_getpmsg 188 /* some people actually want streams */ ++#define __NR_putpmsg 189 /* some people actually want streams */ ++#define __NR_vfork 190 ++#define __NR_ugetrlimit 191 ++#define __NR_mmap2 192 ++#define __NR_truncate64 193 ++#define __NR_ftruncate64 194 ++#define __NR_stat64 195 ++#define __NR_lstat64 196 ++#define __NR_fstat64 197 ++#define __NR_chown32 198 ++#define __NR_getuid32 199 ++#define __NR_getgid32 200 ++#define __NR_geteuid32 201 ++#define __NR_getegid32 202 ++#define __NR_setreuid32 203 ++#define __NR_setregid32 204 ++#define __NR_getgroups32 205 ++#define __NR_setgroups32 206 ++#define __NR_fchown32 207 ++#define __NR_setresuid32 208 ++#define __NR_getresuid32 209 ++#define __NR_setresgid32 210 ++#define __NR_getresgid32 211 ++#define __NR_lchown32 212 ++#define __NR_setuid32 213 ++#define __NR_setgid32 214 ++#define __NR_setfsuid32 215 ++#define __NR_setfsgid32 216 ++#define __NR_pivot_root 217 ++#define __NR_getdents64 220 ++#define __NR_gettid 221 ++#define __NR_tkill 222 ++#define __NR_setxattr 223 ++#define __NR_lsetxattr 224 ++#define __NR_fsetxattr 225 ++#define __NR_getxattr 226 ++#define __NR_lgetxattr 227 ++#define __NR_fgetxattr 228 ++#define __NR_listxattr 229 ++#define __NR_llistxattr 230 ++#define __NR_flistxattr 231 ++#define __NR_removexattr 232 ++#define __NR_lremovexattr 233 ++#define __NR_fremovexattr 234 ++#define __NR_futex 235 ++#define __NR_sendfile64 236 ++#define __NR_mincore 237 ++#define __NR_madvise 238 ++#define __NR_fcntl64 239 ++#define __NR_readahead 240 ++#define __NR_io_setup 241 ++#define __NR_io_destroy 242 ++#define __NR_io_getevents 243 ++#define __NR_io_submit 244 ++#define __NR_io_cancel 245 ++#define __NR_fadvise64 246 ++#define __NR_exit_group 247 ++#define __NR_lookup_dcookie 248 ++#define __NR_epoll_create 249 ++#define __NR_epoll_ctl 250 ++#define __NR_epoll_wait 251 ++#define __NR_remap_file_pages 252 ++#define __NR_set_tid_address 253 ++#define __NR_timer_create 254 ++#define __NR_timer_settime 255 ++#define __NR_timer_gettime 256 ++#define __NR_timer_getoverrun 257 ++#define __NR_timer_delete 258 ++#define __NR_clock_settime 259 ++#define __NR_clock_gettime 260 ++#define __NR_clock_getres 261 ++#define __NR_clock_nanosleep 262 ++#define __NR_statfs64 263 ++#define __NR_fstatfs64 264 ++#define __NR_tgkill 265 ++#define __NR_utimes 266 ++#define __NR_fadvise64_64 267 ++#define __NR_mbind 268 ++#define __NR_get_mempolicy 269 ++#define __NR_set_mempolicy 270 ++#define __NR_mq_open 271 ++#define __NR_mq_unlink 272 ++#define __NR_mq_timedsend 273 ++#define __NR_mq_timedreceive 274 ++#define __NR_mq_notify 275 ++#define __NR_mq_getsetattr 276 ++#define __NR_waitid 277 ++#define __NR_vserver 278 ++#define __NR_add_key 279 ++#define __NR_request_key 280 ++#define __NR_keyctl 281 ++#define __NR_ioprio_set 282 ++#define __NR_ioprio_get 283 ++#define __NR_inotify_init 284 ++#define __NR_inotify_add_watch 285 ++#define __NR_inotify_rm_watch 286 ++#define __NR_migrate_pages 287 ++#define __NR_openat 288 ++#define __NR_mkdirat 289 ++#define __NR_mknodat 290 ++#define __NR_fchownat 291 ++#define __NR_futimesat 292 ++#define __NR_fstatat64 293 ++#define __NR_unlinkat 294 ++#define __NR_renameat 295 ++#define __NR_linkat 296 ++#define __NR_symlinkat 297 ++#define __NR_readlinkat 298 ++#define __NR_fchmodat 299 ++#define __NR_faccessat 300 ++#define __NR_pselect6 301 ++#define __NR_ppoll 302 ++#define __NR_unshare 303 ++#define __NR_set_robust_list 304 ++#define __NR_get_robust_list 305 ++#define __NR_splice 306 ++#define __NR_sync_file_range 307 ++#define __NR_tee 308 ++#define __NR_vmsplice 309 ++#define __NR_move_pages 310 ++#define __NR_sched_setaffinity 311 ++#define __NR_sched_getaffinity 312 ++#define __NR_kexec_load 313 ++#define __NR_getcpu 314 ++#define __NR_epoll_pwait 315 ++#define __NR_utimensat 316 ++#define __NR_signalfd 317 ++#define __NR_timerfd_create 318 ++#define __NR_eventfd 319 ++#define __NR_fallocate 320 ++#define __NR_timerfd_settime 321 ++#define __NR_timerfd_gettime 322 ++#define __NR_signalfd4 323 ++#define __NR_eventfd2 324 ++#define __NR_epoll_create1 325 ++#define __NR_dup3 326 ++#define __NR_pipe2 327 ++#define __NR_inotify_init1 328 ++ ++#ifdef __KERNEL__ ++ ++#define NR_syscalls 329 ++ ++#define __ARCH_WANT_IPC_PARSE_VERSION ++#define __ARCH_WANT_OLD_READDIR ++#define __ARCH_WANT_OLD_STAT ++#define __ARCH_WANT_STAT64 ++#define __ARCH_WANT_SYS_ALARM ++#define __ARCH_WANT_SYS_GETHOSTNAME ++#define __ARCH_WANT_SYS_PAUSE ++#define __ARCH_WANT_SYS_SGETMASK ++#define __ARCH_WANT_SYS_SIGNAL ++#define __ARCH_WANT_SYS_TIME ++#define __ARCH_WANT_SYS_UTIME ++#define __ARCH_WANT_SYS_WAITPID ++#define __ARCH_WANT_SYS_SOCKETCALL ++#define __ARCH_WANT_SYS_FADVISE64 ++#define __ARCH_WANT_SYS_GETPGRP ++#define __ARCH_WANT_SYS_LLSEEK ++#define __ARCH_WANT_SYS_NICE ++#define __ARCH_WANT_SYS_OLD_GETRLIMIT ++#define __ARCH_WANT_SYS_OLDUMOUNT ++#define __ARCH_WANT_SYS_SIGPENDING ++#define __ARCH_WANT_SYS_SIGPROCMASK ++#define __ARCH_WANT_SYS_RT_SIGACTION ++ ++/* ++ * "Conditional" syscalls ++ * ++ * What we want is __attribute__((weak,alias("sys_ni_syscall"))), ++ * but it doesn't work on all toolchains, so we just do it by hand ++ */ ++//#define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall") ++#define cond_syscall(x) long x(void) __attribute__((weak,alias("sys_ni_syscall"))) ++#endif /* __KERNEL__ */ ++ ++#endif /* _ASM_UBICOM32_UNISTD_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/user.h linux-2.6.28.10/arch/ubicom32/include/asm/user.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/user.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/user.h 2009-08-12 13:08:37.000000000 +0300 +@@ -0,0 +1,82 @@ ++/* ++ * arch/ubicom32/include/asm/user.h ++ * Ubicom32 architecture core file definitions. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_USER_H ++#define _ASM_UBICOM32_USER_H ++ ++#include ++#include ++/* ++ * Adapted from ++ * ++ * Core file format: The core file is written in such a way that gdb ++ * can understand it and provide useful information to the user (under ++ * linux we use the `trad-core' bfd, NOT the osf-core). The file contents ++ * are as follows: ++ * ++ * upage: 1 page consisting of a user struct that tells gdb ++ * what is present in the file. Directly after this is a ++ * copy of the task_struct, which is currently not used by gdb, ++ * but it may come in handy at some point. All of the registers ++ * are stored as part of the upage. The upage should always be ++ * only one page long. ++ * data: The data segment follows next. We use current->end_text to ++ * current->brk to pick up all of the user variables, plus any memory ++ * that may have been sbrk'ed. No attempt is made to determine if a ++ * page is demand-zero or if a page is totally unused, we just cover ++ * the entire range. All of the addresses are rounded in such a way ++ * that an integral number of pages is written. ++ * stack: We need the stack information in order to get a meaningful ++ * backtrace. We need to write the data from usp to ++ * current->start_stack, so we round each of these in order to be able ++ * to write an integer number of pages. ++ */ ++ ++struct user_ubicom32fp_struct { ++}; ++ ++struct user { ++ struct pt_regs regs; /* entire machine state */ ++ size_t u_tsize; /* text size (pages) */ ++ size_t u_dsize; /* data size (pages) */ ++ size_t u_ssize; /* stack size (pages) */ ++ unsigned long start_code; /* text starting address */ ++ unsigned long start_data; /* data starting address */ ++ unsigned long start_stack; /* stack starting address */ ++ long int signal; /* signal causing core dump */ ++ unsigned long u_ar0; /* help gdb find registers */ ++ unsigned long magic; /* identifies a core file */ ++ char u_comm[32]; /* user command name */ ++}; ++ ++#define NBPG PAGE_SIZE ++#define UPAGES 1 ++#define HOST_TEXT_START_ADDR (u.start_code) ++#define HOST_DATA_START_ADDR (u.start_data) ++#define HOST_STACK_END_ADDR (u.start_stack + u.u_ssize * NBPG) ++ ++#endif /* _ASM_UBICOM32_USER_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/include/asm/xor.h linux-2.6.28.10/arch/ubicom32/include/asm/xor.h +--- linux-2.6.28.10_o/arch/ubicom32/include/asm/xor.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/include/asm/xor.h 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,33 @@ ++/* ++ * arch/ubicom32/include/asm/xor.h ++ * Generic xor.h definitions for Ubicom32 architecture. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++#ifndef _ASM_UBICOM32_XOR_H ++#define _ASM_UBICOM32_XOR_H ++ ++#include ++ ++#endif /* _ASM_UBICOM32_XOR_H */ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/Kconfig linux-2.6.28.10/arch/ubicom32/Kconfig +--- linux-2.6.28.10_o/arch/ubicom32/Kconfig 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/Kconfig 2009-08-12 13:08:37.000000000 +0300 +@@ -0,0 +1,457 @@ ++# ++# For a description of the syntax of this configuration file, ++# see Documentation/kbuild/kconfig-language.txt. ++# ++ ++mainmenu "uClinux/ubicom32 (w/o MMU) Kernel Configuration" ++ ++config RAMBASE ++ hex ++ default "0x40000000" ++ help ++ Define the address that RAM starts at. ++ ++config UBICOM32 ++ bool ++ select HAVE_OPROFILE ++ default y ++ ++config RAMKERNEL ++ bool ++ default y ++ ++config CPU_BIG_ENDIAN ++ bool ++ default y ++ ++config FORCE_MAX_ZONEORDER ++ int ++ default "14" ++ ++config HAVE_CLK ++ bool ++ default y ++ ++config MMU ++ bool ++ default n ++ ++config FPU ++ bool ++ default n ++ ++config ZONE_DMA ++ bool ++ default y ++ ++config RWSEM_GENERIC_SPINLOCK ++ bool ++ default y ++ ++config RWSEM_XCHGADD_ALGORITHM ++ bool ++ default n ++ ++config ARCH_HAS_ILOG2_U32 ++ bool ++ default n ++ ++config ARCH_HAS_ILOG2_U64 ++ bool ++ default n ++ ++config GENERIC_FIND_NEXT_BIT ++ bool ++ default y ++ ++config GENERIC_GPIO ++ bool ++ default y ++ ++config GPIOLIB ++ bool ++ default y ++ ++config GENERIC_HWEIGHT ++ bool ++ default y ++ ++config GENERIC_HARDIRQS ++ bool ++ default y ++ ++config STACKTRACE_SUPPORT ++ bool ++ default y ++ ++config LOCKDEP_SUPPORT ++ bool ++ default y ++ ++config GENERIC_CALIBRATE_DELAY ++ bool ++ default y ++ ++config GENERIC_TIME ++ bool ++ default y ++ ++config TIME_LOW_RES ++ bool ++ default y ++ ++config GENERIC_CLOCKEVENTS ++ bool ++ default y ++ ++config GENERIC_CLOCKEVENTS_BROADCAST ++ bool ++ depends on GENERIC_CLOCKEVENTS ++ default y if SMP && !LOCAL_TIMERS ++ ++config NO_IOPORT ++ def_bool y ++ ++config ARCH_SUPPORTS_AOUT ++ def_bool y ++ ++config IRQ_PER_CPU ++ bool ++ default y ++ ++config SCHED_NO_NO_OMIT_FRAME_POINTER ++ bool ++ default y ++ ++menu "Processor type and features" ++ ++config BRD_32MB ++ bool ++ depends on IP5160EVAL ++ help ++ Board has 32MB of RAM on it. It is a hidden option used to select default for size of RAM ++ default n ++ ++config BRD_64MB ++ bool ++ depends on IP7145DPF || IP7160RGW || IP7160BRINGUP || IP7160DPF || IP5170DPF || IP5160DEV ++ help ++ Board has 64MB of RAM on it. It is a hidden option used to select default for size of RAM ++ default n ++ ++config BRD_128MB ++ bool ++ depends on IP7500MODULE || IP7500AV || IP7500MEDIA ++ help ++ Board has 128MB of RAM on it. It is a hidden option used to select default for size of RAM ++ default n ++ ++comment "Processor type will be selected by Board" ++ ++config UBICOM32_V3 ++ bool ++ help ++ Ubicom IP5xxx series processor support. ++ ++config UBICOM32_V4 ++ bool ++ help ++ Ubicom IP7xxx series processor support. ++ ++comment "Board" ++choice ++ prompt "Board type" ++ help ++ Select your board. ++ ++config NOBOARD ++ bool "No board selected" ++ help ++ Default. Don't select any board specific config. Will not build unless you change! ++ ++# Add your boards here ++source "arch/ubicom32/mach-ip5k/Kconfig" ++source "arch/ubicom32/mach-ip7k/Kconfig" ++ ++endchoice ++ ++comment "Kernel Options" ++config SMP ++ bool "Symmetric multi-processing support" ++ select USE_GENERIC_SMP_HELPERS ++ default n ++ help ++ Enables multithreading support. Enabling SMP support increases ++ the size of system data structures. SMP support can have either ++ positive or negative impact on performance depending on workloads. ++ ++ If you do not know what to do here, say N. ++ ++config NR_CPUS ++ int "Number of configured CPUs" ++ range 2 32 ++ default 2 ++ depends on SMP ++ help ++ Upper bound on the number of CPUs. Space is reserved ++ at compile time for this many CPUs. ++ ++config LOCAL_TIMERS ++ bool "Use local timer interrupts" ++ depends on SMP ++ default y ++ help ++ Enable support for local timers on SMP platforms, rather then the ++ legacy IPI broadcast method. Local timers allows the system ++ accounting to be spread across the timer interval, preventing a ++ "thundering herd" at every timer tick. A physical timer is allocated ++ per cpu. ++ ++config TIMER_EXTRA_ALLOC ++ int "Number of additional physical timer events to create" ++ depends on GENERIC_CLOCKEVENTS ++ default 0 ++ help ++ The Ubicom32 processor has a number of event timers that can be wrapped ++ in Linux clock event structures (assuming that the timers are not being ++ used for another purpose). Based on the value of LOCAL_TIMERS, either ++ 2 timers will be used or a timer will be used for every CPU. This value ++ allows the programmer to select additional timers over that amount. ++ ++config IRQSTACKS ++ bool "Create separate stacks for interrupt handling" ++ default n ++ help ++ Selecting this causes interrupts to be created on a separate ++ stack instead of nesting the interrupts on the kernel stack. ++ ++config IRQSTACKS_USEOCM ++ bool "Use OCM for interrupt stacks" ++ default n ++ depends on IRQSTACKS ++ help ++ Selecting this cause the interrupt stacks to be placed in OCM ++ reducing cache misses at the expense of using the OCM for servicing ++ interrupts. ++ ++menu "OCM Instruction Heap" ++ ++config OCM_MODULES_RESERVATION ++ int "OCM Instruction heap reservation. 0-192 kB" ++ range 0 192 ++ default "0" ++ help ++ The minimum amount of OCM memory to reserve for kernel loadable module ++ code. If you are not using this memory it cannot be used for anything ++ else. Leave it as 0 if you have prebuilt modules that are compiled with ++ OCM support. ++ ++config OCM_MODULES_MAY_CONSUME_REMAINING_CODESPACE ++ bool "Give all unused ocm code space to the ocm instruction heap." ++ default n ++ help ++ Allow the OCM instruction heap allocation to consume any remaining ++ unused OCM code space. The result of this is that you will not have ++ and deterministic results, but you will not have any waste either. ++ ++config OCM_MODULES_FALLBACK_TO_DDR ++ bool "Loadable Modules requiring OCM may fallback to use DDR." ++ default n ++ help ++ If a module cannot get the OCM code it requires allow DDR to ++ be used instead. ++endmenu ++ ++config HZ ++ int "Frequency of 'jiffies' (for polling)" ++ default 1000 ++ help ++ 100 is common for embedded systems, but 1000 allows ++ you to do more drivers without actually having ++ interrupts working properly. ++ ++comment "RAM configuration" ++ ++if BRD_32MB ++ ++config RAMSIZE ++ hex "Size of RAM (in bytes)" ++ range 0x00000000 0x02000000 ++ default "0x02000000" ++ help ++ Define the size of the system RAM. If you select 0 then the ++ kernel will try to probe the RAM size at runtime. This is not ++ supported on all CPU types. ++ ++endif ++ ++if BRD_64MB ++ ++config RAMSIZE ++ hex "Size of RAM (in bytes)" ++ range 0x00000000 0x04000000 ++ default "0x04000000" ++ help ++ Define the size of the system RAM. If you select 0 then the ++ kernel will try to probe the RAM size at runtime. This is not ++ supported on all CPU types. ++ ++endif ++ ++if BRD_128MB ++ ++config RAMSIZE ++ hex "Size of RAM (in bytes)" ++ range 0x00000000 0x08000000 ++ default "0x08000000" ++ help ++ Define the size of the system RAM. If you select 0 then the ++ kernel will try to probe the RAM size at runtime. This is not ++ supported on all CPU types. ++ ++endif ++ ++config KERNELBASE ++ hex "Address of the base of kernel code" ++ default "0x40400000" ++ help ++ For the time being we are going to start the Kernel at a 4 meg offset. ++ ++comment "Build options" ++config LINKER_RELAXATION ++ bool "Linker Relaxation" ++ default y ++ help ++ Turns on linker relaxation that will produce smaller ++ faster code. Increases link time. ++ ++comment "Driver options" ++menu "PCI Bus" ++config PCI ++ bool "PCI bus" ++ default true ++ help ++ Enable/Disable PCI bus ++ source "drivers/pci/Kconfig" ++ ++ ++config PCI_DEV0_IDSEL ++ hex "slot 0 address" ++ depends on PCI ++ default "0x01000000" ++ help ++ Slot 0 address. This address should correspond to the address line ++ which the IDSEL bit for this slot is connected to. ++ ++config PCI_DEV1_IDSEL ++ hex "slot 1 address" ++ depends on PCI ++ default "0x02000000" ++ help ++ Slot 1 address. This address should correspond to the address line ++ which the IDSEL bit for this slot is connected to. ++endmenu ++# End PCI ++ ++menu "Input devices" ++config UBICOM_INPUT ++ bool "Ubicom polled GPIO input driver" ++ select INPUT ++ select INPUT_POLLDEV ++ help ++ Polling input driver, much like the GPIO input driver, except that it doesn't ++ rely on interrupts. It will report events via the input subsystem. ++ default n ++ ++config UBICOM_INPUT_I2C ++ bool "Ubicom polled GPIO input driver over I2C" ++ select INPUT ++ select INPUT_POLLDEV ++ help ++ Polling input driver, much like the PCA953x driver, it can support a variety of ++ different I2C I/O expanders. This device polls the I2C I/O expander for events ++ and reports them via the input subsystem. ++ default n ++endmenu ++# Input devices ++ ++ ++ ++menu "Misc devices" ++config UBICOM_HID ++ bool "Ubicom HID driver" ++ select INPUT ++ select INPUT_POLLDEV ++ select LCD_CLASS_DEVICE ++ help ++ Driver for HID chip found on some Ubicom reference designs. This chip handles ++ PWM, button input, and IR remote control. It registers as an input device and ++ a backlight device. ++ default n ++endmenu ++# Misc devices ++ ++config CMDLINE_BOOL ++ bool "Built-in kernel command line" ++ default n ++ help ++ Allow for specifying boot arguments to the kernel at ++ build time. On some systems (e.g. embedded ones), it is ++ necessary or convenient to provide some or all of the ++ kernel boot arguments with the kernel itself (that is, ++ to not rely on the boot loader to provide them.) ++ ++ To compile command line arguments into the kernel, ++ set this option to 'Y', then fill in the ++ the boot arguments in CONFIG_CMDLINE. ++ ++ Systems with fully functional boot loaders (i.e. non-embedded) ++ should leave this option set to 'N'. ++ ++config CMDLINE ++ string "Built-in kernel command string" ++ depends on CMDLINE_BOOL ++ default "" ++ help ++ Enter arguments here that should be compiled into the kernel ++ image and used at boot time. If the boot loader provides a ++ command line at boot time, it is appended to this string to ++ form the full kernel command line, when the system boots. ++ ++ However, you can use the CONFIG_CMDLINE_OVERRIDE option to ++ change this behavior. ++ ++ In most cases, the command line (whether built-in or provided ++ by the boot loader) should specify the device for the root ++ file system. ++ ++config CMDLINE_OVERRIDE ++ bool "Built-in command line overrides boot loader arguments" ++ default n ++ depends on CMDLINE_BOOL ++ help ++ Set this option to 'Y' to have the kernel ignore the boot loader ++ command line, and use ONLY the built-in command line. ++ ++ This is used to work around broken boot loaders. This should ++ be set to 'N' under normal conditions. ++ ++endmenu ++# End Processor type and features ++ ++source "arch/ubicom32/Kconfig.debug" ++ ++menu "Executable file formats" ++source "fs/Kconfig.binfmt" ++endmenu ++ ++source "init/Kconfig" ++source "kernel/Kconfig.preempt" ++source "kernel/time/Kconfig" ++source "mm/Kconfig" ++source "net/Kconfig" ++source "drivers/Kconfig" ++source "fs/Kconfig" ++source "security/Kconfig" ++source "crypto/Kconfig" ++source "lib/Kconfig" +diff -ruN linux-2.6.28.10_o/arch/ubicom32/Kconfig.debug linux-2.6.28.10/arch/ubicom32/Kconfig.debug +--- linux-2.6.28.10_o/arch/ubicom32/Kconfig.debug 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/Kconfig.debug 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,117 @@ ++menu "Kernel hacking" ++ ++config TRACE_IRQFLAGS_SUPPORT ++ def_bool y ++ ++config PROTECT_KERNEL ++ default y ++ bool 'Enable Kernel range register Protection' ++ help ++ Adds code to enable/disable range registers to protect static ++ kernel code/data from userspace. Currently the ranges covered ++ do no protect kernel loadable modules or dynamically allocated ++ kernel data. ++ ++config NO_KERNEL_MSG ++ bool "Suppress Kernel BUG Messages" ++ help ++ Do not output any debug BUG messages within the kernel. ++ ++config EARLY_PRINTK ++ bool "Use the driver that you selected as console also for early printk (to debug kernel bootup)." ++ default n ++ help ++ If you want to use the serdes driver (console=ttyUS0) for ++ early printk, you must also supply an additional kernel boot ++ parameter like this: ++ ++ serdes=ioportaddr,irq,clockrate,baud ++ ++ For an IP7160RGW eval board, you could use this: ++ ++ serdes=0x2004000,61,250000000,57600 ++ ++ which will let you see early printk output at 57600 baud. ++ ++config STOP_ON_TRAP ++ bool "Enable stopping at the LDSR for all traps" ++ default n ++ help ++ Cause the LDSR to stop all threads whenever a trap is about to be serviced ++ ++config STOP_ON_BUG ++ bool "Enable stopping on failed BUG_ON()" ++ default n ++ help ++ Cause all BUG_ON failures to stop all threads ++ ++config DEBUG_IRQMEASURE ++ bool "Enable IRQ handler measurements" ++ default n ++ help ++ When enabled each IRQ's min/avg/max times will be printed. If the handler ++ re-enables interrupt, the times will show the full time including to service ++ nested interrupts. See /proc/irq_measurements. ++ ++config DEBUG_PCIMEASURE ++ bool "Enable PCI transaction measurements" ++ default n ++ help ++ When enabled the system will measure the min/avg/max timer for each PCI transactions. ++ See /proc/pci_measurements. ++ ++config ACCESS_OK_CHECKS_ENABLED ++ bool "Enable user space access checks" ++ default n ++ help ++ Enabling this check causes the kernel to verify that addresses passed ++ to the kernel by the user space code are within the processes ++ address space. On a no-mmu system, this is done by examining the ++ processes memory data structures (adversly affecting performance) but ++ ensuring that a process does not ask the kernel to violate another ++ processes address space. Sadly, the kernel uses access_ok() for ++ address that are in the kernel which results in a large volume of ++ false positives. ++ ++choice ++ prompt "Unaligned Access Support" ++ default UNALIGNED_ACCESS_ENABLED ++ help ++ Kernel / Userspace unaligned access handling. ++ ++config UNALIGNED_ACCESS_ENABLED ++ bool "Kernel and Userspace" ++ help ++ ++config UNALIGNED_ACCESS_USERSPACE_ONLY ++ bool "Userspace Only" ++ help ++ ++config UNALIGNED_ACCESS_DISABLED ++ bool "Disabled" ++ help ++ ++endchoice ++ ++config DEBUG_STACKOVERFLOW ++ bool "Check for stack overflows" ++ default n ++ depends on DEBUG_KERNEL ++ help ++ This option will cause messages to be printed if free kernel stack space ++ drops below a certain limit (THREAD_SIZE /8). ++ ++config DEBUG_STACK_USAGE ++ bool "Stack utilization instrumentation" ++ default n ++ depends on DEBUG_KERNEL ++ help ++ Enables the display of the minimum amount of free kernel stack which each ++ task has ever had available in the sysrq-T and sysrq-P debug output. ++ ++ This option will slow down process creation somewhat. ++ ++source "lib/Kconfig.debug" ++ ++endmenu ++ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/kernel/asm-offsets.c linux-2.6.28.10/arch/ubicom32/kernel/asm-offsets.c +--- linux-2.6.28.10_o/arch/ubicom32/kernel/asm-offsets.c 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/kernel/asm-offsets.c 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,162 @@ ++/* ++ * arch/ubicom32/kernel/asm-offsets.c ++ * Ubicom32 architecture definitions needed by assembly language modules. ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++/* ++ * This program is used to generate definitions needed by ++ * assembly language modules. ++ * ++ * We use the technique used in the OSF Mach kernel code: ++ * generate asm statements containing #defines, ++ * compile this file to assembler, and then extract the ++ * #defines from the assembly-language output. ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#define DEFINE(sym, val) \ ++ asm volatile("\n->" #sym " %0 " #val : : "i" (val)) ++ ++#define BLANK() asm volatile("\n->" : : ) ++ ++int main(void) ++{ ++ /* offsets into the task struct */ ++ DEFINE(TASK_STATE, offsetof(struct task_struct, state)); ++ DEFINE(TASK_FLAGS, offsetof(struct task_struct, flags)); ++ DEFINE(TASK_PTRACE, offsetof(struct task_struct, ptrace)); ++ DEFINE(TASK_BLOCKED, offsetof(struct task_struct, blocked)); ++ DEFINE(TASK_THREAD, offsetof(struct task_struct, thread)); ++ DEFINE(TASK_THREAD_INFO, offsetof(struct task_struct, stack)); ++ DEFINE(TASK_MM, offsetof(struct task_struct, mm)); ++ DEFINE(TASK_ACTIVE_MM, offsetof(struct task_struct, active_mm)); ++ ++ /* offsets into the kernel_stat struct */ ++ DEFINE(STAT_IRQ, offsetof(struct kernel_stat, irqs)); ++ ++ /* offsets into the irq_cpustat_t struct */ ++ DEFINE(CPUSTAT_SOFTIRQ_PENDING, offsetof(irq_cpustat_t, __softirq_pending)); ++ ++ /* offsets into the thread struct */ ++ DEFINE(THREAD_D10, offsetof(struct thread_struct, d10)); ++ DEFINE(THREAD_D11, offsetof(struct thread_struct, d11)); ++ DEFINE(THREAD_D12, offsetof(struct thread_struct, d12)); ++ DEFINE(THREAD_D13, offsetof(struct thread_struct, d13)); ++ DEFINE(THREAD_A1, offsetof(struct thread_struct, a1)); ++ DEFINE(THREAD_A2, offsetof(struct thread_struct, a2)); ++ DEFINE(THREAD_A5, offsetof(struct thread_struct, a5)); ++ DEFINE(THREAD_A6, offsetof(struct thread_struct, a6)); ++ DEFINE(THREAD_SP, offsetof(struct thread_struct, sp)); ++ ++ /* offsets into the pt_regs */ ++ DEFINE(PT_D0, offsetof(struct pt_regs, dn[0])); ++ DEFINE(PT_D1, offsetof(struct pt_regs, dn[1])); ++ DEFINE(PT_D2, offsetof(struct pt_regs, dn[2])); ++ DEFINE(PT_D3, offsetof(struct pt_regs, dn[3])); ++ DEFINE(PT_D4, offsetof(struct pt_regs, dn[4])); ++ DEFINE(PT_D5, offsetof(struct pt_regs, dn[5])); ++ DEFINE(PT_D6, offsetof(struct pt_regs, dn[6])); ++ DEFINE(PT_D7, offsetof(struct pt_regs, dn[7])); ++ DEFINE(PT_D8, offsetof(struct pt_regs, dn[8])); ++ DEFINE(PT_D9, offsetof(struct pt_regs, dn[9])); ++ DEFINE(PT_D10, offsetof(struct pt_regs, dn[10])); ++ DEFINE(PT_D11, offsetof(struct pt_regs, dn[11])); ++ DEFINE(PT_D12, offsetof(struct pt_regs, dn[12])); ++ DEFINE(PT_D13, offsetof(struct pt_regs, dn[13])); ++ DEFINE(PT_D14, offsetof(struct pt_regs, dn[14])); ++ DEFINE(PT_D15, offsetof(struct pt_regs, dn[15])); ++ DEFINE(PT_A0, offsetof(struct pt_regs, an[0])); ++ DEFINE(PT_A1, offsetof(struct pt_regs, an[1])); ++ DEFINE(PT_A2, offsetof(struct pt_regs, an[2])); ++ DEFINE(PT_A3, offsetof(struct pt_regs, an[3])); ++ DEFINE(PT_A4, offsetof(struct pt_regs, an[4])); ++ DEFINE(PT_A5, offsetof(struct pt_regs, an[5])); ++ DEFINE(PT_A6, offsetof(struct pt_regs, an[6])); ++ DEFINE(PT_A7, offsetof(struct pt_regs, an[7])); ++ DEFINE(PT_SP, offsetof(struct pt_regs, an[7])); ++ ++ DEFINE(PT_ACC0HI, offsetof(struct pt_regs, acc0[0])); ++ DEFINE(PT_ACC0LO, offsetof(struct pt_regs, acc0[1])); ++ DEFINE(PT_MAC_RC16, offsetof(struct pt_regs, mac_rc16)); ++ ++ DEFINE(PT_ACC1HI, offsetof(struct pt_regs, acc1[0])); ++ DEFINE(PT_ACC1LO, offsetof(struct pt_regs, acc1[1])); ++ ++ DEFINE(PT_SOURCE3, offsetof(struct pt_regs, source3)); ++ DEFINE(PT_INST_CNT, offsetof(struct pt_regs, inst_cnt)); ++ DEFINE(PT_CSR, offsetof(struct pt_regs, csr)); ++ DEFINE(PT_DUMMY_UNUSED, offsetof(struct pt_regs, dummy_unused)); ++ ++ DEFINE(PT_INT_MASK0, offsetof(struct pt_regs, int_mask0)); ++ DEFINE(PT_INT_MASK1, offsetof(struct pt_regs, int_mask1)); ++ ++ DEFINE(PT_PC, offsetof(struct pt_regs, pc)); ++ ++ DEFINE(PT_TRAP_CAUSE, offsetof(struct pt_regs, trap_cause)); ++ ++ DEFINE(PT_SIZE, sizeof(struct pt_regs)); ++ ++ DEFINE(PT_FRAME_TYPE, offsetof(struct pt_regs, frame_type)); ++ ++ DEFINE(PT_ORIGINAL_D0, offsetof(struct pt_regs, original_dn_0)); ++ DEFINE(PT_PREVIOUS_PC, offsetof(struct pt_regs, previous_pc)); ++ ++ /* offsets into the kernel_stat struct */ ++ DEFINE(STAT_IRQ, offsetof(struct kernel_stat, irqs)); ++ ++ /* signal defines */ ++ DEFINE(SIGSEGV, SIGSEGV); ++ //DEFINE(SEGV_MAPERR, SEGV_MAPERR); ++ DEFINE(SIGTRAP, SIGTRAP); ++ //DEFINE(TRAP_TRACE, TRAP_TRACE); ++ ++ DEFINE(PT_PTRACED, PT_PTRACED); ++ DEFINE(PT_DTRACE, PT_DTRACE); ++ ++ DEFINE(ASM_THREAD_SIZE, THREAD_SIZE); ++ ++ /* Offsets in thread_info structure */ ++ DEFINE(TI_TASK, offsetof(struct thread_info, task)); ++ DEFINE(TI_EXECDOMAIN, offsetof(struct thread_info, exec_domain)); ++ DEFINE(TI_FLAGS, offsetof(struct thread_info, flags)); ++ DEFINE(TI_PREEMPTCOUNT, offsetof(struct thread_info, preempt_count)); ++ DEFINE(TI_CPU, offsetof(struct thread_info, cpu)); ++ DEFINE(TI_INTR_NESTING, offsetof(struct thread_info, interrupt_nesting)); ++ DEFINE(ASM_TIF_NEED_RESCHED, TIF_NEED_RESCHED); ++ DEFINE(ASM_TIF_SYSCALL_TRACE, TIF_SYSCALL_TRACE); ++ DEFINE(ASM_TIF_SIGPENDING, TIF_SIGPENDING); ++ ++ DEFINE(ASM_RAM_END, (CONFIG_RAMBASE + CONFIG_RAMSIZE)); ++ return 0; ++} +diff -ruN linux-2.6.28.10_o/arch/ubicom32/kernel/Makefile linux-2.6.28.10/arch/ubicom32/kernel/Makefile +--- linux-2.6.28.10_o/arch/ubicom32/kernel/Makefile 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/kernel/Makefile 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,64 @@ ++# ++# arch/ubicom32/kernel/Makefile ++# Main Makefile for the Ubicom32 arch directory. ++# ++# (C) Copyright 2009, Ubicom, Inc. ++# ++# This file is part of the Ubicom32 Linux Kernel Port. ++# ++# The Ubicom32 Linux Kernel Port 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. ++# ++# The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++# see . ++# ++# Ubicom32 implementation derived from (with many thanks): ++# arch/m68knommu ++# arch/blackfin ++# arch/parisc ++# ++ ++extra-y := head.o vmlinux.lds ++ ++obj-y += \ ++ devtree.o \ ++ dma.o \ ++ flat.o \ ++ init_task.o \ ++ irq.o \ ++ ldsr.o \ ++ os_node.o \ ++ process.o \ ++ processor.o \ ++ ptrace.o \ ++ setup.o \ ++ signal.o \ ++ stacktrace.o \ ++ sys_ubicom32.o \ ++ syscalltable.o \ ++ thread.o \ ++ time.o \ ++ traps.o \ ++ ubicom32_context_switch.o \ ++ ubicom32_ksyms.o \ ++ ubicom32_syscall.o \ ++ unaligned_trap.o ++ ++obj-$(CONFIG_MODULES) += module.o ++obj-$(CONFIG_COMEMPCI) += comempci.o ++obj-$(CONFIG_SMP) += smp.o topology.o ++obj-$(CONFIG_ACCESS_OK_CHECKS_ENABLED) += uaccess.o ++obj-$(CONFIG_GENERIC_CLOCKEVENTS) += timer_device.o ++obj-$(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) += timer_broadcast.o ++ ++ifndef CONFIG_GENERIC_CLOCKEVENTS ++obj-y += timer_tick.o ++endif +diff -ruN linux-2.6.28.10_o/arch/ubicom32/kernel/syscalltable.S linux-2.6.28.10/arch/ubicom32/kernel/syscalltable.S +--- linux-2.6.28.10_o/arch/ubicom32/kernel/syscalltable.S 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/kernel/syscalltable.S 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,377 @@ ++/* ++ * arch/ubicom32/kernel/syscalltable.S ++ * ++ * ++ * (C) Copyright 2009, Ubicom, Inc. ++ * ++ * This file is part of the Ubicom32 Linux Kernel Port. ++ * ++ * The Ubicom32 Linux Kernel Port 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. ++ * ++ * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++ * see . ++ * ++ * Ubicom32 implementation derived from (with many thanks): ++ * arch/m68knommu ++ * arch/blackfin ++ * arch/parisc ++ */ ++/* ++ * ++ * Copyright (C) 2002, Greg Ungerer (gerg@snapgear.com) ++ * Copyright (C) 1998 D. Jeff Dionne , Kenneth Albanowski , ++ * Copyright (C) 2000 Lineo Inc. (www.lineo.com) ++ * Copyright (C) 1991, 1992 Linus Torvalds ++ */ ++ ++#include ++#include ++#include ++ ++.text ++ALIGN ++ .global sys_call_table ++sys_call_table: ++ .long sys_ni_syscall /* 0 - old "setup()" system call*/ ++ .long sys_exit ++ .long sys_fork ++ .long sys_read ++ .long sys_write ++ .long sys_open /* 5 */ ++ .long sys_close ++ .long sys_waitpid ++ .long sys_creat ++ .long sys_link ++ .long sys_unlink /* 10 */ ++ .long execve_intercept ++ .long sys_chdir ++ .long sys_time ++ .long sys_mknod ++ .long sys_chmod /* 15 */ ++ .long sys_chown16 ++ .long sys_ni_syscall /* old break syscall holder */ ++ .long sys_stat ++ .long sys_lseek ++ .long sys_getpid /* 20 */ ++ .long sys_mount ++ .long sys_oldumount ++ .long sys_setuid16 ++ .long sys_getuid16 ++ .long sys_stime /* 25 */ ++ .long sys_ptrace ++ .long sys_alarm ++ .long sys_fstat ++ .long sys_pause ++ .long sys_utime /* 30 */ ++ .long sys_ni_syscall /* old stty syscall holder */ ++ .long sys_ni_syscall /* old gtty syscall holder */ ++ .long sys_access ++ .long sys_nice ++ .long sys_ni_syscall /* 35 */ /* old ftime syscall holder */ ++ .long sys_sync ++ .long sys_kill ++ .long sys_rename ++ .long sys_mkdir ++ .long sys_rmdir /* 40 */ ++ .long sys_dup ++ .long sys_pipe ++ .long sys_times ++ .long sys_ni_syscall /* old prof syscall holder */ ++ .long sys_brk /* 45 */ ++ .long sys_setgid16 ++ .long sys_getgid16 ++ .long sys_signal ++ .long sys_geteuid16 ++ .long sys_getegid16 /* 50 */ ++ .long sys_acct ++ .long sys_umount /* recycled never used phys() */ ++ .long sys_ni_syscall /* old lock syscall holder */ ++ .long sys_ioctl ++ .long sys_fcntl /* 55 */ ++ .long sys_ni_syscall /* old mpx syscall holder */ ++ .long sys_setpgid ++ .long sys_ni_syscall /* old ulimit syscall holder */ ++ .long sys_ni_syscall ++ .long sys_umask /* 60 */ ++ .long sys_chroot ++ .long sys_ustat ++ .long sys_dup2 ++ .long sys_getppid ++ .long sys_getpgrp /* 65 */ ++ .long sys_setsid ++ .long sys_sigaction ++ .long sys_sgetmask ++ .long sys_ssetmask ++ .long sys_setreuid16 /* 70 */ ++ .long sys_setregid16 ++ .long sys_sigsuspend ++ .long sys_sigpending ++ .long sys_sethostname ++ .long sys_setrlimit /* 75 */ ++ .long sys_old_getrlimit ++ .long sys_getrusage ++ .long sys_gettimeofday ++ .long sys_settimeofday ++ .long sys_getgroups16 /* 80 */ ++ .long sys_setgroups16 ++ .long old_select ++ .long sys_symlink ++ .long sys_lstat ++ .long sys_readlink /* 85 */ ++ .long sys_uselib ++ .long sys_ni_syscall /* _sys_swapon */ ++ .long sys_reboot ++ .long sys_old_readdir ++ .long old_mmap /* 90 */ ++ .long sys_munmap ++ .long sys_truncate ++ .long sys_ftruncate ++ .long sys_fchmod ++ .long sys_fchown16 /* 95 */ ++ .long sys_getpriority ++ .long sys_setpriority ++ .long sys_ni_syscall /* old profil syscall holder */ ++ .long sys_statfs ++ .long sys_fstatfs /* 100 */ ++ .long sys_ni_syscall /* ioperm for i386 */ ++ .long sys_socketcall ++ .long sys_syslog ++ .long sys_setitimer ++ .long sys_getitimer /* 105 */ ++ .long sys_newstat ++ .long sys_newlstat ++ .long sys_newfstat ++ .long sys_ni_syscall ++ .long sys_ni_syscall /* iopl for i386 */ /* 110 */ ++ .long sys_vhangup ++ .long sys_ni_syscall /* obsolete idle() syscall */ ++ .long sys_ni_syscall /* vm86old for i386 */ ++ .long sys_wait4 ++ .long sys_ni_syscall /* 115 */ /* _sys_swapoff */ ++ .long sys_sysinfo ++ .long sys_ipc ++ .long sys_fsync ++ .long sys_sigreturn ++ .long clone_intercept /* 120 */ ++ .long sys_setdomainname ++ .long sys_newuname ++ .long sys_cacheflush /* modify_ldt for i386 */ ++ .long sys_adjtimex ++ .long sys_ni_syscall /* 125 */ /* _sys_mprotect */ ++ .long sys_sigprocmask ++ .long sys_ni_syscall /* old "creat_module" */ ++ .long sys_init_module ++ .long sys_delete_module ++ .long sys_ni_syscall /* 130: old "get_kernel_syms" */ ++ .long sys_quotactl ++ .long sys_getpgid ++ .long sys_fchdir ++ .long sys_bdflush ++ .long sys_sysfs /* 135 */ ++ .long sys_personality ++ .long sys_ni_syscall /* for afs_syscall */ ++ .long sys_setfsuid16 ++ .long sys_setfsgid16 ++ .long sys_llseek /* 140 */ ++ .long sys_getdents ++ .long sys_select ++ .long sys_flock ++ .long sys_ni_syscall /* _sys_msync */ ++ .long sys_readv /* 145 */ ++ .long sys_writev ++ .long sys_getsid ++ .long sys_fdatasync ++ .long sys_sysctl ++ .long sys_ni_syscall /* 150 */ /* _sys_mlock */ ++ .long sys_ni_syscall /* _sys_munlock */ ++ .long sys_ni_syscall /* _sys_mlockall */ ++ .long sys_ni_syscall /* _sys_munlockall */ ++ .long sys_sched_setparam ++ .long sys_sched_getparam /* 155 */ ++ .long sys_sched_setscheduler ++ .long sys_sched_getscheduler ++ .long sys_sched_yield ++ .long sys_sched_get_priority_max ++ .long sys_sched_get_priority_min /* 160 */ ++ .long sys_sched_rr_get_interval ++ .long sys_nanosleep ++ .long sys_ni_syscall /* _sys_mremap */ ++ .long sys_setresuid16 ++ .long sys_getresuid16 /* 165 */ ++ .long sys_getpagesize /* _sys_getpagesize */ ++ .long sys_ni_syscall /* old "query_module" */ ++ .long sys_poll ++ .long sys_ni_syscall /* _sys_nfsservctl */ ++ .long sys_setresgid16 /* 170 */ ++ .long sys_getresgid16 ++ .long sys_prctl ++ .long sys_rt_sigreturn ++ .long sys_rt_sigaction ++ .long sys_rt_sigprocmask /* 175 */ ++ .long sys_rt_sigpending ++ .long sys_rt_sigtimedwait ++ .long sys_rt_sigqueueinfo ++ .long sys_rt_sigsuspend ++ .long sys_pread64 /* 180 */ ++ .long sys_pwrite64 ++ .long sys_lchown16 ++ .long sys_getcwd ++ .long sys_capget ++ .long sys_capset /* 185 */ ++ .long sys_sigaltstack ++ .long sys_sendfile ++ .long sys_ni_syscall /* streams1 */ ++ .long sys_ni_syscall /* streams2 */ ++ .long vfork_intercept /* 190 */ ++ .long sys_getrlimit ++ .long sys_mmap2 ++ .long sys_truncate64 ++ .long sys_ftruncate64 ++ .long sys_stat64 /* 195 */ ++ .long sys_lstat64 ++ .long sys_fstat64 ++ .long sys_chown ++ .long sys_getuid ++ .long sys_getgid /* 200 */ ++ .long sys_geteuid ++ .long sys_getegid ++ .long sys_setreuid ++ .long sys_setregid ++ .long sys_getgroups /* 205 */ ++ .long sys_setgroups ++ .long sys_fchown ++ .long sys_setresuid ++ .long sys_getresuid ++ .long sys_setresgid /* 210 */ ++ .long sys_getresgid ++ .long sys_lchown ++ .long sys_setuid ++ .long sys_setgid ++ .long sys_setfsuid /* 215 */ ++ .long sys_setfsgid ++ .long sys_pivot_root ++ .long sys_ni_syscall ++ .long sys_ni_syscall ++ .long sys_getdents64 /* 220 */ ++ .long sys_gettid ++ .long sys_tkill ++ .long sys_setxattr ++ .long sys_lsetxattr ++ .long sys_fsetxattr /* 225 */ ++ .long sys_getxattr ++ .long sys_lgetxattr ++ .long sys_fgetxattr ++ .long sys_listxattr ++ .long sys_llistxattr /* 230 */ ++ .long sys_flistxattr ++ .long sys_removexattr ++ .long sys_lremovexattr ++ .long sys_fremovexattr ++ .long sys_futex /* 235 */ ++ .long sys_sendfile64 ++ .long sys_ni_syscall /* _sys_mincore */ ++ .long sys_ni_syscall /* _sys_madvise */ ++ .long sys_fcntl64 ++ .long sys_readahead /* 240 */ ++ .long sys_io_setup ++ .long sys_io_destroy ++ .long sys_io_getevents ++ .long sys_io_submit ++ .long sys_io_cancel /* 245 */ ++ .long sys_fadvise64 ++ .long sys_exit_group ++ .long sys_lookup_dcookie ++ .long sys_epoll_create ++ .long sys_epoll_ctl /* 250 */ ++ .long sys_epoll_wait ++ .long sys_ni_syscall /* _sys_remap_file_pages */ ++ .long sys_set_tid_address ++ .long sys_timer_create ++ .long sys_timer_settime /* 255 */ ++ .long sys_timer_gettime ++ .long sys_timer_getoverrun ++ .long sys_timer_delete ++ .long sys_clock_settime ++ .long sys_clock_gettime /* 260 */ ++ .long sys_clock_getres ++ .long sys_clock_nanosleep ++ .long sys_statfs64 ++ .long sys_fstatfs64 ++ .long sys_tgkill /* 265 */ ++ .long sys_utimes ++ .long sys_fadvise64_64 ++ .long sys_mbind ++ .long sys_get_mempolicy ++ .long sys_set_mempolicy /* 270 */ ++ .long sys_mq_open ++ .long sys_mq_unlink ++ .long sys_mq_timedsend ++ .long sys_mq_timedreceive ++ .long sys_mq_notify /* 275 */ ++ .long sys_mq_getsetattr ++ .long sys_waitid ++ .long sys_ni_syscall /* for _sys_vserver */ ++ .long sys_add_key ++ .long sys_request_key /* 280 */ ++ .long sys_keyctl ++ .long sys_ioprio_set ++ .long sys_ioprio_get ++ .long sys_inotify_init ++ .long sys_inotify_add_watch /* 285 */ ++ .long sys_inotify_rm_watch ++ .long sys_migrate_pages ++ .long sys_openat ++ .long sys_mkdirat ++ .long sys_mknodat /* 290 */ ++ .long sys_fchownat ++ .long sys_futimesat ++ .long sys_fstatat64 ++ .long sys_unlinkat ++ .long sys_renameat /* 295 */ ++ .long sys_linkat ++ .long sys_symlinkat ++ .long sys_readlinkat ++ .long sys_fchmodat ++ .long sys_faccessat /* 300 */ ++ .long sys_ni_syscall /* Reserved for pselect6 */ ++ .long sys_ni_syscall /* Reserved for ppoll */ ++ .long sys_unshare ++ .long sys_set_robust_list ++ .long sys_get_robust_list /* 305 */ ++ .long sys_splice ++ .long sys_sync_file_range ++ .long sys_tee ++ .long sys_vmsplice ++ .long sys_move_pages /* 310 */ ++ .long sys_sched_setaffinity ++ .long sys_sched_getaffinity ++ .long sys_kexec_load ++ .long sys_getcpu ++ .long sys_epoll_pwait /* 315 */ ++ .long sys_utimensat ++ .long sys_signalfd ++ .long sys_timerfd_create ++ .long sys_eventfd ++ .long sys_fallocate /* 320 */ ++ .long sys_timerfd_settime ++ .long sys_timerfd_gettime ++ .long sys_ni_syscall /* sys_signalfd4 */ ++ .long sys_ni_syscall /* sys_eventfd2 */ ++ .long sys_ni_syscall /* sys_epoll_create1 */ ++ /* 325 */ ++ .long sys_ni_syscall /* sys_dup3 */ ++ .long sys_ni_syscall /* sys_pipe2 */ ++ .long sys_ni_syscall /* sys_inotify_init1 */ ++ .rept NR_syscalls-(.-sys_call_table)/4 ++ .long sys_ni_syscall ++ .endr ++ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/lib/Makefile linux-2.6.28.10/arch/ubicom32/lib/Makefile +--- linux-2.6.28.10_o/arch/ubicom32/lib/Makefile 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/lib/Makefile 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,32 @@ ++# ++# arch/ubicom32/lib/Makefile ++# ++# ++# (C) Copyright 2009, Ubicom, Inc. ++# ++# This file is part of the Ubicom32 Linux Kernel Port. ++# ++# The Ubicom32 Linux Kernel Port 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. ++# ++# The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++# see . ++# ++# Ubicom32 implementation derived from (with many thanks): ++# arch/m68knommu ++# arch/blackfin ++# arch/parisc ++# ++# ++# Makefile for m68knommu specific library files.. ++# ++ ++lib-y := checksum.o delay.o mem_ubicom32.o +diff -ruN linux-2.6.28.10_o/arch/ubicom32/mach-common/Makefile linux-2.6.28.10/arch/ubicom32/mach-common/Makefile +--- linux-2.6.28.10_o/arch/ubicom32/mach-common/Makefile 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/mach-common/Makefile 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,40 @@ ++# ++# arch/ubicom32/mach-common/Makefile ++# Makefile for Ubicom32 generic drivers/code. ++# ++# (C) Copyright 2009, Ubicom, Inc. ++# ++# This file is part of the Ubicom32 Linux Kernel Port. ++# ++# The Ubicom32 Linux Kernel Port 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. ++# ++# The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++# see . ++# ++# Ubicom32 implementation derived from (with many thanks): ++# arch/m68knommu ++# arch/blackfin ++# arch/parisc ++# ++ ++obj-y += cachectl.o common.o usb_tio.o usb.o ubi32-gpio.o board.o bootargs.o ++obj-$(CONFIG_PCI) += pci.o io.o ++ ++obj-$(CONFIG_FB_UBICOM32) += vdc_tio.o ++obj-$(CONFIG_UBICOM_HID) += ubicom32hid.o ++obj-$(CONFIG_UBICOM_INPUT) += ubicom32input.o ++obj-$(CONFIG_UBICOM_INPUT_I2C) += ubicom32input_i2c.o ++obj-$(CONFIG_UBICOM_SWITCH) += switch-core.o ++obj-$(CONFIG_UBICOM_SWITCH_BCM539X) += switch-bcm539x.o ++obj-$(CONFIG_UIO_UBICOM32RING) += ring_tio.o ++obj-$(CONFIG_SND_UBI32) += audio_tio.o ++ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/mach-ip5k/Kconfig linux-2.6.28.10/arch/ubicom32/mach-ip5k/Kconfig +--- linux-2.6.28.10_o/arch/ubicom32/mach-ip5k/Kconfig 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/mach-ip5k/Kconfig 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,32 @@ ++ ++config IP5170DPF ++ bool "IP5170DPF" ++ select UBICOM32_V3 ++ select I2C ++ select I2C_GPIO ++ select FB ++ select FB_UBICOM32 ++ select BACKLIGHT_LCD_SUPPORT ++ select BACKLIGHT_CLASS_DEVICE ++ select UBICOM_HID ++ select NEW_LEDS ++ select LEDS_CLASS ++ select LEDS_GPIO ++ select BRD_64MB ++ help ++ IP5170 Digital Picture Frame board, 8005-1113, IP5K-BEV-0011-13 v1.3 ++ ++config IP5160DEV ++ bool "IP5160Dev_Ver1Dot1" ++ select UBICOM32_V3 ++ select BRD_64MB ++ help ++ Ubicom StreamEngine 5000 Development Board, IP5K-BDV-0004-11 v1.1 ++ ++config IP5160EVAL ++ bool "IP5160RGWEval_Ver2Rev2" ++ select UBICOM32_V3 ++ select BRD_32MB ++ help ++ Ubicom StreamEngine 5000 RGW Evaluation Board, IP5K-RGW-0004-11 v2.2 ++ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/mach-ip5k/Makefile linux-2.6.28.10/arch/ubicom32/mach-ip5k/Makefile +--- linux-2.6.28.10_o/arch/ubicom32/mach-ip5k/Makefile 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/mach-ip5k/Makefile 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,32 @@ ++# ++# arch/ubicom32/mach-ip5k/Makefile ++# Makefile for boards which have an ip5k on them. ++# ++# (C) Copyright 2009, Ubicom, Inc. ++# ++# This file is part of the Ubicom32 Linux Kernel Port. ++# ++# The Ubicom32 Linux Kernel Port 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. ++# ++# The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++# see . ++# ++# Ubicom32 implementation derived from (with many thanks): ++# arch/m68knommu ++# arch/blackfin ++# arch/parisc ++# ++ ++obj-$(CONFIG_IP5170DPF) += board-ip5170dpf.o ++obj-$(CONFIG_IP5160DEV) += board-ip5160dev.o ++obj-$(CONFIG_IP5160EVAL) += board-ip5160rgw.o ++ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/mach-ip7k/Kconfig linux-2.6.28.10/arch/ubicom32/mach-ip7k/Kconfig +--- linux-2.6.28.10_o/arch/ubicom32/mach-ip7k/Kconfig 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/mach-ip7k/Kconfig 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,132 @@ ++config IP7145DPF ++ bool "IP7145DPF" ++ select UBICOM32_V4 ++ select UBICOM_INPUT ++ select UBICOM_INPUT_I2C ++ select RTC_CLASS ++ select RTC_DRV_S35390A ++ select I2C ++ select I2C_GPIO ++ select GPIO_PCA953X ++ select FB ++ select FB_UBICOM32 ++ select BACKLIGHT_LCD_SUPPORT ++ select LCD_CLASS_DEVICE ++ select LCD_UBICOM32 ++ select BACKLIGHT_CLASS_DEVICE ++ select BACKLIGHT_UBICOM32 ++ select SND_UBI32 ++ select MMC_UBICOM32 ++ select MMC ++ select MMC_BLOCK ++ select BRD_64MB ++ help ++ IP7145 Digital Picture Frame reference design, supports: ++ 8007-0410 v1.0 ++ ++config IP7160RGW ++ bool "IP7160RGW" ++ select UBICOM32_V4 ++ select UBICOM_INPUT ++ select NEW_LEDS ++ select LEDS_CLASS ++ select LEDS_GPIO ++ select BRD_64MB ++ select SPI ++ select SPI_UBICOM32_GPIO ++ select VLAN_8021Q ++ select UBICOM_SWITCH ++ select UBICOM_SWITCH_BCM539X ++ help ++ Ubicom IP7160 RGW Eval, supports: ++ 8007-0110 v1.0 ++ 8007-0111 v1.1 ++ 8007-0112 v1.2 ++ ++config IP7160BRINGUP ++ bool "IP7160BRINGUP" ++ select UBICOM32_V4 ++ select NEW_LEDS ++ select LEDS_CLASS ++ select LEDS_GPIO ++ select BRD_64MB ++ help ++ Ubicom IP7160 Bringup, supports: ++ 8007-0010 v1.0 ++ ++config IP7160DPF ++ bool "IP7160DPF" ++ select UBICOM32_V4 ++ select I2C ++ select I2C_GPIO ++ select FB ++ select FB_UBICOM32 ++ select BACKLIGHT_LCD_SUPPORT ++ select BACKLIGHT_CLASS_DEVICE ++ select SND_UBI32 ++ select SND_UBI32_AUDIO_CS4350 ++ select UBICOM_HID ++ select BRD_64MB ++ help ++ IP7160 Digital Picture Frame board, supports: ++ 8007-0211 Rev 1.1 ++ ++config IP7500MODULE ++ bool "IP7500MODULE" ++ select UBICOM32_V4 ++ select BRD_128MB ++ help ++ Ubicom IP7500 CPU Module board, supports: ++ 8007-0510 v1.0 ++ 8007-0510A v1.0 ++ ++ Please see ip7500module.c for more details. ++ ++config IP7500AV ++ bool "IP7500AV" ++ select UBICOM32_V4 ++ select BRD_128MB ++ select I2C ++ select I2C_GPIO ++ select SND_UBI32 ++ select SND_UBI32_AUDIO_CS4384 ++ select FB ++ select FB_UBICOM32 ++ help ++ Ubicom IP7500 Audio Video board, supports: ++ 8007-0810 v1.0 ++ ++ With Ubicom IP7500 CPU Module board: ++ 8007-0510 v1.0 -or- ++ 8007-0510A v1.0 ++ ++ Please see ip7500av.c for more details. ++ ++config IP7500MEDIA ++ bool "IP7500MEDIA" ++ select UBICOM32_V4 ++ select UBICOM_INPUT_I2C ++ select RTC_CLASS ++ select RTC_DRV_S35390A ++ select I2C ++ select I2C_GPIO ++ select GPIO_PCA953X ++ select FB ++ select FB_UBICOM32 ++ select BACKLIGHT_LCD_SUPPORT ++ select LCD_CLASS_DEVICE ++ select LCD_UBICOM32 ++ select BACKLIGHT_CLASS_DEVICE ++ select BACKLIGHT_UBICOM32 ++ select SND_UBI32 ++ select SND_UBI32_AUDIO_CS4350 ++ select MMC_UBICOM32 ++ select MMC ++ select MMC_BLOCK ++ select BRD_128MB ++ help ++ IP7500 Media Board w/ IP7500 CPU Module board, supports: ++ 8007-0610 v1.0 w/ 8007-0510 v1.0 ++ ++ Please see ip7500media.c for more details. ++ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/mach-ip7k/Makefile linux-2.6.28.10/arch/ubicom32/mach-ip7k/Makefile +--- linux-2.6.28.10_o/arch/ubicom32/mach-ip7k/Makefile 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/mach-ip7k/Makefile 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,35 @@ ++# ++# arch/ubicom32/mach-ip7k/Makefile ++# Makefile for ip7k based boards. ++# ++# (C) Copyright 2009, Ubicom, Inc. ++# ++# This file is part of the Ubicom32 Linux Kernel Port. ++# ++# The Ubicom32 Linux Kernel Port 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. ++# ++# The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++# see . ++# ++# Ubicom32 implementation derived from (with many thanks): ++# arch/m68knommu ++# arch/blackfin ++# arch/parisc ++# ++ ++obj-$(CONFIG_IP7145DPF) += board-ip7145dpf.o ++obj-$(CONFIG_IP7160RGW) += board-ip7160rgw.o ++obj-$(CONFIG_IP7160BRINGUP) += board-ip7160bringup.o ++obj-$(CONFIG_IP7160DPF) += board-ip7160dpf.o ++obj-$(CONFIG_IP7500MODULE) += board-ip7500module.o ++obj-$(CONFIG_IP7500MEDIA) += board-ip7500media.o ++obj-$(CONFIG_IP7500AV) += board-ip7500av.o +diff -ruN linux-2.6.28.10_o/arch/ubicom32/Makefile linux-2.6.28.10/arch/ubicom32/Makefile +--- linux-2.6.28.10_o/arch/ubicom32/Makefile 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/Makefile 2009-08-06 10:31:02.000000000 +0300 +@@ -0,0 +1,105 @@ ++# ++# arch/ubicom32/Makefile ++# ++# ++# (C) Copyright 2009, Ubicom, Inc. ++# ++# This file is part of the Ubicom32 Linux Kernel Port. ++# ++# The Ubicom32 Linux Kernel Port 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. ++# ++# The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++# see . ++# ++# Ubicom32 implementation derived from (with many thanks): ++# arch/m68knommu ++# arch/blackfin ++# arch/parisc ++# ++ ++KBUILD_DEFCONFIG := ++ ++# setup the machine name and machine dependent settings ++machine-$(CONFIG_UBICOM32_V3) := ip5k ++machine-$(CONFIG_UBICOM32_V4) := ip7k ++MACHINE := $(machine-y) ++export MACHINE ++ ++model-$(CONFIG_RAMKERNEL) := ram ++model-$(CONFIG_ROMKERNEL) := rom ++MODEL := $(model-y) ++export MODEL ++ ++CPUCLASS := $(cpuclass-y) ++ ++export CPUCLASS ++ ++# ++# We want the core kernel built using the fastcall ABI but modules need ++# to be built using the slower calling convention because they could be ++# loaded out of range for fast calls. ++# ++CFLAGS_KERNEL += -mfastcall ++CFLAGS_MODULE += -mno-fastcall ++ ++# ++# Some CFLAG additions based on specific CPU type. ++# ++cflags-$(CONFIG_UBICOM32_V3) := -march=ubicom32v3 -DIP5000 ++cflags-$(CONFIG_UBICOM32_V4) := -march=ubicom32v4 -DIP7000 ++ ++ldflags-$(CONFIG_LINKER_RELAXATION) := --relax ++LDFLAGS_vmlinux := $(ldflags-y) ++ ++GCCLIBDIR := $(dir $(shell $(CC) $(cflags-y) -print-libgcc-file-name)) ++GCC_LIBS := $(GCCLIBDIR)/libgcc.a ++ ++KBUILD_CFLAGS += $(cflags-y) -ffunction-sections ++KBUILD_AFLAGS += $(cflags-y) ++ ++KBUILD_CFLAGS += -D__linux__ -Dlinux ++KBUILD_CFLAGS += -DUTS_SYSNAME=\"uClinux\" ++ ++# include any machine specific directory ++ifneq ($(machine-y),) ++core-y += arch/$(ARCH)/mach-$(MACHINE)/ ++endif ++ ++head-y := arch/$(ARCH)/kernel/head.o ++ ++core-y += arch/$(ARCH)/kernel/ \ ++ arch/$(ARCH)/mm/ \ ++ arch/$(ARCH)/crypto/ \ ++ arch/$(ARCH)/mach-common/ ++ ++drivers-$(CONFIG_OPROFILE) += arch/ubicom32/oprofile/ ++ ++libs-y += arch/$(ARCH)/lib/ ++libs-y += $(GCC_LIBS) ++ ++archclean: ++ ++# make sure developer has selected a valid board ++ifeq ($(CONFIG_NOBOARD),y) ++# $(error have to select a valid board file $(CONFIG_NOBOARD), please run kernel config again) ++_all: config_board_error ++endif ++ ++config_board_error: ++ @echo "*************************************************" ++ @echo "You have not selected a proper board." ++ @echo "Please run menuconfig (or config) against your" ++ @echo "kernel and choose your board under Processor" ++ @echo "options" ++ @echo "*************************************************" ++ @exit 1 ++ +diff -ruN linux-2.6.28.10_o/arch/ubicom32/mm/Makefile linux-2.6.28.10/arch/ubicom32/mm/Makefile +--- linux-2.6.28.10_o/arch/ubicom32/mm/Makefile 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.28.10/arch/ubicom32/mm/Makefile 2009-08-12 13:08:37.000000000 +0300 +@@ -0,0 +1,32 @@ ++# ++# arch/ubicom32/mm/Makefile ++# ++# ++# (C) Copyright 2009, Ubicom, Inc. ++# ++# This file is part of the Ubicom32 Linux Kernel Port. ++# ++# The Ubicom32 Linux Kernel Port 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. ++# ++# The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port. If not, ++# see . ++# ++# Ubicom32 implementation derived from (with many thanks): ++# arch/m68knommu ++# arch/blackfin ++# arch/parisc ++# ++# ++# Makefile for the linux m68knommu specific parts of the memory manager. ++# ++ ++obj-y += init.o fault.o memory.o kmap.o ocm-alloc.o +diff -ruN linux-2.6.28.10_o/include/linux/elf-em.h linux-2.6.28.10/include/linux/elf-em.h +--- linux-2.6.28.10_o/include/linux/elf-em.h 2009-05-02 21:54:43.000000000 +0300 ++++ linux-2.6.28.10/include/linux/elf-em.h 2009-08-06 10:31:10.000000000 +0300 +@@ -41,6 +41,7 @@ + * up with a final number. + */ + #define EM_ALPHA 0x9026 ++#define EM_UBICOM32 0xde3d /* Ubicom32; no ABI */ + + /* Bogus old v850 magic number, used by old tools. */ + #define EM_CYGNUS_V850 0x9080 +diff -ruN linux-2.6.28.10_o/lib/Kconfig.debug linux-2.6.28.10/lib/Kconfig.debug +--- linux-2.6.28.10_o/lib/Kconfig.debug 2009-05-02 21:54:43.000000000 +0300 ++++ linux-2.6.28.10/lib/Kconfig.debug 2009-08-06 10:31:11.000000000 +0300 +@@ -549,7 +549,7 @@ + bool "Compile the kernel with frame pointers" + depends on DEBUG_KERNEL && \ + (X86 || CRIS || M68K || M68KNOMMU || FRV || UML || S390 || \ +- AVR32 || SUPERH || BLACKFIN || MN10300) ++ AVR32 || SUPERH || BLACKFIN || MN10300 || UBICOM32) + default y if DEBUG_INFO && UML + help + If you say Y here the resulting kernel image will be slightly larger +diff -ruN linux-2.6.28.10_o/scripts/mod/file2alias.c linux-2.6.28.10/scripts/mod/file2alias.c +--- linux-2.6.28.10_o/scripts/mod/file2alias.c 2009-05-02 21:54:43.000000000 +0300 ++++ linux-2.6.28.10/scripts/mod/file2alias.c 2009-08-06 10:31:12.000000000 +0300 +@@ -753,6 +753,15 @@ + + sym->st_value; + } + ++ /* ++ * somehow our gcc is not generating st_size correctly and set 0 for some symbols. ++ * and 0 size will break do_table since it adjust size to (size - id_size) ++ * this is to make sure st_size fall in range. ++ */ ++ if (sym->st_size == 0 || sym->st_size > info->sechdrs[sym->st_shndx].sh_size) { ++ sym->st_size = info->sechdrs[sym->st_shndx].sh_size; ++ } ++ + if (sym_is(symname, "__mod_pci_device_table")) + do_table(symval, sym->st_size, + sizeof(struct pci_device_id), "pci", + diff --git a/toolchain/uClibc/config-0.9.30.1/common b/toolchain/uClibc/config-0.9.30.1/common index 46b9eba05d..9cd2e3d1bb 100644 --- a/toolchain/uClibc/config-0.9.30.1/common +++ b/toolchain/uClibc/config-0.9.30.1/common @@ -64,6 +64,7 @@ TARGET_SUBARCH="" # TARGET_sh is not set # TARGET_sh64 is not set # TARGET_sparc is not set +# TARGET_ubicom32 is not set # TARGET_v850 is not set # TARGET_vax is not set # TARGET_x86_64 is not set diff --git a/toolchain/uClibc/config-0.9.30.1/ubicom32 b/toolchain/uClibc/config-0.9.30.1/ubicom32 new file mode 100644 index 0000000000..ef00e79355 --- /dev/null +++ b/toolchain/uClibc/config-0.9.30.1/ubicom32 @@ -0,0 +1,35 @@ +ARCH_BIG_ENDIAN=y +ARCH_HAS_NO_MMU=y +COMPAT_ATEXIT=y +# CONFIG_UC_UBICOM32_V3 is not set +CONFIG_UC_UBICOM32_V4=y +# DOSTRIP is not set +EXCLUDE_BRK=y +FORCE_SHAREABLE_TEXT_SEGMENTS=y +LDSO_PRELOAD_FILE_SUPPORT=y +MALLOC=y +# MALLOC_STANDARD is not set +PTHREADS_DEBUG_SUPPORT=y +SUPPORT_LD_DEBUG=y +TARGET_ARCH="ubicom32" +TARGET_ubicom32=y +# UCLIBC_FORMAT_ELF is not set +UCLIBC_FORMAT_FDPIC_ELF=y +# UCLIBC_FORMAT_FLAT is not set +# UCLIBC_FORMAT_FLAT_SEP_DATA is not set +# UCLIBC_FORMAT_SHARED_FLAT is not set +UCLIBC_HAS_ADVANCED_REALTIME=y +UCLIBC_HAS_FOPEN_LARGEFILE_MODE=y +UCLIBC_HAS_FPU=y +# UCLIBC_HAS_GETPT is not set +UCLIBC_HAS_OBSOLETE_BSD_SIGNAL=y +UCLIBC_HAS_OBSOLETE_SYSV_SIGNAL=y +UCLIBC_HAS_PROFILING=y +UCLIBC_HAS_REENTRANT_RPC=y +UCLIBC_HAS_STUBS=y +UCLIBC_HAS_XATTR=y +UCLIBC_NTP_LEGACY=y +UCLIBC_STATIC_LDCONFIG=y +UCLIBC_SV4_DEPRECATED=y +UCLIBC_UCLINUX_BROKEN_MUNMAP=y +UNIX98PTY_ONLY=y diff --git a/toolchain/uClibc/patches-0.9.30.1/600-ubicom32-uClibc.patch b/toolchain/uClibc/patches-0.9.30.1/600-ubicom32-uClibc.patch new file mode 100644 index 0000000000..5404f980d5 --- /dev/null +++ b/toolchain/uClibc/patches-0.9.30.1/600-ubicom32-uClibc.patch @@ -0,0 +1,4407 @@ +--- a/Rules.mak ++++ b/Rules.mak +@@ -411,6 +411,17 @@ ifeq ($(TARGET_ARCH),microblaze) + SYMBOL_PREFIX=_ + endif + ++ifeq ($(TARGET_ARCH),ubicom32) ++ OPTIMIZATION+=-fstrict-aliasing ++ CPU_CFLAGS-$(CONFIG_UBICOM32_V3)+=-march=ubicom32v3 ++ CPU_CFLAGS-$(CONFIG_UBICOM32_V4)+=-march=ubicom32v4 ++ifeq ($(UCLIBC_FORMAT_FDPIC_ELF),y) ++ CPU_CFLAGS-y:=-mfdpic ++ CPU_LDFLAGS-y += -Wl,-melf32ubicom32fdpic ++endif ++ ++endif ++ + ifeq ($(TARGET_ARCH),v850) + SYMBOL_PREFIX=_ + endif +--- a/extra/Configs/Config.in ++++ b/extra/Configs/Config.in +@@ -73,6 +73,9 @@ config TARGET_sh64 + config TARGET_sparc + bool "sparc" + ++config TARGET_ubicom32 ++ bool "ubicom32" ++ + config TARGET_v850 + bool "v850 (BROKEN)" + +@@ -174,6 +177,10 @@ if TARGET_sparc + source "extra/Configs/Config.sparc" + endif + ++if TARGET_ubicom32 ++source "extra/Configs/Config.ubicom32" ++endif ++ + if TARGET_v850 + source "extra/Configs/Config.v850" + endif +--- a/extra/Configs/Config.in.arch ++++ b/extra/Configs/Config.in.arch +@@ -148,7 +148,7 @@ config UCLIBC_HAS_SOFT_FLOAT + config DO_C99_MATH + bool "Enable full C99 math library support" + depends on UCLIBC_HAS_FLOATS +- default n ++ default y + help + If you want the uClibc math library to contain the full set C99 + math library features, then answer Y. If you leave this set to +--- /dev/null ++++ b/extra/Configs/Config.ubicom32 +@@ -0,0 +1,44 @@ ++# ++# For a description of the syntax of this configuration file, ++# see extra/config/Kconfig-language.txt ++# ++ ++config TARGET_ARCH ++ string ++ default "ubicom32" ++ ++config FORCE_OPTIONS_FOR_ARCH ++ bool ++ default y ++ select ARCH_BIG_ENDIAN ++ select ARCH_HAS_NO_MMU ++ ++choice ++ prompt "Target Processor Architecture" ++ default CONFIG_UC_UBICOM32_V3 ++ help ++ This selects the instruction set architecture of your Ubicom32 CPU. This ++ information is used for optimizing purposes. To build a library that ++ will run on any Ubicom32 CPU, you can specify "v3" here. ++ If you pick anything other than "v3," there is no ++ guarantee that uClibc will even run on anything other than the ++ selected processor type. ++ ++ You should probably select the Ubicom32 ISA that best matches the ++ CPU you will be using on your device. uClibc will be tuned ++ for that architecture. ++ ++ If you don't know what to do, choose "v3" ++ ++config CONFIG_UC_UBICOM32_V3 ++ bool "ISA v3" ++ ++config CONFIG_UC_UBICOM32_V4 ++ bool "ISA v4" ++endchoice ++ ++config ARCH_CFLAGS ++ string ++ ++config CROSS ++ string +--- a/include/elf.h ++++ b/include/elf.h +@@ -331,6 +331,8 @@ typedef struct + + #define EM_XSTORMY16 0xad45 + ++#define EM_UBICOM32 0xde3d /* Ubicom32; no ABI */ ++ + /* FRV magic number - no EABI available??. */ + #define EM_CYGNUS_FRV 0x5441 + +@@ -3036,6 +3038,55 @@ typedef Elf32_Addr Elf32_Conflict; + /* Keep this the last entry. */ + #define R_XTENSA_NUM 50 + ++/* Ubicom32 ELF relocation types */ ++#define R_UBICOM32_NONE 0 ++#define R_UBICOM32_16 1 ++#define R_UBICOM32_32 2 ++#define R_UBICOM32_LO16 3 ++#define R_UBICOM32_HI16 4 ++#define R_UBICOM32_21_PCREL 5 ++#define R_UBICOM32_24_PCREL 6 ++#define R_UBICOM32_HI24 7 ++#define R_UBICOM32_LO7_S 8 ++#define R_UBICOM32_LO7_2_S 9 ++#define R_UBICOM32_LO7_4_S 10 ++#define R_UBICOM32_LO7_D 11 ++#define R_UBICOM32_LO7_2_D 12 ++#define R_UBICOM32_LO7_4_D 13 ++#define R_UBICOM32_32_HARVARD 14 ++#define R_UBICOM32_LO7_CALLI 15 ++#define R_UBICOM32_LO16_CALLI 16 ++#define R_UBICOM32_GOT_HI24 17 ++#define R_UBICOM32_GOT_LO7_S 18 ++#define R_UBICOM32_GOT_LO7_2_S 19 ++#define R_UBICOM32_GOT_LO7_4_S 20 ++#define R_UBICOM32_GOT_LO7_D 21 ++#define R_UBICOM32_GOT_LO7_2_D 22 ++#define R_UBICOM32_GOT_LO7_4_D 23 ++#define R_UBICOM32_FUNCDESC_GOT_HI24 24 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_S 25 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_2_S 26 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_4_S 27 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_D 28 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_2_D 29 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_4_D 30 ++#define R_UBICOM32_GOT_LO7_CALLI 31 ++#define R_UBICOM32_FUNCDESC_GOT_LO7_CALLI 32 ++#define R_UBICOM32_FUNCDESC_VALUE 33 ++#define R_UBICOM32_FUNCDESC 34 ++#define R_UBICOM32_GOTOFFSET_LO 35 ++#define R_UBICOM32_GOTOFFSET_HI 36 ++#define R_UBICOM32_FUNCDESC_GOTOFFSET_LO 37 ++#define R_UBICOM32_FUNCDESC_GOTOFFSET_HI 38 ++#define R_UBICOM32_GNU_VTINHERIT 200 ++#define R_UBICOM32_GNU_VTENTRY 201 ++ ++/* Ubicom32 Flags. */ ++#define EF_UBICOM32_V3 0x00000001 /* -fmarch=ubicom32v3 */ ++#define EF_UBICOM32_V4 0x00000002 /* -fmarch=ubicom32v4 */ ++#define EF_UBICOM32_PIC 0x80000000 /* -fpic */ ++#define EF_UBICOM32_FDPIC 0x40000000 /* -mfdpic */ ++ + __END_DECLS + + #endif /* elf.h */ +--- a/include/features.h ++++ b/include/features.h +@@ -422,4 +422,10 @@ uClibc was built without large file supp + # define __linux__ 1 + #endif + ++#ifndef libc_hidden_proto ++#define libc_hidden_proto(name, attrs...) ++#endif ++#ifndef libm_hidden_proto ++#define libm_hidden_proto(name, attrs...) ++#endif + #endif /* features.h */ +--- a/ldso/ldso/dl-startup.c ++++ b/ldso/ldso/dl-startup.c +@@ -165,10 +165,13 @@ DL_START(unsigned long args) + aux_dat += 2; + } + ++#if !defined __FDPIC__ + /* locate the ELF header. We need this done as soon as possible + * (esp since SEND_STDERR() needs this on some platforms... */ + if (!auxvt[AT_BASE].a_un.a_val) + auxvt[AT_BASE].a_un.a_val = elf_machine_load_address(); ++#endif ++ + DL_INIT_LOADADDR_BOOT(load_addr, auxvt[AT_BASE].a_un.a_val); + header = (ElfW(Ehdr) *) auxvt[AT_BASE].a_un.a_val; + +--- a/ldso/ldso/ldso.c ++++ b/ldso/ldso/ldso.c +@@ -179,10 +179,12 @@ void _dl_get_ready_to_run(struct elf_res + _dl_progname = argv[0]; + } + ++#if 0 // blackfin does this, we do to avoid die during reloc + if (_start == (void *) auxvt[AT_ENTRY].a_un.a_val) { + _dl_dprintf(_dl_debug_file, "Standalone execution is not supported yet\n"); + _dl_exit(1); + } ++#endif + + /* Start to build the tables of the modules that are required for + * this beast to run. We start with the basic executable, and then +--- /dev/null ++++ b/ldso/ldso/ubicom32/dl-debug.h +@@ -0,0 +1,72 @@ ++/* vi: set sw=4 ts=4: */ ++/* Ubicom32 ELF shared library loader suppport ++ * ++ * Copyright (c) 2009 Ubicom Inc. ++ * Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald, ++ * David Engel, Hongjiu Lu and Mitch D'Souza ++ * Copyright (C) 2001-2004 Erik Andersen ++ * ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. The name of the above contributors may not be ++ * used to endorse or promote products derived from this software ++ * without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ */ ++ ++static const char *_dl_reltypes_tab[] = ++{ ++ "R_UBICOM32_NONE", /* 0 */ ++ "R_UBICOM32_16", ++ "R_UBICOM32_32", ++ "R_UBICOM32_LO16", ++ "R_UBICOM32_HI16", ++ "R_UBICOM32_21_PCREL", /* 5 */ ++ "R_UBICOM32_24_PCREL", ++ "R_UBICOM32_HI24", ++ "R_UBICOM32_LO7_S", ++ "R_UBICOM32_LO7_2_S", ++ "R_UBICOM32_LO7_4_S", /* 10 */ ++ "R_UBICOM32_LO7_D", ++ "R_UBICOM32_LO7_2_D", ++ "R_UBICOM32_LO7_4_D", ++ "R_UBICOM32_32_HARVARD", ++ "R_UBICOM32_LO7_CALLI", /* 15 */ ++ "R_UBICOM32_LO16_CALLI", ++ "R_UBICOM32_GOT_HI24", ++ "R_UBICOM32_GOT_LO7_S", ++ "R_UBICOM32_GOT_LO7_2_S" ++ "R_UBICOM32_GOT_LO7_4_S", /* 20 */ ++ "R_UBICOM32_GOT_LO7_D", ++ "R_UBICOM32_GOT_LO7_2_D", ++ "R_UBICOM32_GOT_LO7_4_D", ++ "R_UBICOM32_FUNCDESC_GOT_HI24 24", ++ "R_UBICOM32_FUNCDESC_GOT_LO7_S", /* 25 */ ++ "R_UBICOM32_FUNCDESC_GOT_LO7_2_S", ++ "R_UBICOM32_FUNCDESC_GOT_LO7_4_S", ++ "R_UBICOM32_FUNCDESC_GOT_LO7_D", ++ "R_UBICOM32_FUNCDESC_GOT_LO7_2_D", ++ "R_UBICOM32_FUNCDESC_GOT_LO7_4_D", /* 30 */ ++ "R_UBICOM32_GOT_LO7_CALLI", ++ "R_UBICOM32_FUNCDESC_VALUE", ++ "R_UBICOM32_FUNCDESC", ++#if 1 ++ [200] "R_UBICOM32_GNU_VTINHERIT" , "R_UBICOM32_GNU_VTENTRY" ++#endif ++}; +--- /dev/null ++++ b/ldso/ldso/ubicom32/dl-inlines.h +@@ -0,0 +1,582 @@ ++ /* Copyright (C) 2003, 2004 Red Hat, Inc. ++ Contributed by Alexandre Oliva ++ ++This file is part of uClibc. ++ ++uClibc is free software; you can redistribute it and/or modify it ++under the terms of the GNU Lesser General Public License as ++published by the Free Software Foundation; either version 2.1 of the ++License, or (at your option) any later version. ++ ++uClibc 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 ++Library General Public License for more details. ++ ++You should have received a copy of the GNU Lesser General Public ++License along with uClibc; see the file COPYING.LIB. If not, write to ++the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, ++USA. */ ++ ++//#include ++#define SRAM_TEST(x) 0 ++#ifndef _dl_assert ++# define _dl_assert(expr) ++#endif ++ ++/* Initialize a DL_LOADADDR_TYPE given a got pointer and a complete ++ load map. */ ++static __always_inline void ++__dl_init_loadaddr_map (struct elf32_fdpic_loadaddr *loadaddr, Elf32_Addr dl_boot_got_pointer, ++ struct elf32_fdpic_loadmap *map) ++{ ++ if (map->version != 0) ++ { ++ SEND_EARLY_STDERR ("Invalid loadmap version number\n"); ++ _dl_exit(-1); ++ } ++ if (map->nsegs == 0) ++ { ++ SEND_EARLY_STDERR ("Invalid segment count in loadmap\n"); ++ _dl_exit(-1); ++ } ++ loadaddr->got_value = (void*)dl_boot_got_pointer; ++ loadaddr->map = map; ++} ++ ++/* Figure out how many LOAD segments there are in the given headers, ++ and allocate a block for the load map big enough for them. ++ got_value will be properly initialized later on, with INIT_GOT. */ ++static __always_inline int ++__dl_init_loadaddr (struct elf32_fdpic_loadaddr *loadaddr, Elf32_Phdr *ppnt, ++ int pcnt) ++{ ++ int count = 0, i; ++ size_t size; ++ ++ for (i = 0; i < pcnt; i++) ++ if (ppnt[i].p_type == PT_LOAD) ++ count++; ++ ++ loadaddr->got_value = 0; ++ ++ size = sizeof (struct elf32_fdpic_loadmap) ++ + sizeof (struct elf32_fdpic_loadseg) * count; ++ loadaddr->map = _dl_malloc (size); ++ if (! loadaddr->map) ++ _dl_exit (-1); ++ ++ loadaddr->map->version = 0; ++ loadaddr->map->nsegs = 0; ++ ++ return count; ++} ++ ++#if defined (__SUPPORT_LD_DEBUG__) ++extern char *_dl_debug; ++extern int _dl_debug_file; ++#endif ++ ++/* Incrementally initialize a load map. */ ++static __always_inline void ++__dl_init_loadaddr_hdr (struct elf32_fdpic_loadaddr loadaddr, void *addr, ++ Elf32_Phdr *phdr, int maxsegs) ++{ ++ struct elf32_fdpic_loadseg *segdata; ++ ++ if (loadaddr.map->nsegs == maxsegs) ++ _dl_exit (-1); ++ ++ segdata = &loadaddr.map->segs[loadaddr.map->nsegs++]; ++ segdata->addr = (Elf32_Addr) addr; ++ segdata->p_vaddr = phdr->p_vaddr; ++ segdata->p_memsz = phdr->p_memsz; ++ ++#if defined (__SUPPORT_LD_DEBUG__) ++ { ++ if (_dl_debug) ++ _dl_dprintf(_dl_debug_file, "%i: mapped %x at %x, size %x\n", ++ loadaddr.map->nsegs-1, ++ segdata->p_vaddr, segdata->addr, segdata->p_memsz); ++ } ++#endif ++} ++ ++static __always_inline void __dl_loadaddr_unmap ++(struct elf32_fdpic_loadaddr loadaddr, struct funcdesc_ht *funcdesc_ht); ++ ++/* Figure out whether the given address is in one of the mapped ++ segments. */ ++static __always_inline int ++__dl_addr_in_loadaddr (void *p, struct elf32_fdpic_loadaddr loadaddr) ++{ ++ struct elf32_fdpic_loadmap *map = loadaddr.map; ++ int c; ++ ++ for (c = 0; c < map->nsegs; c++) ++ if ((void*)map->segs[c].addr <= p ++ && (char*)p < (char*)map->segs[c].addr + map->segs[c].p_memsz) ++ return 1; ++ ++ return 0; ++} ++ ++static __always_inline void * _dl_funcdesc_for (void *entry_point, void *got_value); ++ ++/* The hashcode handling code below is heavily inspired in libiberty's ++ hashtab code, but with most adaptation points and support for ++ deleting elements removed. ++ ++ Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. ++ Contributed by Vladimir Makarov (vmakarov@cygnus.com). */ ++ ++static __always_inline unsigned long ++higher_prime_number (unsigned long n) ++{ ++ /* These are primes that are near, but slightly smaller than, a ++ power of two. */ ++ static const unsigned long primes[] = { ++ (unsigned long) 7, ++ (unsigned long) 13, ++ (unsigned long) 31, ++ (unsigned long) 61, ++ (unsigned long) 127, ++ (unsigned long) 251, ++ (unsigned long) 509, ++ (unsigned long) 1021, ++ (unsigned long) 2039, ++ (unsigned long) 4093, ++ (unsigned long) 8191, ++ (unsigned long) 16381, ++ (unsigned long) 32749, ++ (unsigned long) 65521, ++ (unsigned long) 131071, ++ (unsigned long) 262139, ++ (unsigned long) 524287, ++ (unsigned long) 1048573, ++ (unsigned long) 2097143, ++ (unsigned long) 4194301, ++ (unsigned long) 8388593, ++ (unsigned long) 16777213, ++ (unsigned long) 33554393, ++ (unsigned long) 67108859, ++ (unsigned long) 134217689, ++ (unsigned long) 268435399, ++ (unsigned long) 536870909, ++ (unsigned long) 1073741789, ++ (unsigned long) 2147483647, ++ /* 4294967291L */ ++ ((unsigned long) 2147483647) + ((unsigned long) 2147483644), ++ }; ++ ++ const unsigned long *low = &primes[0]; ++ const unsigned long *high = &primes[sizeof(primes) / sizeof(primes[0])]; ++ ++ while (low != high) ++ { ++ const unsigned long *mid = low + (high - low) / 2; ++ if (n > *mid) ++ low = mid + 1; ++ else ++ high = mid; ++ } ++ ++#if 0 ++ /* If we've run out of primes, abort. */ ++ if (n > *low) ++ { ++ fprintf (stderr, "Cannot find prime bigger than %lu\n", n); ++ abort (); ++ } ++#endif ++ ++ return *low; ++} ++ ++struct funcdesc_ht ++{ ++ /* Table itself. */ ++ struct funcdesc_value **entries; ++ ++ /* Current size (in entries) of the hash table */ ++ size_t size; ++ ++ /* Current number of elements. */ ++ size_t n_elements; ++}; ++ ++static __always_inline int ++hash_pointer (const void *p) ++{ ++ return (int) ((long)p >> 3); ++} ++ ++static __always_inline struct funcdesc_ht * ++htab_create (void) ++{ ++ struct funcdesc_ht *ht = _dl_malloc (sizeof (struct funcdesc_ht)); ++ ++ if (! ht) ++ return NULL; ++ ht->size = 3; ++ ht->entries = _dl_malloc (sizeof (struct funcdesc_ht_value *) * ht->size); ++ if (! ht->entries) ++ return NULL; ++ ++ ht->n_elements = 0; ++ ++ _dl_memset (ht->entries, 0, sizeof (struct funcdesc_ht_value *) * ht->size); ++ ++ return ht; ++} ++ ++/* This is only called from _dl_loadaddr_unmap, so it's safe to call ++ _dl_free(). See the discussion below. */ ++static __always_inline void ++htab_delete (struct funcdesc_ht *htab) ++{ ++ int i; ++ ++ for (i = htab->size - 1; i >= 0; i--) ++ if (htab->entries[i]) ++ _dl_free (htab->entries[i]); ++ ++ _dl_free (htab->entries); ++ _dl_free (htab); ++} ++ ++/* Similar to htab_find_slot, but without several unwanted side effects: ++ - Does not call htab->eq_f when it finds an existing entry. ++ - Does not change the count of elements/searches/collisions in the ++ hash table. ++ This function also assumes there are no deleted entries in the table. ++ HASH is the hash value for the element to be inserted. */ ++ ++static __always_inline struct funcdesc_value ** ++find_empty_slot_for_expand (struct funcdesc_ht *htab, int hash) ++{ ++ size_t size = htab->size; ++ unsigned int index = hash % size; ++ struct funcdesc_value **slot = htab->entries + index; ++ int hash2; ++ ++ if (! *slot) ++ return slot; ++ ++ hash2 = 1 + hash % (size - 2); ++ for (;;) ++ { ++ index += hash2; ++ if (index >= size) ++ index -= size; ++ ++ slot = htab->entries + index; ++ if (! *slot) ++ return slot; ++ } ++} ++ ++/* The following function changes size of memory allocated for the ++ entries and repeatedly inserts the table elements. The occupancy ++ of the table after the call will be about 50%. Naturally the hash ++ table must already exist. Remember also that the place of the ++ table entries is changed. If memory allocation failures are allowed, ++ this function will return zero, indicating that the table could not be ++ expanded. If all goes well, it will return a non-zero value. */ ++ ++static __always_inline int ++htab_expand (struct funcdesc_ht *htab) ++{ ++ struct funcdesc_value **oentries; ++ struct funcdesc_value **olimit; ++ struct funcdesc_value **p; ++ struct funcdesc_value **nentries; ++ size_t nsize; ++ ++ oentries = htab->entries; ++ olimit = oentries + htab->size; ++ ++ /* Resize only when table after removal of unused elements is either ++ too full or too empty. */ ++ if (htab->n_elements * 2 > htab->size) ++ nsize = higher_prime_number (htab->n_elements * 2); ++ else ++ nsize = htab->size; ++ ++ nentries = _dl_malloc (sizeof (struct funcdesc_value *) * nsize); ++ _dl_memset (nentries, 0, sizeof (struct funcdesc_value *) * nsize); ++ if (nentries == NULL) ++ return 0; ++ htab->entries = nentries; ++ htab->size = nsize; ++ ++ p = oentries; ++ do ++ { ++ if (*p) ++ *find_empty_slot_for_expand (htab, hash_pointer ((*p)->entry_point)) ++ = *p; ++ ++ p++; ++ } ++ while (p < olimit); ++ ++#if 0 /* We can't tell whether this was allocated by the _dl_malloc() ++ built into ld.so or malloc() in the main executable or libc, ++ and calling free() for something that wasn't malloc()ed could ++ do Very Bad Things (TM). Take the conservative approach ++ here, potentially wasting as much memory as actually used by ++ the hash table, even if multiple growths occur. That's not ++ so bad as to require some overengineered solution that would ++ enable us to keep track of how it was allocated. */ ++ _dl_free (oentries); ++#endif ++ return 1; ++} ++ ++/* This function searches for a hash table slot containing an entry ++ equal to the given element. To delete an entry, call this with ++ INSERT = 0, then call htab_clear_slot on the slot returned (possibly ++ after doing some checks). To insert an entry, call this with ++ INSERT = 1, then write the value you want into the returned slot. ++ When inserting an entry, NULL may be returned if memory allocation ++ fails. */ ++ ++static __always_inline struct funcdesc_value ** ++htab_find_slot (struct funcdesc_ht *htab, void *ptr, int insert) ++{ ++ unsigned int index; ++ int hash, hash2; ++ size_t size; ++ struct funcdesc_value **entry; ++ ++ if (htab->size * 3 <= htab->n_elements * 4 ++ && htab_expand (htab) == 0) ++ return NULL; ++ ++ hash = hash_pointer (ptr); ++ ++ size = htab->size; ++ index = hash % size; ++ ++ entry = &htab->entries[index]; ++ if (!*entry) ++ goto empty_entry; ++ else if ((*entry)->entry_point == ptr) ++ return entry; ++ ++ hash2 = 1 + hash % (size - 2); ++ for (;;) ++ { ++ index += hash2; ++ if (index >= size) ++ index -= size; ++ ++ entry = &htab->entries[index]; ++ if (!*entry) ++ goto empty_entry; ++ else if ((*entry)->entry_point == ptr) ++ return entry; ++ } ++ ++ empty_entry: ++ if (!insert) ++ return NULL; ++ ++ htab->n_elements++; ++ return entry; ++} ++ ++void * ++_dl_funcdesc_for (void *entry_point, void *got_value) ++{ ++ struct elf_resolve *tpnt = ((void**)got_value)[2]; ++ struct funcdesc_ht *ht = tpnt->funcdesc_ht; ++ struct funcdesc_value **entry; ++ ++ _dl_assert (got_value == tpnt->loadaddr.got_value); ++ ++ if (! ht) ++ { ++ ht = htab_create (); ++ if (! ht) ++ return (void*)-1; ++ tpnt->funcdesc_ht = ht; ++ } ++ ++ entry = htab_find_slot (ht, entry_point, 1); ++ if (*entry) ++ { ++ _dl_assert ((*entry)->entry_point == entry_point); ++ return _dl_stabilize_funcdesc (*entry); ++ } ++ ++ *entry = _dl_malloc (sizeof (struct funcdesc_value)); ++ (*entry)->entry_point = entry_point; ++ (*entry)->got_value = got_value; ++ ++ return _dl_stabilize_funcdesc (*entry); ++} ++ ++static __always_inline void const * ++_dl_lookup_address (void const *address) ++{ ++ struct elf_resolve *rpnt; ++ struct funcdesc_value const *fd; ++ ++ /* Make sure we don't make assumptions about its alignment. */ ++ __asm__ ("" : "+r" (address)); ++ ++ if ((Elf32_Addr)address & 7) ++ /* It's not a function descriptor. */ ++ return address; ++ ++ fd = (struct funcdesc_value const *)address; ++ ++ for (rpnt = _dl_loaded_modules; rpnt; rpnt = rpnt->next) ++ { ++ if (! rpnt->funcdesc_ht) ++ continue; ++ ++ if (fd->got_value != rpnt->loadaddr.got_value) ++ continue; ++ ++ address = htab_find_slot (rpnt->funcdesc_ht, (void*)fd->entry_point, 0); ++ ++ if (address && *(struct funcdesc_value *const*)address == fd) ++ { ++ address = (*(struct funcdesc_value *const*)address)->entry_point; ++ break; ++ } ++ else ++ address = fd; ++ } ++ ++ return address; ++} ++ ++void ++__dl_loadaddr_unmap (struct elf32_fdpic_loadaddr loadaddr, ++ struct funcdesc_ht *funcdesc_ht) ++{ ++ int i; ++ ++ for (i = 0; i < loadaddr.map->nsegs; i++) ++ { ++ struct elf32_fdpic_loadseg *segdata; ++ ssize_t offs; ++ segdata = loadaddr.map->segs + i; ++ ++#if 0 /* SRAM */ ++ /* FIXME: ++ A more cleaner way is to add type for struct elf32_fdpic_loadseg, ++ and release the memory according to the type. ++ Currently, we hardcode the memory address of L1 SRAM. */ ++ if ((segdata->addr & 0xff800000) == 0xff800000) ++ { ++ _dl_sram_free ((void *)segdata->addr); ++ continue; ++ } ++#endif ++ offs = (segdata->p_vaddr & ADDR_ALIGN); ++ _dl_munmap ((void*)segdata->addr - offs, ++ segdata->p_memsz + offs); ++ } ++ /* _dl_unmap is only called for dlopen()ed libraries, for which ++ calling free() is safe, or before we've completed the initial ++ relocation, in which case calling free() is probably pointless, ++ but still safe. */ ++ _dl_free (loadaddr.map); ++ if (funcdesc_ht) ++ htab_delete (funcdesc_ht); ++} ++ ++#if 0 /* XXX TODO will look at enabling this if we decide to add support for OCM ++ * code/data */ ++// OLD BLACKFIN CODE ++static __always_inline int ++__dl_is_special_segment (Elf32_Ehdr *epnt, ++ Elf32_Phdr *ppnt) ++{ ++ if (ppnt->p_type != PT_LOAD) ++ return 0; ++ ++ if ((epnt->e_flags & EF_BFIN_CODE_IN_L1) ++ && !(ppnt->p_flags & PF_W) ++ && (ppnt->p_flags & PF_X)) ++ return 1; ++ ++ if ((epnt->e_flags & EF_BFIN_DATA_IN_L1) ++ && (ppnt->p_flags & PF_W) ++ && !(ppnt->p_flags & PF_X)) ++ return 1; ++ ++ /* 0xff700000, 0xff800000, 0xff900000 and 0xffa00000 are also used in ++ GNU ld and linux kernel. They need to be keep synchronized. */ ++ if (ppnt->p_vaddr == 0xff700000 ++ || ppnt->p_vaddr == 0xff800000 ++ || ppnt->p_vaddr == 0xff900000 ++ || ppnt->p_vaddr == 0xffa00000) ++ return 1; ++ ++ return 0; ++} ++ ++static __always_inline char * ++__dl_map_segment (Elf32_Ehdr *epnt, ++ Elf32_Phdr *ppnt, ++ int infile, ++ int flags) ++{ ++ char *status, *tryaddr, *l1addr; ++ size_t size; ++ ++ ++ if (((epnt->e_flags & EF_BFIN_CODE_IN_L1) || ppnt->p_vaddr == 0xffa00000) ++ && !(ppnt->p_flags & PF_W) ++ && (ppnt->p_flags & PF_X)) { ++ status = (char *) _dl_mmap ++ (tryaddr = 0, ++ size = (ppnt->p_vaddr & ADDR_ALIGN) + ppnt->p_filesz, ++ LXFLAGS(ppnt->p_flags), ++ flags | MAP_EXECUTABLE | MAP_DENYWRITE, ++ infile, ppnt->p_offset & OFFS_ALIGN); ++ if (_dl_mmap_check_error(status) ++ || (tryaddr && tryaddr != status)) ++ return NULL; ++ l1addr = (char *) _dl_sram_alloc (ppnt->p_filesz, L1_INST_SRAM); ++ if (l1addr != NULL) ++ _dl_dma_memcpy (l1addr, status + (ppnt->p_vaddr & ADDR_ALIGN), ppnt->p_filesz); ++ _dl_munmap (status, size); ++ if (l1addr == NULL) ++ _dl_dprintf(2, "%s:%i: L1 allocation failed\n", _dl_progname, __LINE__); ++ return l1addr; ++ } ++ ++ if (((epnt->e_flags & EF_BFIN_DATA_IN_L1) ++ || ppnt->p_vaddr == 0xff700000 ++ || ppnt->p_vaddr == 0xff800000 ++ || ppnt->p_vaddr == 0xff900000) ++ && (ppnt->p_flags & PF_W) ++ && !(ppnt->p_flags & PF_X)) { ++ if (ppnt->p_vaddr == 0xff800000) ++ l1addr = (char *) _dl_sram_alloc (ppnt->p_memsz, L1_DATA_A_SRAM); ++ else if (ppnt->p_vaddr == 0xff900000) ++ l1addr = (char *) _dl_sram_alloc (ppnt->p_memsz, L1_DATA_B_SRAM); ++ else ++ l1addr = (char *) _dl_sram_alloc (ppnt->p_memsz, L1_DATA_SRAM); ++ if (l1addr == NULL) { ++ _dl_dprintf(2, "%s:%i: L1 allocation failed\n", _dl_progname, __LINE__); ++ } else { ++ if (_DL_PREAD (infile, l1addr, ppnt->p_filesz, ppnt->p_offset) != ppnt->p_filesz) { ++ _dl_sram_free (l1addr); ++ return NULL; ++ } ++ if (ppnt->p_filesz < ppnt->p_memsz) ++ _dl_memset (l1addr + ppnt->p_filesz, 0, ppnt->p_memsz - ppnt->p_filesz); ++ } ++ return l1addr; ++ } ++ return 0; ++} ++#endif +--- /dev/null ++++ b/ldso/ldso/ubicom32/dl-startup.h +@@ -0,0 +1,232 @@ ++/* ++ Copyright (C) 2009 Ubicom, Inc. ++ Copyright (C) 2003 Red Hat, Inc. ++ Contributed by Alexandre Oliva ++ ++This file is part of uClibc. ++ ++uClibc is free software; you can redistribute it and/or modify it ++under the terms of the GNU Lesser General Public License as ++published by the Free Software Foundation; either version 2.1 of the ++License, or (at your option) any later version. ++ ++uClibc 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 ++Library General Public License for more details. ++ ++You should have received a copy of the GNU Lesser General Public ++License along with uClibc; see the file COPYING.LIB. If not, write to ++the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, ++USA. */ ++ ++/* Any assembly language/system dependent hacks needed to setup ++ * boot1.c so it will work as expected and cope with whatever platform ++ * specific wierdness is needed for this architecture. ++ ++ * We override the default _dl_boot function, and replace it with a ++ * bit of asm. Then call the real _dl_boot function, which is now ++ * named _dl_boot2. */ ++ ++/* At program start-up, p0 contains a pointer to a ++ elf32_fdpic_loadmap that describes how the executable was loaded ++ into memory. p1 contains a pointer to the interpreter (our!) ++ loadmap, if there is an interpreter, or 0 if we're being run as an ++ executable. p2 holds a pointer to the interpreter's dynamic ++ section, if there is an interpreter, or to the executable's dynamic ++ section, otherwise. If the executable is not dynamic, gr18 is 0. ++ ++ We rely on the fact that the linker adds a pointer to the ++ _GLOBAL_OFFSET_TABLE_ as the last ROFIXUP entry, and that ++ __self_reloc returns the relocated pointer to us, so that we can ++ use this value to initialize the PIC register. */ ++ ++ ++/* ++ * _dl_boot is the entry point for ldso. ++ * ++ * The kernel leaves the main apps args on the stack (positive offsets), and ++ * communicates the load maps as follows ++ * ++ * - d1 is set to the exec_map_addr (struct elf32_fdpic_loadmap *), which is the ++ * current state of the mapped application. ++ * ++ * - d2 is set to interp_map_addr (struct elf32_fdpic_loadmap *), which is use ++ * by ldso to relocate itself. ++ * ++ * - d3 is dynamic_addr which as far as I can tell is the stack pointer. ++ * ++ * - a1 is set to zero and will later be initialised to ldso _dl_fini funcdesc ++ */ ++ ++__asm__( ++ " .text \n\t" ++ " .global _start \n\t" ++ " .type _start,@function \n\t" ++ "_start:\n\t" ++ /* ++ * Jump to .Lcall storing the location .Lcall in a5 ++ */ ++ " call a5, .Lcall \n\t" ++ ".Lcall: \n\t" ++ /* ++ * Reserve and Push inputs to stack. ++ * 32 byte stack layout as follows ++ * offset 0 exec_map_addr ++ * 4 interp_map_addr ++ * 8 dynamic_addr ++ * 12 not used ++ * 16 dl_main_funcdesc structure for _dl_boot ++ * (12 bytes sizeof funcdesc_value) ++ * 28 reserved ++ * 32 start of &original stack ++ */ ++ " pdec sp, 32(sp); reserve stack space \n\t" ++ " move.4 0(sp), d1 ; exec_map_addr \n\t" ++ " move.4 4(sp), d2 ; interp_map_addr \n\t" ++ " move.4 8(sp), d3; dynamic_addr \n\t" ++ ++ /* ++ * Load linker version of .Lcall in to d0 ++ */ ++ " moveai a3, #%hi(.Lcall) \n\t" ++ " lea.1 d0, %lo(.Lcall)(a3) \n\t" ++ ++ /* ++ * Determine the offset from loaded .Lcall and put it in d0. ++ */ ++ " sub.4 d0, a5, d0 \n\t" ++ ++ /* ++ * Load linker version of __ROFIXUP_LIST__ and __ROFIXUP_END__ in to d1 ++ * and d2. ++ */ ++ " moveai a3, #%hi(__ROFIXUP_LIST__) \n\t" ++ " lea.1 d1, %lo(__ROFIXUP_LIST__)(a3) \n\t" ++ " moveai a3, #%hi(__ROFIXUP_END__) \n\t" ++ " lea.1 d2, %lo(__ROFIXUP_END__)(a3) \n\t" ++ /* ++ * Use offset determined above to find the loaded versions. ++ */ ++ " add.4 d1, d1, d0 \n\t" ++ " add.4 d2, d2, d0 \n\t" ++ ++ /* ++ * Load interp_map_addr into d0, if interp_map_addr is null use ++ * exec_map_addr. ++ */ ++ " move.4 d0, 4(sp) ; load interp_map_addr \n\t" ++ " cmpi d0, #0 \n\t" ++ " jmpne.f 1f \n\t" ++ " move.4 d0, 0(sp) ; load exec_map_addr \n\t" ++ ++ /* ++ * call __self_reloc(map, void ***p, void ***e) ++ * it returns the the GOT in d0. ++ */ ++ "1: call a5, __self_reloc ; returns a0 in d0 \n\t" ++ " move.4 a0, d0 ; set GOT \n\t" ++ " move.4 a2, d0 ; save GOT \n\t" ++ ++ /* ++ * now setup to call ++ * _dl_start (Elf32_Addr dl_boot_got_pointer, (d0) ++ * struct elf32_fdpic_loadmap *dl_boot_progmap, (d1) ++ * struct elf32_fdpic_loadmap *dl_boot_ldsomap, (d2) ++ * Elf32_Dyn *dl_boot_ldso_dyn_pointer, (d3) ++ * struct funcdesc_value *dl_main_funcdesc, (d4) ++ * unsigned long args (d5) ++ * ++ * NOTE: for dl_main_funcdesc we reserved space on the stack for this ++ * structure. ++ */ ++ " move.4 d1, 0(sp) ; d1 = exec_map_addr \n\t" ++ " move.4 d2, 4(sp) ; d2 = interp_map_addr \n\t" ++ " move.4 d3, 8(sp) ; d3 = dynamic_addr \n\t" ++ " lea.1 d4, 16(sp) ; d4 = &dl_main_funcdesc \n\t" ++ " lea.1 d5, 32(sp) ; d5 = original stack ptr (args)\n\t" ++ " call a5, _dl_start \n\t" ++ ++ /* ++ * Setup to call the main entry point, starting with passing our FINI ++ * ptr() to the user in a1 (remember we saved the got in a2) ++ */ ++ " movei d15, #%got_funcdesc_lo(_dl_fini) \n\t" ++ " move.4 a1, (a2, d15) \n\t" ++ ++ /* ++ * restore the load map from the kernel. ++ */ ++ " move.4 d1, 0(sp) ; restore exec_map_addr \n\t" ++ " move.4 d2, 4(sp) ; restore interp_map_addr \n\t" ++ " move.4 d3, 8(sp) ; restore dynamic_addr \n\t" ++ ++ /* ++ * _dl_start returned the main apps entry point in dl_main_funcdesc, ++ * load that information now. ++ */ ++ " move.4 a5, 16(sp) ; a5 = dl_main_funcdesc.entry_point \n\t" ++ " move.4 a0, 20(sp) ; a0 = dl_main_funcdesc.got_value \n\t" ++ " lea.1 sp, 32(sp); restore original stack ptr (args) \n\t" ++ " calli a5, 0(a5) \n\t" ++ " bkpt -1; should never get here \n\t" ++ " .size _start, . - _start \n\t" ++); ++ ++#undef DL_START ++#define DL_START(X) \ ++static void __attribute__ ((used)) \ ++_dl_start (Elf32_Addr dl_boot_got_pointer, \ ++ struct elf32_fdpic_loadmap *dl_boot_progmap, \ ++ struct elf32_fdpic_loadmap *dl_boot_ldsomap, \ ++ Elf32_Dyn *dl_boot_ldso_dyn_pointer, \ ++ struct funcdesc_value *dl_main_funcdesc, \ ++ X) ++ ++struct elf32_fdpic_loadmap; ++ ++/* ++ * Get a pointer to the argv array. On many platforms this can be just ++ * the address if the first argument, on other platforms we need to ++ * do something a little more subtle here. ++ */ ++#define GET_ARGV(ARGVP, ARGS) ARGVP = (((unsigned long*) ARGS) + 1) ++ ++/* ++ * Here is a macro to perform a relocation. This is only used when ++ * bootstrapping the dynamic loader. RELP is the relocation that we ++ * are performing, REL is the pointer to the address we are relocating. ++ * SYMBOL is the symbol involved in the relocation, and LOAD is the ++ * load address. ++ */ ++#define PERFORM_BOOTSTRAP_RELOC(RELP,REL,SYMBOL,LOAD,SYMTAB) \ ++ switch(ELF32_R_TYPE((RELP)->r_info)){ \ ++ case R_UBICOM32_32: \ ++ *(REL) += (SYMBOL); \ ++ break; \ ++ case R_UBICOM32_FUNCDESC_VALUE: \ ++ { \ ++ struct funcdesc_value fv = { \ ++ (void*)((SYMBOL) + *(REL)), \ ++ (LOAD).got_value \ ++ }; \ ++ *(struct funcdesc_value volatile *)(REL) = fv; \ ++ break; \ ++ } \ ++ default: \ ++ _dl_exit(1); \ ++ } ++ ++/* ++ * Transfer control to the user's application, once the dynamic loader ++ * is done. We return the address of the function's entry point to ++ * _dl_boot, see boot1_arch.h. ++ */ ++#define START() do { \ ++ struct elf_resolve *exec_mod = _dl_loaded_modules; \ ++ dl_main_funcdesc->entry_point = _dl_elf_main; \ ++ while (exec_mod->libtype != elf_executable) \ ++ exec_mod = exec_mod->next; \ ++ dl_main_funcdesc->got_value = exec_mod->loadaddr.got_value; \ ++ return; \ ++} while (0) +--- /dev/null ++++ b/ldso/ldso/ubicom32/dl-syscalls.h +@@ -0,0 +1,206 @@ ++/* Copyright (C) 2003, 2004 Red Hat, Inc. ++ Contributed by Alexandre Oliva ++ ++This file is part of uClibc. ++ ++uClibc is free software; you can redistribute it and/or modify it ++under the terms of the GNU Lesser General Public License as ++published by the Free Software Foundation; either version 2.1 of the ++License, or (at your option) any later version. ++ ++uClibc 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 ++Library General Public License for more details. ++ ++You should have received a copy of the GNU Lesser General Public ++License along with uClibc; see the file COPYING.LIB. If not, write to ++the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, ++USA. */ ++ ++/* We can't use the real errno in ldso, since it has not yet ++ * been dynamicly linked in yet. */ ++#include "sys/syscall.h" ++extern int _dl_errno; ++#undef __set_errno ++#define __set_errno(X) {(_dl_errno) = (X);} ++#include ++ ++/* The code below is extracted from libc/sysdeps/linux/frv/_mmap.c */ ++ ++#if defined(DYNAMIC_LOADER_IN_SIMULATOR) && DYNAMIC_LOADER_IN_SIMULATOR ++#define __NR___syscall_mmap2 __NR_mmap2 ++static __inline__ _syscall6(__ptr_t, __syscall_mmap2, __ptr_t, addr, ++ size_t, len, int, prot, int, flags, int, fd, off_t, offset); ++ ++/* Make sure we don't get another definition of _dl_mmap from the ++ machine-independent code. */ ++#undef __NR_mmap ++#undef __NR_mmap2 ++ ++/* This is always 12, even on architectures where PAGE_SHIFT != 12. */ ++# ifndef MMAP2_PAGE_SHIFT ++# define MMAP2_PAGE_SHIFT 12 ++# endif ++ ++#include /* for PAGE_SIZE */ ++static __always_inline void *_dl_memset(void*,int,size_t); ++static __always_inline ssize_t _dl_pread(int fd, void *buf, size_t count, off_t offset); ++ ++static __ptr_t ++_dl_mmap(__ptr_t addr, size_t len, int prot, int flags, int fd, __off_t offset) ++{ ++ size_t plen = (len + PAGE_SIZE - 1) & -PAGE_SIZE; ++ ++/* This is a hack to enable the dynamic loader to run within a ++ simulator that doesn't support mmap, with a number of very ugly ++ tricks. Also, it's not as useful as it sounds, since only dynamic ++ executables without DT_NEEDED dependencies can be run. AFAIK, they ++ can only be created with -pie. This trick suffices to enable the ++ dynamic loader to obtain a blank page that it maps early in the ++ bootstrap. */ ++ if ((flags & MAP_FIXED) == 0) ++ { ++ void *_dl_mmap_base = 0; ++ __ptr_t *ret = 0; ++ ++ if (! _dl_mmap_base) ++ { ++ void *stack; ++ __asm__ ("mov sp, %0" : "=r" (stack)); ++ _dl_mmap_base = (void *)(((long)stack + 2 * PAGE_SIZE) & -PAGE_SIZE); ++ retry: ++ if (((void **)_dl_mmap_base)[0] == _dl_mmap_base ++ && ((void **)_dl_mmap_base)[1023] == _dl_mmap_base ++ && (((void **)_dl_mmap_base)[177] ++ == ((void **)_dl_mmap_base)[771])) ++ { ++ while (((void**)_dl_mmap_base)[177]) ++ { ++ _dl_mmap_base = ((void**)_dl_mmap_base)[177]; ++ if (!(((void **)_dl_mmap_base)[0] == _dl_mmap_base ++ && ((void **)_dl_mmap_base)[1023] == _dl_mmap_base ++ && (((void **)_dl_mmap_base)[177] ++ == ((void**)_dl_mmap_base)[771]))) ++ ((void(*)())0)(); ++ } ++ } ++ else ++ { ++ int i; ++ for (i = 0; i < (int)PAGE_SIZE; i++) ++ if (*(char*)(_dl_mmap_base + i)) ++ break; ++ if (i != PAGE_SIZE) ++ { ++ _dl_mmap_base = (void*)((long)_dl_mmap_base + PAGE_SIZE); ++ goto retry; ++ } ++ ((void**)_dl_mmap_base)[-1] = ++ ((void**)_dl_mmap_base)[0] = ++ ((void**)_dl_mmap_base)[1023] = ++ _dl_mmap_base; ++ } ++ } ++ ++ if (_dl_mmap_base) ++ { ++ if (!(((void **)_dl_mmap_base)[0] == _dl_mmap_base ++ && ((void **)_dl_mmap_base)[1023] == _dl_mmap_base ++ && (((void **)_dl_mmap_base)[177] ++ == ((void**)_dl_mmap_base)[771]))) ++ ((void(*)())0)(); ++ ret = (__ptr_t)((char*)_dl_mmap_base + PAGE_SIZE); ++ _dl_mmap_base = ++ ((void**)_dl_mmap_base)[177] = ++ ((void**)_dl_mmap_base)[771] = ++ (char*)_dl_mmap_base + plen + PAGE_SIZE; ++ ((void**)_dl_mmap_base)[0] = ++ ((void**)_dl_mmap_base)[1023] = ++ _dl_mmap_base; ++ } ++ ++ if ((flags & MAP_ANONYMOUS) != 0) ++ { ++ _dl_memset (ret, 0, plen); ++ return ret; ++ } ++ ++ flags |= MAP_FIXED; ++ addr = ret; ++ } ++ if (offset & ((1 << MMAP2_PAGE_SHIFT) - 1)) { ++#if 0 ++ __set_errno (EINVAL); ++#endif ++ return MAP_FAILED; ++ } ++ if ((flags & MAP_FIXED) != 0) ++ { ++ if (_dl_pread(fd, addr, len, offset) != (ssize_t)len) ++ return (void*)MAP_FAILED; ++ if (plen != len) ++ _dl_memset (addr + len, 0, plen - len); ++ return addr; ++ } ++ return(__syscall_mmap2(addr, len, prot, flags, fd, (off_t) (offset >> MMAP2_PAGE_SHIFT))); ++} ++#endif ++ ++#ifdef __NR_pread64 ++#ifdef DYNAMIC_LOADER_IN_SIMULATOR ++#include ++ ++#define __NR___syscall_lseek __NR_lseek ++static __always_inline unsigned long _dl_read(int fd, const void *buf, unsigned long count); ++ ++static __always_inline _syscall3(__off_t, __syscall_lseek, int, fd, __off_t, offset, ++ int, whence); ++static __always_inline ssize_t ++_dl_pread(int fd, void *buf, size_t count, off_t offset) ++{ ++ __off_t orig = __syscall_lseek (fd, 0, SEEK_CUR); ++ ssize_t ret; ++ ++ if (orig == -1) ++ return -1; ++ ++ if (__syscall_lseek (fd, offset, SEEK_SET) != offset) ++ return -1; ++ ++ ret = _dl_read (fd, buf, count); ++ ++ if (__syscall_lseek (fd, orig, SEEK_SET) != orig) ++ ((void(*)())0)(); ++ ++ return ret; ++} ++#else ++#define __NR___syscall_pread __NR_pread64 ++static __always_inline _syscall5(ssize_t, __syscall_pread, int, fd, void *, buf, ++ size_t, count, off_t, offset_hi, off_t, offset_lo); ++ ++static __always_inline ssize_t ++_dl_pread(int fd, void *buf, size_t count, off_t offset) ++{ ++ return(__syscall_pread(fd,buf,count,__LONG_LONG_PAIR (offset >> 31, offset))); ++} ++#endif ++#endif ++ ++#ifdef __NR_sram_alloc ++#define __NR__dl_sram_alloc __NR_sram_alloc ++static __always_inline _syscall2(__ptr_t, _dl_sram_alloc, ++ size_t, len, unsigned long, flags); ++#endif ++ ++#ifdef __NR_sram_free ++#define __NR__dl_sram_free __NR_sram_free ++static __always_inline _syscall1(int, _dl_sram_free, __ptr_t, addr); ++#endif ++ ++#ifdef __NR_dma_memcpy ++#define __NR__dl_dma_memcpy __NR_dma_memcpy ++static __always_inline _syscall3(__ptr_t, _dl_dma_memcpy, ++ __ptr_t, dest, __ptr_t, src, size_t, len); ++#endif +--- /dev/null ++++ b/ldso/ldso/ubicom32/dl-sysdep.h +@@ -0,0 +1,243 @@ ++ /* Copyright (C) 2003, 2004 Red Hat, Inc. ++ Contributed by Alexandre Oliva ++ Based on ../i386/dl-sysdep.h ++ ++This file is part of uClibc. ++ ++uClibc is free software; you can redistribute it and/or modify it ++under the terms of the GNU Lesser General Public License as ++published by the Free Software Foundation; either version 2.1 of the ++License, or (at your option) any later version. ++ ++uClibc 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 ++Library General Public License for more details. ++ ++You should have received a copy of the GNU Lesser General Public ++License along with uClibc; see the file COPYING.LIB. If not, write to ++the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, ++USA. */ ++ ++/* ++ * Various assembly language/system dependent hacks that are required ++ * so that we can minimize the amount of platform specific code. ++ */ ++ ++/* ++ * Define this if the system uses RELOCA. ++ */ ++#undef ELF_USES_RELOCA ++ ++/* JMPREL relocs are inside the DT_RELA table. */ ++#define ELF_MACHINE_PLTREL_OVERLAP ++ ++#define DL_NO_COPY_RELOCS ++ ++#define HAVE_DL_INLINES_H ++ ++/* ++ * Initialization sequence for a GOT. Copy the resolver function ++ * descriptor and the pointer to the elf_resolve/link_map data ++ * structure. Initialize the got_value in the module while at that. ++ */ ++#define INIT_GOT(GOT_BASE,MODULE) \ ++{ \ ++ (MODULE)->loadaddr.got_value = (GOT_BASE); \ ++ GOT_BASE[0] = ((unsigned long *)&_dl_linux_resolve)[0]; \ ++ GOT_BASE[1] = ((unsigned long *)&_dl_linux_resolve)[1]; \ ++ GOT_BASE[2] = (unsigned long) MODULE; \ ++} ++ ++/* Here we define the magic numbers that this dynamic loader should accept */ ++#define MAGIC1 EM_UBICOM32 ++#undef MAGIC2 ++ ++/* Used for error messages */ ++#define ELF_TARGET "UBICOM32" ++ ++struct elf_resolve; ++ ++struct funcdesc_value ++{ ++ void *entry_point; ++ void *got_value; ++/*int relocation; not sure if this required, but it does exist */ ++}; ++ ++extern int _dl_linux_resolve(void) __attribute__((__visibility__("hidden"))); ++extern struct funcdesc_value volatile *__attribute__((__visibility__("hidden"))) ++ _dl_linux_resolver (struct elf_resolve *tpnt, int reloc_entry); ++ ++/* 4KiB page alignment. Should perhaps be made dynamic using ++ getpagesize(), based on AT_PAGESZ from auxvt? */ ++#define PAGE_ALIGN 0xfffff000 ++#define ADDR_ALIGN 0xfff ++#define OFFS_ALIGN 0x7ffff000 ++ ++struct funcdesc_ht; ++ ++/* ++ * This asm does a quick relcation of string S (which is stored in the text ++ * section as thats all we can use ++ */ ++#undef SEND_EARLY_STDERR ++#define SEND_EARLY_STDERR(S) \ ++do { \ ++ static const char __attribute__((section(".text"))) __s[] = (S); \ ++ const char *__p, *__scratch; \ ++ __asm__ ( \ ++ " call a3, 1f; \n\t" \ ++ "1: movei %0, #%%got_lo(1b) \n\t" \ ++ " move.4 %0, (%3, %0) \n\t" \ ++ " sub.4 %1, a3, %0; \n\t" \ ++ " add.4 %1, %1, %2; \n\t" \ ++ : "=&d" (__scratch), "=&d" (__p) \ ++ : "d" (__s), "a" (dl_boot_got_pointer) \ ++ : "a3", "a4", "d15"); \ ++ SEND_STDERR (__p); \ ++ { int __t; \ ++ for (__t = 0; __t < 0x100000; __t++) __asm__ __volatile__ (""); } \ ++} while (0) ++ ++#define DL_LOADADDR_TYPE struct elf32_fdpic_loadaddr ++ ++#define DL_RELOC_ADDR(LOADADDR, ADDR) \ ++ ((ElfW(Addr))__reloc_pointer ((void*)(ADDR), (LOADADDR).map)) ++ ++#define DL_ADDR_TO_FUNC_PTR(ADDR, LOADADDR) \ ++ ((void(*)(void)) _dl_funcdesc_for ((void*)(ADDR), (LOADADDR).got_value)) ++ ++#define _dl_stabilize_funcdesc(val) \ ++ ({ __asm__ ("" : "+m" (*(val))); (val); }) ++ ++#define DL_CALL_FUNC_AT_ADDR(ADDR, LOADADDR, SIGNATURE, ...) \ ++ ({ struct funcdesc_value fd = { (void*)(ADDR), (LOADADDR).got_value }; \ ++ void (*pf)(void) = (void*) _dl_stabilize_funcdesc (&fd); \ ++ (* SIGNATURE pf)(__VA_ARGS__); }) ++ ++#define DL_INIT_LOADADDR_BOOT(LOADADDR, BASEADDR) \ ++ (__dl_init_loadaddr_map (&(LOADADDR), dl_boot_got_pointer, \ ++ dl_boot_ldsomap ?: dl_boot_progmap)) ++ ++#define DL_INIT_LOADADDR_PROG(LOADADDR, BASEADDR) \ ++ (__dl_init_loadaddr_map (&(LOADADDR), 0, dl_boot_progmap)) ++ ++#define DL_INIT_LOADADDR_EXTRA_DECLS \ ++ int dl_init_loadaddr_load_count; ++#define DL_INIT_LOADADDR(LOADADDR, BASEADDR, PHDR, PHDRCNT) \ ++ (dl_init_loadaddr_load_count = \ ++ __dl_init_loadaddr (&(LOADADDR), (PHDR), (PHDRCNT))) ++#define DL_INIT_LOADADDR_HDR(LOADADDR, ADDR, PHDR) \ ++ (__dl_init_loadaddr_hdr ((LOADADDR), (ADDR), (PHDR), \ ++ dl_init_loadaddr_load_count)) ++#define DL_LOADADDR_UNMAP(LOADADDR, LEN) \ ++ (__dl_loadaddr_unmap ((LOADADDR), (NULL))) ++#define DL_LIB_UNMAP(LIB, LEN) \ ++ (__dl_loadaddr_unmap ((LIB)->loadaddr, (LIB)->funcdesc_ht)) ++#define DL_LOADADDR_BASE(LOADADDR) \ ++ ((LOADADDR).got_value) ++ ++/* This is called from dladdr(), such that we map a function ++ descriptor's address to the function's entry point before trying to ++ find in which library it's defined. */ ++#define DL_LOOKUP_ADDRESS(ADDRESS) (_dl_lookup_address (ADDRESS)) ++ ++#define DL_ADDR_IN_LOADADDR(ADDR, TPNT, TFROM) \ ++ (! (TFROM) && __dl_addr_in_loadaddr ((void*)(ADDR), (TPNT)->loadaddr)) ++ ++/* ++ * Compute the GOT address. On several platforms, we use assembly ++ * here. on FR-V FDPIC, there's no way to compute the GOT address, ++ * since the offset between text and data is not fixed, so we arrange ++ * for the assembly _dl_boot to pass this value as an argument to ++ * _dl_boot. */ ++#define DL_BOOT_COMPUTE_GOT(got) ((got) = dl_boot_got_pointer) ++ ++#define DL_BOOT_COMPUTE_DYN(dpnt, got, load_addr) \ ++ ((dpnt) = dl_boot_ldso_dyn_pointer) ++ ++/* We only support loading FDPIC independently-relocatable shared ++ libraries. It probably wouldn't be too hard to support loading ++ shared libraries that require relocation by the same amount, but we ++ don't know that they exist or would be useful, and the dynamic ++ loader code could leak the whole-library map unless we keeping a ++ bit more state for DL_LOADADDR_UNMAP and DL_LIB_UNMAP, so let's ++ keep things simple for now. */ ++#define DL_CHECK_LIB_TYPE(epnt, piclib, _dl_progname, libname) \ ++do \ ++{ \ ++ if (((epnt)->e_flags & EF_UBICOM32_FDPIC) && ! ((epnt)->e_flags & EF_UBICOM32_PIC)) \ ++ (piclib) = 2; \ ++ else \ ++ { \ ++ _dl_internal_error_number = LD_ERROR_NOTDYN; \ ++ _dl_dprintf(2, "%s: '%s' is not an FDPIC shared library" \ ++ "\n", (_dl_progname), (libname)); \ ++ _dl_close(infile); \ ++ return NULL; \ ++ } \ ++\ ++} \ ++while (0) ++ ++/* We want want to apply all relocations in the interpreter during ++ bootstrap. Because of this, we have to skip the interpreter ++ relocations in _dl_parse_relocation_information(), see ++ elfinterp.c. */ ++#define DL_SKIP_BOOTSTRAP_RELOC(SYMTAB, INDEX, STRTAB) 0 ++ ++#ifdef __NR_pread64 ++#define _DL_PREAD(FD, BUF, SIZE, OFFSET) \ ++ (_dl_pread((FD), (BUF), (SIZE), (OFFSET))) ++#endif ++ ++/* We want to return to dlsym() a function descriptor if the symbol ++ turns out to be a function. */ ++#define DL_FIND_HASH_VALUE(TPNT, TYPE_CLASS, SYM) \ ++ (((TYPE_CLASS) & ELF_RTYPE_CLASS_DLSYM) \ ++ && ELF32_ST_TYPE((SYM)->st_info) == STT_FUNC \ ++ ? _dl_funcdesc_for ((void *)DL_RELOC_ADDR ((TPNT)->loadaddr, (SYM)->st_value), \ ++ (TPNT)->loadaddr.got_value) \ ++ : DL_RELOC_ADDR ((TPNT)->loadaddr, (SYM)->st_value)) ++ ++#if 0 /* XXX TODO will look at enabling this if we decide to add support for OCM ++ * code/data */ ++ ++#define DL_IS_SPECIAL_SEGMENT(EPNT, PPNT) \ ++ __dl_is_special_segment(EPNT, PPNT) ++#define DL_MAP_SEGMENT(EPNT, PPNT, INFILE, FLAGS) \ ++ __dl_map_segment (EPNT, PPNT, INFILE, FLAGS) ++ ++#endif ++ ++ ++#define DL_GET_READY_TO_RUN_EXTRA_PARMS \ ++ , struct elf32_fdpic_loadmap *dl_boot_progmap, Elf32_Addr dl_boot_got_pointer ++#define DL_GET_READY_TO_RUN_EXTRA_ARGS \ ++ , dl_boot_progmap, dl_boot_got_pointer ++ ++ ++#ifdef __USE_GNU ++# include ++#else ++# define __USE_GNU ++# include ++# undef __USE_GNU ++#endif ++ ++#include ++static __inline__ void ++elf_machine_relative (DL_LOADADDR_TYPE load_off, const Elf32_Addr rel_addr, ++ Elf32_Word relative_count) ++{ ++#if 0 ++ Elf32_Rel * rpnt = (void *) rel_addr; ++ --rpnt; ++ do { ++ Elf32_Addr *const reloc_addr = (void *) (load_off + (++rpnt)->r_offset); ++ ++ *reloc_addr = DL_RELOC_ADDR (load_off, *reloc_addr); ++ } while (--relative_count); ++#endif ++} +--- /dev/null ++++ b/ldso/ldso/ubicom32/elfinterp.c +@@ -0,0 +1,366 @@ ++/* Blackfin ELF shared library loader suppport ++ Copyright (C) 2003, 2004 Red Hat, Inc. ++ Contributed by Alexandre Oliva ++ Lots of code copied from ../i386/elfinterp.c, so: ++ Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald, ++ David Engel, Hongjiu Lu and Mitch D'Souza ++ Copyright (C) 2001-2002, Erik Andersen ++ All rights reserved. ++ ++This file is part of uClibc. ++ ++uClibc is free software; you can redistribute it and/or modify it ++under the terms of the GNU Lesser General Public License as ++published by the Free Software Foundation; either version 2.1 of the ++License, or (at your option) any later version. ++ ++uClibc 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 ++Library General Public License for more details. ++ ++You should have received a copy of the GNU Lesser General Public ++License along with uClibc; see the file COPYING.LIB. If not, write to ++the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, ++USA. */ ++ ++#include /* __attribute_used__ */ ++ ++/* Program to load an ELF binary on a linux system, and run it. ++ References to symbols in sharable libraries can be resolved by either ++ an ELF sharable library or a linux style of shared library. */ ++ ++/* Disclaimer: I have never seen any AT&T source code for SVr4, nor have ++ I ever taken any courses on internals. This program was developed using ++ information available through the book "UNIX SYSTEM V RELEASE 4, ++ Programmers guide: Ansi C and Programming Support Tools", which did ++ a more than adequate job of explaining everything required to get this ++ working. */ ++extern int _dl_ubicom32_resolve_pending(void) __attribute__((__visibility__("hidden"))); ++ ++struct funcdesc_value volatile *__attribute__((__visibility__("hidden"))) ++_dl_linux_resolver (struct elf_resolve *tpnt, int reloc_entry) ++{ ++ int reloc_type; ++ ELF_RELOC *this_reloc; ++ char *strtab; ++ ElfW(Sym) *symtab; ++ int symtab_index; ++ char *rel_addr; ++ struct elf_resolve *new_tpnt; ++ char *new_addr; ++ struct funcdesc_value funcval; ++ struct funcdesc_value volatile *got_entry; ++ char *symname; ++ ++ rel_addr = (char *)tpnt->dynamic_info[DT_JMPREL]; ++ ++ this_reloc = (ELF_RELOC *)(intptr_t)(rel_addr + reloc_entry); ++ reloc_type = ELF_R_TYPE(this_reloc->r_info); ++ symtab_index = ELF_R_SYM(this_reloc->r_info); ++ ++ symtab = (Elf32_Sym *) tpnt->dynamic_info[DT_SYMTAB]; ++ strtab = (char *) tpnt->dynamic_info[DT_STRTAB]; ++ symname= strtab + symtab[symtab_index].st_name; ++ ++ if (reloc_type != R_UBICOM32_FUNCDESC_VALUE) { ++ _dl_dprintf(2, "%s: Incorrect relocation type in jump relocations\n", ++ _dl_progname); ++ _dl_exit(1); ++ } ++ ++ /* Address of GOT entry fix up */ ++ got_entry = (struct funcdesc_value *) DL_RELOC_ADDR(tpnt->loadaddr, this_reloc->r_offset); ++ ++ /* Get the address to be used to fill in the GOT entry. */ ++ new_addr = _dl_lookup_hash(symname, tpnt->symbol_scope, NULL, 0, &new_tpnt); ++ if (!new_addr) { ++ new_addr = _dl_lookup_hash(symname, NULL, NULL, 0, &new_tpnt); ++ if (!new_addr) { ++ _dl_dprintf(2, "%s: can't resolve symbol '%s'\n", ++ _dl_progname, symname); ++ _dl_exit(1); ++ } ++ } ++ ++ funcval.entry_point = new_addr; ++ funcval.got_value = new_tpnt->loadaddr.got_value; ++ ++#if defined (__SUPPORT_LD_DEBUG__) ++ if (_dl_debug_bindings) { ++ _dl_dprintf(_dl_debug_file, "\nresolve function: %s", symname); ++ if (_dl_debug_detail) ++ _dl_dprintf(_dl_debug_file, ++ "\n\tpatched (%x,%x) ==> (%x,%x) @ %x\n", ++ got_entry->entry_point, got_entry->got_value, ++ funcval.entry_point, funcval.got_value, ++ got_entry); ++ } ++ if (1 || !_dl_debug_nofixups) { ++ got_entry->entry_point = ((unsigned long *)&_dl_ubicom32_resolve_pending)[0]; ++ got_entry->got_value = funcval.got_value; ++ got_entry->entry_point = funcval.entry_point; ++ } ++#else ++ /* ++ * initially set the entry point to resolve pending before starting ++ * the update. This has the effect of putting all other requests in a ++ * holding pattern until the resolution is completed. ++ */ ++ got_entry->entry_point = ((unsigned long *)&_dl_ubicom32_resolve_pending)[0]; ++ got_entry->got_value = funcval.got_value; ++ got_entry->entry_point = funcval.entry_point; ++#endif ++ ++ return got_entry; ++} ++ ++static int ++_dl_parse(struct elf_resolve *tpnt, struct dyn_elf *scope, ++ unsigned long rel_addr, unsigned long rel_size, ++ int (*reloc_fnc) (struct elf_resolve *tpnt, struct dyn_elf *scope, ++ ELF_RELOC *rpnt, ElfW(Sym) *symtab, char *strtab)) ++{ ++ unsigned int i; ++ char *strtab; ++ ElfW(Sym) *symtab; ++ ELF_RELOC *rpnt; ++ int symtab_index; ++ ++ /* Now parse the relocation information */ ++ rpnt = (ELF_RELOC *) rel_addr; ++ rel_size = rel_size / sizeof(ELF_RELOC); ++ ++ symtab = (ElfW(Sym) *) tpnt->dynamic_info[DT_SYMTAB]; ++ strtab = (char *) tpnt->dynamic_info[DT_STRTAB]; ++ ++ for (i = 0; i < rel_size; i++, rpnt++) { ++ int res; ++ ++ symtab_index = ELF_R_SYM(rpnt->r_info); ++ debug_sym(symtab,strtab,symtab_index); ++ debug_reloc(symtab,strtab,rpnt); ++ ++ res = reloc_fnc (tpnt, scope, rpnt, symtab, strtab); ++ ++ if (res==0) continue; ++ ++ _dl_dprintf(2, "\n%s: ",_dl_progname); ++ ++ if (symtab_index) ++ _dl_dprintf(2, "symbol '%s': ", strtab + symtab[symtab_index].st_name); ++ ++ if (res <0) { ++ int reloc_type = ELF_R_TYPE(rpnt->r_info); ++#if defined (__SUPPORT_LD_DEBUG__) ++ _dl_dprintf(2, "can't handle reloc type %s\n ", _dl_reltypes(reloc_type)); ++#else ++ _dl_dprintf(2, "can't handle reloc type %x\n", reloc_type); ++#endif ++ _dl_exit(-res); ++ } else if (res >0) { ++ _dl_dprintf(2, "can't resolve symbol\n"); ++ return res; ++ } ++ } ++ return 0; ++} ++ ++static int ++_dl_do_reloc (struct elf_resolve *tpnt,struct dyn_elf *scope, ++ ELF_RELOC *rpnt, ElfW(Sym) *symtab, char *strtab) ++{ ++ int reloc_type; ++ int symtab_index; ++ char *symname; ++ unsigned long reloc_value = 0, *reloc_addr; ++ struct { unsigned long v; } __attribute__((__packed__)) ++ *reloc_addr_packed; ++ unsigned long symbol_addr; ++ struct elf_resolve *symbol_tpnt; ++ struct funcdesc_value funcval; ++#if defined (__SUPPORT_LD_DEBUG__) ++ unsigned long old_val; ++#endif ++ ++ reloc_addr = (unsigned long *) DL_RELOC_ADDR(tpnt->loadaddr, rpnt->r_offset); ++ __asm__ ("" : "=r" (reloc_addr_packed) : "0" (reloc_addr)); ++ reloc_type = ELF_R_TYPE(rpnt->r_info); ++ symtab_index = ELF_R_SYM(rpnt->r_info); ++ symbol_addr = 0; ++ symname = strtab + symtab[symtab_index].st_name; ++ ++ if (ELF_ST_BIND (symtab[symtab_index].st_info) == STB_LOCAL) { ++ symbol_addr = (unsigned long) DL_RELOC_ADDR(tpnt->loadaddr, symtab[symtab_index].st_value); ++ symbol_tpnt = tpnt; ++ } else { ++ ++ symbol_addr = (unsigned long) ++ _dl_lookup_hash(symname, scope, NULL, 0, &symbol_tpnt); ++ ++ /* ++ * We want to allow undefined references to weak symbols - this might ++ * have been intentional. We should not be linking local symbols ++ * here, so all bases should be covered. ++ */ ++ ++ if (!symbol_addr && ELF_ST_BIND(symtab[symtab_index].st_info) != STB_WEAK) { ++ _dl_dprintf (2, "%s: can't resolve symbol '%s'\n", ++ _dl_progname, strtab + symtab[symtab_index].st_name); ++ _dl_exit (1); ++ } ++ } ++ ++#if defined (__SUPPORT_LD_DEBUG__) ++ if (_dl_debug_reloc && _dl_debug_detail) ++ { ++ if ((long)reloc_addr_packed & 3) ++ old_val = reloc_addr_packed->v; ++ else ++ old_val = *reloc_addr; ++ } ++ else ++ old_val = 0; ++#endif ++ switch (reloc_type) { ++ case R_UBICOM32_NONE: ++ break; ++ case R_UBICOM32_32: ++ if ((long)reloc_addr_packed & 3) ++ reloc_value = reloc_addr_packed->v += symbol_addr; ++ else ++ reloc_value = *reloc_addr += symbol_addr; ++ break; ++ case R_UBICOM32_FUNCDESC_VALUE: ++ funcval.entry_point = (void*)symbol_addr; ++ /* The addend of FUNCDESC_VALUE ++ relocations referencing global ++ symbols must be ignored, because it ++ may hold the address of a lazy PLT ++ entry. */ ++ if (ELF_ST_BIND(symtab[symtab_index].st_info) == STB_LOCAL) ++ funcval.entry_point += *reloc_addr; ++ reloc_value = (unsigned long)funcval.entry_point; ++ if (symbol_addr) ++ funcval.got_value ++ = symbol_tpnt->loadaddr.got_value; ++ else ++ funcval.got_value = 0; ++ ++/// XXX this is my best guess as to what I should be doing, but I'm ++/// putting a break-point here so I can inspect the first time this is ++/// used. ++ __asm__ ( ++ " move.4 4(%0), 4(%1) \n\t" ++ " move.4 0(%0), 0(%1) \n\t" /* Must to entry_point last */ ++ : ++ : "a" (reloc_addr), "a" (&funcval) ++ : "memory" ); ++ break; ++ case R_UBICOM32_FUNCDESC: ++ if ((long)reloc_addr_packed & 3) ++ reloc_value = reloc_addr_packed->v; ++ else ++ reloc_value = *reloc_addr; ++ if (symbol_addr) ++ reloc_value = (unsigned long)_dl_funcdesc_for ++ ((char *)symbol_addr + reloc_value, ++ symbol_tpnt->loadaddr.got_value); ++ else ++ reloc_value = 0; ++ if ((long)reloc_addr_packed & 3) ++ reloc_addr_packed->v = reloc_value; ++ else ++ *reloc_addr = reloc_value; ++ break; ++ default: ++ return -1; ++ } ++#if defined (__SUPPORT_LD_DEBUG__) ++ if (_dl_debug_reloc && _dl_debug_detail) { ++ _dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x", old_val, reloc_value, reloc_addr); ++ switch (reloc_type) { ++ case R_UBICOM32_FUNCDESC_VALUE: ++ _dl_dprintf(_dl_debug_file, " got %x", ((struct funcdesc_value *)reloc_value)->got_value); ++ break; ++ case R_UBICOM32_FUNCDESC: ++ if (! reloc_value) ++ break; ++ _dl_dprintf(_dl_debug_file, " funcdesc (%x,%x)", ++ ((struct funcdesc_value *)reloc_value)->entry_point, ++ ((struct funcdesc_value *)reloc_value)->got_value); ++ break; ++ } ++ } ++#endif ++ ++ return 0; ++} ++ ++static int ++_dl_do_lazy_reloc (struct elf_resolve *tpnt, ++ struct dyn_elf *scope __attribute__((unused)), ++ ELF_RELOC *rpnt, ElfW(Sym) *symtab __attribute__((unused)), ++ char *strtab __attribute__((unused))) ++{ ++ int reloc_type; ++ struct funcdesc_value volatile *reloc_addr; ++ struct funcdesc_value funcval; ++#if defined (__SUPPORT_LD_DEBUG__) ++ unsigned long old_val; ++#endif ++ ++ reloc_addr = (struct funcdesc_value *) DL_RELOC_ADDR(tpnt->loadaddr, rpnt->r_offset); ++ reloc_type = ELF_R_TYPE(rpnt->r_info); ++ ++#if defined (__SUPPORT_LD_DEBUG__) ++ old_val = (unsigned long)reloc_addr->entry_point; ++#endif ++ switch (reloc_type) { ++ case R_UBICOM32_NONE: ++ break; ++ case R_UBICOM32_FUNCDESC_VALUE: ++ funcval = *reloc_addr; ++ funcval.entry_point = (void*)DL_RELOC_ADDR(tpnt->loadaddr, funcval.entry_point); ++ funcval.got_value = tpnt->loadaddr.got_value; ++ *reloc_addr = funcval; ++ break; ++ default: ++ return -1; ++ } ++#if defined (__SUPPORT_LD_DEBUG__) ++ if (_dl_debug_reloc && _dl_debug_detail) ++ _dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x", old_val, reloc_addr->entry_point, reloc_addr); ++#endif ++ return 0; ++ ++} ++ ++void ++_dl_parse_lazy_relocation_information ++(struct dyn_elf *rpnt, unsigned long rel_addr, unsigned long rel_size) ++{ ++ _dl_parse(rpnt->dyn, NULL, rel_addr, rel_size, _dl_do_lazy_reloc); ++} ++ ++int ++_dl_parse_relocation_information ++(struct dyn_elf *rpnt, unsigned long rel_addr, unsigned long rel_size) ++{ ++ return _dl_parse(rpnt->dyn, rpnt->dyn->symbol_scope, rel_addr, rel_size, _dl_do_reloc); ++} ++ ++#if 0 ++/* We don't have copy relocs. */ ++int ++_dl_parse_copy_information ++(struct dyn_elf *rpnt __attribute__((unused)), ++ unsigned long rel_addr __attribute__((unused)), ++ unsigned long rel_size __attribute__((unused))) ++{ ++ return 0; ++} ++#endif ++#ifndef IS_IN_libdl ++# include "../../libc/sysdeps/linux/ubicom32/crtreloc.c" ++#endif +--- /dev/null ++++ b/ldso/ldso/ubicom32/resolve.S +@@ -0,0 +1,161 @@ ++ /* Copyright (C) 2003 Red Hat, Inc. ++ Contributed by Alexandre Oliva ++ ++ Copyright (C) 2009 Ubicom Inc. ++ Ported to Ubicom32 by Ubicom Inc. ++ ++This file is part of uClibc. ++ ++uClibc is free software; you can redistribute it and/or modify it ++under the terms of the GNU Lesser General Public License as ++published by the Free Software Foundation; either version 2.1 of the ++License, or (at your option) any later version. ++ ++uClibc 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 ++Library General Public License for more details. ++ ++You should have received a copy of the GNU Lesser General Public ++License along with uClibc; see the file COPYING.LIB. If not, write to ++the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, ++USA. */ ++ ++ ++/* ++ * The function below is tail-called by resolver stubs when a lazily-bound * ++ * function is called. It must preserve all registers that could * be used to ++ * pass arguments to the actual function. ++ * ++ * On entry to the function d0-d13 contain parameters to the actual function of ++ * interest ++ * ++ * a5 contains the return address ++ * a0 is pointing to the GOT table for the original function ++ * (a0) _dl_linux_resolve ++ * 4(a0) GOT for _dl_linux_resolve ++ * 8(a0) is pointer to "structure elf_resolve" of the module where the call ++ * originated from ++ * ++ * a3 is pointing to the function descriptor in the GOT table, and 8(a3) the ++ * resolver lookup information. ++ * ++ * _dl_linux_resolve calls _dl_linux_resolver passing it pointer to ++ * struct elf_resolve and the relocation entry. ++ * ++ * _dl_linux_resolver() figures out where the jump symbol is _really_ supposed ++ * to have jumped to and returns that to us. Once we have that, we prepare to ++ * tail-call the actual function, clean up after ourselves, restoring the ++ * original arguments, then jump to the fixed up address. ++ */ ++ ++#if 0 ++ /* ++ * Here is what the linker will use for the PLT. ++ */ ++sample_PLT_functionX: /* (at entry a0 contains GOT for this library) */ ++ movei d15, # -%lo(got_funcdescX) ; load offset for GOT ++ lea.4 a3, (a0, d15) ; a4 is now the function descriptor ++ move.4 a4, 0(a3) ; get entry_point ++ move.4 a0, 4(a3) ; set new GOT ++ ++ /* ++ * jump to resovled function OR PLT_trampoline Nat had some code here ++ * that uses the stack instead of a3 to reduces hazards. ++ */ ++ calli a4, 0(a4) ++ ++ ++sample_PLT_trampoline: ++ /* ++ * find the old got by undoing what was done above. An alternative ++ * could have been to ‘save’ the old got in say d14 but that would add 1 ++ * instruction to every PLT and there is only 1 PLT trampoline per library. ++ */ ++ ret (a0) ; jump to _dl_linux_resolve ++#endif ++ ++ .text ++ .p2align 4 ++ ++ .hidden _dl_linux_resolve ++ .global _dl_linux_resolve ++ .type _dl_linux_resolve,@function ++_dl_linux_resolve: ++ /* Preserve arguments and return address */ ++ move.4 -4(sp)++, d0 ++ move.4 -4(sp)++, d1 ++ move.4 -4(sp)++, d2 ++ move.4 -4(sp)++, d3 ++ move.4 -4(sp)++, d4 ++ move.4 -4(sp)++, d5 ++ move.4 -4(sp)++, d6 ++ move.4 -4(sp)++, d7 ++ move.4 -4(sp)++, d8 ++ move.4 -4(sp)++, d9 ++ move.4 -4(sp)++, d10 ++ move.4 -4(sp)++, d11 ++ move.4 -4(sp)++, d12 ++ move.4 -4(sp)++, d13 ++ move.4 -4(sp)++, a5 ++ ++ /* Prepare to call _dl_linux_resolver. */ ++ move.4 d0, 8(a0) ; reference to elf_resolve ++ /* Not aligned for space reasons. */ ++ move.4 d1, mac_hi ; reference to GOT table entry which ++ ; contains the relocation information. ++ ++ move.4 a0, 4(a0) ; switch to GOT for _dl_linux_resolve ++ call a5, _dl_linux_resolver; ++ ++ /* Move aside return value that contains the FUNCDESC_VALUE. */ ++ ;P3 = R0; ++ move.4 a3, d0; ++ ++ /* Restore arguments. */ ++ move.4 a5, (sp)4++ ++ move.4 d13, (sp)4++ ++ move.4 d12, (sp)4++ ++ move.4 d11, (sp)4++ ++ move.4 d10, (sp)4++ ++ move.4 d9, (sp)4++ ++ move.4 d8, (sp)4++ ++ move.4 d7, (sp)4++ ++ move.4 d6, (sp)4++ ++ move.4 d5, (sp)4++ ++ move.4 d4, (sp)4++ ++ move.4 d3, (sp)4++ ++ move.4 d2, (sp)4++ ++ move.4 d1, (sp)4++ ++ move.4 d0, (sp)4++ ++ ++ /* Now jump to the actual function. */ ++ /* a3 contains func_desc resolution */ ++ move.4 a4, 0(a3) ; address of function X ++ move.4 a0, 4(a3) ; switch to GOT for function X ++ calli a4, 0(a4) ; call through a4, a5 remains ++ ++ .size _dl_linux_resolve, . - _dl_linux_resolve ++ ++ .hidden _dl_ubicom32_resolve_pending ++ .global _dl_ubicom32_resolve_pending ++ .type _dl_ubicom32_resolve_pending,@function ++ ++_dl_ubicom32_resolve_pending: ++ /* ++ * A special function that is used to ensure thread saftly when the fd ++ * for a particular resolution is being updated. ++ * ++ * At entry, a3 must point to the FD. While the FD is being updated the ++ * entry_point will continue to point to _dl_ubicom32_resolve_pending so ++ * we will effectively spin until the resolver update is complete. ++ */ ++ ++ move.4 a4, 0(a3) ; get entry_point ++ move.4 a0, 4(a3) ; set new GOT ++ ++ /* ++ * jump to resovled function or back to _dl_ubicom32_resolve_pending. ++ */ ++ calli a4, 0(a4) ++ .size _dl_ubicom32_resolve_pending, . - _dl_ubicom32_resolve_pending +--- a/libc/misc/Makefile.in ++++ b/libc/misc/Makefile.in +@@ -12,7 +12,9 @@ include $(top_srcdir)libc/misc/assert/Ma + include $(top_srcdir)libc/misc/ctype/Makefile.in + include $(top_srcdir)libc/misc/dirent/Makefile.in + include $(top_srcdir)libc/misc/error/Makefile.in ++ifneq ($(ARCH_HAS_NO_LDSO),y) + include $(top_srcdir)libc/misc/elf/Makefile.in ++endif + include $(top_srcdir)libc/misc/file/Makefile.in + include $(top_srcdir)libc/misc/fnmatch/Makefile.in + include $(top_srcdir)libc/misc/ftw/Makefile.in +--- a/libc/misc/elf/dl-iterate-phdr.c ++++ b/libc/misc/elf/dl-iterate-phdr.c +@@ -14,7 +14,7 @@ + + #include + #include +- ++#include + /* we want this in libc but nowhere else */ + #ifdef __USE_GNU + +@@ -60,7 +60,11 @@ dl_iterate_phdr (int (*callback) (struct + /* This entry describes this statically-linked program itself. */ + struct dl_phdr_info info; + int ret; ++#if !defined(__FDPIC__) + info.dlpi_addr = 0; ++#else ++ memset(&info.dlpi_addr, 0, sizeof(info.dlpi_addr)); ++#endif + info.dlpi_name = ""; + info.dlpi_phdr = _dl_phdr; + info.dlpi_phnum = _dl_phnum; +--- a/libc/stdlib/malloc/malloc.c ++++ b/libc/stdlib/malloc/malloc.c +@@ -25,7 +25,7 @@ libc_hidden_proto(sbrk) + + /* The malloc heap. We provide a bit of initial static space so that + programs can do a little mallocing without mmaping in more space. */ +-HEAP_DECLARE_STATIC_FREE_AREA (initial_fa, 256); ++HEAP_DECLARE_STATIC_FREE_AREA (initial_fa, 32768); + struct heap_free_area *__malloc_heap = HEAP_INIT_WITH_FA (initial_fa); + #ifdef HEAP_USE_LOCKING + malloc_mutex_t __malloc_heap_lock = PTHREAD_MUTEX_INITIALIZER; +--- /dev/null ++++ b/libc/string/ubicom32/Makefile +@@ -0,0 +1,13 @@ ++# Makefile for uClibc ++# ++# Copyright (C) 2000-2005 Erik Andersen ++# ++# Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. ++# ++ ++top_srcdir:=../../../ ++top_builddir:=../../../ ++all: objs ++include $(top_builddir)Rules.mak ++include ../Makefile.in ++include $(top_srcdir)Makerules +--- /dev/null ++++ b/libc/string/ubicom32/memcpy.c +@@ -0,0 +1,152 @@ ++/* Copy memory to memory until the specified number of bytes ++ has been copied. Overlap is NOT handled correctly. ++ Copyright (C) 1991, 1997, 2003 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ Contributed by Torbjorn Granlund (tege@sics.se). ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#include ++ ++typedef unsigned long addr_t; ++ ++libc_hidden_proto(memcpy) ++ ++void *memcpy (void *dest, const void *src, size_t n) ++{ ++ void *dest_ret = dest; ++ void *aligned_start; ++ ++ if (likely((((addr_t)dest ^ (addr_t)src) & 3) == 0) && likely(n > 6)) { ++ size_t m; ++ n -= (4 - (addr_t)dest) & 0x03; ++ m = n >> 2; ++ __asm__ volatile ( ++ " call %4, 99f \n\t" // load %4 with address of 99 ++ "99: movei d15, #%%lo(1f-99b) \n\t" // load d15 with offset to 1 from 99 ++ " add.4 %4, %4, d15 \n\t" // add difference ++ ++ " sub.4 d15, #0, %2 \n\t" // set up for jump table ++ " and.4 d15, #(32-1), d15 \n\t" // d15 = (-m) & (32 - 1) ++ " lea.4 %4, (%4,d15) \n\t" ++ ++ " bfextu d15, %0, #2 \n\t" // d15 = (dest & 3) ++ " jmpne.w.f 100f \n\t" ++ " calli %4, 0(%4) \n\t" // 4-byte alignment ++ ++ "100: cmpi d15, #2 \n\t" ++ " jmpne.s.f 101f \n\t" ++ " move.2 (%0)2++, (%1)2++ \n\t" ++ " calli %4, 0(%4) \n\t" // 2-byte alignment ++ ++ "101: move.1 (%0)1++, (%1)1++ \n\t" ++ " jmpgt.s.f 102f \n\t" // 3-byte alignment ++ " move.2 (%0)2++, (%1)2++ \n\t" // 1-byte alignment ++ "102: calli %4, 0(%4) \n\t" ++ ++ "200: cmpi %3, #2 \n\t" ++ " jmplt.s.f 201f \n\t" ++ " move.2 (%0)2++, (%1)2++ \n\t" ++ " jmpeq.s.t 2f \n\t" ++ "201: move.1 (%0)1++, (%1)1++ \n\t" ++ " jmpt.w.t 2f \n\t" ++ ++ "1: .rept 25 \n\t" ++ " movea (%0)4++, (%1)4++ \n\t" ++ " .endr \n\t" ++ " .rept 7 \n\t" ++ " move.4 (%0)4++, (%1)4++ \n\t" ++ " .endr \n\t" ++ " add.4 %2, #-32, %2 \n\t" ++ " jmpgt.w.f 1b \n\t" ++ ++ " and.4 %3, #3, %3 \n\t" // check n ++ " jmpne.w.f 200b \n\t" ++ "2: \n\t" ++ : "+a"(dest), "+a"(src), "+d"(m), "+d"(n), "=a"(aligned_start) ++ : ++ : "d15", "memory", "cc" ++ ); ++ ++ return dest_ret; ++ } ++ ++ if (likely((((addr_t)dest ^ (addr_t)src) & 1) == 0) && likely(n > 2)) { ++ size_t m; ++ n -= (addr_t)dest & 0x01; ++ m = n >> 1; ++ __asm__ volatile ( ++ " call %4, 99f \n\t" // load %4 with address of 99 ++ "99: movei d15, #%%lo(1f-99b) \n\t" // load d15 with offset to 1 from 99 ++ " add.4 %4, %4, d15 \n\t" // add difference ++ ++ " sub.4 d15, #0, %2 \n\t" // set up for jump table ++ " and.4 d15, #(32-1), d15 \n\t" // d15 = (-m) & (32 - 1) ++ " lea.4 %4, (%4,d15) \n\t" ++ ++ " btst %0, #0 \n\t" // check bit 0 ++ " jmpne.w.f 100f \n\t" ++ " calli %4, 0(%4) \n\t" // 4-byte alignment ++ ++ "100: move.1 (%0)1++, (%1)1++ \n\t" ++ " calli %4, 0(%4) \n\t" ++ ++ "200: move.1 (%0)1++, (%1)1++ \n\t" ++ " jmpt.w.t 2f \n\t" ++ ++ "1: .rept 32 \n\t" ++ " move.2 (%0)2++, (%1)2++ \n\t" ++ " .endr \n\t" ++ " add.4 %2, #-32, %2 \n\t" ++ " jmpgt.w.f 1b \n\t" ++ ++ " and.4 %3, #1, %3 \n\t" // check n ++ " jmpne.w.f 200b \n\t" ++ "2: \n\t" ++ ++ : "+a"(dest), "+a"(src), "+d"(m), "+d"(n), "=a"(aligned_start) ++ : ++ : "d15", "memory", "cc" ++ ); ++ return dest_ret; ++ } ++ ++ __asm__ volatile ( ++ " call %3, 99f \n\t" // load %3 with address of 99 ++ "99: movei d15, #%%lo(1f-99b) \n\t" // load d15 with offset to 1 from 99 ++ " add.4 %3, %3, d15 \n\t" // add difference ++ ++ " sub.4 d15, #0, %2 \n\t" ++ " jmpeq.w.f 2f \n\t" ++ " and.4 d15, #(16-1), d15 \n\t" // d15 = (-n) & (16 - 1) ++ " lea.4 %3, (%3,d15) \n\t" ++ " calli %3, 0(%3) \n\t" ++ ++ "1: .rept 16 \n\t" ++ " move.1 (%0)1++, (%1)1++ \n\t" ++ " .endr \n\t" ++ " add.4 %2, #-16, %2 \n\t" ++ " jmpgt.w.f 1b \n\t" ++ "2: \n\t" ++ ++ : "+a"(dest), "+a"(src), "+d"(n), "=a"(aligned_start) ++ : ++ : "d15", "memory", "cc" ++ ); ++ ++ return dest_ret; ++} ++libc_hidden_def(memcpy) +--- /dev/null ++++ b/libc/string/ubicom32/memset.c +@@ -0,0 +1,107 @@ ++/* Copyright (C) 1991, 1997, 2003 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#include ++ ++typedef unsigned long addr_t; ++ ++libc_hidden_proto(memset) ++void *memset (void *s, int c, size_t n) ++{ ++ void *s_ret = s; ++ void *aligned_start; ++ if (likely(n > 6)) { ++ size_t m; ++ n -= (4 - (addr_t)s) & 0x03; ++ m = n >> 2; ++ __asm__ volatile ( ++ " call %4, 99f \n\t" // load %4 with address of 99 ++ "99: movei d15, #%%lo(1f-99b) \n\t" // load d15 with offset to 1 from 99 ++ " add.4 %4, %4, d15 \n\t" // add difference ++ ++ " sub.4 d15, #0, %2 \n\t" // set up for jump table ++ " and.4 d15, #(32-1), d15 \n\t" // d15 = (-m) & (32 - 1) ++ " shmrg.1 %1, %1, %1 \n\t" ++ " shmrg.2 %1, %1, %1 \n\t" // %1 = (c<<24)|(c<<16)|(c<<8)|c ++ " lea.4 %4, (%4,d15) \n\t" ++ ++ " bfextu d15, %0, #2 \n\t" // d15 = (s & 3) ++ " jmpne.w.f 100f \n\t" ++ " calli %4, 0(%4) \n\t" // 4-byte alignment ++ ++ "100: cmpi d15, #2 \n\t" ++ " jmpne.s.f 101f \n\t" ++ " move.2 (%0)2++, %1 \n\t" ++ " calli %4, 0(%4) \n\t" // 2-byte alignment ++ ++ "101: move.1 (%0)1++, %1 \n\t" ++ " jmpgt.s.f 102f \n\t" // 3-byte alignment ++ " move.2 (%0)2++, %1 \n\t" // 1-byte alignment ++ "102: calli %4, 0(%4) \n\t" ++ ++ "200: cmpi %3, #2 \n\t" ++ " jmplt.s.f 201f \n\t" ++ " move.2 (%0)2++, %1 \n\t" ++ " jmpeq.s.t 2f \n\t" ++ "201: move.1 (%0)1++, %1 \n\t" ++ " jmpt.w.t 2f \n\t" ++ ++ "1: .rept 25 \n\t" ++ " movea (%0)4++, %1 \n\t" ++ " .endr \n\t" ++ " .rept 7 \n\t" ++ " move.4 (%0)4++, %1 \n\t" ++ " .endr \n\t" ++ " add.4 %2, #-32, %2 \n\t" ++ " jmpgt.w.f 1b \n\t" ++ ++ " and.4 %3, #3, %3 \n\t" // test bit 1 of n ++ " jmpne.w.f 200b \n\t" ++ "2: \n\t" ++ : "+a"(s), "+d"(c), "+d"(m), "+d"(n), "=a"(aligned_start) ++ : ++ : "d15", "memory", "cc" ++ ); ++ ++ return s_ret; ++ } ++ ++ __asm__ volatile ( ++ " call %3, 99f \n\t" // load %3 with address of 99 ++ "99: movei d15, #%%lo(1f-99b) \n\t" // load d15 with offset to 1 from 99 ++ " add.4 %3, %3, d15 \n\t" // add difference ++ ++ " sub.4 d15, #0, %2 \n\t" ++ " jmpeq.w.f 2f \n\t" ++ " and.4 d15, #(8-1), d15 \n\t" // d15 = (-%2) & (16 - 1) ++ " lea.4 %3, (%3,d15) \n\t" ++ " calli %3, 0(%3) \n\t" ++ ++ "1: .rept 8 \n\t" ++ " move.1 (%0)1++, %1 \n\t" ++ " .endr \n\t" ++ "2: \n\t" ++ ++ : "+a"(s), "+d"(c), "+d"(n), "=a"(aligned_start) ++ : ++ : "d15", "memory", "cc" ++ ); ++ ++ return s_ret; ++} ++libc_hidden_def(memset) +--- a/libc/sysdeps/linux/common/sys/user.h ++++ b/libc/sysdeps/linux/common/sys/user.h +@@ -1 +1,4 @@ ++#if 0 ++/* As of linux v2.6.25 this is not part of the exported linux headers */ + #include ++#endif +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/Makefile +@@ -0,0 +1,13 @@ ++# Makefile for uClibc ++# ++# Copyright (C) 2000-2006 Erik Andersen ++# ++# Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. ++# ++ ++top_srcdir=../../../../ ++top_builddir=../../../../ ++all: objs ++include $(top_builddir)Rules.mak ++include Makefile.arch ++include $(top_srcdir)Makerules +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/Makefile.arch +@@ -0,0 +1,28 @@ ++# Makefile for uClibc ++# ++# Copyright (C) 2000-2006 Erik Andersen ++# ++# Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. ++# ++ ++#CSRC := \ ++# brk.c \ ++# crtbegin.c \ ++# crtend.c ++# ++#SSRC := \ ++# __longjmp.S \ ++# bsd-_setjmp.S \ ++# bsd-setjmp.S \ ++# setjmp.S \ ++# clone.S \ ++# vfork.S ++ ++CSRC := \ ++ syscall.c __syscall_error.c ++ ++SSRC := \ ++ clone.S setjmp.S vfork.S ++ ++ARCH_CFLAGS := $(CPU_CFLAGS-y) ++include $(top_srcdir)libc/sysdeps/linux/Makefile.commonarch +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/__syscall_error.c +@@ -0,0 +1,11 @@ ++#include ++#include ++ ++/* This routine is jumped to by some of the syscall handlers, to stash ++ * an error number into errno. */ ++int __syscall_error(int err_no) attribute_hidden; ++int __syscall_error(int err_no) ++{ ++ __set_errno(err_no); ++ return -1; ++} +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/bits/elf-fdpic.h +@@ -0,0 +1,115 @@ ++/* Copyright 2003, 2004 Free Software Foundation, Inc. ++This file is part of the GNU C Library. ++ ++The GNU C Library is free software; you can redistribute it and/or ++modify it under the terms of the GNU Lesser General Public License as ++published by the Free Software Foundation; either version 2.1 of the ++License, or (at your option) any later version. ++ ++In addition to the permissions in the GNU Lesser General Public ++License, the Free Software Foundation gives you unlimited ++permission to link the compiled version of this file with other ++programs, and to distribute those programs without any restriction ++coming from the use of this file. (The GNU Lesser General Public ++License restrictions do apply in other respects; for example, they ++cover modification of the file, and distribution when not linked ++into another program.) ++ ++The GNU C Library 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 ++Library General Public License for more details. ++ ++You should have received a copy of the GNU Lesser General Public ++License along with the GNU C Library; see the file COPYING.LIB. If ++not, write to the Free Software Foundation, Inc., 675 Mass Ave, ++Cambridge, MA 02139, USA. */ ++ ++#ifndef _BITS_ELF_FDPIC_H ++#define _BITS_ELF_FDPIC_H ++ ++/* These data structures are described in the FDPIC ABI extension. ++ The kernel passes a process a memory map, such that for every LOAD ++ segment there is an elf32_fdpic_loadseg entry. A pointer to an ++ elf32_fdpic_loadmap is passed in d8 at start-up, and a pointer to ++ an additional such map is passed in d9 for the interpreter, when ++ there is one. */ ++ ++#include ++ ++/* This data structure represents a PT_LOAD segment. */ ++struct elf32_fdpic_loadseg ++{ ++ /* Core address to which the segment is mapped. */ ++ Elf32_Addr addr; ++ /* VMA recorded in the program header. */ ++ Elf32_Addr p_vaddr; ++ /* Size of this segment in memory. */ ++ Elf32_Word p_memsz; ++}; ++ ++struct elf32_fdpic_loadmap { ++ /* Protocol version number, must be zero. */ ++ Elf32_Half version; ++ /* Number of segments in this map. */ ++ Elf32_Half nsegs; ++ /* The actual memory map. */ ++ struct elf32_fdpic_loadseg segs[/*nsegs*/]; ++}; ++ ++struct elf32_fdpic_loadaddr { ++ struct elf32_fdpic_loadmap *map; ++ void *got_value; ++}; ++ ++/* Map a pointer's VMA to its corresponding address according to the ++ load map. */ ++static __always_inline void * ++__reloc_pointer (void *p, ++ const struct elf32_fdpic_loadmap *map) ++{ ++ int c; ++ ++#if 0 ++ if (map->version != 0) ++ /* Crash. */ ++ ((void(*)())0)(); ++#endif ++ ++ /* No special provision is made for NULL. We don't want NULL ++ addresses to go through relocation, so they shouldn't be in ++ .rofixup sections, and, if they're present in dynamic ++ relocations, they shall be mapped to the NULL address without ++ undergoing relocations. */ ++ ++ for (c = 0; ++ /* Take advantage of the fact that the loadmap is ordered by ++ virtual addresses. In general there will only be 2 entries, ++ so it's not profitable to do a binary search. */ ++ c < map->nsegs && p >= (void*)map->segs[c].p_vaddr; ++ c++) ++ { ++ /* This should be computed as part of the pointer comparison ++ above, but we want to use the carry in the comparison, so we ++ can't convert it to an integer type beforehand. */ ++ unsigned long offset = p - (void*)map->segs[c].p_vaddr; ++ /* We only check for one-past-the-end for the last segment, ++ assumed to be the data segment, because other cases are ++ ambiguous in the absence of padding between segments, and ++ rofixup already serves as padding between text and data. ++ Unfortunately, unless we special-case the last segment, we ++ fail to relocate the _end symbol. */ ++ if (offset < map->segs[c].p_memsz ++ || (offset == map->segs[c].p_memsz && c + 1 == map->nsegs)) ++ return (char*)map->segs[c].addr + offset; ++ } ++ ++ /* We might want to crash instead. */ ++ return (void*)-1; ++} ++ ++# define __RELOC_POINTER(ptr, loadaddr) \ ++ (__reloc_pointer ((void*)(ptr), \ ++ (loadaddr).map)) ++ ++#endif /* _BITS_ELF_FDPIC_H */ +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/bits/endian.h +@@ -0,0 +1,7 @@ ++/* Ubicom32 is big-endian. */ ++ ++#ifndef _ENDIAN_H ++# error "Never use directly; include instead." ++#endif ++ ++#define __BYTE_ORDER __BIG_ENDIAN +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/bits/fcntl.h +@@ -0,0 +1,224 @@ ++/* O_*, F_*, FD_* bit values for Linux. ++ Copyright (C) 2000 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#ifndef _FCNTL_H ++# error "Never use directly; include instead." ++#endif ++ ++ ++#include ++#ifdef __USE_GNU ++# include ++#endif ++ ++/* open/fcntl - O_SYNC is only implemented on blocks devices and on files ++ located on an ext2 file system */ ++#define O_ACCMODE 0003 ++#define O_RDONLY 00 ++#define O_WRONLY 01 ++#define O_RDWR 02 ++#define O_CREAT 0100 /* not fcntl */ ++#define O_EXCL 0200 /* not fcntl */ ++#define O_NOCTTY 0400 /* not fcntl */ ++#define O_TRUNC 01000 /* not fcntl */ ++#define O_APPEND 02000 ++#define O_NONBLOCK 04000 ++#define O_NDELAY O_NONBLOCK ++#define O_SYNC 010000 ++#define O_FSYNC O_SYNC ++#define O_ASYNC 020000 ++ ++#ifdef __USE_GNU ++# define O_DIRECTORY 040000 /* Must be a directory. */ ++# define O_NOFOLLOW 0100000 /* Do not follow links. */ ++# define O_DIRECT 0200000 /* Direct disk access. */ ++# define O_STREAMING 04000000/* streaming access */ ++#endif ++ ++/* For now Linux has synchronisity options for data and read operations. ++ We define the symbols here but let them do the same as O_SYNC since ++ this is a superset. */ ++#if defined __USE_POSIX199309 || defined __USE_UNIX98 ++# define O_DSYNC O_SYNC /* Synchronize data. */ ++# define O_RSYNC O_SYNC /* Synchronize read operations. */ ++#endif ++ ++#ifdef __USE_LARGEFILE64 ++# define O_LARGEFILE 0400000 ++#endif ++ ++/* Values for the second argument to `fcntl'. */ ++#define F_DUPFD 0 /* Duplicate file descriptor. */ ++#define F_GETFD 1 /* Get file descriptor flags. */ ++#define F_SETFD 2 /* Set file descriptor flags. */ ++#define F_GETFL 3 /* Get file status flags. */ ++#define F_SETFL 4 /* Set file status flags. */ ++#ifndef __USE_FILE_OFFSET64 ++# define F_GETLK 5 /* Get record locking info. */ ++# define F_SETLK 6 /* Set record locking info (non-blocking). */ ++# define F_SETLKW 7 /* Set record locking info (blocking). */ ++#else ++# define F_GETLK F_GETLK64 /* Get record locking info. */ ++# define F_SETLK F_SETLK64 /* Set record locking info (non-blocking).*/ ++# define F_SETLKW F_SETLKW64 /* Set record locking info (blocking). */ ++#endif ++#define F_GETLK64 12 /* Get record locking info. */ ++#define F_SETLK64 13 /* Set record locking info (non-blocking). */ ++#define F_SETLKW64 14 /* Set record locking info (blocking). */ ++ ++#if defined __USE_BSD || defined __USE_XOPEN2K ++# define F_SETOWN 8 /* Get owner of socket (receiver of SIGIO). */ ++# define F_GETOWN 9 /* Set owner of socket (receiver of SIGIO). */ ++#endif ++ ++#ifdef __USE_GNU ++# define F_SETSIG 10 /* Set number of signal to be sent. */ ++# define F_GETSIG 11 /* Get number of signal to be sent. */ ++#endif ++ ++#ifdef __USE_GNU ++# define F_SETLEASE 1024 /* Set a lease. */ ++# define F_GETLEASE 1025 /* Enquire what lease is active. */ ++# define F_NOTIFY 1026 /* Request notfications on a directory. */ ++#endif ++ ++/* For F_[GET|SET]FL. */ ++#define FD_CLOEXEC 1 /* actually anything with low bit set goes */ ++ ++/* For posix fcntl() and `l_type' field of a `struct flock' for lockf(). */ ++#define F_RDLCK 0 /* Read lock. */ ++#define F_WRLCK 1 /* Write lock. */ ++#define F_UNLCK 2 /* Remove lock. */ ++ ++/* For old implementation of bsd flock(). */ ++#define F_EXLCK 4 /* or 3 */ ++#define F_SHLCK 8 /* or 4 */ ++ ++#ifdef __USE_BSD ++/* Operations for bsd flock(), also used by the kernel implementation. */ ++# define LOCK_SH 1 /* shared lock */ ++# define LOCK_EX 2 /* exclusive lock */ ++# define LOCK_NB 4 /* or'd with one of the above to prevent ++ blocking */ ++# define LOCK_UN 8 /* remove lock */ ++#endif ++ ++#ifdef __USE_GNU ++# define LOCK_MAND 32 /* This is a mandatory flock: */ ++# define LOCK_READ 64 /* ... which allows concurrent read operations. */ ++# define LOCK_WRITE 128 /* ... which allows concurrent write operations. */ ++# define LOCK_RW 192 /* ... Which allows concurrent read & write operations. */ ++#endif ++ ++#ifdef __USE_GNU ++/* Types of directory notifications that may be requested with F_NOTIFY. */ ++# define DN_ACCESS 0x00000001 /* File accessed. */ ++# define DN_MODIFY 0x00000002 /* File modified. */ ++# define DN_CREATE 0x00000004 /* File created. */ ++# define DN_DELETE 0x00000008 /* File removed. */ ++# define DN_RENAME 0x00000010 /* File renamed. */ ++# define DN_ATTRIB 0x00000020 /* File changed attibutes. */ ++# define DN_MULTISHOT 0x80000000 /* Don't remove notifier. */ ++#endif ++ ++struct flock ++ { ++ short int l_type; /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK. */ ++ short int l_whence; /* Where `l_start' is relative to (like `lseek'). */ ++#ifndef __USE_FILE_OFFSET64 ++ __off_t l_start; /* Offset where the lock begins. */ ++ __off_t l_len; /* Size of the locked area; zero means until EOF. */ ++#else ++ __off64_t l_start; /* Offset where the lock begins. */ ++ __off64_t l_len; /* Size of the locked area; zero means until EOF. */ ++#endif ++ __pid_t l_pid; /* Process holding the lock. */ ++ }; ++ ++#ifdef __USE_LARGEFILE64 ++struct flock64 ++ { ++ short int l_type; /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK. */ ++ short int l_whence; /* Where `l_start' is relative to (like `lseek'). */ ++ __off64_t l_start; /* Offset where the lock begins. */ ++ __off64_t l_len; /* Size of the locked area; zero means until EOF. */ ++ __pid_t l_pid; /* Process holding the lock. */ ++ }; ++#endif ++ ++/* Define some more compatibility macros to be backward compatible with ++ BSD systems which did not managed to hide these kernel macros. */ ++#ifdef __USE_BSD ++# define FAPPEND O_APPEND ++# define FFSYNC O_FSYNC ++# define FASYNC O_ASYNC ++# define FNONBLOCK O_NONBLOCK ++# define FNDELAY O_NDELAY ++#endif /* Use BSD. */ ++ ++/* Advise to `posix_fadvise'. */ ++#ifdef __USE_XOPEN2K ++# define POSIX_FADV_NORMAL 0 /* No further special treatment. */ ++# define POSIX_FADV_RANDOM 1 /* Expect random page references. */ ++# define POSIX_FADV_SEQUENTIAL 2 /* Expect sequential page references. */ ++# define POSIX_FADV_WILLNEED 3 /* Will need these pages. */ ++# define POSIX_FADV_DONTNEED 4 /* Don't need these pages. */ ++# define POSIX_FADV_NOREUSE 5 /* Data will be accessed once. */ ++#endif ++ ++#ifdef __USE_GNU ++# define SYNC_FILE_RANGE_WAIT_BEFORE 1 /* Wait upon writeout of all pages ++ in the range before performing the ++ write. */ ++# define SYNC_FILE_RANGE_WRITE 2 /* Initiate writeout of all those ++ dirty pages in the range which are ++ not presently under writeback. */ ++# define SYNC_FILE_RANGE_WAIT_AFTER 4 /* Wait upon writeout of all pages in ++ the range after performing the ++ write. */ ++#endif ++ ++__BEGIN_DECLS ++ ++#ifdef __USE_GNU ++ ++/* Provide kernel hint to read ahead. */ ++extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count) ++ __THROW; ++ ++/* Selective file content synch'ing. */ ++extern int sync_file_range (int __fd, __off64_t __from, __off64_t __to, ++ unsigned int __flags); ++ ++/* Splice address range into a pipe. */ ++extern ssize_t vmsplice (int __fdout, const struct iovec *__iov, ++ size_t __count, unsigned int __flags); ++ ++/* Splice two files together. */ ++extern ssize_t splice (int __fdin, __off64_t *__offin, int __fdout, ++ __off64_t *__offout, size_t __len, ++ unsigned int __flags); ++ ++/* In-kernel implementation of tee for pipe buffers. */ ++extern ssize_t tee (int __fdin, int __fdout, size_t __len, ++ unsigned int __flags); ++ ++#endif ++ ++__END_DECLS +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/bits/kernel_stat.h +@@ -0,0 +1,61 @@ ++#ifndef _BITS_STAT_STRUCT_H ++#define _BITS_STAT_STRUCT_H ++ ++#ifndef _LIBC ++#error bits/kernel_stat.h is for internal uClibc use only! ++#endif ++ ++/* This file provides whatever this particular arch's kernel thinks ++ * struct kernel_stat should look like... It turns out each arch has a ++ * different opinion on the subject... */ ++ ++struct kernel_stat { ++ unsigned short st_dev; ++ unsigned short __pad1; ++ unsigned long st_ino; ++ unsigned short st_mode; ++ unsigned short st_nlink; ++ unsigned short st_uid; ++ unsigned short st_gid; ++ unsigned short st_rdev; ++ unsigned short __pad2; ++ unsigned long st_size; ++ unsigned long st_blksize; ++ unsigned long st_blocks; ++ unsigned long st_atime; ++ unsigned long __unused1; ++ unsigned long st_mtime; ++ unsigned long __unused2; ++ unsigned long st_ctime; ++ unsigned long __unused3; ++ unsigned long __unused4; ++ unsigned long __unused5; ++}; ++ ++struct kernel_stat64 { ++ unsigned char __pad0[6]; ++ unsigned short st_dev; ++ unsigned char __pad1[4]; ++#define _HAVE_STAT64___ST_INO ++ unsigned long __st_ino; ++ unsigned int st_mode; ++ unsigned int st_nlink; ++ unsigned long st_uid; ++ unsigned long st_gid; ++ unsigned char __pad2[6]; ++ unsigned short st_rdev; ++ unsigned char __pad3[4]; ++ long long st_size; ++ unsigned long st_blksize; ++ unsigned long st_blocks; /* Number 512-byte blocks allocated. */ ++ unsigned long __pad4; /* future possible st_blocks high bits */ ++ unsigned long st_atime; ++ unsigned long __pad5; ++ unsigned long st_mtime; ++ unsigned long __pad6; ++ unsigned long st_ctime; ++ unsigned long __pad7; /* will be high 32 bits of ctime someday */ ++ unsigned long long st_ino; ++}; ++ ++#endif /* _BITS_STAT_STRUCT_H */ +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/bits/kernel_types.h +@@ -0,0 +1,44 @@ ++/* Note that we use the exact same include guard #define names ++ * as asm/posix_types.h. This will avoid gratuitous conflicts ++ * with the posix_types.h kernel header, and will ensure that ++ * our private content, and not the kernel header, will win. ++ * -Erik ++ */ ++#ifndef __ARCH_UBICOM32_POSIX_TYPES_H ++#define __ARCH_UBICOM32_POSIX_TYPES_H ++ ++typedef unsigned long __kernel_dev_t; ++typedef unsigned long __kernel_ino_t; ++typedef unsigned short __kernel_mode_t; ++typedef unsigned short __kernel_nlink_t; ++typedef long __kernel_off_t; ++typedef int __kernel_pid_t; ++typedef unsigned short __kernel_ipc_pid_t; ++typedef unsigned short __kernel_uid_t; ++typedef unsigned short __kernel_gid_t; ++typedef unsigned int __kernel_size_t; ++typedef int __kernel_ssize_t; ++typedef int __kernel_ptrdiff_t; ++typedef long __kernel_time_t; ++typedef long __kernel_suseconds_t; ++typedef long __kernel_clock_t; ++typedef int __kernel_daddr_t; ++typedef char * __kernel_caddr_t; ++typedef unsigned short __kernel_uid16_t; ++typedef unsigned short __kernel_gid16_t; ++typedef unsigned int __kernel_uid32_t; ++typedef unsigned int __kernel_gid32_t; ++typedef unsigned short __kernel_old_uid_t; ++typedef unsigned short __kernel_old_gid_t; ++typedef unsigned short __kernel_old_dev_t; ++typedef long long __kernel_loff_t; ++ ++typedef struct { ++#ifdef __USE_ALL ++ int val[2]; ++#else ++ int __val[2]; ++#endif ++} __kernel_fsid_t; ++ ++#endif /* __ARCH_UBICOM32_POSIX_TYPES_H */ +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/bits/mman.h +@@ -0,0 +1,102 @@ ++/* Definitions for POSIX memory map interface. Linux/m68k version. ++ Copyright (C) 1997, 2000, 2003, 2005 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#ifndef _SYS_MMAN_H ++# error "Never use directly; include instead." ++#endif ++ ++/* The following definitions basically come from the kernel headers. ++ But the kernel header is not namespace clean. */ ++ ++ ++/* Protections are chosen from these bits, OR'd together. The ++ implementation does not necessarily support PROT_EXEC or PROT_WRITE ++ without PROT_READ. The only guarantees are that no writing will be ++ allowed without PROT_WRITE and no access will be allowed for PROT_NONE. */ ++ ++#define PROT_READ 0x1 /* Page can be read. */ ++#define PROT_WRITE 0x2 /* Page can be written. */ ++#define PROT_EXEC 0x4 /* Page can be executed. */ ++#define PROT_NONE 0x0 /* Page can not be accessed. */ ++#define PROT_GROWSDOWN 0x01000000 /* Extend change to start of ++ growsdown vma (mprotect only). */ ++#define PROT_GROWSUP 0x02000000 /* Extend change to start of ++ growsup vma (mprotect only). */ ++ ++/* Sharing types (must choose one and only one of these). */ ++#define MAP_SHARED 0x01 /* Share changes. */ ++#define MAP_PRIVATE 0x02 /* Changes are private. */ ++#ifdef __USE_MISC ++# define MAP_TYPE 0x0f /* Mask for type of mapping. */ ++#endif ++ ++/* Other flags. */ ++#define MAP_FIXED 0x10 /* Interpret addr exactly. */ ++#ifdef __USE_MISC ++# define MAP_FILE 0 ++# define MAP_ANONYMOUS 0x20 /* Don't use a file. */ ++# define MAP_ANON MAP_ANONYMOUS ++#endif ++ ++/* These are Linux-specific. */ ++#ifdef __USE_MISC ++# define MAP_GROWSDOWN 0x00100 /* Stack-like segment. */ ++# define MAP_DENYWRITE 0x00800 /* ETXTBSY */ ++# define MAP_EXECUTABLE 0x01000 /* Mark it as an executable. */ ++# define MAP_LOCKED 0x02000 /* Lock the mapping. */ ++# define MAP_NORESERVE 0x04000 /* Don't check for reservations. */ ++# define MAP_POPULATE 0x08000 /* Populate (prefault) pagetables. */ ++# define MAP_NONBLOCK 0x10000 /* Do not block on IO. */ ++#endif ++ ++/* Flags to `msync'. */ ++#define MS_ASYNC 1 /* Sync memory asynchronously. */ ++#define MS_SYNC 4 /* Synchronous memory sync. */ ++#define MS_INVALIDATE 2 /* Invalidate the caches. */ ++ ++/* Flags for `mlockall'. */ ++#define MCL_CURRENT 1 /* Lock all currently mapped pages. */ ++#define MCL_FUTURE 2 /* Lock all additions to address ++ space. */ ++ ++/* Flags for `mremap'. */ ++#ifdef __USE_GNU ++# define MREMAP_MAYMOVE 1 ++# define MREMAP_FIXED 2 ++#endif ++ ++/* Advice to `madvise'. */ ++#ifdef __USE_BSD ++# define MADV_NORMAL 0 /* No further special treatment. */ ++# define MADV_RANDOM 1 /* Expect random page references. */ ++# define MADV_SEQUENTIAL 2 /* Expect sequential page references. */ ++# define MADV_WILLNEED 3 /* Will need these pages. */ ++# define MADV_DONTNEED 4 /* Don't need these pages. */ ++# define MADV_DONTFORK 10 /* Do not inherit across fork. */ ++# define MADV_DOFORK 11 /* Do inherit across fork. */ ++#endif ++ ++/* The POSIX people had to invent similar names for the same things. */ ++#ifdef __USE_XOPEN2K ++# define POSIX_MADV_NORMAL 0 /* No further special treatment. */ ++# define POSIX_MADV_RANDOM 1 /* Expect random page references. */ ++# define POSIX_MADV_SEQUENTIAL 2 /* Expect sequential page references. */ ++# define POSIX_MADV_WILLNEED 3 /* Will need these pages. */ ++# define POSIX_MADV_DONTNEED 4 /* Don't need these pages. */ ++#endif +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/bits/setjmp.h +@@ -0,0 +1,52 @@ ++/* Define the machine-dependent type `jmp_buf'. Ubicom32 version. ++ Copyright (C) 1992,93,95,97,2000 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#ifndef _BITS_SETJMP_H ++#define _BITS_SETJMP_H 1 ++ ++#if !defined _SETJMP_H && !defined _PTHREAD_H ++# error "Never include directly; use instead." ++#endif ++ ++#ifndef _ASM ++/* ++ * This is the structure where we are going to save D10-D13, A0, A1, A2, A5, A6 and SP(A7). ++ * A5 is the return address. Call to setjmp will save these. Call to longjmp will return ++ * Control to the address in A5. ++ */ ++typedef struct setjmp_save_struct { ++ unsigned long d10; /* D10 */ ++ unsigned long d11; /* D11 */ ++ unsigned long d12; /* D12 */ ++ unsigned long d13; /* D13 */ ++ unsigned long a1; /* A1 */ ++ unsigned long a2; /* A2 */ ++ unsigned long a5; /* A5 return address. */ ++ unsigned long a6; /* A6 */ ++ unsigned long sp; /* A7 stack pointer. */ ++} __jmp_buf[1]; ++ ++#endif ++ ++/* Test if longjmp to JMPBUF would unwind the frame ++ containing a local variable at ADDRESS. */ ++#define _JMPBUF_UNWINDS(jmpbuf, address) \ ++ ((void *) (address) < (void*)(jmpbuf)->sp) ++ ++#endif /* bits/setjmp.h */ +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/bits/stackinfo.h +@@ -0,0 +1,28 @@ ++/* Copyright (C) 1999 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++/* This file contains a bit of information about the stack allocation ++ of the processor. */ ++ ++#ifndef _STACKINFO_H ++#define _STACKINFO_H 1 ++ ++/* On Ubicom32 the stack grows down. */ ++#define _STACK_GROWS_DOWN 1 ++ ++#endif /* stackinfo.h */ +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/bits/syscalls.h +@@ -0,0 +1,169 @@ ++#ifndef _BITS_SYSCALLS_H ++#define _BITS_SYSCALLS_H ++#ifndef _SYSCALL_H ++# error "Never use directly; include instead." ++#endif ++ ++/* m68k headers does stupid stuff with __NR_iopl / __NR_vm86: ++ * #define __NR_iopl not supported ++ * #define __NR_vm86 not supported ++ */ ++#undef __NR_iopl ++#undef __NR_vm86 ++ ++#ifndef __ASSEMBLER__ ++ ++#include ++ ++/* Linux takes system call arguments in registers: ++ ++ syscall number %d8 ++ arg 1 %d0 ++ arg 2 %d1 ++ arg 3 %d2 ++ arg 4 %d3 ++ arg 5 %d4 ++ arg 6 %d5 ++*/ ++ ++#define __syscall_return(type, res) \ ++ do { \ ++ if (likely((unsigned long)(res) < (unsigned long)(-125))) { \ ++ return (type) (res); \ ++ } else { \ ++ /* avoid using res which is declared to be in register d0; \ ++ errno might expand to a function call and clobber it. */ \ ++ int __err = -(res); \ ++ __set_errno(__err); \ ++ return (type) -1; \ ++ } \ ++ } while (0) ++ ++extern void __illegally_sized_syscall_arg1 (void); ++extern void __illegally_sized_syscall_arg2 (void); ++extern void __illegally_sized_syscall_arg3 (void); ++extern void __illegally_sized_syscall_arg4 (void); ++extern void __illegally_sized_syscall_arg5 (void); ++extern void __illegally_sized_syscall_arg6 (void); ++ ++#define __loadargs_0(name, dummy) \ ++ d8 = name ++ ++#define __loadargs_1(name, __arg1) \ ++ __loadargs_0(name, 0); \ ++ if (__builtin_classify_type (__arg1) != 5 && sizeof (__arg1) > 4) \ ++ __illegally_sized_syscall_arg1 (); \ ++ d0_retval = (long int) __arg1 ++#define __loadargs_2(name, __arg1, __arg2) \ ++ __loadargs_1(name, __arg1); \ ++ if (__builtin_classify_type (__arg2) != 5 && sizeof (__arg2) > 4) \ ++ __illegally_sized_syscall_arg2 (); \ ++ d1 = (long int) __arg2 ++ ++#define __loadargs_3(name, __arg1, __arg2, __arg3) \ ++ __loadargs_2(name, __arg1, __arg2); \ ++ if (__builtin_classify_type (__arg3) != 5 && sizeof (__arg3) > 4) \ ++ __illegally_sized_syscall_arg3 (); \ ++ d2 = (long int) __arg3 ++ ++#define __loadargs_4(name, __arg1, __arg2, __arg3, __arg4) \ ++ __loadargs_3(name, __arg1, __arg2, __arg3); \ ++ if (__builtin_classify_type (__arg4) != 5 && sizeof (__arg4) > 4) \ ++ __illegally_sized_syscall_arg4 (); \ ++ d3 = (long int)__arg4 ++ ++#define __loadargs_5(name, __arg1, __arg2, __arg3, __arg4, __arg5) \ ++ __loadargs_4(name, __arg1, __arg2, __arg3, __arg4); \ ++ if (__builtin_classify_type (__arg5) != 5 && sizeof (__arg5) > 4) \ ++ __illegally_sized_syscall_arg5 (); \ ++ d4 = (long int)__arg5 ++ ++#define __loadargs_6(name, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) \ ++ __loadargs_5(name, __arg1, __arg2, __arg3, __arg4, __arg5); \ ++ if (__builtin_classify_type (__arg6) != 5 && sizeof (__arg6) > 4) \ ++ __illegally_sized_syscall_arg6 (); \ ++ d5 = (long int)__arg6 ++ ++#define __internal_syscall_body(name, nr, args...) \ ++ register long int d0_retval __asm__ ("d0"); \ ++ register long int d1 __asm__ ("d1"); \ ++ register long int d2 __asm__ ("d2"); \ ++ register long int d3 __asm__ ("d3"); \ ++ register long int d4 __asm__ ("d4"); \ ++ register long int d5 __asm__ ("d5"); \ ++ register long int d8 __asm__ ("d8"); \ ++ __loadargs_##nr (__NR_##name, args); \ ++ __asm__ __volatile__ ( \ ++ " moveai a5, #%%hi(0x40400000)\n\t" \ ++ " calli a5, 16(a5)\n\t" \ ++ : "+r" (d0_retval), "+r" (d1), "+r" (d2), "+r" (d3), \ ++ "+r" (d4), "+r" (d5), "+r" (d8) : \ ++ : "cc", "memory", \ ++ "acc0_lo", "acc0_hi", "acc1_lo", "acc1_hi", \ ++ "source3", \ ++ "a0", "a3", "a4", "a5", \ ++ "d6", "d7", "d9", "d14", "d15" \ ++ ); ++ ++#define INLINE_SYSCALL(name, nr, args...) \ ++ ({ \ ++ __internal_syscall_body(name, nr, args); \ ++ if (unlikely((unsigned long)(d0_retval) >= (unsigned long)(-125))) { \ ++ __set_errno (-d0_retval); \ ++ d0_retval = -1L; \ ++ } \ ++ d0_retval; \ ++ }) ++ ++ ++#undef _syscall0 ++#define _syscall0(type,name) \ ++type name(void){ \ ++ __internal_syscall_body(name, 0); \ ++ __syscall_return(type, d0_retval); \ ++} ++ ++#undef _syscall1 ++#define _syscall1(type,name,type1,arg1) \ ++type name(type1 arg1){ \ ++ __internal_syscall_body(name, 1, arg1); \ ++ __syscall_return(type, d0_retval); \ ++} ++ ++#undef _syscall2 ++#define _syscall2(type,name,type1,arg1,type2,arg2) \ ++type name(type1 arg1, type2 arg2){ \ ++ __internal_syscall_body(name, 2, arg1, arg2); \ ++ __syscall_return(type, d0_retval); \ ++} ++ ++#undef _syscall3 ++#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \ ++type name(type1 arg1, type2 arg2, type3 arg3){ \ ++ __internal_syscall_body(name, 3, arg1, arg2, arg3); \ ++ __syscall_return(type, d0_retval); \ ++} ++ ++#undef _syscall4 ++#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ ++type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4){ \ ++ __internal_syscall_body(name, 4, arg1, arg2, arg3, arg4); \ ++ __syscall_return(type, d0_retval); \ ++} ++ ++#undef _syscall5 ++#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,type5,arg5) \ ++type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5){ \ ++ __internal_syscall_body(name, 5, arg1, arg2, arg3, arg4, arg5); \ ++ __syscall_return(type, d0_retval); \ ++} ++ ++#undef _syscall6 ++#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,type5,arg5,type6,arg6) \ ++type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5, type6 arg6){ \ ++ __internal_syscall_body(name, 6, arg1, arg2, arg3, arg4, arg5, arg6); \ ++ __syscall_return(type, d0_retval); \ ++} ++ ++#endif /* __ASSEMBLER__ */ ++#endif /* _BITS_SYSCALLS_H */ +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/bits/uClibc_arch_features.h +@@ -0,0 +1,45 @@ ++/* ++ * Track misc arch-specific features that aren't config options ++ */ ++ ++#ifndef _BITS_UCLIBC_ARCH_FEATURES_H ++#define _BITS_UCLIBC_ARCH_FEATURES_H ++ ++/* instruction used when calling abort() to kill yourself */ ++/*#define __UCLIBC_ABORT_INSTRUCTION__ "asm instruction"*/ ++#undef __UCLIBC_ABORT_INSTRUCTION__ ++ ++/* can your target use syscall6() for mmap ? */ ++#undef __UCLIBC_MMAP_HAS_6_ARGS__ ++ ++/* does your target use syscall4() for truncate64 ? (32bit arches only) */ ++#undef __UCLIBC_TRUNCATE64_HAS_4_ARGS__ ++ ++/* does your target have a broken create_module() ? */ ++#undef __UCLIBC_BROKEN_CREATE_MODULE__ ++ ++/* does your target have to worry about older [gs]etrlimit() ? */ ++#undef __UCLIBC_HANDLE_OLDER_RLIMIT__ ++ ++/* does your target prefix all symbols with an _ ? */ ++#define __UCLIBC_NO_UNDERSCORES__ ++ ++/* does your target have an asm .set ? */ ++#define __UCLIBC_HAVE_ASM_SET_DIRECTIVE__ ++ ++/* define if target doesn't like .global */ ++#undef __UCLIBC_ASM_GLOBAL_DIRECTIVE__ ++ ++/* define if target supports .weak */ ++#define __UCLIBC_HAVE_ASM_WEAK_DIRECTIVE__ ++ ++/* define if target supports .weakext */ ++#undef __UCLIBC_HAVE_ASM_WEAKEXT_DIRECTIVE__ ++ ++/* needed probably only for ppc64 */ ++#undef __UCLIBC_HAVE_ASM_GLOBAL_DOT_NAME__ ++ ++/* define if target supports IEEE signed zero floats */ ++#define __UCLIBC_HAVE_SIGNED_ZERO__ ++ ++#endif /* _BITS_UCLIBC_ARCH_FEATURES_H */ +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/bits/wordsize.h +@@ -0,0 +1,19 @@ ++/* Copyright (C) 1999 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#define __WORDSIZE 32 +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/clone.S +@@ -0,0 +1,71 @@ ++#include ++ ++ .global __syscall_error ++ ++/* int _clone(int (*fn)(void *arg), void *child_stack, int flags, void *arg); */ ++ .text ++ .type clone,@function ++ .global clone ++clone: ++ /* Sanity check arguments. */ ++ sub.4 #0, #0, d0 /* Test if fn is zero. */ ++ jmpeq.f 1f /* arg bad */ ++ sub.4 #0, #0, d1 /* Test if child_stack is zero. */ ++ jmpeq.f 1f /* arg bad */ ++ ++ /* Set up child_stack frame.. arg and fn */ ++ move.4 a3, d1 ++ move.4 -4(a3)++, d3 /* push 'arg' to child stack */ ++ move.4 -4(a3)++, d0 /* push fn to child stack, this will become a5 ++ * on new child */ ++ move.4 d1, a3 ++ move.4 -4(sp)++, a5 /* push a5 to our stack */ ++ ++ /* ++ * The syscall clone is clone(int flags, void *child_stack) so we set ++ * that up now ++ */ ++ move.4 d0, d2 /* Move flags to d0 */ ++ ++ /* Do Clone syscall */ ++ movei d8, #__NR_clone ++ moveai a5, #%hi(0x40400000) ++ calli a5, 0x10(a5) ++ move.4 a5, (sp)4++ /* pop a5 from stack */ ++ ++ /* Clone Complete */ ++ cmpi d0, #0 /* Test if d0 is less than zero. If it is we ++ * return the error */ ++ jmplt.f 2f /* If return is less than we had an error */ ++ jmpeq.f 3f /* If return is 0 we are in the clone, jump to ++ * thread start */ ++ ret a5 /* d0 is pid */ ++ ++ /* Invalid Value */ ++1: movei d0, #-22 /* EINVAL */ ++ ++ /* Call syscall Error */ ++2: sub.4 d0, #0, d0 /* d0 = -d0 */ ++#if defined(__UBICOM32_FDPIC__) ++ call a3, __syscall_error ++#else ++ moveai a3, #%hi(__syscall_error) ++ calli a3, %lo(__syscall_error)(a3) ++#endif ++ /* Child Thread Start */ ++3: ++#if defined(__UBICOM32_FDPIC__) ++ /* a5 actually contains a function descriptor for fdpic */ ++ move.4 a0, 4(a5) /* set GOT for this function */ ++ move.4 a5, 0(a5) /* get address of entry point */ ++#endif ++ move.4 d0, (sp)4++ /* pop 'arg' to stack */ ++ calli a5, 0(a5) ++ movei d8, #__NR_exit ++ moveai a3, #%hi(0x40400000) ++ calli a3, 0x10(a3) ++ ++ .size clone, . - clone ++ .global __GI_clone ++ .hidden __GI_clone ++ .set __GI_clone,clone +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/crt1.S +@@ -0,0 +1,179 @@ ++/* Startup code compliant to the ELF m68k ABI. ++ Copyright (C) 1996, 1997, 1998, 2001, 2002 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ In addition to the permissions in the GNU Lesser General Public ++ License, the Free Software Foundation gives you unlimited ++ permission to link the compiled version of this file with other ++ programs, and to distribute those programs without any restriction ++ coming from the use of this file. (The GNU Lesser General Public ++ License restrictions do apply in other respects; for example, they ++ cover modification of the file, and distribution when not linked ++ into another program.) ++ ++ Note that people who make modified versions of this file are not ++ obligated to grant this special exception for their modified ++ versions; it is their choice whether to do so. The GNU Lesser ++ General Public License gives permission to release a modified ++ version without this exception; this exception also makes it ++ possible to release a modified version which carries forward this ++ exception. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#include ++ ++/* This is the canonical entry point, usually the first thing in the text ++ segment. The SVR4/m68k ABI says that when the entry point runs, ++ most registers' values are unspecified, except for: ++ ++ %a1 Contains a function pointer to be registered with `atexit'. ++ This is how the dynamic linker arranges to have DT_FINI ++ functions called for shared libraries that have been loaded ++ before this code runs. ++ ++ %sp The stack contains the arguments and environment: ++ 0(%sp) argc ++ 4(%sp) argv[0] ++ ... ++ (4*argc)(%sp) NULL ++ (4*(argc+1))(%sp) envp[0] ++ ... ++ NULL ++ ++ The uclinux conventions are different. %a1 is not defined on entry ++ and the stack is laid out as follows: ++ ++ 0(%sp) argc ++ 4(%sp) argv ++ 8(%sp) envp ++*/ ++ ++ ++ .text ++ .type main,@function ++ .type _init,%function ++ .type _fini,%function ++#ifndef __UCLIBC_CTOR_DTOR__ ++ .weak _init ++ .weak _fini ++#endif ++ .globl _start ++ .global __uClibc_main; ++ .type __uClibc_main,@function; ++ .type _start,@function ++_start: ++ ++#if defined(__UBICOM32_FDPIC__) && !defined(L_Scrt1) ++ /* P0 contains a pointer to the program's load map. */ ++ call a3, .Lcall; ++.Lcall: ++ move.4 d0, d1 ; load exec_map_addr ++ moveai a4, #%hi(.Lcall) ++ lea.1 d15, %lo(.Lcall)(a4) ++ sub.4 d15, a3, d15 ; difference between .Lcall and actual address of .Lcall ++ moveai a3, #%hi(__ROFIXUP_LIST__) ++ lea.1 d1, %lo(__ROFIXUP_LIST__)(a3) ++ moveai a3, #%hi(__ROFIXUP_END__) ++ lea.1 d2, %lo(__ROFIXUP_END__)(a3) ++ add.4 d1, d1, d15 ++ add.4 d2, d2, d15 ++ call a5, __self_reloc ; returns GOT in d0 ++ move.4 a0, d0 ; set GOT ++#endif ++ ++/* ++ all this is setup to make the following call. ++ ++ void __uClibc_main( ++ d0 - int (*main)(int, char **, char **), ++ d1 - int argc, (d1) ++ d2 - char **argv, ++ d3 - void (*app_init)(void), ++ d4 - void (*app_fini)(void), ++ d5 - void (*rtld_fini)(void), ++ d6 - void *stack_end ++ ); ++ */ ++ ++ /* ++ * Load pointer to main into d0 ++ */ ++#ifdef __UBICOM32_FDPIC__ ++ movei d0, #%got_funcdesc_lo(main) ++ move.4 d0, (a0, d0) ++#else ++ moveai a3, #%hi(main) ++ lea.1 d0, %lo(main)(a3) ++#endif ++ ++ /* ++ * Grab the environment stuff from stack and set up d1, d2 with it. ++ */ ++ move.4 d1, (sp) ++#ifdef __UBICOM32_FDPIC__ ++ /* For FDPIC the calling convention is different than flat */ ++ lea.1 d2, 4(sp) ++#else ++ move.4 d2, 4(sp) ++#endif ++ ++#ifdef __UCLIBC_CTOR_DTOR__ ++ /* ++ * Load pointer to _init into d3 ++ */ ++#ifdef __UBICOM32_FDPIC__ ++ movei d3, #%got_funcdesc_lo(_init) ++ move.4 d3, (a0, d3) ++#else ++ moveai a3, #%hi(_init) ++ lea.1 d3, %lo(_init)(a3) ++#endif ++ ++ /* ++ * Load pointer to _fini into d4 ++ */ ++#ifdef __UBICOM32_FDPIC__ ++ movei d4, #%got_funcdesc_lo(_fini) ++ move.4 d4, (a0, d4) ++#else ++ moveai a3, #%hi(_fini) ++ lea.1 d4, %lo(_fini)(a3) ++#endif ++ ++#else /* !__UCLIBC_CTOR_DTOR__ */ ++ move.4 d3, #0 ; _init ++ move.4 d4, #0 ; _fini ++#endif ++ ++#ifdef __UBICOM32_FDPIC__ ++ move.4 d5, a1 ; ldso _fini funcdesc (see dl-startup.h) ++#else ++ movei d5, #0 ; rtld_fini (not used) ++#endif ++ ++ move.4 d6, sp ; Stack End. ++ ++ /* Call the user's main function, and exit with its value. But ++ let the libc call main. */ ++#ifdef __UBICOM32_FDPIC__ ++ call a5, __uClibc_main ++#else ++ moveai a5, #%hi(__uClibc_main) ++ calli a5, %lo(__uClibc_main)(a5) ++#endif ++ ++ bkpt #-1 ; Crash if somehow `exit' does return. +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/crti.S +@@ -0,0 +1,54 @@ ++/* Specialized code needed to support construction and destruction of ++ file-scope objects in C++ and Java code, and to support exception handling. ++ Copyright (C) 1999 Free Software Foundation, Inc. ++ Contributed by Charles-Antoine Gauthier (charles.gauthier@iit.nrc.ca). ++ ++This file is part of GCC. ++ ++GCC 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. ++ ++GCC 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 GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++/* As a special exception, if you link this library with files ++ compiled with GCC to produce an executable, this does not cause ++ the resulting executable to be covered by the GNU General Public License. ++ This exception does not however invalidate any other reasons why ++ the executable file might be covered by the GNU General Public License. */ ++ ++/* ++ * This file just supplies function prologues for the .init and .fini ++ * sections. It is linked in before crtbegin.o. ++ */ ++ .file "crti.o" ++ .ident "GNU C crti.o" ++ ++ .section .init ++ .align 2 ++ .globl _init ++ .type _init, @function ++_init: ++ move.4 -4(sp)++, a5 ++#ifdef __UBICOM32_FDPIC__ ++ move.4 -4(sp)++, a0 ++#endif ++ ++ .section .fini ++ .align 2 ++ .globl _fini ++ .type _fini, @function ++_fini: ++ move.4 -4(sp)++, a5 ++#ifdef __UBICOM32_FDPIC__ ++ move.4 -4(sp)++, a0 ++#endif +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/crtn.S +@@ -0,0 +1,47 @@ ++/* Specialized code needed to support construction and destruction of ++ file-scope objects in C++ and Java code, and to support exception handling. ++ Copyright (C) 1999 Free Software Foundation, Inc. ++ Contributed by Charles-Antoine Gauthier (charles.gauthier@iit.nrc.ca). ++ ++This file is part of GCC. ++ ++GCC 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. ++ ++GCC 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 GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++/* As a special exception, if you link this library with files ++ compiled with GCC to produce an executable, this does not cause ++ the resulting executable to be covered by the GNU General Public License. ++ This exception does not however invalidate any other reasons why ++ the executable file might be covered by the GNU General Public License. */ ++ ++/* ++ * This file supplies function epilogues for the .init and .fini sections. ++ * It is linked in after all other files. ++ */ ++ ++ .file "crtn.o" ++ .ident "GNU C crtn.o" ++ ++ .section .init ++#ifdef __UBICOM32_FDPIC__ ++ move.4 a0, (sp)4++ ++#endif ++ ret (sp)4++ ++ ++ .section .fini ++#ifdef __UBICOM32_FDPIC__ ++ move.4 a0, (sp)4++ ++#endif ++ ret (sp)4++ +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/crtreloc.c +@@ -0,0 +1,145 @@ ++/* Copyright (C) 2003, 2004 Free Software Foundation, Inc. ++ written by Alexandre Oliva ++This file is part of the GNU C Library. ++ ++The GNU C Library is free software; you can redistribute it and/or ++modify it under the terms of the GNU Lesser General Public License as ++published by the Free Software Foundation; either version 2.1 of the ++License, or (at your option) any later version. ++ ++In addition to the permissions in the GNU Lesser General Public ++License, the Free Software Foundation gives you unlimited ++permission to link the compiled version of this file with other ++programs, and to distribute those programs without any restriction ++coming from the use of this file. (The GNU Lesser General Public ++License restrictions do apply in other respects; for example, they ++cover modification of the file, and distribution when not linked ++into another program.) ++ ++The GNU C Library 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 ++Library General Public License for more details. ++ ++You should have received a copy of the GNU Lesser General Public ++License along with the GNU C Library; see the file COPYING.LIB. If ++not, write to the Free Software Foundation, Inc., 675 Mass Ave, ++Cambridge, MA 02139, USA. */ ++ ++#ifdef __UBICOM32_FDPIC__ ++ ++#include ++#include ++ ++/* This file is to be compiled into crt object files, to enable ++ executables to easily self-relocate. */ ++ ++union word { ++ char c[4]; ++ void *v; ++}; ++ ++/* Compute the runtime address of pointer in the range [p,e), and then ++ map the pointer pointed by it. */ ++static __always_inline void *** ++reloc_range_indirect (void ***p, void ***e, ++ const struct elf32_fdpic_loadmap *map) ++{ ++ while (p < e) ++ { ++ if (*p != (void **)-1) ++ { ++ void *ptr = __reloc_pointer (*p, map); ++ if (ptr != (void *)-1) ++ { ++ void *pt; ++ if ((long)ptr & 3) ++ { ++ unsigned char *c = ptr; ++ int i; ++ unsigned long v = 0; ++ for (i = 0; i < 4; i++) ++ v |= c[i] << 8 * i; ++ pt = (void *)v; ++ } ++ else ++ pt = *(void**)ptr; ++ pt = __reloc_pointer (pt, map); ++ if ((long)ptr & 3) ++ { ++ unsigned char *c = ptr; ++ int i; ++ unsigned long v = (unsigned long)pt; ++ for (i = 0; i < 4; i++, v >>= 8) ++ c[i] = v; ++ } ++ else ++ *(void**)ptr = pt; ++ } ++ } ++ p++; ++ } ++ return p; ++} ++ ++/* Call __reloc_range_indirect for the given range except for the last ++ entry, whose contents are only relocated. It's expected to hold ++ the GOT value. */ ++void* attribute_hidden ++__self_reloc (const struct elf32_fdpic_loadmap *map, ++ void ***p, void ***e) ++{ ++ p = reloc_range_indirect (p, e-1, map); ++ ++ if (p >= e) ++ return (void*)-1; ++ ++ return __reloc_pointer (*p, map); ++} ++ ++#if 0 ++/* These are other functions that might be useful, but that we don't ++ need. */ ++ ++/* Remap pointers in [p,e). */ ++static __always_inline void** ++reloc_range (void **p, void **e, ++ const struct elf32_fdpic_loadmap *map) ++{ ++ while (p < e) ++ { ++ *p = __reloc_pointer (*p, map); ++ p++; ++ } ++ return p; ++} ++ ++/* Remap p, adjust e by the same offset, then map the pointers in the ++ range determined by them. */ ++void attribute_hidden ++__reloc_range (const struct elf32_fdpic_loadmap *map, ++ void **p, void **e) ++{ ++ void **old = p; ++ ++ p = __reloc_pointer (p, map); ++ e += p - old; ++ reloc_range (p, e, map); ++} ++ ++/* Remap p, adjust e by the same offset, then map pointers referenced ++ by the (unadjusted) pointers in the range. Return the relocated ++ value of the last pointer in the range. */ ++void* attribute_hidden ++__reloc_range_indirect (const struct elf32_fdpic_loadmap *map, ++ void ***p, void ***e) ++{ ++ void ***old = p; ++ ++ p = __reloc_pointer (p, map); ++ e += p - old; ++ return reloc_range_indirect (p, e, map); ++} ++#endif ++ ++#endif /* __UBICOM32_FDPIC__ */ +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/setjmp.S +@@ -0,0 +1,72 @@ ++/* Setjmp for Ubicom32 */ ++ .text ++ .global _setjmp ++ .type _setjmp,@function ++_setjmp: ++ movea a3, d0 ; A3 now holds the jmp buf that was passed in. ++ move.4 (a3)4++, d10 ++ move.4 (a3)4++, d11 ++ move.4 (a3)4++, d12 ++ move.4 (a3)4++, d13 ++ move.4 (a3)4++, a1 ++ move.4 (a3)4++, a2 ++ move.4 (a3)4++, a5 ++ move.4 (a3)4++, a6 ++ move.4 (a3)4++, a7 ++ move.4 d0, #0 ++ ++ calli a5, 0(a5) ++ .size _setjmp, . - _setjmp ++ ++/* ++ * __sigsetjmp for Ubicom32 ++ * d0 holds sigjmp_buf and d1 holds the savemask. We will save the frame and then just call __sigjmp_save to do the mask save. ++ */ ++ .global __sigsetjmp ++ .type __sigsetjmp,@function ++__sigsetjmp: ++ movea a3, d0 ; A3 now holds the jmp buf that was passed in. ++ move.4 (a3)4++, d10 ++ move.4 (a3)4++, d11 ++ move.4 (a3)4++, d12 ++ move.4 (a3)4++, d13 ++ move.4 (a3)4++, a1 ++ move.4 (a3)4++, a2 ++ move.4 (a3)4++, a5 ++ move.4 (a3)4++, a6 ++ move.4 (a3)4++, a7 ++ ++ ;; The frame has been saved. Call _sigjmp_save to get sigmask saved. a5 still has the return address and it will go back to that. ++#if defined(__UBICOM32_FDPIC__) ++ call a3, __sigjmp_save ++#else ++ moveai a3, #%hi(__sigjmp_save) ++ calli a3, %lo(__sigjmp_save)(a3) ++#endif ++ .size __sigjmp_save, . - __sigjmp_save ++ ++ .global __longjmp ++ .type __longjmp,@function ++__longjmp: ++ movea a3, d0 ; A3 now holds the jmp buf that was passed in. ++ move.4 d10, (a3)4++ ++ move.4 d11, (a3)4++ ++ move.4 d12, (a3)4++ ++ move.4 d13, (a3)4++ ++ move.4 a1 , (a3)4++ ++ move.4 a2 , (a3)4++ ++ move.4 a5 , (a3)4++ ++ move.4 a6 , (a3)4++ ++ move.4 a7 , (a3)4++ ++ ++ sub.4 #0, #0, d1 ; Test if d1 is zero. If it is we have to return 1 other wise return content of d1 ++ jmpeq.t 2f ++ move.4 d0, d1 ; d1 is non zero load it into d0 ++ jmpt.t 3f ++ ++2: move.4 d0, #1 ++3: calli a5, 0(a5) ++ .size __longjmp, . - __longjmp ++ .global __GI___longjmp ++ .hidden __GI___longjmp ++ .set __GI___longjmp,__longjmp +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/sys/procfs.h +@@ -0,0 +1,122 @@ ++/* Copyright (C) 1996, 1997, 1999, 2000 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#ifndef _SYS_PROCFS_H ++#define _SYS_PROCFS_H 1 ++ ++/* This is somehow modelled after the file of the same name on SysVr4 ++ systems. It provides a definition of the core file format for ELF ++ used on Linux. */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++__BEGIN_DECLS ++ ++#define ELF_NGREG 38 ++ ++typedef struct ++ { ++ union ++ { ++ unsigned long pr_regs[32]; ++ double pr_dregs[16]; ++ } pr_fr; ++ unsigned long __unused; ++ unsigned long pr_fsr; ++ unsigned char pr_qcnt; ++ unsigned char pr_q_entrysize; ++ unsigned char pr_en; ++ unsigned int pr_q[64]; ++ } elf_fpregset_t; ++ ++typedef unsigned long elf_greg_t; ++typedef elf_greg_t elf_gregset_t[ELF_NGREG]; ++ ++struct elf_siginfo ++ { ++ int si_signo; /* Signal number. */ ++ int si_code; /* Extra code. */ ++ int si_errno; /* Errno. */ ++ }; ++ ++/* Definitions to generate Intel SVR4-like core files. These mostly ++ have the same names as the SVR4 types with "elf_" tacked on the ++ front to prevent clashes with linux definitions, and the typedef ++ forms have been avoided. This is mostly like the SVR4 structure, ++ but more Linuxy, with things that Linux does not support and which ++ gdb doesn't really use excluded. Fields present but not used are ++ marked with "XXX". */ ++struct elf_prstatus ++ { ++ struct elf_siginfo pr_info; /* Info associated with signal. */ ++ short int pr_cursig; /* Current signal. */ ++ unsigned long int pr_sigpend; /* Set of pending signals. */ ++ unsigned long int pr_sighold; /* Set of held signals. */ ++ __pid_t pr_pid; ++ __pid_t pr_ppid; ++ __pid_t pr_pgrp; ++ __pid_t pr_sid; ++ struct timeval pr_utime; /* User time. */ ++ struct timeval pr_stime; /* System time. */ ++ struct timeval pr_cutime; /* Cumulative user time. */ ++ struct timeval pr_cstime; /* Cumulative system time. */ ++ elf_gregset_t pr_reg; /* GP registers. */ ++ int pr_fpvalid; /* True if math copro being used. */ ++ }; ++ ++ ++#define ELF_PRARGSZ (80) /* Number of chars for args */ ++ ++struct elf_prpsinfo ++ { ++ char pr_state; /* Numeric process state. */ ++ char pr_sname; /* Char for pr_state. */ ++ char pr_zomb; /* Zombie. */ ++ char pr_nice; /* Nice val. */ ++ unsigned long int pr_flag; /* Flags. */ ++ unsigned short int pr_uid; ++ unsigned short int pr_gid; ++ int pr_pid, pr_ppid, pr_pgrp, pr_sid; ++ /* Lots missing */ ++ char pr_fname[16]; /* Filename of executable. */ ++ char pr_psargs[ELF_PRARGSZ]; /* Initial part of arg list. */ ++ }; ++ ++/* Addresses. */ ++typedef void *psaddr_t; ++ ++/* Register sets. Linux has different names. */ ++typedef elf_gregset_t prgregset_t; ++typedef elf_fpregset_t prfpregset_t; ++ ++/* We don't have any differences between processes and threads, ++ therefore have only one PID type. */ ++typedef __pid_t lwpid_t; ++ ++ ++typedef struct elf_prstatus prstatus_t; ++typedef struct elf_prpsinfo prpsinfo_t; ++ ++__END_DECLS ++ ++#endif /* sys/procfs.h */ +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/sys/ucontext.h +@@ -0,0 +1,104 @@ ++/* Copyright (C) 1998, 1999 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#ifndef _SYS_UCONTEXT_H ++#define _SYS_UCONTEXT_H 1 ++ ++#include ++#include ++/* ++ * Location of the users' stored registers relative to R0. ++ * Usage is as an index into a gregset_t array or as u.u_ar0[XX]. ++ */ ++#define REG_PSR (0) ++#define REG_PC (1) ++#define REG_SPARE (2) ++#define REG_WVALID (3) ++#define REG_G1 (4) ++#define REG_G2 (5) ++#define REG_G3 (6) ++#define REG_G4 (7) ++#define REG_G5 (8) ++#define REG_G6 (9) ++#define REG_G7 (10) ++#define REG_O0 (11) ++#define REG_O1 (12) ++#define REG_O2 (13) ++#define REG_O3 (14) ++#define REG_O4 (15) ++#define REG_O5 (16) ++#define REG_O6 (17) ++#define REG_O7 (18) ++#define REG_GLOBALS (19) ++ ++/* ++ * A gregset_t is defined as an array type for compatibility with the reference ++ * source. This is important due to differences in the way the C language ++ * treats arrays and structures as parameters. ++ * ++ * Note that NGREG is really (sizeof (struct regs) / sizeof (greg_t)), ++ * but that the ABI defines it absolutely to be 21 (resp. 19). ++ */ ++ ++#define NGREG 20 ++typedef int greg_t; ++ ++typedef greg_t gregset_t[NGREG]; ++ ++/* ++ * The following structures define how a register window can appear on the ++ * stack. This structure is available (when required) through the `gwins' ++ * field of an mcontext (nested within ucontext). NIOS_MAXWINDOW is the ++ * maximum number of outstanding register windows defined in the NIOS ++ * architecture (*not* implementation). ++ */ ++#define NIOS_MAXREGWINDOW 31 /* max windows in NIOS arch. */ ++struct rwindow ++ { ++ greg_t rw_local[8]; /* locals */ ++ greg_t rw_in[8]; /* ins */ ++ }; ++ ++#define rw_fp rw_in[6] /* frame pointer */ ++#define rw_rtn rw_in[7] /* return address */ ++ ++typedef struct gwindows ++ { ++ int wbcnt; ++ int *spbuf[NIOS_MAXREGWINDOW]; ++ struct rwindow wbuf[NIOS_MAXREGWINDOW]; ++ } gwindows_t; ++ ++typedef struct ++ { ++ gregset_t gregs; /* general register set */ ++ gwindows_t *gwins; /* POSSIBLE pointer to register windows */ ++ } mcontext_t; ++ ++ ++/* Userlevel context. */ ++typedef struct ucontext ++ { ++ unsigned long uc_flags; ++ struct ucontext *uc_link; ++ __sigset_t uc_sigmask; ++ stack_t uc_stack; ++ mcontext_t uc_mcontext; ++ } ucontext_t; ++ ++#endif /* sys/ucontext.h */ +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/syscall.c +@@ -0,0 +1,32 @@ ++/* vi: set sw=4 ts=4: */ ++/* syscall for ubicom32/uClibc ++ * ++ * Copyright (C) 2008 by Ubicom Inc. ++ * Copyright (C) 2002 by Erik Andersen ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU Library 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 Library General Public License ++ * for more details. ++ * ++ * You should have received a copy of the GNU Library 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 ++#include ++#include ++#include ++ ++extern long syscall(long sysnum, long a, long b, long c, long d, long e, long f); ++long syscall(long sysnum, long a, long b, long c, long d, long e, long f) ++{ ++ int __NR_syscall_number = sysnum; ++ return (long) INLINE_SYSCALL(syscall_number, 6, a, b, c, d, e, f); ++} +--- /dev/null ++++ b/libc/sysdeps/linux/ubicom32/vfork.S +@@ -0,0 +1,35 @@ ++#include ++ ++ .text ++ .type vfork,@function ++ .global vfork ++vfork: ++ move.4 -4(sp)++, a5 ; Save return address on the stack. ++ movei d8, #__NR_vfork ++ moveai a3, #%hi(0x40400000) ++ calli a5, 0x10(a3) ++ ++ /* ++ * You get here only if the syscall bombed. If things had worked out the ++ * parent and child would have both returned to the instruction after ++ * the vfork call. ++ */ ++ move.4 a5, (sp)4++ ; Pop the return address off the stack. ++ movei d1, #-125 ++ sub.4 #0, d0, d1 ++ jmplt.t 1f ++ ++ ;; We have an error. ++ sub.4 d0, #0, d0 ; d0 = -res. Call __set_errno with that. ++#if defined(__UBICOM32_FDPIC__) ++ call a3, __syscall_error ++#else ++ moveai a3, #%hi(__syscall_error) ++ calli a3, %lo(__syscall_error)(a3) ; __syscall_error will return -1 and not come back here. ++#endif ++1: ++ calli a5, 0(a5) ++ .size vfork, . - vfork ++ .global __GI_vfork ++ .hidden __GI_vfork ++ .set __GI_vfork,vfork +--- a/libpthread/linuxthreads.old/pthread.c ++++ b/libpthread/linuxthreads.old/pthread.c +@@ -393,6 +393,10 @@ void __pthread_initialize_minimal(void) + #endif + + __libc_multiple_threads_ptr = __libc_pthread_init (ptr_pthread_functions); ++#ifndef __ARCH_USE_MMU__ ++ __pthread_initial_thread_tos = ++ (char *)(((long)CURRENT_STACK_FRAME + getpagesize()) & ~(getpagesize() - 1)); ++#endif /* __ARCH_USE_MMU__ */ + } + + +@@ -461,8 +465,11 @@ static void pthread_initialize(void) + * __pthread_initial_thread_bos at address 0. These bounds are refined as we + * malloc other stack frames such that they don't overlap. -StS + */ +- __pthread_initial_thread_tos = +- (char *)(((long)CURRENT_STACK_FRAME + getpagesize()) & ~(getpagesize() - 1)); ++ if (__pthread_initial_thread_tos == NULL) { ++ __pthread_initial_thread_tos = ++ (char *)(((long)CURRENT_STACK_FRAME + getpagesize()) & ~(getpagesize() - 1)); ++ } ++ + __pthread_initial_thread_bos = (char *) 1; /* set it non-zero so we know we have been here */ + PDEBUG("initial thread stack bounds: bos=%p, tos=%p\n", + __pthread_initial_thread_bos, __pthread_initial_thread_tos); +--- /dev/null ++++ b/libpthread/linuxthreads.old/sysdeps/ubicom32/pt-machine.h +@@ -0,0 +1,68 @@ ++/* Machine-dependent pthreads configuration and inline functions. ++ ++ Copyright (C) 1996, 1997, 1998, 2000, 2002, 2003, 2004 ++ Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ Contributed by Ralf Baechle . ++ Based on the Alpha version by Richard Henderson . ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public License as ++ published by the Free Software Foundation; either version 2.1 of the ++ License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; see the file COPYING.LIB. If ++ not, write to the Free Software Foundation, Inc., ++ 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ ++ ++#ifndef _PT_MACHINE_H ++#define _PT_MACHINE_H 1 ++ ++#include ++ ++/* ++ * XXX try to make this inline ++ */ ++extern long int testandset (int *spinlock); ++ ++#ifndef PT_EI ++#define PT_EI ++#else ++/* Spinlock implementation; required. */ ++ ++/* ++ * testandset() is the basis for the pthread spin lock. ++ * ++ * This implementation only requires that we 'set' the state of *spinlock. As ++ * bset is allows us to atomically 'testandset' a single bit define our 'set' is ++ * such that we will set bit 0 (ignoring all other bits, which should also be ++ * zero). ++ * Return value of 1 implies that the bit was already set and is still ++ * set. ++ * Return value of 0 implies that the bit was not previously set but it ++ * now is. ++ */ ++long int ++testandset (int *spinlock) ++{ ++ int ret; ++ __asm__ volatile ( ++ " move.4 %0, #0 \n\t" /* Assume that the bit is not currently set */ ++ " bset %1, %1, #0 \n\t" /* Attempt to 'set' bit 0 */ ++ " jmpeq.t 1f \n\t" ++ " move.4 %0, #1 \n\t" /* Bit was already set, so return 1 */ ++ " 1: \n\t" ++ : "=r"(ret), "+U4"(*spinlock) ++ : ++ : "memory", "cc" ++ ); ++ return ret; ++} ++#endif ++#endif /* pt-machine.h */ +--- /dev/null ++++ b/libpthread/linuxthreads.old/sysdeps/ubicom32/tls.h +@@ -0,0 +1,26 @@ ++/* Definitions for thread-local data handling. linuxthreads/MIPS version. ++ Copyright (C) 2005 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#ifndef _TLS_H ++#define _TLS_H ++#ifdef HAVE_TLS_SUPPORT ++#warning no tls support ++#undef USE_TLS ++#endif ++#endif /* tls.h */