crosstool-ng: patches/binutils/2.18a/130-avr32-atmel-v1.0.1.patch@346263a07115

     1 --- a/bfd/archures.c

     2 +++ b/bfd/archures.c

     3 @@ -346,6 +346,11 @@ DESCRIPTION

     4  .#define bfd_mach_avr4		4

     5  .#define bfd_mach_avr5		5

     6  .#define bfd_mach_avr6		6

     7 +.  bfd_arch_avr32,     {* Atmel AVR32 *}

     8 +.#define bfd_mach_avr32_ap	7000

     9 +.#define bfd_mach_avr32_uc	3000

    10 +.#define bfd_mach_avr32_ucr1    3001

    11 +.#define bfd_mach_avr32_ucr2    3002

    12  .  bfd_arch_bfin,        {* ADI Blackfin *}

    13  .#define bfd_mach_bfin          1

    14  .  bfd_arch_cr16,       {* National Semiconductor CompactRISC (ie CR16). *}

    15 @@ -438,6 +443,7 @@ extern const bfd_arch_info_type bfd_alph

    16  extern const bfd_arch_info_type bfd_arc_arch;

    17  extern const bfd_arch_info_type bfd_arm_arch;

    18  extern const bfd_arch_info_type bfd_avr_arch;

    19 +extern const bfd_arch_info_type bfd_avr32_arch;

    20  extern const bfd_arch_info_type bfd_bfin_arch;

    21  extern const bfd_arch_info_type bfd_cr16_arch;

    22  extern const bfd_arch_info_type bfd_cr16c_arch;

    23 @@ -509,6 +515,7 @@ static const bfd_arch_info_type * const

    24      &bfd_arc_arch,

    25      &bfd_arm_arch,

    26      &bfd_avr_arch,

    27 +    &bfd_avr32_arch,

    28      &bfd_bfin_arch,

    29      &bfd_cr16_arch,

    30      &bfd_cr16c_arch,

    31 --- a/bfd/config.bfd

    32 +++ b/bfd/config.bfd

    33 @@ -335,6 +335,10 @@ case "${targ}" in

    34      targ_underscore=yes

    35      ;;

    37 +  avr32-*-*)

    38 +    targ_defvec=bfd_elf32_avr32_vec

    39 +    ;;

    40 +

    41    c30-*-*aout* | tic30-*-*aout*)

    42      targ_defvec=tic30_aout_vec

    43      ;;

    44 --- a/bfd/configure.in

    45 +++ b/bfd/configure.in

    46 @@ -8,7 +8,7 @@ AC_CONFIG_SRCDIR([libbfd.c])

    47  AC_CANONICAL_TARGET

    48  AC_ISC_POSIX

    50 -AM_INIT_AUTOMAKE(bfd, 2.18)

    51 +AM_INIT_AUTOMAKE(bfd, 2.18.atmel.1.0.1.avr32linux.1)

    53  dnl These must be called before AM_PROG_LIBTOOL, because it may want

    54  dnl to call AC_CHECK_PROG.

    55 @@ -619,6 +619,7 @@ do

    56      bfd_efi_app_ia64_vec)	tb="$tb efi-app-ia64.lo pepigen.lo cofflink.lo"; target_size=64 ;;

    57      bfd_elf32_am33lin_vec)	tb="$tb elf32-am33lin.lo elf32.lo $elf" ;;

    58      bfd_elf32_avr_vec)		tb="$tb elf32-avr.lo elf32.lo $elf" ;;

    59 +    bfd_elf32_avr32_vec)	tb="$tb elf32-avr32.lo elf32.lo $elf" ;;

    60      bfd_elf32_bfin_vec)		tb="$tb elf32-bfin.lo elf32.lo $elf" ;;

    61      bfd_elf32_bfinfdpic_vec)	tb="$tb elf32-bfin.lo elf32.lo $elf" ;;

    62      bfd_elf32_big_generic_vec) 	tb="$tb elf32-gen.lo elf32.lo $elf" ;;

    63 --- /dev/null

    64 +++ b/bfd/cpu-avr32.c

    65 @@ -0,0 +1,51 @@

    66 +/* BFD library support routines for AVR32.

    67 +   Copyright 2003-2006 Atmel Corporation.

    68 +

    69 +   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>

    70 +

    71 +   This is part of BFD, the Binary File Descriptor library.

    72 +

    73 +   This program is free software; you can redistribute it and/or modify

    74 +   it under the terms of the GNU General Public License as published by

    75 +   the Free Software Foundation; either version 2 of the License, or

    76 +   (at your option) any later version.

    77 +

    78 +   This program is distributed in the hope that it will be useful,

    79 +   but WITHOUT ANY WARRANTY; without even the implied warranty of

    80 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    81 +   GNU General Public License for more details.

    82 +

    83 +   You should have received a copy of the GNU General Public License

    84 +   along with this program; if not, write to the Free Software

    85 +   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

    86 +

    87 +#include "bfd.h"

    88 +#include "sysdep.h"

    89 +#include "libbfd.h"

    90 +

    91 +#define N(machine, print, default, next)			\

    92 +  {								\

    93 +    32,				/* 32 bits in a word */		\

    94 +    32,				/* 32 bits in an address */	\

    95 +    8,				/* 8 bits in a byte */		\

    96 +    bfd_arch_avr32,		/* architecture */		\

    97 +    machine,			/* machine */			\

    98 +    "avr32",			/* arch name */			\

    99 +    print,			/* printable name */		\

   100 +    1,				/* section align power */	\

   101 +    default,			/* the default machine? */	\

   102 +    bfd_default_compatible,					\

   103 +    bfd_default_scan,						\

   104 +    next,							\

   105 +  }

   106 +

   107 +static const bfd_arch_info_type cpu_info[] =

   108 +{

   109 +  N(bfd_mach_avr32_ap, "avr32:ap", FALSE, &cpu_info[1]),

   110 +  N(bfd_mach_avr32_uc, "avr32:uc", FALSE, &cpu_info[2]),

   111 +  N(bfd_mach_avr32_ucr1, "avr32:ucr1", FALSE, &cpu_info[3]),

   112 +  N(bfd_mach_avr32_ucr2, "avr32:ucr2", FALSE, NULL),

   113 +};

   114 +

   115 +const bfd_arch_info_type bfd_avr32_arch =

   116 +  N(bfd_mach_avr32_ap, "avr32", TRUE, &cpu_info[0]);

   117 --- /dev/null

   118 +++ b/bfd/elf32-avr32.c

   119 @@ -0,0 +1,3915 @@

   120 +/* AVR32-specific support for 32-bit ELF.

   121 +   Copyright 2003-2006 Atmel Corporation.

   122 +

   123 +   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>

   124 +

   125 +   This file is part of BFD, the Binary File Descriptor library.

   126 +

   127 +   This program is free software; you can redistribute it and/or modify

   128 +   it under the terms of the GNU General Public License as published by

   129 +   the Free Software Foundation; either version 2 of the License, or

   130 +   (at your option) any later version.

   131 +

   132 +   This program is distributed in the hope that it will be useful,

   133 +   but WITHOUT ANY WARRANTY; without even the implied warranty of

   134 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   135 +   GNU General Public License for more details.

   136 +

   137 +   You should have received a copy of the GNU General Public License

   138 +   along with this program; if not, write to the Free Software

   139 +   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */

   140 +

   141 +#include "bfd.h"

   142 +#include "sysdep.h"

   143 +#include "bfdlink.h"

   144 +#include "libbfd.h"

   145 +#include "elf-bfd.h"

   146 +#include "elf/avr32.h"

   147 +#include "elf32-avr32.h"

   148 +

   149 +#define xDEBUG

   150 +#define xRELAX_DEBUG

   151 +

   152 +#ifdef DEBUG

   153 +# define pr_debug(fmt, args...) fprintf(stderr, fmt, ##args)

   154 +#else

   155 +# define pr_debug(fmt, args...) do { } while (0)

   156 +#endif

   157 +

   158 +#ifdef RELAX_DEBUG

   159 +# define RDBG(fmt, args...) fprintf(stderr, fmt, ##args)

   160 +#else

   161 +# define RDBG(fmt, args...) do { } while (0)

   162 +#endif

   163 +

   164 +/* When things go wrong, we want it to blow up, damnit! */

   165 +#undef BFD_ASSERT

   166 +#undef abort

   167 +#define BFD_ASSERT(expr)					\

   168 +  do								\

   169 +    {								\

   170 +      if (!(expr))						\

   171 +	{							\

   172 +	  bfd_assert(__FILE__, __LINE__);			\

   173 +	  abort();						\

   174 +	}							\

   175 +    }								\

   176 +  while (0)

   177 +

   178 +/* The name of the dynamic interpreter. This is put in the .interp section. */

   179 +#define ELF_DYNAMIC_INTERPRETER		"/lib/ld.so.1"

   180 +

   181 +#define AVR32_GOT_HEADER_SIZE		8

   182 +#define AVR32_FUNCTION_STUB_SIZE	8

   183 +

   184 +#define ELF_R_INFO(x, y) ELF32_R_INFO(x, y)

   185 +#define ELF_R_TYPE(x) ELF32_R_TYPE(x)

   186 +#define ELF_R_SYM(x) ELF32_R_SYM(x)

   187 +

   188 +#define NOP_OPCODE 0xd703

   189 +

   190 +

   191 +/* Mapping between BFD relocations and ELF relocations */

   192 +

   193 +static reloc_howto_type *

   194 +bfd_elf32_bfd_reloc_type_lookup(bfd *abfd, bfd_reloc_code_real_type code);

   195 +

   196 +static reloc_howto_type *

   197 +bfd_elf32_bfd_reloc_name_lookup(bfd *abfd, const char *r_name);

   198 +

   199 +static void

   200 +avr32_info_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst);

   201 +

   202 +/* Generic HOWTO */

   203 +#define GENH(name, align, size, bitsize, pcrel, bitpos, complain, mask)	\

   204 +  HOWTO(name, align, size, bitsize, pcrel, bitpos,			\

   205 +	complain_overflow_##complain, bfd_elf_generic_reloc, #name,	\

   206 +	FALSE, 0, mask, pcrel)

   207 +

   208 +static reloc_howto_type elf_avr32_howto_table[] = {

   209 +  /*   NAME		 ALN SZ BSZ PCREL  BP COMPLAIN  MASK	    */

   210 +  GENH(R_AVR32_NONE,	  0, 0, 0,  FALSE, 0, dont,	0x00000000),

   211 +

   212 +  GENH(R_AVR32_32,	  0, 2, 32, FALSE, 0, dont,	0xffffffff),

   213 +  GENH(R_AVR32_16,	  0, 1, 16, FALSE, 0, bitfield,	0x0000ffff),

   214 +  GENH(R_AVR32_8,	  0, 0,  8, FALSE, 0, bitfield,	0x000000ff),

   215 +  GENH(R_AVR32_32_PCREL,  0, 2, 32, TRUE,  0, signed,   0xffffffff),

   216 +  GENH(R_AVR32_16_PCREL,  0, 1, 16, TRUE,  0, signed,   0x0000ffff),

   217 +  GENH(R_AVR32_8_PCREL,	  0, 0,  8, TRUE,  0, signed,   0x000000ff),

   218 +

   219 +  /* Difference between two symbol (sym2 - sym1).  The reloc encodes

   220 +     the value of sym1.  The field contains the difference before any

   221 +     relaxing is done.  */

   222 +  GENH(R_AVR32_DIFF32,	  0, 2, 32, FALSE, 0, dont,	0xffffffff),

   223 +  GENH(R_AVR32_DIFF16,	  0, 1, 16, FALSE, 0, signed,	0x0000ffff),

   224 +  GENH(R_AVR32_DIFF8,	  0, 0,  8, FALSE, 0, signed,	0x000000ff),

   225 +

   226 +  GENH(R_AVR32_GOT32,	  0, 2, 32, FALSE, 0, signed,	0xffffffff),

   227 +  GENH(R_AVR32_GOT16,	  0, 1, 16, FALSE, 0, signed,	0x0000ffff),

   228 +  GENH(R_AVR32_GOT8,	  0, 0,  8, FALSE, 0, signed,	0x000000ff),

   229 +

   230 +  GENH(R_AVR32_21S,	  0, 2, 21, FALSE, 0, signed,	0x1e10ffff),

   231 +  GENH(R_AVR32_16U,	  0, 2, 16, FALSE, 0, unsigned,	0x0000ffff),

   232 +  GENH(R_AVR32_16S,	  0, 2, 16, FALSE, 0, signed,	0x0000ffff),

   233 +  GENH(R_AVR32_8S,	  0, 1,  8, FALSE, 4, signed,	0x00000ff0),

   234 +  GENH(R_AVR32_8S_EXT,	  0, 2,  8, FALSE, 0, signed,	0x000000ff),

   235 +

   236 +  GENH(R_AVR32_22H_PCREL, 1, 2, 21, TRUE,  0, signed,	0x1e10ffff),

   237 +  GENH(R_AVR32_18W_PCREL, 2, 2, 16, TRUE,  0, signed,	0x0000ffff),

   238 +  GENH(R_AVR32_16B_PCREL, 0, 2, 16, TRUE,  0, signed,	0x0000ffff),

   239 +  GENH(R_AVR32_16N_PCREL, 0, 2, 16, TRUE,  0, signed,	0x0000ffff),

   240 +  GENH(R_AVR32_14UW_PCREL, 2, 2, 12, TRUE, 0, unsigned, 0x0000f0ff),

   241 +  GENH(R_AVR32_11H_PCREL, 1, 1, 10, TRUE,  4, signed,	0x00000ff3),

   242 +  GENH(R_AVR32_10UW_PCREL, 2, 2, 8, TRUE,  0, unsigned, 0x000000ff),

   243 +  GENH(R_AVR32_9H_PCREL,  1, 1,  8, TRUE,  4, signed,	0x00000ff0),

   244 +  GENH(R_AVR32_9UW_PCREL, 2, 1,  7, TRUE,  4, unsigned,	0x000007f0),

   245 +

   246 +  GENH(R_AVR32_HI16,	 16, 2, 16, FALSE, 0, dont,	0x0000ffff),

   247 +  GENH(R_AVR32_LO16,	  0, 2, 16, FALSE, 0, dont,	0x0000ffff),

   248 +

   249 +  GENH(R_AVR32_GOTPC,	  0, 2, 32, FALSE, 0, dont,	0xffffffff),

   250 +  GENH(R_AVR32_GOTCALL,   2, 2, 21, FALSE, 0, signed,	0x1e10ffff),

   251 +  GENH(R_AVR32_LDA_GOT,	  2, 2, 21, FALSE, 0, signed,	0x1e10ffff),

   252 +  GENH(R_AVR32_GOT21S,	  0, 2, 21, FALSE, 0, signed,	0x1e10ffff),

   253 +  GENH(R_AVR32_GOT18SW,	  2, 2, 16, FALSE, 0, signed,	0x0000ffff),

   254 +  GENH(R_AVR32_GOT16S,	  0, 2, 16, FALSE, 0, signed,	0x0000ffff),

   255 +  GENH(R_AVR32_GOT7UW,	  2, 1,  5, FALSE, 4, unsigned, 0x000001f0),

   256 +

   257 +  GENH(R_AVR32_32_CPENT,  0, 2, 32, FALSE, 0, dont,	0xffffffff),

   258 +  GENH(R_AVR32_CPCALL,	  2, 2, 16, TRUE,  0, signed,	0x0000ffff),

   259 +  GENH(R_AVR32_16_CP,	  0, 2, 16, TRUE,  0, signed,	0x0000ffff),

   260 +  GENH(R_AVR32_9W_CP,	  2, 1,  7, TRUE,  4, unsigned, 0x000007f0),

   261 +

   262 +  GENH(R_AVR32_RELATIVE,  0, 2, 32, FALSE, 0, signed,	0xffffffff),

   263 +  GENH(R_AVR32_GLOB_DAT,  0, 2, 32, FALSE, 0, dont,	0xffffffff),

   264 +  GENH(R_AVR32_JMP_SLOT,  0, 2, 32, FALSE, 0, dont,	0xffffffff),

   265 +

   266 +  GENH(R_AVR32_ALIGN,	  0, 1, 0,  FALSE, 0, unsigned, 0x00000000),

   267 +

   268 +  GENH(R_AVR32_15S,	  2, 2, 15, FALSE, 0, signed,	0x00007fff),

   269 +};

   270 +

   271 +struct elf_reloc_map

   272 +{

   273 +  bfd_reloc_code_real_type bfd_reloc_val;

   274 +  unsigned char elf_reloc_val;

   275 +};

   276 +

   277 +static const struct elf_reloc_map avr32_reloc_map[] =

   278 +{

   279 +  { BFD_RELOC_NONE,			R_AVR32_NONE },

   280 +

   281 +  { BFD_RELOC_32,			R_AVR32_32 },

   282 +  { BFD_RELOC_16,			R_AVR32_16 },

   283 +  { BFD_RELOC_8,			R_AVR32_8 },

   284 +  { BFD_RELOC_32_PCREL,			R_AVR32_32_PCREL },

   285 +  { BFD_RELOC_16_PCREL,			R_AVR32_16_PCREL },

   286 +  { BFD_RELOC_8_PCREL,			R_AVR32_8_PCREL },

   287 +  { BFD_RELOC_AVR32_DIFF32,		R_AVR32_DIFF32 },

   288 +  { BFD_RELOC_AVR32_DIFF16,		R_AVR32_DIFF16 },

   289 +  { BFD_RELOC_AVR32_DIFF8,		R_AVR32_DIFF8 },

   290 +  { BFD_RELOC_AVR32_GOT32,		R_AVR32_GOT32 },

   291 +  { BFD_RELOC_AVR32_GOT16,		R_AVR32_GOT16 },

   292 +  { BFD_RELOC_AVR32_GOT8,		R_AVR32_GOT8 },

   293 +

   294 +  { BFD_RELOC_AVR32_21S,		R_AVR32_21S },

   295 +  { BFD_RELOC_AVR32_16U,		R_AVR32_16U },

   296 +  { BFD_RELOC_AVR32_16S,		R_AVR32_16S },

   297 +  { BFD_RELOC_AVR32_SUB5,		R_AVR32_16S },

   298 +  { BFD_RELOC_AVR32_8S_EXT,		R_AVR32_8S_EXT },

   299 +  { BFD_RELOC_AVR32_8S,			R_AVR32_8S },

   300 +

   301 +  { BFD_RELOC_AVR32_22H_PCREL,		R_AVR32_22H_PCREL },

   302 +  { BFD_RELOC_AVR32_18W_PCREL,		R_AVR32_18W_PCREL },

   303 +  { BFD_RELOC_AVR32_16B_PCREL,		R_AVR32_16B_PCREL },

   304 +  { BFD_RELOC_AVR32_16N_PCREL,		R_AVR32_16N_PCREL },

   305 +  { BFD_RELOC_AVR32_11H_PCREL,		R_AVR32_11H_PCREL },

   306 +  { BFD_RELOC_AVR32_10UW_PCREL,		R_AVR32_10UW_PCREL },

   307 +  { BFD_RELOC_AVR32_9H_PCREL,		R_AVR32_9H_PCREL },

   308 +  { BFD_RELOC_AVR32_9UW_PCREL,		R_AVR32_9UW_PCREL },

   309 +

   310 +  { BFD_RELOC_HI16,			R_AVR32_HI16 },

   311 +  { BFD_RELOC_LO16,			R_AVR32_LO16 },

   312 +

   313 +  { BFD_RELOC_AVR32_GOTPC,		R_AVR32_GOTPC },

   314 +  { BFD_RELOC_AVR32_GOTCALL,		R_AVR32_GOTCALL },

   315 +  { BFD_RELOC_AVR32_LDA_GOT,		R_AVR32_LDA_GOT },

   316 +  { BFD_RELOC_AVR32_GOT21S,		R_AVR32_GOT21S },

   317 +  { BFD_RELOC_AVR32_GOT18SW,		R_AVR32_GOT18SW },

   318 +  { BFD_RELOC_AVR32_GOT16S,		R_AVR32_GOT16S },

   319 +  /* GOT7UW should never be generated by the assembler */

   320 +

   321 +  { BFD_RELOC_AVR32_32_CPENT,		R_AVR32_32_CPENT },

   322 +  { BFD_RELOC_AVR32_CPCALL,		R_AVR32_CPCALL },

   323 +  { BFD_RELOC_AVR32_16_CP,		R_AVR32_16_CP },

   324 +  { BFD_RELOC_AVR32_9W_CP,		R_AVR32_9W_CP },

   325 +

   326 +  { BFD_RELOC_AVR32_ALIGN,		R_AVR32_ALIGN },

   327 +

   328 +  { BFD_RELOC_AVR32_15S,		R_AVR32_15S },

   329 +};

   330 +

   331 +static reloc_howto_type *

   332 +bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,

   333 +				 bfd_reloc_code_real_type code)

   334 +{

   335 +  unsigned int i;

   336 +

   337 +  for (i = 0; i < sizeof(avr32_reloc_map) / sizeof(struct elf_reloc_map); i++)

   338 +    {

   339 +      if (avr32_reloc_map[i].bfd_reloc_val == code)

   340 +	return &elf_avr32_howto_table[avr32_reloc_map[i].elf_reloc_val];

   341 +    }

   342 +

   343 +  return NULL;

   344 +}

   345 +

   346 +static reloc_howto_type *

   347 +bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,

   348 +                 const char *r_name)

   349 +{

   350 +  unsigned int i;

   351 +

   352 +  for (i = 0;

   353 +       i < sizeof (elf_avr32_howto_table) / sizeof (elf_avr32_howto_table[0]);

   354 +       i++)

   355 +    if (elf_avr32_howto_table[i].name != NULL

   356 +    && strcasecmp (elf_avr32_howto_table[i].name, r_name) == 0)

   357 +      return &elf_avr32_howto_table[i];

   358 +

   359 +  return NULL;

   360 +}

   361 +

   362 +/* Set the howto pointer for an AVR32 ELF reloc.  */

   363 +static void

   364 +avr32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,

   365 +		     arelent *cache_ptr,

   366 +		     Elf_Internal_Rela *dst)

   367 +{

   368 +  unsigned int r_type;

   369 +

   370 +  r_type = ELF32_R_TYPE (dst->r_info);

   371 +  BFD_ASSERT (r_type < (unsigned int) R_AVR32_max);

   372 +  cache_ptr->howto = &elf_avr32_howto_table[r_type];

   373 +}

   374 +

   375 +

   376 +/* AVR32 ELF linker hash table and associated hash entries. */

   377 +

   378 +static struct bfd_hash_entry *

   379 +avr32_elf_link_hash_newfunc(struct bfd_hash_entry *entry,

   380 +			    struct bfd_hash_table *table,

   381 +			    const char *string);

   382 +static void

   383 +avr32_elf_copy_indirect_symbol(struct bfd_link_info *info,

   384 +			       struct elf_link_hash_entry *dir,

   385 +			       struct elf_link_hash_entry *ind);

   386 +static struct bfd_link_hash_table *

   387 +avr32_elf_link_hash_table_create(bfd *abfd);

   388 +

   389 +/*

   390 +  Try to limit memory usage to something reasonable when sorting the

   391 +  GOT.  If just a couple of entries end up getting more references

   392 +  than this, it won't affect performance at all, but if there are many

   393 +  of them, we could end up with the wrong symbols being assigned the

   394 +  first GOT entries.

   395 +*/

   396 +#define MAX_NR_GOT_HOLES	2048

   397 +

   398 +/*

   399 +  AVR32 GOT entry.  We need to keep track of refcounts and offsets

   400 +  simultaneously, since we need the offsets during relaxation, and we

   401 +  also want to be able to drop GOT entries during relaxation. In

   402 +  addition to this, we want to keep the list of GOT entries sorted so

   403 +  that we can keep the most-used entries at the lowest offsets.

   404 +*/

   405 +struct got_entry

   406 +{

   407 +  struct got_entry *next;

   408 +  struct got_entry **pprev;

   409 +  int refcount;

   410 +  bfd_signed_vma offset;

   411 +};

   412 +

   413 +struct elf_avr32_link_hash_entry

   414 +{

   415 +  struct elf_link_hash_entry root;

   416 +

   417 +  /* Number of runtime relocations against this symbol.  */

   418 +  unsigned int possibly_dynamic_relocs;

   419 +

   420 +  /* If there are anything but R_AVR32_GOT18 relocations against this

   421 +     symbol, it means that someone may be taking the address of the

   422 +     function, and we should therefore not create a stub.  */

   423 +  bfd_boolean no_fn_stub;

   424 +

   425 +  /* If there is a R_AVR32_32 relocation in a read-only section

   426 +     against this symbol, we could be in trouble. If we're linking a

   427 +     shared library or this symbol is defined in one, it means we must

   428 +     emit a run-time reloc for it and that's not allowed in read-only

   429 +     sections.  */

   430 +  asection *readonly_reloc_sec;

   431 +  bfd_vma readonly_reloc_offset;

   432 +

   433 +  /* Record which frag (if any) contains the symbol.  This is used

   434 +     during relaxation in order to avoid having to update all symbols

   435 +     whenever we move something.  For local symbols, this information

   436 +     is in the local_sym_frag member of struct elf_obj_tdata.  */

   437 +  struct fragment *sym_frag;

   438 +};

   439 +#define avr32_elf_hash_entry(ent) ((struct elf_avr32_link_hash_entry *)(ent))

   440 +

   441 +struct elf_avr32_link_hash_table

   442 +{

   443 +  struct elf_link_hash_table root;

   444 +

   445 +  /* Shortcuts to get to dynamic linker sections.  */

   446 +  asection *sgot;

   447 +  asection *srelgot;

   448 +  asection *sstub;

   449 +

   450 +  /* We use a variation of Pigeonhole Sort to sort the GOT.  After the

   451 +     initial refcounts have been determined, we initialize

   452 +     nr_got_holes to the highest refcount ever seen and allocate an

   453 +     array of nr_got_holes entries for got_hole.  Each GOT entry is

   454 +     then stored in this array at the index given by its refcount.

   455 +

   456 +     When a GOT entry has its refcount decremented during relaxation,

   457 +     it is moved to a lower index in the got_hole array.

   458 +   */

   459 +  struct got_entry **got_hole;

   460 +  int nr_got_holes;

   461 +

   462 +  /* Dynamic relocations to local symbols.  Only used when linking a

   463 +     shared library and -Bsymbolic is not given.  */

   464 +  unsigned int local_dynamic_relocs;

   465 +

   466 +  bfd_boolean relocations_analyzed;

   467 +  bfd_boolean symbols_adjusted;

   468 +  bfd_boolean repeat_pass;

   469 +  bfd_boolean direct_data_refs;

   470 +  unsigned int relax_iteration;

   471 +  unsigned int relax_pass;

   472 +};

   473 +#define avr32_elf_hash_table(p)				\

   474 +  ((struct elf_avr32_link_hash_table *)((p)->hash))

   475 +

   476 +static struct bfd_hash_entry *

   477 +avr32_elf_link_hash_newfunc(struct bfd_hash_entry *entry,

   478 +			    struct bfd_hash_table *table,

   479 +			    const char *string)

   480 +{

   481 +  struct elf_avr32_link_hash_entry *ret = avr32_elf_hash_entry(entry);

   482 +

   483 +  /* Allocate the structure if it hasn't already been allocated by a

   484 +     subclass */

   485 +  if (ret == NULL)

   486 +    ret = (struct elf_avr32_link_hash_entry *)

   487 +      bfd_hash_allocate(table, sizeof(struct elf_avr32_link_hash_entry));

   488 +

   489 +  if (ret == NULL)

   490 +    return NULL;

   491 +

   492 +  memset(ret, 0, sizeof(struct elf_avr32_link_hash_entry));

   493 +

   494 +  /* Give the superclass a chance */

   495 +  ret = (struct elf_avr32_link_hash_entry *)

   496 +    _bfd_elf_link_hash_newfunc((struct bfd_hash_entry *)ret, table, string);

   497 +

   498 +  return (struct bfd_hash_entry *)ret;

   499 +}

   500 +

   501 +/* Copy data from an indirect symbol to its direct symbol, hiding the

   502 +   old indirect symbol.  Process additional relocation information.

   503 +   Also called for weakdefs, in which case we just let

   504 +   _bfd_elf_link_hash_copy_indirect copy the flags for us.  */

   505 +

   506 +static void

   507 +avr32_elf_copy_indirect_symbol(struct bfd_link_info *info,

   508 +			       struct elf_link_hash_entry *dir,

   509 +			       struct elf_link_hash_entry *ind)

   510 +{

   511 +  struct elf_avr32_link_hash_entry *edir, *eind;

   512 +

   513 +  _bfd_elf_link_hash_copy_indirect (info, dir, ind);

   514 +

   515 +  if (ind->root.type != bfd_link_hash_indirect)

   516 +    return;

   517 +

   518 +  edir = (struct elf_avr32_link_hash_entry *)dir;

   519 +  eind = (struct elf_avr32_link_hash_entry *)ind;

   520 +

   521 +  edir->possibly_dynamic_relocs += eind->possibly_dynamic_relocs;

   522 +  edir->no_fn_stub = edir->no_fn_stub || eind->no_fn_stub;

   523 +}

   524 +

   525 +static struct bfd_link_hash_table *

   526 +avr32_elf_link_hash_table_create(bfd *abfd)

   527 +{

   528 +  struct elf_avr32_link_hash_table *ret;

   529 +

   530 +  ret = bfd_zmalloc(sizeof(*ret));

   531 +  if (ret == NULL)

   532 +    return NULL;

   533 +

   534 +  if (! _bfd_elf_link_hash_table_init(&ret->root, abfd,

   535 +				      avr32_elf_link_hash_newfunc,

   536 +                      sizeof (struct elf_avr32_link_hash_entry)))

   537 +    {

   538 +      free(ret);

   539 +      return NULL;

   540 +    }

   541 +

   542 +  /* Prevent the BFD core from creating bogus got_entry pointers */

   543 +  ret->root.init_got_refcount.glist = NULL;

   544 +  ret->root.init_plt_refcount.glist = NULL;

   545 +  ret->root.init_got_offset.glist = NULL;

   546 +  ret->root.init_plt_offset.glist = NULL;

   547 +

   548 +  return &ret->root.root;

   549 +}

   550 +

   551 +

   552 +/* Initial analysis and creation of dynamic sections and symbols */

   553 +

   554 +static asection *

   555 +create_dynamic_section(bfd *dynobj, const char *name, flagword flags,

   556 +		       unsigned int align_power);

   557 +static struct elf_link_hash_entry *

   558 +create_dynamic_symbol(bfd *dynobj, struct bfd_link_info *info,

   559 +		      const char *name, asection *sec,

   560 +		      bfd_vma offset);

   561 +static bfd_boolean

   562 +avr32_elf_create_got_section (bfd *dynobj, struct bfd_link_info *info);

   563 +static bfd_boolean

   564 +avr32_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info);

   565 +static bfd_boolean

   566 +avr32_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,

   567 +		    const Elf_Internal_Rela *relocs);

   568 +static bfd_boolean

   569 +avr32_elf_adjust_dynamic_symbol(struct bfd_link_info *info,

   570 +				struct elf_link_hash_entry *h);

   571 +

   572 +static asection *

   573 +create_dynamic_section(bfd *dynobj, const char *name, flagword flags,

   574 +		       unsigned int align_power)

   575 +{

   576 +  asection *sec;

   577 +

   578 +  sec = bfd_make_section(dynobj, name);

   579 +  if (!sec

   580 +      || !bfd_set_section_flags(dynobj, sec, flags)

   581 +      || !bfd_set_section_alignment(dynobj, sec, align_power))

   582 +    return NULL;

   583 +

   584 +  return sec;

   585 +}

   586 +

   587 +static struct elf_link_hash_entry *

   588 +create_dynamic_symbol(bfd *dynobj, struct bfd_link_info *info,

   589 +		      const char *name, asection *sec,

   590 +		      bfd_vma offset)

   591 +{

   592 +  struct bfd_link_hash_entry *bh = NULL;

   593 +  struct elf_link_hash_entry *h;

   594 +  const struct elf_backend_data *bed = get_elf_backend_data (dynobj);

   595 +

   596 +  if (!(_bfd_generic_link_add_one_symbol

   597 +	(info, dynobj, name, BSF_GLOBAL, sec, offset, NULL, FALSE,

   598 +	 bed->collect, &bh)))

   599 +    return NULL;

   600 +

   601 +  h = (struct elf_link_hash_entry *)bh;

   602 +  h->def_regular = 1;

   603 +  h->type = STT_OBJECT;

   604 +  h->other = STV_HIDDEN;

   605 +

   606 +  return h;

   607 +}

   608 +

   609 +static bfd_boolean

   610 +avr32_elf_create_got_section (bfd *dynobj, struct bfd_link_info *info)

   611 +{

   612 +  struct elf_avr32_link_hash_table *htab;

   613 +  flagword flags;

   614 +  const struct elf_backend_data *bed = get_elf_backend_data (dynobj);

   615 +

   616 +  htab = avr32_elf_hash_table(info);

   617 +  flags = bed->dynamic_sec_flags;

   618 +

   619 +  if (htab->sgot)

   620 +    return TRUE;

   621 +

   622 +  htab->sgot = create_dynamic_section(dynobj, ".got", flags, 2);

   623 +  if (!htab->srelgot)

   624 +    htab->srelgot = create_dynamic_section(dynobj, ".rela.got",

   625 +					   flags | SEC_READONLY, 2);

   626 +

   627 +  if (!htab->sgot || !htab->srelgot)

   628 +    return FALSE;

   629 +

   630 +  htab->root.hgot = create_dynamic_symbol(dynobj, info, "_GLOBAL_OFFSET_TABLE_",

   631 +					  htab->sgot, 0);

   632 +  if (!htab->root.hgot)

   633 +    return FALSE;

   634 +

   635 +  /* Make room for the GOT header */

   636 +  htab->sgot->size += bed->got_header_size;

   637 +

   638 +  return TRUE;

   639 +}

   640 +

   641 +/* (1) Create all dynamic (i.e. linker generated) sections that we may

   642 +   need during the link */

   643 +

   644 +static bfd_boolean

   645 +avr32_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)

   646 +{

   647 +  struct elf_avr32_link_hash_table *htab;

   648 +  flagword flags;

   649 +  const struct elf_backend_data *bed = get_elf_backend_data (dynobj);

   650 +

   651 +  pr_debug("(1) create dynamic sections\n");

   652 +

   653 +  htab = avr32_elf_hash_table(info);

   654 +  flags = bed->dynamic_sec_flags;

   655 +

   656 +  if (!avr32_elf_create_got_section (dynobj, info))

   657 +    return FALSE;

   658 +

   659 +  if (!htab->sstub)

   660 +    htab->sstub = create_dynamic_section(dynobj, ".stub",

   661 +					 flags | SEC_READONLY | SEC_CODE, 2);

   662 +

   663 +  if (!htab->sstub)

   664 +    return FALSE;

   665 +

   666 +  return TRUE;

   667 +}

   668 +

   669 +/* (2) Go through all the relocs and count any potential GOT- or

   670 +   PLT-references to each symbol */

   671 +

   672 +static bfd_boolean

   673 +avr32_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,

   674 +		    const Elf_Internal_Rela *relocs)

   675 +{

   676 +  Elf_Internal_Shdr *symtab_hdr;

   677 +  struct elf_avr32_link_hash_table *htab;

   678 +  struct elf_link_hash_entry **sym_hashes;

   679 +  const Elf_Internal_Rela *rel, *rel_end;

   680 +  struct got_entry **local_got_ents;

   681 +  struct got_entry *got;

   682 +  const struct elf_backend_data *bed = get_elf_backend_data (abfd);

   683 +  asection *sgot;

   684 +  bfd *dynobj;

   685 +

   686 +  pr_debug("(2) check relocs for %s:<%s> (size 0x%lx)\n",

   687 +	   abfd->filename, sec->name, sec->size);

   688 +

   689 +  if (info->relocatable)

   690 +    return TRUE;

   691 +

   692 +  dynobj = elf_hash_table(info)->dynobj;

   693 +  symtab_hdr = &elf_tdata(abfd)->symtab_hdr;

   694 +  sym_hashes = elf_sym_hashes(abfd);

   695 +  htab = avr32_elf_hash_table(info);

   696 +  local_got_ents = elf_local_got_ents(abfd);

   697 +  sgot = htab->sgot;

   698 +

   699 +  rel_end = relocs + sec->reloc_count;

   700 +  for (rel = relocs; rel < rel_end; rel++)

   701 +    {

   702 +      unsigned long r_symndx, r_type;

   703 +      struct elf_avr32_link_hash_entry *h;

   704 +

   705 +      r_symndx = ELF32_R_SYM(rel->r_info);

   706 +      r_type = ELF32_R_TYPE(rel->r_info);

   707 +

   708 +      /* Local symbols use local_got_ents, while others store the same

   709 +	 information in the hash entry */

   710 +      if (r_symndx < symtab_hdr->sh_info)

   711 +	{

   712 +	  pr_debug("  (2a) processing local symbol %lu\n", r_symndx);

   713 +	  h = NULL;

   714 +	}

   715 +      else

   716 +	{

   717 +	  h = (struct elf_avr32_link_hash_entry *)

   718 +	    sym_hashes[r_symndx - symtab_hdr->sh_info];

   719 +	  while (h->root.type == bfd_link_hash_indirect

   720 +		 || h->root.type == bfd_link_hash_warning)

   721 +	    h = (struct elf_avr32_link_hash_entry *)h->root.root.u.i.link;

   722 +	  pr_debug("  (2a) processing symbol %s\n", h->root.root.root.string);

   723 +	}

   724 +

   725 +      /* Some relocs require special sections to be created.  */

   726 +      switch (r_type)

   727 +	{

   728 +	case R_AVR32_GOT32:

   729 +	case R_AVR32_GOT16:

   730 +	case R_AVR32_GOT8:

   731 +	case R_AVR32_GOT21S:

   732 +	case R_AVR32_GOT18SW:

   733 +	case R_AVR32_GOT16S:

   734 +	case R_AVR32_GOT7UW:

   735 +	case R_AVR32_LDA_GOT:

   736 +	case R_AVR32_GOTCALL:

   737 +	  if (rel->r_addend)

   738 +	    {

   739 +	      if (info->callbacks->reloc_dangerous

   740 +		  (info, _("Non-zero addend on GOT-relative relocation"),

   741 +		   abfd, sec, rel->r_offset) == FALSE)

   742 +		return FALSE;

   743 +	    }

   744 +	  /* fall through */

   745 +	case R_AVR32_GOTPC:

   746 +	  if (dynobj == NULL)

   747 +	    elf_hash_table(info)->dynobj = dynobj = abfd;

   748 +	  if (sgot == NULL && !avr32_elf_create_got_section(dynobj, info))

   749 +	    return FALSE;

   750 +	  break;

   751 +	case R_AVR32_32:

   752 +	  /* We may need to create .rela.dyn later on.  */

   753 +	  if (dynobj == NULL

   754 +	      && (info->shared || h != NULL)

   755 +	      && (sec->flags & SEC_ALLOC))

   756 +	    elf_hash_table(info)->dynobj = dynobj = abfd;

   757 +	  break;

   758 +	}

   759 +

   760 +      if (h != NULL && r_type != R_AVR32_GOT18SW)

   761 +	h->no_fn_stub = TRUE;

   762 +

   763 +      switch (r_type)

   764 +	{

   765 +	case R_AVR32_GOT32:

   766 +	case R_AVR32_GOT16:

   767 +	case R_AVR32_GOT8:

   768 +	case R_AVR32_GOT21S:

   769 +	case R_AVR32_GOT18SW:

   770 +	case R_AVR32_GOT16S:

   771 +	case R_AVR32_GOT7UW:

   772 +	case R_AVR32_LDA_GOT:

   773 +	case R_AVR32_GOTCALL:

   774 +	  if (h != NULL)

   775 +	    {

   776 +	      got = h->root.got.glist;

   777 +	      if (!got)

   778 +		{

   779 +		  got = bfd_zalloc(abfd, sizeof(struct got_entry));

   780 +		  if (!got)

   781 +		    return FALSE;

   782 +		  h->root.got.glist = got;

   783 +		}

   784 +	    }

   785 +	  else

   786 +	    {

   787 +	      if (!local_got_ents)

   788 +		{

   789 +		  bfd_size_type size;

   790 +		  bfd_size_type i;

   791 +		  struct got_entry *tmp_entry;

   792 +

   793 +		  size = symtab_hdr->sh_info;

   794 +		  size *= sizeof(struct got_entry *) + sizeof(struct got_entry);

   795 +		  local_got_ents = bfd_zalloc(abfd, size);

   796 +		  if (!local_got_ents)

   797 +		    return FALSE;

   798 +

   799 +		  elf_local_got_ents(abfd) = local_got_ents;

   800 +

   801 +		  tmp_entry = (struct got_entry *)(local_got_ents

   802 +						   + symtab_hdr->sh_info);

   803 +		  for (i = 0; i < symtab_hdr->sh_info; i++)

   804 +		    local_got_ents[i] = &tmp_entry[i];

   805 +		}

   806 +

   807 +	      got = local_got_ents[r_symndx];

   808 +	    }

   809 +

   810 +	  got->refcount++;

   811 +	  if (got->refcount > htab->nr_got_holes)

   812 +	    htab->nr_got_holes = got->refcount;

   813 +	  break;

   814 +

   815 +	case R_AVR32_32:

   816 +	  if ((info->shared || h != NULL)

   817 +	      && (sec->flags & SEC_ALLOC))

   818 +	    {

   819 +	      if (htab->srelgot == NULL)

   820 +		{

   821 +		  htab->srelgot = create_dynamic_section(dynobj, ".rela.got",

   822 +							 bed->dynamic_sec_flags

   823 +							 | SEC_READONLY, 2);

   824 +		  if (htab->srelgot == NULL)

   825 +		    return FALSE;

   826 +		}

   827 +

   828 +	      if (sec->flags & SEC_READONLY

   829 +		  && !h->readonly_reloc_sec)

   830 +		{

   831 +		  h->readonly_reloc_sec = sec;

   832 +		  h->readonly_reloc_offset = rel->r_offset;

   833 +		}

   834 +

   835 +	      if (h != NULL)

   836 +		{

   837 +		  pr_debug("Non-GOT reference to symbol %s\n",

   838 +			   h->root.root.root.string);

   839 +		  h->possibly_dynamic_relocs++;

   840 +		}

   841 +	      else

   842 +		{

   843 +		  pr_debug("Non-GOT reference to local symbol %lu\n",

   844 +			   r_symndx);

   845 +		  htab->local_dynamic_relocs++;

   846 +		}

   847 +	    }

   848 +

   849 +	  break;

   850 +

   851 +	  /* TODO: GNU_VTINHERIT and GNU_VTENTRY */

   852 +	}

   853 +    }

   854 +

   855 +  return TRUE;

   856 +}

   857 +

   858 +/* (3) Adjust a symbol defined by a dynamic object and referenced by a

   859 +   regular object.  The current definition is in some section of the

   860 +   dynamic object, but we're not including those sections.  We have to

   861 +   change the definition to something the rest of the link can

   862 +   understand.  */

   863 +

   864 +static bfd_boolean

   865 +avr32_elf_adjust_dynamic_symbol(struct bfd_link_info *info,

   866 +				struct elf_link_hash_entry *h)

   867 +{

   868 +  struct elf_avr32_link_hash_table *htab;

   869 +  struct elf_avr32_link_hash_entry *havr;

   870 +  bfd *dynobj;

   871 +

   872 +  pr_debug("(3) adjust dynamic symbol %s\n", h->root.root.string);

   873 +

   874 +  htab = avr32_elf_hash_table(info);

   875 +  havr = (struct elf_avr32_link_hash_entry *)h;

   876 +  dynobj = elf_hash_table(info)->dynobj;

   877 +

   878 +  /* Make sure we know what is going on here.  */

   879 +  BFD_ASSERT (dynobj != NULL

   880 +	      && (h->u.weakdef != NULL

   881 +		  || (h->def_dynamic

   882 +		      && h->ref_regular

   883 +		      && !h->def_regular)));

   884 +

   885 +  /* We don't want dynamic relocations in read-only sections. */

   886 +  if (havr->readonly_reloc_sec)

   887 +    {

   888 +      if (info->callbacks->reloc_dangerous

   889 +	  (info, _("dynamic relocation in read-only section"),

   890 +	   havr->readonly_reloc_sec->owner, havr->readonly_reloc_sec,

   891 +	   havr->readonly_reloc_offset) == FALSE)

   892 +	return FALSE;

   893 +    }

   894 +

   895 +  /* If this is a function, create a stub if possible and set the

   896 +     symbol to the stub location.  */

   897 +  if (0 && !havr->no_fn_stub)

   898 +    {

   899 +      if (!h->def_regular)

   900 +	{

   901 +	  asection *s = htab->sstub;

   902 +

   903 +	  BFD_ASSERT(s != NULL);

   904 +

   905 +	  h->root.u.def.section = s;

   906 +	  h->root.u.def.value = s->size;

   907 +	  h->plt.offset = s->size;

   908 +	  s->size += AVR32_FUNCTION_STUB_SIZE;

   909 +

   910 +	  return TRUE;

   911 +	}

   912 +    }

   913 +  else if (h->type == STT_FUNC)

   914 +    {

   915 +      /* This will set the entry for this symbol in the GOT to 0, and

   916 +	 the dynamic linker will take care of this. */

   917 +      h->root.u.def.value = 0;

   918 +      return TRUE;

   919 +    }

   920 +

   921 +  /* If this is a weak symbol, and there is a real definition, the

   922 +     processor independent code will have arranged for us to see the

   923 +     real definition first, and we can just use the same value.  */

   924 +  if (h->u.weakdef != NULL)

   925 +    {

   926 +      BFD_ASSERT(h->u.weakdef->root.type == bfd_link_hash_defined

   927 +		 || h->u.weakdef->root.type == bfd_link_hash_defweak);

   928 +      h->root.u.def.section = h->u.weakdef->root.u.def.section;

   929 +      h->root.u.def.value = h->u.weakdef->root.u.def.value;

   930 +      return TRUE;

   931 +    }

   932 +

   933 +  /* This is a reference to a symbol defined by a dynamic object which

   934 +     is not a function.  */

   935 +

   936 +  return TRUE;

   937 +}

   938 +

   939 +

   940 +/* Garbage-collection of unused sections */

   941 +

   942 +static asection *

   943 +avr32_elf_gc_mark_hook(asection *sec,

   944 +		       struct bfd_link_info *info ATTRIBUTE_UNUSED,

   945 +		       Elf_Internal_Rela *rel,

   946 +		       struct elf_link_hash_entry *h,

   947 +		       Elf_Internal_Sym *sym)

   948 +{

   949 +  if (h)

   950 +    {

   951 +      switch (ELF32_R_TYPE(rel->r_info))

   952 +	{

   953 +	  /* TODO: VTINHERIT/VTENTRY */

   954 +	default:

   955 +	  switch (h->root.type)

   956 +	    {

   957 +	    case bfd_link_hash_defined:

   958 +	    case bfd_link_hash_defweak:

   959 +	      return h->root.u.def.section;

   960 +

   961 +	    case bfd_link_hash_common:

   962 +	      return h->root.u.c.p->section;

   963 +

   964 +	    default:

   965 +	      break;

   966 +	    }

   967 +	}

   968 +    }

   969 +  else

   970 +    return bfd_section_from_elf_index(sec->owner, sym->st_shndx);

   971 +

   972 +  return NULL;

   973 +}

   974 +

   975 +/* Update the GOT entry reference counts for the section being removed. */

   976 +static bfd_boolean

   977 +avr32_elf_gc_sweep_hook(bfd *abfd,

   978 +			struct bfd_link_info *info ATTRIBUTE_UNUSED,

   979 +			asection *sec,

   980 +			const Elf_Internal_Rela *relocs)

   981 +{

   982 +  Elf_Internal_Shdr *symtab_hdr;

   983 +  struct elf_avr32_link_hash_entry **sym_hashes;

   984 +  struct got_entry **local_got_ents;

   985 +  const Elf_Internal_Rela *rel, *relend;

   986 +

   987 +  if (!(sec->flags & SEC_ALLOC))

   988 +    return TRUE;

   989 +

   990 +  symtab_hdr = &elf_tdata(abfd)->symtab_hdr;

   991 +  sym_hashes = (struct elf_avr32_link_hash_entry **)elf_sym_hashes(abfd);

   992 +  local_got_ents = elf_local_got_ents(abfd);

   993 +

   994 +  relend = relocs + sec->reloc_count;

   995 +  for (rel = relocs; rel < relend; rel++)

   996 +    {

   997 +      unsigned long r_symndx;

   998 +      unsigned int r_type;

   999 +      struct elf_avr32_link_hash_entry *h = NULL;

  1000 +

  1001 +      r_symndx = ELF32_R_SYM(rel->r_info);

  1002 +      if (r_symndx >= symtab_hdr->sh_info)

  1003 +	{

  1004 +	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];

  1005 +	  while (h->root.root.type == bfd_link_hash_indirect

  1006 +		 || h->root.root.type == bfd_link_hash_warning)

  1007 +	    h = (struct elf_avr32_link_hash_entry *)h->root.root.u.i.link;

  1008 +	}

  1009 +

  1010 +      r_type = ELF32_R_TYPE(rel->r_info);

  1011 +

  1012 +      switch (r_type)

  1013 +	{

  1014 +	case R_AVR32_GOT32:

  1015 +	case R_AVR32_GOT16:

  1016 +	case R_AVR32_GOT8:

  1017 +	case R_AVR32_GOT21S:

  1018 +	case R_AVR32_GOT18SW:

  1019 +	case R_AVR32_GOT16S:

  1020 +	case R_AVR32_GOT7UW:

  1021 +	case R_AVR32_LDA_GOT:

  1022 +	case R_AVR32_GOTCALL:

  1023 +	  if (h)

  1024 +	    h->root.got.glist->refcount--;

  1025 +	  else

  1026 +	    local_got_ents[r_symndx]->refcount--;

  1027 +	  break;

  1028 +

  1029 +	case R_AVR32_32:

  1030 +	  if (info->shared || h)

  1031 +	    {

  1032 +	      if (h)

  1033 +		h->possibly_dynamic_relocs--;

  1034 +	      else

  1035 +		avr32_elf_hash_table(info)->local_dynamic_relocs--;

  1036 +	    }

  1037 +

  1038 +	default:

  1039 +	  break;

  1040 +	}

  1041 +    }

  1042 +

  1043 +  return TRUE;

  1044 +}

  1045 +

  1046 +/* Sizing and refcounting of dynamic sections */

  1047 +

  1048 +static void

  1049 +insert_got_entry(struct elf_avr32_link_hash_table *htab, struct got_entry *got);

  1050 +static void

  1051 +unref_got_entry(struct elf_avr32_link_hash_table *htab, struct got_entry *got);

  1052 +static void

  1053 +ref_got_entry(struct elf_avr32_link_hash_table *htab, struct got_entry *got);

  1054 +static bfd_boolean

  1055 +assign_got_offsets(struct elf_avr32_link_hash_table *htab);

  1056 +static bfd_boolean

  1057 +allocate_dynrelocs(struct elf_link_hash_entry *h, void *_info);

  1058 +static bfd_boolean

  1059 +avr32_elf_size_dynamic_sections (bfd *output_bfd,

  1060 +				 struct bfd_link_info *info);

  1061 +

  1062 +static void

  1063 +insert_got_entry(struct elf_avr32_link_hash_table *htab, struct got_entry *got)

  1064 +{

  1065 +  /* Any entries with got_refcount > htab->nr_got_holes end up in the

  1066 +   * last pigeonhole without any sorting. We expect the number of such

  1067 +   * entries to be small, so it is very unlikely to affect

  1068 +   * performance.  */

  1069 +  int entry = got->refcount;

  1070 +

  1071 +  if (entry > htab->nr_got_holes)

  1072 +    entry = htab->nr_got_holes;

  1073 +

  1074 +  got->pprev = &htab->got_hole[entry];

  1075 +  got->next = htab->got_hole[entry];

  1076 +

  1077 +  if (got->next)

  1078 +    got->next->pprev = &got->next;

  1079 +

  1080 +  htab->got_hole[entry] = got;

  1081 +}

  1082 +

  1083 +/* Decrement the refcount of a GOT entry and update its position in

  1084 +   the pigeonhole array.  */

  1085 +static void

  1086 +unref_got_entry(struct elf_avr32_link_hash_table *htab, struct got_entry *got)

  1087 +{

  1088 +  BFD_ASSERT(got->refcount > 0);

  1089 +

  1090 +  if (got->next)

  1091 +    got->next->pprev = got->pprev;

  1092 +

  1093 +  *(got->pprev) = got->next;

  1094 +  got->refcount--;

  1095 +  insert_got_entry(htab, got);

  1096 +}

  1097 +

  1098 +static void

  1099 +ref_got_entry(struct elf_avr32_link_hash_table *htab, struct got_entry *got)

  1100 +{

  1101 +  if (got->next)

  1102 +    got->next->pprev = got->pprev;

  1103 +

  1104 +  *(got->pprev) = got->next;

  1105 +  got->refcount++;

  1106 +  insert_got_entry(htab, got);

  1107 +

  1108 +  BFD_ASSERT(got->refcount > 0);

  1109 +}

  1110 +

  1111 +/* Assign offsets to all GOT entries we intend to keep.  The entries

  1112 +   that are referenced most often are placed at low offsets so that we

  1113 +   can use compact instructions as much as possible.

  1114 +

  1115 +   Returns TRUE if any offsets or the total size of the GOT changed.  */

  1116 +

  1117 +static bfd_boolean

  1118 +assign_got_offsets(struct elf_avr32_link_hash_table *htab)

  1119 +{

  1120 +  struct got_entry *got;

  1121 +  bfd_size_type got_size = 0;

  1122 +  bfd_boolean changed = FALSE;

  1123 +  bfd_signed_vma offset;

  1124 +  int i;

  1125 +

  1126 +  /* The GOT header provides the address of the DYNAMIC segment, so

  1127 +     we need that even if the GOT is otherwise empty.  */

  1128 +  if (htab->root.dynamic_sections_created)

  1129 +    got_size = AVR32_GOT_HEADER_SIZE;

  1130 +

  1131 +  for (i = htab->nr_got_holes; i > 0; i--)

  1132 +    {

  1133 +      got = htab->got_hole[i];

  1134 +      while (got)

  1135 +	{

  1136 +	  if (got->refcount > 0)

  1137 +	    {

  1138 +	      offset = got_size;

  1139 +	      if (got->offset != offset)

  1140 +		{

  1141 +		  RDBG("GOT offset changed: %ld -> %ld\n",

  1142 +		       got->offset, offset);

  1143 +		  changed = TRUE;

  1144 +		}

  1145 +	      got->offset = offset;

  1146 +	      got_size += 4;

  1147 +	    }

  1148 +	  got = got->next;

  1149 +	}

  1150 +    }

  1151 +

  1152 +  if (htab->sgot->size != got_size)

  1153 +    {

  1154 +      RDBG("GOT size changed: %lu -> %lu\n", htab->sgot->size,

  1155 +	   got_size);

  1156 +      changed = TRUE;

  1157 +    }

  1158 +  htab->sgot->size = got_size;

  1159 +

  1160 +  RDBG("assign_got_offsets: total size %lu (%s)\n",

  1161 +       got_size, changed ? "changed" : "no change");

  1162 +

  1163 +  return changed;

  1164 +}

  1165 +

  1166 +static bfd_boolean

  1167 +allocate_dynrelocs(struct elf_link_hash_entry *h, void *_info)

  1168 +{

  1169 +  struct bfd_link_info *info = _info;

  1170 +  struct elf_avr32_link_hash_table *htab;

  1171 +  struct elf_avr32_link_hash_entry *havr;

  1172 +  struct got_entry *got;

  1173 +

  1174 +  pr_debug("  (4b) allocate_dynrelocs: %s\n", h->root.root.string);

  1175 +

  1176 +  if (h->root.type == bfd_link_hash_indirect)

  1177 +    return TRUE;

  1178 +

  1179 +  if (h->root.type == bfd_link_hash_warning)

  1180 +    /* When warning symbols are created, they **replace** the "real"

  1181 +       entry in the hash table, thus we never get to see the real

  1182 +       symbol in a hash traversal.  So look at it now.  */

  1183 +    h = (struct elf_link_hash_entry *) h->root.u.i.link;

  1184 +

  1185 +  htab = avr32_elf_hash_table(info);

  1186 +  havr = (struct elf_avr32_link_hash_entry *)h;

  1187 +

  1188 +  got = h->got.glist;

  1189 +

  1190 +  /* If got is NULL, the symbol is never referenced through the GOT */

  1191 +  if (got && got->refcount > 0)

  1192 +    {

  1193 +      insert_got_entry(htab, got);

  1194 +

  1195 +      /* Shared libraries need relocs for all GOT entries unless the

  1196 +	 symbol is forced local or -Bsymbolic is used.  Others need

  1197 +	 relocs for everything that is not guaranteed to be defined in

  1198 +	 a regular object.  */

  1199 +      if ((info->shared

  1200 +	   && !info->symbolic

  1201 +	   && h->dynindx != -1)

  1202 +	  || (htab->root.dynamic_sections_created

  1203 +	      && h->def_dynamic

  1204 +	      && !h->def_regular))

  1205 +	htab->srelgot->size += sizeof(Elf32_External_Rela);

  1206 +    }

  1207 +

  1208 +  if (havr->possibly_dynamic_relocs

  1209 +      && (info->shared

  1210 +	  || (elf_hash_table(info)->dynamic_sections_created

  1211 +	      && h->def_dynamic

  1212 +	      && !h->def_regular)))

  1213 +    {

  1214 +      pr_debug("Allocating %d dynamic reloc against symbol %s...\n",

  1215 +	       havr->possibly_dynamic_relocs, h->root.root.string);

  1216 +      htab->srelgot->size += (havr->possibly_dynamic_relocs

  1217 +			      * sizeof(Elf32_External_Rela));

  1218 +    }

  1219 +

  1220 +  return TRUE;

  1221 +}

  1222 +

  1223 +/* (4) Calculate the sizes of the linker-generated sections and

  1224 +   allocate memory for them.  */

  1225 +

  1226 +static bfd_boolean

  1227 +avr32_elf_size_dynamic_sections (bfd *output_bfd,

  1228 +				 struct bfd_link_info *info)

  1229 +{

  1230 +  struct elf_avr32_link_hash_table *htab;

  1231 +  bfd *dynobj;

  1232 +  asection *s;

  1233 +  bfd *ibfd;

  1234 +  bfd_boolean relocs;

  1235 +

  1236 +  pr_debug("(4) size dynamic sections\n");

  1237 +

  1238 +  htab = avr32_elf_hash_table(info);

  1239 +  dynobj = htab->root.dynobj;

  1240 +  BFD_ASSERT(dynobj != NULL);

  1241 +

  1242 +  if (htab->root.dynamic_sections_created)

  1243 +    {

  1244 +      /* Initialize the contents of the .interp section to the name of

  1245 +	 the dynamic loader */

  1246 +      if (info->executable)

  1247 +	{

  1248 +	  s = bfd_get_section_by_name(dynobj, ".interp");

  1249 +	  BFD_ASSERT(s != NULL);

  1250 +	  s->size = sizeof(ELF_DYNAMIC_INTERPRETER);

  1251 +	  s->contents = (unsigned char *)ELF_DYNAMIC_INTERPRETER;

  1252 +	}

  1253 +    }

  1254 +

  1255 +  if (htab->nr_got_holes > 0)

  1256 +    {

  1257 +      /* Allocate holes for the pigeonhole sort algorithm */

  1258 +      pr_debug("Highest GOT refcount: %d\n", htab->nr_got_holes);

  1259 +

  1260 +      /* Limit the memory usage by clipping the number of pigeonholes

  1261 +       * at a predefined maximum. All entries with a higher refcount

  1262 +       * will end up in the last pigeonhole.  */

  1263 +    if (htab->nr_got_holes >= MAX_NR_GOT_HOLES)

  1264 +    {

  1265 +        htab->nr_got_holes = MAX_NR_GOT_HOLES - 1;

  1266 +

  1267 +        pr_debug("Limiting maximum number of GOT pigeonholes to %u\n",

  1268 +                    htab->nr_got_holes);

  1269 +    }

  1270 +      htab->got_hole = bfd_zalloc(output_bfd,

  1271 +				  sizeof(struct got_entry *)

  1272 +				  * (htab->nr_got_holes + 1));

  1273 +      if (!htab->got_hole)

  1274 +	return FALSE;

  1275 +

  1276 +      /* Set up .got offsets for local syms.  */

  1277 +      for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)

  1278 +	{

  1279 +	  struct got_entry **local_got;

  1280 +	  struct got_entry **end_local_got;

  1281 +	  Elf_Internal_Shdr *symtab_hdr;

  1282 +	  bfd_size_type locsymcount;

  1283 +

  1284 +	  pr_debug("  (4a) processing file %s...\n", ibfd->filename);

  1285 +

  1286 +	  BFD_ASSERT(bfd_get_flavour(ibfd) == bfd_target_elf_flavour);

  1287 +

  1288 +	  local_got = elf_local_got_ents(ibfd);

  1289 +	  if (!local_got)

  1290 +	    continue;

  1291 +

  1292 +	  symtab_hdr = &elf_tdata(ibfd)->symtab_hdr;

  1293 +	  locsymcount = symtab_hdr->sh_info;

  1294 +	  end_local_got = local_got + locsymcount;

  1295 +

  1296 +	  for (; local_got < end_local_got; ++local_got)

  1297 +	    insert_got_entry(htab, *local_got);

  1298 +	}

  1299 +    }

  1300 +

  1301 +  /* Allocate global sym .got entries and space for global sym

  1302 +     dynamic relocs */

  1303 +  elf_link_hash_traverse(&htab->root, allocate_dynrelocs, info);

  1304 +

  1305 +  /* Now that we have sorted the GOT entries, we are ready to

  1306 +     assign offsets and determine the initial size of the GOT. */

  1307 +  if (htab->sgot)

  1308 +    assign_got_offsets(htab);

  1309 +

  1310 +  /* Allocate space for local sym dynamic relocs */

  1311 +  BFD_ASSERT(htab->local_dynamic_relocs == 0 || info->shared);

  1312 +  if (htab->local_dynamic_relocs)

  1313 +    htab->srelgot->size += (htab->local_dynamic_relocs

  1314 +			    * sizeof(Elf32_External_Rela));

  1315 +

  1316 +  /* We now have determined the sizes of the various dynamic

  1317 +     sections. Allocate memory for them. */

  1318 +  relocs = FALSE;

  1319 +  for (s = dynobj->sections; s; s = s->next)

  1320 +    {

  1321 +      if ((s->flags & SEC_LINKER_CREATED) == 0)

  1322 +	continue;

  1323 +

  1324 +      if (s == htab->sgot

  1325 +	  || s == htab->sstub)

  1326 +	{

  1327 +	  /* Strip this section if we don't need it */

  1328 +	}

  1329 +      else if (strncmp (bfd_get_section_name(dynobj, s), ".rela", 5) == 0)

  1330 +	{

  1331 +	  if (s->size != 0)

  1332 +	    relocs = TRUE;

  1333 +

  1334 +	  s->reloc_count = 0;

  1335 +	}

  1336 +      else

  1337 +	{

  1338 +	  /* It's not one of our sections */

  1339 +	  continue;

  1340 +	}

  1341 +

  1342 +      if (s->size == 0)

  1343 +	{

  1344 +	  /* Strip unneeded sections */

  1345 +	  pr_debug("Stripping section %s from output...\n", s->name);

  1346 +	  /* deleted function in 2.17

  1347 +      _bfd_strip_section_from_output(info, s);

  1348 +      */

  1349 +	  continue;

  1350 +	}

  1351 +

  1352 +      s->contents = bfd_zalloc(dynobj, s->size);

  1353 +      if (s->contents == NULL)

  1354 +	return FALSE;

  1355 +    }

  1356 +

  1357 +  if (htab->root.dynamic_sections_created)

  1358 +    {

  1359 +      /* Add some entries to the .dynamic section.  We fill in the

  1360 +	 values later, in sh_elf_finish_dynamic_sections, but we

  1361 +	 must add the entries now so that we get the correct size for

  1362 +	 the .dynamic section.  The DT_DEBUG entry is filled in by the

  1363 +	 dynamic linker and used by the debugger.  */

  1364 +#define add_dynamic_entry(TAG, VAL) _bfd_elf_add_dynamic_entry(info, TAG, VAL)

  1365 +

  1366 +      if (!add_dynamic_entry(DT_PLTGOT, 0))

  1367 +	return FALSE;

  1368 +      if (!add_dynamic_entry(DT_AVR32_GOTSZ, 0))

  1369 +	return FALSE;

  1370 +

  1371 +      if (info->executable)

  1372 +	{

  1373 +	  if (!add_dynamic_entry(DT_DEBUG, 0))

  1374 +	    return FALSE;

  1375 +	}

  1376 +      if (relocs)

  1377 +	{

  1378 +	  if (!add_dynamic_entry(DT_RELA, 0)

  1379 +	      || !add_dynamic_entry(DT_RELASZ, 0)

  1380 +	      || !add_dynamic_entry(DT_RELAENT,

  1381 +				    sizeof(Elf32_External_Rela)))

  1382 +	    return FALSE;

  1383 +	}

  1384 +    }

  1385 +#undef add_dynamic_entry

  1386 +

  1387 +  return TRUE;

  1388 +}

  1389 +

  1390 +

  1391 +/* Access to internal relocations, section contents and symbols.

  1392 +   (stolen from the xtensa port)  */

  1393 +

  1394 +static Elf_Internal_Rela *

  1395 +retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory);

  1396 +static void

  1397 +pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs);

  1398 +static void

  1399 +release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs);

  1400 +static bfd_byte *

  1401 +retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory);

  1402 +/*

  1403 +static void

  1404 +pin_contents (asection *sec, bfd_byte *contents);

  1405 +*/

  1406 +static void

  1407 +release_contents (asection *sec, bfd_byte *contents);

  1408 +static Elf_Internal_Sym *

  1409 +retrieve_local_syms (bfd *input_bfd, bfd_boolean keep_memory);

  1410 +/*

  1411 +static void

  1412 +pin_local_syms (bfd *input_bfd, Elf_Internal_Sym *isymbuf);

  1413 +*/

  1414 +static void

  1415 +release_local_syms (bfd *input_bfd, Elf_Internal_Sym *isymbuf);

  1416 +

  1417 +/* During relaxation, we need to modify relocations, section contents,

  1418 +   and symbol definitions, and we need to keep the original values from

  1419 +   being reloaded from the input files, i.e., we need to "pin" the

  1420 +   modified values in memory.  We also want to continue to observe the

  1421 +   setting of the "keep-memory" flag.  The following functions wrap the

  1422 +   standard BFD functions to take care of this for us.  */

  1423 +

  1424 +static Elf_Internal_Rela *

  1425 +retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)

  1426 +{

  1427 +  /* _bfd_elf_link_read_relocs knows about caching, so no need for us

  1428 +     to be clever here.  */

  1429 +  return _bfd_elf_link_read_relocs(abfd, sec, NULL, NULL, keep_memory);

  1430 +}

  1431 +

  1432 +static void

  1433 +pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)

  1434 +{

  1435 +  elf_section_data (sec)->relocs = internal_relocs;

  1436 +}

  1437 +

  1438 +static void

  1439 +release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)

  1440 +{

  1441 +  if (internal_relocs

  1442 +      && elf_section_data (sec)->relocs != internal_relocs)

  1443 +    free (internal_relocs);

  1444 +}

  1445 +

  1446 +static bfd_byte *

  1447 +retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)

  1448 +{

  1449 +  bfd_byte *contents;

  1450 +  bfd_size_type sec_size;

  1451 +

  1452 +  sec_size = bfd_get_section_limit (abfd, sec);

  1453 +  contents = elf_section_data (sec)->this_hdr.contents;

  1454 +

  1455 +  if (contents == NULL && sec_size != 0)

  1456 +    {

  1457 +      if (!bfd_malloc_and_get_section (abfd, sec, &contents))

  1458 +	{

  1459 +	  if (contents)

  1460 +	    free (contents);

  1461 +	  return NULL;

  1462 +	}

  1463 +      if (keep_memory)

  1464 +	elf_section_data (sec)->this_hdr.contents = contents;

  1465 +    }

  1466 +  return contents;

  1467 +}

  1468 +

  1469 +/*

  1470 +static void

  1471 +pin_contents (asection *sec, bfd_byte *contents)

  1472 +{

  1473 +  elf_section_data (sec)->this_hdr.contents = contents;

  1474 +}

  1475 +*/

  1476 +static void

  1477 +release_contents (asection *sec, bfd_byte *contents)

  1478 +{

  1479 +  if (contents && elf_section_data (sec)->this_hdr.contents != contents)

  1480 +    free (contents);

  1481 +}

  1482 +

  1483 +static Elf_Internal_Sym *

  1484 +retrieve_local_syms (bfd *input_bfd, bfd_boolean keep_memory)

  1485 +{

  1486 +  Elf_Internal_Shdr *symtab_hdr;

  1487 +  Elf_Internal_Sym *isymbuf;

  1488 +  size_t locsymcount;

  1489 +

  1490 +  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;

  1491 +  locsymcount = symtab_hdr->sh_info;

  1492 +

  1493 +  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;

  1494 +  if (isymbuf == NULL && locsymcount != 0)

  1495 +    {

  1496 +      isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,

  1497 +				      NULL, NULL, NULL);

  1498 +      if (isymbuf && keep_memory)

  1499 +	symtab_hdr->contents = (unsigned char *) isymbuf;

  1500 +    }

  1501 +

  1502 +  return isymbuf;

  1503 +}

  1504 +

  1505 +/*

  1506 +static void

  1507 +pin_local_syms (bfd *input_bfd, Elf_Internal_Sym *isymbuf)

  1508 +{

  1509 +  elf_tdata (input_bfd)->symtab_hdr.contents = (unsigned char *)isymbuf;

  1510 +}

  1511 +

  1512 +*/

  1513 +static void

  1514 +release_local_syms (bfd *input_bfd, Elf_Internal_Sym *isymbuf)

  1515 +{

  1516 +  if (isymbuf && (elf_tdata (input_bfd)->symtab_hdr.contents

  1517 +		  != (unsigned char *)isymbuf))

  1518 +    free (isymbuf);

  1519 +}

  1520 +

  1521 +/* Data structures used during relaxation. */

  1522 +

  1523 +enum relax_state_id {

  1524 +  RS_ERROR = -1,

  1525 +  RS_NONE = 0,

  1526 +  RS_ALIGN,

  1527 +  RS_CPENT,

  1528 +  RS_PIC_CALL,

  1529 +  RS_PIC_MCALL,

  1530 +  RS_PIC_RCALL2,

  1531 +  RS_PIC_RCALL1,

  1532 +  RS_PIC_LDA,

  1533 +  RS_PIC_LDW4,

  1534 +  RS_PIC_LDW3,

  1535 +  RS_PIC_SUB5,

  1536 +  RS_NOPIC_MCALL,

  1537 +  RS_NOPIC_RCALL2,

  1538 +  RS_NOPIC_RCALL1,

  1539 +  RS_NOPIC_LDW4,

  1540 +  RS_NOPIC_LDDPC,

  1541 +  RS_NOPIC_SUB5,

  1542 +  RS_NOPIC_MOV2,

  1543 +  RS_NOPIC_MOV1,

  1544 +  RS_RCALL2,

  1545 +  RS_RCALL1,

  1546 +  RS_BRC2,

  1547 +  RS_BRC1,

  1548 +  RS_BRAL,

  1549 +  RS_RJMP,

  1550 +  RS_MAX,

  1551 +};

  1552 +

  1553 +enum reference_type {

  1554 +  REF_ABSOLUTE,

  1555 +  REF_PCREL,

  1556 +  REF_CPOOL,

  1557 +  REF_GOT,

  1558 +};

  1559 +

  1560 +struct relax_state

  1561 +{

  1562 +  const char *name;

  1563 +  enum relax_state_id id;

  1564 +  enum relax_state_id direct;

  1565 +  enum relax_state_id next;

  1566 +  enum relax_state_id prev;

  1567 +

  1568 +  enum reference_type reftype;

  1569 +

  1570 +  unsigned int r_type;

  1571 +

  1572 +  bfd_vma opcode;

  1573 +  bfd_vma opcode_mask;

  1574 +

  1575 +  bfd_signed_vma range_min;

  1576 +  bfd_signed_vma range_max;

  1577 +

  1578 +  bfd_size_type size;

  1579 +};

  1580 +

  1581 +/*

  1582 + * This is for relocs that

  1583 + *   a) has an addend or is of type R_AVR32_DIFF32, and

  1584 + *   b) references a different section than it's in, and

  1585 + *   c) references a section that is relaxable

  1586 + *

  1587 + * as well as relocs that references the constant pool, in which case

  1588 + * the add_frag member points to the frag containing the constant pool

  1589 + * entry.

  1590 + *

  1591 + * Such relocs must be fixed up whenever we delete any code. Sections

  1592 + * that don't have any relocs with all of the above properties don't

  1593 + * have any additional reloc data, but sections that do will have

  1594 + * additional data for all its relocs.

  1595 + */

  1596 +struct avr32_reloc_data

  1597 +{

  1598 +  struct fragment *add_frag;

  1599 +  struct fragment *sub_frag;

  1600 +};

  1601 +

  1602 +/*

  1603 + * A 'fragment' is a relaxable entity, that is, code may be added or

  1604 + * deleted at the end of a fragment. When this happens, all subsequent

  1605 + * fragments in the list will have their offsets updated.

  1606 + */

  1607 +struct fragment

  1608 +{

  1609 +  enum relax_state_id state;

  1610 +  enum relax_state_id initial_state;

  1611 +

  1612 +  Elf_Internal_Rela *rela;

  1613 +  bfd_size_type size;

  1614 +  bfd_vma offset;

  1615 +  int size_adjust;

  1616 +  int offset_adjust;

  1617 +  bfd_boolean has_grown;

  1618 +

  1619 +  /* Only used by constant pool entries.  When this drops to zero, the

  1620 +     frag is discarded (i.e. size_adjust is set to -4.)  */

  1621 +  int refcount;

  1622 +};

  1623 +

  1624 +struct avr32_relax_data

  1625 +{

  1626 +  unsigned int frag_count;

  1627 +  struct fragment *frag;

  1628 +  struct avr32_reloc_data *reloc_data;

  1629 +

  1630 +  /* TRUE if this section has one or more relaxable relocations */

  1631 +  bfd_boolean is_relaxable;

  1632 +  unsigned int iteration;

  1633 +};

  1634 +

  1635 +struct avr32_section_data

  1636 +{

  1637 +  struct bfd_elf_section_data elf;

  1638 +  struct avr32_relax_data relax_data;

  1639 +};

  1640 +

  1641 +/* Relax state definitions */

  1642 +

  1643 +#define PIC_MOV2_OPCODE		0xe0600000

  1644 +#define PIC_MOV2_MASK		0xe1e00000

  1645 +#define PIC_MOV2_RANGE_MIN	(-1048576 * 4)

  1646 +#define PIC_MOV2_RANGE_MAX	(1048575 * 4)

  1647 +#define PIC_MCALL_OPCODE	0xf0160000

  1648 +#define PIC_MCALL_MASK		0xffff0000

  1649 +#define PIC_MCALL_RANGE_MIN	(-131072)

  1650 +#define PIC_MCALL_RANGE_MAX	(131068)

  1651 +#define RCALL2_OPCODE		0xe0a00000

  1652 +#define RCALL2_MASK		0xe1ef0000

  1653 +#define RCALL2_RANGE_MIN	(-2097152)

  1654 +#define RCALL2_RANGE_MAX	(2097150)

  1655 +#define RCALL1_OPCODE		0xc00c0000

  1656 +#define RCALL1_MASK		0xf00c0000

  1657 +#define RCALL1_RANGE_MIN	(-1024)

  1658 +#define RCALL1_RANGE_MAX	(1022)

  1659 +#define PIC_LDW4_OPCODE		0xecf00000

  1660 +#define PIC_LDW4_MASK		0xfff00000

  1661 +#define PIC_LDW4_RANGE_MIN	(-32768)

  1662 +#define PIC_LDW4_RANGE_MAX	(32767)

  1663 +#define PIC_LDW3_OPCODE		0x6c000000

  1664 +#define PIC_LDW3_MASK		0xfe000000

  1665 +#define PIC_LDW3_RANGE_MIN	(0)

  1666 +#define PIC_LDW3_RANGE_MAX	(124)

  1667 +#define SUB5_PC_OPCODE		0xfec00000

  1668 +#define SUB5_PC_MASK		0xfff00000

  1669 +#define SUB5_PC_RANGE_MIN	(-32768)

  1670 +#define SUB5_PC_RANGE_MAX	(32767)

  1671 +#define NOPIC_MCALL_OPCODE	0xf01f0000

  1672 +#define NOPIC_MCALL_MASK	0xffff0000

  1673 +#define NOPIC_MCALL_RANGE_MIN	PIC_MCALL_RANGE_MIN

  1674 +#define NOPIC_MCALL_RANGE_MAX	PIC_MCALL_RANGE_MAX

  1675 +#define NOPIC_LDW4_OPCODE	0xfef00000

  1676 +#define NOPIC_LDW4_MASK		0xfff00000

  1677 +#define NOPIC_LDW4_RANGE_MIN	PIC_LDW4_RANGE_MIN

  1678 +#define NOPIC_LDW4_RANGE_MAX	PIC_LDW4_RANGE_MAX

  1679 +#define LDDPC_OPCODE		0x48000000

  1680 +#define LDDPC_MASK		0xf8000000

  1681 +#define LDDPC_RANGE_MIN		0

  1682 +#define LDDPC_RANGE_MAX		508

  1683 +

  1684 +#define NOPIC_MOV2_OPCODE  0xe0600000

  1685 +#define NOPIC_MOV2_MASK        0xe1e00000

  1686 +#define NOPIC_MOV2_RANGE_MIN   (-1048576)

  1687 +#define NOPIC_MOV2_RANGE_MAX   (1048575)

  1688 +#define NOPIC_MOV1_OPCODE  0x30000000

  1689 +#define NOPIC_MOV1_MASK        0xf0000000

  1690 +#define NOPIC_MOV1_RANGE_MIN   (-128)

  1691 +#define NOPIC_MOV1_RANGE_MAX   (127)

  1692 +

  1693 +/* Only brc2 variants with cond[3] == 0 is considered, since the

  1694 +   others are not relaxable.  bral is a special case and is handled

  1695 +   separately.  */

  1696 +#define BRC2_OPCODE		0xe0800000

  1697 +#define BRC2_MASK		0xe1e80000

  1698 +#define BRC2_RANGE_MIN		(-2097152)

  1699 +#define BRC2_RANGE_MAX		(2097150)

  1700 +#define BRC1_OPCODE		0xc0000000

  1701 +#define BRC1_MASK		0xf0080000

  1702 +#define BRC1_RANGE_MIN		(-256)

  1703 +#define BRC1_RANGE_MAX		(254)

  1704 +#define BRAL_OPCODE		0xe08f0000

  1705 +#define BRAL_MASK		0xe1ef0000

  1706 +#define BRAL_RANGE_MIN		BRC2_RANGE_MIN

  1707 +#define BRAL_RANGE_MAX		BRC2_RANGE_MAX

  1708 +#define RJMP_OPCODE		0xc0080000

  1709 +#define RJMP_MASK		0xf00c0000

  1710 +#define RJMP_RANGE_MIN		(-1024)

  1711 +#define RJMP_RANGE_MAX		(1022)

  1712 +

  1713 +/* Define a relax state using the GOT  */

  1714 +#define RG(id, dir, next, prev, r_type, opc, size)			\

  1715 +  { "RS_"#id, RS_##id, RS_##dir, RS_##next, RS_##prev, REF_GOT,		\

  1716 +      R_AVR32_##r_type,	opc##_OPCODE, opc##_MASK,			\

  1717 +      opc##_RANGE_MIN, opc##_RANGE_MAX, size }

  1718 +/* Define a relax state using the Constant Pool  */

  1719 +#define RC(id, dir, next, prev, r_type, opc, size)			\

  1720 +  { "RS_"#id, RS_##id, RS_##dir, RS_##next, RS_##prev, REF_CPOOL,	\

  1721 +      R_AVR32_##r_type,	opc##_OPCODE, opc##_MASK,			\

  1722 +      opc##_RANGE_MIN, opc##_RANGE_MAX, size }

  1723 +

  1724 +/* Define a relax state using pc-relative direct reference  */

  1725 +#define RP(id, dir, next, prev, r_type, opc, size)			\

  1726 +  { "RS_"#id, RS_##id, RS_##dir, RS_##next, RS_##prev, REF_PCREL,	\

  1727 +      R_AVR32_##r_type,	opc##_OPCODE, opc##_MASK,			\

  1728 +      opc##_RANGE_MIN, opc##_RANGE_MAX, size }

  1729 +

  1730 +/* Define a relax state using non-pc-relative direct reference */

  1731 +#define RD(id, dir, next, prev, r_type, opc, size)         \

  1732 +  { "RS_"#id, RS_##id, RS_##dir, RS_##next, RS_##prev, REF_ABSOLUTE,   \

  1733 +      R_AVR32_##r_type,    opc##_OPCODE, opc##_MASK,           \

  1734 +      opc##_RANGE_MIN, opc##_RANGE_MAX, size }

  1735 +

  1736 +/* Define a relax state that will be handled specially  */

  1737 +#define RS(id, r_type, size)						\

  1738 +  { "RS_"#id, RS_##id, RS_NONE, RS_NONE, RS_NONE, REF_ABSOLUTE,		\

  1739 +      R_AVR32_##r_type, 0, 0, 0, 0, size }

  1740 +

  1741 +const struct relax_state relax_state[RS_MAX] = {

  1742 +  RS(NONE, NONE, 0),

  1743 +  RS(ALIGN, ALIGN, 0),

  1744 +  RS(CPENT, 32_CPENT, 4),

  1745 +

  1746 +  RG(PIC_CALL, PIC_RCALL1, PIC_MCALL, NONE, GOTCALL, PIC_MOV2, 10),

  1747 +  RG(PIC_MCALL, PIC_RCALL1, NONE, PIC_CALL, GOT18SW, PIC_MCALL, 4),

  1748 +  RP(PIC_RCALL2, NONE, PIC_RCALL1, PIC_MCALL, 22H_PCREL, RCALL2, 4),

  1749 +  RP(PIC_RCALL1, NONE, NONE, PIC_RCALL2, 11H_PCREL, RCALL1, 2),

  1750 +

  1751 +  RG(PIC_LDA, PIC_SUB5, PIC_LDW4, NONE, LDA_GOT, PIC_MOV2, 8),

  1752 +  RG(PIC_LDW4, PIC_SUB5, PIC_LDW3, PIC_LDA, GOT16S, PIC_LDW4, 4),

  1753 +  RG(PIC_LDW3, PIC_SUB5, NONE, PIC_LDW4, GOT7UW, PIC_LDW3, 2),

  1754 +  RP(PIC_SUB5, NONE, NONE, PIC_LDW3, 16N_PCREL, SUB5_PC, 4),

  1755 +

  1756 +  RC(NOPIC_MCALL, NOPIC_RCALL1, NONE, NONE, CPCALL, NOPIC_MCALL, 4),

  1757 +  RP(NOPIC_RCALL2, NONE, NOPIC_RCALL1, NOPIC_MCALL, 22H_PCREL, RCALL2, 4),

  1758 +  RP(NOPIC_RCALL1, NONE, NONE, NOPIC_RCALL2, 11H_PCREL, RCALL1, 2),

  1759 +

  1760 +  RC(NOPIC_LDW4, NOPIC_MOV1, NOPIC_LDDPC, NONE, 16_CP, NOPIC_LDW4, 4),

  1761 +  RC(NOPIC_LDDPC, NOPIC_MOV1, NONE, NOPIC_LDW4, 9W_CP, LDDPC, 2),

  1762 +  RP(NOPIC_SUB5, NOPIC_MOV1, NONE, NOPIC_LDDPC, 16N_PCREL, SUB5_PC, 4),

  1763 +  RD(NOPIC_MOV2, NONE, NOPIC_MOV1, NOPIC_SUB5, 21S, NOPIC_MOV2, 4),

  1764 +  RD(NOPIC_MOV1, NONE, NONE, NOPIC_MOV2, 8S, NOPIC_MOV1, 2),

  1765 +

  1766 +  RP(RCALL2, NONE, RCALL1, NONE, 22H_PCREL, RCALL2, 4),

  1767 +  RP(RCALL1, NONE, NONE, RCALL2, 11H_PCREL, RCALL1, 2),

  1768 +  RP(BRC2, NONE, BRC1, NONE, 22H_PCREL, BRC2, 4),

  1769 +  RP(BRC1, NONE, NONE, BRC2, 9H_PCREL, BRC1, 2),

  1770 +  RP(BRAL, NONE, RJMP, NONE, 22H_PCREL, BRAL, 4),

  1771 +  RP(RJMP, NONE, NONE, BRAL, 11H_PCREL, RJMP, 2),

  1772 +};

  1773 +

  1774 +static bfd_boolean

  1775 +avr32_elf_new_section_hook(bfd *abfd, asection *sec)

  1776 +{

  1777 +  struct avr32_section_data *sdata;

  1778 +

  1779 +  sdata = bfd_zalloc(abfd, sizeof(struct avr32_section_data));

  1780 +  if (!sdata)

  1781 +    return FALSE;

  1782 +

  1783 +  sec->used_by_bfd = sdata;

  1784 +  return _bfd_elf_new_section_hook(abfd, sec);

  1785 +}

  1786 +

  1787 +static struct avr32_relax_data *

  1788 +avr32_relax_data(asection *sec)

  1789 +{

  1790 +  struct avr32_section_data *sdata;

  1791 +

  1792 +  BFD_ASSERT(sec->used_by_bfd);

  1793 +

  1794 +  sdata = (struct avr32_section_data *)elf_section_data(sec);

  1795 +  return &sdata->relax_data;

  1796 +}

  1797 +

  1798 +/* Link-time relaxation */

  1799 +

  1800 +static bfd_boolean

  1801 +avr32_elf_relax_section(bfd *abfd, asection *sec,

  1802 +			struct bfd_link_info *info, bfd_boolean *again);

  1803 +

  1804 +enum relax_pass_id {

  1805 +  RELAX_PASS_SIZE_FRAGS,

  1806 +  RELAX_PASS_MOVE_DATA,

  1807 +};

  1808 +

  1809 +/* Stolen from the xtensa port */

  1810 +static int

  1811 +internal_reloc_compare (const void *ap, const void *bp)

  1812 +{

  1813 +  const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;

  1814 +  const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;

  1815 +

  1816 +  if (a->r_offset != b->r_offset)

  1817 +    return (a->r_offset - b->r_offset);

  1818 +

  1819 +  /* We don't need to sort on these criteria for correctness,

  1820 +     but enforcing a more strict ordering prevents unstable qsort

  1821 +     from behaving differently with different implementations.

  1822 +     Without the code below we get correct but different results

  1823 +     on Solaris 2.7 and 2.8.  We would like to always produce the

  1824 +     same results no matter the host.  */

  1825 +

  1826 +  if (a->r_info != b->r_info)

  1827 +    return (a->r_info - b->r_info);

  1828 +

  1829 +  return (a->r_addend - b->r_addend);

  1830 +}

  1831 +

  1832 +static enum relax_state_id

  1833 +get_pcrel22_relax_state(bfd *abfd, asection *sec, struct bfd_link_info *info,

  1834 +			const Elf_Internal_Rela *rela)

  1835 +{

  1836 +  bfd_byte *contents;

  1837 +  bfd_vma insn;

  1838 +  enum relax_state_id rs = RS_NONE;

  1839 +

  1840 +  contents = retrieve_contents(abfd, sec, info->keep_memory);

  1841 +  if (!contents)

  1842 +    return RS_ERROR;

  1843 +

  1844 +  insn = bfd_get_32(abfd, contents + rela->r_offset);

  1845 +  if ((insn & RCALL2_MASK) == RCALL2_OPCODE)

  1846 +    rs = RS_RCALL2;

  1847 +  else if ((insn & BRAL_MASK) == BRAL_OPCODE)

  1848 +    /* Optimizing bral -> rjmp gets us into all kinds of

  1849 +       trouble with jump tables. Better not do it.  */

  1850 +    rs = RS_NONE;

  1851 +  else if ((insn & BRC2_MASK) == BRC2_OPCODE)

  1852 +    rs = RS_BRC2;

  1853 +

  1854 +  release_contents(sec, contents);

  1855 +

  1856 +  return rs;

  1857 +}

  1858 +

  1859 +static enum relax_state_id

  1860 +get_initial_relax_state(bfd *abfd, asection *sec, struct bfd_link_info *info,

  1861 +			const Elf_Internal_Rela *rela)

  1862 +{

  1863 +  switch (ELF_R_TYPE(rela->r_info))

  1864 +    {

  1865 +    case R_AVR32_GOTCALL:

  1866 +      return RS_PIC_CALL;

  1867 +    case R_AVR32_GOT18SW:

  1868 +      return RS_PIC_MCALL;

  1869 +    case R_AVR32_LDA_GOT:

  1870 +      return RS_PIC_LDA;

  1871 +    case R_AVR32_GOT16S:

  1872 +      return RS_PIC_LDW4;

  1873 +    case R_AVR32_CPCALL:

  1874 +      return RS_NOPIC_MCALL;

  1875 +    case R_AVR32_16_CP:

  1876 +      return RS_NOPIC_LDW4;

  1877 +    case R_AVR32_9W_CP:

  1878 +      return RS_NOPIC_LDDPC;

  1879 +    case R_AVR32_ALIGN:

  1880 +      return RS_ALIGN;

  1881 +    case R_AVR32_32_CPENT:

  1882 +      return RS_CPENT;

  1883 +    case R_AVR32_22H_PCREL:

  1884 +      return get_pcrel22_relax_state(abfd, sec, info, rela);

  1885 +    case R_AVR32_9H_PCREL:

  1886 +      return RS_BRC1;

  1887 +    default:

  1888 +      return RS_NONE;

  1889 +    }

  1890 +}

  1891 +

  1892 +static bfd_boolean

  1893 +reloc_is_cpool_ref(const Elf_Internal_Rela *rela)

  1894 +{

  1895 +  switch (ELF_R_TYPE(rela->r_info))

  1896 +    {

  1897 +    case R_AVR32_CPCALL:

  1898 +    case R_AVR32_16_CP:

  1899 +    case R_AVR32_9W_CP:

  1900 +      return TRUE;

  1901 +    default:

  1902 +      return FALSE;

  1903 +    }

  1904 +}

  1905 +

  1906 +static struct fragment *

  1907 +new_frag(bfd *abfd ATTRIBUTE_UNUSED, asection *sec,

  1908 +	 struct avr32_relax_data *rd, enum relax_state_id state,

  1909 +	 Elf_Internal_Rela *rela)

  1910 +{

  1911 +  struct fragment *frag;

  1912 +  bfd_size_type r_size;

  1913 +  bfd_vma r_offset;

  1914 +  unsigned int i = rd->frag_count;

  1915 +

  1916 +  BFD_ASSERT(state >= RS_NONE && state < RS_MAX);

  1917 +

  1918 +  rd->frag_count++;

  1919 +  frag = bfd_realloc(rd->frag, sizeof(struct fragment) * rd->frag_count);

  1920 +  if (!frag)

  1921 +    return NULL;

  1922 +  rd->frag = frag;

  1923 +

  1924 +  frag += i;

  1925 +  memset(frag, 0, sizeof(struct fragment));

  1926 +

  1927 +  if (state == RS_ALIGN)

  1928 +    r_size = (((rela->r_offset + (1 << rela->r_addend) - 1)

  1929 +	       & ~((1 << rela->r_addend) - 1)) - rela->r_offset);

  1930 +  else

  1931 +    r_size = relax_state[state].size;

  1932 +

  1933 +  if (rela)

  1934 +    r_offset = rela->r_offset;

  1935 +  else

  1936 +    r_offset = sec->size;

  1937 +

  1938 +  if (i == 0)

  1939 +    {

  1940 +      frag->offset = 0;

  1941 +      frag->size = r_offset + r_size;

  1942 +    }

  1943 +  else

  1944 +    {

  1945 +      frag->offset = rd->frag[i - 1].offset + rd->frag[i - 1].size;

  1946 +      frag->size = r_offset + r_size - frag->offset;

  1947 +    }

  1948 +

  1949 +  if (state != RS_CPENT)

  1950 +    /* Make sure we don't discard this frag */

  1951 +    frag->refcount = 1;

  1952 +

  1953 +  frag->initial_state = frag->state = state;

  1954 +  frag->rela = rela;

  1955 +

  1956 +  return frag;

  1957 +}

  1958 +

  1959 +static struct fragment *

  1960 +find_frag(asection *sec, bfd_vma offset)

  1961 +{

  1962 +  struct fragment *first, *last;

  1963 +  struct avr32_relax_data *rd = avr32_relax_data(sec);

  1964 +

  1965 +  if (rd->frag_count == 0)

  1966 +    return NULL;

  1967 +

  1968 +  first = &rd->frag[0];

  1969 +  last = &rd->frag[rd->frag_count - 1];

  1970 +

  1971 +  /* This may be a reloc referencing the end of a section.  The last

  1972 +     frag will never have a reloc associated with it, so its size will

  1973 +     never change, thus the offset adjustment of the last frag will

  1974 +     always be the same as the offset adjustment of the end of the

  1975 +     section.  */

  1976 +  if (offset == sec->size)

  1977 +    {

  1978 +      BFD_ASSERT(last->offset + last->size == sec->size);

  1979 +      BFD_ASSERT(!last->rela);

  1980 +      return last;

  1981 +    }

  1982 +

  1983 +  while (first <= last)

  1984 +    {

  1985 +      struct fragment *mid;

  1986 +

  1987 +      mid = (last - first) / 2 + first;

  1988 +      if ((mid->offset + mid->size) <= offset)

  1989 +	first = mid + 1;

  1990 +      else if (mid->offset > offset)

  1991 +	last = mid - 1;

  1992 +      else

  1993 +	return mid;

  1994 +    }

  1995 +

  1996 +  return NULL;

  1997 +}

  1998 +

  1999 +/* Look through all relocs in a section and determine if any relocs

  2000 +   may be affected by relaxation in other sections.  If so, allocate

  2001 +   an array of additional relocation data which links the affected

  2002 +   relocations to the frag(s) where the relaxation may occur.

  2003 +

  2004 +   This function also links cpool references to cpool entries and

  2005 +   increments the refcount of the latter when this happens.  */

  2006 +

  2007 +static bfd_boolean

  2008 +allocate_reloc_data(bfd *abfd, asection *sec, Elf_Internal_Rela *relocs,

  2009 +		    struct bfd_link_info *info)

  2010 +{

  2011 +  Elf_Internal_Shdr *symtab_hdr;

  2012 +  Elf_Internal_Sym *isymbuf = NULL;

  2013 +  struct avr32_relax_data *rd;

  2014 +  unsigned int i;

  2015 +  bfd_boolean ret = FALSE;

  2016 +

  2017 +  symtab_hdr = &elf_tdata(abfd)->symtab_hdr;

  2018 +  rd = avr32_relax_data(sec);

  2019 +

  2020 +  RDBG("%s<%s>: allocate_reloc_data\n", abfd->filename, sec->name);

  2021 +

  2022 +  for (i = 0; i < sec->reloc_count; i++)

  2023 +    {

  2024 +      Elf_Internal_Rela *rel = &relocs[i];

  2025 +      asection *sym_sec;

  2026 +      unsigned long r_symndx;

  2027 +      bfd_vma sym_value;

  2028 +

  2029 +      if (!rel->r_addend && ELF_R_TYPE(rel->r_info) != R_AVR32_DIFF32

  2030 +	  && !reloc_is_cpool_ref(rel))

  2031 +	continue;

  2032 +

  2033 +      r_symndx = ELF_R_SYM(rel->r_info);

  2034 +

  2035 +      if (r_symndx < symtab_hdr->sh_info)

  2036 +	{

  2037 +	  Elf_Internal_Sym *isym;

  2038 +

  2039 +	  if (!isymbuf)

  2040 +	    isymbuf = retrieve_local_syms(abfd, info->keep_memory);

  2041 +	  if (!isymbuf)

  2042 +	    return FALSE;

  2043 +

  2044 +	  isym = &isymbuf[r_symndx];

  2045 +	  sym_sec = bfd_section_from_elf_index(abfd, isym->st_shndx);

  2046 +	  sym_value = isym->st_value;

  2047 +	}

  2048 +      else

  2049 +	{

  2050 +	  struct elf_link_hash_entry *h;

  2051 +

  2052 +	  h = elf_sym_hashes(abfd)[r_symndx - symtab_hdr->sh_info];

  2053 +

  2054 +	  while (h->root.type == bfd_link_hash_indirect

  2055 +		 || h->root.type == bfd_link_hash_warning)

  2056 +	    h = (struct elf_link_hash_entry *)h->root.u.i.link;

  2057 +

  2058 +	  if (h->root.type != bfd_link_hash_defined

  2059 +	      && h->root.type != bfd_link_hash_defweak)

  2060 +	    continue;

  2061 +

  2062 +	  sym_sec = h->root.u.def.section;

  2063 +	  sym_value = h->root.u.def.value;

  2064 +	}

  2065 +

  2066 +      if (sym_sec && avr32_relax_data(sym_sec)->is_relaxable)

  2067 +	{

  2068 +	  bfd_size_type size;

  2069 +	  struct fragment *frag;

  2070 +

  2071 +	  if (!rd->reloc_data)

  2072 +	    {

  2073 +	      size = sizeof(struct avr32_reloc_data) * sec->reloc_count;

  2074 +	      rd->reloc_data = bfd_zalloc(abfd, size);

  2075 +	      if (!rd->reloc_data)

  2076 +		goto out;

  2077 +	    }

  2078 +

  2079 +	  RDBG("[%3d] 0x%04lx: target: 0x%lx + 0x%lx",

  2080 +	       i, rel->r_offset, sym_value, rel->r_addend);

  2081 +

  2082 +	  frag = find_frag(sym_sec, sym_value + rel->r_addend);

  2083 +	  BFD_ASSERT(frag);

  2084 +	  rd->reloc_data[i].add_frag = frag;

  2085 +

  2086 +	  RDBG(" -> %s<%s>:%04lx\n", sym_sec->owner->filename, sym_sec->name,

  2087 +	       frag->rela ? frag->rela->r_offset : sym_sec->size);

  2088 +

  2089 +	  if (reloc_is_cpool_ref(rel))

  2090 +	    {

  2091 +	      BFD_ASSERT(ELF_R_TYPE(frag->rela->r_info) == R_AVR32_32_CPENT);

  2092 +	      frag->refcount++;

  2093 +	    }

  2094 +

  2095 +	  if (ELF_R_TYPE(rel->r_info) == R_AVR32_DIFF32)

  2096 +	    {

  2097 +	      bfd_byte *contents;

  2098 +	      bfd_signed_vma diff;

  2099 +

  2100 +	      contents = retrieve_contents(abfd, sec, info->keep_memory);

  2101 +	      if (!contents)

  2102 +		goto out;

  2103 +

  2104 +	      diff = bfd_get_signed_32(abfd, contents + rel->r_offset);

  2105 +	      frag = find_frag(sym_sec, sym_value + rel->r_addend + diff);

  2106 +	      BFD_ASSERT(frag);

  2107 +	      rd->reloc_data[i].sub_frag = frag;

  2108 +

  2109 +	      release_contents(sec, contents);

  2110 +	    }

  2111 +	}

  2112 +    }

  2113 +

  2114 +  ret = TRUE;

  2115 +

  2116 + out:

  2117 +  release_local_syms(abfd, isymbuf);

  2118 +  return ret;

  2119 +}

  2120 +

  2121 +static bfd_boolean

  2122 +global_sym_set_frag(struct elf_avr32_link_hash_entry *havr,

  2123 +		    struct bfd_link_info *info ATTRIBUTE_UNUSED)

  2124 +{

  2125 +  struct fragment *frag;

  2126 +  asection *sec;

  2127 +

  2128 +  if (havr->root.root.type != bfd_link_hash_defined

  2129 +      && havr->root.root.type != bfd_link_hash_defweak)

  2130 +    return TRUE;

  2131 +

  2132 +  sec = havr->root.root.u.def.section;

  2133 +  if (bfd_is_const_section(sec)

  2134 +      || !avr32_relax_data(sec)->is_relaxable)

  2135 +    return TRUE;

  2136 +

  2137 +  frag = find_frag(sec, havr->root.root.u.def.value);

  2138 +  if (!frag)

  2139 +    {

  2140 +      unsigned int i;

  2141 +      struct avr32_relax_data *rd = avr32_relax_data(sec);

  2142 +

  2143 +      RDBG("In %s: No frag for %s <%s+%lu> (limit %lu)\n",

  2144 +	   sec->owner->filename, havr->root.root.root.string,

  2145 +	   sec->name, havr->root.root.u.def.value, sec->size);

  2146 +      for (i = 0; i < rd->frag_count; i++)

  2147 +	RDBG("    %8lu - %8lu\n", rd->frag[i].offset,

  2148 +	     rd->frag[i].offset + rd->frag[i].size);

  2149 +    }

  2150 +  BFD_ASSERT(frag);

  2151 +

  2152 +  havr->sym_frag = frag;

  2153 +  return TRUE;

  2154 +}

  2155 +

  2156 +static bfd_boolean

  2157 +analyze_relocations(struct bfd_link_info *info)

  2158 +{

  2159 +  bfd *abfd;

  2160 +  asection *sec;

  2161 +

  2162 +  /* Divide all relaxable sections into fragments */

  2163 +  for (abfd = info->input_bfds; abfd; abfd = abfd->link_next)

  2164 +    {

  2165 +      if (!(elf_elfheader(abfd)->e_flags & EF_AVR32_LINKRELAX))

  2166 +	{

  2167 +	  if (!(*info->callbacks->warning)

  2168 +	      (info, _("input is not relaxable"), NULL, abfd, NULL, 0))

  2169 +	    return FALSE;

  2170 +	  continue;

  2171 +	}

  2172 +

  2173 +      for (sec = abfd->sections; sec; sec = sec->next)

  2174 +	{

  2175 +	  struct avr32_relax_data *rd;

  2176 +	  struct fragment *frag;

  2177 +	  Elf_Internal_Rela *relocs;

  2178 +	  unsigned int i;

  2179 +	  bfd_boolean ret = TRUE;

  2180 +

  2181 +	  if (!(sec->flags & SEC_RELOC) || sec->reloc_count == 0)

  2182 +	    continue;

  2183 +

  2184 +	  rd = avr32_relax_data(sec);

  2185 +

  2186 +	  relocs = retrieve_internal_relocs(abfd, sec, info->keep_memory);

  2187 +	  if (!relocs)

  2188 +	    return FALSE;

  2189 +

  2190 +	  qsort(relocs, sec->reloc_count, sizeof(Elf_Internal_Rela),

  2191 +		internal_reloc_compare);

  2192 +

  2193 +	  for (i = 0; i < sec->reloc_count; i++)

  2194 +	    {

  2195 +	      enum relax_state_id state;

  2196 +

  2197 +	      ret = FALSE;

  2198 +	      state = get_initial_relax_state(abfd, sec, info, &relocs[i]);

  2199 +	      if (state == RS_ERROR)

  2200 +		break;

  2201 +

  2202 +	      if (state)

  2203 +		{

  2204 +		  frag = new_frag(abfd, sec, rd, state, &relocs[i]);

  2205 +		  if (!frag)

  2206 +		    break;

  2207 +

  2208 +		  pin_internal_relocs(sec, relocs);

  2209 +		  rd->is_relaxable = TRUE;

  2210 +		}

  2211 +

  2212 +	      ret = TRUE;

  2213 +	    }

  2214 +

  2215 +	  release_internal_relocs(sec, relocs);

  2216 +	  if (!ret)

  2217 +	    return ret;

  2218 +

  2219 +	  if (rd->is_relaxable)

  2220 +	    {

  2221 +	      frag = new_frag(abfd, sec, rd, RS_NONE, NULL);

  2222 +	      if (!frag)

  2223 +		return FALSE;

  2224 +	    }

  2225 +	}

  2226 +    }

  2227 +

  2228 +  /* Link each global symbol to the fragment where it's defined.  */

  2229 +  elf_link_hash_traverse(elf_hash_table(info), global_sym_set_frag, info);

  2230 +

  2231 +  /* Do the same for local symbols. */

  2232 +  for (abfd = info->input_bfds; abfd; abfd = abfd->link_next)

  2233 +    {

  2234 +      Elf_Internal_Sym *isymbuf, *isym;

  2235 +      struct fragment **local_sym_frag;

  2236 +      unsigned int i, sym_count;

  2237 +

  2238 +      sym_count = elf_tdata(abfd)->symtab_hdr.sh_info;

  2239 +      if (sym_count == 0)

  2240 +	continue;

  2241 +

  2242 +      local_sym_frag = bfd_zalloc(abfd, sym_count * sizeof(struct fragment *));

  2243 +      if (!local_sym_frag)

  2244 +	return FALSE;

  2245 +      elf_tdata(abfd)->local_sym_frag = local_sym_frag;

  2246 +

  2247 +      isymbuf = retrieve_local_syms(abfd, info->keep_memory);

  2248 +      if (!isymbuf)

  2249 +	return FALSE;

  2250 +

  2251 +      for (i = 0; i < sym_count; i++)

  2252 +	{

  2253 +	  struct avr32_relax_data *rd;

  2254 +	  struct fragment *frag;

  2255 +	  asection *sec;

  2256 +

  2257 +	  isym = &isymbuf[i];

  2258 +

  2259 +	  sec = bfd_section_from_elf_index(abfd, isym->st_shndx);

  2260 +	  if (!sec)

  2261 +	    continue;

  2262 +

  2263 +	  rd = avr32_relax_data(sec);

  2264 +	  if (!rd->is_relaxable)

  2265 +	    continue;

  2266 +

  2267 +	  frag = find_frag(sec, isym->st_value);

  2268 +	  BFD_ASSERT(frag);

  2269 +

  2270 +	  local_sym_frag[i] = frag;

  2271 +	}

  2272 +

  2273 +      release_local_syms(abfd, isymbuf);

  2274 +    }

  2275 +

  2276 +  /* And again for relocs with addends and constant pool references */

  2277 +  for (abfd = info->input_bfds; abfd; abfd = abfd->link_next)

  2278 +    for (sec = abfd->sections; sec; sec = sec->next)

  2279 +      {

  2280 +	Elf_Internal_Rela *relocs;

  2281 +	bfd_boolean ret;

  2282 +

  2283 +	if (!(sec->flags & SEC_RELOC) || sec->reloc_count == 0)

  2284 +	  continue;

  2285 +

  2286 +	relocs = retrieve_internal_relocs(abfd, sec, info->keep_memory);

  2287 +	if (!relocs)

  2288 +	  return FALSE;

  2289 +

  2290 +	ret = allocate_reloc_data(abfd, sec, relocs, info);

  2291 +

  2292 +	release_internal_relocs(sec, relocs);

  2293 +	if (ret == FALSE)

  2294 +	  return ret;

  2295 +      }

  2296 +

  2297 +  return TRUE;

  2298 +}

  2299 +

  2300 +static bfd_boolean

  2301 +rs_is_good_enough(const struct relax_state *rs, struct fragment *frag,

  2302 +		  bfd_vma symval, bfd_vma addr, struct got_entry *got,

  2303 +		  struct avr32_reloc_data *ind_data,

  2304 +		  bfd_signed_vma offset_adjust)

  2305 +{

  2306 +  bfd_signed_vma target = 0;

  2307 +

  2308 +  switch (rs->reftype)

  2309 +    {

  2310 +    case REF_ABSOLUTE:

  2311 +      target = symval;

  2312 +      break;

  2313 +    case REF_PCREL:

  2314 +      target = symval - addr;

  2315 +      break;

  2316 +    case REF_CPOOL:

  2317 +      /* cpool frags are always in the same section and always after

  2318 +	 all frags referring to it.  So it's always correct to add in

  2319 +	 offset_adjust here.  */

  2320 +      target = (ind_data->add_frag->offset + ind_data->add_frag->offset_adjust

  2321 +		+ offset_adjust - frag->offset - frag->offset_adjust);

  2322 +      break;

  2323 +    case REF_GOT:

  2324 +      target = got->offset;

  2325 +      break;

  2326 +    default:

  2327 +      abort();

  2328 +    }

  2329 +

  2330 +  if (target >= rs->range_min && target <= rs->range_max)

  2331 +    return TRUE;

  2332 +  else

  2333 +    return FALSE;

  2334 +}

  2335 +

  2336 +static bfd_boolean

  2337 +avr32_size_frags(bfd *abfd, asection *sec, struct bfd_link_info *info)

  2338 +{

  2339 +  struct elf_avr32_link_hash_table *htab;

  2340 +  struct avr32_relax_data *rd;

  2341 +  Elf_Internal_Shdr *symtab_hdr;

  2342 +  Elf_Internal_Rela *relocs = NULL;

  2343 +  Elf_Internal_Sym *isymbuf = NULL;

  2344 +  struct got_entry **local_got_ents;

  2345 +  struct fragment **local_sym_frag;

  2346 +  bfd_boolean ret = FALSE;

  2347 +  bfd_signed_vma delta = 0;

  2348 +  unsigned int i;

  2349 +

  2350 +  htab = avr32_elf_hash_table(info);

  2351 +  rd = avr32_relax_data(sec);

  2352 +

  2353 +  if (sec == htab->sgot)

  2354 +    {

  2355 +      RDBG("Relaxing GOT section (vma: 0x%lx)\n",

  2356 +	   sec->output_section->vma + sec->output_offset);

  2357 +      if (assign_got_offsets(htab))

  2358 +	htab->repeat_pass = TRUE;

  2359 +      return TRUE;

  2360 +    }

  2361 +

  2362 +  if (!rd->is_relaxable)

  2363 +    return TRUE;

  2364 +

  2365 +  if (!sec->rawsize)

  2366 +    sec->rawsize = sec->size;

  2367 +

  2368 +  symtab_hdr = &elf_tdata(abfd)->symtab_hdr;

  2369 +  relocs = retrieve_internal_relocs(abfd, sec, info->keep_memory);

  2370 +  if (!relocs)

  2371 +    goto out;

  2372 +

  2373 +  isymbuf = retrieve_local_syms(abfd, info->keep_memory);

  2374 +  if (!isymbuf)

  2375 +    goto out;

  2376 +

  2377 +  local_got_ents = elf_local_got_ents(abfd);

  2378 +  local_sym_frag = elf_tdata(abfd)->local_sym_frag;

  2379 +

  2380 +  RDBG("size_frags: %s<%s>\n  vma: 0x%08lx, size: 0x%08lx\n",

  2381 +       abfd->filename, sec->name,

  2382 +       sec->output_section->vma + sec->output_offset, sec->size);

  2383 +

  2384 +  for (i = 0; i < rd->frag_count; i++)

  2385 +    {

  2386 +      struct fragment *frag = &rd->frag[i];

  2387 +      struct avr32_reloc_data *r_data = NULL, *ind_data = NULL;

  2388 +      const struct relax_state *state, *next_state;

  2389 +      struct fragment *target_frag = NULL;

  2390 +      asection *sym_sec = NULL;

  2391 +      Elf_Internal_Rela *rela;

  2392 +      struct got_entry *got;

  2393 +      bfd_vma symval, r_offset, addend, addr;

  2394 +      bfd_signed_vma size_adjust = 0, distance;

  2395 +      unsigned long r_symndx;

  2396 +      bfd_boolean defined = TRUE, dynamic = FALSE;

  2397 +      unsigned char sym_type;

  2398 +

  2399 +      frag->offset_adjust += delta;

  2400 +      state = next_state = &relax_state[frag->state];

  2401 +      rela = frag->rela;

  2402 +

  2403 +      BFD_ASSERT(state->id == frag->state);

  2404 +

  2405 +      RDBG("  0x%04lx%c%d: %s [size %ld]", rela ? rela->r_offset : sec->rawsize,

  2406 +	   (frag->offset_adjust < 0)?'-':'+',

  2407 +	   abs(frag->offset_adjust), state->name, state->size);

  2408 +

  2409 +      if (!rela)

  2410 +	{

  2411 +	  RDBG(": no reloc, ignoring\n");

  2412 +	  continue;

  2413 +	}

  2414 +

  2415 +      BFD_ASSERT((unsigned int)(rela - relocs) < sec->reloc_count);

  2416 +      BFD_ASSERT(state != RS_NONE);

  2417 +

  2418 +      r_offset = rela->r_offset + frag->offset_adjust;

  2419 +      addr = sec->output_section->vma + sec->output_offset + r_offset;

  2420 +

  2421 +      switch (frag->state)

  2422 +	{

  2423 +	case RS_ALIGN:

  2424 +	  size_adjust = ((addr + (1 << rela->r_addend) - 1)

  2425 +			 & ~((1 << rela->r_addend) - 1));

  2426 +	  size_adjust -= (sec->output_section->vma + sec->output_offset

  2427 +			  + frag->offset + frag->offset_adjust

  2428 +			  + frag->size + frag->size_adjust);

  2429 +

  2430 +	  RDBG(": adjusting size %lu -> %lu\n", frag->size + frag->size_adjust,

  2431 +	       frag->size + frag->size_adjust + size_adjust);

  2432 +	  break;

  2433 +

  2434 +	case RS_CPENT:

  2435 +	  if (frag->refcount == 0 && frag->size_adjust == 0)

  2436 +	    {

  2437 +	      RDBG(": discarding frag\n");

  2438 +	      size_adjust = -4;

  2439 +	    }

  2440 +	  else if (frag->refcount > 0 && frag->size_adjust < 0)

  2441 +	    {

  2442 +	      RDBG(": un-discarding frag\n");

  2443 +	      size_adjust = 4;

  2444 +	    }

  2445 +	  break;

  2446 +

  2447 +	default:

  2448 +	  if (rd->reloc_data)

  2449 +	    r_data = &rd->reloc_data[frag->rela - relocs];

  2450 +

  2451 +	  /* If this is a cpool reference, we want the symbol that the

  2452 +	     cpool entry refers to, not the symbol for the cpool entry

  2453 +	     itself, as we already know what frag it's in.  */

  2454 +	  if (relax_state[frag->initial_state].reftype == REF_CPOOL)

  2455 +	    {

  2456 +	      Elf_Internal_Rela *irela = r_data->add_frag->rela;

  2457 +

  2458 +	      r_symndx = ELF_R_SYM(irela->r_info);

  2459 +	      addend = irela->r_addend;

  2460 +

  2461 +	      /* The constant pool must be in the same section as the

  2462 +		 reloc referring to it.  */

  2463 +	      BFD_ASSERT((unsigned long)(irela - relocs) < sec->reloc_count);

  2464 +

  2465 +	      ind_data = r_data;

  2466 +	      r_data = &rd->reloc_data[irela - relocs];

  2467 +	    }

  2468 +	  else

  2469 +	    {

  2470 +	      r_symndx = ELF_R_SYM(rela->r_info);

  2471 +	      addend = rela->r_addend;

  2472 +	    }

  2473 +

  2474 +	  /* Get the value of the symbol referred to by the reloc.  */

  2475 +	  if (r_symndx < symtab_hdr->sh_info)

  2476 +	    {

  2477 +	      Elf_Internal_Sym *isym;

  2478 +

  2479 +	      isym = isymbuf + r_symndx;

  2480 +	      symval = 0;

  2481 +

  2482 +	      RDBG(" local sym %lu: ", r_symndx);

  2483 +

  2484 +	      if (isym->st_shndx == SHN_UNDEF)

  2485 +		defined = FALSE;

  2486 +	      else if (isym->st_shndx == SHN_ABS)

  2487 +		sym_sec = bfd_abs_section_ptr;

  2488 +	      else if (isym->st_shndx == SHN_COMMON)

  2489 +		sym_sec = bfd_com_section_ptr;

  2490 +	      else

  2491 +		sym_sec = bfd_section_from_elf_index(abfd, isym->st_shndx);

  2492 +

  2493 +	      symval = isym->st_value;

  2494 +	      sym_type = ELF_ST_TYPE(isym->st_info);

  2495 +	      target_frag = local_sym_frag[r_symndx];

  2496 +

  2497 +	      if (local_got_ents)

  2498 +		got = local_got_ents[r_symndx];

  2499 +	      else

  2500 +		got = NULL;

  2501 +	    }

  2502 +	  else

  2503 +	    {

  2504 +	      /* Global symbol */

  2505 +	      unsigned long index;

  2506 +	      struct elf_link_hash_entry *h;

  2507 +	      struct elf_avr32_link_hash_entry *havr;

  2508 +

  2509 +	      index = r_symndx - symtab_hdr->sh_info;

  2510 +	      h = elf_sym_hashes(abfd)[index];

  2511 +	      BFD_ASSERT(h != NULL);

  2512 +

  2513 +	      while (h->root.type == bfd_link_hash_indirect

  2514 +		     || h->root.type == bfd_link_hash_warning)

  2515 +		h = (struct elf_link_hash_entry *)h->root.u.i.link;

  2516 +

  2517 +	      havr = (struct elf_avr32_link_hash_entry *)h;

  2518 +	      got = h->got.glist;

  2519 +

  2520 +	      symval = 0;

  2521 +

  2522 +	      RDBG(" %s: ", h->root.root.string);

  2523 +

  2524 +	      if (h->root.type != bfd_link_hash_defined

  2525 +		  && h->root.type != bfd_link_hash_defweak)

  2526 +		{

  2527 +		  RDBG("(undef)");

  2528 +		  defined = FALSE;

  2529 +		}

  2530 +	      else if ((info->shared && !info->symbolic && h->dynindx != -1)

  2531 +		       || (htab->root.dynamic_sections_created

  2532 +			   && h->def_dynamic && !h->def_regular))

  2533 +		{

  2534 +		  RDBG("(dynamic)");

  2535 +		  dynamic = TRUE;

  2536 +		  sym_sec = h->root.u.def.section;

  2537 +		}

  2538 +	      else

  2539 +		{

  2540 +		  sym_sec = h->root.u.def.section;

  2541 +		  symval = h->root.u.def.value;

  2542 +		  target_frag = havr->sym_frag;

  2543 +		}

  2544 +

  2545 +	      sym_type = h->type;

  2546 +	    }

  2547 +

  2548 +	  /* Thanks to elf32-ppc for this one.  */

  2549 +	  if (sym_sec && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)

  2550 +	    {

  2551 +	      /* At this stage in linking, no SEC_MERGE symbol has been

  2552 +		 adjusted, so all references to such symbols need to be

  2553 +		 passed through _bfd_merged_section_offset.  (Later, in

  2554 +		 relocate_section, all SEC_MERGE symbols *except* for

  2555 +		 section symbols have been adjusted.)

  2556 +

  2557 +	         SEC_MERGE sections are not relaxed by us, as they

  2558 +	         shouldn't contain any code.  */

  2559 +

  2560 +	      BFD_ASSERT(!target_frag && !(r_data && r_data->add_frag));

  2561 +

  2562 +	      /* gas may reduce relocations against symbols in SEC_MERGE

  2563 +		 sections to a relocation against the section symbol when

  2564 +		 the original addend was zero.  When the reloc is against

  2565 +		 a section symbol we should include the addend in the

  2566 +		 offset passed to _bfd_merged_section_offset, since the

  2567 +		 location of interest is the original symbol.  On the

  2568 +		 other hand, an access to "sym+addend" where "sym" is not

  2569 +		 a section symbol should not include the addend;  Such an

  2570 +		 access is presumed to be an offset from "sym";  The

  2571 +		 location of interest is just "sym".  */

  2572 +	      RDBG("\n    MERGE: %s: 0x%lx+0x%lx+0x%lx -> ",

  2573 +		   (sym_type == STT_SECTION)?"section":"not section",

  2574 +		   sym_sec->output_section->vma + sym_sec->output_offset,

  2575 +		   symval, addend);

  2576 +

  2577 +	      if (sym_type == STT_SECTION)

  2578 +		symval += addend;

  2579 +

  2580 +	      symval = (_bfd_merged_section_offset

  2581 +			(abfd, &sym_sec,

  2582 +			 elf_section_data(sym_sec)->sec_info, symval));

  2583 +

  2584 +	      if (sym_type != STT_SECTION)

  2585 +		symval += addend;

  2586 +	    }

  2587 +	  else

  2588 +	    symval += addend;

  2589 +

  2590 +	  if (defined && !dynamic)

  2591 +	    {

  2592 +	      RDBG("0x%lx+0x%lx",

  2593 +		   sym_sec->output_section->vma + sym_sec->output_offset,

  2594 +		   symval);

  2595 +	      symval += sym_sec->output_section->vma + sym_sec->output_offset;

  2596 +	    }

  2597 +

  2598 +	  if (r_data && r_data->add_frag)

  2599 +	    /* If the add_frag pointer is set, it means that this reloc

  2600 +	       has an addend that may be affected by relaxation.  */

  2601 +	    target_frag = r_data->add_frag;

  2602 +

  2603 +	  if (target_frag)

  2604 +	    {

  2605 +	      symval += target_frag->offset_adjust;

  2606 +

  2607 +	      /* If target_frag comes after this frag in the same

  2608 +		 section, we should assume that it will be moved by

  2609 +		 the same amount we are.  */

  2610 +	      if ((target_frag - rd->frag) < (int)rd->frag_count

  2611 +		  && target_frag > frag)

  2612 +		symval += delta;

  2613 +	    }

  2614 +

  2615 +	  distance = symval - addr;

  2616 +

  2617 +	  /* First, try to make a direct reference.  If the symbol is

  2618 +	     dynamic or undefined, we must take care not to change its

  2619 +	     reference type, that is, we can't make it direct.

  2620 +

  2621 +	     Also, it seems like some sections may actually be resized

  2622 +	     after the relaxation code is done, so we can't really

  2623 +	     trust that our "distance" is correct.  There's really no

  2624 +	     easy solution to this problem, so we'll just disallow

  2625 +	     direct references to SEC_DATA sections.

  2626 +

  2627 +	     Oh, and .bss isn't actually SEC_DATA, so we disallow

  2628 +	     !SEC_HAS_CONTENTS as well. */

  2629 +	  if (!dynamic && defined

  2630 +	      && (htab->direct_data_refs

  2631 +		  || (!(sym_sec->flags & SEC_DATA)

  2632 +		      && (sym_sec->flags & SEC_HAS_CONTENTS)))

  2633 +	      && next_state->direct)

  2634 +	    {

  2635 +	      next_state = &relax_state[next_state->direct];

  2636 +	      RDBG(" D-> %s", next_state->name);

  2637 +	    }

  2638 +

  2639 +	  /* Iterate backwards until we find a state that fits.  */

  2640 +	  while (next_state->prev

  2641 +		 && !rs_is_good_enough(next_state, frag, symval, addr,

  2642 +				       got, ind_data, delta))

  2643 +	    {

  2644 +	      next_state = &relax_state[next_state->prev];

  2645 +	      RDBG(" P-> %s", next_state->name);

  2646 +	    }

  2647 +

  2648 +	  /* Then try to find the best possible state.  */

  2649 +	  while (next_state->next)

  2650 +	    {

  2651 +	      const struct relax_state *candidate;

  2652 +

  2653 +	      candidate = &relax_state[next_state->next];

  2654 +	      if (!rs_is_good_enough(candidate, frag, symval, addr, got,

  2655 +				     ind_data, delta))

  2656 +		break;

  2657 +

  2658 +	      next_state = candidate;

  2659 +	      RDBG(" N-> %s", next_state->name);

  2660 +	    }

  2661 +

  2662 +	  RDBG(" [size %ld]\n", next_state->size);

  2663 +

  2664 +	  BFD_ASSERT(next_state->id);

  2665 +	  BFD_ASSERT(!dynamic || next_state->reftype == REF_GOT);

  2666 +

  2667 +	  size_adjust = next_state->size - state->size;

  2668 +

  2669 +	  /* There's a theoretical possibility that shrinking one frag

  2670 +	     may cause another to grow, which may cause the first one to

  2671 +	     grow as well, and we're back where we started.  Avoid this

  2672 +	     scenario by disallowing a frag that has grown to ever

  2673 +	     shrink again.  */

  2674 +	  if (state->reftype == REF_GOT && next_state->reftype != REF_GOT)

  2675 +	    {

  2676 +	      if (frag->has_grown)

  2677 +		next_state = state;

  2678 +	      else

  2679 +		unref_got_entry(htab, got);

  2680 +	    }

  2681 +	  else if (state->reftype != REF_GOT && next_state->reftype == REF_GOT)

  2682 +	    {

  2683 +	      ref_got_entry(htab, got);

  2684 +	      frag->has_grown = TRUE;

  2685 +	    }

  2686 +	  else if (state->reftype == REF_CPOOL

  2687 +		   && next_state->reftype != REF_CPOOL)

  2688 +	    {

  2689 +	      if (frag->has_grown)

  2690 +		next_state = state;

  2691 +	      else

  2692 +		ind_data->add_frag->refcount--;

  2693 +	    }

  2694 +	  else if (state->reftype != REF_CPOOL

  2695 +		   && next_state->reftype == REF_CPOOL)

  2696 +	    {

  2697 +	      ind_data->add_frag->refcount++;

  2698 +	      frag->has_grown = TRUE;

  2699 +	    }

  2700 +	  else

  2701 +	    {

  2702 +	      if (frag->has_grown && size_adjust < 0)

  2703 +		next_state = state;

  2704 +	      else if (size_adjust > 0)

  2705 +		frag->has_grown = TRUE;

  2706 +	    }

  2707 +

  2708 +	  size_adjust = next_state->size - state->size;

  2709 +	  frag->state = next_state->id;

  2710 +

  2711 +	  break;

  2712 +	}

  2713 +

  2714 +      if (size_adjust)

  2715 +	htab->repeat_pass = TRUE;

  2716 +

  2717 +      frag->size_adjust += size_adjust;

  2718 +      sec->size += size_adjust;

  2719 +      delta += size_adjust;

  2720 +

  2721 +      BFD_ASSERT((frag->offset + frag->offset_adjust

  2722 +		  + frag->size + frag->size_adjust)

  2723 +		 == (frag[1].offset + frag[1].offset_adjust + delta));

  2724 +    }

  2725 +

  2726 +  ret = TRUE;

  2727 +

  2728 + out:

  2729 +  release_local_syms(abfd, isymbuf);

  2730 +  release_internal_relocs(sec, relocs);

  2731 +  return ret;

  2732 +}

  2733 +

  2734 +static bfd_boolean

  2735 +adjust_global_symbol(struct elf_avr32_link_hash_entry *havr,

  2736 +		     struct bfd_link_info *info ATTRIBUTE_UNUSED)

  2737 +{

  2738 +  struct elf_link_hash_entry *h = &havr->root;

  2739 +

  2740 +  if (havr->sym_frag && (h->root.type == bfd_link_hash_defined

  2741 +			 || h->root.type == bfd_link_hash_defweak))

  2742 +    {

  2743 +      RDBG("adjust_global_symbol: %s 0x%08lx -> 0x%08lx\n",

  2744 +	   h->root.root.string, h->root.u.def.value,

  2745 +	   h->root.u.def.value + havr->sym_frag->offset_adjust);

  2746 +      h->root.u.def.value += havr->sym_frag->offset_adjust;

  2747 +    }

  2748 +  return TRUE;

  2749 +}

  2750 +

  2751 +static bfd_boolean

  2752 +adjust_syms(struct bfd_link_info *info)

  2753 +{

  2754 +  struct elf_avr32_link_hash_table *htab;

  2755 +  bfd *abfd;

  2756 +

  2757 +  htab = avr32_elf_hash_table(info);

  2758 +  elf_link_hash_traverse(&htab->root, adjust_global_symbol, info);

  2759 +

  2760 +  for (abfd = info->input_bfds; abfd; abfd = abfd->link_next)

  2761 +    {

  2762 +      Elf_Internal_Sym *isymbuf;

  2763 +      struct fragment **local_sym_frag, *frag;

  2764 +      unsigned int i, sym_count;

  2765 +

  2766 +      sym_count = elf_tdata(abfd)->symtab_hdr.sh_info;

  2767 +      if (sym_count == 0)

  2768 +	continue;

  2769 +

  2770 +      isymbuf = retrieve_local_syms(abfd, info->keep_memory);

  2771 +      if (!isymbuf)

  2772 +	return FALSE;

  2773 +

  2774 +      local_sym_frag = elf_tdata(abfd)->local_sym_frag;

  2775 +

  2776 +      for (i = 0; i < sym_count; i++)

  2777 +	{

  2778 +	  frag = local_sym_frag[i];

  2779 +	  if (frag)

  2780 +	    {

  2781 +	      RDBG("adjust_local_symbol: %s[%u] 0x%08lx -> 0x%08lx\n",

  2782 +		   abfd->filename, i, isymbuf[i].st_value,

  2783 +		   isymbuf[i].st_value + frag->offset_adjust);

  2784 +	      isymbuf[i].st_value += frag->offset_adjust;

  2785 +	    }

  2786 +	}

  2787 +

  2788 +      release_local_syms(abfd, isymbuf);

  2789 +    }

  2790 +

  2791 +  htab->symbols_adjusted = TRUE;

  2792 +  return TRUE;

  2793 +}

  2794 +

  2795 +static bfd_boolean

  2796 +adjust_relocs(bfd *abfd, asection *sec, struct bfd_link_info *info)

  2797 +{

  2798 +  struct avr32_relax_data *rd;

  2799 +  Elf_Internal_Rela *relocs;

  2800 +  Elf_Internal_Shdr *symtab_hdr;

  2801 +  unsigned int i;

  2802 +  bfd_boolean ret = FALSE;

  2803 +

  2804 +  rd = avr32_relax_data(sec);

  2805 +  if (!rd->reloc_data)

  2806 +    return TRUE;

  2807 +

  2808 +  RDBG("adjust_relocs: %s<%s> (count: %u)\n", abfd->filename, sec->name,

  2809 +       sec->reloc_count);

  2810 +

  2811 +  relocs = retrieve_internal_relocs(abfd, sec, info->keep_memory);

  2812 +  if (!relocs)

  2813 +    return FALSE;

  2814 +

  2815 +  symtab_hdr = &elf_tdata(abfd)->symtab_hdr;

  2816 +

  2817 +  for (i = 0; i < sec->reloc_count; i++)

  2818 +    {

  2819 +      Elf_Internal_Rela *rela = &relocs[i];

  2820 +      struct avr32_reloc_data *r_data = &rd->reloc_data[i];

  2821 +      struct fragment *sym_frag;

  2822 +      unsigned long r_symndx;

  2823 +

  2824 +      if (r_data->add_frag)

  2825 +	{

  2826 +	  r_symndx = ELF_R_SYM(rela->r_info);

  2827 +

  2828 +	  if (r_symndx < symtab_hdr->sh_info)

  2829 +	    sym_frag = elf_tdata(abfd)->local_sym_frag[r_symndx];

  2830 +	  else

  2831 +	    {

  2832 +	      struct elf_link_hash_entry *h;

  2833 +

  2834 +	      h = elf_sym_hashes(abfd)[r_symndx - symtab_hdr->sh_info];

  2835 +

  2836 +	      while (h->root.type == bfd_link_hash_indirect

  2837 +		     || h->root.type == bfd_link_hash_warning)

  2838 +		h = (struct elf_link_hash_entry *)h->root.u.i.link;

  2839 +

  2840 +	      BFD_ASSERT(h->root.type == bfd_link_hash_defined

  2841 +			 || h->root.type == bfd_link_hash_defweak);

  2842 +

  2843 +	      sym_frag = ((struct elf_avr32_link_hash_entry *)h)->sym_frag;

  2844 +	    }

  2845 +

  2846 +	  RDBG("    addend: 0x%08lx -> 0x%08lx\n",

  2847 +	       rela->r_addend,

  2848 +	       rela->r_addend + r_data->add_frag->offset_adjust

  2849 +	       - (sym_frag ? sym_frag->offset_adjust : 0));

  2850 +

  2851 +	  /* If this is against a section symbol, we won't find any

  2852 +	     sym_frag, so we'll just adjust the addend.  */

  2853 +	  rela->r_addend += r_data->add_frag->offset_adjust;

  2854 +	  if (sym_frag)

  2855 +	    rela->r_addend -= sym_frag->offset_adjust;

  2856 +

  2857 +	  if (r_data->sub_frag)

  2858 +	    {

  2859 +	      bfd_byte *contents;

  2860 +	      bfd_signed_vma diff;

  2861 +

  2862 +	      contents = retrieve_contents(abfd, sec, info->keep_memory);

  2863 +	      if (!contents)

  2864 +		goto out;

  2865 +

  2866 +	      /* I realize now that sub_frag is misnamed.  It's

  2867 +		 actually add_frag which is subtracted in this

  2868 +		 case...  */

  2869 +	      diff = bfd_get_signed_32(abfd, contents + rela->r_offset);

  2870 +	      diff += (r_data->sub_frag->offset_adjust

  2871 +		       - r_data->add_frag->offset_adjust);

  2872 +	      bfd_put_32(abfd, diff, contents + rela->r_offset);

  2873 +

  2874 +	      RDBG("   0x%lx: DIFF32 updated: 0x%lx\n", rela->r_offset, diff);

  2875 +

  2876 +	      release_contents(sec, contents);

  2877 +	    }

  2878 +	}

  2879 +      else

  2880 +	BFD_ASSERT(!r_data->sub_frag);

  2881 +    }

  2882 +

  2883 +  ret = TRUE;

  2884 +

  2885 + out:

  2886 +  release_internal_relocs(sec, relocs);

  2887 +  return ret;

  2888 +}

  2889 +

  2890 +static bfd_boolean

  2891 +avr32_move_data(bfd *abfd, asection *sec, struct bfd_link_info *info)

  2892 +{

  2893 +  struct elf_avr32_link_hash_table *htab;

  2894 +  struct avr32_relax_data *rd;

  2895 +  struct fragment *frag, *fragend;

  2896 +  Elf_Internal_Rela *relocs = NULL;

  2897 +  bfd_byte *contents = NULL;

  2898 +  unsigned int i;

  2899 +  bfd_boolean ret = FALSE;

  2900 +

  2901 +  htab = avr32_elf_hash_table(info);

  2902 +  rd = avr32_relax_data(sec);

  2903 +

  2904 +  if (!htab->symbols_adjusted)

  2905 +    if (!adjust_syms(info))

  2906 +      return FALSE;

  2907 +

  2908 +  if (rd->is_relaxable)

  2909 +    {

  2910 +      /* Resize the section first, so that we can be sure that enough

  2911 +	 memory is allocated in case the section has grown.  */

  2912 +      if (sec->size > sec->rawsize

  2913 +	  && elf_section_data(sec)->this_hdr.contents)

  2914 +	{

  2915 +	  /* We must not use cached data if the section has grown.  */

  2916 +	  free(elf_section_data(sec)->this_hdr.contents);

  2917 +	  elf_section_data(sec)->this_hdr.contents = NULL;

  2918 +	}

  2919 +

  2920 +      relocs = retrieve_internal_relocs(abfd, sec, info->keep_memory);

  2921 +      if (!relocs)

  2922 +	goto out;

  2923 +      contents = retrieve_contents(abfd, sec, info->keep_memory);

  2924 +      if (!contents)

  2925 +	goto out;

  2926 +

  2927 +      fragend = rd->frag + rd->frag_count;

  2928 +

  2929 +      RDBG("move_data: %s<%s>: relocs=%p, contents=%p\n",

  2930 +	   abfd->filename, sec->name, relocs, contents);

  2931 +

  2932 +      /* First, move the data into place. We must take care to move

  2933 +	 frags in the right order so that we don't accidentally

  2934 +	 overwrite parts of the next frag.  */

  2935 +      for (frag = rd->frag; frag < fragend; frag++)

  2936 +	{

  2937 +	  RDBG("    0x%08lx%c0x%x: size 0x%lx%c0x%x\n",

  2938 +	       frag->offset, frag->offset_adjust >= 0 ? '+' : '-',

  2939 +	       abs(frag->offset_adjust),

  2940 +	       frag->size, frag->size_adjust >= 0 ? '+' : '-',

  2941 +	       abs(frag->size_adjust));

  2942 +	  if (frag->offset_adjust > 0)

  2943 +	    {

  2944 +	      struct fragment *prev = frag - 1;

  2945 +	      struct fragment *last;

  2946 +

  2947 +	      for (last = frag; last < fragend && last->offset_adjust > 0;

  2948 +		   last++) ;

  2949 +

  2950 +	      if (last == fragend)

  2951 +		last--;

  2952 +

  2953 +	      for (frag = last; frag != prev; frag--)

  2954 +		{

  2955 +		  if (frag->offset_adjust

  2956 +		      && frag->size + frag->size_adjust > 0)

  2957 +		    {

  2958 +		      RDBG("memmove 0x%lx -> 0x%lx (size %lu)\n",

  2959 +			   frag->offset, frag->offset + frag->offset_adjust,

  2960 +			   frag->size + frag->size_adjust);

  2961 +		      memmove(contents + frag->offset + frag->offset_adjust,

  2962 +			      contents + frag->offset,

  2963 +			      frag->size + frag->size_adjust);

  2964 +		    }

  2965 +		}

  2966 +	      frag = last;

  2967 +	    }

  2968 +	  else if (frag->offset_adjust && frag->size + frag->size_adjust > 0)

  2969 +	    {

  2970 +	      RDBG("memmove 0x%lx -> 0x%lx (size %lu)\n",

  2971 +		   frag->offset, frag->offset + frag->offset_adjust,

  2972 +		   frag->size + frag->size_adjust);

  2973 +	      memmove(contents + frag->offset + frag->offset_adjust,

  2974 +		      contents + frag->offset,

  2975 +		      frag->size + frag->size_adjust);

  2976 +	    }

  2977 +	}

  2978 +

  2979 +      i = 0;

  2980 +

  2981 +      for (frag = rd->frag; frag < fragend; frag++)

  2982 +	{

  2983 +	  const struct relax_state *state, *istate;

  2984 +	  struct avr32_reloc_data *r_data = NULL;

  2985 +

  2986 +	  istate = &relax_state[frag->initial_state];

  2987 +	  state = &relax_state[frag->state];

  2988 +

  2989 +	  if (rd->reloc_data)

  2990 +	    r_data = &rd->reloc_data[frag->rela - relocs];

  2991 +

  2992 +	  BFD_ASSERT((long)(frag->size + frag->size_adjust) >= 0);

  2993 +	  BFD_ASSERT(state->reftype != REF_CPOOL

  2994 +		     || r_data->add_frag->refcount > 0);

  2995 +

  2996 +	  if (istate->reftype == REF_CPOOL && state->reftype != REF_CPOOL)

  2997 +	    {

  2998 +	      struct fragment *ifrag;

  2999 +

  3000 +	      /* An indirect reference through the cpool has been

  3001 +		 converted to a direct reference.  We must update the

  3002 +		 reloc to point to the symbol itself instead of the

  3003 +		 constant pool entry.  The reloc type will be updated

  3004 +		 later.  */

  3005 +	      ifrag = r_data->add_frag;

  3006 +	      frag->rela->r_info = ifrag->rela->r_info;

  3007 +	      frag->rela->r_addend = ifrag->rela->r_addend;

  3008 +

  3009 +	      /* Copy the reloc data so the addend will be adjusted

  3010 +		 correctly later.  */

  3011 +	      *r_data = rd->reloc_data[ifrag->rela - relocs];

  3012 +	    }

  3013 +

  3014 +	  /* Move all relocs covered by this frag.  */

  3015 +	  if (frag->rela)

  3016 +	    BFD_ASSERT(&relocs[i] <= frag->rela);

  3017 +	  else

  3018 +	    BFD_ASSERT((frag + 1) == fragend && frag->state == RS_NONE);

  3019 +

  3020 +	  if (frag == rd->frag)

  3021 +	    BFD_ASSERT(i == 0);

  3022 +	  else

  3023 +	    BFD_ASSERT(&relocs[i] > frag[-1].rela);

  3024 +

  3025 +	  /* If non-null, frag->rela is the last relocation in the

  3026 +	     fragment.  frag->rela can only be null in the last

  3027 +	     fragment, so in that case, we'll just do the rest.  */

  3028 +	  for (; (i < sec->reloc_count

  3029 +		  && (!frag->rela || &relocs[i] <= frag->rela)); i++)

  3030 +	    {

  3031 +	      RDBG("[%4u] r_offset 0x%08lx -> 0x%08lx\n", i, relocs[i].r_offset,

  3032 +		   relocs[i].r_offset + frag->offset_adjust);

  3033 +	      relocs[i].r_offset += frag->offset_adjust;

  3034 +	    }

  3035 +

  3036 +	  if (frag->refcount == 0)

  3037 +	    {

  3038 +	      /* If this frag is to be discarded, make sure we won't

  3039 +		 relocate it later on.  */

  3040 +	      BFD_ASSERT(frag->state == RS_CPENT);

  3041 +	      frag->rela->r_info = ELF_R_INFO(ELF_R_SYM(frag->rela->r_info),

  3042 +					    R_AVR32_NONE);

  3043 +	    }

  3044 +	  else if (frag->state == RS_ALIGN)

  3045 +	    {

  3046 +	      bfd_vma addr, addr_end;

  3047 +

  3048 +	      addr = frag->rela->r_offset;

  3049 +	      addr_end = (frag->offset + frag->offset_adjust

  3050 +			  + frag->size + frag->size_adjust);

  3051 +

  3052 +	      /* If the section is executable, insert NOPs.

  3053 +		 Otherwise, insert zeroes.  */

  3054 +	      if (sec->flags & SEC_CODE)

  3055 +		{

  3056 +		  if (addr & 1)

  3057 +		    {

  3058 +		      bfd_put_8(abfd, 0, contents + addr);

  3059 +		      addr++;

  3060 +		    }

  3061 +

  3062 +		  BFD_ASSERT(!((addr_end - addr) & 1));

  3063 +

  3064 +		  while (addr < addr_end)

  3065 +		    {

  3066 +		      bfd_put_16(abfd, NOP_OPCODE, contents + addr);

  3067 +		      addr += 2;

  3068 +		    }

  3069 +		}

  3070 +	      else

  3071 +		memset(contents + addr, 0, addr_end - addr);

  3072 +	    }

  3073 +	  else if (state->opcode_mask)

  3074 +	    {

  3075 +	      bfd_vma insn;

  3076 +

  3077 +	      /* Update the opcode and the relocation type unless it's a

  3078 +		 "special" relax state (i.e. RS_NONE, RS_ALIGN or

  3079 +		 RS_CPENT.), in which case the opcode mask is zero.  */

  3080 +	      insn = bfd_get_32(abfd, contents + frag->rela->r_offset);

  3081 +	      insn &= ~state->opcode_mask;

  3082 +	      insn |= state->opcode;

  3083 +	      RDBG("    0x%lx: inserting insn %08lx\n",

  3084 +		   frag->rela->r_offset, insn);

  3085 +	      bfd_put_32(abfd, insn, contents + frag->rela->r_offset);

  3086 +

  3087 +	      frag->rela->r_info = ELF_R_INFO(ELF_R_SYM(frag->rela->r_info),

  3088 +					      state->r_type);

  3089 +	    }

  3090 +

  3091 +	  if ((frag + 1) == fragend)

  3092 +	    BFD_ASSERT((frag->offset + frag->size + frag->offset_adjust

  3093 +			+ frag->size_adjust) == sec->size);

  3094 +	  else

  3095 +	    BFD_ASSERT((frag->offset + frag->size + frag->offset_adjust

  3096 +			+ frag->size_adjust)

  3097 +		       == (frag[1].offset + frag[1].offset_adjust));

  3098 +	}

  3099 +    }

  3100 +

  3101 +  /* Adjust reloc addends and DIFF32 differences */

  3102 +  if (!adjust_relocs(abfd, sec, info))

  3103 +    return FALSE;

  3104 +

  3105 +  ret = TRUE;

  3106 +

  3107 + out:

  3108 +  release_contents(sec, contents);

  3109 +  release_internal_relocs(sec, relocs);

  3110 +  return ret;

  3111 +}

  3112 +

  3113 +static bfd_boolean

  3114 +avr32_elf_relax_section(bfd *abfd, asection *sec,

  3115 +			struct bfd_link_info *info, bfd_boolean *again)

  3116 +{

  3117 +  struct elf_avr32_link_hash_table *htab;

  3118 +  struct avr32_relax_data *rd;

  3119 +

  3120 +  *again = FALSE;

  3121 +  if (info->relocatable)

  3122 +    return TRUE;

  3123 +

  3124 +  htab = avr32_elf_hash_table(info);

  3125 +  if ((!(sec->flags & SEC_RELOC) || sec->reloc_count == 0)

  3126 +      && sec != htab->sgot)

  3127 +    return TRUE;

  3128 +

  3129 +  if (!htab->relocations_analyzed)

  3130 +    {

  3131 +      if (!analyze_relocations(info))

  3132 +	return FALSE;

  3133 +      htab->relocations_analyzed = TRUE;

  3134 +    }

  3135 +

  3136 +  rd = avr32_relax_data(sec);

  3137 +

  3138 +  if (rd->iteration != htab->relax_iteration)

  3139 +    {

  3140 +      if (!htab->repeat_pass)

  3141 +	htab->relax_pass++;

  3142 +      htab->relax_iteration++;

  3143 +      htab->repeat_pass = FALSE;

  3144 +    }

  3145 +

  3146 +  rd->iteration++;

  3147 +

  3148 +  switch (htab->relax_pass)

  3149 +    {

  3150 +    case RELAX_PASS_SIZE_FRAGS:

  3151 +      if (!avr32_size_frags(abfd, sec, info))

  3152 +	return FALSE;

  3153 +      *again = TRUE;

  3154 +      break;

  3155 +    case RELAX_PASS_MOVE_DATA:

  3156 +      if (!avr32_move_data(abfd, sec, info))

  3157 +	return FALSE;

  3158 +      break;

  3159 +  }

  3160 +

  3161 +  return TRUE;

  3162 +}

  3163 +

  3164 +

  3165 +/* Relocation */

  3166 +

  3167 +static bfd_reloc_status_type

  3168 +avr32_check_reloc_value(asection *sec, Elf_Internal_Rela *rela,

  3169 +			bfd_signed_vma relocation, reloc_howto_type *howto);

  3170 +static bfd_reloc_status_type

  3171 +avr32_final_link_relocate(reloc_howto_type *howto, bfd *input_bfd,

  3172 +			  asection *input_section, bfd_byte *contents,

  3173 +			  Elf_Internal_Rela *rel, bfd_vma value);

  3174 +static bfd_boolean

  3175 +avr32_elf_relocate_section(bfd *output_bfd, struct bfd_link_info *info,

  3176 +			   bfd *input_bfd, asection *input_section,

  3177 +			   bfd_byte *contents, Elf_Internal_Rela *relocs,

  3178 +			   Elf_Internal_Sym *local_syms,

  3179 +			   asection **local_sections);

  3180 +

  3181 +

  3182 +#define symbol_address(symbol) \

  3183 +  symbol->value + symbol->section->output_section->vma \

  3184 +  + symbol->section->output_offset

  3185 +

  3186 +#define avr32_elf_insert_field(size, field, abfd, reloc_entry, data)	\

  3187 +  do									\

  3188 +    {									\

  3189 +      unsigned long x;							\

  3190 +      x = bfd_get_##size (abfd, data + reloc_entry->address);		\

  3191 +      x &= ~reloc_entry->howto->dst_mask;				\

  3192 +      x |= field & reloc_entry->howto->dst_mask;			\

  3193 +      bfd_put_##size (abfd, (bfd_vma) x, data + reloc_entry->address);	\

  3194 +    }									\

  3195 +  while(0)

  3196 +

  3197 +static bfd_reloc_status_type

  3198 +avr32_check_reloc_value(asection *sec ATTRIBUTE_UNUSED,

  3199 +			Elf_Internal_Rela *rela ATTRIBUTE_UNUSED,

  3200 +			bfd_signed_vma relocation,

  3201 +			reloc_howto_type *howto)

  3202 +{

  3203 +  bfd_vma reloc_u;

  3204 +

  3205 +  /* We take "complain_overflow_dont" to mean "don't complain on

  3206 +     alignment either". This way, we don't have to special-case

  3207 +     R_AVR32_HI16 */

  3208 +  if (howto->complain_on_overflow == complain_overflow_dont)

  3209 +    return bfd_reloc_ok;

  3210 +

  3211 +  /* Check if the value is correctly aligned */

  3212 +  if (relocation & ((1 << howto->rightshift) - 1))

  3213 +    {

  3214 +      RDBG("misaligned: %s<%s+%lx>: %s: 0x%lx (align %u)\n",

  3215 +	   sec->owner->filename, sec->name, rela->r_offset,

  3216 +	   howto->name, relocation, howto->rightshift);

  3217 +      return bfd_reloc_overflow;

  3218 +    }

  3219 +

  3220 +  /* Now, get rid of the unnecessary bits */

  3221 +  relocation >>= howto->rightshift;

  3222 +  reloc_u = (bfd_vma)relocation;

  3223 +

  3224 +  switch (howto->complain_on_overflow)

  3225 +    {

  3226 +    case complain_overflow_unsigned:

  3227 +    case complain_overflow_bitfield:

  3228 +      if (reloc_u > (unsigned long)((1 << howto->bitsize) - 1))

  3229 +	{

  3230 +	  RDBG("unsigned overflow: %s<%s+%lx>: %s: 0x%lx (size %u)\n",

  3231 +	       sec->owner->filename, sec->name, rela->r_offset,

  3232 +	       howto->name, reloc_u, howto->bitsize);

  3233 +	  RDBG("reloc vma: 0x%lx\n",

  3234 +	       sec->output_section->vma + sec->output_offset + rela->r_offset);

  3235 +

  3236 +	  return bfd_reloc_overflow;

  3237 +	}

  3238 +      break;

  3239 +    case complain_overflow_signed:

  3240 +      if (relocation > (1 << (howto->bitsize - 1)) - 1)

  3241 +	{

  3242 +	  RDBG("signed overflow: %s<%s+%lx>: %s: 0x%lx (size %u)\n",

  3243 +	       sec->owner->filename, sec->name, rela->r_offset,

  3244 +	       howto->name, reloc_u, howto->bitsize);

  3245 +	  RDBG("reloc vma: 0x%lx\n",

  3246 +	       sec->output_section->vma + sec->output_offset + rela->r_offset);

  3247 +

  3248 +	  return bfd_reloc_overflow;

  3249 +	}

  3250 +      if (relocation < -(1 << (howto->bitsize - 1)))

  3251 +	{

  3252 +	  RDBG("signed overflow: %s<%s+%lx>: %s: -0x%lx (size %u)\n",

  3253 +	       sec->owner->filename, sec->name, rela->r_offset,

  3254 +	       howto->name, -relocation, howto->bitsize);

  3255 +	  RDBG("reloc vma: 0x%lx\n",

  3256 +	       sec->output_section->vma + sec->output_offset + rela->r_offset);

  3257 +

  3258 +	  return bfd_reloc_overflow;

  3259 +	}

  3260 +      break;

  3261 +    default:

  3262 +      abort();

  3263 +    }

  3264 +

  3265 +  return bfd_reloc_ok;

  3266 +}

  3267 +

  3268 +

  3269 +static bfd_reloc_status_type

  3270 +avr32_final_link_relocate(reloc_howto_type *howto,

  3271 +			  bfd *input_bfd,

  3272 +			  asection *input_section,

  3273 +			  bfd_byte *contents,

  3274 +			  Elf_Internal_Rela *rel,

  3275 +			  bfd_vma value)

  3276 +{

  3277 +  bfd_vma field;

  3278 +  bfd_vma relocation;

  3279 +  bfd_reloc_status_type status;

  3280 +  bfd_byte *p = contents + rel->r_offset;

  3281 +  unsigned long x;

  3282 +

  3283 +  pr_debug("  (6b) final link relocate\n");

  3284 +

  3285 +  /* Sanity check the address */

  3286 +  if (rel->r_offset > input_section->size)

  3287 +    {

  3288 +      (*_bfd_error_handler)

  3289 +	("%B: %A+0x%lx: offset out of range (section size: 0x%lx)",

  3290 +	 input_bfd, input_section, rel->r_offset, input_section->size);

  3291 +      return bfd_reloc_outofrange;

  3292 +    }

  3293 +

  3294 +  relocation = value + rel->r_addend;

  3295 +

  3296 +  if (howto->pc_relative)

  3297 +    {

  3298 +      bfd_vma addr;

  3299 +

  3300 +      addr = input_section->output_section->vma

  3301 +	+ input_section->output_offset + rel->r_offset;

  3302 +      addr &= ~0UL << howto->rightshift;

  3303 +      relocation -= addr;

  3304 +    }

  3305 +

  3306 +  switch (ELF32_R_TYPE(rel->r_info))

  3307 +    {

  3308 +    case R_AVR32_16N_PCREL:

  3309 +      /* sub reg, pc, . - (sym + addend) */

  3310 +      relocation = -relocation;

  3311 +      break;

  3312 +    }

  3313 +

  3314 +  status = avr32_check_reloc_value(input_section, rel, relocation, howto);

  3315 +

  3316 +  relocation >>= howto->rightshift;

  3317 +  if (howto->bitsize == 21)

  3318 +    field = (relocation & 0xffff)

  3319 +      | ((relocation & 0x10000) << 4)

  3320 +      | ((relocation & 0x1e0000) << 8);

  3321 +  else if (howto->bitsize == 12)

  3322 +    field = (relocation & 0xff) | ((relocation & 0xf00) << 4);

  3323 +  else if (howto->bitsize == 10)

  3324 +    field = ((relocation & 0xff) << 4)

  3325 +      | ((relocation & 0x300) >> 8);

  3326 +  else

  3327 +    field = relocation << howto->bitpos;

  3328 +

  3329 +  switch (howto->size)

  3330 +    {

  3331 +    case 0:

  3332 +      x = bfd_get_8 (input_bfd, p);

  3333 +      x &= ~howto->dst_mask;

  3334 +      x |= field & howto->dst_mask;

  3335 +      bfd_put_8 (input_bfd, (bfd_vma) x, p);

  3336 +      break;

  3337 +    case 1:

  3338 +      x = bfd_get_16 (input_bfd, p);

  3339 +      x &= ~howto->dst_mask;

  3340 +      x |= field & howto->dst_mask;

  3341 +      bfd_put_16 (input_bfd, (bfd_vma) x, p);

  3342 +      break;

  3343 +    case 2:

  3344 +      x = bfd_get_32 (input_bfd, p);

  3345 +      x &= ~howto->dst_mask;

  3346 +      x |= field & howto->dst_mask;

  3347 +      bfd_put_32 (input_bfd, (bfd_vma) x, p);

  3348 +      break;

  3349 +    default:

  3350 +      abort();

  3351 +    }

  3352 +

  3353 +  return status;

  3354 +}

  3355 +

  3356 +/* (6) Apply relocations to the normal (non-dynamic) sections */

  3357 +

  3358 +static bfd_boolean

  3359 +avr32_elf_relocate_section(bfd *output_bfd, struct bfd_link_info *info,

  3360 +			   bfd *input_bfd, asection *input_section,

  3361 +			   bfd_byte *contents, Elf_Internal_Rela *relocs,

  3362 +			   Elf_Internal_Sym *local_syms,

  3363 +			   asection **local_sections)

  3364 +{

  3365 +  struct elf_avr32_link_hash_table *htab;

  3366 +  Elf_Internal_Shdr *symtab_hdr;

  3367 +  Elf_Internal_Rela *rel, *relend;

  3368 +  struct elf_link_hash_entry **sym_hashes;

  3369 +  struct got_entry **local_got_ents;

  3370 +  asection *sgot;

  3371 +  asection *srelgot;

  3372 +

  3373 +  pr_debug("(6) relocate section %s:<%s> (size 0x%lx)\n",

  3374 +	   input_bfd->filename, input_section->name, input_section->size);

  3375 +

  3376 +  /* If we're doing a partial link, we don't have to do anything since

  3377 +     we're using RELA relocations */

  3378 +  if (info->relocatable)

  3379 +    return TRUE;

  3380 +

  3381 +  htab = avr32_elf_hash_table(info);

  3382 +  symtab_hdr = &elf_tdata(input_bfd)->symtab_hdr;

  3383 +  sym_hashes = elf_sym_hashes(input_bfd);

  3384 +  local_got_ents = elf_local_got_ents(input_bfd);

  3385 +  sgot = htab->sgot;

  3386 +  srelgot = htab->srelgot;

  3387 +

  3388 +  relend = relocs + input_section->reloc_count;

  3389 +  for (rel = relocs; rel < relend; rel++)

  3390 +    {

  3391 +      unsigned long r_type, r_symndx;

  3392 +      reloc_howto_type *howto;

  3393 +      Elf_Internal_Sym *sym = NULL;

  3394 +      struct elf_link_hash_entry *h = NULL;

  3395 +      asection *sec = NULL;

  3396 +      bfd_vma value;

  3397 +      bfd_vma offset;

  3398 +      bfd_reloc_status_type status;

  3399 +

  3400 +      r_type = ELF32_R_TYPE(rel->r_info);

  3401 +      r_symndx = ELF32_R_SYM(rel->r_info);

  3402 +

  3403 +      if (r_type == R_AVR32_NONE

  3404 +	  || r_type == R_AVR32_ALIGN

  3405 +	  || r_type == R_AVR32_DIFF32

  3406 +	  || r_type == R_AVR32_DIFF16

  3407 +	  || r_type == R_AVR32_DIFF8)

  3408 +	continue;

  3409 +

  3410 +      /* Sanity check */

  3411 +      if (r_type > R_AVR32_max)

  3412 +	{

  3413 +	  bfd_set_error(bfd_error_bad_value);

  3414 +	  return FALSE;

  3415 +	}

  3416 +

  3417 +      howto = &elf_avr32_howto_table[r_type];

  3418 +

  3419 +      if (r_symndx < symtab_hdr->sh_info)

  3420 +	{

  3421 +	  sym = local_syms + r_symndx;

  3422 +	  sec = local_sections[r_symndx];

  3423 +

  3424 +	  pr_debug("  (6a) processing %s against local symbol %lu\n",

  3425 +		   howto->name, r_symndx);

  3426 +

  3427 +	  /* The following function changes rel->r_addend behind our back. */

  3428 +	  value = _bfd_elf_rela_local_sym(output_bfd, sym, &sec, rel);

  3429 +	  pr_debug("    => value: %lx, addend: %lx\n", value, rel->r_addend);

  3430 +	}

  3431 +      else

  3432 +	{

  3433 +	  if (sym_hashes == NULL)

  3434 +	    return FALSE;

  3435 +

  3436 +	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];

  3437 +	  while (h->root.type == bfd_link_hash_indirect

  3438 +		 || h->root.type == bfd_link_hash_warning)

  3439 +	    h = (struct elf_link_hash_entry *)h->root.u.i.link;

  3440 +

  3441 +	  pr_debug("  (6a) processing %s against symbol %s\n",

  3442 +		   howto->name, h->root.root.string);

  3443 +

  3444 +	  if (h->root.type == bfd_link_hash_defined

  3445 +	      || h->root.type == bfd_link_hash_defweak)

  3446 +	    {

  3447 +	      bfd_boolean dyn;

  3448 +

  3449 +	      dyn = htab->root.dynamic_sections_created;

  3450 +	      sec = h->root.u.def.section;

  3451 +

  3452 +	      if (sec->output_section)

  3453 +		value = (h->root.u.def.value

  3454 +			 + sec->output_section->vma

  3455 +			 + sec->output_offset);

  3456 +	      else

  3457 +		value = h->root.u.def.value;

  3458 +	    }

  3459 +	  else if (h->root.type == bfd_link_hash_undefweak)

  3460 +	    value = 0;

  3461 +	  else if (info->unresolved_syms_in_objects == RM_IGNORE

  3462 +		   && ELF_ST_VISIBILITY(h->other) == STV_DEFAULT)

  3463 +	    value = 0;

  3464 +	  else

  3465 +	    {

  3466 +	      bfd_boolean err;

  3467 +	      err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR

  3468 +		     || ELF_ST_VISIBILITY(h->other) != STV_DEFAULT);

  3469 +	      if (!info->callbacks->undefined_symbol

  3470 +		  (info, h->root.root.string, input_bfd,

  3471 +		   input_section, rel->r_offset, err))

  3472 +		return FALSE;

  3473 +	      value = 0;

  3474 +	    }

  3475 +

  3476 +	  pr_debug("    => value: %lx, addend: %lx\n", value, rel->r_addend);

  3477 +	}

  3478 +

  3479 +      switch (r_type)

  3480 +	{

  3481 +	case R_AVR32_GOT32:

  3482 +	case R_AVR32_GOT16:

  3483 +	case R_AVR32_GOT8:

  3484 +	case R_AVR32_GOT21S:

  3485 +	case R_AVR32_GOT18SW:

  3486 +	case R_AVR32_GOT16S:

  3487 +	case R_AVR32_GOT7UW:

  3488 +	case R_AVR32_LDA_GOT:

  3489 +	case R_AVR32_GOTCALL:

  3490 +	  BFD_ASSERT(sgot != NULL);

  3491 +

  3492 +	  if (h != NULL)

  3493 +	    {

  3494 +	      BFD_ASSERT(h->got.glist->refcount > 0);

  3495 +	      offset = h->got.glist->offset;

  3496 +

  3497 +	      BFD_ASSERT(offset < sgot->size);

  3498 +	      if (!elf_hash_table(info)->dynamic_sections_created

  3499 +		  || (h->def_regular

  3500 +		      && (!info->shared

  3501 +			  || info->symbolic

  3502 +			  || h->dynindx == -1)))

  3503 +		{

  3504 +		  /* This is actually a static link, or it is a

  3505 +		     -Bsymbolic link and the symbol is defined

  3506 +		     locally, or the symbol was forced to be local.  */

  3507 +		  bfd_put_32(output_bfd, value, sgot->contents + offset);

  3508 +		}

  3509 +	    }

  3510 +	  else

  3511 +	    {

  3512 +	      BFD_ASSERT(local_got_ents &&

  3513 +			 local_got_ents[r_symndx]->refcount > 0);

  3514 +	      offset = local_got_ents[r_symndx]->offset;

  3515 +

  3516 +	      /* Local GOT entries don't have relocs.  If this is a

  3517 +		 shared library, the dynamic linker will add the load

  3518 +		 address to the initial value at startup.  */

  3519 +	      BFD_ASSERT(offset < sgot->size);

  3520 +	      pr_debug("Initializing GOT entry at offset %lu: 0x%lx\n",

  3521 +		       offset, value);

  3522 +	      bfd_put_32 (output_bfd, value, sgot->contents + offset);

  3523 +	    }

  3524 +

  3525 +	  value = sgot->output_offset + offset;

  3526 +	  pr_debug("GOT reference: New value %lx\n", value);

  3527 +	  break;

  3528 +

  3529 +	case R_AVR32_GOTPC:

  3530 +	  /* This relocation type is for constant pool entries used in

  3531 +	     the calculation "Rd = PC - (PC - GOT)", where the

  3532 +	     constant pool supplies the constant (PC - GOT)

  3533 +	     offset. The symbol value + addend indicates where the

  3534 +	     value of PC is taken. */

  3535 +	  value -= sgot->output_section->vma;

  3536 +	  break;

  3537 +

  3538 +	case R_AVR32_32_PCREL:

  3539 +	  /* We must adjust r_offset to account for discarded data in

  3540 +	     the .eh_frame section.  This is probably not the right

  3541 +	     way to do this, since AFAICS all other architectures do

  3542 +	     it some other way.  I just can't figure out how...  */

  3543 +	  {

  3544 +	    bfd_vma r_offset;

  3545 +

  3546 +	    r_offset = _bfd_elf_section_offset(output_bfd, info,

  3547 +					       input_section,

  3548 +					       rel->r_offset);

  3549 +	    if (r_offset == (bfd_vma)-1

  3550 +		|| r_offset == (bfd_vma)-2)

  3551 +	      continue;

  3552 +	    rel->r_offset = r_offset;

  3553 +	  }

  3554 +	  break;

  3555 +

  3556 +	case R_AVR32_32:

  3557 +	  /* We need to emit a run-time relocation in the following cases:

  3558 +	       - we're creating a shared library

  3559 +	       - the symbol is not defined in any regular objects

  3560 +

  3561 +	     Of course, sections that aren't going to be part of the

  3562 +	     run-time image will not get any relocs, and undefined

  3563 +	     symbols won't have any either (only weak undefined

  3564 +	     symbols should get this far).  */

  3565 +	  if ((info->shared

  3566 +	       || (elf_hash_table(info)->dynamic_sections_created

  3567 +		   && h != NULL

  3568 +		   && h->def_dynamic

  3569 +		   && !h->def_regular))

  3570 +	      && r_symndx != 0

  3571 +	      && (input_section->flags & SEC_ALLOC))

  3572 +	    {

  3573 +	      Elf_Internal_Rela outrel;

  3574 +	      bfd_byte *loc;

  3575 +	      bfd_boolean skip, relocate;

  3576 +	      struct elf_avr32_link_hash_entry *avrh;

  3577 +

  3578 +	      pr_debug("Going to generate dynamic reloc...\n");

  3579 +

  3580 +	      skip = FALSE;

  3581 +	      relocate = FALSE;

  3582 +

  3583 +	      outrel.r_offset = _bfd_elf_section_offset(output_bfd, info,

  3584 +							input_section,

  3585 +							rel->r_offset);

  3586 +	      if (outrel.r_offset == (bfd_vma)-1)

  3587 +		skip = TRUE;

  3588 +	      else if (outrel.r_offset == (bfd_vma)-2)

  3589 +		skip = TRUE, relocate = TRUE;

  3590 +

  3591 +	      outrel.r_offset += (input_section->output_section->vma

  3592 +				  + input_section->output_offset);

  3593 +

  3594 +	      pr_debug("    ... offset %lx, dynindx %ld\n",

  3595 +		       outrel.r_offset, h ? h->dynindx : -1);

  3596 +

  3597 +	      if (skip)

  3598 +		memset(&outrel, 0, sizeof(outrel));

  3599 +	      else

  3600 +		{

  3601 +		  avrh = (struct elf_avr32_link_hash_entry *)h;

  3602 +		  /* h->dynindx may be -1 if this symbol was marked to

  3603 +		     become local.  */

  3604 +		  if (h == NULL

  3605 +		      || ((info->symbolic || h->dynindx == -1)

  3606 +			  && h->def_regular))

  3607 +		    {

  3608 +		      relocate = TRUE;

  3609 +		      outrel.r_info = ELF32_R_INFO(0, R_AVR32_RELATIVE);

  3610 +		      outrel.r_addend = value + rel->r_addend;

  3611 +		      pr_debug("    ... R_AVR32_RELATIVE\n");

  3612 +		    }

  3613 +		  else

  3614 +		    {

  3615 +		      BFD_ASSERT(h->dynindx != -1);

  3616 +		      relocate = TRUE;

  3617 +		      outrel.r_info = ELF32_R_INFO(h->dynindx, R_AVR32_GLOB_DAT);

  3618 +		      outrel.r_addend = rel->r_addend;

  3619 +		      pr_debug("    ... R_AVR32_GLOB_DAT\n");

  3620 +		    }

  3621 +		}

  3622 +

  3623 +	      pr_debug("srelgot reloc_count: %d, size %lu\n",

  3624 +		       srelgot->reloc_count, srelgot->size);

  3625 +

  3626 +	      loc = srelgot->contents;

  3627 +	      loc += srelgot->reloc_count++ * sizeof(Elf32_External_Rela);

  3628 +	      bfd_elf32_swap_reloca_out(output_bfd, &outrel, loc);

  3629 +

  3630 +	      BFD_ASSERT(srelgot->reloc_count * sizeof(Elf32_External_Rela)

  3631 +			 <= srelgot->size);

  3632 +

  3633 +	      if (!relocate)

  3634 +		continue;

  3635 +	    }

  3636 +	  break;

  3637 +	}

  3638 +

  3639 +      status = avr32_final_link_relocate(howto, input_bfd, input_section,

  3640 +					 contents, rel, value);

  3641 +

  3642 +      switch (status)

  3643 +	{

  3644 +	case bfd_reloc_ok:

  3645 +	  break;

  3646 +

  3647 +	case bfd_reloc_overflow:

  3648 +	  {

  3649 +	    const char *name;

  3650 +

  3651 +	    if (h != NULL)

  3652 +	      name = h->root.root.string;

  3653 +	    else

  3654 +	      {

  3655 +		name = bfd_elf_string_from_elf_section(input_bfd,

  3656 +						       symtab_hdr->sh_link,

  3657 +						       sym->st_name);

  3658 +		if (name == NULL)

  3659 +		  return FALSE;

  3660 +		if (*name == '\0')

  3661 +		  name = bfd_section_name(input_bfd, sec);

  3662 +	      }

  3663 +	    if (!((*info->callbacks->reloc_overflow)

  3664 +		  (info, (h ? &h->root : NULL), name, howto->name,

  3665 +		   rel->r_addend, input_bfd, input_section, rel->r_offset)))

  3666 +	      return FALSE;

  3667 +	  }

  3668 +	  break;

  3669 +

  3670 +	case bfd_reloc_outofrange:

  3671 +	default:

  3672 +	  abort();

  3673 +	}

  3674 +    }

  3675 +

  3676 +  return TRUE;

  3677 +}

  3678 +

  3679 +

  3680 +/* Additional processing of dynamic sections after relocation */

  3681 +

  3682 +static bfd_boolean

  3683 +avr32_elf_finish_dynamic_symbol(bfd *output_bfd, struct bfd_link_info *info,

  3684 +				struct elf_link_hash_entry *h,

  3685 +				Elf_Internal_Sym *sym);

  3686 +static bfd_boolean

  3687 +avr32_elf_finish_dynamic_sections(bfd *output_bfd, struct bfd_link_info *info);

  3688 +

  3689 +

  3690 +/* (7) Initialize the contents of a dynamic symbol and/or emit

  3691 +   relocations for it */

  3692 +

  3693 +static bfd_boolean

  3694 +avr32_elf_finish_dynamic_symbol(bfd *output_bfd, struct bfd_link_info *info,

  3695 +				struct elf_link_hash_entry *h,

  3696 +				Elf_Internal_Sym *sym)

  3697 +{

  3698 +  struct elf_avr32_link_hash_table *htab;

  3699 +  struct got_entry *got;

  3700 +

  3701 +  pr_debug("(7) finish dynamic symbol: %s\n", h->root.root.string);

  3702 +

  3703 +  htab = avr32_elf_hash_table(info);

  3704 +  got = h->got.glist;

  3705 +

  3706 +  if (got && got->refcount > 0)

  3707 +    {

  3708 +      asection *sgot;

  3709 +      asection *srelgot;

  3710 +      Elf_Internal_Rela rel;

  3711 +      bfd_byte *loc;

  3712 +

  3713 +      /* This symbol has an entry in the GOT. Set it up. */

  3714 +      sgot = htab->sgot;

  3715 +      srelgot = htab->srelgot;

  3716 +      BFD_ASSERT(sgot && srelgot);

  3717 +

  3718 +      rel.r_offset = (sgot->output_section->vma

  3719 +		      + sgot->output_offset

  3720 +		      + got->offset);

  3721 +

  3722 +      /* If this is a static link, or it is a -Bsymbolic link and the

  3723 +	 symbol is defined locally or was forced to be local because

  3724 +	 of a version file, we just want to emit a RELATIVE reloc. The

  3725 +	 entry in the global offset table will already have been

  3726 +	 initialized in the relocate_section function. */

  3727 +      if ((info->shared

  3728 +	   && !info->symbolic

  3729 +	   && h->dynindx != -1)

  3730 +	  || (htab->root.dynamic_sections_created

  3731 +	      && h->def_dynamic

  3732 +	      && !h->def_regular))

  3733 +	{

  3734 +	  bfd_put_32(output_bfd, 0, sgot->contents + got->offset);

  3735 +	  rel.r_info = ELF32_R_INFO(h->dynindx, R_AVR32_GLOB_DAT);

  3736 +	  rel.r_addend = 0;

  3737 +

  3738 +	  pr_debug("GOT reloc R_AVR32_GLOB_DAT, dynindx: %ld\n", h->dynindx);

  3739 +	  pr_debug("    srelgot reloc_count: %d, size: %lu\n",

  3740 +		   srelgot->reloc_count, srelgot->size);

  3741 +

  3742 +	  loc = (srelgot->contents

  3743 +		 + srelgot->reloc_count++ * sizeof(Elf32_External_Rela));

  3744 +	  bfd_elf32_swap_reloca_out(output_bfd, &rel, loc);

  3745 +

  3746 +	  BFD_ASSERT(srelgot->reloc_count * sizeof(Elf32_External_Rela)

  3747 +		     <= srelgot->size);

  3748 +	}

  3749 +    }

  3750 +

  3751 +  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute */

  3752 +  if (strcmp(h->root.root.string, "_DYNAMIC") == 0

  3753 +      || strcmp(h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)

  3754 +    sym->st_shndx = SHN_ABS;

  3755 +

  3756 +  return TRUE;

  3757 +}

  3758 +

  3759 +/* (8) Do any remaining initialization of the dynamic sections */

  3760 +

  3761 +static bfd_boolean

  3762 +avr32_elf_finish_dynamic_sections(bfd *output_bfd, struct bfd_link_info *info)

  3763 +{

  3764 +  struct elf_avr32_link_hash_table *htab;

  3765 +  asection *sgot, *sdyn;

  3766 +

  3767 +  pr_debug("(8) finish dynamic sections\n");

  3768 +

  3769 +  htab = avr32_elf_hash_table(info);

  3770 +  sgot = htab->sgot;

  3771 +  sdyn = bfd_get_section_by_name(htab->root.dynobj, ".dynamic");

  3772 +

  3773 +  if (htab->root.dynamic_sections_created)

  3774 +    {

  3775 +      Elf32_External_Dyn *dyncon, *dynconend;

  3776 +

  3777 +      BFD_ASSERT(sdyn && sgot && sgot->size >= AVR32_GOT_HEADER_SIZE);

  3778 +

  3779 +      dyncon = (Elf32_External_Dyn *)sdyn->contents;

  3780 +      dynconend = (Elf32_External_Dyn *)(sdyn->contents + sdyn->size);

  3781 +      for (; dyncon < dynconend; dyncon++)

  3782 +	{

  3783 +	  Elf_Internal_Dyn dyn;

  3784 +	  asection *s;

  3785 +

  3786 +	  bfd_elf32_swap_dyn_in(htab->root.dynobj, dyncon, &dyn);

  3787 +

  3788 +	  switch (dyn.d_tag)

  3789 +	    {

  3790 +	    default:

  3791 +	      break;

  3792 +

  3793 +	    case DT_PLTGOT:

  3794 +	      s = sgot->output_section;

  3795 +	      BFD_ASSERT(s != NULL);

  3796 +	      dyn.d_un.d_ptr = s->vma;

  3797 +	      bfd_elf32_swap_dyn_out(output_bfd, &dyn, dyncon);

  3798 +	      break;

  3799 +

  3800 +	    case DT_AVR32_GOTSZ:

  3801 +	      s = sgot->output_section;

  3802 +	      BFD_ASSERT(s != NULL);

  3803 +	      dyn.d_un.d_val = s->size;

  3804 +	      bfd_elf32_swap_dyn_out(output_bfd, &dyn, dyncon);

  3805 +	      break;

  3806 +	    }

  3807 +	}

  3808 +

  3809 +      /* Fill in the first two entries in the global offset table */

  3810 +      bfd_put_32(output_bfd,

  3811 +		 sdyn->output_section->vma + sdyn->output_offset,

  3812 +		 sgot->contents);

  3813 +

  3814 +      /* The runtime linker will fill this one in with the address of

  3815 +	 the run-time link map */

  3816 +      bfd_put_32(output_bfd, 0, sgot->contents + 4);

  3817 +    }

  3818 +

  3819 +  if (sgot)

  3820 +    elf_section_data(sgot->output_section)->this_hdr.sh_entsize = 4;

  3821 +

  3822 +  return TRUE;

  3823 +}

  3824 +

  3825 +

  3826 +/* AVR32-specific private ELF data */

  3827 +

  3828 +static bfd_boolean

  3829 +avr32_elf_set_private_flags(bfd *abfd, flagword flags);

  3830 +static bfd_boolean

  3831 +avr32_elf_copy_private_bfd_data(bfd *ibfd, bfd *obfd);

  3832 +static bfd_boolean

  3833 +avr32_elf_merge_private_bfd_data(bfd *ibfd, bfd *obfd);

  3834 +static bfd_boolean

  3835 +avr32_elf_print_private_bfd_data(bfd *abfd, void *ptr);

  3836 +

  3837 +static bfd_boolean

  3838 +avr32_elf_set_private_flags(bfd *abfd, flagword flags)

  3839 +{

  3840 +  elf_elfheader(abfd)->e_flags = flags;

  3841 +  elf_flags_init(abfd) = TRUE;

  3842 +

  3843 +  return TRUE;

  3844 +}

  3845 +

  3846 +/* Copy backend specific data from one object module to another.  */

  3847 +

  3848 +static bfd_boolean

  3849 +avr32_elf_copy_private_bfd_data(bfd *ibfd, bfd *obfd)

  3850 +{

  3851 +  elf_elfheader(obfd)->e_flags = elf_elfheader(ibfd)->e_flags;

  3852 +  return TRUE;

  3853 +}

  3854 +

  3855 +/* Merge backend specific data from an object file to the output

  3856 +   object file when linking.  */

  3857 +

  3858 +static bfd_boolean

  3859 +avr32_elf_merge_private_bfd_data(bfd *ibfd, bfd *obfd)

  3860 +{

  3861 +  flagword out_flags, in_flags;

  3862 +

  3863 +  pr_debug("(0) merge_private_bfd_data: %s -> %s\n",

  3864 +	   ibfd->filename, obfd->filename);

  3865 +

  3866 +  in_flags = elf_elfheader(ibfd)->e_flags;

  3867 +  out_flags = elf_elfheader(obfd)->e_flags;

  3868 +

  3869 +  if (elf_flags_init(obfd))

  3870 +    {

  3871 +      /* If one of the inputs are non-PIC, the output must be

  3872 +	 considered non-PIC.  The same applies to linkrelax.  */

  3873 +      if (!(in_flags & EF_AVR32_PIC))

  3874 +	out_flags &= ~EF_AVR32_PIC;

  3875 +      if (!(in_flags & EF_AVR32_LINKRELAX))

  3876 +	out_flags &= ~EF_AVR32_LINKRELAX;

  3877 +    }

  3878 +  else

  3879 +    {

  3880 +      elf_flags_init(obfd) = TRUE;

  3881 +      out_flags = in_flags;

  3882 +    }

  3883 +

  3884 +  elf_elfheader(obfd)->e_flags = out_flags;

  3885 +

  3886 +  return TRUE;

  3887 +}

  3888 +

  3889 +static bfd_boolean

  3890 +avr32_elf_print_private_bfd_data(bfd *abfd, void *ptr)

  3891 +{

  3892 +  FILE *file = (FILE *)ptr;

  3893 +  unsigned long flags;

  3894 +

  3895 +  BFD_ASSERT(abfd != NULL && ptr != NULL);

  3896 +

  3897 +  _bfd_elf_print_private_bfd_data(abfd, ptr);

  3898 +

  3899 +  flags = elf_elfheader(abfd)->e_flags;

  3900 +

  3901 +  fprintf(file, _("private flags = %lx:"), elf_elfheader(abfd)->e_flags);

  3902 +

  3903 +  if (flags & EF_AVR32_PIC)

  3904 +    fprintf(file, " [PIC]");

  3905 +  if (flags & EF_AVR32_LINKRELAX)

  3906 +    fprintf(file, " [linker relaxable]");

  3907 +

  3908 +  flags &= ~(EF_AVR32_PIC | EF_AVR32_LINKRELAX);

  3909 +

  3910 +  if (flags)

  3911 +    fprintf(file, _("<Unrecognized flag bits set>"));

  3912 +

  3913 +  fputc('\n', file);

  3914 +

  3915 +  return TRUE;

  3916 +}

  3917 +

  3918 +/* Set avr32-specific linker options.  */

  3919 +void bfd_elf32_avr32_set_options(struct bfd_link_info *info,

  3920 +				 int direct_data_refs)

  3921 +{

  3922 +  struct elf_avr32_link_hash_table *htab;

  3923 +

  3924 +  htab = avr32_elf_hash_table (info);

  3925 +  htab->direct_data_refs = !!direct_data_refs;

  3926 +}

  3927 +

  3928 +

  3929 +

  3930 +/* Understanding core dumps */

  3931 +

  3932 +static bfd_boolean

  3933 +avr32_elf_grok_prstatus(bfd *abfd, Elf_Internal_Note *note);

  3934 +static bfd_boolean

  3935 +avr32_elf_grok_psinfo(bfd *abfd, Elf_Internal_Note *note);

  3936 +

  3937 +static bfd_boolean

  3938 +avr32_elf_grok_prstatus(bfd *abfd, Elf_Internal_Note *note)

  3939 +{

  3940 +  /* Linux/AVR32B elf_prstatus */

  3941 +  if (note->descsz != 148)

  3942 +    return FALSE;

  3943 +

  3944 +  /* pr_cursig */

  3945 +  elf_tdata(abfd)->core_signal = bfd_get_16(abfd, note->descdata + 12);

  3946 +

  3947 +  /* pr_pid */

  3948 +  elf_tdata(abfd)->core_pid = bfd_get_32(abfd, note->descdata + 24);

  3949 +

  3950 +  /* Make a ".reg/999" section for pr_reg. The size is for 16

  3951 +     general-purpose registers, SR and r12_orig (18 * 4 = 72).  */

  3952 +  return _bfd_elfcore_make_pseudosection(abfd, ".reg", 72,

  3953 +					 note->descpos + 72);

  3954 +}

  3955 +

  3956 +static bfd_boolean

  3957 +avr32_elf_grok_psinfo(bfd *abfd, Elf_Internal_Note *note)

  3958 +{

  3959 +  /* Linux/AVR32B elf_prpsinfo */

  3960 +  if (note->descsz != 128)

  3961 +    return FALSE;

  3962 +

  3963 +  elf_tdata(abfd)->core_program

  3964 +    = _bfd_elfcore_strndup(abfd, note->descdata + 32, 16);

  3965 +  elf_tdata(abfd)->core_command

  3966 +    = _bfd_elfcore_strndup(abfd, note->descdata + 48, 80);

  3967 +

  3968 +  /* Note that for some reason, a spurious space is tacked

  3969 +     onto the end of the args in some (at least one anyway)

  3970 +     implementations, so strip it off if it exists.  */

  3971 +

  3972 +  {

  3973 +    char *command = elf_tdata (abfd)->core_command;

  3974 +    int n = strlen (command);

  3975 +

  3976 +    if (0 < n && command[n - 1] == ' ')

  3977 +      command[n - 1] = '\0';

  3978 +  }

  3979 +

  3980 +  return TRUE;

  3981 +}

  3982 +

  3983 +

  3984 +#define ELF_ARCH			bfd_arch_avr32

  3985 +#define ELF_MACHINE_CODE		EM_AVR32

  3986 +#define ELF_MAXPAGESIZE			0x1000

  3987 +

  3988 +#define TARGET_BIG_SYM			bfd_elf32_avr32_vec

  3989 +#define TARGET_BIG_NAME			"elf32-avr32"

  3990 +

  3991 +#define elf_backend_grok_prstatus	avr32_elf_grok_prstatus

  3992 +#define elf_backend_grok_psinfo		avr32_elf_grok_psinfo

  3993 +

  3994 +/* Only RELA relocations are used */

  3995 +#define elf_backend_may_use_rel_p	0

  3996 +#define elf_backend_may_use_rela_p	1

  3997 +#define elf_backend_default_use_rela_p	1

  3998 +#define elf_backend_rela_normal		1

  3999 +#define elf_info_to_howto_rel		NULL

  4000 +#define elf_info_to_howto		avr32_info_to_howto

  4001 +

  4002 +#define bfd_elf32_bfd_copy_private_bfd_data	avr32_elf_copy_private_bfd_data

  4003 +#define bfd_elf32_bfd_merge_private_bfd_data	avr32_elf_merge_private_bfd_data

  4004 +#define bfd_elf32_bfd_set_private_flags		avr32_elf_set_private_flags

  4005 +#define bfd_elf32_bfd_print_private_bfd_data	avr32_elf_print_private_bfd_data

  4006 +#define bfd_elf32_new_section_hook		avr32_elf_new_section_hook

  4007 +

  4008 +#define elf_backend_gc_mark_hook		avr32_elf_gc_mark_hook

  4009 +#define elf_backend_gc_sweep_hook		avr32_elf_gc_sweep_hook

  4010 +#define elf_backend_relocate_section	avr32_elf_relocate_section

  4011 +#define elf_backend_copy_indirect_symbol avr32_elf_copy_indirect_symbol

  4012 +#define elf_backend_create_dynamic_sections avr32_elf_create_dynamic_sections

  4013 +#define bfd_elf32_bfd_link_hash_table_create avr32_elf_link_hash_table_create

  4014 +#define elf_backend_adjust_dynamic_symbol avr32_elf_adjust_dynamic_symbol

  4015 +#define elf_backend_size_dynamic_sections avr32_elf_size_dynamic_sections

  4016 +#define elf_backend_finish_dynamic_symbol avr32_elf_finish_dynamic_symbol

  4017 +#define elf_backend_finish_dynamic_sections avr32_elf_finish_dynamic_sections

  4018 +

  4019 +#define bfd_elf32_bfd_relax_section	avr32_elf_relax_section

  4020 +

  4021 +/* Find out which symbols need an entry in .got. */

  4022 +#define elf_backend_check_relocs	avr32_check_relocs

  4023 +#define elf_backend_can_refcount	1

  4024 +#define elf_backend_can_gc_sections	1

  4025 +#define elf_backend_plt_readonly	1

  4026 +#define elf_backend_plt_not_loaded	1

  4027 +#define elf_backend_want_plt_sym	0

  4028 +#define elf_backend_plt_alignment	2

  4029 +#define elf_backend_want_dynbss		0

  4030 +#define elf_backend_want_got_plt	0

  4031 +#define elf_backend_want_got_sym	1

  4032 +#define elf_backend_got_header_size	AVR32_GOT_HEADER_SIZE

  4033 +

  4034 +#include "elf32-target.h"

  4035 --- /dev/null

  4036 +++ b/bfd/elf32-avr32.h

  4037 @@ -0,0 +1,23 @@

  4038 +/* AVR32-specific support for 32-bit ELF.

  4039 +   Copyright 2007 Atmel Corporation.

  4040 +

  4041 +   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>

  4042 +

  4043 +   This file is part of BFD, the Binary File Descriptor library.

  4044 +

  4045 +   This program is free software; you can redistribute it and/or modify

  4046 +   it under the terms of the GNU General Public License as published by

  4047 +   the Free Software Foundation; either version 2 of the License, or

  4048 +   (at your option) any later version.

  4049 +

  4050 +   This program is distributed in the hope that it will be useful,

  4051 +   but WITHOUT ANY WARRANTY; without even the implied warranty of

  4052 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  4053 +   GNU General Public License for more details.

  4054 +

  4055 +   You should have received a copy of the GNU General Public License

  4056 +   along with this program; if not, write to the Free Software

  4057 +   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */

  4058 +

  4059 +void bfd_elf32_avr32_set_options(struct bfd_link_info *info,

  4060 +				 int direct_data_refs);

  4061 --- a/bfd/elf-bfd.h

  4062 +++ b/bfd/elf-bfd.h

  4063 @@ -1400,6 +1400,10 @@ struct elf_obj_tdata

  4064       find_nearest_line.  */

  4065    struct mips_elf_find_line *find_line_info;

  4067 +  /* Used by AVR32 ELF relaxation code.  Contains an array of pointers

  4068 +     for each local symbol to the fragment where it is defined.  */

  4069 +  struct fragment **local_sym_frag;

  4070 +

  4071    /* A place to stash dwarf1 info for this bfd.  */

  4072    struct dwarf1_debug *dwarf1_find_line_info;

  4074 --- a/bfd/Makefile.am

  4075 +++ b/bfd/Makefile.am

  4076 @@ -63,6 +63,7 @@ ALL_MACHINES = \

  4077  	cpu-arc.lo \

  4078  	cpu-arm.lo \

  4079  	cpu-avr.lo \

  4080 +	cpu-avr32.lo \

  4081  	cpu-bfin.lo \

  4082  	cpu-cr16.lo \

  4083  	cpu-cr16c.lo \

  4084 @@ -243,6 +244,7 @@ BFD32_BACKENDS = \

  4085  	elf32-arc.lo \

  4086  	elf32-arm.lo \

  4087  	elf32-avr.lo \

  4088 +	elf32-avr32.lo \

  4089  	elf32-bfin.lo \

  4090  	elf32-cr16.lo \

  4091  	elf32-cr16c.lo \

  4092 @@ -1328,6 +1330,10 @@ elf32-cr16.lo: elf32-cr16.c $(INCDIR)/fi

  4093    $(INCDIR)/hashtab.h $(INCDIR)/libiberty.h elf-bfd.h \

  4094    $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \

  4095    $(INCDIR)/elf/cr16.h $(INCDIR)/elf/reloc-macros.h elf32-target.h

  4096 +elf32-avr32.lo: elf32-avr32.c $(INCDIR)/filenames.h elf-bfd.h \

  4097 +  $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \

  4098 +  $(INCDIR)/bfdlink.h $(INCDIR)/elf/avr32.h $(INCDIR)/elf/reloc-macros.h \

  4099 +  elf32-target.h

  4100  elf32-cr16c.lo: elf32-cr16c.c $(INCDIR)/filenames.h \

  4101    $(INCDIR)/hashtab.h $(INCDIR)/bfdlink.h $(INCDIR)/elf/cr16c.h \

  4102    $(INCDIR)/elf/reloc-macros.h elf-bfd.h $(INCDIR)/elf/common.h \

  4103 --- a/bfd/reloc.c

  4104 +++ b/bfd/reloc.c

  4105 @@ -3948,6 +3948,131 @@ ENUMDOC

  4106    instructions

  4108  ENUM

  4109 +  BFD_RELOC_AVR32_DIFF32

  4110 +ENUMX

  4111 +  BFD_RELOC_AVR32_DIFF16

  4112 +ENUMX

  4113 +  BFD_RELOC_AVR32_DIFF8

  4114 +ENUMDOC

  4115 +  Difference between two labels: L2 - L1. The value of L1 is encoded

  4116 +  as sym + addend, while the initial difference after assembly is

  4117 +  inserted into the object file by the assembler.

  4118 +ENUM

  4119 +  BFD_RELOC_AVR32_GOT32

  4120 +ENUMX

  4121 +  BFD_RELOC_AVR32_GOT16

  4122 +ENUMX

  4123 +  BFD_RELOC_AVR32_GOT8

  4124 +ENUMDOC

  4125 +  Reference to a symbol through the Global Offset Table. The linker

  4126 +  will allocate an entry for symbol in the GOT and insert the offset

  4127 +  of this entry as the relocation value.

  4128 +ENUM

  4129 +  BFD_RELOC_AVR32_21S

  4130 +ENUMX

  4131 +  BFD_RELOC_AVR32_16U

  4132 +ENUMX

  4133 +  BFD_RELOC_AVR32_16S

  4134 +ENUMX

  4135 +  BFD_RELOC_AVR32_SUB5

  4136 +ENUMX

  4137 +  BFD_RELOC_AVR32_8S_EXT

  4138 +ENUMX

  4139 +  BFD_RELOC_AVR32_8S

  4140 +ENUMX

  4141 +  BFD_RELOC_AVR32_15S

  4142 +ENUMDOC

  4143 +  Normal (non-pc-relative) code relocations. Alignment and signedness

  4144 +  is indicated by the suffixes. S means signed, U means unsigned. W

  4145 +  means word-aligned, H means halfword-aligned, neither means

  4146 +  byte-aligned (no alignment.) SUB5 is the same relocation as 16S.

  4147 +ENUM

  4148 +  BFD_RELOC_AVR32_22H_PCREL

  4149 +ENUMX

  4150 +  BFD_RELOC_AVR32_18W_PCREL

  4151 +ENUMX

  4152 +  BFD_RELOC_AVR32_16B_PCREL

  4153 +ENUMX

  4154 +  BFD_RELOC_AVR32_16N_PCREL

  4155 +ENUMX

  4156 +  BFD_RELOC_AVR32_14UW_PCREL

  4157 +ENUMX

  4158 +  BFD_RELOC_AVR32_11H_PCREL

  4159 +ENUMX

  4160 +  BFD_RELOC_AVR32_10UW_PCREL

  4161 +ENUMX

  4162 +  BFD_RELOC_AVR32_9H_PCREL

  4163 +ENUMX

  4164 +  BFD_RELOC_AVR32_9UW_PCREL

  4165 +ENUMDOC

  4166 +  PC-relative relocations are signed if neither 'U' nor 'S' is

  4167 +  specified. However, we explicitly tack on a 'B' to indicate no

  4168 +  alignment, to avoid confusion with data relocs. All of these resolve

  4169 +  to sym + addend - offset, except the one with 'N' (negated) suffix.

  4170 +  This particular one resolves to offset - sym - addend.

  4171 +ENUM

  4172 +  BFD_RELOC_AVR32_GOTPC

  4173 +ENUMDOC

  4174 +  Subtract the link-time address of the GOT from (symbol + addend)

  4175 +  and insert the result.

  4176 +ENUM

  4177 +  BFD_RELOC_AVR32_GOTCALL

  4178 +ENUMX

  4179 +  BFD_RELOC_AVR32_LDA_GOT

  4180 +ENUMX

  4181 +  BFD_RELOC_AVR32_GOT21S

  4182 +ENUMX

  4183 +  BFD_RELOC_AVR32_GOT18SW

  4184 +ENUMX

  4185 +  BFD_RELOC_AVR32_GOT16S

  4186 +ENUMDOC

  4187 +  Reference to a symbol through the GOT. The linker will allocate an

  4188 +  entry for symbol in the GOT and insert the offset of this entry as

  4189 +  the relocation value. addend must be zero. As usual, 'S' means

  4190 +  signed, 'W' means word-aligned, etc.

  4191 +ENUM

  4192 +  BFD_RELOC_AVR32_32_CPENT

  4193 +ENUMDOC

  4194 +  32-bit constant pool entry. I don't think 8- and 16-bit entries make

  4195 +  a whole lot of sense.

  4196 +ENUM

  4197 +  BFD_RELOC_AVR32_CPCALL

  4198 +ENUMX

  4199 +  BFD_RELOC_AVR32_16_CP

  4200 +ENUMX

  4201 +  BFD_RELOC_AVR32_9W_CP

  4202 +ENUMDOC

  4203 +  Constant pool references. Some of these relocations are signed,

  4204 +  others are unsigned. It doesn't really matter, since the constant

  4205 +  pool always comes after the code that references it.

  4206 +ENUM

  4207 +  BFD_RELOC_AVR32_ALIGN

  4208 +ENUMDOC

  4209 +  sym must be the absolute symbol. The addend specifies the alignment

  4210 +  order, e.g. if addend is 2, the linker must add padding so that the

  4211 +  next address is aligned to a 4-byte boundary.

  4212 +ENUM

  4213 +  BFD_RELOC_AVR32_14UW

  4214 +ENUMX

  4215 +  BFD_RELOC_AVR32_10UW

  4216 +ENUMX

  4217 +  BFD_RELOC_AVR32_10SW

  4218 +ENUMX

  4219 +  BFD_RELOC_AVR32_STHH_W

  4220 +ENUMX

  4221 +  BFD_RELOC_AVR32_7UW

  4222 +ENUMX

  4223 +  BFD_RELOC_AVR32_6S

  4224 +ENUMX

  4225 +  BFD_RELOC_AVR32_6UW

  4226 +ENUMX

  4227 +  BFD_RELOC_AVR32_4UH

  4228 +ENUMX

  4229 +  BFD_RELOC_AVR32_3U

  4230 +ENUMDOC

  4231 +  Code relocations that will never make it to the output file.

  4232 +

  4233 +ENUM

  4234    BFD_RELOC_390_12

  4235  ENUMDOC

  4236     Direct 12 bit.

  4237 --- a/bfd/targets.c

  4238 +++ b/bfd/targets.c

  4239 @@ -564,6 +564,7 @@ extern const bfd_target bfd_efi_app_ia32

  4240  extern const bfd_target bfd_efi_app_x86_64_vec;

  4241  extern const bfd_target bfd_efi_app_ia64_vec;

  4242  extern const bfd_target bfd_elf32_avr_vec;

  4243 +extern const bfd_target bfd_elf32_avr32_vec;

  4244  extern const bfd_target bfd_elf32_bfin_vec;

  4245  extern const bfd_target bfd_elf32_bfinfdpic_vec;

  4246  extern const bfd_target bfd_elf32_big_generic_vec;

  4247 @@ -884,6 +885,7 @@ static const bfd_target * const _bfd_tar

  4248  	&bfd_efi_app_ia64_vec,

  4249  #endif

  4250  	&bfd_elf32_avr_vec,

  4251 +	&bfd_elf32_avr32_vec,

  4252  	&bfd_elf32_bfin_vec,

  4253  	&bfd_elf32_bfinfdpic_vec,

  4255 --- a/binutils/Makefile.am

  4256 +++ b/binutils/Makefile.am

  4257 @@ -577,7 +577,7 @@ readelf.o: readelf.c sysdep.h $(INCDIR)/

  4258    $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h bucomm.h dwarf.h \

  4259    $(INCDIR)/elf/common.h $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h \

  4260    $(INCDIR)/elf/h8.h $(INCDIR)/elf/reloc-macros.h $(INCDIR)/elf/alpha.h \

  4261 -  $(INCDIR)/elf/arc.h $(INCDIR)/elf/arm.h $(INCDIR)/elf/avr.h \

  4262 +  $(INCDIR)/elf/arc.h $(INCDIR)/elf/arm.h $(INCDIR)/elf/avr.h $(INCDIR)/elf/avr32.h\

  4263    $(INCDIR)/elf/bfin.h $(INCDIR)/elf/cris.h $(INCDIR)/elf/crx.h \

  4264    $(INCDIR)/elf/d10v.h $(INCDIR)/elf/d30v.h $(INCDIR)/elf/dlx.h \

  4265    $(INCDIR)/elf/fr30.h $(INCDIR)/elf/frv.h $(INCDIR)/elf/hppa.h \

  4266 --- a/binutils/readelf.c

  4267 +++ b/binutils/readelf.c

  4268 @@ -21,7 +21,7 @@

  4269     along with this program; if not, write to the Free Software

  4270     Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA

  4271     02110-1301, USA.  */

  4272 -

  4273 +

  4274  /* The difference between readelf and objdump:

  4276    Both programs are capable of displaying the contents of ELF format files,

  4277 @@ -40,7 +40,7 @@

  4278    There is also the case that readelf can provide more information about an

  4279    ELF file than is provided by objdump.  In particular it can display DWARF

  4280    debugging information which (at the moment) objdump cannot.  */

  4281 -

  4282 +

  4283  #include "sysdep.h"

  4284  #include <assert.h>

  4285  #include <sys/stat.h>

  4286 @@ -109,6 +109,7 @@

  4287  #include "elf/arc.h"

  4288  #include "elf/arm.h"

  4289  #include "elf/avr.h"

  4290 +#include "elf/avr32.h"

  4291  #include "elf/bfin.h"

  4292  #include "elf/cr16.h"

  4293  #include "elf/cris.h"

  4294 @@ -303,7 +304,7 @@ static void (*byte_put) (unsigned char *

  4295  #define streq(a,b)	  (strcmp ((a), (b)) == 0)

  4296  #define strneq(a,b,n)	  (strncmp ((a), (b), (n)) == 0)

  4297  #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)

  4298 -

  4299 +

  4300  static void *

  4301  get_data (void *var, FILE *file, long offset, size_t size, size_t nmemb,

  4302  	  const char *reason)

  4303 @@ -614,6 +615,7 @@ guess_is_rela (unsigned long e_machine)

  4304      case EM_ALPHA:

  4305      case EM_ALTERA_NIOS2:

  4306      case EM_AVR:

  4307 +    case EM_AVR32:

  4308      case EM_AVR_OLD:

  4309      case EM_BLACKFIN:

  4310      case EM_CR16:

  4311 @@ -1006,6 +1008,10 @@ dump_relocations (FILE *file,

  4312  	  rtype = elf_avr_reloc_type (type);

  4313  	  break;

  4315 +	case EM_AVR32:

  4316 +	  rtype = elf_avr32_reloc_type (type);

  4317 +	  break;

  4318 +

  4319  	case EM_OLD_SPARCV9:

  4320  	case EM_SPARC32PLUS:

  4321  	case EM_SPARCV9:

  4322 @@ -1763,6 +1769,7 @@ get_machine_name (unsigned e_machine)

  4323      case EM_VAX:		return "Digital VAX";

  4324      case EM_AVR_OLD:

  4325      case EM_AVR:		return "Atmel AVR 8-bit microcontroller";

  4326 +    case EM_AVR32:		return "Atmel AVR32";

  4327      case EM_CRIS:		return "Axis Communications 32-bit embedded processor";

  4328      case EM_JAVELIN:		return "Infineon Technologies 32-bit embedded cpu";

  4329      case EM_FIREPATH:		return "Element 14 64-bit DSP processor";

  4330 --- a/gas/as.c

  4331 +++ b/gas/as.c

  4332 @@ -441,10 +441,10 @@ parse_args (int * pargc, char *** pargv)

  4333         the end of the preceeding line so that it is simpler to

  4334         selectively add and remove lines from this list.  */

  4335      {"alternate", no_argument, NULL, OPTION_ALTERNATE}

  4336 -    /* The entry for "a" is here to prevent getopt_long_only() from

  4337 -       considering that -a is an abbreviation for --alternate.  This is

  4338 -       necessary because -a=<FILE> is a valid switch but getopt would

  4339 -       normally reject it since --alternate does not take an argument.  */

  4340 +    /* The next two entries are here to prevent getopt_long_only() from

  4341 +       considering that -a or -al is an abbreviation for --alternate.

  4342 +       This is necessary because -a=<FILE> is a valid switch but getopt

  4343 +       would normally reject it since --alternate does not take an argument.  */

  4344      ,{"a", optional_argument, NULL, 'a'}

  4345      /* Handle -al=<FILE>.  */

  4346      ,{"al", optional_argument, NULL, OPTION_AL}

  4347 @@ -803,8 +803,15 @@ This program has absolutely no warranty.

  4348  	case 'a':

  4349  	  if (optarg)

  4350  	    {

  4351 -	      if (optarg != old_argv[optind] && optarg[-1] == '=')

  4352 -		--optarg;

  4353 +	      /* If optarg is part of the -a switch and not a separate argument

  4354 +		 in its own right, then scan backwards to the just after the -a.

  4355 +		 This means skipping over both '=' and 'l' which might have been

  4356 +		 taken to be part of the -a switch itself.  */

  4357 +	      if (optarg != old_argv[optind])

  4358 +		{

  4359 +		  while (optarg[-1] == '=' || optarg[-1] == 'l')

  4360 +		    --optarg;

  4361 +		}

  4363  	      if (md_parse_option (optc, optarg) != 0)

  4364  		break;

  4365 @@ -1234,7 +1241,7 @@ main (int argc, char ** argv)

  4366      keep_it = 0;

  4368    if (!keep_it)

  4369 -    unlink_if_ordinary (out_file_name);

  4370 +    unlink (out_file_name);

  4372    input_scrub_end ();

  4374 --- /dev/null

  4375 +++ b/gas/config/tc-avr32.c

  4376 @@ -0,0 +1,4806 @@

  4377 +/* Assembler implementation for AVR32.

  4378 +   Copyright 2003-2006 Atmel Corporation.

  4379 +

  4380 +   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>

  4381 +

  4382 +   This file is part of GAS, the GNU Assembler.

  4383 +

  4384 +   GAS is free software; you can redistribute it and/or modify it

  4385 +   under the terms of the GNU General Public License as published by

  4386 +   the Free Software Foundation; either version 2, or (at your option)

  4387 +   any later version.

  4388 +

  4389 +   GAS is distributed in the hope that it will be useful, but WITHOUT

  4390 +   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

  4391 +   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public

  4392 +   License for more details.

  4393 +

  4394 +   You should have received a copy of the GNU General Public License

  4395 +   along with GAS; see the file COPYING.  If not, write to the Free

  4396 +   Software Foundation, 59 Temple Place - Suite 330, Boston, MA

  4397 +   02111-1307, USA.  */

  4398 +

  4399 +#include <stdio.h>

  4400 +#include "as.h"

  4401 +#include "safe-ctype.h"

  4402 +#include "subsegs.h"

  4403 +#include "symcat.h"

  4404 +#include "opcodes/avr32-opc.h"

  4405 +#include "opcodes/avr32-asm.h"

  4406 +#include "elf/avr32.h"

  4407 +#include "dwarf2dbg.h"

  4408 +

  4409 +#define xDEBUG

  4410 +#define xOPC_CONSISTENCY_CHECK

  4411 +

  4412 +#ifdef DEBUG

  4413 +# define pr_debug(fmt, args...) fprintf(stderr, fmt, ##args)

  4414 +#else

  4415 +# define pr_debug(fmt, args...)

  4416 +#endif

  4417 +

  4418 +/* 3 MSB of instruction word indicate group. Group 7 -> extended */

  4419 +#define AVR32_COMPACT_P(opcode) ((opcode[0] & 0xe0) != 0xe0)

  4420 +

  4421 +#define streq(a, b)		(strcmp(a, b) == 0)

  4422 +#define skip_whitespace(str)	do { while(*(str) == ' ') ++(str); } while(0)

  4423 +

  4424 +/* Flags given on the command line */

  4425 +static int avr32_pic	= FALSE;

  4426 +int linkrelax	= FALSE;

  4427 +int avr32_iarcompat	= FALSE;

  4428 +

  4429 +/* This array holds the chars that always start a comment. */

  4430 +const char comment_chars[]		= "#";

  4431 +

  4432 +/* This array holds the chars that only start a comment at the

  4433 +   beginning of a line.  We must include '#' here because the compiler

  4434 +   may produce #APP and #NO_APP in its output.  */

  4435 +const char line_comment_chars[]		= "#";

  4436 +

  4437 +/* These may be used instead of newline (same as ';' in C).  */

  4438 +const char line_separator_chars[]	= ";";

  4439 +

  4440 +/* Chars that can be used to separate mantissa from exponent in

  4441 +   floating point numbers.  */

  4442 +const char EXP_CHARS[]			= "eE";

  4443 +

  4444 +/* Chars that mean this number is a floating point constant.  */

  4445 +const char FLT_CHARS[]			= "dD";

  4446 +

  4447 +/* Pre-defined "_GLOBAL_OFFSET_TABLE_"  */

  4448 +symbolS *GOT_symbol;

  4449 +

  4450 +static struct hash_control *avr32_mnemonic_htab;

  4451 +

  4452 +struct avr32_ifield_data

  4453 +{

  4454 +  bfd_vma value;

  4455 +  /* FIXME: Get rid of align_order and complain. complain is never

  4456 +     used, align_order is used in one place.  Try to use the relax

  4457 +     table instead.  */

  4458 +  unsigned int align_order;

  4459 +};

  4460 +

  4461 +struct avr32_insn

  4462 +{

  4463 +  const struct avr32_syntax *syntax;

  4464 +  expressionS immediate;

  4465 +  int pcrel;

  4466 +  int force_extended;

  4467 +  unsigned int next_slot;

  4468 +  bfd_reloc_code_real_type r_type;

  4469 +  struct avr32_ifield_data field_value[AVR32_MAX_FIELDS];

  4470 +};

  4471 +

  4472 +static struct avr32_insn current_insn;

  4473 +

  4474 +/* The target specific pseudo-ops we support. */

  4475 +static void s_rseg (int);

  4476 +static void s_cpool(int);

  4477 +

  4478 +const pseudo_typeS md_pseudo_table[] =

  4479 +{

  4480 +  /* Make sure that .word is 32 bits */

  4481 +  { "word", cons, 4 },

  4482 +  { "file", (void (*) PARAMS ((int))) dwarf2_directive_file, 0 },

  4483 +  { "loc", dwarf2_directive_loc, 0 },

  4484 +

  4485 +  /* .lcomm requires an explicit alignment parameter */

  4486 +  { "lcomm", s_lcomm, 1 },

  4487 +

  4488 +  /* AVR32-specific pseudo-ops */

  4489 +  { "cpool", s_cpool, 0},

  4490 +

  4491 +  /* IAR compatible pseudo-ops */

  4492 +  { "program", s_ignore, 0 },

  4493 +  { "public", s_globl, 0 },

  4494 +  { "extern", s_ignore, 0 },

  4495 +  { "module", s_ignore, 0 },

  4496 +  { "rseg", s_rseg, 0 },

  4497 +  { "dc8", cons, 1 },

  4498 +  { "dc16", cons, 2 },

  4499 +  { "dc32", cons, 4 },

  4500 +

  4501 +  { NULL, NULL, 0 }

  4502 +};

  4503 +

  4504 +/* Questionable stuff starts here */

  4505 +

  4506 +enum avr32_opinfo {

  4507 +  AVR32_OPINFO_NONE = BFD_RELOC_NONE,

  4508 +  AVR32_OPINFO_GOT,

  4509 +  AVR32_OPINFO_TLSGD,

  4510 +  AVR32_OPINFO_HI,

  4511 +  AVR32_OPINFO_LO,

  4512 +};

  4513 +

  4514 +enum avr32_arch {

  4515 +  ARCH_TYPE_AP,

  4516 +  ARCH_TYPE_UCR1,

  4517 +  ARCH_TYPE_UCR2,

  4518 +};

  4519 +

  4520 +struct arch_type_s

  4521 +{

  4522 +  /* Architecture name */

  4523 +  char *name;

  4524 +  /* Instruction Set Architecture Flags */

  4525 +  unsigned long isa_flags;

  4526 +};

  4527 +

  4528 +struct part_type_s

  4529 +{

  4530 +  /* Part name */

  4531 +  char *name;

  4532 +  /* Architecture type */

  4533 +  unsigned int arch;

  4534 +};

  4535 +

  4536 +static struct arch_type_s arch_types[] =

  4537 +{

  4538 +  {"ap", AVR32_V1 | AVR32_SIMD | AVR32_DSP | AVR32_PICO},

  4539 +  {"ucr1", AVR32_V1 | AVR32_DSP | AVR32_RMW},

  4540 +  {"ucr2", AVR32_V1 | AVR32_V2 | AVR32_DSP | AVR32_RMW},

  4541 +  {"all-insn", AVR32_V1 | AVR32_V2 | AVR32_SIMD | AVR32_DSP | AVR32_RMW | AVR32_FP | AVR32_PICO},

  4542 +  {NULL, 0}

  4543 +};

  4544 +

  4545 +static struct part_type_s part_types[] = {

  4546 +  {"ap7000", ARCH_TYPE_AP},

  4547 +  {"ap7001", ARCH_TYPE_AP},

  4548 +  {"ap7002", ARCH_TYPE_AP},

  4549 +  {"ap7200", ARCH_TYPE_AP},

  4550 +  {"uc3a0128", ARCH_TYPE_UCR2},

  4551 +  {"uc3a0256", ARCH_TYPE_UCR2},

  4552 +  {"uc3a0512es", ARCH_TYPE_UCR1},

  4553 +  {"uc3a0512", ARCH_TYPE_UCR2},

  4554 +  {"uc3a1128", ARCH_TYPE_UCR2},

  4555 +  {"uc3a1256es", ARCH_TYPE_UCR1},

  4556 +  {"uc3a1256", ARCH_TYPE_UCR2},

  4557 +  {"uc3a1512es", ARCH_TYPE_UCR1},

  4558 +  {"uc3a1512", ARCH_TYPE_UCR2},

  4559 +  {"uc3a364", ARCH_TYPE_UCR2},

  4560 +  {"uc3a364s", ARCH_TYPE_UCR2},

  4561 +  {"uc3a3128", ARCH_TYPE_UCR2},

  4562 +  {"uc3a3128s", ARCH_TYPE_UCR2},

  4563 +  {"uc3a3256", ARCH_TYPE_UCR2},

  4564 +  {"uc3a3256s", ARCH_TYPE_UCR2},

  4565 +  {"uc3b064", ARCH_TYPE_UCR1},

  4566 +  {"uc3b0128", ARCH_TYPE_UCR1},

  4567 +  {"uc3b0256es", ARCH_TYPE_UCR1},

  4568 +  {"uc3b0256", ARCH_TYPE_UCR1},

  4569 +  {"uc3b164", ARCH_TYPE_UCR1},

  4570 +  {"uc3b1128", ARCH_TYPE_UCR1},

  4571 +  {"uc3b1256es", ARCH_TYPE_UCR1},

  4572 +  {"uc3b1256", ARCH_TYPE_UCR1},

  4573 +  {NULL, 0}

  4574 +};

  4575 +

  4576 +/* Current architecture type.  */

  4577 +static struct arch_type_s default_arch = {"all-insn", AVR32_V1 | AVR32_V2 | AVR32_SIMD | AVR32_DSP | AVR32_RMW | AVR32_FP | AVR32_PICO };

  4578 +static struct arch_type_s *avr32_arch = &default_arch;

  4579 +

  4580 +/* Display nicely formatted list of known part- and architecture names.  */

  4581 +

  4582 +static void

  4583 +show_arch_list (FILE *stream)

  4584 +{

  4585 +  int i, x;

  4586 +

  4587 +  fprintf (stream, _("Known architecture names:"));

  4588 +  x = 1000;

  4589 +

  4590 +  for (i = 0; arch_types[i].name; i++)

  4591 +    {

  4592 +      int len = strlen (arch_types[i].name);

  4593 +

  4594 +      x += len + 1;

  4595 +

  4596 +      if (x < 75)

  4597 +	fprintf (stream, " %s", arch_types[i].name);

  4598 +      else

  4599 +	{

  4600 +	  fprintf (stream, "\n  %s", arch_types[i].name);

  4601 +	  x = len + 2;

  4602 +	}

  4603 +    }

  4604 +

  4605 +  fprintf (stream, "\n");

  4606 +}

  4607 +

  4608 +static void

  4609 +show_part_list (FILE *stream)

  4610 +{

  4611 +  int i, x;

  4612 +

  4613 +  fprintf (stream, _("Known part names:"));

  4614 +  x = 1000;

  4615 +

  4616 +  for (i = 0; part_types[i].name; i++)

  4617 +    {

  4618 +      int len = strlen(part_types[i].name);

  4619 +

  4620 +      x += len + 1;

  4621 +

  4622 +      if (x < 75)

  4623 +	fprintf (stream, " %s", part_types[i].name);

  4624 +      else

  4625 +	{

  4626 +	  fprintf(stream, "\n  %s", part_types[i].name);

  4627 +	  x = len + 2;

  4628 +	}

  4629 +    }

  4630 +

  4631 +  fprintf (stream, "\n");

  4632 +}

  4633 +

  4634 +const char *md_shortopts = "";

  4635 +struct option md_longopts[] =

  4636 +{

  4637 +#define OPTION_ARCH		(OPTION_MD_BASE)

  4638 +#define OPTION_PART		(OPTION_ARCH + 1)

  4639 +#define OPTION_IAR		(OPTION_PART + 1)

  4640 +#define OPTION_PIC		(OPTION_IAR + 1)

  4641 +#define OPTION_NOPIC		(OPTION_PIC + 1)

  4642 +#define OPTION_LINKRELAX	(OPTION_NOPIC + 1)

  4643 +#define OPTION_NOLINKRELAX	(OPTION_LINKRELAX + 1)

  4644 +#define OPTION_DIRECT_DATA_REFS (OPTION_NOLINKRELAX + 1)

  4645 +  {"march",		required_argument, NULL, OPTION_ARCH},

  4646 +  {"mpart",		required_argument, NULL, OPTION_PART},

  4647 +  {"iar",		no_argument, NULL, OPTION_IAR},

  4648 +  {"pic",		no_argument, NULL, OPTION_PIC},

  4649 +  {"no-pic",		no_argument, NULL, OPTION_NOPIC},

  4650 +  {"linkrelax",		no_argument, NULL, OPTION_LINKRELAX},

  4651 +  {"no-linkrelax",	no_argument, NULL, OPTION_NOLINKRELAX},

  4652 +  /* deprecated alias for -mpart=xxx */

  4653 +  {"mcpu",		required_argument, NULL, OPTION_PART},

  4654 +  {NULL,		no_argument, NULL, 0}

  4655 +};

  4656 +

  4657 +size_t md_longopts_size = sizeof (md_longopts);

  4658 +

  4659 +void

  4660 +md_show_usage (FILE *stream)

  4661 +{

  4662 +  fprintf (stream, _("\

  4663 +AVR32 options:\n\

  4664 +  -march=[arch-name]      Select cpu architecture. [Default `all-insn']\n\

  4665 +  -mpart=[part-name]      Select specific part. [Default `none']\n\

  4666 +  --pic                   Produce Position-Independent Code\n\

  4667 +  --no-pic                Don't produce Position-Independent Code\n\

  4668 +  --linkrelax             Produce output suitable for linker relaxing\n\

  4669 +  --no-linkrelax          Don't produce output suitable for linker relaxing\n"));

  4670 +  show_arch_list(stream);

  4671 +}

  4672 +

  4673 +int

  4674 +md_parse_option (int c, char *arg ATTRIBUTE_UNUSED)

  4675 +{

  4676 +  switch (c)

  4677 +    {

  4678 +    case OPTION_ARCH:

  4679 +      {

  4680 +	int i;

  4681 +	char *s = alloca (strlen (arg) + 1);

  4682 +

  4683 +	{

  4684 +	  char *t = s;

  4685 +	  char *arg1 = arg;

  4686 +

  4687 +	  do

  4688 +	    *t = TOLOWER (*arg1++);

  4689 +	  while (*t++);

  4690 +	}

  4691 +

  4692 +        /* Add backward compability */

  4693 +        if (strcmp ("uc", s)== 0)

  4694 +          {

  4695 +            as_warn("Deprecated arch `%s' specified. "

  4696 +                    "Please use '-march=ucr1' instead. "

  4697 +                    "Converting to arch 'ucr1'\n",

  4698 +                     s);

  4699 +            s="ucr1";

  4700 +          }

  4701 +

  4702 +	for (i = 0; arch_types[i].name; ++i)

  4703 +	  if (strcmp (arch_types[i].name, s) == 0)

  4704 +	    break;

  4705 +

  4706 +	if (!arch_types[i].name)

  4707 +	  {

  4708 +	    show_arch_list (stderr);

  4709 +	    as_fatal (_("unknown architecture: %s\n"), arg);

  4710 +	  }

  4711 +

  4712 +        avr32_arch = &arch_types[i];

  4713 +	break;

  4714 +      }

  4715 +    case OPTION_PART:

  4716 +      {

  4717 +	int i;

  4718 +	char *s = alloca (strlen (arg) + 1);

  4719 +	char *t = s;

  4720 +	char *p = arg;

  4721 +

  4722 +	/* If arch type has already been set, don't bother.

  4723 +	   -march= always overrides -mpart=  */

  4724 +	if (avr32_arch != &default_arch)

  4725 +	  break;

  4726 +

  4727 +	do

  4728 +	  *t = TOLOWER (*p++);

  4729 +	while (*t++);

  4730 +

  4731 +	for (i = 0; part_types[i].name; ++i)

  4732 +	  if (strcmp (part_types[i].name, s) == 0)

  4733 +	    break;

  4734 +

  4735 +	if (!part_types[i].name)

  4736 +	  {

  4737 +	    show_part_list (stderr);

  4738 +	    as_fatal (_("unknown part: %s\n"), arg);

  4739 +	  }

  4740 +

  4741 +	avr32_arch = &arch_types[part_types[i].arch];

  4742 +	break;

  4743 +      }

  4744 +    case OPTION_IAR:

  4745 +      avr32_iarcompat = 1;

  4746 +      break;

  4747 +    case OPTION_PIC:

  4748 +      avr32_pic = 1;

  4749 +      break;

  4750 +    case OPTION_NOPIC:

  4751 +      avr32_pic = 0;

  4752 +      break;

  4753 +    case OPTION_LINKRELAX:

  4754 +      linkrelax = 1;

  4755 +      break;

  4756 +    case OPTION_NOLINKRELAX:

  4757 +      linkrelax = 0;

  4758 +      break;

  4759 +    default:

  4760 +      return 0;

  4761 +    }

  4762 +  return 1;

  4763 +}

  4764 +

  4765 +/* Can't use symbol_new here, so have to create a symbol and then at

  4766 +   a later date assign it a value. Thats what these functions do.

  4767 +

  4768 +   Shamelessly stolen from ARM.  */

  4769 +

  4770 +static void

  4771 +symbol_locate (symbolS *    symbolP,

  4772 +	       const char * name,	/* It is copied, the caller can modify.  */

  4773 +	       segT         segment,	/* Segment identifier (SEG_<something>).  */

  4774 +	       valueT       valu,	/* Symbol value.  */

  4775 +	       fragS *      frag)	/* Associated fragment.  */

  4776 +{

  4777 +  unsigned int name_length;

  4778 +  char * preserved_copy_of_name;

  4779 +

  4780 +  name_length = strlen (name) + 1;   /* +1 for \0.  */

  4781 +  obstack_grow (&notes, name, name_length);

  4782 +  preserved_copy_of_name = obstack_finish (&notes);

  4783 +#ifdef STRIP_UNDERSCORE

  4784 +  if (preserved_copy_of_name[0] == '_')

  4785 +    preserved_copy_of_name++;

  4786 +#endif

  4787 +

  4788 +#ifdef tc_canonicalize_symbol_name

  4789 +  preserved_copy_of_name =

  4790 +    tc_canonicalize_symbol_name (preserved_copy_of_name);

  4791 +#endif

  4792 +

  4793 +  S_SET_NAME (symbolP, preserved_copy_of_name);

  4794 +

  4795 +  S_SET_SEGMENT (symbolP, segment);

  4796 +  S_SET_VALUE (symbolP, valu);

  4797 +  symbol_clear_list_pointers (symbolP);

  4798 +

  4799 +  symbol_set_frag (symbolP, frag);

  4800 +

  4801 +  /* Link to end of symbol chain.  */

  4802 +  {

  4803 +    extern int symbol_table_frozen;

  4804 +

  4805 +    if (symbol_table_frozen)

  4806 +      abort ();

  4807 +  }

  4808 +

  4809 +  symbol_append (symbolP, symbol_lastP, & symbol_rootP, & symbol_lastP);

  4810 +

  4811 +  obj_symbol_new_hook (symbolP);

  4812 +

  4813 +#ifdef tc_symbol_new_hook

  4814 +  tc_symbol_new_hook (symbolP);

  4815 +#endif

  4816 +

  4817 +#ifdef DEBUG_SYMS

  4818 +  verify_symbol_chain (symbol_rootP, symbol_lastP);

  4819 +#endif /* DEBUG_SYMS  */

  4820 +}

  4821 +

  4822 +struct cpool_entry

  4823 +{

  4824 +  int			refcount;

  4825 +  offsetT		offset;

  4826 +  expressionS		exp;

  4827 +};

  4828 +

  4829 +struct cpool

  4830 +{

  4831 +  struct cpool		*next;

  4832 +  int			used;

  4833 +  struct cpool_entry	*literals;

  4834 +  unsigned int		padding;

  4835 +  unsigned int		next_free_entry;

  4836 +  unsigned int		id;

  4837 +  symbolS		*symbol;

  4838 +  segT			section;

  4839 +  subsegT		sub_section;

  4840 +};

  4841 +

  4842 +struct cpool *cpool_list = NULL;

  4843 +

  4844 +static struct cpool *

  4845 +find_cpool(segT section, subsegT sub_section)

  4846 +{

  4847 +  struct cpool *pool;

  4848 +

  4849 +  for (pool = cpool_list; pool != NULL; pool = pool->next)

  4850 +    {

  4851 +      if (!pool->used

  4852 +	  && pool->section == section

  4853 +	  && pool->sub_section == sub_section)

  4854 +	break;

  4855 +    }

  4856 +

  4857 +  return pool;

  4858 +}

  4859 +

  4860 +static struct cpool *

  4861 +find_or_make_cpool(segT section, subsegT sub_section)

  4862 +{

  4863 +  static unsigned int next_cpool_id = 0;

  4864 +  struct cpool *pool;

  4865 +

  4866 +  pool = find_cpool(section, sub_section);

  4867 +

  4868 +  if (!pool)

  4869 +    {

  4870 +      pool = xmalloc(sizeof(*pool));

  4871 +      if (!pool)

  4872 +	return NULL;

  4873 +

  4874 +      pool->used = 0;

  4875 +      pool->literals = NULL;

  4876 +      pool->padding = 0;

  4877 +      pool->next_free_entry = 0;

  4878 +      pool->section = section;

  4879 +      pool->sub_section = sub_section;

  4880 +      pool->next = cpool_list;

  4881 +      pool->symbol = NULL;

  4882 +

  4883 +      cpool_list = pool;

  4884 +    }

  4885 +

  4886 +  /* NULL symbol means that the pool is new or has just been emptied.  */

  4887 +  if (!pool->symbol)

  4888 +    {

  4889 +      pool->symbol = symbol_create(FAKE_LABEL_NAME, undefined_section,

  4890 +				   0, &zero_address_frag);

  4891 +      pool->id = next_cpool_id++;

  4892 +    }

  4893 +

  4894 +  return pool;

  4895 +}

  4896 +

  4897 +static struct cpool *

  4898 +add_to_cpool(expressionS *exp, unsigned int *index, int ref)

  4899 +{

  4900 +  struct cpool *pool;

  4901 +  unsigned int entry;

  4902 +

  4903 +  pool = find_or_make_cpool(now_seg, now_subseg);

  4904 +

  4905 +  /* Check if this constant is already in the pool.  */

  4906 +  for (entry = 0; entry < pool->next_free_entry; entry++)

  4907 +    {

  4908 +      if ((pool->literals[entry].exp.X_op == exp->X_op)

  4909 +	  && (exp->X_op == O_constant)

  4910 +	  && (pool->literals[entry].exp.X_add_number

  4911 +	      == exp->X_add_number)

  4912 +	  && (pool->literals[entry].exp.X_unsigned

  4913 +	      == exp->X_unsigned))

  4914 +	break;

  4915 +

  4916 +      if ((pool->literals[entry].exp.X_op == exp->X_op)

  4917 +	  && (exp->X_op == O_symbol)

  4918 +	  && (pool->literals[entry].exp.X_add_number

  4919 +	      == exp->X_add_number)

  4920 +	  && (pool->literals[entry].exp.X_add_symbol

  4921 +	      == exp->X_add_symbol)

  4922 +	  && (pool->literals[entry].exp.X_op_symbol

  4923 +	      == exp->X_op_symbol))

  4924 +	break;

  4925 +    }

  4926 +

  4927 +  /* Create an entry if we didn't find a match */

  4928 +  if (entry == pool->next_free_entry)

  4929 +    {

  4930 +      pool->literals = xrealloc(pool->literals,

  4931 +				sizeof(struct cpool_entry) * (entry + 1));

  4932 +      pool->literals[entry].exp = *exp;

  4933 +      pool->literals[entry].refcount = 0;

  4934 +      pool->next_free_entry++;

  4935 +    }

  4936 +

  4937 +  if (index)

  4938 +    *index = entry;

  4939 +  if (ref)

  4940 +    pool->literals[entry].refcount++;

  4941 +

  4942 +  return pool;

  4943 +}

  4944 +

  4945 +struct avr32_operand

  4946 +{

  4947 +  int id;

  4948 +  int is_signed;

  4949 +  int is_pcrel;

  4950 +  int align_order;

  4951 +  int (*match)(char *str);

  4952 +  void (*parse)(const struct avr32_operand *op, char *str, int opindex);

  4953 +};

  4954 +

  4955 +static int

  4956 +match_anything(char *str ATTRIBUTE_UNUSED)

  4957 +{

  4958 +  return 1;

  4959 +}

  4960 +

  4961 +static int

  4962 +match_intreg(char *str)

  4963 +{

  4964 +  int regid, ret = 1;

  4965 +

  4966 +  regid = avr32_parse_intreg(str);

  4967 +  if (regid < 0)

  4968 +    ret = 0;

  4969 +

  4970 +  pr_debug("match_intreg: `%s': %d\n", str, ret);

  4971 +

  4972 +  return ret;

  4973 +}

  4974 +

  4975 +static int

  4976 +match_intreg_predec(char *str)

  4977 +{

  4978 +  int regid;

  4979 +

  4980 +  if (str[0] != '-' || str[1] != '-')

  4981 +    return 0;

  4982 +

  4983 +  regid = avr32_parse_intreg(str + 2);

  4984 +  if (regid < 0)

  4985 +    return 0;

  4986 +

  4987 +  return 1;

  4988 +}

  4989 +

  4990 +static int

  4991 +match_intreg_postinc(char *str)

  4992 +{

  4993 +  int regid, ret = 1;

  4994 +  char *p, c;

  4995 +

  4996 +  for (p = str; *p; p++)

  4997 +    if (*p == '+')

  4998 +      break;

  4999 +

  5000 +  if (p[0] != '+' || p[1] != '+')

  5001 +    return 0;

  5002 +

  5003 +  c = *p, *p = 0;

  5004 +  regid = avr32_parse_intreg(str);

  5005 +  if (regid < 0)

  5006 +    ret = 0;

  5007 +

  5008 +  *p = c;

  5009 +  return ret;

  5010 +}

  5011 +

  5012 +static int

  5013 +match_intreg_lsl(char *str)

  5014 +{

  5015 +  int regid, ret = 1;

  5016 +  char *p, c;

  5017 +

  5018 +  for (p = str; *p; p++)

  5019 +    if (*p == '<')

  5020 +      break;

  5021 +

  5022 +  if (p[0] && p[1] != '<')

  5023 +    return 0;

  5024 +

  5025 +  c = *p, *p = 0;

  5026 +  regid = avr32_parse_intreg(str);

  5027 +  if (regid < 0)

  5028 +    ret = 0;

  5029 +

  5030 +  *p = c;

  5031 +  return ret;

  5032 +}

  5033 +

  5034 +static int

  5035 +match_intreg_lsr(char *str)

  5036 +{

  5037 +  int regid, ret = 1;

  5038 +  char *p, c;

  5039 +

  5040 +  for (p = str; *p; p++)

  5041 +    if (*p == '>')

  5042 +      break;

  5043 +

  5044 +  if (p[0] && p[1] != '>')

  5045 +    return 0;

  5046 +

  5047 +  c = *p, *p = 0;

  5048 +

  5049 +  regid = avr32_parse_intreg(str);

  5050 +  if (regid < 0)

  5051 +    ret = 0;

  5052 +

  5053 +  *p = c;

  5054 +  return ret;

  5055 +}

  5056 +

  5057 +static int

  5058 +match_intreg_part(char *str)

  5059 +{

  5060 +  int regid, ret = 1;

  5061 +  char *p, c;

  5062 +

  5063 +  for (p = str; *p; p++)

  5064 +    if (*p == ':')

  5065 +      break;

  5066 +

  5067 +  if (p[0] != ':' || !ISPRINT(p[1]) || p[2] != '\0')

  5068 +    return 0;

  5069 +

  5070 +  c = *p, *p = 0;

  5071 +  regid = avr32_parse_intreg(str);

  5072 +  if (regid < 0)

  5073 +    ret = 0;

  5074 +

  5075 +  *p = c;

  5076 +

  5077 +  return ret;

  5078 +}

  5079 +

  5080 +#define match_intreg_disp match_anything

  5081 +

  5082 +static int

  5083 +match_intreg_index(char *str)

  5084 +{

  5085 +  int regid, ret = 1;

  5086 +  char *p, *end, c;

  5087 +

  5088 +  for (p = str; *p; p++)

  5089 +    if (*p == '[')

  5090 +      break;

  5091 +

  5092 +  /* don't allow empty displacement here (it makes no sense) */

  5093 +  if (p[0] != '[')

  5094 +    return 0;

  5095 +

  5096 +  for (end = p + 1; *end; end++) ;

  5097 +  if (*(--end) != ']')

  5098 +    return 0;

  5099 +

  5100 +  c = *end, *end = 0;

  5101 +  if (!match_intreg_lsl(p + 1))

  5102 +    ret = 0;

  5103 +  *end = c;

  5104 +

  5105 +  if (ret)

  5106 +    {

  5107 +      c = *p, *p = 0;

  5108 +      regid = avr32_parse_intreg(str);

  5109 +      if (regid < 0)

  5110 +	ret = 0;

  5111 +      *p = c;

  5112 +    }

  5113 +

  5114 +  return ret;

  5115 +}

  5116 +

  5117 +static int

  5118 +match_intreg_xindex(char *str)

  5119 +{

  5120 +  int regid, ret = 1;

  5121 +  char *p, *end, c;

  5122 +

  5123 +  for (p = str; *p; p++)

  5124 +    if (*p == '[')

  5125 +      break;

  5126 +

  5127 +  /* empty displacement makes no sense here either */

  5128 +  if (p[0] != '[')

  5129 +    return 0;

  5130 +

  5131 +  for (end = p + 1; *end; end++)

  5132 +    if (*end == '<')

  5133 +      break;

  5134 +

  5135 +  if (!streq(end, "<<2]"))

  5136 +    return 0;

  5137 +

  5138 +  c = *end, *end = 0;

  5139 +  if (!match_intreg_part(p + 1))

  5140 +    ret = 0;

  5141 +  *end = c;

  5142 +

  5143 +  if (ret)

  5144 +    {

  5145 +      c = *p, *p = 0;

  5146 +      regid = avr32_parse_intreg(str);

  5147 +      if (regid < 0)

  5148 +	ret = 0;

  5149 +      *p = c;

  5150 +    }

  5151 +

  5152 +  return ret;

  5153 +}

  5154 +

  5155 +/* The PC_UDISP_W operator may show up as a label or as a pc[disp]

  5156 +   expression.  So there's no point in attempting to match this...  */

  5157 +#define match_pc_disp	match_anything

  5158 +

  5159 +static int

  5160 +match_sp(char *str)

  5161 +{

  5162 +  /* SP in any form will do */

  5163 +  return avr32_parse_intreg(str) == AVR32_REG_SP;

  5164 +}

  5165 +

  5166 +static int

  5167 +match_sp_disp(char *str)

  5168 +{

  5169 +  int regid, ret = 1;

  5170 +  char *p, c;

  5171 +

  5172 +  for (p = str; *p; p++)

  5173 +    if (*p == '[')

  5174 +      break;

  5175 +

  5176 +  /* allow empty displacement, meaning zero */

  5177 +  if (p[0] == '[')

  5178 +    {

  5179 +      char *end;

  5180 +      for (end = p + 1; *end; end++) ;

  5181 +      if (end[-1] != ']')

  5182 +	return 0;

  5183 +    }

  5184 +

  5185 +  c = *p, *p = 0;

  5186 +  regid = avr32_parse_intreg(str);

  5187 +  if (regid != AVR32_REG_SP)

  5188 +    ret = 0;

  5189 +

  5190 +  *p = c;

  5191 +  return ret;

  5192 +}

  5193 +

  5194 +static int

  5195 +match_cpno(char *str)

  5196 +{

  5197 +  if (strncasecmp(str, "cp", 2) != 0)

  5198 +    return 0;

  5199 +  return 1;

  5200 +}

  5201 +

  5202 +static int

  5203 +match_cpreg(char *str)

  5204 +{

  5205 +  if (strncasecmp(str, "cr", 2) != 0)

  5206 +    return 0;

  5207 +  return 1;

  5208 +}

  5209 +

  5210 +/* We allow complex expressions, and register names may show up as

  5211 +   symbols.  Just make sure immediate expressions are always matched

  5212 +   last.  */

  5213 +#define match_const		match_anything

  5214 +#define match_jmplabel		match_anything

  5215 +#define match_number		match_anything

  5216 +

  5217 +/* Mnemonics that take reglists never accept anything else */

  5218 +#define match_reglist8		match_anything

  5219 +#define match_reglist9		match_anything

  5220 +#define match_reglist16		match_anything

  5221 +#define match_reglist_ldm	match_anything

  5222 +#define match_reglist_cp8	match_anything

  5223 +#define match_reglist_cpd8	match_anything

  5224 +

  5225 +/* Ditto for retval, jospinc and mcall */

  5226 +#define match_retval		match_anything

  5227 +#define match_jospinc		match_anything

  5228 +#define match_mcall		match_anything

  5229 +

  5230 +/* COH is used to select between two different syntaxes */

  5231 +static int

  5232 +match_coh(char *str)

  5233 +{

  5234 +  return strcasecmp(str, "coh") == 0;

  5235 +}

  5236 +

  5237 +static int

  5238 +match_fpreg(char *str)

  5239 +{

  5240 +  unsigned long regid;

  5241 +  char *endptr;

  5242 +

  5243 +  if ((str[0] != 'f' && str[0] != 'F')

  5244 +      || (str[1] != 'r' && str[1] != 'R'))

  5245 +    return 0;

  5246 +

  5247 +  str += 2;

  5248 +  regid = strtoul(str, &endptr, 10);

  5249 +  if (!*str || *endptr)

  5250 +    return 0;

  5251 +

  5252 +  return 1;

  5253 +}

  5254 +

  5255 +static int

  5256 +match_picoreg(char *str)

  5257 +{

  5258 +  int regid;

  5259 +

  5260 +  regid = avr32_parse_picoreg(str);

  5261 +  if (regid < 0)

  5262 +    return 0;

  5263 +  return 1;

  5264 +}

  5265 +

  5266 +#define match_pico_reglist_w	match_anything

  5267 +#define match_pico_reglist_d	match_anything

  5268 +

  5269 +static int

  5270 +match_pico_in(char *str)

  5271 +{

  5272 +  unsigned long regid;

  5273 +  char *end;

  5274 +

  5275 +  if (strncasecmp(str, "in", 2) != 0)

  5276 +    return 0;

  5277 +

  5278 +  str += 2;

  5279 +  regid = strtoul(str, &end, 10);

  5280 +  if (!*str || *end)

  5281 +    return 0;

  5282 +

  5283 +  return 1;

  5284 +}

  5285 +

  5286 +static int

  5287 +match_pico_out0(char *str)

  5288 +{

  5289 +  if (strcasecmp(str, "out0") != 0)

  5290 +    return 0;

  5291 +  return 1;

  5292 +}

  5293 +

  5294 +static int

  5295 +match_pico_out1(char *str)

  5296 +{

  5297 +  if (strcasecmp(str, "out1") != 0)

  5298 +    return 0;

  5299 +  return 1;

  5300 +}

  5301 +

  5302 +static int

  5303 +match_pico_out2(char *str)

  5304 +{

  5305 +  if (strcasecmp(str, "out2") != 0)

  5306 +    return 0;

  5307 +  return 1;

  5308 +}

  5309 +

  5310 +static int

  5311 +match_pico_out3(char *str)

  5312 +{

  5313 +  if (strcasecmp(str, "out3") != 0)

  5314 +    return 0;

  5315 +  return 1;

  5316 +}

  5317 +

  5318 +static void parse_nothing(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  5319 +			  char *str ATTRIBUTE_UNUSED,

  5320 +			  int opindex ATTRIBUTE_UNUSED)

  5321 +{

  5322 +  /* Do nothing (this is used for "match-only" operands like COH) */

  5323 +}

  5324 +

  5325 +static void

  5326 +parse_const(const struct avr32_operand *op, char *str,

  5327 +	    int opindex ATTRIBUTE_UNUSED)

  5328 +{

  5329 +  expressionS *exp = &current_insn.immediate;

  5330 +  expressionS *sym_exp;

  5331 +  int slot;

  5332 +  char *save;

  5333 +

  5334 +  pr_debug("parse_const: `%s' (signed: %d, pcrel: %d, align: %d)\n",

  5335 +	   str, op->is_signed, op->is_pcrel, op->align_order);

  5336 +

  5337 +  save = input_line_pointer;

  5338 +  input_line_pointer = str;

  5339 +

  5340 +  expression(exp);

  5341 +

  5342 +  slot = current_insn.next_slot++;

  5343 +  current_insn.field_value[slot].align_order = op->align_order;

  5344 +  current_insn.pcrel = op->is_pcrel;

  5345 +

  5346 +  switch (exp->X_op)

  5347 +    {

  5348 +    case O_illegal:

  5349 +      as_bad(_("illegal operand"));

  5350 +      break;

  5351 +    case O_absent:

  5352 +      as_bad(_("missing operand"));

  5353 +      break;

  5354 +    case O_constant:

  5355 +      pr_debug("  -> constant: %ld\n", (long)exp->X_add_number);

  5356 +      current_insn.field_value[slot].value = exp->X_add_number;

  5357 +      break;

  5358 +    case O_uminus:

  5359 +      pr_debug("  -> uminus\n");

  5360 +      sym_exp = symbol_get_value_expression(exp->X_add_symbol);

  5361 +      switch (sym_exp->X_op) {

  5362 +      case O_subtract:

  5363 +	pr_debug("     -> subtract: switching operands\n");

  5364 +	exp->X_op_symbol = sym_exp->X_add_symbol;

  5365 +	exp->X_add_symbol = sym_exp->X_op_symbol;

  5366 +	exp->X_op = O_subtract;

  5367 +	/* TODO: Remove the old X_add_symbol */

  5368 +	break;

  5369 +      default:

  5370 +	as_bad(_("Expression too complex\n"));

  5371 +	break;

  5372 +      }

  5373 +      break;

  5374 +#if 0

  5375 +    case O_subtract:

  5376 +      /* Any expression subtracting a symbol from the current section

  5377 +	 can be made PC-relative by adding the right offset.  */

  5378 +      if (S_GET_SEGMENT(exp->X_op_symbol) == now_seg)

  5379 +	current_insn.pcrel = TRUE;

  5380 +      pr_debug("  -> subtract: pcrel? %s\n",

  5381 +	       current_insn.pcrel ? "yes" : "no");

  5382 +      /* fall through */

  5383 +#endif

  5384 +    default:

  5385 +      pr_debug("  -> (%p <%d> %p + %d)\n",

  5386 +	       exp->X_add_symbol, exp->X_op, exp->X_op_symbol,

  5387 +	       exp->X_add_number);

  5388 +      current_insn.field_value[slot].value = 0;

  5389 +      break;

  5390 +    }

  5391 +

  5392 +  input_line_pointer = save;

  5393 +}

  5394 +

  5395 +static void

  5396 +parse_jmplabel(const struct avr32_operand *op, char *str,

  5397 +	       int opindex ATTRIBUTE_UNUSED)

  5398 +{

  5399 +  expressionS *exp = &current_insn.immediate;

  5400 +  int slot;

  5401 +  char *save;

  5402 +

  5403 +  pr_debug("parse_jmplabel: `%s' (signed: %d, pcrel: %d, align: %d)\n",

  5404 +	   str, op->is_signed, op->is_pcrel, op->align_order);

  5405 +

  5406 +  save = input_line_pointer;

  5407 +  input_line_pointer = str;

  5408 +

  5409 +  expression(exp);

  5410 +

  5411 +  slot = current_insn.next_slot++;

  5412 +  current_insn.field_value[slot].align_order = op->align_order;

  5413 +  current_insn.pcrel = TRUE;

  5414 +

  5415 +  switch (exp->X_op)

  5416 +    {

  5417 +    case O_illegal:

  5418 +      as_bad(_("illegal operand"));

  5419 +      break;

  5420 +    case O_absent:

  5421 +      as_bad(_("missing operand"));

  5422 +      break;

  5423 +    case O_constant:

  5424 +      pr_debug("  -> constant: %ld\n", (long)exp->X_add_number);

  5425 +      current_insn.field_value[slot].value = exp->X_add_number;

  5426 +      current_insn.pcrel = 0;

  5427 +      break;

  5428 +    default:

  5429 +      pr_debug("  -> (%p <%d> %p + %d)\n",

  5430 +	       exp->X_add_symbol, exp->X_op, exp->X_op_symbol,

  5431 +	       exp->X_add_number);

  5432 +      current_insn.field_value[slot].value = 0;

  5433 +      break;

  5434 +    }

  5435 +

  5436 +  input_line_pointer = save;

  5437 +}

  5438 +

  5439 +static void

  5440 +parse_intreg(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  5441 +	     char *str, int opindex ATTRIBUTE_UNUSED)

  5442 +{

  5443 +  int regid, slot;

  5444 +

  5445 +  pr_debug("parse_intreg: `%s'\n", str);

  5446 +

  5447 +  regid = avr32_parse_intreg(str);

  5448 +  assert(regid >= 0);

  5449 +

  5450 +  slot = current_insn.next_slot++;

  5451 +  current_insn.field_value[slot].value = regid;

  5452 +  current_insn.field_value[slot].align_order = op->align_order;

  5453 +}

  5454 +

  5455 +static void

  5456 +parse_intreg_predec(const struct avr32_operand *op, char *str, int opindex)

  5457 +{

  5458 +  parse_intreg(op, str + 2, opindex);

  5459 +}

  5460 +

  5461 +static void

  5462 +parse_intreg_postinc(const struct avr32_operand *op, char *str, int opindex)

  5463 +{

  5464 +  char *p, c;

  5465 +

  5466 +  pr_debug("parse_intreg_postinc: `%s'\n", str);

  5467 +

  5468 +  for (p = str; *p != '+'; p++) ;

  5469 +

  5470 +  c = *p, *p = 0;

  5471 +  parse_intreg(op, str, opindex);

  5472 +  *p = c;

  5473 +}

  5474 +

  5475 +static void

  5476 +parse_intreg_shift(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  5477 +		   char *str, int opindex ATTRIBUTE_UNUSED)

  5478 +{

  5479 +  int regid, slot, shift = 0;

  5480 +  char *p, c;

  5481 +  char shiftop;

  5482 +

  5483 +  pr_debug("parse Ry<<sa: `%s'\n", str);

  5484 +

  5485 +  for (p = str; *p; p++)

  5486 +    if (*p == '<' || *p == '>')

  5487 +      break;

  5488 +

  5489 +  shiftop = *p;

  5490 +

  5491 +  c = *p, *p = 0;

  5492 +  regid = avr32_parse_intreg(str);

  5493 +  assert(regid >= 0);

  5494 +  *p = c;

  5495 +

  5496 +  if (c)

  5497 +    {

  5498 +      if (p[0] != shiftop || p[1] != shiftop)

  5499 +	as_bad(_("expected shift operator in `%s'"), p);

  5500 +      else

  5501 +	{

  5502 +	  expressionS exp;

  5503 +	  char *saved;

  5504 +

  5505 +	  saved = input_line_pointer;

  5506 +	  input_line_pointer = p + 2;

  5507 +	  expression(&exp);

  5508 +	  input_line_pointer = saved;

  5509 +

  5510 +	  if (exp.X_op != O_constant)

  5511 +	    as_bad(_("shift amount must be a numeric constant"));

  5512 +	  else

  5513 +	    shift = exp.X_add_number;

  5514 +	}

  5515 +    }

  5516 +

  5517 +  slot = current_insn.next_slot++;

  5518 +  current_insn.field_value[slot].value = regid;

  5519 +  slot = current_insn.next_slot++;

  5520 +  current_insn.field_value[slot].value = shift;

  5521 +}

  5522 +

  5523 +/* The match() function selected the right opcode, so it doesn't

  5524 +   matter which way we shift any more.  */

  5525 +#define parse_intreg_lsl	parse_intreg_shift

  5526 +#define parse_intreg_lsr	parse_intreg_shift

  5527 +

  5528 +static void

  5529 +parse_intreg_part(const struct avr32_operand *op, char *str,

  5530 +		  int opindex ATTRIBUTE_UNUSED)

  5531 +{

  5532 +  static const char bparts[] = { 'b', 'l', 'u', 't' };

  5533 +  static const char hparts[] = { 'b', 't' };

  5534 +  unsigned int slot, sel;

  5535 +  int regid;

  5536 +  char *p, c;

  5537 +

  5538 +  pr_debug("parse reg:part `%s'\n", str);

  5539 +

  5540 +  for (p = str; *p; p++)

  5541 +    if (*p == ':')

  5542 +      break;

  5543 +

  5544 +  c = *p, *p = 0;

  5545 +  regid = avr32_parse_intreg(str);

  5546 +  assert(regid >= 0);

  5547 +  *p = c;

  5548 +

  5549 +  assert(c == ':');

  5550 +

  5551 +  if (op->align_order)

  5552 +    {

  5553 +      for (sel = 0; sel < sizeof(hparts); sel++)

  5554 +	if (TOLOWER(p[1]) == hparts[sel])

  5555 +	  break;

  5556 +

  5557 +      if (sel >= sizeof(hparts))

  5558 +	{

  5559 +	  as_bad(_("invalid halfword selector `%c' (must be either b or t)"),

  5560 +		 p[1]);

  5561 +	  sel = 0;

  5562 +	}

  5563 +    }

  5564 +  else

  5565 +    {

  5566 +      for (sel = 0; sel < sizeof(bparts); sel++)

  5567 +	if (TOLOWER(p[1]) == bparts[sel])

  5568 +	  break;

  5569 +

  5570 +      if (sel >= sizeof(bparts))

  5571 +	{

  5572 +	  as_bad(_("invalid byte selector `%c' (must be one of b,l,u,t)"),

  5573 +		 p[1]);

  5574 +	  sel = 0;

  5575 +	}

  5576 +    }

  5577 +

  5578 +  slot = current_insn.next_slot++;

  5579 +  current_insn.field_value[slot].value = regid;

  5580 +  slot = current_insn.next_slot++;

  5581 +  current_insn.field_value[slot].value = sel;

  5582 +}

  5583 +

  5584 +/* This is the parser for "Rp[displacement]" expressions.  In addition

  5585 +   to the "official" syntax, we accept a label as a replacement for

  5586 +   the register expression.  This syntax implies Rp=PC and the

  5587 +   displacement is the pc-relative distance to the label.  */

  5588 +static void

  5589 +parse_intreg_disp(const struct avr32_operand *op, char *str, int opindex)

  5590 +{

  5591 +  expressionS *exp = &current_insn.immediate;

  5592 +  int slot, regid;

  5593 +  char *save, *p, c;

  5594 +

  5595 +  pr_debug("parse_intreg_disp: `%s' (signed: %d, pcrel: %d, align: %d)\n",

  5596 +	   str, op->is_signed, op->is_pcrel, op->align_order);

  5597 +

  5598 +  for (p = str; *p; p++)

  5599 +    if (*p == '[')

  5600 +      break;

  5601 +

  5602 +  slot = current_insn.next_slot++;

  5603 +

  5604 +  /* First, check if we have a valid register either before '[' or as

  5605 +     the sole expression.  If so, we use the Rp[disp] syntax.  */

  5606 +  c = *p, *p = 0;

  5607 +  regid = avr32_parse_intreg(str);

  5608 +  *p = c;

  5609 +

  5610 +  if (regid >= 0)

  5611 +    {

  5612 +      current_insn.field_value[slot].value = regid;

  5613 +

  5614 +      slot = current_insn.next_slot++;

  5615 +      current_insn.field_value[slot].align_order = op->align_order;

  5616 +

  5617 +      if (c == '[')

  5618 +	{

  5619 +	  save = input_line_pointer;

  5620 +	  input_line_pointer = p + 1;

  5621 +

  5622 +	  expression(exp);

  5623 +

  5624 +	  if (*input_line_pointer != ']')

  5625 +	    as_bad(_("junk after displacement expression"));

  5626 +

  5627 +	  input_line_pointer = save;

  5628 +

  5629 +	  switch (exp->X_op)

  5630 +	    {

  5631 +	    case O_illegal:

  5632 +	      as_bad(_("illegal displacement expression"));

  5633 +	      break;

  5634 +	    case O_absent:

  5635 +	      as_bad(_("missing displacement expression"));

  5636 +	      break;

  5637 +	    case O_constant:

  5638 +	      pr_debug("  -> constant: %ld\n", exp->X_add_number);

  5639 +	      current_insn.field_value[slot].value = exp->X_add_number;

  5640 +	      break;

  5641 +#if 0

  5642 +	    case O_subtract:

  5643 +	      if (S_GET_SEGMENT(exp->X_op_symbol) == now_seg)

  5644 +		current_insn.pcrel = TRUE;

  5645 +	      pr_debug("  -> subtract: pcrel? %s\n",

  5646 +		       current_insn.pcrel ? "yes" : "no");

  5647 +	      /* fall through */

  5648 +#endif

  5649 +	    default:

  5650 +	      pr_debug("  -> (%p <%d> %p + %d)\n",

  5651 +		       exp->X_add_symbol, exp->X_op, exp->X_op_symbol,

  5652 +		       exp->X_add_number);

  5653 +	      current_insn.field_value[slot].value = 0;

  5654 +	    }

  5655 +	}

  5656 +      else

  5657 +	{

  5658 +	  exp->X_op = O_constant;

  5659 +	  exp->X_add_number = 0;

  5660 +	  current_insn.field_value[slot].value = 0;

  5661 +	}

  5662 +    }

  5663 +  else

  5664 +    {

  5665 +      /* Didn't find a valid register.  Try parsing it as a label.  */

  5666 +      current_insn.field_value[slot].value = AVR32_REG_PC;

  5667 +      parse_jmplabel(op, str, opindex);

  5668 +    }

  5669 +}

  5670 +

  5671 +static void

  5672 +parse_intreg_index(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  5673 +		   char *str, int opindex ATTRIBUTE_UNUSED)

  5674 +{

  5675 +  int slot, regid;

  5676 +  char *p, *end, c;

  5677 +

  5678 +  for (p = str; *p; p++)

  5679 +    if (*p == '[')

  5680 +      break;

  5681 +

  5682 +  assert(*p);

  5683 +

  5684 +  c = *p, *p = 0;

  5685 +  regid = avr32_parse_intreg(str);

  5686 +  assert(regid >= 0);

  5687 +  *p = c;

  5688 +

  5689 +  slot = current_insn.next_slot++;

  5690 +  current_insn.field_value[slot].value = regid;

  5691 +

  5692 +  p++;

  5693 +  for (end = p; *end; end++)

  5694 +    if (*end == ']' || *end == '<')

  5695 +      break;

  5696 +

  5697 +  assert(*end);

  5698 +

  5699 +  c = *end, *end = 0;

  5700 +  regid = avr32_parse_intreg(p);

  5701 +  assert(regid >= 0);

  5702 +  *end = c;

  5703 +

  5704 +  slot = current_insn.next_slot++;

  5705 +  current_insn.field_value[slot].value = regid;

  5706 +

  5707 +  slot = current_insn.next_slot++;

  5708 +  current_insn.field_value[slot].value = 0;

  5709 +

  5710 +  if (*end == '<')

  5711 +    {

  5712 +      expressionS exp;

  5713 +      char *save;

  5714 +

  5715 +      p = end + 2;

  5716 +      for (end = p; *end; end++)

  5717 +	if (*end == ']')

  5718 +	  break;

  5719 +

  5720 +      assert(*end == ']');

  5721 +

  5722 +      c = *end, *end = 0;

  5723 +      save = input_line_pointer;

  5724 +      input_line_pointer = p;

  5725 +      expression(&exp);

  5726 +

  5727 +      if (*input_line_pointer)

  5728 +	as_bad(_("junk after shift expression"));

  5729 +

  5730 +      *end = c;

  5731 +      input_line_pointer = save;

  5732 +

  5733 +      if (exp.X_op == O_constant)

  5734 +	current_insn.field_value[slot].value = exp.X_add_number;

  5735 +      else

  5736 +	as_bad(_("shift expression too complex"));

  5737 +    }

  5738 +}

  5739 +

  5740 +static void

  5741 +parse_intreg_xindex(const struct avr32_operand *op, char *str, int opindex)

  5742 +{

  5743 +  int slot, regid;

  5744 +  char *p, *end, c;

  5745 +

  5746 +  for (p = str; *p; p++)

  5747 +    if (*p == '[')

  5748 +      break;

  5749 +

  5750 +  assert(*p);

  5751 +

  5752 +  c = *p, *p = 0;

  5753 +  regid = avr32_parse_intreg(str);

  5754 +  assert(regid >= 0);

  5755 +  *p = c;

  5756 +

  5757 +  slot = current_insn.next_slot++;

  5758 +  current_insn.field_value[slot].value = regid;

  5759 +

  5760 +  p++;

  5761 +  for (end = p; *end; end++)

  5762 +    if (*end == '<')

  5763 +      break;

  5764 +

  5765 +  assert(*end);

  5766 +

  5767 +  c = *end, *end = 0;

  5768 +  parse_intreg_part(op, p, opindex);

  5769 +  *end = c;

  5770 +}

  5771 +

  5772 +static void

  5773 +parse_pc_disp(const struct avr32_operand *op, char *str, int opindex)

  5774 +{

  5775 +  char *p, c;

  5776 +

  5777 +  for (p = str; *p; p++)

  5778 +    if (*p == '[')

  5779 +      break;

  5780 +

  5781 +  /* The lddpc instruction comes in two different syntax variants:

  5782 +       lddpc reg, expression

  5783 +       lddpc reg, pc[disp]

  5784 +     If the operand contains a '[', we use the second form.  */

  5785 +  if (*p)

  5786 +    {

  5787 +      int regid;

  5788 +

  5789 +      c = *p, *p = 0;

  5790 +      regid = avr32_parse_intreg(str);

  5791 +      *p = c;

  5792 +      if (regid == AVR32_REG_PC)

  5793 +	{

  5794 +	  char *end;

  5795 +

  5796 +	  for (end = ++p; *end; end++) ;

  5797 +	  if (*(--end) != ']')

  5798 +	    as_bad(_("unrecognized form of instruction: `%s'"), str);

  5799 +	  else

  5800 +	    {

  5801 +	      c = *end, *end = 0;

  5802 +	      parse_const(op, p, opindex);

  5803 +	      *end = c;

  5804 +	      current_insn.pcrel = 0;

  5805 +	    }

  5806 +	}

  5807 +      else

  5808 +	as_bad(_("unrecognized form of instruction: `%s'"), str);

  5809 +    }

  5810 +  else

  5811 +    {

  5812 +      parse_jmplabel(op, str, opindex);

  5813 +    }

  5814 +}

  5815 +

  5816 +static void parse_sp(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  5817 +		     char *str ATTRIBUTE_UNUSED,

  5818 +		     int opindex ATTRIBUTE_UNUSED)

  5819 +{

  5820 +  int slot;

  5821 +

  5822 +  slot = current_insn.next_slot++;

  5823 +  current_insn.field_value[slot].value = AVR32_REG_SP;

  5824 +}

  5825 +

  5826 +static void

  5827 +parse_sp_disp(const struct avr32_operand *op, char *str, int opindex)

  5828 +{

  5829 +  char *p, c;

  5830 +

  5831 +  for (; *str; str++)

  5832 +    if (*str == '[')

  5833 +      break;

  5834 +

  5835 +  assert(*str);

  5836 +

  5837 +  for (p = ++str; *p; p++)

  5838 +    if (*p == ']')

  5839 +      break;

  5840 +

  5841 +  c = *p, *p = 0;

  5842 +  parse_const(op, str, opindex);

  5843 +  *p = c;

  5844 +}

  5845 +

  5846 +static void

  5847 +parse_cpno(const struct avr32_operand *op ATTRIBUTE_UNUSED, char *str,

  5848 +	   int opindex ATTRIBUTE_UNUSED)

  5849 +{

  5850 +  int slot;

  5851 +

  5852 +  str += 2;

  5853 +  if (*str == '#')

  5854 +    str++;

  5855 +  if (*str < '0' || *str > '7' || str[1])

  5856 +    as_bad(_("invalid coprocessor `%s'"), str);

  5857 +

  5858 +  slot = current_insn.next_slot++;

  5859 +  current_insn.field_value[slot].value = *str - '0';

  5860 +}

  5861 +

  5862 +static void

  5863 +parse_cpreg(const struct avr32_operand *op, char *str,

  5864 +	    int opindex ATTRIBUTE_UNUSED)

  5865 +{

  5866 +  unsigned int crid;

  5867 +  int slot;

  5868 +  char *endptr;

  5869 +

  5870 +  str += 2;

  5871 +  crid = strtoul(str, &endptr, 10);

  5872 +  if (*endptr || crid > 15 || crid & ((1 << op->align_order) - 1))

  5873 +    as_bad(_("invalid coprocessor register `%s'"), str);

  5874 +

  5875 +  crid >>= op->align_order;

  5876 +

  5877 +  slot = current_insn.next_slot++;

  5878 +  current_insn.field_value[slot].value = crid;

  5879 +}

  5880 +

  5881 +static void

  5882 +parse_number(const struct avr32_operand *op, char *str,

  5883 +	     int opindex ATTRIBUTE_UNUSED)

  5884 +{

  5885 +  expressionS exp;

  5886 +  int slot;

  5887 +  char *save;

  5888 +

  5889 +  save = input_line_pointer;

  5890 +  input_line_pointer = str;

  5891 +  expression(&exp);

  5892 +  input_line_pointer = save;

  5893 +

  5894 +  slot = current_insn.next_slot++;

  5895 +  current_insn.field_value[slot].align_order = op->align_order;

  5896 +

  5897 +  if (exp.X_op == O_constant)

  5898 +      current_insn.field_value[slot].value = exp.X_add_number;

  5899 +  else

  5900 +      as_bad(_("invalid numeric expression `%s'"), str);

  5901 +}

  5902 +

  5903 +static void

  5904 +parse_reglist8(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  5905 +	       char *str, int opindex ATTRIBUTE_UNUSED)

  5906 +{

  5907 +  unsigned long regmask;

  5908 +  unsigned long value = 0;

  5909 +  int slot;

  5910 +  char *tail;

  5911 +

  5912 +  regmask = avr32_parse_reglist(str, &tail);

  5913 +  if (*tail)

  5914 +    as_bad(_("invalid register list `%s'"), str);

  5915 +  else

  5916 +    {

  5917 +      if (avr32_make_regmask8(regmask, &value))

  5918 +	as_bad(_("register list `%s' doesn't fit"), str);

  5919 +    }

  5920 +

  5921 +  slot = current_insn.next_slot++;

  5922 +  current_insn.field_value[slot].value = value;

  5923 +}

  5924 +

  5925 +static int

  5926 +parse_reglist_tail(char *str, unsigned long regmask)

  5927 +{

  5928 +  expressionS exp;

  5929 +  char *save, *p, c;

  5930 +  int regid;

  5931 +

  5932 +  for (p = str + 1; *p; p++)

  5933 +    if (*p == '=')

  5934 +      break;

  5935 +

  5936 +  if (!*p)

  5937 +    {

  5938 +      as_bad(_("invalid register list `%s'"), str);

  5939 +      return -2;

  5940 +    }

  5941 +

  5942 +  c = *p, *p = 0;

  5943 +  regid = avr32_parse_intreg(str);

  5944 +  *p = c;

  5945 +

  5946 +  if (regid != 12)

  5947 +    {

  5948 +      as_bad(_("invalid register list `%s'"), str);

  5949 +      return -2;

  5950 +    }

  5951 +

  5952 +  /* If we have an assignment, we must pop PC and we must _not_

  5953 +     pop LR or R12 */

  5954 +  if (!(regmask & (1 << AVR32_REG_PC)))

  5955 +    {

  5956 +      as_bad(_("return value specified for non-return instruction"));

  5957 +      return -2;

  5958 +    }

  5959 +  else if (regmask & ((1 << AVR32_REG_R12) | (1 << AVR32_REG_LR)))

  5960 +    {

  5961 +      as_bad(_("can't pop LR or R12 when specifying return value"));

  5962 +      return -2;

  5963 +    }

  5964 +

  5965 +  save = input_line_pointer;

  5966 +  input_line_pointer = p + 1;

  5967 +  expression(&exp);

  5968 +  input_line_pointer = save;

  5969 +

  5970 +  if (exp.X_op != O_constant

  5971 +      || exp.X_add_number < -1

  5972 +      || exp.X_add_number > 1)

  5973 +    {

  5974 +      as_bad(_("invalid return value `%s'"), str);

  5975 +      return -2;

  5976 +    }

  5977 +

  5978 +  return exp.X_add_number;

  5979 +}

  5980 +

  5981 +static void

  5982 +parse_reglist9(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  5983 +	       char *str, int opindex ATTRIBUTE_UNUSED)

  5984 +{

  5985 +  unsigned long regmask;

  5986 +  unsigned long value = 0, kbit = 0;

  5987 +  int slot;

  5988 +  char *tail;

  5989 +

  5990 +  regmask = avr32_parse_reglist(str, &tail);

  5991 +  /* printf("parsed reglist16: %04lx, tail: `%s'\n", regmask, tail); */

  5992 +  if (*tail)

  5993 +    {

  5994 +      int retval;

  5995 +

  5996 +      retval = parse_reglist_tail(tail, regmask);

  5997 +

  5998 +      switch (retval)

  5999 +	{

  6000 +	case -1:

  6001 +	  regmask |= 1 << AVR32_REG_LR;

  6002 +	  break;

  6003 +	case 0:

  6004 +	  break;

  6005 +	case 1:

  6006 +	  regmask |= 1 << AVR32_REG_R12;

  6007 +	  break;

  6008 +	default:

  6009 +	  break;

  6010 +	}

  6011 +

  6012 +      kbit = 1;

  6013 +    }

  6014 +

  6015 +  if (avr32_make_regmask8(regmask, &value))

  6016 +    as_bad(_("register list `%s' doesn't fit"), str);

  6017 +

  6018 +

  6019 +  slot = current_insn.next_slot++;

  6020 +  current_insn.field_value[slot].value = (value << 1) | kbit;

  6021 +}

  6022 +

  6023 +static void

  6024 +parse_reglist16(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  6025 +		char *str, int opindex ATTRIBUTE_UNUSED)

  6026 +{

  6027 +  unsigned long regmask;

  6028 +  int slot;

  6029 +  char *tail;

  6030 +

  6031 +  regmask = avr32_parse_reglist(str, &tail);

  6032 +  if (*tail)

  6033 +    as_bad(_("invalid register list `%s'"), str);

  6034 +

  6035 +  slot = current_insn.next_slot++;

  6036 +  current_insn.field_value[slot].value = regmask;

  6037 +}

  6038 +

  6039 +static void

  6040 +parse_reglist_ldm(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  6041 +		  char *str, int opindex ATTRIBUTE_UNUSED)

  6042 +{

  6043 +  unsigned long regmask;

  6044 +  int slot, rp, w_bit = 0;

  6045 +  char *tail, *p, c;

  6046 +

  6047 +  for (p = str; *p && *p != ','; p++)

  6048 +    if (*p == '+')

  6049 +      break;

  6050 +

  6051 +  c = *p, *p = 0;

  6052 +  rp = avr32_parse_intreg(str);

  6053 +  *p = c;

  6054 +  if (rp < 0)

  6055 +    {

  6056 +      as_bad(_("invalid destination register in `%s'"), str);

  6057 +      return;

  6058 +    }

  6059 +

  6060 +  if (p[0] == '+' && p[1] == '+')

  6061 +    {

  6062 +      w_bit = 1;

  6063 +      p += 2;

  6064 +    }

  6065 +

  6066 +  if (*p != ',')

  6067 +    {

  6068 +      as_bad(_("expected `,' after destination register in `%s'"), str);

  6069 +      return;

  6070 +    }

  6071 +

  6072 +  str = p + 1;

  6073 +  regmask = avr32_parse_reglist(str, &tail);

  6074 +  if (*tail)

  6075 +    {

  6076 +      int retval;

  6077 +

  6078 +      if (rp != AVR32_REG_SP)

  6079 +	{

  6080 +	  as_bad(_("junk at end of line: `%s'"), tail);

  6081 +	  return;

  6082 +	}

  6083 +

  6084 +      rp = AVR32_REG_PC;

  6085 +

  6086 +      retval = parse_reglist_tail(tail, regmask);

  6087 +

  6088 +      switch (retval)

  6089 +	{

  6090 +	case -1:

  6091 +	  regmask |= 1 << AVR32_REG_LR;

  6092 +	  break;

  6093 +	case 0:

  6094 +	  break;

  6095 +	case 1:

  6096 +	  regmask |= 1 << AVR32_REG_R12;

  6097 +	  break;

  6098 +	default:

  6099 +	  return;

  6100 +	}

  6101 +    }

  6102 +

  6103 +  slot = current_insn.next_slot++;

  6104 +  current_insn.field_value[slot].value = rp;

  6105 +  slot = current_insn.next_slot++;

  6106 +  current_insn.field_value[slot].value = w_bit;

  6107 +  slot = current_insn.next_slot++;

  6108 +  current_insn.field_value[slot].value = regmask;

  6109 +}

  6110 +

  6111 +static void

  6112 +parse_reglist_cp8(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  6113 +		  char *str, int opindex ATTRIBUTE_UNUSED)

  6114 +{

  6115 +  unsigned long regmask;

  6116 +  int slot, h_bit = 0;

  6117 +  char *tail;

  6118 +

  6119 +  regmask = avr32_parse_cpreglist(str, &tail);

  6120 +  if (*tail)

  6121 +    as_bad(_("junk at end of line: `%s'"), tail);

  6122 +  else if (regmask & 0xffUL)

  6123 +    {

  6124 +      if (regmask & 0xff00UL)

  6125 +	as_bad(_("register list `%s' doesn't fit"), str);

  6126 +      regmask &= 0xff;

  6127 +    }

  6128 +  else if (regmask & 0xff00UL)

  6129 +    {

  6130 +      regmask >>= 8;

  6131 +      h_bit = 1;

  6132 +    }

  6133 +  else

  6134 +    as_warn(_("register list is empty"));

  6135 +

  6136 +  slot = current_insn.next_slot++;

  6137 +  current_insn.field_value[slot].value = regmask;

  6138 +  slot = current_insn.next_slot++;

  6139 +  current_insn.field_value[slot].value = h_bit;

  6140 +}

  6141 +

  6142 +static void

  6143 +parse_reglist_cpd8(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  6144 +		   char *str, int opindex ATTRIBUTE_UNUSED)

  6145 +{

  6146 +  unsigned long regmask, regmask_d = 0;

  6147 +  int slot, i;

  6148 +  char *tail;

  6149 +

  6150 +  regmask = avr32_parse_cpreglist(str, &tail);

  6151 +  if (*tail)

  6152 +    as_bad(_("junk at end of line: `%s'"), tail);

  6153 +

  6154 +  for (i = 0; i < 8; i++)

  6155 +    {

  6156 +      if (regmask & 1)

  6157 +	{

  6158 +	  if (!(regmask & 2))

  6159 +	    {

  6160 +	      as_bad(_("register list `%s' doesn't fit"), str);

  6161 +	      break;

  6162 +	    }

  6163 +	  regmask_d |= 1 << i;

  6164 +	}

  6165 +      else if (regmask & 2)

  6166 +	{

  6167 +	  as_bad(_("register list `%s' doesn't fit"), str);

  6168 +	  break;

  6169 +	}

  6170 +

  6171 +      regmask >>= 2;

  6172 +    }

  6173 +

  6174 +  slot = current_insn.next_slot++;

  6175 +  current_insn.field_value[slot].value = regmask_d;

  6176 +}

  6177 +

  6178 +static void

  6179 +parse_retval(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  6180 +	     char *str, int opindex ATTRIBUTE_UNUSED)

  6181 +{

  6182 +  int regid, slot;

  6183 +

  6184 +  regid = avr32_parse_intreg(str);

  6185 +  if (regid < 0)

  6186 +    {

  6187 +      expressionS exp;

  6188 +      char *save;

  6189 +

  6190 +      regid = 0;

  6191 +

  6192 +      save = input_line_pointer;

  6193 +      input_line_pointer = str;

  6194 +      expression(&exp);

  6195 +      input_line_pointer = save;

  6196 +

  6197 +      if (exp.X_op != O_constant)

  6198 +	as_bad(_("invalid return value `%s'"), str);

  6199 +      else

  6200 +	switch (exp.X_add_number)

  6201 +	  {

  6202 +	  case -1:

  6203 +	    regid = AVR32_REG_LR;

  6204 +	    break;

  6205 +	  case 0:

  6206 +	    regid = AVR32_REG_SP;

  6207 +	    break;

  6208 +	  case 1:

  6209 +	    regid = AVR32_REG_PC;

  6210 +	    break;

  6211 +	  default:

  6212 +	    as_bad(_("invalid return value `%s'"), str);

  6213 +	    break;

  6214 +	  }

  6215 +    }

  6216 +

  6217 +  slot = current_insn.next_slot++;

  6218 +  current_insn.field_value[slot].value = regid;

  6219 +}

  6220 +

  6221 +#define parse_mcall parse_intreg_disp

  6222 +

  6223 +static void

  6224 +parse_jospinc(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  6225 +	      char *str, int opindex ATTRIBUTE_UNUSED)

  6226 +{

  6227 +  expressionS exp;

  6228 +  int slot;

  6229 +  char *save;

  6230 +

  6231 +  save = input_line_pointer;

  6232 +  input_line_pointer = str;

  6233 +  expression(&exp);

  6234 +  input_line_pointer = save;

  6235 +

  6236 +  slot = current_insn.next_slot++;

  6237 +

  6238 +  if (exp.X_op == O_constant)

  6239 +    {

  6240 +      if (exp.X_add_number > 0)

  6241 +	exp.X_add_number--;

  6242 +      current_insn.field_value[slot].value = exp.X_add_number;

  6243 +    }

  6244 +  else

  6245 +    as_bad(_("invalid numeric expression `%s'"), str);

  6246 +}

  6247 +

  6248 +#define parse_coh		parse_nothing

  6249 +

  6250 +static void

  6251 +parse_fpreg(const struct avr32_operand *op,

  6252 +	    char *str, int opindex ATTRIBUTE_UNUSED)

  6253 +{

  6254 +  unsigned long regid;

  6255 +  int slot;

  6256 +

  6257 +  regid = strtoul(str + 2, NULL, 10);

  6258 +

  6259 +  if ((regid >= 16) || (regid & ((1 << op->align_order) - 1)))

  6260 +    as_bad(_("invalid floating-point register `%s'"), str);

  6261 +

  6262 +  slot = current_insn.next_slot++;

  6263 +  current_insn.field_value[slot].value = regid;

  6264 +  current_insn.field_value[slot].align_order = op->align_order;

  6265 +}

  6266 +

  6267 +static void

  6268 +parse_picoreg(const struct avr32_operand *op,

  6269 +	      char *str, int opindex ATTRIBUTE_UNUSED)

  6270 +{

  6271 +  unsigned long regid;

  6272 +  int slot;

  6273 +

  6274 +  regid = avr32_parse_picoreg(str);

  6275 +  if (regid & ((1 << op->align_order) - 1))

  6276 +    as_bad(_("invalid double-word PiCo register `%s'"), str);

  6277 +

  6278 +  slot = current_insn.next_slot++;

  6279 +  current_insn.field_value[slot].value = regid;

  6280 +  current_insn.field_value[slot].align_order = op->align_order;

  6281 +}

  6282 +

  6283 +static void

  6284 +parse_pico_reglist_w(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  6285 +		     char *str, int opindex ATTRIBUTE_UNUSED)

  6286 +{

  6287 +  unsigned long regmask;

  6288 +  int slot, h_bit = 0;

  6289 +  char *tail;

  6290 +

  6291 +  regmask = avr32_parse_pico_reglist(str, &tail);

  6292 +  if (*tail)

  6293 +    as_bad(_("junk at end of line: `%s'"), tail);

  6294 +

  6295 +  if (regmask & 0x00ffUL)

  6296 +    {

  6297 +      if (regmask & 0xff00UL)

  6298 +	as_bad(_("register list `%s' doesn't fit"), str);

  6299 +      regmask &= 0x00ffUL;

  6300 +    }

  6301 +  else if (regmask & 0xff00UL)

  6302 +    {

  6303 +      regmask >>= 8;

  6304 +      h_bit = 1;

  6305 +    }

  6306 +  else

  6307 +    as_warn(_("register list is empty"));

  6308 +

  6309 +  slot = current_insn.next_slot++;

  6310 +  current_insn.field_value[slot].value = regmask;

  6311 +  slot = current_insn.next_slot++;

  6312 +  current_insn.field_value[slot].value = h_bit;

  6313 +}

  6314 +

  6315 +static void

  6316 +parse_pico_reglist_d(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  6317 +		     char *str, int opindex ATTRIBUTE_UNUSED)

  6318 +{

  6319 +  unsigned long regmask, regmask_d = 0;

  6320 +  int slot, i;

  6321 +  char *tail;

  6322 +

  6323 +  regmask = avr32_parse_pico_reglist(str, &tail);

  6324 +  if (*tail)

  6325 +    as_bad(_("junk at end of line: `%s'"), tail);

  6326 +

  6327 +  for (i = 0; i < 8; i++)

  6328 +    {

  6329 +      if (regmask & 1)

  6330 +	{

  6331 +	  if (!(regmask & 2))

  6332 +	    {

  6333 +	      as_bad(_("register list `%s' doesn't fit"), str);

  6334 +	      break;

  6335 +	    }

  6336 +	  regmask_d |= 1 << i;

  6337 +	}

  6338 +      else if (regmask & 2)

  6339 +	{

  6340 +	  as_bad(_("register list `%s' doesn't fit"), str);

  6341 +	  break;

  6342 +	}

  6343 +

  6344 +      regmask >>= 2;

  6345 +    }

  6346 +

  6347 +  slot = current_insn.next_slot++;

  6348 +  current_insn.field_value[slot].value = regmask_d;

  6349 +}

  6350 +

  6351 +static void

  6352 +parse_pico_in(const struct avr32_operand *op ATTRIBUTE_UNUSED,

  6353 +	      char *str, int opindex ATTRIBUTE_UNUSED)

  6354 +{

  6355 +  unsigned long regid;

  6356 +  int slot;

  6357 +

  6358 +  regid = strtoul(str + 2, NULL, 10);

  6359 +

  6360 +  if (regid >= 12)

  6361 +    as_bad(_("invalid PiCo IN register `%s'"), str);

  6362 +

  6363 +  slot = current_insn.next_slot++;

  6364 +  current_insn.field_value[slot].value = regid;

  6365 +  current_insn.field_value[slot].align_order = 0;

  6366 +}

  6367 +

  6368 +#define parse_pico_out0		parse_nothing

  6369 +#define parse_pico_out1		parse_nothing

  6370 +#define parse_pico_out2		parse_nothing

  6371 +#define parse_pico_out3		parse_nothing

  6372 +

  6373 +#define OP(name, sgn, pcrel, align, func) \

  6374 +  { AVR32_OPERAND_##name, sgn, pcrel, align, match_##func, parse_##func }

  6375 +

  6376 +struct avr32_operand avr32_operand_table[] = {

  6377 +  OP(INTREG, 0, 0, 0, intreg),

  6378 +  OP(INTREG_PREDEC, 0, 0, 0, intreg_predec),

  6379 +  OP(INTREG_POSTINC, 0, 0, 0, intreg_postinc),

  6380 +  OP(INTREG_LSL, 0, 0, 0, intreg_lsl),

  6381 +  OP(INTREG_LSR, 0, 0, 0, intreg_lsr),

  6382 +  OP(INTREG_BSEL, 0, 0, 0, intreg_part),

  6383 +  OP(INTREG_HSEL, 0, 0, 1, intreg_part),

  6384 +  OP(INTREG_SDISP, 1, 0, 0, intreg_disp),

  6385 +  OP(INTREG_SDISP_H, 1, 0, 1, intreg_disp),

  6386 +  OP(INTREG_SDISP_W, 1, 0, 2, intreg_disp),

  6387 +  OP(INTREG_UDISP, 0, 0, 0, intreg_disp),

  6388 +  OP(INTREG_UDISP_H, 0, 0, 1, intreg_disp),

  6389 +  OP(INTREG_UDISP_W, 0, 0, 2, intreg_disp),

  6390 +  OP(INTREG_INDEX, 0, 0, 0, intreg_index),

  6391 +  OP(INTREG_XINDEX, 0, 0, 0, intreg_xindex),

  6392 +  OP(DWREG, 0, 0, 1, intreg),

  6393 +  OP(PC_UDISP_W, 0, 1, 2, pc_disp),

  6394 +  OP(SP, 0, 0, 0, sp),

  6395 +  OP(SP_UDISP_W, 0, 0, 2, sp_disp),

  6396 +  OP(CPNO, 0, 0, 0, cpno),

  6397 +  OP(CPREG, 0, 0, 0, cpreg),

  6398 +  OP(CPREG_D, 0, 0, 1, cpreg),

  6399 +  OP(UNSIGNED_CONST, 0, 0, 0, const),

  6400 +  OP(UNSIGNED_CONST_W, 0, 0, 2, const),

  6401 +  OP(SIGNED_CONST, 1, 0, 0, const),

  6402 +  OP(SIGNED_CONST_W, 1, 0, 2, const),

  6403 +  OP(JMPLABEL, 1, 1, 1, jmplabel),

  6404 +  OP(UNSIGNED_NUMBER, 0, 0, 0, number),

  6405 +  OP(UNSIGNED_NUMBER_W, 0, 0, 2, number),

  6406 +  OP(REGLIST8, 0, 0, 0, reglist8),

  6407 +  OP(REGLIST9, 0, 0, 0, reglist9),

  6408 +  OP(REGLIST16, 0, 0, 0, reglist16),

  6409 +  OP(REGLIST_LDM, 0, 0, 0, reglist_ldm),

  6410 +  OP(REGLIST_CP8, 0, 0, 0, reglist_cp8),

  6411 +  OP(REGLIST_CPD8, 0, 0, 0, reglist_cpd8),

  6412 +  OP(RETVAL, 0, 0, 0, retval),

  6413 +  OP(MCALL, 1, 0, 2, mcall),

  6414 +  OP(JOSPINC, 0, 0, 0, jospinc),

  6415 +  OP(COH, 0, 0, 0, coh),

  6416 +  OP(FPREG_S, 0, 0, 0, fpreg),

  6417 +  OP(FPREG_D, 0, 0, 1, fpreg),

  6418 +  OP(PICO_REG_W, 0, 0, 0, picoreg),

  6419 +  OP(PICO_REG_D, 0, 0, 1, picoreg),

  6420 +  OP(PICO_REGLIST_W, 0, 0, 0, pico_reglist_w),

  6421 +  OP(PICO_REGLIST_D, 0, 0, 0, pico_reglist_d),

  6422 +  OP(PICO_IN, 0, 0, 0, pico_in),

  6423 +  OP(PICO_OUT0, 0, 0, 0, pico_out0),

  6424 +  OP(PICO_OUT1, 0, 0, 0, pico_out1),

  6425 +  OP(PICO_OUT2, 0, 0, 0, pico_out2),

  6426 +  OP(PICO_OUT3, 0, 0, 0, pico_out3),

  6427 +};

  6428 +

  6429 +symbolS *

  6430 +md_undefined_symbol (char *name ATTRIBUTE_UNUSED)

  6431 +{

  6432 +  pr_debug("md_undefined_symbol: %s\n", name);

  6433 +  return 0;

  6434 +}

  6435 +

  6436 +struct avr32_relax_type

  6437 +{

  6438 +  long lower_bound;

  6439 +  long upper_bound;

  6440 +  unsigned char align;

  6441 +  unsigned char length;

  6442 +  signed short next;

  6443 +};

  6444 +

  6445 +#define EMPTY { 0, 0, 0, 0, -1 }

  6446 +#define C(lower, upper, align, next)			\

  6447 +  { (lower), (upper), (align), 2, AVR32_OPC_##next }

  6448 +#define E(lower, upper, align)				\

  6449 +  { (lower), (upper), (align), 4, -1 }

  6450 +

  6451 +static const struct avr32_relax_type avr32_relax_table[] =

  6452 +  {

  6453 +    /* 0 */

  6454 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6455 +    EMPTY, EMPTY, EMPTY,

  6456 +    E(0, 65535, 0), E(0, 65535, 0), E(0, 65535, 0), E(0, 65535, 0),

  6457 +    EMPTY,

  6458 +    /* 16 */

  6459 +    EMPTY, EMPTY, EMPTY, EMPTY,

  6460 +

  6461 +    C(-256, 254, 1, BREQ2), C(-256, 254, 1, BRNE2),

  6462 +    C(-256, 254, 1, BRCC2), C(-256, 254, 1, BRCS2),

  6463 +    C(-256, 254, 1, BRGE2), C(-256, 254, 1, BRLT2),

  6464 +    C(-256, 254, 1, BRMI2), C(-256, 254, 1, BRPL2),

  6465 +    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),

  6466 +    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),

  6467 +    /* 32 */

  6468 +    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),

  6469 +    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),

  6470 +    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),

  6471 +    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),

  6472 +    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),

  6473 +    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),

  6474 +

  6475 +    EMPTY, EMPTY, EMPTY, EMPTY,

  6476 +    /* 48 */

  6477 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6478 +    EMPTY, EMPTY, EMPTY,

  6479 +

  6480 +    C(-32, 31, 0, CP_W3), E(-1048576, 1048575, 0),

  6481 +

  6482 +    EMPTY, EMPTY, EMPTY,

  6483 +    /* 64: csrfcz */

  6484 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6485 +    E(0, 65535, 0), E(0, 65535, 0),

  6486 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6487 +    E(-32768, 32767, 0),

  6488 +    /* 80: LD_SB2 */

  6489 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6490 +

  6491 +    C(0, 7, 0, LD_UB4), E(-32768, 32767, 0),

  6492 +

  6493 +    EMPTY,

  6494 +    EMPTY, EMPTY,

  6495 +

  6496 +    C(0, 14, 1, LD_SH4), E(-32768, 32767, 0),

  6497 +

  6498 +    EMPTY, EMPTY, EMPTY,

  6499 +

  6500 +    C(0, 14, 1, LD_UH4),

  6501 +

  6502 +    /* 96: LD_UH4 */

  6503 +    E(-32768, 32767, 0),

  6504 +

  6505 +    EMPTY, EMPTY, EMPTY, EMPTY,

  6506 +

  6507 +    C(0, 124, 2, LD_W4), E(-32768, 32767, 0),

  6508 +

  6509 +    E(0, 1020, 2),	/* LDC_D1 */

  6510 +    EMPTY, EMPTY,

  6511 +    E(0, 1020, 2),	/* LDC_W1 */

  6512 +    EMPTY, EMPTY,

  6513 +    E(0, 16380, 2),	/* LDC0_D */

  6514 +    E(0, 16380, 2),	/* LDC0_W */

  6515 +    EMPTY,

  6516 +

  6517 +    /* 112: LDCM_D_PU */

  6518 +    EMPTY, EMPTY, EMPTY,

  6519 +

  6520 +    C(0, 508, 2, LDDPC_EXT), E(-32768, 32767, 0),

  6521 +

  6522 +    EMPTY,EMPTY, EMPTY,

  6523 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6524 +

  6525 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6526 +    /* 134: MACHH_W */

  6527 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6528 +    E(-131072, 131068, 2),	/* MCALL */

  6529 +    E(0, 1020, 2),		/* MFDR */

  6530 +    E(0, 1020, 2),		/* MFSR */

  6531 +    EMPTY, EMPTY,

  6532 +

  6533 +    C(-128, 127, 0, MOV2), E(-1048576, 1048575, 0),

  6534 +

  6535 +    EMPTY, EMPTY, EMPTY,

  6536 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6537 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6538 +

  6539 +    E(-128, 127, 0),		/* MOVEQ2 */

  6540 +    E(-128, 127, 0),		/* MOVNE2 */

  6541 +    E(-128, 127, 0),		/* MOVCC2 */

  6542 +    E(-128, 127, 0),		/* 166: MOVCS2 */

  6543 +    E(-128, 127, 0),		/* MOVGE2 */

  6544 +    E(-128, 127, 0),		/* MOVLT2 */

  6545 +    E(-128, 127, 0),		/* MOVMI2 */

  6546 +    E(-128, 127, 0),		/* MOVPL2 */

  6547 +    E(-128, 127, 0),		/* MOVLS2 */

  6548 +    E(-128, 127, 0),		/* MOVGT2 */

  6549 +    E(-128, 127, 0),		/* MOVLE2 */

  6550 +    E(-128, 127, 0),		/* MOVHI2 */

  6551 +    E(-128, 127, 0),		/* MOVVS2 */

  6552 +    E(-128, 127, 0),		/* MOVVC2 */

  6553 +    E(-128, 127, 0),		/* MOVQS2 */

  6554 +    E(-128, 127, 0),		/* MOVAL2 */

  6555 +

  6556 +    E(0, 1020, 2),		/* MTDR */

  6557 +    E(0, 1020, 2),		/* MTSR */

  6558 +    EMPTY,

  6559 +    EMPTY,

  6560 +    E(-128, 127, 0),		/* MUL3 */

  6561 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6562 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6563 +    /* 198: MVCR_W */

  6564 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6565 +    E(0, 65535, 0), E(0, 65535, 0),

  6566 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6567 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6568 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6569 +    /* 230: PASR_H */

  6570 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6571 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6572 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6573 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6574 +    /* 262: PUNPCKSB_H */

  6575 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6576 +

  6577 +    C(-1024, 1022, 1, RCALL2), E(-2097152, 2097150, 1),

  6578 +

  6579 +    EMPTY,

  6580 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6581 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6582 +    EMPTY, EMPTY, EMPTY,

  6583 +

  6584 +    C(-1024, 1022, 1, BRAL),

  6585 +

  6586 +    EMPTY, EMPTY, EMPTY,

  6587 +    E(-128, 127, 0),		/* RSUB2 */

  6588 +    /* 294: SATADD_H */

  6589 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6590 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6591 +    E(0, 255, 0),		/* SLEEP */

  6592 +    EMPTY, EMPTY,

  6593 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6594 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6595 +    /* 326: ST_B2 */

  6596 +    EMPTY, EMPTY,

  6597 +    C(0, 7, 0, ST_B4), E(-32768, 32767, 0),

  6598 +    EMPTY, EMPTY, EMPTY, EMPTY,

  6599 +    E(-32768, 32767, 0),

  6600 +    EMPTY, EMPTY, EMPTY,

  6601 +    C(0, 14, 1, ST_H4), E(-32768, 32767, 0),

  6602 +    EMPTY, EMPTY,

  6603 +    EMPTY,

  6604 +    C(0, 60, 2, ST_W4), E(-32768, 32767, 0),

  6605 +    E(0, 1020, 2),	/* STC_D1 */

  6606 +    EMPTY, EMPTY,

  6607 +    E(0, 1020, 2),	/* STC_W1 */

  6608 +    EMPTY, EMPTY,

  6609 +    E(0, 16380, 2),	/* STC0_D */

  6610 +    E(0, 16380, 2),	/* STC0_W */

  6611 +

  6612 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6613 +    /* 358: STDSP */

  6614 +    EMPTY, EMPTY,

  6615 +    E(0, 1020, 2),	/* STHH_W1 */

  6616 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6617 +    EMPTY, EMPTY, EMPTY,

  6618 +    E(-32768, 32767, 0),

  6619 +    C(-512, 508, 2, SUB4),

  6620 +    C(-128, 127, 0, SUB4), E(-1048576, 1048576, 0),

  6621 +    /* SUB{cond} */

  6622 +    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),

  6623 +    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),

  6624 +    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),

  6625 +    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),

  6626 +    /* SUBF{cond} */

  6627 +    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),

  6628 +    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),

  6629 +    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),

  6630 +    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),

  6631 +    EMPTY,

  6632 +

  6633 +    /* 406: SWAP_B */

  6634 +    EMPTY, EMPTY, EMPTY,

  6635 +    E(0, 255, 0),	/* SYNC */

  6636 +    EMPTY, EMPTY, EMPTY, EMPTY,

  6637 +    /* 414: TST */

  6638 +    EMPTY, EMPTY, E(-65536, 65535, 2), E(-65536, 65535, 2), E(-65536, 65535, 2), EMPTY, EMPTY, EMPTY,

  6639 +    /* 422: RSUB{cond} */

  6640 +    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),

  6641 +    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),

  6642 +    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),

  6643 +    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),

  6644 +    /* 436: ADD{cond} */

  6645 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6646 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6647 +    /* 454: SUB{cond} */

  6648 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6649 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6650 +    /* 472: AND{cond} */

  6651 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6652 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6653 +    /* 486: OR{cond} */

  6654 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6655 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6656 +    /* 502: EOR{cond} */

  6657 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6658 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6659 +    /* 518: LD.w{cond} */

  6660 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6661 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6662 +    /* 534: LD.sh{cond} */

  6663 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6664 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6665 +    /* 550: LD.uh{cond} */

  6666 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6667 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6668 +    /* 566: LD.sb{cond} */

  6669 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6670 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6671 +    /* 582: LD.ub{cond} */

  6672 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6673 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6674 +    /* 596: ST.w{cond} */

  6675 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6676 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6677 +    /* 614: ST.h{cond} */

  6678 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6679 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6680 +    /* 630: ST.b{cond} */

  6681 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6682 +    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,

  6683 +    /* 646: movh */

  6684 +    E(0, 65535, 0)

  6685 +  };

  6686 +

  6687 +#undef E

  6688 +#undef C

  6689 +#undef EMPTY

  6690 +

  6691 +#define AVR32_RS_NONE (-1)

  6692 +

  6693 +#define avr32_rs_size(state) (avr32_relax_table[(state)].length)

  6694 +#define avr32_rs_align(state) (avr32_relax_table[(state)].align)

  6695 +#define relax_more(state) (avr32_relax_table[(state)].next)

  6696 +

  6697 +#define opc_initial_substate(opc) ((opc)->id)

  6698 +

  6699 +static int need_relax(int subtype, offsetT distance)

  6700 +{

  6701 +  offsetT upper_bound, lower_bound;

  6702 +

  6703 +  upper_bound = avr32_relax_table[subtype].upper_bound;

  6704 +  lower_bound = avr32_relax_table[subtype].lower_bound;

  6705 +

  6706 +  if (distance & ((1 << avr32_rs_align(subtype)) - 1))

  6707 +    return 1;

  6708 +  if ((distance > upper_bound) || (distance < lower_bound))

  6709 +    return 1;

  6710 +

  6711 +  return 0;

  6712 +}

  6713 +

  6714 +enum {

  6715 +  LDA_SUBTYPE_MOV1,

  6716 +  LDA_SUBTYPE_MOV2,

  6717 +  LDA_SUBTYPE_SUB,

  6718 +  LDA_SUBTYPE_LDDPC,

  6719 +  LDA_SUBTYPE_LDW,

  6720 +  LDA_SUBTYPE_GOTLOAD,

  6721 +  LDA_SUBTYPE_GOTLOAD_LARGE,

  6722 +};

  6723 +

  6724 +enum {

  6725 +  CALL_SUBTYPE_RCALL1,

  6726 +  CALL_SUBTYPE_RCALL2,

  6727 +  CALL_SUBTYPE_MCALL_CP,

  6728 +  CALL_SUBTYPE_MCALL_GOT,

  6729 +  CALL_SUBTYPE_MCALL_LARGE,

  6730 +};

  6731 +

  6732 +#define LDA_INITIAL_SIZE	(avr32_pic ? 4 : 2)

  6733 +#define CALL_INITIAL_SIZE	2

  6734 +

  6735 +#define need_reloc(sym, seg, pcrel)					\

  6736 +  (!(S_IS_DEFINED(sym)							\

  6737 +     && ((pcrel && S_GET_SEGMENT(sym) == seg)				\

  6738 +	 || (!pcrel && S_GET_SEGMENT(sym) == absolute_section)))	\

  6739 +   || S_FORCE_RELOC(sym, 1))

  6740 +

  6741 +/* Return an initial guess of the length by which a fragment must grow to

  6742 +   hold a branch to reach its destination.

  6743 +   Also updates fr_type/fr_subtype as necessary.

  6744 +

  6745 +   Called just before doing relaxation.

  6746 +   Any symbol that is now undefined will not become defined.

  6747 +   The guess for fr_var is ACTUALLY the growth beyond fr_fix.

  6748 +   Whatever we do to grow fr_fix or fr_var contributes to our returned value.

  6749 +   Although it may not be explicit in the frag, pretend fr_var starts with a

  6750 +   0 value.  */

  6751 +

  6752 +static int

  6753 +avr32_default_estimate_size_before_relax (fragS *fragP, segT segment)

  6754 +{

  6755 +  int growth = 0;

  6756 +

  6757 +  assert(fragP);

  6758 +  assert(fragP->fr_symbol);

  6759 +

  6760 +  if (fragP->tc_frag_data.force_extended

  6761 +      || need_reloc(fragP->fr_symbol, segment, fragP->tc_frag_data.pcrel))

  6762 +    {

  6763 +      int largest_state = fragP->fr_subtype;

  6764 +      while (relax_more(largest_state) != AVR32_RS_NONE)

  6765 +	largest_state = relax_more(largest_state);

  6766 +      growth = avr32_rs_size(largest_state) - fragP->fr_var;

  6767 +    }

  6768 +  else

  6769 +    {

  6770 +      growth = avr32_rs_size(fragP->fr_subtype) - fragP->fr_var;

  6771 +    }

  6772 +

  6773 +  pr_debug("%s:%d: md_estimate_size_before_relax: %d\n",

  6774 +	   fragP->fr_file, fragP->fr_line, growth);

  6775 +

  6776 +  return growth;

  6777 +}

  6778 +

  6779 +static int

  6780 +avr32_lda_estimate_size_before_relax(fragS *fragP, segT segment ATTRIBUTE_UNUSED)

  6781 +{

  6782 +  return fragP->fr_var - LDA_INITIAL_SIZE;

  6783 +}

  6784 +

  6785 +static int

  6786 +avr32_call_estimate_size_before_relax(fragS *fragP, segT segment ATTRIBUTE_UNUSED)

  6787 +{

  6788 +  return fragP->fr_var - CALL_INITIAL_SIZE;

  6789 +}

  6790 +

  6791 +static int

  6792 +avr32_cpool_estimate_size_before_relax(fragS *fragP,

  6793 +				       segT segment ATTRIBUTE_UNUSED)

  6794 +{

  6795 +  return fragP->fr_var;

  6796 +}

  6797 +

  6798 +/* This macro may be defined to relax a frag. GAS will call this with the

  6799 + * segment, the frag, and the change in size of all previous frags;

  6800 + * md_relax_frag should return the change in size of the frag. */

  6801 +static long

  6802 +avr32_default_relax_frag (segT segment, fragS *fragP, long stretch)

  6803 +{

  6804 +  int state, next_state;

  6805 +  symbolS *symbolP;	/* The target symbol */

  6806 +  long growth = 0;

  6807 +

  6808 +  state = next_state = fragP->fr_subtype;

  6809 +

  6810 +  symbolP = fragP->fr_symbol;

  6811 +

  6812 +  if (fragP->tc_frag_data.force_extended

  6813 +      || need_reloc(symbolP, segment, fragP->tc_frag_data.pcrel))

  6814 +    {

  6815 +      /* Symbol must be resolved by the linker. Emit the largest

  6816 +	 possible opcode. */

  6817 +      while (relax_more(next_state) != AVR32_RS_NONE)

  6818 +	next_state = relax_more(next_state);

  6819 +    }

  6820 +  else

  6821 +    {

  6822 +      addressT address;	/* The address of fragP */

  6823 +      addressT target;	/* The address of the target symbol */

  6824 +      offsetT distance;	/* The distance between the insn and the symbol */

  6825 +      fragS *sym_frag;

  6826 +

  6827 +      address = fragP->fr_address;

  6828 +      target = fragP->fr_offset;

  6829 +      symbolP = fragP->fr_symbol;

  6830 +      sym_frag = symbol_get_frag(symbolP);

  6831 +

  6832 +      address += fragP->fr_fix - fragP->fr_var;

  6833 +      target += S_GET_VALUE(symbolP);

  6834 +

  6835 +      if (stretch != 0

  6836 +	  && sym_frag->relax_marker != fragP->relax_marker

  6837 +	  && S_GET_SEGMENT(symbolP) == segment)

  6838 +	/* if it was correctly aligned before, make sure it stays aligned */

  6839 +	target += stretch & (~0UL << avr32_rs_align(state));

  6840 +

  6841 +      if (fragP->tc_frag_data.pcrel)

  6842 +	distance = target - (address & (~0UL << avr32_rs_align(state)));

  6843 +      else

  6844 +	distance = target;

  6845 +

  6846 +      pr_debug("%s:%d: relax more? 0x%x - 0x%x = 0x%x (%d), align %d\n",

  6847 +	       fragP->fr_file, fragP->fr_line, target, address,

  6848 +	       distance, distance, avr32_rs_align(state));

  6849 +

  6850 +      if (need_relax(state, distance))

  6851 +	{

  6852 +	  if (relax_more(state) != AVR32_RS_NONE)

  6853 +	    next_state = relax_more(state);

  6854 +	  pr_debug("%s:%d: relax more %d -> %d (%d - %d, align %d)\n",

  6855 +		   fragP->fr_file, fragP->fr_line, state, next_state,

  6856 +		   target, address, avr32_rs_align(state));

  6857 +	}

  6858 +    }

  6859 +

  6860 +  growth = avr32_rs_size(next_state) - avr32_rs_size(state);

  6861 +  fragP->fr_subtype = next_state;

  6862 +

  6863 +  pr_debug("%s:%d: md_relax_frag: growth=%d, subtype=%d, opc=0x%08lx\n",

  6864 +	   fragP->fr_file, fragP->fr_line, growth, fragP->fr_subtype,

  6865 +	   avr32_opc_table[next_state].value);

  6866 +

  6867 +  return growth;

  6868 +}

  6869 +

  6870 +static long

  6871 +avr32_lda_relax_frag(segT segment, fragS *fragP, long stretch)

  6872 +{

  6873 +  struct cpool *pool= NULL;

  6874 +  unsigned int entry = 0;

  6875 +  addressT address, target;

  6876 +  offsetT distance;

  6877 +  symbolS *symbolP;

  6878 +  fragS *sym_frag;

  6879 +  long old_size, new_size;

  6880 +

  6881 +  symbolP = fragP->fr_symbol;

  6882 +  old_size = fragP->fr_var;

  6883 +  if (!avr32_pic)

  6884 +    {

  6885 +      pool = fragP->tc_frag_data.pool;

  6886 +      entry = fragP->tc_frag_data.pool_entry;

  6887 +    }

  6888 +

  6889 +  address = fragP->fr_address;

  6890 +  address += fragP->fr_fix - LDA_INITIAL_SIZE;

  6891 +

  6892 +  if (!S_IS_DEFINED(symbolP) || S_FORCE_RELOC(symbolP, 1))

  6893 +    goto relax_max;

  6894 +

  6895 +  target = fragP->fr_offset;

  6896 +  sym_frag = symbol_get_frag(symbolP);

  6897 +  target += S_GET_VALUE(symbolP);

  6898 +

  6899 +  if (sym_frag->relax_marker != fragP->relax_marker

  6900 +      && S_GET_SEGMENT(symbolP) == segment)

  6901 +    target += stretch;

  6902 +

  6903 +  distance = target - address;

  6904 +

  6905 +  pr_debug("lda_relax_frag: target: %d, address: %d, var: %d\n",

  6906 +	   target, address, fragP->fr_var);

  6907 +

  6908 +  if (!avr32_pic && S_GET_SEGMENT(symbolP) == absolute_section

  6909 +      && target <= 127 && (offsetT)target >= -128)

  6910 +    {

  6911 +      if (fragP->fr_subtype == LDA_SUBTYPE_LDDPC

  6912 +	  || fragP->fr_subtype == LDA_SUBTYPE_LDW)

  6913 +	pool->literals[entry].refcount--;

  6914 +      new_size = 2;

  6915 +      fragP->fr_subtype = LDA_SUBTYPE_MOV1;

  6916 +    }

  6917 +  else if (!avr32_pic && S_GET_SEGMENT(symbolP) == absolute_section

  6918 +	   && target <= 1048575 && (offsetT)target >= -1048576)

  6919 +    {

  6920 +      if (fragP->fr_subtype == LDA_SUBTYPE_LDDPC

  6921 +	  || fragP->fr_subtype == LDA_SUBTYPE_LDW)

  6922 +	pool->literals[entry].refcount--;

  6923 +      new_size = 4;

  6924 +      fragP->fr_subtype = LDA_SUBTYPE_MOV2;

  6925 +    }

  6926 +  else if (!linkrelax && S_GET_SEGMENT(symbolP) == segment

  6927 +	   /* the field will be negated, so this is really -(-32768)

  6928 +	      and -(32767) */

  6929 +	   && distance <= 32768 && distance >= -32767)

  6930 +    {

  6931 +      if (!avr32_pic

  6932 +	  && (fragP->fr_subtype == LDA_SUBTYPE_LDDPC

  6933 +	      || fragP->fr_subtype == LDA_SUBTYPE_LDW))

  6934 +	pool->literals[entry].refcount--;

  6935 +      new_size = 4;

  6936 +      fragP->fr_subtype = LDA_SUBTYPE_SUB;

  6937 +    }

  6938 +  else

  6939 +    {

  6940 +    relax_max:

  6941 +      if (avr32_pic)

  6942 +	{

  6943 +	  if (linkrelax)

  6944 +	    {

  6945 +	      new_size = 8;

  6946 +	      fragP->fr_subtype = LDA_SUBTYPE_GOTLOAD_LARGE;

  6947 +	    }

  6948 +	  else

  6949 +	    {

  6950 +	      new_size = 4;

  6951 +	      fragP->fr_subtype = LDA_SUBTYPE_GOTLOAD;

  6952 +	    }

  6953 +	}

  6954 +      else

  6955 +	{

  6956 +	  if (fragP->fr_subtype != LDA_SUBTYPE_LDDPC

  6957 +	      && fragP->fr_subtype != LDA_SUBTYPE_LDW)

  6958 +	    pool->literals[entry].refcount++;

  6959 +

  6960 +	  sym_frag = symbol_get_frag(pool->symbol);

  6961 +	  target = (sym_frag->fr_address + sym_frag->fr_fix

  6962 +		    + pool->padding + pool->literals[entry].offset);

  6963 +

  6964 +	  pr_debug("cpool sym address: 0x%lx\n",

  6965 +		   sym_frag->fr_address + sym_frag->fr_fix);

  6966 +

  6967 +	  know(pool->section == segment);

  6968 +

  6969 +	  if (sym_frag->relax_marker != fragP->relax_marker)

  6970 +	    target += stretch;

  6971 +

  6972 +	  distance = target - address;

  6973 +	  if (distance <= 508 && distance >= 0)

  6974 +	    {

  6975 +	      new_size = 2;

  6976 +	      fragP->fr_subtype = LDA_SUBTYPE_LDDPC;

  6977 +	    }

  6978 +	  else

  6979 +	    {

  6980 +	      new_size = 4;

  6981 +	      fragP->fr_subtype = LDA_SUBTYPE_LDW;

  6982 +	    }

  6983 +

  6984 +	  pr_debug("lda_relax_frag (cpool): target=0x%lx, address=0x%lx, refcount=%d\n",

  6985 +		   target, address, pool->literals[entry].refcount);

  6986 +	}

  6987 +    }

  6988 +

  6989 +  fragP->fr_var = new_size;

  6990 +

  6991 +  pr_debug("%s:%d: lda: relax pass done. subtype: %d, growth: %ld\n",

  6992 +	   fragP->fr_file, fragP->fr_line,

  6993 +	   fragP->fr_subtype, new_size - old_size);

  6994 +

  6995 +  return new_size - old_size;

  6996 +}

  6997 +

  6998 +static long

  6999 +avr32_call_relax_frag(segT segment, fragS *fragP, long stretch)

  7000 +{

  7001 +  struct cpool *pool = NULL;

  7002 +  unsigned int entry = 0;

  7003 +  addressT address, target;

  7004 +  offsetT distance;

  7005 +  symbolS *symbolP;

  7006 +  fragS *sym_frag;

  7007 +  long old_size, new_size;

  7008 +

  7009 +  symbolP = fragP->fr_symbol;

  7010 +  old_size = fragP->fr_var;

  7011 +  if (!avr32_pic)

  7012 +    {

  7013 +      pool = fragP->tc_frag_data.pool;

  7014 +      entry = fragP->tc_frag_data.pool_entry;

  7015 +    }

  7016 +

  7017 +  address = fragP->fr_address;

  7018 +  address += fragP->fr_fix - CALL_INITIAL_SIZE;

  7019 +

  7020 +  if (need_reloc(symbolP, segment, 1))

  7021 +    {

  7022 +      pr_debug("call: must emit reloc\n");

  7023 +      goto relax_max;

  7024 +    }

  7025 +

  7026 +  target = fragP->fr_offset;

  7027 +  sym_frag = symbol_get_frag(symbolP);

  7028 +  target += S_GET_VALUE(symbolP);

  7029 +

  7030 +  if (sym_frag->relax_marker != fragP->relax_marker

  7031 +      && S_GET_SEGMENT(symbolP) == segment)

  7032 +    target += stretch;

  7033 +

  7034 +  distance = target - address;

  7035 +

  7036 +  if (distance <= 1022 && distance >= -1024)

  7037 +    {

  7038 +      pr_debug("call: distance is %d, emitting short rcall\n", distance);

  7039 +      if (!avr32_pic && fragP->fr_subtype == CALL_SUBTYPE_MCALL_CP)

  7040 +	pool->literals[entry].refcount--;

  7041 +      new_size = 2;

  7042 +      fragP->fr_subtype = CALL_SUBTYPE_RCALL1;

  7043 +    }

  7044 +  else if (distance <= 2097150 && distance >= -2097152)

  7045 +    {

  7046 +      pr_debug("call: distance is %d, emitting long rcall\n", distance);

  7047 +      if (!avr32_pic && fragP->fr_subtype == CALL_SUBTYPE_MCALL_CP)

  7048 +	pool->literals[entry].refcount--;

  7049 +      new_size = 4;

  7050 +      fragP->fr_subtype = CALL_SUBTYPE_RCALL2;

  7051 +    }

  7052 +  else

  7053 +    {

  7054 +      pr_debug("call: distance %d too far, emitting something big\n", distance);

  7055 +

  7056 +    relax_max:

  7057 +      if (avr32_pic)

  7058 +	{

  7059 +	  if (linkrelax)

  7060 +	    {

  7061 +	      new_size = 10;

  7062 +	      fragP->fr_subtype = CALL_SUBTYPE_MCALL_LARGE;

  7063 +	    }

  7064 +	  else

  7065 +	    {

  7066 +	      new_size = 4;

  7067 +	      fragP->fr_subtype = CALL_SUBTYPE_MCALL_GOT;

  7068 +	    }

  7069 +	}

  7070 +      else

  7071 +	{

  7072 +	  if (fragP->fr_subtype != CALL_SUBTYPE_MCALL_CP)

  7073 +	    pool->literals[entry].refcount++;

  7074 +

  7075 +	  new_size = 4;

  7076 +	  fragP->fr_subtype = CALL_SUBTYPE_MCALL_CP;

  7077 +	}

  7078 +    }

  7079 +

  7080 +  fragP->fr_var = new_size;

  7081 +

  7082 +  pr_debug("%s:%d: call: relax pass done, growth: %d, fr_var: %d\n",

  7083 +	   fragP->fr_file, fragP->fr_line,

  7084 +	   new_size - old_size, fragP->fr_var);

  7085 +

  7086 +  return new_size - old_size;

  7087 +}

  7088 +

  7089 +static long

  7090 +avr32_cpool_relax_frag(segT segment ATTRIBUTE_UNUSED,

  7091 +		       fragS *fragP,

  7092 +		       long stretch ATTRIBUTE_UNUSED)

  7093 +{

  7094 +  struct cpool *pool;

  7095 +  addressT address;

  7096 +  long old_size, new_size;

  7097 +  unsigned int entry;

  7098 +

  7099 +  pool = fragP->tc_frag_data.pool;

  7100 +  address = fragP->fr_address + fragP->fr_fix;

  7101 +  old_size = fragP->fr_var;

  7102 +  new_size = 0;

  7103 +

  7104 +  for (entry = 0; entry < pool->next_free_entry; entry++)

  7105 +    {

  7106 +      if (pool->literals[entry].refcount > 0)

  7107 +	{

  7108 +	  pool->literals[entry].offset = new_size;

  7109 +	  new_size += 4;

  7110 +	}

  7111 +    }

  7112 +

  7113 +  fragP->fr_var = new_size;

  7114 +

  7115 +  return new_size - old_size;

  7116 +}

  7117 +

  7118 +/* *fragP has been relaxed to its final size, and now needs to have

  7119 +   the bytes inside it modified to conform to the new size.

  7120 +

  7121 +   Called after relaxation is finished.

  7122 +   fragP->fr_type == rs_machine_dependent.

  7123 +   fragP->fr_subtype is the subtype of what the address relaxed to.  */

  7124 +

  7125 +static void

  7126 +avr32_default_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,

  7127 +			    segT segment ATTRIBUTE_UNUSED,

  7128 +			    fragS *fragP)

  7129 +{

  7130 +  const struct avr32_opcode *opc;

  7131 +  const struct avr32_ifield *ifield;

  7132 +  bfd_reloc_code_real_type r_type;

  7133 +  symbolS *symbolP;

  7134 +  fixS *fixP;

  7135 +  bfd_vma value;

  7136 +  int subtype;

  7137 +

  7138 +  opc = &avr32_opc_table[fragP->fr_subtype];

  7139 +  ifield = opc->fields[opc->var_field];

  7140 +  symbolP = fragP->fr_symbol;

  7141 +  subtype = fragP->fr_subtype;

  7142 +  r_type = opc->reloc_type;

  7143 +

  7144 +  /* Clear the opcode bits and the bits belonging to the relaxed

  7145 +     field.  We assume all other fields stay the same.  */

  7146 +  value = bfd_getb32(fragP->fr_opcode);

  7147 +  value &= ~(opc->mask | ifield->mask);

  7148 +

  7149 +  /* Insert the new opcode */

  7150 +  value |= opc->value;

  7151 +  bfd_putb32(value, fragP->fr_opcode);

  7152 +

  7153 +  fragP->fr_fix += opc->size - fragP->fr_var;

  7154 +

  7155 +  if (fragP->tc_frag_data.reloc_info != AVR32_OPINFO_NONE)

  7156 +    {

  7157 +      switch (fragP->tc_frag_data.reloc_info)

  7158 +	{

  7159 +	case AVR32_OPINFO_HI:

  7160 +	  r_type = BFD_RELOC_HI16;

  7161 +	  break;

  7162 +	case AVR32_OPINFO_LO:

  7163 +	  r_type = BFD_RELOC_LO16;

  7164 +	  break;

  7165 +	case AVR32_OPINFO_GOT:

  7166 +	  switch (r_type)

  7167 +	    {

  7168 +	    case BFD_RELOC_AVR32_18W_PCREL:

  7169 +	      r_type = BFD_RELOC_AVR32_GOT18SW;

  7170 +	      break;

  7171 +	    case BFD_RELOC_AVR32_16S:

  7172 +	      r_type = BFD_RELOC_AVR32_GOT16S;

  7173 +	      break;

  7174 +	    default:

  7175 +	      BAD_CASE(r_type);

  7176 +	      break;

  7177 +	    }

  7178 +	  break;

  7179 +	default:

  7180 +	  BAD_CASE(fragP->tc_frag_data.reloc_info);

  7181 +	  break;

  7182 +	}

  7183 +    }

  7184 +

  7185 +  pr_debug("%s:%d: convert_frag: new %s fixup\n",

  7186 +	   fragP->fr_file, fragP->fr_line,

  7187 +	   bfd_get_reloc_code_name(r_type));

  7188 +

  7189 +#if 1

  7190 +  fixP = fix_new_exp(fragP, fragP->fr_fix - opc->size, opc->size,

  7191 +		     &fragP->tc_frag_data.exp,

  7192 +		     fragP->tc_frag_data.pcrel, r_type);

  7193 +#else

  7194 +  fixP = fix_new(fragP, fragP->fr_fix - opc->size, opc->size, symbolP,

  7195 +		 fragP->fr_offset, fragP->tc_frag_data.pcrel, r_type);

  7196 +#endif

  7197 +

  7198 +  /* Revert fix_new brain damage. "dot_value" is the value of PC at

  7199 +     the point of the fixup, relative to the frag address.  fix_new()

  7200 +     and friends think they are only being called during the assembly

  7201 +     pass, not during relaxation or similar, so fx_dot_value, fx_file

  7202 +     and fx_line are all initialized to the wrong value.  But we don't

  7203 +     know the size of the fixup until now, so we really can't live up

  7204 +     to the assumptions these functions make about the target.  What

  7205 +     do these functions think the "where" and "frag" argument mean

  7206 +     anyway?  */

  7207 +  fixP->fx_dot_value = fragP->fr_fix - opc->size;

  7208 +  fixP->fx_file = fragP->fr_file;

  7209 +  fixP->fx_line = fragP->fr_line;

  7210 +

  7211 +  fixP->tc_fix_data.ifield = ifield;

  7212 +  fixP->tc_fix_data.align = avr32_rs_align(subtype);

  7213 +  fixP->tc_fix_data.min = avr32_relax_table[subtype].lower_bound;

  7214 +  fixP->tc_fix_data.max = avr32_relax_table[subtype].upper_bound;

  7215 +}

  7216 +

  7217 +static void

  7218 +avr32_lda_convert_frag(bfd *abfd ATTRIBUTE_UNUSED,

  7219 +		       segT segment ATTRIBUTE_UNUSED,

  7220 +		       fragS *fragP)

  7221 +{

  7222 +  const struct avr32_opcode *opc;

  7223 +  const struct avr32_ifield *ifield;

  7224 +  bfd_reloc_code_real_type r_type;

  7225 +  expressionS exp;

  7226 +  struct cpool *pool;

  7227 +  fixS *fixP;

  7228 +  bfd_vma value;

  7229 +  int regid, pcrel = 0, align = 0;

  7230 +  char *p;

  7231 +

  7232 +  r_type = BFD_RELOC_NONE;

  7233 +  regid = fragP->tc_frag_data.reloc_info;

  7234 +  p = fragP->fr_opcode;

  7235 +  exp.X_add_symbol = fragP->fr_symbol;

  7236 +  exp.X_add_number = fragP->fr_offset;

  7237 +  exp.X_op = O_symbol;

  7238 +

  7239 +  pr_debug("%s:%d: lda_convert_frag, subtype: %d, fix: %d, var: %d, regid: %d\n",

  7240 +	   fragP->fr_file, fragP->fr_line,

  7241 +	   fragP->fr_subtype, fragP->fr_fix, fragP->fr_var, regid);

  7242 +

  7243 +  switch (fragP->fr_subtype)

  7244 +    {

  7245 +    case LDA_SUBTYPE_MOV1:

  7246 +      opc = &avr32_opc_table[AVR32_OPC_MOV1];

  7247 +      opc->fields[0]->insert(opc->fields[0], p, regid);

  7248 +      ifield = opc->fields[1];

  7249 +      r_type = opc->reloc_type;

  7250 +      break;

  7251 +    case LDA_SUBTYPE_MOV2:

  7252 +      opc = &avr32_opc_table[AVR32_OPC_MOV2];

  7253 +      opc->fields[0]->insert(opc->fields[0], p, regid);

  7254 +      ifield = opc->fields[1];

  7255 +      r_type = opc->reloc_type;

  7256 +      break;

  7257 +    case LDA_SUBTYPE_SUB:

  7258 +      opc = &avr32_opc_table[AVR32_OPC_SUB5];

  7259 +      opc->fields[0]->insert(opc->fields[0], p, regid);

  7260 +      opc->fields[1]->insert(opc->fields[1], p, AVR32_REG_PC);

  7261 +      ifield = opc->fields[2];

  7262 +      r_type = BFD_RELOC_AVR32_16N_PCREL;

  7263 +

  7264 +      /* Pretend that SUB5 isn't a "negated" pcrel expression for now.

  7265 +	 We'll have to fix it up later when we know whether to

  7266 +	 generate a reloc for it (in which case the linker will negate

  7267 +	 it, so we shouldn't). */

  7268 +      pcrel = 1;

  7269 +      break;

  7270 +    case LDA_SUBTYPE_LDDPC:

  7271 +      opc = &avr32_opc_table[AVR32_OPC_LDDPC];

  7272 +      align = 2;

  7273 +      r_type = BFD_RELOC_AVR32_9W_CP;

  7274 +      goto cpool_common;

  7275 +    case LDA_SUBTYPE_LDW:

  7276 +      opc = &avr32_opc_table[AVR32_OPC_LDDPC_EXT];

  7277 +      r_type = BFD_RELOC_AVR32_16_CP;

  7278 +    cpool_common:

  7279 +      opc->fields[0]->insert(opc->fields[0], p, regid);

  7280 +      ifield = opc->fields[1];

  7281 +      pool = fragP->tc_frag_data.pool;

  7282 +      exp.X_add_symbol = pool->symbol;

  7283 +      exp.X_add_number = pool->literals[fragP->tc_frag_data.pool_entry].offset;

  7284 +      pcrel = 1;

  7285 +      break;

  7286 +    case LDA_SUBTYPE_GOTLOAD_LARGE:

  7287 +      /* ld.w Rd, r6[Rd << 2] (last) */

  7288 +      opc = &avr32_opc_table[AVR32_OPC_LD_W5];

  7289 +      bfd_putb32(opc->value, p + 4);

  7290 +      opc->fields[0]->insert(opc->fields[0], p + 4, regid);

  7291 +      opc->fields[1]->insert(opc->fields[1], p + 4, 6);

  7292 +      opc->fields[2]->insert(opc->fields[2], p + 4, regid);

  7293 +      opc->fields[3]->insert(opc->fields[3], p + 4, 2);

  7294 +

  7295 +      /* mov Rd, (got_offset / 4) */

  7296 +      opc = &avr32_opc_table[AVR32_OPC_MOV2];

  7297 +      opc->fields[0]->insert(opc->fields[0], p, regid);

  7298 +      ifield = opc->fields[1];

  7299 +      r_type = BFD_RELOC_AVR32_LDA_GOT;

  7300 +      break;

  7301 +    case LDA_SUBTYPE_GOTLOAD:

  7302 +      opc = &avr32_opc_table[AVR32_OPC_LD_W4];

  7303 +      opc->fields[0]->insert(opc->fields[0], p, regid);

  7304 +      opc->fields[1]->insert(opc->fields[1], p, 6);

  7305 +      ifield = opc->fields[2];

  7306 +      if (r_type == BFD_RELOC_NONE)

  7307 +	r_type = BFD_RELOC_AVR32_GOT16S;

  7308 +      break;

  7309 +    default:

  7310 +      BAD_CASE(fragP->fr_subtype);

  7311 +    }

  7312 +

  7313 +  value = bfd_getb32(p);

  7314 +  value &= ~(opc->mask | ifield->mask);

  7315 +  value |= opc->value;

  7316 +  bfd_putb32(value, p);

  7317 +

  7318 +  fragP->fr_fix += fragP->fr_var - LDA_INITIAL_SIZE;

  7319 +

  7320 +  if (fragP->fr_next

  7321 +      && ((offsetT)(fragP->fr_next->fr_address - fragP->fr_address)

  7322 +	  != fragP->fr_fix))

  7323 +    {

  7324 +      fprintf(stderr, "LDA frag: fr_fix is wrong! fragP->fr_var = %ld, r_type = %s\n",

  7325 +	      fragP->fr_var, bfd_get_reloc_code_name(r_type));

  7326 +      abort();

  7327 +    }

  7328 +

  7329 +  fixP = fix_new_exp(fragP, fragP->fr_fix - fragP->fr_var, fragP->fr_var,

  7330 +		     &exp, pcrel, r_type);

  7331 +

  7332 +  /* Revert fix_new brain damage. "dot_value" is the value of PC at

  7333 +     the point of the fixup, relative to the frag address.  fix_new()

  7334 +     and friends think they are only being called during the assembly

  7335 +     pass, not during relaxation or similar, so fx_dot_value, fx_file

  7336 +     and fx_line are all initialized to the wrong value.  But we don't

  7337 +     know the size of the fixup until now, so we really can't live up

  7338 +     to the assumptions these functions make about the target.  What

  7339 +     do these functions think the "where" and "frag" argument mean

  7340 +     anyway?  */

  7341 +  fixP->fx_dot_value = fragP->fr_fix - opc->size;

  7342 +  fixP->fx_file = fragP->fr_file;

  7343 +  fixP->fx_line = fragP->fr_line;

  7344 +

  7345 +  fixP->tc_fix_data.ifield = ifield;

  7346 +  fixP->tc_fix_data.align = align;

  7347 +  /* these are only used if the fixup can actually be resolved */

  7348 +  fixP->tc_fix_data.min = -32768;

  7349 +  fixP->tc_fix_data.max = 32767;

  7350 +}

  7351 +

  7352 +static void

  7353 +avr32_call_convert_frag(bfd *abfd ATTRIBUTE_UNUSED,

  7354 +		       segT segment ATTRIBUTE_UNUSED,

  7355 +		       fragS *fragP)

  7356 +{

  7357 +  const struct avr32_opcode *opc = NULL;

  7358 +  const struct avr32_ifield *ifield;

  7359 +  bfd_reloc_code_real_type r_type;

  7360 +  symbolS *symbol;

  7361 +  offsetT offset;

  7362 +  fixS *fixP;

  7363 +  bfd_vma value;

  7364 +  int pcrel = 0, align = 0;

  7365 +  char *p;

  7366 +

  7367 +  symbol = fragP->fr_symbol;

  7368 +  offset = fragP->fr_offset;

  7369 +  r_type = BFD_RELOC_NONE;

  7370 +  p = fragP->fr_opcode;

  7371 +

  7372 +  pr_debug("%s:%d: call_convert_frag, subtype: %d, fix: %d, var: %d\n",

  7373 +	   fragP->fr_file, fragP->fr_line,

  7374 +	   fragP->fr_subtype, fragP->fr_fix, fragP->fr_var);

  7375 +

  7376 +  switch (fragP->fr_subtype)

  7377 +    {

  7378 +    case CALL_SUBTYPE_RCALL1:

  7379 +      opc = &avr32_opc_table[AVR32_OPC_RCALL1];

  7380 +      /* fall through */

  7381 +    case CALL_SUBTYPE_RCALL2:

  7382 +      if (!opc)

  7383 +	opc = &avr32_opc_table[AVR32_OPC_RCALL2];

  7384 +      ifield = opc->fields[0];

  7385 +      r_type = opc->reloc_type;

  7386 +      pcrel = 1;

  7387 +      align = 1;

  7388 +      break;

  7389 +    case CALL_SUBTYPE_MCALL_CP:

  7390 +      opc = &avr32_opc_table[AVR32_OPC_MCALL];

  7391 +      opc->fields[0]->insert(opc->fields[0], p, AVR32_REG_PC);

  7392 +      ifield = opc->fields[1];

  7393 +      r_type = BFD_RELOC_AVR32_CPCALL;

  7394 +      symbol = fragP->tc_frag_data.pool->symbol;

  7395 +      offset = fragP->tc_frag_data.pool->literals[fragP->tc_frag_data.pool_entry].offset;

  7396 +      assert(fragP->tc_frag_data.pool->literals[fragP->tc_frag_data.pool_entry].refcount > 0);

  7397 +      pcrel = 1;

  7398 +      align = 2;

  7399 +      break;

  7400 +    case CALL_SUBTYPE_MCALL_GOT:

  7401 +      opc = &avr32_opc_table[AVR32_OPC_MCALL];

  7402 +      opc->fields[0]->insert(opc->fields[0], p, 6);

  7403 +      ifield = opc->fields[1];

  7404 +      r_type = BFD_RELOC_AVR32_GOT18SW;

  7405 +      break;

  7406 +    case CALL_SUBTYPE_MCALL_LARGE:

  7407 +      assert(fragP->fr_var == 10);

  7408 +      /* ld.w lr, r6[lr << 2] */

  7409 +      opc = &avr32_opc_table[AVR32_OPC_LD_W5];

  7410 +      bfd_putb32(opc->value, p + 4);

  7411 +      opc->fields[0]->insert(opc->fields[0], p + 4, AVR32_REG_LR);

  7412 +      opc->fields[1]->insert(opc->fields[1], p + 4, 6);

  7413 +      opc->fields[2]->insert(opc->fields[2], p + 4, AVR32_REG_LR);

  7414 +      opc->fields[3]->insert(opc->fields[3], p + 4, 2);

  7415 +

  7416 +      /* icall lr */

  7417 +      opc = &avr32_opc_table[AVR32_OPC_ICALL];

  7418 +      bfd_putb16(opc->value >> 16, p + 8);

  7419 +      opc->fields[0]->insert(opc->fields[0], p + 8, AVR32_REG_LR);

  7420 +

  7421 +      /* mov lr, (got_offset / 4) */

  7422 +      opc = &avr32_opc_table[AVR32_OPC_MOV2];

  7423 +      opc->fields[0]->insert(opc->fields[0], p, AVR32_REG_LR);

  7424 +      ifield = opc->fields[1];

  7425 +      r_type = BFD_RELOC_AVR32_GOTCALL;

  7426 +      break;

  7427 +    default:

  7428 +      BAD_CASE(fragP->fr_subtype);

  7429 +    }

  7430 +

  7431 +  /* Insert the opcode and clear the variable ifield */

  7432 +  value = bfd_getb32(p);

  7433 +  value &= ~(opc->mask | ifield->mask);

  7434 +  value |= opc->value;

  7435 +  bfd_putb32(value, p);

  7436 +

  7437 +  fragP->fr_fix += fragP->fr_var - CALL_INITIAL_SIZE;

  7438 +

  7439 +  if (fragP->fr_next

  7440 +      && ((offsetT)(fragP->fr_next->fr_address - fragP->fr_address)

  7441 +	  != fragP->fr_fix))

  7442 +    {

  7443 +      fprintf(stderr, "%s:%d: fr_fix %lu is wrong! fr_var=%lu, r_type=%s\n",

  7444 +	      fragP->fr_file, fragP->fr_line,

  7445 +	      fragP->fr_fix, fragP->fr_var, bfd_get_reloc_code_name(r_type));

  7446 +      fprintf(stderr, "fr_fix should be %ld. next frag is %s:%d\n",

  7447 +	      (offsetT)(fragP->fr_next->fr_address - fragP->fr_address),

  7448 +	      fragP->fr_next->fr_file, fragP->fr_next->fr_line);

  7449 +    }

  7450 +

  7451 +  fixP = fix_new(fragP, fragP->fr_fix - fragP->fr_var, fragP->fr_var,

  7452 +		 symbol, offset, pcrel, r_type);

  7453 +

  7454 +  /* Revert fix_new brain damage. "dot_value" is the value of PC at

  7455 +     the point of the fixup, relative to the frag address.  fix_new()

  7456 +     and friends think they are only being called during the assembly

  7457 +     pass, not during relaxation or similar, so fx_dot_value, fx_file

  7458 +     and fx_line are all initialized to the wrong value.  But we don't

  7459 +     know the size of the fixup until now, so we really can't live up

  7460 +     to the assumptions these functions make about the target.  What

  7461 +     do these functions think the "where" and "frag" argument mean

  7462 +     anyway?  */

  7463 +  fixP->fx_dot_value = fragP->fr_fix - opc->size;

  7464 +  fixP->fx_file = fragP->fr_file;

  7465 +  fixP->fx_line = fragP->fr_line;

  7466 +

  7467 +  fixP->tc_fix_data.ifield = ifield;

  7468 +  fixP->tc_fix_data.align = align;

  7469 +  /* these are only used if the fixup can actually be resolved */

  7470 +  fixP->tc_fix_data.min = -2097152;

  7471 +  fixP->tc_fix_data.max = 2097150;

  7472 +}

  7473 +

  7474 +static void

  7475 +avr32_cpool_convert_frag(bfd *abfd ATTRIBUTE_UNUSED,

  7476 +			 segT segment ATTRIBUTE_UNUSED,

  7477 +			 fragS *fragP)

  7478 +{

  7479 +  struct cpool *pool;

  7480 +  addressT address;

  7481 +  unsigned int entry;

  7482 +  char *p;

  7483 +  char sym_name[20];

  7484 +

  7485 +  /* Did we get rid of the frag altogether? */

  7486 +  if (!fragP->fr_var)

  7487 +    return;

  7488 +

  7489 +  pool = fragP->tc_frag_data.pool;

  7490 +  address = fragP->fr_address + fragP->fr_fix;

  7491 +  p = fragP->fr_literal + fragP->fr_fix;

  7492 +

  7493 +  sprintf(sym_name, "$$cp_\002%x", pool->id);

  7494 +  symbol_locate(pool->symbol, sym_name, pool->section, fragP->fr_fix, fragP);

  7495 +  symbol_table_insert(pool->symbol);

  7496 +

  7497 +  for (entry = 0; entry < pool->next_free_entry; entry++)

  7498 +    {

  7499 +      if (pool->literals[entry].refcount > 0)

  7500 +	{

  7501 +	  fix_new_exp(fragP, fragP->fr_fix, 4, &pool->literals[entry].exp,

  7502 +		      FALSE, BFD_RELOC_AVR32_32_CPENT);

  7503 +	  fragP->fr_fix += 4;

  7504 +	}

  7505 +    }

  7506 +}

  7507 +

  7508 +static struct avr32_relaxer avr32_default_relaxer = {

  7509 +  .estimate_size	= avr32_default_estimate_size_before_relax,

  7510 +  .relax_frag		= avr32_default_relax_frag,

  7511 +  .convert_frag		= avr32_default_convert_frag,

  7512 +};

  7513 +static struct avr32_relaxer avr32_lda_relaxer = {

  7514 +  .estimate_size	= avr32_lda_estimate_size_before_relax,

  7515 +  .relax_frag		= avr32_lda_relax_frag,

  7516 +  .convert_frag		= avr32_lda_convert_frag,

  7517 +};

  7518 +static struct avr32_relaxer avr32_call_relaxer = {

  7519 +  .estimate_size	= avr32_call_estimate_size_before_relax,

  7520 +  .relax_frag		= avr32_call_relax_frag,

  7521 +  .convert_frag		= avr32_call_convert_frag,

  7522 +};

  7523 +static struct avr32_relaxer avr32_cpool_relaxer = {

  7524 +  .estimate_size	= avr32_cpool_estimate_size_before_relax,

  7525 +  .relax_frag		= avr32_cpool_relax_frag,

  7526 +  .convert_frag		= avr32_cpool_convert_frag,

  7527 +};

  7528 +

  7529 +static void s_cpool(int arg ATTRIBUTE_UNUSED)

  7530 +{

  7531 +  struct cpool *pool;

  7532 +  unsigned int max_size;

  7533 +  char *buf;

  7534 +

  7535 +  pool = find_cpool(now_seg, now_subseg);

  7536 +  if (!pool || !pool->symbol || pool->next_free_entry == 0)

  7537 +    return;

  7538 +

  7539 +  /* Make sure the constant pool is properly aligned */

  7540 +  frag_align_code(2, 0);

  7541 +  if (bfd_get_section_alignment(stdoutput, pool->section) < 2)

  7542 +    bfd_set_section_alignment(stdoutput, pool->section, 2);

  7543 +

  7544 +  /* Assume none of the entries are discarded, and that we need the

  7545 +     maximum amount of alignment.  But we're not going to allocate

  7546 +     anything up front. */

  7547 +  max_size = pool->next_free_entry * 4 + 2;

  7548 +  frag_grow(max_size);

  7549 +  buf = frag_more(0);

  7550 +

  7551 +  frag_now->tc_frag_data.relaxer = &avr32_cpool_relaxer;

  7552 +  frag_now->tc_frag_data.pool = pool;

  7553 +

  7554 +  symbol_set_frag(pool->symbol, frag_now);

  7555 +

  7556 +  /* Assume zero initial size, allowing other relaxers to be

  7557 +     optimistic about things.  */

  7558 +  frag_var(rs_machine_dependent, max_size, 0,

  7559 +	   0, pool->symbol, 0, NULL);

  7560 +

  7561 +  /* Mark the pool as empty.  */

  7562 +  pool->used = 1;

  7563 +}

  7564 +

  7565 +/* The location from which a PC relative jump should be calculated,

  7566 +   given a PC relative reloc.  */

  7567 +

  7568 +long

  7569 +md_pcrel_from_section (fixS *fixP, segT sec)

  7570 +{

  7571 +  pr_debug("pcrel_from_section, fx_offset = %d\n", fixP->fx_offset);

  7572 +

  7573 +  if (fixP->fx_addsy != NULL

  7574 +      && (! S_IS_DEFINED (fixP->fx_addsy)

  7575 +          || S_GET_SEGMENT (fixP->fx_addsy) != sec

  7576 +	  || S_FORCE_RELOC(fixP->fx_addsy, 1)))

  7577 +    {

  7578 +      pr_debug("Unknown pcrel symbol: %s\n", S_GET_NAME(fixP->fx_addsy));

  7579 +

  7580 +      /* The symbol is undefined (or is defined but not in this section).

  7581 +	 Let the linker figure it out.  */

  7582 +      return 0;

  7583 +    }

  7584 +

  7585 +  pr_debug("pcrel from %x + %x, symbol: %s (%x)\n",

  7586 +	   fixP->fx_frag->fr_address, fixP->fx_where,

  7587 +	   fixP->fx_addsy?S_GET_NAME(fixP->fx_addsy):"(null)",

  7588 +	   fixP->fx_addsy?S_GET_VALUE(fixP->fx_addsy):0);

  7589 +

  7590 +  return ((fixP->fx_frag->fr_address + fixP->fx_where)

  7591 +	  & (~0UL << fixP->tc_fix_data.align));

  7592 +}

  7593 +

  7594 +valueT

  7595 +md_section_align (segT segment, valueT size)

  7596 +{

  7597 +  int align = bfd_get_section_alignment (stdoutput, segment);

  7598 +  return ((size + (1 << align) - 1) & (-1 << align));

  7599 +}

  7600 +

  7601 +static int syntax_matches(const struct avr32_syntax *syntax,

  7602 +			  char *str)

  7603 +{

  7604 +  int i;

  7605 +

  7606 +  pr_debug("syntax %d matches `%s'?\n", syntax->id, str);

  7607 +

  7608 +  if (syntax->nr_operands < 0)

  7609 +    {

  7610 +      struct avr32_operand *op;

  7611 +      int optype;

  7612 +

  7613 +      for (i = 0; i < (-syntax->nr_operands - 1); i++)

  7614 +	{

  7615 +	  char *p;

  7616 +	  char c;

  7617 +

  7618 +	  optype = syntax->operand[i];

  7619 +	  assert(optype < AVR32_NR_OPERANDS);

  7620 +	  op = &avr32_operand_table[optype];

  7621 +

  7622 +	  for (p = str; *p; p++)

  7623 +	    if (*p == ',')

  7624 +	      break;

  7625 +

  7626 +	  if (p == str)

  7627 +	    return 0;

  7628 +

  7629 +	  c = *p;

  7630 +	  *p = 0;

  7631 +

  7632 +	  if (!op->match(str))

  7633 +	    {

  7634 +	      *p = c;

  7635 +	      return 0;

  7636 +	    }

  7637 +

  7638 +	  str = p;

  7639 +	  *p = c;

  7640 +	  if (c)

  7641 +	    str++;

  7642 +	}

  7643 +

  7644 +      optype = syntax->operand[i];

  7645 +      assert(optype < AVR32_NR_OPERANDS);

  7646 +      op = &avr32_operand_table[optype];

  7647 +

  7648 +      if (!op->match(str))

  7649 +	return 0;

  7650 +      return 1;

  7651 +    }

  7652 +

  7653 +  for (i = 0; i < syntax->nr_operands; i++)

  7654 +    {

  7655 +      struct avr32_operand *op;

  7656 +      int optype = syntax->operand[i];

  7657 +      char *p;

  7658 +      char c;

  7659 +

  7660 +      assert(optype < AVR32_NR_OPERANDS);

  7661 +      op = &avr32_operand_table[optype];

  7662 +

  7663 +      for (p = str; *p; p++)

  7664 +	if (*p == ',')

  7665 +	  break;

  7666 +

  7667 +      if (p == str)

  7668 +	return 0;

  7669 +

  7670 +      c = *p;

  7671 +      *p = 0;

  7672 +

  7673 +      if (!op->match(str))

  7674 +	{

  7675 +	  *p = c;

  7676 +	  return 0;

  7677 +	}

  7678 +

  7679 +      str = p;

  7680 +      *p = c;

  7681 +      if (c)

  7682 +	str++;

  7683 +    }

  7684 +

  7685 +  if (*str == '\0')

  7686 +    return 1;

  7687 +

  7688 +  if ((*str == 'e' || *str == 'E') && !str[1])

  7689 +    return 1;

  7690 +

  7691 +  return 0;

  7692 +}

  7693 +

  7694 +static int parse_operands(char *str)

  7695 +{

  7696 +  int i;

  7697 +

  7698 +  if (current_insn.syntax->nr_operands < 0)

  7699 +    {

  7700 +      int optype;

  7701 +      struct avr32_operand *op;

  7702 +

  7703 +      for (i = 0; i < (-current_insn.syntax->nr_operands - 1); i++)

  7704 +	{

  7705 +	  char *p;

  7706 +	  char c;

  7707 +

  7708 +	  optype = current_insn.syntax->operand[i];

  7709 +	  op = &avr32_operand_table[optype];

  7710 +

  7711 +	  for (p = str; *p; p++)

  7712 +	    if (*p == ',')

  7713 +	      break;

  7714 +

  7715 +	  assert(p != str);

  7716 +

  7717 +	  c = *p, *p = 0;

  7718 +	  op->parse(op, str, i);

  7719 +	  *p = c;

  7720 +

  7721 +	  str = p;

  7722 +	  if (c) str++;

  7723 +	}

  7724 +

  7725 +      /* give the rest of the line to the last operand */

  7726 +      optype = current_insn.syntax->operand[i];

  7727 +      op = &avr32_operand_table[optype];

  7728 +      op->parse(op, str, i);

  7729 +    }

  7730 +  else

  7731 +    {

  7732 +      for (i = 0; i < current_insn.syntax->nr_operands; i++)

  7733 +	{

  7734 +	  int optype = current_insn.syntax->operand[i];

  7735 +	  struct avr32_operand *op = &avr32_operand_table[optype];

  7736 +	  char *p;

  7737 +	  char c;

  7738 +

  7739 +	  skip_whitespace(str);

  7740 +

  7741 +	  for (p = str; *p; p++)

  7742 +	    if (*p == ',')

  7743 +	      break;

  7744 +

  7745 +	  assert(p != str);

  7746 +

  7747 +	  c = *p, *p = 0;

  7748 +	  op->parse(op, str, i);

  7749 +	  *p = c;

  7750 +

  7751 +	  str = p;

  7752 +	  if (c) str++;

  7753 +	}

  7754 +

  7755 +      if (*str == 'E' || *str == 'e')

  7756 +	current_insn.force_extended = 1;

  7757 +    }

  7758 +

  7759 +  return 0;

  7760 +}

  7761 +

  7762 +static const char *

  7763 +finish_insn(const struct avr32_opcode *opc)

  7764 +{

  7765 +  expressionS *exp = &current_insn.immediate;

  7766 +  unsigned int i;

  7767 +  int will_relax = 0;

  7768 +  char *buf;

  7769 +

  7770 +  assert(current_insn.next_slot == opc->nr_fields);

  7771 +

  7772 +  pr_debug("%s:%d: finish_insn: trying opcode %d\n",

  7773 +	   frag_now->fr_file, frag_now->fr_line, opc->id);

  7774 +

  7775 +  /* Go through the relaxation stage for all instructions that can

  7776 +     possibly take a symbolic immediate.  The relax code will take

  7777 +     care of range checking and alignment.  */

  7778 +  if (opc->var_field != -1)

  7779 +    {

  7780 +      int substate, largest_substate;

  7781 +      symbolS *sym;

  7782 +      offsetT off;

  7783 +

  7784 +      will_relax = 1;

  7785 +      substate = largest_substate = opc_initial_substate(opc);

  7786 +

  7787 +      while (relax_more(largest_substate) != AVR32_RS_NONE)

  7788 +	largest_substate = relax_more(largest_substate);

  7789 +

  7790 +      pr_debug("will relax. initial substate: %d (size %d), largest substate: %d (size %d)\n",

  7791 +	       substate, avr32_rs_size(substate),

  7792 +	       largest_substate, avr32_rs_size(largest_substate));

  7793 +

  7794 +      /* make sure we have enough room for the largest possible opcode */

  7795 +      frag_grow(avr32_rs_size(largest_substate));

  7796 +      buf = frag_more(opc->size);

  7797 +

  7798 +      dwarf2_emit_insn(opc->size);

  7799 +

  7800 +      frag_now->tc_frag_data.reloc_info = AVR32_OPINFO_NONE;

  7801 +      frag_now->tc_frag_data.pcrel = current_insn.pcrel;

  7802 +      frag_now->tc_frag_data.force_extended = current_insn.force_extended;

  7803 +      frag_now->tc_frag_data.relaxer = &avr32_default_relaxer;

  7804 +

  7805 +      if (exp->X_op == O_hi)

  7806 +	{

  7807 +	  frag_now->tc_frag_data.reloc_info = AVR32_OPINFO_HI;

  7808 +	  exp->X_op = exp->X_md;

  7809 +	}

  7810 +      else if (exp->X_op == O_lo)

  7811 +	{

  7812 +	  frag_now->tc_frag_data.reloc_info = AVR32_OPINFO_LO;

  7813 +	  exp->X_op = exp->X_md;

  7814 +	}

  7815 +      else if (exp->X_op == O_got)

  7816 +	{

  7817 +	  frag_now->tc_frag_data.reloc_info = AVR32_OPINFO_GOT;

  7818 +	  exp->X_op = O_symbol;

  7819 +	}

  7820 +

  7821 +#if 0

  7822 +      if ((opc->reloc_type == BFD_RELOC_AVR32_SUB5)

  7823 +	  && exp->X_op == O_subtract)

  7824 +	{

  7825 +	  symbolS *tmp;

  7826 +	  tmp = exp->X_add_symbol;

  7827 +	  exp->X_add_symbol = exp->X_op_symbol;

  7828 +	  exp->X_op_symbol = tmp;

  7829 +	}

  7830 +#endif

  7831 +

  7832 +      frag_now->tc_frag_data.exp = current_insn.immediate;

  7833 +

  7834 +      sym = exp->X_add_symbol;

  7835 +      off = exp->X_add_number;

  7836 +      if (exp->X_op != O_symbol)

  7837 +	{

  7838 +	  sym = make_expr_symbol(exp);

  7839 +	  off = 0;

  7840 +	}

  7841 +

  7842 +      frag_var(rs_machine_dependent,

  7843 +	       avr32_rs_size(largest_substate) - opc->size,

  7844 +	       opc->size,

  7845 +	       substate, sym, off, buf);

  7846 +    }

  7847 +  else

  7848 +    {

  7849 +      assert(avr32_rs_size(opc_initial_substate(opc)) == 0);

  7850 +

  7851 +      /* Make sure we always have room for another whole word, as the ifield

  7852 +	 inserters can only write words. */

  7853 +      frag_grow(4);

  7854 +      buf = frag_more(opc->size);

  7855 +      dwarf2_emit_insn(opc->size);

  7856 +    }

  7857 +

  7858 +  assert(!(opc->value & ~opc->mask));

  7859 +

  7860 +  pr_debug("inserting opcode: 0x%lx\n", opc->value);

  7861 +  bfd_putb32(opc->value, buf);

  7862 +

  7863 +  for (i = 0; i < opc->nr_fields; i++)

  7864 +    {

  7865 +      const struct avr32_ifield *f = opc->fields[i];

  7866 +      const struct avr32_ifield_data *fd = &current_insn.field_value[i];

  7867 +

  7868 +      pr_debug("inserting field: 0x%lx & 0x%lx\n",

  7869 +	       fd->value >> fd->align_order, f->mask);

  7870 +

  7871 +      f->insert(f, buf, fd->value >> fd->align_order);

  7872 +    }

  7873 +

  7874 +  assert(will_relax || !current_insn.immediate.X_add_symbol);

  7875 +  return NULL;

  7876 +}

  7877 +

  7878 +static const char *

  7879 +finish_alias(const struct avr32_alias *alias)

  7880 +{

  7881 +  const struct avr32_opcode *opc;

  7882 +  struct {

  7883 +    unsigned long value;

  7884 +    unsigned long align;

  7885 +  } mapped_operand[AVR32_MAX_OPERANDS];

  7886 +  unsigned int i;

  7887 +

  7888 +  opc = alias->opc;

  7889 +

  7890 +  /* Remap the operands from the alias to the real opcode */

  7891 +  for (i = 0; i < opc->nr_fields; i++)

  7892 +    {

  7893 +      if (alias->operand_map[i].is_opindex)

  7894 +	{

  7895 +	  struct avr32_ifield_data *fd;

  7896 +	  fd = &current_insn.field_value[alias->operand_map[i].value];

  7897 +	  mapped_operand[i].value = fd->value;

  7898 +	  mapped_operand[i].align = fd->align_order;

  7899 +	}

  7900 +      else

  7901 +	{

  7902 +	  mapped_operand[i].value = alias->operand_map[i].value;

  7903 +	  mapped_operand[i].align = 0;

  7904 +	}

  7905 +    }

  7906 +

  7907 +  for (i = 0; i < opc->nr_fields; i++)

  7908 +    {

  7909 +      current_insn.field_value[i].value = mapped_operand[i].value;

  7910 +      if (opc->id == AVR32_OPC_COP)

  7911 +	current_insn.field_value[i].align_order = 0;

  7912 +      else

  7913 +	current_insn.field_value[i].align_order

  7914 +	  = mapped_operand[i].align;

  7915 +    }

  7916 +

  7917 +  current_insn.next_slot = opc->nr_fields;

  7918 +

  7919 +  return finish_insn(opc);

  7920 +}

  7921 +

  7922 +static const char *

  7923 +finish_lda(const struct avr32_syntax *syntax ATTRIBUTE_UNUSED)

  7924 +{

  7925 +  expressionS *exp = &current_insn.immediate;

  7926 +  relax_substateT initial_subtype;

  7927 +  symbolS *sym;

  7928 +  offsetT off;

  7929 +  int initial_size, max_size;

  7930 +  char *buf;

  7931 +

  7932 +  initial_size = LDA_INITIAL_SIZE;

  7933 +

  7934 +  if (avr32_pic)

  7935 +    {

  7936 +      initial_subtype = LDA_SUBTYPE_SUB;

  7937 +      if (linkrelax)

  7938 +	max_size = 8;

  7939 +      else

  7940 +	max_size = 4;

  7941 +    }

  7942 +  else

  7943 +    {

  7944 +      initial_subtype = LDA_SUBTYPE_MOV1;

  7945 +      max_size = 4;

  7946 +    }

  7947 +

  7948 +  frag_grow(max_size);

  7949 +  buf = frag_more(initial_size);

  7950 +  dwarf2_emit_insn(initial_size);

  7951 +

  7952 +  if (exp->X_op == O_symbol)

  7953 +    {

  7954 +      sym = exp->X_add_symbol;

  7955 +      off = exp->X_add_number;

  7956 +    }

  7957 +  else

  7958 +    {

  7959 +      sym = make_expr_symbol(exp);

  7960 +      off = 0;

  7961 +    }

  7962 +

  7963 +  frag_now->tc_frag_data.reloc_info = current_insn.field_value[0].value;

  7964 +  frag_now->tc_frag_data.relaxer = &avr32_lda_relaxer;

  7965 +

  7966 +  if (!avr32_pic)

  7967 +    {

  7968 +      /* The relaxer will bump the refcount if necessary */

  7969 +      frag_now->tc_frag_data.pool

  7970 +	= add_to_cpool(exp, &frag_now->tc_frag_data.pool_entry, 0);

  7971 +    }

  7972 +

  7973 +  frag_var(rs_machine_dependent, max_size - initial_size,

  7974 +	   initial_size, initial_subtype, sym, off, buf);

  7975 +

  7976 +  return NULL;

  7977 +}

  7978 +

  7979 +static const char *

  7980 +finish_call(const struct avr32_syntax *syntax ATTRIBUTE_UNUSED)

  7981 +{

  7982 +  expressionS *exp = &current_insn.immediate;

  7983 +  symbolS *sym;

  7984 +  offsetT off;

  7985 +  int initial_size, max_size;

  7986 +  char *buf;

  7987 +

  7988 +  initial_size = CALL_INITIAL_SIZE;

  7989 +

  7990 +  if (avr32_pic)

  7991 +    {

  7992 +      if (linkrelax)

  7993 +	max_size = 10;

  7994 +      else

  7995 +	max_size = 4;

  7996 +    }

  7997 +  else

  7998 +    max_size = 4;

  7999 +

  8000 +  frag_grow(max_size);

  8001 +  buf = frag_more(initial_size);

  8002 +  dwarf2_emit_insn(initial_size);

  8003 +

  8004 +  frag_now->tc_frag_data.relaxer = &avr32_call_relaxer;

  8005 +

  8006 +  if (exp->X_op == O_symbol)

  8007 +    {

  8008 +      sym = exp->X_add_symbol;

  8009 +      off = exp->X_add_number;

  8010 +    }

  8011 +  else

  8012 +    {

  8013 +      sym = make_expr_symbol(exp);

  8014 +      off = 0;

  8015 +    }

  8016 +

  8017 +  if (!avr32_pic)

  8018 +    {

  8019 +      /* The relaxer will bump the refcount if necessary */

  8020 +      frag_now->tc_frag_data.pool

  8021 +	= add_to_cpool(exp, &frag_now->tc_frag_data.pool_entry, 0);

  8022 +    }

  8023 +

  8024 +  frag_var(rs_machine_dependent, max_size - initial_size,

  8025 +	   initial_size, CALL_SUBTYPE_RCALL1, sym, off, buf);

  8026 +

  8027 +  return NULL;

  8028 +}

  8029 +

  8030 +void

  8031 +md_begin (void)

  8032 +{

  8033 +  unsigned long flags = 0;

  8034 +  int i;

  8035 +

  8036 +  avr32_mnemonic_htab = hash_new();

  8037 +

  8038 +  if (!avr32_mnemonic_htab)

  8039 +    as_fatal(_("virtual memory exhausted"));

  8040 +

  8041 +  for (i = 0; i < AVR32_NR_MNEMONICS; i++)

  8042 +    {

  8043 +      hash_insert(avr32_mnemonic_htab, avr32_mnemonic_table[i].name,

  8044 +		  (void *)&avr32_mnemonic_table[i]);

  8045 +    }

  8046 +

  8047 +  if (linkrelax)

  8048 +    flags |= EF_AVR32_LINKRELAX;

  8049 +  if (avr32_pic)

  8050 +    flags |= EF_AVR32_PIC;

  8051 +

  8052 +  bfd_set_private_flags(stdoutput, flags);

  8053 +

  8054 +#ifdef OPC_CONSISTENCY_CHECK

  8055 +  if (sizeof(avr32_operand_table)/sizeof(avr32_operand_table[0])

  8056 +      < AVR32_NR_OPERANDS)

  8057 +    as_fatal(_("operand table is incomplete"));

  8058 +

  8059 +  for (i = 0; i < AVR32_NR_OPERANDS; i++)

  8060 +    if (avr32_operand_table[i].id != i)

  8061 +      as_fatal(_("operand table inconsistency found at index %d\n"), i);

  8062 +  pr_debug("%d operands verified\n", AVR32_NR_OPERANDS);

  8063 +

  8064 +  for (i = 0; i < AVR32_NR_IFIELDS; i++)

  8065 +    if (avr32_ifield_table[i].id != i)

  8066 +      as_fatal(_("ifield table inconsistency found at index %d\n"), i);

  8067 +  pr_debug("%d instruction fields verified\n", AVR32_NR_IFIELDS);

  8068 +

  8069 +  for (i = 0; i < AVR32_NR_OPCODES; i++)

  8070 +    {

  8071 +      if (avr32_opc_table[i].id != i)

  8072 +	as_fatal(_("opcode table inconsistency found at index %d\n"), i);

  8073 +      if ((avr32_opc_table[i].var_field == -1

  8074 +	   && avr32_relax_table[i].length != 0)

  8075 +	  || (avr32_opc_table[i].var_field != -1

  8076 +	      && avr32_relax_table[i].length == 0))

  8077 +	as_fatal(_("relax table inconsistency found at index %d\n"), i);

  8078 +    }

  8079 +  pr_debug("%d opcodes verified\n", AVR32_NR_OPCODES);

  8080 +

  8081 +  for (i = 0; i < AVR32_NR_SYNTAX; i++)

  8082 +    if (avr32_syntax_table[i].id != i)

  8083 +      as_fatal(_("syntax table inconsistency found at index %d\n"), i);

  8084 +  pr_debug("%d syntax variants verified\n", AVR32_NR_SYNTAX);

  8085 +

  8086 +  for (i = 0; i < AVR32_NR_ALIAS; i++)

  8087 +    if (avr32_alias_table[i].id != i)

  8088 +      as_fatal(_("alias table inconsistency found at index %d\n"), i);

  8089 +  pr_debug("%d aliases verified\n", AVR32_NR_ALIAS);

  8090 +

  8091 +  for (i = 0; i < AVR32_NR_MNEMONICS; i++)

  8092 +    if (avr32_mnemonic_table[i].id != i)

  8093 +      as_fatal(_("mnemonic table inconsistency found at index %d\n"), i);

  8094 +  pr_debug("%d mnemonics verified\n", AVR32_NR_MNEMONICS);

  8095 +#endif

  8096 +}

  8097 +

  8098 +void

  8099 +md_assemble (char *str)

  8100 +{

  8101 +  struct avr32_mnemonic *mnemonic;

  8102 +  char *p, c;

  8103 +

  8104 +  memset(&current_insn, 0, sizeof(current_insn));

  8105 +  current_insn.immediate.X_op = O_constant;

  8106 +

  8107 +  skip_whitespace(str);

  8108 +  for (p = str; *p; p++)

  8109 +    if (*p == ' ')

  8110 +      break;

  8111 +  c = *p;

  8112 +  *p = 0;

  8113 +

  8114 +  mnemonic = hash_find(avr32_mnemonic_htab, str);

  8115 +  *p = c;

  8116 +  if (c) p++;

  8117 +

  8118 +  if (mnemonic)

  8119 +    {

  8120 +      const struct avr32_syntax *syntax;

  8121 +

  8122 +      for (syntax = mnemonic->syntax; syntax; syntax = syntax->next)

  8123 +	{

  8124 +	  const char *errmsg = NULL;

  8125 +

  8126 +	  if (syntax_matches(syntax, p))

  8127 +	    {

  8128 +	      if (!(syntax->isa_flags & avr32_arch->isa_flags))

  8129 +		{

  8130 +		  as_bad(_("Selected architecture `%s'  does not support `%s'"),

  8131 +			 avr32_arch->name, str);

  8132 +		  return;

  8133 +		}

  8134 +

  8135 +	      current_insn.syntax = syntax;

  8136 +	      parse_operands(p);

  8137 +

  8138 +	      switch (syntax->type)

  8139 +		{

  8140 +		case AVR32_PARSER_NORMAL:

  8141 +		  errmsg = finish_insn(syntax->u.opc);

  8142 +		  break;

  8143 +		case AVR32_PARSER_ALIAS:

  8144 +		  errmsg = finish_alias(syntax->u.alias);

  8145 +		  break;

  8146 +		case AVR32_PARSER_LDA:

  8147 +		  errmsg = finish_lda(syntax);

  8148 +		  break;

  8149 +		case AVR32_PARSER_CALL:

  8150 +		  errmsg = finish_call(syntax);

  8151 +		  break;

  8152 +		default:

  8153 +		  BAD_CASE(syntax->type);

  8154 +		  break;

  8155 +		}

  8156 +

  8157 +	      if (errmsg)

  8158 +		as_bad("%s in `%s'", errmsg, str);

  8159 +

  8160 +	      return;

  8161 +	    }

  8162 +	}

  8163 +

  8164 +      as_bad(_("unrecognized form of instruction: `%s'"), str);

  8165 +    }

  8166 +  else

  8167 +    as_bad(_("unrecognized instruction `%s'"), str);

  8168 +}

  8169 +

  8170 +void avr32_cleanup(void)

  8171 +{

  8172 +  struct cpool *pool;

  8173 +

  8174 +  /* Emit any constant pools that haven't been explicitly flushed with

  8175 +     a .cpool directive. */

  8176 +  for (pool = cpool_list; pool; pool = pool->next)

  8177 +    {

  8178 +      subseg_set(pool->section, pool->sub_section);

  8179 +      s_cpool(0);

  8180 +    }

  8181 +}

  8182 +

  8183 +/* Handle any PIC-related operands in data allocation pseudo-ops */

  8184 +void

  8185 +avr32_cons_fix_new (fragS *frag, int off, int size, expressionS *exp)

  8186 +{

  8187 +  bfd_reloc_code_real_type r_type = BFD_RELOC_UNUSED;

  8188 +  int pcrel = 0;

  8189 +

  8190 +  pr_debug("%s:%u: cons_fix_new, add_sym: %s, op_sym: %s, op: %d, add_num: %d\n",

  8191 +	   frag->fr_file, frag->fr_line,

  8192 +	   exp->X_add_symbol?S_GET_NAME(exp->X_add_symbol):"(none)",

  8193 +	   exp->X_op_symbol?S_GET_NAME(exp->X_op_symbol):"(none)",

  8194 +	   exp->X_op, exp->X_add_number);

  8195 +

  8196 +  if (exp->X_op == O_subtract && exp->X_op_symbol)

  8197 +    {

  8198 +      if (exp->X_op_symbol == GOT_symbol)

  8199 +	{

  8200 +	  if (size != 4)

  8201 +	    goto bad_size;

  8202 +	  r_type = BFD_RELOC_AVR32_GOTPC;

  8203 +	  exp->X_op = O_symbol;

  8204 +	  exp->X_op_symbol = NULL;

  8205 +	}

  8206 +    }

  8207 +  else if (exp->X_op == O_got)

  8208 +    {

  8209 +      switch (size)

  8210 +	{

  8211 +	case 1:

  8212 +	  r_type = BFD_RELOC_AVR32_GOT8;

  8213 +	  break;

  8214 +	case 2:

  8215 +	  r_type = BFD_RELOC_AVR32_GOT16;

  8216 +	  break;

  8217 +	case 4:

  8218 +	  r_type = BFD_RELOC_AVR32_GOT32;

  8219 +	  break;

  8220 +	default:

  8221 +	  goto bad_size;

  8222 +	}

  8223 +

  8224 +      exp->X_op = O_symbol;

  8225 +    }

  8226 +

  8227 +  if (r_type == BFD_RELOC_UNUSED)

  8228 +    switch (size)

  8229 +      {

  8230 +      case 1:

  8231 +	r_type = BFD_RELOC_8;

  8232 +	break;

  8233 +      case 2:

  8234 +	r_type = BFD_RELOC_16;

  8235 +	break;

  8236 +      case 4:

  8237 +	r_type = BFD_RELOC_32;

  8238 +	break;

  8239 +      default:

  8240 +	goto bad_size;

  8241 +      }

  8242 +  else if (size != 4)

  8243 +    {

  8244 +    bad_size:

  8245 +      as_bad(_("unsupported BFD relocation size %u"), size);

  8246 +      r_type = BFD_RELOC_UNUSED;

  8247 +    }

  8248 +

  8249 +  fix_new_exp (frag, off, size, exp, pcrel, r_type);

  8250 +}

  8251 +

  8252 +static void

  8253 +avr32_frob_section(bfd *abfd ATTRIBUTE_UNUSED, segT sec,

  8254 +		   void *ignore ATTRIBUTE_UNUSED)

  8255 +{

  8256 +  segment_info_type *seginfo;

  8257 +  fixS *fix;

  8258 +

  8259 +  seginfo = seg_info(sec);

  8260 +  if (!seginfo)

  8261 +    return;

  8262 +

  8263 +  for (fix = seginfo->fix_root; fix; fix = fix->fx_next)

  8264 +    {

  8265 +      if (fix->fx_done)

  8266 +	continue;

  8267 +

  8268 +      if (fix->fx_r_type == BFD_RELOC_AVR32_SUB5

  8269 +	  && fix->fx_addsy && fix->fx_subsy)

  8270 +	{

  8271 +	  if (S_GET_SEGMENT(fix->fx_addsy) != S_GET_SEGMENT(fix->fx_subsy)

  8272 +	      || linkrelax)

  8273 +	    {

  8274 +	      symbolS *tmp;

  8275 +#ifdef DEBUG

  8276 +	      fprintf(stderr, "Swapping symbols in fixup:\n");

  8277 +	      print_fixup(fix);

  8278 +#endif

  8279 +	      tmp = fix->fx_addsy;

  8280 +	      fix->fx_addsy = fix->fx_subsy;

  8281 +	      fix->fx_subsy = tmp;

  8282 +	      fix->fx_offset = -fix->fx_offset;

  8283 +	    }

  8284 +	}

  8285 +    }

  8286 +}

  8287 +

  8288 +/* We need to look for SUB5 instructions with expressions that will be

  8289 +   made PC-relative and switch fx_addsy with fx_subsy.  This has to be

  8290 +   done before adjustment or the wrong symbol might be adjusted.

  8291 +

  8292 +   This applies to fixups that are a result of expressions like -(sym

  8293 +   - .) and that will make it all the way to md_apply_fix3().  LDA

  8294 +   does the right thing in convert_frag, so we must not convert

  8295 +   those. */

  8296 +void

  8297 +avr32_frob_file(void)

  8298 +{

  8299 +  /* if (1 || !linkrelax)

  8300 +     return; */

  8301 +

  8302 +  bfd_map_over_sections(stdoutput, avr32_frob_section, NULL);

  8303 +}

  8304 +

  8305 +static bfd_boolean

  8306 +convert_to_diff_reloc(fixS *fixP)

  8307 +{

  8308 +  switch (fixP->fx_r_type)

  8309 +    {

  8310 +    case BFD_RELOC_32:

  8311 +      fixP->fx_r_type = BFD_RELOC_AVR32_DIFF32;

  8312 +      break;

  8313 +    case BFD_RELOC_16:

  8314 +      fixP->fx_r_type = BFD_RELOC_AVR32_DIFF16;

  8315 +      break;

  8316 +    case BFD_RELOC_8:

  8317 +      fixP->fx_r_type = BFD_RELOC_AVR32_DIFF8;

  8318 +      break;

  8319 +    default:

  8320 +      return FALSE;

  8321 +    }

  8322 +

  8323 +  return TRUE;

  8324 +}

  8325 +

  8326 +/* Simplify a fixup.  If possible, the fixup is reduced to a single

  8327 +   constant which is written to the output file.  Otherwise, a

  8328 +   relocation is generated so that the linker can take care of the

  8329 +   rest.

  8330 +

  8331 +   ELF relocations have certain constraints: They can only take a

  8332 +   single symbol and a single addend.  This means that for difference

  8333 +   expressions, we _must_ get rid of the fx_subsy symbol somehow.

  8334 +

  8335 +   The difference between two labels in the same section can be

  8336 +   calculated directly unless 'linkrelax' is set, or a relocation is

  8337 +   forced.  If so, we must emit a R_AVR32_DIFFxx relocation.  If there

  8338 +   are addends involved at this point, we must be especially careful

  8339 +   as the relocation must point exactly to the symbol being

  8340 +   subtracted.

  8341 +

  8342 +   When subtracting a symbol defined in the same section as the fixup,

  8343 +   we might be able to convert it to a PC-relative expression, unless

  8344 +   linkrelax is set. If this is the case, there's no way we can make

  8345 +   sure that the difference between the fixup and fx_subsy stays

  8346 +   constant.  So for now, we're just going to disallow that.

  8347 +   */

  8348 +void

  8349 +avr32_process_fixup(fixS *fixP, segT this_segment)

  8350 +{

  8351 +  segT add_symbol_segment = absolute_section;

  8352 +  segT sub_symbol_segment = absolute_section;

  8353 +  symbolS *fx_addsy, *fx_subsy;

  8354 +  offsetT value = 0, fx_offset;

  8355 +  bfd_boolean apply = FALSE;

  8356 +

  8357 +  assert(this_segment != absolute_section);

  8358 +

  8359 +  if (fixP->fx_r_type >= BFD_RELOC_UNUSED)

  8360 +    {

  8361 +      as_bad_where(fixP->fx_file, fixP->fx_line,

  8362 +		   _("Bad relocation type %d\n"), fixP->fx_r_type);

  8363 +      return;

  8364 +    }

  8365 +

  8366 +  /* BFD_RELOC_AVR32_SUB5 fixups have been swapped by avr32_frob_section() */

  8367 +  fx_addsy = fixP->fx_addsy;

  8368 +  fx_subsy = fixP->fx_subsy;

  8369 +  fx_offset = fixP->fx_offset;

  8370 +

  8371 +  if (fx_addsy)

  8372 +    add_symbol_segment = S_GET_SEGMENT(fx_addsy);

  8373 +

  8374 +  if (fx_subsy)

  8375 +    {

  8376 +      resolve_symbol_value(fx_subsy);

  8377 +      sub_symbol_segment = S_GET_SEGMENT(fx_subsy);

  8378 +

  8379 +      if (sub_symbol_segment == this_segment

  8380 +	  && (!linkrelax

  8381 +	      || S_GET_VALUE(fx_subsy) == (fixP->fx_frag->fr_address

  8382 +					   + fixP->fx_where)))

  8383 +	{

  8384 +	  fixP->fx_pcrel = TRUE;

  8385 +	  fx_offset += (fixP->fx_frag->fr_address + fixP->fx_where

  8386 +			- S_GET_VALUE(fx_subsy));

  8387 +	  fx_subsy = NULL;

  8388 +	}

  8389 +      else if (sub_symbol_segment == absolute_section)

  8390 +	{

  8391 +	  /* The symbol is really a constant.  */

  8392 +	  fx_offset -= S_GET_VALUE(fx_subsy);

  8393 +	  fx_subsy = NULL;

  8394 +	}

  8395 +      else if (SEG_NORMAL(add_symbol_segment)

  8396 +	       && sub_symbol_segment == add_symbol_segment

  8397 +	       && (!linkrelax || convert_to_diff_reloc(fixP)))

  8398 +	{

  8399 +	  /* Difference between two labels in the same section.  */

  8400 +	  if (linkrelax)

  8401 +	    {

  8402 +	      /* convert_to_diff() has ensured that the reloc type is

  8403 +		 either DIFF32, DIFF16 or DIFF8.  */

  8404 +	      value = (S_GET_VALUE(fx_addsy) + fixP->fx_offset

  8405 +		       - S_GET_VALUE(fx_subsy));

  8406 +

  8407 +	      /* Try to convert it to a section symbol if possible  */

  8408 +	      if (!S_FORCE_RELOC(fx_addsy, 1)

  8409 +		  && !(sub_symbol_segment->flags & SEC_THREAD_LOCAL))

  8410 +		{

  8411 +		  fx_offset = S_GET_VALUE(fx_subsy);

  8412 +		  fx_addsy = section_symbol(sub_symbol_segment);

  8413 +		}

  8414 +	      else

  8415 +		{

  8416 +		  fx_addsy = fx_subsy;

  8417 +		  fx_offset = 0;

  8418 +		}

  8419 +

  8420 +	      fx_subsy = NULL;

  8421 +	      apply = TRUE;

  8422 +	    }

  8423 +	  else

  8424 +	    {

  8425 +	      fx_offset += S_GET_VALUE(fx_addsy);

  8426 +	      fx_offset -= S_GET_VALUE(fx_subsy);

  8427 +	      fx_addsy = NULL;

  8428 +	      fx_subsy = NULL;

  8429 +	    }

  8430 +	}

  8431 +      else

  8432 +	{

  8433 +	  as_bad_where(fixP->fx_file, fixP->fx_line,

  8434 +		       _("can't resolve `%s' {%s section} - `%s' {%s section}"),

  8435 +		       fx_addsy ? S_GET_NAME (fx_addsy) : "0",

  8436 +		       segment_name (add_symbol_segment),

  8437 +		       S_GET_NAME (fx_subsy),

  8438 +		       segment_name (sub_symbol_segment));

  8439 +	  return;

  8440 +	}

  8441 +    }

  8442 +

  8443 +  if (fx_addsy && !TC_FORCE_RELOCATION(fixP))

  8444 +    {

  8445 +      if (add_symbol_segment == this_segment

  8446 +	  && fixP->fx_pcrel)

  8447 +	{

  8448 +	  value += S_GET_VALUE(fx_addsy);

  8449 +	  value -= md_pcrel_from_section(fixP, this_segment);

  8450 +	  fx_addsy = NULL;

  8451 +	  fixP->fx_pcrel = FALSE;

  8452 +	}

  8453 +      else if (add_symbol_segment == absolute_section)

  8454 +	{

  8455 +	  fx_offset += S_GET_VALUE(fixP->fx_addsy);

  8456 +	  fx_addsy = NULL;

  8457 +	}

  8458 +    }

  8459 +

  8460 +  if (!fx_addsy)

  8461 +    fixP->fx_done = TRUE;

  8462 +

  8463 +  if (fixP->fx_pcrel)

  8464 +    {

  8465 +      if (fx_addsy != NULL

  8466 +	  && S_IS_DEFINED(fx_addsy)

  8467 +	  && S_GET_SEGMENT(fx_addsy) != this_segment)

  8468 +	value += md_pcrel_from_section(fixP, this_segment);

  8469 +

  8470 +      switch (fixP->fx_r_type)

  8471 +	{

  8472 +	case BFD_RELOC_32:

  8473 +	  fixP->fx_r_type = BFD_RELOC_32_PCREL;

  8474 +	  break;

  8475 +	case BFD_RELOC_16:

  8476 +	  fixP->fx_r_type = BFD_RELOC_16_PCREL;

  8477 +	  break;

  8478 +	case BFD_RELOC_8:

  8479 +	  fixP->fx_r_type = BFD_RELOC_8_PCREL;

  8480 +	  break;

  8481 +	case BFD_RELOC_AVR32_SUB5:

  8482 +	  fixP->fx_r_type = BFD_RELOC_AVR32_16N_PCREL;

  8483 +	  break;

  8484 +	case BFD_RELOC_AVR32_16S:

  8485 +	  fixP->fx_r_type = BFD_RELOC_AVR32_16B_PCREL;

  8486 +	  break;

  8487 +	case BFD_RELOC_AVR32_14UW:

  8488 +	  fixP->fx_r_type = BFD_RELOC_AVR32_14UW_PCREL;

  8489 +	  break;

  8490 +	case BFD_RELOC_AVR32_10UW:

  8491 +	  fixP->fx_r_type = BFD_RELOC_AVR32_10UW_PCREL;

  8492 +	  break;

  8493 +	default:

  8494 +	  /* Should have been taken care of already */

  8495 +	  break;

  8496 +	}

  8497 +    }

  8498 +

  8499 +  if (fixP->fx_done || apply)

  8500 +    {

  8501 +      const struct avr32_ifield *ifield;

  8502 +      char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;

  8503 +

  8504 +      if (fixP->fx_done)

  8505 +	value += fx_offset;

  8506 +

  8507 +      /* For hosts with longs bigger than 32-bits make sure that the top

  8508 +         bits of a 32-bit negative value read in by the parser are set,

  8509 +         so that the correct comparisons are made.  */

  8510 +      if (value & 0x80000000)

  8511 +        value |= (-1L << 31);

  8512 +

  8513 +      switch (fixP->fx_r_type)

  8514 +	{

  8515 +	case BFD_RELOC_32:

  8516 +	case BFD_RELOC_16:

  8517 +	case BFD_RELOC_8:

  8518 +	case BFD_RELOC_AVR32_DIFF32:

  8519 +	case BFD_RELOC_AVR32_DIFF16:

  8520 +	case BFD_RELOC_AVR32_DIFF8:

  8521 +	  md_number_to_chars(buf, value, fixP->fx_size);

  8522 +	  break;

  8523 +	case BFD_RELOC_HI16:

  8524 +	  value >>= 16;

  8525 +	case BFD_RELOC_LO16:

  8526 +	  value &= 0xffff;

  8527 +	  md_number_to_chars(buf + 2, value, 2);

  8528 +	  break;

  8529 +	case BFD_RELOC_AVR32_16N_PCREL:

  8530 +	  value = -value;

  8531 +	  /* fall through */

  8532 +	case BFD_RELOC_AVR32_22H_PCREL:

  8533 +	case BFD_RELOC_AVR32_18W_PCREL:

  8534 +	case BFD_RELOC_AVR32_16B_PCREL:

  8535 +	case BFD_RELOC_AVR32_11H_PCREL:

  8536 +	case BFD_RELOC_AVR32_9H_PCREL:

  8537 +	case BFD_RELOC_AVR32_9UW_PCREL:

  8538 +	case BFD_RELOC_AVR32_3U:

  8539 +	case BFD_RELOC_AVR32_4UH:

  8540 +	case BFD_RELOC_AVR32_6UW:

  8541 +	case BFD_RELOC_AVR32_6S:

  8542 +	case BFD_RELOC_AVR32_7UW:

  8543 +	case BFD_RELOC_AVR32_8S_EXT:

  8544 +	case BFD_RELOC_AVR32_8S:

  8545 +	case BFD_RELOC_AVR32_10UW:

  8546 +	case BFD_RELOC_AVR32_10SW:

  8547 +	case BFD_RELOC_AVR32_STHH_W:

  8548 +	case BFD_RELOC_AVR32_14UW:

  8549 +	case BFD_RELOC_AVR32_16S:

  8550 +	case BFD_RELOC_AVR32_16U:

  8551 +	case BFD_RELOC_AVR32_21S:

  8552 +	case BFD_RELOC_AVR32_SUB5:

  8553 +	case BFD_RELOC_AVR32_CPCALL:

  8554 +	case BFD_RELOC_AVR32_16_CP:

  8555 +	case BFD_RELOC_AVR32_9W_CP:

  8556 +	case BFD_RELOC_AVR32_15S:

  8557 +	  ifield = fixP->tc_fix_data.ifield;

  8558 +	  pr_debug("insert field: %ld <= %ld <= %ld (align %u)\n",

  8559 +		   fixP->tc_fix_data.min, value, fixP->tc_fix_data.max,

  8560 +		   fixP->tc_fix_data.align);

  8561 +	  if (value < fixP->tc_fix_data.min || value > fixP->tc_fix_data.max)

  8562 +	    as_bad_where(fixP->fx_file, fixP->fx_line,

  8563 +			 _("operand out of range (%ld not between %ld and %ld)"),

  8564 +			 value, fixP->tc_fix_data.min, fixP->tc_fix_data.max);

  8565 +	  if (value & ((1 << fixP->tc_fix_data.align) - 1))

  8566 +	    as_bad_where(fixP->fx_file, fixP->fx_line,

  8567 +			 _("misaligned operand (required alignment: %d)"),

  8568 +			 1 << fixP->tc_fix_data.align);

  8569 +	  ifield->insert(ifield, buf, value >> fixP->tc_fix_data.align);

  8570 +	  break;

  8571 +	case BFD_RELOC_AVR32_ALIGN:

  8572 +	  /* Nothing to do */

  8573 +	  fixP->fx_done = FALSE;

  8574 +	  break;

  8575 +	default:

  8576 +	  as_fatal("reloc type %s not handled\n",

  8577 +		   bfd_get_reloc_code_name(fixP->fx_r_type));

  8578 +	}

  8579 +    }

  8580 +

  8581 +  fixP->fx_addsy = fx_addsy;

  8582 +  fixP->fx_subsy = fx_subsy;

  8583 +  fixP->fx_offset = fx_offset;

  8584 +

  8585 +  if (!fixP->fx_done)

  8586 +    {

  8587 +      if (!fixP->fx_addsy)

  8588 +	fixP->fx_addsy = abs_section_sym;

  8589 +

  8590 +      symbol_mark_used_in_reloc(fixP->fx_addsy);

  8591 +      if (fixP->fx_subsy)

  8592 +	abort();

  8593 +    }

  8594 +}

  8595 +

  8596 +#if 0

  8597 +void

  8598 +md_apply_fix3 (fixS *fixP, valueT *valP, segT seg)

  8599 +{

  8600 +  const struct avr32_ifield *ifield;

  8601 +  offsetT	value = *valP;

  8602 +  char		*buf = fixP->fx_where + fixP->fx_frag->fr_literal;

  8603 +  bfd_boolean	apply;

  8604 +

  8605 +  pr_debug("%s:%u: apply_fix3: r_type=%d value=%lx offset=%lx\n",

  8606 +	   fixP->fx_file, fixP->fx_line, fixP->fx_r_type, *valP,

  8607 +	   fixP->fx_offset);

  8608 +

  8609 +  if (fixP->fx_r_type >= BFD_RELOC_UNUSED)

  8610 +    {

  8611 +      as_bad_where(fixP->fx_file, fixP->fx_line,

  8612 +		   _("Bad relocation type %d\n"), fixP->fx_r_type);

  8613 +      return;

  8614 +    }

  8615 +

  8616 +  if (!fixP->fx_addsy && !fixP->fx_subsy)

  8617 +    fixP->fx_done = 1;

  8618 +

  8619 +  if (fixP->fx_pcrel)

  8620 +    {

  8621 +      if (fixP->fx_addsy != NULL

  8622 +	  && S_IS_DEFINED(fixP->fx_addsy)

  8623 +	  && S_GET_SEGMENT(fixP->fx_addsy) != seg)

  8624 +	value += md_pcrel_from_section(fixP, seg);

  8625 +

  8626 +      switch (fixP->fx_r_type)

  8627 +	{

  8628 +	case BFD_RELOC_32:

  8629 +	  fixP->fx_r_type = BFD_RELOC_32_PCREL;

  8630 +	  break;

  8631 +	case BFD_RELOC_16:

  8632 +	case BFD_RELOC_8:

  8633 +	  as_bad_where (fixP->fx_file, fixP->fx_line,

  8634 +			_("8- and 16-bit PC-relative relocations not supported"));

  8635 +	  break;

  8636 +	case BFD_RELOC_AVR32_SUB5:

  8637 +	  fixP->fx_r_type = BFD_RELOC_AVR32_PCREL_SUB5;

  8638 +	  break;

  8639 +	case BFD_RELOC_AVR32_16S:

  8640 +	  fixP->fx_r_type = BFD_RELOC_AVR32_16_PCREL;

  8641 +	  break;

  8642 +	default:

  8643 +	  /* Should have been taken care of already */

  8644 +	  break;

  8645 +	}

  8646 +    }

  8647 +

  8648 +  if (fixP->fx_r_type == BFD_RELOC_32

  8649 +      && fixP->fx_subsy)

  8650 +    {

  8651 +      fixP->fx_r_type = BFD_RELOC_AVR32_DIFF32;

  8652 +

  8653 +      /* Offsets are only allowed if it's a result of adjusting a

  8654 +	 local symbol into a section-relative offset.

  8655 +	 tc_fix_adjustable() should prevent any adjustment if there

  8656 +	 was an offset involved before.  */

  8657 +      if (fixP->fx_offset && !symbol_section_p(fixP->fx_addsy))

  8658 +	as_bad_where(fixP->fx_file, fixP->fx_line,

  8659 +		     _("cannot represent symbol difference with an offset"));

  8660 +

  8661 +      value = (S_GET_VALUE(fixP->fx_addsy) + fixP->fx_offset

  8662 +	       - S_GET_VALUE(fixP->fx_subsy));

  8663 +

  8664 +      /* The difference before any relaxing takes place is written

  8665 +	 out, and the DIFF32 reloc identifies the address of the first

  8666 +	 symbol (i.e. the on that's subtracted.)  */

  8667 +      *valP = value;

  8668 +      fixP->fx_offset -= value;

  8669 +      fixP->fx_subsy = NULL;

  8670 +

  8671 +      md_number_to_chars(buf, value, fixP->fx_size);

  8672 +    }

  8673 +

  8674 +  if (fixP->fx_done)

  8675 +    {

  8676 +      switch (fixP->fx_r_type)

  8677 +	{

  8678 +	case BFD_RELOC_8:

  8679 +	case BFD_RELOC_16:

  8680 +	case BFD_RELOC_32:

  8681 +	  md_number_to_chars(buf, value, fixP->fx_size);

  8682 +	  break;

  8683 +	case BFD_RELOC_HI16:

  8684 +	  value >>= 16;

  8685 +	case BFD_RELOC_LO16:

  8686 +	  value &= 0xffff;

  8687 +	  *valP = value;

  8688 +	  md_number_to_chars(buf + 2, value, 2);

  8689 +	  break;

  8690 +	case BFD_RELOC_AVR32_PCREL_SUB5:

  8691 +	  value = -value;

  8692 +	  /* fall through */

  8693 +	case BFD_RELOC_AVR32_9_PCREL:

  8694 +	case BFD_RELOC_AVR32_11_PCREL:

  8695 +	case BFD_RELOC_AVR32_16_PCREL:

  8696 +	case BFD_RELOC_AVR32_18_PCREL:

  8697 +	case BFD_RELOC_AVR32_22_PCREL:

  8698 +	case BFD_RELOC_AVR32_3U:

  8699 +	case BFD_RELOC_AVR32_4UH:

  8700 +	case BFD_RELOC_AVR32_6UW:

  8701 +	case BFD_RELOC_AVR32_6S:

  8702 +	case BFD_RELOC_AVR32_7UW:

  8703 +	case BFD_RELOC_AVR32_8S:

  8704 +	case BFD_RELOC_AVR32_10UW:

  8705 +	case BFD_RELOC_AVR32_10SW:

  8706 +	case BFD_RELOC_AVR32_14UW:

  8707 +	case BFD_RELOC_AVR32_16S:

  8708 +	case BFD_RELOC_AVR32_16U:

  8709 +	case BFD_RELOC_AVR32_21S:

  8710 +	case BFD_RELOC_AVR32_BRC1:

  8711 +	case BFD_RELOC_AVR32_SUB5:

  8712 +	case BFD_RELOC_AVR32_CPCALL:

  8713 +	case BFD_RELOC_AVR32_16_CP:

  8714 +	case BFD_RELOC_AVR32_9_CP:

  8715 +	case BFD_RELOC_AVR32_15S:

  8716 +	  ifield = fixP->tc_fix_data.ifield;

  8717 +	  pr_debug("insert field: %ld <= %ld <= %ld (align %u)\n",

  8718 +		   fixP->tc_fix_data.min, value, fixP->tc_fix_data.max,

  8719 +		   fixP->tc_fix_data.align);

  8720 +	  if (value < fixP->tc_fix_data.min || value > fixP->tc_fix_data.max)

  8721 +	    as_bad_where(fixP->fx_file, fixP->fx_line,

  8722 +			 _("operand out of range (%ld not between %ld and %ld)"),

  8723 +			 value, fixP->tc_fix_data.min, fixP->tc_fix_data.max);

  8724 +	  if (value & ((1 << fixP->tc_fix_data.align) - 1))

  8725 +	    as_bad_where(fixP->fx_file, fixP->fx_line,

  8726 +			 _("misaligned operand (required alignment: %d)"),

  8727 +			 1 << fixP->tc_fix_data.align);

  8728 +	  ifield->insert(ifield, buf, value >> fixP->tc_fix_data.align);

  8729 +	  break;

  8730 +	case BFD_RELOC_AVR32_ALIGN:

  8731 +	  /* Nothing to do */

  8732 +	  fixP->fx_done = FALSE;

  8733 +	  break;

  8734 +	default:

  8735 +	  as_fatal("reloc type %s not handled\n",

  8736 +		   bfd_get_reloc_code_name(fixP->fx_r_type));

  8737 +	}

  8738 +    }

  8739 +}

  8740 +#endif

  8741 +

  8742 +arelent *

  8743 +tc_gen_reloc (asection *section ATTRIBUTE_UNUSED,

  8744 +	      fixS *fixp)

  8745 +{

  8746 +  arelent *reloc;

  8747 +  bfd_reloc_code_real_type code;

  8748 +

  8749 +  reloc = xmalloc (sizeof (arelent));

  8750 +

  8751 +  reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));

  8752 +  *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);

  8753 +  reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;

  8754 +  reloc->addend = fixp->fx_offset;

  8755 +  code = fixp->fx_r_type;

  8756 +

  8757 +  reloc->howto = bfd_reloc_type_lookup (stdoutput, code);

  8758 +

  8759 +  if (reloc->howto == NULL)

  8760 +    {

  8761 +      as_bad_where (fixp->fx_file, fixp->fx_line,

  8762 +		    _("cannot represent relocation %s in this object file format"),

  8763 +		    bfd_get_reloc_code_name (code));

  8764 +      return NULL;

  8765 +    }

  8766 +

  8767 +  return reloc;

  8768 +}

  8769 +

  8770 +bfd_boolean

  8771 +avr32_force_reloc(fixS *fixP)

  8772 +{

  8773 +  if (linkrelax && fixP->fx_addsy

  8774 +      && !(S_GET_SEGMENT(fixP->fx_addsy)->flags & SEC_DEBUGGING)

  8775 +      && S_GET_SEGMENT(fixP->fx_addsy) != absolute_section)

  8776 +    {

  8777 +      pr_debug(stderr, "force reloc: addsy=%p, r_type=%d, sec=%s\n",

  8778 +	       fixP->fx_addsy, fixP->fx_r_type, S_GET_SEGMENT(fixP->fx_addsy)->name);

  8779 +      return 1;

  8780 +    }

  8781 +

  8782 +  return generic_force_reloc(fixP);

  8783 +}

  8784 +

  8785 +bfd_boolean

  8786 +avr32_fix_adjustable(fixS *fixP)

  8787 +{

  8788 +  switch (fixP->fx_r_type)

  8789 +    {

  8790 +      /* GOT relocations can't have addends since BFD treats all

  8791 +	 references to a given symbol the same. This means that we

  8792 +	 must avoid section-relative references to local symbols when

  8793 +	 dealing with these kinds of relocs */

  8794 +    case BFD_RELOC_AVR32_GOT32:

  8795 +    case BFD_RELOC_AVR32_GOT16:

  8796 +    case BFD_RELOC_AVR32_GOT8:

  8797 +    case BFD_RELOC_AVR32_GOT21S:

  8798 +    case BFD_RELOC_AVR32_GOT18SW:

  8799 +    case BFD_RELOC_AVR32_GOT16S:

  8800 +    case BFD_RELOC_AVR32_LDA_GOT:

  8801 +    case BFD_RELOC_AVR32_GOTCALL:

  8802 +      pr_debug("fix not adjustable\n");

  8803 +      return 0;

  8804 +

  8805 +    default:

  8806 +      break;

  8807 +    }

  8808 +

  8809 +  return 1;

  8810 +}

  8811 +

  8812 +/* When we want the linker to be able to relax the code, we need to

  8813 +   output a reloc for every .align directive requesting an alignment

  8814 +   to a four byte boundary or larger.  If we don't do this, the linker

  8815 +   can't guarantee that the alignment is actually maintained in the

  8816 +   linker output.

  8817 +

  8818 +   TODO: Might as well insert proper NOPs while we're at it... */

  8819 +void

  8820 +avr32_handle_align(fragS *frag)

  8821 +{

  8822 +  if (linkrelax

  8823 +      && frag->fr_type == rs_align_code

  8824 +      && frag->fr_address + frag->fr_fix > 0

  8825 +      && frag->fr_offset > 0)

  8826 +    {

  8827 +      /* The alignment order (fr_offset) is stored in the addend. */

  8828 +      fix_new(frag, frag->fr_fix, 2, &abs_symbol, frag->fr_offset,

  8829 +	      FALSE, BFD_RELOC_AVR32_ALIGN);

  8830 +    }

  8831 +}

  8832 +

  8833 +/* Relax_align. Advance location counter to next address that has 'alignment'

  8834 +   lowest order bits all 0s, return size of adjustment made.  */

  8835 +relax_addressT

  8836 +avr32_relax_align(segT segment ATTRIBUTE_UNUSED,

  8837 +		  fragS *fragP,

  8838 +		  relax_addressT address)

  8839 +{

  8840 +  relax_addressT mask;

  8841 +  relax_addressT new_address;

  8842 +  int alignment;

  8843 +

  8844 +  alignment = fragP->fr_offset;

  8845 +  mask = ~((~0) << alignment);

  8846 +  new_address = (address + mask) & (~mask);

  8847 +

  8848 +  return new_address - address;

  8849 +}

  8850 +

  8851 +/* Turn a string in input_line_pointer into a floating point constant

  8852 +   of type type, and store the appropriate bytes in *litP.  The number

  8853 +   of LITTLENUMS emitted is stored in *sizeP .  An error message is

  8854 +   returned, or NULL on OK. */

  8855 +

  8856 +/* Equal to MAX_PRECISION in atof-ieee.c */

  8857 +#define MAX_LITTLENUMS 6

  8858 +

  8859 +char *

  8860 +md_atof (type, litP, sizeP)

  8861 +char   type;

  8862 +char * litP;

  8863 +int *  sizeP;

  8864 +{

  8865 +  int              i;

  8866 +  int              prec;

  8867 +  LITTLENUM_TYPE   words [MAX_LITTLENUMS];

  8868 +  char *           t;

  8869 +

  8870 +  switch (type)

  8871 +  {

  8872 +    case 'f':

  8873 +    case 'F':

  8874 +    case 's':

  8875 +    case 'S':

  8876 +      prec = 2;

  8877 +      break;

  8878 +

  8879 +    case 'd':

  8880 +    case 'D':

  8881 +    case 'r':

  8882 +    case 'R':

  8883 +      prec = 4;

  8884 +      break;

  8885 +

  8886 +      /* FIXME: Some targets allow other format chars for bigger sizes here.  */

  8887 +

  8888 +    default:

  8889 +      * sizeP = 0;

  8890 +      return _("Bad call to md_atof()");

  8891 +  }

  8892 +

  8893 +  t = atof_ieee (input_line_pointer, type, words);

  8894 +  if (t)

  8895 +    input_line_pointer = t;

  8896 +  * sizeP = prec * sizeof (LITTLENUM_TYPE);

  8897 +

  8898 +  for (i = 0; i < prec; i++)

  8899 +  {

  8900 +    md_number_to_chars (litP, (valueT) words[i],

  8901 +                        sizeof (LITTLENUM_TYPE));

  8902 +    litP += sizeof (LITTLENUM_TYPE);

  8903 +  }

  8904 +

  8905 +  return 0;

  8906 +}

  8907 +

  8908 +static char *avr32_end_of_match(char *cont, char *what)

  8909 +{

  8910 +  int len = strlen (what);

  8911 +

  8912 +  if (! is_part_of_name (cont[len])

  8913 +      && strncasecmp (cont, what, len) == 0)

  8914 +    return cont + len;

  8915 +

  8916 +  return NULL;

  8917 +}

  8918 +

  8919 +int

  8920 +avr32_parse_name (char const *name, expressionS *exp, char *nextchar)

  8921 +{

  8922 +  char *next = input_line_pointer;

  8923 +  char *next_end;

  8924 +

  8925 +  pr_debug("parse_name: %s, nextchar=%c (%02x)\n", name, *nextchar, *nextchar);

  8926 +

  8927 +  if (*nextchar == '(')

  8928 +    {

  8929 +      if (strcasecmp(name, "hi") == 0)

  8930 +	{

  8931 +	  *next = *nextchar;

  8932 +

  8933 +	  expression(exp);

  8934 +

  8935 +	  if (exp->X_op == O_constant)

  8936 +	    {

  8937 +	      pr_debug("  -> constant hi(0x%08lx) -> 0x%04lx\n",

  8938 +		       exp->X_add_number, exp->X_add_number >> 16);

  8939 +	      exp->X_add_number = (exp->X_add_number >> 16) & 0xffff;

  8940 +	    }

  8941 +	  else

  8942 +	    {

  8943 +	      exp->X_md = exp->X_op;

  8944 +	      exp->X_op = O_hi;

  8945 +	    }

  8946 +

  8947 +	  return 1;

  8948 +	}

  8949 +      else if (strcasecmp(name, "lo") == 0)

  8950 +	{

  8951 +	  *next = *nextchar;

  8952 +

  8953 +	  expression(exp);

  8954 +

  8955 +	  if (exp->X_op == O_constant)

  8956 +	    exp->X_add_number &= 0xffff;

  8957 +	  else

  8958 +	    {

  8959 +	      exp->X_md = exp->X_op;

  8960 +	      exp->X_op = O_lo;

  8961 +	    }

  8962 +

  8963 +	  return 1;

  8964 +	}

  8965 +    }

  8966 +  else if (*nextchar == '@')

  8967 +    {

  8968 +      exp->X_md = exp->X_op;

  8969 +

  8970 +      if ((next_end = avr32_end_of_match (next + 1, "got")))

  8971 +	exp->X_op = O_got;

  8972 +      else if ((next_end = avr32_end_of_match (next + 1, "tlsgd")))

  8973 +	exp->X_op = O_tlsgd;

  8974 +      /* Add more as needed */

  8975 +      else

  8976 +	{

  8977 +	  char c;

  8978 +	  input_line_pointer++;

  8979 +	  c = get_symbol_end();

  8980 +	  as_bad (_("unknown relocation override `%s'"), next + 1);

  8981 +	  *input_line_pointer = c;

  8982 +	  input_line_pointer = next;

  8983 +	  return 0;

  8984 +	}

  8985 +

  8986 +      exp->X_op_symbol = NULL;

  8987 +      exp->X_add_symbol = symbol_find_or_make (name);

  8988 +      exp->X_add_number = 0;

  8989 +

  8990 +      *input_line_pointer = *nextchar;

  8991 +      input_line_pointer = next_end;

  8992 +      *nextchar = *input_line_pointer;

  8993 +      *input_line_pointer = '\0';

  8994 +      return 1;

  8995 +    }

  8996 +  else if (strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)

  8997 +    {

  8998 +      if (!GOT_symbol)

  8999 +	GOT_symbol = symbol_find_or_make(name);

  9000 +

  9001 +      exp->X_add_symbol = GOT_symbol;

  9002 +      exp->X_op = O_symbol;

  9003 +      exp->X_add_number = 0;

  9004 +      return 1;

  9005 +    }

  9006 +

  9007 +  return 0;

  9008 +}

  9009 +

  9010 +static void

  9011 +s_rseg (int value ATTRIBUTE_UNUSED)

  9012 +{

  9013 +  /* Syntax: RSEG segment_name [:type] [NOROOT|ROOT] [(align)]

  9014 +   * Defaults:

  9015 +   *  - type: undocumented ("typically CODE or DATA")

  9016 +   *  - ROOT

  9017 +   *  - align: 1 for code, 0 for others

  9018 +   *

  9019 +   * TODO: NOROOT is ignored. If gas supports discardable segments, it should

  9020 +   * be implemented.

  9021 +   */

  9022 +  char *name, *end;

  9023 +  int length, type, attr;

  9024 +  int align = 0;

  9025 +

  9026 +  SKIP_WHITESPACE();

  9027 +

  9028 +  end = input_line_pointer;

  9029 +  while (0 == strchr ("\n\t;:( ", *end))

  9030 +    end++;

  9031 +  if (end == input_line_pointer)

  9032 +    {

  9033 +      as_warn (_("missing name"));

  9034 +      ignore_rest_of_line();

  9035 +      return;

  9036 +    }

  9037 +

  9038 +  name = xmalloc (end - input_line_pointer + 1);

  9039 +  memcpy (name, input_line_pointer, end - input_line_pointer);

  9040 +  name[end - input_line_pointer] = '\0';

  9041 +  input_line_pointer = end;

  9042 +

  9043 +  SKIP_WHITESPACE();

  9044 +

  9045 +  type = SHT_NULL;

  9046 +  attr = 0;

  9047 +

  9048 +  if (*input_line_pointer == ':')

  9049 +    {

  9050 +      /* Skip the colon */

  9051 +      ++input_line_pointer;

  9052 +      SKIP_WHITESPACE();

  9053 +

  9054 +      /* Possible options at this point:

  9055 +       *   - flag (ROOT or NOROOT)

  9056 +       *   - a segment type

  9057 +       */

  9058 +      end = input_line_pointer;

  9059 +      while (0 == strchr ("\n\t;:( ", *end))

  9060 +	end++;

  9061 +      length = end - input_line_pointer;

  9062 +      if (((length == 4) && (0 == strncasecmp( input_line_pointer, "ROOT", 4))) ||

  9063 +	  ((length == 6) && (0 == strncasecmp( input_line_pointer, "NOROOT", 6))))

  9064 +	{

  9065 +	  /* Ignore ROOT/NOROOT */

  9066 +	  input_line_pointer = end;

  9067 +	}

  9068 +      else

  9069 +	{

  9070 +	  /* Must be a segment type */

  9071 +	  switch (*input_line_pointer)

  9072 +	    {

  9073 +	    case 'C':

  9074 +	    case 'c':

  9075 +	      if ((length == 4) &&

  9076 +		  (0 == strncasecmp (input_line_pointer, "CODE", 4)))

  9077 +		{

  9078 +		  attr |= SHF_ALLOC | SHF_EXECINSTR;

  9079 +		  type = SHT_PROGBITS;

  9080 +		  align = 1;

  9081 +		  break;

  9082 +		}

  9083 +	      if ((length == 5) &&

  9084 +		  (0 == strncasecmp (input_line_pointer, "CONST", 5)))

  9085 +		{

  9086 +		  attr |= SHF_ALLOC;

  9087 +		  type = SHT_PROGBITS;

  9088 +		  break;

  9089 +		}

  9090 +	      goto de_fault;

  9091 +

  9092 +	    case 'D':

  9093 +	    case 'd':

  9094 +	      if ((length == 4) &&

  9095 +		  (0 == strncasecmp (input_line_pointer, "DATA", 4)))

  9096 +		{

  9097 +		  attr |= SHF_ALLOC | SHF_WRITE;

  9098 +		  type = SHT_PROGBITS;

  9099 +		  break;

  9100 +		}

  9101 +	      goto de_fault;

  9102 +

  9103 +	      /* TODO: Add FAR*, HUGE*, IDATA and NEAR* if necessary */

  9104 +

  9105 +	    case 'U':

  9106 +	    case 'u':

  9107 +	      if ((length == 7) &&

  9108 +		  (0 == strncasecmp (input_line_pointer, "UNTYPED", 7)))

  9109 +		break;

  9110 +	      goto de_fault;

  9111 +

  9112 +	      /* TODO: Add XDATA and ZPAGE if necessary */

  9113 +

  9114 +	    de_fault:

  9115 +	    default:

  9116 +	      as_warn (_("unrecognized segment type"));

  9117 +	    }

  9118 +

  9119 +	  input_line_pointer = end;

  9120 +	  SKIP_WHITESPACE();

  9121 +

  9122 +	  if (*input_line_pointer == ':')

  9123 +	    {

  9124 +	      /*  ROOT/NOROOT */

  9125 +	      ++input_line_pointer;

  9126 +	      SKIP_WHITESPACE();

  9127 +

  9128 +	      end = input_line_pointer;

  9129 +	      while (0 == strchr ("\n\t;:( ", *end))

  9130 +		end++;

  9131 +	      length = end - input_line_pointer;

  9132 +	      if (! ((length == 4) &&

  9133 +		     (0 == strncasecmp( input_line_pointer, "ROOT", 4))) &&

  9134 +		  ! ((length == 6) &&

  9135 +		     (0 == strncasecmp( input_line_pointer, "NOROOT", 6))))

  9136 +		{

  9137 +		  as_warn (_("unrecognized segment flag"));

  9138 +		}

  9139 +

  9140 +	      input_line_pointer = end;

  9141 +	      SKIP_WHITESPACE();

  9142 +	    }

  9143 +	}

  9144 +    }

  9145 +

  9146 +  if (*input_line_pointer == '(')

  9147 +    {

  9148 +      align = get_absolute_expression ();

  9149 +    }

  9150 +

  9151 +  demand_empty_rest_of_line();

  9152 +

  9153 +  obj_elf_change_section (name, type, attr, 0, NULL, 0, 0);

  9154 +#ifdef AVR32_DEBUG

  9155 +  fprintf( stderr, "RSEG: Changed section to %s, type: 0x%x, attr: 0x%x\n",

  9156 +      name, type, attr );

  9157 +  fprintf( stderr, "RSEG: Aligning to 2**%d\n", align );

  9158 +#endif

  9159 +

  9160 +  if (align > 15)

  9161 +    {

  9162 +      align = 15;

  9163 +      as_warn (_("alignment too large: %u assumed"), align);

  9164 +    }

  9165 +

  9166 +  /* Hope not, that is */

  9167 +  assert (now_seg != absolute_section);

  9168 +

  9169 +  /* Only make a frag if we HAVE to... */

  9170 +  if (align != 0 && !need_pass_2)

  9171 +    {

  9172 +      if (subseg_text_p (now_seg))

  9173 +	frag_align_code (align, 0);

  9174 +      else

  9175 +	frag_align (align, 0, 0);

  9176 +    }

  9177 +

  9178 +  record_alignment (now_seg, align - OCTETS_PER_BYTE_POWER);

  9179 +}

  9180 +

  9181 +/* vim: syntax=c sw=2

  9182 + */

  9183 --- /dev/null

  9184 +++ b/gas/config/tc-avr32.h

  9185 @@ -0,0 +1,325 @@

  9186 +/* Assembler definitions for AVR32.

  9187 +   Copyright 2003-2006 Atmel Corporation.

  9188 +

  9189 +   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>

  9190 +

  9191 +   This file is part of GAS, the GNU Assembler.

  9192 +

  9193 +   GAS is free software; you can redistribute it and/or modify it

  9194 +   under the terms of the GNU General Public License as published by

  9195 +   the Free Software Foundation; either version 2, or (at your option)

  9196 +   any later version.

  9197 +

  9198 +   GAS is distributed in the hope that it will be useful, but WITHOUT

  9199 +   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

  9200 +   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public

  9201 +   License for more details.

  9202 +

  9203 +   You should have received a copy of the GNU General Public License

  9204 +   along with GAS; see the file COPYING.  If not, write to the Free

  9205 +   Software Foundation, 59 Temple Place - Suite 330, Boston, MA

  9206 +   02111-1307, USA.  */

  9207 +

  9208 +#if 0

  9209 +#define DEBUG

  9210 +#define DEBUG1

  9211 +#define DEBUG2

  9212 +#define DEBUG3

  9213 +#define DEBUG4

  9214 +#define DEBUG5

  9215 +#endif

  9216 +

  9217 +/* Are we trying to be compatible with the IAR assembler? (--iar) */

  9218 +extern int avr32_iarcompat;

  9219 +

  9220 +/* By convention, you should define this macro in the `.h' file.  For

  9221 +   example, `tc-m68k.h' defines `TC_M68K'.  You might have to use this

  9222 +   if it is necessary to add CPU specific code to the object format

  9223 +   file.  */

  9224 +#define TC_AVR32

  9225 +

  9226 +/* This macro is the BFD target name to use when creating the output

  9227 +   file.  This will normally depend upon the `OBJ_FMT' macro.  */

  9228 +#define TARGET_FORMAT "elf32-avr32"

  9229 +

  9230 +/* This macro is the BFD architecture to pass to `bfd_set_arch_mach'.  */

  9231 +#define TARGET_ARCH bfd_arch_avr32

  9232 +

  9233 +/* This macro is the BFD machine number to pass to

  9234 +   `bfd_set_arch_mach'.  If it is not defined, GAS will use 0.  */

  9235 +#define TARGET_MACH 0

  9236 +

  9237 +/* UNDOCUMENTED: Allow //-style comments */

  9238 +#define DOUBLESLASH_LINE_COMMENTS

  9239 +

  9240 +/* You should define this macro to be non-zero if the target is big

  9241 +   endian, and zero if the target is little endian.  */

  9242 +#define TARGET_BYTES_BIG_ENDIAN 1

  9243 +

  9244 +/* FIXME: It seems that GAS only expects a one-byte opcode...

  9245 +   #define NOP_OPCODE 0xd703 */

  9246 +

  9247 +/* If you define this macro, GAS will warn about the use of

  9248 +   nonstandard escape sequences in a string.  */

  9249 +#undef ONLY_STANDARD_ESCAPES

  9250 +

  9251 +#define DWARF2_FORMAT() dwarf2_format_32bit

  9252 +

  9253 +/* Instructions are either 2 or 4 bytes long */

  9254 +/* #define DWARF2_LINE_MIN_INSN_LENGTH 2 */

  9255 +

  9256 +/* GAS will call this function for any expression that can not be

  9257 +   recognized.  When the function is called, `input_line_pointer'

  9258 +   will point to the start of the expression.  */

  9259 +#define md_operand(x)

  9260 +

  9261 +#define md_parse_name(name, expr, mode, c) avr32_parse_name(name, expr, c)

  9262 +extern int avr32_parse_name(const char *, struct expressionS *, char *);

  9263 +

  9264 +/* You may define this macro to generate a fixup for a data

  9265 +   allocation pseudo-op.  */

  9266 +#define TC_CONS_FIX_NEW(FRAG, OFF, LEN, EXP)	\

  9267 +  avr32_cons_fix_new(FRAG, OFF, LEN, EXP)

  9268 +void avr32_cons_fix_new (fragS *, int, int, expressionS *);

  9269 +

  9270 +/* `extsym - .' expressions can be emitted using PC-relative relocs */

  9271 +#define DIFF_EXPR_OK

  9272 +

  9273 +/* This is used to construct expressions out of @gotoff, etc. The

  9274 +   relocation type is stored in X_md */

  9275 +#define O_got		O_md1

  9276 +#define O_hi		O_md2

  9277 +#define O_lo		O_md3

  9278 +#define O_tlsgd		O_md4

  9279 +

  9280 +/* You may define this macro to parse an expression used in a data

  9281 +   allocation pseudo-op such as `.word'.  You can use this to

  9282 +   recognize relocation directives that may appear in such directives.  */

  9283 +/* #define TC_PARSE_CONS_EXPRESSION(EXPR,N) avr_parse_cons_expression (EXPR,N)

  9284 +   void avr_parse_cons_expression (expressionS *exp, int nbytes); */

  9285 +

  9286 +/* This should just call either `number_to_chars_bigendian' or

  9287 +   `number_to_chars_littleendian', whichever is appropriate.  On

  9288 +   targets like the MIPS which support options to change the

  9289 +   endianness, which function to call is a runtime decision.  On

  9290 +   other targets, `md_number_to_chars' can be a simple macro.  */

  9291 +#define md_number_to_chars number_to_chars_bigendian

  9292 +

  9293 +/* `md_short_jump_size'

  9294 +   `md_long_jump_size'

  9295 +   `md_create_short_jump'

  9296 +   `md_create_long_jump'

  9297 +   If `WORKING_DOT_WORD' is defined, GAS will not do broken word

  9298 +   processing (*note Broken words::.).  Otherwise, you should set

  9299 +   `md_short_jump_size' to the size of a short jump (a jump that is

  9300 +   just long enough to jump around a long jmp) and

  9301 +   `md_long_jump_size' to the size of a long jump (a jump that can go

  9302 +   anywhere in the function), You should define

  9303 +   `md_create_short_jump' to create a short jump around a long jump,

  9304 +   and define `md_create_long_jump' to create a long jump.  */

  9305 +#define WORKING_DOT_WORD

  9306 +

  9307 +/* If you define this macro, it means that `tc_gen_reloc' may return

  9308 +   multiple relocation entries for a single fixup.  In this case, the

  9309 +   return value of `tc_gen_reloc' is a pointer to a null terminated

  9310 +   array.  */

  9311 +#undef RELOC_EXPANSION_POSSIBLE

  9312 +

  9313 +/* If you define this macro, GAS will not require pseudo-ops to start with a .

  9314 +   character. */

  9315 +#define NO_PSEUDO_DOT (avr32_iarcompat)

  9316 +

  9317 +/* The IAR assembler uses $ as the location counter. Unfortunately, we

  9318 +   can't make this dependent on avr32_iarcompat... */

  9319 +#define DOLLAR_DOT

  9320 +

  9321 +/* Values passed to md_apply_fix3 don't include the symbol value.  */

  9322 +#define MD_APPLY_SYM_VALUE(FIX) 0

  9323 +

  9324 +/* The number of bytes to put into a word in a listing.  This affects

  9325 +   the way the bytes are clumped together in the listing.  For

  9326 +   example, a value of 2 might print `1234 5678' where a value of 1

  9327 +   would print `12 34 56 78'.  The default value is 4.  */

  9328 +#define LISTING_WORD_SIZE 4

  9329 +

  9330 +/* extern const struct relax_type md_relax_table[];

  9331 +#define TC_GENERIC_RELAX_TABLE md_relax_table */

  9332 +

  9333 +/*

  9334 +  An `.lcomm' directive with no explicit alignment parameter will use

  9335 +  this macro to set P2VAR to the alignment that a request for SIZE

  9336 +  bytes will have.  The alignment is expressed as a power of two.  If

  9337 +  no alignment should take place, the macro definition should do

  9338 +  nothing.  Some targets define a `.bss' directive that is also

  9339 +  affected by this macro.  The default definition will set P2VAR to

  9340 +  the truncated power of two of sizes up to eight bytes.

  9341 +

  9342 +  We want doublewords to be word-aligned, so we're going to modify the

  9343 +  default definition a tiny bit.

  9344 +*/

  9345 +#define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR)	\

  9346 +  do							\

  9347 +    {							\

  9348 +      if ((SIZE) >= 4)					\

  9349 +	(P2VAR) = 2;					\

  9350 +      else if ((SIZE) >= 2)				\

  9351 +	(P2VAR) = 1;					\

  9352 +      else						\

  9353 +	(P2VAR) = 0;					\

  9354 +    }							\

  9355 +  while (0)

  9356 +

  9357 +/* When relaxing, we need to generate relocations for alignment

  9358 +   directives.  */

  9359 +#define HANDLE_ALIGN(frag) avr32_handle_align(frag)

  9360 +extern void avr32_handle_align(fragS *);

  9361 +

  9362 +/* See internals doc for explanation. Oh wait...

  9363 +   Now, can you guess where "alignment" comes from? ;-) */

  9364 +#define MAX_MEM_FOR_RS_ALIGN_CODE ((1 << alignment) - 1)

  9365 +

  9366 +/* We need to stop gas from reducing certain expressions (e.g. GOT

  9367 +   references) */

  9368 +#define tc_fix_adjustable(fix) avr32_fix_adjustable(fix)

  9369 +extern bfd_boolean avr32_fix_adjustable(struct fix *);

  9370 +

  9371 +/* The linker needs to be passed a little more information when relaxing. */

  9372 +#define TC_FORCE_RELOCATION(fix) avr32_force_reloc(fix)

  9373 +extern bfd_boolean avr32_force_reloc(struct fix *);

  9374 +

  9375 +/* I'm tired of working around all the madness in fixup_segment().

  9376 +   This hook will do basically the same things as the generic code,

  9377 +   and then it will "goto" right past it.  */

  9378 +#define TC_VALIDATE_FIX(FIX, SEG, SKIP)		\

  9379 +  do						\

  9380 +    {						\

  9381 +      avr32_process_fixup(FIX, SEG);		\

  9382 +      if (!(FIX)->fx_done)			\

  9383 +	++seg_reloc_count;			\

  9384 +      goto SKIP;				\

  9385 +    }						\

  9386 +  while (0)

  9387 +extern void avr32_process_fixup(struct fix *fixP, segT this_segment);

  9388 +

  9389 +/* Positive values of TC_FX_SIZE_SLACK allow a target to define

  9390 +   fixups that far past the end of a frag.  Having such fixups

  9391 +   is of course most most likely a bug in setting fx_size correctly.

  9392 +   A negative value disables the fixup check entirely, which is

  9393 +   appropriate for something like the Renesas / SuperH SH_COUNT

  9394 +   reloc.  */

  9395 +/* This target is buggy, and sets fix size too large.  */

  9396 +#define TC_FX_SIZE_SLACK(FIX) -1

  9397 +

  9398 +/* We don't want the gas core to make any assumptions about our way of

  9399 +   doing linkrelaxing.  */

  9400 +#define TC_LINKRELAX_FIXUP(SEG)			0

  9401 +

  9402 +/* ... but we do want it to insert lots of padding. */

  9403 +#define LINKER_RELAXING_SHRINKS_ONLY

  9404 +

  9405 +/* Better do it ourselves, really... */

  9406 +#define TC_RELAX_ALIGN(SEG, FRAG, ADDR)	avr32_relax_align(SEG, FRAG, ADDR)

  9407 +extern relax_addressT

  9408 +avr32_relax_align(segT segment, fragS *fragP, relax_addressT address);

  9409 +

  9410 +/* Use line number format that is amenable to linker relaxation.  */

  9411 +#define DWARF2_USE_FIXED_ADVANCE_PC (linkrelax != 0)

  9412 +

  9413 +/* This is called by write_object_file() just before symbols are

  9414 +   attempted converted into section symbols.  */

  9415 +#define tc_frob_file_before_adjust()	avr32_frob_file()

  9416 +extern void avr32_frob_file(void);

  9417 +

  9418 +/* If you define this macro, GAS will call it at the end of each input

  9419 +   file.  */

  9420 +#define md_cleanup() avr32_cleanup()

  9421 +extern void avr32_cleanup(void);

  9422 +

  9423 +/* There's an AVR32-specific hack in operand() which creates O_md

  9424 +   expressions when encountering HWRD or LWRD. We need to generate

  9425 +   proper relocs for them */

  9426 +/* #define md_cgen_record_fixup_exp avr32_cgen_record_fixup_exp */

  9427 +

  9428 +/* I needed to add an extra hook in gas_cgen_finish_insn() for

  9429 +   conversion of O_md* operands because md_cgen_record_fixup_exp()

  9430 +   isn't called for relaxable insns */

  9431 +/* #define md_cgen_convert_expr(exp, opinfo) avr32_cgen_convert_expr(exp, opinfo)

  9432 +   int avr32_cgen_convert_expr(expressionS *, int); */

  9433 +

  9434 +/* #define tc_gen_reloc gas_cgen_tc_gen_reloc */

  9435 +

  9436 +/* If you define this macro, it should return the position from which

  9437 +   the PC relative adjustment for a PC relative fixup should be

  9438 +   made. On many processors, the base of a PC relative instruction is

  9439 +   the next instruction, so this macro would return the length of an

  9440 +   instruction, plus the address of the PC relative fixup. The latter

  9441 +   can be calculated as fixp->fx_where + fixp->fx_frag->fr_address. */

  9442 +extern long md_pcrel_from_section (struct fix *, segT);

  9443 +#define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from_section (FIX, SEC)

  9444 +

  9445 +#define LOCAL_LABEL(name) (name[0] == '.' && (name[1] == 'L'))

  9446 +#define LOCAL_LABELS_FB		1

  9447 +

  9448 +struct avr32_relaxer

  9449 +{

  9450 +  int (*estimate_size)(fragS *, segT);

  9451 +  long (*relax_frag)(segT, fragS *, long);

  9452 +  void (*convert_frag)(bfd *, segT, fragS *);

  9453 +};

  9454 +

  9455 +/* AVR32 has quite complex instruction coding, which means we need

  9456 + * lots of information in order to do the right thing during relaxing

  9457 + * (basically, we need to be able to reconstruct a whole new opcode if

  9458 + * necessary) */

  9459 +#define TC_FRAG_TYPE struct avr32_frag_data

  9460 +

  9461 +struct cpool;

  9462 +

  9463 +struct avr32_frag_data

  9464 +{

  9465 +  /* TODO: Maybe add an expression object here so that we can use

  9466 +     fix_new_exp() in md_convert_frag?  We may have to decide

  9467 +     pcrel-ness in md_estimate_size_before_relax() as well...or we

  9468 +     might do it when parsing.  Doing it while parsing may fail

  9469 +     because the sub_symbol is undefined then... */

  9470 +  int pcrel;

  9471 +  int force_extended;

  9472 +  int reloc_info;

  9473 +  struct avr32_relaxer *relaxer;

  9474 +  expressionS exp;

  9475 +

  9476 +  /* Points to associated constant pool, for use by LDA and CALL in

  9477 +     non-pic mode, and when relaxing the .cpool directive */

  9478 +  struct cpool *pool;

  9479 +  unsigned int pool_entry;

  9480 +};

  9481 +

  9482 +/* We will have to initialize the fields explicitly when needed */

  9483 +#define TC_FRAG_INIT(fragP)

  9484 +

  9485 +#define md_estimate_size_before_relax(fragP, segT)			\

  9486 +  ((fragP)->tc_frag_data.relaxer->estimate_size(fragP, segT))

  9487 +#define md_relax_frag(segment, fragP, stretch)				\

  9488 +  ((fragP)->tc_frag_data.relaxer->relax_frag(segment, fragP, stretch))

  9489 +#define md_convert_frag(abfd, segment, fragP)				\

  9490 +  ((fragP)->tc_frag_data.relaxer->convert_frag(abfd, segment, fragP))

  9491 +

  9492 +#define TC_FIX_TYPE struct avr32_fix_data

  9493 +

  9494 +struct avr32_fix_data

  9495 +{

  9496 +  const struct avr32_ifield *ifield;

  9497 +  unsigned int align;

  9498 +  long min;

  9499 +  long max;

  9500 +};

  9501 +

  9502 +#define TC_INIT_FIX_DATA(fixP)			\

  9503 +  do						\

  9504 +    {						\

  9505 +      (fixP)->tc_fix_data.ifield = NULL;	\

  9506 +      (fixP)->tc_fix_data.align = 0;		\

  9507 +      (fixP)->tc_fix_data.min = 0;		\

  9508 +      (fixP)->tc_fix_data.max = 0;		\

  9509 +    }						\

  9510 +  while (0)

  9511 --- a/gas/configure.tgt

  9512 +++ b/gas/configure.tgt

  9513 @@ -33,6 +33,7 @@ case ${cpu} in

  9514    am33_2.0)		cpu_type=mn10300 endian=little ;;

  9515    arm*be|arm*b)		cpu_type=arm endian=big ;;

  9516    arm*)			cpu_type=arm endian=little ;;

  9517 +  avr32*)		cpu_type=avr32 endian=big ;;

  9518    bfin*)		cpu_type=bfin endian=little ;;

  9519    c4x*)			cpu_type=tic4x ;;

  9520    cr16*)		cpu_type=cr16 endian=little ;;

  9521 @@ -129,6 +130,9 @@ case ${generic_target} in

  9522    bfin-*elf)				fmt=elf ;;

  9523    cr16-*-elf*)	    			fmt=elf ;;

  9525 +  avr32-*-linux*)			fmt=elf  em=linux bfd_gas=yes ;;

  9526 +  avr32*)				fmt=elf  bfd_gas=yes ;;

  9527 +

  9528    cris-*-linux-* | crisv32-*-linux-*)

  9529  					fmt=multi em=linux ;;

  9530    cris-*-* | crisv32-*-*)		fmt=multi ;;

  9531 --- a/gas/doc/all.texi

  9532 +++ b/gas/doc/all.texi

  9533 @@ -30,6 +30,7 @@

  9534  @set ARC

  9535  @set ARM

  9536  @set AVR

  9537 +@set AVR32

  9538  @set BFIN

  9539  @set CR16

  9540  @set CRIS

  9541 --- a/gas/doc/as.texinfo

  9542 +++ b/gas/doc/as.texinfo

  9543 @@ -6353,6 +6353,9 @@ subject, see the hardware manufacturer's

  9544  @ifset AVR

  9545  * AVR-Dependent::               AVR Dependent Features

  9546  @end ifset

  9547 +@ifset AVR32

  9548 +* AVR32-Dependent::             AVR32 Dependent Features

  9549 +@end ifset

  9550  @ifset BFIN

  9551  * BFIN-Dependent::		BFIN Dependent Features

  9552  @end ifset

  9553 @@ -6476,6 +6479,10 @@ subject, see the hardware manufacturer's

  9554  @include c-avr.texi

  9555  @end ifset

  9557 +@ifset AVR32

  9558 +@include c-avr32.texi

  9559 +@end ifset

  9560 +

  9561  @ifset BFIN

  9562  @include c-bfin.texi

  9563  @end ifset

  9564 --- /dev/null

  9565 +++ b/gas/doc/c-avr32.texi

  9566 @@ -0,0 +1,247 @@

  9567 +@c Copyright 2005, 2006

  9568 +@c Atmel Corporation

  9569 +@c This is part of the GAS manual.

  9570 +@c For copying conditions, see the file as.texinfo.

  9571 +

  9572 +@ifset GENERIC

  9573 +@page

  9574 +@node AVR32-Dependent

  9575 +@chapter AVR32 Dependent Features

  9576 +@end ifset

  9577 +

  9578 +@ifclear GENERIC

  9579 +@node Machine Dependencies

  9580 +@chapter AVR32 Dependent Features

  9581 +@end ifclear

  9582 +

  9583 +@cindex AVR32 support

  9584 +@menu

  9585 +* AVR32 Options::               Options

  9586 +* AVR32 Syntax::                Syntax

  9587 +* AVR32 Directives::            Directives

  9588 +* AVR32 Opcodes::               Opcodes

  9589 +@end menu

  9590 +

  9591 +@node AVR32 Options

  9592 +@section Options

  9593 +@cindex AVR32 options

  9594 +@cindex options for AVR32

  9595 +

  9596 +There are currently no AVR32-specific options.  However, the following

  9597 +options are planned:

  9598 +

  9599 +@table @code

  9600 +

  9601 +@cindex @code{--pic} command line option, AVR32

  9602 +@cindex PIC code generation for AVR32

  9603 +@item --pic

  9604 +This option specifies that the output of the assembler should be marked

  9605 +as position-independent code (PIC).  It will also ensure that

  9606 +pseudo-instructions that deal with address calculation are output as

  9607 +PIC, and that all absolute address references in the code are marked as

  9608 +such.

  9609 +

  9610 +@cindex @code{--linkrelax} command line option, AVR32

  9611 +@item --linkrelax

  9612 +This option specifies that the output of the assembler should be marked

  9613 +as linker-relaxable.  It will also ensure that all PC-relative operands

  9614 +that may change during linker relaxation get appropriate relocations.

  9615 +

  9616 +@end table

  9617 +

  9618 +

  9619 +@node AVR32 Syntax

  9620 +@section Syntax

  9621 +@menu

  9622 +* AVR32-Chars::              Special Characters

  9623 +* AVR32-Symrefs::            Symbol references

  9624 +@end menu

  9625 +

  9626 +@node AVR32-Chars

  9627 +@subsection Special Characters

  9628 +

  9629 +@cindex line comment character, AVR32

  9630 +@cindex AVR32 line comment character

  9631 +The presence of a @samp{//} on a line indicates the start of a comment

  9632 +that extends to the end of the current line.  If a @samp{#} appears as

  9633 +the first character of a line, the whole line is treated as a comment.

  9634 +

  9635 +@cindex line separator, AVR32

  9636 +@cindex statement separator, AVR32

  9637 +@cindex AVR32 line separator

  9638 +The @samp{;} character can be used instead of a newline to separate

  9639 +statements.

  9640 +

  9641 +@node AVR32-Symrefs

  9642 +@subsection Symbol references

  9643 +

  9644 +The absolute value of a symbol can be obtained by simply naming the

  9645 +symbol.  However, as AVR32 symbols have 32-bit values, most symbols have

  9646 +values that are outside the range of any instructions.

  9647 +

  9648 +Instructions that take a PC-relative offset, e.g. @code{lddpc} or

  9649 +@code{rcall}, can also reference a symbol by simply naming the symbol

  9650 +(no explicit calculations necessary).  In this case, the assembler or

  9651 +linker subtracts the address of the instruction from the symbol's value

  9652 +and inserts the result into the instruction.  Note that even though an

  9653 +overflow is less likely to happen for a relative reference than for an

  9654 +absolute reference, the assembler or linker will generate an error if

  9655 +the referenced symbol is too far away from the current location.

  9656 +

  9657 +Relative references can be used for data as well.  For example:

  9658 +

  9659 +@smallexample

  9660 +        lddpc   r0, 2f

  9661 +1:      add     r0, pc

  9662 +        ...

  9663 +        .align  2

  9664 +2:      .int    @var{some_symbol} - 1b

  9665 +@end smallexample

  9666 +

  9667 +Here, r0 will end up with the run-time address of @var{some_symbol} even

  9668 +if the program was loaded at a different address than it was linked

  9669 +(position-independent code).

  9670 +

  9671 +@subsubsection Symbol modifiers

  9672 +

  9673 +@table @code

  9674 +

  9675 +@item @code{hi(@var{symbol})}

  9676 +Evaluates to the value of the symbol shifted right 16 bits.  This will

  9677 +work even if @var{symbol} is defined in a different module.

  9678 +

  9679 +@item @code{lo(@var{symbol})}

  9680 +Evaluates to the low 16 bits of the symbol's value.  This will work even

  9681 +if @var{symbol} is defined in a different module.

  9682 +

  9683 +@item @code{@var{symbol}@@got}

  9684 +Create a GOT entry for @var{symbol} and return the offset of that entry

  9685 +relative to the GOT base.

  9686 +

  9687 +@end table

  9688 +

  9689 +

  9690 +@node AVR32 Directives

  9691 +@section Directives

  9692 +@cindex machine directives, AVR32

  9693 +@cindex AVR32 directives

  9694 +

  9695 +@table @code

  9696 +

  9697 +@cindex @code{.cpool} directive, AVR32

  9698 +@item .cpool

  9699 +This directive causes the current contents of the constant pool to be

  9700 +dumped into the current section at the current location (aligned to a

  9701 +word boundary).  @code{GAS} maintains a separate constant pool for each

  9702 +section and each sub-section.  The @code{.cpool} directive will only

  9703 +affect the constant pool of the current section and sub-section.  At the

  9704 +end of assembly, all remaining, non-empty constant pools will

  9705 +automatically be dumped.

  9706 +

  9707 +@end table

  9708 +

  9709 +

  9710 +@node AVR32 Opcodes

  9711 +@section Opcodes

  9712 +@cindex AVR32 opcodes

  9713 +@cindex opcodes for AVR32

  9714 +

  9715 +@code{@value{AS}} implements all the standard AVR32 opcodes.  It also

  9716 +implements several pseudo-opcodes, which are recommended to use wherever

  9717 +possible because they give the tool chain better freedom to generate

  9718 +optimal code.

  9719 +

  9720 +@table @code

  9721 +

  9722 +@cindex @code{LDA.W reg, symbol} pseudo op, AVR32

  9723 +@item LDA.W

  9724 +@smallexample

  9725 +        lda.w   @var{reg}, @var{symbol}

  9726 +@end smallexample

  9727 +

  9728 +This instruction will load the address of @var{symbol} into

  9729 +@var{reg}. The instruction will evaluate to one of the following,

  9730 +depending on the relative distance to the symbol, the relative distance

  9731 +to the constant pool and whether the @code{--pic} option has been

  9732 +specified. If the @code{--pic} option has not been specified, the

  9733 +alternatives are as follows:

  9734 +@smallexample

  9735 +        /* @var{symbol} evaluates to a small enough value */

  9736 +        mov     @var{reg}, @var{symbol}

  9737 +

  9738 +        /* (. - @var{symbol}) evaluates to a small enough value */

  9739 +        sub     @var{reg}, pc, . - @var{symbol}

  9740 +

  9741 +        /* Constant pool is close enough */

  9742 +        lddpc   @var{reg}, @var{cpent}

  9743 +        ...

  9744 +@var{cpent}:

  9745 +        .long   @var{symbol}

  9746 +

  9747 +        /* Otherwise (not implemented yet, probably not necessary) */

  9748 +        mov     @var{reg}, lo(@var{symbol})

  9749 +        orh     @var{reg}, hi(@var{symbol})

  9750 +@end smallexample

  9751 +

  9752 +If the @code{--pic} option has been specified, the alternatives are as

  9753 +follows:

  9754 +@smallexample

  9755 +        /* (. - @var{symbol}) evaluates to a small enough value */

  9756 +        sub     @var{reg}, pc, . - @var{symbol}

  9757 +

  9758 +        /* If @code{--linkrelax} not specified */

  9759 +        ld.w    @var{reg}, r6[@var{symbol}@@got]

  9760 +

  9761 +        /* Otherwise */

  9762 +        mov     @var{reg}, @var{symbol}@@got / 4

  9763 +        ld.w    @var{reg}, r6[@var{reg} << 2]

  9764 +@end smallexample

  9765 +

  9766 +If @var{symbol} is not defined in the same file and section as the

  9767 +@code{LDA.W} instruction, the most pessimistic alternative of the

  9768 +above is selected. The linker may convert it back into the most

  9769 +optimal alternative when the final value of all symbols is known.

  9770 +

  9771 +@cindex @code{CALL symbol} pseudo op, AVR32

  9772 +@item CALL

  9773 +@smallexample

  9774 +        call    @var{symbol}

  9775 +@end smallexample

  9776 +

  9777 +This instruction will insert code to call the subroutine identified by

  9778 +@var{symbol}. It will evaluate to one of the following, depending on

  9779 +the relative distance to the symbol as well as the @code{--linkrelax}

  9780 +and @code{--pic} command-line options.

  9781 +

  9782 +If @var{symbol} is defined in the same section and input file, and the

  9783 +distance is small enough, an @code{rcall} instruction is inserted:

  9784 +@smallexample

  9785 +        rcall   @var{symbol}

  9786 +@end smallexample

  9787 +

  9788 +Otherwise, if the @code{--pic} option has not been specified:

  9789 +@smallexample

  9790 +        mcall   @var{cpent}

  9791 +        ...

  9792 +@var{cpent}:

  9793 +        .long   @var{symbol}

  9794 +@end smallexample

  9795 +

  9796 +Finally, if nothing else fits and the @code{--pic} option has been

  9797 +specified, the assembler will indirect the call through the Global

  9798 +Offset Table:

  9799 +@smallexample

  9800 +        /* If @code{--linkrelax} not specified */

  9801 +        mcall   r6[@var{symbol}@@got]

  9802 +

  9803 +        /* If @code{--linkrelax} specified */

  9804 +        mov     lr, @var{symbol}@@got / 4

  9805 +        ld.w    lr, r6[lr << 2]

  9806 +        icall   lr

  9807 +@end smallexample

  9808 +

  9809 +The linker, after determining the final value of @var{symbol}, may

  9810 +convert any of these into more optimal alternatives. This includes

  9811 +deleting any superfluous constant pool- and GOT-entries.

  9812 +

  9813 +@end table

  9814 --- a/gas/doc/Makefile.am

  9815 +++ b/gas/doc/Makefile.am

  9816 @@ -33,6 +33,7 @@ CPU_DOCS = \

  9817  	c-arc.texi \

  9818  	c-arm.texi \

  9819  	c-avr.texi \

  9820 +    c-avr32.texi \

  9821  	c-bfin.texi \

  9822  	c-cr16.texi \

  9823  	c-d10v.texi \

  9824 --- a/gas/Makefile.am

  9825 +++ b/gas/Makefile.am

  9826 @@ -47,6 +47,7 @@ CPU_TYPES = \

  9827  	arc \

  9828  	arm \

  9829  	avr \

  9830 +	avr32 \

  9831  	bfin \

  9832  	cr16 \

  9833  	cris \

  9834 @@ -241,6 +242,7 @@ TARGET_CPU_CFILES = \

  9835  	config/tc-arc.c \

  9836  	config/tc-arm.c \

  9837  	config/tc-avr.c \

  9838 +	config/tc-avr32.c \

  9839  	config/tc-bfin.c \

  9840  	config/tc-cr16.c \

  9841  	config/tc-cris.c \

  9842 @@ -296,6 +298,7 @@ TARGET_CPU_HFILES = \

  9843  	config/tc-arc.h \

  9844  	config/tc-arm.h \

  9845  	config/tc-avr.h \

  9846 +	config/tc-avr32.h \

  9847  	config/tc-bfin.h \

  9848  	config/tc-cr16.h \

  9849  	config/tc-cris.h \

  9850 @@ -1050,6 +1053,11 @@ DEPTC_avr_elf = $(srcdir)/config/obj-elf

  9851    $(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr.h dwarf2dbg.h \

  9852    $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \

  9853    $(INCDIR)/opcode/avr.h

  9854 +DEPTC_avr32_elf = $(INCDIR)/symcat.h $(srcdir)/config/obj-elf.h \

  9855 +  $(BFDDIR)/elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \

  9856 +  $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr32.h \

  9857 +  $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \

  9858 +  $(srcdir)/../opcodes/avr32-opc.h $(srcdir)/../opcodes/avr32-asm.h

  9859  DEPTC_bfin_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \

  9860    $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \

  9861    $(INCDIR)/bfdlink.h $(srcdir)/config/tc-bfin.h dwarf2dbg.h \

  9862 @@ -1487,6 +1495,11 @@ DEPOBJ_avr_elf = $(srcdir)/config/obj-el

  9863    $(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr.h dwarf2dbg.h \

  9864    $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \

  9865    $(INCDIR)/obstack.h struc-symbol.h dwarf2dbg.h $(INCDIR)/aout/aout64.h

  9866 +DEPOBJ_avr32_elf = $(INCDIR)/symcat.h $(srcdir)/config/obj-elf.h \

  9867 +  $(BFDDIR)/elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \

  9868 +  $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr32.h \

  9869 +  $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \

  9870 +  struc-symbol.h dwarf2dbg.h

  9871  DEPOBJ_bfin_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \

  9872    $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \

  9873    $(INCDIR)/bfdlink.h $(srcdir)/config/tc-bfin.h dwarf2dbg.h \

  9874 @@ -1858,6 +1871,9 @@ DEP_cr16_elf = $(srcdir)/config/obj-elf.

  9875    $(INCDIR)/bfdlink.h $(srcdir)/config/tc-cr16.h dwarf2dbg.h \

  9876    $(srcdir)/config/obj-coff.h $(INCDIR)/coff/internal.h \

  9877    $(BFDDIR)/libcoff.h

  9878 +DEP_avr32_elf = $(srcdir)/config/obj-elf.h $(INCDIR)/symcat.h \

  9879 +  $(BFDDIR)/elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \

  9880 +  $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr32.h

  9881  DEP_cris_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-cris.h \

  9882    $(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h

  9883  DEP_cris_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \

  9884 --- /dev/null

  9885 +++ b/gas/testsuite/gas/avr32/aliases.d

  9886 @@ -0,0 +1,19 @@

  9887 +#as:

  9888 +#objdump: -dr

  9889 +#name: aliases

  9890 +

  9891 +.*: +file format .*

  9892 +

  9893 +Disassembly of section \.text:

  9894 +

  9895 +00000000 <ld_nodisp>:

  9896 +   0:	19 80      [ \t]+ld\.ub r0,r12\[0x0\]

  9897 +   2:	f9 20 00 00[ \t]+ld\.sb r0,r12\[0\]

  9898 +   6:	98 80      [ \t]+ld\.uh r0,r12\[0x0\]

  9899 +   8:	98 00      [ \t]+ld\.sh r0,r12\[0x0\]

  9900 +   a:	78 00      [ \t]+ld\.w r0,r12\[0x0\]

  9901 +

  9902 +0000000c <st_nodisp>:

  9903 +   c:	b8 80      [ \t]+st\.b r12\[0x0\],r0

  9904 +   e:	b8 00      [ \t]+st\.h r12\[0x0\],r0

  9905 +  10:	99 00      [ \t]+st\.w r12\[0x0\],r0

  9906 --- /dev/null

  9907 +++ b/gas/testsuite/gas/avr32/aliases.s

  9908 @@ -0,0 +1,14 @@

  9909 +	.text

  9910 +	.global	ld_nodisp

  9911 +ld_nodisp:

  9912 +	ld.ub	r0, r12

  9913 +	ld.sb	r0, r12

  9914 +	ld.uh	r0, r12

  9915 +	ld.sh	r0, r12

  9916 +	ld.w	r0, r12

  9917 +

  9918 +	.global st_nodisp

  9919 +st_nodisp:

  9920 +	st.b	r12, r0

  9921 +	st.h	r12, r0

  9922 +	st.w	r12, r0

  9923 --- /dev/null

  9924 +++ b/gas/testsuite/gas/avr32/allinsn.d

  9925 @@ -0,0 +1,2987 @@

  9926 +#as:

  9927 +#objdump: -dr

  9928 +#name: allinsn

  9929 +

  9930 +.*: +file format .*

  9931 +

  9932 +Disassembly of section \.text:

  9933 +

  9934 +[0-9a-f]* <ld_d5>:

  9935 + *[0-9a-f]*:	fe 0f 02 3e 	ld\.d lr,pc\[pc<<0x3\]

  9936 + *[0-9a-f]*:	e0 00 02 00 	ld\.d r0,r0\[r0\]

  9937 + *[0-9a-f]*:	ea 05 02 26 	ld\.d r6,r5\[r5<<0x2\]

  9938 + *[0-9a-f]*:	e8 04 02 14 	ld\.d r4,r4\[r4<<0x1\]

  9939 + *[0-9a-f]*:	fc 0e 02 1e 	ld\.d lr,lr\[lr<<0x1\]

  9940 + *[0-9a-f]*:	e6 0d 02 2a 	ld\.d r10,r3\[sp<<0x2\]

  9941 + *[0-9a-f]*:	f4 06 02 28 	ld\.d r8,r10\[r6<<0x2\]

  9942 + *[0-9a-f]*:	ee 09 02 02 	ld\.d r2,r7\[r9\]

  9943 +

  9944 +[0-9a-f]* <ld_w5>:

  9945 + *[0-9a-f]*:	fe 0f 03 0f 	ld\.w pc,pc\[pc\]

  9946 + *[0-9a-f]*:	f8 0c 03 3c 	ld\.w r12,r12\[r12<<0x3\]

  9947 + *[0-9a-f]*:	ea 05 03 25 	ld\.w r5,r5\[r5<<0x2\]

  9948 + *[0-9a-f]*:	e8 04 03 14 	ld\.w r4,r4\[r4<<0x1\]

  9949 + *[0-9a-f]*:	fc 0e 03 1e 	ld\.w lr,lr\[lr<<0x1\]

  9950 + *[0-9a-f]*:	f2 09 03 02 	ld\.w r2,r9\[r9\]

  9951 + *[0-9a-f]*:	e4 06 03 0b 	ld\.w r11,r2\[r6\]

  9952 + *[0-9a-f]*:	e4 0d 03 30 	ld\.w r0,r2\[sp<<0x3\]

  9953 +

  9954 +[0-9a-f]* <ld_sh5>:

  9955 + *[0-9a-f]*:	fe 0f 04 0f 	ld\.sh pc,pc\[pc\]

  9956 + *[0-9a-f]*:	f8 0c 04 3c 	ld\.sh r12,r12\[r12<<0x3\]

  9957 + *[0-9a-f]*:	ea 05 04 25 	ld\.sh r5,r5\[r5<<0x2\]

  9958 + *[0-9a-f]*:	e8 04 04 14 	ld\.sh r4,r4\[r4<<0x1\]

  9959 + *[0-9a-f]*:	fc 0e 04 1e 	ld\.sh lr,lr\[lr<<0x1\]

  9960 + *[0-9a-f]*:	e0 0f 04 2b 	ld\.sh r11,r0\[pc<<0x2\]

  9961 + *[0-9a-f]*:	fa 06 04 2a 	ld\.sh r10,sp\[r6<<0x2\]

  9962 + *[0-9a-f]*:	e4 02 04 0c 	ld\.sh r12,r2\[r2\]

  9963 +

  9964 +[0-9a-f]* <ld_uh5>:

  9965 + *[0-9a-f]*:	fe 0f 05 0f 	ld\.uh pc,pc\[pc\]

  9966 + *[0-9a-f]*:	f8 0c 05 3c 	ld\.uh r12,r12\[r12<<0x3\]

  9967 + *[0-9a-f]*:	ea 05 05 25 	ld\.uh r5,r5\[r5<<0x2\]

  9968 + *[0-9a-f]*:	e8 04 05 14 	ld\.uh r4,r4\[r4<<0x1\]

  9969 + *[0-9a-f]*:	fc 0e 05 1e 	ld\.uh lr,lr\[lr<<0x1\]

  9970 + *[0-9a-f]*:	fe 0e 05 38 	ld\.uh r8,pc\[lr<<0x3\]

  9971 + *[0-9a-f]*:	e2 0f 05 16 	ld\.uh r6,r1\[pc<<0x1\]

  9972 + *[0-9a-f]*:	fc 0d 05 16 	ld\.uh r6,lr\[sp<<0x1\]

  9973 +

  9974 +[0-9a-f]* <ld_sb2>:

  9975 + *[0-9a-f]*:	fe 0f 06 0f 	ld\.sb pc,pc\[pc\]

  9976 + *[0-9a-f]*:	f8 0c 06 3c 	ld\.sb r12,r12\[r12<<0x3\]

  9977 + *[0-9a-f]*:	ea 05 06 25 	ld\.sb r5,r5\[r5<<0x2\]

  9978 + *[0-9a-f]*:	e8 04 06 14 	ld\.sb r4,r4\[r4<<0x1\]

  9979 + *[0-9a-f]*:	fc 0e 06 1e 	ld\.sb lr,lr\[lr<<0x1\]

  9980 + *[0-9a-f]*:	e2 0f 06 39 	ld\.sb r9,r1\[pc<<0x3\]

  9981 + *[0-9a-f]*:	e6 0b 06 10 	ld\.sb r0,r3\[r11<<0x1\]

  9982 + *[0-9a-f]*:	ea 05 06 1a 	ld\.sb r10,r5\[r5<<0x1\]

  9983 +

  9984 +[0-9a-f]* <ld_ub5>:

  9985 + *[0-9a-f]*:	fe 0f 07 0f 	ld\.ub pc,pc\[pc\]

  9986 + *[0-9a-f]*:	f8 0c 07 3c 	ld\.ub r12,r12\[r12<<0x3\]

  9987 + *[0-9a-f]*:	ea 05 07 25 	ld\.ub r5,r5\[r5<<0x2\]

  9988 + *[0-9a-f]*:	e8 04 07 14 	ld\.ub r4,r4\[r4<<0x1\]

  9989 + *[0-9a-f]*:	fc 0e 07 1e 	ld\.ub lr,lr\[lr<<0x1\]

  9990 + *[0-9a-f]*:	f8 07 07 36 	ld\.ub r6,r12\[r7<<0x3\]

  9991 + *[0-9a-f]*:	ec 0c 07 02 	ld\.ub r2,r6\[r12\]

  9992 + *[0-9a-f]*:	ee 0b 07 10 	ld\.ub r0,r7\[r11<<0x1\]

  9993 +

  9994 +[0-9a-f]* <st_d5>:

  9995 + *[0-9a-f]*:	fe 0f 08 0e 	st\.d pc\[pc\],lr

  9996 + *[0-9a-f]*:	f8 0c 08 3c 	st\.d r12\[r12<<0x3\],r12

  9997 + *[0-9a-f]*:	ea 05 08 26 	st\.d r5\[r5<<0x2\],r6

  9998 + *[0-9a-f]*:	e8 04 08 14 	st\.d r4\[r4<<0x1\],r4

  9999 + *[0-9a-f]*:	fc 0e 08 1e 	st\.d lr\[lr<<0x1\],lr

 10000 + *[0-9a-f]*:	e2 09 08 14 	st\.d r1\[r9<<0x1\],r4

 10001 + *[0-9a-f]*:	f4 02 08 14 	st\.d r10\[r2<<0x1\],r4

 10002 + *[0-9a-f]*:	f8 06 08 0e 	st\.d r12\[r6\],lr

 10003 +

 10004 +[0-9a-f]* <st_w5>:

 10005 + *[0-9a-f]*:	fe 0f 09 0f 	st\.w pc\[pc\],pc

 10006 + *[0-9a-f]*:	f8 0c 09 3c 	st\.w r12\[r12<<0x3\],r12

 10007 + *[0-9a-f]*:	ea 05 09 25 	st\.w r5\[r5<<0x2\],r5

 10008 + *[0-9a-f]*:	e8 04 09 14 	st\.w r4\[r4<<0x1\],r4

 10009 + *[0-9a-f]*:	fc 0e 09 1e 	st\.w lr\[lr<<0x1\],lr

 10010 + *[0-9a-f]*:	e2 0a 09 03 	st\.w r1\[r10\],r3

 10011 + *[0-9a-f]*:	e0 0a 09 19 	st\.w r0\[r10<<0x1\],r9

 10012 + *[0-9a-f]*:	e8 05 09 3f 	st\.w r4\[r5<<0x3\],pc

 10013 +

 10014 +[0-9a-f]* <st_h5>:

 10015 + *[0-9a-f]*:	fe 0f 0a 0f 	st\.h pc\[pc\],pc

 10016 + *[0-9a-f]*:	f8 0c 0a 3c 	st\.h r12\[r12<<0x3\],r12

 10017 + *[0-9a-f]*:	ea 05 0a 25 	st\.h r5\[r5<<0x2\],r5

 10018 + *[0-9a-f]*:	e8 04 0a 14 	st\.h r4\[r4<<0x1\],r4

 10019 + *[0-9a-f]*:	fc 0e 0a 1e 	st\.h lr\[lr<<0x1\],lr

 10020 + *[0-9a-f]*:	e4 09 0a 0b 	st\.h r2\[r9\],r11

 10021 + *[0-9a-f]*:	ea 01 0a 2c 	st\.h r5\[r1<<0x2\],r12

 10022 + *[0-9a-f]*:	fe 08 0a 23 	st\.h pc\[r8<<0x2\],r3

 10023 +

 10024 +[0-9a-f]* <st_b5>:

 10025 + *[0-9a-f]*:	fe 0f 0b 0f 	st\.b pc\[pc\],pc

 10026 + *[0-9a-f]*:	f8 0c 0b 3c 	st\.b r12\[r12<<0x3\],r12

 10027 + *[0-9a-f]*:	ea 05 0b 25 	st\.b r5\[r5<<0x2\],r5

 10028 + *[0-9a-f]*:	e8 04 0b 14 	st\.b r4\[r4<<0x1\],r4

 10029 + *[0-9a-f]*:	fc 0e 0b 1e 	st\.b lr\[lr<<0x1\],lr

 10030 + *[0-9a-f]*:	e2 08 0b 16 	st\.b r1\[r8<<0x1\],r6

 10031 + *[0-9a-f]*:	fc 0e 0b 31 	st\.b lr\[lr<<0x3\],r1

 10032 + *[0-9a-f]*:	ea 00 0b 2f 	st\.b r5\[r0<<0x2\],pc

 10033 +

 10034 +[0-9a-f]* <divs>:

 10035 + *[0-9a-f]*:	fe 0f 0c 0f 	divs pc,pc,pc

 10036 + *[0-9a-f]*:	f8 0c 0c 0c 	divs r12,r12,r12

 10037 + *[0-9a-f]*:	ea 05 0c 05 	divs r5,r5,r5

 10038 + *[0-9a-f]*:	e8 04 0c 04 	divs r4,r4,r4

 10039 + *[0-9a-f]*:	fc 0e 0c 0e 	divs lr,lr,lr

 10040 + *[0-9a-f]*:	fe 0f 0c 03 	divs r3,pc,pc

 10041 + *[0-9a-f]*:	f8 02 0c 09 	divs r9,r12,r2

 10042 + *[0-9a-f]*:	e8 01 0c 07 	divs r7,r4,r1

 10043 +

 10044 +[0-9a-f]* <add1>:

 10045 + *[0-9a-f]*:	1e 0f       	add pc,pc

 10046 + *[0-9a-f]*:	18 0c       	add r12,r12

 10047 + *[0-9a-f]*:	0a 05       	add r5,r5

 10048 + *[0-9a-f]*:	08 04       	add r4,r4

 10049 + *[0-9a-f]*:	1c 0e       	add lr,lr

 10050 + *[0-9a-f]*:	12 0c       	add r12,r9

 10051 + *[0-9a-f]*:	06 06       	add r6,r3

 10052 + *[0-9a-f]*:	18 0a       	add r10,r12

 10053 +

 10054 +[0-9a-f]* <sub1>:

 10055 + *[0-9a-f]*:	1e 1f       	sub pc,pc

 10056 + *[0-9a-f]*:	18 1c       	sub r12,r12

 10057 + *[0-9a-f]*:	0a 15       	sub r5,r5

 10058 + *[0-9a-f]*:	08 14       	sub r4,r4

 10059 + *[0-9a-f]*:	1c 1e       	sub lr,lr

 10060 + *[0-9a-f]*:	0c 1e       	sub lr,r6

 10061 + *[0-9a-f]*:	1a 10       	sub r0,sp

 10062 + *[0-9a-f]*:	18 16       	sub r6,r12

 10063 +

 10064 +[0-9a-f]* <rsub1>:

 10065 + *[0-9a-f]*:	1e 2f       	rsub pc,pc

 10066 + *[0-9a-f]*:	18 2c       	rsub r12,r12

 10067 + *[0-9a-f]*:	0a 25       	rsub r5,r5

 10068 + *[0-9a-f]*:	08 24       	rsub r4,r4

 10069 + *[0-9a-f]*:	1c 2e       	rsub lr,lr

 10070 + *[0-9a-f]*:	1a 2b       	rsub r11,sp

 10071 + *[0-9a-f]*:	08 27       	rsub r7,r4

 10072 + *[0-9a-f]*:	02 29       	rsub r9,r1

 10073 +

 10074 +[0-9a-f]* <cp1>:

 10075 + *[0-9a-f]*:	1e 3f       	cp\.w pc,pc

 10076 + *[0-9a-f]*:	18 3c       	cp\.w r12,r12

 10077 + *[0-9a-f]*:	0a 35       	cp\.w r5,r5

 10078 + *[0-9a-f]*:	08 34       	cp\.w r4,r4

 10079 + *[0-9a-f]*:	1c 3e       	cp\.w lr,lr

 10080 + *[0-9a-f]*:	04 36       	cp\.w r6,r2

 10081 + *[0-9a-f]*:	12 30       	cp\.w r0,r9

 10082 + *[0-9a-f]*:	1a 33       	cp\.w r3,sp

 10083 +

 10084 +[0-9a-f]* <or1>:

 10085 + *[0-9a-f]*:	1e 4f       	or pc,pc

 10086 + *[0-9a-f]*:	18 4c       	or r12,r12

 10087 + *[0-9a-f]*:	0a 45       	or r5,r5

 10088 + *[0-9a-f]*:	08 44       	or r4,r4

 10089 + *[0-9a-f]*:	1c 4e       	or lr,lr

 10090 + *[0-9a-f]*:	12 44       	or r4,r9

 10091 + *[0-9a-f]*:	08 4b       	or r11,r4

 10092 + *[0-9a-f]*:	00 44       	or r4,r0

 10093 +

 10094 +[0-9a-f]* <eor1>:

 10095 + *[0-9a-f]*:	1e 5f       	eor pc,pc

 10096 + *[0-9a-f]*:	18 5c       	eor r12,r12

 10097 + *[0-9a-f]*:	0a 55       	eor r5,r5

 10098 + *[0-9a-f]*:	08 54       	eor r4,r4

 10099 + *[0-9a-f]*:	1c 5e       	eor lr,lr

 10100 + *[0-9a-f]*:	16 5c       	eor r12,r11

 10101 + *[0-9a-f]*:	02 50       	eor r0,r1

 10102 + *[0-9a-f]*:	1e 55       	eor r5,pc

 10103 +

 10104 +[0-9a-f]* <and1>:

 10105 + *[0-9a-f]*:	1e 6f       	and pc,pc

 10106 + *[0-9a-f]*:	18 6c       	and r12,r12

 10107 + *[0-9a-f]*:	0a 65       	and r5,r5

 10108 + *[0-9a-f]*:	08 64       	and r4,r4

 10109 + *[0-9a-f]*:	1c 6e       	and lr,lr

 10110 + *[0-9a-f]*:	02 68       	and r8,r1

 10111 + *[0-9a-f]*:	1a 60       	and r0,sp

 10112 + *[0-9a-f]*:	0a 6a       	and r10,r5

 10113 +

 10114 +[0-9a-f]* <tst>:

 10115 + *[0-9a-f]*:	1e 7f       	tst pc,pc

 10116 + *[0-9a-f]*:	18 7c       	tst r12,r12

 10117 + *[0-9a-f]*:	0a 75       	tst r5,r5

 10118 + *[0-9a-f]*:	08 74       	tst r4,r4

 10119 + *[0-9a-f]*:	1c 7e       	tst lr,lr

 10120 + *[0-9a-f]*:	18 70       	tst r0,r12

 10121 + *[0-9a-f]*:	0c 7a       	tst r10,r6

 10122 + *[0-9a-f]*:	08 7d       	tst sp,r4

 10123 +

 10124 +[0-9a-f]* <andn>:

 10125 + *[0-9a-f]*:	1e 8f       	andn pc,pc

 10126 + *[0-9a-f]*:	18 8c       	andn r12,r12

 10127 + *[0-9a-f]*:	0a 85       	andn r5,r5

 10128 + *[0-9a-f]*:	08 84       	andn r4,r4

 10129 + *[0-9a-f]*:	1c 8e       	andn lr,lr

 10130 + *[0-9a-f]*:	18 89       	andn r9,r12

 10131 + *[0-9a-f]*:	1a 8b       	andn r11,sp

 10132 + *[0-9a-f]*:	0a 8c       	andn r12,r5

 10133 +

 10134 +[0-9a-f]* <mov3>:

 10135 + *[0-9a-f]*:	1e 9f       	mov pc,pc

 10136 + *[0-9a-f]*:	18 9c       	mov r12,r12

 10137 + *[0-9a-f]*:	0a 95       	mov r5,r5

 10138 + *[0-9a-f]*:	08 94       	mov r4,r4

 10139 + *[0-9a-f]*:	1c 9e       	mov lr,lr

 10140 + *[0-9a-f]*:	12 95       	mov r5,r9

 10141 + *[0-9a-f]*:	16 9b       	mov r11,r11

 10142 + *[0-9a-f]*:	1c 92       	mov r2,lr

 10143 +

 10144 +[0-9a-f]* <st_w1>:

 10145 + *[0-9a-f]*:	1e af       	st\.w pc\+\+,pc

 10146 + *[0-9a-f]*:	18 ac       	st\.w r12\+\+,r12

 10147 + *[0-9a-f]*:	0a a5       	st\.w r5\+\+,r5

 10148 + *[0-9a-f]*:	08 a4       	st\.w r4\+\+,r4

 10149 + *[0-9a-f]*:	1c ae       	st\.w lr\+\+,lr

 10150 + *[0-9a-f]*:	02 ab       	st\.w r1\+\+,r11

 10151 + *[0-9a-f]*:	1a a0       	st\.w sp\+\+,r0

 10152 + *[0-9a-f]*:	1a a1       	st\.w sp\+\+,r1

 10153 +

 10154 +[0-9a-f]* <st_h1>:

 10155 + *[0-9a-f]*:	1e bf       	st\.h pc\+\+,pc

 10156 + *[0-9a-f]*:	18 bc       	st\.h r12\+\+,r12

 10157 + *[0-9a-f]*:	0a b5       	st\.h r5\+\+,r5

 10158 + *[0-9a-f]*:	08 b4       	st\.h r4\+\+,r4

 10159 + *[0-9a-f]*:	1c be       	st\.h lr\+\+,lr

 10160 + *[0-9a-f]*:	18 bd       	st\.h r12\+\+,sp

 10161 + *[0-9a-f]*:	0e be       	st\.h r7\+\+,lr

 10162 + *[0-9a-f]*:	0e b4       	st\.h r7\+\+,r4

 10163 +

 10164 +[0-9a-f]* <st_b1>:

 10165 + *[0-9a-f]*:	1e cf       	st\.b pc\+\+,pc

 10166 + *[0-9a-f]*:	18 cc       	st\.b r12\+\+,r12

 10167 + *[0-9a-f]*:	0a c5       	st\.b r5\+\+,r5

 10168 + *[0-9a-f]*:	08 c4       	st\.b r4\+\+,r4

 10169 + *[0-9a-f]*:	1c ce       	st\.b lr\+\+,lr

 10170 + *[0-9a-f]*:	12 cd       	st\.b r9\+\+,sp

 10171 + *[0-9a-f]*:	02 cd       	st\.b r1\+\+,sp

 10172 + *[0-9a-f]*:	00 c4       	st\.b r0\+\+,r4

 10173 +

 10174 +[0-9a-f]* <st_w2>:

 10175 + *[0-9a-f]*:	1e df       	st\.w --pc,pc

 10176 + *[0-9a-f]*:	18 dc       	st\.w --r12,r12

 10177 + *[0-9a-f]*:	0a d5       	st\.w --r5,r5

 10178 + *[0-9a-f]*:	08 d4       	st\.w --r4,r4

 10179 + *[0-9a-f]*:	1c de       	st\.w --lr,lr

 10180 + *[0-9a-f]*:	02 d7       	st\.w --r1,r7

 10181 + *[0-9a-f]*:	06 d9       	st\.w --r3,r9

 10182 + *[0-9a-f]*:	0a d5       	st\.w --r5,r5

 10183 +

 10184 +[0-9a-f]* <st_h2>:

 10185 + *[0-9a-f]*:	1e ef       	st\.h --pc,pc

 10186 + *[0-9a-f]*:	18 ec       	st\.h --r12,r12

 10187 + *[0-9a-f]*:	0a e5       	st\.h --r5,r5

 10188 + *[0-9a-f]*:	08 e4       	st\.h --r4,r4

 10189 + *[0-9a-f]*:	1c ee       	st\.h --lr,lr

 10190 + *[0-9a-f]*:	0a e7       	st\.h --r5,r7

 10191 + *[0-9a-f]*:	10 e8       	st\.h --r8,r8

 10192 + *[0-9a-f]*:	0e e2       	st\.h --r7,r2

 10193 +

 10194 +[0-9a-f]* <st_b2>:

 10195 + *[0-9a-f]*:	1e ff       	st\.b --pc,pc

 10196 + *[0-9a-f]*:	18 fc       	st\.b --r12,r12

 10197 + *[0-9a-f]*:	0a f5       	st\.b --r5,r5

 10198 + *[0-9a-f]*:	08 f4       	st\.b --r4,r4

 10199 + *[0-9a-f]*:	1c fe       	st\.b --lr,lr

 10200 + *[0-9a-f]*:	1a fd       	st\.b --sp,sp

 10201 + *[0-9a-f]*:	1a fb       	st\.b --sp,r11

 10202 + *[0-9a-f]*:	08 f5       	st\.b --r4,r5

 10203 +

 10204 +[0-9a-f]* <ld_w1>:

 10205 + *[0-9a-f]*:	1f 0f       	ld\.w pc,pc\+\+

 10206 + *[0-9a-f]*:	19 0c       	ld\.w r12,r12\+\+

 10207 + *[0-9a-f]*:	0b 05       	ld\.w r5,r5\+\+

 10208 + *[0-9a-f]*:	09 04       	ld\.w r4,r4\+\+

 10209 + *[0-9a-f]*:	1d 0e       	ld\.w lr,lr\+\+

 10210 + *[0-9a-f]*:	0f 03       	ld\.w r3,r7\+\+

 10211 + *[0-9a-f]*:	1d 03       	ld\.w r3,lr\+\+

 10212 + *[0-9a-f]*:	0b 0c       	ld\.w r12,r5\+\+

 10213 +

 10214 +[0-9a-f]* <ld_sh1>:

 10215 + *[0-9a-f]*:	1f 1f       	ld\.sh pc,pc\+\+

 10216 + *[0-9a-f]*:	19 1c       	ld\.sh r12,r12\+\+

 10217 + *[0-9a-f]*:	0b 15       	ld\.sh r5,r5\+\+

 10218 + *[0-9a-f]*:	09 14       	ld\.sh r4,r4\+\+

 10219 + *[0-9a-f]*:	1d 1e       	ld\.sh lr,lr\+\+

 10220 + *[0-9a-f]*:	05 1b       	ld\.sh r11,r2\+\+

 10221 + *[0-9a-f]*:	11 12       	ld\.sh r2,r8\+\+

 10222 + *[0-9a-f]*:	0d 17       	ld\.sh r7,r6\+\+

 10223 +

 10224 +[0-9a-f]* <ld_uh1>:

 10225 + *[0-9a-f]*:	1f 2f       	ld\.uh pc,pc\+\+

 10226 + *[0-9a-f]*:	19 2c       	ld\.uh r12,r12\+\+

 10227 + *[0-9a-f]*:	0b 25       	ld\.uh r5,r5\+\+

 10228 + *[0-9a-f]*:	09 24       	ld\.uh r4,r4\+\+

 10229 + *[0-9a-f]*:	1d 2e       	ld\.uh lr,lr\+\+

 10230 + *[0-9a-f]*:	0f 26       	ld\.uh r6,r7\+\+

 10231 + *[0-9a-f]*:	17 2a       	ld\.uh r10,r11\+\+

 10232 + *[0-9a-f]*:	09 2e       	ld\.uh lr,r4\+\+

 10233 +

 10234 +[0-9a-f]* <ld_ub1>:

 10235 + *[0-9a-f]*:	1f 3f       	ld\.ub pc,pc\+\+

 10236 + *[0-9a-f]*:	19 3c       	ld\.ub r12,r12\+\+

 10237 + *[0-9a-f]*:	0b 35       	ld\.ub r5,r5\+\+

 10238 + *[0-9a-f]*:	09 34       	ld\.ub r4,r4\+\+

 10239 + *[0-9a-f]*:	1d 3e       	ld\.ub lr,lr\+\+

 10240 + *[0-9a-f]*:	1d 38       	ld\.ub r8,lr\+\+

 10241 + *[0-9a-f]*:	19 3c       	ld\.ub r12,r12\+\+

 10242 + *[0-9a-f]*:	15 3b       	ld\.ub r11,r10\+\+

 10243 +

 10244 +[0-9a-f]* <ld_w2>:

 10245 + *[0-9a-f]*:	1f 4f       	ld\.w pc,--pc

 10246 + *[0-9a-f]*:	19 4c       	ld\.w r12,--r12

 10247 + *[0-9a-f]*:	0b 45       	ld\.w r5,--r5

 10248 + *[0-9a-f]*:	09 44       	ld\.w r4,--r4

 10249 + *[0-9a-f]*:	1d 4e       	ld\.w lr,--lr

 10250 + *[0-9a-f]*:	1d 4a       	ld\.w r10,--lr

 10251 + *[0-9a-f]*:	13 4c       	ld\.w r12,--r9

 10252 + *[0-9a-f]*:	0b 46       	ld\.w r6,--r5

 10253 +

 10254 +[0-9a-f]* <ld_sh2>:

 10255 + *[0-9a-f]*:	1f 5f       	ld\.sh pc,--pc

 10256 + *[0-9a-f]*:	19 5c       	ld\.sh r12,--r12

 10257 + *[0-9a-f]*:	0b 55       	ld\.sh r5,--r5

 10258 + *[0-9a-f]*:	09 54       	ld\.sh r4,--r4

 10259 + *[0-9a-f]*:	1d 5e       	ld\.sh lr,--lr

 10260 + *[0-9a-f]*:	15 5f       	ld\.sh pc,--r10

 10261 + *[0-9a-f]*:	07 56       	ld\.sh r6,--r3

 10262 + *[0-9a-f]*:	0d 54       	ld\.sh r4,--r6

 10263 +

 10264 +[0-9a-f]* <ld_uh2>:

 10265 + *[0-9a-f]*:	1f 6f       	ld\.uh pc,--pc

 10266 + *[0-9a-f]*:	19 6c       	ld\.uh r12,--r12

 10267 + *[0-9a-f]*:	0b 65       	ld\.uh r5,--r5

 10268 + *[0-9a-f]*:	09 64       	ld\.uh r4,--r4

 10269 + *[0-9a-f]*:	1d 6e       	ld\.uh lr,--lr

 10270 + *[0-9a-f]*:	05 63       	ld\.uh r3,--r2

 10271 + *[0-9a-f]*:	01 61       	ld\.uh r1,--r0

 10272 + *[0-9a-f]*:	13 62       	ld\.uh r2,--r9

 10273 +

 10274 +[0-9a-f]* <ld_ub2>:

 10275 + *[0-9a-f]*:	1f 7f       	ld\.ub pc,--pc

 10276 + *[0-9a-f]*:	19 7c       	ld\.ub r12,--r12

 10277 + *[0-9a-f]*:	0b 75       	ld\.ub r5,--r5

 10278 + *[0-9a-f]*:	09 74       	ld\.ub r4,--r4

 10279 + *[0-9a-f]*:	1d 7e       	ld\.ub lr,--lr

 10280 + *[0-9a-f]*:	03 71       	ld\.ub r1,--r1

 10281 + *[0-9a-f]*:	0d 70       	ld\.ub r0,--r6

 10282 + *[0-9a-f]*:	0f 72       	ld\.ub r2,--r7

 10283 +

 10284 +[0-9a-f]* <ld_ub3>:

 10285 + *[0-9a-f]*:	1f 8f       	ld\.ub pc,pc\[0x0\]

 10286 + *[0-9a-f]*:	19 fc       	ld\.ub r12,r12\[0x7\]

 10287 + *[0-9a-f]*:	0b c5       	ld\.ub r5,r5\[0x4\]

 10288 + *[0-9a-f]*:	09 b4       	ld\.ub r4,r4\[0x3\]

 10289 + *[0-9a-f]*:	1d 9e       	ld\.ub lr,lr\[0x1\]

 10290 + *[0-9a-f]*:	13 e6       	ld\.ub r6,r9\[0x6\]

 10291 + *[0-9a-f]*:	1d c2       	ld\.ub r2,lr\[0x4\]

 10292 + *[0-9a-f]*:	11 81       	ld\.ub r1,r8\[0x0\]

 10293 +

 10294 +[0-9a-f]* <sub3_sp>:

 10295 + *[0-9a-f]*:	20 0d       	sub sp,0

 10296 + *[0-9a-f]*:	2f fd       	sub sp,-4

 10297 + *[0-9a-f]*:	28 0d       	sub sp,-512

 10298 + *[0-9a-f]*:	27 fd       	sub sp,508

 10299 + *[0-9a-f]*:	20 1d       	sub sp,4

 10300 + *[0-9a-f]*:	20 bd       	sub sp,44

 10301 + *[0-9a-f]*:	20 2d       	sub sp,8

 10302 + *[0-9a-f]*:	25 7d       	sub sp,348

 10303 +

 10304 +[0-9a-f]* <sub3>:

 10305 + *[0-9a-f]*:	20 0f       	sub pc,0

 10306 + *[0-9a-f]*:	2f fc       	sub r12,-1

 10307 + *[0-9a-f]*:	28 05       	sub r5,-128

 10308 + *[0-9a-f]*:	27 f4       	sub r4,127

 10309 + *[0-9a-f]*:	20 1e       	sub lr,1

 10310 + *[0-9a-f]*:	2d 76       	sub r6,-41

 10311 + *[0-9a-f]*:	22 54       	sub r4,37

 10312 + *[0-9a-f]*:	23 8c       	sub r12,56

 10313 +

 10314 +[0-9a-f]* <mov1>:

 10315 + *[0-9a-f]*:	30 0f       	mov pc,0

 10316 + *[0-9a-f]*:	3f fc       	mov r12,-1

 10317 + *[0-9a-f]*:	38 05       	mov r5,-128

 10318 + *[0-9a-f]*:	37 f4       	mov r4,127

 10319 + *[0-9a-f]*:	30 1e       	mov lr,1

 10320 + *[0-9a-f]*:	30 ef       	mov pc,14

 10321 + *[0-9a-f]*:	39 c6       	mov r6,-100

 10322 + *[0-9a-f]*:	38 6e       	mov lr,-122

 10323 +

 10324 +[0-9a-f]* <lddsp>:

 10325 + *[0-9a-f]*:	40 0f       	lddsp pc,sp\[0x0\]

 10326 + *[0-9a-f]*:	47 fc       	lddsp r12,sp\[0x1fc\]

 10327 + *[0-9a-f]*:	44 05       	lddsp r5,sp\[0x100\]

 10328 + *[0-9a-f]*:	43 f4       	lddsp r4,sp\[0xfc\]

 10329 + *[0-9a-f]*:	40 1e       	lddsp lr,sp\[0x4\]

 10330 + *[0-9a-f]*:	44 0e       	lddsp lr,sp\[0x100\]

 10331 + *[0-9a-f]*:	40 5c       	lddsp r12,sp\[0x14\]

 10332 + *[0-9a-f]*:	47 69       	lddsp r9,sp\[0x1d8\]

 10333 +

 10334 +[0-9a-f]* <lddpc>:

 10335 + *[0-9a-f]*:	48 0f       	lddpc pc,[0-9a-f]* <.*>

 10336 + *[0-9a-f]*:	4f f0       	lddpc r0,[0-9a-f]* <.*>

 10337 + *[0-9a-f]*:	4c 08       	lddpc r8,[0-9a-f]* <.*>

 10338 + *[0-9a-f]*:	4b f7       	lddpc r7,[0-9a-f]* <.*>

 10339 + *[0-9a-f]*:	48 1e       	lddpc lr,[0-9a-f]* <.*>

 10340 + *[0-9a-f]*:	4f 6d       	lddpc sp,[0-9a-f]* <.*>

 10341 + *[0-9a-f]*:	49 e6       	lddpc r6,[0-9a-f]* <.*>

 10342 + *[0-9a-f]*:	48 7b       	lddpc r11,[0-9a-f]* <.*>

 10343 +

 10344 +[0-9a-f]* <stdsp>:

 10345 + *[0-9a-f]*:	50 0f       	stdsp sp\[0x0\],pc

 10346 + *[0-9a-f]*:	57 fc       	stdsp sp\[0x1fc\],r12

 10347 + *[0-9a-f]*:	54 05       	stdsp sp\[0x100\],r5

 10348 + *[0-9a-f]*:	53 f4       	stdsp sp\[0xfc\],r4

 10349 + *[0-9a-f]*:	50 1e       	stdsp sp\[0x4\],lr

 10350 + *[0-9a-f]*:	54 cf       	stdsp sp\[0x130\],pc

 10351 + *[0-9a-f]*:	54 00       	stdsp sp\[0x100\],r0

 10352 + *[0-9a-f]*:	55 45       	stdsp sp\[0x150\],r5

 10353 +

 10354 +[0-9a-f]* <cp2>:

 10355 + *[0-9a-f]*:	58 0f       	cp.w pc,0

 10356 + *[0-9a-f]*:	5b fc       	cp.w r12,-1

 10357 + *[0-9a-f]*:	5a 05       	cp.w r5,-32

 10358 + *[0-9a-f]*:	59 f4       	cp.w r4,31

 10359 + *[0-9a-f]*:	58 1e       	cp.w lr,1

 10360 + *[0-9a-f]*:	58 38       	cp.w r8,3

 10361 + *[0-9a-f]*:	59 0e       	cp.w lr,16

 10362 + *[0-9a-f]*:	5a 67       	cp.w r7,-26

 10363 +

 10364 +[0-9a-f]* <acr>:

 10365 + *[0-9a-f]*:	5c 0f       	acr pc

 10366 + *[0-9a-f]*:	5c 0c       	acr r12

 10367 + *[0-9a-f]*:	5c 05       	acr r5

 10368 + *[0-9a-f]*:	5c 04       	acr r4

 10369 + *[0-9a-f]*:	5c 0e       	acr lr

 10370 + *[0-9a-f]*:	5c 02       	acr r2

 10371 + *[0-9a-f]*:	5c 0c       	acr r12

 10372 + *[0-9a-f]*:	5c 0f       	acr pc

 10373 +

 10374 +[0-9a-f]* <scr>:

 10375 + *[0-9a-f]*:	5c 1f       	scr pc

 10376 + *[0-9a-f]*:	5c 1c       	scr r12

 10377 + *[0-9a-f]*:	5c 15       	scr r5

 10378 + *[0-9a-f]*:	5c 14       	scr r4

 10379 + *[0-9a-f]*:	5c 1e       	scr lr

 10380 + *[0-9a-f]*:	5c 1f       	scr pc

 10381 + *[0-9a-f]*:	5c 16       	scr r6

 10382 + *[0-9a-f]*:	5c 11       	scr r1

 10383 +

 10384 +[0-9a-f]* <cpc0>:

 10385 + *[0-9a-f]*:	5c 2f       	cpc pc

 10386 + *[0-9a-f]*:	5c 2c       	cpc r12

 10387 + *[0-9a-f]*:	5c 25       	cpc r5

 10388 + *[0-9a-f]*:	5c 24       	cpc r4

 10389 + *[0-9a-f]*:	5c 2e       	cpc lr

 10390 + *[0-9a-f]*:	5c 2f       	cpc pc

 10391 + *[0-9a-f]*:	5c 24       	cpc r4

 10392 + *[0-9a-f]*:	5c 29       	cpc r9

 10393 +

 10394 +[0-9a-f]* <neg>:

 10395 + *[0-9a-f]*:	5c 3f       	neg pc

 10396 + *[0-9a-f]*:	5c 3c       	neg r12

 10397 + *[0-9a-f]*:	5c 35       	neg r5

 10398 + *[0-9a-f]*:	5c 34       	neg r4

 10399 + *[0-9a-f]*:	5c 3e       	neg lr

 10400 + *[0-9a-f]*:	5c 37       	neg r7

 10401 + *[0-9a-f]*:	5c 31       	neg r1

 10402 + *[0-9a-f]*:	5c 39       	neg r9

 10403 +

 10404 +[0-9a-f]* <abs>:

 10405 + *[0-9a-f]*:	5c 4f       	abs pc

 10406 + *[0-9a-f]*:	5c 4c       	abs r12

 10407 + *[0-9a-f]*:	5c 45       	abs r5

 10408 + *[0-9a-f]*:	5c 44       	abs r4

 10409 + *[0-9a-f]*:	5c 4e       	abs lr

 10410 + *[0-9a-f]*:	5c 46       	abs r6

 10411 + *[0-9a-f]*:	5c 46       	abs r6

 10412 + *[0-9a-f]*:	5c 44       	abs r4

 10413 +

 10414 +[0-9a-f]* <castu_b>:

 10415 + *[0-9a-f]*:	5c 5f       	castu\.b pc

 10416 + *[0-9a-f]*:	5c 5c       	castu\.b r12

 10417 + *[0-9a-f]*:	5c 55       	castu\.b r5

 10418 + *[0-9a-f]*:	5c 54       	castu\.b r4

 10419 + *[0-9a-f]*:	5c 5e       	castu\.b lr

 10420 + *[0-9a-f]*:	5c 57       	castu\.b r7

 10421 + *[0-9a-f]*:	5c 5d       	castu\.b sp

 10422 + *[0-9a-f]*:	5c 59       	castu\.b r9

 10423 +

 10424 +[0-9a-f]* <casts_b>:

 10425 + *[0-9a-f]*:	5c 6f       	casts\.b pc

 10426 + *[0-9a-f]*:	5c 6c       	casts\.b r12

 10427 + *[0-9a-f]*:	5c 65       	casts\.b r5

 10428 + *[0-9a-f]*:	5c 64       	casts\.b r4

 10429 + *[0-9a-f]*:	5c 6e       	casts\.b lr

 10430 + *[0-9a-f]*:	5c 6b       	casts\.b r11

 10431 + *[0-9a-f]*:	5c 61       	casts\.b r1

 10432 + *[0-9a-f]*:	5c 6a       	casts\.b r10

 10433 +

 10434 +[0-9a-f]* <castu_h>:

 10435 + *[0-9a-f]*:	5c 7f       	castu\.h pc

 10436 + *[0-9a-f]*:	5c 7c       	castu\.h r12

 10437 + *[0-9a-f]*:	5c 75       	castu\.h r5

 10438 + *[0-9a-f]*:	5c 74       	castu\.h r4

 10439 + *[0-9a-f]*:	5c 7e       	castu\.h lr

 10440 + *[0-9a-f]*:	5c 7a       	castu\.h r10

 10441 + *[0-9a-f]*:	5c 7b       	castu\.h r11

 10442 + *[0-9a-f]*:	5c 71       	castu\.h r1

 10443 +

 10444 +[0-9a-f]* <casts_h>:

 10445 + *[0-9a-f]*:	5c 8f       	casts\.h pc

 10446 + *[0-9a-f]*:	5c 8c       	casts\.h r12

 10447 + *[0-9a-f]*:	5c 85       	casts\.h r5

 10448 + *[0-9a-f]*:	5c 84       	casts\.h r4

 10449 + *[0-9a-f]*:	5c 8e       	casts\.h lr

 10450 + *[0-9a-f]*:	5c 80       	casts\.h r0

 10451 + *[0-9a-f]*:	5c 85       	casts\.h r5

 10452 + *[0-9a-f]*:	5c 89       	casts\.h r9

 10453 +

 10454 +[0-9a-f]* <brev>:

 10455 + *[0-9a-f]*:	5c 9f       	brev pc

 10456 + *[0-9a-f]*:	5c 9c       	brev r12

 10457 + *[0-9a-f]*:	5c 95       	brev r5

 10458 + *[0-9a-f]*:	5c 94       	brev r4

 10459 + *[0-9a-f]*:	5c 9e       	brev lr

 10460 + *[0-9a-f]*:	5c 95       	brev r5

 10461 + *[0-9a-f]*:	5c 9a       	brev r10

 10462 + *[0-9a-f]*:	5c 98       	brev r8

 10463 +

 10464 +[0-9a-f]* <swap_h>:

 10465 + *[0-9a-f]*:	5c af       	swap\.h pc

 10466 + *[0-9a-f]*:	5c ac       	swap\.h r12

 10467 + *[0-9a-f]*:	5c a5       	swap\.h r5

 10468 + *[0-9a-f]*:	5c a4       	swap\.h r4

 10469 + *[0-9a-f]*:	5c ae       	swap\.h lr

 10470 + *[0-9a-f]*:	5c a7       	swap\.h r7

 10471 + *[0-9a-f]*:	5c a0       	swap\.h r0

 10472 + *[0-9a-f]*:	5c a8       	swap\.h r8

 10473 +

 10474 +[0-9a-f]* <swap_b>:

 10475 + *[0-9a-f]*:	5c bf       	swap\.b pc

 10476 + *[0-9a-f]*:	5c bc       	swap\.b r12

 10477 + *[0-9a-f]*:	5c b5       	swap\.b r5

 10478 + *[0-9a-f]*:	5c b4       	swap\.b r4

 10479 + *[0-9a-f]*:	5c be       	swap\.b lr

 10480 + *[0-9a-f]*:	5c ba       	swap\.b r10

 10481 + *[0-9a-f]*:	5c bc       	swap\.b r12

 10482 + *[0-9a-f]*:	5c b1       	swap\.b r1

 10483 +

 10484 +[0-9a-f]* <swap_bh>:

 10485 + *[0-9a-f]*:	5c cf       	swap\.bh pc

 10486 + *[0-9a-f]*:	5c cc       	swap\.bh r12

 10487 + *[0-9a-f]*:	5c c5       	swap\.bh r5

 10488 + *[0-9a-f]*:	5c c4       	swap\.bh r4

 10489 + *[0-9a-f]*:	5c ce       	swap\.bh lr

 10490 + *[0-9a-f]*:	5c c9       	swap\.bh r9

 10491 + *[0-9a-f]*:	5c c4       	swap\.bh r4

 10492 + *[0-9a-f]*:	5c c1       	swap\.bh r1

 10493 +

 10494 +[0-9a-f]* <One_s_compliment>:

 10495 + *[0-9a-f]*:	5c df       	com pc

 10496 + *[0-9a-f]*:	5c dc       	com r12

 10497 + *[0-9a-f]*:	5c d5       	com r5

 10498 + *[0-9a-f]*:	5c d4       	com r4

 10499 + *[0-9a-f]*:	5c de       	com lr

 10500 + *[0-9a-f]*:	5c d2       	com r2

 10501 + *[0-9a-f]*:	5c d2       	com r2

 10502 + *[0-9a-f]*:	5c d7       	com r7

 10503 +

 10504 +[0-9a-f]* <tnbz>:

 10505 + *[0-9a-f]*:	5c ef       	tnbz pc

 10506 + *[0-9a-f]*:	5c ec       	tnbz r12

 10507 + *[0-9a-f]*:	5c e5       	tnbz r5

 10508 + *[0-9a-f]*:	5c e4       	tnbz r4

 10509 + *[0-9a-f]*:	5c ee       	tnbz lr

 10510 + *[0-9a-f]*:	5c e8       	tnbz r8

 10511 + *[0-9a-f]*:	5c ec       	tnbz r12

 10512 + *[0-9a-f]*:	5c ef       	tnbz pc

 10513 +

 10514 +[0-9a-f]* <rol>:

 10515 + *[0-9a-f]*:	5c ff       	rol pc

 10516 + *[0-9a-f]*:	5c fc       	rol r12

 10517 + *[0-9a-f]*:	5c f5       	rol r5

 10518 + *[0-9a-f]*:	5c f4       	rol r4

 10519 + *[0-9a-f]*:	5c fe       	rol lr

 10520 + *[0-9a-f]*:	5c fa       	rol r10

 10521 + *[0-9a-f]*:	5c f9       	rol r9

 10522 + *[0-9a-f]*:	5c f5       	rol r5

 10523 +

 10524 +[0-9a-f]* <ror>:

 10525 + *[0-9a-f]*:	5d 0f       	ror pc

 10526 + *[0-9a-f]*:	5d 0c       	ror r12

 10527 + *[0-9a-f]*:	5d 05       	ror r5

 10528 + *[0-9a-f]*:	5d 04       	ror r4

 10529 + *[0-9a-f]*:	5d 0e       	ror lr

 10530 + *[0-9a-f]*:	5d 08       	ror r8

 10531 + *[0-9a-f]*:	5d 04       	ror r4

 10532 + *[0-9a-f]*:	5d 07       	ror r7

 10533 +

 10534 +[0-9a-f]* <icall>:

 10535 + *[0-9a-f]*:	5d 1f       	icall pc

 10536 + *[0-9a-f]*:	5d 1c       	icall r12

 10537 + *[0-9a-f]*:	5d 15       	icall r5

 10538 + *[0-9a-f]*:	5d 14       	icall r4

 10539 + *[0-9a-f]*:	5d 1e       	icall lr

 10540 + *[0-9a-f]*:	5d 13       	icall r3

 10541 + *[0-9a-f]*:	5d 11       	icall r1

 10542 + *[0-9a-f]*:	5d 13       	icall r3

 10543 +

 10544 +[0-9a-f]* <mustr>:

 10545 + *[0-9a-f]*:	5d 2f       	mustr pc

 10546 + *[0-9a-f]*:	5d 2c       	mustr r12

 10547 + *[0-9a-f]*:	5d 25       	mustr r5

 10548 + *[0-9a-f]*:	5d 24       	mustr r4

 10549 + *[0-9a-f]*:	5d 2e       	mustr lr

 10550 + *[0-9a-f]*:	5d 21       	mustr r1

 10551 + *[0-9a-f]*:	5d 24       	mustr r4

 10552 + *[0-9a-f]*:	5d 2c       	mustr r12

 10553 +

 10554 +[0-9a-f]* <musfr>:

 10555 + *[0-9a-f]*:	5d 3f       	musfr pc

 10556 + *[0-9a-f]*:	5d 3c       	musfr r12

 10557 + *[0-9a-f]*:	5d 35       	musfr r5

 10558 + *[0-9a-f]*:	5d 34       	musfr r4

 10559 + *[0-9a-f]*:	5d 3e       	musfr lr

 10560 + *[0-9a-f]*:	5d 3b       	musfr r11

 10561 + *[0-9a-f]*:	5d 3c       	musfr r12

 10562 + *[0-9a-f]*:	5d 32       	musfr r2

 10563 +

 10564 +[0-9a-f]* <ret_cond>:

 10565 + *[0-9a-f]*:	5e 0f       	reteq 1

 10566 + *[0-9a-f]*:	5e fc       	retal r12

 10567 + *[0-9a-f]*:	5e 85       	retls r5

 10568 + *[0-9a-f]*:	5e 74       	retpl r4

 10569 + *[0-9a-f]*:	5e 1e       	retne -1

 10570 + *[0-9a-f]*:	5e 90       	retgt r0

 10571 + *[0-9a-f]*:	5e 9c       	retgt r12

 10572 + *[0-9a-f]*:	5e 4a       	retge r10

 10573 +

 10574 +[0-9a-f]* <sr_cond>:

 10575 + *[0-9a-f]*:	5f 0f       	sreq pc

 10576 + *[0-9a-f]*:	5f fc       	sral r12

 10577 + *[0-9a-f]*:	5f 85       	srls r5

 10578 + *[0-9a-f]*:	5f 74       	srpl r4

 10579 + *[0-9a-f]*:	5f 1e       	srne lr

 10580 + *[0-9a-f]*:	5f 50       	srlt r0

 10581 + *[0-9a-f]*:	5f fd       	sral sp

 10582 + *[0-9a-f]*:	5f 49       	srge r9

 10583 +

 10584 +[0-9a-f]* <ld_w3>:

 10585 + *[0-9a-f]*:	7e 0f       	ld\.w pc,pc\[0x0\]

 10586 + *[0-9a-f]*:	79 fc       	ld\.w r12,r12\[0x7c\]

 10587 + *[0-9a-f]*:	6b 05       	ld\.w r5,r5\[0x40\]

 10588 + *[0-9a-f]*:	68 f4       	ld\.w r4,r4\[0x3c\]

 10589 + *[0-9a-f]*:	7c 1e       	ld\.w lr,lr\[0x4\]

 10590 + *[0-9a-f]*:	64 dd       	ld\.w sp,r2\[0x34\]

 10591 + *[0-9a-f]*:	62 29       	ld\.w r9,r1\[0x8\]

 10592 + *[0-9a-f]*:	7a f5       	ld\.w r5,sp\[0x3c\]

 10593 +

 10594 +[0-9a-f]* <ld_sh3>:

 10595 + *[0-9a-f]*:	9e 0f       	ld\.sh pc,pc\[0x0\]

 10596 + *[0-9a-f]*:	98 7c       	ld\.sh r12,r12\[0xe\]

 10597 + *[0-9a-f]*:	8a 45       	ld\.sh r5,r5\[0x8\]

 10598 + *[0-9a-f]*:	88 34       	ld\.sh r4,r4\[0x6\]

 10599 + *[0-9a-f]*:	9c 1e       	ld\.sh lr,lr\[0x2\]

 10600 + *[0-9a-f]*:	84 44       	ld\.sh r4,r2\[0x8\]

 10601 + *[0-9a-f]*:	9c 5d       	ld\.sh sp,lr\[0xa\]

 10602 + *[0-9a-f]*:	96 12       	ld\.sh r2,r11\[0x2\]

 10603 +

 10604 +[0-9a-f]* <ld_uh3>:

 10605 + *[0-9a-f]*:	9e 8f       	ld\.uh pc,pc\[0x0\]

 10606 + *[0-9a-f]*:	98 fc       	ld\.uh r12,r12\[0xe\]

 10607 + *[0-9a-f]*:	8a c5       	ld\.uh r5,r5\[0x8\]

 10608 + *[0-9a-f]*:	88 b4       	ld\.uh r4,r4\[0x6\]

 10609 + *[0-9a-f]*:	9c 9e       	ld\.uh lr,lr\[0x2\]

 10610 + *[0-9a-f]*:	80 da       	ld\.uh r10,r0\[0xa\]

 10611 + *[0-9a-f]*:	96 c8       	ld\.uh r8,r11\[0x8\]

 10612 + *[0-9a-f]*:	84 ea       	ld\.uh r10,r2\[0xc\]

 10613 +

 10614 +[0-9a-f]* <st_w3>:

 10615 + *[0-9a-f]*:	9f 0f       	st\.w pc\[0x0\],pc

 10616 + *[0-9a-f]*:	99 fc       	st\.w r12\[0x3c\],r12

 10617 + *[0-9a-f]*:	8b 85       	st\.w r5\[0x20\],r5

 10618 + *[0-9a-f]*:	89 74       	st\.w r4\[0x1c\],r4

 10619 + *[0-9a-f]*:	9d 1e       	st\.w lr\[0x4\],lr

 10620 + *[0-9a-f]*:	8f bb       	st\.w r7\[0x2c\],r11

 10621 + *[0-9a-f]*:	85 66       	st\.w r2\[0x18\],r6

 10622 + *[0-9a-f]*:	89 39       	st\.w r4\[0xc\],r9

 10623 +

 10624 +[0-9a-f]* <st_h3>:

 10625 + *[0-9a-f]*:	be 0f       	st\.h pc\[0x0\],pc

 10626 + *[0-9a-f]*:	b8 7c       	st\.h r12\[0xe\],r12

 10627 + *[0-9a-f]*:	aa 45       	st\.h r5\[0x8\],r5

 10628 + *[0-9a-f]*:	a8 34       	st\.h r4\[0x6\],r4

 10629 + *[0-9a-f]*:	bc 1e       	st\.h lr\[0x2\],lr

 10630 + *[0-9a-f]*:	bc 5c       	st\.h lr\[0xa\],r12

 10631 + *[0-9a-f]*:	ac 20       	st\.h r6\[0x4\],r0

 10632 + *[0-9a-f]*:	aa 6d       	st\.h r5\[0xc\],sp

 10633 +

 10634 +[0-9a-f]* <st_b3>:

 10635 + *[0-9a-f]*:	be 8f       	st\.b pc\[0x0\],pc

 10636 + *[0-9a-f]*:	b8 fc       	st\.b r12\[0x7\],r12

 10637 + *[0-9a-f]*:	aa c5       	st\.b r5\[0x4\],r5

 10638 + *[0-9a-f]*:	a8 b4       	st\.b r4\[0x3\],r4

 10639 + *[0-9a-f]*:	bc 9e       	st\.b lr\[0x1\],lr

 10640 + *[0-9a-f]*:	b8 e9       	st\.b r12\[0x6\],r9

 10641 + *[0-9a-f]*:	a4 be       	st\.b r2\[0x3\],lr

 10642 + *[0-9a-f]*:	a2 bb       	st\.b r1\[0x3\],r11

 10643 +

 10644 +[0-9a-f]* <ldd>:

 10645 + *[0-9a-f]*:	bf 00       	ld\.d r0,pc

 10646 + *[0-9a-f]*:	b9 0e       	ld\.d lr,r12

 10647 + *[0-9a-f]*:	ab 08       	ld\.d r8,r5

 10648 + *[0-9a-f]*:	a9 06       	ld\.d r6,r4

 10649 + *[0-9a-f]*:	bd 02       	ld\.d r2,lr

 10650 + *[0-9a-f]*:	af 0e       	ld\.d lr,r7

 10651 + *[0-9a-f]*:	a9 04       	ld\.d r4,r4

 10652 + *[0-9a-f]*:	bf 0e       	ld\.d lr,pc

 10653 +

 10654 +[0-9a-f]* <ldd_postinc>:

 10655 + *[0-9a-f]*:	bf 01       	ld\.d r0,pc\+\+

 10656 + *[0-9a-f]*:	b9 0f       	ld\.d lr,r12\+\+

 10657 + *[0-9a-f]*:	ab 09       	ld\.d r8,r5\+\+

 10658 + *[0-9a-f]*:	a9 07       	ld\.d r6,r4\+\+

 10659 + *[0-9a-f]*:	bd 03       	ld\.d r2,lr\+\+

 10660 + *[0-9a-f]*:	ab 0f       	ld\.d lr,r5\+\+

 10661 + *[0-9a-f]*:	b7 0d       	ld\.d r12,r11\+\+

 10662 + *[0-9a-f]*:	b9 03       	ld\.d r2,r12\+\+

 10663 +

 10664 +[0-9a-f]* <ldd_predec>:

 10665 + *[0-9a-f]*:	bf 10       	ld\.d r0,--pc

 10666 + *[0-9a-f]*:	b9 1e       	ld\.d lr,--r12

 10667 + *[0-9a-f]*:	ab 18       	ld\.d r8,--r5

 10668 + *[0-9a-f]*:	a9 16       	ld\.d r6,--r4

 10669 + *[0-9a-f]*:	bd 12       	ld\.d r2,--lr

 10670 + *[0-9a-f]*:	a1 18       	ld\.d r8,--r0

 10671 + *[0-9a-f]*:	bf 1a       	ld\.d r10,--pc

 10672 + *[0-9a-f]*:	a9 12       	ld\.d r2,--r4

 10673 +

 10674 +[0-9a-f]* <std>:

 10675 + *[0-9a-f]*:	bf 11       	st\.d pc,r0

 10676 + *[0-9a-f]*:	b9 1f       	st\.d r12,lr

 10677 + *[0-9a-f]*:	ab 19       	st\.d r5,r8

 10678 + *[0-9a-f]*:	a9 17       	st\.d r4,r6

 10679 + *[0-9a-f]*:	bd 13       	st\.d lr,r2

 10680 + *[0-9a-f]*:	a1 1d       	st\.d r0,r12

 10681 + *[0-9a-f]*:	bb 15       	st\.d sp,r4

 10682 + *[0-9a-f]*:	b9 1d       	st\.d r12,r12

 10683 +

 10684 +[0-9a-f]* <std_postinc>:

 10685 + *[0-9a-f]*:	bf 20       	st\.d pc\+\+,r0

 10686 + *[0-9a-f]*:	b9 2e       	st\.d r12\+\+,lr

 10687 + *[0-9a-f]*:	ab 28       	st\.d r5\+\+,r8

 10688 + *[0-9a-f]*:	a9 26       	st\.d r4\+\+,r6

 10689 + *[0-9a-f]*:	bd 22       	st\.d lr\+\+,r2

 10690 + *[0-9a-f]*:	bb 26       	st\.d sp\+\+,r6

 10691 + *[0-9a-f]*:	b5 26       	st\.d r10\+\+,r6

 10692 + *[0-9a-f]*:	af 22       	st\.d r7\+\+,r2

 10693 +

 10694 +[0-9a-f]* <std_predec>:

 10695 + *[0-9a-f]*:	bf 21       	st\.d --pc,r0

 10696 + *[0-9a-f]*:	b9 2f       	st\.d --r12,lr

 10697 + *[0-9a-f]*:	ab 29       	st\.d --r5,r8

 10698 + *[0-9a-f]*:	a9 27       	st\.d --r4,r6

 10699 + *[0-9a-f]*:	bd 23       	st\.d --lr,r2

 10700 + *[0-9a-f]*:	a7 27       	st\.d --r3,r6

 10701 + *[0-9a-f]*:	bd 23       	st\.d --lr,r2

 10702 + *[0-9a-f]*:	a1 25       	st\.d --r0,r4

 10703 +

 10704 +[0-9a-f]* <mul>:

 10705 + *[0-9a-f]*:	bf 3f       	mul pc,pc

 10706 + *[0-9a-f]*:	b9 3c       	mul r12,r12

 10707 + *[0-9a-f]*:	ab 35       	mul r5,r5

 10708 + *[0-9a-f]*:	a9 34       	mul r4,r4

 10709 + *[0-9a-f]*:	bd 3e       	mul lr,lr

 10710 + *[0-9a-f]*:	bd 3a       	mul r10,lr

 10711 + *[0-9a-f]*:	b1 30       	mul r0,r8

 10712 + *[0-9a-f]*:	ab 38       	mul r8,r5

 10713 +

 10714 +[0-9a-f]* <asr_imm5>:

 10715 + *[0-9a-f]*:	a1 4f       	asr pc,0x0

 10716 + *[0-9a-f]*:	bf 5c       	asr r12,0x1f

 10717 + *[0-9a-f]*:	b1 45       	asr r5,0x10

 10718 + *[0-9a-f]*:	af 54       	asr r4,0xf

 10719 + *[0-9a-f]*:	a1 5e       	asr lr,0x1

 10720 + *[0-9a-f]*:	b7 56       	asr r6,0x17

 10721 + *[0-9a-f]*:	b3 46       	asr r6,0x12

 10722 + *[0-9a-f]*:	a9 45       	asr r5,0x8

 10723 +

 10724 +[0-9a-f]* <lsl_imm5>:

 10725 + *[0-9a-f]*:	a1 6f       	lsl pc,0x0

 10726 + *[0-9a-f]*:	bf 7c       	lsl r12,0x1f

 10727 + *[0-9a-f]*:	b1 65       	lsl r5,0x10

 10728 + *[0-9a-f]*:	af 74       	lsl r4,0xf

 10729 + *[0-9a-f]*:	a1 7e       	lsl lr,0x1

 10730 + *[0-9a-f]*:	ad 7c       	lsl r12,0xd

 10731 + *[0-9a-f]*:	b1 66       	lsl r6,0x10

 10732 + *[0-9a-f]*:	b9 71       	lsl r1,0x19

 10733 +

 10734 +[0-9a-f]* <lsr_imm5>:

 10735 + *[0-9a-f]*:	a1 8f       	lsr pc,0x0

 10736 + *[0-9a-f]*:	bf 9c       	lsr r12,0x1f

 10737 + *[0-9a-f]*:	b1 85       	lsr r5,0x10

 10738 + *[0-9a-f]*:	af 94       	lsr r4,0xf

 10739 + *[0-9a-f]*:	a1 9e       	lsr lr,0x1

 10740 + *[0-9a-f]*:	a1 90       	lsr r0,0x1

 10741 + *[0-9a-f]*:	ab 88       	lsr r8,0xa

 10742 + *[0-9a-f]*:	bb 87       	lsr r7,0x1a

 10743 +

 10744 +[0-9a-f]* <sbr>:

 10745 + *[0-9a-f]*:	a1 af       	sbr pc,0x0

 10746 + *[0-9a-f]*:	bf bc       	sbr r12,0x1f

 10747 + *[0-9a-f]*:	b1 a5       	sbr r5,0x10

 10748 + *[0-9a-f]*:	af b4       	sbr r4,0xf

 10749 + *[0-9a-f]*:	a1 be       	sbr lr,0x1

 10750 + *[0-9a-f]*:	bf b8       	sbr r8,0x1f

 10751 + *[0-9a-f]*:	b7 a6       	sbr r6,0x16

 10752 + *[0-9a-f]*:	b7 b1       	sbr r1,0x17

 10753 +

 10754 +[0-9a-f]* <cbr>:

 10755 + *[0-9a-f]*:	a1 cf       	cbr pc,0x0

 10756 + *[0-9a-f]*:	bf dc       	cbr r12,0x1f

 10757 + *[0-9a-f]*:	b1 c5       	cbr r5,0x10

 10758 + *[0-9a-f]*:	af d4       	cbr r4,0xf

 10759 + *[0-9a-f]*:	a1 de       	cbr lr,0x1

 10760 + *[0-9a-f]*:	ab cc       	cbr r12,0xa

 10761 + *[0-9a-f]*:	b7 c7       	cbr r7,0x16

 10762 + *[0-9a-f]*:	a9 d8       	cbr r8,0x9

 10763 +

 10764 +[0-9a-f]* <brc1>:

 10765 + *[0-9a-f]*:	c0 00       	breq [0-9a-f]* <.*>

 10766 + *[0-9a-f]*:	cf f7       	brpl [0-9a-f]* <.*>

 10767 + *[0-9a-f]*:	c8 04       	brge [0-9a-f]* <.*>

 10768 + *[0-9a-f]*:	c7 f3       	brcs [0-9a-f]* <.*>

 10769 + *[0-9a-f]*:	c0 11       	brne [0-9a-f]* <.*>

 10770 + *[0-9a-f]*:	c7 33       	brcs [0-9a-f]* <.*>

 10771 + *[0-9a-f]*:	cf 70       	breq [0-9a-f]* <.*>

 10772 + *[0-9a-f]*:	c0 60       	breq [0-9a-f]* <.*>

 10773 +

 10774 +[0-9a-f]* <rjmp>:

 10775 + *[0-9a-f]*:	c0 08       	rjmp [0-9a-f]* <.*>

 10776 + *[0-9a-f]*:	cf fb       	rjmp [0-9a-f]* <.*>

 10777 + *[0-9a-f]*:	c0 0a       	rjmp [0-9a-f]* <.*>

 10778 + *[0-9a-f]*:	cf f9       	rjmp [0-9a-f]* <.*>

 10779 + *[0-9a-f]*:	c0 18       	rjmp [0-9a-f]* <.*>

 10780 + *[0-9a-f]*:	c1 fa       	rjmp [0-9a-f]* <.*>

 10781 + *[0-9a-f]*:	c0 78       	rjmp [0-9a-f]* <.*>

 10782 + *[0-9a-f]*:	cf ea       	rjmp [0-9a-f]* <.*>

 10783 +

 10784 +[0-9a-f]* <rcall1>:

 10785 + *[0-9a-f]*:	c0 0c       	rcall [0-9a-f]* <.*>

 10786 + *[0-9a-f]*:	cf ff       	rcall [0-9a-f]* <.*>

 10787 + *[0-9a-f]*:	c0 0e       	rcall [0-9a-f]* <.*>

 10788 + *[0-9a-f]*:	cf fd       	rcall [0-9a-f]* <.*>

 10789 + *[0-9a-f]*:	c0 1c       	rcall [0-9a-f]* <.*>

 10790 + *[0-9a-f]*:	c6 cc       	rcall [0-9a-f]* <.*>

 10791 + *[0-9a-f]*:	cf 7e       	rcall [0-9a-f]* <.*>

 10792 + *[0-9a-f]*:	c1 ae       	rcall [0-9a-f]* <.*>

 10793 +

 10794 +[0-9a-f]* <acall>:

 10795 + *[0-9a-f]*:	d0 00       	acall 0x0

 10796 + *[0-9a-f]*:	df f0       	acall 0x3fc

 10797 + *[0-9a-f]*:	d8 00       	acall 0x200

 10798 + *[0-9a-f]*:	d7 f0       	acall 0x1fc

 10799 + *[0-9a-f]*:	d0 10       	acall 0x4

 10800 + *[0-9a-f]*:	d5 90       	acall 0x164

 10801 + *[0-9a-f]*:	d4 c0       	acall 0x130

 10802 + *[0-9a-f]*:	d2 b0       	acall 0xac

 10803 +

 10804 +[0-9a-f]* <scall>:

 10805 + *[0-9a-f]*:	d7 33       	scall

 10806 + *[0-9a-f]*:	d7 33       	scall

 10807 + *[0-9a-f]*:	d7 33       	scall

 10808 + *[0-9a-f]*:	d7 33       	scall

 10809 + *[0-9a-f]*:	d7 33       	scall

 10810 + *[0-9a-f]*:	d7 33       	scall

 10811 + *[0-9a-f]*:	d7 33       	scall

 10812 + *[0-9a-f]*:	d7 33       	scall

 10813 +

 10814 +[0-9a-f]* <popm>:

 10815 + *[0-9a-f]*:	d8 02       	popm pc

 10816 + *[0-9a-f]*:	dd fa       	popm r0-r11,pc,r12=-1

 10817 + *[0-9a-f]*:	d4 02       	popm lr

 10818 + *[0-9a-f]*:	db fa       	popm r0-r11,pc,r12=1

 10819 + *[0-9a-f]*:	d0 12       	popm r0-r3

 10820 + *[0-9a-f]*:	d8 e2       	popm r4-r10,pc

 10821 + *[0-9a-f]*:	d9 1a       	popm r0-r3,r11,pc,r12=0

 10822 + *[0-9a-f]*:	d7 b2       	popm r0-r7,r10-r12,lr

 10823 +

 10824 +[0-9a-f]* <pushm>:

 10825 + *[0-9a-f]*:	d8 01       	pushm pc

 10826 + *[0-9a-f]*:	df f1       	pushm r0-r12,lr-pc

 10827 + *[0-9a-f]*:	d8 01       	pushm pc

 10828 + *[0-9a-f]*:	d7 f1       	pushm r0-r12,lr

 10829 + *[0-9a-f]*:	d0 11       	pushm r0-r3

 10830 + *[0-9a-f]*:	dc c1       	pushm r8-r10,lr-pc

 10831 + *[0-9a-f]*:	d0 91       	pushm r0-r3,r10

 10832 + *[0-9a-f]*:	d2 41       	pushm r8-r9,r12

 10833 +

 10834 +[0-9a-f]* <popm_n>:

 10835 +.*

 10836 +.*

 10837 +.*

 10838 +.*

 10839 +.*

 10840 +.*

 10841 +.*

 10842 +.*

 10843 +

 10844 +[0-9a-f]* <pushm_n>:

 10845 +.*

 10846 +.*

 10847 +.*

 10848 +.*

 10849 +.*

 10850 +.*

 10851 +.*

 10852 +.*

 10853 +

 10854 +[0-9a-f]* <csrfcz>:

 10855 + *[0-9a-f]*:	d0 03       	csrfcz 0x0

 10856 + *[0-9a-f]*:	d1 f3       	csrfcz 0x1f

 10857 + *[0-9a-f]*:	d1 03       	csrfcz 0x10

 10858 + *[0-9a-f]*:	d0 f3       	csrfcz 0xf

 10859 + *[0-9a-f]*:	d0 13       	csrfcz 0x1

 10860 + *[0-9a-f]*:	d0 53       	csrfcz 0x5

 10861 + *[0-9a-f]*:	d0 d3       	csrfcz 0xd

 10862 + *[0-9a-f]*:	d1 73       	csrfcz 0x17

 10863 +

 10864 +[0-9a-f]* <ssrf>:

 10865 + *[0-9a-f]*:	d2 03       	ssrf 0x0

 10866 + *[0-9a-f]*:	d3 f3       	ssrf 0x1f

 10867 + *[0-9a-f]*:	d3 03       	ssrf 0x10

 10868 + *[0-9a-f]*:	d2 f3       	ssrf 0xf

 10869 + *[0-9a-f]*:	d2 13       	ssrf 0x1

 10870 + *[0-9a-f]*:	d3 d3       	ssrf 0x1d

 10871 + *[0-9a-f]*:	d2 d3       	ssrf 0xd

 10872 + *[0-9a-f]*:	d2 d3       	ssrf 0xd

 10873 +

 10874 +[0-9a-f]* <csrf>:

 10875 + *[0-9a-f]*:	d4 03       	csrf 0x0

 10876 + *[0-9a-f]*:	d5 f3       	csrf 0x1f

 10877 + *[0-9a-f]*:	d5 03       	csrf 0x10

 10878 + *[0-9a-f]*:	d4 f3       	csrf 0xf

 10879 + *[0-9a-f]*:	d4 13       	csrf 0x1

 10880 + *[0-9a-f]*:	d4 a3       	csrf 0xa

 10881 + *[0-9a-f]*:	d4 f3       	csrf 0xf

 10882 + *[0-9a-f]*:	d4 b3       	csrf 0xb

 10883 +

 10884 +[0-9a-f]* <rete>:

 10885 + *[0-9a-f]*:	d6 03       	rete

 10886 +

 10887 +[0-9a-f]* <rets>:

 10888 + *[0-9a-f]*:	d6 13       	rets

 10889 +

 10890 +[0-9a-f]* <retd>:

 10891 + *[0-9a-f]*:	d6 23       	retd

 10892 +

 10893 +[0-9a-f]* <retj>:

 10894 + *[0-9a-f]*:	d6 33       	retj

 10895 +

 10896 +[0-9a-f]* <tlbr>:

 10897 + *[0-9a-f]*:	d6 43       	tlbr

 10898 +

 10899 +[0-9a-f]* <tlbs>:

 10900 + *[0-9a-f]*:	d6 53       	tlbs

 10901 +

 10902 +[0-9a-f]* <tlbw>:

 10903 + *[0-9a-f]*:	d6 63       	tlbw

 10904 +

 10905 +[0-9a-f]* <breakpoint>:

 10906 + *[0-9a-f]*:	d6 73       	breakpoint

 10907 +

 10908 +[0-9a-f]* <incjosp>:

 10909 + *[0-9a-f]*:	d6 83       	incjosp 1

 10910 + *[0-9a-f]*:	d6 93       	incjosp 2

 10911 + *[0-9a-f]*:	d6 a3       	incjosp 3

 10912 + *[0-9a-f]*:	d6 b3       	incjosp 4

 10913 + *[0-9a-f]*:	d6 c3       	incjosp -4

 10914 + *[0-9a-f]*:	d6 d3       	incjosp -3

 10915 + *[0-9a-f]*:	d6 e3       	incjosp -2

 10916 + *[0-9a-f]*:	d6 f3       	incjosp -1

 10917 +

 10918 +[0-9a-f]* <nop>:

 10919 + *[0-9a-f]*:	d7 03       	nop

 10920 +

 10921 +[0-9a-f]* <popjc>:

 10922 + *[0-9a-f]*:	d7 13       	popjc

 10923 +

 10924 +[0-9a-f]* <pushjc>:

 10925 + *[0-9a-f]*:	d7 23       	pushjc

 10926 +

 10927 +[0-9a-f]* <add2>:

 10928 + *[0-9a-f]*:	fe 0f 00 0f 	add pc,pc,pc

 10929 + *[0-9a-f]*:	f8 0c 00 3c 	add r12,r12,r12<<0x3

 10930 + *[0-9a-f]*:	ea 05 00 25 	add r5,r5,r5<<0x2

 10931 + *[0-9a-f]*:	e8 04 00 14 	add r4,r4,r4<<0x1

 10932 + *[0-9a-f]*:	fc 0e 00 1e 	add lr,lr,lr<<0x1

 10933 + *[0-9a-f]*:	f8 00 00 10 	add r0,r12,r0<<0x1

 10934 + *[0-9a-f]*:	f8 04 00 09 	add r9,r12,r4

 10935 + *[0-9a-f]*:	f8 07 00 2c 	add r12,r12,r7<<0x2

 10936 +

 10937 +[0-9a-f]* <sub2>:

 10938 + *[0-9a-f]*:	fe 0f 01 0f 	sub pc,pc,pc

 10939 + *[0-9a-f]*:	f8 0c 01 3c 	sub r12,r12,r12<<0x3

 10940 + *[0-9a-f]*:	ea 05 01 25 	sub r5,r5,r5<<0x2

 10941 + *[0-9a-f]*:	e8 04 01 14 	sub r4,r4,r4<<0x1

 10942 + *[0-9a-f]*:	fc 0e 01 1e 	sub lr,lr,lr<<0x1

 10943 + *[0-9a-f]*:	e6 04 01 0d 	sub sp,r3,r4

 10944 + *[0-9a-f]*:	ee 03 01 03 	sub r3,r7,r3

 10945 + *[0-9a-f]*:	f4 0d 01 1d 	sub sp,r10,sp<<0x1

 10946 +

 10947 +[0-9a-f]* <divu>:

 10948 + *[0-9a-f]*:	fe 0f 0d 0f 	divu pc,pc,pc

 10949 + *[0-9a-f]*:	f8 0c 0d 0c 	divu r12,r12,r12

 10950 + *[0-9a-f]*:	ea 05 0d 05 	divu r5,r5,r5

 10951 + *[0-9a-f]*:	e8 04 0d 04 	divu r4,r4,r4

 10952 + *[0-9a-f]*:	fc 0e 0d 0e 	divu lr,lr,lr

 10953 + *[0-9a-f]*:	e8 0f 0d 0d 	divu sp,r4,pc

 10954 + *[0-9a-f]*:	ea 0d 0d 05 	divu r5,r5,sp

 10955 + *[0-9a-f]*:	fa 00 0d 0a 	divu r10,sp,r0

 10956 +

 10957 +[0-9a-f]* <addhh_w>:

 10958 + *[0-9a-f]*:	fe 0f 0e 0f 	addhh\.w pc,pc:b,pc:b

 10959 + *[0-9a-f]*:	f8 0c 0e 3c 	addhh\.w r12,r12:t,r12:t

 10960 + *[0-9a-f]*:	ea 05 0e 35 	addhh\.w r5,r5:t,r5:t

 10961 + *[0-9a-f]*:	e8 04 0e 04 	addhh\.w r4,r4:b,r4:b

 10962 + *[0-9a-f]*:	fc 0e 0e 3e 	addhh\.w lr,lr:t,lr:t

 10963 + *[0-9a-f]*:	e0 03 0e 00 	addhh\.w r0,r0:b,r3:b

 10964 + *[0-9a-f]*:	f8 07 0e 2e 	addhh\.w lr,r12:t,r7:b

 10965 + *[0-9a-f]*:	f4 02 0e 23 	addhh\.w r3,r10:t,r2:b

 10966 +

 10967 +[0-9a-f]* <subhh_w>:

 10968 + *[0-9a-f]*:	fe 0f 0f 0f 	subhh\.w pc,pc:b,pc:b

 10969 + *[0-9a-f]*:	f8 0c 0f 3c 	subhh\.w r12,r12:t,r12:t

 10970 + *[0-9a-f]*:	ea 05 0f 35 	subhh\.w r5,r5:t,r5:t

 10971 + *[0-9a-f]*:	e8 04 0f 04 	subhh\.w r4,r4:b,r4:b

 10972 + *[0-9a-f]*:	fc 0e 0f 3e 	subhh\.w lr,lr:t,lr:t

 10973 + *[0-9a-f]*:	e2 07 0f 2a 	subhh\.w r10,r1:t,r7:b

 10974 + *[0-9a-f]*:	f4 0e 0f 3f 	subhh\.w pc,r10:t,lr:t

 10975 + *[0-9a-f]*:	e0 0c 0f 23 	subhh\.w r3,r0:t,r12:b

 10976 +

 10977 +[0-9a-f]* <adc>:

 10978 + *[0-9a-f]*:	fe 0f 00 4f 	adc pc,pc,pc

 10979 + *[0-9a-f]*:	f8 0c 00 4c 	adc r12,r12,r12

 10980 + *[0-9a-f]*:	ea 05 00 45 	adc r5,r5,r5

 10981 + *[0-9a-f]*:	e8 04 00 44 	adc r4,r4,r4

 10982 + *[0-9a-f]*:	fc 0e 00 4e 	adc lr,lr,lr

 10983 + *[0-9a-f]*:	e0 07 00 44 	adc r4,r0,r7

 10984 + *[0-9a-f]*:	e8 03 00 4d 	adc sp,r4,r3

 10985 + *[0-9a-f]*:	f8 00 00 42 	adc r2,r12,r0

 10986 +

 10987 +[0-9a-f]* <sbc>:

 10988 + *[0-9a-f]*:	fe 0f 01 4f 	sbc pc,pc,pc

 10989 + *[0-9a-f]*:	f8 0c 01 4c 	sbc r12,r12,r12

 10990 + *[0-9a-f]*:	ea 05 01 45 	sbc r5,r5,r5

 10991 + *[0-9a-f]*:	e8 04 01 44 	sbc r4,r4,r4

 10992 + *[0-9a-f]*:	fc 0e 01 4e 	sbc lr,lr,lr

 10993 + *[0-9a-f]*:	ee 09 01 46 	sbc r6,r7,r9

 10994 + *[0-9a-f]*:	f0 05 01 40 	sbc r0,r8,r5

 10995 + *[0-9a-f]*:	e0 04 01 41 	sbc r1,r0,r4

 10996 +

 10997 +[0-9a-f]* <mul_2>:

 10998 + *[0-9a-f]*:	fe 0f 02 4f 	mul pc,pc,pc

 10999 + *[0-9a-f]*:	f8 0c 02 4c 	mul r12,r12,r12

 11000 + *[0-9a-f]*:	ea 05 02 45 	mul r5,r5,r5

 11001 + *[0-9a-f]*:	e8 04 02 44 	mul r4,r4,r4

 11002 + *[0-9a-f]*:	fc 0e 02 4e 	mul lr,lr,lr

 11003 + *[0-9a-f]*:	e0 00 02 4f 	mul pc,r0,r0

 11004 + *[0-9a-f]*:	fe 0e 02 48 	mul r8,pc,lr

 11005 + *[0-9a-f]*:	f8 0f 02 44 	mul r4,r12,pc

 11006 +

 11007 +[0-9a-f]* <mac>:

 11008 + *[0-9a-f]*:	fe 0f 03 4f 	mac pc,pc,pc

 11009 + *[0-9a-f]*:	f8 0c 03 4c 	mac r12,r12,r12

 11010 + *[0-9a-f]*:	ea 05 03 45 	mac r5,r5,r5

 11011 + *[0-9a-f]*:	e8 04 03 44 	mac r4,r4,r4

 11012 + *[0-9a-f]*:	fc 0e 03 4e 	mac lr,lr,lr

 11013 + *[0-9a-f]*:	e8 00 03 4a 	mac r10,r4,r0

 11014 + *[0-9a-f]*:	fc 00 03 47 	mac r7,lr,r0

 11015 + *[0-9a-f]*:	f2 0c 03 42 	mac r2,r9,r12

 11016 +

 11017 +[0-9a-f]* <mulsd>:

 11018 + *[0-9a-f]*:	fe 0f 04 4f 	muls\.d pc,pc,pc

 11019 + *[0-9a-f]*:	f8 0c 04 4c 	muls\.d r12,r12,r12

 11020 + *[0-9a-f]*:	ea 05 04 45 	muls\.d r5,r5,r5

 11021 + *[0-9a-f]*:	e8 04 04 44 	muls\.d r4,r4,r4

 11022 + *[0-9a-f]*:	fc 0e 04 4e 	muls\.d lr,lr,lr

 11023 + *[0-9a-f]*:	f0 0e 04 42 	muls\.d r2,r8,lr

 11024 + *[0-9a-f]*:	e0 0b 04 44 	muls\.d r4,r0,r11

 11025 + *[0-9a-f]*:	fc 06 04 45 	muls\.d r5,lr,r6

 11026 +

 11027 +[0-9a-f]* <macsd>:

 11028 + *[0-9a-f]*:	fe 0f 05 40 	macs\.d r0,pc,pc

 11029 + *[0-9a-f]*:	f8 0c 05 4e 	macs\.d lr,r12,r12

 11030 + *[0-9a-f]*:	ea 05 05 48 	macs\.d r8,r5,r5

 11031 + *[0-9a-f]*:	e8 04 05 46 	macs\.d r6,r4,r4

 11032 + *[0-9a-f]*:	fc 0e 05 42 	macs\.d r2,lr,lr

 11033 + *[0-9a-f]*:	e2 09 05 48 	macs\.d r8,r1,r9

 11034 + *[0-9a-f]*:	f0 08 05 4e 	macs\.d lr,r8,r8

 11035 + *[0-9a-f]*:	e6 0c 05 44 	macs\.d r4,r3,r12

 11036 +

 11037 +[0-9a-f]* <mulud>:

 11038 + *[0-9a-f]*:	fe 0f 06 40 	mulu\.d r0,pc,pc

 11039 + *[0-9a-f]*:	f8 0c 06 4e 	mulu\.d lr,r12,r12

 11040 + *[0-9a-f]*:	ea 05 06 48 	mulu\.d r8,r5,r5

 11041 + *[0-9a-f]*:	e8 04 06 46 	mulu\.d r6,r4,r4

 11042 + *[0-9a-f]*:	fc 0e 06 42 	mulu\.d r2,lr,lr

 11043 + *[0-9a-f]*:	ea 00 06 46 	mulu\.d r6,r5,r0

 11044 + *[0-9a-f]*:	ec 01 06 44 	mulu\.d r4,r6,r1

 11045 + *[0-9a-f]*:	f0 02 06 48 	mulu\.d r8,r8,r2

 11046 +

 11047 +[0-9a-f]* <macud>:

 11048 + *[0-9a-f]*:	fe 0f 07 40 	macu\.d r0,pc,pc

 11049 + *[0-9a-f]*:	f8 0c 07 4e 	macu\.d lr,r12,r12

 11050 + *[0-9a-f]*:	ea 05 07 48 	macu\.d r8,r5,r5

 11051 + *[0-9a-f]*:	e8 04 07 46 	macu\.d r6,r4,r4

 11052 + *[0-9a-f]*:	fc 0e 07 42 	macu\.d r2,lr,lr

 11053 + *[0-9a-f]*:	fa 0b 07 46 	macu\.d r6,sp,r11

 11054 + *[0-9a-f]*:	e8 08 07 42 	macu\.d r2,r4,r8

 11055 + *[0-9a-f]*:	f4 09 07 46 	macu\.d r6,r10,r9

 11056 +

 11057 +[0-9a-f]* <asr_1>:

 11058 + *[0-9a-f]*:	fe 0f 08 4f 	asr pc,pc,pc

 11059 + *[0-9a-f]*:	f8 0c 08 4c 	asr r12,r12,r12

 11060 + *[0-9a-f]*:	ea 05 08 45 	asr r5,r5,r5

 11061 + *[0-9a-f]*:	e8 04 08 44 	asr r4,r4,r4

 11062 + *[0-9a-f]*:	fc 0e 08 4e 	asr lr,lr,lr

 11063 + *[0-9a-f]*:	ec 0f 08 4f 	asr pc,r6,pc

 11064 + *[0-9a-f]*:	ec 0c 08 40 	asr r0,r6,r12

 11065 + *[0-9a-f]*:	fa 00 08 44 	asr r4,sp,r0

 11066 +

 11067 +[0-9a-f]* <lsl_1>:

 11068 + *[0-9a-f]*:	fe 0f 09 4f 	lsl pc,pc,pc

 11069 + *[0-9a-f]*:	f8 0c 09 4c 	lsl r12,r12,r12

 11070 + *[0-9a-f]*:	ea 05 09 45 	lsl r5,r5,r5

 11071 + *[0-9a-f]*:	e8 04 09 44 	lsl r4,r4,r4

 11072 + *[0-9a-f]*:	fc 0e 09 4e 	lsl lr,lr,lr

 11073 + *[0-9a-f]*:	ea 0e 09 4e 	lsl lr,r5,lr

 11074 + *[0-9a-f]*:	fe 03 09 45 	lsl r5,pc,r3

 11075 + *[0-9a-f]*:	fe 09 09 41 	lsl r1,pc,r9

 11076 +

 11077 +[0-9a-f]* <lsr_1>:

 11078 + *[0-9a-f]*:	fe 0f 0a 4f 	lsr pc,pc,pc

 11079 + *[0-9a-f]*:	f8 0c 0a 4c 	lsr r12,r12,r12

 11080 + *[0-9a-f]*:	ea 05 0a 45 	lsr r5,r5,r5

 11081 + *[0-9a-f]*:	e8 04 0a 44 	lsr r4,r4,r4

 11082 + *[0-9a-f]*:	fc 0e 0a 4e 	lsr lr,lr,lr

 11083 + *[0-9a-f]*:	e8 01 0a 42 	lsr r2,r4,r1

 11084 + *[0-9a-f]*:	e2 06 0a 45 	lsr r5,r1,r6

 11085 + *[0-9a-f]*:	ec 07 0a 4d 	lsr sp,r6,r7

 11086 +

 11087 +[0-9a-f]* <xchg>:

 11088 + *[0-9a-f]*:	fe 0f 0b 4f 	xchg pc,pc,pc

 11089 + *[0-9a-f]*:	f8 0c 0b 4c 	xchg r12,r12,r12

 11090 + *[0-9a-f]*:	ea 05 0b 45 	xchg r5,r5,r5

 11091 + *[0-9a-f]*:	e8 04 0b 44 	xchg r4,r4,r4

 11092 + *[0-9a-f]*:	fc 0e 0b 4e 	xchg lr,lr,lr

 11093 + *[0-9a-f]*:	e8 0d 0b 4e 	xchg lr,r4,sp

 11094 + *[0-9a-f]*:	ea 0c 0b 41 	xchg r1,r5,r12

 11095 + *[0-9a-f]*:	f8 00 0b 4e 	xchg lr,r12,r0

 11096 +

 11097 +[0-9a-f]* <max>:

 11098 + *[0-9a-f]*:	fe 0f 0c 4f 	max pc,pc,pc

 11099 + *[0-9a-f]*:	f8 0c 0c 4c 	max r12,r12,r12

 11100 + *[0-9a-f]*:	ea 05 0c 45 	max r5,r5,r5

 11101 + *[0-9a-f]*:	e8 04 0c 44 	max r4,r4,r4

 11102 + *[0-9a-f]*:	fc 0e 0c 4e 	max lr,lr,lr

 11103 + *[0-9a-f]*:	e4 0d 0c 4e 	max lr,r2,sp

 11104 + *[0-9a-f]*:	f4 09 0c 44 	max r4,r10,r9

 11105 + *[0-9a-f]*:	f2 0e 0c 4e 	max lr,r9,lr

 11106 +

 11107 +[0-9a-f]* <min>:

 11108 + *[0-9a-f]*:	fe 0f 0d 4f 	min pc,pc,pc

 11109 + *[0-9a-f]*:	f8 0c 0d 4c 	min r12,r12,r12

 11110 + *[0-9a-f]*:	ea 05 0d 45 	min r5,r5,r5

 11111 + *[0-9a-f]*:	e8 04 0d 44 	min r4,r4,r4

 11112 + *[0-9a-f]*:	fc 0e 0d 4e 	min lr,lr,lr

 11113 + *[0-9a-f]*:	ee 08 0d 49 	min r9,r7,r8

 11114 + *[0-9a-f]*:	ea 05 0d 4d 	min sp,r5,r5

 11115 + *[0-9a-f]*:	e2 04 0d 44 	min r4,r1,r4

 11116 +

 11117 +[0-9a-f]* <addabs>:

 11118 + *[0-9a-f]*:	fe 0f 0e 4f 	addabs pc,pc,pc

 11119 + *[0-9a-f]*:	f8 0c 0e 4c 	addabs r12,r12,r12

 11120 + *[0-9a-f]*:	ea 05 0e 45 	addabs r5,r5,r5

 11121 + *[0-9a-f]*:	e8 04 0e 44 	addabs r4,r4,r4

 11122 + *[0-9a-f]*:	fc 0e 0e 4e 	addabs lr,lr,lr

 11123 + *[0-9a-f]*:	f4 00 0e 47 	addabs r7,r10,r0

 11124 + *[0-9a-f]*:	f2 07 0e 49 	addabs r9,r9,r7

 11125 + *[0-9a-f]*:	f0 0c 0e 42 	addabs r2,r8,r12

 11126 +

 11127 +[0-9a-f]* <mulnhh_w>:

 11128 + *[0-9a-f]*:	fe 0f 01 8f 	mulnhh\.w pc,pc:b,pc:b

 11129 + *[0-9a-f]*:	f8 0c 01 bc 	mulnhh\.w r12,r12:t,r12:t

 11130 + *[0-9a-f]*:	ea 05 01 b5 	mulnhh\.w r5,r5:t,r5:t

 11131 + *[0-9a-f]*:	e8 04 01 84 	mulnhh\.w r4,r4:b,r4:b

 11132 + *[0-9a-f]*:	fc 0e 01 be 	mulnhh\.w lr,lr:t,lr:t

 11133 + *[0-9a-f]*:	fa 09 01 ab 	mulnhh\.w r11,sp:t,r9:b

 11134 + *[0-9a-f]*:	e8 0e 01 9d 	mulnhh\.w sp,r4:b,lr:t

 11135 + *[0-9a-f]*:	e4 0b 01 ac 	mulnhh\.w r12,r2:t,r11:b

 11136 +

 11137 +[0-9a-f]* <mulnwh_d>:

 11138 + *[0-9a-f]*:	fe 0f 02 80 	mulnwh\.d r0,pc,pc:b

 11139 + *[0-9a-f]*:	f8 0c 02 9e 	mulnwh\.d lr,r12,r12:t

 11140 + *[0-9a-f]*:	ea 05 02 98 	mulnwh\.d r8,r5,r5:t

 11141 + *[0-9a-f]*:	e8 04 02 86 	mulnwh\.d r6,r4,r4:b

 11142 + *[0-9a-f]*:	fc 0e 02 92 	mulnwh\.d r2,lr,lr:t

 11143 + *[0-9a-f]*:	e6 02 02 9e 	mulnwh\.d lr,r3,r2:t

 11144 + *[0-9a-f]*:	ea 09 02 84 	mulnwh\.d r4,r5,r9:b

 11145 + *[0-9a-f]*:	e8 04 02 9c 	mulnwh\.d r12,r4,r4:t

 11146 +

 11147 +[0-9a-f]* <machh_w>:

 11148 + *[0-9a-f]*:	fe 0f 04 8f 	machh\.w pc,pc:b,pc:b

 11149 + *[0-9a-f]*:	f8 0c 04 bc 	machh\.w r12,r12:t,r12:t

 11150 + *[0-9a-f]*:	ea 05 04 b5 	machh\.w r5,r5:t,r5:t

 11151 + *[0-9a-f]*:	e8 04 04 84 	machh\.w r4,r4:b,r4:b

 11152 + *[0-9a-f]*:	fc 0e 04 be 	machh\.w lr,lr:t,lr:t

 11153 + *[0-9a-f]*:	ea 01 04 9e 	machh\.w lr,r5:b,r1:t

 11154 + *[0-9a-f]*:	ec 07 04 89 	machh\.w r9,r6:b,r7:b

 11155 + *[0-9a-f]*:	fc 0c 04 a5 	machh\.w r5,lr:t,r12:b

 11156 +

 11157 +[0-9a-f]* <machh_d>:

 11158 + *[0-9a-f]*:	fe 0f 05 80 	machh\.d r0,pc:b,pc:b

 11159 + *[0-9a-f]*:	f8 0c 05 be 	machh\.d lr,r12:t,r12:t

 11160 + *[0-9a-f]*:	ea 05 05 b8 	machh\.d r8,r5:t,r5:t

 11161 + *[0-9a-f]*:	e8 04 05 86 	machh\.d r6,r4:b,r4:b

 11162 + *[0-9a-f]*:	fc 0e 05 b2 	machh\.d r2,lr:t,lr:t

 11163 + *[0-9a-f]*:	e0 08 05 8a 	machh\.d r10,r0:b,r8:b

 11164 + *[0-9a-f]*:	e8 05 05 9e 	machh\.d lr,r4:b,r5:t

 11165 + *[0-9a-f]*:	e0 04 05 98 	machh\.d r8,r0:b,r4:t

 11166 +

 11167 +[0-9a-f]* <macsathh_w>:

 11168 + *[0-9a-f]*:	fe 0f 06 8f 	macsathh\.w pc,pc:b,pc:b

 11169 + *[0-9a-f]*:	f8 0c 06 bc 	macsathh\.w r12,r12:t,r12:t

 11170 + *[0-9a-f]*:	ea 05 06 b5 	macsathh\.w r5,r5:t,r5:t

 11171 + *[0-9a-f]*:	e8 04 06 84 	macsathh\.w r4,r4:b,r4:b

 11172 + *[0-9a-f]*:	fc 0e 06 be 	macsathh\.w lr,lr:t,lr:t

 11173 + *[0-9a-f]*:	ee 0f 06 b7 	macsathh\.w r7,r7:t,pc:t

 11174 + *[0-9a-f]*:	e4 04 06 a4 	macsathh\.w r4,r2:t,r4:b

 11175 + *[0-9a-f]*:	f0 03 06 b4 	macsathh\.w r4,r8:t,r3:t

 11176 +

 11177 +[0-9a-f]* <mulhh_w>:

 11178 + *[0-9a-f]*:	fe 0f 07 8f 	mulhh\.w pc,pc:b,pc:b

 11179 + *[0-9a-f]*:	f8 0c 07 bc 	mulhh\.w r12,r12:t,r12:t

 11180 + *[0-9a-f]*:	ea 05 07 b5 	mulhh\.w r5,r5:t,r5:t

 11181 + *[0-9a-f]*:	e8 04 07 84 	mulhh\.w r4,r4:b,r4:b

 11182 + *[0-9a-f]*:	fc 0e 07 be 	mulhh\.w lr,lr:t,lr:t

 11183 + *[0-9a-f]*:	e8 09 07 a7 	mulhh\.w r7,r4:t,r9:b

 11184 + *[0-9a-f]*:	e6 07 07 bf 	mulhh\.w pc,r3:t,r7:t

 11185 + *[0-9a-f]*:	e8 09 07 9f 	mulhh\.w pc,r4:b,r9:t

 11186 +

 11187 +[0-9a-f]* <mulsathh_h>:

 11188 + *[0-9a-f]*:	fe 0f 08 8f 	mulsathh\.h pc,pc:b,pc:b

 11189 + *[0-9a-f]*:	f8 0c 08 bc 	mulsathh\.h r12,r12:t,r12:t

 11190 + *[0-9a-f]*:	ea 05 08 b5 	mulsathh\.h r5,r5:t,r5:t

 11191 + *[0-9a-f]*:	e8 04 08 84 	mulsathh\.h r4,r4:b,r4:b

 11192 + *[0-9a-f]*:	fc 0e 08 be 	mulsathh\.h lr,lr:t,lr:t

 11193 + *[0-9a-f]*:	e2 0d 08 83 	mulsathh\.h r3,r1:b,sp:b

 11194 + *[0-9a-f]*:	fc 0b 08 ab 	mulsathh\.h r11,lr:t,r11:b

 11195 + *[0-9a-f]*:	f0 0b 08 98 	mulsathh\.h r8,r8:b,r11:t

 11196 +

 11197 +[0-9a-f]* <mulsathh_w>:

 11198 + *[0-9a-f]*:	fe 0f 09 8f 	mulsathh\.w pc,pc:b,pc:b

 11199 + *[0-9a-f]*:	f8 0c 09 bc 	mulsathh\.w r12,r12:t,r12:t

 11200 + *[0-9a-f]*:	ea 05 09 b5 	mulsathh\.w r5,r5:t,r5:t

 11201 + *[0-9a-f]*:	e8 04 09 84 	mulsathh\.w r4,r4:b,r4:b

 11202 + *[0-9a-f]*:	fc 0e 09 be 	mulsathh\.w lr,lr:t,lr:t

 11203 + *[0-9a-f]*:	f6 06 09 ae 	mulsathh\.w lr,r11:t,r6:b

 11204 + *[0-9a-f]*:	ec 07 09 96 	mulsathh\.w r6,r6:b,r7:t

 11205 + *[0-9a-f]*:	e4 03 09 8a 	mulsathh\.w r10,r2:b,r3:b

 11206 +

 11207 +[0-9a-f]* <mulsatrndhh_h>:

 11208 + *[0-9a-f]*:	fe 0f 0a 8f 	mulsatrndhh\.h pc,pc:b,pc:b

 11209 + *[0-9a-f]*:	f8 0c 0a bc 	mulsatrndhh\.h r12,r12:t,r12:t

 11210 + *[0-9a-f]*:	ea 05 0a b5 	mulsatrndhh\.h r5,r5:t,r5:t

 11211 + *[0-9a-f]*:	e8 04 0a 84 	mulsatrndhh\.h r4,r4:b,r4:b

 11212 + *[0-9a-f]*:	fc 0e 0a be 	mulsatrndhh\.h lr,lr:t,lr:t

 11213 + *[0-9a-f]*:	ec 09 0a 8b 	mulsatrndhh\.h r11,r6:b,r9:b

 11214 + *[0-9a-f]*:	e6 08 0a 9b 	mulsatrndhh\.h r11,r3:b,r8:t

 11215 + *[0-9a-f]*:	fa 07 0a b5 	mulsatrndhh\.h r5,sp:t,r7:t

 11216 +

 11217 +[0-9a-f]* <mulsatrndwh_w>:

 11218 + *[0-9a-f]*:	fe 0f 0b 8f 	mulsatrndwh\.w pc,pc,pc:b

 11219 + *[0-9a-f]*:	f8 0c 0b 9c 	mulsatrndwh\.w r12,r12,r12:t

 11220 + *[0-9a-f]*:	ea 05 0b 95 	mulsatrndwh\.w r5,r5,r5:t

 11221 + *[0-9a-f]*:	e8 04 0b 84 	mulsatrndwh\.w r4,r4,r4:b

 11222 + *[0-9a-f]*:	fc 0e 0b 9e 	mulsatrndwh\.w lr,lr,lr:t

 11223 + *[0-9a-f]*:	f8 00 0b 85 	mulsatrndwh\.w r5,r12,r0:b

 11224 + *[0-9a-f]*:	f4 0f 0b 87 	mulsatrndwh\.w r7,r10,pc:b

 11225 + *[0-9a-f]*:	f0 05 0b 9a 	mulsatrndwh\.w r10,r8,r5:t

 11226 +

 11227 +[0-9a-f]* <macwh_d>:

 11228 + *[0-9a-f]*:	fe 0f 0c 80 	macwh\.d r0,pc,pc:b

 11229 + *[0-9a-f]*:	f8 0c 0c 9e 	macwh\.d lr,r12,r12:t

 11230 + *[0-9a-f]*:	ea 05 0c 98 	macwh\.d r8,r5,r5:t

 11231 + *[0-9a-f]*:	e8 04 0c 86 	macwh\.d r6,r4,r4:b

 11232 + *[0-9a-f]*:	fc 0e 0c 92 	macwh\.d r2,lr,lr:t

 11233 + *[0-9a-f]*:	f4 0c 0c 94 	macwh\.d r4,r10,r12:t

 11234 + *[0-9a-f]*:	ee 0d 0c 84 	macwh\.d r4,r7,sp:b

 11235 + *[0-9a-f]*:	f2 0b 0c 8e 	macwh\.d lr,r9,r11:b

 11236 +

 11237 +[0-9a-f]* <mulwh_d>:

 11238 + *[0-9a-f]*:	fe 0f 0d 80 	mulwh\.d r0,pc,pc:b

 11239 + *[0-9a-f]*:	f8 0c 0d 9e 	mulwh\.d lr,r12,r12:t

 11240 + *[0-9a-f]*:	ea 05 0d 98 	mulwh\.d r8,r5,r5:t

 11241 + *[0-9a-f]*:	e8 04 0d 86 	mulwh\.d r6,r4,r4:b

 11242 + *[0-9a-f]*:	fc 0e 0d 92 	mulwh\.d r2,lr,lr:t

 11243 + *[0-9a-f]*:	ea 01 0d 8c 	mulwh\.d r12,r5,r1:b

 11244 + *[0-9a-f]*:	e2 03 0d 90 	mulwh\.d r0,r1,r3:t

 11245 + *[0-9a-f]*:	f2 02 0d 80 	mulwh\.d r0,r9,r2:b

 11246 +

 11247 +[0-9a-f]* <mulsatwh_w>:

 11248 + *[0-9a-f]*:	fe 0f 0e 8f 	mulsatwh\.w pc,pc,pc:b

 11249 + *[0-9a-f]*:	f8 0c 0e 9c 	mulsatwh\.w r12,r12,r12:t

 11250 + *[0-9a-f]*:	ea 05 0e 95 	mulsatwh\.w r5,r5,r5:t

 11251 + *[0-9a-f]*:	e8 04 0e 84 	mulsatwh\.w r4,r4,r4:b

 11252 + *[0-9a-f]*:	fc 0e 0e 9e 	mulsatwh\.w lr,lr,lr:t

 11253 + *[0-9a-f]*:	fe 0a 0e 9b 	mulsatwh\.w r11,pc,r10:t

 11254 + *[0-9a-f]*:	f8 09 0e 9d 	mulsatwh\.w sp,r12,r9:t

 11255 + *[0-9a-f]*:	e6 02 0e 90 	mulsatwh\.w r0,r3,r2:t

 11256 +

 11257 +[0-9a-f]* <ldw7>:

 11258 + *[0-9a-f]*:	fe 0f 0f 8f 	ld\.w pc,pc\[pc:b<<2\]

 11259 + *[0-9a-f]*:	f8 0c 0f bc 	ld\.w r12,r12\[r12:t<<2\]

 11260 + *[0-9a-f]*:	ea 05 0f a5 	ld\.w r5,r5\[r5:u<<2\]

 11261 + *[0-9a-f]*:	e8 04 0f 94 	ld\.w r4,r4\[r4:l<<2\]

 11262 + *[0-9a-f]*:	fc 0e 0f 9e 	ld\.w lr,lr\[lr:l<<2\]

 11263 + *[0-9a-f]*:	f4 06 0f 99 	ld\.w r9,r10\[r6:l<<2\]

 11264 + *[0-9a-f]*:	f4 0a 0f 82 	ld\.w r2,r10\[r10:b<<2\]

 11265 + *[0-9a-f]*:	ea 0f 0f 8b 	ld\.w r11,r5\[pc:b<<2\]

 11266 +

 11267 +[0-9a-f]* <satadd_w>:

 11268 + *[0-9a-f]*:	fe 0f 00 cf 	satadd\.w pc,pc,pc

 11269 + *[0-9a-f]*:	f8 0c 00 cc 	satadd\.w r12,r12,r12

 11270 + *[0-9a-f]*:	ea 05 00 c5 	satadd\.w r5,r5,r5

 11271 + *[0-9a-f]*:	e8 04 00 c4 	satadd\.w r4,r4,r4

 11272 + *[0-9a-f]*:	fc 0e 00 ce 	satadd\.w lr,lr,lr

 11273 + *[0-9a-f]*:	f0 0b 00 c4 	satadd\.w r4,r8,r11

 11274 + *[0-9a-f]*:	f8 06 00 c3 	satadd\.w r3,r12,r6

 11275 + *[0-9a-f]*:	fc 09 00 c3 	satadd\.w r3,lr,r9

 11276 +

 11277 +[0-9a-f]* <satsub_w1>:

 11278 + *[0-9a-f]*:	fe 0f 01 cf 	satsub\.w pc,pc,pc

 11279 + *[0-9a-f]*:	f8 0c 01 cc 	satsub\.w r12,r12,r12

 11280 + *[0-9a-f]*:	ea 05 01 c5 	satsub\.w r5,r5,r5

 11281 + *[0-9a-f]*:	e8 04 01 c4 	satsub\.w r4,r4,r4

 11282 + *[0-9a-f]*:	fc 0e 01 ce 	satsub\.w lr,lr,lr

 11283 + *[0-9a-f]*:	fa 00 01 c8 	satsub\.w r8,sp,r0

 11284 + *[0-9a-f]*:	f0 04 01 c9 	satsub\.w r9,r8,r4

 11285 + *[0-9a-f]*:	fc 02 01 cf 	satsub\.w pc,lr,r2

 11286 +

 11287 +[0-9a-f]* <satadd_h>:

 11288 + *[0-9a-f]*:	fe 0f 02 cf 	satadd\.h pc,pc,pc

 11289 + *[0-9a-f]*:	f8 0c 02 cc 	satadd\.h r12,r12,r12

 11290 + *[0-9a-f]*:	ea 05 02 c5 	satadd\.h r5,r5,r5

 11291 + *[0-9a-f]*:	e8 04 02 c4 	satadd\.h r4,r4,r4

 11292 + *[0-9a-f]*:	fc 0e 02 ce 	satadd\.h lr,lr,lr

 11293 + *[0-9a-f]*:	e6 09 02 c7 	satadd\.h r7,r3,r9

 11294 + *[0-9a-f]*:	e0 02 02 c1 	satadd\.h r1,r0,r2

 11295 + *[0-9a-f]*:	e8 0e 02 c1 	satadd\.h r1,r4,lr

 11296 +

 11297 +[0-9a-f]* <satsub_h>:

 11298 + *[0-9a-f]*:	fe 0f 03 cf 	satsub\.h pc,pc,pc

 11299 + *[0-9a-f]*:	f8 0c 03 cc 	satsub\.h r12,r12,r12

 11300 + *[0-9a-f]*:	ea 05 03 c5 	satsub\.h r5,r5,r5

 11301 + *[0-9a-f]*:	e8 04 03 c4 	satsub\.h r4,r4,r4

 11302 + *[0-9a-f]*:	fc 0e 03 ce 	satsub\.h lr,lr,lr

 11303 + *[0-9a-f]*:	fc 03 03 ce 	satsub\.h lr,lr,r3

 11304 + *[0-9a-f]*:	ec 05 03 cb 	satsub\.h r11,r6,r5

 11305 + *[0-9a-f]*:	fa 00 03 c3 	satsub\.h r3,sp,r0

 11306 +

 11307 +[0-9a-f]* <mul3>:

 11308 + *[0-9a-f]*:	fe 0f 10 00 	mul pc,pc,0

 11309 + *[0-9a-f]*:	f8 0c 10 ff 	mul r12,r12,-1

 11310 + *[0-9a-f]*:	ea 05 10 80 	mul r5,r5,-128

 11311 + *[0-9a-f]*:	e8 04 10 7f 	mul r4,r4,127

 11312 + *[0-9a-f]*:	fc 0e 10 01 	mul lr,lr,1

 11313 + *[0-9a-f]*:	e4 0c 10 f9 	mul r12,r2,-7

 11314 + *[0-9a-f]*:	fe 01 10 5f 	mul r1,pc,95

 11315 + *[0-9a-f]*:	ec 04 10 13 	mul r4,r6,19

 11316 +

 11317 +[0-9a-f]* <rsub2>:

 11318 + *[0-9a-f]*:	fe 0f 11 00 	rsub pc,pc,0

 11319 + *[0-9a-f]*:	f8 0c 11 ff 	rsub r12,r12,-1

 11320 + *[0-9a-f]*:	ea 05 11 80 	rsub r5,r5,-128

 11321 + *[0-9a-f]*:	e8 04 11 7f 	rsub r4,r4,127

 11322 + *[0-9a-f]*:	fc 0e 11 01 	rsub lr,lr,1

 11323 + *[0-9a-f]*:	fc 09 11 60 	rsub r9,lr,96

 11324 + *[0-9a-f]*:	e2 0b 11 38 	rsub r11,r1,56

 11325 + *[0-9a-f]*:	ee 00 11 a9 	rsub r0,r7,-87

 11326 +

 11327 +[0-9a-f]* <clz>:

 11328 + *[0-9a-f]*:	fe 0f 12 00 	clz pc,pc

 11329 + *[0-9a-f]*:	f8 0c 12 00 	clz r12,r12

 11330 + *[0-9a-f]*:	ea 05 12 00 	clz r5,r5

 11331 + *[0-9a-f]*:	e8 04 12 00 	clz r4,r4

 11332 + *[0-9a-f]*:	fc 0e 12 00 	clz lr,lr

 11333 + *[0-9a-f]*:	e6 02 12 00 	clz r2,r3

 11334 + *[0-9a-f]*:	f6 05 12 00 	clz r5,r11

 11335 + *[0-9a-f]*:	e6 0f 12 00 	clz pc,r3

 11336 +

 11337 +[0-9a-f]* <cpc1>:

 11338 + *[0-9a-f]*:	fe 0f 13 00 	cpc pc,pc

 11339 + *[0-9a-f]*:	f8 0c 13 00 	cpc r12,r12

 11340 + *[0-9a-f]*:	ea 05 13 00 	cpc r5,r5

 11341 + *[0-9a-f]*:	e8 04 13 00 	cpc r4,r4

 11342 + *[0-9a-f]*:	fc 0e 13 00 	cpc lr,lr

 11343 + *[0-9a-f]*:	e8 0f 13 00 	cpc pc,r4

 11344 + *[0-9a-f]*:	f2 05 13 00 	cpc r5,r9

 11345 + *[0-9a-f]*:	ee 06 13 00 	cpc r6,r7

 11346 +

 11347 +[0-9a-f]* <asr3>:

 11348 + *[0-9a-f]*:	fe 0f 14 00 	asr pc,pc,0x0

 11349 + *[0-9a-f]*:	f8 0c 14 1f 	asr r12,r12,0x1f

 11350 + *[0-9a-f]*:	ea 05 14 10 	asr r5,r5,0x10

 11351 + *[0-9a-f]*:	e8 04 14 0f 	asr r4,r4,0xf

 11352 + *[0-9a-f]*:	fc 0e 14 01 	asr lr,lr,0x1

 11353 + *[0-9a-f]*:	f6 04 14 13 	asr r4,r11,0x13

 11354 + *[0-9a-f]*:	fe 0d 14 1a 	asr sp,pc,0x1a

 11355 + *[0-9a-f]*:	fa 0b 14 08 	asr r11,sp,0x8

 11356 +

 11357 +[0-9a-f]* <lsl3>:

 11358 + *[0-9a-f]*:	fe 0f 15 00 	lsl pc,pc,0x0

 11359 + *[0-9a-f]*:	f8 0c 15 1f 	lsl r12,r12,0x1f

 11360 + *[0-9a-f]*:	ea 05 15 10 	lsl r5,r5,0x10

 11361 + *[0-9a-f]*:	e8 04 15 0f 	lsl r4,r4,0xf

 11362 + *[0-9a-f]*:	fc 0e 15 01 	lsl lr,lr,0x1

 11363 + *[0-9a-f]*:	f4 08 15 11 	lsl r8,r10,0x11

 11364 + *[0-9a-f]*:	fc 02 15 03 	lsl r2,lr,0x3

 11365 + *[0-9a-f]*:	f6 0e 15 0e 	lsl lr,r11,0xe

 11366 +

 11367 +[0-9a-f]* <lsr3>:

 11368 + *[0-9a-f]*:	fe 0f 16 00 	lsr pc,pc,0x0

 11369 + *[0-9a-f]*:	f8 0c 16 1f 	lsr r12,r12,0x1f

 11370 + *[0-9a-f]*:	ea 05 16 10 	lsr r5,r5,0x10

 11371 + *[0-9a-f]*:	e8 04 16 0f 	lsr r4,r4,0xf

 11372 + *[0-9a-f]*:	fc 0e 16 01 	lsr lr,lr,0x1

 11373 + *[0-9a-f]*:	e6 04 16 1f 	lsr r4,r3,0x1f

 11374 + *[0-9a-f]*:	f2 0f 16 0e 	lsr pc,r9,0xe

 11375 + *[0-9a-f]*:	e0 03 16 06 	lsr r3,r0,0x6

 11376 +

 11377 +[0-9a-f]* <movc1>:

 11378 + *[0-9a-f]*:	fe 0f 17 00 	moveq pc,pc

 11379 + *[0-9a-f]*:	f8 0c 17 f0 	moval r12,r12

 11380 + *[0-9a-f]*:	ea 05 17 80 	movls r5,r5

 11381 + *[0-9a-f]*:	e8 04 17 70 	movpl r4,r4

 11382 + *[0-9a-f]*:	fc 0e 17 10 	movne lr,lr

 11383 + *[0-9a-f]*:	f6 0f 17 10 	movne pc,r11

 11384 + *[0-9a-f]*:	e4 0a 17 60 	movmi r10,r2

 11385 + *[0-9a-f]*:	f8 08 17 80 	movls r8,r12

 11386 +

 11387 +[0-9a-f]* <padd_h>:

 11388 + *[0-9a-f]*:	fe 0f 20 0f 	padd\.h pc,pc,pc

 11389 + *[0-9a-f]*:	f8 0c 20 0c 	padd\.h r12,r12,r12

 11390 + *[0-9a-f]*:	ea 05 20 05 	padd\.h r5,r5,r5

 11391 + *[0-9a-f]*:	e8 04 20 04 	padd\.h r4,r4,r4

 11392 + *[0-9a-f]*:	fc 0e 20 0e 	padd\.h lr,lr,lr

 11393 + *[0-9a-f]*:	e4 07 20 08 	padd\.h r8,r2,r7

 11394 + *[0-9a-f]*:	e0 03 20 00 	padd\.h r0,r0,r3

 11395 + *[0-9a-f]*:	f6 06 20 0d 	padd\.h sp,r11,r6

 11396 +

 11397 +[0-9a-f]* <psub_h>:

 11398 + *[0-9a-f]*:	fe 0f 20 1f 	psub\.h pc,pc,pc

 11399 + *[0-9a-f]*:	f8 0c 20 1c 	psub\.h r12,r12,r12

 11400 + *[0-9a-f]*:	ea 05 20 15 	psub\.h r5,r5,r5

 11401 + *[0-9a-f]*:	e8 04 20 14 	psub\.h r4,r4,r4

 11402 + *[0-9a-f]*:	fc 0e 20 1e 	psub\.h lr,lr,lr

 11403 + *[0-9a-f]*:	ec 08 20 1e 	psub\.h lr,r6,r8

 11404 + *[0-9a-f]*:	e2 0d 20 10 	psub\.h r0,r1,sp

 11405 + *[0-9a-f]*:	fe 0d 20 1f 	psub\.h pc,pc,sp

 11406 +

 11407 +[0-9a-f]* <paddx_h>:

 11408 + *[0-9a-f]*:	fe 0f 20 2f 	paddx\.h pc,pc,pc

 11409 + *[0-9a-f]*:	f8 0c 20 2c 	paddx\.h r12,r12,r12

 11410 + *[0-9a-f]*:	ea 05 20 25 	paddx\.h r5,r5,r5

 11411 + *[0-9a-f]*:	e8 04 20 24 	paddx\.h r4,r4,r4

 11412 + *[0-9a-f]*:	fc 0e 20 2e 	paddx\.h lr,lr,lr

 11413 + *[0-9a-f]*:	fe 01 20 2f 	paddx\.h pc,pc,r1

 11414 + *[0-9a-f]*:	e8 05 20 2a 	paddx\.h r10,r4,r5

 11415 + *[0-9a-f]*:	fe 02 20 25 	paddx\.h r5,pc,r2

 11416 +

 11417 +[0-9a-f]* <psubx_h>:

 11418 + *[0-9a-f]*:	fe 0f 20 3f 	psubx\.h pc,pc,pc

 11419 + *[0-9a-f]*:	f8 0c 20 3c 	psubx\.h r12,r12,r12

 11420 + *[0-9a-f]*:	ea 05 20 35 	psubx\.h r5,r5,r5

 11421 + *[0-9a-f]*:	e8 04 20 34 	psubx\.h r4,r4,r4

 11422 + *[0-9a-f]*:	fc 0e 20 3e 	psubx\.h lr,lr,lr

 11423 + *[0-9a-f]*:	f8 05 20 35 	psubx\.h r5,r12,r5

 11424 + *[0-9a-f]*:	f0 03 20 33 	psubx\.h r3,r8,r3

 11425 + *[0-9a-f]*:	e4 03 20 35 	psubx\.h r5,r2,r3

 11426 +

 11427 +[0-9a-f]* <padds_sh>:

 11428 + *[0-9a-f]*:	fe 0f 20 4f 	padds\.sh pc,pc,pc

 11429 + *[0-9a-f]*:	f8 0c 20 4c 	padds\.sh r12,r12,r12

 11430 + *[0-9a-f]*:	ea 05 20 45 	padds\.sh r5,r5,r5

 11431 + *[0-9a-f]*:	e8 04 20 44 	padds\.sh r4,r4,r4

 11432 + *[0-9a-f]*:	fc 0e 20 4e 	padds\.sh lr,lr,lr

 11433 + *[0-9a-f]*:	fc 02 20 49 	padds\.sh r9,lr,r2

 11434 + *[0-9a-f]*:	f0 01 20 46 	padds\.sh r6,r8,r1

 11435 + *[0-9a-f]*:	e8 0a 20 46 	padds\.sh r6,r4,r10

 11436 +

 11437 +[0-9a-f]* <psubs_sh>:

 11438 + *[0-9a-f]*:	fe 0f 20 5f 	psubs\.sh pc,pc,pc

 11439 + *[0-9a-f]*:	f8 0c 20 5c 	psubs\.sh r12,r12,r12

 11440 + *[0-9a-f]*:	ea 05 20 55 	psubs\.sh r5,r5,r5

 11441 + *[0-9a-f]*:	e8 04 20 54 	psubs\.sh r4,r4,r4

 11442 + *[0-9a-f]*:	fc 0e 20 5e 	psubs\.sh lr,lr,lr

 11443 + *[0-9a-f]*:	fc 0b 20 56 	psubs\.sh r6,lr,r11

 11444 + *[0-9a-f]*:	f8 04 20 52 	psubs\.sh r2,r12,r4

 11445 + *[0-9a-f]*:	f2 00 20 50 	psubs\.sh r0,r9,r0

 11446 +

 11447 +[0-9a-f]* <paddxs_sh>:

 11448 + *[0-9a-f]*:	fe 0f 20 6f 	paddxs\.sh pc,pc,pc

 11449 + *[0-9a-f]*:	f8 0c 20 6c 	paddxs\.sh r12,r12,r12

 11450 + *[0-9a-f]*:	ea 05 20 65 	paddxs\.sh r5,r5,r5

 11451 + *[0-9a-f]*:	e8 04 20 64 	paddxs\.sh r4,r4,r4

 11452 + *[0-9a-f]*:	fc 0e 20 6e 	paddxs\.sh lr,lr,lr

 11453 + *[0-9a-f]*:	e6 09 20 60 	paddxs\.sh r0,r3,r9

 11454 + *[0-9a-f]*:	f4 0b 20 6f 	paddxs\.sh pc,r10,r11

 11455 + *[0-9a-f]*:	f4 0f 20 6f 	paddxs\.sh pc,r10,pc

 11456 +

 11457 +[0-9a-f]* <psubxs_sh>:

 11458 + *[0-9a-f]*:	fe 0f 20 7f 	psubxs\.sh pc,pc,pc

 11459 + *[0-9a-f]*:	f8 0c 20 7c 	psubxs\.sh r12,r12,r12

 11460 + *[0-9a-f]*:	ea 05 20 75 	psubxs\.sh r5,r5,r5

 11461 + *[0-9a-f]*:	e8 04 20 74 	psubxs\.sh r4,r4,r4

 11462 + *[0-9a-f]*:	fc 0e 20 7e 	psubxs\.sh lr,lr,lr

 11463 + *[0-9a-f]*:	e8 04 20 77 	psubxs\.sh r7,r4,r4

 11464 + *[0-9a-f]*:	f0 03 20 77 	psubxs\.sh r7,r8,r3

 11465 + *[0-9a-f]*:	ec 05 20 7f 	psubxs\.sh pc,r6,r5

 11466 +

 11467 +[0-9a-f]* <padds_uh>:

 11468 + *[0-9a-f]*:	fe 0f 20 8f 	padds\.uh pc,pc,pc

 11469 + *[0-9a-f]*:	f8 0c 20 8c 	padds\.uh r12,r12,r12

 11470 + *[0-9a-f]*:	ea 05 20 85 	padds\.uh r5,r5,r5

 11471 + *[0-9a-f]*:	e8 04 20 84 	padds\.uh r4,r4,r4

 11472 + *[0-9a-f]*:	fc 0e 20 8e 	padds\.uh lr,lr,lr

 11473 + *[0-9a-f]*:	f6 07 20 8c 	padds\.uh r12,r11,r7

 11474 + *[0-9a-f]*:	f0 0e 20 87 	padds\.uh r7,r8,lr

 11475 + *[0-9a-f]*:	f2 07 20 86 	padds\.uh r6,r9,r7

 11476 +

 11477 +[0-9a-f]* <psubs_uh>:

 11478 + *[0-9a-f]*:	fe 0f 20 9f 	psubs\.uh pc,pc,pc

 11479 + *[0-9a-f]*:	f8 0c 20 9c 	psubs\.uh r12,r12,r12

 11480 + *[0-9a-f]*:	ea 05 20 95 	psubs\.uh r5,r5,r5

 11481 + *[0-9a-f]*:	e8 04 20 94 	psubs\.uh r4,r4,r4

 11482 + *[0-9a-f]*:	fc 0e 20 9e 	psubs\.uh lr,lr,lr

 11483 + *[0-9a-f]*:	f4 06 20 9e 	psubs\.uh lr,r10,r6

 11484 + *[0-9a-f]*:	e4 0f 20 9d 	psubs\.uh sp,r2,pc

 11485 + *[0-9a-f]*:	f2 02 20 92 	psubs\.uh r2,r9,r2

 11486 +

 11487 +[0-9a-f]* <paddxs_uh>:

 11488 + *[0-9a-f]*:	fe 0f 20 af 	paddxs\.uh pc,pc,pc

 11489 + *[0-9a-f]*:	f8 0c 20 ac 	paddxs\.uh r12,r12,r12

 11490 + *[0-9a-f]*:	ea 05 20 a5 	paddxs\.uh r5,r5,r5

 11491 + *[0-9a-f]*:	e8 04 20 a4 	paddxs\.uh r4,r4,r4

 11492 + *[0-9a-f]*:	fc 0e 20 ae 	paddxs\.uh lr,lr,lr

 11493 + *[0-9a-f]*:	f2 05 20 a7 	paddxs\.uh r7,r9,r5

 11494 + *[0-9a-f]*:	e2 04 20 a9 	paddxs\.uh r9,r1,r4

 11495 + *[0-9a-f]*:	e4 03 20 a5 	paddxs\.uh r5,r2,r3

 11496 +

 11497 +[0-9a-f]* <psubxs_uh>:

 11498 + *[0-9a-f]*:	fe 0f 20 bf 	psubxs\.uh pc,pc,pc

 11499 + *[0-9a-f]*:	f8 0c 20 bc 	psubxs\.uh r12,r12,r12

 11500 + *[0-9a-f]*:	ea 05 20 b5 	psubxs\.uh r5,r5,r5

 11501 + *[0-9a-f]*:	e8 04 20 b4 	psubxs\.uh r4,r4,r4

 11502 + *[0-9a-f]*:	fc 0e 20 be 	psubxs\.uh lr,lr,lr

 11503 + *[0-9a-f]*:	ea 0d 20 bd 	psubxs\.uh sp,r5,sp

 11504 + *[0-9a-f]*:	ec 06 20 bd 	psubxs\.uh sp,r6,r6

 11505 + *[0-9a-f]*:	f6 08 20 b3 	psubxs\.uh r3,r11,r8

 11506 +

 11507 +[0-9a-f]* <paddh_sh>:

 11508 + *[0-9a-f]*:	fe 0f 20 cf 	paddh\.sh pc,pc,pc

 11509 + *[0-9a-f]*:	f8 0c 20 cc 	paddh\.sh r12,r12,r12

 11510 + *[0-9a-f]*:	ea 05 20 c5 	paddh\.sh r5,r5,r5

 11511 + *[0-9a-f]*:	e8 04 20 c4 	paddh\.sh r4,r4,r4

 11512 + *[0-9a-f]*:	fc 0e 20 ce 	paddh\.sh lr,lr,lr

 11513 + *[0-9a-f]*:	fa 03 20 cc 	paddh\.sh r12,sp,r3

 11514 + *[0-9a-f]*:	ea 03 20 cf 	paddh\.sh pc,r5,r3

 11515 + *[0-9a-f]*:	f0 0d 20 c8 	paddh\.sh r8,r8,sp

 11516 +

 11517 +[0-9a-f]* <psubh_sh>:

 11518 + *[0-9a-f]*:	fe 0f 20 df 	psubh\.sh pc,pc,pc

 11519 + *[0-9a-f]*:	f8 0c 20 dc 	psubh\.sh r12,r12,r12

 11520 + *[0-9a-f]*:	ea 05 20 d5 	psubh\.sh r5,r5,r5

 11521 + *[0-9a-f]*:	e8 04 20 d4 	psubh\.sh r4,r4,r4

 11522 + *[0-9a-f]*:	fc 0e 20 de 	psubh\.sh lr,lr,lr

 11523 + *[0-9a-f]*:	ea 08 20 d1 	psubh\.sh r1,r5,r8

 11524 + *[0-9a-f]*:	e6 06 20 d7 	psubh\.sh r7,r3,r6

 11525 + *[0-9a-f]*:	e6 03 20 d4 	psubh\.sh r4,r3,r3

 11526 +

 11527 +[0-9a-f]* <paddxh_sh>:

 11528 + *[0-9a-f]*:	fe 0f 20 ef 	paddxh\.sh pc,pc,pc

 11529 + *[0-9a-f]*:	f8 0c 20 ec 	paddxh\.sh r12,r12,r12

 11530 + *[0-9a-f]*:	ea 05 20 e5 	paddxh\.sh r5,r5,r5

 11531 + *[0-9a-f]*:	e8 04 20 e4 	paddxh\.sh r4,r4,r4

 11532 + *[0-9a-f]*:	fc 0e 20 ee 	paddxh\.sh lr,lr,lr

 11533 + *[0-9a-f]*:	e0 04 20 e6 	paddxh\.sh r6,r0,r4

 11534 + *[0-9a-f]*:	f0 09 20 e9 	paddxh\.sh r9,r8,r9

 11535 + *[0-9a-f]*:	e0 0d 20 e3 	paddxh\.sh r3,r0,sp

 11536 +

 11537 +[0-9a-f]* <psubxh_sh>:

 11538 + *[0-9a-f]*:	fe 0f 20 ff 	psubxh\.sh pc,pc,pc

 11539 + *[0-9a-f]*:	f8 0c 20 fc 	psubxh\.sh r12,r12,r12

 11540 + *[0-9a-f]*:	ea 05 20 f5 	psubxh\.sh r5,r5,r5

 11541 + *[0-9a-f]*:	e8 04 20 f4 	psubxh\.sh r4,r4,r4

 11542 + *[0-9a-f]*:	fc 0e 20 fe 	psubxh\.sh lr,lr,lr

 11543 + *[0-9a-f]*:	fe 0c 20 f4 	psubxh\.sh r4,pc,r12

 11544 + *[0-9a-f]*:	e8 06 20 f8 	psubxh\.sh r8,r4,r6

 11545 + *[0-9a-f]*:	f2 04 20 fc 	psubxh\.sh r12,r9,r4

 11546 +

 11547 +[0-9a-f]* <paddsub_h>:

 11548 + *[0-9a-f]*:	fe 0f 21 0f 	paddsub\.h pc,pc:b,pc:b

 11549 + *[0-9a-f]*:	f8 0c 21 3c 	paddsub\.h r12,r12:t,r12:t

 11550 + *[0-9a-f]*:	ea 05 21 35 	paddsub\.h r5,r5:t,r5:t

 11551 + *[0-9a-f]*:	e8 04 21 04 	paddsub\.h r4,r4:b,r4:b

 11552 + *[0-9a-f]*:	fc 0e 21 3e 	paddsub\.h lr,lr:t,lr:t

 11553 + *[0-9a-f]*:	e4 0e 21 25 	paddsub\.h r5,r2:t,lr:b

 11554 + *[0-9a-f]*:	e2 08 21 07 	paddsub\.h r7,r1:b,r8:b

 11555 + *[0-9a-f]*:	f4 05 21 36 	paddsub\.h r6,r10:t,r5:t

 11556 +

 11557 +[0-9a-f]* <psubadd_h>:

 11558 + *[0-9a-f]*:	fe 0f 21 4f 	psubadd\.h pc,pc:b,pc:b

 11559 + *[0-9a-f]*:	f8 0c 21 7c 	psubadd\.h r12,r12:t,r12:t

 11560 + *[0-9a-f]*:	ea 05 21 75 	psubadd\.h r5,r5:t,r5:t

 11561 + *[0-9a-f]*:	e8 04 21 44 	psubadd\.h r4,r4:b,r4:b

 11562 + *[0-9a-f]*:	fc 0e 21 7e 	psubadd\.h lr,lr:t,lr:t

 11563 + *[0-9a-f]*:	f6 08 21 79 	psubadd\.h r9,r11:t,r8:t

 11564 + *[0-9a-f]*:	ee 0e 21 7a 	psubadd\.h r10,r7:t,lr:t

 11565 + *[0-9a-f]*:	fe 0f 21 66 	psubadd\.h r6,pc:t,pc:b

 11566 +

 11567 +[0-9a-f]* <paddsubs_sh>:

 11568 + *[0-9a-f]*:	fe 0f 21 8f 	paddsubs\.sh pc,pc:b,pc:b

 11569 + *[0-9a-f]*:	f8 0c 21 bc 	paddsubs\.sh r12,r12:t,r12:t

 11570 + *[0-9a-f]*:	ea 05 21 b5 	paddsubs\.sh r5,r5:t,r5:t

 11571 + *[0-9a-f]*:	e8 04 21 84 	paddsubs\.sh r4,r4:b,r4:b

 11572 + *[0-9a-f]*:	fc 0e 21 be 	paddsubs\.sh lr,lr:t,lr:t

 11573 + *[0-9a-f]*:	fc 00 21 a0 	paddsubs\.sh r0,lr:t,r0:b

 11574 + *[0-9a-f]*:	e4 04 21 b9 	paddsubs\.sh r9,r2:t,r4:t

 11575 + *[0-9a-f]*:	f2 0d 21 bc 	paddsubs\.sh r12,r9:t,sp:t

 11576 +

 11577 +[0-9a-f]* <psubadds_sh>:

 11578 + *[0-9a-f]*:	fe 0f 21 cf 	psubadds\.sh pc,pc:b,pc:b

 11579 + *[0-9a-f]*:	f8 0c 21 fc 	psubadds\.sh r12,r12:t,r12:t

 11580 + *[0-9a-f]*:	ea 05 21 f5 	psubadds\.sh r5,r5:t,r5:t

 11581 + *[0-9a-f]*:	e8 04 21 c4 	psubadds\.sh r4,r4:b,r4:b

 11582 + *[0-9a-f]*:	fc 0e 21 fe 	psubadds\.sh lr,lr:t,lr:t

 11583 + *[0-9a-f]*:	fc 01 21 df 	psubadds\.sh pc,lr:b,r1:t

 11584 + *[0-9a-f]*:	e6 0c 21 cb 	psubadds\.sh r11,r3:b,r12:b

 11585 + *[0-9a-f]*:	e4 08 21 fa 	psubadds\.sh r10,r2:t,r8:t

 11586 +

 11587 +[0-9a-f]* <paddsubs_uh>:

 11588 + *[0-9a-f]*:	fe 0f 22 0f 	paddsubs\.uh pc,pc:b,pc:b

 11589 + *[0-9a-f]*:	f8 0c 22 3c 	paddsubs\.uh r12,r12:t,r12:t

 11590 + *[0-9a-f]*:	ea 05 22 35 	paddsubs\.uh r5,r5:t,r5:t

 11591 + *[0-9a-f]*:	e8 04 22 04 	paddsubs\.uh r4,r4:b,r4:b

 11592 + *[0-9a-f]*:	fc 0e 22 3e 	paddsubs\.uh lr,lr:t,lr:t

 11593 + *[0-9a-f]*:	e4 03 22 09 	paddsubs\.uh r9,r2:b,r3:b

 11594 + *[0-9a-f]*:	fa 07 22 1d 	paddsubs\.uh sp,sp:b,r7:t

 11595 + *[0-9a-f]*:	e0 0a 22 1e 	paddsubs\.uh lr,r0:b,r10:t

 11596 +

 11597 +[0-9a-f]* <psubadds_uh>:

 11598 + *[0-9a-f]*:	fe 0f 22 4f 	psubadds\.uh pc,pc:b,pc:b

 11599 + *[0-9a-f]*:	f8 0c 22 7c 	psubadds\.uh r12,r12:t,r12:t

 11600 + *[0-9a-f]*:	ea 05 22 75 	psubadds\.uh r5,r5:t,r5:t

 11601 + *[0-9a-f]*:	e8 04 22 44 	psubadds\.uh r4,r4:b,r4:b

 11602 + *[0-9a-f]*:	fc 0e 22 7e 	psubadds\.uh lr,lr:t,lr:t

 11603 + *[0-9a-f]*:	f2 0f 22 7c 	psubadds\.uh r12,r9:t,pc:t

 11604 + *[0-9a-f]*:	ec 08 22 48 	psubadds\.uh r8,r6:b,r8:b

 11605 + *[0-9a-f]*:	f0 04 22 48 	psubadds\.uh r8,r8:b,r4:b

 11606 +

 11607 +[0-9a-f]* <paddsubh_sh>:

 11608 + *[0-9a-f]*:	fe 0f 22 8f 	paddsubh\.sh pc,pc:b,pc:b

 11609 + *[0-9a-f]*:	f8 0c 22 bc 	paddsubh\.sh r12,r12:t,r12:t

 11610 + *[0-9a-f]*:	ea 05 22 b5 	paddsubh\.sh r5,r5:t,r5:t

 11611 + *[0-9a-f]*:	e8 04 22 84 	paddsubh\.sh r4,r4:b,r4:b

 11612 + *[0-9a-f]*:	fc 0e 22 be 	paddsubh\.sh lr,lr:t,lr:t

 11613 + *[0-9a-f]*:	f2 09 22 a8 	paddsubh\.sh r8,r9:t,r9:b

 11614 + *[0-9a-f]*:	fa 01 22 b0 	paddsubh\.sh r0,sp:t,r1:t

 11615 + *[0-9a-f]*:	e2 00 22 93 	paddsubh\.sh r3,r1:b,r0:t

 11616 +

 11617 +[0-9a-f]* <psubaddh_sh>:

 11618 + *[0-9a-f]*:	fe 0f 22 cf 	psubaddh\.sh pc,pc:b,pc:b

 11619 + *[0-9a-f]*:	f8 0c 22 fc 	psubaddh\.sh r12,r12:t,r12:t

 11620 + *[0-9a-f]*:	ea 05 22 f5 	psubaddh\.sh r5,r5:t,r5:t

 11621 + *[0-9a-f]*:	e8 04 22 c4 	psubaddh\.sh r4,r4:b,r4:b

 11622 + *[0-9a-f]*:	fc 0e 22 fe 	psubaddh\.sh lr,lr:t,lr:t

 11623 + *[0-9a-f]*:	e6 0a 22 e7 	psubaddh\.sh r7,r3:t,r10:b

 11624 + *[0-9a-f]*:	e4 01 22 f7 	psubaddh\.sh r7,r2:t,r1:t

 11625 + *[0-9a-f]*:	e6 06 22 cb 	psubaddh\.sh r11,r3:b,r6:b

 11626 +

 11627 +[0-9a-f]* <padd_b>:

 11628 + *[0-9a-f]*:	fe 0f 23 0f 	padd\.b pc,pc,pc

 11629 + *[0-9a-f]*:	f8 0c 23 0c 	padd\.b r12,r12,r12

 11630 + *[0-9a-f]*:	ea 05 23 05 	padd\.b r5,r5,r5

 11631 + *[0-9a-f]*:	e8 04 23 04 	padd\.b r4,r4,r4

 11632 + *[0-9a-f]*:	fc 0e 23 0e 	padd\.b lr,lr,lr

 11633 + *[0-9a-f]*:	ec 0f 23 02 	padd\.b r2,r6,pc

 11634 + *[0-9a-f]*:	f2 0c 23 08 	padd\.b r8,r9,r12

 11635 + *[0-9a-f]*:	f8 03 23 05 	padd\.b r5,r12,r3

 11636 +

 11637 +[0-9a-f]* <psub_b>:

 11638 + *[0-9a-f]*:	fe 0f 23 1f 	psub\.b pc,pc,pc

 11639 + *[0-9a-f]*:	f8 0c 23 1c 	psub\.b r12,r12,r12

 11640 + *[0-9a-f]*:	ea 05 23 15 	psub\.b r5,r5,r5

 11641 + *[0-9a-f]*:	e8 04 23 14 	psub\.b r4,r4,r4

 11642 + *[0-9a-f]*:	fc 0e 23 1e 	psub\.b lr,lr,lr

 11643 + *[0-9a-f]*:	f8 0f 23 10 	psub\.b r0,r12,pc

 11644 + *[0-9a-f]*:	fa 0a 23 17 	psub\.b r7,sp,r10

 11645 + *[0-9a-f]*:	fa 0c 23 15 	psub\.b r5,sp,r12

 11646 +

 11647 +[0-9a-f]* <padds_sb>:

 11648 + *[0-9a-f]*:	fe 0f 23 2f 	padds\.sb pc,pc,pc

 11649 + *[0-9a-f]*:	f8 0c 23 2c 	padds\.sb r12,r12,r12

 11650 + *[0-9a-f]*:	ea 05 23 25 	padds\.sb r5,r5,r5

 11651 + *[0-9a-f]*:	e8 04 23 24 	padds\.sb r4,r4,r4

 11652 + *[0-9a-f]*:	fc 0e 23 2e 	padds\.sb lr,lr,lr

 11653 + *[0-9a-f]*:	f6 04 23 2d 	padds\.sb sp,r11,r4

 11654 + *[0-9a-f]*:	f4 0b 23 2b 	padds\.sb r11,r10,r11

 11655 + *[0-9a-f]*:	f8 06 23 25 	padds\.sb r5,r12,r6

 11656 +

 11657 +[0-9a-f]* <psubs_sb>:

 11658 + *[0-9a-f]*:	fe 0f 23 3f 	psubs\.sb pc,pc,pc

 11659 + *[0-9a-f]*:	f8 0c 23 3c 	psubs\.sb r12,r12,r12

 11660 + *[0-9a-f]*:	ea 05 23 35 	psubs\.sb r5,r5,r5

 11661 + *[0-9a-f]*:	e8 04 23 34 	psubs\.sb r4,r4,r4

 11662 + *[0-9a-f]*:	fc 0e 23 3e 	psubs\.sb lr,lr,lr

 11663 + *[0-9a-f]*:	ec 08 23 37 	psubs\.sb r7,r6,r8

 11664 + *[0-9a-f]*:	f4 09 23 3c 	psubs\.sb r12,r10,r9

 11665 + *[0-9a-f]*:	f6 00 23 3f 	psubs\.sb pc,r11,r0

 11666 +

 11667 +[0-9a-f]* <padds_ub>:

 11668 + *[0-9a-f]*:	fe 0f 23 4f 	padds\.ub pc,pc,pc

 11669 + *[0-9a-f]*:	f8 0c 23 4c 	padds\.ub r12,r12,r12

 11670 + *[0-9a-f]*:	ea 05 23 45 	padds\.ub r5,r5,r5

 11671 + *[0-9a-f]*:	e8 04 23 44 	padds\.ub r4,r4,r4

 11672 + *[0-9a-f]*:	fc 0e 23 4e 	padds\.ub lr,lr,lr

 11673 + *[0-9a-f]*:	e4 0b 23 43 	padds\.ub r3,r2,r11

 11674 + *[0-9a-f]*:	f0 01 23 4a 	padds\.ub r10,r8,r1

 11675 + *[0-9a-f]*:	f0 0a 23 4b 	padds\.ub r11,r8,r10

 11676 +

 11677 +[0-9a-f]* <psubs_ub>:

 11678 + *[0-9a-f]*:	fe 0f 23 5f 	psubs\.ub pc,pc,pc

 11679 + *[0-9a-f]*:	f8 0c 23 5c 	psubs\.ub r12,r12,r12

 11680 + *[0-9a-f]*:	ea 05 23 55 	psubs\.ub r5,r5,r5

 11681 + *[0-9a-f]*:	e8 04 23 54 	psubs\.ub r4,r4,r4

 11682 + *[0-9a-f]*:	fc 0e 23 5e 	psubs\.ub lr,lr,lr

 11683 + *[0-9a-f]*:	e4 07 23 50 	psubs\.ub r0,r2,r7

 11684 + *[0-9a-f]*:	ea 03 23 5e 	psubs\.ub lr,r5,r3

 11685 + *[0-9a-f]*:	ee 09 23 56 	psubs\.ub r6,r7,r9

 11686 +

 11687 +[0-9a-f]* <paddh_ub>:

 11688 + *[0-9a-f]*:	fe 0f 23 6f 	paddh\.ub pc,pc,pc

 11689 + *[0-9a-f]*:	f8 0c 23 6c 	paddh\.ub r12,r12,r12

 11690 + *[0-9a-f]*:	ea 05 23 65 	paddh\.ub r5,r5,r5

 11691 + *[0-9a-f]*:	e8 04 23 64 	paddh\.ub r4,r4,r4

 11692 + *[0-9a-f]*:	fc 0e 23 6e 	paddh\.ub lr,lr,lr

 11693 + *[0-9a-f]*:	e2 00 23 6e 	paddh\.ub lr,r1,r0

 11694 + *[0-9a-f]*:	ee 07 23 62 	paddh\.ub r2,r7,r7

 11695 + *[0-9a-f]*:	e2 02 23 62 	paddh\.ub r2,r1,r2

 11696 +

 11697 +[0-9a-f]* <psubh_ub>:

 11698 + *[0-9a-f]*:	fe 0f 23 7f 	psubh\.ub pc,pc,pc

 11699 + *[0-9a-f]*:	f8 0c 23 7c 	psubh\.ub r12,r12,r12

 11700 + *[0-9a-f]*:	ea 05 23 75 	psubh\.ub r5,r5,r5

 11701 + *[0-9a-f]*:	e8 04 23 74 	psubh\.ub r4,r4,r4

 11702 + *[0-9a-f]*:	fc 0e 23 7e 	psubh\.ub lr,lr,lr

 11703 + *[0-9a-f]*:	e2 06 23 70 	psubh\.ub r0,r1,r6

 11704 + *[0-9a-f]*:	fc 0a 23 74 	psubh\.ub r4,lr,r10

 11705 + *[0-9a-f]*:	f0 01 23 79 	psubh\.ub r9,r8,r1

 11706 +

 11707 +[0-9a-f]* <pmax_ub>:

 11708 + *[0-9a-f]*:	fe 0f 23 8f 	pmax\.ub pc,pc,pc

 11709 + *[0-9a-f]*:	f8 0c 23 8c 	pmax\.ub r12,r12,r12

 11710 + *[0-9a-f]*:	ea 05 23 85 	pmax\.ub r5,r5,r5

 11711 + *[0-9a-f]*:	e8 04 23 84 	pmax\.ub r4,r4,r4

 11712 + *[0-9a-f]*:	fc 0e 23 8e 	pmax\.ub lr,lr,lr

 11713 + *[0-9a-f]*:	e4 0b 23 8f 	pmax\.ub pc,r2,r11

 11714 + *[0-9a-f]*:	e2 01 23 8c 	pmax\.ub r12,r1,r1

 11715 + *[0-9a-f]*:	e4 00 23 85 	pmax\.ub r5,r2,r0

 11716 +

 11717 +[0-9a-f]* <pmax_sh>:

 11718 + *[0-9a-f]*:	fe 0f 23 9f 	pmax\.sh pc,pc,pc

 11719 + *[0-9a-f]*:	f8 0c 23 9c 	pmax\.sh r12,r12,r12

 11720 + *[0-9a-f]*:	ea 05 23 95 	pmax\.sh r5,r5,r5

 11721 + *[0-9a-f]*:	e8 04 23 94 	pmax\.sh r4,r4,r4

 11722 + *[0-9a-f]*:	fc 0e 23 9e 	pmax\.sh lr,lr,lr

 11723 + *[0-9a-f]*:	ec 0c 23 9e 	pmax\.sh lr,r6,r12

 11724 + *[0-9a-f]*:	fe 05 23 92 	pmax\.sh r2,pc,r5

 11725 + *[0-9a-f]*:	e4 07 23 9f 	pmax\.sh pc,r2,r7

 11726 +

 11727 +[0-9a-f]* <pmin_ub>:

 11728 + *[0-9a-f]*:	fe 0f 23 af 	pmin\.ub pc,pc,pc

 11729 + *[0-9a-f]*:	f8 0c 23 ac 	pmin\.ub r12,r12,r12

 11730 + *[0-9a-f]*:	ea 05 23 a5 	pmin\.ub r5,r5,r5

 11731 + *[0-9a-f]*:	e8 04 23 a4 	pmin\.ub r4,r4,r4

 11732 + *[0-9a-f]*:	fc 0e 23 ae 	pmin\.ub lr,lr,lr

 11733 + *[0-9a-f]*:	e2 05 23 a8 	pmin\.ub r8,r1,r5

 11734 + *[0-9a-f]*:	f0 03 23 a1 	pmin\.ub r1,r8,r3

 11735 + *[0-9a-f]*:	e4 07 23 a0 	pmin\.ub r0,r2,r7

 11736 +

 11737 +[0-9a-f]* <pmin_sh>:

 11738 + *[0-9a-f]*:	fe 0f 23 bf 	pmin\.sh pc,pc,pc

 11739 + *[0-9a-f]*:	f8 0c 23 bc 	pmin\.sh r12,r12,r12

 11740 + *[0-9a-f]*:	ea 05 23 b5 	pmin\.sh r5,r5,r5

 11741 + *[0-9a-f]*:	e8 04 23 b4 	pmin\.sh r4,r4,r4

 11742 + *[0-9a-f]*:	fc 0e 23 be 	pmin\.sh lr,lr,lr

 11743 + *[0-9a-f]*:	e8 0a 23 b8 	pmin\.sh r8,r4,r10

 11744 + *[0-9a-f]*:	f4 0c 23 be 	pmin\.sh lr,r10,r12

 11745 + *[0-9a-f]*:	ec 02 23 b2 	pmin\.sh r2,r6,r2

 11746 +

 11747 +[0-9a-f]* <pavg_ub>:

 11748 + *[0-9a-f]*:	fe 0f 23 cf 	pavg\.ub pc,pc,pc

 11749 + *[0-9a-f]*:	f8 0c 23 cc 	pavg\.ub r12,r12,r12

 11750 + *[0-9a-f]*:	ea 05 23 c5 	pavg\.ub r5,r5,r5

 11751 + *[0-9a-f]*:	e8 04 23 c4 	pavg\.ub r4,r4,r4

 11752 + *[0-9a-f]*:	fc 0e 23 ce 	pavg\.ub lr,lr,lr

 11753 + *[0-9a-f]*:	e2 06 23 c0 	pavg\.ub r0,r1,r6

 11754 + *[0-9a-f]*:	e6 06 23 c8 	pavg\.ub r8,r3,r6

 11755 + *[0-9a-f]*:	f8 0a 23 cf 	pavg\.ub pc,r12,r10

 11756 +

 11757 +[0-9a-f]* <pavg_sh>:

 11758 + *[0-9a-f]*:	fe 0f 23 df 	pavg\.sh pc,pc,pc

 11759 + *[0-9a-f]*:	f8 0c 23 dc 	pavg\.sh r12,r12,r12

 11760 + *[0-9a-f]*:	ea 05 23 d5 	pavg\.sh r5,r5,r5

 11761 + *[0-9a-f]*:	e8 04 23 d4 	pavg\.sh r4,r4,r4

 11762 + *[0-9a-f]*:	fc 0e 23 de 	pavg\.sh lr,lr,lr

 11763 + *[0-9a-f]*:	fe 0d 23 d9 	pavg\.sh r9,pc,sp

 11764 + *[0-9a-f]*:	fa 03 23 df 	pavg\.sh pc,sp,r3

 11765 + *[0-9a-f]*:	e2 09 23 d6 	pavg\.sh r6,r1,r9

 11766 +

 11767 +[0-9a-f]* <pabs_sb>:

 11768 + *[0-9a-f]*:	e0 0f 23 ef 	pabs\.sb pc,pc

 11769 + *[0-9a-f]*:	e0 0c 23 ec 	pabs\.sb r12,r12

 11770 + *[0-9a-f]*:	e0 05 23 e5 	pabs\.sb r5,r5

 11771 + *[0-9a-f]*:	e0 04 23 e4 	pabs\.sb r4,r4

 11772 + *[0-9a-f]*:	e0 0e 23 ee 	pabs\.sb lr,lr

 11773 + *[0-9a-f]*:	e0 06 23 eb 	pabs\.sb r11,r6

 11774 + *[0-9a-f]*:	e0 09 23 ee 	pabs\.sb lr,r9

 11775 + *[0-9a-f]*:	e0 07 23 ed 	pabs\.sb sp,r7

 11776 +

 11777 +[0-9a-f]* <pabs_sh>:

 11778 + *[0-9a-f]*:	e0 0f 23 ff 	pabs\.sh pc,pc

 11779 + *[0-9a-f]*:	e0 0c 23 fc 	pabs\.sh r12,r12

 11780 + *[0-9a-f]*:	e0 05 23 f5 	pabs\.sh r5,r5

 11781 + *[0-9a-f]*:	e0 04 23 f4 	pabs\.sh r4,r4

 11782 + *[0-9a-f]*:	e0 0e 23 fe 	pabs\.sh lr,lr

 11783 + *[0-9a-f]*:	e0 03 23 ff 	pabs\.sh pc,r3

 11784 + *[0-9a-f]*:	e0 07 23 f5 	pabs\.sh r5,r7

 11785 + *[0-9a-f]*:	e0 00 23 f4 	pabs\.sh r4,r0

 11786 +

 11787 +[0-9a-f]* <psad>:

 11788 + *[0-9a-f]*:	fe 0f 24 0f 	psad pc,pc,pc

 11789 + *[0-9a-f]*:	f8 0c 24 0c 	psad r12,r12,r12

 11790 + *[0-9a-f]*:	ea 05 24 05 	psad r5,r5,r5

 11791 + *[0-9a-f]*:	e8 04 24 04 	psad r4,r4,r4

 11792 + *[0-9a-f]*:	fc 0e 24 0e 	psad lr,lr,lr

 11793 + *[0-9a-f]*:	f6 0b 24 09 	psad r9,r11,r11

 11794 + *[0-9a-f]*:	e8 0d 24 0e 	psad lr,r4,sp

 11795 + *[0-9a-f]*:	e8 05 24 0e 	psad lr,r4,r5

 11796 +

 11797 +[0-9a-f]* <pasr_b>:

 11798 + *[0-9a-f]*:	fe 00 24 1f 	pasr\.b pc,pc,0x0

 11799 + *[0-9a-f]*:	f8 07 24 1c 	pasr\.b r12,r12,0x7

 11800 + *[0-9a-f]*:	ea 04 24 15 	pasr\.b r5,r5,0x4

 11801 + *[0-9a-f]*:	e8 03 24 14 	pasr\.b r4,r4,0x3

 11802 + *[0-9a-f]*:	fc 01 24 1e 	pasr\.b lr,lr,0x1

 11803 + *[0-9a-f]*:	ee 01 24 1f 	pasr\.b pc,r7,0x1

 11804 + *[0-9a-f]*:	fc 06 24 1d 	pasr\.b sp,lr,0x6

 11805 + *[0-9a-f]*:	e6 02 24 1d 	pasr\.b sp,r3,0x2

 11806 +

 11807 +[0-9a-f]* <plsl_b>:

 11808 + *[0-9a-f]*:	fe 00 24 2f 	plsl\.b pc,pc,0x0

 11809 + *[0-9a-f]*:	f8 07 24 2c 	plsl\.b r12,r12,0x7

 11810 + *[0-9a-f]*:	ea 04 24 25 	plsl\.b r5,r5,0x4

 11811 + *[0-9a-f]*:	e8 03 24 24 	plsl\.b r4,r4,0x3

 11812 + *[0-9a-f]*:	fc 01 24 2e 	plsl\.b lr,lr,0x1

 11813 + *[0-9a-f]*:	f6 04 24 22 	plsl\.b r2,r11,0x4

 11814 + *[0-9a-f]*:	ea 07 24 28 	plsl\.b r8,r5,0x7

 11815 + *[0-9a-f]*:	e0 02 24 2f 	plsl\.b pc,r0,0x2

 11816 +

 11817 +[0-9a-f]* <plsr_b>:

 11818 + *[0-9a-f]*:	fe 00 24 3f 	plsr\.b pc,pc,0x0

 11819 + *[0-9a-f]*:	f8 07 24 3c 	plsr\.b r12,r12,0x7

 11820 + *[0-9a-f]*:	ea 04 24 35 	plsr\.b r5,r5,0x4

 11821 + *[0-9a-f]*:	e8 03 24 34 	plsr\.b r4,r4,0x3

 11822 + *[0-9a-f]*:	fc 01 24 3e 	plsr\.b lr,lr,0x1

 11823 + *[0-9a-f]*:	e2 02 24 3c 	plsr\.b r12,r1,0x2

 11824 + *[0-9a-f]*:	fe 07 24 36 	plsr\.b r6,pc,0x7

 11825 + *[0-9a-f]*:	f6 02 24 3c 	plsr\.b r12,r11,0x2

 11826 +

 11827 +[0-9a-f]* <pasr_h>:

 11828 + *[0-9a-f]*:	fe 00 24 4f 	pasr\.h pc,pc,0x0

 11829 + *[0-9a-f]*:	f8 0f 24 4c 	pasr\.h r12,r12,0xf

 11830 + *[0-9a-f]*:	ea 08 24 45 	pasr\.h r5,r5,0x8

 11831 + *[0-9a-f]*:	e8 07 24 44 	pasr\.h r4,r4,0x7

 11832 + *[0-9a-f]*:	fc 01 24 4e 	pasr\.h lr,lr,0x1

 11833 + *[0-9a-f]*:	f6 0a 24 40 	pasr\.h r0,r11,0xa

 11834 + *[0-9a-f]*:	ec 08 24 44 	pasr\.h r4,r6,0x8

 11835 + *[0-9a-f]*:	e4 04 24 46 	pasr\.h r6,r2,0x4

 11836 +

 11837 +[0-9a-f]* <plsl_h>:

 11838 + *[0-9a-f]*:	fe 00 24 5f 	plsl\.h pc,pc,0x0

 11839 + *[0-9a-f]*:	f8 0f 24 5c 	plsl\.h r12,r12,0xf

 11840 + *[0-9a-f]*:	ea 08 24 55 	plsl\.h r5,r5,0x8

 11841 + *[0-9a-f]*:	e8 07 24 54 	plsl\.h r4,r4,0x7

 11842 + *[0-9a-f]*:	fc 01 24 5e 	plsl\.h lr,lr,0x1

 11843 + *[0-9a-f]*:	f4 09 24 55 	plsl\.h r5,r10,0x9

 11844 + *[0-9a-f]*:	fc 08 24 5d 	plsl\.h sp,lr,0x8

 11845 + *[0-9a-f]*:	fc 07 24 50 	plsl\.h r0,lr,0x7

 11846 +

 11847 +[0-9a-f]* <plsr_h>:

 11848 + *[0-9a-f]*:	fe 00 24 6f 	plsr\.h pc,pc,0x0

 11849 + *[0-9a-f]*:	f8 0f 24 6c 	plsr\.h r12,r12,0xf

 11850 + *[0-9a-f]*:	ea 08 24 65 	plsr\.h r5,r5,0x8

 11851 + *[0-9a-f]*:	e8 07 24 64 	plsr\.h r4,r4,0x7

 11852 + *[0-9a-f]*:	fc 01 24 6e 	plsr\.h lr,lr,0x1

 11853 + *[0-9a-f]*:	e0 0f 24 6b 	plsr\.h r11,r0,0xf

 11854 + *[0-9a-f]*:	e6 03 24 6e 	plsr\.h lr,r3,0x3

 11855 + *[0-9a-f]*:	fc 0a 24 68 	plsr\.h r8,lr,0xa

 11856 +

 11857 +[0-9a-f]* <packw_sh>:

 11858 + *[0-9a-f]*:	fe 0f 24 7f 	packw\.sh pc,pc,pc

 11859 + *[0-9a-f]*:	f8 0c 24 7c 	packw\.sh r12,r12,r12

 11860 + *[0-9a-f]*:	ea 05 24 75 	packw\.sh r5,r5,r5

 11861 + *[0-9a-f]*:	e8 04 24 74 	packw\.sh r4,r4,r4

 11862 + *[0-9a-f]*:	fc 0e 24 7e 	packw\.sh lr,lr,lr

 11863 + *[0-9a-f]*:	f6 0a 24 7d 	packw\.sh sp,r11,r10

 11864 + *[0-9a-f]*:	e4 0c 24 78 	packw\.sh r8,r2,r12

 11865 + *[0-9a-f]*:	e2 05 24 78 	packw\.sh r8,r1,r5

 11866 +

 11867 +[0-9a-f]* <punpckub_h>:

 11868 + *[0-9a-f]*:	fe 00 24 8f 	punpckub\.h pc,pc:b

 11869 + *[0-9a-f]*:	f8 00 24 9c 	punpckub\.h r12,r12:t

 11870 + *[0-9a-f]*:	ea 00 24 95 	punpckub\.h r5,r5:t

 11871 + *[0-9a-f]*:	e8 00 24 84 	punpckub\.h r4,r4:b

 11872 + *[0-9a-f]*:	fc 00 24 9e 	punpckub\.h lr,lr:t

 11873 + *[0-9a-f]*:	e2 00 24 96 	punpckub\.h r6,r1:t

 11874 + *[0-9a-f]*:	ea 00 24 8e 	punpckub\.h lr,r5:b

 11875 + *[0-9a-f]*:	e4 00 24 9e 	punpckub\.h lr,r2:t

 11876 +

 11877 +[0-9a-f]* <punpcksb_h>:

 11878 + *[0-9a-f]*:	fe 00 24 af 	punpcksb\.h pc,pc:b

 11879 + *[0-9a-f]*:	f8 00 24 bc 	punpcksb\.h r12,r12:t

 11880 + *[0-9a-f]*:	ea 00 24 b5 	punpcksb\.h r5,r5:t

 11881 + *[0-9a-f]*:	e8 00 24 a4 	punpcksb\.h r4,r4:b

 11882 + *[0-9a-f]*:	fc 00 24 be 	punpcksb\.h lr,lr:t

 11883 + *[0-9a-f]*:	ee 00 24 b4 	punpcksb\.h r4,r7:t

 11884 + *[0-9a-f]*:	fc 00 24 a6 	punpcksb\.h r6,lr:b

 11885 + *[0-9a-f]*:	f8 00 24 bc 	punpcksb\.h r12,r12:t

 11886 +

 11887 +[0-9a-f]* <packsh_ub>:

 11888 + *[0-9a-f]*:	fe 0f 24 cf 	packsh\.ub pc,pc,pc

 11889 + *[0-9a-f]*:	f8 0c 24 cc 	packsh\.ub r12,r12,r12

 11890 + *[0-9a-f]*:	ea 05 24 c5 	packsh\.ub r5,r5,r5

 11891 + *[0-9a-f]*:	e8 04 24 c4 	packsh\.ub r4,r4,r4

 11892 + *[0-9a-f]*:	fc 0e 24 ce 	packsh\.ub lr,lr,lr

 11893 + *[0-9a-f]*:	ec 03 24 c3 	packsh\.ub r3,r6,r3

 11894 + *[0-9a-f]*:	e0 03 24 c8 	packsh\.ub r8,r0,r3

 11895 + *[0-9a-f]*:	e6 0e 24 c9 	packsh\.ub r9,r3,lr

 11896 +

 11897 +[0-9a-f]* <packsh_sb>:

 11898 + *[0-9a-f]*:	fe 0f 24 df 	packsh\.sb pc,pc,pc

 11899 + *[0-9a-f]*:	f8 0c 24 dc 	packsh\.sb r12,r12,r12

 11900 + *[0-9a-f]*:	ea 05 24 d5 	packsh\.sb r5,r5,r5

 11901 + *[0-9a-f]*:	e8 04 24 d4 	packsh\.sb r4,r4,r4

 11902 + *[0-9a-f]*:	fc 0e 24 de 	packsh\.sb lr,lr,lr

 11903 + *[0-9a-f]*:	f0 01 24 d6 	packsh\.sb r6,r8,r1

 11904 + *[0-9a-f]*:	f2 08 24 de 	packsh\.sb lr,r9,r8

 11905 + *[0-9a-f]*:	ec 06 24 dd 	packsh\.sb sp,r6,r6

 11906 +

 11907 +[0-9a-f]* <andl>:

 11908 + *[0-9a-f]*:	e0 1f 00 00 	andl pc,0x0

 11909 + *[0-9a-f]*:	e0 1c ff ff 	andl r12,0xffff

 11910 + *[0-9a-f]*:	e0 15 80 00 	andl r5,0x8000

 11911 + *[0-9a-f]*:	e0 14 7f ff 	andl r4,0x7fff

 11912 + *[0-9a-f]*:	e0 1e 00 01 	andl lr,0x1

 11913 + *[0-9a-f]*:	e0 1f 5a 58 	andl pc,0x5a58

 11914 + *[0-9a-f]*:	e0 18 b8 9e 	andl r8,0xb89e

 11915 + *[0-9a-f]*:	e0 17 35 97 	andl r7,0x3597

 11916 +

 11917 +[0-9a-f]* <andl_coh>:

 11918 + *[0-9a-f]*:	e2 1f 00 00 	andl pc,0x0,COH

 11919 + *[0-9a-f]*:	e2 1c ff ff 	andl r12,0xffff,COH

 11920 + *[0-9a-f]*:	e2 15 80 00 	andl r5,0x8000,COH

 11921 + *[0-9a-f]*:	e2 14 7f ff 	andl r4,0x7fff,COH

 11922 + *[0-9a-f]*:	e2 1e 00 01 	andl lr,0x1,COH

 11923 + *[0-9a-f]*:	e2 16 58 e1 	andl r6,0x58e1,COH

 11924 + *[0-9a-f]*:	e2 10 9e cd 	andl r0,0x9ecd,COH

 11925 + *[0-9a-f]*:	e2 14 bd c4 	andl r4,0xbdc4,COH

 11926 +

 11927 +[0-9a-f]* <andh>:

 11928 + *[0-9a-f]*:	e4 1f 00 00 	andh pc,0x0

 11929 + *[0-9a-f]*:	e4 1c ff ff 	andh r12,0xffff

 11930 + *[0-9a-f]*:	e4 15 80 00 	andh r5,0x8000

 11931 + *[0-9a-f]*:	e4 14 7f ff 	andh r4,0x7fff

 11932 + *[0-9a-f]*:	e4 1e 00 01 	andh lr,0x1

 11933 + *[0-9a-f]*:	e4 1c cc 58 	andh r12,0xcc58

 11934 + *[0-9a-f]*:	e4 13 21 e3 	andh r3,0x21e3

 11935 + *[0-9a-f]*:	e4 12 a7 eb 	andh r2,0xa7eb

 11936 +

 11937 +[0-9a-f]* <andh_coh>:

 11938 + *[0-9a-f]*:	e6 1f 00 00 	andh pc,0x0,COH

 11939 + *[0-9a-f]*:	e6 1c ff ff 	andh r12,0xffff,COH

 11940 + *[0-9a-f]*:	e6 15 80 00 	andh r5,0x8000,COH

 11941 + *[0-9a-f]*:	e6 14 7f ff 	andh r4,0x7fff,COH

 11942 + *[0-9a-f]*:	e6 1e 00 01 	andh lr,0x1,COH

 11943 + *[0-9a-f]*:	e6 1b 86 0d 	andh r11,0x860d,COH

 11944 + *[0-9a-f]*:	e6 18 ce f6 	andh r8,0xcef6,COH

 11945 + *[0-9a-f]*:	e6 1a 5c 83 	andh r10,0x5c83,COH

 11946 +

 11947 +[0-9a-f]* <orl>:

 11948 + *[0-9a-f]*:	e8 1f 00 00 	orl pc,0x0

 11949 + *[0-9a-f]*:	e8 1c ff ff 	orl r12,0xffff

 11950 + *[0-9a-f]*:	e8 15 80 00 	orl r5,0x8000

 11951 + *[0-9a-f]*:	e8 14 7f ff 	orl r4,0x7fff

 11952 + *[0-9a-f]*:	e8 1e 00 01 	orl lr,0x1

 11953 + *[0-9a-f]*:	e8 1d 41 7e 	orl sp,0x417e

 11954 + *[0-9a-f]*:	e8 10 52 bd 	orl r0,0x52bd

 11955 + *[0-9a-f]*:	e8 1f ac 47 	orl pc,0xac47

 11956 +

 11957 +[0-9a-f]* <orh>:

 11958 + *[0-9a-f]*:	ea 1f 00 00 	orh pc,0x0

 11959 + *[0-9a-f]*:	ea 1c ff ff 	orh r12,0xffff

 11960 + *[0-9a-f]*:	ea 15 80 00 	orh r5,0x8000

 11961 + *[0-9a-f]*:	ea 14 7f ff 	orh r4,0x7fff

 11962 + *[0-9a-f]*:	ea 1e 00 01 	orh lr,0x1

 11963 + *[0-9a-f]*:	ea 18 6e 7d 	orh r8,0x6e7d

 11964 + *[0-9a-f]*:	ea 1c 77 1c 	orh r12,0x771c

 11965 + *[0-9a-f]*:	ea 11 ea 1a 	orh r1,0xea1a

 11966 +

 11967 +[0-9a-f]* <eorl>:

 11968 + *[0-9a-f]*:	ec 1f 00 00 	eorl pc,0x0

 11969 + *[0-9a-f]*:	ec 1c ff ff 	eorl r12,0xffff

 11970 + *[0-9a-f]*:	ec 15 80 00 	eorl r5,0x8000

 11971 + *[0-9a-f]*:	ec 14 7f ff 	eorl r4,0x7fff

 11972 + *[0-9a-f]*:	ec 1e 00 01 	eorl lr,0x1

 11973 + *[0-9a-f]*:	ec 14 c7 b9 	eorl r4,0xc7b9

 11974 + *[0-9a-f]*:	ec 16 fb dd 	eorl r6,0xfbdd

 11975 + *[0-9a-f]*:	ec 11 51 b1 	eorl r1,0x51b1

 11976 +

 11977 +[0-9a-f]* <eorh>:

 11978 + *[0-9a-f]*:	ee 1f 00 00 	eorh pc,0x0

 11979 + *[0-9a-f]*:	ee 1c ff ff 	eorh r12,0xffff

 11980 + *[0-9a-f]*:	ee 15 80 00 	eorh r5,0x8000

 11981 + *[0-9a-f]*:	ee 14 7f ff 	eorh r4,0x7fff

 11982 + *[0-9a-f]*:	ee 1e 00 01 	eorh lr,0x1

 11983 + *[0-9a-f]*:	ee 10 2d d4 	eorh r0,0x2dd4

 11984 + *[0-9a-f]*:	ee 1a 94 b5 	eorh r10,0x94b5

 11985 + *[0-9a-f]*:	ee 19 df 2a 	eorh r9,0xdf2a

 11986 +

 11987 +[0-9a-f]* <mcall>:

 11988 + *[0-9a-f]*:	f0 1f 00 00 	mcall [0-9a-f]* <.*>

 11989 + *[0-9a-f]*:	f0 1c ff ff 	mcall r12\[-4\]

 11990 + *[0-9a-f]*:	f0 15 80 00 	mcall r5\[-131072\]

 11991 + *[0-9a-f]*:	f0 14 7f ff 	mcall r4\[131068\]

 11992 + *[0-9a-f]*:	f0 1e 00 01 	mcall lr\[4\]

 11993 + *[0-9a-f]*:	f0 1d 3b bf 	mcall sp\[61180\]

 11994 + *[0-9a-f]*:	f0 14 dd d2 	mcall r4\[-35000\]

 11995 + *[0-9a-f]*:	f0 10 09 b1 	mcall r0\[9924\]

 11996 +

 11997 +[0-9a-f]* <pref>:

 11998 + *[0-9a-f]*:	f2 1f 00 00 	pref pc\[0\]

 11999 + *[0-9a-f]*:	f2 1c ff ff 	pref r12\[-1\]

 12000 + *[0-9a-f]*:	f2 15 80 00 	pref r5\[-32768\]

 12001 + *[0-9a-f]*:	f2 14 7f ff 	pref r4\[32767\]

 12002 + *[0-9a-f]*:	f2 1e 00 01 	pref lr\[1\]

 12003 + *[0-9a-f]*:	f2 17 1e 44 	pref r7\[7748\]

 12004 + *[0-9a-f]*:	f2 17 e1 ed 	pref r7\[-7699\]

 12005 + *[0-9a-f]*:	f2 12 9a dc 	pref r2\[-25892\]

 12006 +

 12007 +[0-9a-f]* <cache>:

 12008 + *[0-9a-f]*:	f4 1f 00 00 	cache pc\[0\],0x0

 12009 + *[0-9a-f]*:	f4 1c ff ff 	cache r12\[-1\],0x1f

 12010 + *[0-9a-f]*:	f4 15 84 00 	cache r5\[-1024\],0x10

 12011 + *[0-9a-f]*:	f4 14 7b ff 	cache r4\[1023\],0xf

 12012 + *[0-9a-f]*:	f4 1e 08 01 	cache lr\[1\],0x1

 12013 + *[0-9a-f]*:	f4 13 8c 3c 	cache r3\[-964\],0x11

 12014 + *[0-9a-f]*:	f4 14 b6 89 	cache r4\[-375\],0x16

 12015 + *[0-9a-f]*:	f4 13 8c 88 	cache r3\[-888\],0x11

 12016 +

 12017 +[0-9a-f]* <sub4>:

 12018 + *[0-9a-f]*:	20 0f       	sub pc,0

 12019 + *[0-9a-f]*:	2f fc       	sub r12,-1

 12020 + *[0-9a-f]*:	f0 25 00 00 	sub r5,-1048576

 12021 + *[0-9a-f]*:	ee 34 ff ff 	sub r4,1048575

 12022 + *[0-9a-f]*:	20 1e       	sub lr,1

 12023 + *[0-9a-f]*:	f6 22 8d 6c 	sub r2,-619156

 12024 + *[0-9a-f]*:	e6 3e 0a cd 	sub lr,461517

 12025 + *[0-9a-f]*:	fc 38 2d 25 	sub r8,-185051

 12026 +

 12027 +[0-9a-f]* <cp3>:

 12028 + *[0-9a-f]*:	58 0f       	cp.w pc,0

 12029 + *[0-9a-f]*:	5b fc       	cp.w r12,-1

 12030 + *[0-9a-f]*:	f0 45 00 00 	cp.w r5,-1048576

 12031 + *[0-9a-f]*:	ee 54 ff ff 	cp.w r4,1048575

 12032 + *[0-9a-f]*:	58 1e       	cp.w lr,1

 12033 + *[0-9a-f]*:	e0 51 e4 ae 	cp.w r1,124078

 12034 + *[0-9a-f]*:	fa 40 37 e3 	cp.w r0,-378909

 12035 + *[0-9a-f]*:	fc 44 4a 14 	cp.w r4,-243180

 12036 +

 12037 +[0-9a-f]* <mov2>:

 12038 + *[0-9a-f]*:	30 0f       	mov pc,0

 12039 + *[0-9a-f]*:	3f fc       	mov r12,-1

 12040 + *[0-9a-f]*:	f0 65 00 00 	mov r5,-1048576

 12041 + *[0-9a-f]*:	ee 74 ff ff 	mov r4,1048575

 12042 + *[0-9a-f]*:	30 1e       	mov lr,1

 12043 + *[0-9a-f]*:	fa 75 29 a3 	mov r5,-317021

 12044 + *[0-9a-f]*:	f4 6d 91 94 	mov sp,-749164

 12045 + *[0-9a-f]*:	ee 65 58 93 	mov r5,940179

 12046 +

 12047 +[0-9a-f]* <brc2>:

 12048 + *[0-9a-f]*:	c0 00       	breq [0-9a-f]* <.*>

 12049 + *[0-9a-f]*:	fe 9f ff ff 	bral [0-9a-f]* <.*>

 12050 + *[0-9a-f]*:	f0 88 00 00 	brls [0-9a-f]* <.*>

 12051 + *[0-9a-f]*:	ee 97 ff ff 	brpl [0-9a-f]* <.*>

 12052 + *[0-9a-f]*:	c0 11       	brne [0-9a-f]* <.*>

 12053 + *[0-9a-f]*:	f2 8b 4a 4d 	brhi [0-9a-f]* <.*>

 12054 + *[0-9a-f]*:	ea 8e 14 cc 	brqs [0-9a-f]* <.*>

 12055 + *[0-9a-f]*:	fa 98 98 33 	brls [0-9a-f]* <.*>

 12056 +

 12057 +[0-9a-f]* <rcall2>:

 12058 + *[0-9a-f]*:	c0 0c       	rcall [0-9a-f]* <.*>

 12059 + *[0-9a-f]*:	cf ff       	rcall [0-9a-f]* <.*>

 12060 + *[0-9a-f]*:	f0 a0 00 00 	rcall [0-9a-f]* <.*>

 12061 + *[0-9a-f]*:	ee b0 ff ff 	rcall [0-9a-f]* <.*>

 12062 + *[0-9a-f]*:	c0 1c       	rcall [0-9a-f]* <.*>

 12063 + *[0-9a-f]*:	e2 b0 ca 5a 	rcall [0-9a-f]* <.*>

 12064 + *[0-9a-f]*:	e8 a0 47 52 	rcall [0-9a-f]* <.*>

 12065 + *[0-9a-f]*:	fe b0 fd ef 	rcall [0-9a-f]* <.*>

 12066 +

 12067 +[0-9a-f]* <sub5>:

 12068 + *[0-9a-f]*:	fe cf 00 00 	sub pc,pc,0

 12069 + *[0-9a-f]*:	f8 cc ff ff 	sub r12,r12,-1

 12070 + *[0-9a-f]*:	ea c5 80 00 	sub r5,r5,-32768

 12071 + *[0-9a-f]*:	e8 c4 7f ff 	sub r4,r4,32767

 12072 + *[0-9a-f]*:	fc ce 00 01 	sub lr,lr,1

 12073 + *[0-9a-f]*:	fe cf ce 38 	sub pc,pc,-12744

 12074 + *[0-9a-f]*:	ee c7 95 1b 	sub r7,r7,-27365

 12075 + *[0-9a-f]*:	f2 c2 bc 32 	sub r2,r9,-17358

 12076 +

 12077 +[0-9a-f]* <satsub_w2>:

 12078 + *[0-9a-f]*:	fe df 00 00 	satsub\.w pc,pc,0

 12079 + *[0-9a-f]*:	f8 dc ff ff 	satsub\.w r12,r12,-1

 12080 + *[0-9a-f]*:	ea d5 80 00 	satsub\.w r5,r5,-32768

 12081 + *[0-9a-f]*:	e8 d4 7f ff 	satsub\.w r4,r4,32767

 12082 + *[0-9a-f]*:	fc de 00 01 	satsub\.w lr,lr,1

 12083 + *[0-9a-f]*:	fc d2 f8 29 	satsub\.w r2,lr,-2007

 12084 + *[0-9a-f]*:	f8 d7 fc f0 	satsub\.w r7,r12,-784

 12085 + *[0-9a-f]*:	ee d4 5a 8c 	satsub\.w r4,r7,23180

 12086 +

 12087 +[0-9a-f]* <ld_d4>:

 12088 + *[0-9a-f]*:	fe e0 00 00 	ld\.d r0,pc\[0\]

 12089 + *[0-9a-f]*:	f8 ee ff ff 	ld\.d lr,r12\[-1\]

 12090 + *[0-9a-f]*:	ea e8 80 00 	ld\.d r8,r5\[-32768\]

 12091 + *[0-9a-f]*:	e8 e6 7f ff 	ld\.d r6,r4\[32767\]

 12092 + *[0-9a-f]*:	fc e2 00 01 	ld\.d r2,lr\[1\]

 12093 + *[0-9a-f]*:	f6 ee 39 c0 	ld\.d lr,r11\[14784\]

 12094 + *[0-9a-f]*:	f2 e6 b6 27 	ld\.d r6,r9\[-18905\]

 12095 + *[0-9a-f]*:	e6 e2 e7 2d 	ld\.d r2,r3\[-6355\]

 12096 +

 12097 +[0-9a-f]* <ld_w4>:

 12098 + *[0-9a-f]*:	7e 0f       	ld\.w pc,pc\[0x0\]

 12099 + *[0-9a-f]*:	f8 fc ff ff 	ld\.w r12,r12\[-1\]

 12100 + *[0-9a-f]*:	ea f5 80 00 	ld\.w r5,r5\[-32768\]

 12101 + *[0-9a-f]*:	e8 f4 7f ff 	ld\.w r4,r4\[32767\]

 12102 + *[0-9a-f]*:	fc fe 00 01 	ld\.w lr,lr\[1\]

 12103 + *[0-9a-f]*:	f8 f0 a9 8b 	ld\.w r0,r12\[-22133\]

 12104 + *[0-9a-f]*:	fe fd af d7 	ld\.w sp,pc\[-20521\]

 12105 + *[0-9a-f]*:	d7 03       	nop

 12106 +

 12107 +[0-9a-f]* <ld_sh4>:

 12108 + *[0-9a-f]*:	9e 0f       	ld\.sh pc,pc\[0x0\]

 12109 + *[0-9a-f]*:	f9 0c ff ff 	ld\.sh r12,r12\[-1\]

 12110 + *[0-9a-f]*:	eb 05 80 00 	ld\.sh r5,r5\[-32768\]

 12111 + *[0-9a-f]*:	e9 04 7f ff 	ld\.sh r4,r4\[32767\]

 12112 + *[0-9a-f]*:	fd 0e 00 01 	ld\.sh lr,lr\[1\]

 12113 + *[0-9a-f]*:	f5 06 78 d2 	ld\.sh r6,r10\[30930\]

 12114 + *[0-9a-f]*:	f5 06 55 d5 	ld\.sh r6,r10\[21973\]

 12115 + *[0-9a-f]*:	d7 03       	nop

 12116 +

 12117 +[0-9a-f]* <ld_uh4>:

 12118 + *[0-9a-f]*:	9e 8f       	ld\.uh pc,pc\[0x0\]

 12119 + *[0-9a-f]*:	f9 1c ff ff 	ld\.uh r12,r12\[-1\]

 12120 + *[0-9a-f]*:	eb 15 80 00 	ld\.uh r5,r5\[-32768\]

 12121 + *[0-9a-f]*:	e9 14 7f ff 	ld\.uh r4,r4\[32767\]

 12122 + *[0-9a-f]*:	fd 1e 00 01 	ld\.uh lr,lr\[1\]

 12123 + *[0-9a-f]*:	f3 11 cb d6 	ld\.uh r1,r9\[-13354\]

 12124 + *[0-9a-f]*:	f7 1e 53 59 	ld\.uh lr,r11\[21337\]

 12125 + *[0-9a-f]*:	d7 03       	nop

 12126 +

 12127 +[0-9a-f]* <ld_sb1>:

 12128 + *[0-9a-f]*:	ff 2f 00 00 	ld\.sb pc,pc\[0\]

 12129 + *[0-9a-f]*:	f9 2c ff ff 	ld\.sb r12,r12\[-1\]

 12130 + *[0-9a-f]*:	eb 25 80 00 	ld\.sb r5,r5\[-32768\]

 12131 + *[0-9a-f]*:	e9 24 7f ff 	ld\.sb r4,r4\[32767\]

 12132 + *[0-9a-f]*:	fd 2e 00 01 	ld\.sb lr,lr\[1\]

 12133 + *[0-9a-f]*:	fb 27 90 09 	ld\.sb r7,sp\[-28663\]

 12134 + *[0-9a-f]*:	e3 22 e9 09 	ld\.sb r2,r1\[-5879\]

 12135 + *[0-9a-f]*:	e7 2c 49 2e 	ld\.sb r12,r3\[18734\]

 12136 +

 12137 +[0-9a-f]* <ld_ub4>:

 12138 + *[0-9a-f]*:	1f 8f       	ld\.ub pc,pc\[0x0\]

 12139 + *[0-9a-f]*:	f9 3c ff ff 	ld\.ub r12,r12\[-1\]

 12140 + *[0-9a-f]*:	eb 35 80 00 	ld\.ub r5,r5\[-32768\]

 12141 + *[0-9a-f]*:	e9 34 7f ff 	ld\.ub r4,r4\[32767\]

 12142 + *[0-9a-f]*:	1d 9e       	ld\.ub lr,lr\[0x1\]

 12143 + *[0-9a-f]*:	e9 3f 20 55 	ld\.ub pc,r4\[8277\]

 12144 + *[0-9a-f]*:	f9 35 4a e4 	ld\.ub r5,r12\[19172\]

 12145 + *[0-9a-f]*:	fd 3a 66 eb 	ld\.ub r10,lr\[26347\]

 12146 +

 12147 +[0-9a-f]* <st_d4>:

 12148 + *[0-9a-f]*:	fe e1 00 00 	st\.d pc\[0\],r0

 12149 + *[0-9a-f]*:	f8 ef ff ff 	st\.d r12\[-1\],lr

 12150 + *[0-9a-f]*:	ea e9 80 00 	st\.d r5\[-32768\],r8

 12151 + *[0-9a-f]*:	e8 e7 7f ff 	st\.d r4\[32767\],r6

 12152 + *[0-9a-f]*:	fc e3 00 01 	st\.d lr\[1\],r2

 12153 + *[0-9a-f]*:	ea eb 33 90 	st\.d r5\[13200\],r10

 12154 + *[0-9a-f]*:	ea eb 24 88 	st\.d r5\[9352\],r10

 12155 + *[0-9a-f]*:	ea e5 7e 75 	st\.d r5\[32373\],r4

 12156 +

 12157 +[0-9a-f]* <st_w4>:

 12158 + *[0-9a-f]*:	9f 0f       	st\.w pc\[0x0\],pc

 12159 + *[0-9a-f]*:	f9 4c ff ff 	st\.w r12\[-1\],r12

 12160 + *[0-9a-f]*:	eb 45 80 00 	st\.w r5\[-32768\],r5

 12161 + *[0-9a-f]*:	e9 44 7f ff 	st\.w r4\[32767\],r4

 12162 + *[0-9a-f]*:	fd 4e 00 01 	st\.w lr\[1\],lr

 12163 + *[0-9a-f]*:	fb 47 17 f8 	st\.w sp\[6136\],r7

 12164 + *[0-9a-f]*:	ed 4c 69 cf 	st\.w r6\[27087\],r12

 12165 + *[0-9a-f]*:	d7 03       	nop

 12166 +

 12167 +[0-9a-f]* <st_h4>:

 12168 + *[0-9a-f]*:	be 0f       	st\.h pc\[0x0\],pc

 12169 + *[0-9a-f]*:	f9 5c ff ff 	st\.h r12\[-1\],r12

 12170 + *[0-9a-f]*:	eb 55 80 00 	st\.h r5\[-32768\],r5

 12171 + *[0-9a-f]*:	e9 54 7f ff 	st\.h r4\[32767\],r4

 12172 + *[0-9a-f]*:	fd 5e 00 01 	st\.h lr\[1\],lr

 12173 + *[0-9a-f]*:	e9 57 d9 16 	st\.h r4\[-9962\],r7

 12174 + *[0-9a-f]*:	f3 53 c0 86 	st\.h r9\[-16250\],r3

 12175 + *[0-9a-f]*:	d7 03       	nop

 12176 +

 12177 +[0-9a-f]* <st_b4>:

 12178 + *[0-9a-f]*:	be 8f       	st\.b pc\[0x0\],pc

 12179 + *[0-9a-f]*:	f9 6c ff ff 	st\.b r12\[-1\],r12

 12180 + *[0-9a-f]*:	eb 65 80 00 	st\.b r5\[-32768\],r5

 12181 + *[0-9a-f]*:	e9 64 7f ff 	st\.b r4\[32767\],r4

 12182 + *[0-9a-f]*:	bc 9e       	st\.b lr\[0x1\],lr

 12183 + *[0-9a-f]*:	f9 66 75 96 	st\.b r12\[30102\],r6

 12184 + *[0-9a-f]*:	eb 61 71 31 	st\.b r5\[28977\],r1

 12185 + *[0-9a-f]*:	e1 61 15 5e 	st\.b r0\[5470\],r1

 12186 +

 12187 +[0-9a-f]* <mfsr>:

 12188 + *[0-9a-f]*:	e1 bf 00 00 	mfsr pc,0x0

 12189 + *[0-9a-f]*:	e1 bc 00 ff 	mfsr r12,0x3fc

 12190 + *[0-9a-f]*:	e1 b5 00 80 	mfsr r5,0x200

 12191 + *[0-9a-f]*:	e1 b4 00 7f 	mfsr r4,0x1fc

 12192 + *[0-9a-f]*:	e1 be 00 01 	mfsr lr,0x4

 12193 + *[0-9a-f]*:	e1 b2 00 ae 	mfsr r2,0x2b8

 12194 + *[0-9a-f]*:	e1 b4 00 41 	mfsr r4,0x104

 12195 + *[0-9a-f]*:	e1 ba 00 fe 	mfsr r10,0x3f8

 12196 +

 12197 +[0-9a-f]* <mtsr>:

 12198 + *[0-9a-f]*:	e3 bf 00 00 	mtsr 0x0,pc

 12199 + *[0-9a-f]*:	e3 bc 00 ff 	mtsr 0x3fc,r12

 12200 + *[0-9a-f]*:	e3 b5 00 80 	mtsr 0x200,r5

 12201 + *[0-9a-f]*:	e3 b4 00 7f 	mtsr 0x1fc,r4

 12202 + *[0-9a-f]*:	e3 be 00 01 	mtsr 0x4,lr

 12203 + *[0-9a-f]*:	e3 ba 00 38 	mtsr 0xe0,r10

 12204 + *[0-9a-f]*:	e3 bc 00 d1 	mtsr 0x344,r12

 12205 + *[0-9a-f]*:	e3 b9 00 4c 	mtsr 0x130,r9

 12206 +

 12207 +[0-9a-f]* <mfdr>:

 12208 + *[0-9a-f]*:	e5 bf 00 00 	mfdr pc,0x0

 12209 + *[0-9a-f]*:	e5 bc 00 ff 	mfdr r12,0x3fc

 12210 + *[0-9a-f]*:	e5 b5 00 80 	mfdr r5,0x200

 12211 + *[0-9a-f]*:	e5 b4 00 7f 	mfdr r4,0x1fc

 12212 + *[0-9a-f]*:	e5 be 00 01 	mfdr lr,0x4

 12213 + *[0-9a-f]*:	e5 b6 00 e9 	mfdr r6,0x3a4

 12214 + *[0-9a-f]*:	e5 b5 00 09 	mfdr r5,0x24

 12215 + *[0-9a-f]*:	e5 b9 00 4b 	mfdr r9,0x12c

 12216 +

 12217 +[0-9a-f]* <mtdr>:

 12218 + *[0-9a-f]*:	e7 bf 00 00 	mtdr 0x0,pc

 12219 + *[0-9a-f]*:	e7 bc 00 ff 	mtdr 0x3fc,r12

 12220 + *[0-9a-f]*:	e7 b5 00 80 	mtdr 0x200,r5

 12221 + *[0-9a-f]*:	e7 b4 00 7f 	mtdr 0x1fc,r4

 12222 + *[0-9a-f]*:	e7 be 00 01 	mtdr 0x4,lr

 12223 + *[0-9a-f]*:	e7 b8 00 2d 	mtdr 0xb4,r8

 12224 + *[0-9a-f]*:	e7 ba 00 b4 	mtdr 0x2d0,r10

 12225 + *[0-9a-f]*:	e7 be 00 66 	mtdr 0x198,lr

 12226 +

 12227 +[0-9a-f]* <sleep>:

 12228 + *[0-9a-f]*:	e9 b0 00 00 	sleep 0x0

 12229 + *[0-9a-f]*:	e9 b0 00 ff 	sleep 0xff

 12230 + *[0-9a-f]*:	e9 b0 00 80 	sleep 0x80

 12231 + *[0-9a-f]*:	e9 b0 00 7f 	sleep 0x7f

 12232 + *[0-9a-f]*:	e9 b0 00 01 	sleep 0x1

 12233 + *[0-9a-f]*:	e9 b0 00 fe 	sleep 0xfe

 12234 + *[0-9a-f]*:	e9 b0 00 0f 	sleep 0xf

 12235 + *[0-9a-f]*:	e9 b0 00 2b 	sleep 0x2b

 12236 +

 12237 +[0-9a-f]* <sync>:

 12238 + *[0-9a-f]*:	eb b0 00 00 	sync 0x0

 12239 + *[0-9a-f]*:	eb b0 00 ff 	sync 0xff

 12240 + *[0-9a-f]*:	eb b0 00 80 	sync 0x80

 12241 + *[0-9a-f]*:	eb b0 00 7f 	sync 0x7f

 12242 + *[0-9a-f]*:	eb b0 00 01 	sync 0x1

 12243 + *[0-9a-f]*:	eb b0 00 a6 	sync 0xa6

 12244 + *[0-9a-f]*:	eb b0 00 e6 	sync 0xe6

 12245 + *[0-9a-f]*:	eb b0 00 b4 	sync 0xb4

 12246 +

 12247 +[0-9a-f]* <bld>:

 12248 + *[0-9a-f]*:	ed bf 00 00 	bld pc,0x0

 12249 + *[0-9a-f]*:	ed bc 00 1f 	bld r12,0x1f

 12250 + *[0-9a-f]*:	ed b5 00 10 	bld r5,0x10

 12251 + *[0-9a-f]*:	ed b4 00 0f 	bld r4,0xf

 12252 + *[0-9a-f]*:	ed be 00 01 	bld lr,0x1

 12253 + *[0-9a-f]*:	ed b9 00 0f 	bld r9,0xf

 12254 + *[0-9a-f]*:	ed b0 00 04 	bld r0,0x4

 12255 + *[0-9a-f]*:	ed be 00 1a 	bld lr,0x1a

 12256 +

 12257 +[0-9a-f]* <bst>:

 12258 + *[0-9a-f]*:	ef bf 00 00 	bst pc,0x0

 12259 + *[0-9a-f]*:	ef bc 00 1f 	bst r12,0x1f

 12260 + *[0-9a-f]*:	ef b5 00 10 	bst r5,0x10

 12261 + *[0-9a-f]*:	ef b4 00 0f 	bst r4,0xf

 12262 + *[0-9a-f]*:	ef be 00 01 	bst lr,0x1

 12263 + *[0-9a-f]*:	ef ba 00 1c 	bst r10,0x1c

 12264 + *[0-9a-f]*:	ef b0 00 03 	bst r0,0x3

 12265 + *[0-9a-f]*:	ef bd 00 02 	bst sp,0x2

 12266 +

 12267 +[0-9a-f]* <sats>:

 12268 + *[0-9a-f]*:	f1 bf 00 00 	sats pc,0x0

 12269 + *[0-9a-f]*:	f1 bc 03 ff 	sats r12>>0x1f,0x1f

 12270 + *[0-9a-f]*:	f1 b5 02 10 	sats r5>>0x10,0x10

 12271 + *[0-9a-f]*:	f1 b4 01 ef 	sats r4>>0xf,0xf

 12272 + *[0-9a-f]*:	f1 be 00 21 	sats lr>>0x1,0x1

 12273 + *[0-9a-f]*:	f1 ba 02 63 	sats r10>>0x3,0x13

 12274 + *[0-9a-f]*:	f1 ba 03 42 	sats r10>>0x2,0x1a

 12275 + *[0-9a-f]*:	f1 b1 00 34 	sats r1>>0x14,0x1

 12276 +

 12277 +[0-9a-f]* <satu>:

 12278 + *[0-9a-f]*:	f1 bf 04 00 	satu pc,0x0

 12279 + *[0-9a-f]*:	f1 bc 07 ff 	satu r12>>0x1f,0x1f

 12280 + *[0-9a-f]*:	f1 b5 06 10 	satu r5>>0x10,0x10

 12281 + *[0-9a-f]*:	f1 b4 05 ef 	satu r4>>0xf,0xf

 12282 + *[0-9a-f]*:	f1 be 04 21 	satu lr>>0x1,0x1

 12283 + *[0-9a-f]*:	f1 bf 04 e5 	satu pc>>0x5,0x7

 12284 + *[0-9a-f]*:	f1 b7 04 a5 	satu r7>>0x5,0x5

 12285 + *[0-9a-f]*:	f1 b2 06 7a 	satu r2>>0x1a,0x13

 12286 +

 12287 +[0-9a-f]* <satrnds>:

 12288 + *[0-9a-f]*:	f3 bf 00 00 	satrnds pc,0x0

 12289 + *[0-9a-f]*:	f3 bc 03 ff 	satrnds r12>>0x1f,0x1f

 12290 + *[0-9a-f]*:	f3 b5 02 10 	satrnds r5>>0x10,0x10

 12291 + *[0-9a-f]*:	f3 b4 01 ef 	satrnds r4>>0xf,0xf

 12292 + *[0-9a-f]*:	f3 be 00 21 	satrnds lr>>0x1,0x1

 12293 + *[0-9a-f]*:	f3 b0 02 75 	satrnds r0>>0x15,0x13

 12294 + *[0-9a-f]*:	f3 bd 00 40 	satrnds sp,0x2

 12295 + *[0-9a-f]*:	f3 b7 03 a6 	satrnds r7>>0x6,0x1d

 12296 +

 12297 +[0-9a-f]* <satrndu>:

 12298 + *[0-9a-f]*:	f3 bf 04 00 	satrndu pc,0x0

 12299 + *[0-9a-f]*:	f3 bc 07 ff 	satrndu r12>>0x1f,0x1f

 12300 + *[0-9a-f]*:	f3 b5 06 10 	satrndu r5>>0x10,0x10

 12301 + *[0-9a-f]*:	f3 b4 05 ef 	satrndu r4>>0xf,0xf

 12302 + *[0-9a-f]*:	f3 be 04 21 	satrndu lr>>0x1,0x1

 12303 + *[0-9a-f]*:	f3 bc 07 40 	satrndu r12,0x1a

 12304 + *[0-9a-f]*:	f3 b4 04 75 	satrndu r4>>0x15,0x3

 12305 + *[0-9a-f]*:	f3 ba 06 03 	satrndu r10>>0x3,0x10

 12306 +

 12307 +[0-9a-f]* <subfc>:

 12308 + *[0-9a-f]*:	f5 bf 00 00 	subfeq pc,0

 12309 + *[0-9a-f]*:	f5 bc 0f ff 	subfal r12,-1

 12310 + *[0-9a-f]*:	f5 b5 08 80 	subfls r5,-128

 12311 + *[0-9a-f]*:	f5 b4 07 7f 	subfpl r4,127

 12312 + *[0-9a-f]*:	f5 be 01 01 	subfne lr,1

 12313 + *[0-9a-f]*:	f5 ba 08 08 	subfls r10,8

 12314 + *[0-9a-f]*:	f5 bb 0d 63 	subfvc r11,99

 12315 + *[0-9a-f]*:	f5 b2 0c 49 	subfvs r2,73

 12316 +

 12317 +[0-9a-f]* <subc>:

 12318 + *[0-9a-f]*:	f7 bf 00 00 	subeq pc,0

 12319 + *[0-9a-f]*:	f7 bc 0f ff 	subal r12,-1

 12320 + *[0-9a-f]*:	f7 b5 08 80 	subls r5,-128

 12321 + *[0-9a-f]*:	f7 b4 07 7f 	subpl r4,127

 12322 + *[0-9a-f]*:	f7 be 01 01 	subne lr,1

 12323 + *[0-9a-f]*:	f7 bc 08 76 	subls r12,118

 12324 + *[0-9a-f]*:	f7 be 0d f4 	subvc lr,-12

 12325 + *[0-9a-f]*:	f7 b4 06 f3 	submi r4,-13

 12326 +

 12327 +[0-9a-f]* <movc2>:

 12328 + *[0-9a-f]*:	f9 bf 00 00 	moveq pc,0

 12329 + *[0-9a-f]*:	f9 bc 0f ff 	moval r12,-1

 12330 + *[0-9a-f]*:	f9 b5 08 80 	movls r5,-128

 12331 + *[0-9a-f]*:	f9 b4 07 7f 	movpl r4,127

 12332 + *[0-9a-f]*:	f9 be 01 01 	movne lr,1

 12333 + *[0-9a-f]*:	f9 b3 05 86 	movlt r3,-122

 12334 + *[0-9a-f]*:	f9 b8 0d 02 	movvc r8,2

 12335 + *[0-9a-f]*:	f9 b7 01 91 	movne r7,-111

 12336 +

 12337 +[0-9a-f]* <cp_b>:

 12338 + *[0-9a-f]*:	e0 0f 18 00 	cp\.b pc,r0

 12339 + *[0-9a-f]*:	fe 00 18 00 	cp\.b r0,pc

 12340 + *[0-9a-f]*:	f0 07 18 00 	cp\.b r7,r8

 12341 + *[0-9a-f]*:	ee 08 18 00 	cp\.b r8,r7

 12342 +

 12343 +[0-9a-f]* <cp_h>:

 12344 + *[0-9a-f]*:	e0 0f 19 00 	cp\.h pc,r0

 12345 + *[0-9a-f]*:	fe 00 19 00 	cp\.h r0,pc

 12346 + *[0-9a-f]*:	f0 07 19 00 	cp\.h r7,r8

 12347 + *[0-9a-f]*:	ee 08 19 00 	cp\.h r8,r7

 12348 +

 12349 +[0-9a-f]* <ldm>:

 12350 + *[0-9a-f]*:	e1 cf 00 7e 	ldm pc,r1-r6

 12351 + *[0-9a-f]*:	e1 cc ff ff 	ldm r12,r0-pc

 12352 + *[0-9a-f]*:	e1 c5 80 00 	ldm r5,pc

 12353 + *[0-9a-f]*:	e1 c4 7f ff 	ldm r4,r0-lr

 12354 + *[0-9a-f]*:	e1 ce 00 01 	ldm lr,r0

 12355 + *[0-9a-f]*:	e1 c9 40 22 	ldm r9,r1,r5,lr

 12356 + *[0-9a-f]*:	e1 cb 81 ec 	ldm r11,r2-r3,r5-r8,pc

 12357 + *[0-9a-f]*:	e1 c6 a2 09 	ldm r6,r0,r3,r9,sp,pc

 12358 +

 12359 +[0-9a-f]* <ldm_pu>:

 12360 + *[0-9a-f]*:	e3 cf 03 c0 	ldm pc\+\+,r6-r9

 12361 + *[0-9a-f]*:	e3 cc ff ff 	ldm r12\+\+,r0-pc

 12362 + *[0-9a-f]*:	e3 c5 80 00 	ldm r5\+\+,pc

 12363 + *[0-9a-f]*:	e3 c4 7f ff 	ldm r4\+\+,r0-lr

 12364 + *[0-9a-f]*:	e3 ce 00 01 	ldm lr\+\+,r0

 12365 + *[0-9a-f]*:	e3 cc d5 38 	ldm r12\+\+,r3-r5,r8,r10,r12,lr-pc

 12366 + *[0-9a-f]*:	e3 ca c0 74 	ldm r10\+\+,r2,r4-r6,lr-pc

 12367 + *[0-9a-f]*:	e3 c6 7e 1a 	ldm r6\+\+,r1,r3-r4,r9-lr

 12368 +

 12369 +[0-9a-f]* <ldmts>:

 12370 + *[0-9a-f]*:	e5 cf 01 80 	ldmts pc,r7-r8

 12371 + *[0-9a-f]*:	e5 cc ff ff 	ldmts r12,r0-pc

 12372 + *[0-9a-f]*:	e5 c5 80 00 	ldmts r5,pc

 12373 + *[0-9a-f]*:	e5 c4 7f ff 	ldmts r4,r0-lr

 12374 + *[0-9a-f]*:	e5 ce 00 01 	ldmts lr,r0

 12375 + *[0-9a-f]*:	e5 c0 18 06 	ldmts r0,r1-r2,r11-r12

 12376 + *[0-9a-f]*:	e5 ce 61 97 	ldmts lr,r0-r2,r4,r7-r8,sp-lr

 12377 + *[0-9a-f]*:	e5 cc c2 3b 	ldmts r12,r0-r1,r3-r5,r9,lr-pc

 12378 +

 12379 +[0-9a-f]* <ldmts_pu>:

 12380 + *[0-9a-f]*:	e7 cf 02 00 	ldmts pc\+\+,r9

 12381 + *[0-9a-f]*:	e7 cc ff ff 	ldmts r12\+\+,r0-pc

 12382 + *[0-9a-f]*:	e7 c5 80 00 	ldmts r5\+\+,pc

 12383 + *[0-9a-f]*:	e7 c4 7f ff 	ldmts r4\+\+,r0-lr

 12384 + *[0-9a-f]*:	e7 ce 00 01 	ldmts lr\+\+,r0

 12385 + *[0-9a-f]*:	e7 cd 0a bd 	ldmts sp\+\+,r0,r2-r5,r7,r9,r11

 12386 + *[0-9a-f]*:	e7 c5 0c 8e 	ldmts r5\+\+,r1-r3,r7,r10-r11

 12387 + *[0-9a-f]*:	e7 c8 a1 9c 	ldmts r8\+\+,r2-r4,r7-r8,sp,pc

 12388 +

 12389 +[0-9a-f]* <stm>:

 12390 + *[0-9a-f]*:	e9 cf 00 80 	stm pc,r7

 12391 + *[0-9a-f]*:	e9 cc ff ff 	stm r12,r0-pc

 12392 + *[0-9a-f]*:	e9 c5 80 00 	stm r5,pc

 12393 + *[0-9a-f]*:	e9 c4 7f ff 	stm r4,r0-lr

 12394 + *[0-9a-f]*:	e9 ce 00 01 	stm lr,r0

 12395 + *[0-9a-f]*:	e9 cd 49 2c 	stm sp,r2-r3,r5,r8,r11,lr

 12396 + *[0-9a-f]*:	e9 c4 4c 5f 	stm r4,r0-r4,r6,r10-r11,lr

 12397 + *[0-9a-f]*:	e9 c9 f2 22 	stm r9,r1,r5,r9,r12-pc

 12398 +

 12399 +[0-9a-f]* <stm_pu>:

 12400 + *[0-9a-f]*:	eb cf 00 70 	stm --pc,r4-r6

 12401 + *[0-9a-f]*:	eb cc ff ff 	stm --r12,r0-pc

 12402 + *[0-9a-f]*:	eb c5 80 00 	stm --r5,pc

 12403 + *[0-9a-f]*:	eb c4 7f ff 	stm --r4,r0-lr

 12404 + *[0-9a-f]*:	eb ce 00 01 	stm --lr,r0

 12405 + *[0-9a-f]*:	eb cb fb f1 	stm --r11,r0,r4-r9,r11-pc

 12406 + *[0-9a-f]*:	eb cb 56 09 	stm --r11,r0,r3,r9-r10,r12,lr

 12407 + *[0-9a-f]*:	eb c6 63 04 	stm --r6,r2,r8-r9,sp-lr

 12408 +

 12409 +[0-9a-f]* <stmts>:

 12410 + *[0-9a-f]*:	ed cf 01 00 	stmts pc,r8

 12411 + *[0-9a-f]*:	ed cc ff ff 	stmts r12,r0-pc

 12412 + *[0-9a-f]*:	ed c5 80 00 	stmts r5,pc

 12413 + *[0-9a-f]*:	ed c4 7f ff 	stmts r4,r0-lr

 12414 + *[0-9a-f]*:	ed ce 00 01 	stmts lr,r0

 12415 + *[0-9a-f]*:	ed c1 c6 5b 	stmts r1,r0-r1,r3-r4,r6,r9-r10,lr-pc

 12416 + *[0-9a-f]*:	ed c3 1d c1 	stmts r3,r0,r6-r8,r10-r12

 12417 + *[0-9a-f]*:	ed cb d6 d1 	stmts r11,r0,r4,r6-r7,r9-r10,r12,lr-pc

 12418 +

 12419 +[0-9a-f]* <stmts_pu>:

 12420 + *[0-9a-f]*:	ef cf 01 c0 	stmts --pc,r6-r8

 12421 + *[0-9a-f]*:	ef cc ff ff 	stmts --r12,r0-pc

 12422 + *[0-9a-f]*:	ef c5 80 00 	stmts --r5,pc

 12423 + *[0-9a-f]*:	ef c4 7f ff 	stmts --r4,r0-lr

 12424 + *[0-9a-f]*:	ef ce 00 01 	stmts --lr,r0

 12425 + *[0-9a-f]*:	ef c2 36 19 	stmts --r2,r0,r3-r4,r9-r10,r12-sp

 12426 + *[0-9a-f]*:	ef c3 c0 03 	stmts --r3,r0-r1,lr-pc

 12427 + *[0-9a-f]*:	ef c0 44 7d 	stmts --r0,r0,r2-r6,r10,lr

 12428 +

 12429 +[0-9a-f]* <ldins_h>:

 12430 + *[0-9a-f]*:	ff df 00 00 	ldins\.h pc:b,pc\[0\]

 12431 + *[0-9a-f]*:	f9 dc 1f ff 	ldins\.h r12:t,r12\[-2\]

 12432 + *[0-9a-f]*:	eb d5 18 00 	ldins\.h r5:t,r5\[-4096\]

 12433 + *[0-9a-f]*:	e9 d4 07 ff 	ldins\.h r4:b,r4\[4094\]

 12434 + *[0-9a-f]*:	fd de 10 01 	ldins\.h lr:t,lr\[2\]

 12435 + *[0-9a-f]*:	fd d0 13 c5 	ldins\.h r0:t,lr\[1930\]

 12436 + *[0-9a-f]*:	ef d3 0e f5 	ldins\.h r3:b,r7\[-534\]

 12437 + *[0-9a-f]*:	f9 d2 0b 9a 	ldins\.h r2:b,r12\[-2252\]

 12438 +

 12439 +[0-9a-f]* <ldins_b>:

 12440 + *[0-9a-f]*:	ff df 40 00 	ldins\.b pc:b,pc\[0\]

 12441 + *[0-9a-f]*:	f9 dc 7f ff 	ldins\.b r12:t,r12\[-1\]

 12442 + *[0-9a-f]*:	eb d5 68 00 	ldins\.b r5:u,r5\[-2048\]

 12443 + *[0-9a-f]*:	e9 d4 57 ff 	ldins\.b r4:l,r4\[2047\]

 12444 + *[0-9a-f]*:	fd de 50 01 	ldins\.b lr:l,lr\[1\]

 12445 + *[0-9a-f]*:	e9 d6 7d 6a 	ldins\.b r6:t,r4\[-662\]

 12446 + *[0-9a-f]*:	e3 d5 4f 69 	ldins\.b r5:b,r1\[-151\]

 12447 + *[0-9a-f]*:	f7 da 78 7d 	ldins\.b r10:t,r11\[-1923\]

 12448 +

 12449 +[0-9a-f]* <ldswp_sh>:

 12450 + *[0-9a-f]*:	ff df 20 00 	ldswp\.sh pc,pc\[0\]

 12451 + *[0-9a-f]*:	f9 dc 2f ff 	ldswp\.sh r12,r12\[-2\]

 12452 + *[0-9a-f]*:	eb d5 28 00 	ldswp\.sh r5,r5\[-4096\]

 12453 + *[0-9a-f]*:	e9 d4 27 ff 	ldswp\.sh r4,r4\[4094\]

 12454 + *[0-9a-f]*:	fd de 20 01 	ldswp\.sh lr,lr\[2\]

 12455 + *[0-9a-f]*:	f5 d9 27 84 	ldswp\.sh r9,r10\[3848\]

 12456 + *[0-9a-f]*:	f9 d4 2c 04 	ldswp\.sh r4,r12\[-2040\]

 12457 + *[0-9a-f]*:	e5 da 26 08 	ldswp\.sh r10,r2\[3088\]

 12458 +

 12459 +[0-9a-f]* <ldswp_uh>:

 12460 + *[0-9a-f]*:	ff df 30 00 	ldswp\.uh pc,pc\[0\]

 12461 + *[0-9a-f]*:	f9 dc 3f ff 	ldswp\.uh r12,r12\[-2\]

 12462 + *[0-9a-f]*:	eb d5 38 00 	ldswp\.uh r5,r5\[-4096\]

 12463 + *[0-9a-f]*:	e9 d4 37 ff 	ldswp\.uh r4,r4\[4094\]

 12464 + *[0-9a-f]*:	fd de 30 01 	ldswp\.uh lr,lr\[2\]

 12465 + *[0-9a-f]*:	f3 d4 37 46 	ldswp\.uh r4,r9\[3724\]

 12466 + *[0-9a-f]*:	fb de 3c bc 	ldswp\.uh lr,sp\[-1672\]

 12467 + *[0-9a-f]*:	f9 d8 38 7d 	ldswp\.uh r8,r12\[-3846\]

 12468 +

 12469 +[0-9a-f]* <ldswp_w>:

 12470 + *[0-9a-f]*:	ff df 80 00 	ldswp\.w pc,pc\[0\]

 12471 + *[0-9a-f]*:	f9 dc 8f ff 	ldswp\.w r12,r12\[-4\]

 12472 + *[0-9a-f]*:	eb d5 88 00 	ldswp\.w r5,r5\[-8192\]

 12473 + *[0-9a-f]*:	e9 d4 87 ff 	ldswp\.w r4,r4\[8188\]

 12474 + *[0-9a-f]*:	fd de 80 01 	ldswp\.w lr,lr\[4\]

 12475 + *[0-9a-f]*:	ef dd 81 d1 	ldswp\.w sp,r7\[1860\]

 12476 + *[0-9a-f]*:	eb df 8c c1 	ldswp\.w pc,r5\[-3324\]

 12477 + *[0-9a-f]*:	f5 dc 8c c8 	ldswp\.w r12,r10\[-3296\]

 12478 +

 12479 +[0-9a-f]* <stswp_h>:

 12480 + *[0-9a-f]*:	ff df 90 00 	stswp\.h pc\[0\],pc

 12481 + *[0-9a-f]*:	f9 dc 9f ff 	stswp\.h r12\[-2\],r12

 12482 + *[0-9a-f]*:	eb d5 98 00 	stswp\.h r5\[-4096\],r5

 12483 + *[0-9a-f]*:	e9 d4 97 ff 	stswp\.h r4\[4094\],r4

 12484 + *[0-9a-f]*:	fd de 90 01 	stswp\.h lr\[2\],lr

 12485 + *[0-9a-f]*:	ef da 90 20 	stswp\.h r7\[64\],r10

 12486 + *[0-9a-f]*:	f5 d2 95 e8 	stswp\.h r10\[3024\],r2

 12487 + *[0-9a-f]*:	e1 da 9b 74 	stswp\.h r0\[-2328\],r10

 12488 +

 12489 +[0-9a-f]* <stswp_w>:

 12490 + *[0-9a-f]*:	ff df a0 00 	stswp\.w pc\[0\],pc

 12491 + *[0-9a-f]*:	f9 dc af ff 	stswp\.w r12\[-4\],r12

 12492 + *[0-9a-f]*:	eb d5 a8 00 	stswp\.w r5\[-8192\],r5

 12493 + *[0-9a-f]*:	e9 d4 a7 ff 	stswp\.w r4\[8188\],r4

 12494 + *[0-9a-f]*:	fd de a0 01 	stswp\.w lr\[4\],lr

 12495 + *[0-9a-f]*:	ff d8 a1 21 	stswp\.w pc\[1156\],r8

 12496 + *[0-9a-f]*:	fb da a7 ce 	stswp\.w sp\[7992\],r10

 12497 + *[0-9a-f]*:	f1 d5 ae db 	stswp\.w r8\[-1172\],r5

 12498 +

 12499 +[0-9a-f]* <and2>:

 12500 + *[0-9a-f]*:	ff ef 00 0f 	and pc,pc,pc

 12501 + *[0-9a-f]*:	f9 ec 01 fc 	and r12,r12,r12<<0x1f

 12502 + *[0-9a-f]*:	eb e5 01 05 	and r5,r5,r5<<0x10

 12503 + *[0-9a-f]*:	e9 e4 00 f4 	and r4,r4,r4<<0xf

 12504 + *[0-9a-f]*:	fd ee 00 1e 	and lr,lr,lr<<0x1

 12505 + *[0-9a-f]*:	e5 e1 00 1a 	and r10,r2,r1<<0x1

 12506 + *[0-9a-f]*:	f1 eb 01 bc 	and r12,r8,r11<<0x1b

 12507 + *[0-9a-f]*:	ef e0 00 3a 	and r10,r7,r0<<0x3

 12508 +

 12509 +[0-9a-f]* <and3>:

 12510 + *[0-9a-f]*:	ff ef 02 0f 	and pc,pc,pc

 12511 + *[0-9a-f]*:	f9 ec 03 fc 	and r12,r12,r12>>0x1f

 12512 + *[0-9a-f]*:	eb e5 03 05 	and r5,r5,r5>>0x10

 12513 + *[0-9a-f]*:	e9 e4 02 f4 	and r4,r4,r4>>0xf

 12514 + *[0-9a-f]*:	fd ee 02 1e 	and lr,lr,lr>>0x1

 12515 + *[0-9a-f]*:	f1 e7 03 1c 	and r12,r8,r7>>0x11

 12516 + *[0-9a-f]*:	e9 e9 03 4f 	and pc,r4,r9>>0x14

 12517 + *[0-9a-f]*:	f3 ea 02 ca 	and r10,r9,r10>>0xc

 12518 +

 12519 +[0-9a-f]* <or2>:

 12520 + *[0-9a-f]*:	ff ef 10 0f 	or pc,pc,pc

 12521 + *[0-9a-f]*:	f9 ec 11 fc 	or r12,r12,r12<<0x1f

 12522 + *[0-9a-f]*:	eb e5 11 05 	or r5,r5,r5<<0x10

 12523 + *[0-9a-f]*:	e9 e4 10 f4 	or r4,r4,r4<<0xf

 12524 + *[0-9a-f]*:	fd ee 10 1e 	or lr,lr,lr<<0x1

 12525 + *[0-9a-f]*:	fb eb 11 d8 	or r8,sp,r11<<0x1d

 12526 + *[0-9a-f]*:	f3 e2 11 cf 	or pc,r9,r2<<0x1c

 12527 + *[0-9a-f]*:	e3 e2 10 35 	or r5,r1,r2<<0x3

 12528 +

 12529 +[0-9a-f]* <or3>:

 12530 + *[0-9a-f]*:	ff ef 12 0f 	or pc,pc,pc

 12531 + *[0-9a-f]*:	f9 ec 13 fc 	or r12,r12,r12>>0x1f

 12532 + *[0-9a-f]*:	eb e5 13 05 	or r5,r5,r5>>0x10

 12533 + *[0-9a-f]*:	e9 e4 12 f4 	or r4,r4,r4>>0xf

 12534 + *[0-9a-f]*:	fd ee 12 1e 	or lr,lr,lr>>0x1

 12535 + *[0-9a-f]*:	fb ed 12 21 	or r1,sp,sp>>0x2

 12536 + *[0-9a-f]*:	e3 e1 13 d0 	or r0,r1,r1>>0x1d

 12537 + *[0-9a-f]*:	f9 e8 12 84 	or r4,r12,r8>>0x8

 12538 +

 12539 +[0-9a-f]* <eor2>:

 12540 + *[0-9a-f]*:	ff ef 20 0f 	eor pc,pc,pc

 12541 + *[0-9a-f]*:	f9 ec 21 fc 	eor r12,r12,r12<<0x1f

 12542 + *[0-9a-f]*:	eb e5 21 05 	eor r5,r5,r5<<0x10

 12543 + *[0-9a-f]*:	e9 e4 20 f4 	eor r4,r4,r4<<0xf

 12544 + *[0-9a-f]*:	fd ee 20 1e 	eor lr,lr,lr<<0x1

 12545 + *[0-9a-f]*:	f3 e4 20 ba 	eor r10,r9,r4<<0xb

 12546 + *[0-9a-f]*:	e1 e1 21 f4 	eor r4,r0,r1<<0x1f

 12547 + *[0-9a-f]*:	e5 ec 20 d6 	eor r6,r2,r12<<0xd

 12548 +

 12549 +[0-9a-f]* <eor3>:

 12550 + *[0-9a-f]*:	ff ef 22 0f 	eor pc,pc,pc

 12551 + *[0-9a-f]*:	f9 ec 23 fc 	eor r12,r12,r12>>0x1f

 12552 + *[0-9a-f]*:	eb e5 23 05 	eor r5,r5,r5>>0x10

 12553 + *[0-9a-f]*:	e9 e4 22 f4 	eor r4,r4,r4>>0xf

 12554 + *[0-9a-f]*:	fd ee 22 1e 	eor lr,lr,lr>>0x1

 12555 + *[0-9a-f]*:	eb e5 23 65 	eor r5,r5,r5>>0x16

 12556 + *[0-9a-f]*:	e3 ee 22 3a 	eor r10,r1,lr>>0x3

 12557 + *[0-9a-f]*:	fd ed 23 a7 	eor r7,lr,sp>>0x1a

 12558 +

 12559 +[0-9a-f]* <sthh_w2>:

 12560 + *[0-9a-f]*:	ff ef 8f 0f 	sthh\.w pc\[pc\],pc:b,pc:b

 12561 + *[0-9a-f]*:	f9 ec bc 3c 	sthh\.w r12\[r12<<0x3\],r12:t,r12:t

 12562 + *[0-9a-f]*:	eb e5 b5 25 	sthh\.w r5\[r5<<0x2\],r5:t,r5:t

 12563 + *[0-9a-f]*:	e9 e4 84 14 	sthh\.w r4\[r4<<0x1\],r4:b,r4:b

 12564 + *[0-9a-f]*:	fd ee be 1e 	sthh\.w lr\[lr<<0x1\],lr:t,lr:t

 12565 + *[0-9a-f]*:	e3 ec b6 3d 	sthh\.w sp\[r6<<0x3\],r1:t,r12:t

 12566 + *[0-9a-f]*:	f3 e9 b6 06 	sthh\.w r6\[r6\],r9:t,r9:t

 12567 + *[0-9a-f]*:	e1 eb 93 0a 	sthh\.w r10\[r3\],r0:b,r11:t

 12568 +

 12569 +[0-9a-f]* <sthh_w1>:

 12570 + *[0-9a-f]*:	ff ef c0 0f 	sthh\.w pc\[0x0\],pc:b,pc:b

 12571 + *[0-9a-f]*:	f9 ec ff fc 	sthh\.w r12\[0x3fc\],r12:t,r12:t

 12572 + *[0-9a-f]*:	eb e5 f8 05 	sthh\.w r5\[0x200\],r5:t,r5:t

 12573 + *[0-9a-f]*:	e9 e4 c7 f4 	sthh\.w r4\[0x1fc\],r4:b,r4:b

 12574 + *[0-9a-f]*:	fd ee f0 1e 	sthh\.w lr\[0x4\],lr:t,lr:t

 12575 + *[0-9a-f]*:	f3 e0 e6 54 	sthh\.w r4\[0x194\],r9:t,r0:b

 12576 + *[0-9a-f]*:	e5 ea e5 78 	sthh\.w r8\[0x15c\],r2:t,r10:b

 12577 + *[0-9a-f]*:	f3 e2 c2 bd 	sthh\.w sp\[0xac\],r9:b,r2:b

 12578 +

 12579 +[0-9a-f]* <cop>:

 12580 + *[0-9a-f]*:	e1 a0 00 00 	cop cp0,cr0,cr0,cr0,0x0

 12581 + *[0-9a-f]*:	e7 af ff ff 	cop cp7,cr15,cr15,cr15,0x7f

 12582 + *[0-9a-f]*:	e3 a8 75 55 	cop cp3,cr5,cr5,cr5,0x31

 12583 + *[0-9a-f]*:	e3 a8 44 44 	cop cp2,cr4,cr4,cr4,0x30

 12584 + *[0-9a-f]*:	e5 ad a8 37 	cop cp5,cr8,cr3,cr7,0x5a

 12585 +

 12586 +[0-9a-f]* <ldc_w1>:

 12587 + *[0-9a-f]*:	e9 a0 00 00 	ldc\.w cp0,cr0,r0\[0x0\]

 12588 + *[0-9a-f]*:	e9 af ef ff 	ldc\.w cp7,cr15,pc\[0x3fc\]

 12589 + *[0-9a-f]*:	e9 a5 65 80 	ldc\.w cp3,cr5,r5\[0x200\]

 12590 + *[0-9a-f]*:	e9 a4 44 7f 	ldc\.w cp2,cr4,r4\[0x1fc\]

 12591 + *[0-9a-f]*:	e9 ad 89 24 	ldc\.w cp4,cr9,sp\[0x90\]

 12592 +

 12593 +[0-9a-f]* <ldc_w2>:

 12594 + *[0-9a-f]*:	ef a0 00 40 	ldc\.w cp0,cr0,--r0

 12595 + *[0-9a-f]*:	ef af ef 40 	ldc\.w cp7,cr15,--pc

 12596 + *[0-9a-f]*:	ef a5 65 40 	ldc\.w cp3,cr5,--r5

 12597 + *[0-9a-f]*:	ef a4 44 40 	ldc\.w cp2,cr4,--r4

 12598 + *[0-9a-f]*:	ef ad 89 40 	ldc\.w cp4,cr9,--sp

 12599 +

 12600 +[0-9a-f]* <ldc_w3>:

 12601 + *[0-9a-f]*:	ef a0 10 00 	ldc\.w cp0,cr0,r0\[r0\]

 12602 + *[0-9a-f]*:	ef af ff 3f 	ldc\.w cp7,cr15,pc\[pc<<0x3\]

 12603 + *[0-9a-f]*:	ef a5 75 24 	ldc\.w cp3,cr5,r5\[r4<<0x2\]

 12604 + *[0-9a-f]*:	ef a4 54 13 	ldc\.w cp2,cr4,r4\[r3<<0x1\]

 12605 + *[0-9a-f]*:	ef ad 99 0c 	ldc\.w cp4,cr9,sp\[r12\]

 12606 +

 12607 +[0-9a-f]* <ldc_d1>:

 12608 + *[0-9a-f]*:	e9 a0 10 00 	ldc\.d cp0,cr0,r0\[0x0\]

 12609 + *[0-9a-f]*:	e9 af fe ff 	ldc\.d cp7,cr14,pc\[0x3fc\]

 12610 + *[0-9a-f]*:	e9 a5 76 80 	ldc\.d cp3,cr6,r5\[0x200\]

 12611 + *[0-9a-f]*:	e9 a4 54 7f 	ldc\.d cp2,cr4,r4\[0x1fc\]

 12612 + *[0-9a-f]*:	e9 ad 98 24 	ldc\.d cp4,cr8,sp\[0x90\]

 12613 +

 12614 +[0-9a-f]* <ldc_d2>:

 12615 + *[0-9a-f]*:	ef a0 00 50 	ldc\.d cp0,cr0,--r0

 12616 + *[0-9a-f]*:	ef af ee 50 	ldc\.d cp7,cr14,--pc

 12617 + *[0-9a-f]*:	ef a5 66 50 	ldc\.d cp3,cr6,--r5

 12618 + *[0-9a-f]*:	ef a4 44 50 	ldc\.d cp2,cr4,--r4

 12619 + *[0-9a-f]*:	ef ad 88 50 	ldc\.d cp4,cr8,--sp

 12620 +

 12621 +[0-9a-f]* <ldc_d3>:

 12622 + *[0-9a-f]*:	ef a0 10 40 	ldc\.d cp0,cr0,r0\[r0\]

 12623 + *[0-9a-f]*:	ef af fe 7f 	ldc\.d cp7,cr14,pc\[pc<<0x3\]

 12624 + *[0-9a-f]*:	ef a5 76 64 	ldc\.d cp3,cr6,r5\[r4<<0x2\]

 12625 + *[0-9a-f]*:	ef a4 54 53 	ldc\.d cp2,cr4,r4\[r3<<0x1\]

 12626 + *[0-9a-f]*:	ef ad 98 4c 	ldc\.d cp4,cr8,sp\[r12\]

 12627 +

 12628 +[0-9a-f]* <stc_w1>:

 12629 + *[0-9a-f]*:	eb a0 00 00 	stc\.w cp0,r0\[0x0\],cr0

 12630 + *[0-9a-f]*:	eb af ef ff 	stc\.w cp7,pc\[0x3fc\],cr15

 12631 + *[0-9a-f]*:	eb a5 65 80 	stc\.w cp3,r5\[0x200\],cr5

 12632 + *[0-9a-f]*:	eb a4 44 7f 	stc\.w cp2,r4\[0x1fc\],cr4

 12633 + *[0-9a-f]*:	eb ad 89 24 	stc\.w cp4,sp\[0x90\],cr9

 12634 +

 12635 +[0-9a-f]* <stc_w2>:

 12636 + *[0-9a-f]*:	ef a0 00 60 	stc\.w cp0,r0\+\+,cr0

 12637 + *[0-9a-f]*:	ef af ef 60 	stc\.w cp7,pc\+\+,cr15

 12638 + *[0-9a-f]*:	ef a5 65 60 	stc\.w cp3,r5\+\+,cr5

 12639 + *[0-9a-f]*:	ef a4 44 60 	stc\.w cp2,r4\+\+,cr4

 12640 + *[0-9a-f]*:	ef ad 89 60 	stc\.w cp4,sp\+\+,cr9

 12641 +

 12642 +[0-9a-f]* <stc_w3>:

 12643 + *[0-9a-f]*:	ef a0 10 80 	stc\.w cp0,r0\[r0\],cr0

 12644 + *[0-9a-f]*:	ef af ff bf 	stc\.w cp7,pc\[pc<<0x3\],cr15

 12645 + *[0-9a-f]*:	ef a5 75 a4 	stc\.w cp3,r5\[r4<<0x2\],cr5

 12646 + *[0-9a-f]*:	ef a4 54 93 	stc\.w cp2,r4\[r3<<0x1\],cr4

 12647 + *[0-9a-f]*:	ef ad 99 8c 	stc\.w cp4,sp\[r12\],cr9

 12648 +

 12649 +[0-9a-f]* <stc_d1>:

 12650 + *[0-9a-f]*:	eb a0 10 00 	stc\.d cp0,r0\[0x0\],cr0

 12651 + *[0-9a-f]*:	eb af fe ff 	stc\.d cp7,pc\[0x3fc\],cr14

 12652 + *[0-9a-f]*:	eb a5 76 80 	stc\.d cp3,r5\[0x200\],cr6

 12653 + *[0-9a-f]*:	eb a4 54 7f 	stc\.d cp2,r4\[0x1fc\],cr4

 12654 + *[0-9a-f]*:	eb ad 98 24 	stc\.d cp4,sp\[0x90\],cr8

 12655 +

 12656 +[0-9a-f]* <stc_d2>:

 12657 + *[0-9a-f]*:	ef a0 00 70 	stc\.d cp0,r0\+\+,cr0

 12658 + *[0-9a-f]*:	ef af ee 70 	stc\.d cp7,pc\+\+,cr14

 12659 + *[0-9a-f]*:	ef a5 66 70 	stc\.d cp3,r5\+\+,cr6

 12660 + *[0-9a-f]*:	ef a4 44 70 	stc\.d cp2,r4\+\+,cr4

 12661 + *[0-9a-f]*:	ef ad 88 70 	stc\.d cp4,sp\+\+,cr8

 12662 +

 12663 +[0-9a-f]* <stc_d3>:

 12664 + *[0-9a-f]*:	ef a0 10 c0 	stc\.d cp0,r0\[r0\],cr0

 12665 + *[0-9a-f]*:	ef af fe ff 	stc\.d cp7,pc\[pc<<0x3\],cr14

 12666 + *[0-9a-f]*:	ef a5 76 e4 	stc\.d cp3,r5\[r4<<0x2\],cr6

 12667 + *[0-9a-f]*:	ef a4 54 d3 	stc\.d cp2,r4\[r3<<0x1\],cr4

 12668 + *[0-9a-f]*:	ef ad 98 cc 	stc\.d cp4,sp\[r12\],cr8

 12669 +

 12670 +[0-9a-f]* <ldc0_w>:

 12671 + *[0-9a-f]*:	f1 a0 00 00 	ldc0\.w cr0,r0\[0x0\]

 12672 + *[0-9a-f]*:	f1 af ff ff 	ldc0\.w cr15,pc\[0x3ffc\]

 12673 + *[0-9a-f]*:	f1 a5 85 00 	ldc0\.w cr5,r5\[0x2000\]

 12674 + *[0-9a-f]*:	f1 a4 74 ff 	ldc0\.w cr4,r4\[0x1ffc\]

 12675 + *[0-9a-f]*:	f1 ad 09 93 	ldc0\.w cr9,sp\[0x24c\]

 12676 +

 12677 +[0-9a-f]* <ldc0_d>:

 12678 + *[0-9a-f]*:	f3 a0 00 00 	ldc0\.d cr0,r0\[0x0\]

 12679 + *[0-9a-f]*:	f3 af fe ff 	ldc0\.d cr14,pc\[0x3ffc\]

 12680 + *[0-9a-f]*:	f3 a5 86 00 	ldc0\.d cr6,r5\[0x2000\]

 12681 + *[0-9a-f]*:	f3 a4 74 ff 	ldc0\.d cr4,r4\[0x1ffc\]

 12682 + *[0-9a-f]*:	f3 ad 08 93 	ldc0\.d cr8,sp\[0x24c\]

 12683 +

 12684 +[0-9a-f]* <stc0_w>:

 12685 + *[0-9a-f]*:	f5 a0 00 00 	stc0\.w r0\[0x0\],cr0

 12686 + *[0-9a-f]*:	f5 af ff ff 	stc0\.w pc\[0x3ffc\],cr15

 12687 + *[0-9a-f]*:	f5 a5 85 00 	stc0\.w r5\[0x2000\],cr5

 12688 + *[0-9a-f]*:	f5 a4 74 ff 	stc0\.w r4\[0x1ffc\],cr4

 12689 + *[0-9a-f]*:	f5 ad 09 93 	stc0\.w sp\[0x24c\],cr9

 12690 +

 12691 +[0-9a-f]* <stc0_d>:

 12692 + *[0-9a-f]*:	f7 a0 00 00 	stc0\.d r0\[0x0\],cr0

 12693 + *[0-9a-f]*:	f7 af fe ff 	stc0\.d pc\[0x3ffc\],cr14

 12694 + *[0-9a-f]*:	f7 a5 86 00 	stc0\.d r5\[0x2000\],cr6

 12695 + *[0-9a-f]*:	f7 a4 74 ff 	stc0\.d r4\[0x1ffc\],cr4

 12696 + *[0-9a-f]*:	f7 ad 08 93 	stc0\.d sp\[0x24c\],cr8

 12697 +

 12698 +[0-9a-f]* <memc>:

 12699 + *[0-9a-f]*:	f6 10 00 00 	memc 0,0x0

 12700 + *[0-9a-f]*:	f6 1f ff ff 	memc -4,0x1f

 12701 + *[0-9a-f]*:	f6 18 40 00 	memc -65536,0x10

 12702 + *[0-9a-f]*:	f6 17 bf ff 	memc 65532,0xf

 12703 +

 12704 +[0-9a-f]* <mems>:

 12705 + *[0-9a-f]*:	f8 10 00 00 	mems 0,0x0

 12706 + *[0-9a-f]*:	f8 1f ff ff 	mems -4,0x1f

 12707 + *[0-9a-f]*:	f8 18 40 00 	mems -65536,0x10

 12708 + *[0-9a-f]*:	f8 17 bf ff 	mems 65532,0xf

 12709 +

 12710 +[0-9a-f]* <memt>:

 12711 + *[0-9a-f]*:	fa 10 00 00 	memt 0,0x0

 12712 + *[0-9a-f]*:	fa 1f ff ff 	memt -4,0x1f

 12713 + *[0-9a-f]*:	fa 18 40 00 	memt -65536,0x10

 12714 + *[0-9a-f]*:	fa 17 bf ff 	memt 65532,0xf

 12715 +

 12716 +[0-9a-f]* <stcond>:

 12717 + *[0-9a-f]*:	e1 70 00 00 	stcond r0\[0\],r0

 12718 + *[0-9a-f]*:	ff 7f ff ff 	stcond pc\[-1\],pc

 12719 + *[0-9a-f]*:	f1 77 80 00 	stcond r8\[-32768\],r7

 12720 + *[0-9a-f]*:	ef 78 7f ff 	stcond r7\[32767\],r8

 12721 + *[0-9a-f]*:	eb 7a 12 34 	stcond r5\[4660\],r10

 12722 +

 12723 +[0-9a-f]* <ldcm_w>:

 12724 + *[0-9a-f]*:	ed af 00 ff 	ldcm\.w cp0,pc,cr0-cr7

 12725 + *[0-9a-f]*:	ed a0 e0 01 	ldcm\.w cp7,r0,cr0

 12726 + *[0-9a-f]*:	ed a4 90 7f 	ldcm\.w cp4,r4\+\+,cr0-cr6

 12727 + *[0-9a-f]*:	ed a7 60 80 	ldcm\.w cp3,r7,cr7

 12728 + *[0-9a-f]*:	ed ac 30 72 	ldcm\.w cp1,r12\+\+,cr1,cr4-cr6

 12729 + *[0-9a-f]*:	ed af 01 ff 	ldcm\.w cp0,pc,cr8-cr15

 12730 + *[0-9a-f]*:	ed a0 e1 01 	ldcm\.w cp7,r0,cr8

 12731 + *[0-9a-f]*:	ed a4 91 7f 	ldcm\.w cp4,r4\+\+,cr8-cr14

 12732 + *[0-9a-f]*:	ed a7 61 80 	ldcm\.w cp3,r7,cr15

 12733 + *[0-9a-f]*:	ed ac 31 72 	ldcm\.w cp1,r12\+\+,cr9,cr12-cr14

 12734 +

 12735 +[0-9a-f]* <ldcm_d>:

 12736 + *[0-9a-f]*:	ed af 04 ff 	ldcm\.d cp0,pc,cr0-cr15

 12737 + *[0-9a-f]*:	ed a0 e4 01 	ldcm\.d cp7,r0,cr0-cr1

 12738 + *[0-9a-f]*:	ed a4 94 7f 	ldcm\.d cp4,r4\+\+,cr0-cr13

 12739 + *[0-9a-f]*:	ed a7 64 80 	ldcm\.d cp3,r7,cr14-cr15

 12740 + *[0-9a-f]*:	ed ac 54 93 	ldcm\.d cp2,r12\+\+,cr0-cr3,cr8-cr9,cr14-cr15

 12741 +

 12742 +[0-9a-f]* <stcm_w>:

 12743 + *[0-9a-f]*:	ed af 02 ff 	stcm\.w cp0,pc,cr0-cr7

 12744 + *[0-9a-f]*:	ed a0 e2 01 	stcm\.w cp7,r0,cr0

 12745 + *[0-9a-f]*:	ed a4 92 7f 	stcm\.w cp4,--r4,cr0-cr6

 12746 + *[0-9a-f]*:	ed a7 62 80 	stcm\.w cp3,r7,cr7

 12747 + *[0-9a-f]*:	ed ac 32 72 	stcm\.w cp1,--r12,cr1,cr4-cr6

 12748 + *[0-9a-f]*:	ed af 03 ff 	stcm\.w cp0,pc,cr8-cr15

 12749 + *[0-9a-f]*:	ed a0 e3 01 	stcm\.w cp7,r0,cr8

 12750 + *[0-9a-f]*:	ed a4 93 7f 	stcm\.w cp4,--r4,cr8-cr14

 12751 + *[0-9a-f]*:	ed a7 63 80 	stcm\.w cp3,r7,cr15

 12752 + *[0-9a-f]*:	ed ac 33 72 	stcm\.w cp1,--r12,cr9,cr12-cr14

 12753 +

 12754 +[0-9a-f]* <stcm_d>:

 12755 + *[0-9a-f]*:	ed af 05 ff 	stcm\.d cp0,pc,cr0-cr15

 12756 + *[0-9a-f]*:	ed a0 e5 01 	stcm\.d cp7,r0,cr0-cr1

 12757 + *[0-9a-f]*:	ed a4 95 7f 	stcm\.d cp4,--r4,cr0-cr13

 12758 + *[0-9a-f]*:	ed a7 65 80 	stcm\.d cp3,r7,cr14-cr15

 12759 + *[0-9a-f]*:	ed ac 55 93 	stcm\.d cp2,--r12,cr0-cr3,cr8-cr9,cr14-cr15

 12760 +

 12761 +[0-9a-f]* <mvcr_w>:

 12762 + *[0-9a-f]*:	ef af ef 00 	mvcr\.w cp7,pc,cr15

 12763 + *[0-9a-f]*:	ef a0 00 00 	mvcr\.w cp0,r0,cr0

 12764 + *[0-9a-f]*:	ef af 0f 00 	mvcr\.w cp0,pc,cr15

 12765 + *[0-9a-f]*:	ef a0 ef 00 	mvcr\.w cp7,r0,cr15

 12766 + *[0-9a-f]*:	ef af e0 00 	mvcr\.w cp7,pc,cr0

 12767 + *[0-9a-f]*:	ef a7 88 00 	mvcr\.w cp4,r7,cr8

 12768 + *[0-9a-f]*:	ef a8 67 00 	mvcr\.w cp3,r8,cr7

 12769 +

 12770 +[0-9a-f]* <mvcr_d>:

 12771 + *[0-9a-f]*:	ef ae ee 10 	mvcr\.d cp7,lr,cr14

 12772 + *[0-9a-f]*:	ef a0 00 10 	mvcr\.d cp0,r0,cr0

 12773 + *[0-9a-f]*:	ef ae 0e 10 	mvcr\.d cp0,lr,cr14

 12774 + *[0-9a-f]*:	ef a0 ee 10 	mvcr\.d cp7,r0,cr14

 12775 + *[0-9a-f]*:	ef ae e0 10 	mvcr\.d cp7,lr,cr0

 12776 + *[0-9a-f]*:	ef a6 88 10 	mvcr\.d cp4,r6,cr8

 12777 + *[0-9a-f]*:	ef a8 66 10 	mvcr\.d cp3,r8,cr6

 12778 +

 12779 +[0-9a-f]* <mvrc_w>:

 12780 + *[0-9a-f]*:	ef af ef 20 	mvrc\.w cp7,cr15,pc

 12781 + *[0-9a-f]*:	ef a0 00 20 	mvrc\.w cp0,cr0,r0

 12782 + *[0-9a-f]*:	ef af 0f 20 	mvrc\.w cp0,cr15,pc

 12783 + *[0-9a-f]*:	ef a0 ef 20 	mvrc\.w cp7,cr15,r0

 12784 + *[0-9a-f]*:	ef af e0 20 	mvrc\.w cp7,cr0,pc

 12785 + *[0-9a-f]*:	ef a7 88 20 	mvrc\.w cp4,cr8,r7

 12786 + *[0-9a-f]*:	ef a8 67 20 	mvrc\.w cp3,cr7,r8

 12787 +

 12788 +[0-9a-f]* <mvrc_d>:

 12789 + *[0-9a-f]*:	ef ae ee 30 	mvrc\.d cp7,cr14,lr

 12790 + *[0-9a-f]*:	ef a0 00 30 	mvrc\.d cp0,cr0,r0

 12791 + *[0-9a-f]*:	ef ae 0e 30 	mvrc\.d cp0,cr14,lr

 12792 + *[0-9a-f]*:	ef a0 ee 30 	mvrc\.d cp7,cr14,r0

 12793 + *[0-9a-f]*:	ef ae e0 30 	mvrc\.d cp7,cr0,lr

 12794 + *[0-9a-f]*:	ef a6 88 30 	mvrc\.d cp4,cr8,r6

 12795 + *[0-9a-f]*:	ef a8 66 30 	mvrc\.d cp3,cr6,r8

 12796 +

 12797 +[0-9a-f]* <bfexts>:

 12798 + *[0-9a-f]*:	ff df b3 ff 	bfexts pc,pc,0x1f,0x1f

 12799 + *[0-9a-f]*:	e1 d0 b0 00 	bfexts r0,r0,0x0,0x0

 12800 + *[0-9a-f]*:	e1 df b3 ff 	bfexts r0,pc,0x1f,0x1f

 12801 + *[0-9a-f]*:	ff d0 b3 ff 	bfexts pc,r0,0x1f,0x1f

 12802 + *[0-9a-f]*:	ff df b0 1f 	bfexts pc,pc,0x0,0x1f

 12803 + *[0-9a-f]*:	ff df b3 e0 	bfexts pc,pc,0x1f,0x0

 12804 + *[0-9a-f]*:	ef d8 b1 f0 	bfexts r7,r8,0xf,0x10

 12805 + *[0-9a-f]*:	f1 d7 b2 0f 	bfexts r8,r7,0x10,0xf

 12806 +

 12807 +[0-9a-f]* <bfextu>:

 12808 + *[0-9a-f]*:	ff df c3 ff 	bfextu pc,pc,0x1f,0x1f

 12809 + *[0-9a-f]*:	e1 d0 c0 00 	bfextu r0,r0,0x0,0x0

 12810 + *[0-9a-f]*:	e1 df c3 ff 	bfextu r0,pc,0x1f,0x1f

 12811 + *[0-9a-f]*:	ff d0 c3 ff 	bfextu pc,r0,0x1f,0x1f

 12812 + *[0-9a-f]*:	ff df c0 1f 	bfextu pc,pc,0x0,0x1f

 12813 + *[0-9a-f]*:	ff df c3 e0 	bfextu pc,pc,0x1f,0x0

 12814 + *[0-9a-f]*:	ef d8 c1 f0 	bfextu r7,r8,0xf,0x10

 12815 + *[0-9a-f]*:	f1 d7 c2 0f 	bfextu r8,r7,0x10,0xf

 12816 +

 12817 +[0-9a-f]* <bfins>:

 12818 + *[0-9a-f]*:	ff df d3 ff 	bfins pc,pc,0x1f,0x1f

 12819 + *[0-9a-f]*:	e1 d0 d0 00 	bfins r0,r0,0x0,0x0

 12820 + *[0-9a-f]*:	e1 df d3 ff 	bfins r0,pc,0x1f,0x1f

 12821 + *[0-9a-f]*:	ff d0 d3 ff 	bfins pc,r0,0x1f,0x1f

 12822 + *[0-9a-f]*:	ff df d0 1f 	bfins pc,pc,0x0,0x1f

 12823 + *[0-9a-f]*:	ff df d3 e0 	bfins pc,pc,0x1f,0x0

 12824 + *[0-9a-f]*:	ef d8 d1 f0 	bfins r7,r8,0xf,0x10

 12825 + *[0-9a-f]*:	f1 d7 d2 0f 	bfins r8,r7,0x10,0xf

 12826 +

 12827 +[0-9a-f]* <rsubc>:

 12828 + *[0-9a-f]*:	fb bf 00 00 	rsubeq pc,0

 12829 + *[0-9a-f]*:	fb bc 0f ff 	rsubal r12,-1

 12830 + *[0-9a-f]*:	fb b5 08 80 	rsubls r5,-128

 12831 + *[0-9a-f]*:	fb b4 07 7f 	rsubpl r4,127

 12832 + *[0-9a-f]*:	fb be 01 01 	rsubne lr,1

 12833 + *[0-9a-f]*:	fb bc 08 76 	rsubls r12,118

 12834 + *[0-9a-f]*:	fb be 0d f4 	rsubvc lr,-12

 12835 + *[0-9a-f]*:	fb b4 06 f3 	rsubmi r4,-13

 12836 +

 12837 +[0-9a-f]* <addc>:

 12838 + *[0-9a-f]*:	ff df e0 0f 	addeq pc,pc,pc

 12839 + *[0-9a-f]*:	f9 dc ef 0c 	addal r12,r12,r12

 12840 + *[0-9a-f]*:	eb d5 e8 05 	addls r5,r5,r5

 12841 + *[0-9a-f]*:	e9 d4 e7 04 	addpl r4,r4,r4

 12842 + *[0-9a-f]*:	fd de e1 0e 	addne lr,lr,lr

 12843 + *[0-9a-f]*:	e5 d1 e8 0a 	addls r10,r2,r1

 12844 + *[0-9a-f]*:	f1 db ed 0c 	addvc r12,r8,r11

 12845 + *[0-9a-f]*:	ef d0 e6 0a 	addmi r10,r7,r0

 12846 +

 12847 +[0-9a-f]* <subc2>:

 12848 + *[0-9a-f]*:	ff df e0 1f 	subeq pc,pc,pc

 12849 + *[0-9a-f]*:	f9 dc ef 1c 	subal r12,r12,r12

 12850 + *[0-9a-f]*:	eb d5 e8 15 	subls r5,r5,r5

 12851 + *[0-9a-f]*:	e9 d4 e7 14 	subpl r4,r4,r4

 12852 + *[0-9a-f]*:	fd de e1 1e 	subne lr,lr,lr

 12853 + *[0-9a-f]*:	e5 d1 e8 1a 	subls r10,r2,r1

 12854 + *[0-9a-f]*:	f1 db ed 1c 	subvc r12,r8,r11

 12855 + *[0-9a-f]*:	ef d0 e6 1a 	submi r10,r7,r0

 12856 +

 12857 +[0-9a-f]* <andc>:

 12858 + *[0-9a-f]*:	ff df e0 2f 	andeq pc,pc,pc

 12859 + *[0-9a-f]*:	f9 dc ef 2c 	andal r12,r12,r12

 12860 + *[0-9a-f]*:	eb d5 e8 25 	andls r5,r5,r5

 12861 + *[0-9a-f]*:	e9 d4 e7 24 	andpl r4,r4,r4

 12862 + *[0-9a-f]*:	fd de e1 2e 	andne lr,lr,lr

 12863 + *[0-9a-f]*:	e5 d1 e8 2a 	andls r10,r2,r1

 12864 + *[0-9a-f]*:	f1 db ed 2c 	andvc r12,r8,r11

 12865 + *[0-9a-f]*:	ef d0 e6 2a 	andmi r10,r7,r0

 12866 +

 12867 +[0-9a-f]* <orc>:

 12868 + *[0-9a-f]*:	ff df e0 3f 	oreq pc,pc,pc

 12869 + *[0-9a-f]*:	f9 dc ef 3c 	oral r12,r12,r12

 12870 + *[0-9a-f]*:	eb d5 e8 35 	orls r5,r5,r5

 12871 + *[0-9a-f]*:	e9 d4 e7 34 	orpl r4,r4,r4

 12872 + *[0-9a-f]*:	fd de e1 3e 	orne lr,lr,lr

 12873 + *[0-9a-f]*:	e5 d1 e8 3a 	orls r10,r2,r1

 12874 + *[0-9a-f]*:	f1 db ed 3c 	orvc r12,r8,r11

 12875 + *[0-9a-f]*:	ef d0 e6 3a 	ormi r10,r7,r0

 12876 +

 12877 +[0-9a-f]* <eorc>:

 12878 + *[0-9a-f]*:	ff df e0 4f 	eoreq pc,pc,pc

 12879 + *[0-9a-f]*:	f9 dc ef 4c 	eoral r12,r12,r12

 12880 + *[0-9a-f]*:	eb d5 e8 45 	eorls r5,r5,r5

 12881 + *[0-9a-f]*:	e9 d4 e7 44 	eorpl r4,r4,r4

 12882 + *[0-9a-f]*:	fd de e1 4e 	eorne lr,lr,lr

 12883 + *[0-9a-f]*:	e5 d1 e8 4a 	eorls r10,r2,r1

 12884 + *[0-9a-f]*:	f1 db ed 4c 	eorvc r12,r8,r11

 12885 + *[0-9a-f]*:	ef d0 e6 4a 	eormi r10,r7,r0

 12886 +

 12887 +[0-9a-f]* <ldcond>:

 12888 + *[0-9a-f]*:	ff ff 01 ff     ld.weq  pc,pc[0x7fc]

 12889 + *[0-9a-f]*:	f9 fc f3 ff     ld.shal r12,r12[0x3fe]

 12890 + *[0-9a-f]*:	eb f5 84 00     ld.shls r5,r5[0x0]

 12891 + *[0-9a-f]*:	e9 f4 79 ff     ld.ubpl r4,r4[0x1ff]

 12892 + *[0-9a-f]*:	fd fe 16 00     ld.sbne lr,lr[0x0]

 12893 + *[0-9a-f]*:	e5 fa 80 00     ld.wls  r10,r2[0x0]

 12894 + *[0-9a-f]*:	f1 fc d3 ff     ld.shvc r12,r8[0x3fe]

 12895 + *[0-9a-f]*:	ef fa 68 01     ld.ubmi r10,r7[0x1]

 12896 +

 12897 +[0-9a-f]* <stcond2>:

 12898 + *[0-9a-f]*:	ff ff 0b ff     st.weq pc[0x7fc],pc

 12899 + *[0-9a-f]*:	f9 fc fd ff     st.hal r12[0x3fe],r12

 12900 + *[0-9a-f]*:	eb f5 8c 00     st.hls r5[0x0],r5

 12901 + *[0-9a-f]*:	e9 f4 7f ff     st.bpl r4[0x1ff],r4

 12902 + *[0-9a-f]*:	fd fe 1e 00     st.bne lr[0x0],lr

 12903 + *[0-9a-f]*:	e5 fa 8a 00     st.wls r2[0x0],r10

 12904 + *[0-9a-f]*:	f1 fc dd ff     st.hvc r8[0x3fe],r12

 12905 + *[0-9a-f]*:	ef fa 6e 01     st.bmi r7[0x1],r10

 12906 +

 12907 +[0-9a-f]* <movh>:

 12908 + *[0-9a-f]*:	fc 1f ff ff     movh pc,0xffff

 12909 + *[0-9a-f]*:	fc 10 00 00     movh r0,0x0

 12910 + *[0-9a-f]*:	fc 15 00 01     movh r5,0x1

 12911 + *[0-9a-f]*:	fc 1c 7f ff     movh r12,0x7fff

 12912 +

 12913 --- /dev/null

 12914 +++ b/gas/testsuite/gas/avr32/allinsn.exp

 12915 @@ -0,0 +1,5 @@

 12916 +# AVR32 assembler testsuite. -*- Tcl -*-

 12917 +

 12918 +if [istarget avr32-*-*] {

 12919 +    run_dump_test "allinsn"

 12920 +}

 12921 --- /dev/null

 12922 +++ b/gas/testsuite/gas/avr32/allinsn.s

 12923 @@ -0,0 +1,3330 @@

 12924 + .data

 12925 +foodata: .word 42

 12926 + .text

 12927 +footext:

 12928 +	.text

 12929 +	.global ld_d5

 12930 +ld_d5:

 12931 +	ld.d lr,pc[pc<<3]

 12932 +	ld.d r0,r0[r0<<0]

 12933 +	ld.d r6,r5[r5<<2]

 12934 +	ld.d r4,r4[r4<<1]

 12935 +	ld.d lr,lr[lr<<1]

 12936 +	ld.d r10,r3[sp<<2]

 12937 +	ld.d r8,r10[r6<<2]

 12938 +	ld.d r2,r7[r9<<0]

 12939 +	.text

 12940 +	.global ld_w5

 12941 +ld_w5:

 12942 +	ld.w pc,pc[pc<<0]

 12943 +	ld.w r12,r12[r12<<3]

 12944 +	ld.w r5,r5[r5<<2]

 12945 +	ld.w r4,r4[r4<<1]

 12946 +	ld.w lr,lr[lr<<1]

 12947 +	ld.w r2,r9[r9<<0]

 12948 +	ld.w r11,r2[r6<<0]

 12949 +	ld.w r0,r2[sp<<3]

 12950 +	.text

 12951 +	.global ld_sh5

 12952 +ld_sh5:

 12953 +	ld.sh pc,pc[pc<<0]

 12954 +	ld.sh r12,r12[r12<<3]

 12955 +	ld.sh r5,r5[r5<<2]

 12956 +	ld.sh r4,r4[r4<<1]

 12957 +	ld.sh lr,lr[lr<<1]

 12958 +	ld.sh r11,r0[pc<<2]

 12959 +	ld.sh r10,sp[r6<<2]

 12960 +	ld.sh r12,r2[r2<<0]

 12961 +	.text

 12962 +	.global ld_uh5

 12963 +ld_uh5:

 12964 +	ld.uh pc,pc[pc<<0]

 12965 +	ld.uh r12,r12[r12<<3]

 12966 +	ld.uh r5,r5[r5<<2]

 12967 +	ld.uh r4,r4[r4<<1]

 12968 +	ld.uh lr,lr[lr<<1]

 12969 +	ld.uh r8,pc[lr<<3]

 12970 +	ld.uh r6,r1[pc<<1]

 12971 +	ld.uh r6,lr[sp<<1]

 12972 +	.text

 12973 +	.global ld_sb2

 12974 +ld_sb2:

 12975 +	ld.sb pc,pc[pc<<0]

 12976 +	ld.sb r12,r12[r12<<3]

 12977 +	ld.sb r5,r5[r5<<2]

 12978 +	ld.sb r4,r4[r4<<1]

 12979 +	ld.sb lr,lr[lr<<1]

 12980 +	ld.sb r9,r1[pc<<3]

 12981 +	ld.sb r0,r3[r11<<1]

 12982 +	ld.sb r10,r5[r5<<1]

 12983 +	.text

 12984 +	.global ld_ub5

 12985 +ld_ub5:

 12986 +	ld.ub pc,pc[pc<<0]

 12987 +	ld.ub r12,r12[r12<<3]

 12988 +	ld.ub r5,r5[r5<<2]

 12989 +	ld.ub r4,r4[r4<<1]

 12990 +	ld.ub lr,lr[lr<<1]

 12991 +	ld.ub r6,r12[r7<<3]

 12992 +	ld.ub r2,r6[r12<<0]

 12993 +	ld.ub r0,r7[r11<<1]

 12994 +	.text

 12995 +	.global st_d5

 12996 +st_d5:

 12997 +	st.d pc[pc<<0],r14

 12998 +	st.d r12[r12<<3],r12

 12999 +	st.d r5[r5<<2],r6

 13000 +	st.d r4[r4<<1],r4

 13001 +	st.d lr[lr<<1],lr

 13002 +	st.d r1[r9<<1],r4

 13003 +	st.d r10[r2<<1],r4

 13004 +	st.d r12[r6<<0],lr

 13005 +	.text

 13006 +	.global st_w5

 13007 +st_w5:

 13008 +	st.w pc[pc<<0],pc

 13009 +	st.w r12[r12<<3],r12

 13010 +	st.w r5[r5<<2],r5

 13011 +	st.w r4[r4<<1],r4

 13012 +	st.w lr[lr<<1],lr

 13013 +	st.w r1[r10<<0],r3

 13014 +	st.w r0[r10<<1],r9

 13015 +	st.w r4[r5<<3],pc

 13016 +	.text

 13017 +	.global st_h5

 13018 +st_h5:

 13019 +	st.h pc[pc<<0],pc

 13020 +	st.h r12[r12<<3],r12

 13021 +	st.h r5[r5<<2],r5

 13022 +	st.h r4[r4<<1],r4

 13023 +	st.h lr[lr<<1],lr

 13024 +	st.h r2[r9<<0],r11

 13025 +	st.h r5[r1<<2],r12

 13026 +	st.h pc[r8<<2],r3

 13027 +	.text

 13028 +	.global st_b5

 13029 +st_b5:

 13030 +	st.b pc[pc<<0],pc

 13031 +	st.b r12[r12<<3],r12

 13032 +	st.b r5[r5<<2],r5

 13033 +	st.b r4[r4<<1],r4

 13034 +	st.b lr[lr<<1],lr

 13035 +	st.b r1[r8<<1],r6

 13036 +	st.b lr[lr<<3],r1

 13037 +	st.b r5[r0<<2],pc

 13038 +	.text

 13039 +	.global divs

 13040 +divs:

 13041 +	divs pc,pc,pc

 13042 +	divs r12,r12,r12

 13043 +	divs r5,r5,r5

 13044 +	divs r4,r4,r4

 13045 +	divs lr,lr,lr

 13046 +	divs r3,pc,pc

 13047 +	divs r9,r12,r2

 13048 +	divs r7,r4,r1

 13049 +	.text

 13050 +	.global add1

 13051 +add1:

 13052 +	add pc,pc

 13053 +	add r12,r12

 13054 +	add r5,r5

 13055 +	add r4,r4

 13056 +	add lr,lr

 13057 +	add r12,r9

 13058 +	add r6,r3

 13059 +	add r10,r12

 13060 +	.text

 13061 +	.global sub1

 13062 +sub1:

 13063 +	sub pc,pc

 13064 +	sub r12,r12

 13065 +	sub r5,r5

 13066 +	sub r4,r4

 13067 +	sub lr,lr

 13068 +	sub lr,r6

 13069 +	sub r0,sp

 13070 +	sub r6,r12

 13071 +	.text

 13072 +	.global rsub1

 13073 +rsub1:

 13074 +	rsub pc,pc

 13075 +	rsub r12,r12

 13076 +	rsub r5,r5

 13077 +	rsub r4,r4

 13078 +	rsub lr,lr

 13079 +	rsub r11,sp

 13080 +	rsub r7,r4

 13081 +	rsub r9,r1

 13082 +	.text

 13083 +	.global cp1

 13084 +cp1:

 13085 +	cp pc,pc

 13086 +	cp r12,r12

 13087 +	cp r5,r5

 13088 +	cp r4,r4

 13089 +	cp lr,lr

 13090 +	cp r6,r2

 13091 +	cp r0,r9

 13092 +	cp r3,sp

 13093 +	.text

 13094 +	.global or1

 13095 +or1:

 13096 +	or pc,pc

 13097 +	or r12,r12

 13098 +	or r5,r5

 13099 +	or r4,r4

 13100 +	or lr,lr

 13101 +	or r4,r9

 13102 +	or r11,r4

 13103 +	or r4,r0

 13104 +	.text

 13105 +	.global eor1

 13106 +eor1:

 13107 +	eor pc,pc

 13108 +	eor r12,r12

 13109 +	eor r5,r5

 13110 +	eor r4,r4

 13111 +	eor lr,lr

 13112 +	eor r12,r11

 13113 +	eor r0,r1

 13114 +	eor r5,pc

 13115 +	.text

 13116 +	.global and1

 13117 +and1:

 13118 +	and pc,pc

 13119 +	and r12,r12

 13120 +	and r5,r5

 13121 +	and r4,r4

 13122 +	and lr,lr

 13123 +	and r8,r1

 13124 +	and r0,sp

 13125 +	and r10,r5

 13126 +	.text

 13127 +	.global tst

 13128 +tst:

 13129 +	tst pc,pc

 13130 +	tst r12,r12

 13131 +	tst r5,r5

 13132 +	tst r4,r4

 13133 +	tst lr,lr

 13134 +	tst r0,r12

 13135 +	tst r10,r6

 13136 +	tst sp,r4

 13137 +	.text

 13138 +	.global andn

 13139 +andn:

 13140 +	andn pc,pc

 13141 +	andn r12,r12

 13142 +	andn r5,r5

 13143 +	andn r4,r4

 13144 +	andn lr,lr

 13145 +	andn r9,r12

 13146 +	andn r11,sp

 13147 +	andn r12,r5

 13148 +	.text

 13149 +	.global mov3

 13150 +mov3:

 13151 +	mov pc,pc

 13152 +	mov r12,r12

 13153 +	mov r5,r5

 13154 +	mov r4,r4

 13155 +	mov lr,lr

 13156 +	mov r5,r9

 13157 +	mov r11,r11

 13158 +	mov r2,lr

 13159 +	.text

 13160 +	.global st_w1

 13161 +st_w1:

 13162 +	st.w pc++,pc

 13163 +	st.w r12++,r12

 13164 +	st.w r5++,r5

 13165 +	st.w r4++,r4

 13166 +	st.w lr++,lr

 13167 +	st.w r1++,r11

 13168 +	st.w sp++,r0

 13169 +	st.w sp++,r1

 13170 +	.text

 13171 +	.global st_h1

 13172 +st_h1:

 13173 +	st.h pc++,pc

 13174 +	st.h r12++,r12

 13175 +	st.h r5++,r5

 13176 +	st.h r4++,r4

 13177 +	st.h lr++,lr

 13178 +	st.h r12++,sp

 13179 +	st.h r7++,lr

 13180 +	st.h r7++,r4

 13181 +	.text

 13182 +	.global st_b1

 13183 +st_b1:

 13184 +	st.b pc++,pc

 13185 +	st.b r12++,r12

 13186 +	st.b r5++,r5

 13187 +	st.b r4++,r4

 13188 +	st.b lr++,lr

 13189 +	st.b r9++,sp

 13190 +	st.b r1++,sp

 13191 +	st.b r0++,r4

 13192 +	.text

 13193 +	.global st_w2

 13194 +st_w2:

 13195 +	st.w --pc,pc

 13196 +	st.w --r12,r12

 13197 +	st.w --r5,r5

 13198 +	st.w --r4,r4

 13199 +	st.w --lr,lr

 13200 +	st.w --r1,r7

 13201 +	st.w --r3,r9

 13202 +	st.w --r5,r5

 13203 +	.text

 13204 +	.global st_h2

 13205 +st_h2:

 13206 +	st.h --pc,pc

 13207 +	st.h --r12,r12

 13208 +	st.h --r5,r5

 13209 +	st.h --r4,r4

 13210 +	st.h --lr,lr

 13211 +	st.h --r5,r7

 13212 +	st.h --r8,r8

 13213 +	st.h --r7,r2

 13214 +	.text

 13215 +	.global st_b2

 13216 +st_b2:

 13217 +	st.b --pc,pc

 13218 +	st.b --r12,r12

 13219 +	st.b --r5,r5

 13220 +	st.b --r4,r4

 13221 +	st.b --lr,lr

 13222 +	st.b --sp,sp

 13223 +	st.b --sp,r11

 13224 +	st.b --r4,r5

 13225 +	.text

 13226 +	.global ld_w1

 13227 +ld_w1:

 13228 +	ld.w pc,pc++

 13229 +	ld.w r12,r12++

 13230 +	ld.w r5,r5++

 13231 +	ld.w r4,r4++

 13232 +	ld.w lr,lr++

 13233 +	ld.w r3,r7++

 13234 +	ld.w r3,lr++

 13235 +	ld.w r12,r5++

 13236 +	.text

 13237 +	.global ld_sh1

 13238 +ld_sh1:

 13239 +	ld.sh pc,pc++

 13240 +	ld.sh r12,r12++

 13241 +	ld.sh r5,r5++

 13242 +	ld.sh r4,r4++

 13243 +	ld.sh lr,lr++

 13244 +	ld.sh r11,r2++

 13245 +	ld.sh r2,r8++

 13246 +	ld.sh r7,r6++

 13247 +	.text

 13248 +	.global ld_uh1

 13249 +ld_uh1:

 13250 +	ld.uh pc,pc++

 13251 +	ld.uh r12,r12++

 13252 +	ld.uh r5,r5++

 13253 +	ld.uh r4,r4++

 13254 +	ld.uh lr,lr++

 13255 +	ld.uh r6,r7++

 13256 +	ld.uh r10,r11++

 13257 +	ld.uh lr,r4++

 13258 +	.text

 13259 +	.global ld_ub1

 13260 +ld_ub1:

 13261 +	ld.ub pc,pc++

 13262 +	ld.ub r12,r12++

 13263 +	ld.ub r5,r5++

 13264 +	ld.ub r4,r4++

 13265 +	ld.ub lr,lr++

 13266 +	ld.ub r8,lr++

 13267 +	ld.ub r12,r12++

 13268 +	ld.ub r11,r10++

 13269 +	.text

 13270 +	.global ld_w2

 13271 +ld_w2:

 13272 +	ld.w pc,--pc

 13273 +	ld.w r12,--r12

 13274 +	ld.w r5,--r5

 13275 +	ld.w r4,--r4

 13276 +	ld.w lr,--lr

 13277 +	ld.w r10,--lr

 13278 +	ld.w r12,--r9

 13279 +	ld.w r6,--r5

 13280 +	.text

 13281 +	.global ld_sh2

 13282 +ld_sh2:

 13283 +	ld.sh pc,--pc

 13284 +	ld.sh r12,--r12

 13285 +	ld.sh r5,--r5

 13286 +	ld.sh r4,--r4

 13287 +	ld.sh lr,--lr

 13288 +	ld.sh pc,--r10

 13289 +	ld.sh r6,--r3

 13290 +	ld.sh r4,--r6

 13291 +	.text

 13292 +	.global ld_uh2

 13293 +ld_uh2:

 13294 +	ld.uh pc,--pc

 13295 +	ld.uh r12,--r12

 13296 +	ld.uh r5,--r5

 13297 +	ld.uh r4,--r4

 13298 +	ld.uh lr,--lr

 13299 +	ld.uh r3,--r2

 13300 +	ld.uh r1,--r0

 13301 +	ld.uh r2,--r9

 13302 +	.text

 13303 +	.global ld_ub2

 13304 +ld_ub2:

 13305 +	ld.ub pc,--pc

 13306 +	ld.ub r12,--r12

 13307 +	ld.ub r5,--r5

 13308 +	ld.ub r4,--r4

 13309 +	ld.ub lr,--lr

 13310 +	ld.ub r1,--r1

 13311 +	ld.ub r0,--r6

 13312 +	ld.ub r2,--r7

 13313 +	.text

 13314 +	.global ld_ub3

 13315 +ld_ub3:

 13316 +	ld.ub pc,pc[0]

 13317 +	ld.ub r12,r12[7]

 13318 +	ld.ub r5,r5[4]

 13319 +	ld.ub r4,r4[3]

 13320 +	ld.ub lr,lr[1]

 13321 +	ld.ub r6,r9[6]

 13322 +	ld.ub r2,lr[4]

 13323 +	ld.ub r1,r8[0]

 13324 +	.text

 13325 +	.global sub3_sp

 13326 +sub3_sp:

 13327 +	sub sp,0

 13328 +	sub sp,-4

 13329 +	sub sp,-512

 13330 +	sub sp,508

 13331 +	sub sp,4

 13332 +	sub sp,44

 13333 +	sub sp,8

 13334 +	sub sp,348

 13335 +	.text

 13336 +	.global sub3

 13337 +sub3:

 13338 +	sub pc,0

 13339 +	sub r12,-1

 13340 +	sub r5,-128

 13341 +	sub r4,127

 13342 +	sub lr,1

 13343 +	sub r6,-41

 13344 +	sub r4,37

 13345 +	sub r12,56

 13346 +	.text

 13347 +	.global mov1

 13348 +mov1:

 13349 +	mov pc,0

 13350 +	mov r12,-1

 13351 +	mov r5,-128

 13352 +	mov r4,127

 13353 +	mov lr,1

 13354 +	mov pc,14

 13355 +	mov r6,-100

 13356 +	mov lr,-122

 13357 +	.text

 13358 +	.global lddsp

 13359 +lddsp:

 13360 +	lddsp pc,sp[0]

 13361 +	lddsp r12,sp[508]

 13362 +	lddsp r5,sp[256]

 13363 +	lddsp r4,sp[252]

 13364 +	lddsp lr,sp[4]

 13365 +	lddsp lr,sp[256]

 13366 +	lddsp r12,sp[20]

 13367 +	lddsp r9,sp[472]

 13368 +	.text

 13369 +	.global lddpc

 13370 +lddpc:

 13371 +	lddpc pc,pc[0]

 13372 +	lddpc r0,pc[508]

 13373 +	lddpc r8,pc[256]

 13374 +	lddpc r7,pc[252]

 13375 +	lddpc lr,pc[4]

 13376 +	lddpc sp,pc[472]

 13377 +	lddpc r6,pc[120]

 13378 +	lddpc r11,pc[28]

 13379 +	.text

 13380 +	.global stdsp

 13381 +stdsp:

 13382 +	stdsp sp[0],pc

 13383 +	stdsp sp[508],r12

 13384 +	stdsp sp[256],r5

 13385 +	stdsp sp[252],r4

 13386 +	stdsp sp[4],lr

 13387 +	stdsp sp[304],pc

 13388 +	stdsp sp[256],r0

 13389 +	stdsp sp[336],r5

 13390 +	.text

 13391 +	.global cp2

 13392 +cp2:

 13393 +	cp pc,0

 13394 +	cp r12,-1

 13395 +	cp r5,-32

 13396 +	cp r4,31

 13397 +	cp lr,1

 13398 +	cp r8,3

 13399 +	cp lr,16

 13400 +	cp r7,-26

 13401 +	.text

 13402 +	.global acr

 13403 +acr:

 13404 +	acr pc

 13405 +	acr r12

 13406 +	acr r5

 13407 +	acr r4

 13408 +	acr lr

 13409 +	acr r2

 13410 +	acr r12

 13411 +	acr pc

 13412 +	.text

 13413 +	.global scr

 13414 +scr:

 13415 +	scr pc

 13416 +	scr r12

 13417 +	scr r5

 13418 +	scr r4

 13419 +	scr lr

 13420 +	scr pc

 13421 +	scr r6

 13422 +	scr r1

 13423 +	.text

 13424 +	.global cpc0

 13425 +cpc0:

 13426 +	cpc pc

 13427 +	cpc r12

 13428 +	cpc r5

 13429 +	cpc r4

 13430 +	cpc lr

 13431 +	cpc pc

 13432 +	cpc r4

 13433 +	cpc r9

 13434 +	.text

 13435 +	.global neg

 13436 +neg:

 13437 +	neg pc

 13438 +	neg r12

 13439 +	neg r5

 13440 +	neg r4

 13441 +	neg lr

 13442 +	neg r7

 13443 +	neg r1

 13444 +	neg r9

 13445 +	.text

 13446 +	.global abs

 13447 +abs:

 13448 +	abs pc

 13449 +	abs r12

 13450 +	abs r5

 13451 +	abs r4

 13452 +	abs lr

 13453 +	abs r6

 13454 +	abs r6

 13455 +	abs r4

 13456 +	.text

 13457 +	.global castu_b

 13458 +castu_b:

 13459 +	castu.b pc

 13460 +	castu.b r12

 13461 +	castu.b r5

 13462 +	castu.b r4

 13463 +	castu.b lr

 13464 +	castu.b r7

 13465 +	castu.b sp

 13466 +	castu.b r9

 13467 +	.text

 13468 +	.global casts_b

 13469 +casts_b:

 13470 +	casts.b pc

 13471 +	casts.b r12

 13472 +	casts.b r5

 13473 +	casts.b r4

 13474 +	casts.b lr

 13475 +	casts.b r11

 13476 +	casts.b r1

 13477 +	casts.b r10

 13478 +	.text

 13479 +	.global castu_h

 13480 +castu_h:

 13481 +	castu.h pc

 13482 +	castu.h r12

 13483 +	castu.h r5

 13484 +	castu.h r4

 13485 +	castu.h lr

 13486 +	castu.h r10

 13487 +	castu.h r11

 13488 +	castu.h r1

 13489 +	.text

 13490 +	.global casts_h

 13491 +casts_h:

 13492 +	casts.h pc

 13493 +	casts.h r12

 13494 +	casts.h r5

 13495 +	casts.h r4

 13496 +	casts.h lr

 13497 +	casts.h r0

 13498 +	casts.h r5

 13499 +	casts.h r9

 13500 +	.text

 13501 +	.global brev

 13502 +brev:

 13503 +	brev pc

 13504 +	brev r12

 13505 +	brev r5

 13506 +	brev r4

 13507 +	brev lr

 13508 +	brev r5

 13509 +	brev r10

 13510 +	brev r8

 13511 +	.text

 13512 +	.global swap_h

 13513 +swap_h:

 13514 +	swap.h pc

 13515 +	swap.h r12

 13516 +	swap.h r5

 13517 +	swap.h r4

 13518 +	swap.h lr

 13519 +	swap.h r7

 13520 +	swap.h r0

 13521 +	swap.h r8

 13522 +	.text

 13523 +	.global swap_b

 13524 +swap_b:

 13525 +	swap.b pc

 13526 +	swap.b r12

 13527 +	swap.b r5

 13528 +	swap.b r4

 13529 +	swap.b lr

 13530 +	swap.b r10

 13531 +	swap.b r12

 13532 +	swap.b r1

 13533 +	.text

 13534 +	.global swap_bh

 13535 +swap_bh:

 13536 +	swap.bh pc

 13537 +	swap.bh r12

 13538 +	swap.bh r5

 13539 +	swap.bh r4

 13540 +	swap.bh lr

 13541 +	swap.bh r9

 13542 +	swap.bh r4

 13543 +	swap.bh r1

 13544 +	.text

 13545 +	.global One_s_compliment

 13546 +One_s_compliment:

 13547 +	com pc

 13548 +	com r12

 13549 +	com r5

 13550 +	com r4

 13551 +	com lr

 13552 +	com r2

 13553 +	com r2

 13554 +	com r7

 13555 +	.text

 13556 +	.global tnbz

 13557 +tnbz:

 13558 +	tnbz pc

 13559 +	tnbz r12

 13560 +	tnbz r5

 13561 +	tnbz r4

 13562 +	tnbz lr

 13563 +	tnbz r8

 13564 +	tnbz r12

 13565 +	tnbz pc

 13566 +	.text

 13567 +	.global rol

 13568 +rol:

 13569 +	rol pc

 13570 +	rol r12

 13571 +	rol r5

 13572 +	rol r4

 13573 +	rol lr

 13574 +	rol r10

 13575 +	rol r9

 13576 +	rol r5

 13577 +	.text

 13578 +	.global ror

 13579 +ror:

 13580 +	ror pc

 13581 +	ror r12

 13582 +	ror r5

 13583 +	ror r4

 13584 +	ror lr

 13585 +	ror r8

 13586 +	ror r4

 13587 +	ror r7

 13588 +	.text

 13589 +	.global icall

 13590 +icall:

 13591 +	icall pc

 13592 +	icall r12

 13593 +	icall r5

 13594 +	icall r4

 13595 +	icall lr

 13596 +	icall r3

 13597 +	icall r1

 13598 +	icall r3

 13599 +	.text

 13600 +	.global mustr

 13601 +mustr:

 13602 +	mustr pc

 13603 +	mustr r12

 13604 +	mustr r5

 13605 +	mustr r4

 13606 +	mustr lr

 13607 +	mustr r1

 13608 +	mustr r4

 13609 +	mustr r12

 13610 +	.text

 13611 +	.global musfr

 13612 +musfr:

 13613 +	musfr pc

 13614 +	musfr r12

 13615 +	musfr r5

 13616 +	musfr r4

 13617 +	musfr lr

 13618 +	musfr r11

 13619 +	musfr r12

 13620 +	musfr r2

 13621 +	.text

 13622 +	.global ret_cond

 13623 +ret_cond:

 13624 +	reteq pc

 13625 +	retal r12

 13626 +	retls r5

 13627 +	retpl r4

 13628 +	retne lr

 13629 +	retgt r0

 13630 +	retgt r12

 13631 +	retge r10

 13632 +	.text

 13633 +	.global sr_cond

 13634 +sr_cond:

 13635 +	sreq pc

 13636 +	sral r12

 13637 +	srls r5

 13638 +	srpl r4

 13639 +	srne lr

 13640 +	srlt r0

 13641 +	sral sp

 13642 +	srge r9

 13643 +	.text

 13644 +	.global ld_w3

 13645 +ld_w3:

 13646 +	ld.w pc,pc[0]

 13647 +	ld.w r12,r12[124]

 13648 +	ld.w r5,r5[64]

 13649 +	ld.w r4,r4[60]

 13650 +	ld.w lr,lr[4]

 13651 +	ld.w sp,r2[52]

 13652 +	ld.w r9,r1[8]

 13653 +	ld.w r5,sp[60]

 13654 +	.text

 13655 +	.global ld_sh3

 13656 +ld_sh3:

 13657 +	ld.sh pc,pc[0]

 13658 +	ld.sh r12,r12[14]

 13659 +	ld.sh r5,r5[8]

 13660 +	ld.sh r4,r4[6]

 13661 +	ld.sh lr,lr[2]

 13662 +	ld.sh r4,r2[8]

 13663 +	ld.sh sp,lr[10]

 13664 +	ld.sh r2,r11[2]

 13665 +	.text

 13666 +	.global ld_uh3

 13667 +ld_uh3:

 13668 +	ld.uh pc,pc[0]

 13669 +	ld.uh r12,r12[14]

 13670 +	ld.uh r5,r5[8]

 13671 +	ld.uh r4,r4[6]

 13672 +	ld.uh lr,lr[2]

 13673 +	ld.uh r10,r0[10]

 13674 +	ld.uh r8,r11[8]

 13675 +	ld.uh r10,r2[12]

 13676 +	.text

 13677 +	.global st_w3

 13678 +st_w3:

 13679 +	st.w pc[0],pc

 13680 +	st.w r12[60],r12

 13681 +	st.w r5[32],r5

 13682 +	st.w r4[28],r4

 13683 +	st.w lr[4],lr

 13684 +	st.w r7[44],r11

 13685 +	st.w r2[24],r6

 13686 +	st.w r4[12],r9

 13687 +	.text

 13688 +	.global st_h3

 13689 +st_h3:

 13690 +	st.h pc[0],pc

 13691 +	st.h r12[14],r12

 13692 +	st.h r5[8],r5

 13693 +	st.h r4[6],r4

 13694 +	st.h lr[2],lr

 13695 +	st.h lr[10],r12

 13696 +	st.h r6[4],r0

 13697 +	st.h r5[12],sp

 13698 +	.text

 13699 +	.global st_b3

 13700 +st_b3:

 13701 +	st.b pc[0],pc

 13702 +	st.b r12[7],r12

 13703 +	st.b r5[4],r5

 13704 +	st.b r4[3],r4

 13705 +	st.b lr[1],lr

 13706 +	st.b r12[6],r9

 13707 +	st.b r2[3],lr

 13708 +	st.b r1[3],r11

 13709 +	.text

 13710 +	.global ldd

 13711 +ldd:

 13712 +	ld.d r0,pc

 13713 +	ld.d r14,r12

 13714 +	ld.d r8,r5

 13715 +	ld.d r6,r4

 13716 +	ld.d r2,lr

 13717 +	ld.d r14,r7

 13718 +	ld.d r4,r4

 13719 +	ld.d r14,pc

 13720 +	.text

 13721 +	.global ldd_postinc

 13722 +ldd_postinc:

 13723 +	ld.d r0,pc++

 13724 +	ld.d r14,r12++

 13725 +	ld.d r8,r5++

 13726 +	ld.d r6,r4++

 13727 +	ld.d r2,lr++

 13728 +	ld.d r14,r5++

 13729 +	ld.d r12,r11++

 13730 +	ld.d r2,r12++

 13731 +	.text

 13732 +	.global ldd_predec

 13733 +ldd_predec:

 13734 +	ld.d r0,--pc

 13735 +	ld.d r14,--r12

 13736 +	ld.d r8,--r5

 13737 +	ld.d r6,--r4

 13738 +	ld.d r2,--lr

 13739 +	ld.d r8,--r0

 13740 +	ld.d r10,--pc

 13741 +	ld.d r2,--r4

 13742 +	.text

 13743 +	.global std

 13744 +std:

 13745 +	st.d pc,r0

 13746 +	st.d r12,r14

 13747 +	st.d r5,r8

 13748 +	st.d r4,r6

 13749 +	st.d lr,r2

 13750 +	st.d r0,r12

 13751 +	st.d sp,r4

 13752 +	st.d r12,r12

 13753 +	.text

 13754 +	.global std_postinc

 13755 +std_postinc:

 13756 +	st.d pc++,r0

 13757 +	st.d r12++,r14

 13758 +	st.d r5++,r8

 13759 +	st.d r4++,r6

 13760 +	st.d lr++,r2

 13761 +	st.d sp++,r6

 13762 +	st.d r10++,r6

 13763 +	st.d r7++,r2

 13764 +	.text

 13765 +	.global std_predec

 13766 +std_predec:

 13767 +	st.d --pc,r0

 13768 +	st.d --r12,r14

 13769 +	st.d --r5,r8

 13770 +	st.d --r4,r6

 13771 +	st.d --lr,r2

 13772 +	st.d --r3,r6

 13773 +	st.d --lr,r2

 13774 +	st.d --r0,r4

 13775 +	.text

 13776 +	.global mul

 13777 +mul:

 13778 +	mul pc,pc

 13779 +	mul r12,r12

 13780 +	mul r5,r5

 13781 +	mul r4,r4

 13782 +	mul lr,lr

 13783 +	mul r10,lr

 13784 +	mul r0,r8

 13785 +	mul r8,r5

 13786 +	.text

 13787 +	.global asr_imm5

 13788 +asr_imm5:

 13789 +	asr pc,0

 13790 +	asr r12,31

 13791 +	asr r5,16

 13792 +	asr r4,15

 13793 +	asr lr,1

 13794 +	asr r6,23

 13795 +	asr r6,18

 13796 +	asr r5,8

 13797 +	.text

 13798 +	.global lsl_imm5

 13799 +lsl_imm5:

 13800 +	lsl pc,0

 13801 +	lsl r12,31

 13802 +	lsl r5,16

 13803 +	lsl r4,15

 13804 +	lsl lr,1

 13805 +	lsl r12,13

 13806 +	lsl r6,16

 13807 +	lsl r1,25

 13808 +	.text

 13809 +	.global lsr_imm5

 13810 +lsr_imm5:

 13811 +	lsr pc,0

 13812 +	lsr r12,31

 13813 +	lsr r5,16

 13814 +	lsr r4,15

 13815 +	lsr lr,1

 13816 +	lsr r0,1

 13817 +	lsr r8,10

 13818 +	lsr r7,26

 13819 +	.text

 13820 +	.global sbr

 13821 +sbr:

 13822 +	sbr pc,0

 13823 +	sbr r12,31

 13824 +	sbr r5,16

 13825 +	sbr r4,15

 13826 +	sbr lr,1

 13827 +	sbr r8,31

 13828 +	sbr r6,22

 13829 +	sbr r1,23

 13830 +	.text

 13831 +	.global cbr

 13832 +cbr:

 13833 +	cbr pc,0

 13834 +	cbr r12,31

 13835 +	cbr r5,16

 13836 +	cbr r4,15

 13837 +	cbr lr,1

 13838 +	cbr r12,10

 13839 +	cbr r7,22

 13840 +	cbr r8,9

 13841 +	.text

 13842 +	.global brc1

 13843 +brc1:

 13844 +	breq 0

 13845 +	brpl -2

 13846 +	brge -256

 13847 +	brcs 254

 13848 +	brne 2

 13849 +	brcs 230

 13850 +	breq -18

 13851 +	breq 12

 13852 +	.text

 13853 +	.global rjmp

 13854 +rjmp:

 13855 +	rjmp 0

 13856 +	rjmp -2

 13857 +	rjmp -1024

 13858 +	rjmp 1022

 13859 +	rjmp 2

 13860 +	rjmp -962

 13861 +	rjmp 14

 13862 +	rjmp -516

 13863 +	.text

 13864 +	.global rcall1

 13865 +rcall1:

 13866 +	rcall 0

 13867 +	rcall -2

 13868 +	rcall -1024

 13869 +	rcall 1022

 13870 +	rcall 2

 13871 +	rcall 216

 13872 +	rcall -530

 13873 +	rcall -972

 13874 +	.text

 13875 +	.global acall

 13876 +acall:

 13877 +	acall 0

 13878 +	acall 1020

 13879 +	acall 512

 13880 +	acall 508

 13881 +	acall 4

 13882 +	acall 356

 13883 +	acall 304

 13884 +	acall 172

 13885 +	.text

 13886 +	.global scall

 13887 +scall:

 13888 +	scall

 13889 +	scall

 13890 +	scall

 13891 +	scall

 13892 +	scall

 13893 +	scall

 13894 +	scall

 13895 +	scall

 13896 +	.text

 13897 +	.global popm

 13898 +popm:

 13899 +	/* popm with no argument fails currently */

 13900 +	popm pc

 13901 +	popm r0-r11,pc,r12=-1

 13902 +	popm lr

 13903 +	popm r0-r11,pc,r12=1

 13904 +	popm r0-r3

 13905 +	popm r4-r10,pc

 13906 +	popm r0-r3,r11,pc,r12=0

 13907 +	popm r0-r7,r10-r12,lr

 13908 +	.text

 13909 +	.global pushm

 13910 +pushm:

 13911 +	pushm pc

 13912 +	pushm r0-r12,lr,pc

 13913 +	pushm pc

 13914 +	pushm r0-r12,lr

 13915 +	pushm r0-r3

 13916 +	pushm r8-r10,lr,pc

 13917 +	pushm r0-r3,r10

 13918 +	pushm r8-r9,r12

 13919 +	.text

 13920 +	.global popm_n

 13921 +popm_n:

 13922 +	popm pc

 13923 +	popm r0-r11,pc,r12=-1

 13924 +	popm lr

 13925 +	popm r0-r11,pc,r12=1

 13926 +	popm r0-r3

 13927 +	popm r4-r10,pc

 13928 +	popm r0-r3,r11,pc,r12=0

 13929 +	popm r0-r7,r10-r12,lr

 13930 +	.text

 13931 +	.global pushm_n

 13932 +pushm_n:

 13933 +	pushm pc

 13934 +	pushm r0-r12,lr,pc

 13935 +	pushm pc

 13936 +	pushm r0-r12,lr

 13937 +	pushm r0-r3

 13938 +	pushm r8-r10,lr,pc

 13939 +	pushm r0-r3,r10

 13940 +	pushm r8-r9,r12

 13941 +	.text

 13942 +	.global csrfcz

 13943 +csrfcz:

 13944 +	csrfcz 0

 13945 +	csrfcz 31

 13946 +	csrfcz 16

 13947 +	csrfcz 15

 13948 +	csrfcz 1

 13949 +	csrfcz 5

 13950 +	csrfcz 13

 13951 +	csrfcz 23

 13952 +	.text

 13953 +	.global ssrf

 13954 +ssrf:

 13955 +	ssrf 0

 13956 +	ssrf 31

 13957 +	ssrf 16

 13958 +	ssrf 15

 13959 +	ssrf 1

 13960 +	ssrf 29

 13961 +	ssrf 13

 13962 +	ssrf 13

 13963 +	.text

 13964 +	.global csrf

 13965 +csrf:

 13966 +	csrf 0

 13967 +	csrf 31

 13968 +	csrf 16

 13969 +	csrf 15

 13970 +	csrf 1

 13971 +	csrf 10

 13972 +	csrf 15

 13973 +	csrf 11

 13974 +	.text

 13975 +	.global rete

 13976 +rete:

 13977 +	rete

 13978 +	.text

 13979 +	.global rets

 13980 +rets:

 13981 +	rets

 13982 +	.text

 13983 +	.global retd

 13984 +retd:

 13985 +	retd

 13986 +	.text

 13987 +	.global retj

 13988 +retj:

 13989 +	retj

 13990 +	.text

 13991 +	.global tlbr

 13992 +tlbr:

 13993 +	tlbr

 13994 +	.text

 13995 +	.global tlbs

 13996 +tlbs:

 13997 +	tlbs

 13998 +	.text

 13999 +	.global tlbw

 14000 +tlbw:

 14001 +	tlbw

 14002 +	.text

 14003 +	.global breakpoint

 14004 +breakpoint:

 14005 +	breakpoint

 14006 +	.text

 14007 +	.global incjosp

 14008 +incjosp:

 14009 +	incjosp 1

 14010 +	incjosp 2

 14011 +	incjosp 3

 14012 +	incjosp 4

 14013 +	incjosp -4

 14014 +	incjosp -3

 14015 +	incjosp -2

 14016 +	incjosp -1

 14017 +	.text

 14018 +	.global nop

 14019 +nop:

 14020 +	nop

 14021 +	.text

 14022 +	.global popjc

 14023 +popjc:

 14024 +	popjc

 14025 +	.text

 14026 +	.global pushjc

 14027 +pushjc:

 14028 +	pushjc

 14029 +	.text

 14030 +	.global add2

 14031 +add2:

 14032 +	add pc,pc,pc<<0

 14033 +	add r12,r12,r12<<3

 14034 +	add r5,r5,r5<<2

 14035 +	add r4,r4,r4<<1

 14036 +	add lr,lr,lr<<1

 14037 +	add r0,r12,r0<<1

 14038 +	add r9,r12,r4<<0

 14039 +	add r12,r12,r7<<2

 14040 +	.text

 14041 +	.global sub2

 14042 +sub2:

 14043 +	sub pc,pc,pc<<0

 14044 +	sub r12,r12,r12<<3

 14045 +	sub r5,r5,r5<<2

 14046 +	sub r4,r4,r4<<1

 14047 +	sub lr,lr,lr<<1

 14048 +	sub sp,r3,r4<<0

 14049 +	sub r3,r7,r3<<0

 14050 +	sub sp,r10,sp<<1

 14051 +	.text

 14052 +	.global divu

 14053 +divu:

 14054 +	divu pc,pc,pc

 14055 +	divu r12,r12,r12

 14056 +	divu r5,r5,r5

 14057 +	divu r4,r4,r4

 14058 +	divu lr,lr,lr

 14059 +	divu sp,r4,pc

 14060 +	divu r5,r5,sp

 14061 +	divu r10,sp,r0

 14062 +	.text

 14063 +	.global addhh_w

 14064 +addhh_w:

 14065 +	addhh.w pc,pc:b,pc:b

 14066 +	addhh.w r12,r12:t,r12:t

 14067 +	addhh.w r5,r5:t,r5:t

 14068 +	addhh.w r4,r4:b,r4:b

 14069 +	addhh.w lr,lr:t,lr:t

 14070 +	addhh.w r0,r0:b,r3:b

 14071 +	addhh.w lr,r12:t,r7:b

 14072 +	addhh.w r3,r10:t,r2:b

 14073 +	.text

 14074 +	.global subhh_w

 14075 +subhh_w:

 14076 +	subhh.w pc,pc:b,pc:b

 14077 +	subhh.w r12,r12:t,r12:t

 14078 +	subhh.w r5,r5:t,r5:t

 14079 +	subhh.w r4,r4:b,r4:b

 14080 +	subhh.w lr,lr:t,lr:t

 14081 +	subhh.w r10,r1:t,r7:b

 14082 +	subhh.w pc,r10:t,lr:t

 14083 +	subhh.w r3,r0:t,r12:b

 14084 +	.text

 14085 +	.global adc

 14086 +adc:

 14087 +	adc pc,pc,pc

 14088 +	adc r12,r12,r12

 14089 +	adc r5,r5,r5

 14090 +	adc r4,r4,r4

 14091 +	adc lr,lr,lr

 14092 +	adc r4,r0,r7

 14093 +	adc sp,r4,r3

 14094 +	adc r2,r12,r0

 14095 +	.text

 14096 +	.global sbc

 14097 +sbc:

 14098 +	sbc pc,pc,pc

 14099 +	sbc r12,r12,r12

 14100 +	sbc r5,r5,r5

 14101 +	sbc r4,r4,r4

 14102 +	sbc lr,lr,lr

 14103 +	sbc r6,r7,r9

 14104 +	sbc r0,r8,r5

 14105 +	sbc r1,r0,r4

 14106 +	.text

 14107 +	.global mul_2

 14108 +mul_2:

 14109 +	mul pc,pc,pc

 14110 +	mul r12,r12,r12

 14111 +	mul r5,r5,r5

 14112 +	mul r4,r4,r4

 14113 +	mul lr,lr,lr

 14114 +	mul pc,r0,r0

 14115 +	mul r8,pc,lr

 14116 +	mul r4,r12,pc

 14117 +	.text

 14118 +	.global mac

 14119 +mac:

 14120 +	mac pc,pc,pc

 14121 +	mac r12,r12,r12

 14122 +	mac r5,r5,r5

 14123 +	mac r4,r4,r4

 14124 +	mac lr,lr,lr

 14125 +	mac r10,r4,r0

 14126 +	mac r7,lr,r0

 14127 +	mac r2,r9,r12

 14128 +	.text

 14129 +	.global mulsd

 14130 +mulsd:

 14131 +	muls.d pc,pc,pc

 14132 +	muls.d r12,r12,r12

 14133 +	muls.d r5,r5,r5

 14134 +	muls.d r4,r4,r4

 14135 +	muls.d lr,lr,lr

 14136 +	muls.d r2,r8,lr

 14137 +	muls.d r4,r0,r11

 14138 +	muls.d r5,lr,r6

 14139 +	.text

 14140 +	.global macsd

 14141 +macsd:

 14142 +	macs.d r0,pc,pc

 14143 +	macs.d r14,r12,r12

 14144 +	macs.d r8,r5,r5

 14145 +	macs.d r6,r4,r4

 14146 +	macs.d r2,lr,lr

 14147 +	macs.d r8,r1,r9

 14148 +	macs.d r14,r8,r8

 14149 +	macs.d r4,r3,r12

 14150 +	.text

 14151 +	.global mulud

 14152 +mulud:

 14153 +	mulu.d r0,pc,pc

 14154 +	mulu.d r14,r12,r12

 14155 +	mulu.d r8,r5,r5

 14156 +	mulu.d r6,r4,r4

 14157 +	mulu.d r2,lr,lr

 14158 +	mulu.d r6,r5,r0

 14159 +	mulu.d r4,r6,r1

 14160 +	mulu.d r8,r8,r2

 14161 +	.text

 14162 +	.global macud

 14163 +macud:

 14164 +	macu.d r0,pc,pc

 14165 +	macu.d r14,r12,r12

 14166 +	macu.d r8,r5,r5

 14167 +	macu.d r6,r4,r4

 14168 +	macu.d r2,lr,lr

 14169 +	macu.d r6,sp,r11

 14170 +	macu.d r2,r4,r8

 14171 +	macu.d r6,r10,r9

 14172 +	.text

 14173 +	.global asr_1

 14174 +asr_1:

 14175 +	asr pc,pc,pc

 14176 +	asr r12,r12,r12

 14177 +	asr r5,r5,r5

 14178 +	asr r4,r4,r4

 14179 +	asr lr,lr,lr

 14180 +	asr pc,r6,pc

 14181 +	asr r0,r6,r12

 14182 +	asr r4,sp,r0

 14183 +	.text

 14184 +	.global lsl_1

 14185 +lsl_1:

 14186 +	lsl pc,pc,pc

 14187 +	lsl r12,r12,r12

 14188 +	lsl r5,r5,r5

 14189 +	lsl r4,r4,r4

 14190 +	lsl lr,lr,lr

 14191 +	lsl lr,r5,lr

 14192 +	lsl r5,pc,r3

 14193 +	lsl r1,pc,r9

 14194 +	.text

 14195 +	.global lsr_1

 14196 +lsr_1:

 14197 +	lsr pc,pc,pc

 14198 +	lsr r12,r12,r12

 14199 +	lsr r5,r5,r5

 14200 +	lsr r4,r4,r4

 14201 +	lsr lr,lr,lr

 14202 +	lsr r2,r4,r1

 14203 +	lsr r5,r1,r6

 14204 +	lsr sp,r6,r7

 14205 +	.text

 14206 +	.global xchg

 14207 +xchg:

 14208 +	xchg pc,pc,pc

 14209 +	xchg r12,r12,r12

 14210 +	xchg r5,r5,r5

 14211 +	xchg r4,r4,r4

 14212 +	xchg lr,lr,lr

 14213 +	xchg lr,r4,sp

 14214 +	xchg r1,r5,r12

 14215 +	xchg lr,r12,r0

 14216 +	.text

 14217 +	.global max

 14218 +max:

 14219 +	max pc,pc,pc

 14220 +	max r12,r12,r12

 14221 +	max r5,r5,r5

 14222 +	max r4,r4,r4

 14223 +	max lr,lr,lr

 14224 +	max lr,r2,sp

 14225 +	max r4,r10,r9

 14226 +	max lr,r9,lr

 14227 +	.text

 14228 +	.global min

 14229 +min:

 14230 +	min pc,pc,pc

 14231 +	min r12,r12,r12

 14232 +	min r5,r5,r5

 14233 +	min r4,r4,r4

 14234 +	min lr,lr,lr

 14235 +	min r9,r7,r8

 14236 +	min sp,r5,r5

 14237 +	min r4,r1,r4

 14238 +	.text

 14239 +	.global addabs

 14240 +addabs:

 14241 +	addabs pc,pc,pc

 14242 +	addabs r12,r12,r12

 14243 +	addabs r5,r5,r5

 14244 +	addabs r4,r4,r4

 14245 +	addabs lr,lr,lr

 14246 +	addabs r7,r10,r0

 14247 +	addabs r9,r9,r7

 14248 +	addabs r2,r8,r12

 14249 +	.text

 14250 +	.global mulnhh_w

 14251 +mulnhh_w:

 14252 +	mulnhh.w pc,pc:b,pc:b

 14253 +	mulnhh.w r12,r12:t,r12:t

 14254 +	mulnhh.w r5,r5:t,r5:t

 14255 +	mulnhh.w r4,r4:b,r4:b

 14256 +	mulnhh.w lr,lr:t,lr:t

 14257 +	mulnhh.w r11,sp:t,r9:b

 14258 +	mulnhh.w sp,r4:b,lr:t

 14259 +	mulnhh.w r12,r2:t,r11:b

 14260 +	.text

 14261 +	.global mulnwh_d

 14262 +mulnwh_d:

 14263 +	mulnwh.d r0,pc,pc:b

 14264 +	mulnwh.d r14,r12,r12:t

 14265 +	mulnwh.d r8,r5,r5:t

 14266 +	mulnwh.d r6,r4,r4:b

 14267 +	mulnwh.d r2,lr,lr:t

 14268 +	mulnwh.d r14,r3,r2:t

 14269 +	mulnwh.d r4,r5,r9:b

 14270 +	mulnwh.d r12,r4,r4:t

 14271 +	.text

 14272 +	.global machh_w

 14273 +machh_w:

 14274 +	machh.w pc,pc:b,pc:b

 14275 +	machh.w r12,r12:t,r12:t

 14276 +	machh.w r5,r5:t,r5:t

 14277 +	machh.w r4,r4:b,r4:b

 14278 +	machh.w lr,lr:t,lr:t

 14279 +	machh.w lr,r5:b,r1:t

 14280 +	machh.w r9,r6:b,r7:b

 14281 +	machh.w r5,lr:t,r12:b

 14282 +	.text

 14283 +	.global machh_d

 14284 +machh_d:

 14285 +	machh.d r0,pc:b,pc:b

 14286 +	machh.d r14,r12:t,r12:t

 14287 +	machh.d r8,r5:t,r5:t

 14288 +	machh.d r6,r4:b,r4:b

 14289 +	machh.d r2,lr:t,lr:t

 14290 +	machh.d r10,r0:b,r8:b

 14291 +	machh.d r14,r4:b,r5:t

 14292 +	machh.d r8,r0:b,r4:t

 14293 +	.text

 14294 +	.global macsathh_w

 14295 +macsathh_w:

 14296 +	macsathh.w pc,pc:b,pc:b

 14297 +	macsathh.w r12,r12:t,r12:t

 14298 +	macsathh.w r5,r5:t,r5:t

 14299 +	macsathh.w r4,r4:b,r4:b

 14300 +	macsathh.w lr,lr:t,lr:t

 14301 +	macsathh.w r7,r7:t,pc:t

 14302 +	macsathh.w r4,r2:t,r4:b

 14303 +	macsathh.w r4,r8:t,r3:t

 14304 +	.text

 14305 +	.global mulhh_w

 14306 +mulhh_w:

 14307 +	mulhh.w pc,pc:b,pc:b

 14308 +	mulhh.w r12,r12:t,r12:t

 14309 +	mulhh.w r5,r5:t,r5:t

 14310 +	mulhh.w r4,r4:b,r4:b

 14311 +	mulhh.w lr,lr:t,lr:t

 14312 +	mulhh.w r7,r4:t,r9:b

 14313 +	mulhh.w pc,r3:t,r7:t

 14314 +	mulhh.w pc,r4:b,r9:t

 14315 +	.text

 14316 +	.global mulsathh_h

 14317 +mulsathh_h:

 14318 +	mulsathh.h pc,pc:b,pc:b

 14319 +	mulsathh.h r12,r12:t,r12:t

 14320 +	mulsathh.h r5,r5:t,r5:t

 14321 +	mulsathh.h r4,r4:b,r4:b

 14322 +	mulsathh.h lr,lr:t,lr:t

 14323 +	mulsathh.h r3,r1:b,sp:b

 14324 +	mulsathh.h r11,lr:t,r11:b

 14325 +	mulsathh.h r8,r8:b,r11:t

 14326 +	.text

 14327 +	.global mulsathh_w

 14328 +mulsathh_w:

 14329 +	mulsathh.w pc,pc:b,pc:b

 14330 +	mulsathh.w r12,r12:t,r12:t

 14331 +	mulsathh.w r5,r5:t,r5:t

 14332 +	mulsathh.w r4,r4:b,r4:b

 14333 +	mulsathh.w lr,lr:t,lr:t

 14334 +	mulsathh.w lr,r11:t,r6:b

 14335 +	mulsathh.w r6,r6:b,r7:t

 14336 +	mulsathh.w r10,r2:b,r3:b

 14337 +	.text

 14338 +	.global mulsatrndhh_h

 14339 +mulsatrndhh_h:

 14340 +	mulsatrndhh.h pc,pc:b,pc:b

 14341 +	mulsatrndhh.h r12,r12:t,r12:t

 14342 +	mulsatrndhh.h r5,r5:t,r5:t

 14343 +	mulsatrndhh.h r4,r4:b,r4:b

 14344 +	mulsatrndhh.h lr,lr:t,lr:t

 14345 +	mulsatrndhh.h r11,r6:b,r9:b

 14346 +	mulsatrndhh.h r11,r3:b,r8:t

 14347 +	mulsatrndhh.h r5,sp:t,r7:t

 14348 +	.text

 14349 +	.global mulsatrndwh_w

 14350 +mulsatrndwh_w:

 14351 +	mulsatrndwh.w pc,pc,pc:b

 14352 +	mulsatrndwh.w r12,r12,r12:t

 14353 +	mulsatrndwh.w r5,r5,r5:t

 14354 +	mulsatrndwh.w r4,r4,r4:b

 14355 +	mulsatrndwh.w lr,lr,lr:t

 14356 +	mulsatrndwh.w r5,r12,r0:b

 14357 +	mulsatrndwh.w r7,r10,pc:b

 14358 +	mulsatrndwh.w r10,r8,r5:t

 14359 +	.text

 14360 +	.global macwh_d

 14361 +macwh_d:

 14362 +	macwh.d r0,pc,pc:b

 14363 +	macwh.d r14,r12,r12:t

 14364 +	macwh.d r8,r5,r5:t

 14365 +	macwh.d r6,r4,r4:b

 14366 +	macwh.d r2,lr,lr:t

 14367 +	macwh.d r4,r10,r12:t

 14368 +	macwh.d r4,r7,sp:b

 14369 +	macwh.d r14,r9,r11:b

 14370 +	.text

 14371 +	.global mulwh_d

 14372 +mulwh_d:

 14373 +	mulwh.d r0,pc,pc:b

 14374 +	mulwh.d r14,r12,r12:t

 14375 +	mulwh.d r8,r5,r5:t

 14376 +	mulwh.d r6,r4,r4:b

 14377 +	mulwh.d r2,lr,lr:t

 14378 +	mulwh.d r12,r5,r1:b

 14379 +	mulwh.d r0,r1,r3:t

 14380 +	mulwh.d r0,r9,r2:b

 14381 +	.text

 14382 +	.global mulsatwh_w

 14383 +mulsatwh_w:

 14384 +	mulsatwh.w pc,pc,pc:b

 14385 +	mulsatwh.w r12,r12,r12:t

 14386 +	mulsatwh.w r5,r5,r5:t

 14387 +	mulsatwh.w r4,r4,r4:b

 14388 +	mulsatwh.w lr,lr,lr:t

 14389 +	mulsatwh.w r11,pc,r10:t

 14390 +	mulsatwh.w sp,r12,r9:t

 14391 +	mulsatwh.w r0,r3,r2:t

 14392 +	.text

 14393 +	.global ldw7

 14394 +ldw7:

 14395 +	ld.w pc,pc[pc:b<<2]

 14396 +	ld.w r12,r12[r12:t<<2]

 14397 +	ld.w r5,r5[r5:u<<2]

 14398 +	ld.w r4,r4[r4:l<<2]

 14399 +	ld.w lr,lr[lr:l<<2]

 14400 +	ld.w r9,r10[r6:l<<2]

 14401 +	ld.w r2,r10[r10:b<<2]

 14402 +	ld.w r11,r5[pc:b<<2]

 14403 +	.text

 14404 +	.global satadd_w

 14405 +satadd_w:

 14406 +	satadd.w pc,pc,pc

 14407 +	satadd.w r12,r12,r12

 14408 +	satadd.w r5,r5,r5

 14409 +	satadd.w r4,r4,r4

 14410 +	satadd.w lr,lr,lr

 14411 +	satadd.w r4,r8,r11

 14412 +	satadd.w r3,r12,r6

 14413 +	satadd.w r3,lr,r9

 14414 +	.text

 14415 +	.global satsub_w1

 14416 +satsub_w1:

 14417 +	satsub.w pc,pc,pc

 14418 +	satsub.w r12,r12,r12

 14419 +	satsub.w r5,r5,r5

 14420 +	satsub.w r4,r4,r4

 14421 +	satsub.w lr,lr,lr

 14422 +	satsub.w r8,sp,r0

 14423 +	satsub.w r9,r8,r4

 14424 +	satsub.w pc,lr,r2

 14425 +	.text

 14426 +	.global satadd_h

 14427 +satadd_h:

 14428 +	satadd.h pc,pc,pc

 14429 +	satadd.h r12,r12,r12

 14430 +	satadd.h r5,r5,r5

 14431 +	satadd.h r4,r4,r4

 14432 +	satadd.h lr,lr,lr

 14433 +	satadd.h r7,r3,r9

 14434 +	satadd.h r1,r0,r2

 14435 +	satadd.h r1,r4,lr

 14436 +	.text

 14437 +	.global satsub_h

 14438 +satsub_h:

 14439 +	satsub.h pc,pc,pc

 14440 +	satsub.h r12,r12,r12

 14441 +	satsub.h r5,r5,r5

 14442 +	satsub.h r4,r4,r4

 14443 +	satsub.h lr,lr,lr

 14444 +	satsub.h lr,lr,r3

 14445 +	satsub.h r11,r6,r5

 14446 +	satsub.h r3,sp,r0

 14447 +	.text

 14448 +	.global mul3

 14449 +mul3:

 14450 +	mul pc,pc,0

 14451 +	mul r12,r12,-1

 14452 +	mul r5,r5,-128

 14453 +	mul r4,r4,127

 14454 +	mul lr,lr,1

 14455 +	mul r12,r2,-7

 14456 +	mul r1,pc,95

 14457 +	mul r4,r6,19

 14458 +	.text

 14459 +	.global rsub2

 14460 +rsub2:

 14461 +	rsub pc,pc,0

 14462 +	rsub r12,r12,-1

 14463 +	rsub r5,r5,-128

 14464 +	rsub r4,r4,127

 14465 +	rsub lr,lr,1

 14466 +	rsub r9,lr,96

 14467 +	rsub r11,r1,56

 14468 +	rsub r0,r7,-87

 14469 +	.text

 14470 +	.global clz

 14471 +clz:

 14472 +	clz pc,pc

 14473 +	clz r12,r12

 14474 +	clz r5,r5

 14475 +	clz r4,r4

 14476 +	clz lr,lr

 14477 +	clz r2,r3

 14478 +	clz r5,r11

 14479 +	clz pc,r3

 14480 +	.text

 14481 +	.global cpc1

 14482 +cpc1:

 14483 +	cpc pc,pc

 14484 +	cpc r12,r12

 14485 +	cpc r5,r5

 14486 +	cpc r4,r4

 14487 +	cpc lr,lr

 14488 +	cpc pc,r4

 14489 +	cpc r5,r9

 14490 +	cpc r6,r7

 14491 +	.text

 14492 +	.global asr3

 14493 +asr3:

 14494 +	asr pc,pc,0

 14495 +	asr r12,r12,31

 14496 +	asr r5,r5,16

 14497 +	asr r4,r4,15

 14498 +	asr lr,lr,1

 14499 +	asr r4,r11,19

 14500 +	asr sp,pc,26

 14501 +	asr r11,sp,8

 14502 +	.text

 14503 +	.global lsl3

 14504 +lsl3:

 14505 +	lsl pc,pc,0

 14506 +	lsl r12,r12,31

 14507 +	lsl r5,r5,16

 14508 +	lsl r4,r4,15

 14509 +	lsl lr,lr,1

 14510 +	lsl r8,r10,17

 14511 +	lsl r2,lr,3

 14512 +	lsl lr,r11,14

 14513 +	.text

 14514 +	.global lsr3

 14515 +lsr3:

 14516 +	lsr pc,pc,0

 14517 +	lsr r12,r12,31

 14518 +	lsr r5,r5,16

 14519 +	lsr r4,r4,15

 14520 +	lsr lr,lr,1

 14521 +	lsr r4,r3,31

 14522 +	lsr pc,r9,14

 14523 +	lsr r3,r0,6

 14524 +/*	.text

 14525 +	.global extract_b

 14526 +extract_b:

 14527 +	extract.b pc,pc:b

 14528 +	extract.b r12,r12:t

 14529 +	extract.b r5,r5:u

 14530 +	extract.b r4,r4:l

 14531 +	extract.b lr,lr:l

 14532 +	extract.b r2,r5:l

 14533 +	extract.b r12,r3:l

 14534 +	extract.b sp,r3:l

 14535 +	.text

 14536 +	.global insert_b

 14537 +insert_b:

 14538 +	insert.b pc:b,pc

 14539 +	insert.b r12:t,r12

 14540 +	insert.b r5:u,r5

 14541 +	insert.b r4:l,r4

 14542 +	insert.b lr:l,lr

 14543 +	insert.b r12:u,r3

 14544 +	insert.b r10:l,lr

 14545 +	insert.b r11:l,r12

 14546 +	.text

 14547 +	.global extract_h

 14548 +extract_h:

 14549 +	extract.h pc,pc:b

 14550 +	extract.h r12,r12:t

 14551 +	extract.h r5,r5:t

 14552 +	extract.h r4,r4:b

 14553 +	extract.h lr,lr:t

 14554 +	extract.h r11,lr:b

 14555 +	extract.h r10,r0:b

 14556 +	extract.h r11,r12:b

 14557 +	.text

 14558 +	.global insert_h

 14559 +insert_h:

 14560 +	insert.h pc:b,pc

 14561 +	insert.h r12:t,r12

 14562 +	insert.h r5:t,r5

 14563 +	insert.h r4:b,r4

 14564 +	insert.h lr:t,lr

 14565 +	insert.h r12:t,r11

 14566 +	insert.h r7:b,r6

 14567 +	insert.h r1:t,r11 */

 14568 +	.text

 14569 +	.global movc1

 14570 +movc1:

 14571 +	moveq pc,pc

 14572 +	moval r12,r12

 14573 +	movls r5,r5

 14574 +	movpl r4,r4

 14575 +	movne lr,lr

 14576 +	movne pc,r11

 14577 +	movmi r10,r2

 14578 +	movls r8,r12

 14579 +	.text

 14580 +	.global padd_h

 14581 +padd_h:

 14582 +	padd.h pc,pc,pc

 14583 +	padd.h r12,r12,r12

 14584 +	padd.h r5,r5,r5

 14585 +	padd.h r4,r4,r4

 14586 +	padd.h lr,lr,lr

 14587 +	padd.h r8,r2,r7

 14588 +	padd.h r0,r0,r3

 14589 +	padd.h sp,r11,r6

 14590 +	.text

 14591 +	.global psub_h

 14592 +psub_h:

 14593 +	psub.h pc,pc,pc

 14594 +	psub.h r12,r12,r12

 14595 +	psub.h r5,r5,r5

 14596 +	psub.h r4,r4,r4

 14597 +	psub.h lr,lr,lr

 14598 +	psub.h lr,r6,r8

 14599 +	psub.h r0,r1,sp

 14600 +	psub.h pc,pc,sp

 14601 +	.text

 14602 +	.global paddx_h

 14603 +paddx_h:

 14604 +	paddx.h pc,pc,pc

 14605 +	paddx.h r12,r12,r12

 14606 +	paddx.h r5,r5,r5

 14607 +	paddx.h r4,r4,r4

 14608 +	paddx.h lr,lr,lr

 14609 +	paddx.h pc,pc,r1

 14610 +	paddx.h r10,r4,r5

 14611 +	paddx.h r5,pc,r2

 14612 +	.text

 14613 +	.global psubx_h

 14614 +psubx_h:

 14615 +	psubx.h pc,pc,pc

 14616 +	psubx.h r12,r12,r12

 14617 +	psubx.h r5,r5,r5

 14618 +	psubx.h r4,r4,r4

 14619 +	psubx.h lr,lr,lr

 14620 +	psubx.h r5,r12,r5

 14621 +	psubx.h r3,r8,r3

 14622 +	psubx.h r5,r2,r3

 14623 +	.text

 14624 +	.global padds_sh

 14625 +padds_sh:

 14626 +	padds.sh pc,pc,pc

 14627 +	padds.sh r12,r12,r12

 14628 +	padds.sh r5,r5,r5

 14629 +	padds.sh r4,r4,r4

 14630 +	padds.sh lr,lr,lr

 14631 +	padds.sh r9,lr,r2

 14632 +	padds.sh r6,r8,r1

 14633 +	padds.sh r6,r4,r10

 14634 +	.text

 14635 +	.global psubs_sh

 14636 +psubs_sh:

 14637 +	psubs.sh pc,pc,pc

 14638 +	psubs.sh r12,r12,r12

 14639 +	psubs.sh r5,r5,r5

 14640 +	psubs.sh r4,r4,r4

 14641 +	psubs.sh lr,lr,lr

 14642 +	psubs.sh r6,lr,r11

 14643 +	psubs.sh r2,r12,r4

 14644 +	psubs.sh r0,r9,r0

 14645 +	.text

 14646 +	.global paddxs_sh

 14647 +paddxs_sh:

 14648 +	paddxs.sh pc,pc,pc

 14649 +	paddxs.sh r12,r12,r12

 14650 +	paddxs.sh r5,r5,r5

 14651 +	paddxs.sh r4,r4,r4

 14652 +	paddxs.sh lr,lr,lr

 14653 +	paddxs.sh r0,r3,r9

 14654 +	paddxs.sh pc,r10,r11

 14655 +	paddxs.sh pc,r10,pc

 14656 +	.text

 14657 +	.global psubxs_sh

 14658 +psubxs_sh:

 14659 +	psubxs.sh pc,pc,pc

 14660 +	psubxs.sh r12,r12,r12

 14661 +	psubxs.sh r5,r5,r5

 14662 +	psubxs.sh r4,r4,r4

 14663 +	psubxs.sh lr,lr,lr

 14664 +	psubxs.sh r7,r4,r4

 14665 +	psubxs.sh r7,r8,r3

 14666 +	psubxs.sh pc,r6,r5

 14667 +	.text

 14668 +	.global padds_uh

 14669 +padds_uh:

 14670 +	padds.uh pc,pc,pc

 14671 +	padds.uh r12,r12,r12

 14672 +	padds.uh r5,r5,r5

 14673 +	padds.uh r4,r4,r4

 14674 +	padds.uh lr,lr,lr

 14675 +	padds.uh r12,r11,r7

 14676 +	padds.uh r7,r8,lr

 14677 +	padds.uh r6,r9,r7

 14678 +	.text

 14679 +	.global psubs_uh

 14680 +psubs_uh:

 14681 +	psubs.uh pc,pc,pc

 14682 +	psubs.uh r12,r12,r12

 14683 +	psubs.uh r5,r5,r5

 14684 +	psubs.uh r4,r4,r4

 14685 +	psubs.uh lr,lr,lr

 14686 +	psubs.uh lr,r10,r6

 14687 +	psubs.uh sp,r2,pc

 14688 +	psubs.uh r2,r9,r2

 14689 +	.text

 14690 +	.global paddxs_uh

 14691 +paddxs_uh:

 14692 +	paddxs.uh pc,pc,pc

 14693 +	paddxs.uh r12,r12,r12

 14694 +	paddxs.uh r5,r5,r5

 14695 +	paddxs.uh r4,r4,r4

 14696 +	paddxs.uh lr,lr,lr

 14697 +	paddxs.uh r7,r9,r5

 14698 +	paddxs.uh r9,r1,r4

 14699 +	paddxs.uh r5,r2,r3

 14700 +	.text

 14701 +	.global psubxs_uh

 14702 +psubxs_uh:

 14703 +	psubxs.uh pc,pc,pc

 14704 +	psubxs.uh r12,r12,r12

 14705 +	psubxs.uh r5,r5,r5

 14706 +	psubxs.uh r4,r4,r4

 14707 +	psubxs.uh lr,lr,lr

 14708 +	psubxs.uh sp,r5,sp

 14709 +	psubxs.uh sp,r6,r6

 14710 +	psubxs.uh r3,r11,r8

 14711 +	.text

 14712 +	.global paddh_sh

 14713 +paddh_sh:

 14714 +	paddh.sh pc,pc,pc

 14715 +	paddh.sh r12,r12,r12

 14716 +	paddh.sh r5,r5,r5

 14717 +	paddh.sh r4,r4,r4

 14718 +	paddh.sh lr,lr,lr

 14719 +	paddh.sh r12,sp,r3

 14720 +	paddh.sh pc,r5,r3

 14721 +	paddh.sh r8,r8,sp

 14722 +	.text

 14723 +	.global psubh_sh

 14724 +psubh_sh:

 14725 +	psubh.sh pc,pc,pc

 14726 +	psubh.sh r12,r12,r12

 14727 +	psubh.sh r5,r5,r5

 14728 +	psubh.sh r4,r4,r4

 14729 +	psubh.sh lr,lr,lr

 14730 +	psubh.sh r1,r5,r8

 14731 +	psubh.sh r7,r3,r6

 14732 +	psubh.sh r4,r3,r3

 14733 +	.text

 14734 +	.global paddxh_sh

 14735 +paddxh_sh:

 14736 +	paddxh.sh pc,pc,pc

 14737 +	paddxh.sh r12,r12,r12

 14738 +	paddxh.sh r5,r5,r5

 14739 +	paddxh.sh r4,r4,r4

 14740 +	paddxh.sh lr,lr,lr

 14741 +	paddxh.sh r6,r0,r4

 14742 +	paddxh.sh r9,r8,r9

 14743 +	paddxh.sh r3,r0,sp

 14744 +	.text

 14745 +	.global psubxh_sh

 14746 +psubxh_sh:

 14747 +	psubxh.sh pc,pc,pc

 14748 +	psubxh.sh r12,r12,r12

 14749 +	psubxh.sh r5,r5,r5

 14750 +	psubxh.sh r4,r4,r4

 14751 +	psubxh.sh lr,lr,lr

 14752 +	psubxh.sh r4,pc,r12

 14753 +	psubxh.sh r8,r4,r6

 14754 +	psubxh.sh r12,r9,r4

 14755 +	.text

 14756 +	.global paddsub_h

 14757 +paddsub_h:

 14758 +	paddsub.h pc,pc:b,pc:b

 14759 +	paddsub.h r12,r12:t,r12:t

 14760 +	paddsub.h r5,r5:t,r5:t

 14761 +	paddsub.h r4,r4:b,r4:b

 14762 +	paddsub.h lr,lr:t,lr:t

 14763 +	paddsub.h r5,r2:t,lr:b

 14764 +	paddsub.h r7,r1:b,r8:b

 14765 +	paddsub.h r6,r10:t,r5:t

 14766 +	.text

 14767 +	.global psubadd_h

 14768 +psubadd_h:

 14769 +	psubadd.h pc,pc:b,pc:b

 14770 +	psubadd.h r12,r12:t,r12:t

 14771 +	psubadd.h r5,r5:t,r5:t

 14772 +	psubadd.h r4,r4:b,r4:b

 14773 +	psubadd.h lr,lr:t,lr:t

 14774 +	psubadd.h r9,r11:t,r8:t

 14775 +	psubadd.h r10,r7:t,lr:t

 14776 +	psubadd.h r6,pc:t,pc:b

 14777 +	.text

 14778 +	.global paddsubs_sh

 14779 +paddsubs_sh:

 14780 +	paddsubs.sh pc,pc:b,pc:b

 14781 +	paddsubs.sh r12,r12:t,r12:t

 14782 +	paddsubs.sh r5,r5:t,r5:t

 14783 +	paddsubs.sh r4,r4:b,r4:b

 14784 +	paddsubs.sh lr,lr:t,lr:t

 14785 +	paddsubs.sh r0,lr:t,r0:b

 14786 +	paddsubs.sh r9,r2:t,r4:t

 14787 +	paddsubs.sh r12,r9:t,sp:t

 14788 +	.text

 14789 +	.global psubadds_sh

 14790 +psubadds_sh:

 14791 +	psubadds.sh pc,pc:b,pc:b

 14792 +	psubadds.sh r12,r12:t,r12:t

 14793 +	psubadds.sh r5,r5:t,r5:t

 14794 +	psubadds.sh r4,r4:b,r4:b

 14795 +	psubadds.sh lr,lr:t,lr:t

 14796 +	psubadds.sh pc,lr:b,r1:t

 14797 +	psubadds.sh r11,r3:b,r12:b

 14798 +	psubadds.sh r10,r2:t,r8:t

 14799 +	.text

 14800 +	.global paddsubs_uh

 14801 +paddsubs_uh:

 14802 +	paddsubs.uh pc,pc:b,pc:b

 14803 +	paddsubs.uh r12,r12:t,r12:t

 14804 +	paddsubs.uh r5,r5:t,r5:t

 14805 +	paddsubs.uh r4,r4:b,r4:b

 14806 +	paddsubs.uh lr,lr:t,lr:t

 14807 +	paddsubs.uh r9,r2:b,r3:b

 14808 +	paddsubs.uh sp,sp:b,r7:t

 14809 +	paddsubs.uh lr,r0:b,r10:t

 14810 +	.text

 14811 +	.global psubadds_uh

 14812 +psubadds_uh:

 14813 +	psubadds.uh pc,pc:b,pc:b

 14814 +	psubadds.uh r12,r12:t,r12:t

 14815 +	psubadds.uh r5,r5:t,r5:t

 14816 +	psubadds.uh r4,r4:b,r4:b

 14817 +	psubadds.uh lr,lr:t,lr:t

 14818 +	psubadds.uh r12,r9:t,pc:t

 14819 +	psubadds.uh r8,r6:b,r8:b

 14820 +	psubadds.uh r8,r8:b,r4:b

 14821 +	.text

 14822 +	.global paddsubh_sh

 14823 +paddsubh_sh:

 14824 +	paddsubh.sh pc,pc:b,pc:b

 14825 +	paddsubh.sh r12,r12:t,r12:t

 14826 +	paddsubh.sh r5,r5:t,r5:t

 14827 +	paddsubh.sh r4,r4:b,r4:b

 14828 +	paddsubh.sh lr,lr:t,lr:t

 14829 +	paddsubh.sh r8,r9:t,r9:b

 14830 +	paddsubh.sh r0,sp:t,r1:t

 14831 +	paddsubh.sh r3,r1:b,r0:t

 14832 +	.text

 14833 +	.global psubaddh_sh

 14834 +psubaddh_sh:

 14835 +	psubaddh.sh pc,pc:b,pc:b

 14836 +	psubaddh.sh r12,r12:t,r12:t

 14837 +	psubaddh.sh r5,r5:t,r5:t

 14838 +	psubaddh.sh r4,r4:b,r4:b

 14839 +	psubaddh.sh lr,lr:t,lr:t

 14840 +	psubaddh.sh r7,r3:t,r10:b

 14841 +	psubaddh.sh r7,r2:t,r1:t

 14842 +	psubaddh.sh r11,r3:b,r6:b

 14843 +	.text

 14844 +	.global padd_b

 14845 +padd_b:

 14846 +	padd.b pc,pc,pc

 14847 +	padd.b r12,r12,r12

 14848 +	padd.b r5,r5,r5

 14849 +	padd.b r4,r4,r4

 14850 +	padd.b lr,lr,lr

 14851 +	padd.b r2,r6,pc

 14852 +	padd.b r8,r9,r12

 14853 +	padd.b r5,r12,r3

 14854 +	.text

 14855 +	.global psub_b

 14856 +psub_b:

 14857 +	psub.b pc,pc,pc

 14858 +	psub.b r12,r12,r12

 14859 +	psub.b r5,r5,r5

 14860 +	psub.b r4,r4,r4

 14861 +	psub.b lr,lr,lr

 14862 +	psub.b r0,r12,pc

 14863 +	psub.b r7,sp,r10

 14864 +	psub.b r5,sp,r12

 14865 +	.text

 14866 +	.global padds_sb

 14867 +padds_sb:

 14868 +	padds.sb pc,pc,pc

 14869 +	padds.sb r12,r12,r12

 14870 +	padds.sb r5,r5,r5

 14871 +	padds.sb r4,r4,r4

 14872 +	padds.sb lr,lr,lr

 14873 +	padds.sb sp,r11,r4

 14874 +	padds.sb r11,r10,r11

 14875 +	padds.sb r5,r12,r6

 14876 +	.text

 14877 +	.global psubs_sb

 14878 +psubs_sb:

 14879 +	psubs.sb pc,pc,pc

 14880 +	psubs.sb r12,r12,r12

 14881 +	psubs.sb r5,r5,r5

 14882 +	psubs.sb r4,r4,r4

 14883 +	psubs.sb lr,lr,lr

 14884 +	psubs.sb r7,r6,r8

 14885 +	psubs.sb r12,r10,r9

 14886 +	psubs.sb pc,r11,r0

 14887 +	.text

 14888 +	.global padds_ub

 14889 +padds_ub:

 14890 +	padds.ub pc,pc,pc

 14891 +	padds.ub r12,r12,r12

 14892 +	padds.ub r5,r5,r5

 14893 +	padds.ub r4,r4,r4

 14894 +	padds.ub lr,lr,lr

 14895 +	padds.ub r3,r2,r11

 14896 +	padds.ub r10,r8,r1

 14897 +	padds.ub r11,r8,r10

 14898 +	.text

 14899 +	.global psubs_ub

 14900 +psubs_ub:

 14901 +	psubs.ub pc,pc,pc

 14902 +	psubs.ub r12,r12,r12

 14903 +	psubs.ub r5,r5,r5

 14904 +	psubs.ub r4,r4,r4

 14905 +	psubs.ub lr,lr,lr

 14906 +	psubs.ub r0,r2,r7

 14907 +	psubs.ub lr,r5,r3

 14908 +	psubs.ub r6,r7,r9

 14909 +	.text

 14910 +	.global paddh_ub

 14911 +paddh_ub:

 14912 +	paddh.ub pc,pc,pc

 14913 +	paddh.ub r12,r12,r12

 14914 +	paddh.ub r5,r5,r5

 14915 +	paddh.ub r4,r4,r4

 14916 +	paddh.ub lr,lr,lr

 14917 +	paddh.ub lr,r1,r0

 14918 +	paddh.ub r2,r7,r7

 14919 +	paddh.ub r2,r1,r2

 14920 +	.text

 14921 +	.global psubh_ub

 14922 +psubh_ub:

 14923 +	psubh.ub pc,pc,pc

 14924 +	psubh.ub r12,r12,r12

 14925 +	psubh.ub r5,r5,r5

 14926 +	psubh.ub r4,r4,r4

 14927 +	psubh.ub lr,lr,lr

 14928 +	psubh.ub r0,r1,r6

 14929 +	psubh.ub r4,lr,r10

 14930 +	psubh.ub r9,r8,r1

 14931 +	.text

 14932 +	.global pmax_ub

 14933 +pmax_ub:

 14934 +	pmax.ub pc,pc,pc

 14935 +	pmax.ub r12,r12,r12

 14936 +	pmax.ub r5,r5,r5

 14937 +	pmax.ub r4,r4,r4

 14938 +	pmax.ub lr,lr,lr

 14939 +	pmax.ub pc,r2,r11

 14940 +	pmax.ub r12,r1,r1

 14941 +	pmax.ub r5,r2,r0

 14942 +	.text

 14943 +	.global pmax_sh

 14944 +pmax_sh:

 14945 +	pmax.sh pc,pc,pc

 14946 +	pmax.sh r12,r12,r12

 14947 +	pmax.sh r5,r5,r5

 14948 +	pmax.sh r4,r4,r4

 14949 +	pmax.sh lr,lr,lr

 14950 +	pmax.sh lr,r6,r12

 14951 +	pmax.sh r2,pc,r5

 14952 +	pmax.sh pc,r2,r7

 14953 +	.text

 14954 +	.global pmin_ub

 14955 +pmin_ub:

 14956 +	pmin.ub pc,pc,pc

 14957 +	pmin.ub r12,r12,r12

 14958 +	pmin.ub r5,r5,r5

 14959 +	pmin.ub r4,r4,r4

 14960 +	pmin.ub lr,lr,lr

 14961 +	pmin.ub r8,r1,r5

 14962 +	pmin.ub r1,r8,r3

 14963 +	pmin.ub r0,r2,r7

 14964 +	.text

 14965 +	.global pmin_sh

 14966 +pmin_sh:

 14967 +	pmin.sh pc,pc,pc

 14968 +	pmin.sh r12,r12,r12

 14969 +	pmin.sh r5,r5,r5

 14970 +	pmin.sh r4,r4,r4

 14971 +	pmin.sh lr,lr,lr

 14972 +	pmin.sh r8,r4,r10

 14973 +	pmin.sh lr,r10,r12

 14974 +	pmin.sh r2,r6,r2

 14975 +	.text

 14976 +	.global pavg_ub

 14977 +pavg_ub:

 14978 +	pavg.ub pc,pc,pc

 14979 +	pavg.ub r12,r12,r12

 14980 +	pavg.ub r5,r5,r5

 14981 +	pavg.ub r4,r4,r4

 14982 +	pavg.ub lr,lr,lr

 14983 +	pavg.ub r0,r1,r6

 14984 +	pavg.ub r8,r3,r6

 14985 +	pavg.ub pc,r12,r10

 14986 +	.text

 14987 +	.global pavg_sh

 14988 +pavg_sh:

 14989 +	pavg.sh pc,pc,pc

 14990 +	pavg.sh r12,r12,r12

 14991 +	pavg.sh r5,r5,r5

 14992 +	pavg.sh r4,r4,r4

 14993 +	pavg.sh lr,lr,lr

 14994 +	pavg.sh r9,pc,sp

 14995 +	pavg.sh pc,sp,r3

 14996 +	pavg.sh r6,r1,r9

 14997 +	.text

 14998 +	.global pabs_sb

 14999 +pabs_sb:

 15000 +	pabs.sb pc,pc

 15001 +	pabs.sb r12,r12

 15002 +	pabs.sb r5,r5

 15003 +	pabs.sb r4,r4

 15004 +	pabs.sb lr,lr

 15005 +	pabs.sb r11,r6

 15006 +	pabs.sb lr,r9

 15007 +	pabs.sb sp,r7

 15008 +	.text

 15009 +	.global pabs_sh

 15010 +pabs_sh:

 15011 +	pabs.sh pc,pc

 15012 +	pabs.sh r12,r12

 15013 +	pabs.sh r5,r5

 15014 +	pabs.sh r4,r4

 15015 +	pabs.sh lr,lr

 15016 +	pabs.sh pc,r3

 15017 +	pabs.sh r5,r7

 15018 +	pabs.sh r4,r0

 15019 +	.text

 15020 +	.global psad

 15021 +psad:

 15022 +	psad pc,pc,pc

 15023 +	psad r12,r12,r12

 15024 +	psad r5,r5,r5

 15025 +	psad r4,r4,r4

 15026 +	psad lr,lr,lr

 15027 +	psad r9,r11,r11

 15028 +	psad lr,r4,sp

 15029 +	psad lr,r4,r5

 15030 +	.text

 15031 +	.global pasr_b

 15032 +pasr_b:

 15033 +	pasr.b pc,pc,0

 15034 +	pasr.b r12,r12,7

 15035 +	pasr.b r5,r5,4

 15036 +	pasr.b r4,r4,3

 15037 +	pasr.b lr,lr,1

 15038 +	pasr.b pc,r7,1

 15039 +	pasr.b sp,lr,6

 15040 +	pasr.b sp,r3,2

 15041 +	.text

 15042 +	.global plsl_b

 15043 +plsl_b:

 15044 +	plsl.b pc,pc,0

 15045 +	plsl.b r12,r12,7

 15046 +	plsl.b r5,r5,4

 15047 +	plsl.b r4,r4,3

 15048 +	plsl.b lr,lr,1

 15049 +	plsl.b r2,r11,4

 15050 +	plsl.b r8,r5,7

 15051 +	plsl.b pc,r0,2

 15052 +	.text

 15053 +	.global plsr_b

 15054 +plsr_b:

 15055 +	plsr.b pc,pc,0

 15056 +	plsr.b r12,r12,7

 15057 +	plsr.b r5,r5,4

 15058 +	plsr.b r4,r4,3

 15059 +	plsr.b lr,lr,1

 15060 +	plsr.b r12,r1,2

 15061 +	plsr.b r6,pc,7

 15062 +	plsr.b r12,r11,2

 15063 +	.text

 15064 +	.global pasr_h

 15065 +pasr_h:

 15066 +	pasr.h pc,pc,0

 15067 +	pasr.h r12,r12,15

 15068 +	pasr.h r5,r5,8

 15069 +	pasr.h r4,r4,7

 15070 +	pasr.h lr,lr,1

 15071 +	pasr.h r0,r11,10

 15072 +	pasr.h r4,r6,8

 15073 +	pasr.h r6,r2,4

 15074 +	.text

 15075 +	.global plsl_h

 15076 +plsl_h:

 15077 +	plsl.h pc,pc,0

 15078 +	plsl.h r12,r12,15

 15079 +	plsl.h r5,r5,8

 15080 +	plsl.h r4,r4,7

 15081 +	plsl.h lr,lr,1

 15082 +	plsl.h r5,r10,9

 15083 +	plsl.h sp,lr,8

 15084 +	plsl.h r0,lr,7

 15085 +	.text

 15086 +	.global plsr_h

 15087 +plsr_h:

 15088 +	plsr.h pc,pc,0

 15089 +	plsr.h r12,r12,15

 15090 +	plsr.h r5,r5,8

 15091 +	plsr.h r4,r4,7

 15092 +	plsr.h lr,lr,1

 15093 +	plsr.h r11,r0,15

 15094 +	plsr.h lr,r3,3

 15095 +	plsr.h r8,lr,10

 15096 +	.text

 15097 +	.global packw_sh

 15098 +packw_sh:

 15099 +	packw.sh pc,pc,pc

 15100 +	packw.sh r12,r12,r12

 15101 +	packw.sh r5,r5,r5

 15102 +	packw.sh r4,r4,r4

 15103 +	packw.sh lr,lr,lr

 15104 +	packw.sh sp,r11,r10

 15105 +	packw.sh r8,r2,r12

 15106 +	packw.sh r8,r1,r5

 15107 +	.text

 15108 +	.global punpckub_h

 15109 +punpckub_h:

 15110 +	punpckub.h pc,pc:b

 15111 +	punpckub.h r12,r12:t

 15112 +	punpckub.h r5,r5:t

 15113 +	punpckub.h r4,r4:b

 15114 +	punpckub.h lr,lr:t

 15115 +	punpckub.h r6,r1:t

 15116 +	punpckub.h lr,r5:b

 15117 +	punpckub.h lr,r2:t

 15118 +	.text

 15119 +	.global punpcksb_h

 15120 +punpcksb_h:

 15121 +	punpcksb.h pc,pc:b

 15122 +	punpcksb.h r12,r12:t

 15123 +	punpcksb.h r5,r5:t

 15124 +	punpcksb.h r4,r4:b

 15125 +	punpcksb.h lr,lr:t

 15126 +	punpcksb.h r4,r7:t

 15127 +	punpcksb.h r6,lr:b

 15128 +	punpcksb.h r12,r12:t

 15129 +	.text

 15130 +	.global packsh_ub

 15131 +packsh_ub:

 15132 +	packsh.ub pc,pc,pc

 15133 +	packsh.ub r12,r12,r12

 15134 +	packsh.ub r5,r5,r5

 15135 +	packsh.ub r4,r4,r4

 15136 +	packsh.ub lr,lr,lr

 15137 +	packsh.ub r3,r6,r3

 15138 +	packsh.ub r8,r0,r3

 15139 +	packsh.ub r9,r3,lr

 15140 +	.text

 15141 +	.global packsh_sb

 15142 +packsh_sb:

 15143 +	packsh.sb pc,pc,pc

 15144 +	packsh.sb r12,r12,r12

 15145 +	packsh.sb r5,r5,r5

 15146 +	packsh.sb r4,r4,r4

 15147 +	packsh.sb lr,lr,lr

 15148 +	packsh.sb r6,r8,r1

 15149 +	packsh.sb lr,r9,r8

 15150 +	packsh.sb sp,r6,r6

 15151 +	.text

 15152 +	.global andl

 15153 +andl:

 15154 +	andl pc,0

 15155 +	andl r12,65535

 15156 +	andl r5,32768

 15157 +	andl r4,32767

 15158 +	andl lr,1

 15159 +	andl pc,23128

 15160 +	andl r8,47262

 15161 +	andl r7,13719

 15162 +	.text

 15163 +	.global andl_coh

 15164 +andl_coh:

 15165 +	andl pc,0,COH

 15166 +	andl r12,65535,COH

 15167 +	andl r5,32768,COH

 15168 +	andl r4,32767,COH

 15169 +	andl lr,1,COH

 15170 +	andl r6,22753,COH

 15171 +	andl r0,40653,COH

 15172 +	andl r4,48580,COH

 15173 +	.text

 15174 +	.global andh

 15175 +andh:

 15176 +	andh pc,0

 15177 +	andh r12,65535

 15178 +	andh r5,32768

 15179 +	andh r4,32767

 15180 +	andh lr,1

 15181 +	andh r12,52312

 15182 +	andh r3,8675

 15183 +	andh r2,42987

 15184 +	.text

 15185 +	.global andh_coh

 15186 +andh_coh:

 15187 +	andh pc,0,COH

 15188 +	andh r12,65535,COH

 15189 +	andh r5,32768,COH

 15190 +	andh r4,32767,COH

 15191 +	andh lr,1,COH

 15192 +	andh r11,34317,COH

 15193 +	andh r8,52982,COH

 15194 +	andh r10,23683,COH

 15195 +	.text

 15196 +	.global orl

 15197 +orl:

 15198 +	orl pc,0

 15199 +	orl r12,65535

 15200 +	orl r5,32768

 15201 +	orl r4,32767

 15202 +	orl lr,1

 15203 +	orl sp,16766

 15204 +	orl r0,21181

 15205 +	orl pc,44103

 15206 +	.text

 15207 +	.global orh

 15208 +orh:

 15209 +	orh pc,0

 15210 +	orh r12,65535

 15211 +	orh r5,32768

 15212 +	orh r4,32767

 15213 +	orh lr,1

 15214 +	orh r8,28285

 15215 +	orh r12,30492

 15216 +	orh r1,59930

 15217 +	.text

 15218 +	.global eorl

 15219 +eorl:

 15220 +	eorl pc,0

 15221 +	eorl r12,65535

 15222 +	eorl r5,32768

 15223 +	eorl r4,32767

 15224 +	eorl lr,1

 15225 +	eorl r4,51129

 15226 +	eorl r6,64477

 15227 +	eorl r1,20913

 15228 +	.text

 15229 +	.global eorh

 15230 +eorh:

 15231 +	eorh pc,0

 15232 +	eorh r12,65535

 15233 +	eorh r5,32768

 15234 +	eorh r4,32767

 15235 +	eorh lr,1

 15236 +	eorh r0,11732

 15237 +	eorh r10,38069

 15238 +	eorh r9,57130

 15239 +	.text

 15240 +	.global mcall

 15241 +mcall:

 15242 +	mcall pc[0]

 15243 +	mcall r12[-4]

 15244 +	mcall r5[-131072]

 15245 +	mcall r4[131068]

 15246 +	mcall lr[4]

 15247 +	mcall sp[61180]

 15248 +	mcall r4[-35000]

 15249 +	mcall r0[9924]

 15250 +	.text

 15251 +	.global pref

 15252 +pref:

 15253 +	pref pc[0]

 15254 +	pref r12[-1]

 15255 +	pref r5[-32768]

 15256 +	pref r4[32767]

 15257 +	pref lr[1]

 15258 +	pref r7[7748]

 15259 +	pref r7[-7699]

 15260 +	pref r2[-25892]

 15261 +	.text

 15262 +	.global cache

 15263 +cache:

 15264 +	cache pc[0],0

 15265 +	cache r12[-1],31

 15266 +	cache r5[-1024],16

 15267 +	cache r4[1023],15

 15268 +	cache lr[1],1

 15269 +	cache r3[-964],17

 15270 +	cache r4[-375],22

 15271 +	cache r3[-888],17

 15272 +	.text

 15273 +	.global sub4

 15274 +sub4:

 15275 +	sub pc,0

 15276 +	sub r12,-1

 15277 +	sub r5,-1048576

 15278 +	sub r4,1048575

 15279 +	sub lr,1

 15280 +	sub r2,-619156

 15281 +	sub lr,461517

 15282 +	sub r8,-185051

 15283 +	.text

 15284 +	.global cp3

 15285 +cp3:

 15286 +	cp pc,0

 15287 +	cp r12,-1

 15288 +	cp r5,-1048576

 15289 +	cp r4,1048575

 15290 +	cp lr,1

 15291 +	cp r1,124078

 15292 +	cp r0,-378909

 15293 +	cp r4,-243180

 15294 +	.text

 15295 +	.global mov2

 15296 +mov2:

 15297 +	mov pc,0

 15298 +	mov r12,-1

 15299 +	mov r5,-1048576

 15300 +	mov r4,1048575

 15301 +	mov lr,1

 15302 +	mov r5,-317021

 15303 +	mov sp,-749164

 15304 +	mov r5,940179

 15305 +	.text

 15306 +	.global brc2

 15307 +brc2:

 15308 +	breq 0

 15309 +	bral -2

 15310 +	brls -2097152

 15311 +	brpl 2097150

 15312 +	brne 2

 15313 +	brhi -1796966

 15314 +	brqs 1321368

 15315 +	brls -577434

 15316 +	.text

 15317 +	.global rcall2

 15318 +rcall2:

 15319 +	rcall 0

 15320 +	rcall -2

 15321 +	rcall -2097152

 15322 +	rcall 2097150

 15323 +	rcall 2

 15324 +	rcall 496820

 15325 +	rcall 1085092

 15326 +	rcall -1058

 15327 +	.text

 15328 +	.global sub5

 15329 +sub5:

 15330 +	sub pc,pc,0

 15331 +	sub r12,r12,-1

 15332 +	sub r5,r5,-32768

 15333 +	sub r4,r4,32767

 15334 +	sub lr,lr,1

 15335 +	sub pc,pc,-12744

 15336 +	sub r7,r7,-27365

 15337 +	sub r2,r9,-17358

 15338 +	.text

 15339 +	.global satsub_w2

 15340 +satsub_w2:

 15341 +	satsub.w pc,pc,0

 15342 +	satsub.w r12,r12,-1

 15343 +	satsub.w r5,r5,-32768

 15344 +	satsub.w r4,r4,32767

 15345 +	satsub.w lr,lr,1

 15346 +	satsub.w r2,lr,-2007

 15347 +	satsub.w r7,r12,-784

 15348 +	satsub.w r4,r7,23180

 15349 +	.text

 15350 +	.global ld_d4

 15351 +ld_d4:

 15352 +	ld.d r0,pc[0]

 15353 +	ld.d r14,r12[-1]

 15354 +	ld.d r8,r5[-32768]

 15355 +	ld.d r6,r4[32767]

 15356 +	ld.d r2,lr[1]

 15357 +	ld.d r14,r11[14784]

 15358 +	ld.d r6,r9[-18905]

 15359 +	ld.d r2,r3[-6355]

 15360 +	.text

 15361 +	.global ld_w4

 15362 +ld_w4:

 15363 +	ld.w pc,pc[0]

 15364 +	ld.w r12,r12[-1]

 15365 +	ld.w r5,r5[-32768]

 15366 +	ld.w r4,r4[32767]

 15367 +	ld.w lr,lr[1]

 15368 +	ld.w r0,r12[-22133]

 15369 +	ld.w sp,pc[-20521]

 15370 +	/* ld.w r3,r5[29035] */

 15371 +	nop

 15372 +	.text

 15373 +	.global ld_sh4

 15374 +ld_sh4:

 15375 +	ld.sh pc,pc[0]

 15376 +	ld.sh r12,r12[-1]

 15377 +	ld.sh r5,r5[-32768]

 15378 +	ld.sh r4,r4[32767]

 15379 +	ld.sh lr,lr[1]

 15380 +	ld.sh r6,r10[30930]

 15381 +	ld.sh r6,r10[21973]

 15382 +	/* ld.sh r11,r10[-2058] */

 15383 +	nop

 15384 +	.text

 15385 +	.global ld_uh4

 15386 +ld_uh4:

 15387 +	ld.uh pc,pc[0]

 15388 +	ld.uh r12,r12[-1]

 15389 +	ld.uh r5,r5[-32768]

 15390 +	ld.uh r4,r4[32767]

 15391 +	ld.uh lr,lr[1]

 15392 +	ld.uh r1,r9[-13354]

 15393 +	ld.uh lr,r11[21337]

 15394 +	/* ld.uh r2,lr[-25370] */

 15395 +	nop

 15396 +	.text

 15397 +	.global ld_sb1

 15398 +ld_sb1:

 15399 +	ld.sb pc,pc[0]

 15400 +	ld.sb r12,r12[-1]

 15401 +	ld.sb r5,r5[-32768]

 15402 +	ld.sb r4,r4[32767]

 15403 +	ld.sb lr,lr[1]

 15404 +	ld.sb r7,sp[-28663]

 15405 +	ld.sb r2,r1[-5879]

 15406 +	ld.sb r12,r3[18734]

 15407 +	.text

 15408 +	.global ld_ub4

 15409 +ld_ub4:

 15410 +	ld.ub pc,pc[0]

 15411 +	ld.ub r12,r12[-1]

 15412 +	ld.ub r5,r5[-32768]

 15413 +	ld.ub r4,r4[32767]

 15414 +	ld.ub lr,lr[1]

 15415 +	ld.ub pc,r4[8277]

 15416 +	ld.ub r5,r12[19172]

 15417 +	ld.ub r10,lr[26347]

 15418 +	.text

 15419 +	.global st_d4

 15420 +st_d4:

 15421 +	st.d pc[0],r0

 15422 +	st.d r12[-1],r14

 15423 +	st.d r5[-32768],r8

 15424 +	st.d r4[32767],r6

 15425 +	st.d lr[1],r2

 15426 +	st.d r5[13200],r10

 15427 +	st.d r5[9352],r10

 15428 +	st.d r5[32373],r4

 15429 +	.text

 15430 +	.global st_w4

 15431 +st_w4:

 15432 +	st.w pc[0],pc

 15433 +	st.w r12[-1],r12

 15434 +	st.w r5[-32768],r5

 15435 +	st.w r4[32767],r4

 15436 +	st.w lr[1],lr

 15437 +	st.w sp[6136],r7

 15438 +	st.w r6[27087],r12

 15439 +	/* st.w r3[20143],r7 */

 15440 +	nop

 15441 +	.text

 15442 +	.global st_h4

 15443 +st_h4:

 15444 +	st.h pc[0],pc

 15445 +	st.h r12[-1],r12

 15446 +	st.h r5[-32768],r5

 15447 +	st.h r4[32767],r4

 15448 +	st.h lr[1],lr

 15449 +	st.h r4[-9962],r7

 15450 +	st.h r9[-16250],r3

 15451 +	/* st.h r8[-28810],r7 */

 15452 +	nop

 15453 +	.text

 15454 +	.global st_b4

 15455 +st_b4:

 15456 +	st.b pc[0],pc

 15457 +	st.b r12[-1],r12

 15458 +	st.b r5[-32768],r5

 15459 +	st.b r4[32767],r4

 15460 +	st.b lr[1],lr

 15461 +	st.b r12[30102],r6

 15462 +	st.b r5[28977],r1

 15463 +	st.b r0[5470],r1

 15464 +	.text

 15465 +	.global mfsr

 15466 +mfsr:

 15467 +	mfsr pc,0

 15468 +	mfsr r12,1020

 15469 +	mfsr r5,512

 15470 +	mfsr r4,508

 15471 +	mfsr lr,4

 15472 +	mfsr r2,696

 15473 +	mfsr r4,260

 15474 +	mfsr r10,1016

 15475 +	.text

 15476 +	.global mtsr

 15477 +mtsr:

 15478 +	mtsr 0,pc

 15479 +	mtsr 1020,r12

 15480 +	mtsr 512,r5

 15481 +	mtsr 508,r4

 15482 +	mtsr 4,lr

 15483 +	mtsr 224,r10

 15484 +	mtsr 836,r12

 15485 +	mtsr 304,r9

 15486 +	.text

 15487 +	.global mfdr

 15488 +mfdr:

 15489 +	mfdr pc,0

 15490 +	mfdr r12,1020

 15491 +	mfdr r5,512

 15492 +	mfdr r4,508

 15493 +	mfdr lr,4

 15494 +	mfdr r6,932

 15495 +	mfdr r5,36

 15496 +	mfdr r9,300

 15497 +	.text

 15498 +	.global mtdr

 15499 +mtdr:

 15500 +	mtdr 0,pc

 15501 +	mtdr 1020,r12

 15502 +	mtdr 512,r5

 15503 +	mtdr 508,r4

 15504 +	mtdr 4,lr

 15505 +	mtdr 180,r8

 15506 +	mtdr 720,r10

 15507 +	mtdr 408,lr

 15508 +	.text

 15509 +	.global sleep

 15510 +sleep:

 15511 +	sleep 0

 15512 +	sleep 255

 15513 +	sleep 128

 15514 +	sleep 127

 15515 +	sleep 1

 15516 +	sleep 254

 15517 +	sleep 15

 15518 +	sleep 43

 15519 +	.text

 15520 +	.global sync

 15521 +sync:

 15522 +	sync 0

 15523 +	sync 255

 15524 +	sync 128

 15525 +	sync 127

 15526 +	sync 1

 15527 +	sync 166

 15528 +	sync 230

 15529 +	sync 180

 15530 +	.text

 15531 +	.global bld

 15532 +bld:

 15533 +	bld pc,0

 15534 +	bld r12,31

 15535 +	bld r5,16

 15536 +	bld r4,15

 15537 +	bld lr,1

 15538 +	bld r9,15

 15539 +	bld r0,4

 15540 +	bld lr,26

 15541 +	.text

 15542 +	.global bst

 15543 +bst:

 15544 +	bst pc,0

 15545 +	bst r12,31

 15546 +	bst r5,16

 15547 +	bst r4,15

 15548 +	bst lr,1

 15549 +	bst r10,28

 15550 +	bst r0,3

 15551 +	bst sp,2

 15552 +	.text

 15553 +	.global sats

 15554 +sats:

 15555 +	sats pc>>0,0

 15556 +	sats r12>>31,31

 15557 +	sats r5>>16,16

 15558 +	sats r4>>15,15

 15559 +	sats lr>>1,1

 15560 +	sats r10>>3,19

 15561 +	sats r10>>2,26

 15562 +	sats r1>>20,1

 15563 +	.text

 15564 +	.global satu

 15565 +satu:

 15566 +	satu pc>>0,0

 15567 +	satu r12>>31,31

 15568 +	satu r5>>16,16

 15569 +	satu r4>>15,15

 15570 +	satu lr>>1,1

 15571 +	satu pc>>5,7

 15572 +	satu r7>>5,5

 15573 +	satu r2>>26,19

 15574 +	.text

 15575 +	.global satrnds

 15576 +satrnds:

 15577 +	satrnds pc>>0,0

 15578 +	satrnds r12>>31,31

 15579 +	satrnds r5>>16,16

 15580 +	satrnds r4>>15,15

 15581 +	satrnds lr>>1,1

 15582 +	satrnds r0>>21,19

 15583 +	satrnds sp>>0,2

 15584 +	satrnds r7>>6,29

 15585 +	.text

 15586 +	.global satrndu

 15587 +satrndu:

 15588 +	satrndu pc>>0,0

 15589 +	satrndu r12>>31,31

 15590 +	satrndu r5>>16,16

 15591 +	satrndu r4>>15,15

 15592 +	satrndu lr>>1,1

 15593 +	satrndu r12>>0,26

 15594 +	satrndu r4>>21,3

 15595 +	satrndu r10>>3,16

 15596 +	.text

 15597 +	.global subfc

 15598 +subfc:

 15599 +	subfeq pc,0

 15600 +	subfal r12,-1

 15601 +	subfls r5,-128

 15602 +	subfpl r4,127

 15603 +	subfne lr,1

 15604 +	subfls r10,8

 15605 +	subfvc r11,99

 15606 +	subfvs r2,73

 15607 +	.text

 15608 +	.global subc

 15609 +subc:

 15610 +	subeq pc,0

 15611 +	subal r12,-1

 15612 +	subls r5,-128

 15613 +	subpl r4,127

 15614 +	subne lr,1

 15615 +	subls r12,118

 15616 +	subvc lr,-12

 15617 +	submi r4,-13

 15618 +	.text

 15619 +	.global movc2

 15620 +movc2:

 15621 +	moveq pc,0

 15622 +	moval r12,-1

 15623 +	movls r5,-128

 15624 +	movpl r4,127

 15625 +	movne lr,1

 15626 +	movlt r3,-122

 15627 +	movvc r8,2

 15628 +	movne r7,-111

 15629 +	.text

 15630 +	.global cp_b

 15631 +cp_b:

 15632 +	cp.b pc,r0

 15633 +	cp.b r0,pc

 15634 +	cp.b r7,r8

 15635 +	cp.b r8,r7

 15636 +	.text

 15637 +	.global cp_h

 15638 +cp_h:

 15639 +	cp.h pc,r0

 15640 +	cp.h r0,pc

 15641 +	cp.h r7,r8

 15642 +	cp.h r8,r7

 15643 +	.text

 15644 +	.global ldm

 15645 +ldm:

 15646 +	ldm pc,r1-r6

 15647 +	ldm r12,r0-r15

 15648 +	ldm r5,r15

 15649 +	ldm r4,r0-r14

 15650 +	ldm lr,r0

 15651 +	ldm r9,r1,r5,r14

 15652 +	ldm r11,r2-r3,r5-r8,r15

 15653 +	ldm r6,r0,r3,r9,r13,r15

 15654 +	.text

 15655 +	.global ldm_pu

 15656 +ldm_pu:

 15657 +	ldm pc++,r6-r9

 15658 +	ldm r12++,r0-r15

 15659 +	ldm r5++,r15

 15660 +	ldm r4++,r0-r14

 15661 +	ldm lr++,r0

 15662 +	ldm r12++,r3-r5,r8,r10,r12,r14-r15

 15663 +	ldm r10++,r2,r4-r6,r14-r15

 15664 +	ldm r6++,r1,r3-r4,r9-r14

 15665 +	.text

 15666 +	.global ldmts

 15667 +ldmts:

 15668 +	ldmts pc,r7-r8

 15669 +	ldmts r12,r0-r15

 15670 +	ldmts r5,r15

 15671 +	ldmts r4,r0-r14

 15672 +	ldmts lr,r0

 15673 +	ldmts r0,r1-r2,r11-r12

 15674 +	ldmts lr,r0-r2,r4,r7-r8,r13-r14

 15675 +	ldmts r12,r0-r1,r3-r5,r9,r14-r15

 15676 +	.text

 15677 +	.global ldmts_pu

 15678 +ldmts_pu:

 15679 +	ldmts pc++,r9

 15680 +	ldmts r12++,r0-r15

 15681 +	ldmts r5++,r15

 15682 +	ldmts r4++,r0-r14

 15683 +	ldmts lr++,r0

 15684 +	ldmts sp++,r0,r2-r5,r7,r9,r11

 15685 +	ldmts r5++,r1-r3,r7,r10-r11

 15686 +	ldmts r8++,r2-r4,r7-r8,r13,r15

 15687 +	.text

 15688 +	.global stm

 15689 +stm:

 15690 +	stm pc,r7

 15691 +	stm r12,r0-r15

 15692 +	stm r5,r15

 15693 +	stm r4,r0-r14

 15694 +	stm lr,r0

 15695 +	stm sp,r2-r3,r5,r8,r11,r14

 15696 +	stm r4,r0-r4,r6,r10-r11,r14

 15697 +	stm r9,r1,r5,r9,r12-r15

 15698 +	.text

 15699 +	.global stm_pu

 15700 +stm_pu:

 15701 +	stm --pc,r4-r6

 15702 +	stm --r12,r0-r15

 15703 +	stm --r5,r15

 15704 +	stm --r4,r0-r14

 15705 +	stm --lr,r0

 15706 +	stm --r11,r0,r4-r9,r11-r15

 15707 +	stm --r11,r0,r3,r9-r10,r12,r14

 15708 +	stm --r6,r2,r8-r9,r13-r14

 15709 +	.text

 15710 +	.global stmts

 15711 +stmts:

 15712 +	stmts pc,r8

 15713 +	stmts r12,r0-r15

 15714 +	stmts r5,r15

 15715 +	stmts r4,r0-r14

 15716 +	stmts lr,r0

 15717 +	stmts r1,r0-r1,r3-r4,r6,r9-r10,r14-r15

 15718 +	stmts r3,r0,r6-r8,r10-r12

 15719 +	stmts r11,r0,r4,r6-r7,r9-r10,r12,r14-r15

 15720 +	.text

 15721 +	.global stmts_pu

 15722 +stmts_pu:

 15723 +	stmts --pc,r6-r8

 15724 +	stmts --r12,r0-r15

 15725 +	stmts --r5,r15

 15726 +	stmts --r4,r0-r14

 15727 +	stmts --lr,r0

 15728 +	stmts --r2,r0,r3-r4,r9-r10,r12-r13

 15729 +	stmts --r3,r0-r1,r14-r15

 15730 +	stmts --r0,r0,r2-r6,r10,r14

 15731 +	.text

 15732 +	.global ldins_h

 15733 +ldins_h:

 15734 +	ldins.h pc:b,pc[0]

 15735 +	ldins.h r12:t,r12[-2]

 15736 +	ldins.h r5:t,r5[-4096]

 15737 +	ldins.h r4:b,r4[4094]

 15738 +	ldins.h lr:t,lr[2]

 15739 +	ldins.h r0:t,lr[1930]

 15740 +	ldins.h r3:b,r7[-534]

 15741 +	ldins.h r2:b,r12[-2252]

 15742 +	.text

 15743 +	.global ldins_b

 15744 +ldins_b:

 15745 +	ldins.b pc:b,pc[0]

 15746 +	ldins.b r12:t,r12[-1]

 15747 +	ldins.b r5:u,r5[-2048]

 15748 +	ldins.b r4:l,r4[2047]

 15749 +	ldins.b lr:l,lr[1]

 15750 +	ldins.b r6:t,r4[-662]

 15751 +	ldins.b r5:b,r1[-151]

 15752 +	ldins.b r10:t,r11[-1923]

 15753 +	.text

 15754 +	.global ldswp_sh

 15755 +ldswp_sh:

 15756 +	ldswp.sh pc,pc[0]

 15757 +	ldswp.sh r12,r12[-2]

 15758 +	ldswp.sh r5,r5[-4096]

 15759 +	ldswp.sh r4,r4[4094]

 15760 +	ldswp.sh lr,lr[2]

 15761 +	ldswp.sh r9,r10[3848]

 15762 +	ldswp.sh r4,r12[-2040]

 15763 +	ldswp.sh r10,r2[3088]

 15764 +	.text

 15765 +	.global ldswp_uh

 15766 +ldswp_uh:

 15767 +	ldswp.uh pc,pc[0]

 15768 +	ldswp.uh r12,r12[-2]

 15769 +	ldswp.uh r5,r5[-4096]

 15770 +	ldswp.uh r4,r4[4094]

 15771 +	ldswp.uh lr,lr[2]

 15772 +	ldswp.uh r4,r9[3724]

 15773 +	ldswp.uh lr,sp[-1672]

 15774 +	ldswp.uh r8,r12[-3846]

 15775 +	.text

 15776 +	.global ldswp_w

 15777 +ldswp_w:

 15778 +	ldswp.w pc,pc[0]

 15779 +	ldswp.w r12,r12[-4]

 15780 +	ldswp.w r5,r5[-8192]

 15781 +	ldswp.w r4,r4[8188]

 15782 +	ldswp.w lr,lr[4]

 15783 +	ldswp.w sp,r7[1860]

 15784 +	ldswp.w pc,r5[-3324]

 15785 +	ldswp.w r12,r10[-3296]

 15786 +	.text

 15787 +	.global stswp_h

 15788 +stswp_h:

 15789 +	stswp.h pc[0],pc

 15790 +	stswp.h r12[-2],r12

 15791 +	stswp.h r5[-4096],r5

 15792 +	stswp.h r4[4094],r4

 15793 +	stswp.h lr[2],lr

 15794 +	stswp.h r7[64],r10

 15795 +	stswp.h r10[3024],r2

 15796 +	stswp.h r0[-2328],r10

 15797 +	.text

 15798 +	.global stswp_w

 15799 +stswp_w:

 15800 +	stswp.w pc[0],pc

 15801 +	stswp.w r12[-4],r12

 15802 +	stswp.w r5[-8192],r5

 15803 +	stswp.w r4[8188],r4

 15804 +	stswp.w lr[4],lr

 15805 +	stswp.w pc[1156],r8

 15806 +	stswp.w sp[7992],r10

 15807 +	stswp.w r8[-1172],r5

 15808 +	.text

 15809 +	.global and2

 15810 +and2:

 15811 +	and pc,pc,pc<<0

 15812 +	and r12,r12,r12<<31

 15813 +	and r5,r5,r5<<16

 15814 +	and r4,r4,r4<<15

 15815 +	and lr,lr,lr<<1

 15816 +	and r10,r2,r1<<1

 15817 +	and r12,r8,r11<<27

 15818 +	and r10,r7,r0<<3

 15819 +	.text

 15820 +	.global and3

 15821 +and3:

 15822 +	and pc,pc,pc>>0

 15823 +	and r12,r12,r12>>31

 15824 +	and r5,r5,r5>>16

 15825 +	and r4,r4,r4>>15

 15826 +	and lr,lr,lr>>1

 15827 +	and r12,r8,r7>>17

 15828 +	and pc,r4,r9>>20

 15829 +	and r10,r9,r10>>12

 15830 +	.text

 15831 +	.global or2

 15832 +or2:

 15833 +	or pc,pc,pc<<0

 15834 +	or r12,r12,r12<<31

 15835 +	or r5,r5,r5<<16

 15836 +	or r4,r4,r4<<15

 15837 +	or lr,lr,lr<<1

 15838 +	or r8,sp,r11<<29

 15839 +	or pc,r9,r2<<28

 15840 +	or r5,r1,r2<<3

 15841 +	.text

 15842 +	.global or3

 15843 +or3:

 15844 +	or pc,pc,pc>>0

 15845 +	or r12,r12,r12>>31

 15846 +	or r5,r5,r5>>16

 15847 +	or r4,r4,r4>>15

 15848 +	or lr,lr,lr>>1

 15849 +	or r1,sp,sp>>2

 15850 +	or r0,r1,r1>>29

 15851 +	or r4,r12,r8>>8

 15852 +	.text

 15853 +	.global eor2

 15854 +eor2:

 15855 +	eor pc,pc,pc<<0

 15856 +	eor r12,r12,r12<<31

 15857 +	eor r5,r5,r5<<16

 15858 +	eor r4,r4,r4<<15

 15859 +	eor lr,lr,lr<<1

 15860 +	eor r10,r9,r4<<11

 15861 +	eor r4,r0,r1<<31

 15862 +	eor r6,r2,r12<<13

 15863 +	.text

 15864 +	.global eor3

 15865 +eor3:

 15866 +	eor pc,pc,pc>>0

 15867 +	eor r12,r12,r12>>31

 15868 +	eor r5,r5,r5>>16

 15869 +	eor r4,r4,r4>>15

 15870 +	eor lr,lr,lr>>1

 15871 +	eor r5,r5,r5>>22

 15872 +	eor r10,r1,lr>>3

 15873 +	eor r7,lr,sp>>26

 15874 +	.text

 15875 +	.global sthh_w2

 15876 +sthh_w2:

 15877 +	sthh.w pc[pc<<0],pc:b,pc:b

 15878 +	sthh.w r12[r12<<3],r12:t,r12:t

 15879 +	sthh.w r5[r5<<2],r5:t,r5:t

 15880 +	sthh.w r4[r4<<1],r4:b,r4:b

 15881 +	sthh.w lr[lr<<1],lr:t,lr:t

 15882 +	sthh.w sp[r6<<3],r1:t,r12:t

 15883 +	sthh.w r6[r6<<0],r9:t,r9:t

 15884 +	sthh.w r10[r3<<0],r0:b,r11:t

 15885 +	.text

 15886 +	.global sthh_w1

 15887 +sthh_w1:

 15888 +	sthh.w pc[0],pc:b,pc:b

 15889 +	sthh.w r12[1020],r12:t,r12:t

 15890 +	sthh.w r5[512],r5:t,r5:t

 15891 +	sthh.w r4[508],r4:b,r4:b

 15892 +	sthh.w lr[4],lr:t,lr:t

 15893 +	sthh.w r4[404],r9:t,r0:b

 15894 +	sthh.w r8[348],r2:t,r10:b

 15895 +	sthh.w sp[172],r9:b,r2:b

 15896 +	.text

 15897 +	.global cop

 15898 +cop:

 15899 +	cop cp0,cr0,cr0,cr0,0

 15900 +	cop cp7,cr15,cr15,cr15,0x7f

 15901 +	cop cp3,cr5,cr5,cr5,0x31

 15902 +	cop cp2,cr4,cr4,cr4,0x30

 15903 +	cop cp5,cr8,cr3,cr7,0x5a

 15904 +	.text

 15905 +	.global ldc_w1

 15906 +ldc_w1:

 15907 +	ldc.w cp0,cr0,r0[0]

 15908 +	ldc.w cp7,cr15,pc[255<<2]

 15909 +	ldc.w cp3,cr5,r5[128<<2]

 15910 +	ldc.w cp2,cr4,r4[127<<2]

 15911 +	ldc.w cp4,cr9,r13[36<<2]

 15912 +	.text

 15913 +	.global ldc_w2

 15914 +ldc_w2:

 15915 +	ldc.w cp0,cr0,--r0

 15916 +	ldc.w cp7,cr15,--pc

 15917 +	ldc.w cp3,cr5,--r5

 15918 +	ldc.w cp2,cr4,--r4

 15919 +	ldc.w cp4,cr9,--r13

 15920 +	.text

 15921 +	.global ldc_w3

 15922 +ldc_w3:

 15923 +	ldc.w cp0,cr0,r0[r0]

 15924 +	ldc.w cp7,cr15,pc[pc<<3]

 15925 +	ldc.w cp3,cr5,r5[r4<<2]

 15926 +	ldc.w cp2,cr4,r4[r3<<1]

 15927 +	ldc.w cp4,cr9,r13[r12<<0]

 15928 +	.text

 15929 +	.global ldc_d1

 15930 +ldc_d1:

 15931 +	ldc.d cp0,cr0,r0[0]

 15932 +	ldc.d cp7,cr14,pc[255<<2]

 15933 +	ldc.d cp3,cr6,r5[128<<2]

 15934 +	ldc.d cp2,cr4,r4[127<<2]

 15935 +	ldc.d cp4,cr8,r13[36<<2]

 15936 +	.text

 15937 +	.global ldc_d2

 15938 +ldc_d2:

 15939 +	ldc.d cp0,cr0,--r0

 15940 +	ldc.d cp7,cr14,--pc

 15941 +	ldc.d cp3,cr6,--r5

 15942 +	ldc.d cp2,cr4,--r4

 15943 +	ldc.d cp4,cr8,--r13

 15944 +	.text

 15945 +	.global ldc_d3

 15946 +ldc_d3:

 15947 +	ldc.d cp0,cr0,r0[r0]

 15948 +	ldc.d cp7,cr14,pc[pc<<3]

 15949 +	ldc.d cp3,cr6,r5[r4<<2]

 15950 +	ldc.d cp2,cr4,r4[r3<<1]

 15951 +	ldc.d cp4,cr8,r13[r12<<0]

 15952 +	.text

 15953 +	.global stc_w1

 15954 +stc_w1:

 15955 +	stc.w cp0,r0[0],cr0

 15956 +	stc.w cp7,pc[255<<2],cr15

 15957 +	stc.w cp3,r5[128<<2],cr5

 15958 +	stc.w cp2,r4[127<<2],cr4

 15959 +	stc.w cp4,r13[36<<2],cr9

 15960 +	.text

 15961 +	.global stc_w2

 15962 +stc_w2:

 15963 +	stc.w cp0,r0++,cr0

 15964 +	stc.w cp7,pc++,cr15

 15965 +	stc.w cp3,r5++,cr5

 15966 +	stc.w cp2,r4++,cr4

 15967 +	stc.w cp4,r13++,cr9

 15968 +	.text

 15969 +	.global stc_w3

 15970 +stc_w3:

 15971 +	stc.w cp0,r0[r0],cr0

 15972 +	stc.w cp7,pc[pc<<3],cr15

 15973 +	stc.w cp3,r5[r4<<2],cr5

 15974 +	stc.w cp2,r4[r3<<1],cr4

 15975 +	stc.w cp4,r13[r12<<0],cr9

 15976 +	.text

 15977 +	.global stc_d1

 15978 +stc_d1:

 15979 +	stc.d cp0,r0[0],cr0

 15980 +	stc.d cp7,pc[255<<2],cr14

 15981 +	stc.d cp3,r5[128<<2],cr6

 15982 +	stc.d cp2,r4[127<<2],cr4

 15983 +	stc.d cp4,r13[36<<2],cr8

 15984 +	.text

 15985 +	.global stc_d2

 15986 +stc_d2:

 15987 +	stc.d cp0,r0++,cr0

 15988 +	stc.d cp7,pc++,cr14

 15989 +	stc.d cp3,r5++,cr6

 15990 +	stc.d cp2,r4++,cr4

 15991 +	stc.d cp4,r13++,cr8

 15992 +	.text

 15993 +	.global stc_d3

 15994 +stc_d3:

 15995 +	stc.d cp0,r0[r0],cr0

 15996 +	stc.d cp7,pc[pc<<3],cr14

 15997 +	stc.d cp3,r5[r4<<2],cr6

 15998 +	stc.d cp2,r4[r3<<1],cr4

 15999 +	stc.d cp4,r13[r12<<0],cr8

 16000 +	.text

 16001 +	.global ldc0_w

 16002 +ldc0_w:

 16003 +	ldc0.w cr0,r0[0]

 16004 +	ldc0.w cr15,pc[4095<<2]

 16005 +	ldc0.w cr5,r5[2048<<2]

 16006 +	ldc0.w cr4,r4[2047<<2]

 16007 +	ldc0.w cr9,r13[147<<2]

 16008 +	.text

 16009 +	.global ldc0_d

 16010 +ldc0_d:

 16011 +	ldc0.d cr0,r0[0]

 16012 +	ldc0.d cr14,pc[4095<<2]

 16013 +	ldc0.d cr6,r5[2048<<2]

 16014 +	ldc0.d cr4,r4[2047<<2]

 16015 +	ldc0.d cr8,r13[147<<2]

 16016 +	.text

 16017 +	.global stc0_w

 16018 +stc0_w:

 16019 +	stc0.w r0[0],cr0

 16020 +	stc0.w pc[4095<<2],cr15

 16021 +	stc0.w r5[2048<<2],cr5

 16022 +	stc0.w r4[2047<<2],cr4

 16023 +	stc0.w r13[147<<2],cr9

 16024 +	.text

 16025 +	.global stc0_d

 16026 +stc0_d:

 16027 +	stc0.d r0[0],cr0

 16028 +	stc0.d pc[4095<<2],cr14

 16029 +	stc0.d r5[2048<<2],cr6

 16030 +	stc0.d r4[2047<<2],cr4

 16031 +	stc0.d r13[147<<2],cr8

 16032 +	.text

 16033 +	.global memc

 16034 +memc:

 16035 +	memc 0, 0

 16036 +	memc -4, 31

 16037 +	memc -65536, 16

 16038 +	memc 65532, 15

 16039 +	.text

 16040 +	.global mems

 16041 +mems:

 16042 +	mems 0, 0

 16043 +	mems -4, 31

 16044 +	mems -65536, 16

 16045 +	mems 65532, 15

 16046 +	.text

 16047 +	.global memt

 16048 +memt:

 16049 +	memt 0, 0

 16050 +	memt -4, 31

 16051 +	memt -65536, 16

 16052 +	memt 65532, 15

 16053 +

 16054 +	.text

 16055 +	.global stcond

 16056 +stcond:

 16057 +	stcond r0[0], r0

 16058 +	stcond pc[-1], pc

 16059 +	stcond r8[-32768], r7

 16060 +	stcond r7[32767], r8

 16061 +	stcond r5[0x1234], r10

 16062 +

 16063 +ldcm_w:

 16064 +	ldcm.w cp0,pc,cr0-cr7

 16065 +	ldcm.w cp7,r0,cr0

 16066 +	ldcm.w cp4,r4++,cr0-cr6

 16067 +	ldcm.w cp3,r7,cr7

 16068 +	ldcm.w cp1,r12++,cr1,cr4-cr6

 16069 +	ldcm.w cp0,pc,cr8-cr15

 16070 +	ldcm.w cp7,r0,cr8

 16071 +	ldcm.w cp4,r4++,cr8-cr14

 16072 +	ldcm.w cp3,r7,cr15

 16073 +	ldcm.w cp1,r12++,cr9,cr12-cr14

 16074 +

 16075 +ldcm_d:

 16076 +	ldcm.d cp0,pc,cr0-cr15

 16077 +	ldcm.d cp7,r0,cr0,cr1

 16078 +	ldcm.d cp4,r4++,cr0-cr13

 16079 +	ldcm.d cp3,r7,cr14-cr15

 16080 +	ldcm.d cp2,r12++,cr0-cr3,cr8-cr9,cr14-cr15

 16081 +

 16082 +stcm_w:

 16083 +	stcm.w cp0,pc,cr0-cr7

 16084 +	stcm.w cp7,r0,cr0

 16085 +	stcm.w cp4,--r4,cr0-cr6

 16086 +	stcm.w cp3,r7,cr7

 16087 +	stcm.w cp1,--r12,cr1,cr4-cr6

 16088 +	stcm.w cp0,pc,cr8-cr15

 16089 +	stcm.w cp7,r0,cr8

 16090 +	stcm.w cp4,--r4,cr8-cr14

 16091 +	stcm.w cp3,r7,cr15

 16092 +	stcm.w cp1,--r12,cr9,cr12-cr14

 16093 +

 16094 +stcm_d:

 16095 +	stcm.d cp0,pc,cr0-cr15

 16096 +	stcm.d cp7,r0,cr0,cr1

 16097 +	stcm.d cp4,--r4,cr0-cr13

 16098 +	stcm.d cp3,r7,cr14-cr15

 16099 +	stcm.d cp2,--r12,cr0-cr3,cr8-cr9,cr14-cr15

 16100 +

 16101 +mvcr_w:

 16102 +	mvcr.w cp7,pc,cr15

 16103 +	mvcr.w cp0,r0,cr0

 16104 +	mvcr.w cp0,pc,cr15

 16105 +	mvcr.w cp7,r0,cr15

 16106 +	mvcr.w cp7,pc,cr0

 16107 +	mvcr.w cp4,r7,cr8

 16108 +	mvcr.w cp3,r8,cr7

 16109 +

 16110 +mvcr_d:

 16111 +	mvcr.d cp7,lr,cr14

 16112 +	mvcr.d cp0,r0,cr0

 16113 +	mvcr.d cp0,lr,cr14

 16114 +	mvcr.d cp7,r0,cr14

 16115 +	mvcr.d cp7,lr,cr0

 16116 +	mvcr.d cp4,r6,cr8

 16117 +	mvcr.d cp3,r8,cr6

 16118 +

 16119 +mvrc_w:

 16120 +	mvrc.w cp7,cr15,pc

 16121 +	mvrc.w cp0,cr0,r0

 16122 +	mvrc.w cp0,cr15,pc

 16123 +	mvrc.w cp7,cr15,r0

 16124 +	mvrc.w cp7,cr0,pc

 16125 +	mvrc.w cp4,cr8,r7

 16126 +	mvrc.w cp3,cr7,r8

 16127 +

 16128 +mvrc_d:

 16129 +	mvrc.d cp7,cr14,lr

 16130 +	mvrc.d cp0,cr0,r0

 16131 +	mvrc.d cp0,cr14,lr

 16132 +	mvrc.d cp7,cr14,r0

 16133 +	mvrc.d cp7,cr0,lr

 16134 +	mvrc.d cp4,cr8,r6

 16135 +	mvrc.d cp3,cr6,r8

 16136 +

 16137 +bfexts:

 16138 +	bfexts pc,pc,31,31

 16139 +	bfexts r0,r0,0,0

 16140 +	bfexts r0,pc,31,31

 16141 +	bfexts pc,r0,31,31

 16142 +	bfexts pc,pc,0,31

 16143 +	bfexts pc,pc,31,0

 16144 +	bfexts r7,r8,15,16

 16145 +	bfexts r8,r7,16,15

 16146 +

 16147 +bfextu:

 16148 +	bfextu pc,pc,31,31

 16149 +	bfextu r0,r0,0,0

 16150 +	bfextu r0,pc,31,31

 16151 +	bfextu pc,r0,31,31

 16152 +	bfextu pc,pc,0,31

 16153 +	bfextu pc,pc,31,0

 16154 +	bfextu r7,r8,15,16

 16155 +	bfextu r8,r7,16,15

 16156 +

 16157 +bfins:

 16158 +	bfins pc,pc,31,31

 16159 +	bfins r0,r0,0,0

 16160 +	bfins r0,pc,31,31

 16161 +	bfins pc,r0,31,31

 16162 +	bfins pc,pc,0,31

 16163 +	bfins pc,pc,31,0

 16164 +	bfins r7,r8,15,16

 16165 +	bfins r8,r7,16,15

 16166 +

 16167 +rsubc:

 16168 +	rsubeq pc,0

 16169 +	rsubal r12,-1

 16170 +	rsubls r5,-128

 16171 +	rsubpl r4,127

 16172 +	rsubne lr,1

 16173 +	rsubls r12,118

 16174 +	rsubvc lr,-12

 16175 +	rsubmi r4,-13

 16176 +

 16177 +addc:

 16178 +	addeq pc,pc,pc

 16179 +	addal r12,r12,r12

 16180 +	addls r5,r5,r5

 16181 +	addpl r4,r4,r4

 16182 +	addne lr,lr,lr

 16183 +	addls r10,r2,r1

 16184 +	addvc r12,r8,r11

 16185 +	addmi r10,r7,r0

 16186 +

 16187 +subc2:

 16188 +	subeq pc,pc,pc

 16189 +	subal r12,r12,r12

 16190 +	subls r5,r5,r5

 16191 +	subpl r4,r4,r4

 16192 +	subne lr,lr,lr

 16193 +	subls r10,r2,r1

 16194 +	subvc r12,r8,r11

 16195 +	submi r10,r7,r0

 16196 +

 16197 +andc:

 16198 +	andeq pc,pc,pc

 16199 +	andal r12,r12,r12

 16200 +	andls r5,r5,r5

 16201 +	andpl r4,r4,r4

 16202 +	andne lr,lr,lr

 16203 +	andls r10,r2,r1

 16204 +	andvc r12,r8,r11

 16205 +	andmi r10,r7,r0

 16206 +

 16207 +orc:

 16208 +	oreq pc,pc,pc

 16209 +	oral r12,r12,r12

 16210 +	orls r5,r5,r5

 16211 +	orpl r4,r4,r4

 16212 +	orne lr,lr,lr

 16213 +	orls r10,r2,r1

 16214 +	orvc r12,r8,r11

 16215 +	ormi r10,r7,r0

 16216 +

 16217 +eorc:

 16218 +	eoreq pc,pc,pc

 16219 +	eoral r12,r12,r12

 16220 +	eorls r5,r5,r5

 16221 +	eorpl r4,r4,r4

 16222 +	eorne lr,lr,lr

 16223 +	eorls r10,r2,r1

 16224 +	eorvc r12,r8,r11

 16225 +	eormi r10,r7,r0

 16226 +

 16227 +ldcond:

 16228 +	ld.weq  pc,pc[2044]

 16229 +	ld.shal r12,r12[1022]

 16230 +	ld.uhls r5,r5[0]

 16231 +	ld.ubpl r4,r4[511]

 16232 +	ld.sbne lr,lr[0]

 16233 +	ld.wls  r10,r2[0]

 16234 +	ld.shvc r12,r8[0x3fe]

 16235 +	ld.ubmi r10,r7[1]

 16236 +

 16237 +stcond2:

 16238 +	st.weq pc[2044],pc

 16239 +	st.hal r12[1022],r12

 16240 +	st.hls r5[0],r5

 16241 +	st.bpl r4[511],r4

 16242 +	st.bne lr[0],lr

 16243 +	st.wls r2[0],r10

 16244 +	st.hvc r8[0x3fe],r12

 16245 +	st.bmi r7[1],r10

 16246 +

 16247 +movh:

 16248 +	movh	pc, 65535

 16249 +	movh	r0, 0

 16250 +	movh	r5, 1

 16251 +	movh	r12, 32767

 16252 +

 16253 +

 16254 --- /dev/null

 16255 +++ b/gas/testsuite/gas/avr32/avr32.exp

 16256 @@ -0,0 +1,23 @@

 16257 +# AVR32 assembler testsuite. -*- Tcl -*-

 16258 +

 16259 +if [istarget avr32-*-*] {

 16260 +    run_dump_test "hwrd-lwrd"

 16261 +    run_dump_test "pcrel"

 16262 +    run_dump_test "aliases"

 16263 +    run_dump_test "dwarf2"

 16264 +    run_dump_test "pic_reloc"

 16265 +    run_dump_test "fpinsn"

 16266 +    run_dump_test "pico"

 16267 +    run_dump_test "lda_pic"

 16268 +    run_dump_test "lda_pic_linkrelax"

 16269 +    run_dump_test "lda_nopic"

 16270 +    run_dump_test "lda_nopic_linkrelax"

 16271 +    run_dump_test "call_pic"

 16272 +    run_dump_test "call_pic_linkrelax"

 16273 +    run_dump_test "call_nopic"

 16274 +    run_dump_test "call_nopic_linkrelax"

 16275 +    run_dump_test "jmptable"

 16276 +    run_dump_test "jmptable_linkrelax"

 16277 +    run_dump_test "symdiff"

 16278 +    run_dump_test "symdiff_linkrelax"

 16279 +}

 16280 --- /dev/null

 16281 +++ b/gas/testsuite/gas/avr32/call_nopic.d

 16282 @@ -0,0 +1,36 @@

 16283 +#source: call.s

 16284 +#as:

 16285 +#objdump: -dr

 16286 +#name: call_nopic

 16287 +

 16288 +.*: +file format .*

 16289 +

 16290 +Disassembly of section \.text:

 16291 +

 16292 +00000000 <call_test>:

 16293 +       0:	d7 03       	nop

 16294 +

 16295 +00000002 <toofar_negative>:

 16296 +	\.\.\.

 16297 +  1ffffe:	00 00       	add r0,r0

 16298 +  200000:	f0 a0 00 00 	rcall 0 <call_test>

 16299 +  200004:	f0 1f 00 0c 	mcall 200034 <toofar_negative\+0x200032>

 16300 +  200008:	f0 1f 00 0c 	mcall 200038 <toofar_negative\+0x200036>

 16301 +  20000c:	f0 1f 00 0c 	mcall 20003c <toofar_negative\+0x20003a>

 16302 +  200010:	f0 1f 00 0c 	mcall 200040 <toofar_negative\+0x20003e>

 16303 +	\.\.\.

 16304 +  200030:	ee b0 ff ff 	rcall 40002e <far_positive>

 16305 +	\.\.\.

 16306 +			200034: R_AVR32_32_CPENT	\.text\+0x2

 16307 +			200038: R_AVR32_32_CPENT	\.text\.init

 16308 +			20003c: R_AVR32_32_CPENT	undefined

 16309 +			200040: R_AVR32_32_CPENT	\.text\+0x40002c

 16310 +

 16311 +0040002c <toofar_positive>:

 16312 +  40002c:	d7 03       	nop

 16313 +0040002e <far_positive>:

 16314 +  40002e:	d7 03       	nop

 16315 +Disassembly of section \.text\.init:

 16316 +

 16317 +00000000 <different_section>:

 16318 +   0:	e2 c0 00 00 	sub r0,r1,0

 16319 --- /dev/null

 16320 +++ b/gas/testsuite/gas/avr32/call_nopic_linkrelax.d

 16321 @@ -0,0 +1,43 @@

 16322 +#source: call.s

 16323 +#as: --linkrelax

 16324 +#objdump: -dr

 16325 +#name: call_nopic_linkrelax

 16326 +

 16327 +.*: +file format .*

 16328 +

 16329 +Disassembly of section \.text:

 16330 +

 16331 +00000000 <call_test>:

 16332 +       0:	d7 03       	nop

 16333 +

 16334 +00000002 <toofar_negative>:

 16335 +	\.\.\.

 16336 +  1ffffe:	00 00       	add r0,r0

 16337 +  200000:	e0 a0 00 00 	rcall 200000 <toofar_negative\+0x1ffffe>

 16338 +			200000: R_AVR32_22H_PCREL	\.text

 16339 +  200004:	f0 1f 00 00 	mcall 200004 <toofar_negative\+0x200002>

 16340 +			200004: R_AVR32_CPCALL	\.text\+0x200034

 16341 +  200008:	f0 1f 00 00 	mcall 200008 <toofar_negative\+0x200006>

 16342 +			200008: R_AVR32_CPCALL	\.text\+0x200038

 16343 +  20000c:	f0 1f 00 00 	mcall 20000c <toofar_negative\+0x20000a>

 16344 +			20000c: R_AVR32_CPCALL	\.text\+0x20003c

 16345 +  200010:	f0 1f 00 00 	mcall 200010 <toofar_negative\+0x20000e>

 16346 +			200010: R_AVR32_CPCALL	\.text\+0x200040

 16347 +	\.\.\.

 16348 +  200030:	e0 a0 00 00 	rcall 200030 <toofar_negative\+0x20002e>

 16349 +			200030: R_AVR32_22H_PCREL	\.text\+0x40002e

 16350 +	\.\.\.

 16351 +			200034: R_AVR32_ALIGN	\*ABS\*\+0x2

 16352 +			200034: R_AVR32_32_CPENT	\.text\+0x2

 16353 +			200038: R_AVR32_32_CPENT	\.text\.init

 16354 +			20003c: R_AVR32_32_CPENT	undefined

 16355 +			200040: R_AVR32_32_CPENT	\.text\+0x40002c

 16356 +

 16357 +0040002c <toofar_positive>:

 16358 +  40002c:	d7 03       	nop

 16359 +0040002e <far_positive>:

 16360 +  40002e:	d7 03       	nop

 16361 +Disassembly of section \.text\.init:

 16362 +

 16363 +00000000 <different_section>:

 16364 +   0:	e2 c0 00 00 	sub r0,r1,0

 16365 --- /dev/null

 16366 +++ b/gas/testsuite/gas/avr32/call_pic.d

 16367 @@ -0,0 +1,36 @@

 16368 +#source: call.s

 16369 +#as: --pic

 16370 +#objdump: -dr

 16371 +#name: call_pic

 16372 +

 16373 +.*: +file format .*

 16374 +

 16375 +Disassembly of section \.text:

 16376 +

 16377 +00000000 <call_test>:

 16378 +       0:	d7 03       	nop

 16379 +

 16380 +00000002 <toofar_negative>:

 16381 +	\.\.\.

 16382 +  1ffffe:	00 00       	add r0,r0

 16383 +  200000:	f0 a0 00 00 	rcall 0 <call_test>

 16384 +  200004:	f0 16 00 00 	mcall r6\[0\]

 16385 +			200004: R_AVR32_GOT18SW	toofar_negative

 16386 +  200008:	f0 16 00 00 	mcall r6\[0\]

 16387 +			200008: R_AVR32_GOT18SW	different_section

 16388 +  20000c:	f0 16 00 00 	mcall r6\[0\]

 16389 +			20000c: R_AVR32_GOT18SW	undefined

 16390 +  200010:	f0 16 00 00 	mcall r6\[0\]

 16391 +			200010: R_AVR32_GOT18SW	toofar_positive

 16392 +	\.\.\.

 16393 +  200030:	ee b0 ff ff 	rcall 40002e <far_positive>

 16394 +	\.\.\.

 16395 +

 16396 +0040002c <toofar_positive>:

 16397 +  40002c:	d7 03       	nop

 16398 +0040002e <far_positive>:

 16399 +  40002e:	d7 03       	nop

 16400 +Disassembly of section \.text\.init:

 16401 +

 16402 +00000000 <different_section>:

 16403 +   0:	e2 c0 00 00 	sub r0,r1,0

 16404 --- /dev/null

 16405 +++ b/gas/testsuite/gas/avr32/call_pic_linkrelax.d

 16406 @@ -0,0 +1,47 @@

 16407 +#source: call.s

 16408 +#as: --pic --linkrelax

 16409 +#objdump: -dr

 16410 +#name: call_pic_linkrelax

 16411 +

 16412 +.*: +file format .*

 16413 +

 16414 +Disassembly of section \.text:

 16415 +

 16416 +00000000 <call_test>:

 16417 +       0:	d7 03       	nop

 16418 +

 16419 +00000002 <toofar_negative>:

 16420 +	\.\.\.

 16421 +  1ffffe:	00 00       	add r0,r0

 16422 +  200000:	e0 a0 00 00 	rcall 200000 <toofar_negative\+0x1ffffe>

 16423 +			200000: R_AVR32_22H_PCREL	\.text

 16424 +  200004:	e0 6e 00 00 	mov lr,0

 16425 +			200004: R_AVR32_GOTCALL	toofar_negative

 16426 +  200008:	ec 0e 03 2e 	ld\.w lr,r6\[lr<<0x2\]

 16427 +  20000c:	5d 1e       	icall lr

 16428 +  20000e:	e0 6e 00 00 	mov lr,0

 16429 +			20000e: R_AVR32_GOTCALL	different_section

 16430 +  200012:	ec 0e 03 2e 	ld\.w lr,r6\[lr<<0x2\]

 16431 +  200016:	5d 1e       	icall lr

 16432 +  200018:	e0 6e 00 00 	mov lr,0

 16433 +			200018: R_AVR32_GOTCALL	undefined

 16434 +  20001c:	ec 0e 03 2e 	ld\.w lr,r6\[lr<<0x2\]

 16435 +  200020:	5d 1e       	icall lr

 16436 +  200022:	e0 6e 00 00 	mov lr,0

 16437 +			200022: R_AVR32_GOTCALL	toofar_positive

 16438 +  200026:	ec 0e 03 2e 	ld\.w lr,r6\[lr<<0x2\]

 16439 +  20002a:	5d 1e       	icall lr

 16440 +  20002c:	00 00       	add r0,r0

 16441 +  20002e:	00 00       	add r0,r0

 16442 +  200030:	e0 a0 00 00 	rcall 200030 <toofar_negative\+0x20002e>

 16443 +			200030: R_AVR32_22H_PCREL	\.text\+0x40002e

 16444 +	\.\.\.

 16445 +

 16446 +0040002c <toofar_positive>:

 16447 +  40002c:	d7 03       	nop

 16448 +0040002e <far_positive>:

 16449 +  40002e:	d7 03       	nop

 16450 +Disassembly of section \.text\.init:

 16451 +

 16452 +00000000 <different_section>:

 16453 +   0:	e2 c0 00 00 	sub r0,r1,0

 16454 --- /dev/null

 16455 +++ b/gas/testsuite/gas/avr32/call.s

 16456 @@ -0,0 +1,30 @@

 16457 +

 16458 +	.text

 16459 +	.global call_test

 16460 +call_test:

 16461 +far_negative:

 16462 +	nop

 16463 +toofar_negative:

 16464 +

 16465 +	.org	0x200000

 16466 +

 16467 +	call	far_negative

 16468 +	call	toofar_negative

 16469 +	call	different_section

 16470 +	call	undefined

 16471 +	call	toofar_positive

 16472 +	.org	0x200030

 16473 +	call	far_positive

 16474 +

 16475 +	.cpool

 16476 +

 16477 +	.org	0x40002c

 16478 +

 16479 +toofar_positive:

 16480 +	nop

 16481 +far_positive:

 16482 +	nop

 16483 +

 16484 +	.section .text.init,"ax",@progbits

 16485 +different_section:

 16486 +	sub	r0, r1, 0

 16487 --- /dev/null

 16488 +++ b/gas/testsuite/gas/avr32/dwarf2.d

 16489 @@ -0,0 +1,42 @@

 16490 +#readelf: -wl

 16491 +#name: dwarf2

 16492 +#source: dwarf2.s

 16493 +

 16494 +Dump of debug contents of section \.debug_line:

 16495 +

 16496 +  Length:                      53

 16497 +  DWARF Version:               2

 16498 +  Prologue Length:             26

 16499 +  Minimum Instruction Length:  1

 16500 +  Initial value of 'is_stmt':  1

 16501 +  Line Base:                   -5

 16502 +  Line Range:                  14

 16503 +  Opcode Base:                 10

 16504 +  \(Pointer size:               4\)

 16505 +

 16506 + Opcodes:

 16507 +  Opcode 1 has 0 args

 16508 +  Opcode 2 has 1 args

 16509 +  Opcode 3 has 1 args

 16510 +  Opcode 4 has 1 args

 16511 +  Opcode 5 has 1 args

 16512 +  Opcode 6 has 0 args

 16513 +  Opcode 7 has 0 args

 16514 +  Opcode 8 has 0 args

 16515 +  Opcode 9 has 1 args

 16516 +

 16517 + The Directory Table is empty\.

 16518 +

 16519 + The File Name Table:

 16520 +  Entry	Dir	Time	Size	Name

 16521 +  1	0	0	0	main\.c

 16522 +

 16523 + Line Number Statements:

 16524 +  Extended opcode 2: set Address to 0x0

 16525 +  Advance Line by 87 to 88

 16526 +  Copy

 16527 +  Advance Line by 23 to 111

 16528 +  Special opcode .*: advance Address by 4 to 0x4 and Line by 0 to 111

 16529 +  Special opcode .*: advance Address by 10 to 0xe and Line by 1 to 112

 16530 +  Advance PC by 530 to 220

 16531 +  Extended opcode 1: End of Sequence

 16532 --- /dev/null

 16533 +++ b/gas/testsuite/gas/avr32/dwarf2.s

 16534 @@ -0,0 +1,67 @@

 16535 +# Source file used to test DWARF2 information for AVR32.

 16536 +

 16537 +	.file	"main.c"

 16538 +

 16539 +	.section .debug_abbrev,"",@progbits

 16540 +.Ldebug_abbrev0:

 16541 +	.section .debug_info,"",@progbits

 16542 +.Ldebug_info0:

 16543 +	.section .debug_line,"",@progbits

 16544 +.Ldebug_line0:

 16545 +

 16546 +	.text

 16547 +	.align	1

 16548 +	.globl	main

 16549 +	.type	main, @function

 16550 +.Ltext0:

 16551 +main:

 16552 +	.file 1 "main.c"

 16553 +	.loc 1 88 0

 16554 +	pushm	r0-r7,lr

 16555 +	sub	sp, 4

 16556 +	.loc 1 111 0

 16557 +	lddpc	r12, .LC1

 16558 +	lddpc	r7, .LC1

 16559 +	icall	r7

 16560 +	.loc 1 112 0

 16561 +	lddpc	r6, .LC4

 16562 +

 16563 +	.align	2

 16564 +.LC4:	.int	0

 16565 +

 16566 +	.fill	256, 2, 0

 16567 +

 16568 +	.align	2

 16569 +.LC1:

 16570 +	.int	0

 16571 +.LC2:

 16572 +	.int	0

 16573 +.LC3:

 16574 +	.int	0

 16575 +	.size	main, . - main

 16576 +

 16577 +.Letext0:

 16578 +

 16579 +	.section .debug_info

 16580 +	.int	.Ledebug_info0 - .Ldebug_info0	// size

 16581 +	.short	2				// version

 16582 +	.int	.Ldebug_abbrev0			// abbrev offset

 16583 +	.byte	4				// bytes per addr

 16584 +

 16585 +	.uleb128 1				// abbrev 1

 16586 +	.int	.Ldebug_line0			// DW_AT_stmt_list

 16587 +	.int	.Letext0			// DW_AT_high_pc

 16588 +	.int	.Ltext0				// DW_AT_low_pc

 16589 +

 16590 +.Ledebug_info0:

 16591 +

 16592 +	.section .debug_abbrev

 16593 +	.uleb128 0x01

 16594 +	.uleb128 0x11		// DW_TAG_compile_unit

 16595 +	.byte	0		// DW_CHILDREN_no

 16596 +	.uleb128 0x10, 0x6	// DW_AT_stmt_list

 16597 +	.uleb128 0x12, 0x1	// DW_AT_high_pc

 16598 +	.uleb128 0x11, 0x1	// DW_AT_low_pc

 16599 +	.uleb128 0, 0

 16600 +

 16601 +	.byte	0

 16602 --- /dev/null

 16603 +++ b/gas/testsuite/gas/avr32/fpinsn.d

 16604 @@ -0,0 +1,271 @@

 16605 +#as:

 16606 +#objdump: -dr

 16607 +#name: fpinsn

 16608 +

 16609 +.*: +file format .*

 16610 +

 16611 +Disassembly of section \.text:

 16612 +

 16613 +[0-9a-f]* <fadd_s>:

 16614 + *[0-9a-f]*:	e1 a2 0f ff 	cop cp0,cr15,cr15,cr15,0x4

 16615 + *[0-9a-f]*:	e1 a2 00 00 	cop cp0,cr0,cr0,cr0,0x4

 16616 + *[0-9a-f]*:	e1 a2 00 ff 	cop cp0,cr0,cr15,cr15,0x4

 16617 + *[0-9a-f]*:	e1 a2 0f 0f 	cop cp0,cr15,cr0,cr15,0x4

 16618 + *[0-9a-f]*:	e1 a2 0f f0 	cop cp0,cr15,cr15,cr0,0x4

 16619 + *[0-9a-f]*:	e1 a2 07 88 	cop cp0,cr7,cr8,cr8,0x4

 16620 + *[0-9a-f]*:	e1 a2 08 78 	cop cp0,cr8,cr7,cr8,0x4

 16621 + *[0-9a-f]*:	e1 a2 08 87 	cop cp0,cr8,cr8,cr7,0x4

 16622 +

 16623 +[0-9a-f]* <fsub_s>:

 16624 + *[0-9a-f]*:	e1 a2 1f ff 	cop cp0,cr15,cr15,cr15,0x5

 16625 + *[0-9a-f]*:	e1 a2 10 00 	cop cp0,cr0,cr0,cr0,0x5

 16626 + *[0-9a-f]*:	e1 a2 10 ff 	cop cp0,cr0,cr15,cr15,0x5

 16627 + *[0-9a-f]*:	e1 a2 1f 0f 	cop cp0,cr15,cr0,cr15,0x5

 16628 + *[0-9a-f]*:	e1 a2 1f f0 	cop cp0,cr15,cr15,cr0,0x5

 16629 + *[0-9a-f]*:	e1 a2 17 88 	cop cp0,cr7,cr8,cr8,0x5

 16630 + *[0-9a-f]*:	e1 a2 18 78 	cop cp0,cr8,cr7,cr8,0x5

 16631 + *[0-9a-f]*:	e1 a2 18 87 	cop cp0,cr8,cr8,cr7,0x5

 16632 +

 16633 +[0-9a-f]* <fmac_s>:

 16634 + *[0-9a-f]*:	e1 a0 0f ff 	cop cp0,cr15,cr15,cr15,0x0

 16635 + *[0-9a-f]*:	e1 a0 00 00 	cop cp0,cr0,cr0,cr0,0x0

 16636 + *[0-9a-f]*:	e1 a0 00 ff 	cop cp0,cr0,cr15,cr15,0x0

 16637 + *[0-9a-f]*:	e1 a0 0f 0f 	cop cp0,cr15,cr0,cr15,0x0

 16638 + *[0-9a-f]*:	e1 a0 0f f0 	cop cp0,cr15,cr15,cr0,0x0

 16639 + *[0-9a-f]*:	e1 a0 07 88 	cop cp0,cr7,cr8,cr8,0x0

 16640 + *[0-9a-f]*:	e1 a0 08 78 	cop cp0,cr8,cr7,cr8,0x0

 16641 + *[0-9a-f]*:	e1 a0 08 87 	cop cp0,cr8,cr8,cr7,0x0

 16642 +

 16643 +[0-9a-f]* <fnmac_s>:

 16644 + *[0-9a-f]*:	e1 a0 1f ff 	cop cp0,cr15,cr15,cr15,0x1

 16645 + *[0-9a-f]*:	e1 a0 10 00 	cop cp0,cr0,cr0,cr0,0x1

 16646 + *[0-9a-f]*:	e1 a0 10 ff 	cop cp0,cr0,cr15,cr15,0x1

 16647 + *[0-9a-f]*:	e1 a0 1f 0f 	cop cp0,cr15,cr0,cr15,0x1

 16648 + *[0-9a-f]*:	e1 a0 1f f0 	cop cp0,cr15,cr15,cr0,0x1

 16649 + *[0-9a-f]*:	e1 a0 17 88 	cop cp0,cr7,cr8,cr8,0x1

 16650 + *[0-9a-f]*:	e1 a0 18 78 	cop cp0,cr8,cr7,cr8,0x1

 16651 + *[0-9a-f]*:	e1 a0 18 87 	cop cp0,cr8,cr8,cr7,0x1

 16652 +

 16653 +[0-9a-f]* <fmsc_s>:

 16654 + *[0-9a-f]*:	e1 a1 0f ff 	cop cp0,cr15,cr15,cr15,0x2

 16655 + *[0-9a-f]*:	e1 a1 00 00 	cop cp0,cr0,cr0,cr0,0x2

 16656 + *[0-9a-f]*:	e1 a1 00 ff 	cop cp0,cr0,cr15,cr15,0x2

 16657 + *[0-9a-f]*:	e1 a1 0f 0f 	cop cp0,cr15,cr0,cr15,0x2

 16658 + *[0-9a-f]*:	e1 a1 0f f0 	cop cp0,cr15,cr15,cr0,0x2

 16659 + *[0-9a-f]*:	e1 a1 07 88 	cop cp0,cr7,cr8,cr8,0x2

 16660 + *[0-9a-f]*:	e1 a1 08 78 	cop cp0,cr8,cr7,cr8,0x2

 16661 + *[0-9a-f]*:	e1 a1 08 87 	cop cp0,cr8,cr8,cr7,0x2

 16662 +

 16663 +[0-9a-f]* <fnmsc_s>:

 16664 + *[0-9a-f]*:	e1 a1 1f ff 	cop cp0,cr15,cr15,cr15,0x3

 16665 + *[0-9a-f]*:	e1 a1 10 00 	cop cp0,cr0,cr0,cr0,0x3

 16666 + *[0-9a-f]*:	e1 a1 10 ff 	cop cp0,cr0,cr15,cr15,0x3

 16667 + *[0-9a-f]*:	e1 a1 1f 0f 	cop cp0,cr15,cr0,cr15,0x3

 16668 + *[0-9a-f]*:	e1 a1 1f f0 	cop cp0,cr15,cr15,cr0,0x3

 16669 + *[0-9a-f]*:	e1 a1 17 88 	cop cp0,cr7,cr8,cr8,0x3

 16670 + *[0-9a-f]*:	e1 a1 18 78 	cop cp0,cr8,cr7,cr8,0x3

 16671 + *[0-9a-f]*:	e1 a1 18 87 	cop cp0,cr8,cr8,cr7,0x3

 16672 +

 16673 +[0-9a-f]* <fmul_s>:

 16674 + *[0-9a-f]*:	e1 a3 0f ff 	cop cp0,cr15,cr15,cr15,0x6

 16675 + *[0-9a-f]*:	e1 a3 00 00 	cop cp0,cr0,cr0,cr0,0x6

 16676 + *[0-9a-f]*:	e1 a3 00 ff 	cop cp0,cr0,cr15,cr15,0x6

 16677 + *[0-9a-f]*:	e1 a3 0f 0f 	cop cp0,cr15,cr0,cr15,0x6

 16678 + *[0-9a-f]*:	e1 a3 0f f0 	cop cp0,cr15,cr15,cr0,0x6

 16679 + *[0-9a-f]*:	e1 a3 07 88 	cop cp0,cr7,cr8,cr8,0x6

 16680 + *[0-9a-f]*:	e1 a3 08 78 	cop cp0,cr8,cr7,cr8,0x6

 16681 + *[0-9a-f]*:	e1 a3 08 87 	cop cp0,cr8,cr8,cr7,0x6

 16682 +

 16683 +[0-9a-f]* <fnmul_s>:

 16684 + *[0-9a-f]*:	e1 a3 1f ff 	cop cp0,cr15,cr15,cr15,0x7

 16685 + *[0-9a-f]*:	e1 a3 10 00 	cop cp0,cr0,cr0,cr0,0x7

 16686 + *[0-9a-f]*:	e1 a3 10 ff 	cop cp0,cr0,cr15,cr15,0x7

 16687 + *[0-9a-f]*:	e1 a3 1f 0f 	cop cp0,cr15,cr0,cr15,0x7

 16688 + *[0-9a-f]*:	e1 a3 1f f0 	cop cp0,cr15,cr15,cr0,0x7

 16689 + *[0-9a-f]*:	e1 a3 17 88 	cop cp0,cr7,cr8,cr8,0x7

 16690 + *[0-9a-f]*:	e1 a3 18 78 	cop cp0,cr8,cr7,cr8,0x7

 16691 + *[0-9a-f]*:	e1 a3 18 87 	cop cp0,cr8,cr8,cr7,0x7

 16692 +

 16693 +[0-9a-f]* <fneg_s>:

 16694 + *[0-9a-f]*:	e1 a4 0f f0 	cop cp0,cr15,cr15,cr0,0x8

 16695 + *[0-9a-f]*:	e1 a4 00 00 	cop cp0,cr0,cr0,cr0,0x8

 16696 + *[0-9a-f]*:	e1 a4 00 f0 	cop cp0,cr0,cr15,cr0,0x8

 16697 + *[0-9a-f]*:	e1 a4 0f 00 	cop cp0,cr15,cr0,cr0,0x8

 16698 + *[0-9a-f]*:	e1 a4 07 80 	cop cp0,cr7,cr8,cr0,0x8

 16699 + *[0-9a-f]*:	e1 a4 08 70 	cop cp0,cr8,cr7,cr0,0x8

 16700 +

 16701 +[0-9a-f]* <fabs_s>:

 16702 + *[0-9a-f]*:	e1 a4 1f f0 	cop cp0,cr15,cr15,cr0,0x9

 16703 + *[0-9a-f]*:	e1 a4 10 00 	cop cp0,cr0,cr0,cr0,0x9

 16704 + *[0-9a-f]*:	e1 a4 10 f0 	cop cp0,cr0,cr15,cr0,0x9

 16705 + *[0-9a-f]*:	e1 a4 1f 00 	cop cp0,cr15,cr0,cr0,0x9

 16706 + *[0-9a-f]*:	e1 a4 17 80 	cop cp0,cr7,cr8,cr0,0x9

 16707 + *[0-9a-f]*:	e1 a4 18 70 	cop cp0,cr8,cr7,cr0,0x9

 16708 +

 16709 +[0-9a-f]* <fcmp_s>:

 16710 + *[0-9a-f]*:	e1 a6 10 ff 	cop cp0,cr0,cr15,cr15,0xd

 16711 + *[0-9a-f]*:	e1 a6 10 00 	cop cp0,cr0,cr0,cr0,0xd

 16712 + *[0-9a-f]*:	e1 a6 10 0f 	cop cp0,cr0,cr0,cr15,0xd

 16713 + *[0-9a-f]*:	e1 a6 10 f0 	cop cp0,cr0,cr15,cr0,0xd

 16714 + *[0-9a-f]*:	e1 a6 10 78 	cop cp0,cr0,cr7,cr8,0xd

 16715 + *[0-9a-f]*:	e1 a6 10 87 	cop cp0,cr0,cr8,cr7,0xd

 16716 +

 16717 +[0-9a-f]* <fadd_d>:

 16718 + *[0-9a-f]*:	e5 a2 0e ee 	cop cp0,cr14,cr14,cr14,0x44

 16719 + *[0-9a-f]*:	e5 a2 00 00 	cop cp0,cr0,cr0,cr0,0x44

 16720 + *[0-9a-f]*:	e5 a2 00 ee 	cop cp0,cr0,cr14,cr14,0x44

 16721 + *[0-9a-f]*:	e5 a2 0e 0e 	cop cp0,cr14,cr0,cr14,0x44

 16722 + *[0-9a-f]*:	e5 a2 0e e0 	cop cp0,cr14,cr14,cr0,0x44

 16723 + *[0-9a-f]*:	e5 a2 06 88 	cop cp0,cr6,cr8,cr8,0x44

 16724 + *[0-9a-f]*:	e5 a2 08 68 	cop cp0,cr8,cr6,cr8,0x44

 16725 + *[0-9a-f]*:	e5 a2 08 86 	cop cp0,cr8,cr8,cr6,0x44

 16726 +

 16727 +[0-9a-f]* <fsub_d>:

 16728 + *[0-9a-f]*:	e5 a2 1e ee 	cop cp0,cr14,cr14,cr14,0x45

 16729 + *[0-9a-f]*:	e5 a2 10 00 	cop cp0,cr0,cr0,cr0,0x45

 16730 + *[0-9a-f]*:	e5 a2 10 ee 	cop cp0,cr0,cr14,cr14,0x45

 16731 + *[0-9a-f]*:	e5 a2 1e 0e 	cop cp0,cr14,cr0,cr14,0x45

 16732 + *[0-9a-f]*:	e5 a2 1e e0 	cop cp0,cr14,cr14,cr0,0x45

 16733 + *[0-9a-f]*:	e5 a2 16 88 	cop cp0,cr6,cr8,cr8,0x45

 16734 + *[0-9a-f]*:	e5 a2 18 68 	cop cp0,cr8,cr6,cr8,0x45

 16735 + *[0-9a-f]*:	e5 a2 18 86 	cop cp0,cr8,cr8,cr6,0x45

 16736 +

 16737 +[0-9a-f]* <fmac_d>:

 16738 + *[0-9a-f]*:	e5 a0 0e ee 	cop cp0,cr14,cr14,cr14,0x40

 16739 + *[0-9a-f]*:	e5 a0 00 00 	cop cp0,cr0,cr0,cr0,0x40

 16740 + *[0-9a-f]*:	e5 a0 00 ee 	cop cp0,cr0,cr14,cr14,0x40

 16741 + *[0-9a-f]*:	e5 a0 0e 0e 	cop cp0,cr14,cr0,cr14,0x40

 16742 + *[0-9a-f]*:	e5 a0 0e e0 	cop cp0,cr14,cr14,cr0,0x40

 16743 + *[0-9a-f]*:	e5 a0 06 88 	cop cp0,cr6,cr8,cr8,0x40

 16744 + *[0-9a-f]*:	e5 a0 08 68 	cop cp0,cr8,cr6,cr8,0x40

 16745 + *[0-9a-f]*:	e5 a0 08 86 	cop cp0,cr8,cr8,cr6,0x40

 16746 +

 16747 +[0-9a-f]* <fnmac_d>:

 16748 + *[0-9a-f]*:	e5 a0 1e ee 	cop cp0,cr14,cr14,cr14,0x41

 16749 + *[0-9a-f]*:	e5 a0 10 00 	cop cp0,cr0,cr0,cr0,0x41

 16750 + *[0-9a-f]*:	e5 a0 10 ee 	cop cp0,cr0,cr14,cr14,0x41

 16751 + *[0-9a-f]*:	e5 a0 1e 0e 	cop cp0,cr14,cr0,cr14,0x41

 16752 + *[0-9a-f]*:	e5 a0 1e e0 	cop cp0,cr14,cr14,cr0,0x41

 16753 + *[0-9a-f]*:	e5 a0 16 88 	cop cp0,cr6,cr8,cr8,0x41

 16754 + *[0-9a-f]*:	e5 a0 18 68 	cop cp0,cr8,cr6,cr8,0x41

 16755 + *[0-9a-f]*:	e5 a0 18 86 	cop cp0,cr8,cr8,cr6,0x41

 16756 +

 16757 +[0-9a-f]* <fmsc_d>:

 16758 + *[0-9a-f]*:	e5 a1 0e ee 	cop cp0,cr14,cr14,cr14,0x42

 16759 + *[0-9a-f]*:	e5 a1 00 00 	cop cp0,cr0,cr0,cr0,0x42

 16760 + *[0-9a-f]*:	e5 a1 00 ee 	cop cp0,cr0,cr14,cr14,0x42

 16761 + *[0-9a-f]*:	e5 a1 0e 0e 	cop cp0,cr14,cr0,cr14,0x42

 16762 + *[0-9a-f]*:	e5 a1 0e e0 	cop cp0,cr14,cr14,cr0,0x42

 16763 + *[0-9a-f]*:	e5 a1 06 88 	cop cp0,cr6,cr8,cr8,0x42

 16764 + *[0-9a-f]*:	e5 a1 08 68 	cop cp0,cr8,cr6,cr8,0x42

 16765 + *[0-9a-f]*:	e5 a1 08 86 	cop cp0,cr8,cr8,cr6,0x42

 16766 +

 16767 +[0-9a-f]* <fnmsc_d>:

 16768 + *[0-9a-f]*:	e5 a1 1e ee 	cop cp0,cr14,cr14,cr14,0x43

 16769 + *[0-9a-f]*:	e5 a1 10 00 	cop cp0,cr0,cr0,cr0,0x43

 16770 + *[0-9a-f]*:	e5 a1 10 ee 	cop cp0,cr0,cr14,cr14,0x43

 16771 + *[0-9a-f]*:	e5 a1 1e 0e 	cop cp0,cr14,cr0,cr14,0x43

 16772 + *[0-9a-f]*:	e5 a1 1e e0 	cop cp0,cr14,cr14,cr0,0x43

 16773 + *[0-9a-f]*:	e5 a1 16 88 	cop cp0,cr6,cr8,cr8,0x43

 16774 + *[0-9a-f]*:	e5 a1 18 68 	cop cp0,cr8,cr6,cr8,0x43

 16775 + *[0-9a-f]*:	e5 a1 18 86 	cop cp0,cr8,cr8,cr6,0x43

 16776 +

 16777 +[0-9a-f]* <fmul_d>:

 16778 + *[0-9a-f]*:	e5 a3 0e ee 	cop cp0,cr14,cr14,cr14,0x46

 16779 + *[0-9a-f]*:	e5 a3 00 00 	cop cp0,cr0,cr0,cr0,0x46

 16780 + *[0-9a-f]*:	e5 a3 00 ee 	cop cp0,cr0,cr14,cr14,0x46

 16781 + *[0-9a-f]*:	e5 a3 0e 0e 	cop cp0,cr14,cr0,cr14,0x46

 16782 + *[0-9a-f]*:	e5 a3 0e e0 	cop cp0,cr14,cr14,cr0,0x46

 16783 + *[0-9a-f]*:	e5 a3 06 88 	cop cp0,cr6,cr8,cr8,0x46

 16784 + *[0-9a-f]*:	e5 a3 08 68 	cop cp0,cr8,cr6,cr8,0x46

 16785 + *[0-9a-f]*:	e5 a3 08 86 	cop cp0,cr8,cr8,cr6,0x46

 16786 +

 16787 +[0-9a-f]* <fnmul_d>:

 16788 + *[0-9a-f]*:	e5 a3 1e ee 	cop cp0,cr14,cr14,cr14,0x47

 16789 + *[0-9a-f]*:	e5 a3 10 00 	cop cp0,cr0,cr0,cr0,0x47

 16790 + *[0-9a-f]*:	e5 a3 10 ee 	cop cp0,cr0,cr14,cr14,0x47

 16791 + *[0-9a-f]*:	e5 a3 1e 0e 	cop cp0,cr14,cr0,cr14,0x47

 16792 + *[0-9a-f]*:	e5 a3 1e e0 	cop cp0,cr14,cr14,cr0,0x47

 16793 + *[0-9a-f]*:	e5 a3 16 88 	cop cp0,cr6,cr8,cr8,0x47

 16794 + *[0-9a-f]*:	e5 a3 18 68 	cop cp0,cr8,cr6,cr8,0x47

 16795 + *[0-9a-f]*:	e5 a3 18 86 	cop cp0,cr8,cr8,cr6,0x47

 16796 +

 16797 +[0-9a-f]* <fneg_d>:

 16798 + *[0-9a-f]*:	e5 a4 0e e0 	cop cp0,cr14,cr14,cr0,0x48

 16799 + *[0-9a-f]*:	e5 a4 00 00 	cop cp0,cr0,cr0,cr0,0x48

 16800 + *[0-9a-f]*:	e5 a4 00 e0 	cop cp0,cr0,cr14,cr0,0x48

 16801 + *[0-9a-f]*:	e5 a4 0e 00 	cop cp0,cr14,cr0,cr0,0x48

 16802 + *[0-9a-f]*:	e5 a4 06 80 	cop cp0,cr6,cr8,cr0,0x48

 16803 + *[0-9a-f]*:	e5 a4 08 60 	cop cp0,cr8,cr6,cr0,0x48

 16804 +

 16805 +[0-9a-f]* <fabs_d>:

 16806 + *[0-9a-f]*:	e5 a4 1e e0 	cop cp0,cr14,cr14,cr0,0x49

 16807 + *[0-9a-f]*:	e5 a4 10 00 	cop cp0,cr0,cr0,cr0,0x49

 16808 + *[0-9a-f]*:	e5 a4 10 e0 	cop cp0,cr0,cr14,cr0,0x49

 16809 + *[0-9a-f]*:	e5 a4 1e 00 	cop cp0,cr14,cr0,cr0,0x49

 16810 + *[0-9a-f]*:	e5 a4 16 80 	cop cp0,cr6,cr8,cr0,0x49

 16811 + *[0-9a-f]*:	e5 a4 18 60 	cop cp0,cr8,cr6,cr0,0x49

 16812 +

 16813 +[0-9a-f]* <fcmp_d>:

 16814 + *[0-9a-f]*:	e5 a6 10 ee 	cop cp0,cr0,cr14,cr14,0x4d

 16815 + *[0-9a-f]*:	e5 a6 10 00 	cop cp0,cr0,cr0,cr0,0x4d

 16816 + *[0-9a-f]*:	e5 a6 10 0e 	cop cp0,cr0,cr0,cr14,0x4d

 16817 + *[0-9a-f]*:	e5 a6 10 e0 	cop cp0,cr0,cr14,cr0,0x4d

 16818 + *[0-9a-f]*:	e5 a6 10 68 	cop cp0,cr0,cr6,cr8,0x4d

 16819 + *[0-9a-f]*:	e5 a6 10 86 	cop cp0,cr0,cr8,cr6,0x4d

 16820 +

 16821 +[0-9a-f]* <fmov_s>:

 16822 + *[0-9a-f]*:	e1 a5 0f f0 	cop cp0,cr15,cr15,cr0,0xa

 16823 + *[0-9a-f]*:	e1 a5 00 00 	cop cp0,cr0,cr0,cr0,0xa

 16824 + *[0-9a-f]*:	e1 a5 0f 00 	cop cp0,cr15,cr0,cr0,0xa

 16825 + *[0-9a-f]*:	e1 a5 00 f0 	cop cp0,cr0,cr15,cr0,0xa

 16826 + *[0-9a-f]*:	e1 a5 08 70 	cop cp0,cr8,cr7,cr0,0xa

 16827 + *[0-9a-f]*:	e1 a5 07 80 	cop cp0,cr7,cr8,cr0,0xa

 16828 + *[0-9a-f]*:	ef af 0f 00 	mvcr.w cp0,pc,cr15

 16829 + *[0-9a-f]*:	ef a0 00 00 	mvcr.w cp0,r0,cr0

 16830 + *[0-9a-f]*:	ef af 00 00 	mvcr.w cp0,pc,cr0

 16831 + *[0-9a-f]*:	ef a0 0f 00 	mvcr.w cp0,r0,cr15

 16832 + *[0-9a-f]*:	ef a8 07 00 	mvcr.w cp0,r8,cr7

 16833 + *[0-9a-f]*:	ef a7 08 00 	mvcr.w cp0,r7,cr8

 16834 + *[0-9a-f]*:	ef af 0f 20 	mvrc.w cp0,cr15,pc

 16835 + *[0-9a-f]*:	ef a0 00 20 	mvrc.w cp0,cr0,r0

 16836 + *[0-9a-f]*:	ef a0 0f 20 	mvrc.w cp0,cr15,r0

 16837 + *[0-9a-f]*:	ef af 00 20 	mvrc.w cp0,cr0,pc

 16838 + *[0-9a-f]*:	ef a7 08 20 	mvrc.w cp0,cr8,r7

 16839 + *[0-9a-f]*:	ef a8 07 20 	mvrc.w cp0,cr7,r8

 16840 +

 16841 +[0-9a-f]* <fmov_d>:

 16842 + *[0-9a-f]*:	e5 a5 0e e0 	cop cp0,cr14,cr14,cr0,0x4a

 16843 + *[0-9a-f]*:	e5 a5 00 00 	cop cp0,cr0,cr0,cr0,0x4a

 16844 + *[0-9a-f]*:	e5 a5 0e 00 	cop cp0,cr14,cr0,cr0,0x4a

 16845 + *[0-9a-f]*:	e5 a5 00 e0 	cop cp0,cr0,cr14,cr0,0x4a

 16846 + *[0-9a-f]*:	e5 a5 08 60 	cop cp0,cr8,cr6,cr0,0x4a

 16847 + *[0-9a-f]*:	e5 a5 06 80 	cop cp0,cr6,cr8,cr0,0x4a

 16848 + *[0-9a-f]*:	ef ae 0e 10 	mvcr.d cp0,lr,cr14

 16849 + *[0-9a-f]*:	ef a0 00 10 	mvcr.d cp0,r0,cr0

 16850 + *[0-9a-f]*:	ef ae 00 10 	mvcr.d cp0,lr,cr0

 16851 + *[0-9a-f]*:	ef a0 0e 10 	mvcr.d cp0,r0,cr14

 16852 + *[0-9a-f]*:	ef a8 06 10 	mvcr.d cp0,r8,cr6

 16853 + *[0-9a-f]*:	ef a6 08 10 	mvcr.d cp0,r6,cr8

 16854 + *[0-9a-f]*:	ef ae 0e 30 	mvrc.d cp0,cr14,lr

 16855 + *[0-9a-f]*:	ef a0 00 30 	mvrc.d cp0,cr0,r0

 16856 + *[0-9a-f]*:	ef a0 0e 30 	mvrc.d cp0,cr14,r0

 16857 + *[0-9a-f]*:	ef ae 00 30 	mvrc.d cp0,cr0,lr

 16858 + *[0-9a-f]*:	ef a6 08 30 	mvrc.d cp0,cr8,r6

 16859 + *[0-9a-f]*:	ef a8 06 30 	mvrc.d cp0,cr6,r8

 16860 +

 16861 +[0-9a-f]* <fcasts_d>:

 16862 + *[0-9a-f]*:	e1 a7 1f e0 	cop cp0,cr15,cr14,cr0,0xf

 16863 + *[0-9a-f]*:	e1 a7 10 00 	cop cp0,cr0,cr0,cr0,0xf

 16864 + *[0-9a-f]*:	e1 a7 1f 00 	cop cp0,cr15,cr0,cr0,0xf

 16865 + *[0-9a-f]*:	e1 a7 10 e0 	cop cp0,cr0,cr14,cr0,0xf

 16866 + *[0-9a-f]*:	e1 a7 18 60 	cop cp0,cr8,cr6,cr0,0xf

 16867 + *[0-9a-f]*:	e1 a7 17 80 	cop cp0,cr7,cr8,cr0,0xf

 16868 +

 16869 +[0-9a-f]* <fcastd_s>:

 16870 + *[0-9a-f]*:	e1 a8 0e f0 	cop cp0,cr14,cr15,cr0,0x10

 16871 + *[0-9a-f]*:	e1 a8 00 00 	cop cp0,cr0,cr0,cr0,0x10

 16872 + *[0-9a-f]*:	e1 a8 0e 00 	cop cp0,cr14,cr0,cr0,0x10

 16873 + *[0-9a-f]*:	e1 a8 00 f0 	cop cp0,cr0,cr15,cr0,0x10

 16874 + *[0-9a-f]*:	e1 a8 08 70 	cop cp0,cr8,cr7,cr0,0x10

 16875 + *[0-9a-f]*:	e1 a8 06 80 	cop cp0,cr6,cr8,cr0,0x10

 16876 --- /dev/null

 16877 +++ b/gas/testsuite/gas/avr32/fpinsn.s

 16878 @@ -0,0 +1,266 @@

 16879 +

 16880 +	.text

 16881 +	.global	fadd_s

 16882 +fadd_s:

 16883 +	fadd.s fr15, fr15, fr15

 16884 +	fadd.s fr0, fr0, fr0

 16885 +	fadd.s fr0, fr15, fr15

 16886 +	fadd.s fr15, fr0, fr15

 16887 +	fadd.s fr15, fr15, fr0

 16888 +	fadd.s fr7, fr8, fr8

 16889 +	fadd.s fr8, fr7, fr8

 16890 +	fadd.s fr8, fr8, fr7

 16891 +	.global	fsub_s

 16892 +fsub_s:

 16893 +	fsub.s fr15, fr15, fr15

 16894 +	fsub.s fr0, fr0, fr0

 16895 +	fsub.s fr0, fr15, fr15

 16896 +	fsub.s fr15, fr0, fr15

 16897 +	fsub.s fr15, fr15, fr0

 16898 +	fsub.s fr7, fr8, fr8

 16899 +	fsub.s fr8, fr7, fr8

 16900 +	fsub.s fr8, fr8, fr7

 16901 +	.global	fmac_s

 16902 +fmac_s:

 16903 +	fmac.s fr15, fr15, fr15

 16904 +	fmac.s fr0, fr0, fr0

 16905 +	fmac.s fr0, fr15, fr15

 16906 +	fmac.s fr15, fr0, fr15

 16907 +	fmac.s fr15, fr15, fr0

 16908 +	fmac.s fr7, fr8, fr8

 16909 +	fmac.s fr8, fr7, fr8

 16910 +	fmac.s fr8, fr8, fr7

 16911 +	.global	fnmac_s

 16912 +fnmac_s:

 16913 +	fnmac.s fr15, fr15, fr15

 16914 +	fnmac.s fr0, fr0, fr0

 16915 +	fnmac.s fr0, fr15, fr15

 16916 +	fnmac.s fr15, fr0, fr15

 16917 +	fnmac.s fr15, fr15, fr0

 16918 +	fnmac.s fr7, fr8, fr8

 16919 +	fnmac.s fr8, fr7, fr8

 16920 +	fnmac.s fr8, fr8, fr7

 16921 +	.global	fmsc_s

 16922 +fmsc_s:

 16923 +	fmsc.s fr15, fr15, fr15

 16924 +	fmsc.s fr0, fr0, fr0

 16925 +	fmsc.s fr0, fr15, fr15

 16926 +	fmsc.s fr15, fr0, fr15

 16927 +	fmsc.s fr15, fr15, fr0

 16928 +	fmsc.s fr7, fr8, fr8

 16929 +	fmsc.s fr8, fr7, fr8

 16930 +	fmsc.s fr8, fr8, fr7

 16931 +	.global	fnmsc_s

 16932 +fnmsc_s:

 16933 +	fnmsc.s fr15, fr15, fr15

 16934 +	fnmsc.s fr0, fr0, fr0

 16935 +	fnmsc.s fr0, fr15, fr15

 16936 +	fnmsc.s fr15, fr0, fr15

 16937 +	fnmsc.s fr15, fr15, fr0

 16938 +	fnmsc.s fr7, fr8, fr8

 16939 +	fnmsc.s fr8, fr7, fr8

 16940 +	fnmsc.s fr8, fr8, fr7

 16941 +	.global	fmul_s

 16942 +fmul_s:

 16943 +	fmul.s fr15, fr15, fr15

 16944 +	fmul.s fr0, fr0, fr0

 16945 +	fmul.s fr0, fr15, fr15

 16946 +	fmul.s fr15, fr0, fr15

 16947 +	fmul.s fr15, fr15, fr0

 16948 +	fmul.s fr7, fr8, fr8

 16949 +	fmul.s fr8, fr7, fr8

 16950 +	fmul.s fr8, fr8, fr7

 16951 +	.global	fnmul_s

 16952 +fnmul_s:

 16953 +	fnmul.s fr15, fr15, fr15

 16954 +	fnmul.s fr0, fr0, fr0

 16955 +	fnmul.s fr0, fr15, fr15

 16956 +	fnmul.s fr15, fr0, fr15

 16957 +	fnmul.s fr15, fr15, fr0

 16958 +	fnmul.s fr7, fr8, fr8

 16959 +	fnmul.s fr8, fr7, fr8

 16960 +	fnmul.s fr8, fr8, fr7

 16961 +	.global	fneg_s

 16962 +fneg_s:

 16963 +	fneg.s fr15, fr15

 16964 +	fneg.s fr0, fr0

 16965 +	fneg.s fr0, fr15

 16966 +	fneg.s fr15, fr0

 16967 +	fneg.s fr7, fr8

 16968 +	fneg.s fr8, fr7

 16969 +	.global	fabs_s

 16970 +fabs_s:

 16971 +	fabs.s fr15, fr15

 16972 +	fabs.s fr0, fr0

 16973 +	fabs.s fr0, fr15

 16974 +	fabs.s fr15, fr0

 16975 +	fabs.s fr7, fr8

 16976 +	fabs.s fr8, fr7

 16977 +	.global	fcmp_s

 16978 +fcmp_s:

 16979 +	fcmp.s fr15, fr15

 16980 +	fcmp.s fr0, fr0

 16981 +	fcmp.s fr0, fr15

 16982 +	fcmp.s fr15, fr0

 16983 +	fcmp.s fr7, fr8

 16984 +	fcmp.s fr8, fr7

 16985 +	.global	fadd_d

 16986 +fadd_d:

 16987 +	fadd.d fr14, fr14, fr14

 16988 +	fadd.d fr0, fr0, fr0

 16989 +	fadd.d fr0, fr14, fr14

 16990 +	fadd.d fr14, fr0, fr14

 16991 +	fadd.d fr14, fr14, fr0

 16992 +	fadd.d fr6, fr8, fr8

 16993 +	fadd.d fr8, fr6, fr8

 16994 +	fadd.d fr8, fr8, fr6

 16995 +	.global	fsub_d

 16996 +fsub_d:

 16997 +	fsub.d fr14, fr14, fr14

 16998 +	fsub.d fr0, fr0, fr0

 16999 +	fsub.d fr0, fr14, fr14

 17000 +	fsub.d fr14, fr0, fr14

 17001 +	fsub.d fr14, fr14, fr0

 17002 +	fsub.d fr6, fr8, fr8

 17003 +	fsub.d fr8, fr6, fr8

 17004 +	fsub.d fr8, fr8, fr6

 17005 +	.global	fmac_d

 17006 +fmac_d:

 17007 +	fmac.d fr14, fr14, fr14

 17008 +	fmac.d fr0, fr0, fr0

 17009 +	fmac.d fr0, fr14, fr14

 17010 +	fmac.d fr14, fr0, fr14

 17011 +	fmac.d fr14, fr14, fr0

 17012 +	fmac.d fr6, fr8, fr8

 17013 +	fmac.d fr8, fr6, fr8

 17014 +	fmac.d fr8, fr8, fr6

 17015 +	.global	fnmac_d

 17016 +fnmac_d:

 17017 +	fnmac.d fr14, fr14, fr14

 17018 +	fnmac.d fr0, fr0, fr0

 17019 +	fnmac.d fr0, fr14, fr14

 17020 +	fnmac.d fr14, fr0, fr14

 17021 +	fnmac.d fr14, fr14, fr0

 17022 +	fnmac.d fr6, fr8, fr8

 17023 +	fnmac.d fr8, fr6, fr8

 17024 +	fnmac.d fr8, fr8, fr6

 17025 +	.global	fmsc_d

 17026 +fmsc_d:

 17027 +	fmsc.d fr14, fr14, fr14

 17028 +	fmsc.d fr0, fr0, fr0

 17029 +	fmsc.d fr0, fr14, fr14

 17030 +	fmsc.d fr14, fr0, fr14

 17031 +	fmsc.d fr14, fr14, fr0

 17032 +	fmsc.d fr6, fr8, fr8

 17033 +	fmsc.d fr8, fr6, fr8

 17034 +	fmsc.d fr8, fr8, fr6

 17035 +	.global	fnmsc_d

 17036 +fnmsc_d:

 17037 +	fnmsc.d fr14, fr14, fr14

 17038 +	fnmsc.d fr0, fr0, fr0

 17039 +	fnmsc.d fr0, fr14, fr14

 17040 +	fnmsc.d fr14, fr0, fr14

 17041 +	fnmsc.d fr14, fr14, fr0

 17042 +	fnmsc.d fr6, fr8, fr8

 17043 +	fnmsc.d fr8, fr6, fr8

 17044 +	fnmsc.d fr8, fr8, fr6

 17045 +	.global	fmul_d

 17046 +fmul_d:

 17047 +	fmul.d fr14, fr14, fr14

 17048 +	fmul.d fr0, fr0, fr0

 17049 +	fmul.d fr0, fr14, fr14

 17050 +	fmul.d fr14, fr0, fr14

 17051 +	fmul.d fr14, fr14, fr0

 17052 +	fmul.d fr6, fr8, fr8

 17053 +	fmul.d fr8, fr6, fr8

 17054 +	fmul.d fr8, fr8, fr6

 17055 +	.global	fnmul_d

 17056 +fnmul_d:

 17057 +	fnmul.d fr14, fr14, fr14

 17058 +	fnmul.d fr0, fr0, fr0

 17059 +	fnmul.d fr0, fr14, fr14

 17060 +	fnmul.d fr14, fr0, fr14

 17061 +	fnmul.d fr14, fr14, fr0

 17062 +	fnmul.d fr6, fr8, fr8

 17063 +	fnmul.d fr8, fr6, fr8

 17064 +	fnmul.d fr8, fr8, fr6

 17065 +	.global	fneg_d

 17066 +fneg_d:

 17067 +	fneg.d fr14, fr14

 17068 +	fneg.d fr0, fr0

 17069 +	fneg.d fr0, fr14

 17070 +	fneg.d fr14, fr0

 17071 +	fneg.d fr6, fr8

 17072 +	fneg.d fr8, fr6

 17073 +	.global	fabs_d

 17074 +fabs_d:

 17075 +	fabs.d fr14, fr14

 17076 +	fabs.d fr0, fr0

 17077 +	fabs.d fr0, fr14

 17078 +	fabs.d fr14, fr0

 17079 +	fabs.d fr6, fr8

 17080 +	fabs.d fr8, fr6

 17081 +	.global	fcmp_d

 17082 +fcmp_d:

 17083 +	fcmp.d fr14, fr14

 17084 +	fcmp.d fr0, fr0

 17085 +	fcmp.d fr0, fr14

 17086 +	fcmp.d fr14, fr0

 17087 +	fcmp.d fr6, fr8

 17088 +	fcmp.d fr8, fr6

 17089 +	.global fmov_s

 17090 +fmov_s:

 17091 +	fmov.s fr15, fr15

 17092 +	fmov.s fr0, fr0

 17093 +	fmov.s fr15, fr0

 17094 +	fmov.s fr0, fr15

 17095 +	fmov.s fr8, fr7

 17096 +	fmov.s fr7, fr8

 17097 +	fmov.s pc, fr15

 17098 +	fmov.s r0, fr0

 17099 +	fmov.s pc, fr0

 17100 +	fmov.s r0, fr15

 17101 +	fmov.s r8, fr7

 17102 +	fmov.s r7, fr8

 17103 +	fmov.s fr15, pc

 17104 +	fmov.s fr0, r0

 17105 +	fmov.s fr15, r0

 17106 +	fmov.s fr0, pc

 17107 +	fmov.s fr8, r7

 17108 +	fmov.s fr7, r8

 17109 +	.global fmov_d

 17110 +fmov_d:

 17111 +	fmov.d fr14, fr14

 17112 +	fmov.d fr0, fr0

 17113 +	fmov.d fr14, fr0

 17114 +	fmov.d fr0, fr14

 17115 +	fmov.d fr8, fr6

 17116 +	fmov.d fr6, fr8

 17117 +	fmov.d lr, fr14

 17118 +	fmov.d r0, fr0

 17119 +	fmov.d lr, fr0

 17120 +	fmov.d r0, fr14

 17121 +	fmov.d r8, fr6

 17122 +	fmov.d r6, fr8

 17123 +	fmov.d fr14, lr

 17124 +	fmov.d fr0, r0

 17125 +	fmov.d fr14, r0

 17126 +	fmov.d fr0, lr

 17127 +	fmov.d fr8, r6

 17128 +	fmov.d fr6, r8

 17129 +	.global fcasts_d

 17130 +fcasts_d:

 17131 +	fcasts.d fr15, fr14

 17132 +	fcasts.d fr0, fr0

 17133 +	fcasts.d fr15, fr0

 17134 +	fcasts.d fr0, fr14

 17135 +	fcasts.d fr8, fr6

 17136 +	fcasts.d fr7, fr8

 17137 +	.global fcastd_s

 17138 +fcastd_s:

 17139 +	fcastd.s fr14, fr15

 17140 +	fcastd.s fr0, fr0

 17141 +	fcastd.s fr14, fr0

 17142 +	fcastd.s fr0, fr15

 17143 +	fcastd.s fr8, fr7

 17144 +	fcastd.s fr6, fr8

 17145 --- /dev/null

 17146 +++ b/gas/testsuite/gas/avr32/hwrd-lwrd.d

 17147 @@ -0,0 +1,47 @@

 17148 +#as:

 17149 +#objdump: -dr

 17150 +#name: hwrd-lwrd

 17151 +

 17152 +.*: +file format .*

 17153 +

 17154 +Disassembly of section \.text:

 17155 +

 17156 +00000000 <test_hwrd>:

 17157 +   0:	e0 60 87 65 	mov r0,34661

 17158 +   4:	e0 60 12 34 	mov r0,4660

 17159 +   8:	e0 60 00 00 	mov r0,0

 17160 +			8: R_AVR32_HI16	\.text\+0x60

 17161 +   c:	e0 60 00 00 	mov r0,0

 17162 +			c: R_AVR32_HI16	extsym1

 17163 +  10:	ea 10 87 65 	orh r0,0x8765

 17164 +  14:	ea 10 12 34 	orh r0,0x1234

 17165 +  18:	ea 10 00 00 	orh r0,0x0

 17166 +			18: R_AVR32_HI16	\.text\+0x60

 17167 +  1c:	ea 10 00 00 	orh r0,0x0

 17168 +			1c: R_AVR32_HI16	extsym1

 17169 +  20:	e4 10 87 65 	andh r0,0x8765

 17170 +  24:	e4 10 12 34 	andh r0,0x1234

 17171 +  28:	e4 10 00 00 	andh r0,0x0

 17172 +			28: R_AVR32_HI16	\.text\+0x60

 17173 +  2c:	e4 10 00 00 	andh r0,0x0

 17174 +			2c: R_AVR32_HI16	extsym1

 17175 +

 17176 +00000030 <test_lwrd>:

 17177 +  30:	e0 60 43 21 	mov r0,17185

 17178 +  34:	e0 60 56 78 	mov r0,22136

 17179 +  38:	e0 60 00 00 	mov r0,0

 17180 +			38: R_AVR32_LO16	\.text\+0x60

 17181 +  3c:	e0 60 00 00 	mov r0,0

 17182 +			3c: R_AVR32_LO16	extsym1

 17183 +  40:	e8 10 43 21 	orl r0,0x4321

 17184 +  44:	e8 10 56 78 	orl r0,0x5678

 17185 +  48:	e8 10 00 00 	orl r0,0x0

 17186 +			48: R_AVR32_LO16	\.text\+0x60

 17187 +  4c:	e8 10 00 00 	orl r0,0x0

 17188 +			4c: R_AVR32_LO16	extsym1

 17189 +  50:	e0 10 43 21 	andl r0,0x4321

 17190 +  54:	e0 10 56 78 	andl r0,0x5678

 17191 +  58:	e0 10 00 00 	andl r0,0x0

 17192 +			58: R_AVR32_LO16	\.text\+0x60

 17193 +  5c:	e0 10 00 00 	andl r0,0x0

 17194 +			5c: R_AVR32_LO16	extsym1

 17195 --- /dev/null

 17196 +++ b/gas/testsuite/gas/avr32/hwrd-lwrd.s

 17197 @@ -0,0 +1,39 @@

 17198 +

 17199 +        .equ    sym1, 0x12345678

 17200 +

 17201 +        .text

 17202 +        .global test_hwrd

 17203 +test_hwrd:

 17204 +        mov     r0, hi(0x87654321)

 17205 +        mov     r0, hi(sym1)

 17206 +        mov     r0, hi(sym2)

 17207 +        mov     r0, hi(extsym1)

 17208 +

 17209 +        orh	r0, hi(0x87654321)

 17210 +        orh	r0, hi(sym1)

 17211 +        orh	r0, hi(sym2)

 17212 +        orh	r0, hi(extsym1)

 17213 +

 17214 +        andh	r0, hi(0x87654321)

 17215 +        andh	r0, hi(sym1)

 17216 +        andh	r0, hi(sym2)

 17217 +        andh	r0, hi(extsym1)

 17218 +

 17219 +        .global test_lwrd

 17220 +test_lwrd:

 17221 +        mov     r0, lo(0x87654321)

 17222 +        mov     r0, lo(sym1)

 17223 +        mov     r0, lo(sym2)

 17224 +        mov     r0, lo(extsym1)

 17225 +

 17226 +        orl	r0, lo(0x87654321)

 17227 +        orl	r0, lo(sym1)

 17228 +        orl	r0, lo(sym2)

 17229 +        orl	r0, lo(extsym1)

 17230 +

 17231 +        andl	r0, lo(0x87654321)

 17232 +        andl	r0, lo(sym1)

 17233 +        andl	r0, lo(sym2)

 17234 +        andl	r0, lo(extsym1)

 17235 +

 17236 +sym2:

 17237 --- /dev/null

 17238 +++ b/gas/testsuite/gas/avr32/jmptable.d

 17239 @@ -0,0 +1,20 @@

 17240 +#source: jmptable.s

 17241 +#as:

 17242 +#objdump: -dr

 17243 +#name: jmptable

 17244 +

 17245 +.*: +file format .*

 17246 +

 17247 +Disassembly of section \.text:

 17248 +

 17249 +00000000 <jmptable_test>:

 17250 +   0:	fe c8 ff f4 	sub r8,pc,-12

 17251 +   4:	f0 00 00 2f 	add pc,r8,r0<<0x2

 17252 +   8:	d7 03       	nop

 17253 +   a:	00 00       	add r0,r0

 17254 +   c:	c0 38       	rjmp 12 <jmptable_test\+0x12>

 17255 +   e:	c0 38       	rjmp 14 <jmptable_test\+0x14>

 17256 +  10:	c0 38       	rjmp 16 <jmptable_test\+0x16>

 17257 +  12:	d7 03       	nop

 17258 +  14:	d7 03       	nop

 17259 +  16:	d7 03       	nop

 17260 --- /dev/null

 17261 +++ b/gas/testsuite/gas/avr32/jmptable_linkrelax.d

 17262 @@ -0,0 +1,25 @@

 17263 +#source: jmptable.s

 17264 +#as: --linkrelax

 17265 +#objdump: -dr

 17266 +#name: jmptable_linkrelax

 17267 +

 17268 +.*: +file format .*

 17269 +

 17270 +Disassembly of section \.text:

 17271 +

 17272 +00000000 <jmptable_test>:

 17273 +   0:	fe c8 00 00 	sub r8,pc,0

 17274 +			0: R_AVR32_16N_PCREL	\.text\+0xc

 17275 +   4:	f0 00 00 2f 	add pc,r8,r0<<0x2

 17276 +   8:	d7 03       	nop

 17277 +   a:	00 00       	add r0,r0

 17278 +			a: R_AVR32_ALIGN	\*ABS\*\+0x2

 17279 +   c:	c0 08       	rjmp c <jmptable_test\+0xc>

 17280 +			c: R_AVR32_11H_PCREL	\.text\+0x12

 17281 +   e:	c0 08       	rjmp e <jmptable_test\+0xe>

 17282 +			e: R_AVR32_11H_PCREL	\.text\+0x14

 17283 +  10:	c0 08       	rjmp 10 <jmptable_test\+0x10>

 17284 +			10: R_AVR32_11H_PCREL	\.text\+0x16

 17285 +  12:	d7 03       	nop

 17286 +  14:	d7 03       	nop

 17287 +  16:	d7 03       	nop

 17288 --- /dev/null

 17289 +++ b/gas/testsuite/gas/avr32/jmptable.s

 17290 @@ -0,0 +1,14 @@

 17291 +

 17292 +	.text

 17293 +	.global	jmptable_test

 17294 +jmptable_test:

 17295 +	sub	r8, pc, -(.L1 - .)

 17296 +	add	pc, r8, r0 << 2

 17297 +	nop

 17298 +	.align	2

 17299 +.L1:	rjmp	1f

 17300 +	rjmp	2f

 17301 +	rjmp	3f

 17302 +1:	nop

 17303 +2:	nop

 17304 +3:	nop

 17305 --- /dev/null

 17306 +++ b/gas/testsuite/gas/avr32/lda_nopic.d

 17307 @@ -0,0 +1,32 @@

 17308 +#source: lda.s

 17309 +#as:

 17310 +#objdump: -dr

 17311 +#name: lda_nopic

 17312 +

 17313 +.*: +file format .*

 17314 +

 17315 +Disassembly of section \.text:

 17316 +

 17317 +00000000 <lda_test>:

 17318 +       0:	f2 c8 00 00 	sub r8,r9,0

 17319 +

 17320 +00000004 <far_negative>:

 17321 +       4:	f6 ca 00 00 	sub r10,r11,0

 17322 +	...

 17323 +    8000:	fe c0 7f fc 	sub r0,pc,32764

 17324 +    8004:	48 31       	lddpc r1,8010 <far_negative\+0x800c>

 17325 +    8006:	48 42       	lddpc r2,8014 <far_negative\+0x8010>

 17326 +    8008:	48 43       	lddpc r3,8018 <far_negative\+0x8014>

 17327 +    800a:	48 54       	lddpc r4,801c <far_negative\+0x8018>

 17328 +    800c:	fe c5 80 04 	sub r5,pc,-32764

 17329 +	...

 17330 +			8010: R_AVR32_32_CPENT	\.text

 17331 +			8014: R_AVR32_32_CPENT	\.data

 17332 +			8018: R_AVR32_32_CPENT	undefined

 17333 +			801c: R_AVR32_32_CPENT	\.text\+0x1001c

 17334 +

 17335 +00010008 <far_positive>:

 17336 +   10008:	fa cc 00 00 	sub r12,sp,0

 17337 +	...

 17338 +0001001c <toofar_positive>:

 17339 +   1001c:	fe ce 00 00 	sub lr,pc,0

 17340 --- /dev/null

 17341 +++ b/gas/testsuite/gas/avr32/lda_nopic_linkrelax.d

 17342 @@ -0,0 +1,41 @@

 17343 +#source: lda.s

 17344 +#as: --linkrelax

 17345 +#objdump: -dr

 17346 +#name: lda_nopic_linkrelax

 17347 +

 17348 +.*: +file format .*

 17349 +

 17350 +Disassembly of section \.text:

 17351 +

 17352 +00000000 <lda_test>:

 17353 +       0:	f2 c8 00 00 	sub r8,r9,0

 17354 +

 17355 +00000004 <far_negative>:

 17356 +       4:	f6 ca 00 00 	sub r10,r11,0

 17357 +	\.\.\.

 17358 +    8000:	48 00       	lddpc r0,8000 <far_negative\+0x7ffc>

 17359 +			8000: R_AVR32_9W_CP	\.text\+0x800c

 17360 +    8002:	48 01       	lddpc r1,8000 <far_negative\+0x7ffc>

 17361 +			8002: R_AVR32_9W_CP	\.text\+0x8010

 17362 +    8004:	48 02       	lddpc r2,8004 <far_negative\+0x8000>

 17363 +			8004: R_AVR32_9W_CP	\.text\+0x8014

 17364 +    8006:	48 03       	lddpc r3,8004 <far_negative\+0x8000>

 17365 +			8006: R_AVR32_9W_CP	\.text\+0x8018

 17366 +    8008:	48 04       	lddpc r4,8008 <far_negative\+0x8004>

 17367 +			8008: R_AVR32_9W_CP	\.text\+0x801c

 17368 +    800a:	48 05       	lddpc r5,8008 <far_negative\+0x8004>

 17369 +			800a: R_AVR32_9W_CP	\.text\+0x8020

 17370 +	\.\.\.

 17371 +			800c: R_AVR32_ALIGN	\*ABS\*\+0x2

 17372 +			800c: R_AVR32_32_CPENT	\.text\+0x4

 17373 +			8010: R_AVR32_32_CPENT	\.text

 17374 +			8014: R_AVR32_32_CPENT	\.data

 17375 +			8018: R_AVR32_32_CPENT	undefined

 17376 +			801c: R_AVR32_32_CPENT	\.text\+0x10020

 17377 +			8020: R_AVR32_32_CPENT	\.text\+0x1000c

 17378 +

 17379 +0001000c <far_positive>:

 17380 +   1000c:	fa cc 00 00 	sub r12,sp,0

 17381 +	\.\.\.

 17382 +00010020 <toofar_positive>:

 17383 +   10020:	fe ce 00 00 	sub lr,pc,0

 17384 --- /dev/null

 17385 +++ b/gas/testsuite/gas/avr32/lda_pic.d

 17386 @@ -0,0 +1,32 @@

 17387 +#source: lda.s

 17388 +#as: --pic

 17389 +#objdump: -dr

 17390 +#name: lda_pic

 17391 +

 17392 +.*: +file format .*

 17393 +

 17394 +Disassembly of section \.text:

 17395 +

 17396 +00000000 <lda_test>:

 17397 +       0:	f2 c8 00 00 	sub r8,r9,0

 17398 +

 17399 +00000004 <far_negative>:

 17400 +       4:	f6 ca 00 00 	sub r10,r11,0

 17401 +	...

 17402 +    8000:	fe c0 7f fc 	sub r0,pc,32764

 17403 +    8004:	ec f1 00 00 	ld.w r1,r6\[0\]

 17404 +			8004: R_AVR32_GOT16S	toofar_negative

 17405 +    8008:	ec f2 00 00 	ld.w r2,r6\[0\]

 17406 +			8008: R_AVR32_GOT16S	different_section

 17407 +    800c:	ec f3 00 00 	ld.w r3,r6\[0\]

 17408 +			800c: R_AVR32_GOT16S	undefined

 17409 +    8010:	ec f4 00 00 	ld.w r4,r6\[0\]

 17410 +			8010: R_AVR32_GOT16S	toofar_positive

 17411 +    8014:	fe c5 80 14 	sub r5,pc,-32748

 17412 +	...

 17413 +

 17414 +00010000 <far_positive>:

 17415 +   10000:	fa cc 00 00 	sub r12,sp,0

 17416 +	...

 17417 +00010014 <toofar_positive>:

 17418 +   10014:	fe ce 00 00 	sub lr,pc,0

 17419 --- /dev/null

 17420 +++ b/gas/testsuite/gas/avr32/lda_pic_linkrelax.d

 17421 @@ -0,0 +1,40 @@

 17422 +#source: lda.s

 17423 +#as: --pic --linkrelax

 17424 +#objdump: -dr

 17425 +#name: lda_pic_linkrelax

 17426 +

 17427 +.*: +file format .*

 17428 +

 17429 +Disassembly of section \.text:

 17430 +

 17431 +00000000 <lda_test>:

 17432 +       0:	f2 c8 00 00 	sub r8,r9,0

 17433 +

 17434 +00000004 <far_negative>:

 17435 +       4:	f6 ca 00 00 	sub r10,r11,0

 17436 +	...

 17437 +    8000:	e0 60 00 00 	mov r0,0

 17438 +			8000: R_AVR32_LDA_GOT	far_negative

 17439 +    8004:	ec 00 03 20 	ld\.w r0,r6\[r0<<0x2\]

 17440 +    8008:	e0 61 00 00 	mov r1,0

 17441 +			8008: R_AVR32_LDA_GOT	toofar_negative

 17442 +    800c:	ec 01 03 21 	ld\.w r1,r6\[r1<<0x2\]

 17443 +    8010:	e0 62 00 00 	mov r2,0

 17444 +			8010: R_AVR32_LDA_GOT	different_section

 17445 +    8014:	ec 02 03 22 	ld\.w r2,r6\[r2<<0x2\]

 17446 +    8018:	e0 63 00 00 	mov r3,0

 17447 +			8018: R_AVR32_LDA_GOT	undefined

 17448 +    801c:	ec 03 03 23 	ld\.w r3,r6\[r3<<0x2\]

 17449 +    8020:	e0 64 00 00 	mov r4,0

 17450 +			8020: R_AVR32_LDA_GOT	toofar_positive

 17451 +    8024:	ec 04 03 24 	ld\.w r4,r6\[r4<<0x2\]

 17452 +    8028:	e0 65 00 00 	mov r5,0

 17453 +			8028: R_AVR32_LDA_GOT	far_positive

 17454 +    802c:	ec 05 03 25 	ld\.w r5,r6\[r5<<0x2\]

 17455 +	...

 17456 +

 17457 +00010018 <far_positive>:

 17458 +   10018:	fa cc 00 00 	sub r12,sp,0

 17459 +	...

 17460 +0001002c <toofar_positive>:

 17461 +   1002c:	fe ce 00 00 	sub lr,pc,0

 17462 --- /dev/null

 17463 +++ b/gas/testsuite/gas/avr32/lda.s

 17464 @@ -0,0 +1,30 @@

 17465 +

 17466 +	.text

 17467 +	.global lda_test

 17468 +lda_test:

 17469 +toofar_negative:

 17470 +	sub	r8, r9, 0

 17471 +far_negative:

 17472 +	sub	r10, r11, 0

 17473 +

 17474 +	.fill	32760, 1, 0x00

 17475 +

 17476 +	lda.w	r0, far_negative

 17477 +	lda.w	r1, toofar_negative

 17478 +	lda.w	r2, different_section

 17479 +	lda.w	r3, undefined

 17480 +	lda.w	r4, toofar_positive

 17481 +	lda.w	r5, far_positive

 17482 +

 17483 +	.cpool

 17484 +

 17485 +	.fill	32744, 1, 0x00

 17486 +far_positive:

 17487 +	sub	r12, sp, 0

 17488 +	.fill	16, 1, 0x00

 17489 +toofar_positive:

 17490 +	sub	lr, pc, 0

 17491 +

 17492 +	.data

 17493 +different_section:

 17494 +	.long	0x12345678

 17495 --- /dev/null

 17496 +++ b/gas/testsuite/gas/avr32/pcrel.d

 17497 @@ -0,0 +1,64 @@

 17498 +#as:

 17499 +#objdump: -dr

 17500 +#name: pcrel

 17501 +

 17502 +.*: +file format .*

 17503 +

 17504 +Disassembly of section \.text:

 17505 +

 17506 +00000000 <test_rjmp>:

 17507 +   0:	d7 03       	nop

 17508 +   2:	c0 28       	rjmp 6 <test_rjmp\+0x6>

 17509 +   4:	d7 03       	nop

 17510 +   6:	e0 8f 00 00 	bral 6 <test_rjmp\+0x6>

 17511 +			6: R_AVR32_22H_PCREL	extsym10

 17512 +

 17513 +0000000a <test_rcall>:

 17514 +   a:	d7 03       	nop

 17515 +0000000c <test_rcall2>:

 17516 +   c:	c0 2c       	rcall 10 <test_rcall2\+0x4>

 17517 +   e:	d7 03       	nop

 17518 +  10:	e0 a0 00 00 	rcall 10 <test_rcall2\+0x4>

 17519 +			10: R_AVR32_22H_PCREL	extsym21

 17520 +

 17521 +00000014 <test_branch>:

 17522 +  14:	c0 31       	brne 1a <test_branch\+0x6>

 17523 +  16:	e0 8f 00 00 	bral 16 <test_branch\+0x2>

 17524 +			16: R_AVR32_22H_PCREL	test_branch

 17525 +  1a:	e0 80 00 00 	breq 1a <test_branch\+0x6>

 17526 +			1a: R_AVR32_22H_PCREL	extsym21

 17527 +

 17528 +0000001e <test_lddpc>:

 17529 +  1e:	48 30       	lddpc r0,28 <sym1>

 17530 +  20:	48 20       	lddpc r0,28 <sym1>

 17531 +  22:	fe f0 00 00 	ld.w r0,pc\[0\]

 17532 +			22: R_AVR32_16B_PCREL	extsym16

 17533 +	\.\.\.

 17534 +

 17535 +00000028 <sym1>:

 17536 +  28:	d7 03       	nop

 17537 +  2a:	d7 03       	nop

 17538 +

 17539 +0000002c <test_local>:

 17540 +  2c:	48 20       	lddpc r0,34 <test_local\+0x8>

 17541 +  2e:	48 30       	lddpc r0,38 <test_local\+0xc>

 17542 +  30:	48 20       	lddpc r0,38 <test_local\+0xc>

 17543 +  32:	00 00       	add r0,r0

 17544 +  34:	d7 03       	nop

 17545 +  36:	d7 03       	nop

 17546 +  38:	d7 03       	nop

 17547 +  3a:	d7 03       	nop

 17548 +

 17549 +Disassembly of section \.text\.init:

 17550 +

 17551 +00000000 <test_inter_section>:

 17552 +   0:	e0 a0 .. .. 	rcall [0-9a-f]+ <.*>

 17553 +			0: R_AVR32_22H_PCREL	test_rcall

 17554 +   4:	d7 03       	nop

 17555 +   6:	e0 a0 .. .. 	rcall [0-9a-f]+ <.*>

 17556 +			6: R_AVR32_22H_PCREL	test_rcall

 17557 +   a:	e0 a0 .. .. 	rcall [0-9a-z]+ <.*>

 17558 +			a: R_AVR32_22H_PCREL	\.text\+0xc

 17559 +   e:	d7 03       	nop

 17560 +  10:	e0 a0 .. .. 	rcall [0-9a-f]+ <.*>

 17561 +			10: R_AVR32_22H_PCREL	\.text\+0xc

 17562 --- /dev/null

 17563 +++ b/gas/testsuite/gas/avr32/pcrel.s

 17564 @@ -0,0 +1,57 @@

 17565 +

 17566 +        .text

 17567 +        .global test_rjmp

 17568 +test_rjmp:

 17569 +        nop

 17570 +        rjmp    0f

 17571 +        nop

 17572 +0:      rjmp    extsym10

 17573 +

 17574 +        .global test_rcall

 17575 +test_rcall:

 17576 +        nop

 17577 +test_rcall2:

 17578 +        rcall   0f

 17579 +        nop

 17580 +0:      rcall   extsym21

 17581 +

 17582 +        .global test_branch

 17583 +test_branch:

 17584 +        brne    0f

 17585 +	/* This will generate a reloc since test_branch is global */

 17586 +        bral    test_branch

 17587 +0:	breq    extsym21

 17588 +

 17589 +        .global test_lddpc

 17590 +test_lddpc:

 17591 +        lddpc   r0,sym1

 17592 +        lddpc   r0,sym1

 17593 +        lddpc   r0,extsym16

 17594 +

 17595 +        .align	2

 17596 +sym1:   nop

 17597 +        nop

 17598 +

 17599 +	.global	test_local

 17600 +test_local:

 17601 +	lddpc	r0, .LC1

 17602 +	lddpc	r0, .LC2

 17603 +	lddpc	r0, .LC1 + 0x4

 17604 +

 17605 +	.align	2

 17606 +.LC1:

 17607 +	nop

 17608 +	nop

 17609 +.LC2:

 17610 +	nop

 17611 +	nop

 17612 +

 17613 +	.section .text.init,"ax"

 17614 +	.global test_inter_section

 17615 +test_inter_section:

 17616 +	rcall	test_rcall

 17617 +	nop

 17618 +	rcall	test_rcall

 17619 +	rcall	test_rcall2

 17620 +	nop

 17621 +	rcall	test_rcall2

 17622 --- /dev/null

 17623 +++ b/gas/testsuite/gas/avr32/pico.d

 17624 @@ -0,0 +1,149 @@

 17625 +#as:

 17626 +#objdump: -dr

 17627 +#name: pico

 17628 +

 17629 +.*: +file format .*

 17630 +

 17631 +Disassembly of section \.text:

 17632 +

 17633 +[0-9a-f]* <picosvmac>:

 17634 + *[0-9a-f]*:	e1 a6 20 00 	cop cp1,cr0,cr0,cr0,0xc

 17635 + *[0-9a-f]*:	e1 a7 2b bb 	cop cp1,cr11,cr11,cr11,0xe

 17636 + *[0-9a-f]*:	e1 a6 3a 05 	cop cp1,cr10,cr0,cr5,0xd

 17637 + *[0-9a-f]*:	e1 a7 36 90 	cop cp1,cr6,cr9,cr0,0xf

 17638 +

 17639 +[0-9a-f]* <picosvmul>:

 17640 + *[0-9a-f]*:	e1 a4 20 00 	cop cp1,cr0,cr0,cr0,0x8

 17641 + *[0-9a-f]*:	e1 a5 2b bb 	cop cp1,cr11,cr11,cr11,0xa

 17642 + *[0-9a-f]*:	e1 a4 3a 05 	cop cp1,cr10,cr0,cr5,0x9

 17643 + *[0-9a-f]*:	e1 a5 36 90 	cop cp1,cr6,cr9,cr0,0xb

 17644 +

 17645 +[0-9a-f]* <picovmac>:

 17646 + *[0-9a-f]*:	e1 a2 20 00 	cop cp1,cr0,cr0,cr0,0x4

 17647 + *[0-9a-f]*:	e1 a3 2b bb 	cop cp1,cr11,cr11,cr11,0x6

 17648 + *[0-9a-f]*:	e1 a2 3a 05 	cop cp1,cr10,cr0,cr5,0x5

 17649 + *[0-9a-f]*:	e1 a3 36 90 	cop cp1,cr6,cr9,cr0,0x7

 17650 +

 17651 +[0-9a-f]* <picovmul>:

 17652 + *[0-9a-f]*:	e1 a0 20 00 	cop cp1,cr0,cr0,cr0,0x0

 17653 + *[0-9a-f]*:	e1 a1 2b bb 	cop cp1,cr11,cr11,cr11,0x2

 17654 + *[0-9a-f]*:	e1 a0 3a 05 	cop cp1,cr10,cr0,cr5,0x1

 17655 + *[0-9a-f]*:	e1 a1 36 90 	cop cp1,cr6,cr9,cr0,0x3

 17656 +

 17657 +[0-9a-f]* <picold_d>:

 17658 + *[0-9a-f]*:	e9 af 3e ff 	ldc\.d cp1,cr14,pc\[0x3fc\]

 17659 + *[0-9a-f]*:	e9 a0 30 ff 	ldc\.d cp1,cr0,r0\[0x3fc\]

 17660 + *[0-9a-f]*:	e9 a0 30 00 	ldc\.d cp1,cr0,r0\[0x0\]

 17661 + *[0-9a-f]*:	ef a8 26 50 	ldc\.d cp1,cr6,--r8

 17662 + *[0-9a-f]*:	ef a7 28 50 	ldc\.d cp1,cr8,--r7

 17663 + *[0-9a-f]*:	ef aa 32 65 	ldc\.d cp1,cr2,r10\[r5<<0x2\]

 17664 + *[0-9a-f]*:	ef a3 3c 46 	ldc\.d cp1,cr12,r3\[r6\]

 17665 +

 17666 +[0-9a-f]* <picold_w>:

 17667 + *[0-9a-f]*:	e9 af 2f ff 	ldc\.w cp1,cr15,pc\[0x3fc\]

 17668 + *[0-9a-f]*:	e9 a0 20 ff 	ldc\.w cp1,cr0,r0\[0x3fc\]

 17669 + *[0-9a-f]*:	e9 a0 20 00 	ldc\.w cp1,cr0,r0\[0x0\]

 17670 + *[0-9a-f]*:	ef a8 27 40 	ldc\.w cp1,cr7,--r8

 17671 + *[0-9a-f]*:	ef a7 28 40 	ldc\.w cp1,cr8,--r7

 17672 + *[0-9a-f]*:	ef aa 31 25 	ldc\.w cp1,cr1,r10\[r5<<0x2\]

 17673 + *[0-9a-f]*:	ef a3 3d 06 	ldc\.w cp1,cr13,r3\[r6\]

 17674 +

 17675 +[0-9a-f]* <picoldm_d>:

 17676 + *[0-9a-f]*:	ed af 24 ff 	ldcm\.d cp1,pc,cr0-cr15

 17677 + *[0-9a-f]*:	ed a0 24 01 	ldcm\.d cp1,r0,cr0-cr1

 17678 + *[0-9a-f]*:	ed a7 24 80 	ldcm\.d cp1,r7,cr14-cr15

 17679 + *[0-9a-f]*:	ed a8 24 7f 	ldcm\.d cp1,r8,cr0-cr13

 17680 +

 17681 +[0-9a-f]* <picoldm_d_pu>:

 17682 + *[0-9a-f]*:	ed af 34 ff 	ldcm\.d cp1,pc\+\+,cr0-cr15

 17683 + *[0-9a-f]*:	ed a0 34 01 	ldcm\.d cp1,r0\+\+,cr0-cr1

 17684 + *[0-9a-f]*:	ed a7 34 80 	ldcm\.d cp1,r7\+\+,cr14-cr15

 17685 + *[0-9a-f]*:	ed a8 34 7f 	ldcm\.d cp1,r8\+\+,cr0-cr13

 17686 +

 17687 +[0-9a-f]* <picoldm_w>:

 17688 + *[0-9a-f]*:	ed af 20 ff 	ldcm\.w cp1,pc,cr0-cr7

 17689 + *[0-9a-f]*:	ed a0 20 01 	ldcm\.w cp1,r0,cr0

 17690 + *[0-9a-f]*:	ed a7 20 80 	ldcm\.w cp1,r7,cr7

 17691 + *[0-9a-f]*:	ed a8 20 7f 	ldcm\.w cp1,r8,cr0-cr6

 17692 + *[0-9a-f]*:	ed af 21 ff 	ldcm\.w cp1,pc,cr8-cr15

 17693 + *[0-9a-f]*:	ed a0 21 01 	ldcm\.w cp1,r0,cr8

 17694 + *[0-9a-f]*:	ed a7 21 80 	ldcm\.w cp1,r7,cr15

 17695 + *[0-9a-f]*:	ed a8 21 7f 	ldcm\.w cp1,r8,cr8-cr14

 17696 +

 17697 +[0-9a-f]* <picoldm_w_pu>:

 17698 + *[0-9a-f]*:	ed af 30 ff 	ldcm\.w cp1,pc\+\+,cr0-cr7

 17699 + *[0-9a-f]*:	ed a0 30 01 	ldcm\.w cp1,r0\+\+,cr0

 17700 + *[0-9a-f]*:	ed a7 30 80 	ldcm\.w cp1,r7\+\+,cr7

 17701 + *[0-9a-f]*:	ed a8 30 7f 	ldcm\.w cp1,r8\+\+,cr0-cr6

 17702 + *[0-9a-f]*:	ed af 31 ff 	ldcm\.w cp1,pc\+\+,cr8-cr15

 17703 + *[0-9a-f]*:	ed a0 31 01 	ldcm\.w cp1,r0\+\+,cr8

 17704 + *[0-9a-f]*:	ed a7 31 80 	ldcm\.w cp1,r7\+\+,cr15

 17705 + *[0-9a-f]*:	ed a8 31 7f 	ldcm\.w cp1,r8\+\+,cr8-cr14

 17706 +

 17707 +[0-9a-f]* <picomv_d>:

 17708 + *[0-9a-f]*:	ef ae 2e 30 	mvrc\.d cp1,cr14,lr

 17709 + *[0-9a-f]*:	ef a0 20 30 	mvrc\.d cp1,cr0,r0

 17710 + *[0-9a-f]*:	ef a8 26 30 	mvrc\.d cp1,cr6,r8

 17711 + *[0-9a-f]*:	ef a6 28 30 	mvrc\.d cp1,cr8,r6

 17712 + *[0-9a-f]*:	ef ae 2e 10 	mvcr\.d cp1,lr,cr14

 17713 + *[0-9a-f]*:	ef a0 20 10 	mvcr\.d cp1,r0,cr0

 17714 + *[0-9a-f]*:	ef a8 26 10 	mvcr\.d cp1,r8,cr6

 17715 + *[0-9a-f]*:	ef a6 28 10 	mvcr\.d cp1,r6,cr8

 17716 +

 17717 +[0-9a-f]* <picomv_w>:

 17718 + *[0-9a-f]*:	ef af 2f 20 	mvrc\.w cp1,cr15,pc

 17719 + *[0-9a-f]*:	ef a0 20 20 	mvrc\.w cp1,cr0,r0

 17720 + *[0-9a-f]*:	ef a8 27 20 	mvrc\.w cp1,cr7,r8

 17721 + *[0-9a-f]*:	ef a7 28 20 	mvrc\.w cp1,cr8,r7

 17722 + *[0-9a-f]*:	ef af 2f 00 	mvcr\.w cp1,pc,cr15

 17723 + *[0-9a-f]*:	ef a0 20 00 	mvcr\.w cp1,r0,cr0

 17724 + *[0-9a-f]*:	ef a8 27 00 	mvcr\.w cp1,r8,cr7

 17725 + *[0-9a-f]*:	ef a7 28 00 	mvcr\.w cp1,r7,cr8

 17726 +

 17727 +[0-9a-f]* <picost_d>:

 17728 + *[0-9a-f]*:	eb af 3e ff 	stc\.d cp1,pc\[0x3fc\],cr14

 17729 + *[0-9a-f]*:	eb a0 30 00 	stc\.d cp1,r0\[0x0\],cr0

 17730 + *[0-9a-f]*:	ef a8 26 70 	stc\.d cp1,r8\+\+,cr6

 17731 + *[0-9a-f]*:	ef a7 28 70 	stc\.d cp1,r7\+\+,cr8

 17732 + *[0-9a-f]*:	ef aa 32 e5 	stc\.d cp1,r10\[r5<<0x2\],cr2

 17733 + *[0-9a-f]*:	ef a3 3c c6 	stc\.d cp1,r3\[r6\],cr12

 17734 +

 17735 +[0-9a-f]* <picost_w>:

 17736 + *[0-9a-f]*:	eb af 2f ff 	stc\.w cp1,pc\[0x3fc\],cr15

 17737 + *[0-9a-f]*:	eb a0 20 00 	stc\.w cp1,r0\[0x0\],cr0

 17738 + *[0-9a-f]*:	ef a8 27 60 	stc\.w cp1,r8\+\+,cr7

 17739 + *[0-9a-f]*:	ef a7 28 60 	stc\.w cp1,r7\+\+,cr8

 17740 + *[0-9a-f]*:	ef aa 31 a5 	stc\.w cp1,r10\[r5<<0x2\],cr1

 17741 + *[0-9a-f]*:	ef a3 3d 86 	stc\.w cp1,r3\[r6\],cr13

 17742 +

 17743 +[0-9a-f]* <picostm_d>:

 17744 + *[0-9a-f]*:	ed af 25 ff 	stcm\.d cp1,pc,cr0-cr15

 17745 + *[0-9a-f]*:	ed a0 25 01 	stcm\.d cp1,r0,cr0-cr1

 17746 + *[0-9a-f]*:	ed a7 25 80 	stcm\.d cp1,r7,cr14-cr15

 17747 + *[0-9a-f]*:	ed a8 25 7f 	stcm\.d cp1,r8,cr0-cr13

 17748 +

 17749 +[0-9a-f]* <picostm_d_pu>:

 17750 + *[0-9a-f]*:	ed af 35 ff 	stcm\.d cp1,--pc,cr0-cr15

 17751 + *[0-9a-f]*:	ed a0 35 01 	stcm\.d cp1,--r0,cr0-cr1

 17752 + *[0-9a-f]*:	ed a7 35 80 	stcm\.d cp1,--r7,cr14-cr15

 17753 + *[0-9a-f]*:	ed a8 35 7f 	stcm\.d cp1,--r8,cr0-cr13

 17754 +

 17755 +[0-9a-f]* <picostm_w>:

 17756 + *[0-9a-f]*:	ed af 22 ff 	stcm\.w cp1,pc,cr0-cr7

 17757 + *[0-9a-f]*:	ed a0 22 01 	stcm\.w cp1,r0,cr0

 17758 + *[0-9a-f]*:	ed a7 22 80 	stcm\.w cp1,r7,cr7

 17759 + *[0-9a-f]*:	ed a8 22 7f 	stcm\.w cp1,r8,cr0-cr6

 17760 + *[0-9a-f]*:	ed af 23 ff 	stcm\.w cp1,pc,cr8-cr15

 17761 + *[0-9a-f]*:	ed a0 23 01 	stcm\.w cp1,r0,cr8

 17762 + *[0-9a-f]*:	ed a7 23 80 	stcm\.w cp1,r7,cr15

 17763 + *[0-9a-f]*:	ed a8 23 7f 	stcm\.w cp1,r8,cr8-cr14

 17764 +

 17765 +[0-9a-f]* <picostm_w_pu>:

 17766 + *[0-9a-f]*:	ed af 32 ff 	stcm\.w cp1,--pc,cr0-cr7

 17767 + *[0-9a-f]*:	ed a0 32 01 	stcm\.w cp1,--r0,cr0

 17768 + *[0-9a-f]*:	ed a7 32 80 	stcm\.w cp1,--r7,cr7

 17769 + *[0-9a-f]*:	ed a8 32 7f 	stcm\.w cp1,--r8,cr0-cr6

 17770 + *[0-9a-f]*:	ed af 33 ff 	stcm\.w cp1,--pc,cr8-cr15

 17771 + *[0-9a-f]*:	ed a0 33 01 	stcm\.w cp1,--r0,cr8

 17772 + *[0-9a-f]*:	ed a7 33 80 	stcm\.w cp1,--r7,cr15

 17773 + *[0-9a-f]*:	ed a8 33 7f 	stcm\.w cp1,--r8,cr8-cr14

 17774 --- /dev/null

 17775 +++ b/gas/testsuite/gas/avr32/pico.s

 17776 @@ -0,0 +1,144 @@

 17777 +

 17778 +	.text

 17779 +	.global	picosvmac

 17780 +picosvmac:

 17781 +	picosvmac	out0, in0, in0, in0

 17782 +	picosvmac	out2, in11, in11, in11

 17783 +	picosvmac	out1, in10, in0, in5

 17784 +	picosvmac	out3, in6, in9, in0

 17785 +	.global picosvmul

 17786 +picosvmul:

 17787 +	picosvmul	out0, in0, in0, in0

 17788 +	picosvmul	out2, in11, in11, in11

 17789 +	picosvmul	out1, in10, in0, in5

 17790 +	picosvmul	out3, in6, in9, in0

 17791 +	.global picovmac

 17792 +picovmac:

 17793 +	picovmac	out0, in0, in0, in0

 17794 +	picovmac	out2, in11, in11, in11

 17795 +	picovmac	out1, in10, in0, in5

 17796 +	picovmac	out3, in6, in9, in0

 17797 +	.global picovmul

 17798 +picovmul:

 17799 +	picovmul	out0, in0, in0, in0

 17800 +	picovmul	out2, in11, in11, in11

 17801 +	picovmul	out1, in10, in0, in5

 17802 +	picovmul	out3, in6, in9, in0

 17803 +	.global	picold_d

 17804 +picold_d:

 17805 +	picold.d	vmu2_out, pc[1020]

 17806 +	picold.d	inpix2, r0[1020]

 17807 +	picold.d	inpix2, r0[0]

 17808 +	picold.d	coeff0_a, --r8

 17809 +	picold.d	coeff1_a, --r7

 17810 +	picold.d	inpix0, r10[r5 << 2]

 17811 +	picold.d	vmu0_out, r3[r6 << 0]

 17812 +	.global	picold_w

 17813 +picold_w:

 17814 +	picold.w	config, pc[1020]

 17815 +	picold.w	inpix2, r0[1020]

 17816 +	picold.w	inpix2, r0[0]

 17817 +	picold.w	coeff0_b, --r8

 17818 +	picold.w	coeff1_a, --r7

 17819 +	picold.w	inpix1, r10[r5 << 2]

 17820 +	picold.w	vmu1_out, r3[r6 << 0]

 17821 +	.global	picoldm_d

 17822 +picoldm_d:

 17823 +	picoldm.d	pc, inpix2-config

 17824 +	picoldm.d	r0, inpix2, inpix1

 17825 +	picoldm.d	r7, vmu2_out, config

 17826 +	picoldm.d	r8, inpix2-vmu1_out

 17827 +	.global	picoldm_d_pu

 17828 +picoldm_d_pu:

 17829 +	picoldm.d	pc++, inpix2, inpix1, inpix0, outpix2, outpix1, outpix0, coeff0_a, coeff0_b, coeff1_a, coeff1_b, coeff2_a, coeff2_b, vmu0_out, vmu1_out, vmu2_out, config

 17830 +	picoldm.d	r0++, inpix2, inpix1

 17831 +	picoldm.d	r7++, vmu2_out, config

 17832 +	picoldm.d	r8++, inpix2, inpix1, inpix0, outpix2, outpix1, outpix0, coeff0_a, coeff0_b, coeff1_a, coeff1_b, coeff2_a, coeff2_b, vmu0_out, vmu1_out

 17833 +	.global	picoldm_w

 17834 +picoldm_w:

 17835 +	picoldm.w	pc, inpix2-coeff0_b

 17836 +	picoldm.w	r0, inpix2

 17837 +	picoldm.w	r7, coeff0_b

 17838 +	picoldm.w	r8, inpix2-coeff0_a

 17839 +	picoldm.w	pc, coeff1_a-config

 17840 +	picoldm.w	r0, coeff1_a

 17841 +	picoldm.w	r7, config

 17842 +	picoldm.w	r8, coeff1_a-vmu2_out

 17843 +	.global	picoldm_w_pu

 17844 +picoldm_w_pu:

 17845 +	picoldm.w	pc++, inpix2-coeff0_b

 17846 +	picoldm.w	r0++, inpix2

 17847 +	picoldm.w	r7++, coeff0_b

 17848 +	picoldm.w	r8++, inpix2-coeff0_a

 17849 +	picoldm.w	pc++, coeff1_a-config

 17850 +	picoldm.w	r0++, coeff1_a

 17851 +	picoldm.w	r7++, config

 17852 +	picoldm.w	r8++, coeff1_a-vmu2_out

 17853 +	.global	picomv_d

 17854 +picomv_d:

 17855 +	picomv.d	vmu2_out, lr

 17856 +	picomv.d	inpix2, r0

 17857 +	picomv.d	coeff0_a, r8

 17858 +	picomv.d	coeff1_a, r6

 17859 +	picomv.d	pc, vmu2_out

 17860 +	picomv.d	r0, inpix2

 17861 +	picomv.d	r8, coeff0_a

 17862 +	picomv.d	r6, coeff1_a

 17863 +	.global	picomv_w

 17864 +picomv_w:

 17865 +	picomv.w	config, pc

 17866 +	picomv.w	inpix2, r0

 17867 +	picomv.w	coeff0_b, r8

 17868 +	picomv.w	coeff1_a, r7

 17869 +	picomv.w	pc, config

 17870 +	picomv.w	r0, inpix2

 17871 +	picomv.w	r8, coeff0_b

 17872 +	picomv.w	r7, coeff1_a

 17873 +	.global	picost_d

 17874 +picost_d:

 17875 +	picost.d	pc[1020], vmu2_out

 17876 +	picost.d	r0[0], inpix2

 17877 +	picost.d	r8++, coeff0_a

 17878 +	picost.d	r7++, coeff1_a

 17879 +	picost.d	r10[r5 << 2], inpix0

 17880 +	picost.d	r3[r6 << 0], vmu0_out

 17881 +	.global	picost_w

 17882 +picost_w:

 17883 +	picost.w	pc[1020], config

 17884 +	picost.w	r0[0], inpix2

 17885 +	picost.w	r8++, coeff0_b

 17886 +	picost.w	r7++, coeff1_a

 17887 +	picost.w	r10[r5 << 2], inpix1

 17888 +	picost.w	r3[r6 << 0], vmu1_out

 17889 +	.global	picostm_d

 17890 +picostm_d:

 17891 +	picostm.d	pc, inpix2-config

 17892 +	picostm.d	r0, inpix2, inpix1

 17893 +	picostm.d	r7, vmu2_out, config

 17894 +	picostm.d	r8, inpix2-vmu1_out

 17895 +	.global	picostm_d_pu

 17896 +picostm_d_pu:

 17897 +	picostm.d	--pc, inpix2, inpix1, inpix0, outpix2, outpix1, outpix0, coeff0_a, coeff0_b, coeff1_a, coeff1_b, coeff2_a, coeff2_b, vmu0_out, vmu1_out, vmu2_out, config

 17898 +	picostm.d	--r0, inpix2, inpix1

 17899 +	picostm.d	--r7, vmu2_out, config

 17900 +	picostm.d	--r8, inpix2, inpix1, inpix0, outpix2, outpix1, outpix0, coeff0_a, coeff0_b, coeff1_a, coeff1_b, coeff2_a, coeff2_b, vmu0_out, vmu1_out

 17901 +	.global	picostm_w

 17902 +picostm_w:

 17903 +	picostm.w	pc, inpix2-coeff0_b

 17904 +	picostm.w	r0, inpix2

 17905 +	picostm.w	r7, coeff0_b

 17906 +	picostm.w	r8, inpix2-coeff0_a

 17907 +	picostm.w	pc, coeff1_a-config

 17908 +	picostm.w	r0, coeff1_a

 17909 +	picostm.w	r7, config

 17910 +	picostm.w	r8, coeff1_a-vmu2_out

 17911 +	.global	picostm_w_pu

 17912 +picostm_w_pu:

 17913 +	picostm.w	--pc, inpix2-coeff0_b

 17914 +	picostm.w	--r0, inpix2

 17915 +	picostm.w	--r7, coeff0_b

 17916 +	picostm.w	--r8, inpix2-coeff0_a

 17917 +	picostm.w	--pc, coeff1_a-config

 17918 +	picostm.w	--r0, coeff1_a

 17919 +	picostm.w	--r7, config

 17920 +	picostm.w	--r8, coeff1_a-vmu2_out

 17921 --- /dev/null

 17922 +++ b/gas/testsuite/gas/avr32/pic_reloc.d

 17923 @@ -0,0 +1,27 @@

 17924 +#as:

 17925 +#objdump: -dr

 17926 +#name: pic_reloc

 17927 +

 17928 +.*: +file format .*

 17929 +

 17930 +Disassembly of section \.text:

 17931 +

 17932 +00000000 <mcall_got>:

 17933 +   0:	f0 16 00 00 	mcall r6\[0\]

 17934 +			0: R_AVR32_GOT18SW	extfunc

 17935 +   4:	f0 16 00 00 	mcall r6\[0\]

 17936 +			4: R_AVR32_GOT18SW	\.L1

 17937 +   8:	f0 16 00 00 	mcall r6\[0\]

 17938 +			8: R_AVR32_GOT18SW	\.L2

 17939 +   c:	f0 16 00 00 	mcall r6\[0\]

 17940 +			c: R_AVR32_GOT18SW	mcall_got

 17941 +

 17942 +00000010 <ldw_got>:

 17943 +  10:	ec f0 00 00 	ld.w r0,r6\[0\]

 17944 +			10: R_AVR32_GOT16S	extvar

 17945 +  14:	ec f0 00 00 	ld.w r0,r6\[0\]

 17946 +			14: R_AVR32_GOT16S	\.L3

 17947 +  18:	ec f0 00 00 	ld.w r0,r6\[0\]

 17948 +			18: R_AVR32_GOT16S	\.L4

 17949 +  1c:	ec f0 00 00 	ld.w r0,r6\[0\]

 17950 +			1c: R_AVR32_GOT16S	ldw_got

 17951 --- /dev/null

 17952 +++ b/gas/testsuite/gas/avr32/pic_reloc.s

 17953 @@ -0,0 +1,18 @@

 17954 +

 17955 +	.text

 17956 +	.global	mcall_got

 17957 +mcall_got:

 17958 +.L1:

 17959 +	mcall	r6[extfunc@got]

 17960 +	mcall	r6[.L1@got]

 17961 +	mcall	r6[.L2@got]

 17962 +	mcall	r6[mcall_got@got]

 17963 +.L2:

 17964 +

 17965 +	.global	ldw_got

 17966 +ldw_got:

 17967 +.L3:	ld.w	r0,r6[extvar@got]

 17968 +	ld.w	r0,r6[.L3@got]

 17969 +	ld.w	r0,r6[.L4@got]

 17970 +	ld.w	r0,r6[ldw_got@got]

 17971 +.L4:

 17972 --- /dev/null

 17973 +++ b/gas/testsuite/gas/avr32/symdiff.d

 17974 @@ -0,0 +1,24 @@

 17975 +#source: symdiff.s

 17976 +#as:

 17977 +#objdump: -dr

 17978 +#name: symdiff

 17979 +

 17980 +.*: +file format .*

 17981 +

 17982 +Disassembly of section \.text:

 17983 +

 17984 +00000000 <diff32>:

 17985 +   0:	00 00       	add r0,r0

 17986 +   2:	00 04       	add r4,r0

 17987 +

 17988 +00000004 <diff16>:

 17989 +   4:	00 04       	add r4,r0

 17990 +

 17991 +00000006 <diff8>:

 17992 +   6:	04 00       	add r0,r2

 17993 +

 17994 +00000008 <symdiff_test>:

 17995 +   8:	d7 03       	nop

 17996 +   a:	d7 03       	nop

 17997 +   c:	d7 03       	nop

 17998 +   e:	d7 03       	nop

 17999 --- /dev/null

 18000 +++ b/gas/testsuite/gas/avr32/symdiff_linkrelax.d

 18001 @@ -0,0 +1,28 @@

 18002 +#source: symdiff.s

 18003 +#as: --linkrelax

 18004 +#objdump: -dr

 18005 +#name: symdiff_linkrelax

 18006 +

 18007 +.*: +file format .*

 18008 +

 18009 +Disassembly of section \.text:

 18010 +

 18011 +00000000 <diff32>:

 18012 +   0:	00 00       	add r0,r0

 18013 +			0: R_AVR32_DIFF32	\.text\+0xa

 18014 +   2:	00 04       	add r4,r0

 18015 +

 18016 +00000004 <diff16>:

 18017 +   4:	00 04       	add r4,r0

 18018 +			4: R_AVR32_DIFF16	\.text\+0xa

 18019 +

 18020 +00000006 <diff8>:

 18021 +   6:	04 00       	add r0,r2

 18022 +			6: R_AVR32_DIFF8	\.text\+0xa

 18023 +			7: R_AVR32_ALIGN	\*ABS\*\+0x1

 18024 +

 18025 +00000008 <symdiff_test>:

 18026 +   8:	d7 03       	nop

 18027 +   a:	d7 03       	nop

 18028 +   c:	d7 03       	nop

 18029 +   e:	d7 03       	nop

 18030 --- /dev/null

 18031 +++ b/gas/testsuite/gas/avr32/symdiff.s

 18032 @@ -0,0 +1,19 @@

 18033 +

 18034 +	.text

 18035 +	.global	diff32

 18036 +diff32:

 18037 +	.long	.L2 - .L1

 18038 +	.global	diff16

 18039 +diff16:

 18040 +	.short	.L2 - .L1

 18041 +	.global	diff8

 18042 +diff8:

 18043 +	.byte	.L2 - .L1

 18044 +

 18045 +	.global	symdiff_test

 18046 +	.align	1

 18047 +symdiff_test:

 18048 +	nop

 18049 +.L1:	nop

 18050 +	nop

 18051 +.L2:	nop

 18052 --- a/gas/write.c

 18053 +++ b/gas/write.c

 18054 @@ -1955,6 +1955,10 @@ relax_frag (segT segment, fragS *fragP,

 18056  #endif /* defined (TC_GENERIC_RELAX_TABLE)  */

 18058 +#ifdef TC_RELAX_ALIGN

 18059 +#define RELAX_ALIGN(SEG, FRAG, ADDR) TC_RELAX_ALIGN(SEG, FRAG, ADDR)

 18060 +#else

 18061 +#define RELAX_ALIGN(SEG, FRAG, ADDR) relax_align(ADDR, (FRAG)->fr_offset)

 18062  /* Relax_align. Advance location counter to next address that has 'alignment'

 18063     lowest order bits all 0s, return size of adjustment made.  */

 18064  static relax_addressT

 18065 @@ -1974,6 +1978,7 @@ relax_align (register relax_addressT add

 18066  #endif

 18067    return (new_address - address);

 18068  }

 18069 +#endif

 18071  /* Now we have a segment, not a crowd of sub-segments, we can make

 18072     fr_address values.

 18073 @@ -2017,7 +2022,7 @@ relax_segment (struct frag *segment_frag

 18074  	case rs_align_code:

 18075  	case rs_align_test:

 18076  	  {

 18077 -	    addressT offset = relax_align (address, (int) fragP->fr_offset);

 18078 +	    addressT offset = RELAX_ALIGN(segment, fragP, address);

 18080  	    if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)

 18081  	      offset = 0;

 18082 @@ -2218,10 +2223,10 @@ relax_segment (struct frag *segment_frag

 18083  		{

 18084  		  addressT oldoff, newoff;

 18086 -		  oldoff = relax_align (was_address + fragP->fr_fix,

 18087 -					(int) offset);

 18088 -		  newoff = relax_align (address + fragP->fr_fix,

 18089 -					(int) offset);

 18090 +		  oldoff = RELAX_ALIGN (segment, fragP,

 18091 +					was_address + fragP->fr_fix);

 18092 +		  newoff = RELAX_ALIGN (segment, fragP,

 18093 +					address + fragP->fr_fix);

 18095  		  if (fragP->fr_subtype != 0)

 18096  		    {

 18097 --- a/include/dis-asm.h

 18098 +++ b/include/dis-asm.h

 18099 @@ -204,13 +204,14 @@ typedef struct disassemble_info

 18101  } disassemble_info;

 18103 -

 18104 +

 18105  /* Standard disassemblers.  Disassemble one instruction at the given

 18106     target address.  Return number of octets processed.  */

 18107  typedef int (*disassembler_ftype) (bfd_vma, disassemble_info *);

 18109  extern int print_insn_alpha		(bfd_vma, disassemble_info *);

 18110  extern int print_insn_avr		(bfd_vma, disassemble_info *);

 18111 +extern int print_insn_avr32		(bfd_vma, disassemble_info *);

 18112  extern int print_insn_bfin		(bfd_vma, disassemble_info *);

 18113  extern int print_insn_big_arm		(bfd_vma, disassemble_info *);

 18114  extern int print_insn_big_mips		(bfd_vma, disassemble_info *);

 18115 @@ -242,7 +243,7 @@ extern int print_insn_little_arm	(bfd_vm

 18116  extern int print_insn_little_mips	(bfd_vma, disassemble_info *);

 18117  extern int print_insn_little_or32	(bfd_vma, disassemble_info *);

 18118  extern int print_insn_little_powerpc	(bfd_vma, disassemble_info *);

 18119 -extern int print_insn_little_score      (bfd_vma, disassemble_info *);

 18120 +extern int print_insn_little_score      (bfd_vma, disassemble_info *);

 18121  extern int print_insn_m32c	        (bfd_vma, disassemble_info *);

 18122  extern int print_insn_m32r		(bfd_vma, disassemble_info *);

 18123  extern int print_insn_m68hc11		(bfd_vma, disassemble_info *);

 18124 @@ -290,7 +291,9 @@ extern void print_i386_disassembler_opti

 18125  extern void print_mips_disassembler_options (FILE *);

 18126  extern void print_ppc_disassembler_options (FILE *);

 18127  extern void print_arm_disassembler_options (FILE *);

 18128 +extern void print_avr32_disassembler_options (FILE *);

 18129  extern void parse_arm_disassembler_option (char *);

 18130 +extern void parse_avr32_disassembler_option (char *);

 18131  extern int  get_arm_regname_num_options (void);

 18132  extern int  set_arm_regname_option (int);

 18133  extern int  get_arm_regnames (int, const char **, const char **, const char *const **);

 18134 @@ -306,7 +309,7 @@ extern void disassemble_init_for_target

 18135  /* Document any target specific options available from the disassembler.  */

 18136  extern void disassembler_usage (FILE *);

 18138 -

 18139 +

 18140  /* This block of definitions is for particular callers who read instructions

 18141     into a buffer before calling the instruction decoder.  */

 18143 --- /dev/null

 18144 +++ b/include/elf/avr32.h

 18145 @@ -0,0 +1,98 @@

 18146 +/* AVR32 ELF support for BFD.

 18147 +   Copyright 2003-2006 Atmel Corporation.

 18148 +

 18149 +   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>

 18150 +

 18151 +   This file is part of BFD, the Binary File Descriptor library.

 18152 +

 18153 +   This program is free software; you can redistribute it and/or

 18154 +   modify it under the terms of the GNU General Public License as

 18155 +   published by the Free Software Foundation; either version 2 of the

 18156 +   License, or (at your option) any later version.

 18157 +

 18158 +   This program is distributed in the hope that it will be useful, but

 18159 +   WITHOUT ANY WARRANTY; without even the implied warranty of

 18160 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 18161 +   General Public License for more details.

 18162 +

 18163 +   You should have received a copy of the GNU General Public License

 18164 +   along with this program; if not, write to the Free Software

 18165 +   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

 18166 +   02111-1307, USA.  */

 18167 +

 18168 +#include "elf/reloc-macros.h"

 18169 +

 18170 +/* CPU-specific flags for the ELF header e_flags field */

 18171 +#define EF_AVR32_LINKRELAX		0x01

 18172 +#define EF_AVR32_PIC			0x02

 18173 +

 18174 +START_RELOC_NUMBERS (elf_avr32_reloc_type)

 18175 +    RELOC_NUMBER (R_AVR32_NONE,			0)

 18176 +

 18177 +    /* Data Relocations */

 18178 +    RELOC_NUMBER (R_AVR32_32,			1)

 18179 +    RELOC_NUMBER (R_AVR32_16,			2)

 18180 +    RELOC_NUMBER (R_AVR32_8,			3)

 18181 +    RELOC_NUMBER (R_AVR32_32_PCREL,		4)

 18182 +    RELOC_NUMBER (R_AVR32_16_PCREL,		5)

 18183 +    RELOC_NUMBER (R_AVR32_8_PCREL,		6)

 18184 +    RELOC_NUMBER (R_AVR32_DIFF32,		7)

 18185 +    RELOC_NUMBER (R_AVR32_DIFF16,		8)

 18186 +    RELOC_NUMBER (R_AVR32_DIFF8,		9)

 18187 +    RELOC_NUMBER (R_AVR32_GOT32,		10)

 18188 +    RELOC_NUMBER (R_AVR32_GOT16,		11)

 18189 +    RELOC_NUMBER (R_AVR32_GOT8,			12)

 18190 +

 18191 +    /* Normal Code Relocations */

 18192 +    RELOC_NUMBER (R_AVR32_21S,			13)

 18193 +    RELOC_NUMBER (R_AVR32_16U,			14)

 18194 +    RELOC_NUMBER (R_AVR32_16S,			15)

 18195 +    RELOC_NUMBER (R_AVR32_8S,			16)

 18196 +    RELOC_NUMBER (R_AVR32_8S_EXT,		17)

 18197 +

 18198 +    /* PC-Relative Code Relocations */

 18199 +    RELOC_NUMBER (R_AVR32_22H_PCREL,		18)

 18200 +    RELOC_NUMBER (R_AVR32_18W_PCREL,		19)

 18201 +    RELOC_NUMBER (R_AVR32_16B_PCREL,		20)

 18202 +    RELOC_NUMBER (R_AVR32_16N_PCREL,		21)

 18203 +    RELOC_NUMBER (R_AVR32_14UW_PCREL,		22)

 18204 +    RELOC_NUMBER (R_AVR32_11H_PCREL,		23)

 18205 +    RELOC_NUMBER (R_AVR32_10UW_PCREL,		24)

 18206 +    RELOC_NUMBER (R_AVR32_9H_PCREL,		25)

 18207 +    RELOC_NUMBER (R_AVR32_9UW_PCREL,		26)

 18208 +

 18209 +    /* Special Code Relocations */

 18210 +    RELOC_NUMBER (R_AVR32_HI16,			27)

 18211 +    RELOC_NUMBER (R_AVR32_LO16,			28)

 18212 +

 18213 +    /* PIC Relocations */

 18214 +    RELOC_NUMBER (R_AVR32_GOTPC,		29)

 18215 +    RELOC_NUMBER (R_AVR32_GOTCALL,		30)

 18216 +    RELOC_NUMBER (R_AVR32_LDA_GOT,		31)

 18217 +    RELOC_NUMBER (R_AVR32_GOT21S,		32)

 18218 +    RELOC_NUMBER (R_AVR32_GOT18SW,		33)

 18219 +    RELOC_NUMBER (R_AVR32_GOT16S,		34)

 18220 +    RELOC_NUMBER (R_AVR32_GOT7UW,		35)

 18221 +

 18222 +    /* Constant Pool Relocations */

 18223 +    RELOC_NUMBER (R_AVR32_32_CPENT,		36)

 18224 +    RELOC_NUMBER (R_AVR32_CPCALL,		37)

 18225 +    RELOC_NUMBER (R_AVR32_16_CP,		38)

 18226 +    RELOC_NUMBER (R_AVR32_9W_CP,		39)

 18227 +

 18228 +    /* Dynamic Relocations */

 18229 +    RELOC_NUMBER (R_AVR32_RELATIVE,		40)

 18230 +    RELOC_NUMBER (R_AVR32_GLOB_DAT,		41)

 18231 +    RELOC_NUMBER (R_AVR32_JMP_SLOT,		42)

 18232 +

 18233 +    /* Linkrelax Information */

 18234 +    RELOC_NUMBER (R_AVR32_ALIGN,		43)

 18235 +

 18236 +    RELOC_NUMBER (R_AVR32_15S,		        44)

 18237 +

 18238 +END_RELOC_NUMBERS (R_AVR32_max)

 18239 +

 18240 +/* Processor specific dynamic array tags.  */

 18241 +

 18242 +/* The total size in bytes of the Global Offset Table */

 18243 +#define DT_AVR32_GOTSZ			0x70000001

 18244 --- a/include/elf/common.h

 18245 +++ b/include/elf/common.h

 18246 @@ -259,6 +259,9 @@

 18247  /* V850 backend magic number.  Written in the absense of an ABI.  */

 18248  #define EM_CYGNUS_V850		0x9080

 18250 +/* AVR32 magic number, picked by IAR Systems. */

 18251 +#define EM_AVR32		0x18ad

 18252 +

 18253  /* old S/390 backend magic number. Written in the absence of an ABI.  */

 18254  #define EM_S390_OLD		0xa390

 18256 --- a/ld/configdoc.texi

 18257 +++ b/ld/configdoc.texi

 18258 @@ -7,6 +7,7 @@

 18259  @set H8300

 18260  @set HPPA

 18261  @set I960

 18262 +@set AVR32

 18263  @set M68HC11

 18264  @set MMIX

 18265  @set MSP430

 18266 --- a/ld/configure.tgt

 18267 +++ b/ld/configure.tgt

 18268 @@ -109,6 +109,9 @@ xscale-*-elf)		targ_emul=armelf

 18269  avr-*-*)		targ_emul=avr2

 18270  			targ_extra_emuls="avr1 avr3 avr4 avr5 avr6"

 18271  			;;

 18272 +avr32-*-none)       targ_emul=avr32elf_ap7000

 18273 +            targ_extra_emuls="avr32elf_ap7001 avr32elf_ap7002 avr32elf_ap7200 avr32elf_uc3a0128 avr32elf_uc3a0256 avr32elf_uc3a0512 avr32elf_uc3a0512es avr32elf_uc3a1128 avr32elf_uc3a1256 avr32elf_uc3a1512es avr32elf_uc3a1512 avr32elf_uc3a364 avr32elf_uc3a364s avr32elf_uc3a3128 avr32elf_uc3a3128s avr32elf_uc3a3256 avr32elf_uc3a3256s avr32elf_uc3b064 avr32elf_uc3b0128 avr32elf_uc3b0256es avr32elf_uc3b0256 avr32elf_uc3b164 avr32elf_uc3b1128 avr32elf_uc3b1256es avr32elf_uc3b1256" ;;

 18274 +avr32-*-linux*)     targ_emul=avr32linux ;;

 18275  bfin-*-elf)		targ_emul=elf32bfin;

 18276  			targ_extra_emuls="elf32bfinfd"

 18277  			targ_extra_libpath=$targ_extra_emuls

 18278 --- /dev/null

 18279 +++ b/ld/emulparams/avr32elf.sh

 18280 @@ -0,0 +1,163 @@

 18281 +# This script is called from ld/genscript.sh

 18282 +# There is a difference on how 'bash' and POSIX handles

 18283 +# the  '.' (source) command in a script.

 18284 +# genscript.sh calls this script with argument ${EMULATION_NAME}

 18285 +# but that will fail on POSIX compilant shells like 'sh' or 'dash'

 18286 +# therefor I use the variable directly instead of $1

 18287 +EMULATION=${EMULATION_NAME}

 18288 +SCRIPT_NAME=elf_xip

 18289 +TEMPLATE_NAME=elf32

 18290 +EXTRA_EM_FILE=avr32elf

 18291 +OUTPUT_FORMAT="elf32-avr32"

 18292 +ARCH=avr32

 18293 +MAXPAGESIZE=4096

 18294 +ENTRY=_start

 18295 +EMBEDDED=yes

 18296 +NO_SMALL_DATA=yes

 18297 +NOP=0xd703d703

 18298 +

 18299 +DATA_SEGMENT_ALIGN=8

 18300 +BSS_ALIGNMENT=8

 18301 +

 18302 +RO_LMA_REGION="FLASH"

 18303 +RO_VMA_REGION="FLASH"

 18304 +RW_LMA_REGION="FLASH"

 18305 +RW_VMA_REGION="CPUSRAM"

 18306 +

 18307 +STACK_SIZE=0x1000

 18308 +STACK_ADDR="ORIGIN(CPUSRAM) + LENGTH(CPUSRAM) - ${STACK_SIZE}"

 18309 +

 18310 +DATA_SEGMENT_END="__heap_start__ = ALIGN(8);

 18311 +  . = ${STACK_ADDR};

 18312 +  __heap_end__ = .;"

 18313 +

 18314 +case "$EMULATION" in

 18315 +avr32elf_ap*)

 18316 +    MACHINE=ap

 18317 +    INITIAL_READONLY_SECTIONS=".reset : {  *(.reset) } >FLASH AT>FLASH

 18318 +    . = . & 0x9fffffff;"

 18319 +    TEXT_START_ADDR=0xa0000000

 18320 +    case "$EMULATION" in

 18321 +	    avr32elf_ap700[0-2])

 18322 +	       MEMORY="MEMORY

 18323 +  {

 18324 +	FLASH (rxai) : ORIGIN = 0x00000000, LENGTH = 64M

 18325 +	CPUSRAM (rwxa) : ORIGIN = 0x24000000, LENGTH = 32K

 18326 +  }"

 18327 +        ;;

 18328 +    avr32elf_ap7200)

 18329 +        MEMORY="MEMORY

 18330 +  {

 18331 +    FLASH (rxai) : ORIGIN = 0x00000000, LENGTH = 64M

 18332 +    CPUSRAM (rwxa) : ORIGIN = 0x08000000, LENGTH = 64K

 18333 +  }"

 18334 +        ;;

 18335 +    esac

 18336 +    ;;

 18337 +

 18338 +avr32elf_uc3*)

 18339 +    MACHINE=uc

 18340 +    INITIAL_READONLY_SECTIONS=".reset : {  *(.reset) } >FLASH AT>FLASH"

 18341 +    TEXT_START_ADDR=0x80000000

 18342 +    OTHER_SECTIONS=".userpage :  {	*(.userpage .userpage.*)  } >USERPAGE AT>USERPAGE

 18343 +  	.factorypage :  {	*(.factorypage .factorypage.*)  } >FACTORYPAGE AT>FACTORYPAGE"

 18344 +

 18345 +    case "$EMULATION" in

 18346 +    avr32elf_uc3a[01]512*)

 18347 +       MEMORY="MEMORY

 18348 +  {

 18349 +    FLASH (rxai!w) : ORIGIN = 0x80000000, LENGTH = 512K

 18350 +    CPUSRAM (wxa!ri) : ORIGIN = 0x00000000, LENGTH = 64K

 18351 +	USERPAGE : ORIGIN = 0x80800000, LENGTH = 512

 18352 +	FACTORYPAGE : ORIGIN = 0x80800200, LENGTH = 512

 18353 +  }"

 18354 +        ;;

 18355 +

 18356 +    avr32elf_uc3a[01]256)

 18357 +        MEMORY="MEMORY

 18358 +  {

 18359 +    FLASH (rxai!w) : ORIGIN = 0x80000000, LENGTH = 256K

 18360 +    CPUSRAM (wxa!ri) : ORIGIN = 0x00000000, LENGTH = 64K

 18361 +	USERPAGE : ORIGIN = 0x80800000, LENGTH = 512

 18362 +	FACTORYPAGE : ORIGIN = 0x80800200, LENGTH = 512

 18363 +  }"

 18364 +        ;;

 18365 +

 18366 +    avr32elf_uc3b[01]256*)

 18367 +        MEMORY="MEMORY

 18368 +  {

 18369 +    FLASH (rxai!w) : ORIGIN = 0x80000000, LENGTH = 256K

 18370 +    CPUSRAM (wxa!ri) : ORIGIN = 0x00000000, LENGTH = 32K

 18371 +	USERPAGE : ORIGIN = 0x80800000, LENGTH = 512

 18372 +	FACTORYPAGE : ORIGIN = 0x80800200, LENGTH = 512

 18373 +  }"

 18374 +        ;;

 18375 +

 18376 +    avr32elf_uc3[ab][01]128)

 18377 +        MEMORY="MEMORY

 18378 +  {

 18379 +    FLASH (rxai!w) : ORIGIN = 0x80000000, LENGTH = 128K

 18380 +    CPUSRAM (wxa!ri) : ORIGIN = 0x00000000, LENGTH = 32K

 18381 +	USERPAGE : ORIGIN = 0x80800000, LENGTH = 512

 18382 +	FACTORYPAGE : ORIGIN = 0x80800200, LENGTH = 512

 18383 +  }"

 18384 +        ;;

 18385 +

 18386 +    avr32elf_uc3b[01]64)

 18387 +        MEMORY="MEMORY

 18388 +  {

 18389 +    FLASH (rxai!w) : ORIGIN = 0x80000000, LENGTH = 64K

 18390 +    CPUSRAM (wxa!ri) : ORIGIN = 0x00000000, LENGTH = 16K

 18391 +	USERPAGE : ORIGIN = 0x80800000, LENGTH = 512

 18392 +	FACTORYPAGE : ORIGIN = 0x80800200, LENGTH = 512

 18393 +  }"

 18394 +        ;;

 18395 +

 18396 +    avr32elf_uc3a3256*)

 18397 +        MEMORY="MEMORY

 18398 +  {

 18399 +    FLASH (rxai!w) : ORIGIN = 0x80000000, LENGTH = 256K

 18400 +    CPUSRAM (wxa!ri) : ORIGIN = 0x00000000, LENGTH = 64K

 18401 +    HSBSRAM (wxa!ri) : ORIGIN = 0xFF000000, LENGTH = 64K

 18402 +	USERPAGE : ORIGIN = 0x80800000, LENGTH = 512

 18403 +	FACTORYPAGE : ORIGIN = 0x80800200, LENGTH = 512

 18404 +  }"

 18405 +  		OTHER_SECTIONS ="${OTHER_SECTIONS}

 18406 +  	.hsbsram       : { *(.hsbsram .hsbsram.*) } >HSBSRAM AT>FLASH :FLASH

 18407 +"

 18408 +

 18409 +        ;;

 18410 +

 18411 +    avr32elf_uc3a3128*)

 18412 +        MEMORY="MEMORY

 18413 +  {

 18414 +    FLASH (rxai!w) : ORIGIN = 0x80000000, LENGTH = 128K

 18415 +    CPUSRAM (wxa!ri) : ORIGIN = 0x00000000, LENGTH = 64K

 18416 +    HSBSRAM (wxa!ri) : ORIGIN = 0xFF000000, LENGTH = 64K

 18417 +    USERPAGE : ORIGIN = 0x80800000, LENGTH = 512

 18418 +    FACTORYPAGE : ORIGIN = 0x80800200, LENGTH = 512

 18419 +  }"

 18420 +  		OTHER_SECTIONS ="${OTHER_SECTIONS}

 18421 +  	.hsbsram       : { *(.hsbsram .hsbsram.*) } >HSBSRAM AT>FLASH :FLASH

 18422 +"

 18423 +        ;;

 18424 +

 18425 +    avr32elf_uc3a364*)

 18426 +        MEMORY="MEMORY

 18427 +  {

 18428 +    FLASH (rxai!w) : ORIGIN = 0x80000000, LENGTH = 64K

 18429 +    CPUSRAM (wxa!ri) : ORIGIN = 0x00000000, LENGTH = 64K

 18430 +    HSBSRAM (wxa!ri) : ORIGIN = 0xFF000000, LENGTH = 64K

 18431 +	USERPAGE : ORIGIN = 0x80800000, LENGTH = 512

 18432 +	FACTORYPAGE : ORIGIN = 0x80800200, LENGTH = 512

 18433 +  }"

 18434 +  		OTHER_SECTIONS ="${OTHER_SECTIONS}

 18435 +  	.hsbsram       : { *(.hsbsram .hsbsram.*) } >HSBSRAM AT>FLASH :FLASH

 18436 +"

 18437 +        ;;

 18438 +

 18439 +

 18440 +    esac

 18441 +    ;;

 18442 +

 18443 +esac

 18444 --- /dev/null

 18445 +++ b/ld/emulparams/avr32linux.sh

 18446 @@ -0,0 +1,14 @@

 18447 +ARCH=avr32

 18448 +SCRIPT_NAME=elf

 18449 +TEMPLATE_NAME=elf32

 18450 +EXTRA_EM_FILE=avr32elf

 18451 +OUTPUT_FORMAT="elf32-avr32"

 18452 +GENERATE_SHLIB_SCRIPT=yes

 18453 +MAXPAGESIZE=0x1000

 18454 +TEXT_START_ADDR=0x00001000

 18455 +NOP=0xd703d703

 18456 +

 18457 +# This appears to place the GOT before the data section, which is

 18458 +# essential for uClinux.  We don't use those .s* sections on AVR32

 18459 +# anyway, so it shouldn't hurt for regular Linux either...

 18460 +NO_SMALL_DATA=yes

 18461 --- /dev/null

 18462 +++ b/ld/emultempl/avr32elf.em

 18463 @@ -0,0 +1,133 @@

 18464 +# This shell script emits a C file. -*- C -*-

 18465 +#   Copyright (C) 2007 Atmel Corporation

 18466 +#

 18467 +# This file is part of GLD, the Gnu Linker.

 18468 +#

 18469 +# This program is free software; you can redistribute it and/or modify

 18470 +# it under the terms of the GNU General Public License as published by

 18471 +# the Free Software Foundation; either version 2 of the License, or

 18472 +# (at your option) any later version.

 18473 +#

 18474 +# This program is distributed in the hope that it will be useful,

 18475 +# but WITHOUT ANY WARRANTY; without even the implied warranty of

 18476 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 18477 +# GNU General Public License for more details.

 18478 +#

 18479 +# You should have received a copy of the GNU General Public License

 18480 +# along with this program; if not, write to the Free Software

 18481 +# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.

 18482 +#

 18483 +

 18484 +# This file is sourced from elf32.em, and defines extra avr32-elf

 18485 +# specific routines.

 18486 +#

 18487 +

 18488 +# Generate linker script for writable rodata

 18489 +LD_FLAG=rodata-writable

 18490 +DATA_ALIGNMENT=${DATA_ALIGNMENT_}

 18491 +RELOCATING=" "

 18492 +WRITABLE_RODATA=" "

 18493 +( echo "/* Linker script for writable rodata */"

 18494 +  . ${CUSTOMIZER_SCRIPT} ${EMULATION_NAME}

 18495 +  . ${srcdir}/scripttempl/${SCRIPT_NAME}.sc

 18496 +) | sed -e '/^ *$/d;s/[ 	]*$//' > ldscripts/${EMULATION_NAME}.xwr

 18497 +

 18498 +

 18499 +cat >> e${EMULATION_NAME}.c <<EOF

 18500 +

 18501 +#include "libbfd.h"

 18502 +#include "elf32-avr32.h"

 18503 +

 18504 +/* Whether to allow direct references (sub or mov) to SEC_DATA and

 18505 +   !SEC_CONTENTS sections when optimizing.  Not enabled by default

 18506 +   since it might cause link errors.  */

 18507 +static int direct_data_refs = 0;

 18508 +

 18509 +static void avr32_elf_after_open (void)

 18510 +{

 18511 +  bfd_elf32_avr32_set_options (&link_info, direct_data_refs);

 18512 +  gld${EMULATION_NAME}_after_open ();

 18513 +}

 18514 +

 18515 +static int rodata_writable = 0;

 18516 +

 18517 +static char * gld${EMULATION_NAME}_get_script (int *isfile);

 18518 +

 18519 +static char * avr32_elf_get_script (int *isfile)

 18520 +{

 18521 +  if ( rodata_writable )

 18522 +    {

 18523 +EOF

 18524 +if test -n "$COMPILE_IN"

 18525 +then

 18526 +# Scripts compiled in.

 18527 +

 18528 +# sed commands to quote an ld script as a C string.

 18529 +sc="-f stringify.sed"

 18530 +

 18531 +cat >>e${EMULATION_NAME}.c <<EOF

 18532 +      *isfile = 0;

 18533 +      return

 18534 +EOF

 18535 +sed $sc ldscripts/${EMULATION_NAME}.xwr			>> e${EMULATION_NAME}.c

 18536 +echo  ';'	                                        >> e${EMULATION_NAME}.c

 18537 +else

 18538 +# Scripts read from the filesystem.

 18539 +

 18540 +cat >>e${EMULATION_NAME}.c <<EOF

 18541 +      *isfile = 1;

 18542 +      return "ldscripts/${EMULATION_NAME}.xwr";

 18543 +EOF

 18544 +fi

 18545 +

 18546 +cat >>e${EMULATION_NAME}.c <<EOF

 18547 +    }

 18548 +  return gld${EMULATION_NAME}_get_script (isfile);

 18549 +}

 18550 +

 18551 +

 18552 +EOF

 18553 +

 18554 +# Define some shell vars to insert bits of code into the standard elf

 18555 +# parse_args and list_options functions.

 18556 +#

 18557 +PARSE_AND_LIST_PROLOGUE='

 18558 +#define OPTION_DIRECT_DATA		300

 18559 +#define OPTION_NO_DIRECT_DATA		301

 18560 +#define OPTION_RODATA_WRITABLE		302

 18561 +#define OPTION_NO_RODATA_WRITABLE	303

 18562 +'

 18563 +

 18564 +PARSE_AND_LIST_LONGOPTS='

 18565 +  { "direct-data", no_argument, NULL, OPTION_DIRECT_DATA },

 18566 +  { "no-direct-data", no_argument, NULL, OPTION_NO_DIRECT_DATA },

 18567 +  { "rodata-writable", no_argument, NULL, OPTION_RODATA_WRITABLE },

 18568 +  { "no-rodata-writable", no_argument, NULL, OPTION_NO_RODATA_WRITABLE },

 18569 +'

 18570 +

 18571 +PARSE_AND_LIST_OPTIONS='

 18572 +  fprintf (file, _("  --direct-data\t\tAllow direct data references when optimizing\n"));

 18573 +  fprintf (file, _("  --no-direct-data\tDo not allow direct data references when optimizing\n"));

 18574 +  fprintf (file, _("  --rodata-writable\tPut read-only data in writable data section\n"));

 18575 +  fprintf (file, _("  --no-rodata-writable\tDo not put read-only data in writable data section\n"));

 18576 +'

 18577 +

 18578 +PARSE_AND_LIST_ARGS_CASES='

 18579 +    case OPTION_DIRECT_DATA:

 18580 +      direct_data_refs = 1;

 18581 +      break;

 18582 +    case OPTION_NO_DIRECT_DATA:

 18583 +      direct_data_refs = 0;

 18584 +      break;

 18585 +    case OPTION_RODATA_WRITABLE:

 18586 +      rodata_writable = 1;

 18587 +      break;

 18588 +    case OPTION_NO_RODATA_WRITABLE:

 18589 +      rodata_writable = 0;

 18590 +      break;

 18591 +'

 18592 +

 18593 +# Replace some of the standard ELF functions with our own versions.

 18594 +#

 18595 +LDEMUL_AFTER_OPEN=avr32_elf_after_open

 18596 +LDEMUL_GET_SCRIPT=avr32_elf_get_script

 18597 --- a/ld/ld.info

 18598 +++ b/ld/ld.info

 18599 @@ -4347,6 +4347,8 @@ not listed.

 18601  * ARM::				`ld' and the ARM family

 18603 +* AVR32::                       `ld' and AVR32 processors

 18604 +

 18605  * HPPA ELF32::                  `ld' and HPPA 32-bit ELF

 18607  * MMIX::			`ld' and MMIX

 18608 @@ -4487,7 +4489,7 @@ PIC.  This avoids problems on uClinux ta

 18609  used to generate relocatable binaries.

 18612 -File: ld.info,  Node: ARM,  Next: HPPA ELF32,  Prev: i960,  Up: Machine Dependent

 18613 +File: ld.info,  Node: ARM,  Next: AV32,  Prev: i960,  Up: Machine Dependent

 18615  4.4 `ld' and the ARM family

 18616  ===========================

 18617 @@ -4588,7 +4590,31 @@ enumeration values fitted into the small

 18618  diagnosed.

 18621 -File: ld.info,  Node: HPPA ELF32,  Next: MMIX,  Prev: ARM,  Up: Machine Dependent

 18622 +File: ld.info,  Node: AVR32,  Next: HPPA ELF32,  Prev: ARM,  Up: Machine Dependent

 18623 +

 18624 +4.4 `ld' and AVR32 processors

 18625 +=============================

 18626 +

 18627 +`--direct-data'

 18628 +

 18629 +`--no-direct-data'

 18630 +     Taking the address of a symbol can often be done by using a direct

 18631 +     `mov' or pc-relative `sub' instruction, which is faster than using

 18632 +     a PC- or GOT-relative load, especially on the uC3 processors.

 18633 +     However, this does not always work when dealing with symbols in

 18634 +     the `.data' section so this optimization is disabled by default.

 18635 +

 18636 +     Specifying `--direct-data' will enable this optimization. Note

 18637 +     that this may cause `relocation truncated to fit' errors for

 18638 +     certain large programs. If this happens, the optimization can be

 18639 +     turned off by specifying `--no-direct-data'.

 18640 +

 18641 +     All known issues with direct data optimizations are detected at

 18642 +     link time, so if the linker doesn't complain, the result should

 18643 +     run just fine.

 18644 +

 18645 +

 18646 +File: ld.info,  Node: HPPA ELF32,  Next: MMIX,  Prev: AVR32,  Up: Machine Dependent

 18648  4.5 `ld' and HPPA 32-bit ELF Support

 18649  ====================================

 18650 @@ -6336,6 +6362,7 @@ LD Index

 18651  * --no-check-sections:                   Options.            (line  765)

 18652  * --no-define-common:                    Options.            (line  787)

 18653  * --no-demangle:                         Options.            (line  816)

 18654 +* --no-direct-data:                      AVR32.              (line    6)

 18655  * --no-dotsyms:                          PowerPC64 ELF64.    (line   33)

 18656  * --no-enum-size-warning:                ARM.                (line   94)

 18657  * --no-gc-sections:                      Options.            (line  848)

 18658 @@ -6534,6 +6561,7 @@ LD Index

 18659  * AT(LMA):                               Output Section LMA. (line    6)

 18660  * AT>LMA_REGION:                         Output Section LMA. (line    6)

 18661  * automatic data imports:                WIN32.              (line  170)

 18662 +* AVR32 options:                         AVR32.              (line    6)

 18663  * back end:                              BFD.                (line    6)

 18664  * BASE (MRI):                            MRI.                (line   54)

 18665  * BE8:                                   ARM.                (line   23)

 18666 @@ -7018,6 +7046,7 @@ Node: H8/300183897

 18667  Node: i960185522

 18668  Node: M68HC11/68HC12187207

 18669  Node: ARM188910

 18670 +Node: AVR32182578

 18671  Node: HPPA ELF32193760

 18672  Node: MMIX195383

 18673  Node: MSP430196600

 18674 --- a/ld/ld.texinfo

 18675 +++ b/ld/ld.texinfo

 18676 @@ -21,6 +21,7 @@

 18677  @set UsesEnvVars

 18678  @set GENERIC

 18679  @set ARM

 18680 +@set AVR32

 18681  @set H8300

 18682  @set HPPA

 18683  @set I960

 18684 @@ -139,6 +140,9 @@ section entitled ``GNU Free Documentatio

 18685  @ifset ARM

 18686  * ARM::				ld and the ARM family

 18687  @end ifset

 18688 +@ifset AVR32

 18689 +* AVR32::                       ld and AVR32 processors

 18690 +@end ifset

 18691  @ifset HPPA

 18692  * HPPA ELF32::                  ld and HPPA 32-bit ELF

 18693  @end ifset

 18694 @@ -5248,6 +5252,9 @@ functionality are not listed.

 18695  @ifset ARM

 18696  * ARM::				@command{ld} and the ARM family

 18697  @end ifset

 18698 +@ifset AVR32

 18699 +* AVR32::                       @command{ld} and AVR32 processors

 18700 +@end ifset

 18701  @ifset HPPA

 18702  * HPPA ELF32::                  @command{ld} and HPPA 32-bit ELF

 18703  @end ifset

 18704 @@ -5589,6 +5596,52 @@ not be diagnosed.

 18705  @end ifclear

 18706  @end ifset

 18708 +@ifset AVR32

 18709 +@ifclear GENERIC

 18710 +@raisesections

 18711 +@end ifclear

 18712 +

 18713 +@node AVR32

 18714 +@section @command{ld} and AVR32 processors

 18715 +@cindex AVR32 options

 18716 +@table @option

 18717 +@kindex --direct-data

 18718 +@kindex --no-direct-data

 18719 +@item --direct-data

 18720 +@item --no-direct-data

 18721 +Taking the address of a symbol can often be done by using a direct

 18722 +@code{mov} or pc-relative @code{sub} instruction, which is faster than

 18723 +using a PC- or GOT-relative load, especially on the uC3

 18724 +processors. However, this does not always work when dealing with

 18725 +symbols in the @code{.data} section so this optimization is disabled

 18726 +by default.

 18727 +

 18728 +Specifying @option{--direct-data} will enable this optimization. Note

 18729 +that this may cause @samp{relocation truncated to fit} errors for

 18730 +certain large programs. If this happens, the optimization can be

 18731 +turned off by specifying @option{--no-direct-data}.

 18732 +

 18733 +All known issues with direct data optimizations are detected at link

 18734 +time, so if the linker doesn't complain, the result should run just

 18735 +fine.

 18736 +

 18737 +@kindex --rodata-writable

 18738 +@kindex --no-rodata-writable

 18739 +@item --rodata-writable

 18740 +@item --no-rodata-writable

 18741 +Using the @option{--rodata-writable} options will cause the linker

 18742 +to try and use a linker script where read-only data will be placed

 18743 +in the same section as writable data. This can give great performance

 18744 +gain on cacheless processors where read-only data normally is placed in

 18745 +flash, and writable data is placed in internal sram. This will however

 18746 +come at the expence of a larger memory footprint.

 18747 +@end table

 18748 +

 18749 +@ifclear GENERIC

 18750 +@lowersections

 18751 +@end ifclear

 18752 +@end ifset

 18753 +

 18754  @ifset HPPA

 18755  @ifclear GENERIC

 18756  @raisesections

 18757 --- a/ld/Makefile.am

 18758 +++ b/ld/Makefile.am

 18759 @@ -137,7 +137,34 @@ ALL_EMULATIONS = \

 18760  	eavr3.o \

 18761  	eavr4.o \

 18762  	eavr5.o \

 18763 -	eavr6.o \

 18764 +    eavr6.o \

 18765 +	eavr32elf_ap7000.o \

 18766 +	eavr32elf_ap7001.o \

 18767 +	eavr32elf_ap7002.o \

 18768 +	eavr32elf_ap7200.o \

 18769 +	eavr32elf_uc3a0128.o \

 18770 +	eavr32elf_uc3a0256.o \

 18771 +	eavr32elf_uc3a0512.o \

 18772 +	eavr32elf_uc3a0512es.o \

 18773 +	eavr32elf_uc3a1128.o \

 18774 +	eavr32elf_uc3a1256.o \

 18775 +	eavr32elf_uc3a1512es.o \

 18776 +	eavr32elf_uc3a1512.o \

 18777 +	eavr32elf_uc3a364.o \

 18778 +	eavr32elf_uc3a364s.o \

 18779 +	eavr32elf_uc3a3128.o \

 18780 +	eavr32elf_uc3a3128s.o \

 18781 +	eavr32elf_uc3a3256.o \

 18782 +	eavr32elf_uc3a3256s.o \

 18783 +	eavr32elf_uc3b064.o \

 18784 +	eavr32elf_uc3b0128.o \

 18785 +	eavr32elf_uc3b0256es.o \

 18786 +	eavr32elf_uc3b0256.o \

 18787 +	eavr32elf_uc3b164.o \

 18788 +	eavr32elf_uc3b1128.o \

 18789 +	eavr32elf_uc3b1256es.o \

 18790 +	eavr32elf_uc3b1256.o \

 18791 +	eavr32linux.o \

 18792  	ecoff_i860.o \

 18793  	ecoff_sparc.o \

 18794  	eelf32_spu.o \

 18795 @@ -622,6 +649,114 @@ eavr6.c: $(srcdir)/emulparams/avr6.sh $(

 18796    $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \

 18797    ${GEN_DEPENDS}

 18798  	${GENSCRIPTS} avr6 "$(tdir_avr2)"

 18799 +eavr32elf_ap7000.c: $(srcdir)/emulparams/avr32elf.sh \

 18800 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18801 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18802 +	${GENSCRIPTS} avr32elf_ap7000 "$(tdir_avr32)" avr32elf

 18803 +eavr32elf_ap7001.c: $(srcdir)/emulparams/avr32elf.sh \

 18804 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18805 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18806 +	${GENSCRIPTS} avr32elf_ap7001 "$(tdir_avr32)" avr32elf

 18807 +eavr32elf_ap7002.c: $(srcdir)/emulparams/avr32elf.sh \

 18808 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18809 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18810 +	${GENSCRIPTS} avr32elf_ap7002 "$(tdir_avr32)" avr32elf

 18811 +eavr32elf_ap7200.c: $(srcdir)/emulparams/avr32elf.sh \

 18812 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18813 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18814 +	${GENSCRIPTS} avr32elf_ap7200 "$(tdir_avr32)" avr32elf

 18815 +eavr32elf_uc3a0128.c: $(srcdir)/emulparams/avr32elf.sh \

 18816 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18817 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18818 +	${GENSCRIPTS} avr32elf_uc3a0128 "$(tdir_avr32)" avr32elf

 18819 +eavr32elf_uc3a0256.c: $(srcdir)/emulparams/avr32elf.sh \

 18820 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18821 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18822 +	${GENSCRIPTS} avr32elf_uc3a0256 "$(tdir_avr32)" avr32elf

 18823 +eavr32elf_uc3a0512.c: $(srcdir)/emulparams/avr32elf.sh \

 18824 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18825 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18826 +	${GENSCRIPTS} avr32elf_uc3a0512 "$(tdir_avr32)" avr32elf

 18827 +eavr32elf_uc3a0512es.c: $(srcdir)/emulparams/avr32elf.sh \

 18828 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18829 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18830 +	${GENSCRIPTS} avr32elf_uc3a0512es "$(tdir_avr32)" avr32elf

 18831 +eavr32elf_uc3a1128.c: $(srcdir)/emulparams/avr32elf.sh \

 18832 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18833 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18834 +	${GENSCRIPTS} avr32elf_uc3a1128 "$(tdir_avr32)" avr32elf

 18835 +eavr32elf_uc3a1256.c: $(srcdir)/emulparams/avr32elf.sh \

 18836 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18837 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18838 +	${GENSCRIPTS} avr32elf_uc3a1256 "$(tdir_avr32)" avr32elf

 18839 +eavr32elf_uc3a1512.c: $(srcdir)/emulparams/avr32elf.sh \

 18840 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18841 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18842 +	${GENSCRIPTS} avr32elf_uc3a1512 "$(tdir_avr32)" avr32elf

 18843 +eavr32elf_uc3a1512es.c: $(srcdir)/emulparams/avr32elf.sh \

 18844 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18845 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18846 +	${GENSCRIPTS} avr32elf_uc3a1512es "$(tdir_avr32)" avr32elf

 18847 +eavr32elf_uc3a364.c: $(srcdir)/emulparams/avr32elf.sh \

 18848 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18849 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18850 +	${GENSCRIPTS} avr32elf_uc3a364 "$(tdir_avr32)" avr32elf

 18851 +eavr32elf_uc3a364s.c: $(srcdir)/emulparams/avr32elf.sh \

 18852 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18853 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18854 +	${GENSCRIPTS} avr32elf_uc3a364s "$(tdir_avr32)" avr32elf

 18855 +eavr32elf_uc3a3128.c: $(srcdir)/emulparams/avr32elf.sh \

 18856 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18857 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18858 +	${GENSCRIPTS} avr32elf_uc3a3128 "$(tdir_avr32)" avr32elf

 18859 +eavr32elf_uc3a3128s.c: $(srcdir)/emulparams/avr32elf.sh \

 18860 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18861 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18862 +	${GENSCRIPTS} avr32elf_uc3a3128s "$(tdir_avr32)" avr32elf

 18863 +eavr32elf_uc3a3256.c: $(srcdir)/emulparams/avr32elf.sh \

 18864 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18865 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18866 +	${GENSCRIPTS} avr32elf_uc3a3256 "$(tdir_avr32)" avr32elf

 18867 +eavr32elf_uc3a3256s.c: $(srcdir)/emulparams/avr32elf.sh \

 18868 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18869 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18870 +	${GENSCRIPTS} avr32elf_uc3a3256s "$(tdir_avr32)" avr32elf

 18871 +eavr32elf_uc3b064.c: $(srcdir)/emulparams/avr32elf.sh \

 18872 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18873 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18874 +	${GENSCRIPTS} avr32elf_uc3b064 "$(tdir_avr32)" avr32elf

 18875 +eavr32elf_uc3b0128.c: $(srcdir)/emulparams/avr32elf.sh \

 18876 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18877 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18878 +	${GENSCRIPTS} avr32elf_uc3b0128 "$(tdir_avr32)" avr32elf

 18879 +eavr32elf_uc3b0256.c: $(srcdir)/emulparams/avr32elf.sh \

 18880 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18881 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18882 +	${GENSCRIPTS} avr32elf_uc3b0256 "$(tdir_avr32)" avr32elf

 18883 +eavr32elf_uc3b0256es.c: $(srcdir)/emulparams/avr32elf.sh \

 18884 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18885 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18886 +	${GENSCRIPTS} avr32elf_uc3b0256es "$(tdir_avr32)" avr32elf

 18887 +eavr32elf_uc3b164.c: $(srcdir)/emulparams/avr32elf.sh \

 18888 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18889 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18890 +	${GENSCRIPTS} avr32elf_uc3b164 "$(tdir_avr32)" avr32elf

 18891 +eavr32elf_uc3b1128.c: $(srcdir)/emulparams/avr32elf.sh \

 18892 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18893 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18894 +	${GENSCRIPTS} avr32elf_uc3b1128 "$(tdir_avr32)" avr32elf

 18895 +eavr32elf_uc3b1256.c: $(srcdir)/emulparams/avr32elf.sh \

 18896 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18897 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18898 +	${GENSCRIPTS} avr32elf_uc3b1256 "$(tdir_avr32)" avr32elf

 18899 +eavr32elf_uc3b1256es.c: $(srcdir)/emulparams/avr32elf.sh \

 18900 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18901 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 18902 +	${GENSCRIPTS} avr32elf_uc3b1256es "$(tdir_avr32)" avr32elf

 18903 +eavr32linux.c: $(srcdir)/emulparams/avr32linux.sh \

 18904 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 18905 +  $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS}

 18906 +	${GENSCRIPTS} avr32linux "$(tdir_avr32)"

 18907  ecoff_i860.c: $(srcdir)/emulparams/coff_i860.sh \

 18908    $(srcdir)/emultempl/generic.em $(srcdir)/scripttempl/i860coff.sc ${GEN_DEPENDS}

 18909  	${GENSCRIPTS} coff_i860 "$(tdir_coff_i860)"

 18910 @@ -1877,7 +2012,9 @@ install-exec-local: ld-new$(EXEEXT)

 18911  	  || $(LIBTOOL) --mode=install $(INSTALL_PROGRAM) ld-new$(EXEEXT) $(DESTDIR)$(tooldir)/bin/ld$(EXEEXT); \

 18912  	fi

 18914 -install-data-local:

 18915 +# We want install to imply install-info as per GNU standards, despite the

 18916 +# cygnus option.

 18917 +install-data-local: install-info

 18918  	$(mkinstalldirs) $(DESTDIR)$(scriptdir)/ldscripts

 18919  	for f in ldscripts/*; do \

 18920  	  $(INSTALL_DATA) $$f $(DESTDIR)$(scriptdir)/$$f ; \

 18921 --- /dev/null

 18922 +++ b/ld/scripttempl/elf_xip.sc

 18923 @@ -0,0 +1,456 @@

 18924 +#

 18925 +# Unusual variables checked by this code:

 18926 +#	NOP - four byte opcode for no-op (defaults to 0)

 18927 +#	NO_SMALL_DATA - no .sbss/.sbss2/.sdata/.sdata2 sections if not

 18928 +#		empty.

 18929 +#	SMALL_DATA_CTOR - .ctors contains small data.

 18930 +#	SMALL_DATA_DTOR - .dtors contains small data.

 18931 +#	DATA_ADDR - if end-of-text-plus-one-page isn't right for data start

 18932 +#	INITIAL_READONLY_SECTIONS - at start of text segment

 18933 +#	OTHER_READONLY_SECTIONS - other than .text .init .rodata ...

 18934 +#		(e.g., .PARISC.milli)

 18935 +#	OTHER_TEXT_SECTIONS - these get put in .text when relocating

 18936 +#	OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ...

 18937 +#		(e.g., .PARISC.global)

 18938 +#	OTHER_RELRO_SECTIONS - other than .data.rel.ro ...

 18939 +#		(e.g. PPC32 .fixup, .got[12])

 18940 +#	OTHER_BSS_SECTIONS - other than .bss .sbss ...

 18941 +#	OTHER_SECTIONS - at the end

 18942 +#	EXECUTABLE_SYMBOLS - symbols that must be defined for an

 18943 +#		executable (e.g., _DYNAMIC_LINK)

 18944 +#       TEXT_START_ADDR - the first byte of the text segment, after any

 18945 +#               headers.

 18946 +#       TEXT_BASE_ADDRESS - the first byte of the text segment.

 18947 +#	TEXT_START_SYMBOLS - symbols that appear at the start of the

 18948 +#		.text section.

 18949 +#	DATA_START_SYMBOLS - symbols that appear at the start of the

 18950 +#		.data section.

 18951 +#	OTHER_GOT_SYMBOLS - symbols defined just before .got.

 18952 +#	OTHER_GOT_SECTIONS - sections just after .got.

 18953 +#	OTHER_SDATA_SECTIONS - sections just after .sdata.

 18954 +#	OTHER_BSS_SYMBOLS - symbols that appear at the start of the

 18955 +#		.bss section besides __bss_start.

 18956 +#	DATA_PLT - .plt should be in data segment, not text segment.

 18957 +#	PLT_BEFORE_GOT - .plt just before .got when .plt is in data segement.

 18958 +#	BSS_PLT - .plt should be in bss segment

 18959 +#	TEXT_DYNAMIC - .dynamic in text segment, not data segment.

 18960 +#	EMBEDDED - whether this is for an embedded system.

 18961 +#	SHLIB_TEXT_START_ADDR - if set, add to SIZEOF_HEADERS to set

 18962 +#		start address of shared library.

 18963 +#	INPUT_FILES - INPUT command of files to always include

 18964 +#	WRITABLE_RODATA - if set, the .rodata section should be writable

 18965 +#	INIT_START, INIT_END -  statements just before and just after

 18966 +# 	combination of .init sections.

 18967 +#	FINI_START, FINI_END - statements just before and just after

 18968 +# 	combination of .fini sections.

 18969 +#	STACK_ADDR - start of a .stack section.

 18970 +#	OTHER_END_SYMBOLS - symbols to place right at the end of the script.

 18971 +#	SEPARATE_GOTPLT - if set, .got.plt should be separate output section,

 18972 +#		so that .got can be in the RELRO area.  It should be set to

 18973 +#		the number of bytes in the beginning of .got.plt which can be

 18974 +#		in the RELRO area as well.

 18975 +#

 18976 +# When adding sections, do note that the names of some sections are used

 18977 +# when specifying the start address of the next.

 18978 +#

 18979 +

 18980 +#  Many sections come in three flavours.  There is the 'real' section,

 18981 +#  like ".data".  Then there are the per-procedure or per-variable

 18982 +#  sections, generated by -ffunction-sections and -fdata-sections in GCC,

 18983 +#  and useful for --gc-sections, which for a variable "foo" might be

 18984 +#  ".data.foo".  Then there are the linkonce sections, for which the linker

 18985 +#  eliminates duplicates, which are named like ".gnu.linkonce.d.foo".

 18986 +#  The exact correspondences are:

 18987 +#

 18988 +#  Section	Linkonce section

 18989 +#  .text	.gnu.linkonce.t.foo

 18990 +#  .rodata	.gnu.linkonce.r.foo

 18991 +#  .data	.gnu.linkonce.d.foo

 18992 +#  .bss		.gnu.linkonce.b.foo

 18993 +#  .sdata	.gnu.linkonce.s.foo

 18994 +#  .sbss	.gnu.linkonce.sb.foo

 18995 +#  .sdata2	.gnu.linkonce.s2.foo

 18996 +#  .sbss2	.gnu.linkonce.sb2.foo

 18997 +#  .debug_info	.gnu.linkonce.wi.foo

 18998 +#  .tdata	.gnu.linkonce.td.foo

 18999 +#  .tbss	.gnu.linkonce.tb.foo

 19000 +#

 19001 +#  Each of these can also have corresponding .rel.* and .rela.* sections.

 19002 +

 19003 +test -z "$ENTRY" && ENTRY=_start

 19004 +test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}

 19005 +test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}

 19006 +if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi

 19007 +test -z "${ELFSIZE}" && ELFSIZE=32

 19008 +test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"

 19009 +test "$LD_FLAG" = "N" && DATA_ADDR=.

 19010 +test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""

 19011 +test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""

 19012 +test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT

 19013 +if test -n "$RELOCATING"; then

 19014 +  RO_REGION="${RO_VMA_REGION+ >}${RO_VMA_REGION}${RO_LMA_REGION+ AT>}${RO_LMA_REGION}"

 19015 +  RW_REGION="${RW_VMA_REGION+ >}${RW_VMA_REGION}${RW_LMA_REGION+ AT>}${RW_LMA_REGION}"

 19016 +else

 19017 +  RO_REGION=""

 19018 +  RW_REGION=""

 19019 +fi

 19020 +INTERP=".interp       ${RELOCATING-0} : { *(.interp) }${RO_REGION}"

 19021 +PLT=".plt          ${RELOCATING-0} : { *(.plt) }"

 19022 +if test -z "$GOT"; then

 19023 +  if test -z "$SEPARATE_GOTPLT"; then

 19024 +    GOT=".got          ${RELOCATING-0} : { *(.got.plt) *(.got) }"

 19025 +  else

 19026 +    GOT=".got          ${RELOCATING-0} : { *(.got) }"

 19027 +    GOTPLT="${RELOCATING+${DATA_SEGMENT_RELRO_GOTPLT_END}}

 19028 +  .got.plt      ${RELOCATING-0} : { *(.got.plt) }"

 19029 +  fi

 19030 +fi

 19031 +DALIGN=".dalign	: { . = ALIGN(${DATA_SEGMENT_ALIGN}); PROVIDE(_data_lma = .); }${RO_REGION}"

 19032 +BALIGN=".balign	: { . = ALIGN(${BSS_ALIGNMENT}); _edata = .; }${RW_REGION}"

 19033 +DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"

 19034 +RODATA=".rodata       ${RELOCATING-0} : { *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.*}) }"

 19035 +DATARELRO=".data.rel.ro : { *(.data.rel.ro.local) *(.data.rel.ro*) }${RW_REGION}"

 19036 +STACKNOTE="/DISCARD/ : { *(.note.GNU-stack) }"

 19037 +if test -z "${NO_SMALL_DATA}"; then

 19038 +  SBSS=".sbss         ${RELOCATING-0} :

 19039 +  {

 19040 +    ${RELOCATING+PROVIDE (__sbss_start = .);}

 19041 +    ${RELOCATING+PROVIDE (___sbss_start = .);}

 19042 +    ${CREATE_SHLIB+*(.sbss2 .sbss2.* .gnu.linkonce.sb2.*)}

 19043 +    *(.dynsbss)

 19044 +    *(.sbss${RELOCATING+ .sbss.* .gnu.linkonce.sb.*})

 19045 +    *(.scommon)

 19046 +    ${RELOCATING+PROVIDE (__sbss_end = .);}

 19047 +    ${RELOCATING+PROVIDE (___sbss_end = .);}

 19048 +  }${RW_REGION}"

 19049 +  SBSS2=".sbss2        ${RELOCATING-0} : { *(.sbss2${RELOCATING+ .sbss2.* .gnu.linkonce.sb2.*}) }${RW_REGION}"

 19050 +  SDATA="/* We want the small data sections together, so single-instruction offsets

 19051 +     can access them all, and initialized data all before uninitialized, so

 19052 +     we can shorten the on-disk segment size.  */

 19053 +  .sdata        ${RELOCATING-0} :

 19054 +  {

 19055 +    ${RELOCATING+${SDATA_START_SYMBOLS}}

 19056 +    ${CREATE_SHLIB+*(.sdata2 .sdata2.* .gnu.linkonce.s2.*)}

 19057 +    *(.sdata${RELOCATING+ .sdata.* .gnu.linkonce.s.*})

 19058 +  }${RW_REGION}"

 19059 +  SDATA2=".sdata2       ${RELOCATING-0} : { *(.sdata2${RELOCATING+ .sdata2.* .gnu.linkonce.s2.*}) }${RW_REGION}"

 19060 +  REL_SDATA=".rel.sdata    ${RELOCATING-0} : { *(.rel.sdata${RELOCATING+ .rel.sdata.* .rel.gnu.linkonce.s.*}) }${RO_REGION}

 19061 +  .rela.sdata   ${RELOCATING-0} : { *(.rela.sdata${RELOCATING+ .rela.sdata.* .rela.gnu.linkonce.s.*}) }"

 19062 +  REL_SBSS=".rel.sbss     ${RELOCATING-0} : { *(.rel.sbss${RELOCATING+ .rel.sbss.* .rel.gnu.linkonce.sb.*}) }${RO_REGION}

 19063 +  .rela.sbss    ${RELOCATING-0} : { *(.rela.sbss${RELOCATING+ .rela.sbss.* .rela.gnu.linkonce.sb.*}) }${RO_REGION}"

 19064 +  REL_SDATA2=".rel.sdata2   ${RELOCATING-0} : { *(.rel.sdata2${RELOCATING+ .rel.sdata2.* .rel.gnu.linkonce.s2.*}) }${RO_REGION}

 19065 +  .rela.sdata2  ${RELOCATING-0} : { *(.rela.sdata2${RELOCATING+ .rela.sdata2.* .rela.gnu.linkonce.s2.*}) }${RO_REGION}"

 19066 +  REL_SBSS2=".rel.sbss2    ${RELOCATING-0} : { *(.rel.sbss2${RELOCATING+ .rel.sbss2.* .rel.gnu.linkonce.sb2.*}) }${RO_REGION}

 19067 +  .rela.sbss2   ${RELOCATING-0} : { *(.rela.sbss2${RELOCATING+ .rela.sbss2.* .rela.gnu.linkonce.sb2.*}) }${RO_REGION}"

 19068 +else

 19069 +  NO_SMALL_DATA=" "

 19070 +fi

 19071 +test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "

 19072 +CTOR=".ctors        ${CONSTRUCTING-0} :

 19073 +  {

 19074 +    ${CONSTRUCTING+${CTOR_START}}

 19075 +    /* gcc uses crtbegin.o to find the start of

 19076 +       the constructors, so we make sure it is

 19077 +       first.  Because this is a wildcard, it

 19078 +       doesn't matter if the user does not

 19079 +       actually link against crtbegin.o; the

 19080 +       linker won't look for a file to match a

 19081 +       wildcard.  The wildcard also means that it

 19082 +       doesn't matter which directory crtbegin.o

 19083 +       is in.  */

 19084 +

 19085 +    KEEP (*crtbegin*.o(.ctors))

 19086 +

 19087 +    /* We don't want to include the .ctor section from

 19088 +       from the crtend.o file until after the sorted ctors.

 19089 +       The .ctor section from the crtend file contains the

 19090 +       end of ctors marker and it must be last */

 19091 +

 19092 +    KEEP (*(EXCLUDE_FILE (*crtend*.o $OTHER_EXCLUDE_FILES) .ctors))

 19093 +    KEEP (*(SORT(.ctors.*)))

 19094 +    KEEP (*(.ctors))

 19095 +    ${CONSTRUCTING+${CTOR_END}}

 19096 +  }"

 19097 +DTOR=".dtors        ${CONSTRUCTING-0} :

 19098 +  {

 19099 +    ${CONSTRUCTING+${DTOR_START}}

 19100 +    KEEP (*crtbegin*.o(.dtors))

 19101 +    KEEP (*(EXCLUDE_FILE (*crtend*.o $OTHER_EXCLUDE_FILES) .dtors))

 19102 +    KEEP (*(SORT(.dtors.*)))

 19103 +    KEEP (*(.dtors))

 19104 +    ${CONSTRUCTING+${DTOR_END}}

 19105 +  }"

 19106 +STACK=".stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :

 19107 +  {

 19108 +    ${RELOCATING+_stack = .;}

 19109 +    *(.stack)

 19110 +    ${RELOCATING+${STACK_SIZE+. = ${STACK_SIZE};}}

 19111 +    ${RELOCATING+_estack = .;}

 19112 +  }${RW_REGION}"

 19113 +

 19114 +# if this is for an embedded system, don't add SIZEOF_HEADERS.

 19115 +if [ -z "$EMBEDDED" ]; then

 19116 +   test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS"

 19117 +else

 19118 +   test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"

 19119 +fi

 19120 +

 19121 +cat <<EOF

 19122 +OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",

 19123 +	      "${LITTLE_OUTPUT_FORMAT}")

 19124 +OUTPUT_ARCH(${OUTPUT_ARCH})

 19125 +ENTRY(${ENTRY})

 19126 +

 19127 +${RELOCATING+${LIB_SEARCH_DIRS}}

 19128 +${RELOCATING+/* Do we need any of these for elf?

 19129 +   __DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}}  */}

 19130 +${RELOCATING+${EXECUTABLE_SYMBOLS}}

 19131 +${RELOCATING+${INPUT_FILES}}

 19132 +${RELOCATING- /* For some reason, the Solaris linker makes bad executables

 19133 +  if gld -r is used and the intermediate file has sections starting

 19134 +  at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld

 19135 +  bug.  But for now assigning the zero vmas works.  */}

 19136 +

 19137 +${RELOCATING+${MEMORY}}

 19138 +

 19139 +SECTIONS

 19140 +{

 19141 +  /* Read-only sections, merged into text segment: */

 19142 +  ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}

 19143 +  ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}

 19144 +  ${CREATE_PIE+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}

 19145 +  ${CREATE_SHLIB-${INTERP}}

 19146 +  ${INITIAL_READONLY_SECTIONS}

 19147 +  ${TEXT_DYNAMIC+${DYNAMIC}${RO_REGION}}

 19148 +  .hash         ${RELOCATING-0} : { *(.hash) }${RO_REGION}

 19149 +  .dynsym       ${RELOCATING-0} : { *(.dynsym) }${RO_REGION}

 19150 +  .dynstr       ${RELOCATING-0} : { *(.dynstr) }${RO_REGION}

 19151 +  .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }${RO_REGION}

 19152 +  .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }${RO_REGION}

 19153 +  .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }${RO_REGION}

 19154 +

 19155 +EOF

 19156 +if [ "x$COMBRELOC" = x ]; then

 19157 +  COMBRELOCCAT=cat

 19158 +else

 19159 +  COMBRELOCCAT="cat > $COMBRELOC"

 19160 +fi

 19161 +eval $COMBRELOCCAT <<EOF

 19162 +  .rel.init     ${RELOCATING-0} : { *(.rel.init) }${RO_REGION}

 19163 +  .rela.init    ${RELOCATING-0} : { *(.rela.init) }${RO_REGION}

 19164 +  .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }${RO_REGION}

 19165 +  .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }${RO_REGION}

 19166 +  .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }${RO_REGION}

 19167 +  .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }${RO_REGION}

 19168 +  .rel.rodata   ${RELOCATING-0} : { *(.rel.rodata${RELOCATING+ .rel.rodata.* .rel.gnu.linkonce.r.*}) }${RO_REGION}

 19169 +  .rela.rodata  ${RELOCATING-0} : { *(.rela.rodata${RELOCATING+ .rela.rodata.* .rela.gnu.linkonce.r.*}) }${RO_REGION}

 19170 +  ${OTHER_READONLY_RELOC_SECTIONS}

 19171 +  .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+*}) }${RO_REGION}

 19172 +  .rela.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+*}) }${RO_REGION}

 19173 +  .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }${RO_REGION}

 19174 +  .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }${RO_REGION}

 19175 +  .rel.tdata	${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }${RO_REGION}

 19176 +  .rela.tdata	${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }${RO_REGION}

 19177 +  .rel.tbss	${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }${RO_REGION}

 19178 +  .rela.tbss	${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }${RO_REGION}

 19179 +  .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }${RO_REGION}

 19180 +  .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }${RO_REGION}

 19181 +  .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }${RO_REGION}

 19182 +  .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }${RO_REGION}

 19183 +  .rel.got      ${RELOCATING-0} : { *(.rel.got) }${RO_REGION}

 19184 +  .rela.got     ${RELOCATING-0} : { *(.rela.got) }${RO_REGION}

 19185 +  ${OTHER_GOT_RELOC_SECTIONS}

 19186 +  ${REL_SDATA}

 19187 +  ${REL_SBSS}

 19188 +  ${REL_SDATA2}

 19189 +  ${REL_SBSS2}

 19190 +  .rel.bss      ${RELOCATING-0} : { *(.rel.bss${RELOCATING+ .rel.bss.* .rel.gnu.linkonce.b.*}) }${RO_REGION}

 19191 +  .rela.bss     ${RELOCATING-0} : { *(.rela.bss${RELOCATING+ .rela.bss.* .rela.gnu.linkonce.b.*}) }${RO_REGION}

 19192 +EOF

 19193 +if [ -n "$COMBRELOC" ]; then

 19194 +cat <<EOF

 19195 +  .rel.dyn      ${RELOCATING-0} :

 19196 +    {

 19197 +EOF

 19198 +sed -e '/^[ 	]*[{}][ 	]*$/d;/:[ 	]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC

 19199 +cat <<EOF

 19200 +    }${RO_REGION}

 19201 +  .rela.dyn     ${RELOCATING-0} :

 19202 +    {

 19203 +EOF

 19204 +sed -e '/^[ 	]*[{}][ 	]*$/d;/:[ 	]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC

 19205 +cat <<EOF

 19206 +    }${RO_REGION}

 19207 +EOF

 19208 +fi

 19209 +cat <<EOF

 19210 +  .rel.plt      ${RELOCATING-0} : { *(.rel.plt) }${RO_REGION}

 19211 +  .rela.plt     ${RELOCATING-0} : { *(.rela.plt) }${RO_REGION}

 19212 +  ${OTHER_PLT_RELOC_SECTIONS}

 19213 +

 19214 +  .init         ${RELOCATING-0} :

 19215 +  {

 19216 +    ${RELOCATING+${INIT_START}}

 19217 +    KEEP (*(.init))

 19218 +    ${RELOCATING+${INIT_END}}

 19219 +  }${RO_REGION} =${NOP-0}

 19220 +

 19221 +  ${DATA_PLT-${BSS_PLT-${PLT}${RO_REGION}}}

 19222 +  .text         ${RELOCATING-0} :

 19223 +  {

 19224 +    ${RELOCATING+${TEXT_START_SYMBOLS}}

 19225 +    *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})

 19226 +    KEEP (*(.text.*personality*))

 19227 +    /* .gnu.warning sections are handled specially by elf32.em.  */

 19228 +    *(.gnu.warning)

 19229 +    ${RELOCATING+${OTHER_TEXT_SECTIONS}}

 19230 +  }${RO_REGION} =${NOP-0}

 19231 +  .fini         ${RELOCATING-0} :

 19232 +  {

 19233 +    ${RELOCATING+${FINI_START}}

 19234 +    KEEP (*(.fini))

 19235 +    ${RELOCATING+${FINI_END}}

 19236 +  }${RO_REGION} =${NOP-0}

 19237 +  ${RELOCATING+PROVIDE (__etext = .);}

 19238 +  ${RELOCATING+PROVIDE (_etext = .);}

 19239 +  ${RELOCATING+PROVIDE (etext = .);}

 19240 +  ${WRITABLE_RODATA-${RODATA}${RO_REGION}}

 19241 +  .rodata1      ${RELOCATING-0} : { *(.rodata1) }${RO_REGION}

 19242 +  ${CREATE_SHLIB-${SDATA2}}

 19243 +  ${CREATE_SHLIB-${SBSS2}}

 19244 +  ${OTHER_READONLY_SECTIONS}

 19245 +  .eh_frame_hdr : { *(.eh_frame_hdr) }${RO_REGION}

 19246 +  .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }${RO_REGION}

 19247 +  .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }${RO_REGION}

 19248 +

 19249 +  ${RELOCATING+${DALIGN}}

 19250 +  ${RELOCATING+PROVIDE (_data = ORIGIN(${RW_VMA_REGION}));}

 19251 +  . = ORIGIN(${RW_VMA_REGION});

 19252 +  /* Exception handling  */

 19253 +  .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }${RW_REGION}

 19254 +  .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }${RW_REGION}

 19255 +

 19256 +  /* Thread Local Storage sections  */

 19257 +  .tdata	${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }${RW_REGION}

 19258 +  .tbss		${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }${RW_REGION}

 19259 +

 19260 +  /* Ensure the __preinit_array_start label is properly aligned.  We

 19261 +     could instead move the label definition inside the section, but

 19262 +     the linker would then create the section even if it turns out to

 19263 +     be empty, which isn't pretty.  */

 19264 +  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_start = ALIGN(${ALIGNMENT}));}}

 19265 +  .preinit_array   ${RELOCATING-0} : { KEEP (*(.preinit_array)) }${RW_REGION}

 19266 +  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_end = .);}}

 19267 +

 19268 +  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__init_array_start = .);}}

 19269 +  .init_array   ${RELOCATING-0} : { KEEP (*(.init_array)) }${RW_REGION}

 19270 +  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__init_array_end = .);}}

 19271 +

 19272 +  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__fini_array_start = .);}}

 19273 +  .fini_array   ${RELOCATING-0} : { KEEP (*(.fini_array)) }${RW_REGION}

 19274 +  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__fini_array_end = .);}}

 19275 +

 19276 +  ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}${RW_REGION}}}

 19277 +  ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}${RW_REGION}}}

 19278 +  .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }${RW_REGION}

 19279 +

 19280 +  ${RELOCATING+${DATARELRO}}

 19281 +  ${OTHER_RELRO_SECTIONS}

 19282 +  ${TEXT_DYNAMIC-${DYNAMIC}${RW_REGION}}

 19283 +  ${NO_SMALL_DATA+${RELRO_NOW+${GOT}${RW_REGION}}}

 19284 +  ${NO_SMALL_DATA+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}${RW_REGION}}}}

 19285 +  ${NO_SMALL_DATA+${RELRO_NOW-${SEPARATE_GOTPLT+${GOTPLT}${RW_REGION}}}}

 19286 +  ${RELOCATING+${DATA_SEGMENT_RELRO_END}}

 19287 +  ${NO_SMALL_DATA+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}${RW_REGION}}}}

 19288 +

 19289 +  ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}${RW_REGION}}}

 19290 +

 19291 +  .data         ${RELOCATING-0} :

 19292 +  {

 19293 +    ${RELOCATING+${DATA_START_SYMBOLS}}

 19294 +    *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})

 19295 +    KEEP (*(.gnu.linkonce.d.*personality*))

 19296 +    ${CONSTRUCTING+SORT(CONSTRUCTORS)}

 19297 +  }${RW_REGION}

 19298 +  .data1        ${RELOCATING-0} : { *(.data1) }${RW_REGION}

 19299 +  ${WRITABLE_RODATA+${RODATA}${RW_REGION}}

 19300 +  ${OTHER_READWRITE_SECTIONS}

 19301 +  ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}${RW_REGION}}}

 19302 +  ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}${RW_REGION}}}

 19303 +  ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}${RW_REGION}}}

 19304 +  ${RELOCATING+${OTHER_GOT_SYMBOLS}}

 19305 +  ${NO_SMALL_DATA-${GOT}${RW_REGION}}

 19306 +  ${OTHER_GOT_SECTIONS}

 19307 +  ${SDATA}

 19308 +  ${OTHER_SDATA_SECTIONS}

 19309 +  ${RELOCATING+${BALIGN}}

 19310 +  ${RELOCATING+_edata = .;}

 19311 +  ${RELOCATING+PROVIDE (edata = .);}

 19312 +  ${RELOCATING+__bss_start = .;}

 19313 +  ${RELOCATING+${OTHER_BSS_SYMBOLS}}

 19314 +  ${SBSS}

 19315 +  ${BSS_PLT+${PLT}${RW_REGION}}

 19316 +  .bss          ${RELOCATING-0} :

 19317 +  {

 19318 +   *(.dynbss)

 19319 +   *(.bss${RELOCATING+ .bss.* .gnu.linkonce.b.*})

 19320 +   *(COMMON)

 19321 +   /* Align here to ensure that the .bss section occupies space up to

 19322 +      _end.  Align after .bss to ensure correct alignment even if the

 19323 +      .bss section disappears because there are no input sections.  */

 19324 +   ${RELOCATING+. = ALIGN(${BSS_ALIGNMENT});}

 19325 +  }${RW_REGION}

 19326 +  ${OTHER_BSS_SECTIONS}

 19327 +  ${RELOCATING+. = ALIGN(${BSS_ALIGNMENT});}

 19328 +  ${RELOCATING+_end = .;}

 19329 +  ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}

 19330 +  ${RELOCATING+PROVIDE (end = .);}

 19331 +  ${RELOCATING+${DATA_SEGMENT_END}}

 19332 +

 19333 +  /* Stabs debugging sections.  */

 19334 +  .stab          0 : { *(.stab) }

 19335 +  .stabstr       0 : { *(.stabstr) }

 19336 +  .stab.excl     0 : { *(.stab.excl) }

 19337 +  .stab.exclstr  0 : { *(.stab.exclstr) }

 19338 +  .stab.index    0 : { *(.stab.index) }

 19339 +  .stab.indexstr 0 : { *(.stab.indexstr) }

 19340 +

 19341 +  .comment       0 : { *(.comment) }

 19342 +

 19343 +  /* DWARF debug sections.

 19344 +     Symbols in the DWARF debugging sections are relative to the beginning

 19345 +     of the section so we begin them at 0.  */

 19346 +

 19347 +  /* DWARF 1 */

 19348 +  .debug          0 : { *(.debug) }

 19349 +  .line           0 : { *(.line) }

 19350 +

 19351 +  /* GNU DWARF 1 extensions */

 19352 +  .debug_srcinfo  0 : { *(.debug_srcinfo) }

 19353 +  .debug_sfnames  0 : { *(.debug_sfnames) }

 19354 +

 19355 +  /* DWARF 1.1 and DWARF 2 */

 19356 +  .debug_aranges  0 : { *(.debug_aranges) }

 19357 +  .debug_pubnames 0 : { *(.debug_pubnames) }

 19358 +

 19359 +  /* DWARF 2 */

 19360 +  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }

 19361 +  .debug_abbrev   0 : { *(.debug_abbrev) }

 19362 +  .debug_line     0 : { *(.debug_line) }

 19363 +  .debug_frame    0 : { *(.debug_frame) }

 19364 +  .debug_str      0 : { *(.debug_str) }

 19365 +  .debug_loc      0 : { *(.debug_loc) }

 19366 +  .debug_macinfo  0 : { *(.debug_macinfo) }

 19367 +

 19368 +  /* SGI/MIPS DWARF 2 extensions */

 19369 +  .debug_weaknames 0 : { *(.debug_weaknames) }

 19370 +  .debug_funcnames 0 : { *(.debug_funcnames) }

 19371 +  .debug_typenames 0 : { *(.debug_typenames) }

 19372 +  .debug_varnames  0 : { *(.debug_varnames) }

 19373 +

 19374 +  ${STACK_ADDR+${STACK}}

 19375 +  ${OTHER_SECTIONS}

 19376 +  ${RELOCATING+${OTHER_END_SYMBOLS}}

 19377 +  ${RELOCATING+${STACKNOTE}}

 19378 +}

 19379 +EOF

 19380 --- /dev/null

 19381 +++ b/ld/testsuite/ld-avr32/avr32.exp

 19382 @@ -0,0 +1,25 @@

 19383 +# Expect script for AVR32 ELF linker tests.

 19384 +#   Copyright 2004-2006 Atmel Corporation.

 19385 +#

 19386 +# This file is free software; you can redistribute it and/or modify

 19387 +# it under the terms of the GNU General Public License as published by

 19388 +# the Free Software Foundation; either version 2 of the License, or

 19389 +# (at your option) any later version.

 19390 +#

 19391 +# This program is distributed in the hope that it will be useful,

 19392 +# but WITHOUT ANY WARRANTY; without even the implied warranty of

 19393 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 19394 +# GNU General Public License for more details.

 19395 +#

 19396 +# You should have received a copy of the GNU General Public License

 19397 +# along with this program; if not, write to the Free Software

 19398 +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

 19399 +#

 19400 +# Written by Haavard Skinnemoen (hskinnemoen@atmel.com)

 19401 +#

 19402 +

 19403 +if ![istarget avr32-*-*] {

 19404 +    return

 19405 +}

 19406 +

 19407 +run_dump_test "pcrel"

 19408 --- /dev/null

 19409 +++ b/ld/testsuite/ld-avr32/pcrel.d

 19410 @@ -0,0 +1,74 @@

 19411 +#name: AVR32 ELF PC-relative external relocs

 19412 +#source: symbols.s

 19413 +#source: ../../../gas/testsuite/gas/avr32/pcrel.s

 19414 +#ld: -T $srcdir/$subdir/pcrel.ld

 19415 +#objdump: -d

 19416 +

 19417 +.*:     file format elf.*avr32.*

 19418 +

 19419 +Disassembly of section .text:

 19420 +

 19421 +a0000000 <_start>:

 19422 +a0000000:	d7 03       	nop

 19423 +a0000002:	d7 03       	nop

 19424 +

 19425 +a0000004 <test_rjmp>:

 19426 +a0000004:	d7 03       	nop

 19427 +a0000006:	c0 28       	rjmp a000000a <test_rjmp\+0x6>

 19428 +a0000008:	d7 03       	nop

 19429 +a000000a:	e0 8f 01 fb 	bral a0000400 <extsym10>

 19430 +

 19431 +a000000e <test_rcall>:

 19432 +a000000e:	d7 03       	nop

 19433 +a0000010 <test_rcall2>:

 19434 +a0000010:	c0 2c       	rcall a0000014 <test_rcall2\+0x4>

 19435 +a0000012:	d7 03       	nop

 19436 +a0000014:	ee b0 ff f6 	rcall a0200000 <extsym21>

 19437 +

 19438 +a0000018 <test_branch>:

 19439 +a0000018:	c0 31       	brne a000001e <test_branch\+0x6>

 19440 +a000001a:	fe 9f ff ff 	bral a0000018 <test_branch>

 19441 +a000001e:	ee 90 ff f1 	breq a0200000 <extsym21>

 19442 +

 19443 +a0000022 <test_lddpc>:

 19444 +a0000022:	48 30       	lddpc r0,a000002c <sym1>

 19445 +a0000024:	48 20       	lddpc r0,a000002c <sym1>

 19446 +a0000026:	fe f0 7f da 	ld.w r0,pc\[32730\]

 19447 +	...

 19448 +

 19449 +a000002c <sym1>:

 19450 +a000002c:	d7 03       	nop

 19451 +a000002e:	d7 03       	nop

 19452 +

 19453 +a0000030 <test_local>:

 19454 +a0000030:	48 20       	lddpc r0,a0000038 <test_local\+0x8>

 19455 +a0000032:	48 30       	lddpc r0,a000003c <test_local\+0xc>

 19456 +a0000034:	48 20       	lddpc r0,a000003c <test_local\+0xc>

 19457 +a0000036:	00 00       	add r0,r0

 19458 +a0000038:	d7 03       	nop

 19459 +a000003a:	d7 03       	nop

 19460 +a000003c:	d7 03       	nop

 19461 +a000003e:	d7 03       	nop

 19462 +

 19463 +Disassembly of section \.text\.init:

 19464 +a0000040 <test_inter_section>:

 19465 +a0000040:	fe b0 ff e7 	rcall a000000e <test_rcall>

 19466 +a0000044:	d7 03       	nop

 19467 +a0000046:	fe b0 ff e4 	rcall a000000e <test_rcall>

 19468 +a000004a:	fe b0 ff e3 	rcall a0000010 <test_rcall2>

 19469 +a000004e:	d7 03       	nop

 19470 +a0000050:	fe b0 ff e0 	rcall a0000010 <test_rcall2>

 19471 +

 19472 +Disassembly of section \.text\.pcrel10:

 19473 +

 19474 +a0000400 <extsym10>:

 19475 +a0000400:	d7 03       	nop

 19476 +

 19477 +Disassembly of section \.text\.pcrel16:

 19478 +

 19479 +a0008000 <extsym16>:

 19480 +a0008000:	d7 03       	nop

 19481 +

 19482 +Disassembly of section \.text\.pcrel21:

 19483 +a0200000 <extsym21>:

 19484 +a0200000:	d7 03       	nop

 19485 --- /dev/null

 19486 +++ b/ld/testsuite/ld-avr32/pcrel.ld

 19487 @@ -0,0 +1,23 @@

 19488 +ENTRY(_start)

 19489 +SECTIONS

 19490 +{

 19491 +	.text 0xa0000000:

 19492 +	{

 19493 +		*(.text)

 19494 +	}

 19495 +

 19496 +	.text.pcrel10 0xa0000400:

 19497 +	{

 19498 +		*(.text.pcrel10)

 19499 +	}

 19500 +

 19501 +	.text.pcrel16 0xa0008000:

 19502 +	{

 19503 +		*(.text.pcrel16)

 19504 +	}

 19505 +

 19506 +	.text.pcrel21 0xa0200000:

 19507 +	{

 19508 +		*(.text.pcrel21)

 19509 +	}

 19510 +}

 19511 --- /dev/null

 19512 +++ b/ld/testsuite/ld-avr32/symbols.s

 19513 @@ -0,0 +1,20 @@

 19514 +	.text

 19515 +	.global _start

 19516 +_start:

 19517 +	nop

 19518 +	nop

 19519 +

 19520 +	.section .text.pcrel10,"ax"

 19521 +	.global extsym10

 19522 +extsym10:

 19523 +	nop

 19524 +

 19525 +	.section .text.pcrel16,"ax"

 19526 +	.global extsym16

 19527 +extsym16:

 19528 +	nop

 19529 +

 19530 +	.section .text.pcrel21,"ax"

 19531 +	.global extsym21

 19532 +extsym21:

 19533 +	nop

 19534 --- /dev/null

 19535 +++ b/opcodes/avr32-asm.c

 19536 @@ -0,0 +1,264 @@

 19537 +/* Assembler interface for AVR32.

 19538 +   Copyright 2005, 2006 Atmel Corporation.

 19539 +

 19540 +   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>

 19541 +

 19542 +   This file is part of libopcodes.

 19543 +

 19544 +   This program is free software; you can redistribute it and/or

 19545 +   modify it under the terms of the GNU General Public License as

 19546 +   published by the Free Software Foundation; either version 2 of the

 19547 +   License, or (at your option) any later version.

 19548 +

 19549 +   This program is distributed in the hope that it will be useful, but

 19550 +   WITHOUT ANY WARRANTY; without even the implied warranty of

 19551 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 19552 +   General Public License for more details.

 19553 +

 19554 +   You should have received a copy of the GNU General Public License

 19555 +   along with this program; if not, write to the Free Software

 19556 +   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

 19557 +   02111-1307, USA.  */

 19558 +

 19559 +#include <string.h>

 19560 +

 19561 +#include "avr32-opc.h"

 19562 +#include "avr32-asm.h"

 19563 +

 19564 +/* Structure for a register hash table entry.  */

 19565 +struct reg_entry

 19566 +{

 19567 +  const char	*name;

 19568 +  int		number;

 19569 +};

 19570 +

 19571 +/* Integer Registers.  */

 19572 +static const struct reg_entry reg_table[] =

 19573 +  {

 19574 +    /* Primary names (used by the disassembler) */

 19575 +    { "r0",   0 }, { "r1",   1 }, { "r2",   2 }, { "r3",   3 },

 19576 +    { "r4",   4 }, { "r5",   5 }, { "r6",   6 }, { "r7",   7 },

 19577 +    { "r8",   8 }, { "r9",   9 }, { "r10", 10 }, { "r11", 11 },

 19578 +    { "r12", 12 }, { "sp",  13 }, { "lr",  14 }, { "pc",  15 },

 19579 +    /* Alternatives to sp, lr and pc.  */

 19580 +    { "r13", 13 }, { "r14", 14 }, { "r15", 15 },

 19581 +  };

 19582 +#define AVR32_NR_INTREGS (sizeof(reg_table)/sizeof(reg_table[0]))

 19583 +

 19584 +/* Coprocessor Registers.  */

 19585 +static const struct reg_entry cr_table[] =

 19586 +  {

 19587 +    { "cr0",   0 }, { "cr1",   1 }, { "cr2",   2 }, { "cr3",   3 },

 19588 +    { "cr4",   4 }, { "cr5",   5 }, { "cr6",   6 }, { "cr7",   7 },

 19589 +    { "cr8",   8 }, { "cr9",   9 }, { "cr10", 10 }, { "cr11", 11 },

 19590 +    { "cr12", 12 }, { "cr13", 13 }, { "cr14", 14 }, { "cr15", 15 },

 19591 +  };

 19592 +#define AVR32_NR_CPREGS (sizeof(cr_table)/sizeof(cr_table[0]))

 19593 +

 19594 +/* Floating-point Registers.  */

 19595 +static const struct reg_entry fr_table[] =

 19596 +  {

 19597 +    { "fr0",   0 }, { "fr1",   1 }, { "fr2",   2 }, { "fr3",   3 },

 19598 +    { "fr4",   4 }, { "fr5",   5 }, { "fr6",   6 }, { "fr7",   7 },

 19599 +    { "fr8",   8 }, { "fr9",   9 }, { "fr10", 10 }, { "fr11", 11 },

 19600 +    { "fr12", 12 }, { "fr13", 13 }, { "fr14", 14 }, { "fr15", 15 },

 19601 +  };

 19602 +#define AVR32_NR_FPREGS (sizeof(fr_table)/sizeof(fr_table[0]))

 19603 +

 19604 +/* PiCo Registers.  */

 19605 +static const struct reg_entry pico_table[] =

 19606 +  {

 19607 +    { "inpix2",    0 }, { "inpix1",    1 }, { "inpix0",    2 },

 19608 +    { "outpix2",   3 }, { "outpix1",   4 }, { "outpix0",   5 },

 19609 +    { "coeff0_a",  6 }, { "coeff0_b",  7 }, { "coeff1_a",  8 },

 19610 +    { "coeff1_b",  9 }, { "coeff2_a", 10 }, { "coeff2_b", 11 },

 19611 +    { "vmu0_out", 12 }, { "vmu1_out", 13 }, { "vmu2_out", 14 },

 19612 +    { "config",   15 },

 19613 +  };

 19614 +#define AVR32_NR_PICOREGS (sizeof(pico_table)/sizeof(pico_table[0]))

 19615 +

 19616 +int

 19617 +avr32_parse_intreg(const char *str)

 19618 +{

 19619 +  unsigned int i;

 19620 +

 19621 +  for (i = 0; i < AVR32_NR_INTREGS; i++)

 19622 +    {

 19623 +      if (strcasecmp(reg_table[i].name, str) == 0)

 19624 +	return reg_table[i].number;

 19625 +    }

 19626 +

 19627 +  return -1;

 19628 +}

 19629 +

 19630 +int

 19631 +avr32_parse_cpreg(const char *str)

 19632 +{

 19633 +  unsigned int i;

 19634 +

 19635 +  for (i = 0; i < AVR32_NR_CPREGS; i++)

 19636 +    {

 19637 +      if (strcasecmp(cr_table[i].name, str) == 0)

 19638 +	return cr_table[i].number;

 19639 +    }

 19640 +

 19641 +  return -1;

 19642 +}

 19643 +

 19644 +int avr32_parse_fpreg(const char *str)

 19645 +{

 19646 +  unsigned int i;

 19647 +

 19648 +  for (i = 0; i < AVR32_NR_FPREGS; i++)

 19649 +    {

 19650 +      if (strcasecmp(fr_table[i].name, str) == 0)

 19651 +	return fr_table[i].number;

 19652 +    }

 19653 +

 19654 +  return -1;

 19655 +}

 19656 +

 19657 +int avr32_parse_picoreg(const char *str)

 19658 +{

 19659 +  unsigned int i;

 19660 +

 19661 +  for (i = 0; i < AVR32_NR_PICOREGS; i++)

 19662 +    {

 19663 +      if (strcasecmp(pico_table[i].name, str) == 0)

 19664 +	return pico_table[i].number;

 19665 +    }

 19666 +

 19667 +  return -1;

 19668 +}

 19669 +

 19670 +static unsigned long

 19671 +parse_reglist(char *str, char **endptr, int (*parse_reg)(const char *))

 19672 +{

 19673 +  int reg_from, reg_to;

 19674 +  unsigned long result = 0;

 19675 +  char *p1, *p2, c;

 19676 +

 19677 +  while (*str)

 19678 +    {

 19679 +      for (p1 = str; *p1; p1++)

 19680 +	if (*p1 == ',' || *p1 == '-')

 19681 +	  break;

 19682 +

 19683 +      c = *p1, *p1 = 0;

 19684 +      reg_from = parse_reg(str);

 19685 +      *p1 = c;

 19686 +

 19687 +      if (reg_from < 0)

 19688 +	break;

 19689 +

 19690 +      if (*p1 == '-')

 19691 +	{

 19692 +	  for (p2 = ++p1; *p2; p2++)

 19693 +	    if (*p2 == ',')

 19694 +	      break;

 19695 +

 19696 +	  c = *p2, *p2 = 0;

 19697 +	  /* printf("going to parse reg_to from `%s'\n", p1); */

 19698 +	  reg_to = parse_reg(p1);

 19699 +	  *p2 = c;

 19700 +

 19701 +	  if (reg_to < 0)

 19702 +	    break;

 19703 +

 19704 +	  while (reg_from <= reg_to)

 19705 +	    result |= (1 << reg_from++);

 19706 +	  p1 = p2;

 19707 +	}

 19708 +      else

 19709 +	result |= (1 << reg_from);

 19710 +

 19711 +      str = p1;

 19712 +      if (*str) ++str;

 19713 +    }

 19714 +

 19715 +  if (endptr)

 19716 +    *endptr = str;

 19717 +

 19718 +  return result;

 19719 +}

 19720 +

 19721 +unsigned long

 19722 +avr32_parse_reglist(char *str, char **endptr)

 19723 +{

 19724 +  return parse_reglist(str, endptr, avr32_parse_intreg);

 19725 +}

 19726 +

 19727 +unsigned long

 19728 +avr32_parse_cpreglist(char *str, char **endptr)

 19729 +{

 19730 +  return parse_reglist(str, endptr, avr32_parse_cpreg);

 19731 +}

 19732 +

 19733 +unsigned long

 19734 +avr32_parse_pico_reglist(char *str, char **endptr)

 19735 +{

 19736 +  return parse_reglist(str, endptr, avr32_parse_picoreg);

 19737 +}

 19738 +

 19739 +int

 19740 +avr32_make_regmask8(unsigned long regmask16, unsigned long *regmask8)

 19741 +{

 19742 +  unsigned long result = 0;

 19743 +

 19744 +  /* printf("convert regmask16 0x%04lx\n", regmask16); */

 19745 +

 19746 +  if (regmask16 & 0xf)

 19747 +    {

 19748 +      if ((regmask16 & 0xf) == 0xf)

 19749 +	result |= 1 << 0;

 19750 +      else

 19751 +	return -1;

 19752 +    }

 19753 +  if (regmask16 & 0xf0)

 19754 +    {

 19755 +      if ((regmask16 & 0xf0) == 0xf0)

 19756 +	result |= 1 << 1;

 19757 +      else

 19758 +	return -1;

 19759 +    }

 19760 +  if (regmask16 & 0x300)

 19761 +    {

 19762 +      if ((regmask16 & 0x300) == 0x300)

 19763 +	result |= 1 << 2;

 19764 +      else

 19765 +	return -1;

 19766 +    }

 19767 +  if (regmask16 & (1 << 13))

 19768 +    return -1;

 19769 +

 19770 +  if (regmask16 & (1 << 10))

 19771 +    result |= 1 << 3;

 19772 +  if (regmask16 & (1 << 11))

 19773 +    result |= 1 << 4;

 19774 +  if (regmask16 & (1 << 12))

 19775 +    result |= 1 << 5;

 19776 +  if (regmask16 & (1 << 14))

 19777 +    result |= 1 << 6;

 19778 +  if (regmask16 & (1 << 15))

 19779 +    result |= 1 << 7;

 19780 +

 19781 +  *regmask8 = result;

 19782 +

 19783 +  return 0;

 19784 +}

 19785 +

 19786 +#if 0

 19787 +struct reg_map

 19788 +{

 19789 +  const struct reg_entry	*names;

 19790 +  int				nr_regs;

 19791 +  struct hash_control		*htab;

 19792 +  const char			*errmsg;

 19793 +};

 19794 +

 19795 +struct reg_map all_reg_maps[] =

 19796 +  {

 19797 +    { reg_table, AVR32_NR_INTREGS, NULL, N_("integral register expected") },

 19798 +    { cr_table,  AVR32_NR_CPREGS,  NULL, N_("coprocessor register expected") },

 19799 +  };

 19800 +#endif

 19801 --- /dev/null

 19802 +++ b/opcodes/avr32-asm.h

 19803 @@ -0,0 +1,42 @@

 19804 +/* Assembler interface for AVR32.

 19805 +   Copyright 2005, 2006 Atmel Corporation.

 19806 +

 19807 +   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>

 19808 +

 19809 +   This file is part of libopcodes.

 19810 +

 19811 +   This program is free software; you can redistribute it and/or

 19812 +   modify it under the terms of the GNU General Public License as

 19813 +   published by the Free Software Foundation; either version 2 of the

 19814 +   License, or (at your option) any later version.

 19815 +

 19816 +   This program is distributed in the hope that it will be useful, but

 19817 +   WITHOUT ANY WARRANTY; without even the implied warranty of

 19818 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 19819 +   General Public License for more details.

 19820 +

 19821 +   You should have received a copy of the GNU General Public License

 19822 +   along with this program; if not, write to the Free Software

 19823 +   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

 19824 +   02111-1307, USA.  */

 19825 +#ifndef __OPCODES_AVR32_ASM_H

 19826 +#define __OPCODES_AVR32_ASM_H

 19827 +

 19828 +extern int

 19829 +avr32_parse_intreg(const char *str);

 19830 +extern int

 19831 +avr32_parse_cpreg(const char *str);

 19832 +extern int

 19833 +avr32_parse_fpreg(const char *str);

 19834 +extern int

 19835 +avr32_parse_picoreg(const char *str);

 19836 +extern unsigned long

 19837 +avr32_parse_reglist(char *str, char **endptr);

 19838 +extern unsigned long

 19839 +avr32_parse_cpreglist(char *str, char **endptr);

 19840 +extern unsigned long

 19841 +avr32_parse_pico_reglist(char *str, char **endptr);

 19842 +extern int

 19843 +avr32_make_regmask8(unsigned long regmask16, unsigned long *regmask8);

 19844 +

 19845 +#endif /* __OPCODES_AVR32_ASM_H */

 19846 --- /dev/null

 19847 +++ b/opcodes/avr32-dis.c

 19848 @@ -0,0 +1,891 @@

 19849 +/* Print AVR32 instructions for GDB and objdump.

 19850 +   Copyright 2005, 2006 Atmel Corporation.

 19851 +

 19852 +   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>

 19853 +

 19854 +   This file is part of libopcodes.

 19855 +

 19856 +   This program is free software; you can redistribute it and/or

 19857 +   modify it under the terms of the GNU General Public License as

 19858 +   published by the Free Software Foundation; either version 2 of the

 19859 +   License, or (at your option) any later version.

 19860 +

 19861 +   This program is distributed in the hope that it will be useful, but

 19862 +   WITHOUT ANY WARRANTY; without even the implied warranty of

 19863 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 19864 +   General Public License for more details.

 19865 +

 19866 +   You should have received a copy of the GNU General Public License

 19867 +   along with this program; if not, write to the Free Software

 19868 +   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

 19869 +   02111-1307, USA.  */

 19870 +

 19871 +#include "sysdep.h"

 19872 +#include "dis-asm.h"

 19873 +#include "avr32-opc.h"

 19874 +#include "opintl.h"

 19875 +#include "safe-ctype.h"

 19876 +

 19877 +/* TODO: Share this with -asm */

 19878 +

 19879 +/* Structure for a register hash table entry.  */

 19880 +struct reg_entry

 19881 +{

 19882 +  const char	*name;

 19883 +  int		number;

 19884 +};

 19885 +

 19886 +#ifndef strneq

 19887 +#define strneq(a,b,n)	(strncmp ((a), (b), (n)) == 0)

 19888 +#endif

 19889 +

 19890 +

 19891 +static const struct reg_entry reg_table[] =

 19892 +  {

 19893 +    /* Primary names (used by the disassembler) */

 19894 +    { "r0",   0 }, { "r1",   1 }, { "r2",   2 }, { "r3",   3 },

 19895 +    { "r4",   4 }, { "r5",   5 }, { "r6",   6 }, { "r7",   7 },

 19896 +    { "r8",   8 }, { "r9",   9 }, { "r10", 10 }, { "r11", 11 },

 19897 +    { "r12", 12 }, { "sp",  13 }, { "lr",  14 }, { "pc",  15 },

 19898 +    /* Alternatives to sp, lr and pc.  */

 19899 +    { "r13", 13 }, { "r14", 14 }, { "r15", 15 },

 19900 +  };

 19901 +#define AVR32_NR_INTREGS (sizeof(reg_table)/sizeof(reg_table[0]))

 19902 +

 19903 +/* Coprocessor Registers.  */

 19904 +static const struct reg_entry cr_table[] =

 19905 +  {

 19906 +    { "cr0",   0 }, { "cr1",   1 }, { "cr2",   2 }, { "cr3",   3 },

 19907 +    { "cr4",   4 }, { "cr5",   5 }, { "cr6",   6 }, { "cr7",   7 },

 19908 +    { "cr8",   8 }, { "cr9",   9 }, { "cr10", 10 }, { "cr11", 11 },

 19909 +    { "cr12", 12 }, { "cr13", 13 }, { "cr14", 14 }, { "cr15", 15 },

 19910 +  };

 19911 +#define AVR32_NR_CPREGS (sizeof(cr_table)/sizeof(cr_table[0]))

 19912 +

 19913 +static const char bparts[4] = { 'b', 'l', 'u', 't' };

 19914 +static bfd_vma current_pc;

 19915 +

 19916 +struct avr32_field_value

 19917 +{

 19918 +  const struct avr32_ifield *ifield;

 19919 +  unsigned long value;

 19920 +};

 19921 +

 19922 +struct avr32_operand

 19923 +{

 19924 +  int id;

 19925 +  int is_pcrel;

 19926 +  int align_order;

 19927 +  int (*print)(struct avr32_operand *op, struct disassemble_info *info,

 19928 +	       struct avr32_field_value *ifields);

 19929 +};

 19930 +

 19931 +static signed long

 19932 +get_signed_value(const struct avr32_field_value *fv)

 19933 +{

 19934 +  signed long value = fv->value;

 19935 +

 19936 +  if (fv->value & (1 << (fv->ifield->bitsize - 1)))

 19937 +    value |= (~0UL << fv->ifield->bitsize);

 19938 +

 19939 +  return value;

 19940 +}

 19941 +

 19942 +static void

 19943 +print_reglist_range(unsigned int first, unsigned int last,

 19944 +		    const struct reg_entry *reg_names,

 19945 +		    int need_comma,

 19946 +		    struct disassemble_info *info)

 19947 +{

 19948 +  if (need_comma)

 19949 +    info->fprintf_func(info->stream, ",");

 19950 +

 19951 +  if (first == last)

 19952 +    info->fprintf_func(info->stream, "%s",

 19953 +		       reg_names[first].name);

 19954 +  else

 19955 +    info->fprintf_func(info->stream, "%s-%s",

 19956 +		       reg_names[first].name, reg_names[last].name);

 19957 +}

 19958 +

 19959 +static int

 19960 +print_intreg(struct avr32_operand *op,

 19961 +	     struct disassemble_info *info,

 19962 +	     struct avr32_field_value *ifields)

 19963 +{

 19964 +  unsigned long regid = ifields[0].value << op->align_order;

 19965 +

 19966 +  info->fprintf_func(info->stream, "%s",

 19967 +		     reg_table[regid].name);

 19968 +  return 1;

 19969 +}

 19970 +

 19971 +static int

 19972 +print_intreg_predec(struct avr32_operand *op ATTRIBUTE_UNUSED,

 19973 +		    struct disassemble_info *info,

 19974 +		    struct avr32_field_value *ifields)

 19975 +{

 19976 +  info->fprintf_func(info->stream, "--%s",

 19977 +		     reg_table[ifields[0].value].name);

 19978 +  return 1;

 19979 +}

 19980 +

 19981 +static int

 19982 +print_intreg_postinc(struct avr32_operand *op ATTRIBUTE_UNUSED,

 19983 +		     struct disassemble_info *info,

 19984 +		     struct avr32_field_value *ifields)

 19985 +{

 19986 +  info->fprintf_func(info->stream, "%s++",

 19987 +		     reg_table[ifields[0].value].name);

 19988 +  return 1;

 19989 +}

 19990 +

 19991 +static int

 19992 +print_intreg_lsl(struct avr32_operand *op ATTRIBUTE_UNUSED,

 19993 +		 struct disassemble_info *info,

 19994 +		 struct avr32_field_value *ifields)

 19995 +{

 19996 +  const char *rp = reg_table[ifields[0].value].name;

 19997 +  unsigned long sa = ifields[1].value;

 19998 +

 19999 +  if (sa)

 20000 +    info->fprintf_func(info->stream, "%s<<0x%lx", rp, sa);

 20001 +  else

 20002 +    info->fprintf_func(info->stream, "%s", rp);

 20003 +

 20004 +  return 2;

 20005 +}

 20006 +

 20007 +static int

 20008 +print_intreg_lsr(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20009 +		 struct disassemble_info *info,

 20010 +		 struct avr32_field_value *ifields)

 20011 +{

 20012 +  const char *rp = reg_table[ifields[0].value].name;

 20013 +  unsigned long sa = ifields[1].value;

 20014 +

 20015 +  if (sa)

 20016 +    info->fprintf_func(info->stream, "%s>>0x%lx", rp, sa);

 20017 +  else

 20018 +    info->fprintf_func(info->stream, "%s", rp);

 20019 +

 20020 +  return 2;

 20021 +}

 20022 +

 20023 +static int

 20024 +print_intreg_bpart(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20025 +		   struct disassemble_info *info,

 20026 +		   struct avr32_field_value *ifields)

 20027 +{

 20028 +  info->fprintf_func(info->stream, "%s:%c",

 20029 +		     reg_table[ifields[0].value].name,

 20030 +		     bparts[ifields[1].value]);

 20031 +  return 2;

 20032 +}

 20033 +

 20034 +static int

 20035 +print_intreg_hpart(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20036 +		   struct disassemble_info *info,

 20037 +		   struct avr32_field_value *ifields)

 20038 +{

 20039 +  info->fprintf_func(info->stream, "%s:%c",

 20040 +		     reg_table[ifields[0].value].name,

 20041 +		     ifields[1].value ? 't' : 'b');

 20042 +  return 2;

 20043 +}

 20044 +

 20045 +static int

 20046 +print_intreg_sdisp(struct avr32_operand *op,

 20047 +		  struct disassemble_info *info,

 20048 +		  struct avr32_field_value *ifields)

 20049 +{

 20050 +  signed long disp;

 20051 +

 20052 +  disp = get_signed_value(&ifields[1]) << op->align_order;

 20053 +

 20054 +  info->fprintf_func(info->stream, "%s[%ld]",

 20055 +		     reg_table[ifields[0].value].name, disp);

 20056 +  return 2;

 20057 +}

 20058 +

 20059 +static int

 20060 +print_intreg_udisp(struct avr32_operand *op,

 20061 +		   struct disassemble_info *info,

 20062 +		   struct avr32_field_value *ifields)

 20063 +{

 20064 +  info->fprintf_func(info->stream, "%s[0x%lx]",

 20065 +		     reg_table[ifields[0].value].name,

 20066 +		     ifields[1].value << op->align_order);

 20067 +  return 2;

 20068 +}

 20069 +

 20070 +static int

 20071 +print_intreg_index(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20072 +		   struct disassemble_info *info,

 20073 +		   struct avr32_field_value *ifields)

 20074 +{

 20075 +  const char *rb, *ri;

 20076 +  unsigned long sa = ifields[2].value;

 20077 +

 20078 +  rb = reg_table[ifields[0].value].name;

 20079 +  ri = reg_table[ifields[1].value].name;

 20080 +

 20081 +  if (sa)

 20082 +    info->fprintf_func(info->stream, "%s[%s<<0x%lx]", rb, ri, sa);

 20083 +  else

 20084 +    info->fprintf_func(info->stream, "%s[%s]", rb, ri);

 20085 +

 20086 +  return 3;

 20087 +}

 20088 +

 20089 +static int

 20090 +print_intreg_xindex(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20091 +		    struct disassemble_info *info,

 20092 +		    struct avr32_field_value *ifields)

 20093 +{

 20094 +  info->fprintf_func(info->stream, "%s[%s:%c<<2]",

 20095 +		     reg_table[ifields[0].value].name,

 20096 +		     reg_table[ifields[1].value].name,

 20097 +		     bparts[ifields[2].value]);

 20098 +  return 3;

 20099 +}

 20100 +

 20101 +static int

 20102 +print_jmplabel(struct avr32_operand *op,

 20103 +	       struct disassemble_info *info,

 20104 +	       struct avr32_field_value *ifields)

 20105 +{

 20106 +  bfd_vma address, offset;

 20107 +

 20108 +  offset = get_signed_value(ifields) << op->align_order;

 20109 +  address = (current_pc & (~0UL << op->align_order)) + offset;

 20110 +

 20111 +  info->print_address_func(address, info);

 20112 +

 20113 +  return 1;

 20114 +}

 20115 +

 20116 +static int

 20117 +print_pc_disp(struct avr32_operand *op,

 20118 +	      struct disassemble_info *info,

 20119 +	      struct avr32_field_value *ifields)

 20120 +{

 20121 +  bfd_vma address, offset;

 20122 +

 20123 +  offset = ifields[0].value << op->align_order;

 20124 +  address = (current_pc & (~0UL << op->align_order)) + offset;

 20125 +

 20126 +  info->print_address_func(address, info);

 20127 +

 20128 +  return 1;

 20129 +}

 20130 +

 20131 +static int

 20132 +print_sp(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20133 +	 struct disassemble_info *info,

 20134 +	 struct avr32_field_value *ifields ATTRIBUTE_UNUSED)

 20135 +{

 20136 +  info->fprintf_func(info->stream, "sp");

 20137 +  return 1;

 20138 +}

 20139 +

 20140 +static int

 20141 +print_sp_disp(struct avr32_operand *op,

 20142 +	      struct disassemble_info *info,

 20143 +	      struct avr32_field_value *ifields)

 20144 +{

 20145 +  info->fprintf_func(info->stream, "sp[0x%lx]",

 20146 +		     ifields[0].value << op->align_order);

 20147 +  return 1;

 20148 +}

 20149 +

 20150 +static int

 20151 +print_cpno(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20152 +	   struct disassemble_info *info,

 20153 +	   struct avr32_field_value *ifields)

 20154 +{

 20155 +  info->fprintf_func(info->stream, "cp%lu", ifields[0].value);

 20156 +  return 1;

 20157 +}

 20158 +

 20159 +static int

 20160 +print_cpreg(struct avr32_operand *op,

 20161 +	    struct disassemble_info *info,

 20162 +	    struct avr32_field_value *ifields)

 20163 +{

 20164 +  info->fprintf_func(info->stream, "cr%lu",

 20165 +		     ifields[0].value << op->align_order);

 20166 +  return 1;

 20167 +}

 20168 +

 20169 +static int

 20170 +print_uconst(struct avr32_operand *op,

 20171 +	     struct disassemble_info *info,

 20172 +	     struct avr32_field_value *ifields)

 20173 +{

 20174 +  info->fprintf_func(info->stream, "0x%lx",

 20175 +		     ifields[0].value << op->align_order);

 20176 +  return 1;

 20177 +}

 20178 +

 20179 +static int

 20180 +print_sconst(struct avr32_operand *op,

 20181 +	     struct disassemble_info *info,

 20182 +	     struct avr32_field_value *ifields)

 20183 +{

 20184 +  info->fprintf_func(info->stream, "%ld",

 20185 +		     get_signed_value(ifields) << op->align_order);

 20186 +  return 1;

 20187 +}

 20188 +

 20189 +static int

 20190 +print_reglist8_head(unsigned long regmask, int *commap,

 20191 +		    struct disassemble_info *info)

 20192 +{

 20193 +  int first = -1, last, i = 0;

 20194 +  int need_comma = 0;

 20195 +

 20196 +  while (i < 12)

 20197 +    {

 20198 +      if (first == -1 && (regmask & 1))

 20199 +	{

 20200 +	  first = i;

 20201 +	}

 20202 +      else if (first != -1 && !(regmask & 1))

 20203 +	{

 20204 +	  last = i - 1;

 20205 +

 20206 +	  print_reglist_range(first, last, reg_table, need_comma, info);

 20207 +	  need_comma = 1;

 20208 +	  first = -1;

 20209 +	}

 20210 +

 20211 +      if (i < 8)

 20212 +	i += 4;

 20213 +      else if (i < 10)

 20214 +	i += 2;

 20215 +      else

 20216 +	i++;

 20217 +      regmask >>= 1;

 20218 +    }

 20219 +

 20220 +  *commap = need_comma;

 20221 +  return first;

 20222 +}

 20223 +

 20224 +static void

 20225 +print_reglist8_tail(unsigned long regmask, int first, int need_comma,

 20226 +		    struct disassemble_info *info)

 20227 +{

 20228 +  int last = 11;

 20229 +

 20230 +  if (regmask & 0x20)

 20231 +    {

 20232 +      if (first == -1)

 20233 +	first = 12;

 20234 +      last = 12;

 20235 +    }

 20236 +

 20237 +  if (first != -1)

 20238 +    {

 20239 +      print_reglist_range(first, last, reg_table, need_comma, info);

 20240 +      need_comma = 1;

 20241 +      first = -1;

 20242 +    }

 20243 +

 20244 +  if (regmask & 0x40)

 20245 +    {

 20246 +      if (first == -1)

 20247 +	first = 14;

 20248 +      last = 14;

 20249 +    }

 20250 +

 20251 +  if (regmask & 0x80)

 20252 +    {

 20253 +      if (first == -1)

 20254 +	first = 15;

 20255 +      last = 15;

 20256 +    }

 20257 +

 20258 +  if (first != -1)

 20259 +    print_reglist_range(first, last, reg_table, need_comma, info);

 20260 +}

 20261 +

 20262 +static int

 20263 +print_reglist8(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20264 +	       struct disassemble_info *info,

 20265 +	       struct avr32_field_value *ifields)

 20266 +{

 20267 +  unsigned long regmask = ifields[0].value;

 20268 +  int first, need_comma;

 20269 +

 20270 +  first = print_reglist8_head(regmask, &need_comma, info);

 20271 +  print_reglist8_tail(regmask, first, need_comma, info);

 20272 +

 20273 +  return 1;

 20274 +}

 20275 +

 20276 +static int

 20277 +print_reglist9(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20278 +	       struct disassemble_info *info,

 20279 +	       struct avr32_field_value *ifields)

 20280 +{

 20281 +  unsigned long regmask = ifields[0].value >> 1;

 20282 +  int first, last, need_comma;

 20283 +

 20284 +  first = print_reglist8_head(regmask, &need_comma, info);

 20285 +

 20286 +  if ((ifields[0].value & 0x101) == 0x101)

 20287 +    {

 20288 +      if (first != -1)

 20289 +	{

 20290 +	  last = 11;

 20291 +

 20292 +	  print_reglist_range(first, last, reg_table, need_comma, info);

 20293 +	  need_comma = 1;

 20294 +	  first = -1;

 20295 +	}

 20296 +

 20297 +      print_reglist_range(15, 15, reg_table, need_comma, info);

 20298 +

 20299 +      regmask >>= 5;

 20300 +

 20301 +      if ((regmask & 3) == 0)

 20302 +	info->fprintf_func(info->stream, ",r12=0");

 20303 +      else if ((regmask & 3) == 1)

 20304 +	info->fprintf_func(info->stream, ",r12=1");

 20305 +      else

 20306 +	info->fprintf_func(info->stream, ",r12=-1");

 20307 +    }

 20308 +  else

 20309 +      print_reglist8_tail(regmask, first, need_comma, info);

 20310 +

 20311 +  return 1;

 20312 +}

 20313 +

 20314 +static int

 20315 +print_reglist16(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20316 +		struct disassemble_info *info,

 20317 +		struct avr32_field_value *ifields)

 20318 +{

 20319 +  unsigned long regmask = ifields[0].value;

 20320 +  unsigned int i = 0, first, last;

 20321 +  int need_comma = 0;

 20322 +

 20323 +  while (i < 16)

 20324 +    {

 20325 +      if (regmask & 1)

 20326 +	{

 20327 +	  first = i;

 20328 +	  while (i < 16)

 20329 +	    {

 20330 +	      i++;

 20331 +	      regmask >>= 1;

 20332 +	      if (!(regmask & 1))

 20333 +		break;

 20334 +	    }

 20335 +	  last = i - 1;

 20336 +	  print_reglist_range(first, last, reg_table, need_comma, info);

 20337 +	  need_comma = 1;

 20338 +	}

 20339 +      else

 20340 +	{

 20341 +	  i++;

 20342 +	  regmask >>= 1;

 20343 +	}

 20344 +    }

 20345 +

 20346 +  return 1;

 20347 +}

 20348 +

 20349 +static int

 20350 +print_reglist_ldm(struct avr32_operand *op,

 20351 +		  struct disassemble_info *info,

 20352 +		  struct avr32_field_value *ifields)

 20353 +{

 20354 +  int rp, w_bit;

 20355 +  int i, first, last;

 20356 +  unsigned long regmask;

 20357 +

 20358 +  rp = ifields[0].value;

 20359 +  w_bit = ifields[1].value;

 20360 +  regmask = ifields[2].value;

 20361 +

 20362 +  if (regmask & (1 << AVR32_REG_PC) && rp == AVR32_REG_PC)

 20363 +    {

 20364 +      if (w_bit)

 20365 +	info->fprintf_func(info->stream, "sp++");

 20366 +      else

 20367 +	info->fprintf_func(info->stream, "sp");

 20368 +

 20369 +      for (i = 0; i < 12; )

 20370 +	{

 20371 +	  if (regmask & (1 << i))

 20372 +	    {

 20373 +	      first = i;

 20374 +	      while (i < 12)

 20375 +		{

 20376 +		  i++;

 20377 +		  if (!(regmask & (1 << i)))

 20378 +		    break;

 20379 +		}

 20380 +	      last = i - 1;

 20381 +	      print_reglist_range(first, last, reg_table, 1, info);

 20382 +	    }

 20383 +	  else

 20384 +	    i++;

 20385 +	}

 20386 +

 20387 +      info->fprintf_func(info->stream, ",pc");

 20388 +      if (regmask & (1 << AVR32_REG_LR))

 20389 +	info->fprintf_func(info->stream, ",r12=-1");

 20390 +      else if (regmask & (1 << AVR32_REG_R12))

 20391 +	info->fprintf_func(info->stream, ",r12=1");

 20392 +      else

 20393 +	info->fprintf_func(info->stream, ",r12=0");

 20394 +    }

 20395 +  else

 20396 +    {

 20397 +      if (w_bit)

 20398 +	info->fprintf_func(info->stream, "%s++,", reg_table[rp].name);

 20399 +      else

 20400 +	info->fprintf_func(info->stream, "%s,", reg_table[rp].name);

 20401 +

 20402 +      print_reglist16(op, info, ifields + 2);

 20403 +    }

 20404 +

 20405 +  return 3;

 20406 +}

 20407 +

 20408 +static int

 20409 +print_reglist_cp8(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20410 +		  struct disassemble_info *info,

 20411 +		  struct avr32_field_value *ifields)

 20412 +{

 20413 +  unsigned long regmask = ifields[0].value;

 20414 +  unsigned int i = 0, first, last, offset = 0;

 20415 +  int need_comma = 0;

 20416 +

 20417 +  if (ifields[1].value)

 20418 +    offset = 8;

 20419 +

 20420 +  while (i < 8)

 20421 +    {

 20422 +      if (regmask & 1)

 20423 +	{

 20424 +	  first = i;

 20425 +	  while (i < 8)

 20426 +	    {

 20427 +	      i++;

 20428 +	      regmask >>= 1;

 20429 +	      if (!(regmask & 1))

 20430 +		break;

 20431 +	    }

 20432 +	  last = i - 1;

 20433 +	  print_reglist_range(offset + first, offset + last,

 20434 +			      cr_table, need_comma, info);

 20435 +	  need_comma = 1;

 20436 +	}

 20437 +      else

 20438 +	{

 20439 +	  i++;

 20440 +	  regmask >>= 1;

 20441 +	}

 20442 +    }

 20443 +

 20444 +  return 2;

 20445 +}

 20446 +

 20447 +static int

 20448 +print_reglist_cpd8(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20449 +		   struct disassemble_info *info,

 20450 +		   struct avr32_field_value *ifields)

 20451 +{

 20452 +  unsigned long regmask = ifields[0].value;

 20453 +  unsigned int i = 0, first, last;

 20454 +  int need_comma = 0;

 20455 +

 20456 +  while (i < 8)

 20457 +    {

 20458 +      if (regmask & 1)

 20459 +	{

 20460 +	  first = 2 * i;

 20461 +	  while (i < 8)

 20462 +	    {

 20463 +	      i++;

 20464 +	      regmask >>= 1;

 20465 +	      if (!(regmask & 1))

 20466 +		break;

 20467 +	    }

 20468 +	  last = 2 * (i - 1) + 1;

 20469 +	  print_reglist_range(first, last, cr_table, need_comma, info);

 20470 +	  need_comma = 1;

 20471 +	}

 20472 +      else

 20473 +	{

 20474 +	  i++;

 20475 +	  regmask >>= 1;

 20476 +	}

 20477 +    }

 20478 +

 20479 +  return 1;

 20480 +}

 20481 +

 20482 +static int

 20483 +print_retval(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20484 +	     struct disassemble_info *info,

 20485 +	     struct avr32_field_value *ifields)

 20486 +{

 20487 +  unsigned long regid = ifields[0].value;

 20488 +  const char *retval;

 20489 +

 20490 +  if (regid < AVR32_REG_SP)

 20491 +    retval = reg_table[regid].name;

 20492 +  else if (regid == AVR32_REG_SP)

 20493 +    retval = "0";

 20494 +  else if (regid == AVR32_REG_LR)

 20495 +    retval = "-1";

 20496 +  else

 20497 +    retval = "1";

 20498 +

 20499 +  info->fprintf_func(info->stream, "%s", retval);

 20500 +

 20501 +  return 1;

 20502 +}

 20503 +

 20504 +static int

 20505 +print_mcall(struct avr32_operand *op,

 20506 +	    struct disassemble_info *info,

 20507 +	    struct avr32_field_value *ifields)

 20508 +{

 20509 +  unsigned long regid = ifields[0].value;

 20510 +

 20511 +  if (regid == AVR32_REG_PC)

 20512 +    print_jmplabel(op, info, ifields + 1);

 20513 +  else

 20514 +    print_intreg_sdisp(op, info, ifields);

 20515 +

 20516 +  return 2;

 20517 +}

 20518 +

 20519 +static int

 20520 +print_jospinc(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20521 +	      struct disassemble_info *info,

 20522 +	      struct avr32_field_value *ifields)

 20523 +{

 20524 +  signed long value = ifields[0].value;

 20525 +

 20526 +  if (value >= 4)

 20527 +    value -= 8;

 20528 +  else

 20529 +    value += 1;

 20530 +

 20531 +  info->fprintf_func(info->stream, "%ld", value);

 20532 +

 20533 +  return 1;

 20534 +}

 20535 +

 20536 +static int

 20537 +print_coh(struct avr32_operand *op ATTRIBUTE_UNUSED,

 20538 +	  struct disassemble_info *info,

 20539 +	  struct avr32_field_value *ifields ATTRIBUTE_UNUSED)

 20540 +{

 20541 +  info->fprintf_func(info->stream, "COH");

 20542 +  return 0;

 20543 +}

 20544 +

 20545 +#define OP(name, sgn, pcrel, align, func) \

 20546 +  { AVR32_OPERAND_##name, pcrel, align, print_##func }

 20547 +

 20548 +struct avr32_operand operand[AVR32_NR_OPERANDS] =

 20549 +  {

 20550 +    OP(INTREG, 0, 0, 0, intreg),

 20551 +    OP(INTREG_PREDEC, 0, 0, 0, intreg_predec),

 20552 +    OP(INTREG_POSTINC, 0, 0, 0, intreg_postinc),

 20553 +    OP(INTREG_LSL, 0, 0, 0, intreg_lsl),

 20554 +    OP(INTREG_LSR, 0, 0, 0, intreg_lsr),

 20555 +    OP(INTREG_BSEL, 0, 0, 0, intreg_bpart),

 20556 +    OP(INTREG_HSEL, 0, 0, 1, intreg_hpart),

 20557 +    OP(INTREG_SDISP, 1, 0, 0, intreg_sdisp),

 20558 +    OP(INTREG_SDISP_H, 1, 0, 1, intreg_sdisp),

 20559 +    OP(INTREG_SDISP_W, 1, 0, 2, intreg_sdisp),

 20560 +    OP(INTREG_UDISP, 0, 0, 0, intreg_udisp),

 20561 +    OP(INTREG_UDISP_H, 0, 0, 1, intreg_udisp),

 20562 +    OP(INTREG_UDISP_W, 0, 0, 2, intreg_udisp),

 20563 +    OP(INTREG_INDEX, 0, 0, 0, intreg_index),

 20564 +    OP(INTREG_XINDEX, 0, 0, 0, intreg_xindex),

 20565 +    OP(DWREG, 0, 0, 1, intreg),

 20566 +    OP(PC_UDISP_W, 0, 1, 2, pc_disp),

 20567 +    OP(SP, 0, 0, 0, sp),

 20568 +    OP(SP_UDISP_W, 0, 0, 2, sp_disp),

 20569 +    OP(CPNO, 0, 0, 0, cpno),

 20570 +    OP(CPREG, 0, 0, 0, cpreg),

 20571 +    OP(CPREG_D, 0, 0, 1, cpreg),

 20572 +    OP(UNSIGNED_CONST, 0, 0, 0, uconst),

 20573 +    OP(UNSIGNED_CONST_W, 0, 0, 2, uconst),

 20574 +    OP(SIGNED_CONST, 1, 0, 0, sconst),

 20575 +    OP(SIGNED_CONST_W, 1, 0, 2, sconst),

 20576 +    OP(JMPLABEL, 1, 1, 1, jmplabel),

 20577 +    OP(UNSIGNED_NUMBER, 0, 0, 0, uconst),

 20578 +    OP(UNSIGNED_NUMBER_W, 0, 0, 2, uconst),

 20579 +    OP(REGLIST8, 0, 0, 0, reglist8),

 20580 +    OP(REGLIST9, 0, 0, 0, reglist9),

 20581 +    OP(REGLIST16, 0, 0, 0, reglist16),

 20582 +    OP(REGLIST_LDM, 0, 0, 0, reglist_ldm),

 20583 +    OP(REGLIST_CP8, 0, 0, 0, reglist_cp8),

 20584 +    OP(REGLIST_CPD8, 0, 0, 0, reglist_cpd8),

 20585 +    OP(RETVAL, 0, 0, 0, retval),

 20586 +    OP(MCALL, 1, 0, 2, mcall),

 20587 +    OP(JOSPINC, 0, 0, 0, jospinc),

 20588 +    OP(COH, 0, 0, 0, coh),

 20589 +  };

 20590 +

 20591 +static void

 20592 +print_opcode(bfd_vma insn_word, const struct avr32_opcode *opc,

 20593 +	     bfd_vma pc, struct disassemble_info *info)

 20594 +{

 20595 +  const struct avr32_syntax *syntax = opc->syntax;

 20596 +  struct avr32_field_value fields[AVR32_MAX_FIELDS];

 20597 +  unsigned int i, next_field = 0, nr_operands;

 20598 +

 20599 +  for (i = 0; i < opc->nr_fields; i++)

 20600 +    {

 20601 +      opc->fields[i]->extract(opc->fields[i], &insn_word, &fields[i].value);

 20602 +      fields[i].ifield = opc->fields[i];

 20603 +    }

 20604 +

 20605 +  current_pc = pc;

 20606 +  info->fprintf_func(info->stream, "%s", syntax->mnemonic->name);

 20607 +

 20608 +  if (syntax->nr_operands < 0)

 20609 +    nr_operands = (unsigned int) -syntax->nr_operands;

 20610 +  else

 20611 +    nr_operands = (unsigned int) syntax->nr_operands;

 20612 +

 20613 +  for (i = 0; i < nr_operands; i++)

 20614 +    {

 20615 +      struct avr32_operand *op = &operand[syntax->operand[i]];

 20616 +

 20617 +      if (i)

 20618 +	info->fprintf_func(info->stream, ",");

 20619 +      else

 20620 +	info->fprintf_func(info->stream, "\t");

 20621 +      next_field += op->print(op, info, &fields[next_field]);

 20622 +    }

 20623 +}

 20624 +

 20625 +static const struct avr32_opcode *

 20626 +find_opcode(bfd_vma insn_word)

 20627 +{

 20628 +  int i;

 20629 +

 20630 +  for (i = 0; i < AVR32_NR_OPCODES; i++)

 20631 +    {

 20632 +      const struct avr32_opcode *opc = &avr32_opc_table[i];

 20633 +

 20634 +      if ((insn_word & opc->mask) == opc->value)

 20635 +	return opc;

 20636 +    }

 20637 +

 20638 +  return NULL;

 20639 +}

 20640 +

 20641 +static int

 20642 +read_insn_word(bfd_vma pc, bfd_vma *valuep,

 20643 +	       struct disassemble_info *info)

 20644 +{

 20645 +  bfd_byte b[4];

 20646 +  int status;

 20647 +

 20648 +  status = info->read_memory_func(pc, b, 4, info);

 20649 +  if (status)

 20650 +    {

 20651 +      status = info->read_memory_func(pc, b, 2, info);

 20652 +      if (status)

 20653 +	{

 20654 +	  info->memory_error_func(status, pc, info);

 20655 +	  return -1;

 20656 +	}

 20657 +      b[3] = b[2] = 0;

 20658 +    }

 20659 +

 20660 +  *valuep =  (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];

 20661 +  return 0;

 20662 +}

 20663 +

 20664 +/* Parse an individual disassembler option.  */

 20665 +

 20666 +void

 20667 +parse_avr32_disassembler_option (option)

 20668 +     char * option;

 20669 +{

 20670 +  if (option == NULL)

 20671 +    return;

 20672 +

 20673 +  /* XXX - should break 'option' at following delimiter.  */

 20674 +  fprintf (stderr, _("Unrecognised disassembler option: %s\n"), option);

 20675 +

 20676 +  return;

 20677 +}

 20678 +

 20679 +/* Parse the string of disassembler options, spliting it at whitespaces

 20680 +   or commas.  (Whitespace separators supported for backwards compatibility).  */

 20681 +

 20682 +static void

 20683 +parse_disassembler_options (char *options)

 20684 +{

 20685 +  if (options == NULL)

 20686 +    return;

 20687 +

 20688 +  while (*options)

 20689 +    {

 20690 +      parse_avr32_disassembler_option (options);

 20691 +

 20692 +      /* Skip forward to next seperator.  */

 20693 +      while ((*options) && (! ISSPACE (*options)) && (*options != ','))

 20694 +	++ options;

 20695 +      /* Skip forward past seperators.  */

 20696 +      while (ISSPACE (*options) || (*options == ','))

 20697 +	++ options;

 20698 +    }

 20699 +}

 20700 +

 20701 +int

 20702 +print_insn_avr32(bfd_vma pc, struct disassemble_info *info)

 20703 +{

 20704 +  bfd_vma insn_word;

 20705 +  const struct avr32_opcode *opc;

 20706 +

 20707 +  if (info->disassembler_options)

 20708 +    {

 20709 +      parse_disassembler_options (info->disassembler_options);

 20710 +

 20711 +      /* To avoid repeated parsing of these options, we remove them here.  */

 20712 +      info->disassembler_options = NULL;

 20713 +    }

 20714 +

 20715 +  info->bytes_per_chunk = 1;

 20716 +  info->display_endian = BFD_ENDIAN_BIG;

 20717 +

 20718 +  if (read_insn_word(pc, &insn_word, info))

 20719 +    return -1;

 20720 +

 20721 +  opc = find_opcode(insn_word);

 20722 +  if (opc)

 20723 +    {

 20724 +      print_opcode(insn_word, opc, pc, info);

 20725 +      return opc->size;

 20726 +    }

 20727 +  else

 20728 +    {

 20729 +      info->fprintf_func(info->stream, _("*unknown*"));

 20730 +      return 2;

 20731 +    }

 20732 +

 20733 +}

 20734 +

 20735 +void

 20736 +print_avr32_disassembler_options (FILE *stream ATTRIBUTE_UNUSED)

 20737 +{

 20738 +

 20739 +}

 20740 --- /dev/null

 20741 +++ b/opcodes/avr32-opc.c

 20742 @@ -0,0 +1,6932 @@

 20743 +/* Opcode tables for AVR32.

 20744 +   Copyright 2005, 2006 Atmel Corporation.

 20745 +

 20746 +   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>

 20747 +

 20748 +   This file is part of libopcodes.

 20749 +

 20750 +   This program is free software; you can redistribute it and/or

 20751 +   modify it under the terms of the GNU General Public License as

 20752 +   published by the Free Software Foundation; either version 2 of the

 20753 +   License, or (at your option) any later version.

 20754 +

 20755 +   This program is distributed in the hope that it will be useful, but

 20756 +   WITHOUT ANY WARRANTY; without even the implied warranty of

 20757 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 20758 +   General Public License for more details.

 20759 +

 20760 +   You should have received a copy of the GNU General Public License

 20761 +   along with this program; if not, write to the Free Software

 20762 +   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

 20763 +   02111-1307, USA.  */

 20764 +

 20765 +#include <stdlib.h>

 20766 +#include <assert.h>

 20767 +

 20768 +#include "avr32-opc.h"

 20769 +

 20770 +#define PICO_CPNO	1

 20771 +

 20772 +void

 20773 +avr32_insert_simple(const struct avr32_ifield *field,

 20774 +		    void *buf, unsigned long value)

 20775 +{

 20776 +  bfd_vma word;

 20777 +

 20778 +  word = bfd_getb32(buf);

 20779 +  word &= ~field->mask;

 20780 +  word |= (value << field->shift) & field->mask;

 20781 +  bfd_putb32(word, buf);

 20782 +}

 20783 +

 20784 +void

 20785 +avr32_insert_bit5c(const struct avr32_ifield *field ATTRIBUTE_UNUSED,

 20786 +		   void *buf, unsigned long value)

 20787 +{

 20788 +  char *opcode = buf;

 20789 +

 20790 +  opcode[0] = (opcode[0] & 0xe1) | (value & 0x1e);

 20791 +  opcode[1] = (opcode[1] & 0xef) | ((value & 1) << 4);

 20792 +}

 20793 +

 20794 +void

 20795 +avr32_insert_k10(const struct avr32_ifield *field ATTRIBUTE_UNUSED,

 20796 +		 void *buf, unsigned long value)

 20797 +{

 20798 +  char *opcode = buf;

 20799 +

 20800 +  opcode[0] = (opcode[0] & 0xf0) | ((value & 0xf0) >> 4);

 20801 +  opcode[1] = ((opcode[1] & 0x0c) | ((value & 0x0f) << 4)

 20802 +	       | ((value & 0x300) >> 8));

 20803 +}

 20804 +

 20805 +

 20806 +void

 20807 +avr32_insert_k21(const struct avr32_ifield *field,

 20808 +		 void *buf, unsigned long value)

 20809 +{

 20810 +  bfd_vma word;

 20811 +  bfd_vma k21;

 20812 +

 20813 +  word = bfd_getb32(buf);

 20814 +  word &= ~field->mask;

 20815 +  k21 = ((value & 0xffff) | ((value & 0x10000) << 4)

 20816 +	 | ((value & 0x1e0000) << 8));

 20817 +  assert(!(k21 & ~field->mask));

 20818 +  word |= k21;

 20819 +  bfd_putb32(word, buf);

 20820 +}

 20821 +

 20822 +void

 20823 +avr32_insert_cpop(const struct avr32_ifield *field,

 20824 +		  void *buf, unsigned long value)

 20825 +{

 20826 +  bfd_vma word;

 20827 +

 20828 +  word = bfd_getb32(buf);

 20829 +  word &= ~field->mask;

 20830 +  word |= (((value & 0x1e) << 15) | ((value & 0x60) << 20)

 20831 +	   | ((value & 0x01) << 12));

 20832 +  bfd_putb32(word, buf);

 20833 +}

 20834 +

 20835 +void

 20836 +avr32_insert_k12cp(const struct avr32_ifield *field,

 20837 +		   void *buf, unsigned long value)

 20838 +{

 20839 +  bfd_vma word;

 20840 +

 20841 +  word = bfd_getb32(buf);

 20842 +  word &= ~field->mask;

 20843 +  word |= ((value & 0xf00) << 4) | (value & 0xff);

 20844 +  bfd_putb32(word, buf);

 20845 +}

 20846 +

 20847 +void avr32_extract_simple(const struct avr32_ifield *field,

 20848 +			  void *buf, unsigned long *value)

 20849 +{

 20850 +  /* XXX: The disassembler has done any necessary byteswapping already */

 20851 +  bfd_vma word = *(bfd_vma *)buf;

 20852 +

 20853 +  *value = (word & field->mask) >> field->shift;

 20854 +}

 20855 +

 20856 +void avr32_extract_bit5c(const struct avr32_ifield *field ATTRIBUTE_UNUSED,

 20857 +			 void *buf, unsigned long *value)

 20858 +{

 20859 +  bfd_vma word = *(bfd_vma *)buf;

 20860 +

 20861 +  *value = ((word >> 20) & 1) | ((word >> 24) & 0x1e);

 20862 +}

 20863 +

 20864 +void avr32_extract_k10(const struct avr32_ifield *field ATTRIBUTE_UNUSED,

 20865 +		       void *buf, unsigned long *value)

 20866 +{

 20867 +  bfd_vma word = *(bfd_vma *)buf;

 20868 +

 20869 +  *value = ((word >> 8) & 0x300) | ((word >> 20) & 0xff);

 20870 +}

 20871 +

 20872 +void avr32_extract_k21(const struct avr32_ifield *field ATTRIBUTE_UNUSED,

 20873 +		       void *buf, unsigned long *value)

 20874 +{

 20875 +  bfd_vma word = *(bfd_vma *)buf;

 20876 +

 20877 +  *value = ((word & 0xffff) | ((word >> 4) & 0x10000)

 20878 +	    | ((word >> 8) & 0x1e0000));

 20879 +}

 20880 +

 20881 +void avr32_extract_cpop(const struct avr32_ifield *field ATTRIBUTE_UNUSED,

 20882 +			void *buf, unsigned long *value)

 20883 +{

 20884 +  bfd_vma word = *(bfd_vma *)buf;

 20885 +

 20886 +  *value = (((word >> 12) & 1) | ((word >> 15) & 0x1e)

 20887 +	    | ((word >> 20) & 0x60));

 20888 +}

 20889 +

 20890 +void avr32_extract_k12cp(const struct avr32_ifield *field ATTRIBUTE_UNUSED,

 20891 +			 void *buf, unsigned long *value)

 20892 +{

 20893 +  bfd_vma word = *(bfd_vma *)buf;

 20894 +

 20895 +  *value = ((word >> 4) & 0xf00) | (word & 0xff);

 20896 +}

 20897 +

 20898 +

 20899 +#define IFLD(id, bitsz, shift, mask, func) \

 20900 +  { AVR32_IFIELD_##id, bitsz, shift, mask, \

 20901 +    avr32_insert_##func, avr32_extract_##func }

 20902 +

 20903 +const struct avr32_ifield avr32_ifield_table[] =

 20904 +  {

 20905 +    IFLD(RX, 4, 25, 0x1e000000, simple),

 20906 +    IFLD(RY, 4, 16, 0x000f0000, simple),

 20907 +    IFLD(COND4C, 4, 20, 0x00f00000, simple),

 20908 +    IFLD(K8C, 8, 20, 0x0ff00000, simple),

 20909 +    IFLD(K7C, 7, 20, 0x07f00000, simple),

 20910 +    IFLD(K5C, 5, 20, 0x01f00000, simple),

 20911 +    IFLD(K3, 3, 20, 0x00700000, simple),

 20912 +    IFLD(RY_DW, 3, 17, 0x000e0000, simple),

 20913 +    IFLD(COND4E, 4, 8, 0x00000f00, simple),

 20914 +    IFLD(K8E, 8, 0, 0x000000ff, simple),

 20915 +    IFLD(BIT5C, 5, 20, 0x1e100000, bit5c),

 20916 +    IFLD(COND3, 3, 16, 0x00070000, simple),

 20917 +    IFLD(K10, 10, 16, 0x0ff30000, k10),

 20918 +    IFLD(POPM, 9, 19, 0x0ff80000, simple),

 20919 +    IFLD(K2, 2, 4, 0x00000030, simple),

 20920 +    IFLD(RD_E, 4, 0, 0x0000000f, simple),

 20921 +    IFLD(RD_DW, 3, 1, 0x0000000e, simple),

 20922 +    IFLD(X, 1, 5, 0x00000020, simple),

 20923 +    IFLD(Y, 1, 4, 0x00000010, simple),

 20924 +    IFLD(X2, 1, 13, 0x00002000, simple),

 20925 +    IFLD(Y2, 1, 12, 0x00001000, simple),

 20926 +    IFLD(K5E, 5, 0, 0x0000001f, simple),

 20927 +    IFLD(PART2, 2, 0, 0x00000003, simple),

 20928 +    IFLD(PART1, 1, 0, 0x00000001, simple),

 20929 +    IFLD(K16, 16, 0, 0x0000ffff, simple),

 20930 +    IFLD(CACHEOP, 5, 11, 0x0000f800, simple),

 20931 +    IFLD(K11, 11, 0, 0x000007ff, simple),

 20932 +    IFLD(K21, 21, 0, 0x1e10ffff, k21),

 20933 +    IFLD(CPOP, 7, 12, 0x060f1000, cpop),

 20934 +    IFLD(CPNO, 3, 13, 0x0000e000, simple),

 20935 +    IFLD(CRD_RI, 4, 8, 0x00000f00, simple),

 20936 +    IFLD(CRX, 4, 4, 0x000000f0, simple),

 20937 +    IFLD(CRY, 4, 0, 0x0000000f, simple),

 20938 +    IFLD(K7E, 7, 0, 0x0000007f, simple),

 20939 +    IFLD(CRD_DW, 3, 9, 0x00000e00, simple),

 20940 +    IFLD(PART1_K12, 1, 12, 0x00001000, simple),

 20941 +    IFLD(PART2_K12, 2, 12, 0x00003000, simple),

 20942 +    IFLD(K12, 12, 0, 0x00000fff, simple),

 20943 +    IFLD(S5, 5, 5, 0x000003e0, simple),

 20944 +    IFLD(K5E2, 5, 4, 0x000001f0, simple),

 20945 +    IFLD(K4, 4, 20, 0x00f00000, simple),

 20946 +    IFLD(COND4E2, 4, 4, 0x000000f0, simple),

 20947 +    IFLD(K8E2, 8, 4, 0x00000ff0, simple),

 20948 +    IFLD(K6, 6, 20, 0x03f00000, simple),

 20949 +    IFLD(MEM15, 15, 0, 0x00007fff, simple),

 20950 +    IFLD(MEMB5, 5, 15, 0x000f8000, simple),

 20951 +    IFLD(W, 1, 25, 0x02000000, simple),

 20952 +    /* Coprocessor Multiple High/Low */

 20953 +    IFLD(CM_HL, 1, 8, 0x00000100, simple),

 20954 +    IFLD(K12CP, 12 ,0, 0x0000f0ff, k12cp),

 20955 +    IFLD(K9E, 9 ,0, 0x000001ff, simple),

 20956 +  };

 20957 +#undef IFLD

 20958 +

 20959 +

 20960 +struct avr32_opcode avr32_opc_table[] =

 20961 +  {

 20962 +    {

 20963 +      AVR32_OPC_ABS, 2, 0x5c400000, 0xfff00000,

 20964 +      &avr32_syntax_table[AVR32_SYNTAX_ABS],

 20965 +      BFD_RELOC_UNUSED, 1, -1,

 20966 +      {

 20967 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 20968 +      }

 20969 +    },

 20970 +    {

 20971 +      AVR32_OPC_ACALL, 2, 0xd0000000, 0xf00f0000,

 20972 +      &avr32_syntax_table[AVR32_SYNTAX_ACALL],

 20973 +      BFD_RELOC_UNUSED, 1, -1,

 20974 +      {

 20975 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 20976 +      },

 20977 +    },

 20978 +    {

 20979 +      AVR32_OPC_ACR, 2, 0x5c000000, 0xfff00000,

 20980 +      &avr32_syntax_table[AVR32_SYNTAX_ACR],

 20981 +      BFD_RELOC_UNUSED, 1, -1,

 20982 +      {

 20983 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 20984 +      },

 20985 +    },

 20986 +    {

 20987 +      AVR32_OPC_ADC, 4, 0xe0000040, 0xe1f0fff0,

 20988 +      &avr32_syntax_table[AVR32_SYNTAX_ADC],

 20989 +      BFD_RELOC_UNUSED, 3, -1,

 20990 +      {

 20991 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 20992 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 20993 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 20994 +      },

 20995 +    },

 20996 +    {

 20997 +      AVR32_OPC_ADD1, 2, 0x00000000, 0xe1f00000,

 20998 +      &avr32_syntax_table[AVR32_SYNTAX_ADD1],

 20999 +      BFD_RELOC_UNUSED, 2, -1,

 21000 +      {

 21001 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21002 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21003 +      },

 21004 +    },

 21005 +    {

 21006 +      AVR32_OPC_ADD2, 4, 0xe0000000, 0xe1f0ffc0,

 21007 +      &avr32_syntax_table[AVR32_SYNTAX_ADD2],

 21008 +      BFD_RELOC_UNUSED, 4, -1,

 21009 +      {

 21010 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21011 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21012 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21013 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 21014 +      },

 21015 +    },

 21016 +    {

 21017 +      AVR32_OPC_ADDABS, 4, 0xe0000e40, 0xe1f0fff0,

 21018 +      &avr32_syntax_table[AVR32_SYNTAX_ADDABS],

 21019 +      BFD_RELOC_UNUSED, 3, -1,

 21020 +      {

 21021 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21022 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21023 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21024 +      },

 21025 +    },

 21026 +    {

 21027 +      AVR32_OPC_ADDHH_W, 4, 0xe0000e00, 0xe1f0ffc0,

 21028 +      &avr32_syntax_table[AVR32_SYNTAX_ADDHH_W],

 21029 +      BFD_RELOC_UNUSED, 5, -1,

 21030 +      {

 21031 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21032 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21033 +	&avr32_ifield_table[AVR32_IFIELD_X],

 21034 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21035 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 21036 +      },

 21037 +    },

 21038 +    {

 21039 +      AVR32_OPC_AND1, 2, 0x00600000, 0xe1f00000,

 21040 +      &avr32_syntax_table[AVR32_SYNTAX_AND1],

 21041 +      BFD_RELOC_UNUSED, 2, -1,

 21042 +      {

 21043 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21044 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21045 +      },

 21046 +    },

 21047 +    {

 21048 +      AVR32_OPC_AND2, 4, 0xe1e00000, 0xe1f0fe00,

 21049 +      &avr32_syntax_table[AVR32_SYNTAX_AND2],

 21050 +      BFD_RELOC_UNUSED, 4, -1,

 21051 +      {

 21052 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21053 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21054 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21055 +	&avr32_ifield_table[AVR32_IFIELD_K5E2],

 21056 +      },

 21057 +    },

 21058 +    {

 21059 +      AVR32_OPC_AND3, 4, 0xe1e00200, 0xe1f0fe00,

 21060 +      &avr32_syntax_table[AVR32_SYNTAX_AND3],

 21061 +      BFD_RELOC_UNUSED, 4, -1,

 21062 +      {

 21063 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21064 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21065 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21066 +	&avr32_ifield_table[AVR32_IFIELD_K5E2],

 21067 +      },

 21068 +    },

 21069 +    {

 21070 +      AVR32_OPC_ANDH, 4, 0xe4100000, 0xfff00000,

 21071 +      &avr32_syntax_table[AVR32_SYNTAX_ANDH],

 21072 +      BFD_RELOC_AVR32_16U, 2, 1,

 21073 +      {

 21074 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21075 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 21076 +      },

 21077 +    },

 21078 +    {

 21079 +      AVR32_OPC_ANDH_COH, 4, 0xe6100000, 0xfff00000,

 21080 +      &avr32_syntax_table[AVR32_SYNTAX_ANDH_COH],

 21081 +      BFD_RELOC_AVR32_16U, 2, 1,

 21082 +      {

 21083 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21084 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 21085 +      },

 21086 +    },

 21087 +    {

 21088 +      AVR32_OPC_ANDL, 4, 0xe0100000, 0xfff00000,

 21089 +      &avr32_syntax_table[AVR32_SYNTAX_ANDL],

 21090 +      BFD_RELOC_AVR32_16U, 2, 1,

 21091 +      {

 21092 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21093 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 21094 +      },

 21095 +    },

 21096 +    {

 21097 +      AVR32_OPC_ANDL_COH, 4, 0xe2100000, 0xfff00000,

 21098 +      &avr32_syntax_table[AVR32_SYNTAX_ANDL_COH],

 21099 +      BFD_RELOC_AVR32_16U, 2, 1,

 21100 +      {

 21101 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21102 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 21103 +      },

 21104 +    },

 21105 +    {

 21106 +      AVR32_OPC_ANDN, 2, 0x00800000, 0xe1f00000,

 21107 +      &avr32_syntax_table[AVR32_SYNTAX_ANDN],

 21108 +      BFD_RELOC_UNUSED, 2, -1,

 21109 +      {

 21110 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21111 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21112 +      },

 21113 +    },

 21114 +    {

 21115 +      AVR32_OPC_ASR1, 4, 0xe0000840, 0xe1f0fff0,

 21116 +      &avr32_syntax_table[AVR32_SYNTAX_ASR1],

 21117 +      BFD_RELOC_UNUSED, 3, -1,

 21118 +      {

 21119 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21120 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21121 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21122 +      },

 21123 +    },

 21124 +    {

 21125 +      AVR32_OPC_ASR3, 4, 0xe0001400, 0xe1f0ffe0,

 21126 +      &avr32_syntax_table[AVR32_SYNTAX_ASR3],

 21127 +      BFD_RELOC_UNUSED, 3, -1,

 21128 +      {

 21129 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21130 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21131 +	&avr32_ifield_table[AVR32_IFIELD_K5E],

 21132 +      },

 21133 +    },

 21134 +    {

 21135 +      AVR32_OPC_ASR2, 2, 0xa1400000, 0xe1e00000,

 21136 +      &avr32_syntax_table[AVR32_SYNTAX_ASR2],

 21137 +      BFD_RELOC_UNUSED, 2, -1,

 21138 +      {

 21139 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21140 +	&avr32_ifield_table[AVR32_IFIELD_BIT5C],

 21141 +      },

 21142 +    },

 21143 +    {

 21144 +      AVR32_OPC_BLD, 4, 0xedb00000, 0xfff0ffe0,

 21145 +      &avr32_syntax_table[AVR32_SYNTAX_BLD],

 21146 +      BFD_RELOC_UNUSED, 2, -1,

 21147 +      {

 21148 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21149 +	&avr32_ifield_table[AVR32_IFIELD_K5E],

 21150 +      },

 21151 +    },

 21152 +    {

 21153 +      AVR32_OPC_BREQ1, 2, 0xc0000000, 0xf00f0000,

 21154 +      &avr32_syntax_table[AVR32_SYNTAX_BREQ1],

 21155 +      BFD_RELOC_AVR32_9H_PCREL, 1, 0,

 21156 +      {

 21157 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 21158 +      },

 21159 +    },

 21160 +    {

 21161 +      AVR32_OPC_BRNE1, 2, 0xc0010000, 0xf00f0000,

 21162 +      &avr32_syntax_table[AVR32_SYNTAX_BRNE1],

 21163 +      BFD_RELOC_AVR32_9H_PCREL, 1, 0,

 21164 +      {

 21165 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 21166 +      },

 21167 +    },

 21168 +    {

 21169 +      AVR32_OPC_BRCC1, 2, 0xc0020000, 0xf00f0000,

 21170 +      &avr32_syntax_table[AVR32_SYNTAX_BRCC1],

 21171 +      BFD_RELOC_AVR32_9H_PCREL, 1, 0,

 21172 +      {

 21173 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 21174 +      },

 21175 +    },

 21176 +    {

 21177 +      AVR32_OPC_BRCS1, 2, 0xc0030000, 0xf00f0000,

 21178 +      &avr32_syntax_table[AVR32_SYNTAX_BRCS1],

 21179 +      BFD_RELOC_AVR32_9H_PCREL, 1, 0,

 21180 +      {

 21181 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 21182 +      },

 21183 +    },

 21184 +    {

 21185 +      AVR32_OPC_BRGE1, 2, 0xc0040000, 0xf00f0000,

 21186 +      &avr32_syntax_table[AVR32_SYNTAX_BRGE1],

 21187 +      BFD_RELOC_AVR32_9H_PCREL, 1, 0,

 21188 +      {

 21189 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 21190 +      },

 21191 +    },

 21192 +    {

 21193 +      AVR32_OPC_BRLT1, 2, 0xc0050000, 0xf00f0000,

 21194 +      &avr32_syntax_table[AVR32_SYNTAX_BRLT1],

 21195 +      BFD_RELOC_AVR32_9H_PCREL, 1, 0,

 21196 +      {

 21197 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 21198 +      },

 21199 +    },

 21200 +    {

 21201 +      AVR32_OPC_BRMI1, 2, 0xc0060000, 0xf00f0000,

 21202 +      &avr32_syntax_table[AVR32_SYNTAX_BRMI1],

 21203 +      BFD_RELOC_AVR32_9H_PCREL, 1, 0,

 21204 +      {

 21205 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 21206 +      },

 21207 +    },

 21208 +    {

 21209 +      AVR32_OPC_BRPL1, 2, 0xc0070000, 0xf00f0000,

 21210 +      &avr32_syntax_table[AVR32_SYNTAX_BRPL1],

 21211 +      BFD_RELOC_AVR32_9H_PCREL, 1, 0,

 21212 +      {

 21213 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 21214 +      },

 21215 +    },

 21216 +    {

 21217 +      AVR32_OPC_BREQ2, 4, 0xe0800000, 0xe1ef0000,

 21218 +      &avr32_syntax_table[AVR32_SYNTAX_BREQ2],

 21219 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21220 +      {

 21221 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21222 +      },

 21223 +    },

 21224 +    {

 21225 +      AVR32_OPC_BRNE2, 4, 0xe0810000, 0xe1ef0000,

 21226 +      &avr32_syntax_table[AVR32_SYNTAX_BRNE2],

 21227 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21228 +      {

 21229 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21230 +      },

 21231 +    },

 21232 +    {

 21233 +      AVR32_OPC_BRCC2, 4, 0xe0820000, 0xe1ef0000,

 21234 +      &avr32_syntax_table[AVR32_SYNTAX_BRHS2],

 21235 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21236 +      {

 21237 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21238 +      },

 21239 +    },

 21240 +    {

 21241 +      AVR32_OPC_BRCS2, 4, 0xe0830000, 0xe1ef0000,

 21242 +      &avr32_syntax_table[AVR32_SYNTAX_BRLO2],

 21243 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21244 +      {

 21245 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21246 +      },

 21247 +    },

 21248 +    {

 21249 +      AVR32_OPC_BRGE2, 4, 0xe0840000, 0xe1ef0000,

 21250 +      &avr32_syntax_table[AVR32_SYNTAX_BRGE2],

 21251 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21252 +      {

 21253 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21254 +      },

 21255 +    },

 21256 +    {

 21257 +      AVR32_OPC_BRLT2, 4, 0xe0850000, 0xe1ef0000,

 21258 +      &avr32_syntax_table[AVR32_SYNTAX_BRLT2],

 21259 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21260 +      {

 21261 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21262 +      },

 21263 +    },

 21264 +    {

 21265 +      AVR32_OPC_BRMI2, 4, 0xe0860000, 0xe1ef0000,

 21266 +      &avr32_syntax_table[AVR32_SYNTAX_BRMI2],

 21267 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21268 +      {

 21269 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21270 +      },

 21271 +    },

 21272 +    {

 21273 +      AVR32_OPC_BRPL2, 4, 0xe0870000, 0xe1ef0000,

 21274 +      &avr32_syntax_table[AVR32_SYNTAX_BRPL2],

 21275 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21276 +      {

 21277 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21278 +      },

 21279 +    },

 21280 +    {

 21281 +      AVR32_OPC_BRLS, 4, 0xe0880000, 0xe1ef0000,

 21282 +      &avr32_syntax_table[AVR32_SYNTAX_BRLS],

 21283 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21284 +      {

 21285 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21286 +      },

 21287 +    },

 21288 +    {

 21289 +      AVR32_OPC_BRGT, 4, 0xe0890000, 0xe1ef0000,

 21290 +      &avr32_syntax_table[AVR32_SYNTAX_BRGT],

 21291 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21292 +      {

 21293 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21294 +      },

 21295 +    },

 21296 +    {

 21297 +      AVR32_OPC_BRLE, 4, 0xe08a0000, 0xe1ef0000,

 21298 +      &avr32_syntax_table[AVR32_SYNTAX_BRLE],

 21299 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21300 +      {

 21301 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21302 +      },

 21303 +    },

 21304 +    {

 21305 +      AVR32_OPC_BRHI, 4, 0xe08b0000, 0xe1ef0000,

 21306 +      &avr32_syntax_table[AVR32_SYNTAX_BRHI],

 21307 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21308 +      {

 21309 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21310 +      },

 21311 +    },

 21312 +    {

 21313 +      AVR32_OPC_BRVS, 4, 0xe08c0000, 0xe1ef0000,

 21314 +      &avr32_syntax_table[AVR32_SYNTAX_BRVS],

 21315 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21316 +      {

 21317 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21318 +      },

 21319 +    },

 21320 +    {

 21321 +      AVR32_OPC_BRVC, 4, 0xe08d0000, 0xe1ef0000,

 21322 +      &avr32_syntax_table[AVR32_SYNTAX_BRVC],

 21323 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21324 +      {

 21325 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21326 +      },

 21327 +    },

 21328 +    {

 21329 +      AVR32_OPC_BRQS, 4, 0xe08e0000, 0xe1ef0000,

 21330 +      &avr32_syntax_table[AVR32_SYNTAX_BRQS],

 21331 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21332 +      {

 21333 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21334 +      },

 21335 +    },

 21336 +    {

 21337 +      AVR32_OPC_BRAL, 4, 0xe08f0000, 0xe1ef0000,

 21338 +      &avr32_syntax_table[AVR32_SYNTAX_BRAL],

 21339 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 21340 +      {

 21341 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21342 +      },

 21343 +    },

 21344 +    {

 21345 +      AVR32_OPC_BREAKPOINT, 2, 0xd6730000, 0xffff0000,

 21346 +      &avr32_syntax_table[AVR32_SYNTAX_BREAKPOINT],

 21347 +      BFD_RELOC_UNUSED, 0, -1, { NULL },

 21348 +    },

 21349 +    {

 21350 +      AVR32_OPC_BREV, 2, 0x5c900000, 0xfff00000,

 21351 +      &avr32_syntax_table[AVR32_SYNTAX_BREV],

 21352 +      BFD_RELOC_UNUSED, 1, -1,

 21353 +      {

 21354 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21355 +      },

 21356 +    },

 21357 +    {

 21358 +      AVR32_OPC_BST, 4, 0xefb00000, 0xfff0ffe0,

 21359 +      &avr32_syntax_table[AVR32_SYNTAX_BST],

 21360 +      BFD_RELOC_UNUSED, 2, -1,

 21361 +      {

 21362 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21363 +	&avr32_ifield_table[AVR32_IFIELD_K5E],

 21364 +      },

 21365 +    },

 21366 +    {

 21367 +      AVR32_OPC_CACHE, 4, 0xf4100000, 0xfff00000,

 21368 +      &avr32_syntax_table[AVR32_SYNTAX_CACHE],

 21369 +      BFD_RELOC_UNUSED, 3, -1,

 21370 +      {

 21371 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21372 +	&avr32_ifield_table[AVR32_IFIELD_K11],

 21373 +	&avr32_ifield_table[AVR32_IFIELD_CACHEOP],

 21374 +      },

 21375 +    },

 21376 +    {

 21377 +      AVR32_OPC_CASTS_B, 2, 0x5c600000, 0xfff00000,

 21378 +      &avr32_syntax_table[AVR32_SYNTAX_CASTS_B],

 21379 +      BFD_RELOC_UNUSED, 1, -1,

 21380 +      {

 21381 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21382 +      },

 21383 +    },

 21384 +    {

 21385 +      AVR32_OPC_CASTS_H, 2, 0x5c800000, 0xfff00000,

 21386 +      &avr32_syntax_table[AVR32_SYNTAX_CASTS_H],

 21387 +      BFD_RELOC_UNUSED, 1, -1,

 21388 +      {

 21389 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21390 +      },

 21391 +    },

 21392 +    {

 21393 +      AVR32_OPC_CASTU_B, 2, 0x5c500000, 0xfff00000,

 21394 +      &avr32_syntax_table[AVR32_SYNTAX_CASTU_B],

 21395 +      BFD_RELOC_UNUSED, 1, -1,

 21396 +      {

 21397 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21398 +      },

 21399 +    },

 21400 +    {

 21401 +      AVR32_OPC_CASTU_H, 2, 0x5c700000, 0xfff00000,

 21402 +      &avr32_syntax_table[AVR32_SYNTAX_CASTU_H],

 21403 +      BFD_RELOC_UNUSED, 1, -1,

 21404 +      {

 21405 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21406 +      },

 21407 +    },

 21408 +    {

 21409 +      AVR32_OPC_CBR, 2, 0xa1c00000, 0xe1e00000,

 21410 +      &avr32_syntax_table[AVR32_SYNTAX_CBR],

 21411 +      BFD_RELOC_UNUSED, 2, -1,

 21412 +      {

 21413 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21414 +	&avr32_ifield_table[AVR32_IFIELD_BIT5C],

 21415 +      },

 21416 +    },

 21417 +    {

 21418 +      AVR32_OPC_CLZ, 4, 0xe0001200, 0xe1f0ffff,

 21419 +      &avr32_syntax_table[AVR32_SYNTAX_CLZ],

 21420 +      BFD_RELOC_UNUSED, 2, -1,

 21421 +      {

 21422 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21423 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21424 +      },

 21425 +    },

 21426 +    {

 21427 +      AVR32_OPC_COM, 2, 0x5cd00000, 0xfff00000,

 21428 +      &avr32_syntax_table[AVR32_SYNTAX_COM],

 21429 +      BFD_RELOC_UNUSED, 1, -1,

 21430 +      {

 21431 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21432 +      },

 21433 +    },

 21434 +    {

 21435 +      AVR32_OPC_COP, 4, 0xe1a00000, 0xf9f00000,

 21436 +      &avr32_syntax_table[AVR32_SYNTAX_COP],

 21437 +      BFD_RELOC_UNUSED, 5, -1,

 21438 +      {

 21439 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 21440 +	&avr32_ifield_table[AVR32_IFIELD_CRD_RI],

 21441 +	&avr32_ifield_table[AVR32_IFIELD_CRX],

 21442 +	&avr32_ifield_table[AVR32_IFIELD_CRY],

 21443 +	&avr32_ifield_table[AVR32_IFIELD_CPOP],

 21444 +      },

 21445 +    },

 21446 +    {

 21447 +      AVR32_OPC_CP_B, 4, 0xe0001800, 0xe1f0ffff,

 21448 +      &avr32_syntax_table[AVR32_SYNTAX_CP_B],

 21449 +      BFD_RELOC_UNUSED, 2, -1,

 21450 +      {

 21451 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21452 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21453 +      },

 21454 +    },

 21455 +    {

 21456 +      AVR32_OPC_CP_H, 4, 0xe0001900, 0xe1f0ffff,

 21457 +      &avr32_syntax_table[AVR32_SYNTAX_CP_H],

 21458 +      BFD_RELOC_UNUSED, 2, -1,

 21459 +      {

 21460 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21461 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21462 +      },

 21463 +    },

 21464 +    {

 21465 +      AVR32_OPC_CP_W1, 2, 0x00300000, 0xe1f00000,

 21466 +      &avr32_syntax_table[AVR32_SYNTAX_CP_W1],

 21467 +      BFD_RELOC_UNUSED, 2, -1,

 21468 +      {

 21469 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21470 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21471 +      },

 21472 +    },

 21473 +    {

 21474 +      AVR32_OPC_CP_W2, 2, 0x58000000, 0xfc000000,

 21475 +      &avr32_syntax_table[AVR32_SYNTAX_CP_W2],

 21476 +      BFD_RELOC_AVR32_6S, 2, 1,

 21477 +      {

 21478 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21479 +	&avr32_ifield_table[AVR32_IFIELD_K6],

 21480 +      },

 21481 +    },

 21482 +    {

 21483 +      AVR32_OPC_CP_W3, 4, 0xe0400000, 0xe1e00000,

 21484 +      &avr32_syntax_table[AVR32_SYNTAX_CP_W3],

 21485 +      BFD_RELOC_AVR32_21S, 2, 1,

 21486 +      {

 21487 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21488 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 21489 +      },

 21490 +    },

 21491 +    {

 21492 +      AVR32_OPC_CPC1, 4, 0xe0001300, 0xe1f0ffff,

 21493 +      &avr32_syntax_table[AVR32_SYNTAX_CPC1],

 21494 +      BFD_RELOC_UNUSED, 2, -1,

 21495 +      {

 21496 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21497 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21498 +      },

 21499 +    },

 21500 +    {

 21501 +      AVR32_OPC_CPC2, 2, 0x5c200000, 0xfff00000,

 21502 +      &avr32_syntax_table[AVR32_SYNTAX_CPC2],

 21503 +      BFD_RELOC_UNUSED, 1, -1,

 21504 +      {

 21505 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21506 +      },

 21507 +    },

 21508 +    {

 21509 +      AVR32_OPC_CSRF, 2, 0xd4030000, 0xfe0f0000,

 21510 +      &avr32_syntax_table[AVR32_SYNTAX_CSRF],

 21511 +      BFD_RELOC_UNUSED, 1, -1,

 21512 +      {

 21513 +	&avr32_ifield_table[AVR32_IFIELD_K5C],

 21514 +      },

 21515 +    },

 21516 +    {

 21517 +      AVR32_OPC_CSRFCZ, 2, 0xd0030000, 0xfe0f0000,

 21518 +      &avr32_syntax_table[AVR32_SYNTAX_CSRFCZ],

 21519 +      BFD_RELOC_UNUSED, 1, -1,

 21520 +      {

 21521 +	&avr32_ifield_table[AVR32_IFIELD_K5C],

 21522 +      },

 21523 +    },

 21524 +    {

 21525 +      AVR32_OPC_DIVS, 4, 0xe0000c00, 0xe1f0ffc0,

 21526 +      &avr32_syntax_table[AVR32_SYNTAX_DIVS],

 21527 +      BFD_RELOC_UNUSED, 3, -1,

 21528 +      {

 21529 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21530 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21531 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21532 +      },

 21533 +    },

 21534 +    {

 21535 +      AVR32_OPC_DIVU, 4, 0xe0000d00, 0xe1f0ffc0,

 21536 +      &avr32_syntax_table[AVR32_SYNTAX_DIVU],

 21537 +      BFD_RELOC_UNUSED, 3, -1,

 21538 +      {

 21539 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21540 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21541 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21542 +      },

 21543 +    },

 21544 +    {

 21545 +      AVR32_OPC_EOR1, 2, 0x00500000, 0xe1f00000,

 21546 +      &avr32_syntax_table[AVR32_SYNTAX_EOR1],

 21547 +      BFD_RELOC_UNUSED, 2, -1,

 21548 +      {

 21549 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21550 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21551 +      },

 21552 +    },

 21553 +    {

 21554 +      AVR32_OPC_EOR2, 4, 0xe1e02000, 0xe1f0fe00,

 21555 +      &avr32_syntax_table[AVR32_SYNTAX_EOR2],

 21556 +      BFD_RELOC_UNUSED, 4, -1,

 21557 +      {

 21558 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21559 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21560 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21561 +	&avr32_ifield_table[AVR32_IFIELD_K5E2],

 21562 +      }

 21563 +    },

 21564 +    {

 21565 +      AVR32_OPC_EOR3, 4, 0xe1e02200, 0xe1f0fe00,

 21566 +      &avr32_syntax_table[AVR32_SYNTAX_EOR3],

 21567 +      BFD_RELOC_UNUSED, 4, -1,

 21568 +      {

 21569 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21570 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21571 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21572 +	&avr32_ifield_table[AVR32_IFIELD_K5E2],

 21573 +      }

 21574 +    },

 21575 +    {

 21576 +      AVR32_OPC_EORL, 4, 0xec100000, 0xfff00000,

 21577 +      &avr32_syntax_table[AVR32_SYNTAX_EORL],

 21578 +      BFD_RELOC_AVR32_16U, 2, 1,

 21579 +      {

 21580 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21581 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 21582 +      },

 21583 +    },

 21584 +    {

 21585 +      AVR32_OPC_EORH, 4, 0xee100000, 0xfff00000,

 21586 +      &avr32_syntax_table[AVR32_SYNTAX_EORH],

 21587 +      BFD_RELOC_AVR32_16U, 2, 1,

 21588 +      {

 21589 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21590 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 21591 +      },

 21592 +    },

 21593 +    {

 21594 +      AVR32_OPC_FRS, 2, 0xd7430000, 0xffff0000,

 21595 +      &avr32_syntax_table[AVR32_SYNTAX_FRS],

 21596 +      BFD_RELOC_UNUSED, 0, -1, { NULL },

 21597 +    },

 21598 +    {

 21599 +      AVR32_OPC_ICALL, 2, 0x5d100000, 0xfff00000,

 21600 +      &avr32_syntax_table[AVR32_SYNTAX_ICALL],

 21601 +      BFD_RELOC_UNUSED, 1, -1,

 21602 +      {

 21603 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21604 +      },

 21605 +    },

 21606 +    {

 21607 +      AVR32_OPC_INCJOSP, 2, 0xd6830000, 0xff8f0000,

 21608 +      &avr32_syntax_table[AVR32_SYNTAX_INCJOSP],

 21609 +      BFD_RELOC_UNUSED, 1, -1,

 21610 +      {

 21611 +	&avr32_ifield_table[AVR32_IFIELD_K3],

 21612 +      },

 21613 +    },

 21614 +    {

 21615 +      AVR32_OPC_LD_D1, 2, 0xa1010000, 0xe1f10000,

 21616 +      &avr32_syntax_table[AVR32_SYNTAX_LD_D1],

 21617 +      BFD_RELOC_UNUSED, 2, -1,

 21618 +      {

 21619 +	&avr32_ifield_table[AVR32_IFIELD_RY_DW],

 21620 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21621 +      },

 21622 +    },

 21623 +    {

 21624 +      AVR32_OPC_LD_D2, 2, 0xa1100000, 0xe1f10000,

 21625 +      &avr32_syntax_table[AVR32_SYNTAX_LD_D2],

 21626 +      BFD_RELOC_UNUSED, 2, -1,

 21627 +      {

 21628 +	&avr32_ifield_table[AVR32_IFIELD_RY_DW],

 21629 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21630 +      },

 21631 +    },

 21632 +    {

 21633 +      AVR32_OPC_LD_D3, 2, 0xa1000000, 0xe1f10000,

 21634 +      &avr32_syntax_table[AVR32_SYNTAX_LD_D3],

 21635 +      BFD_RELOC_UNUSED, 2, -1,

 21636 +      {

 21637 +	&avr32_ifield_table[AVR32_IFIELD_RY_DW],

 21638 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21639 +      },

 21640 +    },

 21641 +    {

 21642 +      AVR32_OPC_LD_D5, 4, 0xe0000200, 0xe1f0ffc1,

 21643 +      &avr32_syntax_table[AVR32_SYNTAX_LD_D5],

 21644 +      BFD_RELOC_UNUSED, 4, -1,

 21645 +      {

 21646 +	&avr32_ifield_table[AVR32_IFIELD_RD_DW],

 21647 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21648 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21649 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 21650 +      },

 21651 +    },

 21652 +    {

 21653 +      AVR32_OPC_LD_D4, 4, 0xe0e00000, 0xe1f10000,

 21654 +      &avr32_syntax_table[AVR32_SYNTAX_LD_D4],

 21655 +      BFD_RELOC_AVR32_16S, 3, 2,

 21656 +      {

 21657 +	&avr32_ifield_table[AVR32_IFIELD_RY_DW],

 21658 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21659 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 21660 +      },

 21661 +    },

 21662 +    {

 21663 +      AVR32_OPC_LD_SB2, 4, 0xe0000600, 0xe1f0ffc0,

 21664 +      &avr32_syntax_table[AVR32_SYNTAX_LD_SB2],

 21665 +      BFD_RELOC_UNUSED, 4, -1,

 21666 +      {

 21667 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21668 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21669 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21670 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 21671 +      },

 21672 +    },

 21673 +    {

 21674 +      AVR32_OPC_LD_SB1, 4, 0xe1200000, 0xe1f00000,

 21675 +      &avr32_syntax_table[AVR32_SYNTAX_LD_SB1],

 21676 +      BFD_RELOC_AVR32_16S, 3, -1,

 21677 +      {

 21678 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21679 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21680 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 21681 +      },

 21682 +    },

 21683 +    {

 21684 +      AVR32_OPC_LD_UB1, 2, 0x01300000, 0xe1f00000,

 21685 +      &avr32_syntax_table[AVR32_SYNTAX_LD_UB1],

 21686 +      BFD_RELOC_UNUSED, 2, -1,

 21687 +      {

 21688 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21689 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21690 +      },

 21691 +    },

 21692 +    {

 21693 +      AVR32_OPC_LD_UB2, 2, 0x01700000, 0xe1f00000,

 21694 +      &avr32_syntax_table[AVR32_SYNTAX_LD_UB2],

 21695 +      BFD_RELOC_UNUSED, 2, -1,

 21696 +      {

 21697 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21698 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21699 +      },

 21700 +    },

 21701 +    {

 21702 +      AVR32_OPC_LD_UB5, 4, 0xe0000700, 0xe1f0ffc0,

 21703 +      &avr32_syntax_table[AVR32_SYNTAX_LD_UB5],

 21704 +      BFD_RELOC_UNUSED, 4, -1,

 21705 +      {

 21706 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21707 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21708 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21709 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 21710 +      },

 21711 +    },

 21712 +    {

 21713 +      AVR32_OPC_LD_UB3, 2, 0x01800000, 0xe1800000,

 21714 +      &avr32_syntax_table[AVR32_SYNTAX_LD_UB3],

 21715 +      BFD_RELOC_AVR32_3U, 3, 2,

 21716 +      {

 21717 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21718 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21719 +	&avr32_ifield_table[AVR32_IFIELD_K3],

 21720 +      },

 21721 +    },

 21722 +    {

 21723 +      AVR32_OPC_LD_UB4, 4, 0xe1300000, 0xe1f00000,

 21724 +      &avr32_syntax_table[AVR32_SYNTAX_LD_UB4],

 21725 +      BFD_RELOC_AVR32_16S, 3, 2,

 21726 +      {

 21727 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21728 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21729 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 21730 +      },

 21731 +    },

 21732 +    {

 21733 +      AVR32_OPC_LD_SH1, 2, 0x01100000, 0xe1f00000,

 21734 +      &avr32_syntax_table[AVR32_SYNTAX_LD_SH1],

 21735 +      BFD_RELOC_UNUSED, 2, -1,

 21736 +      {

 21737 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21738 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21739 +      },

 21740 +    },

 21741 +    {

 21742 +      AVR32_OPC_LD_SH2, 2, 0x01500000, 0xe1f00000,

 21743 +      &avr32_syntax_table[AVR32_SYNTAX_LD_SH2],

 21744 +      BFD_RELOC_UNUSED, 2, -1,

 21745 +      {

 21746 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21747 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21748 +      },

 21749 +    },

 21750 +    {

 21751 +      AVR32_OPC_LD_SH5, 4, 0xe0000400, 0xe1f0ffc0,

 21752 +      &avr32_syntax_table[AVR32_SYNTAX_LD_SH5],

 21753 +      BFD_RELOC_UNUSED, 4, -1,

 21754 +      {

 21755 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21756 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21757 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21758 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 21759 +      },

 21760 +    },

 21761 +    {

 21762 +      AVR32_OPC_LD_SH3, 2, 0x80000000, 0xe1800000,

 21763 +      &avr32_syntax_table[AVR32_SYNTAX_LD_SH3],

 21764 +      BFD_RELOC_AVR32_4UH, 3, 2,

 21765 +      {

 21766 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21767 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21768 +	&avr32_ifield_table[AVR32_IFIELD_K3],

 21769 +      },

 21770 +    },

 21771 +    {

 21772 +      AVR32_OPC_LD_SH4, 4, 0xe1000000, 0xe1f00000,

 21773 +      &avr32_syntax_table[AVR32_SYNTAX_LD_SH4],

 21774 +      BFD_RELOC_AVR32_16S, 3, 2,

 21775 +      {

 21776 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21777 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21778 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 21779 +      },

 21780 +    },

 21781 +    {

 21782 +      AVR32_OPC_LD_UH1, 2, 0x01200000, 0xe1f00000,

 21783 +      &avr32_syntax_table[AVR32_SYNTAX_LD_UH1],

 21784 +      BFD_RELOC_UNUSED, 2, -1,

 21785 +      {

 21786 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21787 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21788 +      },

 21789 +    },

 21790 +    {

 21791 +      AVR32_OPC_LD_UH2, 2, 0x01600000, 0xe1f00000,

 21792 +      &avr32_syntax_table[AVR32_SYNTAX_LD_UH2],

 21793 +      BFD_RELOC_UNUSED, 2, -1,

 21794 +      {

 21795 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21796 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21797 +      },

 21798 +    },

 21799 +    {

 21800 +      AVR32_OPC_LD_UH5, 4, 0xe0000500, 0xe1f0ffc0,

 21801 +      &avr32_syntax_table[AVR32_SYNTAX_LD_UH5],

 21802 +      BFD_RELOC_UNUSED, 4, -1,

 21803 +      {

 21804 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21805 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21806 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21807 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 21808 +      },

 21809 +    },

 21810 +    {

 21811 +      AVR32_OPC_LD_UH3, 2, 0x80800000, 0xe1800000,

 21812 +      &avr32_syntax_table[AVR32_SYNTAX_LD_UH3],

 21813 +      BFD_RELOC_AVR32_4UH, 3, 2,

 21814 +      {

 21815 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21816 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21817 +	&avr32_ifield_table[AVR32_IFIELD_K3],

 21818 +      },

 21819 +    },

 21820 +    {

 21821 +      AVR32_OPC_LD_UH4, 4, 0xe1100000, 0xe1f00000,

 21822 +      &avr32_syntax_table[AVR32_SYNTAX_LD_UH4],

 21823 +      BFD_RELOC_AVR32_16S, 3, 2,

 21824 +      {

 21825 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21826 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21827 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 21828 +      },

 21829 +    },

 21830 +    {

 21831 +      AVR32_OPC_LD_W1, 2, 0x01000000, 0xe1f00000,

 21832 +      &avr32_syntax_table[AVR32_SYNTAX_LD_W1],

 21833 +      BFD_RELOC_UNUSED, 2, -1,

 21834 +      {

 21835 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21836 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21837 +      },

 21838 +    },

 21839 +    {

 21840 +      AVR32_OPC_LD_W2, 2, 0x01400000, 0xe1f00000,

 21841 +      &avr32_syntax_table[AVR32_SYNTAX_LD_W2],

 21842 +      BFD_RELOC_UNUSED, 2, -1,

 21843 +      {

 21844 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21845 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21846 +      },

 21847 +    },

 21848 +    {

 21849 +      AVR32_OPC_LD_W5, 4, 0xe0000300, 0xe1f0ffc0,

 21850 +      &avr32_syntax_table[AVR32_SYNTAX_LD_W5],

 21851 +      BFD_RELOC_UNUSED, 4, -1,

 21852 +      {

 21853 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21854 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21855 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21856 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 21857 +      },

 21858 +    },

 21859 +    {

 21860 +      AVR32_OPC_LD_W6, 4, 0xe0000f80, 0xe1f0ffc0,

 21861 +      &avr32_syntax_table[AVR32_SYNTAX_LD_W6],

 21862 +      BFD_RELOC_UNUSED, 4, -1,

 21863 +      {

 21864 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21865 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21866 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21867 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 21868 +      },

 21869 +    },

 21870 +    {

 21871 +      AVR32_OPC_LD_W3, 2, 0x60000000, 0xe0000000,

 21872 +      &avr32_syntax_table[AVR32_SYNTAX_LD_W3],

 21873 +      BFD_RELOC_AVR32_7UW, 3, 2,

 21874 +      {

 21875 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21876 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21877 +	&avr32_ifield_table[AVR32_IFIELD_K5C],

 21878 +      },

 21879 +    },

 21880 +    {

 21881 +      AVR32_OPC_LD_W4, 4, 0xe0f00000, 0xe1f00000,

 21882 +      &avr32_syntax_table[AVR32_SYNTAX_LD_W4],

 21883 +      BFD_RELOC_AVR32_16S, 3, 2,

 21884 +      {

 21885 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21886 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 21887 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 21888 +      },

 21889 +    },

 21890 +    {

 21891 +      AVR32_OPC_LDC_D1, 4, 0xe9a01000, 0xfff01100,

 21892 +      &avr32_syntax_table[AVR32_SYNTAX_LDC_D1],

 21893 +      BFD_RELOC_AVR32_10UW, 4, 3,

 21894 +      {

 21895 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 21896 +	&avr32_ifield_table[AVR32_IFIELD_CRD_DW],

 21897 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21898 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 21899 +      },

 21900 +    },

 21901 +    {

 21902 +      AVR32_OPC_LDC_D2, 4, 0xefa00050, 0xfff011ff,

 21903 +      &avr32_syntax_table[AVR32_SYNTAX_LDC_D2],

 21904 +      BFD_RELOC_UNUSED, 3, -1,

 21905 +      {

 21906 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 21907 +	&avr32_ifield_table[AVR32_IFIELD_CRD_DW],

 21908 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21909 +      },

 21910 +    },

 21911 +    {

 21912 +      AVR32_OPC_LDC_D3, 4, 0xefa01040, 0xfff011c0,

 21913 +      &avr32_syntax_table[AVR32_SYNTAX_LDC_D3],

 21914 +      BFD_RELOC_UNUSED, 5, -1,

 21915 +      {

 21916 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 21917 +	&avr32_ifield_table[AVR32_IFIELD_CRD_DW],

 21918 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21919 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21920 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 21921 +      },

 21922 +    },

 21923 +    {

 21924 +      AVR32_OPC_LDC_W1, 4, 0xe9a00000, 0xfff01000,

 21925 +      &avr32_syntax_table[AVR32_SYNTAX_LDC_W1],

 21926 +      BFD_RELOC_AVR32_10UW, 4, 3,

 21927 +      {

 21928 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 21929 +	&avr32_ifield_table[AVR32_IFIELD_CRD_RI],

 21930 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21931 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 21932 +      },

 21933 +    },

 21934 +    {

 21935 +      AVR32_OPC_LDC_W2, 4, 0xefa00040, 0xfff010ff,

 21936 +      &avr32_syntax_table[AVR32_SYNTAX_LDC_W2],

 21937 +      BFD_RELOC_UNUSED, 3, -1,

 21938 +      {

 21939 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 21940 +	&avr32_ifield_table[AVR32_IFIELD_CRD_RI],

 21941 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21942 +      },

 21943 +    },

 21944 +    {

 21945 +      AVR32_OPC_LDC_W3, 4, 0xefa01000, 0xfff010c0,

 21946 +      &avr32_syntax_table[AVR32_SYNTAX_LDC_W3],

 21947 +      BFD_RELOC_UNUSED, 5, -1,

 21948 +      {

 21949 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 21950 +	&avr32_ifield_table[AVR32_IFIELD_CRD_RI],

 21951 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21952 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 21953 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 21954 +      },

 21955 +    },

 21956 +    {

 21957 +      AVR32_OPC_LDC0_D, 4, 0xf3a00000, 0xfff00100,

 21958 +      &avr32_syntax_table[AVR32_SYNTAX_LDC0_D],

 21959 +      BFD_RELOC_AVR32_14UW, 3, 2,

 21960 +      {

 21961 +	&avr32_ifield_table[AVR32_IFIELD_CRD_DW],

 21962 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21963 +	&avr32_ifield_table[AVR32_IFIELD_K12CP],

 21964 +      },

 21965 +    },

 21966 +    {

 21967 +      AVR32_OPC_LDC0_W, 4, 0xf1a00000, 0xfff00000,

 21968 +      &avr32_syntax_table[AVR32_SYNTAX_LDC0_W],

 21969 +      BFD_RELOC_AVR32_14UW, 3, 2,

 21970 +      {

 21971 +	&avr32_ifield_table[AVR32_IFIELD_CRD_RI],

 21972 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21973 +	&avr32_ifield_table[AVR32_IFIELD_K12CP],

 21974 +      },

 21975 +    },

 21976 +    {

 21977 +      AVR32_OPC_LDCM_D, 4, 0xeda00400, 0xfff01f00,

 21978 +      &avr32_syntax_table[AVR32_SYNTAX_LDCM_D],

 21979 +      BFD_RELOC_UNUSED, 3, -1,

 21980 +      {

 21981 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 21982 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21983 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 21984 +      },

 21985 +    },

 21986 +    {

 21987 +      AVR32_OPC_LDCM_D_PU, 4, 0xeda01400, 0xfff01f00,

 21988 +      &avr32_syntax_table[AVR32_SYNTAX_LDCM_D_PU],

 21989 +      BFD_RELOC_UNUSED, 3, -1,

 21990 +      {

 21991 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 21992 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 21993 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 21994 +      },

 21995 +    },

 21996 +    {

 21997 +      AVR32_OPC_LDCM_W, 4, 0xeda00000, 0xfff01e00,

 21998 +      &avr32_syntax_table[AVR32_SYNTAX_LDCM_W],

 21999 +      BFD_RELOC_UNUSED, 4, -1,

 22000 +      {

 22001 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 22002 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22003 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22004 +	&avr32_ifield_table[AVR32_IFIELD_CM_HL],

 22005 +      },

 22006 +    },

 22007 +    {

 22008 +      AVR32_OPC_LDCM_W_PU, 4, 0xeda01000, 0xfff01e00,

 22009 +      &avr32_syntax_table[AVR32_SYNTAX_LDCM_W_PU],

 22010 +      BFD_RELOC_UNUSED, 4, -1,

 22011 +      {

 22012 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 22013 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22014 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22015 +	&avr32_ifield_table[AVR32_IFIELD_CM_HL],

 22016 +      },

 22017 +    },

 22018 +    {

 22019 +      AVR32_OPC_LDDPC, 2, 0x48000000, 0xf8000000,

 22020 +      &avr32_syntax_table[AVR32_SYNTAX_LDDPC],

 22021 +      BFD_RELOC_AVR32_9UW_PCREL, 2, 1,

 22022 +      {

 22023 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22024 +	&avr32_ifield_table[AVR32_IFIELD_K7C],

 22025 +      },

 22026 +    },

 22027 +    {

 22028 +      AVR32_OPC_LDDPC_EXT, 4, 0xfef00000, 0xfff00000,

 22029 +      &avr32_syntax_table[AVR32_SYNTAX_LDDPC_EXT],

 22030 +      BFD_RELOC_AVR32_16B_PCREL, 2, 1,

 22031 +      {

 22032 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22033 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 22034 +      },

 22035 +    },

 22036 +    {

 22037 +      AVR32_OPC_LDDSP, 2, 0x40000000, 0xf8000000,

 22038 +      &avr32_syntax_table[AVR32_SYNTAX_LDDSP],

 22039 +      BFD_RELOC_UNUSED, 2, -1,

 22040 +      {

 22041 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22042 +	&avr32_ifield_table[AVR32_IFIELD_K7C],

 22043 +      },

 22044 +    },

 22045 +    {

 22046 +      AVR32_OPC_LDINS_B, 4, 0xe1d04000, 0xe1f0c000,

 22047 +      &avr32_syntax_table[AVR32_SYNTAX_LDINS_B],

 22048 +      BFD_RELOC_UNUSED, 4, -1,

 22049 +      {

 22050 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22051 +	&avr32_ifield_table[AVR32_IFIELD_PART2_K12],

 22052 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22053 +	&avr32_ifield_table[AVR32_IFIELD_K12],

 22054 +      },

 22055 +    },

 22056 +    {

 22057 +      AVR32_OPC_LDINS_H, 4, 0xe1d00000, 0xe1f0e000,

 22058 +      &avr32_syntax_table[AVR32_SYNTAX_LDINS_H],

 22059 +      BFD_RELOC_UNUSED, 4, -1,

 22060 +      {

 22061 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22062 +	&avr32_ifield_table[AVR32_IFIELD_PART1_K12],

 22063 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22064 +	&avr32_ifield_table[AVR32_IFIELD_K12],

 22065 +      },

 22066 +    },

 22067 +    {

 22068 +      AVR32_OPC_LDM, 4, 0xe1c00000, 0xfdf00000,

 22069 +      &avr32_syntax_table[AVR32_SYNTAX_LDM],

 22070 +      BFD_RELOC_UNUSED, 3, -1,

 22071 +      {

 22072 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22073 +	&avr32_ifield_table[AVR32_IFIELD_W],

 22074 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 22075 +      },

 22076 +    },

 22077 +    {

 22078 +      AVR32_OPC_LDMTS, 4, 0xe5c00000, 0xfff00000,

 22079 +      &avr32_syntax_table[AVR32_SYNTAX_LDMTS],

 22080 +      BFD_RELOC_UNUSED, 2, -1,

 22081 +      {

 22082 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22083 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 22084 +      },

 22085 +    },

 22086 +    {

 22087 +      AVR32_OPC_LDMTS_PU, 4, 0xe7c00000, 0xfff00000,

 22088 +      &avr32_syntax_table[AVR32_SYNTAX_LDMTS_PU],

 22089 +      BFD_RELOC_UNUSED, 2, -1,

 22090 +      {

 22091 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22092 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 22093 +      },

 22094 +    },

 22095 +    {

 22096 +      AVR32_OPC_LDSWP_SH, 4, 0xe1d02000, 0xe1f0f000,

 22097 +      &avr32_syntax_table[AVR32_SYNTAX_LDSWP_SH],

 22098 +      BFD_RELOC_UNUSED, 3, -1,

 22099 +      {

 22100 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22101 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22102 +	&avr32_ifield_table[AVR32_IFIELD_K12],

 22103 +      },

 22104 +    },

 22105 +    {

 22106 +      AVR32_OPC_LDSWP_UH, 4, 0xe1d03000, 0xe1f0f000,

 22107 +      &avr32_syntax_table[AVR32_SYNTAX_LDSWP_UH],

 22108 +      BFD_RELOC_UNUSED, 3, -1,

 22109 +      {

 22110 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22111 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22112 +	&avr32_ifield_table[AVR32_IFIELD_K12],

 22113 +      },

 22114 +    },

 22115 +    {

 22116 +      AVR32_OPC_LDSWP_W, 4, 0xe1d08000, 0xe1f0f000,

 22117 +      &avr32_syntax_table[AVR32_SYNTAX_LDSWP_W],

 22118 +      BFD_RELOC_UNUSED, 3, -1,

 22119 +      {

 22120 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22121 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22122 +	&avr32_ifield_table[AVR32_IFIELD_K12],

 22123 +      },

 22124 +    },

 22125 +    {

 22126 +      AVR32_OPC_LSL1, 4, 0xe0000940, 0xe1f0fff0,

 22127 +      &avr32_syntax_table[AVR32_SYNTAX_LSL1],

 22128 +      BFD_RELOC_UNUSED, 3, -1,

 22129 +      {

 22130 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22131 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22132 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22133 +      },

 22134 +    },

 22135 +    {

 22136 +      AVR32_OPC_LSL3, 4, 0xe0001500, 0xe1f0ffe0,

 22137 +      &avr32_syntax_table[AVR32_SYNTAX_LSL3],

 22138 +      BFD_RELOC_UNUSED, 3, -1,

 22139 +      {

 22140 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22141 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22142 +	&avr32_ifield_table[AVR32_IFIELD_K5E],

 22143 +      },

 22144 +    },

 22145 +    {

 22146 +      AVR32_OPC_LSL2, 2, 0xa1600000, 0xe1e00000,

 22147 +      &avr32_syntax_table[AVR32_SYNTAX_LSL2],

 22148 +      BFD_RELOC_UNUSED, 2, -1,

 22149 +      {

 22150 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22151 +	&avr32_ifield_table[AVR32_IFIELD_BIT5C],

 22152 +      },

 22153 +    },

 22154 +    {

 22155 +      AVR32_OPC_LSR1, 4, 0xe0000a40, 0xe1f0fff0,

 22156 +      &avr32_syntax_table[AVR32_SYNTAX_LSR1],

 22157 +      BFD_RELOC_UNUSED, 3, -1,

 22158 +      {

 22159 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22160 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22161 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22162 +      },

 22163 +    },

 22164 +    {

 22165 +      AVR32_OPC_LSR3, 4, 0xe0001600, 0xe1f0ffe0,

 22166 +      &avr32_syntax_table[AVR32_SYNTAX_LSR3],

 22167 +      BFD_RELOC_UNUSED, 3, -1,

 22168 +      {

 22169 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22170 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22171 +	&avr32_ifield_table[AVR32_IFIELD_K5E],

 22172 +      },

 22173 +    },

 22174 +    {

 22175 +      AVR32_OPC_LSR2, 2, 0xa1800000, 0xe1e00000,

 22176 +      &avr32_syntax_table[AVR32_SYNTAX_LSR2],

 22177 +      BFD_RELOC_UNUSED, 2, -1,

 22178 +      {

 22179 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22180 +	&avr32_ifield_table[AVR32_IFIELD_BIT5C],

 22181 +      },

 22182 +    },

 22183 +    {

 22184 +      AVR32_OPC_MAC, 4, 0xe0000340, 0xe1f0fff0,

 22185 +      &avr32_syntax_table[AVR32_SYNTAX_MAC],

 22186 +      BFD_RELOC_UNUSED, 3, -1,

 22187 +      {

 22188 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22189 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22190 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22191 +      },

 22192 +    },

 22193 +    {

 22194 +      AVR32_OPC_MACHH_D, 4, 0xe0000580, 0xe1f0ffc1,

 22195 +      &avr32_syntax_table[AVR32_SYNTAX_MACHH_D],

 22196 +      BFD_RELOC_UNUSED, 5, -1,

 22197 +      {

 22198 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22199 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22200 +	&avr32_ifield_table[AVR32_IFIELD_X],

 22201 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22202 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22203 +      },

 22204 +    },

 22205 +    {

 22206 +      AVR32_OPC_MACHH_W, 4, 0xe0000480, 0xe1f0ffc0,

 22207 +      &avr32_syntax_table[AVR32_SYNTAX_MACHH_W],

 22208 +      BFD_RELOC_UNUSED, 5, -1,

 22209 +      {

 22210 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22211 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22212 +	&avr32_ifield_table[AVR32_IFIELD_X],

 22213 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22214 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22215 +      },

 22216 +    },

 22217 +    {

 22218 +      AVR32_OPC_MACS_D, 4, 0xe0000540, 0xe1f0fff1,

 22219 +      &avr32_syntax_table[AVR32_SYNTAX_MACS_D],

 22220 +      BFD_RELOC_UNUSED, 3, -1,

 22221 +      {

 22222 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22223 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22224 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22225 +      },

 22226 +    },

 22227 +    {

 22228 +      AVR32_OPC_MACSATHH_W, 4, 0xe0000680, 0xe1f0ffc0,

 22229 +      &avr32_syntax_table[AVR32_SYNTAX_MACSATHH_W],

 22230 +      BFD_RELOC_UNUSED, 5, -1,

 22231 +      {

 22232 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22233 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22234 +	&avr32_ifield_table[AVR32_IFIELD_X],

 22235 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22236 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22237 +      },

 22238 +    },

 22239 +    {

 22240 +      AVR32_OPC_MACUD, 4, 0xe0000740, 0xe1f0fff1,

 22241 +      &avr32_syntax_table[AVR32_SYNTAX_MACUD],

 22242 +      BFD_RELOC_UNUSED, 3, -1,

 22243 +      {

 22244 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22245 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22246 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22247 +      },

 22248 +    },

 22249 +    {

 22250 +      AVR32_OPC_MACWH_D, 4, 0xe0000c80, 0xe1f0ffe1,

 22251 +      &avr32_syntax_table[AVR32_SYNTAX_MACWH_D],

 22252 +      BFD_RELOC_UNUSED, 4, -1,

 22253 +      {

 22254 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22255 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22256 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22257 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22258 +      },

 22259 +    },

 22260 +    {

 22261 +      AVR32_OPC_MAX, 4, 0xe0000c40, 0xe1f0fff0,

 22262 +      &avr32_syntax_table[AVR32_SYNTAX_MAX],

 22263 +      BFD_RELOC_UNUSED, 3, -1,

 22264 +      {

 22265 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22266 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22267 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22268 +      },

 22269 +    },

 22270 +    {

 22271 +      AVR32_OPC_MCALL, 4, 0xf0100000, 0xfff00000,

 22272 +      &avr32_syntax_table[AVR32_SYNTAX_MCALL],

 22273 +      BFD_RELOC_AVR32_18W_PCREL, 2, 1,

 22274 +      {

 22275 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22276 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 22277 +      },

 22278 +    },

 22279 +    {

 22280 +      AVR32_OPC_MFDR, 4, 0xe5b00000, 0xfff0ff00,

 22281 +      &avr32_syntax_table[AVR32_SYNTAX_MFDR],

 22282 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22283 +      {

 22284 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22285 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22286 +      },

 22287 +    },

 22288 +    {

 22289 +      AVR32_OPC_MFSR, 4, 0xe1b00000, 0xfff0ff00,

 22290 +      &avr32_syntax_table[AVR32_SYNTAX_MFSR],

 22291 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22292 +      {

 22293 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22294 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22295 +      },

 22296 +    },

 22297 +    {

 22298 +      AVR32_OPC_MIN, 4, 0xe0000d40, 0xe1f0fff0,

 22299 +      &avr32_syntax_table[AVR32_SYNTAX_MIN],

 22300 +      BFD_RELOC_UNUSED, 3, -1,

 22301 +      {

 22302 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22303 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22304 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22305 +      },

 22306 +    },

 22307 +    {

 22308 +      AVR32_OPC_MOV3, 2, 0x00900000, 0xe1f00000,

 22309 +      &avr32_syntax_table[AVR32_SYNTAX_MOV3],

 22310 +      BFD_RELOC_NONE, 2, -1,

 22311 +      {

 22312 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22313 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22314 +      },

 22315 +    },

 22316 +    {

 22317 +      AVR32_OPC_MOV1, 2, 0x30000000, 0xf0000000,

 22318 +      &avr32_syntax_table[AVR32_SYNTAX_MOV1],

 22319 +      BFD_RELOC_AVR32_8S, 2, 1,

 22320 +      {

 22321 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22322 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 22323 +      },

 22324 +    },

 22325 +    {

 22326 +      AVR32_OPC_MOV2, 4, 0xe0600000, 0xe1e00000,

 22327 +      &avr32_syntax_table[AVR32_SYNTAX_MOV2],

 22328 +      BFD_RELOC_AVR32_21S, 2, 1,

 22329 +      {

 22330 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22331 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 22332 +      },

 22333 +    },

 22334 +    {

 22335 +      AVR32_OPC_MOVEQ1, 4, 0xe0001700, 0xe1f0ffff,

 22336 +      &avr32_syntax_table[AVR32_SYNTAX_MOVEQ1],

 22337 +      BFD_RELOC_UNUSED, 2, -1,

 22338 +      {

 22339 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22340 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22341 +      },

 22342 +    },

 22343 +    {

 22344 +      AVR32_OPC_MOVNE1, 4, 0xe0001710, 0xe1f0ffff,

 22345 +      &avr32_syntax_table[AVR32_SYNTAX_MOVNE1],

 22346 +      BFD_RELOC_UNUSED, 2, -1,

 22347 +      {

 22348 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22349 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22350 +      },

 22351 +    },

 22352 +    {

 22353 +      AVR32_OPC_MOVCC1, 4, 0xe0001720, 0xe1f0ffff,

 22354 +      &avr32_syntax_table[AVR32_SYNTAX_MOVHS1],

 22355 +      BFD_RELOC_UNUSED, 2, -1,

 22356 +      {

 22357 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22358 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22359 +      },

 22360 +    },

 22361 +    {

 22362 +      AVR32_OPC_MOVCS1, 4, 0xe0001730, 0xe1f0ffff,

 22363 +      &avr32_syntax_table[AVR32_SYNTAX_MOVLO1],

 22364 +      BFD_RELOC_UNUSED, 2, -1,

 22365 +      {

 22366 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22367 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22368 +      },

 22369 +    },

 22370 +    {

 22371 +      AVR32_OPC_MOVGE1, 4, 0xe0001740, 0xe1f0ffff,

 22372 +      &avr32_syntax_table[AVR32_SYNTAX_MOVGE1],

 22373 +      BFD_RELOC_UNUSED, 2, -1,

 22374 +      {

 22375 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22376 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22377 +      },

 22378 +    },

 22379 +    {

 22380 +      AVR32_OPC_MOVLT1, 4, 0xe0001750, 0xe1f0ffff,

 22381 +      &avr32_syntax_table[AVR32_SYNTAX_MOVLT1],

 22382 +      BFD_RELOC_UNUSED, 2, -1,

 22383 +      {

 22384 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22385 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22386 +      },

 22387 +    },

 22388 +    {

 22389 +      AVR32_OPC_MOVMI1, 4, 0xe0001760, 0xe1f0ffff,

 22390 +      &avr32_syntax_table[AVR32_SYNTAX_MOVMI1],

 22391 +      BFD_RELOC_UNUSED, 2, -1,

 22392 +      {

 22393 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22394 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22395 +      },

 22396 +    },

 22397 +    {

 22398 +      AVR32_OPC_MOVPL1, 4, 0xe0001770, 0xe1f0ffff,

 22399 +      &avr32_syntax_table[AVR32_SYNTAX_MOVPL1],

 22400 +      BFD_RELOC_UNUSED, 2, -1,

 22401 +      {

 22402 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22403 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22404 +      },

 22405 +    },

 22406 +    {

 22407 +      AVR32_OPC_MOVLS1, 4, 0xe0001780, 0xe1f0ffff,

 22408 +      &avr32_syntax_table[AVR32_SYNTAX_MOVLS1],

 22409 +      BFD_RELOC_UNUSED, 2, -1,

 22410 +      {

 22411 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22412 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22413 +      },

 22414 +    },

 22415 +    {

 22416 +      AVR32_OPC_MOVGT1, 4, 0xe0001790, 0xe1f0ffff,

 22417 +      &avr32_syntax_table[AVR32_SYNTAX_MOVGT1],

 22418 +      BFD_RELOC_UNUSED, 2, -1,

 22419 +      {

 22420 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22421 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22422 +      },

 22423 +    },

 22424 +    {

 22425 +      AVR32_OPC_MOVLE1, 4, 0xe00017a0, 0xe1f0ffff,

 22426 +      &avr32_syntax_table[AVR32_SYNTAX_MOVLE1],

 22427 +      BFD_RELOC_UNUSED, 2, -1,

 22428 +      {

 22429 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22430 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22431 +      },

 22432 +    },

 22433 +    {

 22434 +      AVR32_OPC_MOVHI1, 4, 0xe00017b0, 0xe1f0ffff,

 22435 +      &avr32_syntax_table[AVR32_SYNTAX_MOVHI1],

 22436 +      BFD_RELOC_UNUSED, 2, -1,

 22437 +      {

 22438 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22439 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22440 +      },

 22441 +    },

 22442 +    {

 22443 +      AVR32_OPC_MOVVS1, 4, 0xe00017c0, 0xe1f0ffff,

 22444 +      &avr32_syntax_table[AVR32_SYNTAX_MOVVS1],

 22445 +      BFD_RELOC_UNUSED, 2, -1,

 22446 +      {

 22447 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22448 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22449 +      },

 22450 +    },

 22451 +    {

 22452 +      AVR32_OPC_MOVVC1, 4, 0xe00017d0, 0xe1f0ffff,

 22453 +      &avr32_syntax_table[AVR32_SYNTAX_MOVVC1],

 22454 +      BFD_RELOC_UNUSED, 2, -1,

 22455 +      {

 22456 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22457 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22458 +      },

 22459 +    },

 22460 +    {

 22461 +      AVR32_OPC_MOVQS1, 4, 0xe00017e0, 0xe1f0ffff,

 22462 +      &avr32_syntax_table[AVR32_SYNTAX_MOVQS1],

 22463 +      BFD_RELOC_UNUSED, 2, -1,

 22464 +      {

 22465 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22466 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22467 +      },

 22468 +    },

 22469 +    {

 22470 +      AVR32_OPC_MOVAL1, 4, 0xe00017f0, 0xe1f0ffff,

 22471 +      &avr32_syntax_table[AVR32_SYNTAX_MOVAL1],

 22472 +      BFD_RELOC_UNUSED, 2, -1,

 22473 +      {

 22474 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22475 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22476 +      },

 22477 +    },

 22478 +    {

 22479 +      AVR32_OPC_MOVEQ2, 4, 0xf9b00000, 0xfff0ff00,

 22480 +      &avr32_syntax_table[AVR32_SYNTAX_MOVEQ2],

 22481 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22482 +      {

 22483 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22484 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22485 +      },

 22486 +    },

 22487 +    {

 22488 +      AVR32_OPC_MOVNE2, 4, 0xf9b00100, 0xfff0ff00,

 22489 +      &avr32_syntax_table[AVR32_SYNTAX_MOVNE2],

 22490 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22491 +      {

 22492 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22493 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22494 +      },

 22495 +    },

 22496 +    {

 22497 +      AVR32_OPC_MOVCC2, 4, 0xf9b00200, 0xfff0ff00,

 22498 +      &avr32_syntax_table[AVR32_SYNTAX_MOVHS2],

 22499 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22500 +      {

 22501 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22502 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22503 +      },

 22504 +    },

 22505 +    {

 22506 +      AVR32_OPC_MOVCS2, 4, 0xf9b00300, 0xfff0ff00,

 22507 +      &avr32_syntax_table[AVR32_SYNTAX_MOVLO2],

 22508 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22509 +      {

 22510 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22511 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22512 +      },

 22513 +    },

 22514 +    {

 22515 +      AVR32_OPC_MOVGE2, 4, 0xf9b00400, 0xfff0ff00,

 22516 +      &avr32_syntax_table[AVR32_SYNTAX_MOVGE2],

 22517 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22518 +      {

 22519 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22520 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22521 +      },

 22522 +    },

 22523 +    {

 22524 +      AVR32_OPC_MOVLT2, 4, 0xf9b00500, 0xfff0ff00,

 22525 +      &avr32_syntax_table[AVR32_SYNTAX_MOVLT2],

 22526 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22527 +      {

 22528 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22529 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22530 +      },

 22531 +    },

 22532 +    {

 22533 +      AVR32_OPC_MOVMI2, 4, 0xf9b00600, 0xfff0ff00,

 22534 +      &avr32_syntax_table[AVR32_SYNTAX_MOVMI2],

 22535 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22536 +      {

 22537 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22538 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22539 +      },

 22540 +    },

 22541 +    {

 22542 +      AVR32_OPC_MOVPL2, 4, 0xf9b00700, 0xfff0ff00,

 22543 +      &avr32_syntax_table[AVR32_SYNTAX_MOVPL2],

 22544 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22545 +      {

 22546 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22547 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22548 +      },

 22549 +    },

 22550 +    {

 22551 +      AVR32_OPC_MOVLS2, 4, 0xf9b00800, 0xfff0ff00,

 22552 +      &avr32_syntax_table[AVR32_SYNTAX_MOVLS2],

 22553 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22554 +      {

 22555 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22556 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22557 +      },

 22558 +    },

 22559 +    {

 22560 +      AVR32_OPC_MOVGT2, 4, 0xf9b00900, 0xfff0ff00,

 22561 +      &avr32_syntax_table[AVR32_SYNTAX_MOVGT2],

 22562 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22563 +      {

 22564 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22565 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22566 +      },

 22567 +    },

 22568 +    {

 22569 +      AVR32_OPC_MOVLE2, 4, 0xf9b00a00, 0xfff0ff00,

 22570 +      &avr32_syntax_table[AVR32_SYNTAX_MOVLE2],

 22571 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22572 +      {

 22573 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22574 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22575 +      },

 22576 +    },

 22577 +    {

 22578 +      AVR32_OPC_MOVHI2, 4, 0xf9b00b00, 0xfff0ff00,

 22579 +      &avr32_syntax_table[AVR32_SYNTAX_MOVHI2],

 22580 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22581 +      {

 22582 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22583 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22584 +      },

 22585 +    },

 22586 +    {

 22587 +      AVR32_OPC_MOVVS2, 4, 0xf9b00c00, 0xfff0ff00,

 22588 +      &avr32_syntax_table[AVR32_SYNTAX_MOVVS2],

 22589 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22590 +      {

 22591 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22592 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22593 +      },

 22594 +    },

 22595 +    {

 22596 +      AVR32_OPC_MOVVC2, 4, 0xf9b00d00, 0xfff0ff00,

 22597 +      &avr32_syntax_table[AVR32_SYNTAX_MOVVC2],

 22598 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22599 +      {

 22600 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22601 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22602 +      },

 22603 +    },

 22604 +    {

 22605 +      AVR32_OPC_MOVQS2, 4, 0xf9b00e00, 0xfff0ff00,

 22606 +      &avr32_syntax_table[AVR32_SYNTAX_MOVQS2],

 22607 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22608 +      {

 22609 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22610 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22611 +      },

 22612 +    },

 22613 +    {

 22614 +      AVR32_OPC_MOVAL2, 4, 0xf9b00f00, 0xfff0ff00,

 22615 +      &avr32_syntax_table[AVR32_SYNTAX_MOVAL2],

 22616 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 22617 +      {

 22618 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22619 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22620 +      },

 22621 +    },

 22622 +    {

 22623 +      AVR32_OPC_MTDR, 4, 0xe7b00000, 0xfff0ff00,

 22624 +      &avr32_syntax_table[AVR32_SYNTAX_MTDR],

 22625 +      BFD_RELOC_AVR32_8S_EXT, 2, 0,

 22626 +      {

 22627 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22628 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22629 +      },

 22630 +    },

 22631 +    {

 22632 +      AVR32_OPC_MTSR, 4, 0xe3b00000, 0xfff0ff00,

 22633 +      &avr32_syntax_table[AVR32_SYNTAX_MTSR],

 22634 +      BFD_RELOC_AVR32_8S_EXT, 2, 0,

 22635 +      {

 22636 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22637 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22638 +      },

 22639 +    },

 22640 +    {

 22641 +      AVR32_OPC_MUL1, 2, 0xa1300000, 0xe1f00000,

 22642 +      &avr32_syntax_table[AVR32_SYNTAX_MUL1],

 22643 +      BFD_RELOC_UNUSED, 2, -1,

 22644 +      {

 22645 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22646 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22647 +      },

 22648 +    },

 22649 +    {

 22650 +      AVR32_OPC_MUL2, 4, 0xe0000240, 0xe1f0fff0,

 22651 +      &avr32_syntax_table[AVR32_SYNTAX_MUL2],

 22652 +      BFD_RELOC_UNUSED, 3, -1,

 22653 +      {

 22654 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22655 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22656 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22657 +      },

 22658 +    },

 22659 +    {

 22660 +      AVR32_OPC_MUL3, 4, 0xe0001000, 0xe1f0ff00,

 22661 +      &avr32_syntax_table[AVR32_SYNTAX_MUL3],

 22662 +      BFD_RELOC_AVR32_8S_EXT, 3, 2,

 22663 +      {

 22664 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22665 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22666 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 22667 +      },

 22668 +    },

 22669 +    {

 22670 +      AVR32_OPC_MULHH_W, 4, 0xe0000780, 0xe1f0ffc0,

 22671 +      &avr32_syntax_table[AVR32_SYNTAX_MULHH_W],

 22672 +      BFD_RELOC_UNUSED, 5, -1,

 22673 +      {

 22674 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22675 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22676 +	&avr32_ifield_table[AVR32_IFIELD_X],

 22677 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22678 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22679 +      },

 22680 +    },

 22681 +    {

 22682 +      AVR32_OPC_MULNHH_W, 4, 0xe0000180, 0xe1f0ffc0,

 22683 +      &avr32_syntax_table[AVR32_SYNTAX_MULNHH_W],

 22684 +      BFD_RELOC_UNUSED, 5, -1,

 22685 +      {

 22686 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22687 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22688 +	&avr32_ifield_table[AVR32_IFIELD_X],

 22689 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22690 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22691 +      },

 22692 +    },

 22693 +    {

 22694 +      AVR32_OPC_MULNWH_D, 4, 0xe0000280, 0xe1f0ffe1,

 22695 +      &avr32_syntax_table[AVR32_SYNTAX_MULNWH_D],

 22696 +      BFD_RELOC_UNUSED, 4, -1,

 22697 +      {

 22698 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22699 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22700 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22701 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22702 +      },

 22703 +    },

 22704 +    {

 22705 +      AVR32_OPC_MULSD, 4, 0xe0000440, 0xe1f0fff0,

 22706 +      &avr32_syntax_table[AVR32_SYNTAX_MULSD],

 22707 +      BFD_RELOC_UNUSED, 3, -1,

 22708 +      {

 22709 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22710 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22711 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22712 +      },

 22713 +    },

 22714 +    {

 22715 +      AVR32_OPC_MULSATHH_H, 4, 0xe0000880, 0xe1f0ffc0,

 22716 +      &avr32_syntax_table[AVR32_SYNTAX_MULSATHH_H],

 22717 +      BFD_RELOC_UNUSED, 5, -1,

 22718 +      {

 22719 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22720 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22721 +	&avr32_ifield_table[AVR32_IFIELD_X],

 22722 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22723 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22724 +      },

 22725 +    },

 22726 +    {

 22727 +      AVR32_OPC_MULSATHH_W, 4, 0xe0000980, 0xe1f0ffc0,

 22728 +      &avr32_syntax_table[AVR32_SYNTAX_MULSATHH_W],

 22729 +      BFD_RELOC_UNUSED, 5, -1,

 22730 +      {

 22731 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22732 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22733 +	&avr32_ifield_table[AVR32_IFIELD_X],

 22734 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22735 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22736 +      },

 22737 +    },

 22738 +    {

 22739 +      AVR32_OPC_MULSATRNDHH_H, 4, 0xe0000a80, 0xe1f0ffc0,

 22740 +      &avr32_syntax_table[AVR32_SYNTAX_MULSATRNDHH_H],

 22741 +      BFD_RELOC_UNUSED, 5, -1,

 22742 +      {

 22743 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22744 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22745 +	&avr32_ifield_table[AVR32_IFIELD_X],

 22746 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22747 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22748 +      },

 22749 +    },

 22750 +    {

 22751 +      AVR32_OPC_MULSATRNDWH_W, 4, 0xe0000b80, 0xe1f0ffe0,

 22752 +      &avr32_syntax_table[AVR32_SYNTAX_MULSATRNDWH_W],

 22753 +      BFD_RELOC_UNUSED, 4, -1,

 22754 +      {

 22755 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22756 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22757 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22758 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22759 +      },

 22760 +    },

 22761 +    {

 22762 +      AVR32_OPC_MULSATWH_W, 4, 0xe0000e80, 0xe1f0ffe0,

 22763 +      &avr32_syntax_table[AVR32_SYNTAX_MULSATWH_W],

 22764 +      BFD_RELOC_UNUSED, 4, -1,

 22765 +      {

 22766 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22767 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22768 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22769 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22770 +      },

 22771 +    },

 22772 +    {

 22773 +      AVR32_OPC_MULU_D, 4, 0xe0000640, 0xe1f0fff1,

 22774 +      &avr32_syntax_table[AVR32_SYNTAX_MULU_D],

 22775 +      BFD_RELOC_UNUSED, 3, -1,

 22776 +      {

 22777 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22778 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22779 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22780 +      },

 22781 +    },

 22782 +    {

 22783 +      AVR32_OPC_MULWH_D, 4, 0xe0000d80, 0xe1f0ffe1,

 22784 +      &avr32_syntax_table[AVR32_SYNTAX_MULWH_D],

 22785 +      BFD_RELOC_UNUSED, 4, -1,

 22786 +      {

 22787 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22788 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22789 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22790 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 22791 +      },

 22792 +    },

 22793 +    {

 22794 +      AVR32_OPC_MUSFR, 2, 0x5d300000, 0xfff00000,

 22795 +      &avr32_syntax_table[AVR32_SYNTAX_MUSFR],

 22796 +      BFD_RELOC_UNUSED, 1, -1,

 22797 +      {

 22798 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22799 +      }

 22800 +    },

 22801 +    {

 22802 +      AVR32_OPC_MUSTR, 2, 0x5d200000, 0xfff00000,

 22803 +      &avr32_syntax_table[AVR32_SYNTAX_MUSTR],

 22804 +      BFD_RELOC_UNUSED, 1, -1,

 22805 +      {

 22806 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22807 +      }

 22808 +    },

 22809 +    {

 22810 +      AVR32_OPC_MVCR_D, 4, 0xefa00010, 0xfff111ff,

 22811 +      &avr32_syntax_table[AVR32_SYNTAX_MVCR_D],

 22812 +      BFD_RELOC_UNUSED, 3, -1,

 22813 +      {

 22814 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 22815 +	&avr32_ifield_table[AVR32_IFIELD_RY_DW],

 22816 +	&avr32_ifield_table[AVR32_IFIELD_CRD_DW],

 22817 +      },

 22818 +    },

 22819 +    {

 22820 +      AVR32_OPC_MVCR_W, 4, 0xefa00000, 0xfff010ff,

 22821 +      &avr32_syntax_table[AVR32_SYNTAX_MVCR_W],

 22822 +      BFD_RELOC_UNUSED, 3, -1,

 22823 +      {

 22824 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 22825 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22826 +	&avr32_ifield_table[AVR32_IFIELD_CRD_RI],

 22827 +      },

 22828 +    },

 22829 +    {

 22830 +      AVR32_OPC_MVRC_D, 4, 0xefa00030, 0xfff111ff,

 22831 +      &avr32_syntax_table[AVR32_SYNTAX_MVRC_D],

 22832 +      BFD_RELOC_UNUSED, 3, -1,

 22833 +      {

 22834 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 22835 +	&avr32_ifield_table[AVR32_IFIELD_CRD_DW],

 22836 +	&avr32_ifield_table[AVR32_IFIELD_RY_DW],

 22837 +      },

 22838 +    },

 22839 +    {

 22840 +      AVR32_OPC_MVRC_W, 4, 0xefa00020, 0xfff010ff,

 22841 +      &avr32_syntax_table[AVR32_SYNTAX_MVRC_W],

 22842 +      BFD_RELOC_UNUSED, 3, -1,

 22843 +      {

 22844 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 22845 +	&avr32_ifield_table[AVR32_IFIELD_CRD_RI],

 22846 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22847 +      },

 22848 +    },

 22849 +    {

 22850 +      AVR32_OPC_NEG, 2, 0x5c300000, 0xfff00000,

 22851 +      &avr32_syntax_table[AVR32_SYNTAX_NEG],

 22852 +      BFD_RELOC_UNUSED, 1, -1,

 22853 +      {

 22854 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22855 +      }

 22856 +    },

 22857 +    {

 22858 +      AVR32_OPC_NOP, 2, 0xd7030000, 0xffff0000,

 22859 +      &avr32_syntax_table[AVR32_SYNTAX_NOP],

 22860 +      BFD_RELOC_UNUSED, 0, -1, { NULL },

 22861 +    },

 22862 +    {

 22863 +      AVR32_OPC_OR1, 2, 0x00400000, 0xe1f00000,

 22864 +      &avr32_syntax_table[AVR32_SYNTAX_OR1],

 22865 +      BFD_RELOC_UNUSED, 2, -1,

 22866 +      {

 22867 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22868 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22869 +      },

 22870 +    },

 22871 +    {

 22872 +      AVR32_OPC_OR2, 4, 0xe1e01000, 0xe1f0fe00,

 22873 +      &avr32_syntax_table[AVR32_SYNTAX_OR2],

 22874 +      BFD_RELOC_UNUSED, 4, -1,

 22875 +      {

 22876 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22877 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22878 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22879 +	&avr32_ifield_table[AVR32_IFIELD_K5E2],

 22880 +      },

 22881 +    },

 22882 +    {

 22883 +      AVR32_OPC_OR3, 4, 0xe1e01200, 0xe1f0fe00,

 22884 +      &avr32_syntax_table[AVR32_SYNTAX_OR3],

 22885 +      BFD_RELOC_UNUSED, 4, -1,

 22886 +      {

 22887 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22888 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22889 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22890 +	&avr32_ifield_table[AVR32_IFIELD_K5E2],

 22891 +      },

 22892 +    },

 22893 +    {

 22894 +      AVR32_OPC_ORH, 4, 0xea100000, 0xfff00000,

 22895 +      &avr32_syntax_table[AVR32_SYNTAX_ORH],

 22896 +      BFD_RELOC_AVR32_16U, 2, 1,

 22897 +      {

 22898 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22899 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 22900 +      },

 22901 +    },

 22902 +    {

 22903 +      AVR32_OPC_ORL, 4, 0xe8100000, 0xfff00000,

 22904 +      &avr32_syntax_table[AVR32_SYNTAX_ORL],

 22905 +      BFD_RELOC_AVR32_16U, 2, 1,

 22906 +      {

 22907 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22908 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 22909 +      },

 22910 +    },

 22911 +    {

 22912 +      AVR32_OPC_PABS_SB, 4, 0xe00023e0, 0xfff0fff0,

 22913 +      &avr32_syntax_table[AVR32_SYNTAX_PABS_SB],

 22914 +      BFD_RELOC_UNUSED, 2, -1,

 22915 +      {

 22916 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22917 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22918 +      },

 22919 +    },

 22920 +    {

 22921 +      AVR32_OPC_PABS_SH, 4, 0xe00023f0, 0xfff0fff0,

 22922 +      &avr32_syntax_table[AVR32_SYNTAX_PABS_SH],

 22923 +      BFD_RELOC_UNUSED, 2, -1,

 22924 +      {

 22925 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22926 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22927 +      },

 22928 +    },

 22929 +    {

 22930 +      AVR32_OPC_PACKSH_SB, 4, 0xe00024d0, 0xe1f0fff0,

 22931 +      &avr32_syntax_table[AVR32_SYNTAX_PACKSH_SB],

 22932 +      BFD_RELOC_UNUSED, 3, -1,

 22933 +      {

 22934 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22935 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22936 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22937 +      },

 22938 +    },

 22939 +    {

 22940 +      AVR32_OPC_PACKSH_UB, 4, 0xe00024c0, 0xe1f0fff0,

 22941 +      &avr32_syntax_table[AVR32_SYNTAX_PACKSH_UB],

 22942 +      BFD_RELOC_UNUSED, 3, -1,

 22943 +      {

 22944 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22945 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22946 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22947 +      },

 22948 +    },

 22949 +    {

 22950 +      AVR32_OPC_PACKW_SH, 4, 0xe0002470, 0xe1f0fff0,

 22951 +      &avr32_syntax_table[AVR32_SYNTAX_PACKW_SH],

 22952 +      BFD_RELOC_UNUSED, 3, -1,

 22953 +      {

 22954 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22955 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22956 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22957 +      },

 22958 +    },

 22959 +    {

 22960 +      AVR32_OPC_PADD_B, 4, 0xe0002300, 0xe1f0fff0,

 22961 +      &avr32_syntax_table[AVR32_SYNTAX_PADD_B],

 22962 +      BFD_RELOC_UNUSED, 3, -1,

 22963 +      {

 22964 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22965 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22966 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22967 +      },

 22968 +    },

 22969 +    {

 22970 +      AVR32_OPC_PADD_H, 4, 0xe0002000, 0xe1f0fff0,

 22971 +      &avr32_syntax_table[AVR32_SYNTAX_PADD_H],

 22972 +      BFD_RELOC_UNUSED, 3, -1,

 22973 +      {

 22974 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22975 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22976 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22977 +      },

 22978 +    },

 22979 +    {

 22980 +      AVR32_OPC_PADDH_SH, 4, 0xe00020c0, 0xe1f0fff0,

 22981 +      &avr32_syntax_table[AVR32_SYNTAX_PADDH_SH],

 22982 +      BFD_RELOC_UNUSED, 3, -1,

 22983 +      {

 22984 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22985 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22986 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22987 +      },

 22988 +    },

 22989 +    {

 22990 +      AVR32_OPC_PADDH_UB, 4, 0xe0002360, 0xe1f0fff0,

 22991 +      &avr32_syntax_table[AVR32_SYNTAX_PADDH_UB],

 22992 +      BFD_RELOC_UNUSED, 3, -1,

 22993 +      {

 22994 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 22995 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 22996 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 22997 +      },

 22998 +    },

 22999 +    {

 23000 +      AVR32_OPC_PADDS_SB, 4, 0xe0002320, 0xe1f0fff0,

 23001 +      &avr32_syntax_table[AVR32_SYNTAX_PADDS_SB],

 23002 +      BFD_RELOC_UNUSED, 3, -1,

 23003 +      {

 23004 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23005 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23006 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23007 +      },

 23008 +    },

 23009 +    {

 23010 +      AVR32_OPC_PADDS_SH, 4, 0xe0002040, 0xe1f0fff0,

 23011 +      &avr32_syntax_table[AVR32_SYNTAX_PADDS_SH],

 23012 +      BFD_RELOC_UNUSED, 3, -1,

 23013 +      {

 23014 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23015 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23016 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23017 +      },

 23018 +    },

 23019 +    {

 23020 +      AVR32_OPC_PADDS_UB, 4, 0xe0002340, 0xe1f0fff0,

 23021 +      &avr32_syntax_table[AVR32_SYNTAX_PADDS_UB],

 23022 +      BFD_RELOC_UNUSED, 3, -1,

 23023 +      {

 23024 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23025 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23026 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23027 +      },

 23028 +    },

 23029 +    {

 23030 +      AVR32_OPC_PADDS_UH, 4, 0xe0002080, 0xe1f0fff0,

 23031 +      &avr32_syntax_table[AVR32_SYNTAX_PADDS_UH],

 23032 +      BFD_RELOC_UNUSED, 3, -1,

 23033 +      {

 23034 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23035 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23036 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23037 +      },

 23038 +    },

 23039 +    {

 23040 +      AVR32_OPC_PADDSUB_H, 4, 0xe0002100, 0xe1f0ffc0,

 23041 +      &avr32_syntax_table[AVR32_SYNTAX_PADDSUB_H],

 23042 +      BFD_RELOC_UNUSED, 5, -1,

 23043 +      {

 23044 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23045 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23046 +	&avr32_ifield_table[AVR32_IFIELD_X],

 23047 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23048 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 23049 +      },

 23050 +    },

 23051 +    {

 23052 +      AVR32_OPC_PADDSUBH_SH, 4, 0xe0002280, 0xe1f0ffc0,

 23053 +      &avr32_syntax_table[AVR32_SYNTAX_PADDSUBH_SH],

 23054 +      BFD_RELOC_UNUSED, 5, -1,

 23055 +      {

 23056 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23057 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23058 +	&avr32_ifield_table[AVR32_IFIELD_X],

 23059 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23060 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 23061 +      },

 23062 +    },

 23063 +    {

 23064 +      AVR32_OPC_PADDSUBS_SH, 4, 0xe0002180, 0xe1f0ffc0,

 23065 +      &avr32_syntax_table[AVR32_SYNTAX_PADDSUBS_SH],

 23066 +      BFD_RELOC_UNUSED, 5, -1,

 23067 +      {

 23068 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23069 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23070 +	&avr32_ifield_table[AVR32_IFIELD_X],

 23071 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23072 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 23073 +      },

 23074 +    },

 23075 +    {

 23076 +      AVR32_OPC_PADDSUBS_UH, 4, 0xe0002200, 0xe1f0ffc0,

 23077 +      &avr32_syntax_table[AVR32_SYNTAX_PADDSUBS_UH],

 23078 +      BFD_RELOC_UNUSED, 5, -1,

 23079 +      {

 23080 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23081 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23082 +	&avr32_ifield_table[AVR32_IFIELD_X],

 23083 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23084 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 23085 +      },

 23086 +    },

 23087 +    {

 23088 +      AVR32_OPC_PADDX_H, 4, 0xe0002020, 0xe1f0fff0,

 23089 +      &avr32_syntax_table[AVR32_SYNTAX_PADDX_H],

 23090 +      BFD_RELOC_UNUSED, 3, -1,

 23091 +      {

 23092 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23093 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23094 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23095 +      },

 23096 +    },

 23097 +    {

 23098 +      AVR32_OPC_PADDXH_SH, 4, 0xe00020e0, 0xe1f0fff0,

 23099 +      &avr32_syntax_table[AVR32_SYNTAX_PADDXH_SH],

 23100 +      BFD_RELOC_UNUSED, 3, -1,

 23101 +      {

 23102 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23103 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23104 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23105 +      },

 23106 +    },

 23107 +    {

 23108 +      AVR32_OPC_PADDXS_SH, 4, 0xe0002060, 0xe1f0fff0,

 23109 +      &avr32_syntax_table[AVR32_SYNTAX_PADDXS_SH],

 23110 +      BFD_RELOC_UNUSED, 3, -1,

 23111 +      {

 23112 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23113 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23114 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23115 +      },

 23116 +    },

 23117 +    {

 23118 +      AVR32_OPC_PADDXS_UH, 4, 0xe00020a0, 0xe1f0fff0,

 23119 +      &avr32_syntax_table[AVR32_SYNTAX_PADDXS_UH],

 23120 +      BFD_RELOC_UNUSED, 3, -1,

 23121 +      {

 23122 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23123 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23124 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23125 +      },

 23126 +    },

 23127 +    {

 23128 +      AVR32_OPC_PASR_B, 4, 0xe0002410, 0xe1f8fff0,

 23129 +      &avr32_syntax_table[AVR32_SYNTAX_PASR_B],

 23130 +      BFD_RELOC_UNUSED, 3, -1,

 23131 +      {

 23132 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23133 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23134 +	&avr32_ifield_table[AVR32_IFIELD_COND3],

 23135 +      },

 23136 +    },

 23137 +    {

 23138 +      AVR32_OPC_PASR_H, 4, 0xe0002440, 0xe1f0fff0,

 23139 +      &avr32_syntax_table[AVR32_SYNTAX_PASR_H],

 23140 +      BFD_RELOC_UNUSED, 3, -1,

 23141 +      {

 23142 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23143 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23144 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23145 +      },

 23146 +    },

 23147 +    {

 23148 +      AVR32_OPC_PAVG_SH, 4, 0xe00023d0, 0xe1f0fff0,

 23149 +      &avr32_syntax_table[AVR32_SYNTAX_PAVG_SH],

 23150 +      BFD_RELOC_UNUSED, 3, -1,

 23151 +      {

 23152 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23153 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23154 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23155 +      },

 23156 +    },

 23157 +    {

 23158 +      AVR32_OPC_PAVG_UB, 4, 0xe00023c0, 0xe1f0fff0,

 23159 +      &avr32_syntax_table[AVR32_SYNTAX_PAVG_UB],

 23160 +      BFD_RELOC_UNUSED, 3, -1,

 23161 +      {

 23162 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23163 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23164 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23165 +      },

 23166 +    },

 23167 +    {

 23168 +      AVR32_OPC_PLSL_B, 4, 0xe0002420, 0xe1f8fff0,

 23169 +      &avr32_syntax_table[AVR32_SYNTAX_PLSL_B],

 23170 +      BFD_RELOC_UNUSED, 3, -1,

 23171 +      {

 23172 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23173 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23174 +	&avr32_ifield_table[AVR32_IFIELD_COND3],

 23175 +      },

 23176 +    },

 23177 +    {

 23178 +      AVR32_OPC_PLSL_H, 4, 0xe0002450, 0xe1f0fff0,

 23179 +      &avr32_syntax_table[AVR32_SYNTAX_PLSL_H],

 23180 +      BFD_RELOC_UNUSED, 3, -1,

 23181 +      {

 23182 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23183 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23184 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23185 +      },

 23186 +    },

 23187 +    {

 23188 +      AVR32_OPC_PLSR_B, 4, 0xe0002430, 0xe1f8fff0,

 23189 +      &avr32_syntax_table[AVR32_SYNTAX_PLSR_B],

 23190 +      BFD_RELOC_UNUSED, 3, -1,

 23191 +      {

 23192 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23193 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23194 +	&avr32_ifield_table[AVR32_IFIELD_COND3],

 23195 +      },

 23196 +    },

 23197 +    {

 23198 +      AVR32_OPC_PLSR_H, 4, 0xe0002460, 0xe1f0fff0,

 23199 +      &avr32_syntax_table[AVR32_SYNTAX_PLSR_H],

 23200 +      BFD_RELOC_UNUSED, 3, -1,

 23201 +      {

 23202 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23203 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23204 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23205 +      },

 23206 +    },

 23207 +    {

 23208 +      AVR32_OPC_PMAX_SH, 4, 0xe0002390, 0xe1f0fff0,

 23209 +      &avr32_syntax_table[AVR32_SYNTAX_PMAX_SH],

 23210 +      BFD_RELOC_UNUSED, 3, -1,

 23211 +      {

 23212 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23213 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23214 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23215 +      },

 23216 +    },

 23217 +    {

 23218 +      AVR32_OPC_PMAX_UB, 4, 0xe0002380, 0xe1f0fff0,

 23219 +      &avr32_syntax_table[AVR32_SYNTAX_PMAX_UB],

 23220 +      BFD_RELOC_UNUSED, 3, -1,

 23221 +      {

 23222 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23223 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23224 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23225 +      },

 23226 +    },

 23227 +    {

 23228 +      AVR32_OPC_PMIN_SH, 4, 0xe00023b0, 0xe1f0fff0,

 23229 +      &avr32_syntax_table[AVR32_SYNTAX_PMIN_SH],

 23230 +      BFD_RELOC_UNUSED, 3, -1,

 23231 +      {

 23232 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23233 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23234 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23235 +      },

 23236 +    },

 23237 +    {

 23238 +      AVR32_OPC_PMIN_UB, 4, 0xe00023a0, 0xe1f0fff0,

 23239 +      &avr32_syntax_table[AVR32_SYNTAX_PMIN_UB],

 23240 +      BFD_RELOC_UNUSED, 3, -1,

 23241 +      {

 23242 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23243 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23244 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23245 +      },

 23246 +    },

 23247 +    {

 23248 +      AVR32_OPC_POPJC, 2, 0xd7130000, 0xffff0000,

 23249 +      &avr32_syntax_table[AVR32_SYNTAX_POPJC],

 23250 +      BFD_RELOC_UNUSED, 0, -1, { NULL },

 23251 +    },

 23252 +    {

 23253 +      AVR32_OPC_POPM, 2, 0xd0020000, 0xf0070000,

 23254 +      &avr32_syntax_table[AVR32_SYNTAX_POPM],

 23255 +      BFD_RELOC_UNUSED, 1, -1,

 23256 +      {

 23257 +	&avr32_ifield_table[AVR32_IFIELD_POPM],

 23258 +      },

 23259 +    },

 23260 +    {

 23261 +      AVR32_OPC_POPM_E, 4, 0xe3cd0000, 0xffff0000,

 23262 +      &avr32_syntax_table[AVR32_SYNTAX_POPM_E],

 23263 +      BFD_RELOC_UNUSED, 1, -1,

 23264 +      {

 23265 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 23266 +      },

 23267 +    },

 23268 +    {

 23269 +      AVR32_OPC_PREF, 4, 0xf2100000, 0xfff00000,

 23270 +      &avr32_syntax_table[AVR32_SYNTAX_PREF],

 23271 +      BFD_RELOC_AVR32_16S, 2, -1,

 23272 +      {

 23273 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23274 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 23275 +      },

 23276 +    },

 23277 +    {

 23278 +      AVR32_OPC_PSAD, 4, 0xe0002400, 0xe1f0fff0,

 23279 +      &avr32_syntax_table[AVR32_SYNTAX_PSAD],

 23280 +      BFD_RELOC_UNUSED, 3, -1,

 23281 +      {

 23282 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23283 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23284 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23285 +      },

 23286 +    },

 23287 +    {

 23288 +      AVR32_OPC_PSUB_B, 4, 0xe0002310, 0xe1f0fff0,

 23289 +      &avr32_syntax_table[AVR32_SYNTAX_PSUB_B],

 23290 +      BFD_RELOC_UNUSED, 3, -1,

 23291 +      {

 23292 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23293 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23294 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23295 +      },

 23296 +    },

 23297 +    {

 23298 +      AVR32_OPC_PSUB_H, 4, 0xe0002010, 0xe1f0fff0,

 23299 +      &avr32_syntax_table[AVR32_SYNTAX_PSUB_H],

 23300 +      BFD_RELOC_UNUSED, 3, -1,

 23301 +      {

 23302 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23303 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23304 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23305 +      },

 23306 +    },

 23307 +    {

 23308 +      AVR32_OPC_PSUBADD_H, 4, 0xe0002140, 0xe1f0ffc0,

 23309 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBADD_H],

 23310 +      BFD_RELOC_UNUSED, 5, -1,

 23311 +      {

 23312 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23313 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23314 +	&avr32_ifield_table[AVR32_IFIELD_X],

 23315 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23316 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 23317 +      },

 23318 +    },

 23319 +    {

 23320 +      AVR32_OPC_PSUBADDH_SH, 4, 0xe00022c0, 0xe1f0ffc0,

 23321 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBADDH_SH],

 23322 +      BFD_RELOC_UNUSED, 5, -1,

 23323 +      {

 23324 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23325 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23326 +	&avr32_ifield_table[AVR32_IFIELD_X],

 23327 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23328 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 23329 +      },

 23330 +    },

 23331 +    {

 23332 +      AVR32_OPC_PSUBADDS_SH, 4, 0xe00021c0, 0xe1f0ffc0,

 23333 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBADDS_SH],

 23334 +      BFD_RELOC_UNUSED, 5, -1,

 23335 +      {

 23336 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23337 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23338 +	&avr32_ifield_table[AVR32_IFIELD_X],

 23339 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23340 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 23341 +      },

 23342 +    },

 23343 +    {

 23344 +      AVR32_OPC_PSUBADDS_UH, 4, 0xe0002240, 0xe1f0ffc0,

 23345 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBADDS_UH],

 23346 +      BFD_RELOC_UNUSED, 5, -1,

 23347 +      {

 23348 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23349 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23350 +	&avr32_ifield_table[AVR32_IFIELD_X],

 23351 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23352 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 23353 +      },

 23354 +    },

 23355 +    {

 23356 +      AVR32_OPC_PSUBH_SH, 4, 0xe00020d0, 0xe1f0fff0,

 23357 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBH_SH],

 23358 +      BFD_RELOC_UNUSED, 3, -1,

 23359 +      {

 23360 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23361 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23362 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23363 +      },

 23364 +    },

 23365 +    {

 23366 +      AVR32_OPC_PSUBH_UB, 4, 0xe0002370, 0xe1f0fff0,

 23367 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBH_UB],

 23368 +      BFD_RELOC_UNUSED, 3, -1,

 23369 +      {

 23370 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23371 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23372 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23373 +      },

 23374 +    },

 23375 +    {

 23376 +      AVR32_OPC_PSUBS_SB, 4, 0xe0002330, 0xe1f0fff0,

 23377 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBS_SB],

 23378 +      BFD_RELOC_UNUSED, 3, -1,

 23379 +      {

 23380 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23381 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23382 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23383 +      },

 23384 +    },

 23385 +    {

 23386 +      AVR32_OPC_PSUBS_SH, 4, 0xe0002050, 0xe1f0fff0,

 23387 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBS_SH],

 23388 +      BFD_RELOC_UNUSED, 3, -1,

 23389 +      {

 23390 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23391 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23392 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23393 +      },

 23394 +    },

 23395 +    {

 23396 +      AVR32_OPC_PSUBS_UB, 4, 0xe0002350, 0xe1f0fff0,

 23397 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBS_UB],

 23398 +      BFD_RELOC_UNUSED, 3, -1,

 23399 +      {

 23400 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23401 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23402 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23403 +      },

 23404 +    },

 23405 +    {

 23406 +      AVR32_OPC_PSUBS_UH, 4, 0xe0002090, 0xe1f0fff0,

 23407 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBS_UH],

 23408 +      BFD_RELOC_UNUSED, 3, -1,

 23409 +      {

 23410 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23411 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23412 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23413 +      },

 23414 +    },

 23415 +    {

 23416 +      AVR32_OPC_PSUBX_H, 4, 0xe0002030, 0xe1f0fff0,

 23417 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBX_H],

 23418 +      BFD_RELOC_UNUSED, 3, -1,

 23419 +      {

 23420 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23421 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23422 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23423 +      },

 23424 +    },

 23425 +    {

 23426 +      AVR32_OPC_PSUBXH_SH, 4, 0xe00020f0, 0xe1f0fff0,

 23427 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBXH_SH],

 23428 +      BFD_RELOC_UNUSED, 3, -1,

 23429 +      {

 23430 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23431 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23432 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23433 +      },

 23434 +    },

 23435 +    {

 23436 +      AVR32_OPC_PSUBXS_SH, 4, 0xe0002070, 0xe1f0fff0,

 23437 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBXS_SH],

 23438 +      BFD_RELOC_UNUSED, 3, -1,

 23439 +      {

 23440 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23441 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23442 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23443 +      },

 23444 +    },

 23445 +    {

 23446 +      AVR32_OPC_PSUBXS_UH, 4, 0xe00020b0, 0xe1f0fff0,

 23447 +      &avr32_syntax_table[AVR32_SYNTAX_PSUBXS_UH],

 23448 +      BFD_RELOC_UNUSED, 3, -1,

 23449 +      {

 23450 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23451 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23452 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23453 +      },

 23454 +    },

 23455 +    {

 23456 +      AVR32_OPC_PUNPCKSB_H, 4, 0xe00024a0, 0xe1ffffe0,

 23457 +      &avr32_syntax_table[AVR32_SYNTAX_PUNPCKSB_H],

 23458 +      BFD_RELOC_UNUSED, 3, -1,

 23459 +      {

 23460 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23461 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23462 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 23463 +      },

 23464 +    },

 23465 +    {

 23466 +      AVR32_OPC_PUNPCKUB_H, 4, 0xe0002480, 0xe1ffffe0,

 23467 +      &avr32_syntax_table[AVR32_SYNTAX_PUNPCKUB_H],

 23468 +      BFD_RELOC_UNUSED, 3, -1,

 23469 +      {

 23470 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23471 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23472 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 23473 +      },

 23474 +    },

 23475 +    {

 23476 +      AVR32_OPC_PUSHJC, 2, 0xd7230000, 0xffff0000,

 23477 +      &avr32_syntax_table[AVR32_SYNTAX_PUSHJC],

 23478 +      BFD_RELOC_UNUSED, 0, -1, { NULL },

 23479 +    },

 23480 +    {

 23481 +      AVR32_OPC_PUSHM, 2, 0xd0010000, 0xf00f0000,

 23482 +      &avr32_syntax_table[AVR32_SYNTAX_PUSHM],

 23483 +      BFD_RELOC_UNUSED, 1, -1,

 23484 +      {

 23485 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 23486 +      },

 23487 +    },

 23488 +    {

 23489 +      AVR32_OPC_PUSHM_E, 4, 0xebcd0000, 0xffff0000,

 23490 +      &avr32_syntax_table[AVR32_SYNTAX_PUSHM_E],

 23491 +      BFD_RELOC_UNUSED, 1, -1,

 23492 +      {

 23493 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 23494 +      },

 23495 +    },

 23496 +    {

 23497 +      AVR32_OPC_RCALL1, 2, 0xc00c0000, 0xf00c0000,

 23498 +      &avr32_syntax_table[AVR32_SYNTAX_RCALL1],

 23499 +      BFD_RELOC_AVR32_11H_PCREL, 1, 0,

 23500 +      {

 23501 +	&avr32_ifield_table[AVR32_IFIELD_K10],

 23502 +      },

 23503 +    },

 23504 +    {

 23505 +      AVR32_OPC_RCALL2, 4, 0xe0a00000, 0xe1ef0000,

 23506 +      &avr32_syntax_table[AVR32_SYNTAX_RCALL2],

 23507 +      BFD_RELOC_AVR32_22H_PCREL, 1, 0,

 23508 +      {

 23509 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 23510 +      },

 23511 +    },

 23512 +    {

 23513 +      AVR32_OPC_RETEQ, 2, 0x5e000000, 0xfff00000,

 23514 +      &avr32_syntax_table[AVR32_SYNTAX_RETEQ],

 23515 +      BFD_RELOC_NONE, 1, -1,

 23516 +      {

 23517 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23518 +      },

 23519 +    },

 23520 +    {

 23521 +      AVR32_OPC_RETNE, 2, 0x5e100000, 0xfff00000,

 23522 +      &avr32_syntax_table[AVR32_SYNTAX_RETNE],

 23523 +      BFD_RELOC_NONE, 1, -1,

 23524 +      {

 23525 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23526 +      },

 23527 +    },

 23528 +    {

 23529 +      AVR32_OPC_RETCC, 2, 0x5e200000, 0xfff00000,

 23530 +      &avr32_syntax_table[AVR32_SYNTAX_RETHS],

 23531 +      BFD_RELOC_NONE, 1, -1,

 23532 +      {

 23533 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23534 +      },

 23535 +    },

 23536 +    {

 23537 +      AVR32_OPC_RETCS, 2, 0x5e300000, 0xfff00000,

 23538 +      &avr32_syntax_table[AVR32_SYNTAX_RETLO],

 23539 +      BFD_RELOC_NONE, 1, -1,

 23540 +      {

 23541 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23542 +      },

 23543 +    },

 23544 +    {

 23545 +      AVR32_OPC_RETGE, 2, 0x5e400000, 0xfff00000,

 23546 +      &avr32_syntax_table[AVR32_SYNTAX_RETGE],

 23547 +      BFD_RELOC_NONE, 1, -1,

 23548 +      {

 23549 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23550 +      },

 23551 +    },

 23552 +    {

 23553 +      AVR32_OPC_RETLT, 2, 0x5e500000, 0xfff00000,

 23554 +      &avr32_syntax_table[AVR32_SYNTAX_RETLT],

 23555 +      BFD_RELOC_NONE, 1, -1,

 23556 +      {

 23557 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23558 +      },

 23559 +    },

 23560 +    {

 23561 +      AVR32_OPC_RETMI, 2, 0x5e600000, 0xfff00000,

 23562 +      &avr32_syntax_table[AVR32_SYNTAX_RETMI],

 23563 +      BFD_RELOC_NONE, 1, -1,

 23564 +      {

 23565 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23566 +      },

 23567 +    },

 23568 +    {

 23569 +      AVR32_OPC_RETPL, 2, 0x5e700000, 0xfff00000,

 23570 +      &avr32_syntax_table[AVR32_SYNTAX_RETPL],

 23571 +      BFD_RELOC_NONE, 1, -1,

 23572 +      {

 23573 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23574 +      },

 23575 +    },

 23576 +    {

 23577 +      AVR32_OPC_RETLS, 2, 0x5e800000, 0xfff00000,

 23578 +      &avr32_syntax_table[AVR32_SYNTAX_RETLS],

 23579 +      BFD_RELOC_NONE, 1, -1,

 23580 +      {

 23581 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23582 +      },

 23583 +    },

 23584 +    {

 23585 +      AVR32_OPC_RETGT, 2, 0x5e900000, 0xfff00000,

 23586 +      &avr32_syntax_table[AVR32_SYNTAX_RETGT],

 23587 +      BFD_RELOC_NONE, 1, -1,

 23588 +      {

 23589 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23590 +      },

 23591 +    },

 23592 +    {

 23593 +      AVR32_OPC_RETLE, 2, 0x5ea00000, 0xfff00000,

 23594 +      &avr32_syntax_table[AVR32_SYNTAX_RETLE],

 23595 +      BFD_RELOC_NONE, 1, -1,

 23596 +      {

 23597 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23598 +      },

 23599 +    },

 23600 +    {

 23601 +      AVR32_OPC_RETHI, 2, 0x5eb00000, 0xfff00000,

 23602 +      &avr32_syntax_table[AVR32_SYNTAX_RETHI],

 23603 +      BFD_RELOC_NONE, 1, -1,

 23604 +      {

 23605 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23606 +      },

 23607 +    },

 23608 +    {

 23609 +      AVR32_OPC_RETVS, 2, 0x5ec00000, 0xfff00000,

 23610 +      &avr32_syntax_table[AVR32_SYNTAX_RETVS],

 23611 +      BFD_RELOC_NONE, 1, -1,

 23612 +      {

 23613 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23614 +      },

 23615 +    },

 23616 +    {

 23617 +      AVR32_OPC_RETVC, 2, 0x5ed00000, 0xfff00000,

 23618 +      &avr32_syntax_table[AVR32_SYNTAX_RETVC],

 23619 +      BFD_RELOC_NONE, 1, -1,

 23620 +      {

 23621 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23622 +      },

 23623 +    },

 23624 +    {

 23625 +      AVR32_OPC_RETQS, 2, 0x5ee00000, 0xfff00000,

 23626 +      &avr32_syntax_table[AVR32_SYNTAX_RETQS],

 23627 +      BFD_RELOC_NONE, 1, -1,

 23628 +      {

 23629 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23630 +      },

 23631 +    },

 23632 +    {

 23633 +      AVR32_OPC_RETAL, 2, 0x5ef00000, 0xfff00000,

 23634 +      &avr32_syntax_table[AVR32_SYNTAX_RETAL],

 23635 +      BFD_RELOC_NONE, 1, -1,

 23636 +      {

 23637 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23638 +      },

 23639 +    },

 23640 +    {

 23641 +      AVR32_OPC_RETD, 2, 0xd6230000, 0xffff0000,

 23642 +      &avr32_syntax_table[AVR32_SYNTAX_RETD],

 23643 +      BFD_RELOC_NONE, 0, -1, { NULL },

 23644 +    },

 23645 +    {

 23646 +      AVR32_OPC_RETE, 2, 0xd6030000, 0xffff0000,

 23647 +      &avr32_syntax_table[AVR32_SYNTAX_RETE],

 23648 +      BFD_RELOC_NONE, 0, -1, { NULL },

 23649 +    },

 23650 +    {

 23651 +      AVR32_OPC_RETJ, 2, 0xd6330000, 0xffff0000,

 23652 +      &avr32_syntax_table[AVR32_SYNTAX_RETJ],

 23653 +      BFD_RELOC_NONE, 0, -1, { NULL },

 23654 +    },

 23655 +    {

 23656 +      AVR32_OPC_RETS, 2, 0xd6130000, 0xffff0000,

 23657 +      &avr32_syntax_table[AVR32_SYNTAX_RETS],

 23658 +      BFD_RELOC_NONE, 0, -1, { NULL },

 23659 +    },

 23660 +    {

 23661 +      AVR32_OPC_RJMP, 2, 0xc0080000, 0xf00c0000,

 23662 +      &avr32_syntax_table[AVR32_SYNTAX_RJMP],

 23663 +      BFD_RELOC_AVR32_11H_PCREL, 1, 0,

 23664 +      {

 23665 +	&avr32_ifield_table[AVR32_IFIELD_K10],

 23666 +      },

 23667 +    },

 23668 +    {

 23669 +      AVR32_OPC_ROL, 2, 0x5cf00000, 0xfff00000,

 23670 +      &avr32_syntax_table[AVR32_SYNTAX_ROL],

 23671 +      BFD_RELOC_UNUSED, 1, -1,

 23672 +      {

 23673 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23674 +      }

 23675 +    },

 23676 +    {

 23677 +      AVR32_OPC_ROR, 2, 0x5d000000, 0xfff00000,

 23678 +      &avr32_syntax_table[AVR32_SYNTAX_ROR],

 23679 +      BFD_RELOC_UNUSED, 1, -1,

 23680 +      {

 23681 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23682 +      }

 23683 +    },

 23684 +    {

 23685 +      AVR32_OPC_RSUB1, 2, 0x00200000, 0xe1f00000,

 23686 +      &avr32_syntax_table[AVR32_SYNTAX_RSUB1],

 23687 +      BFD_RELOC_UNUSED, 2, -1,

 23688 +      {

 23689 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23690 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23691 +      },

 23692 +    },

 23693 +    {

 23694 +      AVR32_OPC_RSUB2, 4, 0xe0001100, 0xe1f0ff00,

 23695 +      &avr32_syntax_table[AVR32_SYNTAX_RSUB2],

 23696 +      BFD_RELOC_AVR32_8S_EXT, 3, 2,

 23697 +      {

 23698 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23699 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23700 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 23701 +      },

 23702 +    },

 23703 +    {

 23704 +      AVR32_OPC_SATADD_H, 4, 0xe00002c0, 0xe1f0fff0,

 23705 +      &avr32_syntax_table[AVR32_SYNTAX_SATADD_H],

 23706 +      BFD_RELOC_UNUSED, 3, -1,

 23707 +      {

 23708 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23709 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23710 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23711 +      },

 23712 +    },

 23713 +    {

 23714 +      AVR32_OPC_SATADD_W, 4, 0xe00000c0, 0xe1f0fff0,

 23715 +      &avr32_syntax_table[AVR32_SYNTAX_SATADD_W],

 23716 +      BFD_RELOC_UNUSED, 3, -1,

 23717 +      {

 23718 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23719 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23720 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23721 +      },

 23722 +    },

 23723 +    {

 23724 +      AVR32_OPC_SATRNDS, 4, 0xf3b00000, 0xfff0fc00,

 23725 +      &avr32_syntax_table[AVR32_SYNTAX_SATRNDS],

 23726 +      BFD_RELOC_UNUSED, 3, -1,

 23727 +      {

 23728 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23729 +	&avr32_ifield_table[AVR32_IFIELD_K5E],

 23730 +	&avr32_ifield_table[AVR32_IFIELD_S5],

 23731 +      },

 23732 +    },

 23733 +    {

 23734 +      AVR32_OPC_SATRNDU, 4, 0xf3b00400, 0xfff0fc00,

 23735 +      &avr32_syntax_table[AVR32_SYNTAX_SATRNDU],

 23736 +      BFD_RELOC_UNUSED, 3, -1,

 23737 +      {

 23738 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23739 +	&avr32_ifield_table[AVR32_IFIELD_K5E],

 23740 +	&avr32_ifield_table[AVR32_IFIELD_S5],

 23741 +      },

 23742 +    },

 23743 +    {

 23744 +      AVR32_OPC_SATS, 4, 0xf1b00000, 0xfff0fc00,

 23745 +      &avr32_syntax_table[AVR32_SYNTAX_SATS],

 23746 +      BFD_RELOC_UNUSED, 3, -1,

 23747 +      {

 23748 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23749 +	&avr32_ifield_table[AVR32_IFIELD_K5E],

 23750 +	&avr32_ifield_table[AVR32_IFIELD_S5],

 23751 +      },

 23752 +    },

 23753 +    {

 23754 +      AVR32_OPC_SATSUB_H, 4, 0xe00003c0, 0xe1f0fff0,

 23755 +      &avr32_syntax_table[AVR32_SYNTAX_SATSUB_H],

 23756 +      BFD_RELOC_UNUSED, 3, -1,

 23757 +      {

 23758 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23759 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23760 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23761 +      },

 23762 +    },

 23763 +    {

 23764 +      AVR32_OPC_SATSUB_W1, 4, 0xe00001c0, 0xe1f0fff0,

 23765 +      &avr32_syntax_table[AVR32_SYNTAX_SATSUB_W1],

 23766 +      BFD_RELOC_UNUSED, 3, -1,

 23767 +      {

 23768 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23769 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23770 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23771 +      },

 23772 +    },

 23773 +    {

 23774 +      AVR32_OPC_SATSUB_W2, 4, 0xe0d00000, 0xe1f00000,

 23775 +      &avr32_syntax_table[AVR32_SYNTAX_SATSUB_W2],

 23776 +      BFD_RELOC_UNUSED, 3, -1,

 23777 +      {

 23778 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23779 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23780 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 23781 +      },

 23782 +    },

 23783 +    {

 23784 +      AVR32_OPC_SATU, 4, 0xf1b00400, 0xfff0fc00,

 23785 +      &avr32_syntax_table[AVR32_SYNTAX_SATU],

 23786 +      BFD_RELOC_UNUSED, 3, -1,

 23787 +      {

 23788 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23789 +	&avr32_ifield_table[AVR32_IFIELD_K5E],

 23790 +	&avr32_ifield_table[AVR32_IFIELD_S5],

 23791 +      },

 23792 +    },

 23793 +    {

 23794 +      AVR32_OPC_SBC, 4, 0xe0000140, 0xe1f0fff0,

 23795 +      &avr32_syntax_table[AVR32_SYNTAX_SBC],

 23796 +      BFD_RELOC_UNUSED, 3, -1,

 23797 +      {

 23798 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23799 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23800 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23801 +      },

 23802 +    },

 23803 +    {

 23804 +      AVR32_OPC_SBR, 2, 0xa1a00000, 0xe1e00000,

 23805 +      &avr32_syntax_table[AVR32_SYNTAX_SBR],

 23806 +      BFD_RELOC_UNUSED, 2, -1,

 23807 +      {

 23808 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23809 +	&avr32_ifield_table[AVR32_IFIELD_BIT5C],

 23810 +      },

 23811 +    },

 23812 +    {

 23813 +      AVR32_OPC_SCALL, 2, 0xd7330000, 0xffff0000,

 23814 +      &avr32_syntax_table[AVR32_SYNTAX_SCALL],

 23815 +      BFD_RELOC_UNUSED, 0, -1, { NULL },

 23816 +    },

 23817 +    {

 23818 +      AVR32_OPC_SCR, 2, 0x5c100000, 0xfff00000,

 23819 +      &avr32_syntax_table[AVR32_SYNTAX_SCR],

 23820 +      BFD_RELOC_UNUSED, 1, -1,

 23821 +      {

 23822 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23823 +      },

 23824 +    },

 23825 +    {

 23826 +      AVR32_OPC_SLEEP, 4, 0xe9b00000, 0xffffff00,

 23827 +      &avr32_syntax_table[AVR32_SYNTAX_SLEEP],

 23828 +      BFD_RELOC_AVR32_8S_EXT, 1, 0,

 23829 +      {

 23830 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 23831 +      },

 23832 +    },

 23833 +    {

 23834 +      AVR32_OPC_SREQ, 2, 0x5f000000, 0xfff00000,

 23835 +      &avr32_syntax_table[AVR32_SYNTAX_SREQ],

 23836 +      BFD_RELOC_UNUSED, 1, -1,

 23837 +      {

 23838 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23839 +      },

 23840 +    },

 23841 +    {

 23842 +      AVR32_OPC_SRNE, 2, 0x5f100000, 0xfff00000,

 23843 +      &avr32_syntax_table[AVR32_SYNTAX_SRNE],

 23844 +      BFD_RELOC_UNUSED, 1, -1,

 23845 +      {

 23846 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23847 +      },

 23848 +    },

 23849 +    {

 23850 +      AVR32_OPC_SRCC, 2, 0x5f200000, 0xfff00000,

 23851 +      &avr32_syntax_table[AVR32_SYNTAX_SRHS],

 23852 +      BFD_RELOC_UNUSED, 1, -1,

 23853 +      {

 23854 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23855 +      },

 23856 +    },

 23857 +    {

 23858 +      AVR32_OPC_SRCS, 2, 0x5f300000, 0xfff00000,

 23859 +      &avr32_syntax_table[AVR32_SYNTAX_SRLO],

 23860 +      BFD_RELOC_UNUSED, 1, -1,

 23861 +      {

 23862 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23863 +      },

 23864 +    },

 23865 +    {

 23866 +      AVR32_OPC_SRGE, 2, 0x5f400000, 0xfff00000,

 23867 +      &avr32_syntax_table[AVR32_SYNTAX_SRGE],

 23868 +      BFD_RELOC_UNUSED, 1, -1,

 23869 +      {

 23870 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23871 +      },

 23872 +    },

 23873 +    {

 23874 +      AVR32_OPC_SRLT, 2, 0x5f500000, 0xfff00000,

 23875 +      &avr32_syntax_table[AVR32_SYNTAX_SRLT],

 23876 +      BFD_RELOC_UNUSED, 1, -1,

 23877 +      {

 23878 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23879 +      },

 23880 +    },

 23881 +    {

 23882 +      AVR32_OPC_SRMI, 2, 0x5f600000, 0xfff00000,

 23883 +      &avr32_syntax_table[AVR32_SYNTAX_SRMI],

 23884 +      BFD_RELOC_UNUSED, 1, -1,

 23885 +      {

 23886 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23887 +      },

 23888 +    },

 23889 +    {

 23890 +      AVR32_OPC_SRPL, 2, 0x5f700000, 0xfff00000,

 23891 +      &avr32_syntax_table[AVR32_SYNTAX_SRPL],

 23892 +      BFD_RELOC_UNUSED, 1, -1,

 23893 +      {

 23894 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23895 +      },

 23896 +    },

 23897 +    {

 23898 +      AVR32_OPC_SRLS, 2, 0x5f800000, 0xfff00000,

 23899 +      &avr32_syntax_table[AVR32_SYNTAX_SRLS],

 23900 +      BFD_RELOC_UNUSED, 1, -1,

 23901 +      {

 23902 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23903 +      },

 23904 +    },

 23905 +    {

 23906 +      AVR32_OPC_SRGT, 2, 0x5f900000, 0xfff00000,

 23907 +      &avr32_syntax_table[AVR32_SYNTAX_SRGT],

 23908 +      BFD_RELOC_UNUSED, 1, -1,

 23909 +      {

 23910 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23911 +      },

 23912 +    },

 23913 +    {

 23914 +      AVR32_OPC_SRLE, 2, 0x5fa00000, 0xfff00000,

 23915 +      &avr32_syntax_table[AVR32_SYNTAX_SRLE],

 23916 +      BFD_RELOC_UNUSED, 1, -1,

 23917 +      {

 23918 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23919 +      },

 23920 +    },

 23921 +    {

 23922 +      AVR32_OPC_SRHI, 2, 0x5fb00000, 0xfff00000,

 23923 +      &avr32_syntax_table[AVR32_SYNTAX_SRHI],

 23924 +      BFD_RELOC_UNUSED, 1, -1,

 23925 +      {

 23926 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23927 +      },

 23928 +    },

 23929 +    {

 23930 +      AVR32_OPC_SRVS, 2, 0x5fc00000, 0xfff00000,

 23931 +      &avr32_syntax_table[AVR32_SYNTAX_SRVS],

 23932 +      BFD_RELOC_UNUSED, 1, -1,

 23933 +      {

 23934 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23935 +      },

 23936 +    },

 23937 +    {

 23938 +      AVR32_OPC_SRVC, 2, 0x5fd00000, 0xfff00000,

 23939 +      &avr32_syntax_table[AVR32_SYNTAX_SRVC],

 23940 +      BFD_RELOC_UNUSED, 1, -1,

 23941 +      {

 23942 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23943 +      },

 23944 +    },

 23945 +    {

 23946 +      AVR32_OPC_SRQS, 2, 0x5fe00000, 0xfff00000,

 23947 +      &avr32_syntax_table[AVR32_SYNTAX_SRQS],

 23948 +      BFD_RELOC_UNUSED, 1, -1,

 23949 +      {

 23950 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23951 +      },

 23952 +    },

 23953 +    {

 23954 +      AVR32_OPC_SRAL, 2, 0x5ff00000, 0xfff00000,

 23955 +      &avr32_syntax_table[AVR32_SYNTAX_SRAL],

 23956 +      BFD_RELOC_UNUSED, 1, -1,

 23957 +      {

 23958 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23959 +      },

 23960 +    },

 23961 +    {

 23962 +      AVR32_OPC_SSRF, 2, 0xd2030000, 0xfe0f0000,

 23963 +      &avr32_syntax_table[AVR32_SYNTAX_SSRF],

 23964 +      BFD_RELOC_UNUSED, 1, -1,

 23965 +      {

 23966 +	&avr32_ifield_table[AVR32_IFIELD_K5C],

 23967 +      },

 23968 +    },

 23969 +    {

 23970 +      AVR32_OPC_ST_B1, 2, 0x00c00000, 0xe1f00000,

 23971 +      &avr32_syntax_table[AVR32_SYNTAX_ST_B1],

 23972 +      BFD_RELOC_UNUSED, 2, -1,

 23973 +      {

 23974 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23975 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23976 +      },

 23977 +    },

 23978 +    {

 23979 +      AVR32_OPC_ST_B2, 2, 0x00f00000, 0xe1f00000,

 23980 +      &avr32_syntax_table[AVR32_SYNTAX_ST_B2],

 23981 +      BFD_RELOC_UNUSED, 2, -1,

 23982 +      {

 23983 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23984 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23985 +      },

 23986 +    },

 23987 +    {

 23988 +      AVR32_OPC_ST_B5, 4, 0xe0000b00, 0xe1f0ffc0,

 23989 +      &avr32_syntax_table[AVR32_SYNTAX_ST_B5],

 23990 +      BFD_RELOC_UNUSED, 4, -1,

 23991 +      {

 23992 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 23993 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 23994 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 23995 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 23996 +      },

 23997 +    },

 23998 +    {

 23999 +      AVR32_OPC_ST_B3, 2, 0xa0800000, 0xe1800000,

 24000 +      &avr32_syntax_table[AVR32_SYNTAX_ST_B3],

 24001 +      BFD_RELOC_AVR32_3U, 3, 1,

 24002 +      {

 24003 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24004 +	&avr32_ifield_table[AVR32_IFIELD_K3],

 24005 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24006 +      },

 24007 +    },

 24008 +    {

 24009 +      AVR32_OPC_ST_B4, 4, 0xe1600000, 0xe1f00000,

 24010 +      &avr32_syntax_table[AVR32_SYNTAX_ST_B4],

 24011 +      BFD_RELOC_AVR32_16S, 3, 1,

 24012 +      {

 24013 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24014 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 24015 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24016 +      },

 24017 +    },

 24018 +    {

 24019 +      AVR32_OPC_ST_D1, 2, 0xa1200000, 0xe1f10000,

 24020 +      &avr32_syntax_table[AVR32_SYNTAX_ST_D1],

 24021 +      BFD_RELOC_UNUSED, 2, -1,

 24022 +      {

 24023 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24024 +	&avr32_ifield_table[AVR32_IFIELD_RY_DW],

 24025 +      },

 24026 +    },

 24027 +    {

 24028 +      AVR32_OPC_ST_D2, 2, 0xa1210000, 0xe1f10000,

 24029 +      &avr32_syntax_table[AVR32_SYNTAX_ST_D2],

 24030 +      BFD_RELOC_UNUSED, 2, -1,

 24031 +      {

 24032 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24033 +	&avr32_ifield_table[AVR32_IFIELD_RY_DW],

 24034 +      },

 24035 +    },

 24036 +    {

 24037 +      AVR32_OPC_ST_D3, 2, 0xa1110000, 0xe1f10000,

 24038 +      &avr32_syntax_table[AVR32_SYNTAX_ST_D3],

 24039 +      BFD_RELOC_UNUSED, 2, -1,

 24040 +      {

 24041 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24042 +	&avr32_ifield_table[AVR32_IFIELD_RY_DW],

 24043 +      },

 24044 +    },

 24045 +    {

 24046 +      AVR32_OPC_ST_D5, 4, 0xe0000800, 0xe1f0ffc1,

 24047 +      &avr32_syntax_table[AVR32_SYNTAX_ST_D5],

 24048 +      BFD_RELOC_UNUSED, 4, -1,

 24049 +      {

 24050 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24051 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24052 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 24053 +	&avr32_ifield_table[AVR32_IFIELD_RD_DW],

 24054 +      },

 24055 +    },

 24056 +    {

 24057 +      AVR32_OPC_ST_D4, 4, 0xe0e10000, 0xe1f10000,

 24058 +      &avr32_syntax_table[AVR32_SYNTAX_ST_D4],

 24059 +      BFD_RELOC_AVR32_16S, 3, 1,

 24060 +      {

 24061 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24062 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 24063 +	&avr32_ifield_table[AVR32_IFIELD_RY_DW],

 24064 +      },

 24065 +    },

 24066 +    {

 24067 +      AVR32_OPC_ST_H1, 2, 0x00b00000, 0xe1f00000,

 24068 +      &avr32_syntax_table[AVR32_SYNTAX_ST_H1],

 24069 +      BFD_RELOC_UNUSED, 2, -1,

 24070 +      {

 24071 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24072 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24073 +      },

 24074 +    },

 24075 +    {

 24076 +      AVR32_OPC_ST_H2, 2, 0x00e00000, 0xe1f00000,

 24077 +      &avr32_syntax_table[AVR32_SYNTAX_ST_H2],

 24078 +      BFD_RELOC_UNUSED, 2, -1,

 24079 +      {

 24080 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24081 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24082 +      },

 24083 +    },

 24084 +    {

 24085 +      AVR32_OPC_ST_H5, 4, 0xe0000a00, 0xe1f0ffc0,

 24086 +      &avr32_syntax_table[AVR32_SYNTAX_ST_H5],

 24087 +      BFD_RELOC_UNUSED, 4, -1,

 24088 +      {

 24089 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24090 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24091 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 24092 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 24093 +      },

 24094 +    },

 24095 +    {

 24096 +      AVR32_OPC_ST_H3, 2, 0xa0000000, 0xe1800000,

 24097 +      &avr32_syntax_table[AVR32_SYNTAX_ST_H3],

 24098 +      BFD_RELOC_AVR32_4UH, 3, 1,

 24099 +      {

 24100 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24101 +	&avr32_ifield_table[AVR32_IFIELD_K3],

 24102 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24103 +      },

 24104 +    },

 24105 +    {

 24106 +      AVR32_OPC_ST_H4, 4, 0xe1500000, 0xe1f00000,

 24107 +      &avr32_syntax_table[AVR32_SYNTAX_ST_H4],

 24108 +      BFD_RELOC_AVR32_16S, 3, 1,

 24109 +      {

 24110 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24111 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 24112 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24113 +      },

 24114 +    },

 24115 +    {

 24116 +      AVR32_OPC_ST_W1, 2, 0x00a00000, 0xe1f00000,

 24117 +      &avr32_syntax_table[AVR32_SYNTAX_ST_W1],

 24118 +      BFD_RELOC_UNUSED, 2, -1,

 24119 +      {

 24120 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24121 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24122 +      },

 24123 +    },

 24124 +    {

 24125 +      AVR32_OPC_ST_W2, 2, 0x00d00000, 0xe1f00000,

 24126 +      &avr32_syntax_table[AVR32_SYNTAX_ST_W2],

 24127 +      BFD_RELOC_UNUSED, 2, -1,

 24128 +      {

 24129 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24130 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24131 +      },

 24132 +    },

 24133 +    {

 24134 +      AVR32_OPC_ST_W5, 4, 0xe0000900, 0xe1f0ffc0,

 24135 +      &avr32_syntax_table[AVR32_SYNTAX_ST_W5],

 24136 +      BFD_RELOC_UNUSED, 4, -1,

 24137 +      {

 24138 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24139 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24140 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 24141 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 24142 +      },

 24143 +    },

 24144 +    {

 24145 +      AVR32_OPC_ST_W3, 2, 0x81000000, 0xe1000000,

 24146 +      &avr32_syntax_table[AVR32_SYNTAX_ST_W3],

 24147 +      BFD_RELOC_AVR32_6UW, 3, 1,

 24148 +      {

 24149 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24150 +	&avr32_ifield_table[AVR32_IFIELD_K4],

 24151 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24152 +      },

 24153 +    },

 24154 +    {

 24155 +      AVR32_OPC_ST_W4, 4, 0xe1400000, 0xe1f00000,

 24156 +      &avr32_syntax_table[AVR32_SYNTAX_ST_W4],

 24157 +      BFD_RELOC_AVR32_16S, 3, 1,

 24158 +      {

 24159 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24160 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 24161 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24162 +      },

 24163 +    },

 24164 +    {

 24165 +      AVR32_OPC_STC_D1, 4, 0xeba01000, 0xfff01100,

 24166 +      &avr32_syntax_table[AVR32_SYNTAX_STC_D1],

 24167 +      BFD_RELOC_AVR32_10UW, 4, 2,

 24168 +      {

 24169 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 24170 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24171 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24172 +	&avr32_ifield_table[AVR32_IFIELD_CRD_DW],

 24173 +      },

 24174 +    },

 24175 +    {

 24176 +      AVR32_OPC_STC_D2, 4, 0xefa00070, 0xfff011f0,

 24177 +      &avr32_syntax_table[AVR32_SYNTAX_STC_D2],

 24178 +      BFD_RELOC_UNUSED, 3, -1,

 24179 +      {

 24180 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 24181 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24182 +	&avr32_ifield_table[AVR32_IFIELD_CRD_DW],

 24183 +      },

 24184 +    },

 24185 +    {

 24186 +      AVR32_OPC_STC_D3, 4, 0xefa010c0, 0xfff011c0,

 24187 +      &avr32_syntax_table[AVR32_SYNTAX_STC_D3],

 24188 +      BFD_RELOC_UNUSED, 5, -1,

 24189 +      {

 24190 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 24191 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24192 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 24193 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 24194 +	&avr32_ifield_table[AVR32_IFIELD_CRD_DW],

 24195 +      },

 24196 +    },

 24197 +    {

 24198 +      AVR32_OPC_STC_W1, 4, 0xeba00000, 0xfff01000,

 24199 +      &avr32_syntax_table[AVR32_SYNTAX_STC_W1],

 24200 +      BFD_RELOC_AVR32_10UW, 4, 2,

 24201 +      {

 24202 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 24203 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24204 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24205 +	&avr32_ifield_table[AVR32_IFIELD_CRD_RI],

 24206 +      },

 24207 +    },

 24208 +    {

 24209 +      AVR32_OPC_STC_W2, 4, 0xefa00060, 0xfff010ff,

 24210 +      &avr32_syntax_table[AVR32_SYNTAX_STC_W2],

 24211 +      BFD_RELOC_UNUSED, 3, -1,

 24212 +      {

 24213 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 24214 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24215 +	&avr32_ifield_table[AVR32_IFIELD_CRD_RI],

 24216 +      },

 24217 +    },

 24218 +    {

 24219 +      AVR32_OPC_STC_W3, 4, 0xefa01080, 0xfff010c0,

 24220 +      &avr32_syntax_table[AVR32_SYNTAX_STC_W3],

 24221 +      BFD_RELOC_UNUSED, 5, -1,

 24222 +      {

 24223 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 24224 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24225 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 24226 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 24227 +	&avr32_ifield_table[AVR32_IFIELD_CRD_RI],

 24228 +      },

 24229 +    },

 24230 +    {

 24231 +      AVR32_OPC_STC0_D, 4, 0xf7a00000, 0xfff00100,

 24232 +      &avr32_syntax_table[AVR32_SYNTAX_STC0_D],

 24233 +      BFD_RELOC_AVR32_14UW, 3, 1,

 24234 +      {

 24235 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24236 +	&avr32_ifield_table[AVR32_IFIELD_K12CP],

 24237 +	&avr32_ifield_table[AVR32_IFIELD_CRD_DW],

 24238 +      },

 24239 +    },

 24240 +    {

 24241 +      AVR32_OPC_STC0_W, 4, 0xf5a00000, 0xfff00000,

 24242 +      &avr32_syntax_table[AVR32_SYNTAX_STC0_W],

 24243 +      BFD_RELOC_AVR32_14UW, 3, 1,

 24244 +      {

 24245 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24246 +	&avr32_ifield_table[AVR32_IFIELD_K12CP],

 24247 +	&avr32_ifield_table[AVR32_IFIELD_CRD_RI],

 24248 +      },

 24249 +    },

 24250 +    {

 24251 +      AVR32_OPC_STCM_D, 4, 0xeda00500, 0xfff01f00,

 24252 +      &avr32_syntax_table[AVR32_SYNTAX_STCM_D],

 24253 +      BFD_RELOC_UNUSED, 3, -1,

 24254 +      {

 24255 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 24256 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24257 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24258 +      },

 24259 +    },

 24260 +    {

 24261 +      AVR32_OPC_STCM_D_PU, 4, 0xeda01500, 0xfff01f00,

 24262 +      &avr32_syntax_table[AVR32_SYNTAX_STCM_D_PU],

 24263 +      BFD_RELOC_UNUSED, 3, -1,

 24264 +      {

 24265 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 24266 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24267 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24268 +      },

 24269 +    },

 24270 +    {

 24271 +      AVR32_OPC_STCM_W, 4, 0xeda00200, 0xfff01e00,

 24272 +      &avr32_syntax_table[AVR32_SYNTAX_STCM_W],

 24273 +      BFD_RELOC_UNUSED, 4, -1,

 24274 +      {

 24275 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 24276 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24277 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24278 +	&avr32_ifield_table[AVR32_IFIELD_CM_HL],

 24279 +      },

 24280 +    },

 24281 +    {

 24282 +      AVR32_OPC_STCM_W_PU, 4, 0xeda01200, 0xfff01e00,

 24283 +      &avr32_syntax_table[AVR32_SYNTAX_STCM_W_PU],

 24284 +      BFD_RELOC_UNUSED, 4, -1,

 24285 +      {

 24286 +	&avr32_ifield_table[AVR32_IFIELD_CPNO],

 24287 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24288 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24289 +	&avr32_ifield_table[AVR32_IFIELD_CM_HL],

 24290 +      },

 24291 +    },

 24292 +    {

 24293 +      AVR32_OPC_STCOND, 4, 0xe1700000, 0xe1f00000,

 24294 +      &avr32_syntax_table[AVR32_SYNTAX_STCOND],

 24295 +      BFD_RELOC_UNUSED, 3, -1,

 24296 +      {

 24297 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24298 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 24299 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24300 +      },

 24301 +    },

 24302 +    {

 24303 +      AVR32_OPC_STDSP, 2, 0x50000000, 0xf8000000,

 24304 +      &avr32_syntax_table[AVR32_SYNTAX_STDSP],

 24305 +      BFD_RELOC_UNUSED, 2, -1,

 24306 +      {

 24307 +	&avr32_ifield_table[AVR32_IFIELD_K7C],

 24308 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24309 +      },

 24310 +    },

 24311 +    {

 24312 +      AVR32_OPC_STHH_W2, 4, 0xe1e08000, 0xe1f0c0c0,

 24313 +      &avr32_syntax_table[AVR32_SYNTAX_STHH_W2],

 24314 +      BFD_RELOC_UNUSED, 7, -1,

 24315 +      {

 24316 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 24317 +	&avr32_ifield_table[AVR32_IFIELD_CRD_RI],

 24318 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 24319 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24320 +	&avr32_ifield_table[AVR32_IFIELD_X2],

 24321 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24322 +	&avr32_ifield_table[AVR32_IFIELD_Y2],

 24323 +      },

 24324 +    },

 24325 +    {

 24326 +      AVR32_OPC_STHH_W1, 4, 0xe1e0c000, 0xe1f0c000,

 24327 +      &avr32_syntax_table[AVR32_SYNTAX_STHH_W1],

 24328 +      BFD_RELOC_AVR32_STHH_W, 6, 1,

 24329 +      {

 24330 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 24331 +	&avr32_ifield_table[AVR32_IFIELD_K8E2],

 24332 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24333 +	&avr32_ifield_table[AVR32_IFIELD_X2],

 24334 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24335 +	&avr32_ifield_table[AVR32_IFIELD_Y2],

 24336 +      },

 24337 +    },

 24338 +    {

 24339 +      AVR32_OPC_STM, 4, 0xe9c00000, 0xfff00000,

 24340 +      &avr32_syntax_table[AVR32_SYNTAX_STM],

 24341 +      BFD_RELOC_UNUSED, 2, -1,

 24342 +      {

 24343 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24344 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 24345 +      },

 24346 +    },

 24347 +    {

 24348 +      AVR32_OPC_STM_PU, 4, 0xebc00000, 0xfff00000,

 24349 +      &avr32_syntax_table[AVR32_SYNTAX_STM_PU],

 24350 +      BFD_RELOC_UNUSED, 2, -1,

 24351 +      {

 24352 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24353 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 24354 +      },

 24355 +    },

 24356 +    {

 24357 +      AVR32_OPC_STMTS, 4, 0xedc00000, 0xfff00000,

 24358 +      &avr32_syntax_table[AVR32_SYNTAX_STMTS],

 24359 +      BFD_RELOC_UNUSED, 2, -1,

 24360 +      {

 24361 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24362 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 24363 +      },

 24364 +    },

 24365 +    {

 24366 +      AVR32_OPC_STMTS_PU, 4, 0xefc00000, 0xfff00000,

 24367 +      &avr32_syntax_table[AVR32_SYNTAX_STMTS_PU],

 24368 +      BFD_RELOC_UNUSED, 2, -1,

 24369 +      {

 24370 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24371 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 24372 +      },

 24373 +    },

 24374 +    {

 24375 +      AVR32_OPC_STSWP_H, 4, 0xe1d09000, 0xe1f0f000,

 24376 +      &avr32_syntax_table[AVR32_SYNTAX_STSWP_H],

 24377 +      BFD_RELOC_UNUSED, 3, -1,

 24378 +      {

 24379 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24380 +	&avr32_ifield_table[AVR32_IFIELD_K12],

 24381 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24382 +      },

 24383 +    },

 24384 +    {

 24385 +      AVR32_OPC_STSWP_W, 4, 0xe1d0a000, 0xe1f0f000,

 24386 +      &avr32_syntax_table[AVR32_SYNTAX_STSWP_W],

 24387 +      BFD_RELOC_UNUSED, 3, -1,

 24388 +      {

 24389 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24390 +	&avr32_ifield_table[AVR32_IFIELD_K12],

 24391 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24392 +      },

 24393 +    },

 24394 +    {

 24395 +      AVR32_OPC_SUB1, 2, 0x00100000, 0xe1f00000,

 24396 +      &avr32_syntax_table[AVR32_SYNTAX_SUB1],

 24397 +      BFD_RELOC_UNUSED, 2, -1,

 24398 +      {

 24399 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24400 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24401 +      },

 24402 +    },

 24403 +    {

 24404 +      AVR32_OPC_SUB2, 4, 0xe0000100, 0xe1f0ffc0,

 24405 +      &avr32_syntax_table[AVR32_SYNTAX_SUB2],

 24406 +      BFD_RELOC_UNUSED, 4, -1,

 24407 +      {

 24408 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 24409 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24410 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24411 +	&avr32_ifield_table[AVR32_IFIELD_K2],

 24412 +      },

 24413 +    },

 24414 +    {

 24415 +      AVR32_OPC_SUB5, 4, 0xe0c00000, 0xe1f00000,

 24416 +      &avr32_syntax_table[AVR32_SYNTAX_SUB5],

 24417 +      BFD_RELOC_AVR32_SUB5, 3, 2,

 24418 +      {

 24419 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24420 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24421 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 24422 +      },

 24423 +    },

 24424 +    {

 24425 +      AVR32_OPC_SUB3_SP, 2, 0x200d0000, 0xf00f0000,

 24426 +      &avr32_syntax_table[AVR32_SYNTAX_SUB3_SP],

 24427 +      BFD_RELOC_AVR32_10SW, 2, 1,

 24428 +      {

 24429 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24430 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 24431 +      },

 24432 +    },

 24433 +    {

 24434 +      AVR32_OPC_SUB3, 2, 0x20000000, 0xf0000000,

 24435 +      &avr32_syntax_table[AVR32_SYNTAX_SUB3],

 24436 +      BFD_RELOC_AVR32_8S, 2, 1,

 24437 +      {

 24438 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24439 +	&avr32_ifield_table[AVR32_IFIELD_K8C],

 24440 +      },

 24441 +    },

 24442 +    {

 24443 +      AVR32_OPC_SUB4, 4, 0xe0200000, 0xe1e00000,

 24444 +      &avr32_syntax_table[AVR32_SYNTAX_SUB4],

 24445 +      BFD_RELOC_AVR32_21S, 2, 1,

 24446 +      {

 24447 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24448 +	&avr32_ifield_table[AVR32_IFIELD_K21],

 24449 +      },

 24450 +    },

 24451 +    {

 24452 +      AVR32_OPC_SUBEQ, 4, 0xf7b00000, 0xfff0ff00,

 24453 +      &avr32_syntax_table[AVR32_SYNTAX_SUBEQ],

 24454 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24455 +      {

 24456 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24457 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24458 +      },

 24459 +    },

 24460 +    {

 24461 +      AVR32_OPC_SUBNE, 4, 0xf7b00100, 0xfff0ff00,

 24462 +      &avr32_syntax_table[AVR32_SYNTAX_SUBNE],

 24463 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24464 +      {

 24465 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24466 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24467 +      },

 24468 +    },

 24469 +    {

 24470 +      AVR32_OPC_SUBCC, 4, 0xf7b00200, 0xfff0ff00,

 24471 +      &avr32_syntax_table[AVR32_SYNTAX_SUBHS],

 24472 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24473 +      {

 24474 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24475 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24476 +      },

 24477 +    },

 24478 +    {

 24479 +      AVR32_OPC_SUBCS, 4, 0xf7b00300, 0xfff0ff00,

 24480 +      &avr32_syntax_table[AVR32_SYNTAX_SUBLO],

 24481 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24482 +      {

 24483 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24484 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24485 +      },

 24486 +    },

 24487 +    {

 24488 +      AVR32_OPC_SUBGE, 4, 0xf7b00400, 0xfff0ff00,

 24489 +      &avr32_syntax_table[AVR32_SYNTAX_SUBGE],

 24490 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24491 +      {

 24492 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24493 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24494 +      },

 24495 +    },

 24496 +    {

 24497 +      AVR32_OPC_SUBLT, 4, 0xf7b00500, 0xfff0ff00,

 24498 +      &avr32_syntax_table[AVR32_SYNTAX_SUBLT],

 24499 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24500 +      {

 24501 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24502 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24503 +      },

 24504 +    },

 24505 +    {

 24506 +      AVR32_OPC_SUBMI, 4, 0xf7b00600, 0xfff0ff00,

 24507 +      &avr32_syntax_table[AVR32_SYNTAX_SUBMI],

 24508 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24509 +      {

 24510 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24511 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24512 +      },

 24513 +    },

 24514 +    {

 24515 +      AVR32_OPC_SUBPL, 4, 0xf7b00700, 0xfff0ff00,

 24516 +      &avr32_syntax_table[AVR32_SYNTAX_SUBPL],

 24517 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24518 +      {

 24519 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24520 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24521 +      },

 24522 +    },

 24523 +    {

 24524 +      AVR32_OPC_SUBLS, 4, 0xf7b00800, 0xfff0ff00,

 24525 +      &avr32_syntax_table[AVR32_SYNTAX_SUBLS],

 24526 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24527 +      {

 24528 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24529 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24530 +      },

 24531 +    },

 24532 +    {

 24533 +      AVR32_OPC_SUBGT, 4, 0xf7b00900, 0xfff0ff00,

 24534 +      &avr32_syntax_table[AVR32_SYNTAX_SUBGT],

 24535 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24536 +      {

 24537 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24538 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24539 +      },

 24540 +    },

 24541 +    {

 24542 +      AVR32_OPC_SUBLE, 4, 0xf7b00a00, 0xfff0ff00,

 24543 +      &avr32_syntax_table[AVR32_SYNTAX_SUBLE],

 24544 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24545 +      {

 24546 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24547 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24548 +      },

 24549 +    },

 24550 +    {

 24551 +      AVR32_OPC_SUBHI, 4, 0xf7b00b00, 0xfff0ff00,

 24552 +      &avr32_syntax_table[AVR32_SYNTAX_SUBHI],

 24553 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24554 +      {

 24555 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24556 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24557 +      },

 24558 +    },

 24559 +    {

 24560 +      AVR32_OPC_SUBVS, 4, 0xf7b00c00, 0xfff0ff00,

 24561 +      &avr32_syntax_table[AVR32_SYNTAX_SUBVS],

 24562 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24563 +      {

 24564 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24565 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24566 +      },

 24567 +    },

 24568 +    {

 24569 +      AVR32_OPC_SUBVC, 4, 0xf7b00d00, 0xfff0ff00,

 24570 +      &avr32_syntax_table[AVR32_SYNTAX_SUBVC],

 24571 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24572 +      {

 24573 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24574 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24575 +      },

 24576 +    },

 24577 +    {

 24578 +      AVR32_OPC_SUBQS, 4, 0xf7b00e00, 0xfff0ff00,

 24579 +      &avr32_syntax_table[AVR32_SYNTAX_SUBQS],

 24580 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24581 +      {

 24582 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24583 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24584 +      },

 24585 +    },

 24586 +    {

 24587 +      AVR32_OPC_SUBAL, 4, 0xf7b00f00, 0xfff0ff00,

 24588 +      &avr32_syntax_table[AVR32_SYNTAX_SUBAL],

 24589 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24590 +      {

 24591 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24592 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24593 +      },

 24594 +    },

 24595 +    {

 24596 +      AVR32_OPC_SUBFEQ, 4, 0xf5b00000, 0xfff0ff00,

 24597 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFEQ],

 24598 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24599 +      {

 24600 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24601 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24602 +      },

 24603 +    },

 24604 +    {

 24605 +      AVR32_OPC_SUBFNE, 4, 0xf5b00100, 0xfff0ff00,

 24606 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFNE],

 24607 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24608 +      {

 24609 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24610 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24611 +      },

 24612 +    },

 24613 +    {

 24614 +      AVR32_OPC_SUBFCC, 4, 0xf5b00200, 0xfff0ff00,

 24615 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFHS],

 24616 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24617 +      {

 24618 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24619 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24620 +      },

 24621 +    },

 24622 +    {

 24623 +      AVR32_OPC_SUBFCS, 4, 0xf5b00300, 0xfff0ff00,

 24624 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFLO],

 24625 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24626 +      {

 24627 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24628 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24629 +      },

 24630 +    },

 24631 +    {

 24632 +      AVR32_OPC_SUBFGE, 4, 0xf5b00400, 0xfff0ff00,

 24633 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFGE],

 24634 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24635 +      {

 24636 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24637 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24638 +      },

 24639 +    },

 24640 +    {

 24641 +      AVR32_OPC_SUBFLT, 4, 0xf5b00500, 0xfff0ff00,

 24642 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFLT],

 24643 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24644 +      {

 24645 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24646 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24647 +      },

 24648 +    },

 24649 +    {

 24650 +      AVR32_OPC_SUBFMI, 4, 0xf5b00600, 0xfff0ff00,

 24651 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFMI],

 24652 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24653 +      {

 24654 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24655 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24656 +      },

 24657 +    },

 24658 +    {

 24659 +      AVR32_OPC_SUBFPL, 4, 0xf5b00700, 0xfff0ff00,

 24660 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFPL],

 24661 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24662 +      {

 24663 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24664 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24665 +      },

 24666 +    },

 24667 +    {

 24668 +      AVR32_OPC_SUBFLS, 4, 0xf5b00800, 0xfff0ff00,

 24669 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFLS],

 24670 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24671 +      {

 24672 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24673 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24674 +      },

 24675 +    },

 24676 +    {

 24677 +      AVR32_OPC_SUBFGT, 4, 0xf5b00900, 0xfff0ff00,

 24678 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFGT],

 24679 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24680 +      {

 24681 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24682 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24683 +      },

 24684 +    },

 24685 +    {

 24686 +      AVR32_OPC_SUBFLE, 4, 0xf5b00a00, 0xfff0ff00,

 24687 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFLE],

 24688 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24689 +      {

 24690 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24691 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24692 +      },

 24693 +    },

 24694 +    {

 24695 +      AVR32_OPC_SUBFHI, 4, 0xf5b00b00, 0xfff0ff00,

 24696 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFHI],

 24697 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24698 +      {

 24699 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24700 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24701 +      },

 24702 +    },

 24703 +    {

 24704 +      AVR32_OPC_SUBFVS, 4, 0xf5b00c00, 0xfff0ff00,

 24705 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFVS],

 24706 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24707 +      {

 24708 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24709 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24710 +      },

 24711 +    },

 24712 +    {

 24713 +      AVR32_OPC_SUBFVC, 4, 0xf5b00d00, 0xfff0ff00,

 24714 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFVC],

 24715 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24716 +      {

 24717 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24718 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24719 +      },

 24720 +    },

 24721 +    {

 24722 +      AVR32_OPC_SUBFQS, 4, 0xf5b00e00, 0xfff0ff00,

 24723 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFQS],

 24724 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24725 +      {

 24726 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24727 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24728 +      },

 24729 +    },

 24730 +    {

 24731 +      AVR32_OPC_SUBFAL, 4, 0xf5b00f00, 0xfff0ff00,

 24732 +      &avr32_syntax_table[AVR32_SYNTAX_SUBFAL],

 24733 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,

 24734 +      {

 24735 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24736 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24737 +      },

 24738 +    },

 24739 +    {

 24740 +      AVR32_OPC_SUBHH_W, 4, 0xe0000f00, 0xe1f0ffc0,

 24741 +      &avr32_syntax_table[AVR32_SYNTAX_SUBHH_W],

 24742 +      BFD_RELOC_UNUSED, 5, -1,

 24743 +      {

 24744 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 24745 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24746 +	&avr32_ifield_table[AVR32_IFIELD_X],

 24747 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24748 +	&avr32_ifield_table[AVR32_IFIELD_Y],

 24749 +      },

 24750 +    },

 24751 +    {

 24752 +      AVR32_OPC_SWAP_B, 2, 0x5cb00000, 0xfff00000,

 24753 +      &avr32_syntax_table[AVR32_SYNTAX_SWAP_B],

 24754 +      BFD_RELOC_UNUSED, 1, -1,

 24755 +      {

 24756 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24757 +      }

 24758 +    },

 24759 +    {

 24760 +      AVR32_OPC_SWAP_BH, 2, 0x5cc00000, 0xfff00000,

 24761 +      &avr32_syntax_table[AVR32_SYNTAX_SWAP_BH],

 24762 +      BFD_RELOC_UNUSED, 1, -1,

 24763 +      {

 24764 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24765 +      }

 24766 +    },

 24767 +    {

 24768 +      AVR32_OPC_SWAP_H, 2, 0x5ca00000, 0xfff00000,

 24769 +      &avr32_syntax_table[AVR32_SYNTAX_SWAP_H],

 24770 +      BFD_RELOC_UNUSED, 1, -1,

 24771 +      {

 24772 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24773 +      }

 24774 +    },

 24775 +    {

 24776 +      AVR32_OPC_SYNC, 4, 0xebb00000, 0xffffff00,

 24777 +      &avr32_syntax_table[AVR32_SYNTAX_SYNC],

 24778 +      BFD_RELOC_AVR32_8S_EXT, 1, 0,

 24779 +      {

 24780 +	&avr32_ifield_table[AVR32_IFIELD_K8E],

 24781 +      }

 24782 +    },

 24783 +    {

 24784 +      AVR32_OPC_TLBR, 2, 0xd6430000, 0xffff0000,

 24785 +      &avr32_syntax_table[AVR32_SYNTAX_TLBR],

 24786 +      BFD_RELOC_UNUSED, 0, -1, { NULL },

 24787 +    },

 24788 +    {

 24789 +      AVR32_OPC_TLBS, 2, 0xd6530000, 0xffff0000,

 24790 +      &avr32_syntax_table[AVR32_SYNTAX_TLBS],

 24791 +      BFD_RELOC_UNUSED, 0, -1, { NULL },

 24792 +    },

 24793 +    {

 24794 +      AVR32_OPC_TLBW, 2, 0xd6630000, 0xffff0000,

 24795 +      &avr32_syntax_table[AVR32_SYNTAX_TLBW],

 24796 +      BFD_RELOC_UNUSED, 0, -1, { NULL },

 24797 +    },

 24798 +    {

 24799 +      AVR32_OPC_TNBZ, 2, 0x5ce00000, 0xfff00000,

 24800 +      &avr32_syntax_table[AVR32_SYNTAX_TNBZ],

 24801 +      BFD_RELOC_UNUSED, 1, -1,

 24802 +      {

 24803 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24804 +      }

 24805 +    },

 24806 +    {

 24807 +      AVR32_OPC_TST, 2, 0x00700000, 0xe1f00000,

 24808 +      &avr32_syntax_table[AVR32_SYNTAX_TST],

 24809 +      BFD_RELOC_UNUSED, 2, -1,

 24810 +      {

 24811 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24812 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24813 +      },

 24814 +    },

 24815 +    {

 24816 +      AVR32_OPC_XCHG, 4, 0xe0000b40, 0xe1f0fff0,

 24817 +      &avr32_syntax_table[AVR32_SYNTAX_XCHG],

 24818 +      BFD_RELOC_UNUSED, 3, -1,

 24819 +      {

 24820 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],

 24821 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24822 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24823 +      },

 24824 +    },

 24825 +    {

 24826 +      AVR32_OPC_MEMC, 4, 0xf6100000, 0xfff00000,

 24827 +      &avr32_syntax_table[AVR32_SYNTAX_MEMC],

 24828 +      BFD_RELOC_AVR32_15S, 2, 0,

 24829 +      {

 24830 +	&avr32_ifield_table[AVR32_IFIELD_MEM15],

 24831 +	&avr32_ifield_table[AVR32_IFIELD_MEMB5],

 24832 +      },

 24833 +    },

 24834 +    {

 24835 +      AVR32_OPC_MEMS, 4, 0xf8100000, 0xfff00000,

 24836 +      &avr32_syntax_table[AVR32_SYNTAX_MEMS],

 24837 +      BFD_RELOC_AVR32_15S, 2, 0,

 24838 +      {

 24839 +	&avr32_ifield_table[AVR32_IFIELD_MEM15],

 24840 +	&avr32_ifield_table[AVR32_IFIELD_MEMB5],

 24841 +      },

 24842 +    },

 24843 +    {

 24844 +      AVR32_OPC_MEMT, 4, 0xfa100000, 0xfff00000,

 24845 +      &avr32_syntax_table[AVR32_SYNTAX_MEMT],

 24846 +      BFD_RELOC_AVR32_15S, 2, 0,

 24847 +      {

 24848 +	&avr32_ifield_table[AVR32_IFIELD_MEM15],

 24849 +	&avr32_ifield_table[AVR32_IFIELD_MEMB5],

 24850 +      },

 24851 +    },

 24852 +    {

 24853 +      AVR32_OPC_BFEXTS, 4, 0xe1d0b000, 0xe1f0fc00,

 24854 +      &avr32_syntax_table[AVR32_SYNTAX_BFEXTS],

 24855 +      BFD_RELOC_UNUSED, 4, -1,

 24856 +      {

 24857 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24858 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24859 +	&avr32_ifield_table[AVR32_IFIELD_S5],

 24860 +	&avr32_ifield_table[AVR32_IFIELD_K5E],

 24861 +      },

 24862 +    },

 24863 +    {

 24864 +      AVR32_OPC_BFEXTU, 4, 0xe1d0c000, 0xe1f0fc00,

 24865 +      &avr32_syntax_table[AVR32_SYNTAX_BFEXTU],

 24866 +      BFD_RELOC_UNUSED, 4, -1,

 24867 +      {

 24868 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24869 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24870 +	&avr32_ifield_table[AVR32_IFIELD_S5],

 24871 +	&avr32_ifield_table[AVR32_IFIELD_K5E],

 24872 +      },

 24873 +    },

 24874 +    {

 24875 +      AVR32_OPC_BFINS, 4, 0xe1d0d000, 0xe1f0fc00,

 24876 +      &avr32_syntax_table[AVR32_SYNTAX_BFINS],

 24877 +      BFD_RELOC_UNUSED, 4, -1,

 24878 +      {

 24879 +	&avr32_ifield_table[AVR32_IFIELD_RX],

 24880 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 24881 +	&avr32_ifield_table[AVR32_IFIELD_S5],

 24882 +	&avr32_ifield_table[AVR32_IFIELD_K5E],

 24883 +      },

 24884 +    },

 24885 +#define AVR32_OPCODE_RSUBCOND(cond_name, cond_field)                    \

 24886 +    {                                                                   \

 24887 +      AVR32_OPC_RSUB ## cond_name , 4,                                  \

 24888 +      0xfbb00000 | (cond_field << 8), 0xfff0ff00,                       \

 24889 +      &avr32_syntax_table[AVR32_SYNTAX_RSUB ## cond_name ],             \

 24890 +      BFD_RELOC_AVR32_8S_EXT, 2, 1,                                     \

 24891 +      {                                                                 \

 24892 +	&avr32_ifield_table[AVR32_IFIELD_RY],                           \

 24893 +	&avr32_ifield_table[AVR32_IFIELD_K8E],                          \

 24894 +      },                                                                \

 24895 +    },

 24896 +

 24897 +    AVR32_OPCODE_RSUBCOND (EQ, 0)

 24898 +    AVR32_OPCODE_RSUBCOND (NE, 1)

 24899 +    AVR32_OPCODE_RSUBCOND (CC, 2)

 24900 +    AVR32_OPCODE_RSUBCOND (CS, 3)

 24901 +    AVR32_OPCODE_RSUBCOND (GE, 4)

 24902 +    AVR32_OPCODE_RSUBCOND (LT, 5)

 24903 +    AVR32_OPCODE_RSUBCOND (MI, 6)

 24904 +    AVR32_OPCODE_RSUBCOND (PL, 7)

 24905 +    AVR32_OPCODE_RSUBCOND (LS, 8)

 24906 +    AVR32_OPCODE_RSUBCOND (GT, 9)

 24907 +    AVR32_OPCODE_RSUBCOND (LE, 10)

 24908 +    AVR32_OPCODE_RSUBCOND (HI, 11)

 24909 +    AVR32_OPCODE_RSUBCOND (VS, 12)

 24910 +    AVR32_OPCODE_RSUBCOND (VC, 13)

 24911 +    AVR32_OPCODE_RSUBCOND (QS, 14)

 24912 +    AVR32_OPCODE_RSUBCOND (AL, 15)

 24913 +

 24914 +#define AVR32_OPCODE_OP3_COND(op_name, op_field, cond_name, cond_field) \

 24915 +    {                                                                   \

 24916 +      AVR32_OPC_ ## op_name ## cond_name , 4,                           \

 24917 +      0xe1d0e000 | (cond_field << 8) | (op_field << 4), 0xe1f0fff0,     \

 24918 +      &avr32_syntax_table[AVR32_SYNTAX_ ## op_name ## cond_name ],      \

 24919 +      BFD_RELOC_UNUSED, 3, -1,                                          \

 24920 +      {                                                                 \

 24921 +	&avr32_ifield_table[AVR32_IFIELD_RD_E],                         \

 24922 +	&avr32_ifield_table[AVR32_IFIELD_RX],                           \

 24923 +	&avr32_ifield_table[AVR32_IFIELD_RY],                           \

 24924 +      },                                                                \

 24925 +    },

 24926 +

 24927 +    AVR32_OPCODE_OP3_COND (ADD, 0, EQ, 0)

 24928 +    AVR32_OPCODE_OP3_COND (ADD, 0, NE, 1)

 24929 +    AVR32_OPCODE_OP3_COND (ADD, 0, CC, 2)

 24930 +    AVR32_OPCODE_OP3_COND (ADD, 0, CS, 3)

 24931 +    AVR32_OPCODE_OP3_COND (ADD, 0, GE, 4)

 24932 +    AVR32_OPCODE_OP3_COND (ADD, 0, LT, 5)

 24933 +    AVR32_OPCODE_OP3_COND (ADD, 0, MI, 6)

 24934 +    AVR32_OPCODE_OP3_COND (ADD, 0, PL, 7)

 24935 +    AVR32_OPCODE_OP3_COND (ADD, 0, LS, 8)

 24936 +    AVR32_OPCODE_OP3_COND (ADD, 0, GT, 9)

 24937 +    AVR32_OPCODE_OP3_COND (ADD, 0, LE, 10)

 24938 +    AVR32_OPCODE_OP3_COND (ADD, 0, HI, 11)

 24939 +    AVR32_OPCODE_OP3_COND (ADD, 0, VS, 12)

 24940 +    AVR32_OPCODE_OP3_COND (ADD, 0, VC, 13)

 24941 +    AVR32_OPCODE_OP3_COND (ADD, 0, QS, 14)

 24942 +    AVR32_OPCODE_OP3_COND (ADD, 0, AL, 15)

 24943 +

 24944 +    AVR32_OPCODE_OP3_COND (SUB2, 1, EQ, 0)

 24945 +    AVR32_OPCODE_OP3_COND (SUB2, 1, NE, 1)

 24946 +    AVR32_OPCODE_OP3_COND (SUB2, 1, CC, 2)

 24947 +    AVR32_OPCODE_OP3_COND (SUB2, 1, CS, 3)

 24948 +    AVR32_OPCODE_OP3_COND (SUB2, 1, GE, 4)

 24949 +    AVR32_OPCODE_OP3_COND (SUB2, 1, LT, 5)

 24950 +    AVR32_OPCODE_OP3_COND (SUB2, 1, MI, 6)

 24951 +    AVR32_OPCODE_OP3_COND (SUB2, 1, PL, 7)

 24952 +    AVR32_OPCODE_OP3_COND (SUB2, 1, LS, 8)

 24953 +    AVR32_OPCODE_OP3_COND (SUB2, 1, GT, 9)

 24954 +    AVR32_OPCODE_OP3_COND (SUB2, 1, LE, 10)

 24955 +    AVR32_OPCODE_OP3_COND (SUB2, 1, HI, 11)

 24956 +    AVR32_OPCODE_OP3_COND (SUB2, 1, VS, 12)

 24957 +    AVR32_OPCODE_OP3_COND (SUB2, 1, VC, 13)

 24958 +    AVR32_OPCODE_OP3_COND (SUB2, 1, QS, 14)

 24959 +    AVR32_OPCODE_OP3_COND (SUB2, 1, AL, 15)

 24960 +

 24961 +    AVR32_OPCODE_OP3_COND (AND, 2, EQ, 0)

 24962 +    AVR32_OPCODE_OP3_COND (AND, 2, NE, 1)

 24963 +    AVR32_OPCODE_OP3_COND (AND, 2, CC, 2)

 24964 +    AVR32_OPCODE_OP3_COND (AND, 2, CS, 3)

 24965 +    AVR32_OPCODE_OP3_COND (AND, 2, GE, 4)

 24966 +    AVR32_OPCODE_OP3_COND (AND, 2, LT, 5)

 24967 +    AVR32_OPCODE_OP3_COND (AND, 2, MI, 6)

 24968 +    AVR32_OPCODE_OP3_COND (AND, 2, PL, 7)

 24969 +    AVR32_OPCODE_OP3_COND (AND, 2, LS, 8)

 24970 +    AVR32_OPCODE_OP3_COND (AND, 2, GT, 9)

 24971 +    AVR32_OPCODE_OP3_COND (AND, 2, LE, 10)

 24972 +    AVR32_OPCODE_OP3_COND (AND, 2, HI, 11)

 24973 +    AVR32_OPCODE_OP3_COND (AND, 2, VS, 12)

 24974 +    AVR32_OPCODE_OP3_COND (AND, 2, VC, 13)

 24975 +    AVR32_OPCODE_OP3_COND (AND, 2, QS, 14)

 24976 +    AVR32_OPCODE_OP3_COND (AND, 2, AL, 15)

 24977 +

 24978 +    AVR32_OPCODE_OP3_COND (OR, 3, EQ, 0)

 24979 +    AVR32_OPCODE_OP3_COND (OR, 3, NE, 1)

 24980 +    AVR32_OPCODE_OP3_COND (OR, 3, CC, 2)

 24981 +    AVR32_OPCODE_OP3_COND (OR, 3, CS, 3)

 24982 +    AVR32_OPCODE_OP3_COND (OR, 3, GE, 4)

 24983 +    AVR32_OPCODE_OP3_COND (OR, 3, LT, 5)

 24984 +    AVR32_OPCODE_OP3_COND (OR, 3, MI, 6)

 24985 +    AVR32_OPCODE_OP3_COND (OR, 3, PL, 7)

 24986 +    AVR32_OPCODE_OP3_COND (OR, 3, LS, 8)

 24987 +    AVR32_OPCODE_OP3_COND (OR, 3, GT, 9)

 24988 +    AVR32_OPCODE_OP3_COND (OR, 3, LE, 10)

 24989 +    AVR32_OPCODE_OP3_COND (OR, 3, HI, 11)

 24990 +    AVR32_OPCODE_OP3_COND (OR, 3, VS, 12)

 24991 +    AVR32_OPCODE_OP3_COND (OR, 3, VC, 13)

 24992 +    AVR32_OPCODE_OP3_COND (OR, 3, QS, 14)

 24993 +    AVR32_OPCODE_OP3_COND (OR, 3, AL, 15)

 24994 +

 24995 +    AVR32_OPCODE_OP3_COND (EOR, 4, EQ, 0)

 24996 +    AVR32_OPCODE_OP3_COND (EOR, 4, NE, 1)

 24997 +    AVR32_OPCODE_OP3_COND (EOR, 4, CC, 2)

 24998 +    AVR32_OPCODE_OP3_COND (EOR, 4, CS, 3)

 24999 +    AVR32_OPCODE_OP3_COND (EOR, 4, GE, 4)

 25000 +    AVR32_OPCODE_OP3_COND (EOR, 4, LT, 5)

 25001 +    AVR32_OPCODE_OP3_COND (EOR, 4, MI, 6)

 25002 +    AVR32_OPCODE_OP3_COND (EOR, 4, PL, 7)

 25003 +    AVR32_OPCODE_OP3_COND (EOR, 4, LS, 8)

 25004 +    AVR32_OPCODE_OP3_COND (EOR, 4, GT, 9)

 25005 +    AVR32_OPCODE_OP3_COND (EOR, 4, LE, 10)

 25006 +    AVR32_OPCODE_OP3_COND (EOR, 4, HI, 11)

 25007 +    AVR32_OPCODE_OP3_COND (EOR, 4, VS, 12)

 25008 +    AVR32_OPCODE_OP3_COND (EOR, 4, VC, 13)

 25009 +    AVR32_OPCODE_OP3_COND (EOR, 4, QS, 14)

 25010 +    AVR32_OPCODE_OP3_COND (EOR, 4, AL, 15)

 25011 +

 25012 +#define AVR32_OPCODE_LD_COND(op_name, op_field, cond_name, cond_field)  \

 25013 +    {                                                                   \

 25014 +      AVR32_OPC_ ## op_name ## cond_name , 4,                           \

 25015 +      0xe1f00000 | (cond_field << 12) | (op_field  << 9), 0xe1f0fe00,   \

 25016 +      &avr32_syntax_table[AVR32_SYNTAX_ ## op_name ## cond_name ],      \

 25017 +      BFD_RELOC_UNUSED, 3, -1,                                          \

 25018 +      {                                                                 \

 25019 +	&avr32_ifield_table[AVR32_IFIELD_RY],                           \

 25020 +	&avr32_ifield_table[AVR32_IFIELD_RX],                           \

 25021 +	&avr32_ifield_table[AVR32_IFIELD_K9E],                          \

 25022 +      },                                                                \

 25023 +    },

 25024 +

 25025 +#define AVR32_OPCODE_ST_COND(op_name, op_field, cond_name, cond_field)  \

 25026 +    {                                                                   \

 25027 +      AVR32_OPC_ ## op_name ## cond_name , 4,                           \

 25028 +      0xe1f00000 | (cond_field << 12) | (op_field  << 9), 0xe1f0fe00,   \

 25029 +      &avr32_syntax_table[AVR32_SYNTAX_ ## op_name ## cond_name ],      \

 25030 +      BFD_RELOC_UNUSED, 3, -1,                                          \

 25031 +      {                                                                 \

 25032 +	&avr32_ifield_table[AVR32_IFIELD_RX],                           \

 25033 +	&avr32_ifield_table[AVR32_IFIELD_K9E],                          \

 25034 +	&avr32_ifield_table[AVR32_IFIELD_RY],                           \

 25035 +      },                                                                \

 25036 +    },

 25037 +

 25038 +    AVR32_OPCODE_LD_COND (LD_W, 0, EQ, 0)

 25039 +    AVR32_OPCODE_LD_COND (LD_W, 0, NE, 1)

 25040 +    AVR32_OPCODE_LD_COND (LD_W, 0, CC, 2)

 25041 +    AVR32_OPCODE_LD_COND (LD_W, 0, CS, 3)

 25042 +    AVR32_OPCODE_LD_COND (LD_W, 0, GE, 4)

 25043 +    AVR32_OPCODE_LD_COND (LD_W, 0, LT, 5)

 25044 +    AVR32_OPCODE_LD_COND (LD_W, 0, MI, 6)

 25045 +    AVR32_OPCODE_LD_COND (LD_W, 0, PL, 7)

 25046 +    AVR32_OPCODE_LD_COND (LD_W, 0, LS, 8)

 25047 +    AVR32_OPCODE_LD_COND (LD_W, 0, GT, 9)

 25048 +    AVR32_OPCODE_LD_COND (LD_W, 0, LE, 10)

 25049 +    AVR32_OPCODE_LD_COND (LD_W, 0, HI, 11)

 25050 +    AVR32_OPCODE_LD_COND (LD_W, 0, VS, 12)

 25051 +    AVR32_OPCODE_LD_COND (LD_W, 0, VC, 13)

 25052 +    AVR32_OPCODE_LD_COND (LD_W, 0, QS, 14)

 25053 +    AVR32_OPCODE_LD_COND (LD_W, 0, AL, 15)

 25054 +

 25055 +    AVR32_OPCODE_LD_COND (LD_SH, 1, EQ, 0)

 25056 +    AVR32_OPCODE_LD_COND (LD_SH, 1, NE, 1)

 25057 +    AVR32_OPCODE_LD_COND (LD_SH, 1, CC, 2)

 25058 +    AVR32_OPCODE_LD_COND (LD_SH, 1, CS, 3)

 25059 +    AVR32_OPCODE_LD_COND (LD_SH, 1, GE, 4)

 25060 +    AVR32_OPCODE_LD_COND (LD_SH, 1, LT, 5)

 25061 +    AVR32_OPCODE_LD_COND (LD_SH, 1, MI, 6)

 25062 +    AVR32_OPCODE_LD_COND (LD_SH, 1, PL, 7)

 25063 +    AVR32_OPCODE_LD_COND (LD_SH, 1, LS, 8)

 25064 +    AVR32_OPCODE_LD_COND (LD_SH, 1, GT, 9)

 25065 +    AVR32_OPCODE_LD_COND (LD_SH, 1, LE, 10)

 25066 +    AVR32_OPCODE_LD_COND (LD_SH, 1, HI, 11)

 25067 +    AVR32_OPCODE_LD_COND (LD_SH, 1, VS, 12)

 25068 +    AVR32_OPCODE_LD_COND (LD_SH, 1, VC, 13)

 25069 +    AVR32_OPCODE_LD_COND (LD_SH, 1, QS, 14)

 25070 +    AVR32_OPCODE_LD_COND (LD_SH, 1, AL, 15)

 25071 +

 25072 +    AVR32_OPCODE_LD_COND (LD_UH, 2, EQ, 0)

 25073 +    AVR32_OPCODE_LD_COND (LD_UH, 2, NE, 1)

 25074 +    AVR32_OPCODE_LD_COND (LD_UH, 2, CC, 2)

 25075 +    AVR32_OPCODE_LD_COND (LD_UH, 2, CS, 3)

 25076 +    AVR32_OPCODE_LD_COND (LD_UH, 2, GE, 4)

 25077 +    AVR32_OPCODE_LD_COND (LD_UH, 2, LT, 5)

 25078 +    AVR32_OPCODE_LD_COND (LD_UH, 2, MI, 6)

 25079 +    AVR32_OPCODE_LD_COND (LD_UH, 2, PL, 7)

 25080 +    AVR32_OPCODE_LD_COND (LD_SH, 2, LS, 8)

 25081 +    AVR32_OPCODE_LD_COND (LD_SH, 2, GT, 9)

 25082 +    AVR32_OPCODE_LD_COND (LD_SH, 2, LE, 10)

 25083 +    AVR32_OPCODE_LD_COND (LD_SH, 2, HI, 11)

 25084 +    AVR32_OPCODE_LD_COND (LD_SH, 2, VS, 12)

 25085 +    AVR32_OPCODE_LD_COND (LD_SH, 2, VC, 13)

 25086 +    AVR32_OPCODE_LD_COND (LD_SH, 2, QS, 14)

 25087 +    AVR32_OPCODE_LD_COND (LD_SH, 2, AL, 15)

 25088 +

 25089 +    AVR32_OPCODE_LD_COND (LD_SB, 3, EQ, 0)

 25090 +    AVR32_OPCODE_LD_COND (LD_SB, 3, NE, 1)

 25091 +    AVR32_OPCODE_LD_COND (LD_SB, 3, CC, 2)

 25092 +    AVR32_OPCODE_LD_COND (LD_SB, 3, CS, 3)

 25093 +    AVR32_OPCODE_LD_COND (LD_SB, 3, GE, 4)

 25094 +    AVR32_OPCODE_LD_COND (LD_SB, 3, LT, 5)

 25095 +    AVR32_OPCODE_LD_COND (LD_SB, 3, MI, 6)

 25096 +    AVR32_OPCODE_LD_COND (LD_SB, 3, PL, 7)

 25097 +    AVR32_OPCODE_LD_COND (LD_SB, 3, LS, 8)

 25098 +    AVR32_OPCODE_LD_COND (LD_SB, 3, GT, 9)

 25099 +    AVR32_OPCODE_LD_COND (LD_SB, 3, LE, 10)

 25100 +    AVR32_OPCODE_LD_COND (LD_SB, 3, HI, 11)

 25101 +    AVR32_OPCODE_LD_COND (LD_SB, 3, VS, 12)

 25102 +    AVR32_OPCODE_LD_COND (LD_SB, 3, VC, 13)

 25103 +    AVR32_OPCODE_LD_COND (LD_SB, 3, QS, 14)

 25104 +    AVR32_OPCODE_LD_COND (LD_SB, 3, AL, 15)

 25105 +

 25106 +    AVR32_OPCODE_LD_COND (LD_UB, 4, EQ, 0)

 25107 +    AVR32_OPCODE_LD_COND (LD_UB, 4, NE, 1)

 25108 +    AVR32_OPCODE_LD_COND (LD_UB, 4, CC, 2)

 25109 +    AVR32_OPCODE_LD_COND (LD_UB, 4, CS, 3)

 25110 +    AVR32_OPCODE_LD_COND (LD_UB, 4, GE, 4)

 25111 +    AVR32_OPCODE_LD_COND (LD_UB, 4, LT, 5)

 25112 +    AVR32_OPCODE_LD_COND (LD_UB, 4, MI, 6)

 25113 +    AVR32_OPCODE_LD_COND (LD_UB, 4, PL, 7)

 25114 +    AVR32_OPCODE_LD_COND (LD_UB, 4, LS, 8)

 25115 +    AVR32_OPCODE_LD_COND (LD_UB, 4, GT, 9)

 25116 +    AVR32_OPCODE_LD_COND (LD_UB, 4, LE, 10)

 25117 +    AVR32_OPCODE_LD_COND (LD_UB, 4, HI, 11)

 25118 +    AVR32_OPCODE_LD_COND (LD_UB, 4, VS, 12)

 25119 +    AVR32_OPCODE_LD_COND (LD_UB, 4, VC, 13)

 25120 +    AVR32_OPCODE_LD_COND (LD_UB, 4, QS, 14)

 25121 +    AVR32_OPCODE_LD_COND (LD_UB, 4, AL, 15)

 25122 +

 25123 +    AVR32_OPCODE_ST_COND (ST_W, 5, EQ, 0)

 25124 +    AVR32_OPCODE_ST_COND (ST_W, 5, NE, 1)

 25125 +    AVR32_OPCODE_ST_COND (ST_W, 5, CC, 2)

 25126 +    AVR32_OPCODE_ST_COND (ST_W, 5, CS, 3)

 25127 +    AVR32_OPCODE_ST_COND (ST_W, 5, GE, 4)

 25128 +    AVR32_OPCODE_ST_COND (ST_W, 5, LT, 5)

 25129 +    AVR32_OPCODE_ST_COND (ST_W, 5, MI, 6)

 25130 +    AVR32_OPCODE_ST_COND (ST_W, 5, PL, 7)

 25131 +    AVR32_OPCODE_ST_COND (ST_W, 5, LS, 8)

 25132 +    AVR32_OPCODE_ST_COND (ST_W, 5, GT, 9)

 25133 +    AVR32_OPCODE_ST_COND (ST_W, 5, LE, 10)

 25134 +    AVR32_OPCODE_ST_COND (ST_W, 5, HI, 11)

 25135 +    AVR32_OPCODE_ST_COND (ST_W, 5, VS, 12)

 25136 +    AVR32_OPCODE_ST_COND (ST_W, 5, VC, 13)

 25137 +    AVR32_OPCODE_ST_COND (ST_W, 5, QS, 14)

 25138 +    AVR32_OPCODE_ST_COND (ST_W, 5, AL, 15)

 25139 +

 25140 +    AVR32_OPCODE_ST_COND (ST_H, 6, EQ, 0)

 25141 +    AVR32_OPCODE_ST_COND (ST_H, 6, NE, 1)

 25142 +    AVR32_OPCODE_ST_COND (ST_H, 6, CC, 2)

 25143 +    AVR32_OPCODE_ST_COND (ST_H, 6, CS, 3)

 25144 +    AVR32_OPCODE_ST_COND (ST_H, 6, GE, 4)

 25145 +    AVR32_OPCODE_ST_COND (ST_H, 6, LT, 5)

 25146 +    AVR32_OPCODE_ST_COND (ST_H, 6, MI, 6)

 25147 +    AVR32_OPCODE_ST_COND (ST_H, 6, PL, 7)

 25148 +    AVR32_OPCODE_ST_COND (ST_H, 6, LS, 8)

 25149 +    AVR32_OPCODE_ST_COND (ST_H, 6, GT, 9)

 25150 +    AVR32_OPCODE_ST_COND (ST_H, 6, LE, 10)

 25151 +    AVR32_OPCODE_ST_COND (ST_H, 6, HI, 11)

 25152 +    AVR32_OPCODE_ST_COND (ST_H, 6, VS, 12)

 25153 +    AVR32_OPCODE_ST_COND (ST_H, 6, VC, 13)

 25154 +    AVR32_OPCODE_ST_COND (ST_H, 6, QS, 14)

 25155 +    AVR32_OPCODE_ST_COND (ST_H, 6, AL, 15)

 25156 +

 25157 +    AVR32_OPCODE_ST_COND (ST_B, 7, EQ, 0)

 25158 +    AVR32_OPCODE_ST_COND (ST_B, 7, NE, 1)

 25159 +    AVR32_OPCODE_ST_COND (ST_B, 7, CC, 2)

 25160 +    AVR32_OPCODE_ST_COND (ST_B, 7, CS, 3)

 25161 +    AVR32_OPCODE_ST_COND (ST_B, 7, GE, 4)

 25162 +    AVR32_OPCODE_ST_COND (ST_B, 7, LT, 5)

 25163 +    AVR32_OPCODE_ST_COND (ST_B, 7, MI, 6)

 25164 +    AVR32_OPCODE_ST_COND (ST_B, 7, PL, 7)

 25165 +    AVR32_OPCODE_ST_COND (ST_B, 7, LS, 8)

 25166 +    AVR32_OPCODE_ST_COND (ST_B, 7, GT, 9)

 25167 +    AVR32_OPCODE_ST_COND (ST_B, 7, LE, 10)

 25168 +    AVR32_OPCODE_ST_COND (ST_B, 7, HI, 11)

 25169 +    AVR32_OPCODE_ST_COND (ST_B, 7, VS, 12)

 25170 +    AVR32_OPCODE_ST_COND (ST_B, 7, VC, 13)

 25171 +    AVR32_OPCODE_ST_COND (ST_B, 7, QS, 14)

 25172 +    AVR32_OPCODE_ST_COND (ST_B, 7, AL, 15)

 25173 +

 25174 +    {

 25175 +      AVR32_OPC_MOVH, 4, 0xfc100000, 0xfff00000,

 25176 +      &avr32_syntax_table[AVR32_SYNTAX_MOVH],

 25177 +      BFD_RELOC_AVR32_16U,  2, 1,

 25178 +      {

 25179 +	&avr32_ifield_table[AVR32_IFIELD_RY],

 25180 +	&avr32_ifield_table[AVR32_IFIELD_K16],

 25181 +      },

 25182 +    },

 25183 +

 25184 + };

 25185 +

 25186 +#define FPALIAS_DXY(name, opcode)			\

 25187 +  {							\

 25188 +    AVR32_ALIAS_##name##_S,				\

 25189 +    &avr32_opc_table[AVR32_OPC_COP],			\

 25190 +    {							\

 25191 +      { 0, 0 },						\

 25192 +      { 1, 0 }, { 1, 1 }, { 1, 2 },			\

 25193 +      { 0, opcode },					\

 25194 +    },							\

 25195 +  }, {							\

 25196 +    AVR32_ALIAS_##name##_D,				\

 25197 +    &avr32_opc_table[AVR32_OPC_COP],			\

 25198 +    {							\

 25199 +      { 0, 0 },						\

 25200 +      { 1, 0 }, { 1, 1 }, { 1, 2 },			\

 25201 +      { 0, (opcode) | 0x40 },				\

 25202 +    },							\

 25203 +  }

 25204 +#define FPALIAS_DX(name, opcode)			\

 25205 +  {							\

 25206 +    AVR32_ALIAS_##name##_S,				\

 25207 +    &avr32_opc_table[AVR32_OPC_COP],			\

 25208 +    {							\

 25209 +      { 0, 0 },						\

 25210 +      { 1, 0 }, { 1, 1 }, { 0, 0 },			\

 25211 +      { 0, opcode },					\

 25212 +    },							\

 25213 +  }, {							\

 25214 +    AVR32_ALIAS_##name##_D,				\

 25215 +    &avr32_opc_table[AVR32_OPC_COP],			\

 25216 +    {							\

 25217 +      { 0, 0 },						\

 25218 +      { 1, 0 }, { 1, 1 }, { 0, 0 },			\

 25219 +      { 0, (opcode) | 0x40 },				\

 25220 +    },							\

 25221 +  }

 25222 +#define FPALIAS_XY(name, opcode)			\

 25223 +  {							\

 25224 +    AVR32_ALIAS_##name##_S,				\

 25225 +    &avr32_opc_table[AVR32_OPC_COP],			\

 25226 +    {							\

 25227 +      { 0, 0 },						\

 25228 +      { 0, 0 }, { 1, 0 }, { 1, 1 },			\

 25229 +      { 0, opcode },					\

 25230 +    },							\

 25231 +  }, {							\

 25232 +    AVR32_ALIAS_##name##_D,				\

 25233 +    &avr32_opc_table[AVR32_OPC_COP],			\

 25234 +    {							\

 25235 +      { 0, 0 },						\

 25236 +      { 0, 0 }, { 1, 0 }, { 1, 1 },			\

 25237 +      { 0, (opcode) | 0x40 },				\

 25238 +    },							\

 25239 +  }

 25240 +

 25241 +const struct avr32_alias avr32_alias_table[] =

 25242 +  {

 25243 +    FPALIAS_DXY(FMAC, 0x00),

 25244 +    FPALIAS_DXY(FNMAC, 0x01),

 25245 +    FPALIAS_DXY(FMSC, 0x02),

 25246 +    FPALIAS_DXY(FNMSC, 0x03),

 25247 +    FPALIAS_DXY(FADD, 0x04),

 25248 +    FPALIAS_DXY(FSUB, 0x05),

 25249 +    FPALIAS_DXY(FMUL, 0x06),

 25250 +    FPALIAS_DXY(FNMUL, 0x07),

 25251 +    FPALIAS_DX(FNEG, 0x08),

 25252 +    FPALIAS_DX(FABS, 0x09),

 25253 +    FPALIAS_XY(FCMP, 0x0d),

 25254 +    FPALIAS_DX(FMOV1, 0x0a),

 25255 +    {

 25256 +      AVR32_ALIAS_FMOV2_S,

 25257 +      &avr32_opc_table[AVR32_OPC_MVCR_W],

 25258 +      { { 0, 0 }, { 1, 0 }, { 1, 1 }, },

 25259 +    },

 25260 +    {

 25261 +      AVR32_ALIAS_FMOV2_D,

 25262 +      &avr32_opc_table[AVR32_OPC_MVCR_D],

 25263 +      { { 0, 0 }, { 1, 0 }, { 1, 1 }, },

 25264 +    },

 25265 +    {

 25266 +      AVR32_ALIAS_FMOV3_S,

 25267 +      &avr32_opc_table[AVR32_OPC_MVRC_W],

 25268 +      { { 0, 0 }, { 1, 0 }, { 1, 1 }, },

 25269 +    },

 25270 +    {

 25271 +      AVR32_ALIAS_FMOV3_D,

 25272 +      &avr32_opc_table[AVR32_OPC_MVRC_D],

 25273 +      { { 0, 0 }, { 1, 0 }, { 1, 1 }, },

 25274 +    },

 25275 +    {

 25276 +      AVR32_ALIAS_FCASTS_D,

 25277 +      &avr32_opc_table[AVR32_OPC_COP],

 25278 +      {

 25279 +	{ 0, 0 },

 25280 +	{ 1, 0 }, { 1, 1 }, { 0, 0 },

 25281 +	{ 0, 0x0f },

 25282 +      },

 25283 +    },

 25284 +    {

 25285 +      AVR32_ALIAS_FCASTD_S,

 25286 +      &avr32_opc_table[AVR32_OPC_COP],

 25287 +      {

 25288 +	{ 0, 0 },

 25289 +	{ 1, 0 }, { 1, 1 }, { 0, 0 },

 25290 +	{ 0, 0x10 },

 25291 +      },

 25292 +    },

 25293 +    {

 25294 +      AVR32_ALIAS_PICOSVMAC0,

 25295 +      &avr32_opc_table[AVR32_OPC_COP],

 25296 +      {

 25297 +	{ 0, PICO_CPNO },

 25298 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25299 +	{ 0, 0x0c },

 25300 +      },

 25301 +    },

 25302 +    {

 25303 +      AVR32_ALIAS_PICOSVMAC1,

 25304 +      &avr32_opc_table[AVR32_OPC_COP],

 25305 +      {

 25306 +	{ 0, PICO_CPNO },

 25307 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25308 +	{ 0, 0x0d },

 25309 +      },

 25310 +    },

 25311 +    {

 25312 +      AVR32_ALIAS_PICOSVMAC2,

 25313 +      &avr32_opc_table[AVR32_OPC_COP],

 25314 +      {

 25315 +	{ 0, PICO_CPNO },

 25316 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25317 +	{ 0, 0x0e },

 25318 +      },

 25319 +    },

 25320 +    {

 25321 +      AVR32_ALIAS_PICOSVMAC3,

 25322 +      &avr32_opc_table[AVR32_OPC_COP],

 25323 +      {

 25324 +	{ 0, PICO_CPNO },

 25325 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25326 +	{ 0, 0x0f },

 25327 +      },

 25328 +    },

 25329 +    {

 25330 +      AVR32_ALIAS_PICOSVMUL0,

 25331 +      &avr32_opc_table[AVR32_OPC_COP],

 25332 +      {

 25333 +	{ 0, PICO_CPNO },

 25334 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25335 +	{ 0, 0x08 },

 25336 +      },

 25337 +    },

 25338 +    {

 25339 +      AVR32_ALIAS_PICOSVMUL1,

 25340 +      &avr32_opc_table[AVR32_OPC_COP],

 25341 +      {

 25342 +	{ 0, PICO_CPNO },

 25343 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25344 +	{ 0, 0x09 },

 25345 +      },

 25346 +    },

 25347 +    {

 25348 +      AVR32_ALIAS_PICOSVMUL2,

 25349 +      &avr32_opc_table[AVR32_OPC_COP],

 25350 +      {

 25351 +	{ 0, PICO_CPNO },

 25352 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25353 +	{ 0, 0x0a },

 25354 +      },

 25355 +    },

 25356 +    {

 25357 +      AVR32_ALIAS_PICOSVMUL3,

 25358 +      &avr32_opc_table[AVR32_OPC_COP],

 25359 +      {

 25360 +	{ 0, PICO_CPNO },

 25361 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25362 +	{ 0, 0x0b },

 25363 +      },

 25364 +    },

 25365 +    {

 25366 +      AVR32_ALIAS_PICOVMAC0,

 25367 +      &avr32_opc_table[AVR32_OPC_COP],

 25368 +      {

 25369 +	{ 0, PICO_CPNO },

 25370 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25371 +	{ 0, 0x04 },

 25372 +      },

 25373 +    },

 25374 +    {

 25375 +      AVR32_ALIAS_PICOVMAC1,

 25376 +      &avr32_opc_table[AVR32_OPC_COP],

 25377 +      {

 25378 +	{ 0, PICO_CPNO },

 25379 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25380 +	{ 0, 0x05 },

 25381 +      },

 25382 +    },

 25383 +    {

 25384 +      AVR32_ALIAS_PICOVMAC2,

 25385 +      &avr32_opc_table[AVR32_OPC_COP],

 25386 +      {

 25387 +	{ 0, PICO_CPNO },

 25388 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25389 +	{ 0, 0x06 },

 25390 +      },

 25391 +    },

 25392 +    {

 25393 +      AVR32_ALIAS_PICOVMAC3,

 25394 +      &avr32_opc_table[AVR32_OPC_COP],

 25395 +      {

 25396 +	{ 0, PICO_CPNO },

 25397 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25398 +	{ 0, 0x07 },

 25399 +      },

 25400 +    },

 25401 +    {

 25402 +      AVR32_ALIAS_PICOVMUL0,

 25403 +      &avr32_opc_table[AVR32_OPC_COP],

 25404 +      {

 25405 +	{ 0, PICO_CPNO },

 25406 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25407 +	{ 0, 0x00 },

 25408 +      },

 25409 +    },

 25410 +    {

 25411 +      AVR32_ALIAS_PICOVMUL1,

 25412 +      &avr32_opc_table[AVR32_OPC_COP],

 25413 +      {

 25414 +	{ 0, PICO_CPNO },

 25415 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25416 +	{ 0, 0x01 },

 25417 +      },

 25418 +    },

 25419 +    {

 25420 +      AVR32_ALIAS_PICOVMUL2,

 25421 +      &avr32_opc_table[AVR32_OPC_COP],

 25422 +      {

 25423 +	{ 0, PICO_CPNO },

 25424 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25425 +	{ 0, 0x02 },

 25426 +      },

 25427 +    },

 25428 +    {

 25429 +      AVR32_ALIAS_PICOVMUL3,

 25430 +      &avr32_opc_table[AVR32_OPC_COP],

 25431 +      {

 25432 +	{ 0, PICO_CPNO },

 25433 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25434 +	{ 0, 0x03 },

 25435 +      },

 25436 +    },

 25437 +    {

 25438 +      AVR32_ALIAS_PICOLD_D1,

 25439 +      &avr32_opc_table[AVR32_OPC_LDC_D1],

 25440 +      {

 25441 +	{ 0, PICO_CPNO },

 25442 +	{ 1, 0 }, { 1, 1 },

 25443 +      },

 25444 +    },

 25445 +    {

 25446 +      AVR32_ALIAS_PICOLD_D2,

 25447 +      &avr32_opc_table[AVR32_OPC_LDC_D2],

 25448 +      {

 25449 +	{ 0, PICO_CPNO },

 25450 +	{ 1, 0 }, { 1, 1 },

 25451 +      },

 25452 +    },

 25453 +    {

 25454 +      AVR32_ALIAS_PICOLD_D3,

 25455 +      &avr32_opc_table[AVR32_OPC_LDC_D3],

 25456 +      {

 25457 +	{ 0, PICO_CPNO },

 25458 +	{ 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },

 25459 +      },

 25460 +    },

 25461 +    {

 25462 +      AVR32_ALIAS_PICOLD_W1,

 25463 +      &avr32_opc_table[AVR32_OPC_LDC_W1],

 25464 +      {

 25465 +	{ 0, PICO_CPNO },

 25466 +	{ 1, 0 }, { 1, 1 },

 25467 +      },

 25468 +    },

 25469 +    {

 25470 +      AVR32_ALIAS_PICOLD_W2,

 25471 +      &avr32_opc_table[AVR32_OPC_LDC_W2],

 25472 +      {

 25473 +	{ 0, PICO_CPNO },

 25474 +	{ 1, 0 }, { 1, 1 },

 25475 +      },

 25476 +    },

 25477 +    {

 25478 +      AVR32_ALIAS_PICOLD_W3,

 25479 +      &avr32_opc_table[AVR32_OPC_LDC_W3],

 25480 +      {

 25481 +	{ 0, PICO_CPNO },

 25482 +	{ 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },

 25483 +      },

 25484 +    },

 25485 +    {

 25486 +      AVR32_ALIAS_PICOLDM_D,

 25487 +      &avr32_opc_table[AVR32_OPC_LDCM_D],

 25488 +      {

 25489 +	{ 0, PICO_CPNO },

 25490 +	{ 1, 0 }, { 1, 1 },

 25491 +      },

 25492 +    },

 25493 +    {

 25494 +      AVR32_ALIAS_PICOLDM_D_PU,

 25495 +      &avr32_opc_table[AVR32_OPC_LDCM_D_PU],

 25496 +      {

 25497 +	{ 0, PICO_CPNO },

 25498 +	{ 1, 0 }, { 1, 1 },

 25499 +      },

 25500 +    },

 25501 +    {

 25502 +      AVR32_ALIAS_PICOLDM_W,

 25503 +      &avr32_opc_table[AVR32_OPC_LDCM_W],

 25504 +      {

 25505 +	{ 0, PICO_CPNO },

 25506 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25507 +      },

 25508 +    },

 25509 +    {

 25510 +      AVR32_ALIAS_PICOLDM_W_PU,

 25511 +      &avr32_opc_table[AVR32_OPC_LDCM_W_PU],

 25512 +      {

 25513 +	{ 0, PICO_CPNO },

 25514 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25515 +      },

 25516 +    },

 25517 +    {

 25518 +      AVR32_ALIAS_PICOMV_D1,

 25519 +      &avr32_opc_table[AVR32_OPC_MVCR_D],

 25520 +      {

 25521 +	{ 0, PICO_CPNO },

 25522 +	{ 1, 0 }, { 1, 1 },

 25523 +      },

 25524 +    },

 25525 +    {

 25526 +      AVR32_ALIAS_PICOMV_D2,

 25527 +      &avr32_opc_table[AVR32_OPC_MVRC_D],

 25528 +      {

 25529 +	{ 0, PICO_CPNO },

 25530 +	{ 1, 0 }, { 1, 1 },

 25531 +      },

 25532 +    },

 25533 +    {

 25534 +      AVR32_ALIAS_PICOMV_W1,

 25535 +      &avr32_opc_table[AVR32_OPC_MVCR_W],

 25536 +      {

 25537 +	{ 0, PICO_CPNO },

 25538 +	{ 1, 0 }, { 1, 1 },

 25539 +      },

 25540 +    },

 25541 +    {

 25542 +      AVR32_ALIAS_PICOMV_W2,

 25543 +      &avr32_opc_table[AVR32_OPC_MVRC_W],

 25544 +      {

 25545 +	{ 0, PICO_CPNO },

 25546 +	{ 1, 0 }, { 1, 1 },

 25547 +      },

 25548 +    },

 25549 +    {

 25550 +      AVR32_ALIAS_PICOST_D1,

 25551 +      &avr32_opc_table[AVR32_OPC_STC_D1],

 25552 +      {

 25553 +	{ 0, PICO_CPNO },

 25554 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25555 +      },

 25556 +    },

 25557 +    {

 25558 +      AVR32_ALIAS_PICOST_D2,

 25559 +      &avr32_opc_table[AVR32_OPC_STC_D2],

 25560 +      {

 25561 +	{ 0, PICO_CPNO },

 25562 +	{ 1, 0 }, { 1, 1 },

 25563 +      },

 25564 +    },

 25565 +    {

 25566 +      AVR32_ALIAS_PICOST_D3,

 25567 +      &avr32_opc_table[AVR32_OPC_STC_D3],

 25568 +      {

 25569 +	{ 0, PICO_CPNO },

 25570 +	{ 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },

 25571 +      },

 25572 +    },

 25573 +    {

 25574 +      AVR32_ALIAS_PICOST_W1,

 25575 +      &avr32_opc_table[AVR32_OPC_STC_W1],

 25576 +      {

 25577 +	{ 0, PICO_CPNO },

 25578 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25579 +      },

 25580 +    },

 25581 +    {

 25582 +      AVR32_ALIAS_PICOST_W2,

 25583 +      &avr32_opc_table[AVR32_OPC_STC_W2],

 25584 +      {

 25585 +	{ 0, PICO_CPNO },

 25586 +	{ 1, 0 }, { 1, 1 },

 25587 +      },

 25588 +    },

 25589 +    {

 25590 +      AVR32_ALIAS_PICOST_W3,

 25591 +      &avr32_opc_table[AVR32_OPC_STC_W3],

 25592 +      {

 25593 +	{ 0, PICO_CPNO },

 25594 +	{ 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },

 25595 +      },

 25596 +    },

 25597 +    {

 25598 +      AVR32_ALIAS_PICOSTM_D,

 25599 +      &avr32_opc_table[AVR32_OPC_STCM_D],

 25600 +      {

 25601 +	{ 0, PICO_CPNO },

 25602 +	{ 1, 0 }, { 1, 1 },

 25603 +      },

 25604 +    },

 25605 +    {

 25606 +      AVR32_ALIAS_PICOSTM_D_PU,

 25607 +      &avr32_opc_table[AVR32_OPC_STCM_D_PU],

 25608 +      {

 25609 +	{ 0, PICO_CPNO },

 25610 +	{ 1, 0 }, { 1, 1 },

 25611 +      },

 25612 +    },

 25613 +    {

 25614 +      AVR32_ALIAS_PICOSTM_W,

 25615 +      &avr32_opc_table[AVR32_OPC_STCM_W],

 25616 +      {

 25617 +	{ 0, PICO_CPNO },

 25618 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25619 +      },

 25620 +    },

 25621 +    {

 25622 +      AVR32_ALIAS_PICOSTM_W_PU,

 25623 +      &avr32_opc_table[AVR32_OPC_STCM_W_PU],

 25624 +      {

 25625 +	{ 0, PICO_CPNO },

 25626 +	{ 1, 0 }, { 1, 1 }, { 1, 2 },

 25627 +      },

 25628 +    },

 25629 +  };

 25630 +

 25631 +

 25632 +#define SYNTAX_NORMAL0(id, mne, opc, arch)			\

 25633 +  {							\

 25634 +    AVR32_SYNTAX_##id, arch,			\

 25635 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],	\

 25636 +    AVR32_PARSER_NORMAL,					\

 25637 +    { &avr32_opc_table[AVR32_OPC_##opc], },		\

 25638 +    NULL, 0, { }					\

 25639 +  }

 25640 +#define SYNTAX_NORMAL1(id, mne, opc, op0, arch)		\

 25641 +  {							\

 25642 +    AVR32_SYNTAX_##id, arch,			\

 25643 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],	\

 25644 +    AVR32_PARSER_NORMAL,					\

 25645 +    { &avr32_opc_table[AVR32_OPC_##opc], },		\

 25646 +    NULL, 1,						\

 25647 +    {							\

 25648 +      AVR32_OPERAND_##op0,				\

 25649 +    }							\

 25650 +  }

 25651 +#define SYNTAX_NORMALM1(id, mne, opc, op0, arch)		\

 25652 +  {							\

 25653 +    AVR32_SYNTAX_##id, arch,			\

 25654 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],	\

 25655 +    AVR32_PARSER_NORMAL,					\

 25656 +    { &avr32_opc_table[AVR32_OPC_##opc], },			\

 25657 +    NULL, -1,						\

 25658 +    {							\

 25659 +      AVR32_OPERAND_##op0,				\

 25660 +    }							\

 25661 +  }

 25662 +#define SYNTAX_NORMAL2(id, mne, opc, op0, op1, arch)		\

 25663 +  {							\

 25664 +    AVR32_SYNTAX_##id, arch,			\

 25665 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],	\

 25666 +    AVR32_PARSER_NORMAL,					\

 25667 +    { &avr32_opc_table[AVR32_OPC_##opc], },			\

 25668 +    NULL, 2,						\

 25669 +    {							\

 25670 +      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,		\

 25671 +    }							\

 25672 +  }

 25673 +#define SYNTAX_NORMALM2(id, mne, opc, op0, op1, arch)		\

 25674 +  {							\

 25675 +    AVR32_SYNTAX_##id, arch,			\

 25676 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],	\

 25677 +    AVR32_PARSER_NORMAL,					\

 25678 +    { &avr32_opc_table[AVR32_OPC_##opc], },			\

 25679 +    NULL, -2,						\

 25680 +    {							\

 25681 +      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,		\

 25682 +    }							\

 25683 +  }

 25684 +#define SYNTAX_NORMAL3(id, mne, opc, op0, op1, op2, arch)	\

 25685 +  {							\

 25686 +    AVR32_SYNTAX_##id, arch,			\

 25687 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],	\

 25688 +    AVR32_PARSER_NORMAL,					\

 25689 +    { &avr32_opc_table[AVR32_OPC_##opc], },			\

 25690 +    NULL, 3,						\

 25691 +    {							\

 25692 +      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,		\

 25693 +      AVR32_OPERAND_##op2,				\

 25694 +    }							\

 25695 +  }

 25696 +#define SYNTAX_NORMALM3(id, mne, opc, op0, op1, op2, arch)	\

 25697 +  {							\

 25698 +    AVR32_SYNTAX_##id, arch,			\

 25699 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],	\

 25700 +    AVR32_PARSER_NORMAL,					\

 25701 +    { &avr32_opc_table[AVR32_OPC_##opc], },			\

 25702 +    NULL, -3,						\

 25703 +    {							\

 25704 +      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,		\

 25705 +      AVR32_OPERAND_##op2,				\

 25706 +    }							\

 25707 +  }

 25708 +#define SYNTAX_NORMAL4(id, mne, opc, op0, op1, op2, op3, arch)\

 25709 +  {							\

 25710 +    AVR32_SYNTAX_##id, arch,			\

 25711 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],	\

 25712 +    AVR32_PARSER_NORMAL,					\

 25713 +    { &avr32_opc_table[AVR32_OPC_##opc], },			\

 25714 +    NULL, 4,						\

 25715 +    {							\

 25716 +      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,		\

 25717 +      AVR32_OPERAND_##op2, AVR32_OPERAND_##op3,		\

 25718 +    }							\

 25719 +  }

 25720 +#define SYNTAX_NORMAL5(id, mne, opc, op0, op1, op2, op3, op4, arch)	\

 25721 +  {								\

 25722 +    AVR32_SYNTAX_##id, arch,				\

 25723 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],		\

 25724 +    AVR32_PARSER_NORMAL,						\

 25725 +    { &avr32_opc_table[AVR32_OPC_##opc], },				\

 25726 +    NULL, 5,							\

 25727 +    {								\

 25728 +      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,			\

 25729 +      AVR32_OPERAND_##op2, AVR32_OPERAND_##op3,			\

 25730 +      AVR32_OPERAND_##op4,					\

 25731 +    }								\

 25732 +  }

 25733 +

 25734 +#define SYNTAX_NORMAL_C1(id, mne, opc, nxt, op0, arch)	\

 25735 +  {							\

 25736 +    AVR32_SYNTAX_##id, arch,			\

 25737 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],	\

 25738 +    AVR32_PARSER_NORMAL,					\

 25739 +    { &avr32_opc_table[AVR32_OPC_##opc], },			\

 25740 +    &avr32_syntax_table[AVR32_SYNTAX_##nxt], 1,		\

 25741 +    {							\

 25742 +      AVR32_OPERAND_##op0,				\

 25743 +    }							\

 25744 +  }

 25745 +#define SYNTAX_NORMAL_CM1(id, mne, opc, nxt, op0, arch)	\

 25746 +  {							\

 25747 +    AVR32_SYNTAX_##id, arch,			\

 25748 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],	\

 25749 +    AVR32_PARSER_NORMAL,					\

 25750 +    { &avr32_opc_table[AVR32_OPC_##opc], },			\

 25751 +    &avr32_syntax_table[AVR32_SYNTAX_##nxt], -1,	\

 25752 +    {							\

 25753 +      AVR32_OPERAND_##op0,				\

 25754 +    }							\

 25755 +  }

 25756 +#define SYNTAX_NORMAL_C2(id, mne, opc, nxt, op0, op1, arch)	\

 25757 +  {							\

 25758 +    AVR32_SYNTAX_##id, arch,			\

 25759 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],	\

 25760 +    AVR32_PARSER_NORMAL,					\

 25761 +    { &avr32_opc_table[AVR32_OPC_##opc], },			\

 25762 +    &avr32_syntax_table[AVR32_SYNTAX_##nxt], 2,		\

 25763 +    {							\

 25764 +      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,		\

 25765 +    }							\

 25766 +  }

 25767 +#define SYNTAX_NORMAL_CM2(id, mne, opc, nxt, op0, op1, arch)	\

 25768 +  {							\

 25769 +    AVR32_SYNTAX_##id, arch,			\

 25770 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],	\

 25771 +    AVR32_PARSER_NORMAL,					\

 25772 +    { &avr32_opc_table[AVR32_OPC_##opc], },			\

 25773 +    &avr32_syntax_table[AVR32_SYNTAX_##nxt], -2,	\

 25774 +    {							\

 25775 +      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,		\

 25776 +    }							\

 25777 +  }

 25778 +#define SYNTAX_NORMAL_C3(id, mne, opc, nxt, op0, op1, op2, arch)	\

 25779 +  {								\

 25780 +    AVR32_SYNTAX_##id, arch,				\

 25781 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],		\

 25782 +    AVR32_PARSER_NORMAL,						\

 25783 +    { &avr32_opc_table[AVR32_OPC_##opc], },				\

 25784 +    &avr32_syntax_table[AVR32_SYNTAX_##nxt], 3,			\

 25785 +    {								\

 25786 +      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,			\

 25787 +      AVR32_OPERAND_##op2,					\

 25788 +    }								\

 25789 +  }

 25790 +#define SYNTAX_NORMAL_CM3(id, mne, opc, nxt, op0, op1, op2, arch)	\

 25791 +  {								\

 25792 +    AVR32_SYNTAX_##id, arch,				\

 25793 +    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],		\

 25794 +    AVR32_PARSER_NORMAL,						\

 25795 +    { &avr32_opc_table[AVR32_OPC_##opc], },				\

 25796 +    &avr32_syntax_table[AVR32_SYNTAX_##nxt], -3,		\

 25797 +    {								\

 25798 +      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,			\

 25799 +      AVR32_OPERAND_##op2,					\

 25800 +    }								\

 25801 +  }

 25802 +

 25803 +#define SYNTAX_FP(name, nr_ops)					\

 25804 +    {								\

 25805 +      AVR32_SYNTAX_##name##_S,					\

 25806 +      AVR32_FP, NULL, AVR32_PARSER_ALIAS,			\

 25807 +      { .alias = &avr32_alias_table[AVR32_ALIAS_##name##_S] },	\

 25808 +      NULL, nr_ops,						\

 25809 +      {								\

 25810 +	AVR32_OPERAND_FPREG_S,					\

 25811 +	AVR32_OPERAND_FPREG_S,					\

 25812 +	AVR32_OPERAND_FPREG_S,					\

 25813 +      },							\

 25814 +    },								\

 25815 +    {								\

 25816 +      AVR32_SYNTAX_##name##_D,					\

 25817 +      AVR32_FP, NULL, AVR32_PARSER_ALIAS,			\

 25818 +      { .alias = &avr32_alias_table[AVR32_ALIAS_##name##_D] },	\

 25819 +      NULL, nr_ops,						\

 25820 +      {								\

 25821 +	AVR32_OPERAND_FPREG_D,					\

 25822 +	AVR32_OPERAND_FPREG_D,					\

 25823 +	AVR32_OPERAND_FPREG_D,					\

 25824 +      },							\

 25825 +    }

 25826 +

 25827 +const struct avr32_syntax avr32_syntax_table[] =

 25828 +  {

 25829 +    SYNTAX_NORMAL1(ABS, ABS, ABS, INTREG, AVR32_V1),

 25830 +    SYNTAX_NORMAL1(ACALL, ACALL, ACALL, UNSIGNED_CONST_W, AVR32_V1),

 25831 +    SYNTAX_NORMAL1(ACR, ACR, ACR, INTREG,AVR32_V1),

 25832 +    SYNTAX_NORMAL3(ADC, ADC, ADC, INTREG, INTREG, INTREG, AVR32_V1),

 25833 +    SYNTAX_NORMAL_C2(ADD1, ADD, ADD1, ADD2, INTREG, INTREG, AVR32_V1),

 25834 +    SYNTAX_NORMAL3(ADD2, ADD, ADD2, INTREG, INTREG, INTREG_LSL, AVR32_V1),

 25835 +    SYNTAX_NORMAL3(ADDABS, ADDABS, ADDABS, INTREG, INTREG, INTREG, AVR32_V1),

 25836 +    SYNTAX_NORMAL3(ADDHH_W, ADDHH_W, ADDHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),

 25837 +    SYNTAX_NORMAL_C2(AND1, AND, AND1, AND2, INTREG, INTREG, AVR32_V1),

 25838 +    SYNTAX_NORMAL_C3(AND2, AND, AND2, AND3, INTREG, INTREG, INTREG_LSL, AVR32_V1),

 25839 +    SYNTAX_NORMAL3(AND3, AND, AND3, INTREG, INTREG, INTREG_LSR, AVR32_V1),

 25840 +    SYNTAX_NORMAL_C2(ANDH, ANDH, ANDH, ANDH_COH, INTREG, UNSIGNED_CONST, AVR32_V1),

 25841 +    SYNTAX_NORMAL3(ANDH_COH, ANDH, ANDH_COH, INTREG, UNSIGNED_CONST, COH, AVR32_V1),

 25842 +    SYNTAX_NORMAL_C2(ANDL, ANDL, ANDL, ANDL_COH, INTREG, UNSIGNED_CONST, AVR32_V1),

 25843 +    SYNTAX_NORMAL3(ANDL_COH, ANDL, ANDL_COH, INTREG, UNSIGNED_CONST, COH, AVR32_V1),

 25844 +    SYNTAX_NORMAL2(ANDN, ANDN, ANDN, INTREG, INTREG, AVR32_V1),

 25845 +    SYNTAX_NORMAL_C3(ASR1, ASR, ASR1, ASR3, INTREG, INTREG, INTREG, AVR32_V1),

 25846 +    SYNTAX_NORMAL_C3(ASR3, ASR, ASR3, ASR2, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_V1),

 25847 +    SYNTAX_NORMAL2(ASR2, ASR, ASR2, INTREG, UNSIGNED_NUMBER, AVR32_V1),

 25848 +    SYNTAX_NORMAL4(BFEXTS, BFEXTS, BFEXTS, INTREG, INTREG, UNSIGNED_NUMBER, UNSIGNED_NUMBER, AVR32_V1),

 25849 +    SYNTAX_NORMAL4(BFEXTU, BFEXTU, BFEXTU, INTREG, INTREG, UNSIGNED_NUMBER, UNSIGNED_NUMBER, AVR32_V1),

 25850 +    SYNTAX_NORMAL4(BFINS, BFINS, BFINS, INTREG, INTREG, UNSIGNED_NUMBER, UNSIGNED_NUMBER, AVR32_V1),

 25851 +    SYNTAX_NORMAL2(BLD, BLD, BLD, INTREG, UNSIGNED_NUMBER, AVR32_V1),

 25852 +    SYNTAX_NORMAL_C1(BREQ1, BREQ, BREQ1, BREQ2, JMPLABEL, AVR32_V1),

 25853 +    SYNTAX_NORMAL_C1(BRNE1, BRNE, BRNE1, BRNE2, JMPLABEL, AVR32_V1),

 25854 +    SYNTAX_NORMAL_C1(BRCC1, BRCC, BRCC1, BRCC2, JMPLABEL, AVR32_V1),

 25855 +    SYNTAX_NORMAL_C1(BRCS1, BRCS, BRCS1, BRCS2, JMPLABEL, AVR32_V1),

 25856 +    SYNTAX_NORMAL_C1(BRGE1, BRGE, BRGE1, BRGE2, JMPLABEL, AVR32_V1),

 25857 +    SYNTAX_NORMAL_C1(BRLT1, BRLT, BRLT1, BRLT2, JMPLABEL, AVR32_V1),

 25858 +    SYNTAX_NORMAL_C1(BRMI1, BRMI, BRMI1, BRMI2, JMPLABEL, AVR32_V1),

 25859 +    SYNTAX_NORMAL_C1(BRPL1, BRPL, BRPL1, BRPL2, JMPLABEL, AVR32_V1),

 25860 +    SYNTAX_NORMAL_C1(BRHS1, BRHS, BRCC1, BRHS2, JMPLABEL, AVR32_V1),

 25861 +    SYNTAX_NORMAL_C1(BRLO1, BRLO, BRCS1, BRLO2, JMPLABEL, AVR32_V1),

 25862 +    SYNTAX_NORMAL1(BREQ2, BREQ, BREQ2, JMPLABEL, AVR32_V1),

 25863 +    SYNTAX_NORMAL1(BRNE2, BRNE, BRNE2, JMPLABEL, AVR32_V1),

 25864 +    SYNTAX_NORMAL1(BRCC2, BRCC, BRCC2, JMPLABEL, AVR32_V1),

 25865 +    SYNTAX_NORMAL1(BRCS2, BRCS, BRCS2, JMPLABEL, AVR32_V1),

 25866 +    SYNTAX_NORMAL1(BRGE2, BRGE, BRGE2, JMPLABEL, AVR32_V1),

 25867 +    SYNTAX_NORMAL1(BRLT2, BRLT, BRLT2, JMPLABEL, AVR32_V1),

 25868 +    SYNTAX_NORMAL1(BRMI2, BRMI, BRMI2, JMPLABEL, AVR32_V1),

 25869 +    SYNTAX_NORMAL1(BRPL2, BRPL, BRPL2, JMPLABEL, AVR32_V1),

 25870 +    SYNTAX_NORMAL1(BRLS, BRLS, BRLS, JMPLABEL, AVR32_V1),

 25871 +    SYNTAX_NORMAL1(BRGT, BRGT, BRGT, JMPLABEL, AVR32_V1),

 25872 +    SYNTAX_NORMAL1(BRLE, BRLE, BRLE, JMPLABEL, AVR32_V1),

 25873 +    SYNTAX_NORMAL1(BRHI, BRHI, BRHI, JMPLABEL, AVR32_V1),

 25874 +    SYNTAX_NORMAL1(BRVS, BRVS, BRVS, JMPLABEL, AVR32_V1),

 25875 +    SYNTAX_NORMAL1(BRVC, BRVC, BRVC, JMPLABEL, AVR32_V1),

 25876 +    SYNTAX_NORMAL1(BRQS, BRQS, BRQS, JMPLABEL, AVR32_V1),

 25877 +    SYNTAX_NORMAL1(BRAL, BRAL, BRAL, JMPLABEL, AVR32_V1),

 25878 +    SYNTAX_NORMAL1(BRHS2, BRHS, BRCC2, JMPLABEL, AVR32_V1),

 25879 +    SYNTAX_NORMAL1(BRLO2, BRLO, BRCS2, JMPLABEL, AVR32_V1),

 25880 +    SYNTAX_NORMAL0(BREAKPOINT, BREAKPOINT, BREAKPOINT, AVR32_V1),

 25881 +    SYNTAX_NORMAL1(BREV, BREV, BREV, INTREG, AVR32_V1),

 25882 +    SYNTAX_NORMAL2(BST, BST, BST, INTREG, UNSIGNED_NUMBER, AVR32_V1),

 25883 +    SYNTAX_NORMAL2(CACHE, CACHE, CACHE, INTREG_SDISP, UNSIGNED_NUMBER, AVR32_V1),

 25884 +    SYNTAX_NORMAL1(CASTS_B, CASTS_B, CASTS_B, INTREG, AVR32_V1),

 25885 +    SYNTAX_NORMAL1(CASTS_H, CASTS_H, CASTS_H, INTREG, AVR32_V1),

 25886 +    SYNTAX_NORMAL1(CASTU_B, CASTU_B, CASTU_B, INTREG, AVR32_V1),

 25887 +    SYNTAX_NORMAL1(CASTU_H, CASTU_H, CASTU_H, INTREG, AVR32_V1),

 25888 +    SYNTAX_NORMAL2(CBR, CBR, CBR, INTREG, UNSIGNED_NUMBER, AVR32_V1),

 25889 +    SYNTAX_NORMAL2(CLZ, CLZ, CLZ, INTREG, INTREG, AVR32_V1),

 25890 +    SYNTAX_NORMAL1(COM, COM, COM, INTREG, AVR32_V1),

 25891 +    SYNTAX_NORMAL5(COP, COP, COP, CPNO, CPREG, CPREG, CPREG, UNSIGNED_NUMBER, AVR32_V1),

 25892 +    SYNTAX_NORMAL2(CP_B, CP_B, CP_B, INTREG, INTREG, AVR32_V1),

 25893 +    SYNTAX_NORMAL2(CP_H, CP_H, CP_H, INTREG, INTREG, AVR32_V1),

 25894 +    SYNTAX_NORMAL_C2(CP_W1, CP_W, CP_W1, CP_W2, INTREG, INTREG, AVR32_V1),

 25895 +    SYNTAX_NORMAL_C2(CP_W2, CP_W, CP_W2, CP_W3, INTREG, SIGNED_CONST, AVR32_V1),

 25896 +    SYNTAX_NORMAL2(CP_W3, CP_W, CP_W3, INTREG, SIGNED_CONST, AVR32_V1),

 25897 +    SYNTAX_NORMAL_C2(CPC1, CPC, CPC1, CPC2, INTREG, INTREG, AVR32_V1),

 25898 +    SYNTAX_NORMAL1(CPC2, CPC, CPC2, INTREG, AVR32_V1),

 25899 +    SYNTAX_NORMAL1(CSRF, CSRF, CSRF, UNSIGNED_NUMBER, AVR32_V1),

 25900 +    SYNTAX_NORMAL1(CSRFCZ, CSRFCZ, CSRFCZ, UNSIGNED_NUMBER, AVR32_V1),

 25901 +    SYNTAX_NORMAL3(DIVS, DIVS, DIVS, INTREG, INTREG, INTREG, AVR32_V1),

 25902 +    SYNTAX_NORMAL3(DIVU, DIVU, DIVU, INTREG, INTREG, INTREG, AVR32_V1),

 25903 +    SYNTAX_NORMAL_C2(EOR1, EOR, EOR1, EOR2, INTREG, INTREG, AVR32_V1),

 25904 +    SYNTAX_NORMAL_C3(EOR2, EOR, EOR2, EOR3, INTREG, INTREG, INTREG_LSL, AVR32_V1),

 25905 +    SYNTAX_NORMAL3(EOR3, EOR, EOR3, INTREG, INTREG, INTREG_LSR, AVR32_V1),

 25906 +    SYNTAX_NORMAL2(EORL, EORL, EORL, INTREG, UNSIGNED_CONST, AVR32_V1),

 25907 +    SYNTAX_NORMAL2(EORH, EORH, EORH, INTREG, UNSIGNED_CONST, AVR32_V1),

 25908 +    SYNTAX_NORMAL0(FRS, FRS, FRS, AVR32_V1),

 25909 +    SYNTAX_NORMAL1(ICALL, ICALL, ICALL, INTREG, AVR32_V1),

 25910 +    SYNTAX_NORMAL1(INCJOSP, INCJOSP, INCJOSP, JOSPINC, AVR32_V1),

 25911 +    SYNTAX_NORMAL_C2(LD_D1, LD_D, LD_D1, LD_D2, DWREG, INTREG_POSTINC, AVR32_V1),

 25912 +    SYNTAX_NORMAL_C2(LD_D2, LD_D, LD_D2, LD_D3, DWREG, INTREG_PREDEC, AVR32_V1),

 25913 +    SYNTAX_NORMAL_C2(LD_D3, LD_D, LD_D3, LD_D5, DWREG, INTREG, AVR32_V1),

 25914 +    SYNTAX_NORMAL_C2(LD_D5, LD_D, LD_D5, LD_D4, DWREG, INTREG_INDEX, AVR32_V1),

 25915 +    SYNTAX_NORMAL2(LD_D4, LD_D, LD_D4, DWREG, INTREG_SDISP, AVR32_V1),

 25916 +    SYNTAX_NORMAL_C2(LD_SB2, LD_SB, LD_SB2, LD_SB1, INTREG, INTREG_INDEX, AVR32_V1),

 25917 +    SYNTAX_NORMAL2(LD_SB1, LD_SB, LD_SB1, INTREG, INTREG_SDISP, AVR32_V1),

 25918 +    SYNTAX_NORMAL_C2(LD_UB1, LD_UB, LD_UB1, LD_UB2, INTREG, INTREG_POSTINC, AVR32_V1),

 25919 +    SYNTAX_NORMAL_C2(LD_UB2, LD_UB, LD_UB2, LD_UB5, INTREG, INTREG_PREDEC, AVR32_V1),

 25920 +    SYNTAX_NORMAL_C2(LD_UB5, LD_UB, LD_UB5, LD_UB3, INTREG, INTREG_INDEX, AVR32_V1),

 25921 +    SYNTAX_NORMAL_C2(LD_UB3, LD_UB, LD_UB3, LD_UB4, INTREG, INTREG_UDISP, AVR32_V1),

 25922 +    SYNTAX_NORMAL2(LD_UB4, LD_UB, LD_UB4, INTREG, INTREG_SDISP, AVR32_V1),

 25923 +    SYNTAX_NORMAL_C2(LD_SH1, LD_SH, LD_SH1, LD_SH2, INTREG, INTREG_POSTINC, AVR32_V1),

 25924 +    SYNTAX_NORMAL_C2(LD_SH2, LD_SH, LD_SH2, LD_SH5, INTREG, INTREG_PREDEC, AVR32_V1),

 25925 +    SYNTAX_NORMAL_C2(LD_SH5, LD_SH, LD_SH5, LD_SH3, INTREG, INTREG_INDEX, AVR32_V1),

 25926 +    SYNTAX_NORMAL_C2(LD_SH3, LD_SH, LD_SH3, LD_SH4, INTREG, INTREG_UDISP_H, AVR32_V1),

 25927 +    SYNTAX_NORMAL2(LD_SH4, LD_SH, LD_SH4, INTREG, INTREG_SDISP, AVR32_V1),

 25928 +    SYNTAX_NORMAL_C2(LD_UH1, LD_UH, LD_UH1, LD_UH2, INTREG, INTREG_POSTINC, AVR32_V1),

 25929 +    SYNTAX_NORMAL_C2(LD_UH2, LD_UH, LD_UH2, LD_UH5, INTREG, INTREG_PREDEC, AVR32_V1),

 25930 +    SYNTAX_NORMAL_C2(LD_UH5, LD_UH, LD_UH5, LD_UH3, INTREG, INTREG_INDEX, AVR32_V1),

 25931 +    SYNTAX_NORMAL_C2(LD_UH3, LD_UH, LD_UH3, LD_UH4, INTREG, INTREG_UDISP_H, AVR32_V1),

 25932 +    SYNTAX_NORMAL2(LD_UH4, LD_UH, LD_UH4, INTREG, INTREG_SDISP, AVR32_V1),

 25933 +    SYNTAX_NORMAL_C2(LD_W1, LD_W, LD_W1, LD_W2, INTREG, INTREG_POSTINC, AVR32_V1),

 25934 +    SYNTAX_NORMAL_C2(LD_W2, LD_W, LD_W2, LD_W5, INTREG, INTREG_PREDEC, AVR32_V1),

 25935 +    SYNTAX_NORMAL_C2(LD_W5, LD_W, LD_W5, LD_W6, INTREG, INTREG_INDEX, AVR32_V1),

 25936 +    SYNTAX_NORMAL_C2(LD_W6, LD_W, LD_W6, LD_W3, INTREG, INTREG_XINDEX, AVR32_V1),

 25937 +    SYNTAX_NORMAL_C2(LD_W3, LD_W, LD_W3, LD_W4, INTREG, INTREG_UDISP_W, AVR32_V1),

 25938 +    SYNTAX_NORMAL2(LD_W4, LD_W, LD_W4, INTREG, INTREG_SDISP, AVR32_V1),

 25939 +    SYNTAX_NORMAL3(LDC_D1, LDC_D, LDC_D1, CPNO, CPREG_D, INTREG_UDISP_W, AVR32_V1),

 25940 +    SYNTAX_NORMAL_C3(LDC_D2, LDC_D, LDC_D2, LDC_D1, CPNO, CPREG_D, INTREG_PREDEC, AVR32_V1),

 25941 +    SYNTAX_NORMAL_C3(LDC_D3, LDC_D, LDC_D3, LDC_D2, CPNO, CPREG_D, INTREG_INDEX, AVR32_V1),

 25942 +    SYNTAX_NORMAL3(LDC_W1, LDC_W, LDC_W1, CPNO, CPREG, INTREG_UDISP_W, AVR32_V1),

 25943 +    SYNTAX_NORMAL_C3(LDC_W2, LDC_W, LDC_W2, LDC_W1, CPNO, CPREG, INTREG_PREDEC, AVR32_V1),

 25944 +    SYNTAX_NORMAL_C3(LDC_W3, LDC_W, LDC_W3, LDC_W2, CPNO, CPREG, INTREG_INDEX, AVR32_V1),

 25945 +    SYNTAX_NORMAL2(LDC0_D, LDC0_D, LDC0_D, CPREG_D, INTREG_UDISP_W, AVR32_V1),

 25946 +    SYNTAX_NORMAL2(LDC0_W, LDC0_W, LDC0_W, CPREG, INTREG_UDISP_W, AVR32_V1),

 25947 +    SYNTAX_NORMAL_CM3(LDCM_D, LDCM_D, LDCM_D, LDCM_D_PU, CPNO, INTREG, REGLIST_CPD8, AVR32_V1),

 25948 +    SYNTAX_NORMALM3(LDCM_D_PU, LDCM_D, LDCM_D_PU, CPNO, INTREG_POSTINC, REGLIST_CPD8, AVR32_V1),

 25949 +    SYNTAX_NORMAL_CM3(LDCM_W, LDCM_W, LDCM_W, LDCM_W_PU, CPNO, INTREG, REGLIST_CP8, AVR32_V1),

 25950 +    SYNTAX_NORMALM3(LDCM_W_PU, LDCM_W, LDCM_W_PU, CPNO, INTREG_POSTINC, REGLIST_CP8, AVR32_V1),

 25951 +    SYNTAX_NORMAL2(LDDPC, LDDPC, LDDPC, INTREG, PC_UDISP_W, AVR32_V1),

 25952 +    SYNTAX_NORMAL2(LDDPC_EXT, LDDPC, LDDPC_EXT, INTREG, SIGNED_CONST, AVR32_V1),

 25953 +    SYNTAX_NORMAL2(LDDSP, LDDSP, LDDSP, INTREG, SP_UDISP_W, AVR32_V1),

 25954 +    SYNTAX_NORMAL2(LDINS_B, LDINS_B, LDINS_B, INTREG_BSEL, INTREG_SDISP, AVR32_V1),

 25955 +    SYNTAX_NORMAL2(LDINS_H, LDINS_H, LDINS_H, INTREG_HSEL, INTREG_SDISP_H, AVR32_V1),

 25956 +    SYNTAX_NORMALM1(LDM, LDM, LDM, REGLIST_LDM, AVR32_V1),

 25957 +    SYNTAX_NORMAL_CM2(LDMTS, LDMTS, LDMTS, LDMTS_PU, INTREG, REGLIST16, AVR32_V1),

 25958 +    SYNTAX_NORMALM2(LDMTS_PU, LDMTS, LDMTS_PU, INTREG_POSTINC, REGLIST16, AVR32_V1),

 25959 +    SYNTAX_NORMAL2(LDSWP_SH, LDSWP_SH, LDSWP_SH, INTREG, INTREG_SDISP_H, AVR32_V1),

 25960 +    SYNTAX_NORMAL2(LDSWP_UH, LDSWP_UH, LDSWP_UH, INTREG, INTREG_SDISP_H, AVR32_V1),

 25961 +    SYNTAX_NORMAL2(LDSWP_W, LDSWP_W, LDSWP_W, INTREG, INTREG_SDISP_W, AVR32_V1),

 25962 +    SYNTAX_NORMAL_C3(LSL1, LSL, LSL1, LSL3, INTREG, INTREG, INTREG, AVR32_V1),

 25963 +    SYNTAX_NORMAL_C3(LSL3, LSL, LSL3, LSL2, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_V1),

 25964 +    SYNTAX_NORMAL2(LSL2, LSL, LSL2, INTREG, UNSIGNED_NUMBER, AVR32_V1),

 25965 +    SYNTAX_NORMAL_C3(LSR1, LSR, LSR1, LSR3, INTREG, INTREG, INTREG, AVR32_V1),

 25966 +    SYNTAX_NORMAL_C3(LSR3, LSR, LSR3, LSR2, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_V1),

 25967 +    SYNTAX_NORMAL2(LSR2, LSR, LSR2, INTREG, UNSIGNED_NUMBER, AVR32_V1),

 25968 +    SYNTAX_NORMAL3(MAC, MAC, MAC, INTREG, INTREG, INTREG, AVR32_V1),

 25969 +    SYNTAX_NORMAL3(MACHH_D, MACHH_D, MACHH_D, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),

 25970 +    SYNTAX_NORMAL3(MACHH_W, MACHH_W, MACHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),

 25971 +    SYNTAX_NORMAL3(MACS_D, MACS_D, MACS_D, INTREG, INTREG, INTREG, AVR32_V1),

 25972 +    SYNTAX_NORMAL3(MACSATHH_W, MACSATHH_W, MACSATHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),

 25973 +    SYNTAX_NORMAL3(MACUD, MACU_D, MACUD, INTREG, INTREG, INTREG, AVR32_V1),

 25974 +    SYNTAX_NORMAL3(MACWH_D, MACWH_D, MACWH_D, INTREG, INTREG, INTREG_HSEL, AVR32_DSP),

 25975 +    SYNTAX_NORMAL3(MAX, MAX, MAX, INTREG, INTREG, INTREG, AVR32_V1),

 25976 +    SYNTAX_NORMAL1(MCALL, MCALL, MCALL, MCALL, AVR32_V1),

 25977 +    SYNTAX_NORMAL2(MFDR, MFDR, MFDR, INTREG, UNSIGNED_CONST_W, AVR32_V1),

 25978 +    SYNTAX_NORMAL2(MFSR, MFSR, MFSR, INTREG, UNSIGNED_CONST_W, AVR32_V1),

 25979 +    SYNTAX_NORMAL3(MIN, MIN, MIN, INTREG, INTREG, INTREG, AVR32_V1),

 25980 +    SYNTAX_NORMAL_C2(MOV3, MOV, MOV3, MOV1, INTREG, INTREG, AVR32_V1),

 25981 +    SYNTAX_NORMAL_C2(MOV1, MOV, MOV1, MOV2, INTREG, SIGNED_CONST, AVR32_V1),

 25982 +    SYNTAX_NORMAL2(MOV2, MOV, MOV2,INTREG, SIGNED_CONST, AVR32_V1),

 25983 +    SYNTAX_NORMAL_C2(MOVEQ1, MOVEQ, MOVEQ1, MOVEQ2, INTREG, INTREG, AVR32_V1),

 25984 +    SYNTAX_NORMAL_C2(MOVNE1, MOVNE, MOVNE1, MOVNE2, INTREG, INTREG, AVR32_V1),

 25985 +    SYNTAX_NORMAL_C2(MOVCC1, MOVCC, MOVCC1, MOVCC2, INTREG, INTREG, AVR32_V1),

 25986 +    SYNTAX_NORMAL_C2(MOVCS1, MOVCS, MOVCS1, MOVCS2, INTREG, INTREG, AVR32_V1),

 25987 +    SYNTAX_NORMAL_C2(MOVGE1, MOVGE, MOVGE1, MOVGE2, INTREG, INTREG, AVR32_V1),

 25988 +    SYNTAX_NORMAL_C2(MOVLT1, MOVLT, MOVLT1, MOVLT2, INTREG, INTREG, AVR32_V1),

 25989 +    SYNTAX_NORMAL_C2(MOVMI1, MOVMI, MOVMI1, MOVMI2, INTREG, INTREG, AVR32_V1),

 25990 +    SYNTAX_NORMAL_C2(MOVPL1, MOVPL, MOVPL1, MOVPL2, INTREG, INTREG, AVR32_V1),

 25991 +    SYNTAX_NORMAL_C2(MOVLS1, MOVLS, MOVLS1, MOVLS2, INTREG, INTREG, AVR32_V1),

 25992 +    SYNTAX_NORMAL_C2(MOVGT1, MOVGT, MOVGT1, MOVGT2, INTREG, INTREG, AVR32_V1),

 25993 +    SYNTAX_NORMAL_C2(MOVLE1, MOVLE, MOVLE1, MOVLE2, INTREG, INTREG, AVR32_V1),

 25994 +    SYNTAX_NORMAL_C2(MOVHI1, MOVHI, MOVHI1, MOVHI2, INTREG, INTREG, AVR32_V1),

 25995 +    SYNTAX_NORMAL_C2(MOVVS1, MOVVS, MOVVS1, MOVVS2, INTREG, INTREG, AVR32_V1),

 25996 +    SYNTAX_NORMAL_C2(MOVVC1, MOVVC, MOVVC1, MOVVC2, INTREG, INTREG, AVR32_V1),

 25997 +    SYNTAX_NORMAL_C2(MOVQS1, MOVQS, MOVQS1, MOVQS2, INTREG, INTREG, AVR32_V1),

 25998 +    SYNTAX_NORMAL_C2(MOVAL1, MOVAL, MOVAL1, MOVAL2, INTREG, INTREG, AVR32_V1),

 25999 +    SYNTAX_NORMAL_C2(MOVHS1, MOVHS, MOVCC1, MOVHS2, INTREG, INTREG, AVR32_V1),

 26000 +    SYNTAX_NORMAL_C2(MOVLO1, MOVLO, MOVCS1, MOVLO2, INTREG, INTREG, AVR32_V1),

 26001 +    SYNTAX_NORMAL2(MOVEQ2, MOVEQ, MOVEQ2, INTREG, SIGNED_CONST, AVR32_V1),

 26002 +    SYNTAX_NORMAL2(MOVNE2, MOVNE, MOVNE2, INTREG, SIGNED_CONST, AVR32_V1),

 26003 +    SYNTAX_NORMAL2(MOVCC2, MOVCC, MOVCC2, INTREG, SIGNED_CONST, AVR32_V1),

 26004 +    SYNTAX_NORMAL2(MOVCS2, MOVCS, MOVCS2, INTREG, SIGNED_CONST, AVR32_V1),

 26005 +    SYNTAX_NORMAL2(MOVGE2, MOVGE, MOVGE2, INTREG, SIGNED_CONST, AVR32_V1),

 26006 +    SYNTAX_NORMAL2(MOVLT2, MOVLT, MOVLT2, INTREG, SIGNED_CONST, AVR32_V1),

 26007 +    SYNTAX_NORMAL2(MOVMI2, MOVMI, MOVMI2, INTREG, SIGNED_CONST, AVR32_V1),

 26008 +    SYNTAX_NORMAL2(MOVPL2, MOVPL, MOVPL2, INTREG, SIGNED_CONST, AVR32_V1),

 26009 +    SYNTAX_NORMAL2(MOVLS2, MOVLS, MOVLS2, INTREG, SIGNED_CONST, AVR32_V1),

 26010 +    SYNTAX_NORMAL2(MOVGT2, MOVGT, MOVGT2, INTREG, SIGNED_CONST, AVR32_V1),

 26011 +    SYNTAX_NORMAL2(MOVLE2, MOVLE, MOVLE2, INTREG, SIGNED_CONST, AVR32_V1),

 26012 +    SYNTAX_NORMAL2(MOVHI2, MOVHI, MOVHI2, INTREG, SIGNED_CONST, AVR32_V1),

 26013 +    SYNTAX_NORMAL2(MOVVS2, MOVVS, MOVVS2, INTREG, SIGNED_CONST, AVR32_V1),

 26014 +    SYNTAX_NORMAL2(MOVVC2, MOVVC, MOVVC2, INTREG, SIGNED_CONST, AVR32_V1),

 26015 +    SYNTAX_NORMAL2(MOVQS2, MOVQS, MOVQS2, INTREG, SIGNED_CONST, AVR32_V1),

 26016 +    SYNTAX_NORMAL2(MOVAL2, MOVAL, MOVAL2, INTREG, SIGNED_CONST, AVR32_V1),

 26017 +    SYNTAX_NORMAL2(MOVHS2, MOVHS, MOVCC2, INTREG, SIGNED_CONST, AVR32_V1),

 26018 +    SYNTAX_NORMAL2(MOVLO2, MOVLO, MOVCS2, INTREG, SIGNED_CONST, AVR32_V1),

 26019 +    SYNTAX_NORMAL2(MTDR, MTDR, MTDR, UNSIGNED_CONST_W, INTREG, AVR32_V1),

 26020 +    SYNTAX_NORMAL2(MTSR, MTSR, MTSR, UNSIGNED_CONST_W, INTREG, AVR32_V1),

 26021 +    SYNTAX_NORMAL_C2(MUL1, MUL, MUL1, MUL2, INTREG, INTREG, AVR32_V1),

 26022 +    SYNTAX_NORMAL_C3(MUL2, MUL, MUL2, MUL3, INTREG, INTREG, INTREG, AVR32_V1),

 26023 +    SYNTAX_NORMAL3(MUL3, MUL, MUL3, INTREG, INTREG, SIGNED_CONST, AVR32_V1),

 26024 +    SYNTAX_NORMAL3(MULHH_W, MULHH_W, MULHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),

 26025 +    SYNTAX_NORMAL3(MULNHH_W, MULNHH_W, MULNHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),

 26026 +    SYNTAX_NORMAL3(MULNWH_D, MULNWH_D, MULNWH_D, INTREG, INTREG, INTREG_HSEL, AVR32_DSP),

 26027 +    SYNTAX_NORMAL3(MULSD, MULS_D, MULSD, INTREG, INTREG, INTREG, AVR32_V1),

 26028 +    SYNTAX_NORMAL3(MULSATHH_H, MULSATHH_H, MULSATHH_H, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),

 26029 +    SYNTAX_NORMAL3(MULSATHH_W, MULSATHH_W, MULSATHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),

 26030 +    SYNTAX_NORMAL3(MULSATRNDHH_H, MULSATRNDHH_H, MULSATRNDHH_H, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),

 26031 +    SYNTAX_NORMAL3(MULSATRNDWH_W, MULSATRNDWH_W, MULSATRNDWH_W, INTREG, INTREG, INTREG_HSEL, AVR32_DSP),

 26032 +    SYNTAX_NORMAL3(MULSATWH_W, MULSATWH_W, MULSATWH_W, INTREG, INTREG, INTREG_HSEL, AVR32_DSP),

 26033 +    SYNTAX_NORMAL3(MULU_D, MULU_D, MULU_D, INTREG, INTREG, INTREG, AVR32_V1),

 26034 +    SYNTAX_NORMAL3(MULWH_D, MULWH_D, MULWH_D, INTREG, INTREG, INTREG_HSEL, AVR32_DSP),

 26035 +    SYNTAX_NORMAL1(MUSFR, MUSFR, MUSFR, INTREG, AVR32_V1),

 26036 +    SYNTAX_NORMAL1(MUSTR, MUSTR, MUSTR, INTREG, AVR32_V1),

 26037 +    SYNTAX_NORMAL3(MVCR_D, MVCR_D, MVCR_D, CPNO, DWREG, CPREG_D, AVR32_V1),

 26038 +    SYNTAX_NORMAL3(MVCR_W, MVCR_W, MVCR_W, CPNO, INTREG, CPREG, AVR32_V1),

 26039 +    SYNTAX_NORMAL3(MVRC_D, MVRC_D, MVRC_D, CPNO, CPREG_D, DWREG, AVR32_V1),

 26040 +    SYNTAX_NORMAL3(MVRC_W, MVRC_W, MVRC_W, CPNO, CPREG, INTREG, AVR32_V1),

 26041 +    SYNTAX_NORMAL1(NEG, NEG, NEG, INTREG, AVR32_V1),

 26042 +    SYNTAX_NORMAL0(NOP, NOP, NOP, AVR32_V1),

 26043 +    SYNTAX_NORMAL_C2(OR1, OR, OR1, OR2, INTREG, INTREG, AVR32_V1),

 26044 +    SYNTAX_NORMAL_C3(OR2, OR, OR2, OR3, INTREG, INTREG, INTREG_LSL, AVR32_V1),

 26045 +    SYNTAX_NORMAL3(OR3, OR, OR3, INTREG, INTREG, INTREG_LSR, AVR32_V1),

 26046 +    SYNTAX_NORMAL2(ORH, ORH, ORH, INTREG, UNSIGNED_CONST, AVR32_V1),

 26047 +    SYNTAX_NORMAL2(ORL, ORL, ORL, INTREG, UNSIGNED_CONST, AVR32_V1),

 26048 +    SYNTAX_NORMAL2(PABS_SB, PABS_SB, PABS_SB, INTREG, INTREG, AVR32_SIMD),

 26049 +    SYNTAX_NORMAL2(PABS_SH, PABS_SH, PABS_SH, INTREG, INTREG, AVR32_SIMD),

 26050 +    SYNTAX_NORMAL3(PACKSH_SB, PACKSH_SB, PACKSH_SB, INTREG, INTREG, INTREG, AVR32_SIMD),

 26051 +    SYNTAX_NORMAL3(PACKSH_UB, PACKSH_UB, PACKSH_UB, INTREG, INTREG, INTREG, AVR32_SIMD),

 26052 +    SYNTAX_NORMAL3(PACKW_SH, PACKW_SH, PACKW_SH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26053 +    SYNTAX_NORMAL3(PADD_B, PADD_B, PADD_B, INTREG, INTREG, INTREG, AVR32_SIMD),

 26054 +    SYNTAX_NORMAL3(PADD_H, PADD_H, PADD_H, INTREG, INTREG, INTREG, AVR32_SIMD),

 26055 +    SYNTAX_NORMAL3(PADDH_SH, PADDH_SH, PADDH_SH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26056 +    SYNTAX_NORMAL3(PADDH_UB, PADDH_UB, PADDH_UB, INTREG, INTREG, INTREG, AVR32_SIMD),

 26057 +    SYNTAX_NORMAL3(PADDS_SB, PADDS_SB, PADDS_SB, INTREG, INTREG, INTREG, AVR32_SIMD),

 26058 +    SYNTAX_NORMAL3(PADDS_SH, PADDS_SH, PADDS_SH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26059 +    SYNTAX_NORMAL3(PADDS_UB, PADDS_UB, PADDS_UB, INTREG, INTREG, INTREG, AVR32_SIMD),

 26060 +    SYNTAX_NORMAL3(PADDS_UH, PADDS_UH, PADDS_UH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26061 +    SYNTAX_NORMAL3(PADDSUB_H, PADDSUB_H, PADDSUB_H, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),

 26062 +    SYNTAX_NORMAL3(PADDSUBH_SH, PADDSUBH_SH, PADDSUBH_SH, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),

 26063 +    SYNTAX_NORMAL3(PADDSUBS_SH, PADDSUBS_SH, PADDSUBS_SH, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),

 26064 +    SYNTAX_NORMAL3(PADDSUBS_UH, PADDSUBS_UH, PADDSUBS_UH, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),

 26065 +    SYNTAX_NORMAL3(PADDX_H, PADDX_H, PADDX_H, INTREG, INTREG, INTREG, AVR32_SIMD),

 26066 +    SYNTAX_NORMAL3(PADDXH_SH, PADDXH_SH, PADDXH_SH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26067 +    SYNTAX_NORMAL3(PADDXS_SH, PADDXS_SH, PADDXS_SH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26068 +    SYNTAX_NORMAL3(PADDXS_UH, PADDXS_UH, PADDXS_UH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26069 +    SYNTAX_NORMAL3(PASR_B, PASR_B, PASR_B, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_SIMD),

 26070 +    SYNTAX_NORMAL3(PASR_H, PASR_H, PASR_H, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_SIMD),

 26071 +    SYNTAX_NORMAL3(PAVG_SH, PAVG_SH, PAVG_SH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26072 +    SYNTAX_NORMAL3(PAVG_UB, PAVG_UB, PAVG_UB, INTREG, INTREG, INTREG, AVR32_SIMD),

 26073 +    SYNTAX_NORMAL3(PLSL_B, PLSL_B, PLSL_B, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_SIMD),

 26074 +    SYNTAX_NORMAL3(PLSL_H, PLSL_H, PLSL_H, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_SIMD),

 26075 +    SYNTAX_NORMAL3(PLSR_B, PLSR_B, PLSR_B, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_SIMD),

 26076 +    SYNTAX_NORMAL3(PLSR_H, PLSR_H, PLSR_H, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_SIMD),

 26077 +    SYNTAX_NORMAL3(PMAX_SH, PMAX_SH, PMAX_SH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26078 +    SYNTAX_NORMAL3(PMAX_UB, PMAX_UB, PMAX_UB, INTREG, INTREG, INTREG, AVR32_SIMD),

 26079 +    SYNTAX_NORMAL3(PMIN_SH, PMIN_SH, PMIN_SH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26080 +    SYNTAX_NORMAL3(PMIN_UB, PMIN_UB, PMIN_UB, INTREG, INTREG, INTREG, AVR32_SIMD),

 26081 +    SYNTAX_NORMAL0(POPJC, POPJC, POPJC, AVR32_V1),

 26082 +    SYNTAX_NORMAL_CM1(POPM, POPM, POPM, POPM_E, REGLIST9, AVR32_V1),

 26083 +    SYNTAX_NORMALM1(POPM_E, POPM, POPM_E, REGLIST16, AVR32_V1),

 26084 +    SYNTAX_NORMAL1(PREF, PREF, PREF, INTREG_SDISP, AVR32_V1),

 26085 +    SYNTAX_NORMAL3(PSAD, PSAD, PSAD, INTREG, INTREG, INTREG, AVR32_SIMD),

 26086 +    SYNTAX_NORMAL3(PSUB_B, PSUB_B, PSUB_B, INTREG, INTREG, INTREG, AVR32_SIMD),

 26087 +    SYNTAX_NORMAL3(PSUB_H, PSUB_H, PSUB_H, INTREG, INTREG, INTREG, AVR32_SIMD),

 26088 +    SYNTAX_NORMAL3(PSUBADD_H, PSUBADD_H, PSUBADD_H, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),

 26089 +    SYNTAX_NORMAL3(PSUBADDH_SH, PSUBADDH_SH, PSUBADDH_SH, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),

 26090 +    SYNTAX_NORMAL3(PSUBADDS_SH, PSUBADDS_SH, PSUBADDS_SH, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),

 26091 +    SYNTAX_NORMAL3(PSUBADDS_UH, PSUBADDS_UH, PSUBADDS_UH, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),

 26092 +    SYNTAX_NORMAL3(PSUBH_SH, PSUBH_SH, PSUBH_SH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26093 +    SYNTAX_NORMAL3(PSUBH_UB, PSUBH_UB, PSUBH_UB, INTREG, INTREG, INTREG, AVR32_SIMD),

 26094 +    SYNTAX_NORMAL3(PSUBS_SB, PSUBS_SB, PSUBS_SB, INTREG, INTREG, INTREG, AVR32_SIMD),

 26095 +    SYNTAX_NORMAL3(PSUBS_SH, PSUBS_SH, PSUBS_SH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26096 +    SYNTAX_NORMAL3(PSUBS_UB, PSUBS_UB, PSUBS_UB, INTREG, INTREG, INTREG, AVR32_SIMD),

 26097 +    SYNTAX_NORMAL3(PSUBS_UH, PSUBS_UH, PSUBS_UH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26098 +    SYNTAX_NORMAL3(PSUBX_H, PSUBX_H, PSUBX_H, INTREG, INTREG, INTREG, AVR32_SIMD),

 26099 +    SYNTAX_NORMAL3(PSUBXH_SH, PSUBXH_SH, PSUBXH_SH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26100 +    SYNTAX_NORMAL3(PSUBXS_SH, PSUBXS_SH, PSUBXS_SH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26101 +    SYNTAX_NORMAL3(PSUBXS_UH, PSUBXS_UH, PSUBXS_UH, INTREG, INTREG, INTREG, AVR32_SIMD),

 26102 +    SYNTAX_NORMAL2(PUNPCKSB_H, PUNPCKSB_H, PUNPCKSB_H, INTREG, INTREG_HSEL, AVR32_SIMD),

 26103 +    SYNTAX_NORMAL2(PUNPCKUB_H, PUNPCKUB_H, PUNPCKUB_H, INTREG, INTREG_HSEL, AVR32_SIMD),

 26104 +    SYNTAX_NORMAL0(PUSHJC, PUSHJC, PUSHJC, AVR32_V1),

 26105 +    SYNTAX_NORMAL_CM1(PUSHM, PUSHM, PUSHM, PUSHM_E, REGLIST8, AVR32_V1),

 26106 +    SYNTAX_NORMALM1(PUSHM_E, PUSHM, PUSHM_E, REGLIST16, AVR32_V1),

 26107 +    SYNTAX_NORMAL_C1(RCALL1, RCALL, RCALL1, RCALL2, JMPLABEL, AVR32_V1),

 26108 +    SYNTAX_NORMAL1(RCALL2, RCALL, RCALL2, JMPLABEL, AVR32_V1),

 26109 +    SYNTAX_NORMAL1(RETEQ, RETEQ, RETEQ, RETVAL, AVR32_V1),

 26110 +    SYNTAX_NORMAL1(RETNE, RETNE, RETNE, RETVAL, AVR32_V1),

 26111 +    SYNTAX_NORMAL1(RETCC, RETCC, RETCC, RETVAL, AVR32_V1),

 26112 +    SYNTAX_NORMAL1(RETCS, RETCS, RETCS, RETVAL, AVR32_V1),

 26113 +    SYNTAX_NORMAL1(RETGE, RETGE, RETGE, RETVAL, AVR32_V1),

 26114 +    SYNTAX_NORMAL1(RETLT, RETLT, RETLT, RETVAL, AVR32_V1),

 26115 +    SYNTAX_NORMAL1(RETMI, RETMI, RETMI, RETVAL, AVR32_V1),

 26116 +    SYNTAX_NORMAL1(RETPL, RETPL, RETPL, RETVAL, AVR32_V1),

 26117 +    SYNTAX_NORMAL1(RETLS, RETLS, RETLS, RETVAL, AVR32_V1),

 26118 +    SYNTAX_NORMAL1(RETGT, RETGT, RETGT, RETVAL, AVR32_V1),

 26119 +    SYNTAX_NORMAL1(RETLE, RETLE, RETLE, RETVAL, AVR32_V1),

 26120 +    SYNTAX_NORMAL1(RETHI, RETHI, RETHI, RETVAL, AVR32_V1),

 26121 +    SYNTAX_NORMAL1(RETVS, RETVS, RETVS, RETVAL, AVR32_V1),

 26122 +    SYNTAX_NORMAL1(RETVC, RETVC, RETVC, RETVAL, AVR32_V1),

 26123 +    SYNTAX_NORMAL1(RETQS, RETQS, RETQS, RETVAL, AVR32_V1),

 26124 +    SYNTAX_NORMAL1(RETAL, RETAL, RETAL, RETVAL, AVR32_V1),

 26125 +    SYNTAX_NORMAL1(RETHS, RETHS, RETCC, RETVAL, AVR32_V1),

 26126 +    SYNTAX_NORMAL1(RETLO, RETLO, RETCS, RETVAL, AVR32_V1),

 26127 +    SYNTAX_NORMAL0(RETD, RETD, RETD, AVR32_V1),

 26128 +    SYNTAX_NORMAL0(RETE, RETE, RETE, AVR32_V1),

 26129 +    SYNTAX_NORMAL0(RETJ, RETJ, RETJ, AVR32_V1),

 26130 +    SYNTAX_NORMAL0(RETS, RETS, RETS, AVR32_V1),

 26131 +    SYNTAX_NORMAL1(RJMP, RJMP, RJMP, JMPLABEL, AVR32_V1),

 26132 +    SYNTAX_NORMAL1(ROL, ROL, ROL, INTREG, AVR32_V1),

 26133 +    SYNTAX_NORMAL1(ROR, ROR, ROR, INTREG, AVR32_V1),

 26134 +    SYNTAX_NORMAL_C2(RSUB1, RSUB, RSUB1, RSUB2, INTREG, INTREG, AVR32_V1),

 26135 +    SYNTAX_NORMAL3(RSUB2, RSUB, RSUB2, INTREG, INTREG, SIGNED_CONST, AVR32_V1),

 26136 +    SYNTAX_NORMAL3(SATADD_H, SATADD_H, SATADD_H, INTREG, INTREG, INTREG,  AVR32_DSP),

 26137 +    SYNTAX_NORMAL3(SATADD_W, SATADD_W, SATADD_W, INTREG, INTREG, INTREG, AVR32_DSP),

 26138 +    SYNTAX_NORMAL2(SATRNDS, SATRNDS, SATRNDS, INTREG_LSR, UNSIGNED_NUMBER, AVR32_DSP),

 26139 +    SYNTAX_NORMAL2(SATRNDU, SATRNDU, SATRNDU, INTREG_LSR, UNSIGNED_NUMBER, AVR32_DSP),

 26140 +    SYNTAX_NORMAL2(SATS, SATS, SATS, INTREG_LSR, UNSIGNED_NUMBER, AVR32_DSP),

 26141 +    SYNTAX_NORMAL3(SATSUB_H, SATSUB_H, SATSUB_H, INTREG, INTREG, INTREG, AVR32_DSP),

 26142 +    SYNTAX_NORMAL_C3(SATSUB_W1, SATSUB_W, SATSUB_W1, SATSUB_W2, INTREG, INTREG, INTREG, AVR32_DSP),

 26143 +    SYNTAX_NORMAL3(SATSUB_W2, SATSUB_W, SATSUB_W2, INTREG, INTREG, SIGNED_CONST, AVR32_DSP),

 26144 +    SYNTAX_NORMAL2(SATU, SATU, SATU, INTREG_LSR, UNSIGNED_NUMBER, AVR32_V1),

 26145 +    SYNTAX_NORMAL3(SBC, SBC, SBC, INTREG, INTREG, INTREG, AVR32_V1),

 26146 +    SYNTAX_NORMAL2(SBR, SBR, SBR, INTREG, UNSIGNED_NUMBER, AVR32_V1),

 26147 +    SYNTAX_NORMAL0(SCALL, SCALL, SCALL, AVR32_V1),

 26148 +    SYNTAX_NORMAL1(SCR, SCR, SCR, INTREG, AVR32_V1),

 26149 +    SYNTAX_NORMAL1(SLEEP, SLEEP, SLEEP, UNSIGNED_CONST, AVR32_V1),

 26150 +    SYNTAX_NORMAL1(SREQ, SREQ, SREQ, INTREG, AVR32_V1),

 26151 +    SYNTAX_NORMAL1(SRNE, SRNE, SRNE, INTREG, AVR32_V1),

 26152 +    SYNTAX_NORMAL1(SRCC, SRCC, SRCC, INTREG, AVR32_V1),

 26153 +    SYNTAX_NORMAL1(SRCS, SRCS, SRCS, INTREG, AVR32_V1),

 26154 +    SYNTAX_NORMAL1(SRGE, SRGE, SRGE, INTREG, AVR32_V1),

 26155 +    SYNTAX_NORMAL1(SRLT, SRLT, SRLT, INTREG, AVR32_V1),

 26156 +    SYNTAX_NORMAL1(SRMI, SRMI, SRMI, INTREG, AVR32_V1),

 26157 +    SYNTAX_NORMAL1(SRPL, SRPL, SRPL, INTREG, AVR32_V1),

 26158 +    SYNTAX_NORMAL1(SRLS, SRLS, SRLS, INTREG, AVR32_V1),

 26159 +    SYNTAX_NORMAL1(SRGT, SRGT, SRGT, INTREG, AVR32_V1),

 26160 +    SYNTAX_NORMAL1(SRLE, SRLE, SRLE, INTREG, AVR32_V1),

 26161 +    SYNTAX_NORMAL1(SRHI, SRHI, SRHI, INTREG, AVR32_V1),

 26162 +    SYNTAX_NORMAL1(SRVS, SRVS, SRVS, INTREG, AVR32_V1),

 26163 +    SYNTAX_NORMAL1(SRVC, SRVC, SRVC, INTREG, AVR32_V1),

 26164 +    SYNTAX_NORMAL1(SRQS, SRQS, SRQS, INTREG, AVR32_V1),

 26165 +    SYNTAX_NORMAL1(SRAL, SRAL, SRAL, INTREG, AVR32_V1),

 26166 +    SYNTAX_NORMAL1(SRHS, SRHS, SRCC, INTREG, AVR32_V1),

 26167 +    SYNTAX_NORMAL1(SRLO, SRLO, SRCS, INTREG, AVR32_V1),

 26168 +    SYNTAX_NORMAL1(SSRF, SSRF, SSRF, UNSIGNED_NUMBER, AVR32_V1),

 26169 +    SYNTAX_NORMAL_C2(ST_B1, ST_B, ST_B1, ST_B2, INTREG_POSTINC, INTREG, AVR32_V1),

 26170 +    SYNTAX_NORMAL_C2(ST_B2, ST_B, ST_B2, ST_B5, INTREG_PREDEC, INTREG, AVR32_V1),

 26171 +    SYNTAX_NORMAL_C2(ST_B5, ST_B, ST_B5, ST_B3, INTREG_INDEX, INTREG, AVR32_V1),

 26172 +    SYNTAX_NORMAL_C2(ST_B3, ST_B, ST_B3, ST_B4, INTREG_UDISP, INTREG, AVR32_V1),

 26173 +    SYNTAX_NORMAL2(ST_B4, ST_B, ST_B4, INTREG_SDISP, INTREG, AVR32_V1),

 26174 +    SYNTAX_NORMAL_C2(ST_D1, ST_D, ST_D1, ST_D2, INTREG_POSTINC, DWREG, AVR32_V1),

 26175 +    SYNTAX_NORMAL_C2(ST_D2, ST_D, ST_D2, ST_D3, INTREG_PREDEC, DWREG, AVR32_V1),

 26176 +    SYNTAX_NORMAL_C2(ST_D3, ST_D, ST_D3, ST_D5, INTREG, DWREG, AVR32_V1),

 26177 +    SYNTAX_NORMAL_C2(ST_D5, ST_D, ST_D5, ST_D4, INTREG_INDEX, DWREG, AVR32_V1),

 26178 +    SYNTAX_NORMAL2(ST_D4, ST_D, ST_D4, INTREG_SDISP, DWREG, AVR32_V1),

 26179 +    SYNTAX_NORMAL_C2(ST_H1, ST_H, ST_H1, ST_H2, INTREG_POSTINC, INTREG, AVR32_V1),

 26180 +    SYNTAX_NORMAL_C2(ST_H2, ST_H, ST_H2, ST_H5, INTREG_PREDEC, INTREG, AVR32_V1),

 26181 +    SYNTAX_NORMAL_C2(ST_H5, ST_H, ST_H5, ST_H3, INTREG_INDEX, INTREG, AVR32_V1),

 26182 +    SYNTAX_NORMAL_C2(ST_H3, ST_H, ST_H3, ST_H4, INTREG_UDISP_H, INTREG, AVR32_V1),

 26183 +    SYNTAX_NORMAL2(ST_H4, ST_H, ST_H4, INTREG_SDISP, INTREG, AVR32_V1),

 26184 +    SYNTAX_NORMAL_C2(ST_W1, ST_W, ST_W1, ST_W2, INTREG_POSTINC, INTREG, AVR32_V1),

 26185 +    SYNTAX_NORMAL_C2(ST_W2, ST_W, ST_W2, ST_W5, INTREG_PREDEC, INTREG, AVR32_V1),

 26186 +    SYNTAX_NORMAL_C2(ST_W5, ST_W, ST_W5, ST_W3, INTREG_INDEX, INTREG, AVR32_V1),

 26187 +    SYNTAX_NORMAL_C2(ST_W3, ST_W, ST_W3, ST_W4, INTREG_UDISP_W, INTREG, AVR32_V1),

 26188 +    SYNTAX_NORMAL2(ST_W4, ST_W, ST_W4, INTREG_SDISP, INTREG, AVR32_V1),

 26189 +    SYNTAX_NORMAL3(STC_D1, STC_D, STC_D1, CPNO, INTREG_UDISP_W, CPREG_D, AVR32_V1),

 26190 +    SYNTAX_NORMAL_C3(STC_D2, STC_D, STC_D2, STC_D1, CPNO, INTREG_POSTINC, CPREG_D, AVR32_V1),

 26191 +    SYNTAX_NORMAL_C3(STC_D3, STC_D, STC_D3, STC_D2, CPNO, INTREG_INDEX, CPREG_D, AVR32_V1),

 26192 +    SYNTAX_NORMAL3(STC_W1, STC_W, STC_W1, CPNO, INTREG_UDISP_W, CPREG, AVR32_V1),

 26193 +    SYNTAX_NORMAL_C3(STC_W2, STC_W, STC_W2, STC_W1, CPNO, INTREG_POSTINC, CPREG, AVR32_V1),

 26194 +    SYNTAX_NORMAL_C3(STC_W3, STC_W, STC_W3, STC_W2, CPNO, INTREG_INDEX, CPREG, AVR32_V1),

 26195 +    SYNTAX_NORMAL2(STC0_D, STC0_D, STC0_D, INTREG_UDISP_W, CPREG_D, AVR32_V1),

 26196 +    SYNTAX_NORMAL2(STC0_W, STC0_W, STC0_W, INTREG_UDISP_W, CPREG, AVR32_V1),

 26197 +    SYNTAX_NORMAL_CM3(STCM_D, STCM_D, STCM_D, STCM_D_PU, CPNO, INTREG, REGLIST_CPD8, AVR32_V1),

 26198 +    SYNTAX_NORMALM3(STCM_D_PU, STCM_D, STCM_D_PU, CPNO, INTREG_PREDEC, REGLIST_CPD8, AVR32_V1),

 26199 +    SYNTAX_NORMAL_CM3(STCM_W, STCM_W, STCM_W, STCM_W_PU, CPNO, INTREG, REGLIST_CP8, AVR32_V1),

 26200 +    SYNTAX_NORMALM3(STCM_W_PU, STCM_W, STCM_W_PU, CPNO, INTREG_PREDEC, REGLIST_CP8, AVR32_V1),

 26201 +    SYNTAX_NORMAL2(STCOND, STCOND, STCOND, INTREG_SDISP, INTREG, AVR32_V1),

 26202 +    SYNTAX_NORMAL2(STDSP, STDSP, STDSP, SP_UDISP_W, INTREG, AVR32_V1),

 26203 +    SYNTAX_NORMAL_C3(STHH_W2, STHH_W, STHH_W2, STHH_W1, INTREG_INDEX, INTREG_HSEL, INTREG_HSEL, AVR32_V1),

 26204 +    SYNTAX_NORMAL3(STHH_W1, STHH_W, STHH_W1, INTREG_UDISP_W, INTREG_HSEL, INTREG_HSEL, AVR32_V1),

 26205 +    SYNTAX_NORMAL_CM2(STM, STM, STM, STM_PU, INTREG, REGLIST16, AVR32_V1),

 26206 +    SYNTAX_NORMALM2(STM_PU, STM, STM_PU, INTREG_PREDEC, REGLIST16, AVR32_V1),

 26207 +    SYNTAX_NORMAL_CM2(STMTS, STMTS, STMTS, STMTS_PU, INTREG, REGLIST16, AVR32_V1),

 26208 +    SYNTAX_NORMALM2(STMTS_PU, STMTS, STMTS_PU, INTREG_PREDEC, REGLIST16, AVR32_V1),

 26209 +    SYNTAX_NORMAL2(STSWP_H, STSWP_H, STSWP_H, INTREG_SDISP_H, INTREG, AVR32_V1),

 26210 +    SYNTAX_NORMAL2(STSWP_W, STSWP_W, STSWP_W, INTREG_SDISP_W, INTREG, AVR32_V1),

 26211 +    SYNTAX_NORMAL_C2(SUB1, SUB, SUB1, SUB2, INTREG, INTREG, AVR32_V1),

 26212 +    SYNTAX_NORMAL_C3(SUB2, SUB, SUB2, SUB5, INTREG, INTREG, INTREG_LSL, AVR32_V1),

 26213 +    SYNTAX_NORMAL_C3(SUB5, SUB, SUB5, SUB3_SP, INTREG, INTREG, SIGNED_CONST, AVR32_V1),

 26214 +    SYNTAX_NORMAL_C2(SUB3_SP, SUB, SUB3_SP, SUB3, SP, SIGNED_CONST_W, AVR32_V1),

 26215 +    SYNTAX_NORMAL_C2(SUB3, SUB, SUB3, SUB4, INTREG, SIGNED_CONST, AVR32_V1),

 26216 +    SYNTAX_NORMAL2(SUB4, SUB, SUB4, INTREG, SIGNED_CONST, AVR32_V1),

 26217 +    SYNTAX_NORMAL_C2(SUBEQ, SUBEQ, SUBEQ, SUB2EQ, INTREG, SIGNED_CONST, AVR32_V1),

 26218 +    SYNTAX_NORMAL_C2(SUBNE, SUBNE, SUBNE, SUB2NE, INTREG, SIGNED_CONST, AVR32_V1),

 26219 +    SYNTAX_NORMAL_C2(SUBCC, SUBCC, SUBCC, SUB2CC, INTREG, SIGNED_CONST, AVR32_V1),

 26220 +    SYNTAX_NORMAL_C2(SUBCS, SUBCS, SUBCS, SUB2CS, INTREG, SIGNED_CONST, AVR32_V1),

 26221 +    SYNTAX_NORMAL_C2(SUBGE, SUBGE, SUBGE, SUB2GE, INTREG, SIGNED_CONST, AVR32_V1),

 26222 +    SYNTAX_NORMAL_C2(SUBLT, SUBLT, SUBLT, SUB2LT, INTREG, SIGNED_CONST, AVR32_V1),

 26223 +    SYNTAX_NORMAL_C2(SUBMI, SUBMI, SUBMI, SUB2MI, INTREG, SIGNED_CONST, AVR32_V1),

 26224 +    SYNTAX_NORMAL_C2(SUBPL, SUBPL, SUBPL, SUB2PL, INTREG, SIGNED_CONST, AVR32_V1),

 26225 +    SYNTAX_NORMAL_C2(SUBLS, SUBLS, SUBLS, SUB2LS, INTREG, SIGNED_CONST, AVR32_V1),

 26226 +    SYNTAX_NORMAL_C2(SUBGT, SUBGT, SUBGT, SUB2GT, INTREG, SIGNED_CONST, AVR32_V1),

 26227 +    SYNTAX_NORMAL_C2(SUBLE, SUBLE, SUBLE, SUB2LE, INTREG, SIGNED_CONST, AVR32_V1),

 26228 +    SYNTAX_NORMAL_C2(SUBHI, SUBHI, SUBHI, SUB2HI, INTREG, SIGNED_CONST, AVR32_V1),

 26229 +    SYNTAX_NORMAL_C2(SUBVS, SUBVS, SUBVS, SUB2VS, INTREG, SIGNED_CONST, AVR32_V1),

 26230 +    SYNTAX_NORMAL_C2(SUBVC, SUBVC, SUBVC, SUB2VC, INTREG, SIGNED_CONST, AVR32_V1),

 26231 +    SYNTAX_NORMAL_C2(SUBQS, SUBQS, SUBQS, SUB2QS, INTREG, SIGNED_CONST, AVR32_V1),

 26232 +    SYNTAX_NORMAL_C2(SUBAL, SUBAL, SUBAL, SUB2AL, INTREG, SIGNED_CONST, AVR32_V1),

 26233 +    SYNTAX_NORMAL_C2(SUBHS, SUBHS, SUBCC, SUB2CC, INTREG, SIGNED_CONST, AVR32_V1),

 26234 +    SYNTAX_NORMAL_C2(SUBLO, SUBLO, SUBCS, SUB2CS, INTREG, SIGNED_CONST, AVR32_V1),

 26235 +    SYNTAX_NORMAL2(SUBFEQ, SUBFEQ, SUBFEQ, INTREG, SIGNED_CONST, AVR32_V1),

 26236 +    SYNTAX_NORMAL2(SUBFNE, SUBFNE, SUBFNE, INTREG, SIGNED_CONST, AVR32_V1),

 26237 +    SYNTAX_NORMAL2(SUBFCC, SUBFCC, SUBFCC, INTREG, SIGNED_CONST, AVR32_V1),

 26238 +    SYNTAX_NORMAL2(SUBFCS, SUBFCS, SUBFCS, INTREG, SIGNED_CONST, AVR32_V1),

 26239 +    SYNTAX_NORMAL2(SUBFGE, SUBFGE, SUBFGE, INTREG, SIGNED_CONST, AVR32_V1),

 26240 +    SYNTAX_NORMAL2(SUBFLT, SUBFLT, SUBFLT, INTREG, SIGNED_CONST, AVR32_V1),

 26241 +    SYNTAX_NORMAL2(SUBFMI, SUBFMI, SUBFMI, INTREG, SIGNED_CONST, AVR32_V1),

 26242 +    SYNTAX_NORMAL2(SUBFPL, SUBFPL, SUBFPL, INTREG, SIGNED_CONST, AVR32_V1),

 26243 +    SYNTAX_NORMAL2(SUBFLS, SUBFLS, SUBFLS, INTREG, SIGNED_CONST, AVR32_V1),

 26244 +    SYNTAX_NORMAL2(SUBFGT, SUBFGT, SUBFGT, INTREG, SIGNED_CONST, AVR32_V1),

 26245 +    SYNTAX_NORMAL2(SUBFLE, SUBFLE, SUBFLE, INTREG, SIGNED_CONST, AVR32_V1),

 26246 +    SYNTAX_NORMAL2(SUBFHI, SUBFHI, SUBFHI, INTREG, SIGNED_CONST, AVR32_V1),

 26247 +    SYNTAX_NORMAL2(SUBFVS, SUBFVS, SUBFVS, INTREG, SIGNED_CONST, AVR32_V1),

 26248 +    SYNTAX_NORMAL2(SUBFVC, SUBFVC, SUBFVC, INTREG, SIGNED_CONST, AVR32_V1),

 26249 +    SYNTAX_NORMAL2(SUBFQS, SUBFQS, SUBFQS, INTREG, SIGNED_CONST, AVR32_V1),

 26250 +    SYNTAX_NORMAL2(SUBFAL, SUBFAL, SUBFAL, INTREG, SIGNED_CONST, AVR32_V1),

 26251 +    SYNTAX_NORMAL2(SUBFHS, SUBFHS, SUBFCC, INTREG, SIGNED_CONST, AVR32_V1),

 26252 +    SYNTAX_NORMAL2(SUBFLO, SUBFLO, SUBFCS, INTREG, SIGNED_CONST, AVR32_V1),

 26253 +    SYNTAX_NORMAL3(SUBHH_W, SUBHH_W, SUBHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),

 26254 +    SYNTAX_NORMAL1(SWAP_B, SWAP_B, SWAP_B, INTREG, AVR32_V1),

 26255 +    SYNTAX_NORMAL1(SWAP_BH, SWAP_BH, SWAP_BH, INTREG, AVR32_V1),

 26256 +    SYNTAX_NORMAL1(SWAP_H, SWAP_H, SWAP_H, INTREG, AVR32_V1),

 26257 +    SYNTAX_NORMAL1(SYNC, SYNC, SYNC, UNSIGNED_CONST, AVR32_V1),

 26258 +    SYNTAX_NORMAL0(TLBR, TLBR, TLBR, AVR32_V1),

 26259 +    SYNTAX_NORMAL0(TLBS, TLBS, TLBS, AVR32_V1),

 26260 +    SYNTAX_NORMAL0(TLBW, TLBW, TLBW, AVR32_V1),

 26261 +    SYNTAX_NORMAL1(TNBZ, TNBZ, TNBZ, INTREG, AVR32_V1),

 26262 +    SYNTAX_NORMAL2(TST, TST, TST, INTREG, INTREG, AVR32_V1),

 26263 +    SYNTAX_NORMAL3(XCHG, XCHG, XCHG, INTREG, INTREG, INTREG, AVR32_V1),

 26264 +    SYNTAX_NORMAL2(MEMC, MEMC, MEMC, SIGNED_CONST_W, UNSIGNED_NUMBER, AVR32_RMW),

 26265 +    SYNTAX_NORMAL2(MEMS, MEMS, MEMS, SIGNED_CONST_W, UNSIGNED_NUMBER, AVR32_RMW),

 26266 +    SYNTAX_NORMAL2(MEMT, MEMT, MEMT, SIGNED_CONST_W, UNSIGNED_NUMBER, AVR32_RMW),

 26267 +    SYNTAX_FP(FADD, 3),

 26268 +    SYNTAX_FP(FSUB, 3),

 26269 +    SYNTAX_FP(FMAC, 3),

 26270 +    SYNTAX_FP(FNMAC, 3),

 26271 +    SYNTAX_FP(FMSC, 3),

 26272 +    SYNTAX_FP(FNMSC, 3),

 26273 +    SYNTAX_FP(FMUL, 3),

 26274 +    SYNTAX_FP(FNMUL, 3),

 26275 +    SYNTAX_FP(FNEG, 2),

 26276 +    SYNTAX_FP(FABS, 2),

 26277 +    SYNTAX_FP(FCMP, 2),

 26278 +    {

 26279 +      AVR32_SYNTAX_FMOV1_S,

 26280 +      AVR32_FP, NULL, AVR32_PARSER_ALIAS,

 26281 +      { .alias = &avr32_alias_table[AVR32_ALIAS_FMOV1_S] },

 26282 +      &avr32_syntax_table[AVR32_SYNTAX_FMOV2_S],

 26283 +      2,

 26284 +      {

 26285 +	AVR32_OPERAND_FPREG_S,

 26286 +	AVR32_OPERAND_FPREG_S,

 26287 +      },

 26288 +    },

 26289 +    {

 26290 +      AVR32_SYNTAX_FMOV1_D,

 26291 +      AVR32_FP, NULL, AVR32_PARSER_ALIAS,

 26292 +      { .alias = &avr32_alias_table[AVR32_ALIAS_FMOV1_D] },

 26293 +      &avr32_syntax_table[AVR32_SYNTAX_FMOV2_D],

 26294 +      2,

 26295 +      {

 26296 +	AVR32_OPERAND_FPREG_D,

 26297 +	AVR32_OPERAND_FPREG_D,

 26298 +      },

 26299 +    },

 26300 +    {

 26301 +      AVR32_SYNTAX_FMOV2_S,

 26302 +      AVR32_FP, NULL, AVR32_PARSER_ALIAS,

 26303 +      { .alias = &avr32_alias_table[AVR32_ALIAS_FMOV2_S] },

 26304 +      &avr32_syntax_table[AVR32_SYNTAX_FMOV3_S],

 26305 +      2,

 26306 +      {

 26307 +	AVR32_OPERAND_INTREG,

 26308 +	AVR32_OPERAND_FPREG_S,

 26309 +      },

 26310 +    },

 26311 +    {

 26312 +      AVR32_SYNTAX_FMOV2_D,

 26313 +      AVR32_FP, NULL, AVR32_PARSER_ALIAS,

 26314 +      { .alias = &avr32_alias_table[AVR32_ALIAS_FMOV2_D] },

 26315 +      &avr32_syntax_table[AVR32_SYNTAX_FMOV3_D],

 26316 +      2,

 26317 +      {

 26318 +	AVR32_OPERAND_DWREG,

 26319 +	AVR32_OPERAND_FPREG_D,

 26320 +      },

 26321 +    },

 26322 +    {

 26323 +      AVR32_SYNTAX_FMOV3_S,

 26324 +      AVR32_FP, NULL, AVR32_PARSER_ALIAS,

 26325 +      { .alias = &avr32_alias_table[AVR32_ALIAS_FMOV3_S] }, NULL,

 26326 +      2,

 26327 +      {

 26328 +	AVR32_OPERAND_FPREG_S,

 26329 +	AVR32_OPERAND_INTREG,

 26330 +      },

 26331 +    },

 26332 +    {

 26333 +      AVR32_SYNTAX_FMOV3_D,

 26334 +      AVR32_FP, NULL, AVR32_PARSER_ALIAS,

 26335 +      { .alias = &avr32_alias_table[AVR32_ALIAS_FMOV3_D] }, NULL,

 26336 +      2,

 26337 +      {

 26338 +	AVR32_OPERAND_FPREG_D,

 26339 +	AVR32_OPERAND_DWREG,

 26340 +      },

 26341 +    },

 26342 +    {

 26343 +      AVR32_SYNTAX_FCASTS_D,

 26344 +      AVR32_FP, NULL, AVR32_PARSER_ALIAS,

 26345 +      { .alias = &avr32_alias_table[AVR32_ALIAS_FCASTS_D] }, NULL,

 26346 +      2,

 26347 +      {

 26348 +	AVR32_OPERAND_FPREG_S,

 26349 +	AVR32_OPERAND_FPREG_D,

 26350 +      },

 26351 +    },

 26352 +    {

 26353 +      AVR32_SYNTAX_FCASTD_S,

 26354 +      AVR32_FP, NULL, AVR32_PARSER_ALIAS,

 26355 +      { .alias = &avr32_alias_table[AVR32_ALIAS_FCASTD_S] }, NULL,

 26356 +      2,

 26357 +      {

 26358 +	AVR32_OPERAND_FPREG_D,

 26359 +	AVR32_OPERAND_FPREG_S,

 26360 +      },

 26361 +    },

 26362 +    {

 26363 +      AVR32_SYNTAX_LDA_W,

 26364 +      AVR32_V1, NULL, AVR32_PARSER_LDA,

 26365 +      { NULL }, NULL,

 26366 +      2,

 26367 +      {

 26368 +	AVR32_OPERAND_INTREG,

 26369 +	AVR32_OPERAND_SIGNED_CONST,

 26370 +      },

 26371 +    },

 26372 +    {

 26373 +      AVR32_SYNTAX_CALL,

 26374 +      AVR32_V1, NULL, AVR32_PARSER_CALL,

 26375 +      { NULL }, NULL,

 26376 +      1,

 26377 +      {

 26378 +	AVR32_OPERAND_JMPLABEL,

 26379 +      },

 26380 +    },

 26381 +    {

 26382 +      AVR32_SYNTAX_PICOSVMAC0,

 26383 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMAC], AVR32_PARSER_ALIAS,

 26384 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMAC0] },

 26385 +      &avr32_syntax_table[AVR32_SYNTAX_PICOSVMAC1], 4,

 26386 +      {

 26387 +	AVR32_OPERAND_PICO_OUT0,

 26388 +	AVR32_OPERAND_PICO_IN,

 26389 +	AVR32_OPERAND_PICO_IN,

 26390 +	AVR32_OPERAND_PICO_IN,

 26391 +      },

 26392 +    },

 26393 +    {

 26394 +      AVR32_SYNTAX_PICOSVMAC1,

 26395 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMAC], AVR32_PARSER_ALIAS,

 26396 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMAC1] },

 26397 +      &avr32_syntax_table[AVR32_SYNTAX_PICOSVMAC2], 4,

 26398 +      {

 26399 +	AVR32_OPERAND_PICO_OUT1,

 26400 +	AVR32_OPERAND_PICO_IN,

 26401 +	AVR32_OPERAND_PICO_IN,

 26402 +	AVR32_OPERAND_PICO_IN,

 26403 +      },

 26404 +    },

 26405 +    {

 26406 +      AVR32_SYNTAX_PICOSVMAC2,

 26407 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMAC], AVR32_PARSER_ALIAS,

 26408 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMAC2] },

 26409 +      &avr32_syntax_table[AVR32_SYNTAX_PICOSVMAC3], 4,

 26410 +      {

 26411 +	AVR32_OPERAND_PICO_OUT2,

 26412 +	AVR32_OPERAND_PICO_IN,

 26413 +	AVR32_OPERAND_PICO_IN,

 26414 +	AVR32_OPERAND_PICO_IN,

 26415 +      },

 26416 +    },

 26417 +    {

 26418 +      AVR32_SYNTAX_PICOSVMAC3,

 26419 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMAC], AVR32_PARSER_ALIAS,

 26420 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMAC3] },

 26421 +      NULL, 4,

 26422 +      {

 26423 +	AVR32_OPERAND_PICO_OUT3,

 26424 +	AVR32_OPERAND_PICO_IN,

 26425 +	AVR32_OPERAND_PICO_IN,

 26426 +	AVR32_OPERAND_PICO_IN,

 26427 +      },

 26428 +    },

 26429 +    {

 26430 +      AVR32_SYNTAX_PICOSVMUL0,

 26431 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMUL], AVR32_PARSER_ALIAS,

 26432 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMUL0] },

 26433 +      &avr32_syntax_table[AVR32_SYNTAX_PICOSVMUL1], 4,

 26434 +      {

 26435 +	AVR32_OPERAND_PICO_OUT0,

 26436 +	AVR32_OPERAND_PICO_IN,

 26437 +	AVR32_OPERAND_PICO_IN,

 26438 +	AVR32_OPERAND_PICO_IN,

 26439 +      },

 26440 +    },

 26441 +    {

 26442 +      AVR32_SYNTAX_PICOSVMUL1,

 26443 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMUL], AVR32_PARSER_ALIAS,

 26444 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMUL1] },

 26445 +      &avr32_syntax_table[AVR32_SYNTAX_PICOSVMUL2], 4,

 26446 +      {

 26447 +	AVR32_OPERAND_PICO_OUT1,

 26448 +	AVR32_OPERAND_PICO_IN,

 26449 +	AVR32_OPERAND_PICO_IN,

 26450 +	AVR32_OPERAND_PICO_IN,

 26451 +      },

 26452 +    },

 26453 +    {

 26454 +      AVR32_SYNTAX_PICOSVMUL2,

 26455 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMUL], AVR32_PARSER_ALIAS,

 26456 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMUL2] },

 26457 +      &avr32_syntax_table[AVR32_SYNTAX_PICOSVMUL3], 4,

 26458 +      {

 26459 +	AVR32_OPERAND_PICO_OUT2,

 26460 +	AVR32_OPERAND_PICO_IN,

 26461 +	AVR32_OPERAND_PICO_IN,

 26462 +	AVR32_OPERAND_PICO_IN,

 26463 +      },

 26464 +    },

 26465 +    {

 26466 +      AVR32_SYNTAX_PICOSVMUL3,

 26467 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMUL], AVR32_PARSER_ALIAS,

 26468 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMUL3] },

 26469 +      NULL, 4,

 26470 +      {

 26471 +	AVR32_OPERAND_PICO_OUT3,

 26472 +	AVR32_OPERAND_PICO_IN,

 26473 +	AVR32_OPERAND_PICO_IN,

 26474 +	AVR32_OPERAND_PICO_IN,

 26475 +      },

 26476 +    },

 26477 +    {

 26478 +      AVR32_SYNTAX_PICOVMAC0,

 26479 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMAC], AVR32_PARSER_ALIAS,

 26480 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMAC0] },

 26481 +      &avr32_syntax_table[AVR32_SYNTAX_PICOVMAC1], 4,

 26482 +      {

 26483 +	AVR32_OPERAND_PICO_OUT0,

 26484 +	AVR32_OPERAND_PICO_IN,

 26485 +	AVR32_OPERAND_PICO_IN,

 26486 +	AVR32_OPERAND_PICO_IN,

 26487 +      },

 26488 +    },

 26489 +    {

 26490 +      AVR32_SYNTAX_PICOVMAC1,

 26491 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMAC], AVR32_PARSER_ALIAS,

 26492 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMAC1] },

 26493 +      &avr32_syntax_table[AVR32_SYNTAX_PICOVMAC2], 4,

 26494 +      {

 26495 +	AVR32_OPERAND_PICO_OUT1,

 26496 +	AVR32_OPERAND_PICO_IN,

 26497 +	AVR32_OPERAND_PICO_IN,

 26498 +	AVR32_OPERAND_PICO_IN,

 26499 +      },

 26500 +    },

 26501 +    {

 26502 +      AVR32_SYNTAX_PICOVMAC2,

 26503 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMAC], AVR32_PARSER_ALIAS,

 26504 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMAC2] },

 26505 +      &avr32_syntax_table[AVR32_SYNTAX_PICOVMAC3], 4,

 26506 +      {

 26507 +	AVR32_OPERAND_PICO_OUT2,

 26508 +	AVR32_OPERAND_PICO_IN,

 26509 +	AVR32_OPERAND_PICO_IN,

 26510 +	AVR32_OPERAND_PICO_IN,

 26511 +      },

 26512 +    },

 26513 +    {

 26514 +      AVR32_SYNTAX_PICOVMAC3,

 26515 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMAC], AVR32_PARSER_ALIAS,

 26516 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMAC3] },

 26517 +      NULL, 4,

 26518 +      {

 26519 +	AVR32_OPERAND_PICO_OUT3,

 26520 +	AVR32_OPERAND_PICO_IN,

 26521 +	AVR32_OPERAND_PICO_IN,

 26522 +	AVR32_OPERAND_PICO_IN,

 26523 +      },

 26524 +    },

 26525 +    {

 26526 +      AVR32_SYNTAX_PICOVMUL0,

 26527 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMUL], AVR32_PARSER_ALIAS,

 26528 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMUL0] },

 26529 +      &avr32_syntax_table[AVR32_SYNTAX_PICOVMUL1], 4,

 26530 +      {

 26531 +	AVR32_OPERAND_PICO_OUT0,

 26532 +	AVR32_OPERAND_PICO_IN,

 26533 +	AVR32_OPERAND_PICO_IN,

 26534 +	AVR32_OPERAND_PICO_IN,

 26535 +      },

 26536 +    },

 26537 +    {

 26538 +      AVR32_SYNTAX_PICOVMUL1,

 26539 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMUL], AVR32_PARSER_ALIAS,

 26540 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMUL1] },

 26541 +      &avr32_syntax_table[AVR32_SYNTAX_PICOVMUL2], 4,

 26542 +      {

 26543 +	AVR32_OPERAND_PICO_OUT1,

 26544 +	AVR32_OPERAND_PICO_IN,

 26545 +	AVR32_OPERAND_PICO_IN,

 26546 +	AVR32_OPERAND_PICO_IN,

 26547 +      },

 26548 +    },

 26549 +    {

 26550 +      AVR32_SYNTAX_PICOVMUL2,

 26551 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMUL], AVR32_PARSER_ALIAS,

 26552 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMUL2] },

 26553 +      &avr32_syntax_table[AVR32_SYNTAX_PICOVMUL3], 4,

 26554 +      {

 26555 +	AVR32_OPERAND_PICO_OUT2,

 26556 +	AVR32_OPERAND_PICO_IN,

 26557 +	AVR32_OPERAND_PICO_IN,

 26558 +	AVR32_OPERAND_PICO_IN,

 26559 +      },

 26560 +    },

 26561 +    {

 26562 +      AVR32_SYNTAX_PICOVMUL3,

 26563 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMUL], AVR32_PARSER_ALIAS,

 26564 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMUL3] },

 26565 +      NULL, 4,

 26566 +      {

 26567 +	AVR32_OPERAND_PICO_OUT3,

 26568 +	AVR32_OPERAND_PICO_IN,

 26569 +	AVR32_OPERAND_PICO_IN,

 26570 +	AVR32_OPERAND_PICO_IN,

 26571 +      },

 26572 +    },

 26573 +    {

 26574 +      AVR32_SYNTAX_PICOLD_D2,

 26575 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLD_D], AVR32_PARSER_ALIAS,

 26576 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLD_D2] },

 26577 +      &avr32_syntax_table[AVR32_SYNTAX_PICOLD_D3], 2,

 26578 +      {

 26579 +	AVR32_OPERAND_PICO_REG_D,

 26580 +	AVR32_OPERAND_INTREG_PREDEC,

 26581 +      },

 26582 +    },

 26583 +    {

 26584 +      AVR32_SYNTAX_PICOLD_D3,

 26585 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLD_D], AVR32_PARSER_ALIAS,

 26586 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLD_D3] },

 26587 +      &avr32_syntax_table[AVR32_SYNTAX_PICOLD_D1], 2,

 26588 +      {

 26589 +	AVR32_OPERAND_PICO_REG_D,

 26590 +	AVR32_OPERAND_INTREG_INDEX,

 26591 +      },

 26592 +    },

 26593 +    {

 26594 +      AVR32_SYNTAX_PICOLD_D1,

 26595 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLD_D], AVR32_PARSER_ALIAS,

 26596 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLD_D1] },

 26597 +      NULL, 2,

 26598 +      {

 26599 +	AVR32_OPERAND_PICO_REG_D,

 26600 +	AVR32_OPERAND_INTREG_UDISP_W,

 26601 +      },

 26602 +    },

 26603 +    {

 26604 +      AVR32_SYNTAX_PICOLD_W2,

 26605 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLD_W], AVR32_PARSER_ALIAS,

 26606 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLD_W2] },

 26607 +      &avr32_syntax_table[AVR32_SYNTAX_PICOLD_W3], 2,

 26608 +      {

 26609 +	AVR32_OPERAND_PICO_REG_W,

 26610 +	AVR32_OPERAND_INTREG_PREDEC,

 26611 +      },

 26612 +    },

 26613 +    {

 26614 +      AVR32_SYNTAX_PICOLD_W3,

 26615 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLD_W], AVR32_PARSER_ALIAS,

 26616 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLD_W3] },

 26617 +      &avr32_syntax_table[AVR32_SYNTAX_PICOLD_W1], 2,

 26618 +      {

 26619 +	AVR32_OPERAND_PICO_REG_W,

 26620 +	AVR32_OPERAND_INTREG_INDEX,

 26621 +      },

 26622 +    },

 26623 +    {

 26624 +      AVR32_SYNTAX_PICOLD_W1,

 26625 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLD_W], AVR32_PARSER_ALIAS,

 26626 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLD_W1] },

 26627 +      NULL, 2,

 26628 +      {

 26629 +	AVR32_OPERAND_PICO_REG_W,

 26630 +	AVR32_OPERAND_INTREG_UDISP_W,

 26631 +      },

 26632 +    },

 26633 +    {

 26634 +      AVR32_SYNTAX_PICOLDM_D,

 26635 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLDM_D], AVR32_PARSER_ALIAS,

 26636 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLDM_D] },

 26637 +      &avr32_syntax_table[AVR32_SYNTAX_PICOLDM_D_PU], -2,

 26638 +      {

 26639 +	AVR32_OPERAND_INTREG,

 26640 +	AVR32_OPERAND_PICO_REGLIST_D,

 26641 +      },

 26642 +    },

 26643 +    {

 26644 +      AVR32_SYNTAX_PICOLDM_D_PU,

 26645 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLDM_D], AVR32_PARSER_ALIAS,

 26646 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLDM_D_PU] },

 26647 +      NULL, -2,

 26648 +      {

 26649 +	AVR32_OPERAND_INTREG_POSTINC,

 26650 +	AVR32_OPERAND_PICO_REGLIST_D,

 26651 +      },

 26652 +    },

 26653 +    {

 26654 +      AVR32_SYNTAX_PICOLDM_W,

 26655 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLDM_W], AVR32_PARSER_ALIAS,

 26656 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLDM_W] },

 26657 +      &avr32_syntax_table[AVR32_SYNTAX_PICOLDM_W_PU], -2,

 26658 +      {

 26659 +	AVR32_OPERAND_INTREG,

 26660 +	AVR32_OPERAND_PICO_REGLIST_W,

 26661 +      },

 26662 +    },

 26663 +    {

 26664 +      AVR32_SYNTAX_PICOLDM_W_PU,

 26665 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLDM_W], AVR32_PARSER_ALIAS,

 26666 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLDM_W_PU] },

 26667 +      NULL, -2,

 26668 +      {

 26669 +	AVR32_OPERAND_INTREG_POSTINC,

 26670 +	AVR32_OPERAND_PICO_REGLIST_W,

 26671 +      },

 26672 +    },

 26673 +    {

 26674 +      AVR32_SYNTAX_PICOMV_D1,

 26675 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOMV_D], AVR32_PARSER_ALIAS,

 26676 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOMV_D1] },

 26677 +      &avr32_syntax_table[AVR32_SYNTAX_PICOMV_D2], 2,

 26678 +      {

 26679 +	AVR32_OPERAND_DWREG,

 26680 +	AVR32_OPERAND_PICO_REG_D,

 26681 +      },

 26682 +    },

 26683 +    {

 26684 +      AVR32_SYNTAX_PICOMV_D2,

 26685 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOMV_D], AVR32_PARSER_ALIAS,

 26686 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOMV_D2] },

 26687 +      NULL, 2,

 26688 +      {

 26689 +	AVR32_OPERAND_PICO_REG_D,

 26690 +	AVR32_OPERAND_DWREG,

 26691 +      },

 26692 +    },

 26693 +    {

 26694 +      AVR32_SYNTAX_PICOMV_W1,

 26695 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOMV_W], AVR32_PARSER_ALIAS,

 26696 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOMV_W1] },

 26697 +      &avr32_syntax_table[AVR32_SYNTAX_PICOMV_W2], 2,

 26698 +      {

 26699 +	AVR32_OPERAND_INTREG,

 26700 +	AVR32_OPERAND_PICO_REG_W,

 26701 +      },

 26702 +    },

 26703 +    {

 26704 +      AVR32_SYNTAX_PICOMV_W2,

 26705 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOMV_W], AVR32_PARSER_ALIAS,

 26706 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOMV_W2] },

 26707 +      NULL, 2,

 26708 +      {

 26709 +	AVR32_OPERAND_PICO_REG_W,

 26710 +	AVR32_OPERAND_INTREG,

 26711 +      },

 26712 +    },

 26713 +    {

 26714 +      AVR32_SYNTAX_PICOST_D2,

 26715 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOST_D], AVR32_PARSER_ALIAS,

 26716 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOST_D2] },

 26717 +      &avr32_syntax_table[AVR32_SYNTAX_PICOST_D3], 2,

 26718 +      {

 26719 +	AVR32_OPERAND_INTREG_POSTINC,

 26720 +	AVR32_OPERAND_PICO_REG_D,

 26721 +      },

 26722 +    },

 26723 +    {

 26724 +      AVR32_SYNTAX_PICOST_D3,

 26725 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOST_D], AVR32_PARSER_ALIAS,

 26726 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOST_D3] },

 26727 +      &avr32_syntax_table[AVR32_SYNTAX_PICOST_D1], 2,

 26728 +      {

 26729 +	AVR32_OPERAND_INTREG_INDEX,

 26730 +	AVR32_OPERAND_PICO_REG_D,

 26731 +      },

 26732 +    },

 26733 +    {

 26734 +      AVR32_SYNTAX_PICOST_D1,

 26735 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOST_D], AVR32_PARSER_ALIAS,

 26736 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOST_D1] },

 26737 +      NULL, 2,

 26738 +      {

 26739 +	AVR32_OPERAND_INTREG_UDISP_W,

 26740 +	AVR32_OPERAND_PICO_REG_D,

 26741 +      },

 26742 +    },

 26743 +    {

 26744 +      AVR32_SYNTAX_PICOST_W2,

 26745 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOST_W], AVR32_PARSER_ALIAS,

 26746 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOST_W2] },

 26747 +      &avr32_syntax_table[AVR32_SYNTAX_PICOST_W3], 2,

 26748 +      {

 26749 +	AVR32_OPERAND_INTREG_POSTINC,

 26750 +	AVR32_OPERAND_PICO_REG_W,

 26751 +      },

 26752 +    },

 26753 +    {

 26754 +      AVR32_SYNTAX_PICOST_W3,

 26755 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOST_W], AVR32_PARSER_ALIAS,

 26756 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOST_W3] },

 26757 +      &avr32_syntax_table[AVR32_SYNTAX_PICOST_W1], 2,

 26758 +      {

 26759 +	AVR32_OPERAND_INTREG_INDEX,

 26760 +	AVR32_OPERAND_PICO_REG_W,

 26761 +      },

 26762 +    },

 26763 +    {

 26764 +      AVR32_SYNTAX_PICOST_W1,

 26765 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOST_W], AVR32_PARSER_ALIAS,

 26766 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOST_W1] },

 26767 +      NULL, 2,

 26768 +      {

 26769 +	AVR32_OPERAND_INTREG_UDISP_W,

 26770 +	AVR32_OPERAND_PICO_REG_W,

 26771 +      },

 26772 +    },

 26773 +    {

 26774 +      AVR32_SYNTAX_PICOSTM_D,

 26775 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSTM_D], AVR32_PARSER_ALIAS,

 26776 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSTM_D] },

 26777 +      &avr32_syntax_table[AVR32_SYNTAX_PICOSTM_D_PU], -2,

 26778 +      {

 26779 +	AVR32_OPERAND_INTREG,

 26780 +	AVR32_OPERAND_PICO_REGLIST_D,

 26781 +      },

 26782 +    },

 26783 +    {

 26784 +      AVR32_SYNTAX_PICOSTM_D_PU,

 26785 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSTM_D], AVR32_PARSER_ALIAS,

 26786 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSTM_D_PU] },

 26787 +      NULL, -2,

 26788 +      {

 26789 +	AVR32_OPERAND_INTREG_PREDEC,

 26790 +	AVR32_OPERAND_PICO_REGLIST_D,

 26791 +      },

 26792 +    },

 26793 +    {

 26794 +      AVR32_SYNTAX_PICOSTM_W,

 26795 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSTM_W], AVR32_PARSER_ALIAS,

 26796 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSTM_W] },

 26797 +      &avr32_syntax_table[AVR32_SYNTAX_PICOSTM_W_PU], -2,

 26798 +      {

 26799 +	AVR32_OPERAND_INTREG,

 26800 +	AVR32_OPERAND_PICO_REGLIST_W,

 26801 +      },

 26802 +    },

 26803 +    {

 26804 +      AVR32_SYNTAX_PICOSTM_W_PU,

 26805 +      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSTM_W], AVR32_PARSER_ALIAS,

 26806 +      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSTM_W_PU] },

 26807 +      NULL, -2,

 26808 +      {

 26809 +	AVR32_OPERAND_INTREG_PREDEC,

 26810 +	AVR32_OPERAND_PICO_REGLIST_W,

 26811 +      },

 26812 +    },

 26813 +    SYNTAX_NORMAL2(RSUBEQ, RSUBEQ, RSUBEQ, INTREG, SIGNED_CONST, AVR32_V1),

 26814 +    SYNTAX_NORMAL2(RSUBNE, RSUBNE, RSUBNE, INTREG, SIGNED_CONST, AVR32_V2),

 26815 +    SYNTAX_NORMAL2(RSUBCC, RSUBCC, RSUBCC, INTREG, SIGNED_CONST, AVR32_V2),

 26816 +    SYNTAX_NORMAL2(RSUBCS, RSUBCS, RSUBCS, INTREG, SIGNED_CONST, AVR32_V2),

 26817 +    SYNTAX_NORMAL2(RSUBGE, RSUBGE, RSUBGE, INTREG, SIGNED_CONST, AVR32_V2),

 26818 +    SYNTAX_NORMAL2(RSUBLT, RSUBLT, RSUBLT, INTREG, SIGNED_CONST, AVR32_V2),

 26819 +    SYNTAX_NORMAL2(RSUBMI, RSUBMI, RSUBMI, INTREG, SIGNED_CONST, AVR32_V2),

 26820 +    SYNTAX_NORMAL2(RSUBPL, RSUBPL, RSUBPL, INTREG, SIGNED_CONST, AVR32_V2),

 26821 +    SYNTAX_NORMAL2(RSUBLS, RSUBLS, RSUBLS, INTREG, SIGNED_CONST, AVR32_V2),

 26822 +    SYNTAX_NORMAL2(RSUBGT, RSUBGT, RSUBGT, INTREG, SIGNED_CONST, AVR32_V2),

 26823 +    SYNTAX_NORMAL2(RSUBLE, RSUBLE, RSUBLE, INTREG, SIGNED_CONST, AVR32_V2),

 26824 +    SYNTAX_NORMAL2(RSUBHI, RSUBHI, RSUBHI, INTREG, SIGNED_CONST, AVR32_V2),

 26825 +    SYNTAX_NORMAL2(RSUBVS, RSUBVS, RSUBVS, INTREG, SIGNED_CONST, AVR32_V2),

 26826 +    SYNTAX_NORMAL2(RSUBVC, RSUBVC, RSUBVC, INTREG, SIGNED_CONST, AVR32_V2),

 26827 +    SYNTAX_NORMAL2(RSUBQS, RSUBQS, RSUBQS, INTREG, SIGNED_CONST, AVR32_V2),

 26828 +    SYNTAX_NORMAL2(RSUBAL, RSUBAL, RSUBAL, INTREG, SIGNED_CONST, AVR32_V2),

 26829 +    SYNTAX_NORMAL2(RSUBHS, RSUBHS, RSUBCC, INTREG, SIGNED_CONST, AVR32_V2),

 26830 +    SYNTAX_NORMAL2(RSUBLO, RSUBLO, RSUBCS, INTREG, SIGNED_CONST, AVR32_V2),

 26831 +    SYNTAX_NORMAL3(ADDEQ, ADDEQ, ADDEQ, INTREG, INTREG, INTREG, AVR32_V2),

 26832 +    SYNTAX_NORMAL3(ADDNE, ADDNE, ADDNE, INTREG, INTREG, INTREG, AVR32_V2),

 26833 +    SYNTAX_NORMAL3(ADDCC, ADDCC, ADDCC, INTREG, INTREG, INTREG, AVR32_V2),

 26834 +    SYNTAX_NORMAL3(ADDCS, ADDCS, ADDCS, INTREG, INTREG, INTREG, AVR32_V2),

 26835 +    SYNTAX_NORMAL3(ADDGE, ADDGE, ADDGE, INTREG, INTREG, INTREG, AVR32_V2),

 26836 +    SYNTAX_NORMAL3(ADDLT, ADDLT, ADDLT, INTREG, INTREG, INTREG, AVR32_V2),

 26837 +    SYNTAX_NORMAL3(ADDMI, ADDMI, ADDMI, INTREG, INTREG, INTREG, AVR32_V2),

 26838 +    SYNTAX_NORMAL3(ADDPL, ADDPL, ADDPL, INTREG, INTREG, INTREG, AVR32_V2),

 26839 +    SYNTAX_NORMAL3(ADDLS, ADDLS, ADDLS, INTREG, INTREG, INTREG, AVR32_V2),

 26840 +    SYNTAX_NORMAL3(ADDGT, ADDGT, ADDGT, INTREG, INTREG, INTREG, AVR32_V2),

 26841 +    SYNTAX_NORMAL3(ADDLE, ADDLE, ADDLE, INTREG, INTREG, INTREG, AVR32_V2),

 26842 +    SYNTAX_NORMAL3(ADDHI, ADDHI, ADDHI, INTREG, INTREG, INTREG, AVR32_V2),

 26843 +    SYNTAX_NORMAL3(ADDVS, ADDVS, ADDVS, INTREG, INTREG, INTREG, AVR32_V2),

 26844 +    SYNTAX_NORMAL3(ADDVC, ADDVC, ADDVC, INTREG, INTREG, INTREG, AVR32_V2),

 26845 +    SYNTAX_NORMAL3(ADDQS, ADDQS, ADDQS, INTREG, INTREG, INTREG, AVR32_V2),

 26846 +    SYNTAX_NORMAL3(ADDAL, ADDAL, ADDAL, INTREG, INTREG, INTREG, AVR32_V2),

 26847 +    SYNTAX_NORMAL3(ADDHS, ADDHS, ADDCC, INTREG, INTREG, INTREG, AVR32_V2),

 26848 +    SYNTAX_NORMAL3(ADDLO, ADDLO, ADDCS, INTREG, INTREG, INTREG, AVR32_V2),

 26849 +    SYNTAX_NORMAL3(SUB2EQ, SUBEQ, SUB2EQ, INTREG, INTREG, INTREG, AVR32_V2),

 26850 +    SYNTAX_NORMAL3(SUB2NE, SUBNE, SUB2NE, INTREG, INTREG, INTREG, AVR32_V2),

 26851 +    SYNTAX_NORMAL3(SUB2CC, SUBCC, SUB2CC, INTREG, INTREG, INTREG, AVR32_V2),

 26852 +    SYNTAX_NORMAL3(SUB2CS, SUBCS, SUB2CS, INTREG, INTREG, INTREG, AVR32_V2),

 26853 +    SYNTAX_NORMAL3(SUB2GE, SUBGE, SUB2GE, INTREG, INTREG, INTREG, AVR32_V2),

 26854 +    SYNTAX_NORMAL3(SUB2LT, SUBLT, SUB2LT, INTREG, INTREG, INTREG, AVR32_V2),

 26855 +    SYNTAX_NORMAL3(SUB2MI, SUBMI, SUB2MI, INTREG, INTREG, INTREG, AVR32_V2),

 26856 +    SYNTAX_NORMAL3(SUB2PL, SUBPL, SUB2PL, INTREG, INTREG, INTREG, AVR32_V2),

 26857 +    SYNTAX_NORMAL3(SUB2LS, SUBLS, SUB2LS, INTREG, INTREG, INTREG, AVR32_V2),

 26858 +    SYNTAX_NORMAL3(SUB2GT, SUBGT, SUB2GT, INTREG, INTREG, INTREG, AVR32_V2),

 26859 +    SYNTAX_NORMAL3(SUB2LE, SUBLE, SUB2LE, INTREG, INTREG, INTREG, AVR32_V2),

 26860 +    SYNTAX_NORMAL3(SUB2HI, SUBHI, SUB2HI, INTREG, INTREG, INTREG, AVR32_V2),

 26861 +    SYNTAX_NORMAL3(SUB2VS, SUBVS, SUB2VS, INTREG, INTREG, INTREG, AVR32_V2),

 26862 +    SYNTAX_NORMAL3(SUB2VC, SUBVC, SUB2VC, INTREG, INTREG, INTREG, AVR32_V2),

 26863 +    SYNTAX_NORMAL3(SUB2QS, SUBQS, SUB2QS, INTREG, INTREG, INTREG, AVR32_V2),

 26864 +    SYNTAX_NORMAL3(SUB2AL, SUBAL, SUB2AL, INTREG, INTREG, INTREG, AVR32_V2),

 26865 +    SYNTAX_NORMAL3(SUB2HS, SUBHS, SUB2CC, INTREG, INTREG, INTREG, AVR32_V2),

 26866 +    SYNTAX_NORMAL3(SUB2LO, SUBLO, SUB2CS, INTREG, INTREG, INTREG, AVR32_V2),

 26867 +    SYNTAX_NORMAL3(ANDEQ, ANDEQ, ANDEQ, INTREG, INTREG, INTREG, AVR32_V2),

 26868 +    SYNTAX_NORMAL3(ANDNE, ANDNE, ANDNE, INTREG, INTREG, INTREG, AVR32_V2),

 26869 +    SYNTAX_NORMAL3(ANDCC, ANDCC, ANDCC, INTREG, INTREG, INTREG, AVR32_V2),

 26870 +    SYNTAX_NORMAL3(ANDCS, ANDCS, ANDCS, INTREG, INTREG, INTREG, AVR32_V2),

 26871 +    SYNTAX_NORMAL3(ANDGE, ANDGE, ANDGE, INTREG, INTREG, INTREG, AVR32_V2),

 26872 +    SYNTAX_NORMAL3(ANDLT, ANDLT, ANDLT, INTREG, INTREG, INTREG, AVR32_V2),

 26873 +    SYNTAX_NORMAL3(ANDMI, ANDMI, ANDMI, INTREG, INTREG, INTREG, AVR32_V2),

 26874 +    SYNTAX_NORMAL3(ANDPL, ANDPL, ANDPL, INTREG, INTREG, INTREG, AVR32_V2),

 26875 +    SYNTAX_NORMAL3(ANDLS, ANDLS, ANDLS, INTREG, INTREG, INTREG, AVR32_V2),

 26876 +    SYNTAX_NORMAL3(ANDGT, ANDGT, ANDGT, INTREG, INTREG, INTREG, AVR32_V2),

 26877 +    SYNTAX_NORMAL3(ANDLE, ANDLE, ANDLE, INTREG, INTREG, INTREG, AVR32_V2),

 26878 +    SYNTAX_NORMAL3(ANDHI, ANDHI, ANDHI, INTREG, INTREG, INTREG, AVR32_V2),

 26879 +    SYNTAX_NORMAL3(ANDVS, ANDVS, ANDVS, INTREG, INTREG, INTREG, AVR32_V2),

 26880 +    SYNTAX_NORMAL3(ANDVC, ANDVC, ANDVC, INTREG, INTREG, INTREG, AVR32_V2),

 26881 +    SYNTAX_NORMAL3(ANDQS, ANDQS, ANDQS, INTREG, INTREG, INTREG, AVR32_V2),

 26882 +    SYNTAX_NORMAL3(ANDAL, ANDAL, ANDAL, INTREG, INTREG, INTREG, AVR32_V2),

 26883 +    SYNTAX_NORMAL3(ANDHS, ANDHS, ANDCC, INTREG, INTREG, INTREG, AVR32_V2),

 26884 +    SYNTAX_NORMAL3(ANDLO, ANDLO, ANDCS, INTREG, INTREG, INTREG, AVR32_V2),

 26885 +    SYNTAX_NORMAL3(OREQ, OREQ, OREQ, INTREG, INTREG, INTREG, AVR32_V2),

 26886 +    SYNTAX_NORMAL3(ORNE, ORNE, ORNE, INTREG, INTREG, INTREG, AVR32_V2),

 26887 +    SYNTAX_NORMAL3(ORCC, ORCC, ORCC, INTREG, INTREG, INTREG, AVR32_V2),

 26888 +    SYNTAX_NORMAL3(ORCS, ORCS, ORCS, INTREG, INTREG, INTREG, AVR32_V2),

 26889 +    SYNTAX_NORMAL3(ORGE, ORGE, ORGE, INTREG, INTREG, INTREG, AVR32_V2),

 26890 +    SYNTAX_NORMAL3(ORLT, ORLT, ORLT, INTREG, INTREG, INTREG, AVR32_V2),

 26891 +    SYNTAX_NORMAL3(ORMI, ORMI, ORMI, INTREG, INTREG, INTREG, AVR32_V2),

 26892 +    SYNTAX_NORMAL3(ORPL, ORPL, ORPL, INTREG, INTREG, INTREG, AVR32_V2),

 26893 +    SYNTAX_NORMAL3(ORLS, ORLS, ORLS, INTREG, INTREG, INTREG, AVR32_V2),

 26894 +    SYNTAX_NORMAL3(ORGT, ORGT, ORGT, INTREG, INTREG, INTREG, AVR32_V2),

 26895 +    SYNTAX_NORMAL3(ORLE, ORLE, ORLE, INTREG, INTREG, INTREG, AVR32_V2),

 26896 +    SYNTAX_NORMAL3(ORHI, ORHI, ORHI, INTREG, INTREG, INTREG, AVR32_V2),

 26897 +    SYNTAX_NORMAL3(ORVS, ORVS, ORVS, INTREG, INTREG, INTREG, AVR32_V2),

 26898 +    SYNTAX_NORMAL3(ORVC, ORVC, ORVC, INTREG, INTREG, INTREG, AVR32_V2),

 26899 +    SYNTAX_NORMAL3(ORQS, ORQS, ORQS, INTREG, INTREG, INTREG, AVR32_V2),

 26900 +    SYNTAX_NORMAL3(ORAL, ORAL, ORAL, INTREG, INTREG, INTREG, AVR32_V2),

 26901 +    SYNTAX_NORMAL3(ORHS, ORHS, ORCC, INTREG, INTREG, INTREG, AVR32_V2),

 26902 +    SYNTAX_NORMAL3(ORLO, ORLO, ORCS, INTREG, INTREG, INTREG, AVR32_V2),

 26903 +    SYNTAX_NORMAL3(EOREQ, EOREQ, EOREQ, INTREG, INTREG, INTREG, AVR32_V2),

 26904 +    SYNTAX_NORMAL3(EORNE, EORNE, EORNE, INTREG, INTREG, INTREG, AVR32_V2),

 26905 +    SYNTAX_NORMAL3(EORCC, EORCC, EORCC, INTREG, INTREG, INTREG, AVR32_V2),

 26906 +    SYNTAX_NORMAL3(EORCS, EORCS, EORCS, INTREG, INTREG, INTREG, AVR32_V2),

 26907 +    SYNTAX_NORMAL3(EORGE, EORGE, EORGE, INTREG, INTREG, INTREG, AVR32_V2),

 26908 +    SYNTAX_NORMAL3(EORLT, EORLT, EORLT, INTREG, INTREG, INTREG, AVR32_V2),

 26909 +    SYNTAX_NORMAL3(EORMI, EORMI, EORMI, INTREG, INTREG, INTREG, AVR32_V2),

 26910 +    SYNTAX_NORMAL3(EORPL, EORPL, EORPL, INTREG, INTREG, INTREG, AVR32_V2),

 26911 +    SYNTAX_NORMAL3(EORLS, EORLS, EORLS, INTREG, INTREG, INTREG, AVR32_V2),

 26912 +    SYNTAX_NORMAL3(EORGT, EORGT, EORGT, INTREG, INTREG, INTREG, AVR32_V2),

 26913 +    SYNTAX_NORMAL3(EORLE, EORLE, EORLE, INTREG, INTREG, INTREG, AVR32_V2),

 26914 +    SYNTAX_NORMAL3(EORHI, EORHI, EORHI, INTREG, INTREG, INTREG, AVR32_V2),

 26915 +    SYNTAX_NORMAL3(EORVS, EORVS, EORVS, INTREG, INTREG, INTREG, AVR32_V2),

 26916 +    SYNTAX_NORMAL3(EORVC, EORVC, EORVC, INTREG, INTREG, INTREG, AVR32_V2),

 26917 +    SYNTAX_NORMAL3(EORQS, EORQS, EORQS, INTREG, INTREG, INTREG, AVR32_V2),

 26918 +    SYNTAX_NORMAL3(EORAL, EORAL, EORAL, INTREG, INTREG, INTREG, AVR32_V2),

 26919 +    SYNTAX_NORMAL3(EORHS, EORHS, EORCC, INTREG, INTREG, INTREG, AVR32_V2),

 26920 +    SYNTAX_NORMAL3(EORLO, EORLO, EORCS, INTREG, INTREG, INTREG, AVR32_V2),

 26921 +    SYNTAX_NORMAL2(LD_WEQ, LD_WEQ, LD_WEQ, INTREG, INTREG_UDISP_W, AVR32_V2),

 26922 +    SYNTAX_NORMAL2(LD_WNE, LD_WNE, LD_WNE, INTREG, INTREG_UDISP_W, AVR32_V2),

 26923 +    SYNTAX_NORMAL2(LD_WCC, LD_WCC, LD_WCC, INTREG, INTREG_UDISP_W, AVR32_V2),

 26924 +    SYNTAX_NORMAL2(LD_WCS, LD_WCS, LD_WCS, INTREG, INTREG_UDISP_W, AVR32_V2),

 26925 +    SYNTAX_NORMAL2(LD_WGE, LD_WGE, LD_WGE, INTREG, INTREG_UDISP_W, AVR32_V2),

 26926 +    SYNTAX_NORMAL2(LD_WLT, LD_WLT, LD_WLT, INTREG, INTREG_UDISP_W, AVR32_V2),

 26927 +    SYNTAX_NORMAL2(LD_WMI, LD_WMI, LD_WMI, INTREG, INTREG_UDISP_W, AVR32_V2),

 26928 +    SYNTAX_NORMAL2(LD_WPL, LD_WPL, LD_WPL, INTREG, INTREG_UDISP_W, AVR32_V2),

 26929 +    SYNTAX_NORMAL2(LD_WLS, LD_WLS, LD_WLS, INTREG, INTREG_UDISP_W, AVR32_V2),

 26930 +    SYNTAX_NORMAL2(LD_WGT, LD_WGT, LD_WGT, INTREG, INTREG_UDISP_W, AVR32_V2),

 26931 +    SYNTAX_NORMAL2(LD_WLE, LD_WLE, LD_WLE, INTREG, INTREG_UDISP_W, AVR32_V2),

 26932 +    SYNTAX_NORMAL2(LD_WHI, LD_WHI, LD_WHI, INTREG, INTREG_UDISP_W, AVR32_V2),

 26933 +    SYNTAX_NORMAL2(LD_WVS, LD_WVS, LD_WVS, INTREG, INTREG_UDISP_W, AVR32_V2),

 26934 +    SYNTAX_NORMAL2(LD_WVC, LD_WVC, LD_WVC, INTREG, INTREG_UDISP_W, AVR32_V2),

 26935 +    SYNTAX_NORMAL2(LD_WQS, LD_WQS, LD_WQS, INTREG, INTREG_UDISP_W, AVR32_V2),

 26936 +    SYNTAX_NORMAL2(LD_WAL, LD_WAL, LD_WAL, INTREG, INTREG_UDISP_W, AVR32_V2),

 26937 +    SYNTAX_NORMAL2(LD_WHS, LD_WHS, LD_WCC, INTREG, INTREG_UDISP_W, AVR32_V2),

 26938 +    SYNTAX_NORMAL2(LD_WLO, LD_WLO, LD_WCS, INTREG, INTREG_UDISP_W, AVR32_V2),

 26939 +    SYNTAX_NORMAL2(LD_SHEQ, LD_SHEQ, LD_SHEQ, INTREG, INTREG_UDISP_H, AVR32_V2),

 26940 +    SYNTAX_NORMAL2(LD_SHNE, LD_SHNE, LD_SHNE, INTREG, INTREG_UDISP_H, AVR32_V2),

 26941 +    SYNTAX_NORMAL2(LD_SHCC, LD_SHCC, LD_SHCC, INTREG, INTREG_UDISP_H, AVR32_V2),

 26942 +    SYNTAX_NORMAL2(LD_SHCS, LD_SHCS, LD_SHCS, INTREG, INTREG_UDISP_H, AVR32_V2),

 26943 +    SYNTAX_NORMAL2(LD_SHGE, LD_SHGE, LD_SHGE, INTREG, INTREG_UDISP_H, AVR32_V2),

 26944 +    SYNTAX_NORMAL2(LD_SHLT, LD_SHLT, LD_SHLT, INTREG, INTREG_UDISP_H, AVR32_V2),

 26945 +    SYNTAX_NORMAL2(LD_SHMI, LD_SHMI, LD_SHMI, INTREG, INTREG_UDISP_H, AVR32_V2),

 26946 +    SYNTAX_NORMAL2(LD_SHPL, LD_SHPL, LD_SHPL, INTREG, INTREG_UDISP_H, AVR32_V2),

 26947 +    SYNTAX_NORMAL2(LD_SHLS, LD_SHLS, LD_SHLS, INTREG, INTREG_UDISP_H, AVR32_V2),

 26948 +    SYNTAX_NORMAL2(LD_SHGT, LD_SHGT, LD_SHGT, INTREG, INTREG_UDISP_H, AVR32_V2),

 26949 +    SYNTAX_NORMAL2(LD_SHLE, LD_SHLE, LD_SHLE, INTREG, INTREG_UDISP_H, AVR32_V2),

 26950 +    SYNTAX_NORMAL2(LD_SHHI, LD_SHHI, LD_SHHI, INTREG, INTREG_UDISP_H, AVR32_V2),

 26951 +    SYNTAX_NORMAL2(LD_SHVS, LD_SHVS, LD_SHVS, INTREG, INTREG_UDISP_H, AVR32_V2),

 26952 +    SYNTAX_NORMAL2(LD_SHVC, LD_SHVC, LD_SHVC, INTREG, INTREG_UDISP_H, AVR32_V2),

 26953 +    SYNTAX_NORMAL2(LD_SHQS, LD_SHQS, LD_SHQS, INTREG, INTREG_UDISP_H, AVR32_V2),

 26954 +    SYNTAX_NORMAL2(LD_SHAL, LD_SHAL, LD_SHAL, INTREG, INTREG_UDISP_H, AVR32_V2),

 26955 +    SYNTAX_NORMAL2(LD_SHHS, LD_SHHS, LD_SHCC, INTREG, INTREG_UDISP_H, AVR32_V2),

 26956 +    SYNTAX_NORMAL2(LD_SHLO, LD_SHLO, LD_SHCS, INTREG, INTREG_UDISP_H, AVR32_V2),

 26957 +    SYNTAX_NORMAL2(LD_UHEQ, LD_UHEQ, LD_UHEQ, INTREG, INTREG_UDISP_H, AVR32_V2),

 26958 +    SYNTAX_NORMAL2(LD_UHNE, LD_UHNE, LD_UHNE, INTREG, INTREG_UDISP_H, AVR32_V2),

 26959 +    SYNTAX_NORMAL2(LD_UHCC, LD_UHCC, LD_UHCC, INTREG, INTREG_UDISP_H, AVR32_V2),

 26960 +    SYNTAX_NORMAL2(LD_UHCS, LD_UHCS, LD_UHCS, INTREG, INTREG_UDISP_H, AVR32_V2),

 26961 +    SYNTAX_NORMAL2(LD_UHGE, LD_UHGE, LD_UHGE, INTREG, INTREG_UDISP_H, AVR32_V2),

 26962 +    SYNTAX_NORMAL2(LD_UHLT, LD_UHLT, LD_UHLT, INTREG, INTREG_UDISP_H, AVR32_V2),

 26963 +    SYNTAX_NORMAL2(LD_UHMI, LD_UHMI, LD_UHMI, INTREG, INTREG_UDISP_H, AVR32_V2),

 26964 +    SYNTAX_NORMAL2(LD_UHPL, LD_UHPL, LD_UHPL, INTREG, INTREG_UDISP_H, AVR32_V2),

 26965 +    SYNTAX_NORMAL2(LD_UHLS, LD_UHLS, LD_UHLS, INTREG, INTREG_UDISP_H, AVR32_V2),

 26966 +    SYNTAX_NORMAL2(LD_UHGT, LD_UHGT, LD_UHGT, INTREG, INTREG_UDISP_H, AVR32_V2),

 26967 +    SYNTAX_NORMAL2(LD_UHLE, LD_UHLE, LD_UHLE, INTREG, INTREG_UDISP_H, AVR32_V2),

 26968 +    SYNTAX_NORMAL2(LD_UHHI, LD_UHHI, LD_UHHI, INTREG, INTREG_UDISP_H, AVR32_V2),

 26969 +    SYNTAX_NORMAL2(LD_UHVS, LD_UHVS, LD_UHVS, INTREG, INTREG_UDISP_H, AVR32_V2),

 26970 +    SYNTAX_NORMAL2(LD_UHVC, LD_UHVC, LD_UHVC, INTREG, INTREG_UDISP_H, AVR32_V2),

 26971 +    SYNTAX_NORMAL2(LD_UHQS, LD_UHQS, LD_UHQS, INTREG, INTREG_UDISP_H, AVR32_V2),

 26972 +    SYNTAX_NORMAL2(LD_UHAL, LD_UHAL, LD_UHAL, INTREG, INTREG_UDISP_H, AVR32_V2),

 26973 +    SYNTAX_NORMAL2(LD_UHHS, LD_UHHS, LD_UHCC, INTREG, INTREG_UDISP_H, AVR32_V2),

 26974 +    SYNTAX_NORMAL2(LD_UHLO, LD_UHLO, LD_UHCS, INTREG, INTREG_UDISP_H, AVR32_V2),

 26975 +    SYNTAX_NORMAL2(LD_SBEQ, LD_SBEQ, LD_SBEQ, INTREG, INTREG_UDISP, AVR32_V2),

 26976 +    SYNTAX_NORMAL2(LD_SBNE, LD_SBNE, LD_SBNE, INTREG, INTREG_UDISP, AVR32_V2),

 26977 +    SYNTAX_NORMAL2(LD_SBCC, LD_SBCC, LD_SBCC, INTREG, INTREG_UDISP, AVR32_V2),

 26978 +    SYNTAX_NORMAL2(LD_SBCS, LD_SBCS, LD_SBCS, INTREG, INTREG_UDISP, AVR32_V2),

 26979 +    SYNTAX_NORMAL2(LD_SBGE, LD_SBGE, LD_SBGE, INTREG, INTREG_UDISP, AVR32_V2),

 26980 +    SYNTAX_NORMAL2(LD_SBLT, LD_SBLT, LD_SBLT, INTREG, INTREG_UDISP, AVR32_V2),

 26981 +    SYNTAX_NORMAL2(LD_SBMI, LD_SBMI, LD_SBMI, INTREG, INTREG_UDISP, AVR32_V2),

 26982 +    SYNTAX_NORMAL2(LD_SBPL, LD_SBPL, LD_SBPL, INTREG, INTREG_UDISP, AVR32_V2),

 26983 +    SYNTAX_NORMAL2(LD_SBLS, LD_SBLS, LD_SBLS, INTREG, INTREG_UDISP, AVR32_V2),

 26984 +    SYNTAX_NORMAL2(LD_SBGT, LD_SBGT, LD_SBGT, INTREG, INTREG_UDISP, AVR32_V2),

 26985 +    SYNTAX_NORMAL2(LD_SBLE, LD_SBLE, LD_SBLE, INTREG, INTREG_UDISP, AVR32_V2),

 26986 +    SYNTAX_NORMAL2(LD_SBHI, LD_SBHI, LD_SBHI, INTREG, INTREG_UDISP, AVR32_V2),

 26987 +    SYNTAX_NORMAL2(LD_SBVS, LD_SBVS, LD_SBVS, INTREG, INTREG_UDISP, AVR32_V2),

 26988 +    SYNTAX_NORMAL2(LD_SBVC, LD_SBVC, LD_SBVC, INTREG, INTREG_UDISP, AVR32_V2),

 26989 +    SYNTAX_NORMAL2(LD_SBQS, LD_SBQS, LD_SBQS, INTREG, INTREG_UDISP, AVR32_V2),

 26990 +    SYNTAX_NORMAL2(LD_SBAL, LD_SBAL, LD_SBAL, INTREG, INTREG_UDISP, AVR32_V2),

 26991 +    SYNTAX_NORMAL2(LD_SBHS, LD_SBHS, LD_SBCC, INTREG, INTREG_UDISP, AVR32_V2),

 26992 +    SYNTAX_NORMAL2(LD_SBLO, LD_SBLO, LD_SBCS, INTREG, INTREG_UDISP, AVR32_V2),

 26993 +    SYNTAX_NORMAL2(LD_UBEQ, LD_UBEQ, LD_UBEQ, INTREG, INTREG_UDISP, AVR32_V2),

 26994 +    SYNTAX_NORMAL2(LD_UBNE, LD_UBNE, LD_UBNE, INTREG, INTREG_UDISP, AVR32_V2),

 26995 +    SYNTAX_NORMAL2(LD_UBCC, LD_UBCC, LD_UBCC, INTREG, INTREG_UDISP, AVR32_V2),

 26996 +    SYNTAX_NORMAL2(LD_UBCS, LD_UBCS, LD_UBCS, INTREG, INTREG_UDISP, AVR32_V2),

 26997 +    SYNTAX_NORMAL2(LD_UBGE, LD_UBGE, LD_UBGE, INTREG, INTREG_UDISP, AVR32_V2),

 26998 +    SYNTAX_NORMAL2(LD_UBLT, LD_UBLT, LD_UBLT, INTREG, INTREG_UDISP, AVR32_V2),

 26999 +    SYNTAX_NORMAL2(LD_UBMI, LD_UBMI, LD_UBMI, INTREG, INTREG_UDISP, AVR32_V2),

 27000 +    SYNTAX_NORMAL2(LD_UBPL, LD_UBPL, LD_UBPL, INTREG, INTREG_UDISP, AVR32_V2),

 27001 +    SYNTAX_NORMAL2(LD_UBLS, LD_UBLS, LD_UBLS, INTREG, INTREG_UDISP, AVR32_V2),

 27002 +    SYNTAX_NORMAL2(LD_UBGT, LD_UBGT, LD_UBGT, INTREG, INTREG_UDISP, AVR32_V2),

 27003 +    SYNTAX_NORMAL2(LD_UBLE, LD_UBLE, LD_UBLE, INTREG, INTREG_UDISP, AVR32_V2),

 27004 +    SYNTAX_NORMAL2(LD_UBHI, LD_UBHI, LD_UBHI, INTREG, INTREG_UDISP, AVR32_V2),

 27005 +    SYNTAX_NORMAL2(LD_UBVS, LD_UBVS, LD_UBVS, INTREG, INTREG_UDISP, AVR32_V2),

 27006 +    SYNTAX_NORMAL2(LD_UBVC, LD_UBVC, LD_UBVC, INTREG, INTREG_UDISP, AVR32_V2),

 27007 +    SYNTAX_NORMAL2(LD_UBQS, LD_UBQS, LD_UBQS, INTREG, INTREG_UDISP, AVR32_V2),

 27008 +    SYNTAX_NORMAL2(LD_UBAL, LD_UBAL, LD_UBAL, INTREG, INTREG_UDISP, AVR32_V2),

 27009 +    SYNTAX_NORMAL2(LD_UBHS, LD_UBHS, LD_UBCC, INTREG, INTREG_UDISP, AVR32_V2),

 27010 +    SYNTAX_NORMAL2(LD_UBLO, LD_UBLO, LD_UBCS, INTREG, INTREG_UDISP, AVR32_V2),

 27011 +    SYNTAX_NORMAL2(ST_WEQ, ST_WEQ, ST_WEQ, INTREG_UDISP_W, INTREG, AVR32_V2),

 27012 +    SYNTAX_NORMAL2(ST_WNE, ST_WNE, ST_WNE, INTREG_UDISP_W, INTREG, AVR32_V2),

 27013 +    SYNTAX_NORMAL2(ST_WCC, ST_WCC, ST_WCC, INTREG_UDISP_W, INTREG, AVR32_V2),

 27014 +    SYNTAX_NORMAL2(ST_WCS, ST_WCS, ST_WCS, INTREG_UDISP_W, INTREG, AVR32_V2),

 27015 +    SYNTAX_NORMAL2(ST_WGE, ST_WGE, ST_WGE, INTREG_UDISP_W, INTREG, AVR32_V2),

 27016 +    SYNTAX_NORMAL2(ST_WLT, ST_WLT, ST_WLT, INTREG_UDISP_W, INTREG, AVR32_V2),

 27017 +    SYNTAX_NORMAL2(ST_WMI, ST_WMI, ST_WMI, INTREG_UDISP_W, INTREG, AVR32_V2),

 27018 +    SYNTAX_NORMAL2(ST_WPL, ST_WPL, ST_WPL, INTREG_UDISP_W, INTREG, AVR32_V2),

 27019 +    SYNTAX_NORMAL2(ST_WLS, ST_WLS, ST_WLS, INTREG_UDISP_W, INTREG, AVR32_V2),

 27020 +    SYNTAX_NORMAL2(ST_WGT, ST_WGT, ST_WGT, INTREG_UDISP_W, INTREG, AVR32_V2),

 27021 +    SYNTAX_NORMAL2(ST_WLE, ST_WLE, ST_WLE, INTREG_UDISP_W, INTREG, AVR32_V2),

 27022 +    SYNTAX_NORMAL2(ST_WHI, ST_WHI, ST_WHI, INTREG_UDISP_W, INTREG, AVR32_V2),

 27023 +    SYNTAX_NORMAL2(ST_WVS, ST_WVS, ST_WVS, INTREG_UDISP_W, INTREG, AVR32_V2),

 27024 +    SYNTAX_NORMAL2(ST_WVC, ST_WVC, ST_WVC, INTREG_UDISP_W, INTREG, AVR32_V2),

 27025 +    SYNTAX_NORMAL2(ST_WQS, ST_WQS, ST_WQS, INTREG_UDISP_W, INTREG, AVR32_V2),

 27026 +    SYNTAX_NORMAL2(ST_WAL, ST_WAL, ST_WAL, INTREG_UDISP_W, INTREG, AVR32_V2),

 27027 +    SYNTAX_NORMAL2(ST_WHS, ST_WHS, ST_WCC, INTREG_UDISP_W, INTREG, AVR32_V2),

 27028 +    SYNTAX_NORMAL2(ST_WLO, ST_WLO, ST_WCS, INTREG_UDISP_W, INTREG, AVR32_V2),

 27029 +    SYNTAX_NORMAL2(ST_HEQ, ST_HEQ, ST_HEQ, INTREG_UDISP_H, INTREG, AVR32_V2),

 27030 +    SYNTAX_NORMAL2(ST_HNE, ST_HNE, ST_HNE, INTREG_UDISP_H, INTREG, AVR32_V2),

 27031 +    SYNTAX_NORMAL2(ST_HCC, ST_HCC, ST_HCC, INTREG_UDISP_H, INTREG, AVR32_V2),

 27032 +    SYNTAX_NORMAL2(ST_HCS, ST_HCS, ST_HCS, INTREG_UDISP_H, INTREG, AVR32_V2),

 27033 +    SYNTAX_NORMAL2(ST_HGE, ST_HGE, ST_HGE, INTREG_UDISP_H, INTREG, AVR32_V2),

 27034 +    SYNTAX_NORMAL2(ST_HLT, ST_HLT, ST_HLT, INTREG_UDISP_H, INTREG, AVR32_V2),

 27035 +    SYNTAX_NORMAL2(ST_HMI, ST_HMI, ST_HMI, INTREG_UDISP_H, INTREG, AVR32_V2),

 27036 +    SYNTAX_NORMAL2(ST_HPL, ST_HPL, ST_HPL, INTREG_UDISP_H, INTREG, AVR32_V2),

 27037 +    SYNTAX_NORMAL2(ST_HLS, ST_HLS, ST_HLS, INTREG_UDISP_H, INTREG, AVR32_V2),

 27038 +    SYNTAX_NORMAL2(ST_HGT, ST_HGT, ST_HGT, INTREG_UDISP_H, INTREG, AVR32_V2),

 27039 +    SYNTAX_NORMAL2(ST_HLE, ST_HLE, ST_HLE, INTREG_UDISP_H, INTREG, AVR32_V2),

 27040 +    SYNTAX_NORMAL2(ST_HHI, ST_HHI, ST_HHI, INTREG_UDISP_H, INTREG, AVR32_V2),

 27041 +    SYNTAX_NORMAL2(ST_HVS, ST_HVS, ST_HVS, INTREG_UDISP_H, INTREG, AVR32_V2),

 27042 +    SYNTAX_NORMAL2(ST_HVC, ST_HVC, ST_HVC, INTREG_UDISP_H, INTREG, AVR32_V2),

 27043 +    SYNTAX_NORMAL2(ST_HQS, ST_HQS, ST_HQS, INTREG_UDISP_H, INTREG, AVR32_V2),

 27044 +    SYNTAX_NORMAL2(ST_HAL, ST_HAL, ST_HAL, INTREG_UDISP_H, INTREG, AVR32_V2),

 27045 +    SYNTAX_NORMAL2(ST_HHS, ST_HHS, ST_HCC, INTREG_UDISP_H, INTREG, AVR32_V2),

 27046 +    SYNTAX_NORMAL2(ST_HLO, ST_HLO, ST_HCS, INTREG_UDISP_H, INTREG, AVR32_V2),

 27047 +    SYNTAX_NORMAL2(ST_BEQ, ST_BEQ, ST_BEQ, INTREG_UDISP, INTREG, AVR32_V2),

 27048 +    SYNTAX_NORMAL2(ST_BNE, ST_BNE, ST_BNE, INTREG_UDISP, INTREG, AVR32_V2),

 27049 +    SYNTAX_NORMAL2(ST_BCC, ST_BCC, ST_BCC, INTREG_UDISP, INTREG, AVR32_V2),

 27050 +    SYNTAX_NORMAL2(ST_BCS, ST_BCS, ST_BCS, INTREG_UDISP, INTREG, AVR32_V2),

 27051 +    SYNTAX_NORMAL2(ST_BGE, ST_BGE, ST_BGE, INTREG_UDISP, INTREG, AVR32_V2),

 27052 +    SYNTAX_NORMAL2(ST_BLT, ST_BLT, ST_BLT, INTREG_UDISP, INTREG, AVR32_V2),

 27053 +    SYNTAX_NORMAL2(ST_BMI, ST_BMI, ST_BMI, INTREG_UDISP, INTREG, AVR32_V2),

 27054 +    SYNTAX_NORMAL2(ST_BPL, ST_BPL, ST_BPL, INTREG_UDISP, INTREG, AVR32_V2),

 27055 +    SYNTAX_NORMAL2(ST_BLS, ST_BLS, ST_BLS, INTREG_UDISP, INTREG, AVR32_V2),

 27056 +    SYNTAX_NORMAL2(ST_BGT, ST_BGT, ST_BGT, INTREG_UDISP, INTREG, AVR32_V2),

 27057 +    SYNTAX_NORMAL2(ST_BLE, ST_BLE, ST_BLE, INTREG_UDISP, INTREG, AVR32_V2),

 27058 +    SYNTAX_NORMAL2(ST_BHI, ST_BHI, ST_BHI, INTREG_UDISP, INTREG, AVR32_V2),

 27059 +    SYNTAX_NORMAL2(ST_BVS, ST_BVS, ST_BVS, INTREG_UDISP, INTREG, AVR32_V2),

 27060 +    SYNTAX_NORMAL2(ST_BVC, ST_BVC, ST_BVC, INTREG_UDISP, INTREG, AVR32_V2),

 27061 +    SYNTAX_NORMAL2(ST_BQS, ST_BQS, ST_BQS, INTREG_UDISP, INTREG, AVR32_V2),

 27062 +    SYNTAX_NORMAL2(ST_BAL, ST_BAL, ST_BAL, INTREG_UDISP, INTREG, AVR32_V2),

 27063 +    SYNTAX_NORMAL2(ST_BHS, ST_BHS, ST_BCC, INTREG_UDISP, INTREG, AVR32_V2),

 27064 +    SYNTAX_NORMAL2(ST_BLO, ST_BLO, ST_BCS, INTREG_UDISP, INTREG, AVR32_V2),

 27065 +    SYNTAX_NORMAL2(MOVH, MOVH, MOVH, INTREG, UNSIGNED_CONST, AVR32_V2),

 27066 +

 27067 +  };

 27068 +

 27069 +#define NORMAL_MNEMONIC(name, syntax, str)		\

 27070 +  {							\

 27071 +    AVR32_MNEMONIC_##name, str,				\

 27072 +    &avr32_syntax_table[AVR32_SYNTAX_##syntax],		\

 27073 +  }

 27074 +#define FP_MNEMONIC(name, syntax, str)			\

 27075 +  NORMAL_MNEMONIC(name##_S, syntax##_S, str ".s"),	\

 27076 +  NORMAL_MNEMONIC(name##_D, syntax##_D, str ".d")

 27077 +

 27078 +const struct avr32_mnemonic avr32_mnemonic_table[] =

 27079 +  {

 27080 +    NORMAL_MNEMONIC(ABS, ABS, "abs"),

 27081 +    NORMAL_MNEMONIC(ACALL, ACALL, "acall"),

 27082 +    NORMAL_MNEMONIC(ACR, ACR, "acr"),

 27083 +    NORMAL_MNEMONIC(ADC, ADC, "adc"),

 27084 +    NORMAL_MNEMONIC(ADD, ADD1, "add"),

 27085 +    NORMAL_MNEMONIC(ADDABS, ADDABS, "addabs"),

 27086 +    NORMAL_MNEMONIC(ADDHH_W, ADDHH_W, "addhh.w"),

 27087 +    NORMAL_MNEMONIC(AND, AND1, "and"),

 27088 +    NORMAL_MNEMONIC(ANDH, ANDH, "andh"),

 27089 +    NORMAL_MNEMONIC(ANDL, ANDL, "andl"),

 27090 +    NORMAL_MNEMONIC(ANDN, ANDN, "andn"),

 27091 +    NORMAL_MNEMONIC(ASR, ASR1, "asr"),

 27092 +    NORMAL_MNEMONIC(BFEXTS, BFEXTS, "bfexts"),

 27093 +    NORMAL_MNEMONIC(BFEXTU, BFEXTU, "bfextu"),

 27094 +    NORMAL_MNEMONIC(BFINS, BFINS, "bfins"),

 27095 +    NORMAL_MNEMONIC(BLD, BLD, "bld"),

 27096 +    NORMAL_MNEMONIC(BREQ, BREQ1, "breq"),

 27097 +    NORMAL_MNEMONIC(BRNE, BRNE1, "brne"),

 27098 +    NORMAL_MNEMONIC(BRCC, BRCC1, "brcc"),

 27099 +    NORMAL_MNEMONIC(BRCS, BRCS1, "brcs"),

 27100 +    NORMAL_MNEMONIC(BRGE, BRGE1, "brge"),

 27101 +    NORMAL_MNEMONIC(BRLT, BRLT1, "brlt"),

 27102 +    NORMAL_MNEMONIC(BRMI, BRMI1, "brmi"),

 27103 +    NORMAL_MNEMONIC(BRPL, BRPL1, "brpl"),

 27104 +    NORMAL_MNEMONIC(BRHS, BRHS1, "brhs"),

 27105 +    NORMAL_MNEMONIC(BRLO, BRLO1, "brlo"),

 27106 +    NORMAL_MNEMONIC(BRLS, BRLS, "brls"),

 27107 +    NORMAL_MNEMONIC(BRGT, BRGT, "brgt"),

 27108 +    NORMAL_MNEMONIC(BRLE, BRLE, "brle"),

 27109 +    NORMAL_MNEMONIC(BRHI, BRHI, "brhi"),

 27110 +    NORMAL_MNEMONIC(BRVS, BRVS, "brvs"),

 27111 +    NORMAL_MNEMONIC(BRVC, BRVC, "brvc"),

 27112 +    NORMAL_MNEMONIC(BRQS, BRQS, "brqs"),

 27113 +    NORMAL_MNEMONIC(BRAL, BRAL, "bral"),

 27114 +    NORMAL_MNEMONIC(BREAKPOINT, BREAKPOINT, "breakpoint"),

 27115 +    NORMAL_MNEMONIC(BREV, BREV, "brev"),

 27116 +    NORMAL_MNEMONIC(BST, BST, "bst"),

 27117 +    NORMAL_MNEMONIC(CACHE, CACHE, "cache"),

 27118 +    NORMAL_MNEMONIC(CASTS_B, CASTS_B, "casts.b"),

 27119 +    NORMAL_MNEMONIC(CASTS_H, CASTS_H, "casts.h"),

 27120 +    NORMAL_MNEMONIC(CASTU_B, CASTU_B, "castu.b"),

 27121 +    NORMAL_MNEMONIC(CASTU_H, CASTU_H, "castu.h"),

 27122 +    NORMAL_MNEMONIC(CBR, CBR, "cbr"),

 27123 +    NORMAL_MNEMONIC(CLZ, CLZ, "clz"),

 27124 +    NORMAL_MNEMONIC(COM, COM, "com"),

 27125 +    NORMAL_MNEMONIC(COP, COP, "cop"),

 27126 +    NORMAL_MNEMONIC(CP_B, CP_B, "cp.b"),

 27127 +    NORMAL_MNEMONIC(CP_H, CP_H, "cp.h"),

 27128 +    NORMAL_MNEMONIC(CP_W, CP_W1, "cp.w"),

 27129 +    NORMAL_MNEMONIC(CP, CP_W1, "cp"),

 27130 +    NORMAL_MNEMONIC(CPC, CPC1, "cpc"),

 27131 +    NORMAL_MNEMONIC(CSRF, CSRF, "csrf"),

 27132 +    NORMAL_MNEMONIC(CSRFCZ, CSRFCZ, "csrfcz"),

 27133 +    NORMAL_MNEMONIC(DIVS, DIVS, "divs"),

 27134 +    NORMAL_MNEMONIC(DIVU, DIVU, "divu"),

 27135 +    NORMAL_MNEMONIC(EOR, EOR1, "eor"),

 27136 +    NORMAL_MNEMONIC(EORL, EORL, "eorl"),

 27137 +    NORMAL_MNEMONIC(EORH, EORH, "eorh"),

 27138 +    NORMAL_MNEMONIC(FRS, FRS, "frs"),

 27139 +    NORMAL_MNEMONIC(ICALL, ICALL, "icall"),

 27140 +    NORMAL_MNEMONIC(INCJOSP, INCJOSP, "incjosp"),

 27141 +    NORMAL_MNEMONIC(LD_D, LD_D1, "ld.d"),

 27142 +    NORMAL_MNEMONIC(LD_SB, LD_SB2, "ld.sb"),

 27143 +    NORMAL_MNEMONIC(LD_UB, LD_UB1, "ld.ub"),

 27144 +    NORMAL_MNEMONIC(LD_SH, LD_SH1, "ld.sh"),

 27145 +    NORMAL_MNEMONIC(LD_UH, LD_UH1, "ld.uh"),

 27146 +    NORMAL_MNEMONIC(LD_W, LD_W1, "ld.w"),

 27147 +    NORMAL_MNEMONIC(LDC_D, LDC_D3, "ldc.d"),

 27148 +    NORMAL_MNEMONIC(LDC_W, LDC_W3, "ldc.w"),

 27149 +    NORMAL_MNEMONIC(LDC0_D, LDC0_D, "ldc0.d"),

 27150 +    NORMAL_MNEMONIC(LDC0_W, LDC0_W, "ldc0.w"),

 27151 +    NORMAL_MNEMONIC(LDCM_D, LDCM_D, "ldcm.d"),

 27152 +    NORMAL_MNEMONIC(LDCM_W, LDCM_W, "ldcm.w"),

 27153 +    NORMAL_MNEMONIC(LDDPC, LDDPC, "lddpc"),

 27154 +    NORMAL_MNEMONIC(LDDSP, LDDSP, "lddsp"),

 27155 +    NORMAL_MNEMONIC(LDINS_B, LDINS_B, "ldins.b"),

 27156 +    NORMAL_MNEMONIC(LDINS_H, LDINS_H, "ldins.h"),

 27157 +    NORMAL_MNEMONIC(LDM, LDM, "ldm"),

 27158 +    NORMAL_MNEMONIC(LDMTS, LDMTS, "ldmts"),

 27159 +    NORMAL_MNEMONIC(LDSWP_SH, LDSWP_SH, "ldswp.sh"),

 27160 +    NORMAL_MNEMONIC(LDSWP_UH, LDSWP_UH, "ldswp.uh"),

 27161 +    NORMAL_MNEMONIC(LDSWP_W, LDSWP_W, "ldswp.w"),

 27162 +    NORMAL_MNEMONIC(LSL, LSL1, "lsl"),

 27163 +    NORMAL_MNEMONIC(LSR, LSR1, "lsr"),

 27164 +    NORMAL_MNEMONIC(MAC, MAC, "mac"),

 27165 +    NORMAL_MNEMONIC(MACHH_D, MACHH_D, "machh.d"),

 27166 +    NORMAL_MNEMONIC(MACHH_W, MACHH_W, "machh.w"),

 27167 +    NORMAL_MNEMONIC(MACS_D, MACS_D, "macs.d"),

 27168 +    NORMAL_MNEMONIC(MACSATHH_W, MACSATHH_W, "macsathh.w"),

 27169 +    NORMAL_MNEMONIC(MACU_D, MACUD, "macu.d"),

 27170 +    NORMAL_MNEMONIC(MACWH_D, MACWH_D, "macwh.d"),

 27171 +    NORMAL_MNEMONIC(MAX, MAX, "max"),

 27172 +    NORMAL_MNEMONIC(MCALL, MCALL, "mcall"),

 27173 +    NORMAL_MNEMONIC(MFDR, MFDR, "mfdr"),

 27174 +    NORMAL_MNEMONIC(MFSR, MFSR, "mfsr"),

 27175 +    NORMAL_MNEMONIC(MIN, MIN, "min"),

 27176 +    NORMAL_MNEMONIC(MOV, MOV3, "mov"),

 27177 +    NORMAL_MNEMONIC(MOVEQ, MOVEQ1, "moveq"),

 27178 +    NORMAL_MNEMONIC(MOVNE, MOVNE1, "movne"),

 27179 +    NORMAL_MNEMONIC(MOVCC, MOVCC1, "movcc"),

 27180 +    NORMAL_MNEMONIC(MOVCS, MOVCS1, "movcs"),

 27181 +    NORMAL_MNEMONIC(MOVGE, MOVGE1, "movge"),

 27182 +    NORMAL_MNEMONIC(MOVLT, MOVLT1, "movlt"),

 27183 +    NORMAL_MNEMONIC(MOVMI, MOVMI1, "movmi"),

 27184 +    NORMAL_MNEMONIC(MOVPL, MOVPL1, "movpl"),

 27185 +    NORMAL_MNEMONIC(MOVLS, MOVLS1, "movls"),

 27186 +    NORMAL_MNEMONIC(MOVGT, MOVGT1, "movgt"),

 27187 +    NORMAL_MNEMONIC(MOVLE, MOVLE1, "movle"),

 27188 +    NORMAL_MNEMONIC(MOVHI, MOVHI1, "movhi"),

 27189 +    NORMAL_MNEMONIC(MOVVS, MOVVS1, "movvs"),

 27190 +    NORMAL_MNEMONIC(MOVVC, MOVVC1, "movvc"),

 27191 +    NORMAL_MNEMONIC(MOVQS, MOVQS1, "movqs"),

 27192 +    NORMAL_MNEMONIC(MOVAL, MOVAL1, "moval"),

 27193 +    NORMAL_MNEMONIC(MOVHS, MOVHS1, "movhs"),

 27194 +    NORMAL_MNEMONIC(MOVLO, MOVLO1, "movlo"),

 27195 +    NORMAL_MNEMONIC(MTDR, MTDR, "mtdr"),

 27196 +    NORMAL_MNEMONIC(MTSR, MTSR, "mtsr"),

 27197 +    NORMAL_MNEMONIC(MUL, MUL1, "mul"),

 27198 +    NORMAL_MNEMONIC(MULHH_W, MULHH_W, "mulhh.w"),

 27199 +    NORMAL_MNEMONIC(MULNHH_W, MULNHH_W, "mulnhh.w"),

 27200 +    NORMAL_MNEMONIC(MULNWH_D, MULNWH_D, "mulnwh.d"),

 27201 +    NORMAL_MNEMONIC(MULS_D, MULSD, "muls.d"),

 27202 +    NORMAL_MNEMONIC(MULSATHH_H, MULSATHH_H, "mulsathh.h"),

 27203 +    NORMAL_MNEMONIC(MULSATHH_W, MULSATHH_W, "mulsathh.w"),

 27204 +    NORMAL_MNEMONIC(MULSATRNDHH_H, MULSATRNDHH_H, "mulsatrndhh.h"),

 27205 +    NORMAL_MNEMONIC(MULSATRNDWH_W, MULSATRNDWH_W, "mulsatrndwh.w"),

 27206 +    NORMAL_MNEMONIC(MULSATWH_W, MULSATWH_W, "mulsatwh.w"),

 27207 +    NORMAL_MNEMONIC(MULU_D, MULU_D, "mulu.d"),

 27208 +    NORMAL_MNEMONIC(MULWH_D, MULWH_D, "mulwh.d"),

 27209 +    NORMAL_MNEMONIC(MUSFR, MUSFR, "musfr"),

 27210 +    NORMAL_MNEMONIC(MUSTR, MUSTR, "mustr"),

 27211 +    NORMAL_MNEMONIC(MVCR_D, MVCR_D, "mvcr.d"),

 27212 +    NORMAL_MNEMONIC(MVCR_W, MVCR_W, "mvcr.w"),

 27213 +    NORMAL_MNEMONIC(MVRC_D, MVRC_D, "mvrc.d"),

 27214 +    NORMAL_MNEMONIC(MVRC_W, MVRC_W, "mvrc.w"),

 27215 +    NORMAL_MNEMONIC(NEG, NEG, "neg"),

 27216 +    NORMAL_MNEMONIC(NOP, NOP, "nop"),

 27217 +    NORMAL_MNEMONIC(OR, OR1, "or"),

 27218 +    NORMAL_MNEMONIC(ORH, ORH, "orh"),

 27219 +    NORMAL_MNEMONIC(ORL, ORL, "orl"),

 27220 +    NORMAL_MNEMONIC(PABS_SB, PABS_SB, "pabs.sb"),

 27221 +    NORMAL_MNEMONIC(PABS_SH, PABS_SH, "pabs.sh"),

 27222 +    NORMAL_MNEMONIC(PACKSH_SB, PACKSH_SB, "packsh.sb"),

 27223 +    NORMAL_MNEMONIC(PACKSH_UB, PACKSH_UB, "packsh.ub"),

 27224 +    NORMAL_MNEMONIC(PACKW_SH, PACKW_SH, "packw.sh"),

 27225 +    NORMAL_MNEMONIC(PADD_B, PADD_B, "padd.b"),

 27226 +    NORMAL_MNEMONIC(PADD_H, PADD_H, "padd.h"),

 27227 +    NORMAL_MNEMONIC(PADDH_SH, PADDH_SH, "paddh.sh"),

 27228 +    NORMAL_MNEMONIC(PADDH_UB, PADDH_UB, "paddh.ub"),

 27229 +    NORMAL_MNEMONIC(PADDS_SB, PADDS_SB, "padds.sb"),

 27230 +    NORMAL_MNEMONIC(PADDS_SH, PADDS_SH, "padds.sh"),

 27231 +    NORMAL_MNEMONIC(PADDS_UB, PADDS_UB, "padds.ub"),

 27232 +    NORMAL_MNEMONIC(PADDS_UH, PADDS_UH, "padds.uh"),

 27233 +    NORMAL_MNEMONIC(PADDSUB_H, PADDSUB_H, "paddsub.h"),

 27234 +    NORMAL_MNEMONIC(PADDSUBH_SH, PADDSUBH_SH, "paddsubh.sh"),

 27235 +    NORMAL_MNEMONIC(PADDSUBS_SH, PADDSUBS_SH, "paddsubs.sh"),

 27236 +    NORMAL_MNEMONIC(PADDSUBS_UH, PADDSUBS_UH, "paddsubs.uh"),

 27237 +    NORMAL_MNEMONIC(PADDX_H, PADDX_H, "paddx.h"),

 27238 +    NORMAL_MNEMONIC(PADDXH_SH, PADDXH_SH, "paddxh.sh"),

 27239 +    NORMAL_MNEMONIC(PADDXS_SH, PADDXS_SH, "paddxs.sh"),

 27240 +    NORMAL_MNEMONIC(PADDXS_UH, PADDXS_UH, "paddxs.uh"),

 27241 +    NORMAL_MNEMONIC(PASR_B, PASR_B, "pasr.b"),

 27242 +    NORMAL_MNEMONIC(PASR_H, PASR_H, "pasr.h"),

 27243 +    NORMAL_MNEMONIC(PAVG_SH, PAVG_SH, "pavg.sh"),

 27244 +    NORMAL_MNEMONIC(PAVG_UB, PAVG_UB, "pavg.ub"),

 27245 +    NORMAL_MNEMONIC(PLSL_B, PLSL_B, "plsl.b"),

 27246 +    NORMAL_MNEMONIC(PLSL_H, PLSL_H, "plsl.h"),

 27247 +    NORMAL_MNEMONIC(PLSR_B, PLSR_B, "plsr.b"),

 27248 +    NORMAL_MNEMONIC(PLSR_H, PLSR_H, "plsr.h"),

 27249 +    NORMAL_MNEMONIC(PMAX_SH, PMAX_SH, "pmax.sh"),

 27250 +    NORMAL_MNEMONIC(PMAX_UB, PMAX_UB, "pmax.ub"),

 27251 +    NORMAL_MNEMONIC(PMIN_SH, PMIN_SH, "pmin.sh"),

 27252 +    NORMAL_MNEMONIC(PMIN_UB, PMIN_UB, "pmin.ub"),

 27253 +    NORMAL_MNEMONIC(POPJC, POPJC, "popjc"),

 27254 +    NORMAL_MNEMONIC(POPM, POPM, "popm"),

 27255 +    NORMAL_MNEMONIC(PREF, PREF, "pref"),

 27256 +    NORMAL_MNEMONIC(PSAD, PSAD, "psad"),

 27257 +    NORMAL_MNEMONIC(PSUB_B, PSUB_B, "psub.b"),

 27258 +    NORMAL_MNEMONIC(PSUB_H, PSUB_H, "psub.h"),

 27259 +    NORMAL_MNEMONIC(PSUBADD_H, PSUBADD_H, "psubadd.h"),

 27260 +    NORMAL_MNEMONIC(PSUBADDH_SH, PSUBADDH_SH, "psubaddh.sh"),

 27261 +    NORMAL_MNEMONIC(PSUBADDS_SH, PSUBADDS_SH, "psubadds.sh"),

 27262 +    NORMAL_MNEMONIC(PSUBADDS_UH, PSUBADDS_UH, "psubadds.uh"),

 27263 +    NORMAL_MNEMONIC(PSUBH_SH, PSUBH_SH, "psubh.sh"),

 27264 +    NORMAL_MNEMONIC(PSUBH_UB, PSUBH_UB, "psubh.ub"),

 27265 +    NORMAL_MNEMONIC(PSUBS_SB, PSUBS_SB, "psubs.sb"),

 27266 +    NORMAL_MNEMONIC(PSUBS_SH, PSUBS_SH, "psubs.sh"),

 27267 +    NORMAL_MNEMONIC(PSUBS_UB, PSUBS_UB, "psubs.ub"),

 27268 +    NORMAL_MNEMONIC(PSUBS_UH, PSUBS_UH, "psubs.uh"),

 27269 +    NORMAL_MNEMONIC(PSUBX_H, PSUBX_H, "psubx.h"),

 27270 +    NORMAL_MNEMONIC(PSUBXH_SH, PSUBXH_SH, "psubxh.sh"),

 27271 +    NORMAL_MNEMONIC(PSUBXS_SH, PSUBXS_SH, "psubxs.sh"),

 27272 +    NORMAL_MNEMONIC(PSUBXS_UH, PSUBXS_UH, "psubxs.uh"),

 27273 +    NORMAL_MNEMONIC(PUNPCKSB_H, PUNPCKSB_H, "punpcksb.h"),

 27274 +    NORMAL_MNEMONIC(PUNPCKUB_H, PUNPCKUB_H, "punpckub.h"),

 27275 +    NORMAL_MNEMONIC(PUSHJC, PUSHJC, "pushjc"),

 27276 +    NORMAL_MNEMONIC(PUSHM, PUSHM, "pushm"),

 27277 +    NORMAL_MNEMONIC(RCALL, RCALL1, "rcall"),

 27278 +    NORMAL_MNEMONIC(RETEQ, RETEQ, "reteq"),

 27279 +    NORMAL_MNEMONIC(RETNE, RETNE, "retne"),

 27280 +    NORMAL_MNEMONIC(RETCC, RETCC, "retcc"),

 27281 +    NORMAL_MNEMONIC(RETCS, RETCS, "retcs"),

 27282 +    NORMAL_MNEMONIC(RETGE, RETGE, "retge"),

 27283 +    NORMAL_MNEMONIC(RETLT, RETLT, "retlt"),

 27284 +    NORMAL_MNEMONIC(RETMI, RETMI, "retmi"),

 27285 +    NORMAL_MNEMONIC(RETPL, RETPL, "retpl"),

 27286 +    NORMAL_MNEMONIC(RETLS, RETLS, "retls"),

 27287 +    NORMAL_MNEMONIC(RETGT, RETGT, "retgt"),

 27288 +    NORMAL_MNEMONIC(RETLE, RETLE, "retle"),

 27289 +    NORMAL_MNEMONIC(RETHI, RETHI, "rethi"),

 27290 +    NORMAL_MNEMONIC(RETVS, RETVS, "retvs"),

 27291 +    NORMAL_MNEMONIC(RETVC, RETVC, "retvc"),

 27292 +    NORMAL_MNEMONIC(RETQS, RETQS, "retqs"),

 27293 +    NORMAL_MNEMONIC(RETAL, RETAL, "retal"),

 27294 +    NORMAL_MNEMONIC(RETHS, RETHS, "reths"),

 27295 +    NORMAL_MNEMONIC(RETLO, RETLO, "retlo"),

 27296 +    NORMAL_MNEMONIC(RET, RETAL, "ret"),

 27297 +    NORMAL_MNEMONIC(RETD, RETD, "retd"),

 27298 +    NORMAL_MNEMONIC(RETE, RETE, "rete"),

 27299 +    NORMAL_MNEMONIC(RETJ, RETJ, "retj"),

 27300 +    NORMAL_MNEMONIC(RETS, RETS, "rets"),

 27301 +    NORMAL_MNEMONIC(RJMP, RJMP, "rjmp"),

 27302 +    NORMAL_MNEMONIC(ROL, ROL, "rol"),

 27303 +    NORMAL_MNEMONIC(ROR, ROR, "ror"),

 27304 +    NORMAL_MNEMONIC(RSUB, RSUB1, "rsub"),

 27305 +    NORMAL_MNEMONIC(SATADD_H, SATADD_H, "satadd.h"),

 27306 +    NORMAL_MNEMONIC(SATADD_W, SATADD_W, "satadd.w"),

 27307 +    NORMAL_MNEMONIC(SATRNDS, SATRNDS, "satrnds"),

 27308 +    NORMAL_MNEMONIC(SATRNDU, SATRNDU, "satrndu"),

 27309 +    NORMAL_MNEMONIC(SATS, SATS, "sats"),

 27310 +    NORMAL_MNEMONIC(SATSUB_H, SATSUB_H, "satsub.h"),

 27311 +    NORMAL_MNEMONIC(SATSUB_W, SATSUB_W1, "satsub.w"),

 27312 +    NORMAL_MNEMONIC(SATU, SATU, "satu"),

 27313 +    NORMAL_MNEMONIC(SBC, SBC, "sbc"),

 27314 +    NORMAL_MNEMONIC(SBR, SBR, "sbr"),

 27315 +    NORMAL_MNEMONIC(SCALL, SCALL, "scall"),

 27316 +    NORMAL_MNEMONIC(SCR, SCR, "scr"),

 27317 +    NORMAL_MNEMONIC(SLEEP, SLEEP, "sleep"),

 27318 +    NORMAL_MNEMONIC(SREQ, SREQ, "sreq"),

 27319 +    NORMAL_MNEMONIC(SRNE, SRNE, "srne"),

 27320 +    NORMAL_MNEMONIC(SRCC, SRCC, "srcc"),

 27321 +    NORMAL_MNEMONIC(SRCS, SRCS, "srcs"),

 27322 +    NORMAL_MNEMONIC(SRGE, SRGE, "srge"),

 27323 +    NORMAL_MNEMONIC(SRLT, SRLT, "srlt"),

 27324 +    NORMAL_MNEMONIC(SRMI, SRMI, "srmi"),

 27325 +    NORMAL_MNEMONIC(SRPL, SRPL, "srpl"),

 27326 +    NORMAL_MNEMONIC(SRLS, SRLS, "srls"),

 27327 +    NORMAL_MNEMONIC(SRGT, SRGT, "srgt"),

 27328 +    NORMAL_MNEMONIC(SRLE, SRLE, "srle"),

 27329 +    NORMAL_MNEMONIC(SRHI, SRHI, "srhi"),

 27330 +    NORMAL_MNEMONIC(SRVS, SRVS, "srvs"),

 27331 +    NORMAL_MNEMONIC(SRVC, SRVC, "srvc"),

 27332 +    NORMAL_MNEMONIC(SRQS, SRQS, "srqs"),

 27333 +    NORMAL_MNEMONIC(SRAL, SRAL, "sral"),

 27334 +    NORMAL_MNEMONIC(SRHS, SRHS, "srhs"),

 27335 +    NORMAL_MNEMONIC(SRLO, SRLO, "srlo"),

 27336 +    NORMAL_MNEMONIC(SSRF, SSRF, "ssrf"),

 27337 +    NORMAL_MNEMONIC(ST_B, ST_B1, "st.b"),

 27338 +    NORMAL_MNEMONIC(ST_D, ST_D1, "st.d"),

 27339 +    NORMAL_MNEMONIC(ST_H, ST_H1, "st.h"),

 27340 +    NORMAL_MNEMONIC(ST_W, ST_W1, "st.w"),

 27341 +    NORMAL_MNEMONIC(STC_D, STC_D3, "stc.d"),

 27342 +    NORMAL_MNEMONIC(STC_W, STC_W3, "stc.w"),

 27343 +    NORMAL_MNEMONIC(STC0_D, STC0_D, "stc0.d"),

 27344 +    NORMAL_MNEMONIC(STC0_W, STC0_W, "stc0.w"),

 27345 +    NORMAL_MNEMONIC(STCM_D, STCM_D, "stcm.d"),

 27346 +    NORMAL_MNEMONIC(STCM_W, STCM_W, "stcm.w"),

 27347 +    NORMAL_MNEMONIC(STCOND, STCOND, "stcond"),

 27348 +    NORMAL_MNEMONIC(STDSP, STDSP, "stdsp"),

 27349 +    NORMAL_MNEMONIC(STHH_W, STHH_W2, "sthh.w"),

 27350 +    NORMAL_MNEMONIC(STM, STM, "stm"),

 27351 +    NORMAL_MNEMONIC(STMTS, STMTS, "stmts"),

 27352 +    NORMAL_MNEMONIC(STSWP_H, STSWP_H, "stswp.h"),

 27353 +    NORMAL_MNEMONIC(STSWP_W, STSWP_W, "stswp.w"),

 27354 +    NORMAL_MNEMONIC(SUB, SUB1, "sub"),

 27355 +    NORMAL_MNEMONIC(SUBEQ, SUBEQ, "subeq"),

 27356 +    NORMAL_MNEMONIC(SUBNE, SUBNE, "subne"),

 27357 +    NORMAL_MNEMONIC(SUBCC, SUBCC, "subcc"),

 27358 +    NORMAL_MNEMONIC(SUBCS, SUBCS, "subcs"),

 27359 +    NORMAL_MNEMONIC(SUBGE, SUBGE, "subge"),

 27360 +    NORMAL_MNEMONIC(SUBLT, SUBLT, "sublt"),

 27361 +    NORMAL_MNEMONIC(SUBMI, SUBMI, "submi"),

 27362 +    NORMAL_MNEMONIC(SUBPL, SUBPL, "subpl"),

 27363 +    NORMAL_MNEMONIC(SUBLS, SUBLS, "subls"),

 27364 +    NORMAL_MNEMONIC(SUBGT, SUBGT, "subgt"),

 27365 +    NORMAL_MNEMONIC(SUBLE, SUBLE, "suble"),

 27366 +    NORMAL_MNEMONIC(SUBHI, SUBHI, "subhi"),

 27367 +    NORMAL_MNEMONIC(SUBVS, SUBVS, "subvs"),

 27368 +    NORMAL_MNEMONIC(SUBVC, SUBVC, "subvc"),

 27369 +    NORMAL_MNEMONIC(SUBQS, SUBQS, "subqs"),

 27370 +    NORMAL_MNEMONIC(SUBAL, SUBAL, "subal"),

 27371 +    NORMAL_MNEMONIC(SUBHS, SUBHS, "subhs"),

 27372 +    NORMAL_MNEMONIC(SUBLO, SUBLO, "sublo"),

 27373 +    NORMAL_MNEMONIC(SUBFEQ, SUBFEQ, "subfeq"),

 27374 +    NORMAL_MNEMONIC(SUBFNE, SUBFNE, "subfne"),

 27375 +    NORMAL_MNEMONIC(SUBFCC, SUBFCC, "subfcc"),

 27376 +    NORMAL_MNEMONIC(SUBFCS, SUBFCS, "subfcs"),

 27377 +    NORMAL_MNEMONIC(SUBFGE, SUBFGE, "subfge"),

 27378 +    NORMAL_MNEMONIC(SUBFLT, SUBFLT, "subflt"),

 27379 +    NORMAL_MNEMONIC(SUBFMI, SUBFMI, "subfmi"),

 27380 +    NORMAL_MNEMONIC(SUBFPL, SUBFPL, "subfpl"),

 27381 +    NORMAL_MNEMONIC(SUBFLS, SUBFLS, "subfls"),

 27382 +    NORMAL_MNEMONIC(SUBFGT, SUBFGT, "subfgt"),

 27383 +    NORMAL_MNEMONIC(SUBFLE, SUBFLE, "subfle"),

 27384 +    NORMAL_MNEMONIC(SUBFHI, SUBFHI, "subfhi"),

 27385 +    NORMAL_MNEMONIC(SUBFVS, SUBFVS, "subfvs"),

 27386 +    NORMAL_MNEMONIC(SUBFVC, SUBFVC, "subfvc"),

 27387 +    NORMAL_MNEMONIC(SUBFQS, SUBFQS, "subfqs"),

 27388 +    NORMAL_MNEMONIC(SUBFAL, SUBFAL, "subfal"),

 27389 +    NORMAL_MNEMONIC(SUBFHS, SUBFHS, "subfhs"),

 27390 +    NORMAL_MNEMONIC(SUBFLO, SUBFLO, "subflo"),

 27391 +    NORMAL_MNEMONIC(SUBHH_W, SUBHH_W, "subhh.w"),

 27392 +    NORMAL_MNEMONIC(SWAP_B, SWAP_B, "swap.b"),

 27393 +    NORMAL_MNEMONIC(SWAP_BH, SWAP_BH, "swap.bh"),

 27394 +    NORMAL_MNEMONIC(SWAP_H, SWAP_H, "swap.h"),

 27395 +    NORMAL_MNEMONIC(SYNC, SYNC, "sync"),

 27396 +    NORMAL_MNEMONIC(TLBR, TLBR, "tlbr"),

 27397 +    NORMAL_MNEMONIC(TLBS, TLBS, "tlbs"),

 27398 +    NORMAL_MNEMONIC(TLBW, TLBW, "tlbw"),

 27399 +    NORMAL_MNEMONIC(TNBZ, TNBZ, "tnbz"),

 27400 +    NORMAL_MNEMONIC(TST, TST, "tst"),

 27401 +    NORMAL_MNEMONIC(XCHG, XCHG, "xchg"),

 27402 +    NORMAL_MNEMONIC(MEMC, MEMC, "memc"),

 27403 +    NORMAL_MNEMONIC(MEMS, MEMS, "mems"),

 27404 +    NORMAL_MNEMONIC(MEMT, MEMT, "memt"),

 27405 +    FP_MNEMONIC(FADD, FADD, "fadd"),

 27406 +    FP_MNEMONIC(FSUB, FSUB, "fsub"),

 27407 +    FP_MNEMONIC(FMAC, FMAC, "fmac"),

 27408 +    FP_MNEMONIC(FNMAC, FNMAC, "fnmac"),

 27409 +    FP_MNEMONIC(FMSC, FMSC, "fmsc"),

 27410 +    FP_MNEMONIC(FNMSC, FNMSC, "fnmsc"),

 27411 +    FP_MNEMONIC(FMUL, FMUL, "fmul"),

 27412 +    FP_MNEMONIC(FNMUL, FNMUL, "fnmul"),

 27413 +    FP_MNEMONIC(FNEG, FNEG, "fneg"),

 27414 +    FP_MNEMONIC(FABS, FABS, "fabs"),

 27415 +    FP_MNEMONIC(FCMP, FCMP, "fcmp"),

 27416 +    FP_MNEMONIC(FMOV, FMOV1, "fmov"),

 27417 +    NORMAL_MNEMONIC(FCASTS_D, FCASTS_D, "fcasts.d"),

 27418 +    NORMAL_MNEMONIC(FCASTD_S, FCASTD_S, "fcastd.s"),

 27419 +    NORMAL_MNEMONIC(LDA_W, LDA_W, "lda.w"),

 27420 +    NORMAL_MNEMONIC(CALL, CALL, "call"),

 27421 +    NORMAL_MNEMONIC(PICOSVMAC, PICOSVMAC0, "picosvmac"),

 27422 +    NORMAL_MNEMONIC(PICOSVMUL, PICOSVMUL0, "picosvmul"),

 27423 +    NORMAL_MNEMONIC(PICOVMAC, PICOVMAC0, "picovmac"),

 27424 +    NORMAL_MNEMONIC(PICOVMUL, PICOVMUL0, "picovmul"),

 27425 +    NORMAL_MNEMONIC(PICOLD_D, PICOLD_D2, "picold.d"),

 27426 +    NORMAL_MNEMONIC(PICOLD_W, PICOLD_W2, "picold.w"),

 27427 +    NORMAL_MNEMONIC(PICOLDM_D, PICOLDM_D, "picoldm.d"),

 27428 +    NORMAL_MNEMONIC(PICOLDM_W, PICOLDM_W, "picoldm.w"),

 27429 +    NORMAL_MNEMONIC(PICOMV_D, PICOMV_D1, "picomv.d"),

 27430 +    NORMAL_MNEMONIC(PICOMV_W, PICOMV_W1, "picomv.w"),

 27431 +    NORMAL_MNEMONIC(PICOST_D, PICOST_D2, "picost.d"),

 27432 +    NORMAL_MNEMONIC(PICOST_W, PICOST_W2, "picost.w"),

 27433 +    NORMAL_MNEMONIC(PICOSTM_D, PICOSTM_D, "picostm.d"),

 27434 +    NORMAL_MNEMONIC(PICOSTM_W, PICOSTM_W, "picostm.w"),

 27435 +    NORMAL_MNEMONIC(RSUBEQ, RSUBEQ, "rsubeq"),

 27436 +    NORMAL_MNEMONIC(RSUBNE, RSUBNE, "rsubne"),

 27437 +    NORMAL_MNEMONIC(RSUBCC, RSUBCC, "rsubcc"),

 27438 +    NORMAL_MNEMONIC(RSUBCS, RSUBCS, "rsubcs"),

 27439 +    NORMAL_MNEMONIC(RSUBGE, RSUBGE, "rsubge"),

 27440 +    NORMAL_MNEMONIC(RSUBLT, RSUBLT, "rsublt"),

 27441 +    NORMAL_MNEMONIC(RSUBMI, RSUBMI, "rsubmi"),

 27442 +    NORMAL_MNEMONIC(RSUBPL, RSUBPL, "rsubpl"),

 27443 +    NORMAL_MNEMONIC(RSUBLS, RSUBLS, "rsubls"),

 27444 +    NORMAL_MNEMONIC(RSUBGT, RSUBGT, "rsubgt"),

 27445 +    NORMAL_MNEMONIC(RSUBLE, RSUBLE, "rsuble"),

 27446 +    NORMAL_MNEMONIC(RSUBHI, RSUBHI, "rsubhi"),

 27447 +    NORMAL_MNEMONIC(RSUBVS, RSUBVS, "rsubvs"),

 27448 +    NORMAL_MNEMONIC(RSUBVC, RSUBVC, "rsubvc"),

 27449 +    NORMAL_MNEMONIC(RSUBQS, RSUBQS, "rsubqs"),

 27450 +    NORMAL_MNEMONIC(RSUBAL, RSUBAL, "rsubal"),

 27451 +    NORMAL_MNEMONIC(RSUBHS, RSUBHS, "rsubhs"),

 27452 +    NORMAL_MNEMONIC(RSUBLO, RSUBLO, "rsublo"),

 27453 +    NORMAL_MNEMONIC(ADDEQ, ADDEQ, "addeq"),

 27454 +    NORMAL_MNEMONIC(ADDNE, ADDNE, "addne"),

 27455 +    NORMAL_MNEMONIC(ADDCC, ADDCC, "addcc"),

 27456 +    NORMAL_MNEMONIC(ADDCS, ADDCS, "addcs"),

 27457 +    NORMAL_MNEMONIC(ADDGE, ADDGE, "addge"),

 27458 +    NORMAL_MNEMONIC(ADDLT, ADDLT, "addlt"),

 27459 +    NORMAL_MNEMONIC(ADDMI, ADDMI, "addmi"),

 27460 +    NORMAL_MNEMONIC(ADDPL, ADDPL, "addpl"),

 27461 +    NORMAL_MNEMONIC(ADDLS, ADDLS, "addls"),

 27462 +    NORMAL_MNEMONIC(ADDGT, ADDGT, "addgt"),

 27463 +    NORMAL_MNEMONIC(ADDLE, ADDLE, "addle"),

 27464 +    NORMAL_MNEMONIC(ADDHI, ADDHI, "addhi"),

 27465 +    NORMAL_MNEMONIC(ADDVS, ADDVS, "addvs"),

 27466 +    NORMAL_MNEMONIC(ADDVC, ADDVC, "addvc"),

 27467 +    NORMAL_MNEMONIC(ADDQS, ADDQS, "addqs"),

 27468 +    NORMAL_MNEMONIC(ADDAL, ADDAL, "addal"),

 27469 +    NORMAL_MNEMONIC(ADDHS, ADDHS, "addhs"),

 27470 +    NORMAL_MNEMONIC(ADDLO, ADDLO, "addlo"),

 27471 +    NORMAL_MNEMONIC(ANDEQ, ANDEQ, "andeq"),

 27472 +    NORMAL_MNEMONIC(ANDNE, ANDNE, "andne"),

 27473 +    NORMAL_MNEMONIC(ANDCC, ANDCC, "andcc"),

 27474 +    NORMAL_MNEMONIC(ANDCS, ANDCS, "andcs"),

 27475 +    NORMAL_MNEMONIC(ANDGE, ANDGE, "andge"),

 27476 +    NORMAL_MNEMONIC(ANDLT, ANDLT, "andlt"),

 27477 +    NORMAL_MNEMONIC(ANDMI, ANDMI, "andmi"),

 27478 +    NORMAL_MNEMONIC(ANDPL, ANDPL, "andpl"),

 27479 +    NORMAL_MNEMONIC(ANDLS, ANDLS, "andls"),

 27480 +    NORMAL_MNEMONIC(ANDGT, ANDGT, "andgt"),

 27481 +    NORMAL_MNEMONIC(ANDLE, ANDLE, "andle"),

 27482 +    NORMAL_MNEMONIC(ANDHI, ANDHI, "andhi"),

 27483 +    NORMAL_MNEMONIC(ANDVS, ANDVS, "andvs"),

 27484 +    NORMAL_MNEMONIC(ANDVC, ANDVC, "andvc"),

 27485 +    NORMAL_MNEMONIC(ANDQS, ANDQS, "andqs"),

 27486 +    NORMAL_MNEMONIC(ANDAL, ANDAL, "andal"),

 27487 +    NORMAL_MNEMONIC(ANDHS, ANDHS, "andhs"),

 27488 +    NORMAL_MNEMONIC(ANDLO, ANDLO, "andlo"),

 27489 +    NORMAL_MNEMONIC(OREQ, OREQ, "oreq"),

 27490 +    NORMAL_MNEMONIC(ORNE, ORNE, "orne"),

 27491 +    NORMAL_MNEMONIC(ORCC, ORCC, "orcc"),

 27492 +    NORMAL_MNEMONIC(ORCS, ORCS, "orcs"),

 27493 +    NORMAL_MNEMONIC(ORGE, ORGE, "orge"),

 27494 +    NORMAL_MNEMONIC(ORLT, ORLT, "orlt"),

 27495 +    NORMAL_MNEMONIC(ORMI, ORMI, "ormi"),

 27496 +    NORMAL_MNEMONIC(ORPL, ORPL, "orpl"),

 27497 +    NORMAL_MNEMONIC(ORLS, ORLS, "orls"),

 27498 +    NORMAL_MNEMONIC(ORGT, ORGT, "orgt"),

 27499 +    NORMAL_MNEMONIC(ORLE, ORLE, "orle"),

 27500 +    NORMAL_MNEMONIC(ORHI, ORHI, "orhi"),

 27501 +    NORMAL_MNEMONIC(ORVS, ORVS, "orvs"),

 27502 +    NORMAL_MNEMONIC(ORVC, ORVC, "orvc"),

 27503 +    NORMAL_MNEMONIC(ORQS, ORQS, "orqs"),

 27504 +    NORMAL_MNEMONIC(ORAL, ORAL, "oral"),

 27505 +    NORMAL_MNEMONIC(ORHS, ORHS, "orhs"),

 27506 +    NORMAL_MNEMONIC(ORLO, ORLO, "orlo"),

 27507 +    NORMAL_MNEMONIC(EOREQ, EOREQ, "eoreq"),

 27508 +    NORMAL_MNEMONIC(EORNE, EORNE, "eorne"),

 27509 +    NORMAL_MNEMONIC(EORCC, EORCC, "eorcc"),

 27510 +    NORMAL_MNEMONIC(EORCS, EORCS, "eorcs"),

 27511 +    NORMAL_MNEMONIC(EORGE, EORGE, "eorge"),

 27512 +    NORMAL_MNEMONIC(EORLT, EORLT, "eorlt"),

 27513 +    NORMAL_MNEMONIC(EORMI, EORMI, "eormi"),

 27514 +    NORMAL_MNEMONIC(EORPL, EORPL, "eorpl"),

 27515 +    NORMAL_MNEMONIC(EORLS, EORLS, "eorls"),

 27516 +    NORMAL_MNEMONIC(EORGT, EORGT, "eorgt"),

 27517 +    NORMAL_MNEMONIC(EORLE, EORLE, "eorle"),

 27518 +    NORMAL_MNEMONIC(EORHI, EORHI, "eorhi"),

 27519 +    NORMAL_MNEMONIC(EORVS, EORVS, "eorvs"),

 27520 +    NORMAL_MNEMONIC(EORVC, EORVC, "eorvc"),

 27521 +    NORMAL_MNEMONIC(EORQS, EORQS, "eorqs"),

 27522 +    NORMAL_MNEMONIC(EORAL, EORAL, "eoral"),

 27523 +    NORMAL_MNEMONIC(EORHS, EORHS, "eorhs"),

 27524 +    NORMAL_MNEMONIC(EORLO, EORLO, "eorlo"),

 27525 +    NORMAL_MNEMONIC(LD_WEQ, LD_WEQ, "ld.weq"),

 27526 +    NORMAL_MNEMONIC(LD_WNE, LD_WNE, "ld.wne"),

 27527 +    NORMAL_MNEMONIC(LD_WCC, LD_WCC, "ld.wcc"),

 27528 +    NORMAL_MNEMONIC(LD_WCS, LD_WCS, "ld.wcs"),

 27529 +    NORMAL_MNEMONIC(LD_WGE, LD_WGE, "ld.wge"),

 27530 +    NORMAL_MNEMONIC(LD_WLT, LD_WLT, "ld.wlt"),

 27531 +    NORMAL_MNEMONIC(LD_WMI, LD_WMI, "ld.wmi"),

 27532 +    NORMAL_MNEMONIC(LD_WPL, LD_WPL, "ld.wpl"),

 27533 +    NORMAL_MNEMONIC(LD_WLS, LD_WLS, "ld.wls"),

 27534 +    NORMAL_MNEMONIC(LD_WGT, LD_WGT, "ld.wgt"),

 27535 +    NORMAL_MNEMONIC(LD_WLE, LD_WLE, "ld.wle"),

 27536 +    NORMAL_MNEMONIC(LD_WHI, LD_WHI, "ld.whi"),

 27537 +    NORMAL_MNEMONIC(LD_WVS, LD_WVS, "ld.wvs"),

 27538 +    NORMAL_MNEMONIC(LD_WVC, LD_WVC, "ld.wvc"),

 27539 +    NORMAL_MNEMONIC(LD_WQS, LD_WQS, "ld.wqs"),

 27540 +    NORMAL_MNEMONIC(LD_WAL, LD_WAL, "ld.wal"),

 27541 +    NORMAL_MNEMONIC(LD_WHS, LD_WHS, "ld.whs"),

 27542 +    NORMAL_MNEMONIC(LD_WLO, LD_WLO, "ld.wlo"),

 27543 +    NORMAL_MNEMONIC(LD_SHEQ, LD_SHEQ, "ld.sheq"),

 27544 +    NORMAL_MNEMONIC(LD_SHNE, LD_SHNE, "ld.shne"),

 27545 +    NORMAL_MNEMONIC(LD_SHCC, LD_SHCC, "ld.shcc"),

 27546 +    NORMAL_MNEMONIC(LD_SHCS, LD_SHCS, "ld.shcs"),

 27547 +    NORMAL_MNEMONIC(LD_SHGE, LD_SHGE, "ld.shge"),

 27548 +    NORMAL_MNEMONIC(LD_SHLT, LD_SHLT, "ld.shlt"),

 27549 +    NORMAL_MNEMONIC(LD_SHMI, LD_SHMI, "ld.shmi"),

 27550 +    NORMAL_MNEMONIC(LD_SHPL, LD_SHPL, "ld.shpl"),

 27551 +    NORMAL_MNEMONIC(LD_SHLS, LD_SHLS, "ld.shls"),

 27552 +    NORMAL_MNEMONIC(LD_SHGT, LD_SHGT, "ld.shgt"),

 27553 +    NORMAL_MNEMONIC(LD_SHLE, LD_SHLE, "ld.shle"),

 27554 +    NORMAL_MNEMONIC(LD_SHHI, LD_SHHI, "ld.shhi"),

 27555 +    NORMAL_MNEMONIC(LD_SHVS, LD_SHVS, "ld.shvs"),

 27556 +    NORMAL_MNEMONIC(LD_SHVC, LD_SHVC, "ld.shvc"),

 27557 +    NORMAL_MNEMONIC(LD_SHQS, LD_SHQS, "ld.shqs"),

 27558 +    NORMAL_MNEMONIC(LD_SHAL, LD_SHAL, "ld.shal"),

 27559 +    NORMAL_MNEMONIC(LD_SHHS, LD_SHHS, "ld.shhs"),

 27560 +    NORMAL_MNEMONIC(LD_SHLO, LD_SHLO, "ld.shlo"),

 27561 +    NORMAL_MNEMONIC(LD_UHEQ, LD_UHEQ, "ld.uheq"),

 27562 +    NORMAL_MNEMONIC(LD_UHNE, LD_UHNE, "ld.uhne"),

 27563 +    NORMAL_MNEMONIC(LD_UHCC, LD_UHCC, "ld.uhcc"),

 27564 +    NORMAL_MNEMONIC(LD_UHCS, LD_UHCS, "ld.uhcs"),

 27565 +    NORMAL_MNEMONIC(LD_UHGE, LD_UHGE, "ld.uhge"),

 27566 +    NORMAL_MNEMONIC(LD_UHLT, LD_UHLT, "ld.uhlt"),

 27567 +    NORMAL_MNEMONIC(LD_UHMI, LD_UHMI, "ld.uhmi"),

 27568 +    NORMAL_MNEMONIC(LD_UHPL, LD_UHPL, "ld.uhpl"),

 27569 +    NORMAL_MNEMONIC(LD_UHLS, LD_UHLS, "ld.uhls"),

 27570 +    NORMAL_MNEMONIC(LD_UHGT, LD_UHGT, "ld.uhgt"),

 27571 +    NORMAL_MNEMONIC(LD_UHLE, LD_UHLE, "ld.uhle"),

 27572 +    NORMAL_MNEMONIC(LD_UHHI, LD_UHHI, "ld.uhhi"),

 27573 +    NORMAL_MNEMONIC(LD_UHVS, LD_UHVS, "ld.uhvs"),

 27574 +    NORMAL_MNEMONIC(LD_UHVC, LD_UHVC, "ld.uhvc"),

 27575 +    NORMAL_MNEMONIC(LD_UHQS, LD_UHQS, "ld.uhqs"),

 27576 +    NORMAL_MNEMONIC(LD_UHAL, LD_UHAL, "ld.uhal"),

 27577 +    NORMAL_MNEMONIC(LD_UHHS, LD_UHHS, "ld.uhhs"),

 27578 +    NORMAL_MNEMONIC(LD_UHLO, LD_UHLO, "ld.uhlo"),

 27579 +    NORMAL_MNEMONIC(LD_SBEQ, LD_SBEQ, "ld.sbeq"),

 27580 +    NORMAL_MNEMONIC(LD_SBNE, LD_SBNE, "ld.sbne"),

 27581 +    NORMAL_MNEMONIC(LD_SBCC, LD_SBCC, "ld.sbcc"),

 27582 +    NORMAL_MNEMONIC(LD_SBCS, LD_SBCS, "ld.sbcs"),

 27583 +    NORMAL_MNEMONIC(LD_SBGE, LD_SBGE, "ld.sbge"),

 27584 +    NORMAL_MNEMONIC(LD_SBLT, LD_SBLT, "ld.sblt"),

 27585 +    NORMAL_MNEMONIC(LD_SBMI, LD_SBMI, "ld.sbmi"),

 27586 +    NORMAL_MNEMONIC(LD_SBPL, LD_SBPL, "ld.sbpl"),

 27587 +    NORMAL_MNEMONIC(LD_SBLS, LD_SBLS, "ld.sbls"),

 27588 +    NORMAL_MNEMONIC(LD_SBGT, LD_SBGT, "ld.sbgt"),

 27589 +    NORMAL_MNEMONIC(LD_SBLE, LD_SBLE, "ld.sble"),

 27590 +    NORMAL_MNEMONIC(LD_SBHI, LD_SBHI, "ld.sbhi"),

 27591 +    NORMAL_MNEMONIC(LD_SBVS, LD_SBVS, "ld.sbvs"),

 27592 +    NORMAL_MNEMONIC(LD_SBVC, LD_SBVC, "ld.sbvc"),

 27593 +    NORMAL_MNEMONIC(LD_SBQS, LD_SBQS, "ld.sbqs"),

 27594 +    NORMAL_MNEMONIC(LD_SBAL, LD_SBAL, "ld.sbal"),

 27595 +    NORMAL_MNEMONIC(LD_SBHS, LD_SBHS, "ld.sbhs"),

 27596 +    NORMAL_MNEMONIC(LD_SBLO, LD_SBLO, "ld.sblo"),

 27597 +    NORMAL_MNEMONIC(LD_UBEQ, LD_UBEQ, "ld.ubeq"),

 27598 +    NORMAL_MNEMONIC(LD_UBNE, LD_UBNE, "ld.ubne"),

 27599 +    NORMAL_MNEMONIC(LD_UBCC, LD_UBCC, "ld.ubcc"),

 27600 +    NORMAL_MNEMONIC(LD_UBCS, LD_UBCS, "ld.ubcs"),

 27601 +    NORMAL_MNEMONIC(LD_UBGE, LD_UBGE, "ld.ubge"),

 27602 +    NORMAL_MNEMONIC(LD_UBLT, LD_UBLT, "ld.ublt"),

 27603 +    NORMAL_MNEMONIC(LD_UBMI, LD_UBMI, "ld.ubmi"),

 27604 +    NORMAL_MNEMONIC(LD_UBPL, LD_UBPL, "ld.ubpl"),

 27605 +    NORMAL_MNEMONIC(LD_UBLS, LD_UBLS, "ld.ubls"),

 27606 +    NORMAL_MNEMONIC(LD_UBGT, LD_UBGT, "ld.ubgt"),

 27607 +    NORMAL_MNEMONIC(LD_UBLE, LD_UBLE, "ld.uble"),

 27608 +    NORMAL_MNEMONIC(LD_UBHI, LD_UBHI, "ld.ubhi"),

 27609 +    NORMAL_MNEMONIC(LD_UBVS, LD_UBVS, "ld.ubvs"),

 27610 +    NORMAL_MNEMONIC(LD_UBVC, LD_UBVC, "ld.ubvc"),

 27611 +    NORMAL_MNEMONIC(LD_UBQS, LD_UBQS, "ld.ubqs"),

 27612 +    NORMAL_MNEMONIC(LD_UBAL, LD_UBAL, "ld.ubal"),

 27613 +    NORMAL_MNEMONIC(LD_UBHS, LD_UBHS, "ld.ubhs"),

 27614 +    NORMAL_MNEMONIC(LD_UBLO, LD_UBLO, "ld.ublo"),

 27615 +    NORMAL_MNEMONIC(ST_WEQ, ST_WEQ, "st.weq"),

 27616 +    NORMAL_MNEMONIC(ST_WNE, ST_WNE, "st.wne"),

 27617 +    NORMAL_MNEMONIC(ST_WCC, ST_WCC, "st.wcc"),

 27618 +    NORMAL_MNEMONIC(ST_WCS, ST_WCS, "st.wcs"),

 27619 +    NORMAL_MNEMONIC(ST_WGE, ST_WGE, "st.wge"),

 27620 +    NORMAL_MNEMONIC(ST_WLT, ST_WLT, "st.wlt"),

 27621 +    NORMAL_MNEMONIC(ST_WMI, ST_WMI, "st.wmi"),

 27622 +    NORMAL_MNEMONIC(ST_WPL, ST_WPL, "st.wpl"),

 27623 +    NORMAL_MNEMONIC(ST_WLS, ST_WLS, "st.wls"),

 27624 +    NORMAL_MNEMONIC(ST_WGT, ST_WGT, "st.wgt"),

 27625 +    NORMAL_MNEMONIC(ST_WLE, ST_WLE, "st.wle"),

 27626 +    NORMAL_MNEMONIC(ST_WHI, ST_WHI, "st.whi"),

 27627 +    NORMAL_MNEMONIC(ST_WVS, ST_WVS, "st.wvs"),

 27628 +    NORMAL_MNEMONIC(ST_WVC, ST_WVC, "st.wvc"),

 27629 +    NORMAL_MNEMONIC(ST_WQS, ST_WQS, "st.wqs"),

 27630 +    NORMAL_MNEMONIC(ST_WAL, ST_WAL, "st.wal"),

 27631 +    NORMAL_MNEMONIC(ST_WHS, ST_WHS, "st.whs"),

 27632 +    NORMAL_MNEMONIC(ST_WLO, ST_WLO, "st.wlo"),

 27633 +    NORMAL_MNEMONIC(ST_HEQ, ST_HEQ, "st.heq"),

 27634 +    NORMAL_MNEMONIC(ST_HNE, ST_HNE, "st.hne"),

 27635 +    NORMAL_MNEMONIC(ST_HCC, ST_HCC, "st.hcc"),

 27636 +    NORMAL_MNEMONIC(ST_HCS, ST_HCS, "st.hcs"),

 27637 +    NORMAL_MNEMONIC(ST_HGE, ST_HGE, "st.hge"),

 27638 +    NORMAL_MNEMONIC(ST_HLT, ST_HLT, "st.hlt"),

 27639 +    NORMAL_MNEMONIC(ST_HMI, ST_HMI, "st.hmi"),

 27640 +    NORMAL_MNEMONIC(ST_HPL, ST_HPL, "st.hpl"),

 27641 +    NORMAL_MNEMONIC(ST_HLS, ST_HLS, "st.hls"),

 27642 +    NORMAL_MNEMONIC(ST_HGT, ST_HGT, "st.hgt"),

 27643 +    NORMAL_MNEMONIC(ST_HLE, ST_HLE, "st.hle"),

 27644 +    NORMAL_MNEMONIC(ST_HHI, ST_HHI, "st.hhi"),

 27645 +    NORMAL_MNEMONIC(ST_HVS, ST_HVS, "st.hvs"),

 27646 +    NORMAL_MNEMONIC(ST_HVC, ST_HVC, "st.hvc"),

 27647 +    NORMAL_MNEMONIC(ST_HQS, ST_HQS, "st.hqs"),

 27648 +    NORMAL_MNEMONIC(ST_HAL, ST_HAL, "st.hal"),

 27649 +    NORMAL_MNEMONIC(ST_HHS, ST_HHS, "st.hhs"),

 27650 +    NORMAL_MNEMONIC(ST_HLO, ST_HLO, "st.hlo"),

 27651 +    NORMAL_MNEMONIC(ST_BEQ, ST_BEQ, "st.beq"),

 27652 +    NORMAL_MNEMONIC(ST_BNE, ST_BNE, "st.bne"),

 27653 +    NORMAL_MNEMONIC(ST_BCC, ST_BCC, "st.bcc"),

 27654 +    NORMAL_MNEMONIC(ST_BCS, ST_BCS, "st.bcs"),

 27655 +    NORMAL_MNEMONIC(ST_BGE, ST_BGE, "st.bge"),

 27656 +    NORMAL_MNEMONIC(ST_BLT, ST_BLT, "st.blt"),

 27657 +    NORMAL_MNEMONIC(ST_BMI, ST_BMI, "st.bmi"),

 27658 +    NORMAL_MNEMONIC(ST_BPL, ST_BPL, "st.bpl"),

 27659 +    NORMAL_MNEMONIC(ST_BLS, ST_BLS, "st.bls"),

 27660 +    NORMAL_MNEMONIC(ST_BGT, ST_BGT, "st.bgt"),

 27661 +    NORMAL_MNEMONIC(ST_BLE, ST_BLE, "st.ble"),

 27662 +    NORMAL_MNEMONIC(ST_BHI, ST_BHI, "st.bhi"),

 27663 +    NORMAL_MNEMONIC(ST_BVS, ST_BVS, "st.bvs"),

 27664 +    NORMAL_MNEMONIC(ST_BVC, ST_BVC, "st.bvc"),

 27665 +    NORMAL_MNEMONIC(ST_BQS, ST_BQS, "st.bqs"),

 27666 +    NORMAL_MNEMONIC(ST_BAL, ST_BAL, "st.bal"),

 27667 +    NORMAL_MNEMONIC(ST_BHS, ST_BHS, "st.bhs"),

 27668 +    NORMAL_MNEMONIC(ST_BLO, ST_BLO, "st.blo"),

 27669 +    NORMAL_MNEMONIC(MOVH, MOVH, "movh"),

 27670 +

 27671 +  };

 27672 +#undef NORMAL_MNEMONIC

 27673 +#undef ALIAS_MNEMONIC

 27674 +#undef FP_MNEMONIC

 27675 --- /dev/null

 27676 +++ b/opcodes/avr32-opc.h

 27677 @@ -0,0 +1,2370 @@

 27678 +/* Opcode tables for AVR32.

 27679 +   Copyright 2005, 2006 Atmel Corporation.

 27680 +

 27681 +   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>

 27682 +

 27683 +   This file is part of libopcodes.

 27684 +

 27685 +   This program is free software; you can redistribute it and/or

 27686 +   modify it under the terms of the GNU General Public License as

 27687 +   published by the Free Software Foundation; either version 2 of the

 27688 +   License, or (at your option) any later version.

 27689 +

 27690 +   This program is distributed in the hope that it will be useful, but

 27691 +   WITHOUT ANY WARRANTY; without even the implied warranty of

 27692 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 27693 +   General Public License for more details.

 27694 +

 27695 +   You should have received a copy of the GNU General Public License

 27696 +   along with this program; if not, write to the Free Software

 27697 +   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

 27698 +   02111-1307, USA.  */

 27699 +

 27700 +#include "bfd.h"

 27701 +

 27702 +#define AVR32_MAX_OPERANDS	8

 27703 +#define AVR32_MAX_FIELDS	8

 27704 +

 27705 +#define AVR32_V1	        (1 << 1)

 27706 +#define AVR32_SIMD		(1 << 2)

 27707 +#define AVR32_DSP		(1 << 3)

 27708 +#define AVR32_RMW		(1 << 4)

 27709 +#define AVR32_V2	        (1 << 5)

 27710 +#define AVR32_FP		(1 << 16)

 27711 +#define AVR32_PICO		(1 << 17)

 27712 +

 27713 +/* Registers we commonly refer to */

 27714 +#define AVR32_REG_R12		12

 27715 +#define AVR32_REG_SP		13

 27716 +#define AVR32_REG_LR		14

 27717 +#define AVR32_REG_PC		15

 27718 +

 27719 +struct avr32_ifield

 27720 +{

 27721 +  int id;

 27722 +  unsigned short bitsize;

 27723 +  unsigned short shift;

 27724 +  unsigned long mask;

 27725 +

 27726 +  /* If the value doesn't fit, it will be truncated with no warning */

 27727 +  void (*insert)(const struct avr32_ifield *, void *, unsigned long);

 27728 +  void (*extract)(const struct avr32_ifield *, void *, unsigned long *);

 27729 +};

 27730 +

 27731 +struct avr32_opcode

 27732 +{

 27733 +  int id;

 27734 +  int size;

 27735 +  unsigned long value;

 27736 +  unsigned long mask;

 27737 +  const struct avr32_syntax *syntax;

 27738 +  bfd_reloc_code_real_type reloc_type;

 27739 +  unsigned int nr_fields;

 27740 +  /* if relaxable, which field is variable, otherwise -1 */

 27741 +  int var_field;

 27742 +  const struct avr32_ifield *fields[AVR32_MAX_FIELDS];

 27743 +};

 27744 +

 27745 +struct avr32_alias

 27746 +{

 27747 +  int id;

 27748 +  const struct avr32_opcode *opc;

 27749 +  struct {

 27750 +    int is_opindex;

 27751 +    unsigned long value;

 27752 +  } operand_map[AVR32_MAX_OPERANDS];

 27753 +};

 27754 +

 27755 +struct avr32_syntax

 27756 +{

 27757 +  int id;

 27758 +  unsigned long isa_flags;

 27759 +  const struct avr32_mnemonic *mnemonic;

 27760 +  int type;

 27761 +  union {

 27762 +    const struct avr32_opcode *opc;

 27763 +    const struct avr32_alias *alias;

 27764 +  } u;

 27765 +  const struct avr32_syntax *next;

 27766 +  /* negative means "vararg" */

 27767 +  int nr_operands;

 27768 +  int operand[AVR32_MAX_OPERANDS];

 27769 +};

 27770 +

 27771 +#if 0

 27772 +#define AVR32_ALIAS_MAKE_CONST(val) ((val) | 0x80000000UL)

 27773 +#define AVR32_ALIAS_IS_CONST(mapval) (((mapval) & 0x80000000UL) != 0)

 27774 +#define AVR32_ALIAS_GET_CONST(mapval) ((mapval) & ~0x80000000UL)

 27775 +#endif

 27776 +

 27777 +struct avr32_mnemonic

 27778 +{

 27779 +  int id;

 27780 +  const char *name;

 27781 +  const struct avr32_syntax *syntax;

 27782 +};

 27783 +

 27784 +extern const struct avr32_ifield avr32_ifield_table[];

 27785 +extern struct avr32_opcode avr32_opc_table[];

 27786 +extern const struct avr32_syntax avr32_syntax_table[];

 27787 +extern const struct avr32_alias avr32_alias_table[];

 27788 +extern const struct avr32_mnemonic avr32_mnemonic_table[];

 27789 +

 27790 +extern void avr32_insert_simple(const struct avr32_ifield *field,

 27791 +				void *buf, unsigned long value);

 27792 +extern void avr32_insert_bit5c(const struct avr32_ifield *field,

 27793 +			       void *buf, unsigned long value);

 27794 +extern void avr32_insert_k10(const struct avr32_ifield *field,

 27795 +			     void *buf, unsigned long value);

 27796 +extern void avr32_insert_k21(const struct avr32_ifield *field,

 27797 +			     void *buf, unsigned long value);

 27798 +extern void avr32_insert_cpop(const struct avr32_ifield *field,

 27799 +			      void *buf, unsigned long value);

 27800 +extern void avr32_insert_k12cp(const struct avr32_ifield *field,

 27801 +			       void *buf, unsigned long value);

 27802 +

 27803 +extern void avr32_extract_simple(const struct avr32_ifield *field,

 27804 +				 void *buf, unsigned long *value);

 27805 +extern void avr32_extract_bit5c(const struct avr32_ifield *field,

 27806 +				void *buf, unsigned long *value);

 27807 +extern void avr32_extract_k10(const struct avr32_ifield *field,

 27808 +			      void *buf, unsigned long *value);

 27809 +extern void avr32_extract_k21(const struct avr32_ifield *field,

 27810 +			      void *buf, unsigned long *value);

 27811 +extern void avr32_extract_cpop(const struct avr32_ifield *field,

 27812 +			       void *buf, unsigned long *value);

 27813 +extern void avr32_extract_k12cp(const struct avr32_ifield *field,

 27814 +				void *buf, unsigned long *value);

 27815 +

 27816 +enum avr32_operand_type

 27817 +{

 27818 +  AVR32_OPERAND_INTREG,		/* just a register */

 27819 +  AVR32_OPERAND_INTREG_PREDEC,	/* register with pre-decrement */

 27820 +  AVR32_OPERAND_INTREG_POSTINC,	/* register with post-increment */

 27821 +  AVR32_OPERAND_INTREG_LSL,	/* register with left shift */

 27822 +  AVR32_OPERAND_INTREG_LSR,	/* register with right shift */

 27823 +  AVR32_OPERAND_INTREG_BSEL,	/* register with byte selector */

 27824 +  AVR32_OPERAND_INTREG_HSEL,	/* register with halfword selector */

 27825 +  AVR32_OPERAND_INTREG_SDISP,	/* Rp[signed disp] */

 27826 +  AVR32_OPERAND_INTREG_SDISP_H,	/* Rp[signed hword-aligned disp] */

 27827 +  AVR32_OPERAND_INTREG_SDISP_W,	/* Rp[signed word-aligned disp] */

 27828 +  AVR32_OPERAND_INTREG_UDISP,	/* Rp[unsigned disp] */

 27829 +  AVR32_OPERAND_INTREG_UDISP_H,	/* Rp[unsigned hword-aligned disp] */

 27830 +  AVR32_OPERAND_INTREG_UDISP_W, /* Rp[unsigned word-aligned disp] */

 27831 +  AVR32_OPERAND_INTREG_INDEX,	/* Rp[Ri << sa] */

 27832 +  AVR32_OPERAND_INTREG_XINDEX,	/* Rp[Ri:bytesel << 2] */

 27833 +  AVR32_OPERAND_DWREG,		/* Even-numbered register */

 27834 +  AVR32_OPERAND_PC_UDISP_W,	/* PC[unsigned word-aligned disp] or label */

 27835 +  AVR32_OPERAND_SP,		/* Just SP */

 27836 +  AVR32_OPERAND_SP_UDISP_W,	/* SP[unsigned word-aligned disp] */

 27837 +  AVR32_OPERAND_CPNO,

 27838 +  AVR32_OPERAND_CPREG,

 27839 +  AVR32_OPERAND_CPREG_D,

 27840 +  AVR32_OPERAND_UNSIGNED_CONST,

 27841 +  AVR32_OPERAND_UNSIGNED_CONST_W,

 27842 +  AVR32_OPERAND_SIGNED_CONST,

 27843 +  AVR32_OPERAND_SIGNED_CONST_W,

 27844 +  AVR32_OPERAND_JMPLABEL,

 27845 +  AVR32_OPERAND_UNSIGNED_NUMBER,

 27846 +  AVR32_OPERAND_UNSIGNED_NUMBER_W,

 27847 +  AVR32_OPERAND_REGLIST8,

 27848 +  AVR32_OPERAND_REGLIST9,

 27849 +  AVR32_OPERAND_REGLIST16,

 27850 +  AVR32_OPERAND_REGLIST_LDM,

 27851 +  AVR32_OPERAND_REGLIST_CP8,

 27852 +  AVR32_OPERAND_REGLIST_CPD8,

 27853 +  AVR32_OPERAND_RETVAL,

 27854 +  AVR32_OPERAND_MCALL,

 27855 +  AVR32_OPERAND_JOSPINC,

 27856 +  AVR32_OPERAND_COH,

 27857 +  AVR32_OPERAND_FPREG_S,

 27858 +  AVR32_OPERAND_FPREG_D,

 27859 +  AVR32_OPERAND_PICO_REG_W,

 27860 +  AVR32_OPERAND_PICO_REG_D,

 27861 +  AVR32_OPERAND_PICO_REGLIST_W,

 27862 +  AVR32_OPERAND_PICO_REGLIST_D,

 27863 +  AVR32_OPERAND_PICO_IN,

 27864 +  AVR32_OPERAND_PICO_OUT0,

 27865 +  AVR32_OPERAND_PICO_OUT1,

 27866 +  AVR32_OPERAND_PICO_OUT2,

 27867 +  AVR32_OPERAND_PICO_OUT3,

 27868 +  AVR32_OPERAND__END_

 27869 +};

 27870 +#define AVR32_OPERAND_UNKNOWN AVR32_OPERAND__END_

 27871 +#define AVR32_NR_OPERANDS AVR32_OPERAND__END_

 27872 +

 27873 +enum avr32_ifield_type

 27874 +{

 27875 +  AVR32_IFIELD_RX,

 27876 +  AVR32_IFIELD_RY,

 27877 +  AVR32_IFIELD_COND4C,

 27878 +  AVR32_IFIELD_K8C,

 27879 +  AVR32_IFIELD_K7C,

 27880 +  AVR32_IFIELD_K5C,

 27881 +  AVR32_IFIELD_K3,

 27882 +  AVR32_IFIELD_RY_DW,

 27883 +  AVR32_IFIELD_COND4E,

 27884 +  AVR32_IFIELD_K8E,

 27885 +  AVR32_IFIELD_BIT5C,

 27886 +  AVR32_IFIELD_COND3,

 27887 +  AVR32_IFIELD_K10,

 27888 +  AVR32_IFIELD_POPM,

 27889 +  AVR32_IFIELD_K2,

 27890 +  AVR32_IFIELD_RD_E,

 27891 +  AVR32_IFIELD_RD_DW,

 27892 +  AVR32_IFIELD_X,

 27893 +  AVR32_IFIELD_Y,

 27894 +  AVR32_IFIELD_X2,

 27895 +  AVR32_IFIELD_Y2,

 27896 +  AVR32_IFIELD_K5E,

 27897 +  AVR32_IFIELD_PART2,

 27898 +  AVR32_IFIELD_PART1,

 27899 +  AVR32_IFIELD_K16,

 27900 +  AVR32_IFIELD_CACHEOP,

 27901 +  AVR32_IFIELD_K11,

 27902 +  AVR32_IFIELD_K21,

 27903 +  AVR32_IFIELD_CPOP,

 27904 +  AVR32_IFIELD_CPNO,

 27905 +  AVR32_IFIELD_CRD_RI,

 27906 +  AVR32_IFIELD_CRX,

 27907 +  AVR32_IFIELD_CRY,

 27908 +  AVR32_IFIELD_K7E,

 27909 +  AVR32_IFIELD_CRD_DW,

 27910 +  AVR32_IFIELD_PART1_K12,

 27911 +  AVR32_IFIELD_PART2_K12,

 27912 +  AVR32_IFIELD_K12,

 27913 +  AVR32_IFIELD_S5,

 27914 +  AVR32_IFIELD_K5E2,

 27915 +  AVR32_IFIELD_K4,

 27916 +  AVR32_IFIELD_COND4E2,

 27917 +  AVR32_IFIELD_K8E2,

 27918 +  AVR32_IFIELD_K6,

 27919 +  AVR32_IFIELD_MEM15,

 27920 +  AVR32_IFIELD_MEMB5,

 27921 +  AVR32_IFIELD_W,

 27922 +  AVR32_IFIELD_CM_HL,

 27923 +  AVR32_IFIELD_K12CP,

 27924 +  AVR32_IFIELD_K9E,

 27925 +  AVR32_IFIELD__END_,

 27926 +};

 27927 +#define AVR32_NR_IFIELDS AVR32_IFIELD__END_

 27928 +

 27929 +enum avr32_opc_type

 27930 +{

 27931 +  AVR32_OPC_ABS,

 27932 +  AVR32_OPC_ACALL,

 27933 +  AVR32_OPC_ACR,

 27934 +  AVR32_OPC_ADC,

 27935 +  AVR32_OPC_ADD1,

 27936 +  AVR32_OPC_ADD2,

 27937 +  AVR32_OPC_ADDABS,

 27938 +  AVR32_OPC_ADDHH_W,

 27939 +  AVR32_OPC_AND1,

 27940 +  AVR32_OPC_AND2,

 27941 +  AVR32_OPC_AND3,

 27942 +  AVR32_OPC_ANDH,

 27943 +  AVR32_OPC_ANDH_COH,

 27944 +  AVR32_OPC_ANDL,

 27945 +  AVR32_OPC_ANDL_COH,

 27946 +  AVR32_OPC_ANDN,

 27947 +  AVR32_OPC_ASR1,

 27948 +  AVR32_OPC_ASR3,

 27949 +  AVR32_OPC_ASR2,

 27950 +  AVR32_OPC_BLD,

 27951 +  AVR32_OPC_BREQ1,

 27952 +  AVR32_OPC_BRNE1,

 27953 +  AVR32_OPC_BRCC1,

 27954 +  AVR32_OPC_BRCS1,

 27955 +  AVR32_OPC_BRGE1,

 27956 +  AVR32_OPC_BRLT1,

 27957 +  AVR32_OPC_BRMI1,

 27958 +  AVR32_OPC_BRPL1,

 27959 +  AVR32_OPC_BREQ2,

 27960 +  AVR32_OPC_BRNE2,

 27961 +  AVR32_OPC_BRCC2,

 27962 +  AVR32_OPC_BRCS2,

 27963 +  AVR32_OPC_BRGE2,

 27964 +  AVR32_OPC_BRLT2,

 27965 +  AVR32_OPC_BRMI2,

 27966 +  AVR32_OPC_BRPL2,

 27967 +  AVR32_OPC_BRLS,

 27968 +  AVR32_OPC_BRGT,

 27969 +  AVR32_OPC_BRLE,

 27970 +  AVR32_OPC_BRHI,

 27971 +  AVR32_OPC_BRVS,

 27972 +  AVR32_OPC_BRVC,

 27973 +  AVR32_OPC_BRQS,

 27974 +  AVR32_OPC_BRAL,

 27975 +  AVR32_OPC_BREAKPOINT,

 27976 +  AVR32_OPC_BREV,

 27977 +  AVR32_OPC_BST,

 27978 +  AVR32_OPC_CACHE,

 27979 +  AVR32_OPC_CASTS_B,

 27980 +  AVR32_OPC_CASTS_H,

 27981 +  AVR32_OPC_CASTU_B,

 27982 +  AVR32_OPC_CASTU_H,

 27983 +  AVR32_OPC_CBR,

 27984 +  AVR32_OPC_CLZ,

 27985 +  AVR32_OPC_COM,

 27986 +  AVR32_OPC_COP,

 27987 +  AVR32_OPC_CP_B,

 27988 +  AVR32_OPC_CP_H,

 27989 +  AVR32_OPC_CP_W1,

 27990 +  AVR32_OPC_CP_W2,

 27991 +  AVR32_OPC_CP_W3,

 27992 +  AVR32_OPC_CPC1,

 27993 +  AVR32_OPC_CPC2,

 27994 +  AVR32_OPC_CSRF,

 27995 +  AVR32_OPC_CSRFCZ,

 27996 +  AVR32_OPC_DIVS,

 27997 +  AVR32_OPC_DIVU,

 27998 +  AVR32_OPC_EOR1,

 27999 +  AVR32_OPC_EOR2,

 28000 +  AVR32_OPC_EOR3,

 28001 +  AVR32_OPC_EORL,

 28002 +  AVR32_OPC_EORH,

 28003 +  AVR32_OPC_FRS,

 28004 +  AVR32_OPC_ICALL,

 28005 +  AVR32_OPC_INCJOSP,

 28006 +  AVR32_OPC_LD_D1,

 28007 +  AVR32_OPC_LD_D2,

 28008 +  AVR32_OPC_LD_D3,

 28009 +  AVR32_OPC_LD_D5,

 28010 +  AVR32_OPC_LD_D4,

 28011 +  AVR32_OPC_LD_SB2,

 28012 +  AVR32_OPC_LD_SB1,

 28013 +  AVR32_OPC_LD_UB1,

 28014 +  AVR32_OPC_LD_UB2,

 28015 +  AVR32_OPC_LD_UB5,

 28016 +  AVR32_OPC_LD_UB3,

 28017 +  AVR32_OPC_LD_UB4,

 28018 +  AVR32_OPC_LD_SH1,

 28019 +  AVR32_OPC_LD_SH2,

 28020 +  AVR32_OPC_LD_SH5,

 28021 +  AVR32_OPC_LD_SH3,

 28022 +  AVR32_OPC_LD_SH4,

 28023 +  AVR32_OPC_LD_UH1,

 28024 +  AVR32_OPC_LD_UH2,

 28025 +  AVR32_OPC_LD_UH5,

 28026 +  AVR32_OPC_LD_UH3,

 28027 +  AVR32_OPC_LD_UH4,

 28028 +  AVR32_OPC_LD_W1,

 28029 +  AVR32_OPC_LD_W2,

 28030 +  AVR32_OPC_LD_W5,

 28031 +  AVR32_OPC_LD_W6,

 28032 +  AVR32_OPC_LD_W3,

 28033 +  AVR32_OPC_LD_W4,

 28034 +  AVR32_OPC_LDC_D1,

 28035 +  AVR32_OPC_LDC_D2,

 28036 +  AVR32_OPC_LDC_D3,

 28037 +  AVR32_OPC_LDC_W1,

 28038 +  AVR32_OPC_LDC_W2,

 28039 +  AVR32_OPC_LDC_W3,

 28040 +  AVR32_OPC_LDC0_D,

 28041 +  AVR32_OPC_LDC0_W,

 28042 +  AVR32_OPC_LDCM_D,

 28043 +  AVR32_OPC_LDCM_D_PU,

 28044 +  AVR32_OPC_LDCM_W,

 28045 +  AVR32_OPC_LDCM_W_PU,

 28046 +  AVR32_OPC_LDDPC,

 28047 +  AVR32_OPC_LDDPC_EXT,

 28048 +  AVR32_OPC_LDDSP,

 28049 +  AVR32_OPC_LDINS_B,

 28050 +  AVR32_OPC_LDINS_H,

 28051 +  AVR32_OPC_LDM,

 28052 +  AVR32_OPC_LDMTS,

 28053 +  AVR32_OPC_LDMTS_PU,

 28054 +  AVR32_OPC_LDSWP_SH,

 28055 +  AVR32_OPC_LDSWP_UH,

 28056 +  AVR32_OPC_LDSWP_W,

 28057 +  AVR32_OPC_LSL1,

 28058 +  AVR32_OPC_LSL3,

 28059 +  AVR32_OPC_LSL2,

 28060 +  AVR32_OPC_LSR1,

 28061 +  AVR32_OPC_LSR3,

 28062 +  AVR32_OPC_LSR2,

 28063 +  AVR32_OPC_MAC,

 28064 +  AVR32_OPC_MACHH_D,

 28065 +  AVR32_OPC_MACHH_W,

 28066 +  AVR32_OPC_MACS_D,

 28067 +  AVR32_OPC_MACSATHH_W,

 28068 +  AVR32_OPC_MACUD,

 28069 +  AVR32_OPC_MACWH_D,

 28070 +  AVR32_OPC_MAX,

 28071 +  AVR32_OPC_MCALL,

 28072 +  AVR32_OPC_MFDR,

 28073 +  AVR32_OPC_MFSR,

 28074 +  AVR32_OPC_MIN,

 28075 +  AVR32_OPC_MOV3,

 28076 +  AVR32_OPC_MOV1,

 28077 +  AVR32_OPC_MOV2,

 28078 +  AVR32_OPC_MOVEQ1,

 28079 +  AVR32_OPC_MOVNE1,

 28080 +  AVR32_OPC_MOVCC1,

 28081 +  AVR32_OPC_MOVCS1,

 28082 +  AVR32_OPC_MOVGE1,

 28083 +  AVR32_OPC_MOVLT1,

 28084 +  AVR32_OPC_MOVMI1,

 28085 +  AVR32_OPC_MOVPL1,

 28086 +  AVR32_OPC_MOVLS1,

 28087 +  AVR32_OPC_MOVGT1,

 28088 +  AVR32_OPC_MOVLE1,

 28089 +  AVR32_OPC_MOVHI1,

 28090 +  AVR32_OPC_MOVVS1,

 28091 +  AVR32_OPC_MOVVC1,

 28092 +  AVR32_OPC_MOVQS1,

 28093 +  AVR32_OPC_MOVAL1,

 28094 +  AVR32_OPC_MOVEQ2,

 28095 +  AVR32_OPC_MOVNE2,

 28096 +  AVR32_OPC_MOVCC2,

 28097 +  AVR32_OPC_MOVCS2,

 28098 +  AVR32_OPC_MOVGE2,

 28099 +  AVR32_OPC_MOVLT2,

 28100 +  AVR32_OPC_MOVMI2,

 28101 +  AVR32_OPC_MOVPL2,

 28102 +  AVR32_OPC_MOVLS2,

 28103 +  AVR32_OPC_MOVGT2,

 28104 +  AVR32_OPC_MOVLE2,

 28105 +  AVR32_OPC_MOVHI2,

 28106 +  AVR32_OPC_MOVVS2,

 28107 +  AVR32_OPC_MOVVC2,

 28108 +  AVR32_OPC_MOVQS2,

 28109 +  AVR32_OPC_MOVAL2,

 28110 +  AVR32_OPC_MTDR,

 28111 +  AVR32_OPC_MTSR,

 28112 +  AVR32_OPC_MUL1,

 28113 +  AVR32_OPC_MUL2,

 28114 +  AVR32_OPC_MUL3,

 28115 +  AVR32_OPC_MULHH_W,

 28116 +  AVR32_OPC_MULNHH_W,

 28117 +  AVR32_OPC_MULNWH_D,

 28118 +  AVR32_OPC_MULSD,

 28119 +  AVR32_OPC_MULSATHH_H,

 28120 +  AVR32_OPC_MULSATHH_W,

 28121 +  AVR32_OPC_MULSATRNDHH_H,

 28122 +  AVR32_OPC_MULSATRNDWH_W,

 28123 +  AVR32_OPC_MULSATWH_W,

 28124 +  AVR32_OPC_MULU_D,

 28125 +  AVR32_OPC_MULWH_D,

 28126 +  AVR32_OPC_MUSFR,

 28127 +  AVR32_OPC_MUSTR,

 28128 +  AVR32_OPC_MVCR_D,

 28129 +  AVR32_OPC_MVCR_W,

 28130 +  AVR32_OPC_MVRC_D,

 28131 +  AVR32_OPC_MVRC_W,

 28132 +  AVR32_OPC_NEG,

 28133 +  AVR32_OPC_NOP,

 28134 +  AVR32_OPC_OR1,

 28135 +  AVR32_OPC_OR2,

 28136 +  AVR32_OPC_OR3,

 28137 +  AVR32_OPC_ORH,

 28138 +  AVR32_OPC_ORL,

 28139 +  AVR32_OPC_PABS_SB,

 28140 +  AVR32_OPC_PABS_SH,

 28141 +  AVR32_OPC_PACKSH_SB,

 28142 +  AVR32_OPC_PACKSH_UB,

 28143 +  AVR32_OPC_PACKW_SH,

 28144 +  AVR32_OPC_PADD_B,

 28145 +  AVR32_OPC_PADD_H,

 28146 +  AVR32_OPC_PADDH_SH,

 28147 +  AVR32_OPC_PADDH_UB,

 28148 +  AVR32_OPC_PADDS_SB,

 28149 +  AVR32_OPC_PADDS_SH,

 28150 +  AVR32_OPC_PADDS_UB,

 28151 +  AVR32_OPC_PADDS_UH,

 28152 +  AVR32_OPC_PADDSUB_H,

 28153 +  AVR32_OPC_PADDSUBH_SH,

 28154 +  AVR32_OPC_PADDSUBS_SH,

 28155 +  AVR32_OPC_PADDSUBS_UH,

 28156 +  AVR32_OPC_PADDX_H,

 28157 +  AVR32_OPC_PADDXH_SH,

 28158 +  AVR32_OPC_PADDXS_SH,

 28159 +  AVR32_OPC_PADDXS_UH,

 28160 +  AVR32_OPC_PASR_B,

 28161 +  AVR32_OPC_PASR_H,

 28162 +  AVR32_OPC_PAVG_SH,

 28163 +  AVR32_OPC_PAVG_UB,

 28164 +  AVR32_OPC_PLSL_B,

 28165 +  AVR32_OPC_PLSL_H,

 28166 +  AVR32_OPC_PLSR_B,

 28167 +  AVR32_OPC_PLSR_H,

 28168 +  AVR32_OPC_PMAX_SH,

 28169 +  AVR32_OPC_PMAX_UB,

 28170 +  AVR32_OPC_PMIN_SH,

 28171 +  AVR32_OPC_PMIN_UB,

 28172 +  AVR32_OPC_POPJC,

 28173 +  AVR32_OPC_POPM,

 28174 +  AVR32_OPC_POPM_E,

 28175 +  AVR32_OPC_PREF,

 28176 +  AVR32_OPC_PSAD,

 28177 +  AVR32_OPC_PSUB_B,

 28178 +  AVR32_OPC_PSUB_H,

 28179 +  AVR32_OPC_PSUBADD_H,

 28180 +  AVR32_OPC_PSUBADDH_SH,

 28181 +  AVR32_OPC_PSUBADDS_SH,

 28182 +  AVR32_OPC_PSUBADDS_UH,

 28183 +  AVR32_OPC_PSUBH_SH,

 28184 +  AVR32_OPC_PSUBH_UB,

 28185 +  AVR32_OPC_PSUBS_SB,

 28186 +  AVR32_OPC_PSUBS_SH,

 28187 +  AVR32_OPC_PSUBS_UB,

 28188 +  AVR32_OPC_PSUBS_UH,

 28189 +  AVR32_OPC_PSUBX_H,

 28190 +  AVR32_OPC_PSUBXH_SH,

 28191 +  AVR32_OPC_PSUBXS_SH,

 28192 +  AVR32_OPC_PSUBXS_UH,

 28193 +  AVR32_OPC_PUNPCKSB_H,

 28194 +  AVR32_OPC_PUNPCKUB_H,

 28195 +  AVR32_OPC_PUSHJC,

 28196 +  AVR32_OPC_PUSHM,

 28197 +  AVR32_OPC_PUSHM_E,

 28198 +  AVR32_OPC_RCALL1,

 28199 +  AVR32_OPC_RCALL2,

 28200 +  AVR32_OPC_RETEQ,

 28201 +  AVR32_OPC_RETNE,

 28202 +  AVR32_OPC_RETCC,

 28203 +  AVR32_OPC_RETCS,

 28204 +  AVR32_OPC_RETGE,

 28205 +  AVR32_OPC_RETLT,

 28206 +  AVR32_OPC_RETMI,

 28207 +  AVR32_OPC_RETPL,

 28208 +  AVR32_OPC_RETLS,

 28209 +  AVR32_OPC_RETGT,

 28210 +  AVR32_OPC_RETLE,

 28211 +  AVR32_OPC_RETHI,

 28212 +  AVR32_OPC_RETVS,

 28213 +  AVR32_OPC_RETVC,

 28214 +  AVR32_OPC_RETQS,

 28215 +  AVR32_OPC_RETAL,

 28216 +  AVR32_OPC_RETD,

 28217 +  AVR32_OPC_RETE,

 28218 +  AVR32_OPC_RETJ,

 28219 +  AVR32_OPC_RETS,

 28220 +  AVR32_OPC_RJMP,

 28221 +  AVR32_OPC_ROL,

 28222 +  AVR32_OPC_ROR,

 28223 +  AVR32_OPC_RSUB1,

 28224 +  AVR32_OPC_RSUB2,

 28225 +  AVR32_OPC_SATADD_H,

 28226 +  AVR32_OPC_SATADD_W,

 28227 +  AVR32_OPC_SATRNDS,

 28228 +  AVR32_OPC_SATRNDU,

 28229 +  AVR32_OPC_SATS,

 28230 +  AVR32_OPC_SATSUB_H,

 28231 +  AVR32_OPC_SATSUB_W1,

 28232 +  AVR32_OPC_SATSUB_W2,

 28233 +  AVR32_OPC_SATU,

 28234 +  AVR32_OPC_SBC,

 28235 +  AVR32_OPC_SBR,

 28236 +  AVR32_OPC_SCALL,

 28237 +  AVR32_OPC_SCR,

 28238 +  AVR32_OPC_SLEEP,

 28239 +  AVR32_OPC_SREQ,

 28240 +  AVR32_OPC_SRNE,

 28241 +  AVR32_OPC_SRCC,

 28242 +  AVR32_OPC_SRCS,

 28243 +  AVR32_OPC_SRGE,

 28244 +  AVR32_OPC_SRLT,

 28245 +  AVR32_OPC_SRMI,

 28246 +  AVR32_OPC_SRPL,

 28247 +  AVR32_OPC_SRLS,

 28248 +  AVR32_OPC_SRGT,

 28249 +  AVR32_OPC_SRLE,

 28250 +  AVR32_OPC_SRHI,

 28251 +  AVR32_OPC_SRVS,

 28252 +  AVR32_OPC_SRVC,

 28253 +  AVR32_OPC_SRQS,

 28254 +  AVR32_OPC_SRAL,

 28255 +  AVR32_OPC_SSRF,

 28256 +  AVR32_OPC_ST_B1,

 28257 +  AVR32_OPC_ST_B2,

 28258 +  AVR32_OPC_ST_B5,

 28259 +  AVR32_OPC_ST_B3,

 28260 +  AVR32_OPC_ST_B4,

 28261 +  AVR32_OPC_ST_D1,

 28262 +  AVR32_OPC_ST_D2,

 28263 +  AVR32_OPC_ST_D3,

 28264 +  AVR32_OPC_ST_D5,

 28265 +  AVR32_OPC_ST_D4,

 28266 +  AVR32_OPC_ST_H1,

 28267 +  AVR32_OPC_ST_H2,

 28268 +  AVR32_OPC_ST_H5,

 28269 +  AVR32_OPC_ST_H3,

 28270 +  AVR32_OPC_ST_H4,

 28271 +  AVR32_OPC_ST_W1,

 28272 +  AVR32_OPC_ST_W2,

 28273 +  AVR32_OPC_ST_W5,

 28274 +  AVR32_OPC_ST_W3,

 28275 +  AVR32_OPC_ST_W4,

 28276 +  AVR32_OPC_STC_D1,

 28277 +  AVR32_OPC_STC_D2,

 28278 +  AVR32_OPC_STC_D3,

 28279 +  AVR32_OPC_STC_W1,

 28280 +  AVR32_OPC_STC_W2,

 28281 +  AVR32_OPC_STC_W3,

 28282 +  AVR32_OPC_STC0_D,

 28283 +  AVR32_OPC_STC0_W,

 28284 +  AVR32_OPC_STCM_D,

 28285 +  AVR32_OPC_STCM_D_PU,

 28286 +  AVR32_OPC_STCM_W,

 28287 +  AVR32_OPC_STCM_W_PU,

 28288 +  AVR32_OPC_STCOND,

 28289 +  AVR32_OPC_STDSP,

 28290 +  AVR32_OPC_STHH_W2,

 28291 +  AVR32_OPC_STHH_W1,

 28292 +  AVR32_OPC_STM,

 28293 +  AVR32_OPC_STM_PU,

 28294 +  AVR32_OPC_STMTS,

 28295 +  AVR32_OPC_STMTS_PU,

 28296 +  AVR32_OPC_STSWP_H,

 28297 +  AVR32_OPC_STSWP_W,

 28298 +  AVR32_OPC_SUB1,

 28299 +  AVR32_OPC_SUB2,

 28300 +  AVR32_OPC_SUB5,

 28301 +  AVR32_OPC_SUB3_SP,

 28302 +  AVR32_OPC_SUB3,

 28303 +  AVR32_OPC_SUB4,

 28304 +  AVR32_OPC_SUBEQ,

 28305 +  AVR32_OPC_SUBNE,

 28306 +  AVR32_OPC_SUBCC,

 28307 +  AVR32_OPC_SUBCS,

 28308 +  AVR32_OPC_SUBGE,

 28309 +  AVR32_OPC_SUBLT,

 28310 +  AVR32_OPC_SUBMI,

 28311 +  AVR32_OPC_SUBPL,

 28312 +  AVR32_OPC_SUBLS,

 28313 +  AVR32_OPC_SUBGT,

 28314 +  AVR32_OPC_SUBLE,

 28315 +  AVR32_OPC_SUBHI,

 28316 +  AVR32_OPC_SUBVS,

 28317 +  AVR32_OPC_SUBVC,

 28318 +  AVR32_OPC_SUBQS,

 28319 +  AVR32_OPC_SUBAL,

 28320 +  AVR32_OPC_SUBFEQ,

 28321 +  AVR32_OPC_SUBFNE,

 28322 +  AVR32_OPC_SUBFCC,

 28323 +  AVR32_OPC_SUBFCS,

 28324 +  AVR32_OPC_SUBFGE,

 28325 +  AVR32_OPC_SUBFLT,

 28326 +  AVR32_OPC_SUBFMI,

 28327 +  AVR32_OPC_SUBFPL,

 28328 +  AVR32_OPC_SUBFLS,

 28329 +  AVR32_OPC_SUBFGT,

 28330 +  AVR32_OPC_SUBFLE,

 28331 +  AVR32_OPC_SUBFHI,

 28332 +  AVR32_OPC_SUBFVS,

 28333 +  AVR32_OPC_SUBFVC,

 28334 +  AVR32_OPC_SUBFQS,

 28335 +  AVR32_OPC_SUBFAL,

 28336 +  AVR32_OPC_SUBHH_W,

 28337 +  AVR32_OPC_SWAP_B,

 28338 +  AVR32_OPC_SWAP_BH,

 28339 +  AVR32_OPC_SWAP_H,

 28340 +  AVR32_OPC_SYNC,

 28341 +  AVR32_OPC_TLBR,

 28342 +  AVR32_OPC_TLBS,

 28343 +  AVR32_OPC_TLBW,

 28344 +  AVR32_OPC_TNBZ,

 28345 +  AVR32_OPC_TST,

 28346 +  AVR32_OPC_XCHG,

 28347 +  AVR32_OPC_MEMC,

 28348 +  AVR32_OPC_MEMS,

 28349 +  AVR32_OPC_MEMT,

 28350 +  AVR32_OPC_BFEXTS,

 28351 +  AVR32_OPC_BFEXTU,

 28352 +  AVR32_OPC_BFINS,

 28353 +  AVR32_OPC_RSUBEQ,

 28354 +  AVR32_OPC_RSUBNE,

 28355 +  AVR32_OPC_RSUBCC,

 28356 +  AVR32_OPC_RSUBCS,

 28357 +  AVR32_OPC_RSUBGE,

 28358 +  AVR32_OPC_RSUBLT,

 28359 +  AVR32_OPC_RSUBMI,

 28360 +  AVR32_OPC_RSUBPL,

 28361 +  AVR32_OPC_RSUBLS,

 28362 +  AVR32_OPC_RSUBGT,

 28363 +  AVR32_OPC_RSUBLE,

 28364 +  AVR32_OPC_RSUBHI,

 28365 +  AVR32_OPC_RSUBVS,

 28366 +  AVR32_OPC_RSUBVC,

 28367 +  AVR32_OPC_RSUBQS,

 28368 +  AVR32_OPC_RSUBAL,

 28369 +  AVR32_OPC_ADDEQ,

 28370 +  AVR32_OPC_ADDNE,

 28371 +  AVR32_OPC_ADDCC,

 28372 +  AVR32_OPC_ADDCS,

 28373 +  AVR32_OPC_ADDGE,

 28374 +  AVR32_OPC_ADDLT,

 28375 +  AVR32_OPC_ADDMI,

 28376 +  AVR32_OPC_ADDPL,

 28377 +  AVR32_OPC_ADDLS,

 28378 +  AVR32_OPC_ADDGT,

 28379 +  AVR32_OPC_ADDLE,

 28380 +  AVR32_OPC_ADDHI,

 28381 +  AVR32_OPC_ADDVS,

 28382 +  AVR32_OPC_ADDVC,

 28383 +  AVR32_OPC_ADDQS,

 28384 +  AVR32_OPC_ADDAL,

 28385 +  AVR32_OPC_SUB2EQ,

 28386 +  AVR32_OPC_SUB2NE,

 28387 +  AVR32_OPC_SUB2CC,

 28388 +  AVR32_OPC_SUB2CS,

 28389 +  AVR32_OPC_SUB2GE,

 28390 +  AVR32_OPC_SUB2LT,

 28391 +  AVR32_OPC_SUB2MI,

 28392 +  AVR32_OPC_SUB2PL,

 28393 +  AVR32_OPC_SUB2LS,

 28394 +  AVR32_OPC_SUB2GT,

 28395 +  AVR32_OPC_SUB2LE,

 28396 +  AVR32_OPC_SUB2HI,

 28397 +  AVR32_OPC_SUB2VS,

 28398 +  AVR32_OPC_SUB2VC,

 28399 +  AVR32_OPC_SUB2QS,

 28400 +  AVR32_OPC_SUB2AL,

 28401 +  AVR32_OPC_ANDEQ,

 28402 +  AVR32_OPC_ANDNE,

 28403 +  AVR32_OPC_ANDCC,

 28404 +  AVR32_OPC_ANDCS,

 28405 +  AVR32_OPC_ANDGE,

 28406 +  AVR32_OPC_ANDLT,

 28407 +  AVR32_OPC_ANDMI,

 28408 +  AVR32_OPC_ANDPL,

 28409 +  AVR32_OPC_ANDLS,

 28410 +  AVR32_OPC_ANDGT,

 28411 +  AVR32_OPC_ANDLE,

 28412 +  AVR32_OPC_ANDHI,

 28413 +  AVR32_OPC_ANDVS,

 28414 +  AVR32_OPC_ANDVC,

 28415 +  AVR32_OPC_ANDQS,

 28416 +  AVR32_OPC_ANDAL,

 28417 +  AVR32_OPC_OREQ,

 28418 +  AVR32_OPC_ORNE,

 28419 +  AVR32_OPC_ORCC,

 28420 +  AVR32_OPC_ORCS,

 28421 +  AVR32_OPC_ORGE,

 28422 +  AVR32_OPC_ORLT,

 28423 +  AVR32_OPC_ORMI,

 28424 +  AVR32_OPC_ORPL,

 28425 +  AVR32_OPC_ORLS,

 28426 +  AVR32_OPC_ORGT,

 28427 +  AVR32_OPC_ORLE,

 28428 +  AVR32_OPC_ORHI,

 28429 +  AVR32_OPC_ORVS,

 28430 +  AVR32_OPC_ORVC,

 28431 +  AVR32_OPC_ORQS,

 28432 +  AVR32_OPC_ORAL,

 28433 +  AVR32_OPC_EOREQ,

 28434 +  AVR32_OPC_EORNE,

 28435 +  AVR32_OPC_EORCC,

 28436 +  AVR32_OPC_EORCS,

 28437 +  AVR32_OPC_EORGE,

 28438 +  AVR32_OPC_EORLT,

 28439 +  AVR32_OPC_EORMI,

 28440 +  AVR32_OPC_EORPL,

 28441 +  AVR32_OPC_EORLS,

 28442 +  AVR32_OPC_EORGT,

 28443 +  AVR32_OPC_EORLE,

 28444 +  AVR32_OPC_EORHI,

 28445 +  AVR32_OPC_EORVS,

 28446 +  AVR32_OPC_EORVC,

 28447 +  AVR32_OPC_EORQS,

 28448 +  AVR32_OPC_EORAL,

 28449 +  AVR32_OPC_LD_WEQ,

 28450 +  AVR32_OPC_LD_WNE,

 28451 +  AVR32_OPC_LD_WCC,

 28452 +  AVR32_OPC_LD_WCS,

 28453 +  AVR32_OPC_LD_WGE,

 28454 +  AVR32_OPC_LD_WLT,

 28455 +  AVR32_OPC_LD_WMI,

 28456 +  AVR32_OPC_LD_WPL,

 28457 +  AVR32_OPC_LD_WLS,

 28458 +  AVR32_OPC_LD_WGT,

 28459 +  AVR32_OPC_LD_WLE,

 28460 +  AVR32_OPC_LD_WHI,

 28461 +  AVR32_OPC_LD_WVS,

 28462 +  AVR32_OPC_LD_WVC,

 28463 +  AVR32_OPC_LD_WQS,

 28464 +  AVR32_OPC_LD_WAL,

 28465 +  AVR32_OPC_LD_SHEQ,

 28466 +  AVR32_OPC_LD_SHNE,

 28467 +  AVR32_OPC_LD_SHCC,

 28468 +  AVR32_OPC_LD_SHCS,

 28469 +  AVR32_OPC_LD_SHGE,

 28470 +  AVR32_OPC_LD_SHLT,

 28471 +  AVR32_OPC_LD_SHMI,

 28472 +  AVR32_OPC_LD_SHPL,

 28473 +  AVR32_OPC_LD_SHLS,

 28474 +  AVR32_OPC_LD_SHGT,

 28475 +  AVR32_OPC_LD_SHLE,

 28476 +  AVR32_OPC_LD_SHHI,

 28477 +  AVR32_OPC_LD_SHVS,

 28478 +  AVR32_OPC_LD_SHVC,

 28479 +  AVR32_OPC_LD_SHQS,

 28480 +  AVR32_OPC_LD_SHAL,

 28481 +  AVR32_OPC_LD_UHEQ,

 28482 +  AVR32_OPC_LD_UHNE,

 28483 +  AVR32_OPC_LD_UHCC,

 28484 +  AVR32_OPC_LD_UHCS,

 28485 +  AVR32_OPC_LD_UHGE,

 28486 +  AVR32_OPC_LD_UHLT,

 28487 +  AVR32_OPC_LD_UHMI,

 28488 +  AVR32_OPC_LD_UHPL,

 28489 +  AVR32_OPC_LD_UHLS,

 28490 +  AVR32_OPC_LD_UHGT,

 28491 +  AVR32_OPC_LD_UHLE,

 28492 +  AVR32_OPC_LD_UHHI,

 28493 +  AVR32_OPC_LD_UHVS,

 28494 +  AVR32_OPC_LD_UHVC,

 28495 +  AVR32_OPC_LD_UHQS,

 28496 +  AVR32_OPC_LD_UHAL,

 28497 +  AVR32_OPC_LD_SBEQ,

 28498 +  AVR32_OPC_LD_SBNE,

 28499 +  AVR32_OPC_LD_SBCC,

 28500 +  AVR32_OPC_LD_SBCS,

 28501 +  AVR32_OPC_LD_SBGE,

 28502 +  AVR32_OPC_LD_SBLT,

 28503 +  AVR32_OPC_LD_SBMI,

 28504 +  AVR32_OPC_LD_SBPL,

 28505 +  AVR32_OPC_LD_SBLS,

 28506 +  AVR32_OPC_LD_SBGT,

 28507 +  AVR32_OPC_LD_SBLE,

 28508 +  AVR32_OPC_LD_SBHI,

 28509 +  AVR32_OPC_LD_SBVS,

 28510 +  AVR32_OPC_LD_SBVC,

 28511 +  AVR32_OPC_LD_SBQS,

 28512 +  AVR32_OPC_LD_SBAL,

 28513 +  AVR32_OPC_LD_UBEQ,

 28514 +  AVR32_OPC_LD_UBNE,

 28515 +  AVR32_OPC_LD_UBCC,

 28516 +  AVR32_OPC_LD_UBCS,

 28517 +  AVR32_OPC_LD_UBGE,

 28518 +  AVR32_OPC_LD_UBLT,

 28519 +  AVR32_OPC_LD_UBMI,

 28520 +  AVR32_OPC_LD_UBPL,

 28521 +  AVR32_OPC_LD_UBLS,

 28522 +  AVR32_OPC_LD_UBGT,

 28523 +  AVR32_OPC_LD_UBLE,

 28524 +  AVR32_OPC_LD_UBHI,

 28525 +  AVR32_OPC_LD_UBVS,

 28526 +  AVR32_OPC_LD_UBVC,

 28527 +  AVR32_OPC_LD_UBQS,

 28528 +  AVR32_OPC_LD_UBAL,

 28529 +  AVR32_OPC_ST_WEQ,

 28530 +  AVR32_OPC_ST_WNE,

 28531 +  AVR32_OPC_ST_WCC,

 28532 +  AVR32_OPC_ST_WCS,

 28533 +  AVR32_OPC_ST_WGE,

 28534 +  AVR32_OPC_ST_WLT,

 28535 +  AVR32_OPC_ST_WMI,

 28536 +  AVR32_OPC_ST_WPL,

 28537 +  AVR32_OPC_ST_WLS,

 28538 +  AVR32_OPC_ST_WGT,

 28539 +  AVR32_OPC_ST_WLE,

 28540 +  AVR32_OPC_ST_WHI,

 28541 +  AVR32_OPC_ST_WVS,

 28542 +  AVR32_OPC_ST_WVC,

 28543 +  AVR32_OPC_ST_WQS,

 28544 +  AVR32_OPC_ST_WAL,

 28545 +  AVR32_OPC_ST_HEQ,

 28546 +  AVR32_OPC_ST_HNE,

 28547 +  AVR32_OPC_ST_HCC,

 28548 +  AVR32_OPC_ST_HCS,

 28549 +  AVR32_OPC_ST_HGE,

 28550 +  AVR32_OPC_ST_HLT,

 28551 +  AVR32_OPC_ST_HMI,

 28552 +  AVR32_OPC_ST_HPL,

 28553 +  AVR32_OPC_ST_HLS,

 28554 +  AVR32_OPC_ST_HGT,

 28555 +  AVR32_OPC_ST_HLE,

 28556 +  AVR32_OPC_ST_HHI,

 28557 +  AVR32_OPC_ST_HVS,

 28558 +  AVR32_OPC_ST_HVC,

 28559 +  AVR32_OPC_ST_HQS,

 28560 +  AVR32_OPC_ST_HAL,

 28561 +  AVR32_OPC_ST_BEQ,

 28562 +  AVR32_OPC_ST_BNE,

 28563 +  AVR32_OPC_ST_BCC,

 28564 +  AVR32_OPC_ST_BCS,

 28565 +  AVR32_OPC_ST_BGE,

 28566 +  AVR32_OPC_ST_BLT,

 28567 +  AVR32_OPC_ST_BMI,

 28568 +  AVR32_OPC_ST_BPL,

 28569 +  AVR32_OPC_ST_BLS,

 28570 +  AVR32_OPC_ST_BGT,

 28571 +  AVR32_OPC_ST_BLE,

 28572 +  AVR32_OPC_ST_BHI,

 28573 +  AVR32_OPC_ST_BVS,

 28574 +  AVR32_OPC_ST_BVC,

 28575 +  AVR32_OPC_ST_BQS,

 28576 +  AVR32_OPC_ST_BAL,

 28577 +  AVR32_OPC_MOVH,

 28578 +  AVR32_OPC__END_

 28579 +};

 28580 +#define AVR32_NR_OPCODES AVR32_OPC__END_

 28581 +

 28582 +enum avr32_syntax_type

 28583 +{

 28584 +  AVR32_SYNTAX_ABS,

 28585 +  AVR32_SYNTAX_ACALL,

 28586 +  AVR32_SYNTAX_ACR,

 28587 +  AVR32_SYNTAX_ADC,

 28588 +  AVR32_SYNTAX_ADD1,

 28589 +  AVR32_SYNTAX_ADD2,

 28590 +  AVR32_SYNTAX_ADDABS,

 28591 +  AVR32_SYNTAX_ADDHH_W,

 28592 +  AVR32_SYNTAX_AND1,

 28593 +  AVR32_SYNTAX_AND2,

 28594 +  AVR32_SYNTAX_AND3,

 28595 +  AVR32_SYNTAX_ANDH,

 28596 +  AVR32_SYNTAX_ANDH_COH,

 28597 +  AVR32_SYNTAX_ANDL,

 28598 +  AVR32_SYNTAX_ANDL_COH,

 28599 +  AVR32_SYNTAX_ANDN,

 28600 +  AVR32_SYNTAX_ASR1,

 28601 +  AVR32_SYNTAX_ASR3,

 28602 +  AVR32_SYNTAX_ASR2,

 28603 +  AVR32_SYNTAX_BFEXTS,

 28604 +  AVR32_SYNTAX_BFEXTU,

 28605 +  AVR32_SYNTAX_BFINS,

 28606 +  AVR32_SYNTAX_BLD,

 28607 +  AVR32_SYNTAX_BREQ1,

 28608 +  AVR32_SYNTAX_BRNE1,

 28609 +  AVR32_SYNTAX_BRCC1,

 28610 +  AVR32_SYNTAX_BRCS1,

 28611 +  AVR32_SYNTAX_BRGE1,

 28612 +  AVR32_SYNTAX_BRLT1,

 28613 +  AVR32_SYNTAX_BRMI1,

 28614 +  AVR32_SYNTAX_BRPL1,

 28615 +  AVR32_SYNTAX_BRHS1,

 28616 +  AVR32_SYNTAX_BRLO1,

 28617 +  AVR32_SYNTAX_BREQ2,

 28618 +  AVR32_SYNTAX_BRNE2,

 28619 +  AVR32_SYNTAX_BRCC2,

 28620 +  AVR32_SYNTAX_BRCS2,

 28621 +  AVR32_SYNTAX_BRGE2,

 28622 +  AVR32_SYNTAX_BRLT2,

 28623 +  AVR32_SYNTAX_BRMI2,

 28624 +  AVR32_SYNTAX_BRPL2,

 28625 +  AVR32_SYNTAX_BRLS,

 28626 +  AVR32_SYNTAX_BRGT,

 28627 +  AVR32_SYNTAX_BRLE,

 28628 +  AVR32_SYNTAX_BRHI,

 28629 +  AVR32_SYNTAX_BRVS,

 28630 +  AVR32_SYNTAX_BRVC,

 28631 +  AVR32_SYNTAX_BRQS,

 28632 +  AVR32_SYNTAX_BRAL,

 28633 +  AVR32_SYNTAX_BRHS2,

 28634 +  AVR32_SYNTAX_BRLO2,

 28635 +  AVR32_SYNTAX_BREAKPOINT,

 28636 +  AVR32_SYNTAX_BREV,

 28637 +  AVR32_SYNTAX_BST,

 28638 +  AVR32_SYNTAX_CACHE,

 28639 +  AVR32_SYNTAX_CASTS_B,

 28640 +  AVR32_SYNTAX_CASTS_H,

 28641 +  AVR32_SYNTAX_CASTU_B,

 28642 +  AVR32_SYNTAX_CASTU_H,

 28643 +  AVR32_SYNTAX_CBR,

 28644 +  AVR32_SYNTAX_CLZ,

 28645 +  AVR32_SYNTAX_COM,

 28646 +  AVR32_SYNTAX_COP,

 28647 +  AVR32_SYNTAX_CP_B,

 28648 +  AVR32_SYNTAX_CP_H,

 28649 +  AVR32_SYNTAX_CP_W1,

 28650 +  AVR32_SYNTAX_CP_W2,

 28651 +  AVR32_SYNTAX_CP_W3,

 28652 +  AVR32_SYNTAX_CPC1,

 28653 +  AVR32_SYNTAX_CPC2,

 28654 +  AVR32_SYNTAX_CSRF,

 28655 +  AVR32_SYNTAX_CSRFCZ,

 28656 +  AVR32_SYNTAX_DIVS,

 28657 +  AVR32_SYNTAX_DIVU,

 28658 +  AVR32_SYNTAX_EOR1,

 28659 +  AVR32_SYNTAX_EOR2,

 28660 +  AVR32_SYNTAX_EOR3,

 28661 +  AVR32_SYNTAX_EORL,

 28662 +  AVR32_SYNTAX_EORH,

 28663 +  AVR32_SYNTAX_FRS,

 28664 +  AVR32_SYNTAX_ICALL,

 28665 +  AVR32_SYNTAX_INCJOSP,

 28666 +  AVR32_SYNTAX_LD_D1,

 28667 +  AVR32_SYNTAX_LD_D2,

 28668 +  AVR32_SYNTAX_LD_D3,

 28669 +  AVR32_SYNTAX_LD_D5,

 28670 +  AVR32_SYNTAX_LD_D4,

 28671 +  AVR32_SYNTAX_LD_SB2,

 28672 +  AVR32_SYNTAX_LD_SB1,

 28673 +  AVR32_SYNTAX_LD_UB1,

 28674 +  AVR32_SYNTAX_LD_UB2,

 28675 +  AVR32_SYNTAX_LD_UB5,

 28676 +  AVR32_SYNTAX_LD_UB3,

 28677 +  AVR32_SYNTAX_LD_UB4,

 28678 +  AVR32_SYNTAX_LD_SH1,

 28679 +  AVR32_SYNTAX_LD_SH2,

 28680 +  AVR32_SYNTAX_LD_SH5,

 28681 +  AVR32_SYNTAX_LD_SH3,

 28682 +  AVR32_SYNTAX_LD_SH4,

 28683 +  AVR32_SYNTAX_LD_UH1,

 28684 +  AVR32_SYNTAX_LD_UH2,

 28685 +  AVR32_SYNTAX_LD_UH5,

 28686 +  AVR32_SYNTAX_LD_UH3,

 28687 +  AVR32_SYNTAX_LD_UH4,

 28688 +  AVR32_SYNTAX_LD_W1,

 28689 +  AVR32_SYNTAX_LD_W2,

 28690 +  AVR32_SYNTAX_LD_W5,

 28691 +  AVR32_SYNTAX_LD_W6,

 28692 +  AVR32_SYNTAX_LD_W3,

 28693 +  AVR32_SYNTAX_LD_W4,

 28694 +  AVR32_SYNTAX_LDC_D1,

 28695 +  AVR32_SYNTAX_LDC_D2,

 28696 +  AVR32_SYNTAX_LDC_D3,

 28697 +  AVR32_SYNTAX_LDC_W1,

 28698 +  AVR32_SYNTAX_LDC_W2,

 28699 +  AVR32_SYNTAX_LDC_W3,

 28700 +  AVR32_SYNTAX_LDC0_D,

 28701 +  AVR32_SYNTAX_LDC0_W,

 28702 +  AVR32_SYNTAX_LDCM_D,

 28703 +  AVR32_SYNTAX_LDCM_D_PU,

 28704 +  AVR32_SYNTAX_LDCM_W,

 28705 +  AVR32_SYNTAX_LDCM_W_PU,

 28706 +  AVR32_SYNTAX_LDDPC,

 28707 +  AVR32_SYNTAX_LDDPC_EXT,

 28708 +  AVR32_SYNTAX_LDDSP,

 28709 +  AVR32_SYNTAX_LDINS_B,

 28710 +  AVR32_SYNTAX_LDINS_H,

 28711 +  AVR32_SYNTAX_LDM,

 28712 +  AVR32_SYNTAX_LDMTS,

 28713 +  AVR32_SYNTAX_LDMTS_PU,

 28714 +  AVR32_SYNTAX_LDSWP_SH,

 28715 +  AVR32_SYNTAX_LDSWP_UH,

 28716 +  AVR32_SYNTAX_LDSWP_W,

 28717 +  AVR32_SYNTAX_LSL1,

 28718 +  AVR32_SYNTAX_LSL3,

 28719 +  AVR32_SYNTAX_LSL2,

 28720 +  AVR32_SYNTAX_LSR1,

 28721 +  AVR32_SYNTAX_LSR3,

 28722 +  AVR32_SYNTAX_LSR2,

 28723 +  AVR32_SYNTAX_MAC,

 28724 +  AVR32_SYNTAX_MACHH_D,

 28725 +  AVR32_SYNTAX_MACHH_W,

 28726 +  AVR32_SYNTAX_MACS_D,

 28727 +  AVR32_SYNTAX_MACSATHH_W,

 28728 +  AVR32_SYNTAX_MACUD,

 28729 +  AVR32_SYNTAX_MACWH_D,

 28730 +  AVR32_SYNTAX_MAX,

 28731 +  AVR32_SYNTAX_MCALL,

 28732 +  AVR32_SYNTAX_MFDR,

 28733 +  AVR32_SYNTAX_MFSR,

 28734 +  AVR32_SYNTAX_MIN,

 28735 +  AVR32_SYNTAX_MOV3,

 28736 +  AVR32_SYNTAX_MOV1,

 28737 +  AVR32_SYNTAX_MOV2,

 28738 +  AVR32_SYNTAX_MOVEQ1,

 28739 +  AVR32_SYNTAX_MOVNE1,

 28740 +  AVR32_SYNTAX_MOVCC1,

 28741 +  AVR32_SYNTAX_MOVCS1,

 28742 +  AVR32_SYNTAX_MOVGE1,

 28743 +  AVR32_SYNTAX_MOVLT1,

 28744 +  AVR32_SYNTAX_MOVMI1,

 28745 +  AVR32_SYNTAX_MOVPL1,

 28746 +  AVR32_SYNTAX_MOVLS1,

 28747 +  AVR32_SYNTAX_MOVGT1,

 28748 +  AVR32_SYNTAX_MOVLE1,

 28749 +  AVR32_SYNTAX_MOVHI1,

 28750 +  AVR32_SYNTAX_MOVVS1,

 28751 +  AVR32_SYNTAX_MOVVC1,

 28752 +  AVR32_SYNTAX_MOVQS1,

 28753 +  AVR32_SYNTAX_MOVAL1,

 28754 +  AVR32_SYNTAX_MOVHS1,

 28755 +  AVR32_SYNTAX_MOVLO1,

 28756 +  AVR32_SYNTAX_MOVEQ2,

 28757 +  AVR32_SYNTAX_MOVNE2,

 28758 +  AVR32_SYNTAX_MOVCC2,

 28759 +  AVR32_SYNTAX_MOVCS2,

 28760 +  AVR32_SYNTAX_MOVGE2,

 28761 +  AVR32_SYNTAX_MOVLT2,

 28762 +  AVR32_SYNTAX_MOVMI2,

 28763 +  AVR32_SYNTAX_MOVPL2,

 28764 +  AVR32_SYNTAX_MOVLS2,

 28765 +  AVR32_SYNTAX_MOVGT2,

 28766 +  AVR32_SYNTAX_MOVLE2,

 28767 +  AVR32_SYNTAX_MOVHI2,

 28768 +  AVR32_SYNTAX_MOVVS2,

 28769 +  AVR32_SYNTAX_MOVVC2,

 28770 +  AVR32_SYNTAX_MOVQS2,

 28771 +  AVR32_SYNTAX_MOVAL2,

 28772 +  AVR32_SYNTAX_MOVHS2,

 28773 +  AVR32_SYNTAX_MOVLO2,

 28774 +  AVR32_SYNTAX_MTDR,

 28775 +  AVR32_SYNTAX_MTSR,

 28776 +  AVR32_SYNTAX_MUL1,

 28777 +  AVR32_SYNTAX_MUL2,

 28778 +  AVR32_SYNTAX_MUL3,

 28779 +  AVR32_SYNTAX_MULHH_W,

 28780 +  AVR32_SYNTAX_MULNHH_W,

 28781 +  AVR32_SYNTAX_MULNWH_D,

 28782 +  AVR32_SYNTAX_MULSD,

 28783 +  AVR32_SYNTAX_MULSATHH_H,

 28784 +  AVR32_SYNTAX_MULSATHH_W,

 28785 +  AVR32_SYNTAX_MULSATRNDHH_H,

 28786 +  AVR32_SYNTAX_MULSATRNDWH_W,

 28787 +  AVR32_SYNTAX_MULSATWH_W,

 28788 +  AVR32_SYNTAX_MULU_D,

 28789 +  AVR32_SYNTAX_MULWH_D,

 28790 +  AVR32_SYNTAX_MUSFR,

 28791 +  AVR32_SYNTAX_MUSTR,

 28792 +  AVR32_SYNTAX_MVCR_D,

 28793 +  AVR32_SYNTAX_MVCR_W,

 28794 +  AVR32_SYNTAX_MVRC_D,

 28795 +  AVR32_SYNTAX_MVRC_W,

 28796 +  AVR32_SYNTAX_NEG,

 28797 +  AVR32_SYNTAX_NOP,

 28798 +  AVR32_SYNTAX_OR1,

 28799 +  AVR32_SYNTAX_OR2,

 28800 +  AVR32_SYNTAX_OR3,

 28801 +  AVR32_SYNTAX_ORH,

 28802 +  AVR32_SYNTAX_ORL,

 28803 +  AVR32_SYNTAX_PABS_SB,

 28804 +  AVR32_SYNTAX_PABS_SH,

 28805 +  AVR32_SYNTAX_PACKSH_SB,

 28806 +  AVR32_SYNTAX_PACKSH_UB,

 28807 +  AVR32_SYNTAX_PACKW_SH,

 28808 +  AVR32_SYNTAX_PADD_B,

 28809 +  AVR32_SYNTAX_PADD_H,

 28810 +  AVR32_SYNTAX_PADDH_SH,

 28811 +  AVR32_SYNTAX_PADDH_UB,

 28812 +  AVR32_SYNTAX_PADDS_SB,

 28813 +  AVR32_SYNTAX_PADDS_SH,

 28814 +  AVR32_SYNTAX_PADDS_UB,

 28815 +  AVR32_SYNTAX_PADDS_UH,

 28816 +  AVR32_SYNTAX_PADDSUB_H,

 28817 +  AVR32_SYNTAX_PADDSUBH_SH,

 28818 +  AVR32_SYNTAX_PADDSUBS_SH,

 28819 +  AVR32_SYNTAX_PADDSUBS_UH,

 28820 +  AVR32_SYNTAX_PADDX_H,

 28821 +  AVR32_SYNTAX_PADDXH_SH,

 28822 +  AVR32_SYNTAX_PADDXS_SH,

 28823 +  AVR32_SYNTAX_PADDXS_UH,

 28824 +  AVR32_SYNTAX_PASR_B,

 28825 +  AVR32_SYNTAX_PASR_H,

 28826 +  AVR32_SYNTAX_PAVG_SH,

 28827 +  AVR32_SYNTAX_PAVG_UB,

 28828 +  AVR32_SYNTAX_PLSL_B,

 28829 +  AVR32_SYNTAX_PLSL_H,

 28830 +  AVR32_SYNTAX_PLSR_B,

 28831 +  AVR32_SYNTAX_PLSR_H,

 28832 +  AVR32_SYNTAX_PMAX_SH,

 28833 +  AVR32_SYNTAX_PMAX_UB,

 28834 +  AVR32_SYNTAX_PMIN_SH,

 28835 +  AVR32_SYNTAX_PMIN_UB,

 28836 +  AVR32_SYNTAX_POPJC,

 28837 +  AVR32_SYNTAX_POPM,

 28838 +  AVR32_SYNTAX_POPM_E,

 28839 +  AVR32_SYNTAX_PREF,

 28840 +  AVR32_SYNTAX_PSAD,

 28841 +  AVR32_SYNTAX_PSUB_B,

 28842 +  AVR32_SYNTAX_PSUB_H,

 28843 +  AVR32_SYNTAX_PSUBADD_H,

 28844 +  AVR32_SYNTAX_PSUBADDH_SH,

 28845 +  AVR32_SYNTAX_PSUBADDS_SH,

 28846 +  AVR32_SYNTAX_PSUBADDS_UH,

 28847 +  AVR32_SYNTAX_PSUBH_SH,

 28848 +  AVR32_SYNTAX_PSUBH_UB,

 28849 +  AVR32_SYNTAX_PSUBS_SB,

 28850 +  AVR32_SYNTAX_PSUBS_SH,

 28851 +  AVR32_SYNTAX_PSUBS_UB,

 28852 +  AVR32_SYNTAX_PSUBS_UH,

 28853 +  AVR32_SYNTAX_PSUBX_H,

 28854 +  AVR32_SYNTAX_PSUBXH_SH,

 28855 +  AVR32_SYNTAX_PSUBXS_SH,

 28856 +  AVR32_SYNTAX_PSUBXS_UH,

 28857 +  AVR32_SYNTAX_PUNPCKSB_H,

 28858 +  AVR32_SYNTAX_PUNPCKUB_H,

 28859 +  AVR32_SYNTAX_PUSHJC,

 28860 +  AVR32_SYNTAX_PUSHM,

 28861 +  AVR32_SYNTAX_PUSHM_E,

 28862 +  AVR32_SYNTAX_RCALL1,

 28863 +  AVR32_SYNTAX_RCALL2,

 28864 +  AVR32_SYNTAX_RETEQ,

 28865 +  AVR32_SYNTAX_RETNE,

 28866 +  AVR32_SYNTAX_RETCC,

 28867 +  AVR32_SYNTAX_RETCS,

 28868 +  AVR32_SYNTAX_RETGE,

 28869 +  AVR32_SYNTAX_RETLT,

 28870 +  AVR32_SYNTAX_RETMI,

 28871 +  AVR32_SYNTAX_RETPL,

 28872 +  AVR32_SYNTAX_RETLS,

 28873 +  AVR32_SYNTAX_RETGT,

 28874 +  AVR32_SYNTAX_RETLE,

 28875 +  AVR32_SYNTAX_RETHI,

 28876 +  AVR32_SYNTAX_RETVS,

 28877 +  AVR32_SYNTAX_RETVC,

 28878 +  AVR32_SYNTAX_RETQS,

 28879 +  AVR32_SYNTAX_RETAL,

 28880 +  AVR32_SYNTAX_RETHS,

 28881 +  AVR32_SYNTAX_RETLO,

 28882 +  AVR32_SYNTAX_RETD,

 28883 +  AVR32_SYNTAX_RETE,

 28884 +  AVR32_SYNTAX_RETJ,

 28885 +  AVR32_SYNTAX_RETS,

 28886 +  AVR32_SYNTAX_RJMP,

 28887 +  AVR32_SYNTAX_ROL,

 28888 +  AVR32_SYNTAX_ROR,

 28889 +  AVR32_SYNTAX_RSUB1,

 28890 +  AVR32_SYNTAX_RSUB2,

 28891 +  AVR32_SYNTAX_SATADD_H,

 28892 +  AVR32_SYNTAX_SATADD_W,

 28893 +  AVR32_SYNTAX_SATRNDS,

 28894 +  AVR32_SYNTAX_SATRNDU,

 28895 +  AVR32_SYNTAX_SATS,

 28896 +  AVR32_SYNTAX_SATSUB_H,

 28897 +  AVR32_SYNTAX_SATSUB_W1,

 28898 +  AVR32_SYNTAX_SATSUB_W2,

 28899 +  AVR32_SYNTAX_SATU,

 28900 +  AVR32_SYNTAX_SBC,

 28901 +  AVR32_SYNTAX_SBR,

 28902 +  AVR32_SYNTAX_SCALL,

 28903 +  AVR32_SYNTAX_SCR,

 28904 +  AVR32_SYNTAX_SLEEP,

 28905 +  AVR32_SYNTAX_SREQ,

 28906 +  AVR32_SYNTAX_SRNE,

 28907 +  AVR32_SYNTAX_SRCC,

 28908 +  AVR32_SYNTAX_SRCS,

 28909 +  AVR32_SYNTAX_SRGE,

 28910 +  AVR32_SYNTAX_SRLT,

 28911 +  AVR32_SYNTAX_SRMI,

 28912 +  AVR32_SYNTAX_SRPL,

 28913 +  AVR32_SYNTAX_SRLS,

 28914 +  AVR32_SYNTAX_SRGT,

 28915 +  AVR32_SYNTAX_SRLE,

 28916 +  AVR32_SYNTAX_SRHI,

 28917 +  AVR32_SYNTAX_SRVS,

 28918 +  AVR32_SYNTAX_SRVC,

 28919 +  AVR32_SYNTAX_SRQS,

 28920 +  AVR32_SYNTAX_SRAL,

 28921 +  AVR32_SYNTAX_SRHS,

 28922 +  AVR32_SYNTAX_SRLO,

 28923 +  AVR32_SYNTAX_SSRF,

 28924 +  AVR32_SYNTAX_ST_B1,

 28925 +  AVR32_SYNTAX_ST_B2,

 28926 +  AVR32_SYNTAX_ST_B5,

 28927 +  AVR32_SYNTAX_ST_B3,

 28928 +  AVR32_SYNTAX_ST_B4,

 28929 +  AVR32_SYNTAX_ST_D1,

 28930 +  AVR32_SYNTAX_ST_D2,

 28931 +  AVR32_SYNTAX_ST_D3,

 28932 +  AVR32_SYNTAX_ST_D5,

 28933 +  AVR32_SYNTAX_ST_D4,

 28934 +  AVR32_SYNTAX_ST_H1,

 28935 +  AVR32_SYNTAX_ST_H2,

 28936 +  AVR32_SYNTAX_ST_H5,

 28937 +  AVR32_SYNTAX_ST_H3,

 28938 +  AVR32_SYNTAX_ST_H4,

 28939 +  AVR32_SYNTAX_ST_W1,

 28940 +  AVR32_SYNTAX_ST_W2,

 28941 +  AVR32_SYNTAX_ST_W5,

 28942 +  AVR32_SYNTAX_ST_W3,

 28943 +  AVR32_SYNTAX_ST_W4,

 28944 +  AVR32_SYNTAX_STC_D1,

 28945 +  AVR32_SYNTAX_STC_D2,

 28946 +  AVR32_SYNTAX_STC_D3,

 28947 +  AVR32_SYNTAX_STC_W1,

 28948 +  AVR32_SYNTAX_STC_W2,

 28949 +  AVR32_SYNTAX_STC_W3,

 28950 +  AVR32_SYNTAX_STC0_D,

 28951 +  AVR32_SYNTAX_STC0_W,

 28952 +  AVR32_SYNTAX_STCM_D,

 28953 +  AVR32_SYNTAX_STCM_D_PU,

 28954 +  AVR32_SYNTAX_STCM_W,

 28955 +  AVR32_SYNTAX_STCM_W_PU,

 28956 +  AVR32_SYNTAX_STCOND,

 28957 +  AVR32_SYNTAX_STDSP,

 28958 +  AVR32_SYNTAX_STHH_W2,

 28959 +  AVR32_SYNTAX_STHH_W1,

 28960 +  AVR32_SYNTAX_STM,

 28961 +  AVR32_SYNTAX_STM_PU,

 28962 +  AVR32_SYNTAX_STMTS,

 28963 +  AVR32_SYNTAX_STMTS_PU,

 28964 +  AVR32_SYNTAX_STSWP_H,

 28965 +  AVR32_SYNTAX_STSWP_W,

 28966 +  AVR32_SYNTAX_SUB1,

 28967 +  AVR32_SYNTAX_SUB2,

 28968 +  AVR32_SYNTAX_SUB5,

 28969 +  AVR32_SYNTAX_SUB3_SP,

 28970 +  AVR32_SYNTAX_SUB3,

 28971 +  AVR32_SYNTAX_SUB4,

 28972 +  AVR32_SYNTAX_SUBEQ,

 28973 +  AVR32_SYNTAX_SUBNE,

 28974 +  AVR32_SYNTAX_SUBCC,

 28975 +  AVR32_SYNTAX_SUBCS,

 28976 +  AVR32_SYNTAX_SUBGE,

 28977 +  AVR32_SYNTAX_SUBLT,

 28978 +  AVR32_SYNTAX_SUBMI,

 28979 +  AVR32_SYNTAX_SUBPL,

 28980 +  AVR32_SYNTAX_SUBLS,

 28981 +  AVR32_SYNTAX_SUBGT,

 28982 +  AVR32_SYNTAX_SUBLE,

 28983 +  AVR32_SYNTAX_SUBHI,

 28984 +  AVR32_SYNTAX_SUBVS,

 28985 +  AVR32_SYNTAX_SUBVC,

 28986 +  AVR32_SYNTAX_SUBQS,

 28987 +  AVR32_SYNTAX_SUBAL,

 28988 +  AVR32_SYNTAX_SUBHS,

 28989 +  AVR32_SYNTAX_SUBLO,

 28990 +  AVR32_SYNTAX_SUBFEQ,

 28991 +  AVR32_SYNTAX_SUBFNE,

 28992 +  AVR32_SYNTAX_SUBFCC,

 28993 +  AVR32_SYNTAX_SUBFCS,

 28994 +  AVR32_SYNTAX_SUBFGE,

 28995 +  AVR32_SYNTAX_SUBFLT,

 28996 +  AVR32_SYNTAX_SUBFMI,

 28997 +  AVR32_SYNTAX_SUBFPL,

 28998 +  AVR32_SYNTAX_SUBFLS,

 28999 +  AVR32_SYNTAX_SUBFGT,

 29000 +  AVR32_SYNTAX_SUBFLE,

 29001 +  AVR32_SYNTAX_SUBFHI,

 29002 +  AVR32_SYNTAX_SUBFVS,

 29003 +  AVR32_SYNTAX_SUBFVC,

 29004 +  AVR32_SYNTAX_SUBFQS,

 29005 +  AVR32_SYNTAX_SUBFAL,

 29006 +  AVR32_SYNTAX_SUBFHS,

 29007 +  AVR32_SYNTAX_SUBFLO,

 29008 +  AVR32_SYNTAX_SUBHH_W,

 29009 +  AVR32_SYNTAX_SWAP_B,

 29010 +  AVR32_SYNTAX_SWAP_BH,

 29011 +  AVR32_SYNTAX_SWAP_H,

 29012 +  AVR32_SYNTAX_SYNC,

 29013 +  AVR32_SYNTAX_TLBR,

 29014 +  AVR32_SYNTAX_TLBS,

 29015 +  AVR32_SYNTAX_TLBW,

 29016 +  AVR32_SYNTAX_TNBZ,

 29017 +  AVR32_SYNTAX_TST,

 29018 +  AVR32_SYNTAX_XCHG,

 29019 +  AVR32_SYNTAX_MEMC,

 29020 +  AVR32_SYNTAX_MEMS,

 29021 +  AVR32_SYNTAX_MEMT,

 29022 +  AVR32_SYNTAX_FADD_S,

 29023 +  AVR32_SYNTAX_FADD_D,

 29024 +  AVR32_SYNTAX_FSUB_S,

 29025 +  AVR32_SYNTAX_FSUB_D,

 29026 +  AVR32_SYNTAX_FMAC_S,

 29027 +  AVR32_SYNTAX_FMAC_D,

 29028 +  AVR32_SYNTAX_FNMAC_S,

 29029 +  AVR32_SYNTAX_FNMAC_D,

 29030 +  AVR32_SYNTAX_FMSC_S,

 29031 +  AVR32_SYNTAX_FMSC_D,

 29032 +  AVR32_SYNTAX_FNMSC_S,

 29033 +  AVR32_SYNTAX_FNMSC_D,

 29034 +  AVR32_SYNTAX_FMUL_S,

 29035 +  AVR32_SYNTAX_FMUL_D,

 29036 +  AVR32_SYNTAX_FNMUL_S,

 29037 +  AVR32_SYNTAX_FNMUL_D,

 29038 +  AVR32_SYNTAX_FNEG_S,

 29039 +  AVR32_SYNTAX_FNEG_D,

 29040 +  AVR32_SYNTAX_FABS_S,

 29041 +  AVR32_SYNTAX_FABS_D,

 29042 +  AVR32_SYNTAX_FCMP_S,

 29043 +  AVR32_SYNTAX_FCMP_D,

 29044 +  AVR32_SYNTAX_FMOV1_S,

 29045 +  AVR32_SYNTAX_FMOV1_D,

 29046 +  AVR32_SYNTAX_FMOV2_S,

 29047 +  AVR32_SYNTAX_FMOV2_D,

 29048 +  AVR32_SYNTAX_FMOV3_S,

 29049 +  AVR32_SYNTAX_FMOV3_D,

 29050 +  AVR32_SYNTAX_FCASTS_D,

 29051 +  AVR32_SYNTAX_FCASTD_S,

 29052 +  AVR32_SYNTAX_LDA_W,

 29053 +  AVR32_SYNTAX_CALL,

 29054 +  AVR32_SYNTAX_PICOSVMAC0,

 29055 +  AVR32_SYNTAX_PICOSVMAC1,

 29056 +  AVR32_SYNTAX_PICOSVMAC2,

 29057 +  AVR32_SYNTAX_PICOSVMAC3,

 29058 +  AVR32_SYNTAX_PICOSVMUL0,

 29059 +  AVR32_SYNTAX_PICOSVMUL1,

 29060 +  AVR32_SYNTAX_PICOSVMUL2,

 29061 +  AVR32_SYNTAX_PICOSVMUL3,

 29062 +  AVR32_SYNTAX_PICOVMAC0,

 29063 +  AVR32_SYNTAX_PICOVMAC1,

 29064 +  AVR32_SYNTAX_PICOVMAC2,

 29065 +  AVR32_SYNTAX_PICOVMAC3,

 29066 +  AVR32_SYNTAX_PICOVMUL0,

 29067 +  AVR32_SYNTAX_PICOVMUL1,

 29068 +  AVR32_SYNTAX_PICOVMUL2,

 29069 +  AVR32_SYNTAX_PICOVMUL3,

 29070 +  AVR32_SYNTAX_PICOLD_D2,

 29071 +  AVR32_SYNTAX_PICOLD_D3,

 29072 +  AVR32_SYNTAX_PICOLD_D1,

 29073 +  AVR32_SYNTAX_PICOLD_W2,

 29074 +  AVR32_SYNTAX_PICOLD_W3,

 29075 +  AVR32_SYNTAX_PICOLD_W1,

 29076 +  AVR32_SYNTAX_PICOLDM_D,

 29077 +  AVR32_SYNTAX_PICOLDM_D_PU,

 29078 +  AVR32_SYNTAX_PICOLDM_W,

 29079 +  AVR32_SYNTAX_PICOLDM_W_PU,

 29080 +  AVR32_SYNTAX_PICOMV_D1,

 29081 +  AVR32_SYNTAX_PICOMV_D2,

 29082 +  AVR32_SYNTAX_PICOMV_W1,

 29083 +  AVR32_SYNTAX_PICOMV_W2,

 29084 +  AVR32_SYNTAX_PICOST_D2,

 29085 +  AVR32_SYNTAX_PICOST_D3,

 29086 +  AVR32_SYNTAX_PICOST_D1,

 29087 +  AVR32_SYNTAX_PICOST_W2,

 29088 +  AVR32_SYNTAX_PICOST_W3,

 29089 +  AVR32_SYNTAX_PICOST_W1,

 29090 +  AVR32_SYNTAX_PICOSTM_D,

 29091 +  AVR32_SYNTAX_PICOSTM_D_PU,

 29092 +  AVR32_SYNTAX_PICOSTM_W,

 29093 +  AVR32_SYNTAX_PICOSTM_W_PU,

 29094 +  AVR32_SYNTAX_RSUBEQ,

 29095 +  AVR32_SYNTAX_RSUBNE,

 29096 +  AVR32_SYNTAX_RSUBCC,

 29097 +  AVR32_SYNTAX_RSUBCS,

 29098 +  AVR32_SYNTAX_RSUBGE,

 29099 +  AVR32_SYNTAX_RSUBLT,

 29100 +  AVR32_SYNTAX_RSUBMI,

 29101 +  AVR32_SYNTAX_RSUBPL,

 29102 +  AVR32_SYNTAX_RSUBLS,

 29103 +  AVR32_SYNTAX_RSUBGT,

 29104 +  AVR32_SYNTAX_RSUBLE,

 29105 +  AVR32_SYNTAX_RSUBHI,

 29106 +  AVR32_SYNTAX_RSUBVS,

 29107 +  AVR32_SYNTAX_RSUBVC,

 29108 +  AVR32_SYNTAX_RSUBQS,

 29109 +  AVR32_SYNTAX_RSUBAL,

 29110 +  AVR32_SYNTAX_RSUBHS,

 29111 +  AVR32_SYNTAX_RSUBLO,

 29112 +  AVR32_SYNTAX_ADDEQ,

 29113 +  AVR32_SYNTAX_ADDNE,

 29114 +  AVR32_SYNTAX_ADDCC,

 29115 +  AVR32_SYNTAX_ADDCS,

 29116 +  AVR32_SYNTAX_ADDGE,

 29117 +  AVR32_SYNTAX_ADDLT,

 29118 +  AVR32_SYNTAX_ADDMI,

 29119 +  AVR32_SYNTAX_ADDPL,

 29120 +  AVR32_SYNTAX_ADDLS,

 29121 +  AVR32_SYNTAX_ADDGT,

 29122 +  AVR32_SYNTAX_ADDLE,

 29123 +  AVR32_SYNTAX_ADDHI,

 29124 +  AVR32_SYNTAX_ADDVS,

 29125 +  AVR32_SYNTAX_ADDVC,

 29126 +  AVR32_SYNTAX_ADDQS,

 29127 +  AVR32_SYNTAX_ADDAL,

 29128 +  AVR32_SYNTAX_ADDHS,

 29129 +  AVR32_SYNTAX_ADDLO,

 29130 +  AVR32_SYNTAX_SUB2EQ,

 29131 +  AVR32_SYNTAX_SUB2NE,

 29132 +  AVR32_SYNTAX_SUB2CC,

 29133 +  AVR32_SYNTAX_SUB2CS,

 29134 +  AVR32_SYNTAX_SUB2GE,

 29135 +  AVR32_SYNTAX_SUB2LT,

 29136 +  AVR32_SYNTAX_SUB2MI,

 29137 +  AVR32_SYNTAX_SUB2PL,

 29138 +  AVR32_SYNTAX_SUB2LS,

 29139 +  AVR32_SYNTAX_SUB2GT,

 29140 +  AVR32_SYNTAX_SUB2LE,

 29141 +  AVR32_SYNTAX_SUB2HI,

 29142 +  AVR32_SYNTAX_SUB2VS,

 29143 +  AVR32_SYNTAX_SUB2VC,

 29144 +  AVR32_SYNTAX_SUB2QS,

 29145 +  AVR32_SYNTAX_SUB2AL,

 29146 +  AVR32_SYNTAX_SUB2HS,

 29147 +  AVR32_SYNTAX_SUB2LO,

 29148 +  AVR32_SYNTAX_ANDEQ,

 29149 +  AVR32_SYNTAX_ANDNE,

 29150 +  AVR32_SYNTAX_ANDCC,

 29151 +  AVR32_SYNTAX_ANDCS,

 29152 +  AVR32_SYNTAX_ANDGE,

 29153 +  AVR32_SYNTAX_ANDLT,

 29154 +  AVR32_SYNTAX_ANDMI,

 29155 +  AVR32_SYNTAX_ANDPL,

 29156 +  AVR32_SYNTAX_ANDLS,

 29157 +  AVR32_SYNTAX_ANDGT,

 29158 +  AVR32_SYNTAX_ANDLE,

 29159 +  AVR32_SYNTAX_ANDHI,

 29160 +  AVR32_SYNTAX_ANDVS,

 29161 +  AVR32_SYNTAX_ANDVC,

 29162 +  AVR32_SYNTAX_ANDQS,

 29163 +  AVR32_SYNTAX_ANDAL,

 29164 +  AVR32_SYNTAX_ANDHS,

 29165 +  AVR32_SYNTAX_ANDLO,

 29166 +  AVR32_SYNTAX_OREQ,

 29167 +  AVR32_SYNTAX_ORNE,

 29168 +  AVR32_SYNTAX_ORCC,

 29169 +  AVR32_SYNTAX_ORCS,

 29170 +  AVR32_SYNTAX_ORGE,

 29171 +  AVR32_SYNTAX_ORLT,

 29172 +  AVR32_SYNTAX_ORMI,

 29173 +  AVR32_SYNTAX_ORPL,

 29174 +  AVR32_SYNTAX_ORLS,

 29175 +  AVR32_SYNTAX_ORGT,

 29176 +  AVR32_SYNTAX_ORLE,

 29177 +  AVR32_SYNTAX_ORHI,

 29178 +  AVR32_SYNTAX_ORVS,

 29179 +  AVR32_SYNTAX_ORVC,

 29180 +  AVR32_SYNTAX_ORQS,

 29181 +  AVR32_SYNTAX_ORAL,

 29182 +  AVR32_SYNTAX_ORHS,

 29183 +  AVR32_SYNTAX_ORLO,

 29184 +  AVR32_SYNTAX_EOREQ,

 29185 +  AVR32_SYNTAX_EORNE,

 29186 +  AVR32_SYNTAX_EORCC,

 29187 +  AVR32_SYNTAX_EORCS,

 29188 +  AVR32_SYNTAX_EORGE,

 29189 +  AVR32_SYNTAX_EORLT,

 29190 +  AVR32_SYNTAX_EORMI,

 29191 +  AVR32_SYNTAX_EORPL,

 29192 +  AVR32_SYNTAX_EORLS,

 29193 +  AVR32_SYNTAX_EORGT,

 29194 +  AVR32_SYNTAX_EORLE,

 29195 +  AVR32_SYNTAX_EORHI,

 29196 +  AVR32_SYNTAX_EORVS,

 29197 +  AVR32_SYNTAX_EORVC,

 29198 +  AVR32_SYNTAX_EORQS,

 29199 +  AVR32_SYNTAX_EORAL,

 29200 +  AVR32_SYNTAX_EORHS,

 29201 +  AVR32_SYNTAX_EORLO,

 29202 +  AVR32_SYNTAX_LD_WEQ,

 29203 +  AVR32_SYNTAX_LD_WNE,

 29204 +  AVR32_SYNTAX_LD_WCC,

 29205 +  AVR32_SYNTAX_LD_WCS,

 29206 +  AVR32_SYNTAX_LD_WGE,

 29207 +  AVR32_SYNTAX_LD_WLT,

 29208 +  AVR32_SYNTAX_LD_WMI,

 29209 +  AVR32_SYNTAX_LD_WPL,

 29210 +  AVR32_SYNTAX_LD_WLS,

 29211 +  AVR32_SYNTAX_LD_WGT,

 29212 +  AVR32_SYNTAX_LD_WLE,

 29213 +  AVR32_SYNTAX_LD_WHI,

 29214 +  AVR32_SYNTAX_LD_WVS,

 29215 +  AVR32_SYNTAX_LD_WVC,

 29216 +  AVR32_SYNTAX_LD_WQS,

 29217 +  AVR32_SYNTAX_LD_WAL,

 29218 +  AVR32_SYNTAX_LD_WHS,

 29219 +  AVR32_SYNTAX_LD_WLO,

 29220 +  AVR32_SYNTAX_LD_SHEQ,

 29221 +  AVR32_SYNTAX_LD_SHNE,

 29222 +  AVR32_SYNTAX_LD_SHCC,

 29223 +  AVR32_SYNTAX_LD_SHCS,

 29224 +  AVR32_SYNTAX_LD_SHGE,

 29225 +  AVR32_SYNTAX_LD_SHLT,

 29226 +  AVR32_SYNTAX_LD_SHMI,

 29227 +  AVR32_SYNTAX_LD_SHPL,

 29228 +  AVR32_SYNTAX_LD_SHLS,

 29229 +  AVR32_SYNTAX_LD_SHGT,

 29230 +  AVR32_SYNTAX_LD_SHLE,

 29231 +  AVR32_SYNTAX_LD_SHHI,

 29232 +  AVR32_SYNTAX_LD_SHVS,

 29233 +  AVR32_SYNTAX_LD_SHVC,

 29234 +  AVR32_SYNTAX_LD_SHQS,

 29235 +  AVR32_SYNTAX_LD_SHAL,

 29236 +  AVR32_SYNTAX_LD_SHHS,

 29237 +  AVR32_SYNTAX_LD_SHLO,

 29238 +  AVR32_SYNTAX_LD_UHEQ,

 29239 +  AVR32_SYNTAX_LD_UHNE,

 29240 +  AVR32_SYNTAX_LD_UHCC,

 29241 +  AVR32_SYNTAX_LD_UHCS,

 29242 +  AVR32_SYNTAX_LD_UHGE,

 29243 +  AVR32_SYNTAX_LD_UHLT,

 29244 +  AVR32_SYNTAX_LD_UHMI,

 29245 +  AVR32_SYNTAX_LD_UHPL,

 29246 +  AVR32_SYNTAX_LD_UHLS,

 29247 +  AVR32_SYNTAX_LD_UHGT,

 29248 +  AVR32_SYNTAX_LD_UHLE,

 29249 +  AVR32_SYNTAX_LD_UHHI,

 29250 +  AVR32_SYNTAX_LD_UHVS,

 29251 +  AVR32_SYNTAX_LD_UHVC,

 29252 +  AVR32_SYNTAX_LD_UHQS,

 29253 +  AVR32_SYNTAX_LD_UHAL,

 29254 +  AVR32_SYNTAX_LD_UHHS,

 29255 +  AVR32_SYNTAX_LD_UHLO,

 29256 +  AVR32_SYNTAX_LD_SBEQ,

 29257 +  AVR32_SYNTAX_LD_SBNE,

 29258 +  AVR32_SYNTAX_LD_SBCC,

 29259 +  AVR32_SYNTAX_LD_SBCS,

 29260 +  AVR32_SYNTAX_LD_SBGE,

 29261 +  AVR32_SYNTAX_LD_SBLT,

 29262 +  AVR32_SYNTAX_LD_SBMI,

 29263 +  AVR32_SYNTAX_LD_SBPL,

 29264 +  AVR32_SYNTAX_LD_SBLS,

 29265 +  AVR32_SYNTAX_LD_SBGT,

 29266 +  AVR32_SYNTAX_LD_SBLE,

 29267 +  AVR32_SYNTAX_LD_SBHI,

 29268 +  AVR32_SYNTAX_LD_SBVS,

 29269 +  AVR32_SYNTAX_LD_SBVC,

 29270 +  AVR32_SYNTAX_LD_SBQS,

 29271 +  AVR32_SYNTAX_LD_SBAL,

 29272 +  AVR32_SYNTAX_LD_SBHS,

 29273 +  AVR32_SYNTAX_LD_SBLO,

 29274 +  AVR32_SYNTAX_LD_UBEQ,

 29275 +  AVR32_SYNTAX_LD_UBNE,

 29276 +  AVR32_SYNTAX_LD_UBCC,

 29277 +  AVR32_SYNTAX_LD_UBCS,

 29278 +  AVR32_SYNTAX_LD_UBGE,

 29279 +  AVR32_SYNTAX_LD_UBLT,

 29280 +  AVR32_SYNTAX_LD_UBMI,

 29281 +  AVR32_SYNTAX_LD_UBPL,

 29282 +  AVR32_SYNTAX_LD_UBLS,

 29283 +  AVR32_SYNTAX_LD_UBGT,

 29284 +  AVR32_SYNTAX_LD_UBLE,

 29285 +  AVR32_SYNTAX_LD_UBHI,

 29286 +  AVR32_SYNTAX_LD_UBVS,

 29287 +  AVR32_SYNTAX_LD_UBVC,

 29288 +  AVR32_SYNTAX_LD_UBQS,

 29289 +  AVR32_SYNTAX_LD_UBAL,

 29290 +  AVR32_SYNTAX_LD_UBHS,

 29291 +  AVR32_SYNTAX_LD_UBLO,

 29292 +  AVR32_SYNTAX_ST_WEQ,

 29293 +  AVR32_SYNTAX_ST_WNE,

 29294 +  AVR32_SYNTAX_ST_WCC,

 29295 +  AVR32_SYNTAX_ST_WCS,

 29296 +  AVR32_SYNTAX_ST_WGE,

 29297 +  AVR32_SYNTAX_ST_WLT,

 29298 +  AVR32_SYNTAX_ST_WMI,

 29299 +  AVR32_SYNTAX_ST_WPL,

 29300 +  AVR32_SYNTAX_ST_WLS,

 29301 +  AVR32_SYNTAX_ST_WGT,

 29302 +  AVR32_SYNTAX_ST_WLE,

 29303 +  AVR32_SYNTAX_ST_WHI,

 29304 +  AVR32_SYNTAX_ST_WVS,

 29305 +  AVR32_SYNTAX_ST_WVC,

 29306 +  AVR32_SYNTAX_ST_WQS,

 29307 +  AVR32_SYNTAX_ST_WAL,

 29308 +  AVR32_SYNTAX_ST_WHS,

 29309 +  AVR32_SYNTAX_ST_WLO,

 29310 +  AVR32_SYNTAX_ST_HEQ,

 29311 +  AVR32_SYNTAX_ST_HNE,

 29312 +  AVR32_SYNTAX_ST_HCC,

 29313 +  AVR32_SYNTAX_ST_HCS,

 29314 +  AVR32_SYNTAX_ST_HGE,

 29315 +  AVR32_SYNTAX_ST_HLT,

 29316 +  AVR32_SYNTAX_ST_HMI,

 29317 +  AVR32_SYNTAX_ST_HPL,

 29318 +  AVR32_SYNTAX_ST_HLS,

 29319 +  AVR32_SYNTAX_ST_HGT,

 29320 +  AVR32_SYNTAX_ST_HLE,

 29321 +  AVR32_SYNTAX_ST_HHI,

 29322 +  AVR32_SYNTAX_ST_HVS,

 29323 +  AVR32_SYNTAX_ST_HVC,

 29324 +  AVR32_SYNTAX_ST_HQS,

 29325 +  AVR32_SYNTAX_ST_HAL,

 29326 +  AVR32_SYNTAX_ST_HHS,

 29327 +  AVR32_SYNTAX_ST_HLO,

 29328 +  AVR32_SYNTAX_ST_BEQ,

 29329 +  AVR32_SYNTAX_ST_BNE,

 29330 +  AVR32_SYNTAX_ST_BCC,

 29331 +  AVR32_SYNTAX_ST_BCS,

 29332 +  AVR32_SYNTAX_ST_BGE,

 29333 +  AVR32_SYNTAX_ST_BLT,

 29334 +  AVR32_SYNTAX_ST_BMI,

 29335 +  AVR32_SYNTAX_ST_BPL,

 29336 +  AVR32_SYNTAX_ST_BLS,

 29337 +  AVR32_SYNTAX_ST_BGT,

 29338 +  AVR32_SYNTAX_ST_BLE,

 29339 +  AVR32_SYNTAX_ST_BHI,

 29340 +  AVR32_SYNTAX_ST_BVS,

 29341 +  AVR32_SYNTAX_ST_BVC,

 29342 +  AVR32_SYNTAX_ST_BQS,

 29343 +  AVR32_SYNTAX_ST_BAL,

 29344 +  AVR32_SYNTAX_ST_BHS,

 29345 +  AVR32_SYNTAX_ST_BLO,

 29346 +  AVR32_SYNTAX_MOVH,

 29347 +  AVR32_SYNTAX__END_

 29348 +};

 29349 +#define AVR32_NR_SYNTAX AVR32_SYNTAX__END_

 29350 +

 29351 +enum avr32_alias_type

 29352 +  {

 29353 +    AVR32_ALIAS_FMAC_S,

 29354 +    AVR32_ALIAS_FMAC_D,

 29355 +    AVR32_ALIAS_FNMAC_S,

 29356 +    AVR32_ALIAS_FNMAC_D,

 29357 +    AVR32_ALIAS_FMSC_S,

 29358 +    AVR32_ALIAS_FMSC_D,

 29359 +    AVR32_ALIAS_FNMSC_S,

 29360 +    AVR32_ALIAS_FNMSC_D,

 29361 +    AVR32_ALIAS_FADD_S,

 29362 +    AVR32_ALIAS_FADD_D,

 29363 +    AVR32_ALIAS_FSUB_S,

 29364 +    AVR32_ALIAS_FSUB_D,

 29365 +    AVR32_ALIAS_FMUL_S,

 29366 +    AVR32_ALIAS_FMUL_D,

 29367 +    AVR32_ALIAS_FNMUL_S,

 29368 +    AVR32_ALIAS_FNMUL_D,

 29369 +    AVR32_ALIAS_FNEG_S,

 29370 +    AVR32_ALIAS_FNEG_D,

 29371 +    AVR32_ALIAS_FABS_S,

 29372 +    AVR32_ALIAS_FABS_D,

 29373 +    AVR32_ALIAS_FCMP_S,

 29374 +    AVR32_ALIAS_FCMP_D,

 29375 +    AVR32_ALIAS_FMOV1_S,

 29376 +    AVR32_ALIAS_FMOV1_D,

 29377 +    AVR32_ALIAS_FMOV2_S,

 29378 +    AVR32_ALIAS_FMOV2_D,

 29379 +    AVR32_ALIAS_FMOV3_S,

 29380 +    AVR32_ALIAS_FMOV3_D,

 29381 +    AVR32_ALIAS_FCASTS_D,

 29382 +    AVR32_ALIAS_FCASTD_S,

 29383 +    AVR32_ALIAS_PICOSVMAC0,

 29384 +    AVR32_ALIAS_PICOSVMAC1,

 29385 +    AVR32_ALIAS_PICOSVMAC2,

 29386 +    AVR32_ALIAS_PICOSVMAC3,

 29387 +    AVR32_ALIAS_PICOSVMUL0,

 29388 +    AVR32_ALIAS_PICOSVMUL1,

 29389 +    AVR32_ALIAS_PICOSVMUL2,

 29390 +    AVR32_ALIAS_PICOSVMUL3,

 29391 +    AVR32_ALIAS_PICOVMAC0,

 29392 +    AVR32_ALIAS_PICOVMAC1,

 29393 +    AVR32_ALIAS_PICOVMAC2,

 29394 +    AVR32_ALIAS_PICOVMAC3,

 29395 +    AVR32_ALIAS_PICOVMUL0,

 29396 +    AVR32_ALIAS_PICOVMUL1,

 29397 +    AVR32_ALIAS_PICOVMUL2,

 29398 +    AVR32_ALIAS_PICOVMUL3,

 29399 +    AVR32_ALIAS_PICOLD_D1,

 29400 +    AVR32_ALIAS_PICOLD_D2,

 29401 +    AVR32_ALIAS_PICOLD_D3,

 29402 +    AVR32_ALIAS_PICOLD_W1,

 29403 +    AVR32_ALIAS_PICOLD_W2,

 29404 +    AVR32_ALIAS_PICOLD_W3,

 29405 +    AVR32_ALIAS_PICOLDM_D,

 29406 +    AVR32_ALIAS_PICOLDM_D_PU,

 29407 +    AVR32_ALIAS_PICOLDM_W,

 29408 +    AVR32_ALIAS_PICOLDM_W_PU,

 29409 +    AVR32_ALIAS_PICOMV_D1,

 29410 +    AVR32_ALIAS_PICOMV_D2,

 29411 +    AVR32_ALIAS_PICOMV_W1,

 29412 +    AVR32_ALIAS_PICOMV_W2,

 29413 +    AVR32_ALIAS_PICOST_D1,

 29414 +    AVR32_ALIAS_PICOST_D2,

 29415 +    AVR32_ALIAS_PICOST_D3,

 29416 +    AVR32_ALIAS_PICOST_W1,

 29417 +    AVR32_ALIAS_PICOST_W2,

 29418 +    AVR32_ALIAS_PICOST_W3,

 29419 +    AVR32_ALIAS_PICOSTM_D,

 29420 +    AVR32_ALIAS_PICOSTM_D_PU,

 29421 +    AVR32_ALIAS_PICOSTM_W,

 29422 +    AVR32_ALIAS_PICOSTM_W_PU,

 29423 +    AVR32_ALIAS__END_

 29424 +  };

 29425 +#define AVR32_NR_ALIAS AVR32_ALIAS__END_

 29426 +

 29427 +enum avr32_mnemonic_type

 29428 +{

 29429 +  AVR32_MNEMONIC_ABS,

 29430 +  AVR32_MNEMONIC_ACALL,

 29431 +  AVR32_MNEMONIC_ACR,

 29432 +  AVR32_MNEMONIC_ADC,

 29433 +  AVR32_MNEMONIC_ADD,

 29434 +  AVR32_MNEMONIC_ADDABS,

 29435 +  AVR32_MNEMONIC_ADDHH_W,

 29436 +  AVR32_MNEMONIC_AND,

 29437 +  AVR32_MNEMONIC_ANDH,

 29438 +  AVR32_MNEMONIC_ANDL,

 29439 +  AVR32_MNEMONIC_ANDN,

 29440 +  AVR32_MNEMONIC_ASR,

 29441 +  AVR32_MNEMONIC_BFEXTS,

 29442 +  AVR32_MNEMONIC_BFEXTU,

 29443 +  AVR32_MNEMONIC_BFINS,

 29444 +  AVR32_MNEMONIC_BLD,

 29445 +  AVR32_MNEMONIC_BREQ,

 29446 +  AVR32_MNEMONIC_BRNE,

 29447 +  AVR32_MNEMONIC_BRCC,

 29448 +  AVR32_MNEMONIC_BRCS,

 29449 +  AVR32_MNEMONIC_BRGE,

 29450 +  AVR32_MNEMONIC_BRLT,

 29451 +  AVR32_MNEMONIC_BRMI,

 29452 +  AVR32_MNEMONIC_BRPL,

 29453 +  AVR32_MNEMONIC_BRHS,

 29454 +  AVR32_MNEMONIC_BRLO,

 29455 +  AVR32_MNEMONIC_BRLS,

 29456 +  AVR32_MNEMONIC_BRGT,

 29457 +  AVR32_MNEMONIC_BRLE,

 29458 +  AVR32_MNEMONIC_BRHI,

 29459 +  AVR32_MNEMONIC_BRVS,

 29460 +  AVR32_MNEMONIC_BRVC,

 29461 +  AVR32_MNEMONIC_BRQS,

 29462 +  AVR32_MNEMONIC_BRAL,

 29463 +  AVR32_MNEMONIC_BREAKPOINT,

 29464 +  AVR32_MNEMONIC_BREV,

 29465 +  AVR32_MNEMONIC_BST,

 29466 +  AVR32_MNEMONIC_CACHE,

 29467 +  AVR32_MNEMONIC_CASTS_B,

 29468 +  AVR32_MNEMONIC_CASTS_H,

 29469 +  AVR32_MNEMONIC_CASTU_B,

 29470 +  AVR32_MNEMONIC_CASTU_H,

 29471 +  AVR32_MNEMONIC_CBR,

 29472 +  AVR32_MNEMONIC_CLZ,

 29473 +  AVR32_MNEMONIC_COM,

 29474 +  AVR32_MNEMONIC_COP,

 29475 +  AVR32_MNEMONIC_CP_B,

 29476 +  AVR32_MNEMONIC_CP_H,

 29477 +  AVR32_MNEMONIC_CP_W,

 29478 +  AVR32_MNEMONIC_CP,

 29479 +  AVR32_MNEMONIC_CPC,

 29480 +  AVR32_MNEMONIC_CSRF,

 29481 +  AVR32_MNEMONIC_CSRFCZ,

 29482 +  AVR32_MNEMONIC_DIVS,

 29483 +  AVR32_MNEMONIC_DIVU,

 29484 +  AVR32_MNEMONIC_EOR,

 29485 +  AVR32_MNEMONIC_EORL,

 29486 +  AVR32_MNEMONIC_EORH,

 29487 +  AVR32_MNEMONIC_FRS,

 29488 +  AVR32_MNEMONIC_ICALL,

 29489 +  AVR32_MNEMONIC_INCJOSP,

 29490 +  AVR32_MNEMONIC_LD_D,

 29491 +  AVR32_MNEMONIC_LD_SB,

 29492 +  AVR32_MNEMONIC_LD_UB,

 29493 +  AVR32_MNEMONIC_LD_SH,

 29494 +  AVR32_MNEMONIC_LD_UH,

 29495 +  AVR32_MNEMONIC_LD_W,

 29496 +  AVR32_MNEMONIC_LDC_D,

 29497 +  AVR32_MNEMONIC_LDC_W,

 29498 +  AVR32_MNEMONIC_LDC0_D,

 29499 +  AVR32_MNEMONIC_LDC0_W,

 29500 +  AVR32_MNEMONIC_LDCM_D,

 29501 +  AVR32_MNEMONIC_LDCM_W,

 29502 +  AVR32_MNEMONIC_LDDPC,

 29503 +  AVR32_MNEMONIC_LDDSP,

 29504 +  AVR32_MNEMONIC_LDINS_B,

 29505 +  AVR32_MNEMONIC_LDINS_H,

 29506 +  AVR32_MNEMONIC_LDM,

 29507 +  AVR32_MNEMONIC_LDMTS,

 29508 +  AVR32_MNEMONIC_LDSWP_SH,

 29509 +  AVR32_MNEMONIC_LDSWP_UH,

 29510 +  AVR32_MNEMONIC_LDSWP_W,

 29511 +  AVR32_MNEMONIC_LSL,

 29512 +  AVR32_MNEMONIC_LSR,

 29513 +  AVR32_MNEMONIC_MAC,

 29514 +  AVR32_MNEMONIC_MACHH_D,

 29515 +  AVR32_MNEMONIC_MACHH_W,

 29516 +  AVR32_MNEMONIC_MACS_D,

 29517 +  AVR32_MNEMONIC_MACSATHH_W,

 29518 +  AVR32_MNEMONIC_MACU_D,

 29519 +  AVR32_MNEMONIC_MACWH_D,

 29520 +  AVR32_MNEMONIC_MAX,

 29521 +  AVR32_MNEMONIC_MCALL,

 29522 +  AVR32_MNEMONIC_MFDR,

 29523 +  AVR32_MNEMONIC_MFSR,

 29524 +  AVR32_MNEMONIC_MIN,

 29525 +  AVR32_MNEMONIC_MOV,

 29526 +  AVR32_MNEMONIC_MOVEQ,

 29527 +  AVR32_MNEMONIC_MOVNE,

 29528 +  AVR32_MNEMONIC_MOVCC,

 29529 +  AVR32_MNEMONIC_MOVCS,

 29530 +  AVR32_MNEMONIC_MOVGE,

 29531 +  AVR32_MNEMONIC_MOVLT,

 29532 +  AVR32_MNEMONIC_MOVMI,

 29533 +  AVR32_MNEMONIC_MOVPL,

 29534 +  AVR32_MNEMONIC_MOVLS,

 29535 +  AVR32_MNEMONIC_MOVGT,

 29536 +  AVR32_MNEMONIC_MOVLE,

 29537 +  AVR32_MNEMONIC_MOVHI,

 29538 +  AVR32_MNEMONIC_MOVVS,

 29539 +  AVR32_MNEMONIC_MOVVC,

 29540 +  AVR32_MNEMONIC_MOVQS,

 29541 +  AVR32_MNEMONIC_MOVAL,

 29542 +  AVR32_MNEMONIC_MOVHS,

 29543 +  AVR32_MNEMONIC_MOVLO,

 29544 +  AVR32_MNEMONIC_MTDR,

 29545 +  AVR32_MNEMONIC_MTSR,

 29546 +  AVR32_MNEMONIC_MUL,

 29547 +  AVR32_MNEMONIC_MULHH_W,

 29548 +  AVR32_MNEMONIC_MULNHH_W,

 29549 +  AVR32_MNEMONIC_MULNWH_D,

 29550 +  AVR32_MNEMONIC_MULS_D,

 29551 +  AVR32_MNEMONIC_MULSATHH_H,

 29552 +  AVR32_MNEMONIC_MULSATHH_W,

 29553 +  AVR32_MNEMONIC_MULSATRNDHH_H,

 29554 +  AVR32_MNEMONIC_MULSATRNDWH_W,

 29555 +  AVR32_MNEMONIC_MULSATWH_W,

 29556 +  AVR32_MNEMONIC_MULU_D,

 29557 +  AVR32_MNEMONIC_MULWH_D,

 29558 +  AVR32_MNEMONIC_MUSFR,

 29559 +  AVR32_MNEMONIC_MUSTR,

 29560 +  AVR32_MNEMONIC_MVCR_D,

 29561 +  AVR32_MNEMONIC_MVCR_W,

 29562 +  AVR32_MNEMONIC_MVRC_D,

 29563 +  AVR32_MNEMONIC_MVRC_W,

 29564 +  AVR32_MNEMONIC_NEG,

 29565 +  AVR32_MNEMONIC_NOP,

 29566 +  AVR32_MNEMONIC_OR,

 29567 +  AVR32_MNEMONIC_ORH,

 29568 +  AVR32_MNEMONIC_ORL,

 29569 +  AVR32_MNEMONIC_PABS_SB,

 29570 +  AVR32_MNEMONIC_PABS_SH,

 29571 +  AVR32_MNEMONIC_PACKSH_SB,

 29572 +  AVR32_MNEMONIC_PACKSH_UB,

 29573 +  AVR32_MNEMONIC_PACKW_SH,

 29574 +  AVR32_MNEMONIC_PADD_B,

 29575 +  AVR32_MNEMONIC_PADD_H,

 29576 +  AVR32_MNEMONIC_PADDH_SH,

 29577 +  AVR32_MNEMONIC_PADDH_UB,

 29578 +  AVR32_MNEMONIC_PADDS_SB,

 29579 +  AVR32_MNEMONIC_PADDS_SH,

 29580 +  AVR32_MNEMONIC_PADDS_UB,

 29581 +  AVR32_MNEMONIC_PADDS_UH,

 29582 +  AVR32_MNEMONIC_PADDSUB_H,

 29583 +  AVR32_MNEMONIC_PADDSUBH_SH,

 29584 +  AVR32_MNEMONIC_PADDSUBS_SH,

 29585 +  AVR32_MNEMONIC_PADDSUBS_UH,

 29586 +  AVR32_MNEMONIC_PADDX_H,

 29587 +  AVR32_MNEMONIC_PADDXH_SH,

 29588 +  AVR32_MNEMONIC_PADDXS_SH,

 29589 +  AVR32_MNEMONIC_PADDXS_UH,

 29590 +  AVR32_MNEMONIC_PASR_B,

 29591 +  AVR32_MNEMONIC_PASR_H,

 29592 +  AVR32_MNEMONIC_PAVG_SH,

 29593 +  AVR32_MNEMONIC_PAVG_UB,

 29594 +  AVR32_MNEMONIC_PLSL_B,

 29595 +  AVR32_MNEMONIC_PLSL_H,

 29596 +  AVR32_MNEMONIC_PLSR_B,

 29597 +  AVR32_MNEMONIC_PLSR_H,

 29598 +  AVR32_MNEMONIC_PMAX_SH,

 29599 +  AVR32_MNEMONIC_PMAX_UB,

 29600 +  AVR32_MNEMONIC_PMIN_SH,

 29601 +  AVR32_MNEMONIC_PMIN_UB,

 29602 +  AVR32_MNEMONIC_POPJC,

 29603 +  AVR32_MNEMONIC_POPM,

 29604 +  AVR32_MNEMONIC_PREF,

 29605 +  AVR32_MNEMONIC_PSAD,

 29606 +  AVR32_MNEMONIC_PSUB_B,

 29607 +  AVR32_MNEMONIC_PSUB_H,

 29608 +  AVR32_MNEMONIC_PSUBADD_H,

 29609 +  AVR32_MNEMONIC_PSUBADDH_SH,

 29610 +  AVR32_MNEMONIC_PSUBADDS_SH,

 29611 +  AVR32_MNEMONIC_PSUBADDS_UH,

 29612 +  AVR32_MNEMONIC_PSUBH_SH,

 29613 +  AVR32_MNEMONIC_PSUBH_UB,

 29614 +  AVR32_MNEMONIC_PSUBS_SB,

 29615 +  AVR32_MNEMONIC_PSUBS_SH,

 29616 +  AVR32_MNEMONIC_PSUBS_UB,

 29617 +  AVR32_MNEMONIC_PSUBS_UH,

 29618 +  AVR32_MNEMONIC_PSUBX_H,

 29619 +  AVR32_MNEMONIC_PSUBXH_SH,

 29620 +  AVR32_MNEMONIC_PSUBXS_SH,

 29621 +  AVR32_MNEMONIC_PSUBXS_UH,

 29622 +  AVR32_MNEMONIC_PUNPCKSB_H,

 29623 +  AVR32_MNEMONIC_PUNPCKUB_H,

 29624 +  AVR32_MNEMONIC_PUSHJC,

 29625 +  AVR32_MNEMONIC_PUSHM,

 29626 +  AVR32_MNEMONIC_RCALL,

 29627 +  AVR32_MNEMONIC_RETEQ,

 29628 +  AVR32_MNEMONIC_RETNE,

 29629 +  AVR32_MNEMONIC_RETCC,

 29630 +  AVR32_MNEMONIC_RETCS,

 29631 +  AVR32_MNEMONIC_RETGE,

 29632 +  AVR32_MNEMONIC_RETLT,

 29633 +  AVR32_MNEMONIC_RETMI,

 29634 +  AVR32_MNEMONIC_RETPL,

 29635 +  AVR32_MNEMONIC_RETLS,

 29636 +  AVR32_MNEMONIC_RETGT,

 29637 +  AVR32_MNEMONIC_RETLE,

 29638 +  AVR32_MNEMONIC_RETHI,

 29639 +  AVR32_MNEMONIC_RETVS,

 29640 +  AVR32_MNEMONIC_RETVC,

 29641 +  AVR32_MNEMONIC_RETQS,

 29642 +  AVR32_MNEMONIC_RETAL,

 29643 +  AVR32_MNEMONIC_RETHS,

 29644 +  AVR32_MNEMONIC_RETLO,

 29645 +  AVR32_MNEMONIC_RET,

 29646 +  AVR32_MNEMONIC_RETD,

 29647 +  AVR32_MNEMONIC_RETE,

 29648 +  AVR32_MNEMONIC_RETJ,

 29649 +  AVR32_MNEMONIC_RETS,

 29650 +  AVR32_MNEMONIC_RJMP,

 29651 +  AVR32_MNEMONIC_ROL,

 29652 +  AVR32_MNEMONIC_ROR,

 29653 +  AVR32_MNEMONIC_RSUB,

 29654 +  AVR32_MNEMONIC_SATADD_H,

 29655 +  AVR32_MNEMONIC_SATADD_W,

 29656 +  AVR32_MNEMONIC_SATRNDS,

 29657 +  AVR32_MNEMONIC_SATRNDU,

 29658 +  AVR32_MNEMONIC_SATS,

 29659 +  AVR32_MNEMONIC_SATSUB_H,

 29660 +  AVR32_MNEMONIC_SATSUB_W,

 29661 +  AVR32_MNEMONIC_SATU,

 29662 +  AVR32_MNEMONIC_SBC,

 29663 +  AVR32_MNEMONIC_SBR,

 29664 +  AVR32_MNEMONIC_SCALL,

 29665 +  AVR32_MNEMONIC_SCR,

 29666 +  AVR32_MNEMONIC_SLEEP,

 29667 +  AVR32_MNEMONIC_SREQ,

 29668 +  AVR32_MNEMONIC_SRNE,

 29669 +  AVR32_MNEMONIC_SRCC,

 29670 +  AVR32_MNEMONIC_SRCS,

 29671 +  AVR32_MNEMONIC_SRGE,

 29672 +  AVR32_MNEMONIC_SRLT,

 29673 +  AVR32_MNEMONIC_SRMI,

 29674 +  AVR32_MNEMONIC_SRPL,

 29675 +  AVR32_MNEMONIC_SRLS,

 29676 +  AVR32_MNEMONIC_SRGT,

 29677 +  AVR32_MNEMONIC_SRLE,

 29678 +  AVR32_MNEMONIC_SRHI,

 29679 +  AVR32_MNEMONIC_SRVS,

 29680 +  AVR32_MNEMONIC_SRVC,

 29681 +  AVR32_MNEMONIC_SRQS,

 29682 +  AVR32_MNEMONIC_SRAL,

 29683 +  AVR32_MNEMONIC_SRHS,

 29684 +  AVR32_MNEMONIC_SRLO,

 29685 +  AVR32_MNEMONIC_SSRF,

 29686 +  AVR32_MNEMONIC_ST_B,

 29687 +  AVR32_MNEMONIC_ST_D,

 29688 +  AVR32_MNEMONIC_ST_H,

 29689 +  AVR32_MNEMONIC_ST_W,

 29690 +  AVR32_MNEMONIC_STC_D,

 29691 +  AVR32_MNEMONIC_STC_W,

 29692 +  AVR32_MNEMONIC_STC0_D,

 29693 +  AVR32_MNEMONIC_STC0_W,

 29694 +  AVR32_MNEMONIC_STCM_D,

 29695 +  AVR32_MNEMONIC_STCM_W,

 29696 +  AVR32_MNEMONIC_STCOND,

 29697 +  AVR32_MNEMONIC_STDSP,

 29698 +  AVR32_MNEMONIC_STHH_W,

 29699 +  AVR32_MNEMONIC_STM,

 29700 +  AVR32_MNEMONIC_STMTS,

 29701 +  AVR32_MNEMONIC_STSWP_H,

 29702 +  AVR32_MNEMONIC_STSWP_W,

 29703 +  AVR32_MNEMONIC_SUB,

 29704 +  AVR32_MNEMONIC_SUBEQ,

 29705 +  AVR32_MNEMONIC_SUBNE,

 29706 +  AVR32_MNEMONIC_SUBCC,

 29707 +  AVR32_MNEMONIC_SUBCS,

 29708 +  AVR32_MNEMONIC_SUBGE,

 29709 +  AVR32_MNEMONIC_SUBLT,

 29710 +  AVR32_MNEMONIC_SUBMI,

 29711 +  AVR32_MNEMONIC_SUBPL,

 29712 +  AVR32_MNEMONIC_SUBLS,

 29713 +  AVR32_MNEMONIC_SUBGT,

 29714 +  AVR32_MNEMONIC_SUBLE,

 29715 +  AVR32_MNEMONIC_SUBHI,

 29716 +  AVR32_MNEMONIC_SUBVS,

 29717 +  AVR32_MNEMONIC_SUBVC,

 29718 +  AVR32_MNEMONIC_SUBQS,

 29719 +  AVR32_MNEMONIC_SUBAL,

 29720 +  AVR32_MNEMONIC_SUBHS,

 29721 +  AVR32_MNEMONIC_SUBLO,

 29722 +  AVR32_MNEMONIC_SUBFEQ,

 29723 +  AVR32_MNEMONIC_SUBFNE,

 29724 +  AVR32_MNEMONIC_SUBFCC,

 29725 +  AVR32_MNEMONIC_SUBFCS,

 29726 +  AVR32_MNEMONIC_SUBFGE,

 29727 +  AVR32_MNEMONIC_SUBFLT,

 29728 +  AVR32_MNEMONIC_SUBFMI,

 29729 +  AVR32_MNEMONIC_SUBFPL,

 29730 +  AVR32_MNEMONIC_SUBFLS,

 29731 +  AVR32_MNEMONIC_SUBFGT,

 29732 +  AVR32_MNEMONIC_SUBFLE,

 29733 +  AVR32_MNEMONIC_SUBFHI,

 29734 +  AVR32_MNEMONIC_SUBFVS,

 29735 +  AVR32_MNEMONIC_SUBFVC,

 29736 +  AVR32_MNEMONIC_SUBFQS,

 29737 +  AVR32_MNEMONIC_SUBFAL,

 29738 +  AVR32_MNEMONIC_SUBFHS,

 29739 +  AVR32_MNEMONIC_SUBFLO,

 29740 +  AVR32_MNEMONIC_SUBHH_W,

 29741 +  AVR32_MNEMONIC_SWAP_B,

 29742 +  AVR32_MNEMONIC_SWAP_BH,

 29743 +  AVR32_MNEMONIC_SWAP_H,

 29744 +  AVR32_MNEMONIC_SYNC,

 29745 +  AVR32_MNEMONIC_TLBR,

 29746 +  AVR32_MNEMONIC_TLBS,

 29747 +  AVR32_MNEMONIC_TLBW,

 29748 +  AVR32_MNEMONIC_TNBZ,

 29749 +  AVR32_MNEMONIC_TST,

 29750 +  AVR32_MNEMONIC_XCHG,

 29751 +  AVR32_MNEMONIC_MEMC,

 29752 +  AVR32_MNEMONIC_MEMS,

 29753 +  AVR32_MNEMONIC_MEMT,

 29754 +  AVR32_MNEMONIC_FADD_S,

 29755 +  AVR32_MNEMONIC_FADD_D,

 29756 +  AVR32_MNEMONIC_FSUB_S,

 29757 +  AVR32_MNEMONIC_FSUB_D,

 29758 +  AVR32_MNEMONIC_FMAC_S,

 29759 +  AVR32_MNEMONIC_FMAC_D,

 29760 +  AVR32_MNEMONIC_FNMAC_S,

 29761 +  AVR32_MNEMONIC_FNMAC_D,

 29762 +  AVR32_MNEMONIC_FMSC_S,

 29763 +  AVR32_MNEMONIC_FMSC_D,

 29764 +  AVR32_MNEMONIC_FNMSC_S,

 29765 +  AVR32_MNEMONIC_FNMSC_D,

 29766 +  AVR32_MNEMONIC_FMUL_S,

 29767 +  AVR32_MNEMONIC_FMUL_D,

 29768 +  AVR32_MNEMONIC_FNMUL_S,

 29769 +  AVR32_MNEMONIC_FNMUL_D,

 29770 +  AVR32_MNEMONIC_FNEG_S,

 29771 +  AVR32_MNEMONIC_FNEG_D,

 29772 +  AVR32_MNEMONIC_FABS_S,

 29773 +  AVR32_MNEMONIC_FABS_D,

 29774 +  AVR32_MNEMONIC_FCMP_S,

 29775 +  AVR32_MNEMONIC_FCMP_D,

 29776 +  AVR32_MNEMONIC_FMOV_S,

 29777 +  AVR32_MNEMONIC_FMOV_D,

 29778 +  AVR32_MNEMONIC_FCASTS_D,

 29779 +  AVR32_MNEMONIC_FCASTD_S,

 29780 +  /* AVR32_MNEMONIC_FLD_S,

 29781 +     AVR32_MNEMONIC_FLD_D,

 29782 +     AVR32_MNEMONIC_FST_S,

 29783 +     AVR32_MNEMONIC_FST_D, */

 29784 +  AVR32_MNEMONIC_LDA_W,

 29785 +  AVR32_MNEMONIC_CALL,

 29786 +  AVR32_MNEMONIC_PICOSVMAC,

 29787 +  AVR32_MNEMONIC_PICOSVMUL,

 29788 +  AVR32_MNEMONIC_PICOVMAC,

 29789 +  AVR32_MNEMONIC_PICOVMUL,

 29790 +  AVR32_MNEMONIC_PICOLD_D,

 29791 +  AVR32_MNEMONIC_PICOLD_W,

 29792 +  AVR32_MNEMONIC_PICOLDM_D,

 29793 +  AVR32_MNEMONIC_PICOLDM_W,

 29794 +  AVR32_MNEMONIC_PICOMV_D,

 29795 +  AVR32_MNEMONIC_PICOMV_W,

 29796 +  AVR32_MNEMONIC_PICOST_D,

 29797 +  AVR32_MNEMONIC_PICOST_W,

 29798 +  AVR32_MNEMONIC_PICOSTM_D,

 29799 +  AVR32_MNEMONIC_PICOSTM_W,

 29800 +  AVR32_MNEMONIC_RSUBEQ,

 29801 +  AVR32_MNEMONIC_RSUBNE,

 29802 +  AVR32_MNEMONIC_RSUBCC,

 29803 +  AVR32_MNEMONIC_RSUBCS,

 29804 +  AVR32_MNEMONIC_RSUBGE,

 29805 +  AVR32_MNEMONIC_RSUBLT,

 29806 +  AVR32_MNEMONIC_RSUBMI,

 29807 +  AVR32_MNEMONIC_RSUBPL,

 29808 +  AVR32_MNEMONIC_RSUBLS,

 29809 +  AVR32_MNEMONIC_RSUBGT,

 29810 +  AVR32_MNEMONIC_RSUBLE,

 29811 +  AVR32_MNEMONIC_RSUBHI,

 29812 +  AVR32_MNEMONIC_RSUBVS,

 29813 +  AVR32_MNEMONIC_RSUBVC,

 29814 +  AVR32_MNEMONIC_RSUBQS,

 29815 +  AVR32_MNEMONIC_RSUBAL,

 29816 +  AVR32_MNEMONIC_RSUBHS,

 29817 +  AVR32_MNEMONIC_RSUBLO,

 29818 +  AVR32_MNEMONIC_ADDEQ,

 29819 +  AVR32_MNEMONIC_ADDNE,

 29820 +  AVR32_MNEMONIC_ADDCC,

 29821 +  AVR32_MNEMONIC_ADDCS,

 29822 +  AVR32_MNEMONIC_ADDGE,

 29823 +  AVR32_MNEMONIC_ADDLT,

 29824 +  AVR32_MNEMONIC_ADDMI,

 29825 +  AVR32_MNEMONIC_ADDPL,

 29826 +  AVR32_MNEMONIC_ADDLS,

 29827 +  AVR32_MNEMONIC_ADDGT,

 29828 +  AVR32_MNEMONIC_ADDLE,

 29829 +  AVR32_MNEMONIC_ADDHI,

 29830 +  AVR32_MNEMONIC_ADDVS,

 29831 +  AVR32_MNEMONIC_ADDVC,

 29832 +  AVR32_MNEMONIC_ADDQS,

 29833 +  AVR32_MNEMONIC_ADDAL,

 29834 +  AVR32_MNEMONIC_ADDHS,

 29835 +  AVR32_MNEMONIC_ADDLO,

 29836 +  AVR32_MNEMONIC_ANDEQ,

 29837 +  AVR32_MNEMONIC_ANDNE,

 29838 +  AVR32_MNEMONIC_ANDCC,

 29839 +  AVR32_MNEMONIC_ANDCS,

 29840 +  AVR32_MNEMONIC_ANDGE,

 29841 +  AVR32_MNEMONIC_ANDLT,

 29842 +  AVR32_MNEMONIC_ANDMI,

 29843 +  AVR32_MNEMONIC_ANDPL,

 29844 +  AVR32_MNEMONIC_ANDLS,

 29845 +  AVR32_MNEMONIC_ANDGT,

 29846 +  AVR32_MNEMONIC_ANDLE,

 29847 +  AVR32_MNEMONIC_ANDHI,

 29848 +  AVR32_MNEMONIC_ANDVS,

 29849 +  AVR32_MNEMONIC_ANDVC,

 29850 +  AVR32_MNEMONIC_ANDQS,

 29851 +  AVR32_MNEMONIC_ANDAL,

 29852 +  AVR32_MNEMONIC_ANDHS,

 29853 +  AVR32_MNEMONIC_ANDLO,

 29854 +  AVR32_MNEMONIC_OREQ,

 29855 +  AVR32_MNEMONIC_ORNE,

 29856 +  AVR32_MNEMONIC_ORCC,

 29857 +  AVR32_MNEMONIC_ORCS,

 29858 +  AVR32_MNEMONIC_ORGE,

 29859 +  AVR32_MNEMONIC_ORLT,

 29860 +  AVR32_MNEMONIC_ORMI,

 29861 +  AVR32_MNEMONIC_ORPL,

 29862 +  AVR32_MNEMONIC_ORLS,

 29863 +  AVR32_MNEMONIC_ORGT,

 29864 +  AVR32_MNEMONIC_ORLE,

 29865 +  AVR32_MNEMONIC_ORHI,

 29866 +  AVR32_MNEMONIC_ORVS,

 29867 +  AVR32_MNEMONIC_ORVC,

 29868 +  AVR32_MNEMONIC_ORQS,

 29869 +  AVR32_MNEMONIC_ORAL,

 29870 +  AVR32_MNEMONIC_ORHS,

 29871 +  AVR32_MNEMONIC_ORLO,

 29872 +  AVR32_MNEMONIC_EOREQ,

 29873 +  AVR32_MNEMONIC_EORNE,

 29874 +  AVR32_MNEMONIC_EORCC,

 29875 +  AVR32_MNEMONIC_EORCS,

 29876 +  AVR32_MNEMONIC_EORGE,

 29877 +  AVR32_MNEMONIC_EORLT,

 29878 +  AVR32_MNEMONIC_EORMI,

 29879 +  AVR32_MNEMONIC_EORPL,

 29880 +  AVR32_MNEMONIC_EORLS,

 29881 +  AVR32_MNEMONIC_EORGT,

 29882 +  AVR32_MNEMONIC_EORLE,

 29883 +  AVR32_MNEMONIC_EORHI,

 29884 +  AVR32_MNEMONIC_EORVS,

 29885 +  AVR32_MNEMONIC_EORVC,

 29886 +  AVR32_MNEMONIC_EORQS,

 29887 +  AVR32_MNEMONIC_EORAL,

 29888 +  AVR32_MNEMONIC_EORHS,

 29889 +  AVR32_MNEMONIC_EORLO,

 29890 +  AVR32_MNEMONIC_LD_WEQ,

 29891 +  AVR32_MNEMONIC_LD_WNE,

 29892 +  AVR32_MNEMONIC_LD_WCC,

 29893 +  AVR32_MNEMONIC_LD_WCS,

 29894 +  AVR32_MNEMONIC_LD_WGE,

 29895 +  AVR32_MNEMONIC_LD_WLT,

 29896 +  AVR32_MNEMONIC_LD_WMI,

 29897 +  AVR32_MNEMONIC_LD_WPL,

 29898 +  AVR32_MNEMONIC_LD_WLS,

 29899 +  AVR32_MNEMONIC_LD_WGT,

 29900 +  AVR32_MNEMONIC_LD_WLE,

 29901 +  AVR32_MNEMONIC_LD_WHI,

 29902 +  AVR32_MNEMONIC_LD_WVS,

 29903 +  AVR32_MNEMONIC_LD_WVC,

 29904 +  AVR32_MNEMONIC_LD_WQS,

 29905 +  AVR32_MNEMONIC_LD_WAL,

 29906 +  AVR32_MNEMONIC_LD_WHS,

 29907 +  AVR32_MNEMONIC_LD_WLO,

 29908 +  AVR32_MNEMONIC_LD_SHEQ,

 29909 +  AVR32_MNEMONIC_LD_SHNE,

 29910 +  AVR32_MNEMONIC_LD_SHCC,

 29911 +  AVR32_MNEMONIC_LD_SHCS,

 29912 +  AVR32_MNEMONIC_LD_SHGE,

 29913 +  AVR32_MNEMONIC_LD_SHLT,

 29914 +  AVR32_MNEMONIC_LD_SHMI,

 29915 +  AVR32_MNEMONIC_LD_SHPL,

 29916 +  AVR32_MNEMONIC_LD_SHLS,

 29917 +  AVR32_MNEMONIC_LD_SHGT,

 29918 +  AVR32_MNEMONIC_LD_SHLE,

 29919 +  AVR32_MNEMONIC_LD_SHHI,

 29920 +  AVR32_MNEMONIC_LD_SHVS,

 29921 +  AVR32_MNEMONIC_LD_SHVC,

 29922 +  AVR32_MNEMONIC_LD_SHQS,

 29923 +  AVR32_MNEMONIC_LD_SHAL,

 29924 +  AVR32_MNEMONIC_LD_SHHS,

 29925 +  AVR32_MNEMONIC_LD_SHLO,

 29926 +  AVR32_MNEMONIC_LD_UHEQ,

 29927 +  AVR32_MNEMONIC_LD_UHNE,

 29928 +  AVR32_MNEMONIC_LD_UHCC,

 29929 +  AVR32_MNEMONIC_LD_UHCS,

 29930 +  AVR32_MNEMONIC_LD_UHGE,

 29931 +  AVR32_MNEMONIC_LD_UHLT,

 29932 +  AVR32_MNEMONIC_LD_UHMI,

 29933 +  AVR32_MNEMONIC_LD_UHPL,

 29934 +  AVR32_MNEMONIC_LD_UHLS,

 29935 +  AVR32_MNEMONIC_LD_UHGT,

 29936 +  AVR32_MNEMONIC_LD_UHLE,

 29937 +  AVR32_MNEMONIC_LD_UHHI,

 29938 +  AVR32_MNEMONIC_LD_UHVS,

 29939 +  AVR32_MNEMONIC_LD_UHVC,

 29940 +  AVR32_MNEMONIC_LD_UHQS,

 29941 +  AVR32_MNEMONIC_LD_UHAL,

 29942 +  AVR32_MNEMONIC_LD_UHHS,

 29943 +  AVR32_MNEMONIC_LD_UHLO,

 29944 +  AVR32_MNEMONIC_LD_SBEQ,

 29945 +  AVR32_MNEMONIC_LD_SBNE,

 29946 +  AVR32_MNEMONIC_LD_SBCC,

 29947 +  AVR32_MNEMONIC_LD_SBCS,

 29948 +  AVR32_MNEMONIC_LD_SBGE,

 29949 +  AVR32_MNEMONIC_LD_SBLT,

 29950 +  AVR32_MNEMONIC_LD_SBMI,

 29951 +  AVR32_MNEMONIC_LD_SBPL,

 29952 +  AVR32_MNEMONIC_LD_SBLS,

 29953 +  AVR32_MNEMONIC_LD_SBGT,

 29954 +  AVR32_MNEMONIC_LD_SBLE,

 29955 +  AVR32_MNEMONIC_LD_SBHI,

 29956 +  AVR32_MNEMONIC_LD_SBVS,

 29957 +  AVR32_MNEMONIC_LD_SBVC,

 29958 +  AVR32_MNEMONIC_LD_SBQS,

 29959 +  AVR32_MNEMONIC_LD_SBAL,

 29960 +  AVR32_MNEMONIC_LD_SBHS,

 29961 +  AVR32_MNEMONIC_LD_SBLO,

 29962 +  AVR32_MNEMONIC_LD_UBEQ,

 29963 +  AVR32_MNEMONIC_LD_UBNE,

 29964 +  AVR32_MNEMONIC_LD_UBCC,

 29965 +  AVR32_MNEMONIC_LD_UBCS,

 29966 +  AVR32_MNEMONIC_LD_UBGE,

 29967 +  AVR32_MNEMONIC_LD_UBLT,

 29968 +  AVR32_MNEMONIC_LD_UBMI,

 29969 +  AVR32_MNEMONIC_LD_UBPL,

 29970 +  AVR32_MNEMONIC_LD_UBLS,

 29971 +  AVR32_MNEMONIC_LD_UBGT,

 29972 +  AVR32_MNEMONIC_LD_UBLE,

 29973 +  AVR32_MNEMONIC_LD_UBHI,

 29974 +  AVR32_MNEMONIC_LD_UBVS,

 29975 +  AVR32_MNEMONIC_LD_UBVC,

 29976 +  AVR32_MNEMONIC_LD_UBQS,

 29977 +  AVR32_MNEMONIC_LD_UBAL,

 29978 +  AVR32_MNEMONIC_LD_UBHS,

 29979 +  AVR32_MNEMONIC_LD_UBLO,

 29980 +  AVR32_MNEMONIC_ST_WEQ,

 29981 +  AVR32_MNEMONIC_ST_WNE,

 29982 +  AVR32_MNEMONIC_ST_WCC,

 29983 +  AVR32_MNEMONIC_ST_WCS,

 29984 +  AVR32_MNEMONIC_ST_WGE,

 29985 +  AVR32_MNEMONIC_ST_WLT,

 29986 +  AVR32_MNEMONIC_ST_WMI,

 29987 +  AVR32_MNEMONIC_ST_WPL,

 29988 +  AVR32_MNEMONIC_ST_WLS,

 29989 +  AVR32_MNEMONIC_ST_WGT,

 29990 +  AVR32_MNEMONIC_ST_WLE,

 29991 +  AVR32_MNEMONIC_ST_WHI,

 29992 +  AVR32_MNEMONIC_ST_WVS,

 29993 +  AVR32_MNEMONIC_ST_WVC,

 29994 +  AVR32_MNEMONIC_ST_WQS,

 29995 +  AVR32_MNEMONIC_ST_WAL,

 29996 +  AVR32_MNEMONIC_ST_WHS,

 29997 +  AVR32_MNEMONIC_ST_WLO,

 29998 +  AVR32_MNEMONIC_ST_HEQ,

 29999 +  AVR32_MNEMONIC_ST_HNE,

 30000 +  AVR32_MNEMONIC_ST_HCC,

 30001 +  AVR32_MNEMONIC_ST_HCS,

 30002 +  AVR32_MNEMONIC_ST_HGE,

 30003 +  AVR32_MNEMONIC_ST_HLT,

 30004 +  AVR32_MNEMONIC_ST_HMI,

 30005 +  AVR32_MNEMONIC_ST_HPL,

 30006 +  AVR32_MNEMONIC_ST_HLS,

 30007 +  AVR32_MNEMONIC_ST_HGT,

 30008 +  AVR32_MNEMONIC_ST_HLE,

 30009 +  AVR32_MNEMONIC_ST_HHI,

 30010 +  AVR32_MNEMONIC_ST_HVS,

 30011 +  AVR32_MNEMONIC_ST_HVC,

 30012 +  AVR32_MNEMONIC_ST_HQS,

 30013 +  AVR32_MNEMONIC_ST_HAL,

 30014 +  AVR32_MNEMONIC_ST_HHS,

 30015 +  AVR32_MNEMONIC_ST_HLO,

 30016 +  AVR32_MNEMONIC_ST_BEQ,

 30017 +  AVR32_MNEMONIC_ST_BNE,

 30018 +  AVR32_MNEMONIC_ST_BCC,

 30019 +  AVR32_MNEMONIC_ST_BCS,

 30020 +  AVR32_MNEMONIC_ST_BGE,

 30021 +  AVR32_MNEMONIC_ST_BLT,

 30022 +  AVR32_MNEMONIC_ST_BMI,

 30023 +  AVR32_MNEMONIC_ST_BPL,

 30024 +  AVR32_MNEMONIC_ST_BLS,

 30025 +  AVR32_MNEMONIC_ST_BGT,

 30026 +  AVR32_MNEMONIC_ST_BLE,

 30027 +  AVR32_MNEMONIC_ST_BHI,

 30028 +  AVR32_MNEMONIC_ST_BVS,

 30029 +  AVR32_MNEMONIC_ST_BVC,

 30030 +  AVR32_MNEMONIC_ST_BQS,

 30031 +  AVR32_MNEMONIC_ST_BAL,

 30032 +  AVR32_MNEMONIC_ST_BHS,

 30033 +  AVR32_MNEMONIC_ST_BLO,

 30034 +  AVR32_MNEMONIC_MOVH,

 30035 +  AVR32_MNEMONIC__END_

 30036 +};

 30037 +#define AVR32_NR_MNEMONICS AVR32_MNEMONIC__END_

 30038 +

 30039 +enum avr32_syntax_parser

 30040 +  {

 30041 +    AVR32_PARSER_NORMAL,

 30042 +    AVR32_PARSER_ALIAS,

 30043 +    AVR32_PARSER_LDA,

 30044 +    AVR32_PARSER_CALL,

 30045 +    AVR32_PARSER__END_

 30046 +  };

 30047 +#define AVR32_NR_PARSERS AVR32_PARSER__END_

 30048 --- a/opcodes/configure.in

 30049 +++ b/opcodes/configure.in

 30050 @@ -158,6 +158,7 @@ if test x${all_targets} = xfalse ; then

 30051  	bfd_arc_arch)		ta="$ta arc-dis.lo arc-opc.lo arc-ext.lo" ;;

 30052  	bfd_arm_arch)		ta="$ta arm-dis.lo" ;;

 30053  	bfd_avr_arch)		ta="$ta avr-dis.lo" ;;

 30054 +	bfd_avr32_arch)		ta="$ta avr32-asm.lo avr32-dis.lo avr32-opc.lo" ;;

 30055  	bfd_bfin_arch)		ta="$ta bfin-dis.lo" ;;

 30056  	bfd_cr16_arch)    	ta="$ta cr16-dis.lo cr16-opc.lo" ;;

 30057  	bfd_cris_arch)		ta="$ta cris-dis.lo cris-opc.lo cgen-bitset.lo" ;;

 30058 @@ -216,7 +217,7 @@ if test x${all_targets} = xfalse ; then

 30059  				ta="$ta sh64-dis.lo sh64-opc.lo"

 30060  				archdefs="$archdefs -DINCLUDE_SHMEDIA"

 30061  				break;;

 30062 -	    esac;

 30063 +	    esac

 30064  	  done

 30065  				ta="$ta sh-dis.lo cgen-bitset.lo" ;;

 30066  	bfd_sparc_arch)		ta="$ta sparc-dis.lo sparc-opc.lo" ;;

 30067 --- a/opcodes/disassemble.c

 30068 +++ b/opcodes/disassemble.c

 30069 @@ -27,6 +27,7 @@

 30070  #define ARCH_arc

 30071  #define ARCH_arm

 30072  #define ARCH_avr

 30073 +#define ARCH_avr32

 30074  #define ARCH_bfin

 30075  #define ARCH_cr16

 30076  #define ARCH_cris

 30077 @@ -128,6 +129,11 @@ disassembler (abfd)

 30078        disassemble = print_insn_avr;

 30079        break;

 30080  #endif

 30081 +#ifdef ARCH_avr32

 30082 +    case bfd_arch_avr32:

 30083 +      disassemble = print_insn_avr32;

 30084 +      break;

 30085 +#endif

 30086  #ifdef ARCH_bfin

 30087      case bfd_arch_bfin:

 30088        disassemble = print_insn_bfin;

 30089 @@ -346,9 +352,9 @@ disassembler (abfd)

 30090  #ifdef ARCH_score

 30091      case bfd_arch_score:

 30092        if (bfd_big_endian (abfd))

 30093 -        disassemble = print_insn_big_score;

 30094 +        disassemble = print_insn_big_score;

 30095        else

 30096 -        disassemble = print_insn_little_score;

 30097 +        disassemble = print_insn_little_score;

 30098       break;

 30099  #endif

 30100  #ifdef ARCH_sh

 30101 @@ -466,6 +472,9 @@ disassembler_usage (stream)

 30102  #ifdef ARCH_i386

 30103    print_i386_disassembler_options (stream);

 30104  #endif

 30105 +#ifdef ARCH_avr32

 30106 +  print_avr32_disassembler_options (stream);

 30107 +#endif

 30109    return;

 30110  }

 30111 --- a/opcodes/Makefile.am

 30112 +++ b/opcodes/Makefile.am

 30113 @@ -30,6 +30,7 @@ LIBIBERTY = ../libiberty/libiberty.a

 30114  # Header files.

 30115  HFILES = \

 30116  	cgen-ops.h cgen-types.h \

 30117 +	avr32-asm.h avr32-opc.h \

 30118  	fr30-desc.h fr30-opc.h \

 30119  	frv-desc.h frv-opc.h \

 30120  	h8500-opc.h \

 30121 @@ -63,6 +64,9 @@ CFILES = \

 30122  	arc-ext.c \

 30123  	arm-dis.c \

 30124  	avr-dis.c \

 30125 +	avr32-asm.c \

 30126 +	avr32-dis.c \

 30127 +	avr32-opc.c \

 30128  	bfin-dis.c \

 30129  	cgen-asm.c \

 30130  	cgen-bitset.c \

 30131 @@ -217,6 +221,9 @@ ALL_MACHINES = \

 30132  	arc-ext.lo \

 30133  	arm-dis.lo \

 30134  	avr-dis.lo \

 30135 +	avr32-asm.lo \

 30136 +	avr32-dis.lo \

 30137 +	avr32-opc.lo \

 30138  	bfin-dis.lo \

 30139  	cgen-asm.lo \

 30140  	cgen-bitset.lo \

 30141 @@ -674,6 +681,15 @@ avr-dis.lo: avr-dis.c sysdep.h config.h

 30142    $(INCDIR)/dis-asm.h $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h \

 30143    opintl.h $(INCDIR)/libiberty.h $(INCDIR)/ansidecl.h \

 30144    $(INCDIR)/opcode/avr.h

 30145 +avr32-asm.lo: avr32-asm.c sysdep.h config.h $(INCDIR)/ansidecl.h \

 30146 +  $(BFD_H) $(INCDIR)/symcat.h avr32-opc.h opintl.h \

 30147 +  $(INCDIR)/xregex.h $(INCDIR)/xregex2.h \

 30148 +  $(INCDIR)/libiberty.h $(INCDIR)/safe-ctype.h

 30149 +avr32-dis.lo: avr32-dis.c sysdep.h config.h $(INCDIR)/ansidecl.h \

 30150 +  $(INCDIR)/dis-asm.h $(BFD_H) $(INCDIR)/symcat.h $(INCDIR)/libiberty.h \

 30151 +  avr32-opc.h opintl.h

 30152 +avr32-opc.lo: avr32-opc.c sysdep.h config.h $(INCDIR)/ansidecl.h \

 30153 +  $(BFD_H) $(INCDIR)/symcat.h avr32-opc.h $(INCDIR)/libiberty.h

 30154  bfin-dis.lo: bfin-dis.c $(INCDIR)/opcode/bfin.h $(INCDIR)/dis-asm.h \

 30155    $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h

 30156  cgen-asm.lo: cgen-asm.c sysdep.h config.h $(INCDIR)/ansidecl.h \

 30157 --- a/bfd/bfd-in2.h

 30158 +++ b/bfd/bfd-in2.h

 30159 @@ -2017,6 +2017,11 @@ enum bfd_architecture

 30160  #define bfd_mach_avr4          4

 30161  #define bfd_mach_avr5          5

 30162  #define bfd_mach_avr6          6

 30163 +  bfd_arch_avr32,     /* Atmel AVR32 */

 30164 +#define bfd_mach_avr32_ap      7000

 30165 +#define bfd_mach_avr32_uc      3000

 30166 +#define bfd_mach_avr32_ucr1    3001

 30167 +#define bfd_mach_avr32_ucr2    3002

 30168    bfd_arch_bfin,        /* ADI Blackfin */

 30169  #define bfd_mach_bfin          1

 30170    bfd_arch_cr16,       /* National Semiconductor CompactRISC (ie CR16). */

 30171 @@ -3758,6 +3763,88 @@ instructions  */

 30172  instructions  */

 30173    BFD_RELOC_AVR_6_ADIW,

 30175 +/* Difference between two labels: L2 - L1. The value of L1 is encoded

 30176 +as sym + addend, while the initial difference after assembly is

 30177 +inserted into the object file by the assembler.  */

 30178 +  BFD_RELOC_AVR32_DIFF32,

 30179 +  BFD_RELOC_AVR32_DIFF16,

 30180 +  BFD_RELOC_AVR32_DIFF8,

 30181 +

 30182 +/* Reference to a symbol through the Global Offset Table. The linker

 30183 +will allocate an entry for symbol in the GOT and insert the offset

 30184 +of this entry as the relocation value.  */

 30185 +  BFD_RELOC_AVR32_GOT32,

 30186 +  BFD_RELOC_AVR32_GOT16,

 30187 +  BFD_RELOC_AVR32_GOT8,

 30188 +

 30189 +/* Normal (non-pc-relative) code relocations. Alignment and signedness

 30190 +is indicated by the suffixes. S means signed, U means unsigned. W

 30191 +means word-aligned, H means halfword-aligned, neither means

 30192 +byte-aligned (no alignment.) SUB5 is the same relocation as 16S.  */

 30193 +  BFD_RELOC_AVR32_21S,

 30194 +  BFD_RELOC_AVR32_16U,

 30195 +  BFD_RELOC_AVR32_16S,

 30196 +  BFD_RELOC_AVR32_SUB5,

 30197 +  BFD_RELOC_AVR32_8S_EXT,

 30198 +  BFD_RELOC_AVR32_8S,

 30199 +  BFD_RELOC_AVR32_15S,

 30200 +

 30201 +/* PC-relative relocations are signed if neither 'U' nor 'S' is

 30202 +specified. However, we explicitly tack on a 'B' to indicate no

 30203 +alignment, to avoid confusion with data relocs. All of these resolve

 30204 +to sym + addend - offset, except the one with 'N' (negated) suffix.

 30205 +This particular one resolves to offset - sym - addend.  */

 30206 +  BFD_RELOC_AVR32_22H_PCREL,

 30207 +  BFD_RELOC_AVR32_18W_PCREL,

 30208 +  BFD_RELOC_AVR32_16B_PCREL,

 30209 +  BFD_RELOC_AVR32_16N_PCREL,

 30210 +  BFD_RELOC_AVR32_14UW_PCREL,

 30211 +  BFD_RELOC_AVR32_11H_PCREL,

 30212 +  BFD_RELOC_AVR32_10UW_PCREL,

 30213 +  BFD_RELOC_AVR32_9H_PCREL,

 30214 +  BFD_RELOC_AVR32_9UW_PCREL,

 30215 +

 30216 +/* Subtract the link-time address of the GOT from (symbol + addend)

 30217 +and insert the result.  */

 30218 +  BFD_RELOC_AVR32_GOTPC,

 30219 +

 30220 +/* Reference to a symbol through the GOT. The linker will allocate an

 30221 +entry for symbol in the GOT and insert the offset of this entry as

 30222 +the relocation value. addend must be zero. As usual, 'S' means

 30223 +signed, 'W' means word-aligned, etc.  */

 30224 +  BFD_RELOC_AVR32_GOTCALL,

 30225 +  BFD_RELOC_AVR32_LDA_GOT,

 30226 +  BFD_RELOC_AVR32_GOT21S,

 30227 +  BFD_RELOC_AVR32_GOT18SW,

 30228 +  BFD_RELOC_AVR32_GOT16S,

 30229 +

 30230 +/* 32-bit constant pool entry. I don't think 8- and 16-bit entries make

 30231 +a whole lot of sense.  */

 30232 +  BFD_RELOC_AVR32_32_CPENT,

 30233 +

 30234 +/* Constant pool references. Some of these relocations are signed,

 30235 +others are unsigned. It doesn't really matter, since the constant

 30236 +pool always comes after the code that references it.  */

 30237 +  BFD_RELOC_AVR32_CPCALL,

 30238 +  BFD_RELOC_AVR32_16_CP,

 30239 +  BFD_RELOC_AVR32_9W_CP,

 30240 +

 30241 +/* sym must be the absolute symbol. The addend specifies the alignment

 30242 +order, e.g. if addend is 2, the linker must add padding so that the

 30243 +next address is aligned to a 4-byte boundary.  */

 30244 +  BFD_RELOC_AVR32_ALIGN,

 30245 +

 30246 +/* Code relocations that will never make it to the output file.  */

 30247 +  BFD_RELOC_AVR32_14UW,

 30248 +  BFD_RELOC_AVR32_10UW,

 30249 +  BFD_RELOC_AVR32_10SW,

 30250 +  BFD_RELOC_AVR32_STHH_W,

 30251 +  BFD_RELOC_AVR32_7UW,

 30252 +  BFD_RELOC_AVR32_6S,

 30253 +  BFD_RELOC_AVR32_6UW,

 30254 +  BFD_RELOC_AVR32_4UH,

 30255 +  BFD_RELOC_AVR32_3U,

 30256 +

 30257  /* Direct 12 bit.  */

 30258    BFD_RELOC_390_12,

 30260 --- /dev/null

 30261 +++ b/bfd/bfd-in3.h

 30262 @@ -0,0 +1,5406 @@

 30263 +/* DO NOT EDIT!  -*- buffer-read-only: t -*-  This file is automatically

 30264 +   generated from "bfd-in.h", "init.c", "opncls.c", "libbfd.c",

 30265 +   "bfdio.c", "bfdwin.c", "section.c", "archures.c", "reloc.c",

 30266 +   "syms.c", "bfd.c", "archive.c", "corefile.c", "targets.c", "format.c",

 30267 +   "linker.c" and "simple.c".

 30268 +   Run "make headers" in your build bfd/ to regenerate.  */

 30269 +

 30270 +/* Main header file for the bfd library -- portable access to object files.

 30271 +

 30272 +   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

 30273 +   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007

 30274 +   Free Software Foundation, Inc.

 30275 +

 30276 +   Contributed by Cygnus Support.

 30277 +

 30278 +   This file is part of BFD, the Binary File Descriptor library.

 30279 +

 30280 +   This program is free software; you can redistribute it and/or modify

 30281 +   it under the terms of the GNU General Public License as published by

 30282 +   the Free Software Foundation; either version 3 of the License, or

 30283 +   (at your option) any later version.

 30284 +

 30285 +   This program is distributed in the hope that it will be useful,

 30286 +   but WITHOUT ANY WARRANTY; without even the implied warranty of

 30287 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 30288 +   GNU General Public License for more details.

 30289 +

 30290 +   You should have received a copy of the GNU General Public License

 30291 +   along with this program; if not, write to the Free Software

 30292 +   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */

 30293 +

 30294 +#ifndef __BFD_H_SEEN__

 30295 +#define __BFD_H_SEEN__

 30296 +

 30297 +#ifdef __cplusplus

 30298 +extern "C" {

 30299 +#endif

 30300 +

 30301 +#include "ansidecl.h"

 30302 +#include "symcat.h"

 30303 +#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)

 30304 +#ifndef SABER

 30305 +/* This hack is to avoid a problem with some strict ANSI C preprocessors.

 30306 +   The problem is, "32_" is not a valid preprocessing token, and we don't

 30307 +   want extra underscores (e.g., "nlm_32_").  The XCONCAT2 macro will

 30308 +   cause the inner CONCAT2 macros to be evaluated first, producing

 30309 +   still-valid pp-tokens.  Then the final concatenation can be done.  */

 30310 +#undef CONCAT4

 30311 +#define CONCAT4(a,b,c,d) XCONCAT2(CONCAT2(a,b),CONCAT2(c,d))

 30312 +#endif

 30313 +#endif

 30314 +

 30315 +/* This is a utility macro to handle the situation where the code

 30316 +   wants to place a constant string into the code, followed by a

 30317 +   comma and then the length of the string.  Doing this by hand

 30318 +   is error prone, so using this macro is safer.  The macro will

 30319 +   also safely handle the case where a NULL is passed as the arg.  */

 30320 +#define STRING_COMMA_LEN(STR) (STR), ((STR) ? sizeof (STR) - 1 : 0)

 30321 +/* Unfortunately it is not possible to use the STRING_COMMA_LEN macro

 30322 +   to create the arguments to another macro, since the preprocessor

 30323 +   will mis-count the number of arguments to the outer macro (by not

 30324 +   evaluating STRING_COMMA_LEN and so missing the comma).  This is a

 30325 +   problem for example when trying to use STRING_COMMA_LEN to build

 30326 +   the arguments to the strncmp() macro.  Hence this alternative

 30327 +   definition of strncmp is provided here.

 30328 +

 30329 +   Note - these macros do NOT work if STR2 is not a constant string.  */

 30330 +#define CONST_STRNEQ(STR1,STR2) (strncmp ((STR1), (STR2), sizeof (STR2) - 1) == 0)

 30331 +  /* strcpy() can have a similar problem, but since we know we are

 30332 +     copying a constant string, we can use memcpy which will be faster

 30333 +     since there is no need to check for a NUL byte inside STR.  We

 30334 +     can also save time if we do not need to copy the terminating NUL.  */

 30335 +#define LITMEMCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2) - 1)

 30336 +#define LITSTRCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2))

 30337 +

 30338 +

 30339 +/* The word size used by BFD on the host.  This may be 64 with a 32

 30340 +   bit target if the host is 64 bit, or if other 64 bit targets have

 30341 +   been selected with --enable-targets, or if --enable-64-bit-bfd.  */

 30342 +#define BFD_ARCH_SIZE 32

 30343 +

 30344 +/* The word size of the default bfd target.  */

 30345 +#define BFD_DEFAULT_TARGET_SIZE 32

 30346 +

 30347 +#define BFD_HOST_64BIT_LONG 0

 30348 +#define BFD_HOST_64BIT_LONG_LONG 0

 30349 +#define BFD_HOST_LONG_LONG 1

 30350 +#if 1

 30351 +#define BFD_HOST_64_BIT long long

 30352 +#define BFD_HOST_U_64_BIT unsigned long long

 30353 +typedef BFD_HOST_64_BIT bfd_int64_t;

 30354 +typedef BFD_HOST_U_64_BIT bfd_uint64_t;

 30355 +#endif

 30356 +

 30357 +#if BFD_ARCH_SIZE >= 64

 30358 +#define BFD64

 30359 +#endif

 30360 +

 30361 +#ifndef INLINE

 30362 +#if __GNUC__ >= 2

 30363 +#define INLINE __inline__

 30364 +#else

 30365 +#define INLINE

 30366 +#endif

 30367 +#endif

 30368 +

 30369 +/* Declaring a type wide enough to hold a host long and a host pointer.  */

 30370 +#define BFD_HOSTPTR_T	unsigned long

 30371 +typedef BFD_HOSTPTR_T bfd_hostptr_t;

 30372 +

 30373 +/* Forward declaration.  */

 30374 +typedef struct bfd bfd;

 30375 +

 30376 +/* Boolean type used in bfd.  Too many systems define their own

 30377 +   versions of "boolean" for us to safely typedef a "boolean" of

 30378 +   our own.  Using an enum for "bfd_boolean" has its own set of

 30379 +   problems, with strange looking casts required to avoid warnings

 30380 +   on some older compilers.  Thus we just use an int.

 30381 +

 30382 +   General rule: Functions which are bfd_boolean return TRUE on

 30383 +   success and FALSE on failure (unless they're a predicate).  */

 30384 +

 30385 +typedef int bfd_boolean;

 30386 +#undef FALSE

 30387 +#undef TRUE

 30388 +#define FALSE 0

 30389 +#define TRUE 1

 30390 +

 30391 +#ifdef BFD64

 30392 +

 30393 +#ifndef BFD_HOST_64_BIT

 30394 + #error No 64 bit integer type available

 30395 +#endif /* ! defined (BFD_HOST_64_BIT) */

 30396 +

 30397 +typedef BFD_HOST_U_64_BIT bfd_vma;

 30398 +typedef BFD_HOST_64_BIT bfd_signed_vma;

 30399 +typedef BFD_HOST_U_64_BIT bfd_size_type;

 30400 +typedef BFD_HOST_U_64_BIT symvalue;

 30401 +

 30402 +#ifndef fprintf_vma

 30403 +#if BFD_HOST_64BIT_LONG

 30404 +#define sprintf_vma(s,x) sprintf (s, "%016lx", x)

 30405 +#define fprintf_vma(f,x) fprintf (f, "%016lx", x)

 30406 +#elif BFD_HOST_64BIT_LONG_LONG

 30407 +#define sprintf_vma(s,x) sprintf (s, "%016llx", x)

 30408 +#define fprintf_vma(f,x) fprintf (f, "%016llx", x)

 30409 +#else

 30410 +#define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff)))

 30411 +#define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff))

 30412 +#define fprintf_vma(s,x) \

 30413 +  fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))

 30414 +#define sprintf_vma(s,x) \

 30415 +  sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))

 30416 +#endif

 30417 +#endif

 30418 +

 30419 +#else /* not BFD64  */

 30420 +

 30421 +/* Represent a target address.  Also used as a generic unsigned type

 30422 +   which is guaranteed to be big enough to hold any arithmetic types

 30423 +   we need to deal with.  */

 30424 +typedef unsigned long bfd_vma;

 30425 +

 30426 +/* A generic signed type which is guaranteed to be big enough to hold any

 30427 +   arithmetic types we need to deal with.  Can be assumed to be compatible

 30428 +   with bfd_vma in the same way that signed and unsigned ints are compatible

 30429 +   (as parameters, in assignment, etc).  */

 30430 +typedef long bfd_signed_vma;

 30431 +

 30432 +typedef unsigned long symvalue;

 30433 +typedef unsigned long bfd_size_type;

 30434 +

 30435 +/* Print a bfd_vma x on stream s.  */

 30436 +#define fprintf_vma(s,x) fprintf (s, "%08lx", x)

 30437 +#define sprintf_vma(s,x) sprintf (s, "%08lx", x)

 30438 +

 30439 +#endif /* not BFD64  */

 30440 +

 30441 +#define HALF_BFD_SIZE_TYPE \

 30442 +  (((bfd_size_type) 1) << (8 * sizeof (bfd_size_type) / 2))

 30443 +

 30444 +#ifndef BFD_HOST_64_BIT

 30445 +/* Fall back on a 32 bit type.  The idea is to make these types always

 30446 +   available for function return types, but in the case that

 30447 +   BFD_HOST_64_BIT is undefined such a function should abort or

 30448 +   otherwise signal an error.  */

 30449 +typedef bfd_signed_vma bfd_int64_t;

 30450 +typedef bfd_vma bfd_uint64_t;

 30451 +#endif

 30452 +

 30453 +/* An offset into a file.  BFD always uses the largest possible offset

 30454 +   based on the build time availability of fseek, fseeko, or fseeko64.  */

 30455 +typedef BFD_HOST_64_BIT file_ptr;

 30456 +typedef unsigned BFD_HOST_64_BIT ufile_ptr;

 30457 +

 30458 +extern void bfd_sprintf_vma (bfd *, char *, bfd_vma);

 30459 +extern void bfd_fprintf_vma (bfd *, void *, bfd_vma);

 30460 +

 30461 +#define printf_vma(x) fprintf_vma(stdout,x)

 30462 +#define bfd_printf_vma(abfd,x) bfd_fprintf_vma (abfd,stdout,x)

 30463 +

 30464 +typedef unsigned int flagword;	/* 32 bits of flags */

 30465 +typedef unsigned char bfd_byte;

 30466 +

 30467 +/* File formats.  */

 30468 +

 30469 +typedef enum bfd_format

 30470 +{

 30471 +  bfd_unknown = 0,	/* File format is unknown.  */

 30472 +  bfd_object,		/* Linker/assembler/compiler output.  */

 30473 +  bfd_archive,		/* Object archive file.  */

 30474 +  bfd_core,		/* Core dump.  */

 30475 +  bfd_type_end		/* Marks the end; don't use it!  */

 30476 +}

 30477 +bfd_format;

 30478 +

 30479 +/* Values that may appear in the flags field of a BFD.  These also

 30480 +   appear in the object_flags field of the bfd_target structure, where

 30481 +   they indicate the set of flags used by that backend (not all flags

 30482 +   are meaningful for all object file formats) (FIXME: at the moment,

 30483 +   the object_flags values have mostly just been copied from backend

 30484 +   to another, and are not necessarily correct).  */

 30485 +

 30486 +/* No flags.  */

 30487 +#define BFD_NO_FLAGS   	0x00

 30488 +

 30489 +/* BFD contains relocation entries.  */

 30490 +#define HAS_RELOC   	0x01

 30491 +

 30492 +/* BFD is directly executable.  */

 30493 +#define EXEC_P      	0x02

 30494 +

 30495 +/* BFD has line number information (basically used for F_LNNO in a

 30496 +   COFF header).  */

 30497 +#define HAS_LINENO  	0x04

 30498 +

 30499 +/* BFD has debugging information.  */

 30500 +#define HAS_DEBUG   	0x08

 30501 +

 30502 +/* BFD has symbols.  */

 30503 +#define HAS_SYMS    	0x10

 30504 +

 30505 +/* BFD has local symbols (basically used for F_LSYMS in a COFF

 30506 +   header).  */

 30507 +#define HAS_LOCALS  	0x20

 30508 +

 30509 +/* BFD is a dynamic object.  */

 30510 +#define DYNAMIC     	0x40

 30511 +

 30512 +/* Text section is write protected (if D_PAGED is not set, this is

 30513 +   like an a.out NMAGIC file) (the linker sets this by default, but

 30514 +   clears it for -r or -N).  */

 30515 +#define WP_TEXT     	0x80

 30516 +

 30517 +/* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the

 30518 +   linker sets this by default, but clears it for -r or -n or -N).  */

 30519 +#define D_PAGED     	0x100

 30520 +

 30521 +/* BFD is relaxable (this means that bfd_relax_section may be able to

 30522 +   do something) (sometimes bfd_relax_section can do something even if

 30523 +   this is not set).  */

 30524 +#define BFD_IS_RELAXABLE 0x200

 30525 +

 30526 +/* This may be set before writing out a BFD to request using a

 30527 +   traditional format.  For example, this is used to request that when

 30528 +   writing out an a.out object the symbols not be hashed to eliminate

 30529 +   duplicates.  */

 30530 +#define BFD_TRADITIONAL_FORMAT 0x400

 30531 +

 30532 +/* This flag indicates that the BFD contents are actually cached in

 30533 +   memory.  If this is set, iostream points to a bfd_in_memory struct.  */

 30534 +#define BFD_IN_MEMORY 0x800

 30535 +

 30536 +/* The sections in this BFD specify a memory page.  */

 30537 +#define HAS_LOAD_PAGE 0x1000

 30538 +

 30539 +/* This BFD has been created by the linker and doesn't correspond

 30540 +   to any input file.  */

 30541 +#define BFD_LINKER_CREATED 0x2000

 30542 +

 30543 +/* Symbols and relocation.  */

 30544 +

 30545 +/* A count of carsyms (canonical archive symbols).  */

 30546 +typedef unsigned long symindex;

 30547 +

 30548 +/* How to perform a relocation.  */

 30549 +typedef const struct reloc_howto_struct reloc_howto_type;

 30550 +

 30551 +#define BFD_NO_MORE_SYMBOLS ((symindex) ~0)

 30552 +

 30553 +/* General purpose part of a symbol X;

 30554 +   target specific parts are in libcoff.h, libaout.h, etc.  */

 30555 +

 30556 +#define bfd_get_section(x) ((x)->section)

 30557 +#define bfd_get_output_section(x) ((x)->section->output_section)

 30558 +#define bfd_set_section(x,y) ((x)->section) = (y)

 30559 +#define bfd_asymbol_base(x) ((x)->section->vma)

 30560 +#define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value)

 30561 +#define bfd_asymbol_name(x) ((x)->name)

 30562 +/*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/

 30563 +#define bfd_asymbol_bfd(x) ((x)->the_bfd)

 30564 +#define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour)

 30565 +

 30566 +/* A canonical archive symbol.  */

 30567 +/* This is a type pun with struct ranlib on purpose!  */

 30568 +typedef struct carsym

 30569 +{

 30570 +  char *name;

 30571 +  file_ptr file_offset;	/* Look here to find the file.  */

 30572 +}

 30573 +carsym;			/* To make these you call a carsymogen.  */

 30574 +

 30575 +/* Used in generating armaps (archive tables of contents).

 30576 +   Perhaps just a forward definition would do?  */

 30577 +struct orl 			/* Output ranlib.  */

 30578 +{

 30579 +  char **name;		/* Symbol name.  */

 30580 +  union

 30581 +  {

 30582 +    file_ptr pos;

 30583 +    bfd *abfd;

 30584 +  } u;			/* bfd* or file position.  */

 30585 +  int namidx;		/* Index into string table.  */

 30586 +};

 30587 +

 30588 +/* Linenumber stuff.  */

 30589 +typedef struct lineno_cache_entry

 30590 +{

 30591 +  unsigned int line_number;	/* Linenumber from start of function.  */

 30592 +  union

 30593 +  {

 30594 +    struct bfd_symbol *sym;	/* Function name.  */

 30595 +    bfd_vma offset;	    		/* Offset into section.  */

 30596 +  } u;

 30597 +}

 30598 +alent;

 30599 +

 30600 +/* Object and core file sections.  */

 30601 +

 30602 +#define	align_power(addr, align)	\

 30603 +  (((addr) + ((bfd_vma) 1 << (align)) - 1) & ((bfd_vma) -1 << (align)))

 30604 +

 30605 +typedef struct bfd_section *sec_ptr;

 30606 +

 30607 +#define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0)

 30608 +#define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0)

 30609 +#define bfd_get_section_lma(bfd, ptr) ((ptr)->lma + 0)

 30610 +#define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0)

 30611 +#define bfd_section_name(bfd, ptr) ((ptr)->name)

 30612 +#define bfd_section_size(bfd, ptr) ((ptr)->size)

 30613 +#define bfd_get_section_size(ptr) ((ptr)->size)

 30614 +#define bfd_section_vma(bfd, ptr) ((ptr)->vma)

 30615 +#define bfd_section_lma(bfd, ptr) ((ptr)->lma)

 30616 +#define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)

 30617 +#define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0)

 30618 +#define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)

 30619 +

 30620 +#define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)

 30621 +

 30622 +#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = TRUE), TRUE)

 30623 +#define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),TRUE)

 30624 +#define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),TRUE)

 30625 +/* Find the address one past the end of SEC.  */

 30626 +#define bfd_get_section_limit(bfd, sec) \

 30627 +  (((sec)->rawsize ? (sec)->rawsize : (sec)->size) \

 30628 +   / bfd_octets_per_byte (bfd))

 30629 +

 30630 +/* Return TRUE if section has been discarded.  */

 30631 +#define elf_discarded_section(sec)				\

 30632 +  (!bfd_is_abs_section (sec)					\

 30633 +   && bfd_is_abs_section ((sec)->output_section)		\

 30634 +   && (sec)->sec_info_type != ELF_INFO_TYPE_MERGE		\

 30635 +   && (sec)->sec_info_type != ELF_INFO_TYPE_JUST_SYMS)

 30636 +

 30637 +/* Forward define.  */

 30638 +struct stat;

 30639 +

 30640 +typedef enum bfd_print_symbol

 30641 +{

 30642 +  bfd_print_symbol_name,

 30643 +  bfd_print_symbol_more,

 30644 +  bfd_print_symbol_all

 30645 +} bfd_print_symbol_type;

 30646 +

 30647 +/* Information about a symbol that nm needs.  */

 30648 +

 30649 +typedef struct _symbol_info

 30650 +{

 30651 +  symvalue value;

 30652 +  char type;

 30653 +  const char *name;            /* Symbol name.  */

 30654 +  unsigned char stab_type;     /* Stab type.  */

 30655 +  char stab_other;             /* Stab other.  */

 30656 +  short stab_desc;             /* Stab desc.  */

 30657 +  const char *stab_name;       /* String for stab type.  */

 30658 +} symbol_info;

 30659 +

 30660 +/* Get the name of a stabs type code.  */

 30661 +

 30662 +extern const char *bfd_get_stab_name (int);

 30663 +

 30664 +/* Hash table routines.  There is no way to free up a hash table.  */

 30665 +

 30666 +/* An element in the hash table.  Most uses will actually use a larger

 30667 +   structure, and an instance of this will be the first field.  */

 30668 +

 30669 +struct bfd_hash_entry

 30670 +{

 30671 +  /* Next entry for this hash code.  */

 30672 +  struct bfd_hash_entry *next;

 30673 +  /* String being hashed.  */

 30674 +  const char *string;

 30675 +  /* Hash code.  This is the full hash code, not the index into the

 30676 +     table.  */

 30677 +  unsigned long hash;

 30678 +};

 30679 +

 30680 +/* A hash table.  */

 30681 +

 30682 +struct bfd_hash_table

 30683 +{

 30684 +  /* The hash array.  */

 30685 +  struct bfd_hash_entry **table;

 30686 +  /* A function used to create new elements in the hash table.  The

 30687 +     first entry is itself a pointer to an element.  When this

 30688 +     function is first invoked, this pointer will be NULL.  However,

 30689 +     having the pointer permits a hierarchy of method functions to be

 30690 +     built each of which calls the function in the superclass.  Thus

 30691 +     each function should be written to allocate a new block of memory

 30692 +     only if the argument is NULL.  */

 30693 +  struct bfd_hash_entry *(*newfunc)

 30694 +    (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);

 30695 +   /* An objalloc for this hash table.  This is a struct objalloc *,

 30696 +     but we use void * to avoid requiring the inclusion of objalloc.h.  */

 30697 +  void *memory;

 30698 +  /* The number of slots in the hash table.  */

 30699 +  unsigned int size;

 30700 +  /* The number of entries in the hash table.  */

 30701 +  unsigned int count;

 30702 +  /* The size of elements.  */

 30703 +  unsigned int entsize;

 30704 +  /* If non-zero, don't grow the hash table.  */

 30705 +  unsigned int frozen:1;

 30706 +};

 30707 +

 30708 +/* Initialize a hash table.  */

 30709 +extern bfd_boolean bfd_hash_table_init

 30710 +  (struct bfd_hash_table *,

 30711 +   struct bfd_hash_entry *(*) (struct bfd_hash_entry *,

 30712 +			       struct bfd_hash_table *,

 30713 +			       const char *),

 30714 +   unsigned int);

 30715 +

 30716 +/* Initialize a hash table specifying a size.  */

 30717 +extern bfd_boolean bfd_hash_table_init_n

 30718 +  (struct bfd_hash_table *,

 30719 +   struct bfd_hash_entry *(*) (struct bfd_hash_entry *,

 30720 +			       struct bfd_hash_table *,

 30721 +			       const char *),

 30722 +   unsigned int, unsigned int);

 30723 +

 30724 +/* Free up a hash table.  */

 30725 +extern void bfd_hash_table_free

 30726 +  (struct bfd_hash_table *);

 30727 +

 30728 +/* Look up a string in a hash table.  If CREATE is TRUE, a new entry

 30729 +   will be created for this string if one does not already exist.  The

 30730 +   COPY argument must be TRUE if this routine should copy the string

 30731 +   into newly allocated memory when adding an entry.  */

 30732 +extern struct bfd_hash_entry *bfd_hash_lookup

 30733 +  (struct bfd_hash_table *, const char *, bfd_boolean create,

 30734 +   bfd_boolean copy);

 30735 +

 30736 +/* Replace an entry in a hash table.  */

 30737 +extern void bfd_hash_replace

 30738 +  (struct bfd_hash_table *, struct bfd_hash_entry *old,

 30739 +   struct bfd_hash_entry *nw);

 30740 +

 30741 +/* Base method for creating a hash table entry.  */

 30742 +extern struct bfd_hash_entry *bfd_hash_newfunc

 30743 +  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);

 30744 +

 30745 +/* Grab some space for a hash table entry.  */

 30746 +extern void *bfd_hash_allocate

 30747 +  (struct bfd_hash_table *, unsigned int);

 30748 +

 30749 +/* Traverse a hash table in a random order, calling a function on each

 30750 +   element.  If the function returns FALSE, the traversal stops.  The

 30751 +   INFO argument is passed to the function.  */

 30752 +extern void bfd_hash_traverse

 30753 +  (struct bfd_hash_table *,

 30754 +   bfd_boolean (*) (struct bfd_hash_entry *, void *),

 30755 +   void *info);

 30756 +

 30757 +/* Allows the default size of a hash table to be configured. New hash

 30758 +   tables allocated using bfd_hash_table_init will be created with

 30759 +   this size.  */

 30760 +extern void bfd_hash_set_default_size (bfd_size_type);

 30761 +

 30762 +/* This structure is used to keep track of stabs in sections

 30763 +   information while linking.  */

 30764 +

 30765 +struct stab_info

 30766 +{

 30767 +  /* A hash table used to hold stabs strings.  */

 30768 +  struct bfd_strtab_hash *strings;

 30769 +  /* The header file hash table.  */

 30770 +  struct bfd_hash_table includes;

 30771 +  /* The first .stabstr section.  */

 30772 +  struct bfd_section *stabstr;

 30773 +};

 30774 +

 30775 +#define COFF_SWAP_TABLE (void *) &bfd_coff_std_swap_table

 30776 +

 30777 +/* User program access to BFD facilities.  */

 30778 +

 30779 +/* Direct I/O routines, for programs which know more about the object

 30780 +   file than BFD does.  Use higher level routines if possible.  */

 30781 +

 30782 +extern bfd_size_type bfd_bread (void *, bfd_size_type, bfd *);

 30783 +extern bfd_size_type bfd_bwrite (const void *, bfd_size_type, bfd *);

 30784 +extern int bfd_seek (bfd *, file_ptr, int);

 30785 +extern file_ptr bfd_tell (bfd *);

 30786 +extern int bfd_flush (bfd *);

 30787 +extern int bfd_stat (bfd *, struct stat *);

 30788 +

 30789 +/* Deprecated old routines.  */

 30790 +#if __GNUC__

 30791 +#define bfd_read(BUF, ELTSIZE, NITEMS, ABFD)				\

 30792 +  (warn_deprecated ("bfd_read", __FILE__, __LINE__, __FUNCTION__),	\

 30793 +   bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))

 30794 +#define bfd_write(BUF, ELTSIZE, NITEMS, ABFD)				\

 30795 +  (warn_deprecated ("bfd_write", __FILE__, __LINE__, __FUNCTION__),	\

 30796 +   bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))

 30797 +#else

 30798 +#define bfd_read(BUF, ELTSIZE, NITEMS, ABFD)				\

 30799 +  (warn_deprecated ("bfd_read", (const char *) 0, 0, (const char *) 0), \

 30800 +   bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))

 30801 +#define bfd_write(BUF, ELTSIZE, NITEMS, ABFD)				\

 30802 +  (warn_deprecated ("bfd_write", (const char *) 0, 0, (const char *) 0),\

 30803 +   bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))

 30804 +#endif

 30805 +extern void warn_deprecated (const char *, const char *, int, const char *);

 30806 +

 30807 +/* Cast from const char * to char * so that caller can assign to

 30808 +   a char * without a warning.  */

 30809 +#define bfd_get_filename(abfd) ((char *) (abfd)->filename)

 30810 +#define bfd_get_cacheable(abfd) ((abfd)->cacheable)

 30811 +#define bfd_get_format(abfd) ((abfd)->format)

 30812 +#define bfd_get_target(abfd) ((abfd)->xvec->name)

 30813 +#define bfd_get_flavour(abfd) ((abfd)->xvec->flavour)

 30814 +#define bfd_family_coff(abfd) \

 30815 +  (bfd_get_flavour (abfd) == bfd_target_coff_flavour || \

 30816 +   bfd_get_flavour (abfd) == bfd_target_xcoff_flavour)

 30817 +#define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)

 30818 +#define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE)

 30819 +#define bfd_header_big_endian(abfd) \

 30820 +  ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG)

 30821 +#define bfd_header_little_endian(abfd) \

 30822 +  ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE)

 30823 +#define bfd_get_file_flags(abfd) ((abfd)->flags)

 30824 +#define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)

 30825 +#define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)

 30826 +#define bfd_my_archive(abfd) ((abfd)->my_archive)

 30827 +#define bfd_has_map(abfd) ((abfd)->has_armap)

 30828 +

 30829 +#define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)

 30830 +#define bfd_usrdata(abfd) ((abfd)->usrdata)

 30831 +

 30832 +#define bfd_get_start_address(abfd) ((abfd)->start_address)

 30833 +#define bfd_get_symcount(abfd) ((abfd)->symcount)

 30834 +#define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)

 30835 +#define bfd_count_sections(abfd) ((abfd)->section_count)

 30836 +

 30837 +#define bfd_get_dynamic_symcount(abfd) ((abfd)->dynsymcount)

 30838 +

 30839 +#define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char)

 30840 +

 30841 +#define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = bool), TRUE)

 30842 +

 30843 +extern bfd_boolean bfd_cache_close

 30844 +  (bfd *abfd);

 30845 +/* NB: This declaration should match the autogenerated one in libbfd.h.  */

 30846 +

 30847 +extern bfd_boolean bfd_cache_close_all (void);

 30848 +

 30849 +extern bfd_boolean bfd_record_phdr

 30850 +  (bfd *, unsigned long, bfd_boolean, flagword, bfd_boolean, bfd_vma,

 30851 +   bfd_boolean, bfd_boolean, unsigned int, struct bfd_section **);

 30852 +

 30853 +/* Byte swapping routines.  */

 30854 +

 30855 +bfd_uint64_t bfd_getb64 (const void *);

 30856 +bfd_uint64_t bfd_getl64 (const void *);

 30857 +bfd_int64_t bfd_getb_signed_64 (const void *);

 30858 +bfd_int64_t bfd_getl_signed_64 (const void *);

 30859 +bfd_vma bfd_getb32 (const void *);

 30860 +bfd_vma bfd_getl32 (const void *);

 30861 +bfd_signed_vma bfd_getb_signed_32 (const void *);

 30862 +bfd_signed_vma bfd_getl_signed_32 (const void *);

 30863 +bfd_vma bfd_getb16 (const void *);

 30864 +bfd_vma bfd_getl16 (const void *);

 30865 +bfd_signed_vma bfd_getb_signed_16 (const void *);

 30866 +bfd_signed_vma bfd_getl_signed_16 (const void *);

 30867 +void bfd_putb64 (bfd_uint64_t, void *);

 30868 +void bfd_putl64 (bfd_uint64_t, void *);

 30869 +void bfd_putb32 (bfd_vma, void *);

 30870 +void bfd_putl32 (bfd_vma, void *);

 30871 +void bfd_putb16 (bfd_vma, void *);

 30872 +void bfd_putl16 (bfd_vma, void *);

 30873 +

 30874 +/* Byte swapping routines which take size and endiannes as arguments.  */

 30875 +

 30876 +bfd_uint64_t bfd_get_bits (const void *, int, bfd_boolean);

 30877 +void bfd_put_bits (bfd_uint64_t, void *, int, bfd_boolean);

 30878 +

 30879 +extern bfd_boolean bfd_section_already_linked_table_init (void);

 30880 +extern void bfd_section_already_linked_table_free (void);

 30881 +

 30882 +/* Externally visible ECOFF routines.  */

 30883 +

 30884 +#if defined(__STDC__) || defined(ALMOST_STDC)

 30885 +struct ecoff_debug_info;

 30886 +struct ecoff_debug_swap;

 30887 +struct ecoff_extr;

 30888 +struct bfd_symbol;

 30889 +struct bfd_link_info;

 30890 +struct bfd_link_hash_entry;

 30891 +struct bfd_elf_version_tree;

 30892 +#endif

 30893 +extern bfd_vma bfd_ecoff_get_gp_value

 30894 +  (bfd * abfd);

 30895 +extern bfd_boolean bfd_ecoff_set_gp_value

 30896 +  (bfd *abfd, bfd_vma gp_value);

 30897 +extern bfd_boolean bfd_ecoff_set_regmasks

 30898 +  (bfd *abfd, unsigned long gprmask, unsigned long fprmask,

 30899 +   unsigned long *cprmask);

 30900 +extern void *bfd_ecoff_debug_init

 30901 +  (bfd *output_bfd, struct ecoff_debug_info *output_debug,

 30902 +   const struct ecoff_debug_swap *output_swap, struct bfd_link_info *);

 30903 +extern void bfd_ecoff_debug_free

 30904 +  (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,

 30905 +   const struct ecoff_debug_swap *output_swap, struct bfd_link_info *);

 30906 +extern bfd_boolean bfd_ecoff_debug_accumulate

 30907 +  (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,

 30908 +   const struct ecoff_debug_swap *output_swap, bfd *input_bfd,

 30909 +   struct ecoff_debug_info *input_debug,

 30910 +   const struct ecoff_debug_swap *input_swap, struct bfd_link_info *);

 30911 +extern bfd_boolean bfd_ecoff_debug_accumulate_other

 30912 +  (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,

 30913 +   const struct ecoff_debug_swap *output_swap, bfd *input_bfd,

 30914 +   struct bfd_link_info *);

 30915 +extern bfd_boolean bfd_ecoff_debug_externals

 30916 +  (bfd *abfd, struct ecoff_debug_info *debug,

 30917 +   const struct ecoff_debug_swap *swap, bfd_boolean relocatable,

 30918 +   bfd_boolean (*get_extr) (struct bfd_symbol *, struct ecoff_extr *),

 30919 +   void (*set_index) (struct bfd_symbol *, bfd_size_type));

 30920 +extern bfd_boolean bfd_ecoff_debug_one_external

 30921 +  (bfd *abfd, struct ecoff_debug_info *debug,

 30922 +   const struct ecoff_debug_swap *swap, const char *name,

 30923 +   struct ecoff_extr *esym);

 30924 +extern bfd_size_type bfd_ecoff_debug_size

 30925 +  (bfd *abfd, struct ecoff_debug_info *debug,

 30926 +   const struct ecoff_debug_swap *swap);

 30927 +extern bfd_boolean bfd_ecoff_write_debug

 30928 +  (bfd *abfd, struct ecoff_debug_info *debug,

 30929 +   const struct ecoff_debug_swap *swap, file_ptr where);

 30930 +extern bfd_boolean bfd_ecoff_write_accumulated_debug

 30931 +  (void *handle, bfd *abfd, struct ecoff_debug_info *debug,

 30932 +   const struct ecoff_debug_swap *swap,

 30933 +   struct bfd_link_info *info, file_ptr where);

 30934 +

 30935 +/* Externally visible ELF routines.  */

 30936 +

 30937 +struct bfd_link_needed_list

 30938 +{

 30939 +  struct bfd_link_needed_list *next;

 30940 +  bfd *by;

 30941 +  const char *name;

 30942 +};

 30943 +

 30944 +enum dynamic_lib_link_class {

 30945 +  DYN_NORMAL = 0,

 30946 +  DYN_AS_NEEDED = 1,

 30947 +  DYN_DT_NEEDED = 2,

 30948 +  DYN_NO_ADD_NEEDED = 4,

 30949 +  DYN_NO_NEEDED = 8

 30950 +};

 30951 +

 30952 +enum notice_asneeded_action {

 30953 +  notice_as_needed,

 30954 +  notice_not_needed,

 30955 +  notice_needed

 30956 +};

 30957 +

 30958 +extern bfd_boolean bfd_elf_record_link_assignment

 30959 +  (bfd *, struct bfd_link_info *, const char *, bfd_boolean,

 30960 +   bfd_boolean);

 30961 +extern struct bfd_link_needed_list *bfd_elf_get_needed_list

 30962 +  (bfd *, struct bfd_link_info *);

 30963 +extern bfd_boolean bfd_elf_get_bfd_needed_list

 30964 +  (bfd *, struct bfd_link_needed_list **);

 30965 +extern bfd_boolean bfd_elf_size_dynamic_sections

 30966 +  (bfd *, const char *, const char *, const char *, const char * const *,

 30967 +   struct bfd_link_info *, struct bfd_section **,

 30968 +   struct bfd_elf_version_tree *);

 30969 +extern bfd_boolean bfd_elf_size_dynsym_hash_dynstr

 30970 +  (bfd *, struct bfd_link_info *);

 30971 +extern void bfd_elf_set_dt_needed_name

 30972 +  (bfd *, const char *);

 30973 +extern const char *bfd_elf_get_dt_soname

 30974 +  (bfd *);

 30975 +extern void bfd_elf_set_dyn_lib_class

 30976 +  (bfd *, enum dynamic_lib_link_class);

 30977 +extern int bfd_elf_get_dyn_lib_class

 30978 +  (bfd *);

 30979 +extern struct bfd_link_needed_list *bfd_elf_get_runpath_list

 30980 +  (bfd *, struct bfd_link_info *);

 30981 +extern bfd_boolean bfd_elf_discard_info

 30982 +  (bfd *, struct bfd_link_info *);

 30983 +extern unsigned int _bfd_elf_default_action_discarded

 30984 +  (struct bfd_section *);

 30985 +

 30986 +/* Return an upper bound on the number of bytes required to store a

 30987 +   copy of ABFD's program header table entries.  Return -1 if an error

 30988 +   occurs; bfd_get_error will return an appropriate code.  */

 30989 +extern long bfd_get_elf_phdr_upper_bound

 30990 +  (bfd *abfd);

 30991 +

 30992 +/* Copy ABFD's program header table entries to *PHDRS.  The entries

 30993 +   will be stored as an array of Elf_Internal_Phdr structures, as

 30994 +   defined in include/elf/internal.h.  To find out how large the

 30995 +   buffer needs to be, call bfd_get_elf_phdr_upper_bound.

 30996 +

 30997 +   Return the number of program header table entries read, or -1 if an

 30998 +   error occurs; bfd_get_error will return an appropriate code.  */

 30999 +extern int bfd_get_elf_phdrs

 31000 +  (bfd *abfd, void *phdrs);

 31001 +

 31002 +/* Create a new BFD as if by bfd_openr.  Rather than opening a file,

 31003 +   reconstruct an ELF file by reading the segments out of remote memory

 31004 +   based on the ELF file header at EHDR_VMA and the ELF program headers it

 31005 +   points to.  If not null, *LOADBASEP is filled in with the difference

 31006 +   between the VMAs from which the segments were read, and the VMAs the

 31007 +   file headers (and hence BFD's idea of each section's VMA) put them at.

 31008 +

 31009 +   The function TARGET_READ_MEMORY is called to copy LEN bytes from the

 31010 +   remote memory at target address VMA into the local buffer at MYADDR; it

 31011 +   should return zero on success or an `errno' code on failure.  TEMPL must

 31012 +   be a BFD for an ELF target with the word size and byte order found in

 31013 +   the remote memory.  */

 31014 +extern bfd *bfd_elf_bfd_from_remote_memory

 31015 +  (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,

 31016 +   int (*target_read_memory) (bfd_vma vma, bfd_byte *myaddr, int len));

 31017 +

 31018 +/* Return the arch_size field of an elf bfd, or -1 if not elf.  */

 31019 +extern int bfd_get_arch_size

 31020 +  (bfd *);

 31021 +

 31022 +/* Return TRUE if address "naturally" sign extends, or -1 if not elf.  */

 31023 +extern int bfd_get_sign_extend_vma

 31024 +  (bfd *);

 31025 +

 31026 +extern struct bfd_section *_bfd_elf_tls_setup

 31027 +  (bfd *, struct bfd_link_info *);

 31028 +

 31029 +extern void _bfd_fix_excluded_sec_syms

 31030 +  (bfd *, struct bfd_link_info *);

 31031 +

 31032 +extern unsigned bfd_m68k_mach_to_features (int);

 31033 +

 31034 +extern int bfd_m68k_features_to_mach (unsigned);

 31035 +

 31036 +extern bfd_boolean bfd_m68k_elf32_create_embedded_relocs

 31037 +  (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *,

 31038 +   char **);

 31039 +

 31040 +extern bfd_boolean bfd_bfin_elf32_create_embedded_relocs

 31041 +  (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *,

 31042 +   char **);

 31043 +

 31044 +/* SunOS shared library support routines for the linker.  */

 31045 +

 31046 +extern struct bfd_link_needed_list *bfd_sunos_get_needed_list

 31047 +  (bfd *, struct bfd_link_info *);

 31048 +extern bfd_boolean bfd_sunos_record_link_assignment

 31049 +  (bfd *, struct bfd_link_info *, const char *);

 31050 +extern bfd_boolean bfd_sunos_size_dynamic_sections

 31051 +  (bfd *, struct bfd_link_info *, struct bfd_section **,

 31052 +   struct bfd_section **, struct bfd_section **);

 31053 +

 31054 +/* Linux shared library support routines for the linker.  */

 31055 +

 31056 +extern bfd_boolean bfd_i386linux_size_dynamic_sections

 31057 +  (bfd *, struct bfd_link_info *);

 31058 +extern bfd_boolean bfd_m68klinux_size_dynamic_sections

 31059 +  (bfd *, struct bfd_link_info *);

 31060 +extern bfd_boolean bfd_sparclinux_size_dynamic_sections

 31061 +  (bfd *, struct bfd_link_info *);

 31062 +

 31063 +/* mmap hacks */

 31064 +

 31065 +struct _bfd_window_internal;

 31066 +typedef struct _bfd_window_internal bfd_window_internal;

 31067 +

 31068 +typedef struct _bfd_window

 31069 +{

 31070 +  /* What the user asked for.  */

 31071 +  void *data;

 31072 +  bfd_size_type size;

 31073 +  /* The actual window used by BFD.  Small user-requested read-only

 31074 +     regions sharing a page may share a single window into the object

 31075 +     file.  Read-write versions shouldn't until I've fixed things to

 31076 +     keep track of which portions have been claimed by the

 31077 +     application; don't want to give the same region back when the

 31078 +     application wants two writable copies!  */

 31079 +  struct _bfd_window_internal *i;

 31080 +}

 31081 +bfd_window;

 31082 +

 31083 +extern void bfd_init_window

 31084 +  (bfd_window *);

 31085 +extern void bfd_free_window

 31086 +  (bfd_window *);

 31087 +extern bfd_boolean bfd_get_file_window

 31088 +  (bfd *, file_ptr, bfd_size_type, bfd_window *, bfd_boolean);

 31089 +

 31090 +/* XCOFF support routines for the linker.  */

 31091 +

 31092 +extern bfd_boolean bfd_xcoff_link_record_set

 31093 +  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_size_type);

 31094 +extern bfd_boolean bfd_xcoff_import_symbol

 31095 +  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_vma,

 31096 +   const char *, const char *, const char *, unsigned int);

 31097 +extern bfd_boolean bfd_xcoff_export_symbol

 31098 +  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *);

 31099 +extern bfd_boolean bfd_xcoff_link_count_reloc

 31100 +  (bfd *, struct bfd_link_info *, const char *);

 31101 +extern bfd_boolean bfd_xcoff_record_link_assignment

 31102 +  (bfd *, struct bfd_link_info *, const char *);

 31103 +extern bfd_boolean bfd_xcoff_size_dynamic_sections

 31104 +  (bfd *, struct bfd_link_info *, const char *, const char *,

 31105 +   unsigned long, unsigned long, unsigned long, bfd_boolean,

 31106 +   int, bfd_boolean, bfd_boolean, struct bfd_section **, bfd_boolean);

 31107 +extern bfd_boolean bfd_xcoff_link_generate_rtinit

 31108 +  (bfd *, const char *, const char *, bfd_boolean);

 31109 +

 31110 +/* XCOFF support routines for ar.  */

 31111 +extern bfd_boolean bfd_xcoff_ar_archive_set_magic

 31112 +  (bfd *, char *);

 31113 +

 31114 +/* Externally visible COFF routines.  */

 31115 +

 31116 +#if defined(__STDC__) || defined(ALMOST_STDC)

 31117 +struct internal_syment;

 31118 +union internal_auxent;

 31119 +#endif

 31120 +

 31121 +extern bfd_boolean bfd_coff_get_syment

 31122 +  (bfd *, struct bfd_symbol *, struct internal_syment *);

 31123 +

 31124 +extern bfd_boolean bfd_coff_get_auxent

 31125 +  (bfd *, struct bfd_symbol *, int, union internal_auxent *);

 31126 +

 31127 +extern bfd_boolean bfd_coff_set_symbol_class

 31128 +  (bfd *, struct bfd_symbol *, unsigned int);

 31129 +

 31130 +extern bfd_boolean bfd_m68k_coff_create_embedded_relocs

 31131 +  (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, char **);

 31132 +

 31133 +/* ARM VFP11 erratum workaround support.  */

 31134 +typedef enum

 31135 +{

 31136 +  BFD_ARM_VFP11_FIX_DEFAULT,

 31137 +  BFD_ARM_VFP11_FIX_NONE,

 31138 +  BFD_ARM_VFP11_FIX_SCALAR,

 31139 +  BFD_ARM_VFP11_FIX_VECTOR

 31140 +} bfd_arm_vfp11_fix;

 31141 +

 31142 +extern void bfd_elf32_arm_init_maps

 31143 +  (bfd *);

 31144 +

 31145 +extern void bfd_elf32_arm_set_vfp11_fix

 31146 +  (bfd *, struct bfd_link_info *);

 31147 +

 31148 +extern bfd_boolean bfd_elf32_arm_vfp11_erratum_scan

 31149 +  (bfd *, struct bfd_link_info *);

 31150 +

 31151 +extern void bfd_elf32_arm_vfp11_fix_veneer_locations

 31152 +  (bfd *, struct bfd_link_info *);

 31153 +

 31154 +/* ARM Interworking support.  Called from linker.  */

 31155 +extern bfd_boolean bfd_arm_allocate_interworking_sections

 31156 +  (struct bfd_link_info *);

 31157 +

 31158 +extern bfd_boolean bfd_arm_process_before_allocation

 31159 +  (bfd *, struct bfd_link_info *, int);

 31160 +

 31161 +extern bfd_boolean bfd_arm_get_bfd_for_interworking

 31162 +  (bfd *, struct bfd_link_info *);

 31163 +

 31164 +/* PE ARM Interworking support.  Called from linker.  */

 31165 +extern bfd_boolean bfd_arm_pe_allocate_interworking_sections

 31166 +  (struct bfd_link_info *);

 31167 +

 31168 +extern bfd_boolean bfd_arm_pe_process_before_allocation

 31169 +  (bfd *, struct bfd_link_info *, int);

 31170 +

 31171 +extern bfd_boolean bfd_arm_pe_get_bfd_for_interworking

 31172 +  (bfd *, struct bfd_link_info *);

 31173 +

 31174 +/* ELF ARM Interworking support.  Called from linker.  */

 31175 +extern bfd_boolean bfd_elf32_arm_allocate_interworking_sections

 31176 +  (struct bfd_link_info *);

 31177 +

 31178 +extern bfd_boolean bfd_elf32_arm_process_before_allocation

 31179 +  (bfd *, struct bfd_link_info *);

 31180 +

 31181 +void bfd_elf32_arm_set_target_relocs

 31182 +  (bfd *, struct bfd_link_info *, int, char *, int, int, bfd_arm_vfp11_fix,

 31183 +   int, int);

 31184 +

 31185 +extern bfd_boolean bfd_elf32_arm_get_bfd_for_interworking

 31186 +  (bfd *, struct bfd_link_info *);

 31187 +

 31188 +extern bfd_boolean bfd_elf32_arm_add_glue_sections_to_bfd

 31189 +  (bfd *, struct bfd_link_info *);

 31190 +

 31191 +/* ELF ARM mapping symbol support */

 31192 +#define BFD_ARM_SPECIAL_SYM_TYPE_MAP	(1 << 0)

 31193 +#define BFD_ARM_SPECIAL_SYM_TYPE_TAG	(1 << 1)

 31194 +#define BFD_ARM_SPECIAL_SYM_TYPE_OTHER  (1 << 2)

 31195 +#define BFD_ARM_SPECIAL_SYM_TYPE_ANY	(~0)

 31196 +extern bfd_boolean bfd_is_arm_special_symbol_name

 31197 +  (const char * name, int type);

 31198 +

 31199 +extern void bfd_elf32_arm_set_byteswap_code (struct bfd_link_info *, int);

 31200 +

 31201 +/* ARM Note section processing.  */

 31202 +extern bfd_boolean bfd_arm_merge_machines

 31203 +  (bfd *, bfd *);

 31204 +

 31205 +extern bfd_boolean bfd_arm_update_notes

 31206 +  (bfd *, const char *);

 31207 +

 31208 +extern unsigned int bfd_arm_get_mach_from_notes

 31209 +  (bfd *, const char *);

 31210 +

 31211 +/* TI COFF load page support.  */

 31212 +extern void bfd_ticoff_set_section_load_page

 31213 +  (struct bfd_section *, int);

 31214 +

 31215 +extern int bfd_ticoff_get_section_load_page

 31216 +  (struct bfd_section *);

 31217 +

 31218 +/* H8/300 functions.  */

 31219 +extern bfd_vma bfd_h8300_pad_address

 31220 +  (bfd *, bfd_vma);

 31221 +

 31222 +/* IA64 Itanium code generation.  Called from linker.  */

 31223 +extern void bfd_elf32_ia64_after_parse

 31224 +  (int);

 31225 +

 31226 +extern void bfd_elf64_ia64_after_parse

 31227 +  (int);

 31228 +

 31229 +/* This structure is used for a comdat section, as in PE.  A comdat

 31230 +   section is associated with a particular symbol.  When the linker

 31231 +   sees a comdat section, it keeps only one of the sections with a

 31232 +   given name and associated with a given symbol.  */

 31233 +

 31234 +struct coff_comdat_info

 31235 +{

 31236 +  /* The name of the symbol associated with a comdat section.  */

 31237 +  const char *name;

 31238 +

 31239 +  /* The local symbol table index of the symbol associated with a

 31240 +     comdat section.  This is only meaningful to the object file format

 31241 +     specific code; it is not an index into the list returned by

 31242 +     bfd_canonicalize_symtab.  */

 31243 +  long symbol;

 31244 +};

 31245 +

 31246 +extern struct coff_comdat_info *bfd_coff_get_comdat_section

 31247 +  (bfd *, struct bfd_section *);

 31248 +

 31249 +/* Extracted from init.c.  */

 31250 +void bfd_init (void);

 31251 +

 31252 +/* Extracted from opncls.c.  */

 31253 +bfd *bfd_fopen (const char *filename, const char *target,

 31254 +    const char *mode, int fd);

 31255 +

 31256 +bfd *bfd_openr (const char *filename, const char *target);

 31257 +

 31258 +bfd *bfd_fdopenr (const char *filename, const char *target, int fd);

 31259 +

 31260 +bfd *bfd_openstreamr (const char *, const char *, void *);

 31261 +

 31262 +bfd *bfd_openr_iovec (const char *filename, const char *target,

 31263 +    void *(*open) (struct bfd *nbfd,

 31264 +    void *open_closure),

 31265 +    void *open_closure,

 31266 +    file_ptr (*pread) (struct bfd *nbfd,

 31267 +    void *stream,

 31268 +    void *buf,

 31269 +    file_ptr nbytes,

 31270 +    file_ptr offset),

 31271 +    int (*close) (struct bfd *nbfd,

 31272 +    void *stream),

 31273 +    int (*stat) (struct bfd *abfd,

 31274 +    void *stream,

 31275 +    struct stat *sb));

 31276 +

 31277 +bfd *bfd_openw (const char *filename, const char *target);

 31278 +

 31279 +bfd_boolean bfd_close (bfd *abfd);

 31280 +

 31281 +bfd_boolean bfd_close_all_done (bfd *);

 31282 +

 31283 +bfd *bfd_create (const char *filename, bfd *templ);

 31284 +

 31285 +bfd_boolean bfd_make_writable (bfd *abfd);

 31286 +

 31287 +bfd_boolean bfd_make_readable (bfd *abfd);

 31288 +

 31289 +unsigned long bfd_calc_gnu_debuglink_crc32

 31290 +   (unsigned long crc, const unsigned char *buf, bfd_size_type len);

 31291 +

 31292 +char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);

 31293 +

 31294 +struct bfd_section *bfd_create_gnu_debuglink_section

 31295 +   (bfd *abfd, const char *filename);

 31296 +

 31297 +bfd_boolean bfd_fill_in_gnu_debuglink_section

 31298 +   (bfd *abfd, struct bfd_section *sect, const char *filename);

 31299 +

 31300 +/* Extracted from libbfd.c.  */

 31301 +

 31302 +/* Byte swapping macros for user section data.  */

 31303 +

 31304 +#define bfd_put_8(abfd, val, ptr) \

 31305 +  ((void) (*((unsigned char *) (ptr)) = (val) & 0xff))

 31306 +#define bfd_put_signed_8 \

 31307 +  bfd_put_8

 31308 +#define bfd_get_8(abfd, ptr) \

 31309 +  (*(unsigned char *) (ptr) & 0xff)

 31310 +#define bfd_get_signed_8(abfd, ptr) \

 31311 +  (((*(unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)

 31312 +

 31313 +#define bfd_put_16(abfd, val, ptr) \

 31314 +  BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))

 31315 +#define bfd_put_signed_16 \

 31316 +  bfd_put_16

 31317 +#define bfd_get_16(abfd, ptr) \

 31318 +  BFD_SEND (abfd, bfd_getx16, (ptr))

 31319 +#define bfd_get_signed_16(abfd, ptr) \

 31320 +  BFD_SEND (abfd, bfd_getx_signed_16, (ptr))

 31321 +

 31322 +#define bfd_put_32(abfd, val, ptr) \

 31323 +  BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))

 31324 +#define bfd_put_signed_32 \

 31325 +  bfd_put_32

 31326 +#define bfd_get_32(abfd, ptr) \

 31327 +  BFD_SEND (abfd, bfd_getx32, (ptr))

 31328 +#define bfd_get_signed_32(abfd, ptr) \

 31329 +  BFD_SEND (abfd, bfd_getx_signed_32, (ptr))

 31330 +

 31331 +#define bfd_put_64(abfd, val, ptr) \

 31332 +  BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))

 31333 +#define bfd_put_signed_64 \

 31334 +  bfd_put_64

 31335 +#define bfd_get_64(abfd, ptr) \

 31336 +  BFD_SEND (abfd, bfd_getx64, (ptr))

 31337 +#define bfd_get_signed_64(abfd, ptr) \

 31338 +  BFD_SEND (abfd, bfd_getx_signed_64, (ptr))

 31339 +

 31340 +#define bfd_get(bits, abfd, ptr)                       \

 31341 +  ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr)       \

 31342 +   : (bits) == 16 ? bfd_get_16 (abfd, ptr)             \

 31343 +   : (bits) == 32 ? bfd_get_32 (abfd, ptr)             \

 31344 +   : (bits) == 64 ? bfd_get_64 (abfd, ptr)             \

 31345 +   : (abort (), (bfd_vma) - 1))

 31346 +

 31347 +#define bfd_put(bits, abfd, val, ptr)                  \

 31348 +  ((bits) == 8 ? bfd_put_8  (abfd, val, ptr)           \

 31349 +   : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)                \

 31350 +   : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)                \

 31351 +   : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)                \

 31352 +   : (abort (), (void) 0))

 31353 +

 31354 +

 31355 +/* Byte swapping macros for file header data.  */

 31356 +

 31357 +#define bfd_h_put_8(abfd, val, ptr) \

 31358 +  bfd_put_8 (abfd, val, ptr)

 31359 +#define bfd_h_put_signed_8(abfd, val, ptr) \

 31360 +  bfd_put_8 (abfd, val, ptr)

 31361 +#define bfd_h_get_8(abfd, ptr) \

 31362 +  bfd_get_8 (abfd, ptr)

 31363 +#define bfd_h_get_signed_8(abfd, ptr) \

 31364 +  bfd_get_signed_8 (abfd, ptr)

 31365 +

 31366 +#define bfd_h_put_16(abfd, val, ptr) \

 31367 +  BFD_SEND (abfd, bfd_h_putx16, (val, ptr))

 31368 +#define bfd_h_put_signed_16 \

 31369 +  bfd_h_put_16

 31370 +#define bfd_h_get_16(abfd, ptr) \

 31371 +  BFD_SEND (abfd, bfd_h_getx16, (ptr))

 31372 +#define bfd_h_get_signed_16(abfd, ptr) \

 31373 +  BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))

 31374 +

 31375 +#define bfd_h_put_32(abfd, val, ptr) \

 31376 +  BFD_SEND (abfd, bfd_h_putx32, (val, ptr))

 31377 +#define bfd_h_put_signed_32 \

 31378 +  bfd_h_put_32

 31379 +#define bfd_h_get_32(abfd, ptr) \

 31380 +  BFD_SEND (abfd, bfd_h_getx32, (ptr))

 31381 +#define bfd_h_get_signed_32(abfd, ptr) \

 31382 +  BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))

 31383 +

 31384 +#define bfd_h_put_64(abfd, val, ptr) \

 31385 +  BFD_SEND (abfd, bfd_h_putx64, (val, ptr))

 31386 +#define bfd_h_put_signed_64 \

 31387 +  bfd_h_put_64

 31388 +#define bfd_h_get_64(abfd, ptr) \

 31389 +  BFD_SEND (abfd, bfd_h_getx64, (ptr))

 31390 +#define bfd_h_get_signed_64(abfd, ptr) \

 31391 +  BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))

 31392 +

 31393 +/* Aliases for the above, which should eventually go away.  */

 31394 +

 31395 +#define H_PUT_64  bfd_h_put_64

 31396 +#define H_PUT_32  bfd_h_put_32

 31397 +#define H_PUT_16  bfd_h_put_16

 31398 +#define H_PUT_8   bfd_h_put_8

 31399 +#define H_PUT_S64 bfd_h_put_signed_64

 31400 +#define H_PUT_S32 bfd_h_put_signed_32

 31401 +#define H_PUT_S16 bfd_h_put_signed_16

 31402 +#define H_PUT_S8  bfd_h_put_signed_8

 31403 +#define H_GET_64  bfd_h_get_64

 31404 +#define H_GET_32  bfd_h_get_32

 31405 +#define H_GET_16  bfd_h_get_16

 31406 +#define H_GET_8   bfd_h_get_8

 31407 +#define H_GET_S64 bfd_h_get_signed_64

 31408 +#define H_GET_S32 bfd_h_get_signed_32

 31409 +#define H_GET_S16 bfd_h_get_signed_16

 31410 +#define H_GET_S8  bfd_h_get_signed_8

 31411 +

 31412 +

 31413 +/* Extracted from bfdio.c.  */

 31414 +long bfd_get_mtime (bfd *abfd);

 31415 +

 31416 +file_ptr bfd_get_size (bfd *abfd);

 31417 +

 31418 +/* Extracted from bfdwin.c.  */

 31419 +/* Extracted from section.c.  */

 31420 +typedef struct bfd_section

 31421 +{

 31422 +  /* The name of the section; the name isn't a copy, the pointer is

 31423 +     the same as that passed to bfd_make_section.  */

 31424 +  const char *name;

 31425 +

 31426 +  /* A unique sequence number.  */

 31427 +  int id;

 31428 +

 31429 +  /* Which section in the bfd; 0..n-1 as sections are created in a bfd.  */

 31430 +  int index;

 31431 +

 31432 +  /* The next section in the list belonging to the BFD, or NULL.  */

 31433 +  struct bfd_section *next;

 31434 +

 31435 +  /* The previous section in the list belonging to the BFD, or NULL.  */

 31436 +  struct bfd_section *prev;

 31437 +

 31438 +  /* The field flags contains attributes of the section. Some

 31439 +     flags are read in from the object file, and some are

 31440 +     synthesized from other information.  */

 31441 +  flagword flags;

 31442 +

 31443 +#define SEC_NO_FLAGS   0x000

 31444 +

 31445 +  /* Tells the OS to allocate space for this section when loading.

 31446 +     This is clear for a section containing debug information only.  */

 31447 +#define SEC_ALLOC      0x001

 31448 +

 31449 +  /* Tells the OS to load the section from the file when loading.

 31450 +     This is clear for a .bss section.  */

 31451 +#define SEC_LOAD       0x002

 31452 +

 31453 +  /* The section contains data still to be relocated, so there is

 31454 +     some relocation information too.  */

 31455 +#define SEC_RELOC      0x004

 31456 +

 31457 +  /* A signal to the OS that the section contains read only data.  */

 31458 +#define SEC_READONLY   0x008

 31459 +

 31460 +  /* The section contains code only.  */

 31461 +#define SEC_CODE       0x010

 31462 +

 31463 +  /* The section contains data only.  */

 31464 +#define SEC_DATA       0x020

 31465 +

 31466 +  /* The section will reside in ROM.  */

 31467 +#define SEC_ROM        0x040

 31468 +

 31469 +  /* The section contains constructor information. This section

 31470 +     type is used by the linker to create lists of constructors and

 31471 +     destructors used by <<g++>>. When a back end sees a symbol

 31472 +     which should be used in a constructor list, it creates a new

 31473 +     section for the type of name (e.g., <<__CTOR_LIST__>>), attaches

 31474 +     the symbol to it, and builds a relocation. To build the lists

 31475 +     of constructors, all the linker has to do is catenate all the

 31476 +     sections called <<__CTOR_LIST__>> and relocate the data

 31477 +     contained within - exactly the operations it would peform on

 31478 +     standard data.  */

 31479 +#define SEC_CONSTRUCTOR 0x080

 31480 +

 31481 +  /* The section has contents - a data section could be

 31482 +     <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>; a debug section could be

 31483 +     <<SEC_HAS_CONTENTS>>  */

 31484 +#define SEC_HAS_CONTENTS 0x100

 31485 +

 31486 +  /* An instruction to the linker to not output the section

 31487 +     even if it has information which would normally be written.  */

 31488 +#define SEC_NEVER_LOAD 0x200

 31489 +

 31490 +  /* The section contains thread local data.  */

 31491 +#define SEC_THREAD_LOCAL 0x400

 31492 +

 31493 +  /* The section has GOT references.  This flag is only for the

 31494 +     linker, and is currently only used by the elf32-hppa back end.

 31495 +     It will be set if global offset table references were detected

 31496 +     in this section, which indicate to the linker that the section

 31497 +     contains PIC code, and must be handled specially when doing a

 31498 +     static link.  */

 31499 +#define SEC_HAS_GOT_REF 0x800

 31500 +

 31501 +  /* The section contains common symbols (symbols may be defined

 31502 +     multiple times, the value of a symbol is the amount of

 31503 +     space it requires, and the largest symbol value is the one

 31504 +     used).  Most targets have exactly one of these (which we

 31505 +     translate to bfd_com_section_ptr), but ECOFF has two.  */

 31506 +#define SEC_IS_COMMON 0x1000

 31507 +

 31508 +  /* The section contains only debugging information.  For

 31509 +     example, this is set for ELF .debug and .stab sections.

 31510 +     strip tests this flag to see if a section can be

 31511 +     discarded.  */

 31512 +#define SEC_DEBUGGING 0x2000

 31513 +

 31514 +  /* The contents of this section are held in memory pointed to

 31515 +     by the contents field.  This is checked by bfd_get_section_contents,

 31516 +     and the data is retrieved from memory if appropriate.  */

 31517 +#define SEC_IN_MEMORY 0x4000

 31518 +

 31519 +  /* The contents of this section are to be excluded by the

 31520 +     linker for executable and shared objects unless those

 31521 +     objects are to be further relocated.  */

 31522 +#define SEC_EXCLUDE 0x8000

 31523 +

 31524 +  /* The contents of this section are to be sorted based on the sum of

 31525 +     the symbol and addend values specified by the associated relocation

 31526 +     entries.  Entries without associated relocation entries will be

 31527 +     appended to the end of the section in an unspecified order.  */

 31528 +#define SEC_SORT_ENTRIES 0x10000

 31529 +

 31530 +  /* When linking, duplicate sections of the same name should be

 31531 +     discarded, rather than being combined into a single section as

 31532 +     is usually done.  This is similar to how common symbols are

 31533 +     handled.  See SEC_LINK_DUPLICATES below.  */

 31534 +#define SEC_LINK_ONCE 0x20000

 31535 +

 31536 +  /* If SEC_LINK_ONCE is set, this bitfield describes how the linker

 31537 +     should handle duplicate sections.  */

 31538 +#define SEC_LINK_DUPLICATES 0x40000

 31539 +

 31540 +  /* This value for SEC_LINK_DUPLICATES means that duplicate

 31541 +     sections with the same name should simply be discarded.  */

 31542 +#define SEC_LINK_DUPLICATES_DISCARD 0x0

 31543 +

 31544 +  /* This value for SEC_LINK_DUPLICATES means that the linker

 31545 +     should warn if there are any duplicate sections, although

 31546 +     it should still only link one copy.  */

 31547 +#define SEC_LINK_DUPLICATES_ONE_ONLY 0x80000

 31548 +

 31549 +  /* This value for SEC_LINK_DUPLICATES means that the linker

 31550 +     should warn if any duplicate sections are a different size.  */

 31551 +#define SEC_LINK_DUPLICATES_SAME_SIZE 0x100000

 31552 +

 31553 +  /* This value for SEC_LINK_DUPLICATES means that the linker

 31554 +     should warn if any duplicate sections contain different

 31555 +     contents.  */

 31556 +#define SEC_LINK_DUPLICATES_SAME_CONTENTS \

 31557 +  (SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE)

 31558 +

 31559 +  /* This section was created by the linker as part of dynamic

 31560 +     relocation or other arcane processing.  It is skipped when

 31561 +     going through the first-pass output, trusting that someone

 31562 +     else up the line will take care of it later.  */

 31563 +#define SEC_LINKER_CREATED 0x200000

 31564 +

 31565 +  /* This section should not be subject to garbage collection.

 31566 +     Also set to inform the linker that this section should not be

 31567 +     listed in the link map as discarded.  */

 31568 +#define SEC_KEEP 0x400000

 31569 +

 31570 +  /* This section contains "short" data, and should be placed

 31571 +     "near" the GP.  */

 31572 +#define SEC_SMALL_DATA 0x800000

 31573 +

 31574 +  /* Attempt to merge identical entities in the section.

 31575 +     Entity size is given in the entsize field.  */

 31576 +#define SEC_MERGE 0x1000000

 31577 +

 31578 +  /* If given with SEC_MERGE, entities to merge are zero terminated

 31579 +     strings where entsize specifies character size instead of fixed

 31580 +     size entries.  */

 31581 +#define SEC_STRINGS 0x2000000

 31582 +

 31583 +  /* This section contains data about section groups.  */

 31584 +#define SEC_GROUP 0x4000000

 31585 +

 31586 +  /* The section is a COFF shared library section.  This flag is

 31587 +     only for the linker.  If this type of section appears in

 31588 +     the input file, the linker must copy it to the output file

 31589 +     without changing the vma or size.  FIXME: Although this

 31590 +     was originally intended to be general, it really is COFF

 31591 +     specific (and the flag was renamed to indicate this).  It

 31592 +     might be cleaner to have some more general mechanism to

 31593 +     allow the back end to control what the linker does with

 31594 +     sections.  */

 31595 +#define SEC_COFF_SHARED_LIBRARY 0x10000000

 31596 +

 31597 +  /* This section contains data which may be shared with other

 31598 +     executables or shared objects. This is for COFF only.  */

 31599 +#define SEC_COFF_SHARED 0x20000000

 31600 +

 31601 +  /* When a section with this flag is being linked, then if the size of

 31602 +     the input section is less than a page, it should not cross a page

 31603 +     boundary.  If the size of the input section is one page or more,

 31604 +     it should be aligned on a page boundary.  This is for TI

 31605 +     TMS320C54X only.  */

 31606 +#define SEC_TIC54X_BLOCK 0x40000000

 31607 +

 31608 +  /* Conditionally link this section; do not link if there are no

 31609 +     references found to any symbol in the section.  This is for TI

 31610 +     TMS320C54X only.  */

 31611 +#define SEC_TIC54X_CLINK 0x80000000

 31612 +

 31613 +  /*  End of section flags.  */

 31614 +

 31615 +  /* Some internal packed boolean fields.  */

 31616 +

 31617 +  /* See the vma field.  */

 31618 +  unsigned int user_set_vma : 1;

 31619 +

 31620 +  /* A mark flag used by some of the linker backends.  */

 31621 +  unsigned int linker_mark : 1;

 31622 +

 31623 +  /* Another mark flag used by some of the linker backends.  Set for

 31624 +     output sections that have an input section.  */

 31625 +  unsigned int linker_has_input : 1;

 31626 +

 31627 +  /* Mark flags used by some linker backends for garbage collection.  */

 31628 +  unsigned int gc_mark : 1;

 31629 +  unsigned int gc_mark_from_eh : 1;

 31630 +

 31631 +  /* The following flags are used by the ELF linker. */

 31632 +

 31633 +  /* Mark sections which have been allocated to segments.  */

 31634 +  unsigned int segment_mark : 1;

 31635 +

 31636 +  /* Type of sec_info information.  */

 31637 +  unsigned int sec_info_type:3;

 31638 +#define ELF_INFO_TYPE_NONE      0

 31639 +#define ELF_INFO_TYPE_STABS     1

 31640 +#define ELF_INFO_TYPE_MERGE     2

 31641 +#define ELF_INFO_TYPE_EH_FRAME  3

 31642 +#define ELF_INFO_TYPE_JUST_SYMS 4

 31643 +

 31644 +  /* Nonzero if this section uses RELA relocations, rather than REL.  */

 31645 +  unsigned int use_rela_p:1;

 31646 +

 31647 +  /* Bits used by various backends.  The generic code doesn't touch

 31648 +     these fields.  */

 31649 +

 31650 +  /* Nonzero if this section has TLS related relocations.  */

 31651 +  unsigned int has_tls_reloc:1;

 31652 +

 31653 +  /* Nonzero if this section has a gp reloc.  */

 31654 +  unsigned int has_gp_reloc:1;

 31655 +

 31656 +  /* Nonzero if this section needs the relax finalize pass.  */

 31657 +  unsigned int need_finalize_relax:1;

 31658 +

 31659 +  /* Whether relocations have been processed.  */

 31660 +  unsigned int reloc_done : 1;

 31661 +

 31662 +  /* End of internal packed boolean fields.  */

 31663 +

 31664 +  /*  The virtual memory address of the section - where it will be

 31665 +      at run time.  The symbols are relocated against this.  The

 31666 +      user_set_vma flag is maintained by bfd; if it's not set, the

 31667 +      backend can assign addresses (for example, in <<a.out>>, where

 31668 +      the default address for <<.data>> is dependent on the specific

 31669 +      target and various flags).  */

 31670 +  bfd_vma vma;

 31671 +

 31672 +  /*  The load address of the section - where it would be in a

 31673 +      rom image; really only used for writing section header

 31674 +      information.  */

 31675 +  bfd_vma lma;

 31676 +

 31677 +  /* The size of the section in octets, as it will be output.

 31678 +     Contains a value even if the section has no contents (e.g., the

 31679 +     size of <<.bss>>).  */

 31680 +  bfd_size_type size;

 31681 +

 31682 +  /* For input sections, the original size on disk of the section, in

 31683 +     octets.  This field is used by the linker relaxation code.  It is

 31684 +     currently only set for sections where the linker relaxation scheme

 31685 +     doesn't cache altered section and reloc contents (stabs, eh_frame,

 31686 +     SEC_MERGE, some coff relaxing targets), and thus the original size

 31687 +     needs to be kept to read the section multiple times.

 31688 +     For output sections, rawsize holds the section size calculated on

 31689 +     a previous linker relaxation pass.  */

 31690 +  bfd_size_type rawsize;

 31691 +

 31692 +  /* If this section is going to be output, then this value is the

 31693 +     offset in *bytes* into the output section of the first byte in the

 31694 +     input section (byte ==> smallest addressable unit on the

 31695 +     target).  In most cases, if this was going to start at the

 31696 +     100th octet (8-bit quantity) in the output section, this value

 31697 +     would be 100.  However, if the target byte size is 16 bits

 31698 +     (bfd_octets_per_byte is "2"), this value would be 50.  */

 31699 +  bfd_vma output_offset;

 31700 +

 31701 +  /* The output section through which to map on output.  */

 31702 +  struct bfd_section *output_section;

 31703 +

 31704 +  /* The alignment requirement of the section, as an exponent of 2 -

 31705 +     e.g., 3 aligns to 2^3 (or 8).  */

 31706 +  unsigned int alignment_power;

 31707 +

 31708 +  /* If an input section, a pointer to a vector of relocation

 31709 +     records for the data in this section.  */

 31710 +  struct reloc_cache_entry *relocation;

 31711 +

 31712 +  /* If an output section, a pointer to a vector of pointers to

 31713 +     relocation records for the data in this section.  */

 31714 +  struct reloc_cache_entry **orelocation;

 31715 +

 31716 +  /* The number of relocation records in one of the above.  */

 31717 +  unsigned reloc_count;

 31718 +

 31719 +  /* Information below is back end specific - and not always used

 31720 +     or updated.  */

 31721 +

 31722 +  /* File position of section data.  */

 31723 +  file_ptr filepos;

 31724 +

 31725 +  /* File position of relocation info.  */

 31726 +  file_ptr rel_filepos;

 31727 +

 31728 +  /* File position of line data.  */

 31729 +  file_ptr line_filepos;

 31730 +

 31731 +  /* Pointer to data for applications.  */

 31732 +  void *userdata;

 31733 +

 31734 +  /* If the SEC_IN_MEMORY flag is set, this points to the actual

 31735 +     contents.  */

 31736 +  unsigned char *contents;

 31737 +

 31738 +  /* Attached line number information.  */

 31739 +  alent *lineno;

 31740 +

 31741 +  /* Number of line number records.  */

 31742 +  unsigned int lineno_count;

 31743 +

 31744 +  /* Entity size for merging purposes.  */

 31745 +  unsigned int entsize;

 31746 +

 31747 +  /* Points to the kept section if this section is a link-once section,

 31748 +     and is discarded.  */

 31749 +  struct bfd_section *kept_section;

 31750 +

 31751 +  /* When a section is being output, this value changes as more

 31752 +     linenumbers are written out.  */

 31753 +  file_ptr moving_line_filepos;

 31754 +

 31755 +  /* What the section number is in the target world.  */

 31756 +  int target_index;

 31757 +

 31758 +  void *used_by_bfd;

 31759 +

 31760 +  /* If this is a constructor section then here is a list of the

 31761 +     relocations created to relocate items within it.  */

 31762 +  struct relent_chain *constructor_chain;

 31763 +

 31764 +  /* The BFD which owns the section.  */

 31765 +  bfd *owner;

 31766 +

 31767 +  /* A symbol which points at this section only.  */

 31768 +  struct bfd_symbol *symbol;

 31769 +  struct bfd_symbol **symbol_ptr_ptr;

 31770 +

 31771 +  /* Early in the link process, map_head and map_tail are used to build

 31772 +     a list of input sections attached to an output section.  Later,

 31773 +     output sections use these fields for a list of bfd_link_order

 31774 +     structs.  */

 31775 +  union {

 31776 +    struct bfd_link_order *link_order;

 31777 +    struct bfd_section *s;

 31778 +  } map_head, map_tail;

 31779 +} asection;

 31780 +

 31781 +/* These sections are global, and are managed by BFD.  The application

 31782 +   and target back end are not permitted to change the values in

 31783 +   these sections.  New code should use the section_ptr macros rather

 31784 +   than referring directly to the const sections.  The const sections

 31785 +   may eventually vanish.  */

 31786 +#define BFD_ABS_SECTION_NAME "*ABS*"

 31787 +#define BFD_UND_SECTION_NAME "*UND*"

 31788 +#define BFD_COM_SECTION_NAME "*COM*"

 31789 +#define BFD_IND_SECTION_NAME "*IND*"

 31790 +

 31791 +/* The absolute section.  */

 31792 +extern asection bfd_abs_section;

 31793 +#define bfd_abs_section_ptr ((asection *) &bfd_abs_section)

 31794 +#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr)

 31795 +/* Pointer to the undefined section.  */

 31796 +extern asection bfd_und_section;

 31797 +#define bfd_und_section_ptr ((asection *) &bfd_und_section)

 31798 +#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr)

 31799 +/* Pointer to the common section.  */

 31800 +extern asection bfd_com_section;

 31801 +#define bfd_com_section_ptr ((asection *) &bfd_com_section)

 31802 +/* Pointer to the indirect section.  */

 31803 +extern asection bfd_ind_section;

 31804 +#define bfd_ind_section_ptr ((asection *) &bfd_ind_section)

 31805 +#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr)

 31806 +

 31807 +#define bfd_is_const_section(SEC)              \

 31808 + (   ((SEC) == bfd_abs_section_ptr)            \

 31809 +  || ((SEC) == bfd_und_section_ptr)            \

 31810 +  || ((SEC) == bfd_com_section_ptr)            \

 31811 +  || ((SEC) == bfd_ind_section_ptr))

 31812 +

 31813 +/* Macros to handle insertion and deletion of a bfd's sections.  These

 31814 +   only handle the list pointers, ie. do not adjust section_count,

 31815 +   target_index etc.  */

 31816 +#define bfd_section_list_remove(ABFD, S) \

 31817 +  do                                                   \

 31818 +    {                                                  \

 31819 +      asection *_s = S;                                \

 31820 +      asection *_next = _s->next;                      \

 31821 +      asection *_prev = _s->prev;                      \

 31822 +      if (_prev)                                       \

 31823 +        _prev->next = _next;                           \

 31824 +      else                                             \

 31825 +        (ABFD)->sections = _next;                      \

 31826 +      if (_next)                                       \

 31827 +        _next->prev = _prev;                           \

 31828 +      else                                             \

 31829 +        (ABFD)->section_last = _prev;                  \

 31830 +    }                                                  \

 31831 +  while (0)

 31832 +#define bfd_section_list_append(ABFD, S) \

 31833 +  do                                                   \

 31834 +    {                                                  \

 31835 +      asection *_s = S;                                \

 31836 +      bfd *_abfd = ABFD;                               \

 31837 +      _s->next = NULL;                                 \

 31838 +      if (_abfd->section_last)                         \

 31839 +        {                                              \

 31840 +          _s->prev = _abfd->section_last;              \

 31841 +          _abfd->section_last->next = _s;              \

 31842 +        }                                              \

 31843 +      else                                             \

 31844 +        {                                              \

 31845 +          _s->prev = NULL;                             \

 31846 +          _abfd->sections = _s;                        \

 31847 +        }                                              \

 31848 +      _abfd->section_last = _s;                        \

 31849 +    }                                                  \

 31850 +  while (0)

 31851 +#define bfd_section_list_prepend(ABFD, S) \

 31852 +  do                                                   \

 31853 +    {                                                  \

 31854 +      asection *_s = S;                                \

 31855 +      bfd *_abfd = ABFD;                               \

 31856 +      _s->prev = NULL;                                 \

 31857 +      if (_abfd->sections)                             \

 31858 +        {                                              \

 31859 +          _s->next = _abfd->sections;                  \

 31860 +          _abfd->sections->prev = _s;                  \

 31861 +        }                                              \

 31862 +      else                                             \

 31863 +        {                                              \

 31864 +          _s->next = NULL;                             \

 31865 +          _abfd->section_last = _s;                    \

 31866 +        }                                              \

 31867 +      _abfd->sections = _s;                            \

 31868 +    }                                                  \

 31869 +  while (0)

 31870 +#define bfd_section_list_insert_after(ABFD, A, S) \

 31871 +  do                                                   \

 31872 +    {                                                  \

 31873 +      asection *_a = A;                                \

 31874 +      asection *_s = S;                                \

 31875 +      asection *_next = _a->next;                      \

 31876 +      _s->next = _next;                                \

 31877 +      _s->prev = _a;                                   \

 31878 +      _a->next = _s;                                   \

 31879 +      if (_next)                                       \

 31880 +        _next->prev = _s;                              \

 31881 +      else                                             \

 31882 +        (ABFD)->section_last = _s;                     \

 31883 +    }                                                  \

 31884 +  while (0)

 31885 +#define bfd_section_list_insert_before(ABFD, B, S) \

 31886 +  do                                                   \

 31887 +    {                                                  \

 31888 +      asection *_b = B;                                \

 31889 +      asection *_s = S;                                \

 31890 +      asection *_prev = _b->prev;                      \

 31891 +      _s->prev = _prev;                                \

 31892 +      _s->next = _b;                                   \

 31893 +      _b->prev = _s;                                   \

 31894 +      if (_prev)                                       \

 31895 +        _prev->next = _s;                              \

 31896 +      else                                             \

 31897 +        (ABFD)->sections = _s;                         \

 31898 +    }                                                  \

 31899 +  while (0)

 31900 +#define bfd_section_removed_from_list(ABFD, S) \

 31901 +  ((S)->next == NULL ? (ABFD)->section_last != (S) : (S)->next->prev != (S))

 31902 +

 31903 +#define BFD_FAKE_SECTION(SEC, FLAGS, SYM, NAME, IDX)                   \

 31904 +  /* name, id,  index, next, prev, flags, user_set_vma,            */  \

 31905 +  { NAME,  IDX, 0,     NULL, NULL, FLAGS, 0,                           \

 31906 +                                                                       \

 31907 +  /* linker_mark, linker_has_input, gc_mark, gc_mark_from_eh,      */  \

 31908 +     0,           0,                1,       0,                        \

 31909 +                                                                       \

 31910 +  /* segment_mark, sec_info_type, use_rela_p, has_tls_reloc,       */  \

 31911 +     0,            0,             0,          0,                       \

 31912 +                                                                       \

 31913 +  /* has_gp_reloc, need_finalize_relax, reloc_done,                */  \

 31914 +     0,            0,                   0,                             \

 31915 +                                                                       \

 31916 +  /* vma, lma, size, rawsize                                       */  \

 31917 +     0,   0,   0,    0,                                                \

 31918 +                                                                       \

 31919 +  /* output_offset, output_section,              alignment_power,  */  \

 31920 +     0,             (struct bfd_section *) &SEC, 0,                    \

 31921 +                                                                       \

 31922 +  /* relocation, orelocation, reloc_count, filepos, rel_filepos,   */  \

 31923 +     NULL,       NULL,        0,           0,       0,                 \

 31924 +                                                                       \

 31925 +  /* line_filepos, userdata, contents, lineno, lineno_count,       */  \

 31926 +     0,            NULL,     NULL,     NULL,   0,                      \

 31927 +                                                                       \

 31928 +  /* entsize, kept_section, moving_line_filepos,                    */ \

 31929 +     0,       NULL,          0,                                        \

 31930 +                                                                       \

 31931 +  /* target_index, used_by_bfd, constructor_chain, owner,          */  \

 31932 +     0,            NULL,        NULL,              NULL,               \

 31933 +                                                                       \

 31934 +  /* symbol,                    symbol_ptr_ptr,                    */  \

 31935 +     (struct bfd_symbol *) SYM, &SEC.symbol,                           \

 31936 +                                                                       \

 31937 +  /* map_head, map_tail                                            */  \

 31938 +     { NULL }, { NULL }                                                \

 31939 +    }

 31940 +

 31941 +void bfd_section_list_clear (bfd *);

 31942 +

 31943 +asection *bfd_get_section_by_name (bfd *abfd, const char *name);

 31944 +

 31945 +asection *bfd_get_section_by_name_if

 31946 +   (bfd *abfd,

 31947 +    const char *name,

 31948 +    bfd_boolean (*func) (bfd *abfd, asection *sect, void *obj),

 31949 +    void *obj);

 31950 +

 31951 +char *bfd_get_unique_section_name

 31952 +   (bfd *abfd, const char *templat, int *count);

 31953 +

 31954 +asection *bfd_make_section_old_way (bfd *abfd, const char *name);

 31955 +

 31956 +asection *bfd_make_section_anyway_with_flags

 31957 +   (bfd *abfd, const char *name, flagword flags);

 31958 +

 31959 +asection *bfd_make_section_anyway (bfd *abfd, const char *name);

 31960 +

 31961 +asection *bfd_make_section_with_flags

 31962 +   (bfd *, const char *name, flagword flags);

 31963 +

 31964 +asection *bfd_make_section (bfd *, const char *name);

 31965 +

 31966 +bfd_boolean bfd_set_section_flags

 31967 +   (bfd *abfd, asection *sec, flagword flags);

 31968 +

 31969 +void bfd_map_over_sections

 31970 +   (bfd *abfd,

 31971 +    void (*func) (bfd *abfd, asection *sect, void *obj),

 31972 +    void *obj);

 31973 +

 31974 +asection *bfd_sections_find_if

 31975 +   (bfd *abfd,

 31976 +    bfd_boolean (*operation) (bfd *abfd, asection *sect, void *obj),

 31977 +    void *obj);

 31978 +

 31979 +bfd_boolean bfd_set_section_size

 31980 +   (bfd *abfd, asection *sec, bfd_size_type val);

 31981 +

 31982 +bfd_boolean bfd_set_section_contents

 31983 +   (bfd *abfd, asection *section, const void *data,

 31984 +    file_ptr offset, bfd_size_type count);

 31985 +

 31986 +bfd_boolean bfd_get_section_contents

 31987 +   (bfd *abfd, asection *section, void *location, file_ptr offset,

 31988 +    bfd_size_type count);

 31989 +

 31990 +bfd_boolean bfd_malloc_and_get_section

 31991 +   (bfd *abfd, asection *section, bfd_byte **buf);

 31992 +

 31993 +bfd_boolean bfd_copy_private_section_data

 31994 +   (bfd *ibfd, asection *isec, bfd *obfd, asection *osec);

 31995 +

 31996 +#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \

 31997 +     BFD_SEND (obfd, _bfd_copy_private_section_data, \

 31998 +               (ibfd, isection, obfd, osection))

 31999 +bfd_boolean bfd_generic_is_group_section (bfd *, const asection *sec);

 32000 +

 32001 +bfd_boolean bfd_generic_discard_group (bfd *abfd, asection *group);

 32002 +

 32003 +/* Extracted from archures.c.  */

 32004 +enum bfd_architecture

 32005 +{

 32006 +  bfd_arch_unknown,   /* File arch not known.  */

 32007 +  bfd_arch_obscure,   /* Arch known, not one of these.  */

 32008 +  bfd_arch_m68k,      /* Motorola 68xxx */

 32009 +#define bfd_mach_m68000 1

 32010 +#define bfd_mach_m68008 2

 32011 +#define bfd_mach_m68010 3

 32012 +#define bfd_mach_m68020 4

 32013 +#define bfd_mach_m68030 5

 32014 +#define bfd_mach_m68040 6

 32015 +#define bfd_mach_m68060 7

 32016 +#define bfd_mach_cpu32  8

 32017 +#define bfd_mach_fido   9

 32018 +#define bfd_mach_mcf_isa_a_nodiv 10

 32019 +#define bfd_mach_mcf_isa_a 11

 32020 +#define bfd_mach_mcf_isa_a_mac 12

 32021 +#define bfd_mach_mcf_isa_a_emac 13

 32022 +#define bfd_mach_mcf_isa_aplus 14

 32023 +#define bfd_mach_mcf_isa_aplus_mac 15

 32024 +#define bfd_mach_mcf_isa_aplus_emac 16

 32025 +#define bfd_mach_mcf_isa_b_nousp 17

 32026 +#define bfd_mach_mcf_isa_b_nousp_mac 18

 32027 +#define bfd_mach_mcf_isa_b_nousp_emac 19

 32028 +#define bfd_mach_mcf_isa_b 20

 32029 +#define bfd_mach_mcf_isa_b_mac 21

 32030 +#define bfd_mach_mcf_isa_b_emac 22

 32031 +#define bfd_mach_mcf_isa_b_float 23

 32032 +#define bfd_mach_mcf_isa_b_float_mac 24

 32033 +#define bfd_mach_mcf_isa_b_float_emac 25

 32034 +#define bfd_mach_mcf_isa_c 26

 32035 +#define bfd_mach_mcf_isa_c_mac 27

 32036 +#define bfd_mach_mcf_isa_c_emac 28

 32037 +  bfd_arch_vax,       /* DEC Vax */

 32038 +  bfd_arch_i960,      /* Intel 960 */

 32039 +    /* The order of the following is important.

 32040 +       lower number indicates a machine type that

 32041 +       only accepts a subset of the instructions

 32042 +       available to machines with higher numbers.

 32043 +       The exception is the "ca", which is

 32044 +       incompatible with all other machines except

 32045 +       "core".  */

 32046 +

 32047 +#define bfd_mach_i960_core      1

 32048 +#define bfd_mach_i960_ka_sa     2

 32049 +#define bfd_mach_i960_kb_sb     3

 32050 +#define bfd_mach_i960_mc        4

 32051 +#define bfd_mach_i960_xa        5

 32052 +#define bfd_mach_i960_ca        6

 32053 +#define bfd_mach_i960_jx        7

 32054 +#define bfd_mach_i960_hx        8

 32055 +

 32056 +  bfd_arch_or32,      /* OpenRISC 32 */

 32057 +

 32058 +  bfd_arch_sparc,     /* SPARC */

 32059 +#define bfd_mach_sparc                 1

 32060 +/* The difference between v8plus and v9 is that v9 is a true 64 bit env.  */

 32061 +#define bfd_mach_sparc_sparclet        2

 32062 +#define bfd_mach_sparc_sparclite       3

 32063 +#define bfd_mach_sparc_v8plus          4

 32064 +#define bfd_mach_sparc_v8plusa         5 /* with ultrasparc add'ns.  */

 32065 +#define bfd_mach_sparc_sparclite_le    6

 32066 +#define bfd_mach_sparc_v9              7

 32067 +#define bfd_mach_sparc_v9a             8 /* with ultrasparc add'ns.  */

 32068 +#define bfd_mach_sparc_v8plusb         9 /* with cheetah add'ns.  */

 32069 +#define bfd_mach_sparc_v9b             10 /* with cheetah add'ns.  */

 32070 +/* Nonzero if MACH has the v9 instruction set.  */

 32071 +#define bfd_mach_sparc_v9_p(mach) \

 32072 +  ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9b \

 32073 +   && (mach) != bfd_mach_sparc_sparclite_le)

 32074 +/* Nonzero if MACH is a 64 bit sparc architecture.  */

 32075 +#define bfd_mach_sparc_64bit_p(mach) \

 32076 +  ((mach) >= bfd_mach_sparc_v9 && (mach) != bfd_mach_sparc_v8plusb)

 32077 +  bfd_arch_spu,       /* PowerPC SPU */

 32078 +#define bfd_mach_spu           256

 32079 +  bfd_arch_mips,      /* MIPS Rxxxx */

 32080 +#define bfd_mach_mips3000              3000

 32081 +#define bfd_mach_mips3900              3900

 32082 +#define bfd_mach_mips4000              4000

 32083 +#define bfd_mach_mips4010              4010

 32084 +#define bfd_mach_mips4100              4100

 32085 +#define bfd_mach_mips4111              4111

 32086 +#define bfd_mach_mips4120              4120

 32087 +#define bfd_mach_mips4300              4300

 32088 +#define bfd_mach_mips4400              4400

 32089 +#define bfd_mach_mips4600              4600

 32090 +#define bfd_mach_mips4650              4650

 32091 +#define bfd_mach_mips5000              5000

 32092 +#define bfd_mach_mips5400              5400

 32093 +#define bfd_mach_mips5500              5500

 32094 +#define bfd_mach_mips6000              6000

 32095 +#define bfd_mach_mips7000              7000

 32096 +#define bfd_mach_mips8000              8000

 32097 +#define bfd_mach_mips9000              9000

 32098 +#define bfd_mach_mips10000             10000

 32099 +#define bfd_mach_mips12000             12000

 32100 +#define bfd_mach_mips16                16

 32101 +#define bfd_mach_mips5                 5

 32102 +#define bfd_mach_mips_sb1              12310201 /* octal 'SB', 01 */

 32103 +#define bfd_mach_mipsisa32             32

 32104 +#define bfd_mach_mipsisa32r2           33

 32105 +#define bfd_mach_mipsisa64             64

 32106 +#define bfd_mach_mipsisa64r2           65

 32107 +  bfd_arch_i386,      /* Intel 386 */

 32108 +#define bfd_mach_i386_i386 1

 32109 +#define bfd_mach_i386_i8086 2

 32110 +#define bfd_mach_i386_i386_intel_syntax 3

 32111 +#define bfd_mach_x86_64 64

 32112 +#define bfd_mach_x86_64_intel_syntax 65

 32113 +  bfd_arch_we32k,     /* AT&T WE32xxx */

 32114 +  bfd_arch_tahoe,     /* CCI/Harris Tahoe */

 32115 +  bfd_arch_i860,      /* Intel 860 */

 32116 +  bfd_arch_i370,      /* IBM 360/370 Mainframes */

 32117 +  bfd_arch_romp,      /* IBM ROMP PC/RT */

 32118 +  bfd_arch_convex,    /* Convex */

 32119 +  bfd_arch_m88k,      /* Motorola 88xxx */

 32120 +  bfd_arch_m98k,      /* Motorola 98xxx */

 32121 +  bfd_arch_pyramid,   /* Pyramid Technology */

 32122 +  bfd_arch_h8300,     /* Renesas H8/300 (formerly Hitachi H8/300) */

 32123 +#define bfd_mach_h8300    1

 32124 +#define bfd_mach_h8300h   2

 32125 +#define bfd_mach_h8300s   3

 32126 +#define bfd_mach_h8300hn  4

 32127 +#define bfd_mach_h8300sn  5

 32128 +#define bfd_mach_h8300sx  6

 32129 +#define bfd_mach_h8300sxn 7

 32130 +  bfd_arch_pdp11,     /* DEC PDP-11 */

 32131 +  bfd_arch_powerpc,   /* PowerPC */

 32132 +#define bfd_mach_ppc           32

 32133 +#define bfd_mach_ppc64         64

 32134 +#define bfd_mach_ppc_403       403

 32135 +#define bfd_mach_ppc_403gc     4030

 32136 +#define bfd_mach_ppc_505       505

 32137 +#define bfd_mach_ppc_601       601

 32138 +#define bfd_mach_ppc_602       602

 32139 +#define bfd_mach_ppc_603       603

 32140 +#define bfd_mach_ppc_ec603e    6031

 32141 +#define bfd_mach_ppc_604       604

 32142 +#define bfd_mach_ppc_620       620

 32143 +#define bfd_mach_ppc_630       630

 32144 +#define bfd_mach_ppc_750       750

 32145 +#define bfd_mach_ppc_860       860

 32146 +#define bfd_mach_ppc_a35       35

 32147 +#define bfd_mach_ppc_rs64ii    642

 32148 +#define bfd_mach_ppc_rs64iii   643

 32149 +#define bfd_mach_ppc_7400      7400

 32150 +#define bfd_mach_ppc_e500      500

 32151 +  bfd_arch_rs6000,    /* IBM RS/6000 */

 32152 +#define bfd_mach_rs6k          6000

 32153 +#define bfd_mach_rs6k_rs1      6001

 32154 +#define bfd_mach_rs6k_rsc      6003

 32155 +#define bfd_mach_rs6k_rs2      6002

 32156 +  bfd_arch_hppa,      /* HP PA RISC */

 32157 +#define bfd_mach_hppa10        10

 32158 +#define bfd_mach_hppa11        11

 32159 +#define bfd_mach_hppa20        20

 32160 +#define bfd_mach_hppa20w       25

 32161 +  bfd_arch_d10v,      /* Mitsubishi D10V */

 32162 +#define bfd_mach_d10v          1

 32163 +#define bfd_mach_d10v_ts2      2

 32164 +#define bfd_mach_d10v_ts3      3

 32165 +  bfd_arch_d30v,      /* Mitsubishi D30V */

 32166 +  bfd_arch_dlx,       /* DLX */

 32167 +  bfd_arch_m68hc11,   /* Motorola 68HC11 */

 32168 +  bfd_arch_m68hc12,   /* Motorola 68HC12 */

 32169 +#define bfd_mach_m6812_default 0

 32170 +#define bfd_mach_m6812         1

 32171 +#define bfd_mach_m6812s        2

 32172 +  bfd_arch_z8k,       /* Zilog Z8000 */

 32173 +#define bfd_mach_z8001         1

 32174 +#define bfd_mach_z8002         2

 32175 +  bfd_arch_h8500,     /* Renesas H8/500 (formerly Hitachi H8/500) */

 32176 +  bfd_arch_sh,        /* Renesas / SuperH SH (formerly Hitachi SH) */

 32177 +#define bfd_mach_sh            1

 32178 +#define bfd_mach_sh2        0x20

 32179 +#define bfd_mach_sh_dsp     0x2d

 32180 +#define bfd_mach_sh2a       0x2a

 32181 +#define bfd_mach_sh2a_nofpu 0x2b

 32182 +#define bfd_mach_sh2a_nofpu_or_sh4_nommu_nofpu 0x2a1

 32183 +#define bfd_mach_sh2a_nofpu_or_sh3_nommu 0x2a2

 32184 +#define bfd_mach_sh2a_or_sh4  0x2a3

 32185 +#define bfd_mach_sh2a_or_sh3e 0x2a4

 32186 +#define bfd_mach_sh2e       0x2e

 32187 +#define bfd_mach_sh3        0x30

 32188 +#define bfd_mach_sh3_nommu  0x31

 32189 +#define bfd_mach_sh3_dsp    0x3d

 32190 +#define bfd_mach_sh3e       0x3e

 32191 +#define bfd_mach_sh4        0x40

 32192 +#define bfd_mach_sh4_nofpu  0x41

 32193 +#define bfd_mach_sh4_nommu_nofpu  0x42

 32194 +#define bfd_mach_sh4a       0x4a

 32195 +#define bfd_mach_sh4a_nofpu 0x4b

 32196 +#define bfd_mach_sh4al_dsp  0x4d

 32197 +#define bfd_mach_sh5        0x50

 32198 +  bfd_arch_alpha,     /* Dec Alpha */

 32199 +#define bfd_mach_alpha_ev4  0x10

 32200 +#define bfd_mach_alpha_ev5  0x20

 32201 +#define bfd_mach_alpha_ev6  0x30

 32202 +  bfd_arch_arm,       /* Advanced Risc Machines ARM.  */

 32203 +#define bfd_mach_arm_unknown   0

 32204 +#define bfd_mach_arm_2         1

 32205 +#define bfd_mach_arm_2a        2

 32206 +#define bfd_mach_arm_3         3

 32207 +#define bfd_mach_arm_3M        4

 32208 +#define bfd_mach_arm_4         5

 32209 +#define bfd_mach_arm_4T        6

 32210 +#define bfd_mach_arm_5         7

 32211 +#define bfd_mach_arm_5T        8

 32212 +#define bfd_mach_arm_5TE       9

 32213 +#define bfd_mach_arm_XScale    10

 32214 +#define bfd_mach_arm_ep9312    11

 32215 +#define bfd_mach_arm_iWMMXt    12

 32216 +#define bfd_mach_arm_iWMMXt2   13

 32217 +  bfd_arch_ns32k,     /* National Semiconductors ns32000 */

 32218 +  bfd_arch_w65,       /* WDC 65816 */

 32219 +  bfd_arch_tic30,     /* Texas Instruments TMS320C30 */

 32220 +  bfd_arch_tic4x,     /* Texas Instruments TMS320C3X/4X */

 32221 +#define bfd_mach_tic3x         30

 32222 +#define bfd_mach_tic4x         40

 32223 +  bfd_arch_tic54x,    /* Texas Instruments TMS320C54X */

 32224 +  bfd_arch_tic80,     /* TI TMS320c80 (MVP) */

 32225 +  bfd_arch_v850,      /* NEC V850 */

 32226 +#define bfd_mach_v850          1

 32227 +#define bfd_mach_v850e         'E'

 32228 +#define bfd_mach_v850e1        '1'

 32229 +  bfd_arch_arc,       /* ARC Cores */

 32230 +#define bfd_mach_arc_5         5

 32231 +#define bfd_mach_arc_6         6

 32232 +#define bfd_mach_arc_7         7

 32233 +#define bfd_mach_arc_8         8

 32234 + bfd_arch_m32c,     /* Renesas M16C/M32C.  */

 32235 +#define bfd_mach_m16c        0x75

 32236 +#define bfd_mach_m32c        0x78

 32237 +  bfd_arch_m32r,      /* Renesas M32R (formerly Mitsubishi M32R/D) */

 32238 +#define bfd_mach_m32r          1 /* For backwards compatibility.  */

 32239 +#define bfd_mach_m32rx         'x'

 32240 +#define bfd_mach_m32r2         '2'

 32241 +  bfd_arch_mn10200,   /* Matsushita MN10200 */

 32242 +  bfd_arch_mn10300,   /* Matsushita MN10300 */

 32243 +#define bfd_mach_mn10300               300

 32244 +#define bfd_mach_am33          330

 32245 +#define bfd_mach_am33_2        332

 32246 +  bfd_arch_fr30,

 32247 +#define bfd_mach_fr30          0x46523330

 32248 +  bfd_arch_frv,

 32249 +#define bfd_mach_frv           1

 32250 +#define bfd_mach_frvsimple     2

 32251 +#define bfd_mach_fr300         300

 32252 +#define bfd_mach_fr400         400

 32253 +#define bfd_mach_fr450         450

 32254 +#define bfd_mach_frvtomcat     499     /* fr500 prototype */

 32255 +#define bfd_mach_fr500         500

 32256 +#define bfd_mach_fr550         550

 32257 +  bfd_arch_mcore,

 32258 +  bfd_arch_mep,

 32259 +#define bfd_mach_mep           1

 32260 +#define bfd_mach_mep_h1        0x6831

 32261 +  bfd_arch_ia64,      /* HP/Intel ia64 */

 32262 +#define bfd_mach_ia64_elf64    64

 32263 +#define bfd_mach_ia64_elf32    32

 32264 +  bfd_arch_ip2k,      /* Ubicom IP2K microcontrollers. */

 32265 +#define bfd_mach_ip2022        1

 32266 +#define bfd_mach_ip2022ext     2

 32267 + bfd_arch_iq2000,     /* Vitesse IQ2000.  */

 32268 +#define bfd_mach_iq2000        1

 32269 +#define bfd_mach_iq10          2

 32270 +  bfd_arch_mt,

 32271 +#define bfd_mach_ms1           1

 32272 +#define bfd_mach_mrisc2        2

 32273 +#define bfd_mach_ms2           3

 32274 +  bfd_arch_pj,

 32275 +  bfd_arch_avr,       /* Atmel AVR microcontrollers.  */

 32276 +#define bfd_mach_avr1          1

 32277 +#define bfd_mach_avr2          2

 32278 +#define bfd_mach_avr3          3

 32279 +#define bfd_mach_avr4          4

 32280 +#define bfd_mach_avr5          5

 32281 +#define bfd_mach_avr6          6

 32282 +  bfd_arch_bfin,        /* ADI Blackfin */

 32283 +#define bfd_mach_bfin          1

 32284 +  bfd_arch_cr16,       /* National Semiconductor CompactRISC (ie CR16). */

 32285 +#define bfd_mach_cr16          1

 32286 +  bfd_arch_cr16c,       /* National Semiconductor CompactRISC. */

 32287 +#define bfd_mach_cr16c         1

 32288 +  bfd_arch_crx,       /*  National Semiconductor CRX.  */

 32289 +#define bfd_mach_crx           1

 32290 +  bfd_arch_cris,      /* Axis CRIS */

 32291 +#define bfd_mach_cris_v0_v10   255

 32292 +#define bfd_mach_cris_v32      32

 32293 +#define bfd_mach_cris_v10_v32  1032

 32294 +  bfd_arch_s390,      /* IBM s390 */

 32295 +#define bfd_mach_s390_31       31

 32296 +#define bfd_mach_s390_64       64

 32297 +  bfd_arch_score,     /* Sunplus score */

 32298 +  bfd_arch_openrisc,  /* OpenRISC */

 32299 +  bfd_arch_mmix,      /* Donald Knuth's educational processor.  */

 32300 +  bfd_arch_xstormy16,

 32301 +#define bfd_mach_xstormy16     1

 32302 +  bfd_arch_msp430,    /* Texas Instruments MSP430 architecture.  */

 32303 +#define bfd_mach_msp11          11

 32304 +#define bfd_mach_msp110         110

 32305 +#define bfd_mach_msp12          12

 32306 +#define bfd_mach_msp13          13

 32307 +#define bfd_mach_msp14          14

 32308 +#define bfd_mach_msp15          15

 32309 +#define bfd_mach_msp16          16

 32310 +#define bfd_mach_msp21          21

 32311 +#define bfd_mach_msp31          31

 32312 +#define bfd_mach_msp32          32

 32313 +#define bfd_mach_msp33          33

 32314 +#define bfd_mach_msp41          41

 32315 +#define bfd_mach_msp42          42

 32316 +#define bfd_mach_msp43          43

 32317 +#define bfd_mach_msp44          44

 32318 +  bfd_arch_xc16x,     /* Infineon's XC16X Series.               */

 32319 +#define bfd_mach_xc16x         1

 32320 +#define bfd_mach_xc16xl        2

 32321 +#define bfd_mach_xc16xs         3

 32322 +  bfd_arch_xtensa,    /* Tensilica's Xtensa cores.  */

 32323 +#define bfd_mach_xtensa        1

 32324 +   bfd_arch_maxq,     /* Dallas MAXQ 10/20 */

 32325 +#define bfd_mach_maxq10    10

 32326 +#define bfd_mach_maxq20    20

 32327 +  bfd_arch_z80,

 32328 +#define bfd_mach_z80strict      1 /* No undocumented opcodes.  */

 32329 +#define bfd_mach_z80            3 /* With ixl, ixh, iyl, and iyh.  */

 32330 +#define bfd_mach_z80full        7 /* All undocumented instructions.  */

 32331 +#define bfd_mach_r800           11 /* R800: successor with multiplication.  */

 32332 +  bfd_arch_last

 32333 +  };

 32334 +

 32335 +typedef struct bfd_arch_info

 32336 +{

 32337 +  int bits_per_word;

 32338 +  int bits_per_address;

 32339 +  int bits_per_byte;

 32340 +  enum bfd_architecture arch;

 32341 +  unsigned long mach;

 32342 +  const char *arch_name;

 32343 +  const char *printable_name;

 32344 +  unsigned int section_align_power;

 32345 +  /* TRUE if this is the default machine for the architecture.

 32346 +     The default arch should be the first entry for an arch so that

 32347 +     all the entries for that arch can be accessed via <<next>>.  */

 32348 +  bfd_boolean the_default;

 32349 +  const struct bfd_arch_info * (*compatible)

 32350 +    (const struct bfd_arch_info *a, const struct bfd_arch_info *b);

 32351 +

 32352 +  bfd_boolean (*scan) (const struct bfd_arch_info *, const char *);

 32353 +

 32354 +  const struct bfd_arch_info *next;

 32355 +}

 32356 +bfd_arch_info_type;

 32357 +

 32358 +const char *bfd_printable_name (bfd *abfd);

 32359 +

 32360 +const bfd_arch_info_type *bfd_scan_arch (const char *string);

 32361 +

 32362 +const char **bfd_arch_list (void);

 32363 +

 32364 +const bfd_arch_info_type *bfd_arch_get_compatible

 32365 +   (const bfd *abfd, const bfd *bbfd, bfd_boolean accept_unknowns);

 32366 +

 32367 +void bfd_set_arch_info (bfd *abfd, const bfd_arch_info_type *arg);

 32368 +

 32369 +enum bfd_architecture bfd_get_arch (bfd *abfd);

 32370 +

 32371 +unsigned long bfd_get_mach (bfd *abfd);

 32372 +

 32373 +unsigned int bfd_arch_bits_per_byte (bfd *abfd);

 32374 +

 32375 +unsigned int bfd_arch_bits_per_address (bfd *abfd);

 32376 +

 32377 +const bfd_arch_info_type *bfd_get_arch_info (bfd *abfd);

 32378 +

 32379 +const bfd_arch_info_type *bfd_lookup_arch

 32380 +   (enum bfd_architecture arch, unsigned long machine);

 32381 +

 32382 +const char *bfd_printable_arch_mach

 32383 +   (enum bfd_architecture arch, unsigned long machine);

 32384 +

 32385 +unsigned int bfd_octets_per_byte (bfd *abfd);

 32386 +

 32387 +unsigned int bfd_arch_mach_octets_per_byte

 32388 +   (enum bfd_architecture arch, unsigned long machine);

 32389 +

 32390 +/* Extracted from reloc.c.  */

 32391 +typedef enum bfd_reloc_status

 32392 +{

 32393 +  /* No errors detected.  */

 32394 +  bfd_reloc_ok,

 32395 +

 32396 +  /* The relocation was performed, but there was an overflow.  */

 32397 +  bfd_reloc_overflow,

 32398 +

 32399 +  /* The address to relocate was not within the section supplied.  */

 32400 +  bfd_reloc_outofrange,

 32401 +

 32402 +  /* Used by special functions.  */

 32403 +  bfd_reloc_continue,

 32404 +

 32405 +  /* Unsupported relocation size requested.  */

 32406 +  bfd_reloc_notsupported,

 32407 +

 32408 +  /* Unused.  */

 32409 +  bfd_reloc_other,

 32410 +

 32411 +  /* The symbol to relocate against was undefined.  */

 32412 +  bfd_reloc_undefined,

 32413 +

 32414 +  /* The relocation was performed, but may not be ok - presently

 32415 +     generated only when linking i960 coff files with i960 b.out

 32416 +     symbols.  If this type is returned, the error_message argument

 32417 +     to bfd_perform_relocation will be set.  */

 32418 +  bfd_reloc_dangerous

 32419 + }

 32420 + bfd_reloc_status_type;

 32421 +

 32422 +

 32423 +typedef struct reloc_cache_entry

 32424 +{

 32425 +  /* A pointer into the canonical table of pointers.  */

 32426 +  struct bfd_symbol **sym_ptr_ptr;

 32427 +

 32428 +  /* offset in section.  */

 32429 +  bfd_size_type address;

 32430 +

 32431 +  /* addend for relocation value.  */

 32432 +  bfd_vma addend;

 32433 +

 32434 +  /* Pointer to how to perform the required relocation.  */

 32435 +  reloc_howto_type *howto;

 32436 +

 32437 +}

 32438 +arelent;

 32439 +

 32440 +enum complain_overflow

 32441 +{

 32442 +  /* Do not complain on overflow.  */

 32443 +  complain_overflow_dont,

 32444 +

 32445 +  /* Complain if the value overflows when considered as a signed

 32446 +     number one bit larger than the field.  ie. A bitfield of N bits

 32447 +     is allowed to represent -2**n to 2**n-1.  */

 32448 +  complain_overflow_bitfield,

 32449 +

 32450 +  /* Complain if the value overflows when considered as a signed

 32451 +     number.  */

 32452 +  complain_overflow_signed,

 32453 +

 32454 +  /* Complain if the value overflows when considered as an

 32455 +     unsigned number.  */

 32456 +  complain_overflow_unsigned

 32457 +};

 32458 +

 32459 +struct reloc_howto_struct

 32460 +{

 32461 +  /*  The type field has mainly a documentary use - the back end can

 32462 +      do what it wants with it, though normally the back end's

 32463 +      external idea of what a reloc number is stored

 32464 +      in this field.  For example, a PC relative word relocation

 32465 +      in a coff environment has the type 023 - because that's

 32466 +      what the outside world calls a R_PCRWORD reloc.  */

 32467 +  unsigned int type;

 32468 +

 32469 +  /*  The value the final relocation is shifted right by.  This drops

 32470 +      unwanted data from the relocation.  */

 32471 +  unsigned int rightshift;

 32472 +

 32473 +  /*  The size of the item to be relocated.  This is *not* a

 32474 +      power-of-two measure.  To get the number of bytes operated

 32475 +      on by a type of relocation, use bfd_get_reloc_size.  */

 32476 +  int size;

 32477 +

 32478 +  /*  The number of bits in the item to be relocated.  This is used

 32479 +      when doing overflow checking.  */

 32480 +  unsigned int bitsize;

 32481 +

 32482 +  /*  Notes that the relocation is relative to the location in the

 32483 +      data section of the addend.  The relocation function will

 32484 +      subtract from the relocation value the address of the location

 32485 +      being relocated.  */

 32486 +  bfd_boolean pc_relative;

 32487 +

 32488 +  /*  The bit position of the reloc value in the destination.

 32489 +      The relocated value is left shifted by this amount.  */

 32490 +  unsigned int bitpos;

 32491 +

 32492 +  /* What type of overflow error should be checked for when

 32493 +     relocating.  */

 32494 +  enum complain_overflow complain_on_overflow;

 32495 +

 32496 +  /* If this field is non null, then the supplied function is

 32497 +     called rather than the normal function.  This allows really

 32498 +     strange relocation methods to be accommodated (e.g., i960 callj

 32499 +     instructions).  */

 32500 +  bfd_reloc_status_type (*special_function)

 32501 +    (bfd *, arelent *, struct bfd_symbol *, void *, asection *,

 32502 +     bfd *, char **);

 32503 +

 32504 +  /* The textual name of the relocation type.  */

 32505 +  char *name;

 32506 +

 32507 +  /* Some formats record a relocation addend in the section contents

 32508 +     rather than with the relocation.  For ELF formats this is the

 32509 +     distinction between USE_REL and USE_RELA (though the code checks

 32510 +     for USE_REL == 1/0).  The value of this field is TRUE if the

 32511 +     addend is recorded with the section contents; when performing a

 32512 +     partial link (ld -r) the section contents (the data) will be

 32513 +     modified.  The value of this field is FALSE if addends are

 32514 +     recorded with the relocation (in arelent.addend); when performing

 32515 +     a partial link the relocation will be modified.

 32516 +     All relocations for all ELF USE_RELA targets should set this field

 32517 +     to FALSE (values of TRUE should be looked on with suspicion).

 32518 +     However, the converse is not true: not all relocations of all ELF

 32519 +     USE_REL targets set this field to TRUE.  Why this is so is peculiar

 32520 +     to each particular target.  For relocs that aren't used in partial

 32521 +     links (e.g. GOT stuff) it doesn't matter what this is set to.  */

 32522 +  bfd_boolean partial_inplace;

 32523 +

 32524 +  /* src_mask selects the part of the instruction (or data) to be used

 32525 +     in the relocation sum.  If the target relocations don't have an

 32526 +     addend in the reloc, eg. ELF USE_REL, src_mask will normally equal

 32527 +     dst_mask to extract the addend from the section contents.  If

 32528 +     relocations do have an addend in the reloc, eg. ELF USE_RELA, this

 32529 +     field should be zero.  Non-zero values for ELF USE_RELA targets are

 32530 +     bogus as in those cases the value in the dst_mask part of the

 32531 +     section contents should be treated as garbage.  */

 32532 +  bfd_vma src_mask;

 32533 +

 32534 +  /* dst_mask selects which parts of the instruction (or data) are

 32535 +     replaced with a relocated value.  */

 32536 +  bfd_vma dst_mask;

 32537 +

 32538 +  /* When some formats create PC relative instructions, they leave

 32539 +     the value of the pc of the place being relocated in the offset

 32540 +     slot of the instruction, so that a PC relative relocation can

 32541 +     be made just by adding in an ordinary offset (e.g., sun3 a.out).

 32542 +     Some formats leave the displacement part of an instruction

 32543 +     empty (e.g., m88k bcs); this flag signals the fact.  */

 32544 +  bfd_boolean pcrel_offset;

 32545 +};

 32546 +

 32547 +#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \

 32548 +  { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC }

 32549 +#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \

 32550 +  HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \

 32551 +         NAME, FALSE, 0, 0, IN)

 32552 +

 32553 +#define EMPTY_HOWTO(C) \

 32554 +  HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \

 32555 +         NULL, FALSE, 0, 0, FALSE)

 32556 +

 32557 +#define HOWTO_PREPARE(relocation, symbol)               \

 32558 +  {                                                     \

 32559 +    if (symbol != NULL)                                 \

 32560 +      {                                                 \

 32561 +        if (bfd_is_com_section (symbol->section))       \

 32562 +          {                                             \

 32563 +            relocation = 0;                             \

 32564 +          }                                             \

 32565 +        else                                            \

 32566 +          {                                             \

 32567 +            relocation = symbol->value;                 \

 32568 +          }                                             \

 32569 +      }                                                 \

 32570 +  }

 32571 +

 32572 +unsigned int bfd_get_reloc_size (reloc_howto_type *);

 32573 +

 32574 +typedef struct relent_chain

 32575 +{

 32576 +  arelent relent;

 32577 +  struct relent_chain *next;

 32578 +}

 32579 +arelent_chain;

 32580 +

 32581 +bfd_reloc_status_type bfd_check_overflow

 32582 +   (enum complain_overflow how,

 32583 +    unsigned int bitsize,

 32584 +    unsigned int rightshift,

 32585 +    unsigned int addrsize,

 32586 +    bfd_vma relocation);

 32587 +

 32588 +bfd_reloc_status_type bfd_perform_relocation

 32589 +   (bfd *abfd,

 32590 +    arelent *reloc_entry,

 32591 +    void *data,

 32592 +    asection *input_section,

 32593 +    bfd *output_bfd,

 32594 +    char **error_message);

 32595 +

 32596 +bfd_reloc_status_type bfd_install_relocation

 32597 +   (bfd *abfd,

 32598 +    arelent *reloc_entry,

 32599 +    void *data, bfd_vma data_start,

 32600 +    asection *input_section,

 32601 +    char **error_message);

 32602 +

 32603 +enum bfd_reloc_code_real {

 32604 +  _dummy_first_bfd_reloc_code_real,

 32605 +

 32606 +

 32607 +/* Basic absolute relocations of N bits.  */

 32608 +  BFD_RELOC_64,

 32609 +  BFD_RELOC_32,

 32610 +  BFD_RELOC_26,

 32611 +  BFD_RELOC_24,

 32612 +  BFD_RELOC_16,

 32613 +  BFD_RELOC_14,

 32614 +  BFD_RELOC_8,

 32615 +

 32616 +/* PC-relative relocations.  Sometimes these are relative to the address

 32617 +of the relocation itself; sometimes they are relative to the start of

 32618 +the section containing the relocation.  It depends on the specific target.

 32619 +

 32620 +The 24-bit relocation is used in some Intel 960 configurations.  */

 32621 +  BFD_RELOC_64_PCREL,

 32622 +  BFD_RELOC_32_PCREL,

 32623 +  BFD_RELOC_24_PCREL,

 32624 +  BFD_RELOC_16_PCREL,

 32625 +  BFD_RELOC_12_PCREL,

 32626 +  BFD_RELOC_8_PCREL,

 32627 +

 32628 +/* Section relative relocations.  Some targets need this for DWARF2.  */

 32629 +  BFD_RELOC_32_SECREL,

 32630 +

 32631 +/* For ELF.  */

 32632 +  BFD_RELOC_32_GOT_PCREL,

 32633 +  BFD_RELOC_16_GOT_PCREL,

 32634 +  BFD_RELOC_8_GOT_PCREL,

 32635 +  BFD_RELOC_32_GOTOFF,

 32636 +  BFD_RELOC_16_GOTOFF,

 32637 +  BFD_RELOC_LO16_GOTOFF,

 32638 +  BFD_RELOC_HI16_GOTOFF,

 32639 +  BFD_RELOC_HI16_S_GOTOFF,

 32640 +  BFD_RELOC_8_GOTOFF,

 32641 +  BFD_RELOC_64_PLT_PCREL,

 32642 +  BFD_RELOC_32_PLT_PCREL,

 32643 +  BFD_RELOC_24_PLT_PCREL,

 32644 +  BFD_RELOC_16_PLT_PCREL,

 32645 +  BFD_RELOC_8_PLT_PCREL,

 32646 +  BFD_RELOC_64_PLTOFF,

 32647 +  BFD_RELOC_32_PLTOFF,

 32648 +  BFD_RELOC_16_PLTOFF,

 32649 +  BFD_RELOC_LO16_PLTOFF,

 32650 +  BFD_RELOC_HI16_PLTOFF,

 32651 +  BFD_RELOC_HI16_S_PLTOFF,

 32652 +  BFD_RELOC_8_PLTOFF,

 32653 +

 32654 +/* Relocations used by 68K ELF.  */

 32655 +  BFD_RELOC_68K_GLOB_DAT,

 32656 +  BFD_RELOC_68K_JMP_SLOT,

 32657 +  BFD_RELOC_68K_RELATIVE,

 32658 +

 32659 +/* Linkage-table relative.  */

 32660 +  BFD_RELOC_32_BASEREL,

 32661 +  BFD_RELOC_16_BASEREL,

 32662 +  BFD_RELOC_LO16_BASEREL,

 32663 +  BFD_RELOC_HI16_BASEREL,

 32664 +  BFD_RELOC_HI16_S_BASEREL,

 32665 +  BFD_RELOC_8_BASEREL,

 32666 +  BFD_RELOC_RVA,

 32667 +

 32668 +/* Absolute 8-bit relocation, but used to form an address like 0xFFnn.  */

 32669 +  BFD_RELOC_8_FFnn,

 32670 +

 32671 +/* These PC-relative relocations are stored as word displacements --

 32672 +i.e., byte displacements shifted right two bits.  The 30-bit word

 32673 +displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the

 32674 +SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The

 32675 +signed 16-bit displacement is used on the MIPS, and the 23-bit

 32676 +displacement is used on the Alpha.  */

 32677 +  BFD_RELOC_32_PCREL_S2,

 32678 +  BFD_RELOC_16_PCREL_S2,

 32679 +  BFD_RELOC_23_PCREL_S2,

 32680 +

 32681 +/* High 22 bits and low 10 bits of 32-bit value, placed into lower bits of

 32682 +the target word.  These are used on the SPARC.  */

 32683 +  BFD_RELOC_HI22,

 32684 +  BFD_RELOC_LO10,

 32685 +

 32686 +/* For systems that allocate a Global Pointer register, these are

 32687 +displacements off that register.  These relocation types are

 32688 +handled specially, because the value the register will have is

 32689 +decided relatively late.  */

 32690 +  BFD_RELOC_GPREL16,

 32691 +  BFD_RELOC_GPREL32,

 32692 +

 32693 +/* Reloc types used for i960/b.out.  */

 32694 +  BFD_RELOC_I960_CALLJ,

 32695 +

 32696 +/* SPARC ELF relocations.  There is probably some overlap with other

 32697 +relocation types already defined.  */

 32698 +  BFD_RELOC_NONE,

 32699 +  BFD_RELOC_SPARC_WDISP22,

 32700 +  BFD_RELOC_SPARC22,

 32701 +  BFD_RELOC_SPARC13,

 32702 +  BFD_RELOC_SPARC_GOT10,

 32703 +  BFD_RELOC_SPARC_GOT13,

 32704 +  BFD_RELOC_SPARC_GOT22,

 32705 +  BFD_RELOC_SPARC_PC10,

 32706 +  BFD_RELOC_SPARC_PC22,

 32707 +  BFD_RELOC_SPARC_WPLT30,

 32708 +  BFD_RELOC_SPARC_COPY,

 32709 +  BFD_RELOC_SPARC_GLOB_DAT,

 32710 +  BFD_RELOC_SPARC_JMP_SLOT,

 32711 +  BFD_RELOC_SPARC_RELATIVE,

 32712 +  BFD_RELOC_SPARC_UA16,

 32713 +  BFD_RELOC_SPARC_UA32,

 32714 +  BFD_RELOC_SPARC_UA64,

 32715 +

 32716 +/* I think these are specific to SPARC a.out (e.g., Sun 4).  */

 32717 +  BFD_RELOC_SPARC_BASE13,

 32718 +  BFD_RELOC_SPARC_BASE22,

 32719 +

 32720 +/* SPARC64 relocations  */

 32721 +#define BFD_RELOC_SPARC_64 BFD_RELOC_64

 32722 +  BFD_RELOC_SPARC_10,

 32723 +  BFD_RELOC_SPARC_11,

 32724 +  BFD_RELOC_SPARC_OLO10,

 32725 +  BFD_RELOC_SPARC_HH22,

 32726 +  BFD_RELOC_SPARC_HM10,

 32727 +  BFD_RELOC_SPARC_LM22,

 32728 +  BFD_RELOC_SPARC_PC_HH22,

 32729 +  BFD_RELOC_SPARC_PC_HM10,

 32730 +  BFD_RELOC_SPARC_PC_LM22,

 32731 +  BFD_RELOC_SPARC_WDISP16,

 32732 +  BFD_RELOC_SPARC_WDISP19,

 32733 +  BFD_RELOC_SPARC_7,

 32734 +  BFD_RELOC_SPARC_6,

 32735 +  BFD_RELOC_SPARC_5,

 32736 +#define BFD_RELOC_SPARC_DISP64 BFD_RELOC_64_PCREL

 32737 +  BFD_RELOC_SPARC_PLT32,

 32738 +  BFD_RELOC_SPARC_PLT64,

 32739 +  BFD_RELOC_SPARC_HIX22,

 32740 +  BFD_RELOC_SPARC_LOX10,

 32741 +  BFD_RELOC_SPARC_H44,

 32742 +  BFD_RELOC_SPARC_M44,

 32743 +  BFD_RELOC_SPARC_L44,

 32744 +  BFD_RELOC_SPARC_REGISTER,

 32745 +

 32746 +/* SPARC little endian relocation  */

 32747 +  BFD_RELOC_SPARC_REV32,

 32748 +

 32749 +/* SPARC TLS relocations  */

 32750 +  BFD_RELOC_SPARC_TLS_GD_HI22,

 32751 +  BFD_RELOC_SPARC_TLS_GD_LO10,

 32752 +  BFD_RELOC_SPARC_TLS_GD_ADD,

 32753 +  BFD_RELOC_SPARC_TLS_GD_CALL,

 32754 +  BFD_RELOC_SPARC_TLS_LDM_HI22,

 32755 +  BFD_RELOC_SPARC_TLS_LDM_LO10,

 32756 +  BFD_RELOC_SPARC_TLS_LDM_ADD,

 32757 +  BFD_RELOC_SPARC_TLS_LDM_CALL,

 32758 +  BFD_RELOC_SPARC_TLS_LDO_HIX22,

 32759 +  BFD_RELOC_SPARC_TLS_LDO_LOX10,

 32760 +  BFD_RELOC_SPARC_TLS_LDO_ADD,

 32761 +  BFD_RELOC_SPARC_TLS_IE_HI22,

 32762 +  BFD_RELOC_SPARC_TLS_IE_LO10,

 32763 +  BFD_RELOC_SPARC_TLS_IE_LD,

 32764 +  BFD_RELOC_SPARC_TLS_IE_LDX,

 32765 +  BFD_RELOC_SPARC_TLS_IE_ADD,

 32766 +  BFD_RELOC_SPARC_TLS_LE_HIX22,

 32767 +  BFD_RELOC_SPARC_TLS_LE_LOX10,

 32768 +  BFD_RELOC_SPARC_TLS_DTPMOD32,

 32769 +  BFD_RELOC_SPARC_TLS_DTPMOD64,

 32770 +  BFD_RELOC_SPARC_TLS_DTPOFF32,

 32771 +  BFD_RELOC_SPARC_TLS_DTPOFF64,

 32772 +  BFD_RELOC_SPARC_TLS_TPOFF32,

 32773 +  BFD_RELOC_SPARC_TLS_TPOFF64,

 32774 +

 32775 +/* SPU Relocations.  */

 32776 +  BFD_RELOC_SPU_IMM7,

 32777 +  BFD_RELOC_SPU_IMM8,

 32778 +  BFD_RELOC_SPU_IMM10,

 32779 +  BFD_RELOC_SPU_IMM10W,

 32780 +  BFD_RELOC_SPU_IMM16,

 32781 +  BFD_RELOC_SPU_IMM16W,

 32782 +  BFD_RELOC_SPU_IMM18,

 32783 +  BFD_RELOC_SPU_PCREL9a,

 32784 +  BFD_RELOC_SPU_PCREL9b,

 32785 +  BFD_RELOC_SPU_PCREL16,

 32786 +  BFD_RELOC_SPU_LO16,

 32787 +  BFD_RELOC_SPU_HI16,

 32788 +  BFD_RELOC_SPU_PPU32,

 32789 +  BFD_RELOC_SPU_PPU64,

 32790 +

 32791 +/* Alpha ECOFF and ELF relocations.  Some of these treat the symbol or

 32792 +"addend" in some special way.

 32793 +For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when

 32794 +writing; when reading, it will be the absolute section symbol.  The

 32795 +addend is the displacement in bytes of the "lda" instruction from

 32796 +the "ldah" instruction (which is at the address of this reloc).  */

 32797 +  BFD_RELOC_ALPHA_GPDISP_HI16,

 32798 +

 32799 +/* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as

 32800 +with GPDISP_HI16 relocs.  The addend is ignored when writing the

 32801 +relocations out, and is filled in with the file's GP value on

 32802 +reading, for convenience.  */

 32803 +  BFD_RELOC_ALPHA_GPDISP_LO16,

 32804 +

 32805 +/* The ELF GPDISP relocation is exactly the same as the GPDISP_HI16

 32806 +relocation except that there is no accompanying GPDISP_LO16

 32807 +relocation.  */

 32808 +  BFD_RELOC_ALPHA_GPDISP,

 32809 +

 32810 +/* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;

 32811 +the assembler turns it into a LDQ instruction to load the address of

 32812 +the symbol, and then fills in a register in the real instruction.

 32813 +

 32814 +The LITERAL reloc, at the LDQ instruction, refers to the .lita

 32815 +section symbol.  The addend is ignored when writing, but is filled

 32816 +in with the file's GP value on reading, for convenience, as with the

 32817 +GPDISP_LO16 reloc.

 32818 +

 32819 +The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.

 32820 +It should refer to the symbol to be referenced, as with 16_GOTOFF,

 32821 +but it generates output not based on the position within the .got

 32822 +section, but relative to the GP value chosen for the file during the

 32823 +final link stage.

 32824 +

 32825 +The LITUSE reloc, on the instruction using the loaded address, gives

 32826 +information to the linker that it might be able to use to optimize

 32827 +away some literal section references.  The symbol is ignored (read

 32828 +as the absolute section symbol), and the "addend" indicates the type

 32829 +of instruction using the register:

 32830 +1 - "memory" fmt insn

 32831 +2 - byte-manipulation (byte offset reg)

 32832 +3 - jsr (target of branch)  */

 32833 +  BFD_RELOC_ALPHA_LITERAL,

 32834 +  BFD_RELOC_ALPHA_ELF_LITERAL,

 32835 +  BFD_RELOC_ALPHA_LITUSE,

 32836 +

 32837 +/* The HINT relocation indicates a value that should be filled into the

 32838 +"hint" field of a jmp/jsr/ret instruction, for possible branch-

 32839 +prediction logic which may be provided on some processors.  */

 32840 +  BFD_RELOC_ALPHA_HINT,

 32841 +

 32842 +/* The LINKAGE relocation outputs a linkage pair in the object file,

 32843 +which is filled by the linker.  */

 32844 +  BFD_RELOC_ALPHA_LINKAGE,

 32845 +

 32846 +/* The CODEADDR relocation outputs a STO_CA in the object file,

 32847 +which is filled by the linker.  */

 32848 +  BFD_RELOC_ALPHA_CODEADDR,

 32849 +

 32850 +/* The GPREL_HI/LO relocations together form a 32-bit offset from the

 32851 +GP register.  */

 32852 +  BFD_RELOC_ALPHA_GPREL_HI16,

 32853 +  BFD_RELOC_ALPHA_GPREL_LO16,

 32854 +

 32855 +/* Like BFD_RELOC_23_PCREL_S2, except that the source and target must

 32856 +share a common GP, and the target address is adjusted for

 32857 +STO_ALPHA_STD_GPLOAD.  */

 32858 +  BFD_RELOC_ALPHA_BRSGP,

 32859 +

 32860 +/* Alpha thread-local storage relocations.  */

 32861 +  BFD_RELOC_ALPHA_TLSGD,

 32862 +  BFD_RELOC_ALPHA_TLSLDM,

 32863 +  BFD_RELOC_ALPHA_DTPMOD64,

 32864 +  BFD_RELOC_ALPHA_GOTDTPREL16,

 32865 +  BFD_RELOC_ALPHA_DTPREL64,

 32866 +  BFD_RELOC_ALPHA_DTPREL_HI16,

 32867 +  BFD_RELOC_ALPHA_DTPREL_LO16,

 32868 +  BFD_RELOC_ALPHA_DTPREL16,

 32869 +  BFD_RELOC_ALPHA_GOTTPREL16,

 32870 +  BFD_RELOC_ALPHA_TPREL64,

 32871 +  BFD_RELOC_ALPHA_TPREL_HI16,

 32872 +  BFD_RELOC_ALPHA_TPREL_LO16,

 32873 +  BFD_RELOC_ALPHA_TPREL16,

 32874 +

 32875 +/* Bits 27..2 of the relocation address shifted right 2 bits;

 32876 +simple reloc otherwise.  */

 32877 +  BFD_RELOC_MIPS_JMP,

 32878 +

 32879 +/* The MIPS16 jump instruction.  */

 32880 +  BFD_RELOC_MIPS16_JMP,

 32881 +

 32882 +/* MIPS16 GP relative reloc.  */

 32883 +  BFD_RELOC_MIPS16_GPREL,

 32884 +

 32885 +/* High 16 bits of 32-bit value; simple reloc.  */

 32886 +  BFD_RELOC_HI16,

 32887 +

 32888 +/* High 16 bits of 32-bit value but the low 16 bits will be sign

 32889 +extended and added to form the final result.  If the low 16

 32890 +bits form a negative number, we need to add one to the high value

 32891 +to compensate for the borrow when the low bits are added.  */

 32892 +  BFD_RELOC_HI16_S,

 32893 +

 32894 +/* Low 16 bits.  */

 32895 +  BFD_RELOC_LO16,

 32896 +

 32897 +/* High 16 bits of 32-bit pc-relative value  */

 32898 +  BFD_RELOC_HI16_PCREL,

 32899 +

 32900 +/* High 16 bits of 32-bit pc-relative value, adjusted  */

 32901 +  BFD_RELOC_HI16_S_PCREL,

 32902 +

 32903 +/* Low 16 bits of pc-relative value  */

 32904 +  BFD_RELOC_LO16_PCREL,

 32905 +

 32906 +/* MIPS16 high 16 bits of 32-bit value.  */

 32907 +  BFD_RELOC_MIPS16_HI16,

 32908 +

 32909 +/* MIPS16 high 16 bits of 32-bit value but the low 16 bits will be sign

 32910 +extended and added to form the final result.  If the low 16

 32911 +bits form a negative number, we need to add one to the high value

 32912 +to compensate for the borrow when the low bits are added.  */

 32913 +  BFD_RELOC_MIPS16_HI16_S,

 32914 +

 32915 +/* MIPS16 low 16 bits.  */

 32916 +  BFD_RELOC_MIPS16_LO16,

 32917 +

 32918 +/* Relocation against a MIPS literal section.  */

 32919 +  BFD_RELOC_MIPS_LITERAL,

 32920 +

 32921 +/* MIPS ELF relocations.  */

 32922 +  BFD_RELOC_MIPS_GOT16,

 32923 +  BFD_RELOC_MIPS_CALL16,

 32924 +  BFD_RELOC_MIPS_GOT_HI16,

 32925 +  BFD_RELOC_MIPS_GOT_LO16,

 32926 +  BFD_RELOC_MIPS_CALL_HI16,

 32927 +  BFD_RELOC_MIPS_CALL_LO16,

 32928 +  BFD_RELOC_MIPS_SUB,

 32929 +  BFD_RELOC_MIPS_GOT_PAGE,

 32930 +  BFD_RELOC_MIPS_GOT_OFST,

 32931 +  BFD_RELOC_MIPS_GOT_DISP,

 32932 +  BFD_RELOC_MIPS_SHIFT5,

 32933 +  BFD_RELOC_MIPS_SHIFT6,

 32934 +  BFD_RELOC_MIPS_INSERT_A,

 32935 +  BFD_RELOC_MIPS_INSERT_B,

 32936 +  BFD_RELOC_MIPS_DELETE,

 32937 +  BFD_RELOC_MIPS_HIGHEST,

 32938 +  BFD_RELOC_MIPS_HIGHER,

 32939 +  BFD_RELOC_MIPS_SCN_DISP,

 32940 +  BFD_RELOC_MIPS_REL16,

 32941 +  BFD_RELOC_MIPS_RELGOT,

 32942 +  BFD_RELOC_MIPS_JALR,

 32943 +  BFD_RELOC_MIPS_TLS_DTPMOD32,

 32944 +  BFD_RELOC_MIPS_TLS_DTPREL32,

 32945 +  BFD_RELOC_MIPS_TLS_DTPMOD64,

 32946 +  BFD_RELOC_MIPS_TLS_DTPREL64,

 32947 +  BFD_RELOC_MIPS_TLS_GD,

 32948 +  BFD_RELOC_MIPS_TLS_LDM,

 32949 +  BFD_RELOC_MIPS_TLS_DTPREL_HI16,

 32950 +  BFD_RELOC_MIPS_TLS_DTPREL_LO16,

 32951 +  BFD_RELOC_MIPS_TLS_GOTTPREL,

 32952 +  BFD_RELOC_MIPS_TLS_TPREL32,

 32953 +  BFD_RELOC_MIPS_TLS_TPREL64,

 32954 +  BFD_RELOC_MIPS_TLS_TPREL_HI16,

 32955 +  BFD_RELOC_MIPS_TLS_TPREL_LO16,

 32956 +

 32957 +

 32958 +/* MIPS ELF relocations (VxWorks extensions).  */

 32959 +  BFD_RELOC_MIPS_COPY,

 32960 +  BFD_RELOC_MIPS_JUMP_SLOT,

 32961 +

 32962 +

 32963 +/* Fujitsu Frv Relocations.  */

 32964 +  BFD_RELOC_FRV_LABEL16,

 32965 +  BFD_RELOC_FRV_LABEL24,

 32966 +  BFD_RELOC_FRV_LO16,

 32967 +  BFD_RELOC_FRV_HI16,

 32968 +  BFD_RELOC_FRV_GPREL12,

 32969 +  BFD_RELOC_FRV_GPRELU12,

 32970 +  BFD_RELOC_FRV_GPREL32,

 32971 +  BFD_RELOC_FRV_GPRELHI,

 32972 +  BFD_RELOC_FRV_GPRELLO,

 32973 +  BFD_RELOC_FRV_GOT12,

 32974 +  BFD_RELOC_FRV_GOTHI,

 32975 +  BFD_RELOC_FRV_GOTLO,

 32976 +  BFD_RELOC_FRV_FUNCDESC,

 32977 +  BFD_RELOC_FRV_FUNCDESC_GOT12,

 32978 +  BFD_RELOC_FRV_FUNCDESC_GOTHI,

 32979 +  BFD_RELOC_FRV_FUNCDESC_GOTLO,

 32980 +  BFD_RELOC_FRV_FUNCDESC_VALUE,

 32981 +  BFD_RELOC_FRV_FUNCDESC_GOTOFF12,

 32982 +  BFD_RELOC_FRV_FUNCDESC_GOTOFFHI,

 32983 +  BFD_RELOC_FRV_FUNCDESC_GOTOFFLO,

 32984 +  BFD_RELOC_FRV_GOTOFF12,

 32985 +  BFD_RELOC_FRV_GOTOFFHI,

 32986 +  BFD_RELOC_FRV_GOTOFFLO,

 32987 +  BFD_RELOC_FRV_GETTLSOFF,

 32988 +  BFD_RELOC_FRV_TLSDESC_VALUE,

 32989 +  BFD_RELOC_FRV_GOTTLSDESC12,

 32990 +  BFD_RELOC_FRV_GOTTLSDESCHI,

 32991 +  BFD_RELOC_FRV_GOTTLSDESCLO,

 32992 +  BFD_RELOC_FRV_TLSMOFF12,

 32993 +  BFD_RELOC_FRV_TLSMOFFHI,

 32994 +  BFD_RELOC_FRV_TLSMOFFLO,

 32995 +  BFD_RELOC_FRV_GOTTLSOFF12,

 32996 +  BFD_RELOC_FRV_GOTTLSOFFHI,

 32997 +  BFD_RELOC_FRV_GOTTLSOFFLO,

 32998 +  BFD_RELOC_FRV_TLSOFF,

 32999 +  BFD_RELOC_FRV_TLSDESC_RELAX,

 33000 +  BFD_RELOC_FRV_GETTLSOFF_RELAX,

 33001 +  BFD_RELOC_FRV_TLSOFF_RELAX,

 33002 +  BFD_RELOC_FRV_TLSMOFF,

 33003 +

 33004 +

 33005 +/* This is a 24bit GOT-relative reloc for the mn10300.  */

 33006 +  BFD_RELOC_MN10300_GOTOFF24,

 33007 +

 33008 +/* This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes

 33009 +in the instruction.  */

 33010 +  BFD_RELOC_MN10300_GOT32,

 33011 +

 33012 +/* This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes

 33013 +in the instruction.  */

 33014 +  BFD_RELOC_MN10300_GOT24,

 33015 +

 33016 +/* This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes

 33017 +in the instruction.  */

 33018 +  BFD_RELOC_MN10300_GOT16,

 33019 +

 33020 +/* Copy symbol at runtime.  */

 33021 +  BFD_RELOC_MN10300_COPY,

 33022 +

 33023 +/* Create GOT entry.  */

 33024 +  BFD_RELOC_MN10300_GLOB_DAT,

 33025 +

 33026 +/* Create PLT entry.  */

 33027 +  BFD_RELOC_MN10300_JMP_SLOT,

 33028 +

 33029 +/* Adjust by program base.  */

 33030 +  BFD_RELOC_MN10300_RELATIVE,

 33031 +

 33032 +

 33033 +/* i386/elf relocations  */

 33034 +  BFD_RELOC_386_GOT32,

 33035 +  BFD_RELOC_386_PLT32,

 33036 +  BFD_RELOC_386_COPY,

 33037 +  BFD_RELOC_386_GLOB_DAT,

 33038 +  BFD_RELOC_386_JUMP_SLOT,

 33039 +  BFD_RELOC_386_RELATIVE,

 33040 +  BFD_RELOC_386_GOTOFF,

 33041 +  BFD_RELOC_386_GOTPC,

 33042 +  BFD_RELOC_386_TLS_TPOFF,

 33043 +  BFD_RELOC_386_TLS_IE,

 33044 +  BFD_RELOC_386_TLS_GOTIE,

 33045 +  BFD_RELOC_386_TLS_LE,

 33046 +  BFD_RELOC_386_TLS_GD,

 33047 +  BFD_RELOC_386_TLS_LDM,

 33048 +  BFD_RELOC_386_TLS_LDO_32,

 33049 +  BFD_RELOC_386_TLS_IE_32,

 33050 +  BFD_RELOC_386_TLS_LE_32,

 33051 +  BFD_RELOC_386_TLS_DTPMOD32,

 33052 +  BFD_RELOC_386_TLS_DTPOFF32,

 33053 +  BFD_RELOC_386_TLS_TPOFF32,

 33054 +  BFD_RELOC_386_TLS_GOTDESC,

 33055 +  BFD_RELOC_386_TLS_DESC_CALL,

 33056 +  BFD_RELOC_386_TLS_DESC,

 33057 +

 33058 +/* x86-64/elf relocations  */

 33059 +  BFD_RELOC_X86_64_GOT32,

 33060 +  BFD_RELOC_X86_64_PLT32,

 33061 +  BFD_RELOC_X86_64_COPY,

 33062 +  BFD_RELOC_X86_64_GLOB_DAT,

 33063 +  BFD_RELOC_X86_64_JUMP_SLOT,

 33064 +  BFD_RELOC_X86_64_RELATIVE,

 33065 +  BFD_RELOC_X86_64_GOTPCREL,

 33066 +  BFD_RELOC_X86_64_32S,

 33067 +  BFD_RELOC_X86_64_DTPMOD64,

 33068 +  BFD_RELOC_X86_64_DTPOFF64,

 33069 +  BFD_RELOC_X86_64_TPOFF64,

 33070 +  BFD_RELOC_X86_64_TLSGD,

 33071 +  BFD_RELOC_X86_64_TLSLD,

 33072 +  BFD_RELOC_X86_64_DTPOFF32,

 33073 +  BFD_RELOC_X86_64_GOTTPOFF,

 33074 +  BFD_RELOC_X86_64_TPOFF32,

 33075 +  BFD_RELOC_X86_64_GOTOFF64,

 33076 +  BFD_RELOC_X86_64_GOTPC32,

 33077 +  BFD_RELOC_X86_64_GOT64,

 33078 +  BFD_RELOC_X86_64_GOTPCREL64,

 33079 +  BFD_RELOC_X86_64_GOTPC64,

 33080 +  BFD_RELOC_X86_64_GOTPLT64,

 33081 +  BFD_RELOC_X86_64_PLTOFF64,

 33082 +  BFD_RELOC_X86_64_GOTPC32_TLSDESC,

 33083 +  BFD_RELOC_X86_64_TLSDESC_CALL,

 33084 +  BFD_RELOC_X86_64_TLSDESC,

 33085 +

 33086 +/* ns32k relocations  */

 33087 +  BFD_RELOC_NS32K_IMM_8,

 33088 +  BFD_RELOC_NS32K_IMM_16,

 33089 +  BFD_RELOC_NS32K_IMM_32,

 33090 +  BFD_RELOC_NS32K_IMM_8_PCREL,

 33091 +  BFD_RELOC_NS32K_IMM_16_PCREL,

 33092 +  BFD_RELOC_NS32K_IMM_32_PCREL,

 33093 +  BFD_RELOC_NS32K_DISP_8,

 33094 +  BFD_RELOC_NS32K_DISP_16,

 33095 +  BFD_RELOC_NS32K_DISP_32,

 33096 +  BFD_RELOC_NS32K_DISP_8_PCREL,

 33097 +  BFD_RELOC_NS32K_DISP_16_PCREL,

 33098 +  BFD_RELOC_NS32K_DISP_32_PCREL,

 33099 +

 33100 +/* PDP11 relocations  */

 33101 +  BFD_RELOC_PDP11_DISP_8_PCREL,

 33102 +  BFD_RELOC_PDP11_DISP_6_PCREL,

 33103 +

 33104 +/* Picojava relocs.  Not all of these appear in object files.  */

 33105 +  BFD_RELOC_PJ_CODE_HI16,

 33106 +  BFD_RELOC_PJ_CODE_LO16,

 33107 +  BFD_RELOC_PJ_CODE_DIR16,

 33108 +  BFD_RELOC_PJ_CODE_DIR32,

 33109 +  BFD_RELOC_PJ_CODE_REL16,

 33110 +  BFD_RELOC_PJ_CODE_REL32,

 33111 +

 33112 +/* Power(rs6000) and PowerPC relocations.  */

 33113 +  BFD_RELOC_PPC_B26,

 33114 +  BFD_RELOC_PPC_BA26,

 33115 +  BFD_RELOC_PPC_TOC16,

 33116 +  BFD_RELOC_PPC_B16,

 33117 +  BFD_RELOC_PPC_B16_BRTAKEN,

 33118 +  BFD_RELOC_PPC_B16_BRNTAKEN,

 33119 +  BFD_RELOC_PPC_BA16,

 33120 +  BFD_RELOC_PPC_BA16_BRTAKEN,

 33121 +  BFD_RELOC_PPC_BA16_BRNTAKEN,

 33122 +  BFD_RELOC_PPC_COPY,

 33123 +  BFD_RELOC_PPC_GLOB_DAT,

 33124 +  BFD_RELOC_PPC_JMP_SLOT,

 33125 +  BFD_RELOC_PPC_RELATIVE,

 33126 +  BFD_RELOC_PPC_LOCAL24PC,

 33127 +  BFD_RELOC_PPC_EMB_NADDR32,

 33128 +  BFD_RELOC_PPC_EMB_NADDR16,

 33129 +  BFD_RELOC_PPC_EMB_NADDR16_LO,

 33130 +  BFD_RELOC_PPC_EMB_NADDR16_HI,

 33131 +  BFD_RELOC_PPC_EMB_NADDR16_HA,

 33132 +  BFD_RELOC_PPC_EMB_SDAI16,

 33133 +  BFD_RELOC_PPC_EMB_SDA2I16,

 33134 +  BFD_RELOC_PPC_EMB_SDA2REL,

 33135 +  BFD_RELOC_PPC_EMB_SDA21,

 33136 +  BFD_RELOC_PPC_EMB_MRKREF,

 33137 +  BFD_RELOC_PPC_EMB_RELSEC16,

 33138 +  BFD_RELOC_PPC_EMB_RELST_LO,

 33139 +  BFD_RELOC_PPC_EMB_RELST_HI,

 33140 +  BFD_RELOC_PPC_EMB_RELST_HA,

 33141 +  BFD_RELOC_PPC_EMB_BIT_FLD,

 33142 +  BFD_RELOC_PPC_EMB_RELSDA,

 33143 +  BFD_RELOC_PPC64_HIGHER,

 33144 +  BFD_RELOC_PPC64_HIGHER_S,

 33145 +  BFD_RELOC_PPC64_HIGHEST,

 33146 +  BFD_RELOC_PPC64_HIGHEST_S,

 33147 +  BFD_RELOC_PPC64_TOC16_LO,

 33148 +  BFD_RELOC_PPC64_TOC16_HI,

 33149 +  BFD_RELOC_PPC64_TOC16_HA,

 33150 +  BFD_RELOC_PPC64_TOC,

 33151 +  BFD_RELOC_PPC64_PLTGOT16,

 33152 +  BFD_RELOC_PPC64_PLTGOT16_LO,

 33153 +  BFD_RELOC_PPC64_PLTGOT16_HI,

 33154 +  BFD_RELOC_PPC64_PLTGOT16_HA,

 33155 +  BFD_RELOC_PPC64_ADDR16_DS,

 33156 +  BFD_RELOC_PPC64_ADDR16_LO_DS,

 33157 +  BFD_RELOC_PPC64_GOT16_DS,

 33158 +  BFD_RELOC_PPC64_GOT16_LO_DS,

 33159 +  BFD_RELOC_PPC64_PLT16_LO_DS,

 33160 +  BFD_RELOC_PPC64_SECTOFF_DS,

 33161 +  BFD_RELOC_PPC64_SECTOFF_LO_DS,

 33162 +  BFD_RELOC_PPC64_TOC16_DS,

 33163 +  BFD_RELOC_PPC64_TOC16_LO_DS,

 33164 +  BFD_RELOC_PPC64_PLTGOT16_DS,

 33165 +  BFD_RELOC_PPC64_PLTGOT16_LO_DS,

 33166 +

 33167 +/* PowerPC and PowerPC64 thread-local storage relocations.  */

 33168 +  BFD_RELOC_PPC_TLS,

 33169 +  BFD_RELOC_PPC_DTPMOD,

 33170 +  BFD_RELOC_PPC_TPREL16,

 33171 +  BFD_RELOC_PPC_TPREL16_LO,

 33172 +  BFD_RELOC_PPC_TPREL16_HI,

 33173 +  BFD_RELOC_PPC_TPREL16_HA,

 33174 +  BFD_RELOC_PPC_TPREL,

 33175 +  BFD_RELOC_PPC_DTPREL16,

 33176 +  BFD_RELOC_PPC_DTPREL16_LO,

 33177 +  BFD_RELOC_PPC_DTPREL16_HI,

 33178 +  BFD_RELOC_PPC_DTPREL16_HA,

 33179 +  BFD_RELOC_PPC_DTPREL,

 33180 +  BFD_RELOC_PPC_GOT_TLSGD16,

 33181 +  BFD_RELOC_PPC_GOT_TLSGD16_LO,

 33182 +  BFD_RELOC_PPC_GOT_TLSGD16_HI,

 33183 +  BFD_RELOC_PPC_GOT_TLSGD16_HA,

 33184 +  BFD_RELOC_PPC_GOT_TLSLD16,

 33185 +  BFD_RELOC_PPC_GOT_TLSLD16_LO,

 33186 +  BFD_RELOC_PPC_GOT_TLSLD16_HI,

 33187 +  BFD_RELOC_PPC_GOT_TLSLD16_HA,

 33188 +  BFD_RELOC_PPC_GOT_TPREL16,

 33189 +  BFD_RELOC_PPC_GOT_TPREL16_LO,

 33190 +  BFD_RELOC_PPC_GOT_TPREL16_HI,

 33191 +  BFD_RELOC_PPC_GOT_TPREL16_HA,

 33192 +  BFD_RELOC_PPC_GOT_DTPREL16,

 33193 +  BFD_RELOC_PPC_GOT_DTPREL16_LO,

 33194 +  BFD_RELOC_PPC_GOT_DTPREL16_HI,

 33195 +  BFD_RELOC_PPC_GOT_DTPREL16_HA,

 33196 +  BFD_RELOC_PPC64_TPREL16_DS,

 33197 +  BFD_RELOC_PPC64_TPREL16_LO_DS,

 33198 +  BFD_RELOC_PPC64_TPREL16_HIGHER,

 33199 +  BFD_RELOC_PPC64_TPREL16_HIGHERA,

 33200 +  BFD_RELOC_PPC64_TPREL16_HIGHEST,

 33201 +  BFD_RELOC_PPC64_TPREL16_HIGHESTA,

 33202 +  BFD_RELOC_PPC64_DTPREL16_DS,

 33203 +  BFD_RELOC_PPC64_DTPREL16_LO_DS,

 33204 +  BFD_RELOC_PPC64_DTPREL16_HIGHER,

 33205 +  BFD_RELOC_PPC64_DTPREL16_HIGHERA,

 33206 +  BFD_RELOC_PPC64_DTPREL16_HIGHEST,

 33207 +  BFD_RELOC_PPC64_DTPREL16_HIGHESTA,

 33208 +

 33209 +/* IBM 370/390 relocations  */

 33210 +  BFD_RELOC_I370_D12,

 33211 +

 33212 +/* The type of reloc used to build a constructor table - at the moment

 33213 +probably a 32 bit wide absolute relocation, but the target can choose.

 33214 +It generally does map to one of the other relocation types.  */

 33215 +  BFD_RELOC_CTOR,

 33216 +

 33217 +/* ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are

 33218 +not stored in the instruction.  */

 33219 +  BFD_RELOC_ARM_PCREL_BRANCH,

 33220 +

 33221 +/* ARM 26 bit pc-relative branch.  The lowest bit must be zero and is

 33222 +not stored in the instruction.  The 2nd lowest bit comes from a 1 bit

 33223 +field in the instruction.  */

 33224 +  BFD_RELOC_ARM_PCREL_BLX,

 33225 +

 33226 +/* Thumb 22 bit pc-relative branch.  The lowest bit must be zero and is

 33227 +not stored in the instruction.  The 2nd lowest bit comes from a 1 bit

 33228 +field in the instruction.  */

 33229 +  BFD_RELOC_THUMB_PCREL_BLX,

 33230 +

 33231 +/* ARM 26-bit pc-relative branch for an unconditional BL or BLX instruction.  */

 33232 +  BFD_RELOC_ARM_PCREL_CALL,

 33233 +

 33234 +/* ARM 26-bit pc-relative branch for B or conditional BL instruction.  */

 33235 +  BFD_RELOC_ARM_PCREL_JUMP,

 33236 +

 33237 +/* Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches.

 33238 +The lowest bit must be zero and is not stored in the instruction.

 33239 +Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an

 33240 +"nn" one smaller in all cases.  Note further that BRANCH23

 33241 +corresponds to R_ARM_THM_CALL.  */

 33242 +  BFD_RELOC_THUMB_PCREL_BRANCH7,

 33243 +  BFD_RELOC_THUMB_PCREL_BRANCH9,

 33244 +  BFD_RELOC_THUMB_PCREL_BRANCH12,

 33245 +  BFD_RELOC_THUMB_PCREL_BRANCH20,

 33246 +  BFD_RELOC_THUMB_PCREL_BRANCH23,

 33247 +  BFD_RELOC_THUMB_PCREL_BRANCH25,

 33248 +

 33249 +/* 12-bit immediate offset, used in ARM-format ldr and str instructions.  */

 33250 +  BFD_RELOC_ARM_OFFSET_IMM,

 33251 +

 33252 +/* 5-bit immediate offset, used in Thumb-format ldr and str instructions.  */

 33253 +  BFD_RELOC_ARM_THUMB_OFFSET,

 33254 +

 33255 +/* Pc-relative or absolute relocation depending on target.  Used for

 33256 +entries in .init_array sections.  */

 33257 +  BFD_RELOC_ARM_TARGET1,

 33258 +

 33259 +/* Read-only segment base relative address.  */

 33260 +  BFD_RELOC_ARM_ROSEGREL32,

 33261 +

 33262 +/* Data segment base relative address.  */

 33263 +  BFD_RELOC_ARM_SBREL32,

 33264 +

 33265 +/* This reloc is used for references to RTTI data from exception handling

 33266 +tables.  The actual definition depends on the target.  It may be a

 33267 +pc-relative or some form of GOT-indirect relocation.  */

 33268 +  BFD_RELOC_ARM_TARGET2,

 33269 +

 33270 +/* 31-bit PC relative address.  */

 33271 +  BFD_RELOC_ARM_PREL31,

 33272 +

 33273 +/* Low and High halfword relocations for MOVW and MOVT instructions.  */

 33274 +  BFD_RELOC_ARM_MOVW,

 33275 +  BFD_RELOC_ARM_MOVT,

 33276 +  BFD_RELOC_ARM_MOVW_PCREL,

 33277 +  BFD_RELOC_ARM_MOVT_PCREL,

 33278 +  BFD_RELOC_ARM_THUMB_MOVW,

 33279 +  BFD_RELOC_ARM_THUMB_MOVT,

 33280 +  BFD_RELOC_ARM_THUMB_MOVW_PCREL,

 33281 +  BFD_RELOC_ARM_THUMB_MOVT_PCREL,

 33282 +

 33283 +/* Relocations for setting up GOTs and PLTs for shared libraries.  */

 33284 +  BFD_RELOC_ARM_JUMP_SLOT,

 33285 +  BFD_RELOC_ARM_GLOB_DAT,

 33286 +  BFD_RELOC_ARM_GOT32,

 33287 +  BFD_RELOC_ARM_PLT32,

 33288 +  BFD_RELOC_ARM_RELATIVE,

 33289 +  BFD_RELOC_ARM_GOTOFF,

 33290 +  BFD_RELOC_ARM_GOTPC,

 33291 +

 33292 +/* ARM thread-local storage relocations.  */

 33293 +  BFD_RELOC_ARM_TLS_GD32,

 33294 +  BFD_RELOC_ARM_TLS_LDO32,

 33295 +  BFD_RELOC_ARM_TLS_LDM32,

 33296 +  BFD_RELOC_ARM_TLS_DTPOFF32,

 33297 +  BFD_RELOC_ARM_TLS_DTPMOD32,

 33298 +  BFD_RELOC_ARM_TLS_TPOFF32,

 33299 +  BFD_RELOC_ARM_TLS_IE32,

 33300 +  BFD_RELOC_ARM_TLS_LE32,

 33301 +

 33302 +/* ARM group relocations.  */

 33303 +  BFD_RELOC_ARM_ALU_PC_G0_NC,

 33304 +  BFD_RELOC_ARM_ALU_PC_G0,

 33305 +  BFD_RELOC_ARM_ALU_PC_G1_NC,

 33306 +  BFD_RELOC_ARM_ALU_PC_G1,

 33307 +  BFD_RELOC_ARM_ALU_PC_G2,

 33308 +  BFD_RELOC_ARM_LDR_PC_G0,

 33309 +  BFD_RELOC_ARM_LDR_PC_G1,

 33310 +  BFD_RELOC_ARM_LDR_PC_G2,

 33311 +  BFD_RELOC_ARM_LDRS_PC_G0,

 33312 +  BFD_RELOC_ARM_LDRS_PC_G1,

 33313 +  BFD_RELOC_ARM_LDRS_PC_G2,

 33314 +  BFD_RELOC_ARM_LDC_PC_G0,

 33315 +  BFD_RELOC_ARM_LDC_PC_G1,

 33316 +  BFD_RELOC_ARM_LDC_PC_G2,

 33317 +  BFD_RELOC_ARM_ALU_SB_G0_NC,

 33318 +  BFD_RELOC_ARM_ALU_SB_G0,

 33319 +  BFD_RELOC_ARM_ALU_SB_G1_NC,

 33320 +  BFD_RELOC_ARM_ALU_SB_G1,

 33321 +  BFD_RELOC_ARM_ALU_SB_G2,

 33322 +  BFD_RELOC_ARM_LDR_SB_G0,

 33323 +  BFD_RELOC_ARM_LDR_SB_G1,

 33324 +  BFD_RELOC_ARM_LDR_SB_G2,

 33325 +  BFD_RELOC_ARM_LDRS_SB_G0,

 33326 +  BFD_RELOC_ARM_LDRS_SB_G1,

 33327 +  BFD_RELOC_ARM_LDRS_SB_G2,

 33328 +  BFD_RELOC_ARM_LDC_SB_G0,

 33329 +  BFD_RELOC_ARM_LDC_SB_G1,

 33330 +  BFD_RELOC_ARM_LDC_SB_G2,

 33331 +

 33332 +/* These relocs are only used within the ARM assembler.  They are not

 33333 +(at present) written to any object files.  */

 33334 +  BFD_RELOC_ARM_IMMEDIATE,

 33335 +  BFD_RELOC_ARM_ADRL_IMMEDIATE,

 33336 +  BFD_RELOC_ARM_T32_IMMEDIATE,

 33337 +  BFD_RELOC_ARM_T32_ADD_IMM,

 33338 +  BFD_RELOC_ARM_T32_IMM12,

 33339 +  BFD_RELOC_ARM_T32_ADD_PC12,

 33340 +  BFD_RELOC_ARM_SHIFT_IMM,

 33341 +  BFD_RELOC_ARM_SMC,

 33342 +  BFD_RELOC_ARM_SWI,

 33343 +  BFD_RELOC_ARM_MULTI,

 33344 +  BFD_RELOC_ARM_CP_OFF_IMM,

 33345 +  BFD_RELOC_ARM_CP_OFF_IMM_S2,

 33346 +  BFD_RELOC_ARM_T32_CP_OFF_IMM,

 33347 +  BFD_RELOC_ARM_T32_CP_OFF_IMM_S2,

 33348 +  BFD_RELOC_ARM_ADR_IMM,

 33349 +  BFD_RELOC_ARM_LDR_IMM,

 33350 +  BFD_RELOC_ARM_LITERAL,

 33351 +  BFD_RELOC_ARM_IN_POOL,

 33352 +  BFD_RELOC_ARM_OFFSET_IMM8,

 33353 +  BFD_RELOC_ARM_T32_OFFSET_U8,

 33354 +  BFD_RELOC_ARM_T32_OFFSET_IMM,

 33355 +  BFD_RELOC_ARM_HWLITERAL,

 33356 +  BFD_RELOC_ARM_THUMB_ADD,

 33357 +  BFD_RELOC_ARM_THUMB_IMM,

 33358 +  BFD_RELOC_ARM_THUMB_SHIFT,

 33359 +

 33360 +/* Renesas / SuperH SH relocs.  Not all of these appear in object files.  */

 33361 +  BFD_RELOC_SH_PCDISP8BY2,

 33362 +  BFD_RELOC_SH_PCDISP12BY2,

 33363 +  BFD_RELOC_SH_IMM3,

 33364 +  BFD_RELOC_SH_IMM3U,

 33365 +  BFD_RELOC_SH_DISP12,

 33366 +  BFD_RELOC_SH_DISP12BY2,

 33367 +  BFD_RELOC_SH_DISP12BY4,

 33368 +  BFD_RELOC_SH_DISP12BY8,

 33369 +  BFD_RELOC_SH_DISP20,

 33370 +  BFD_RELOC_SH_DISP20BY8,

 33371 +  BFD_RELOC_SH_IMM4,

 33372 +  BFD_RELOC_SH_IMM4BY2,

 33373 +  BFD_RELOC_SH_IMM4BY4,

 33374 +  BFD_RELOC_SH_IMM8,

 33375 +  BFD_RELOC_SH_IMM8BY2,

 33376 +  BFD_RELOC_SH_IMM8BY4,

 33377 +  BFD_RELOC_SH_PCRELIMM8BY2,

 33378 +  BFD_RELOC_SH_PCRELIMM8BY4,

 33379 +  BFD_RELOC_SH_SWITCH16,

 33380 +  BFD_RELOC_SH_SWITCH32,

 33381 +  BFD_RELOC_SH_USES,

 33382 +  BFD_RELOC_SH_COUNT,

 33383 +  BFD_RELOC_SH_ALIGN,

 33384 +  BFD_RELOC_SH_CODE,

 33385 +  BFD_RELOC_SH_DATA,

 33386 +  BFD_RELOC_SH_LABEL,

 33387 +  BFD_RELOC_SH_LOOP_START,

 33388 +  BFD_RELOC_SH_LOOP_END,

 33389 +  BFD_RELOC_SH_COPY,

 33390 +  BFD_RELOC_SH_GLOB_DAT,

 33391 +  BFD_RELOC_SH_JMP_SLOT,

 33392 +  BFD_RELOC_SH_RELATIVE,

 33393 +  BFD_RELOC_SH_GOTPC,

 33394 +  BFD_RELOC_SH_GOT_LOW16,

 33395 +  BFD_RELOC_SH_GOT_MEDLOW16,

 33396 +  BFD_RELOC_SH_GOT_MEDHI16,

 33397 +  BFD_RELOC_SH_GOT_HI16,

 33398 +  BFD_RELOC_SH_GOTPLT_LOW16,

 33399 +  BFD_RELOC_SH_GOTPLT_MEDLOW16,

 33400 +  BFD_RELOC_SH_GOTPLT_MEDHI16,

 33401 +  BFD_RELOC_SH_GOTPLT_HI16,

 33402 +  BFD_RELOC_SH_PLT_LOW16,

 33403 +  BFD_RELOC_SH_PLT_MEDLOW16,

 33404 +  BFD_RELOC_SH_PLT_MEDHI16,

 33405 +  BFD_RELOC_SH_PLT_HI16,

 33406 +  BFD_RELOC_SH_GOTOFF_LOW16,

 33407 +  BFD_RELOC_SH_GOTOFF_MEDLOW16,

 33408 +  BFD_RELOC_SH_GOTOFF_MEDHI16,

 33409 +  BFD_RELOC_SH_GOTOFF_HI16,

 33410 +  BFD_RELOC_SH_GOTPC_LOW16,

 33411 +  BFD_RELOC_SH_GOTPC_MEDLOW16,

 33412 +  BFD_RELOC_SH_GOTPC_MEDHI16,

 33413 +  BFD_RELOC_SH_GOTPC_HI16,

 33414 +  BFD_RELOC_SH_COPY64,

 33415 +  BFD_RELOC_SH_GLOB_DAT64,

 33416 +  BFD_RELOC_SH_JMP_SLOT64,

 33417 +  BFD_RELOC_SH_RELATIVE64,

 33418 +  BFD_RELOC_SH_GOT10BY4,

 33419 +  BFD_RELOC_SH_GOT10BY8,

 33420 +  BFD_RELOC_SH_GOTPLT10BY4,

 33421 +  BFD_RELOC_SH_GOTPLT10BY8,

 33422 +  BFD_RELOC_SH_GOTPLT32,

 33423 +  BFD_RELOC_SH_SHMEDIA_CODE,

 33424 +  BFD_RELOC_SH_IMMU5,

 33425 +  BFD_RELOC_SH_IMMS6,

 33426 +  BFD_RELOC_SH_IMMS6BY32,

 33427 +  BFD_RELOC_SH_IMMU6,

 33428 +  BFD_RELOC_SH_IMMS10,

 33429 +  BFD_RELOC_SH_IMMS10BY2,

 33430 +  BFD_RELOC_SH_IMMS10BY4,

 33431 +  BFD_RELOC_SH_IMMS10BY8,

 33432 +  BFD_RELOC_SH_IMMS16,

 33433 +  BFD_RELOC_SH_IMMU16,

 33434 +  BFD_RELOC_SH_IMM_LOW16,

 33435 +  BFD_RELOC_SH_IMM_LOW16_PCREL,

 33436 +  BFD_RELOC_SH_IMM_MEDLOW16,

 33437 +  BFD_RELOC_SH_IMM_MEDLOW16_PCREL,

 33438 +  BFD_RELOC_SH_IMM_MEDHI16,

 33439 +  BFD_RELOC_SH_IMM_MEDHI16_PCREL,

 33440 +  BFD_RELOC_SH_IMM_HI16,

 33441 +  BFD_RELOC_SH_IMM_HI16_PCREL,

 33442 +  BFD_RELOC_SH_PT_16,

 33443 +  BFD_RELOC_SH_TLS_GD_32,

 33444 +  BFD_RELOC_SH_TLS_LD_32,

 33445 +  BFD_RELOC_SH_TLS_LDO_32,

 33446 +  BFD_RELOC_SH_TLS_IE_32,

 33447 +  BFD_RELOC_SH_TLS_LE_32,

 33448 +  BFD_RELOC_SH_TLS_DTPMOD32,

 33449 +  BFD_RELOC_SH_TLS_DTPOFF32,

 33450 +  BFD_RELOC_SH_TLS_TPOFF32,

 33451 +

 33452 +/* ARC Cores relocs.

 33453 +ARC 22 bit pc-relative branch.  The lowest two bits must be zero and are

 33454 +not stored in the instruction.  The high 20 bits are installed in bits 26

 33455 +through 7 of the instruction.  */

 33456 +  BFD_RELOC_ARC_B22_PCREL,

 33457 +

 33458 +/* ARC 26 bit absolute branch.  The lowest two bits must be zero and are not

 33459 +stored in the instruction.  The high 24 bits are installed in bits 23

 33460 +through 0.  */

 33461 +  BFD_RELOC_ARC_B26,

 33462 +

 33463 +/* ADI Blackfin 16 bit immediate absolute reloc.  */

 33464 +  BFD_RELOC_BFIN_16_IMM,

 33465 +

 33466 +/* ADI Blackfin 16 bit immediate absolute reloc higher 16 bits.  */

 33467 +  BFD_RELOC_BFIN_16_HIGH,

 33468 +

 33469 +/* ADI Blackfin 'a' part of LSETUP.  */

 33470 +  BFD_RELOC_BFIN_4_PCREL,

 33471 +

 33472 +/* ADI Blackfin.  */

 33473 +  BFD_RELOC_BFIN_5_PCREL,

 33474 +

 33475 +/* ADI Blackfin 16 bit immediate absolute reloc lower 16 bits.  */

 33476 +  BFD_RELOC_BFIN_16_LOW,

 33477 +

 33478 +/* ADI Blackfin.  */

 33479 +  BFD_RELOC_BFIN_10_PCREL,

 33480 +

 33481 +/* ADI Blackfin 'b' part of LSETUP.  */

 33482 +  BFD_RELOC_BFIN_11_PCREL,

 33483 +

 33484 +/* ADI Blackfin.  */

 33485 +  BFD_RELOC_BFIN_12_PCREL_JUMP,

 33486 +

 33487 +/* ADI Blackfin Short jump, pcrel.  */

 33488 +  BFD_RELOC_BFIN_12_PCREL_JUMP_S,

 33489 +

 33490 +/* ADI Blackfin Call.x not implemented.  */

 33491 +  BFD_RELOC_BFIN_24_PCREL_CALL_X,

 33492 +

 33493 +/* ADI Blackfin Long Jump pcrel.  */

 33494 +  BFD_RELOC_BFIN_24_PCREL_JUMP_L,

 33495 +

 33496 +/* ADI Blackfin FD-PIC relocations.  */

 33497 +  BFD_RELOC_BFIN_GOT17M4,

 33498 +  BFD_RELOC_BFIN_GOTHI,

 33499 +  BFD_RELOC_BFIN_GOTLO,

 33500 +  BFD_RELOC_BFIN_FUNCDESC,

 33501 +  BFD_RELOC_BFIN_FUNCDESC_GOT17M4,

 33502 +  BFD_RELOC_BFIN_FUNCDESC_GOTHI,

 33503 +  BFD_RELOC_BFIN_FUNCDESC_GOTLO,

 33504 +  BFD_RELOC_BFIN_FUNCDESC_VALUE,

 33505 +  BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4,

 33506 +  BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI,

 33507 +  BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO,

 33508 +  BFD_RELOC_BFIN_GOTOFF17M4,

 33509 +  BFD_RELOC_BFIN_GOTOFFHI,

 33510 +  BFD_RELOC_BFIN_GOTOFFLO,

 33511 +

 33512 +/* ADI Blackfin GOT relocation.  */

 33513 +  BFD_RELOC_BFIN_GOT,

 33514 +

 33515 +/* ADI Blackfin PLTPC relocation.  */

 33516 +  BFD_RELOC_BFIN_PLTPC,

 33517 +

 33518 +/* ADI Blackfin arithmetic relocation.  */

 33519 +  BFD_ARELOC_BFIN_PUSH,

 33520 +

 33521 +/* ADI Blackfin arithmetic relocation.  */

 33522 +  BFD_ARELOC_BFIN_CONST,

 33523 +

 33524 +/* ADI Blackfin arithmetic relocation.  */

 33525 +  BFD_ARELOC_BFIN_ADD,

 33526 +

 33527 +/* ADI Blackfin arithmetic relocation.  */

 33528 +  BFD_ARELOC_BFIN_SUB,

 33529 +

 33530 +/* ADI Blackfin arithmetic relocation.  */

 33531 +  BFD_ARELOC_BFIN_MULT,

 33532 +

 33533 +/* ADI Blackfin arithmetic relocation.  */

 33534 +  BFD_ARELOC_BFIN_DIV,

 33535 +

 33536 +/* ADI Blackfin arithmetic relocation.  */

 33537 +  BFD_ARELOC_BFIN_MOD,

 33538 +

 33539 +/* ADI Blackfin arithmetic relocation.  */

 33540 +  BFD_ARELOC_BFIN_LSHIFT,

 33541 +

 33542 +/* ADI Blackfin arithmetic relocation.  */

 33543 +  BFD_ARELOC_BFIN_RSHIFT,

 33544 +

 33545 +/* ADI Blackfin arithmetic relocation.  */

 33546 +  BFD_ARELOC_BFIN_AND,

 33547 +

 33548 +/* ADI Blackfin arithmetic relocation.  */

 33549 +  BFD_ARELOC_BFIN_OR,

 33550 +

 33551 +/* ADI Blackfin arithmetic relocation.  */

 33552 +  BFD_ARELOC_BFIN_XOR,

 33553 +

 33554 +/* ADI Blackfin arithmetic relocation.  */

 33555 +  BFD_ARELOC_BFIN_LAND,

 33556 +

 33557 +/* ADI Blackfin arithmetic relocation.  */

 33558 +  BFD_ARELOC_BFIN_LOR,

 33559 +

 33560 +/* ADI Blackfin arithmetic relocation.  */

 33561 +  BFD_ARELOC_BFIN_LEN,

 33562 +

 33563 +/* ADI Blackfin arithmetic relocation.  */

 33564 +  BFD_ARELOC_BFIN_NEG,

 33565 +

 33566 +/* ADI Blackfin arithmetic relocation.  */

 33567 +  BFD_ARELOC_BFIN_COMP,

 33568 +

 33569 +/* ADI Blackfin arithmetic relocation.  */

 33570 +  BFD_ARELOC_BFIN_PAGE,

 33571 +

 33572 +/* ADI Blackfin arithmetic relocation.  */

 33573 +  BFD_ARELOC_BFIN_HWPAGE,

 33574 +

 33575 +/* ADI Blackfin arithmetic relocation.  */

 33576 +  BFD_ARELOC_BFIN_ADDR,

 33577 +

 33578 +/* Mitsubishi D10V relocs.

 33579 +This is a 10-bit reloc with the right 2 bits

 33580 +assumed to be 0.  */

 33581 +  BFD_RELOC_D10V_10_PCREL_R,

 33582 +

 33583 +/* Mitsubishi D10V relocs.

 33584 +This is a 10-bit reloc with the right 2 bits

 33585 +assumed to be 0.  This is the same as the previous reloc

 33586 +except it is in the left container, i.e.,

 33587 +shifted left 15 bits.  */

 33588 +  BFD_RELOC_D10V_10_PCREL_L,

 33589 +

 33590 +/* This is an 18-bit reloc with the right 2 bits

 33591 +assumed to be 0.  */

 33592 +  BFD_RELOC_D10V_18,

 33593 +

 33594 +/* This is an 18-bit reloc with the right 2 bits

 33595 +assumed to be 0.  */

 33596 +  BFD_RELOC_D10V_18_PCREL,

 33597 +

 33598 +/* Mitsubishi D30V relocs.

 33599 +This is a 6-bit absolute reloc.  */

 33600 +  BFD_RELOC_D30V_6,

 33601 +

 33602 +/* This is a 6-bit pc-relative reloc with

 33603 +the right 3 bits assumed to be 0.  */

 33604 +  BFD_RELOC_D30V_9_PCREL,

 33605 +

 33606 +/* This is a 6-bit pc-relative reloc with

 33607 +the right 3 bits assumed to be 0. Same

 33608 +as the previous reloc but on the right side

 33609 +of the container.  */

 33610 +  BFD_RELOC_D30V_9_PCREL_R,

 33611 +

 33612 +/* This is a 12-bit absolute reloc with the

 33613 +right 3 bitsassumed to be 0.  */

 33614 +  BFD_RELOC_D30V_15,

 33615 +

 33616 +/* This is a 12-bit pc-relative reloc with

 33617 +the right 3 bits assumed to be 0.  */

 33618 +  BFD_RELOC_D30V_15_PCREL,

 33619 +

 33620 +/* This is a 12-bit pc-relative reloc with

 33621 +the right 3 bits assumed to be 0. Same

 33622 +as the previous reloc but on the right side

 33623 +of the container.  */

 33624 +  BFD_RELOC_D30V_15_PCREL_R,

 33625 +

 33626 +/* This is an 18-bit absolute reloc with

 33627 +the right 3 bits assumed to be 0.  */

 33628 +  BFD_RELOC_D30V_21,

 33629 +

 33630 +/* This is an 18-bit pc-relative reloc with

 33631 +the right 3 bits assumed to be 0.  */

 33632 +  BFD_RELOC_D30V_21_PCREL,

 33633 +

 33634 +/* This is an 18-bit pc-relative reloc with

 33635 +the right 3 bits assumed to be 0. Same

 33636 +as the previous reloc but on the right side

 33637 +of the container.  */

 33638 +  BFD_RELOC_D30V_21_PCREL_R,

 33639 +

 33640 +/* This is a 32-bit absolute reloc.  */

 33641 +  BFD_RELOC_D30V_32,

 33642 +

 33643 +/* This is a 32-bit pc-relative reloc.  */

 33644 +  BFD_RELOC_D30V_32_PCREL,

 33645 +

 33646 +/* DLX relocs  */

 33647 +  BFD_RELOC_DLX_HI16_S,

 33648 +

 33649 +/* DLX relocs  */

 33650 +  BFD_RELOC_DLX_LO16,

 33651 +

 33652 +/* DLX relocs  */

 33653 +  BFD_RELOC_DLX_JMP26,

 33654 +

 33655 +/* Renesas M16C/M32C Relocations.  */

 33656 +  BFD_RELOC_M32C_HI8,

 33657 +  BFD_RELOC_M32C_RL_JUMP,

 33658 +  BFD_RELOC_M32C_RL_1ADDR,

 33659 +  BFD_RELOC_M32C_RL_2ADDR,

 33660 +

 33661 +/* Renesas M32R (formerly Mitsubishi M32R) relocs.

 33662 +This is a 24 bit absolute address.  */

 33663 +  BFD_RELOC_M32R_24,

 33664 +

 33665 +/* This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.  */

 33666 +  BFD_RELOC_M32R_10_PCREL,

 33667 +

 33668 +/* This is an 18-bit reloc with the right 2 bits assumed to be 0.  */

 33669 +  BFD_RELOC_M32R_18_PCREL,

 33670 +

 33671 +/* This is a 26-bit reloc with the right 2 bits assumed to be 0.  */

 33672 +  BFD_RELOC_M32R_26_PCREL,

 33673 +

 33674 +/* This is a 16-bit reloc containing the high 16 bits of an address

 33675 +used when the lower 16 bits are treated as unsigned.  */

 33676 +  BFD_RELOC_M32R_HI16_ULO,

 33677 +

 33678 +/* This is a 16-bit reloc containing the high 16 bits of an address

 33679 +used when the lower 16 bits are treated as signed.  */

 33680 +  BFD_RELOC_M32R_HI16_SLO,

 33681 +

 33682 +/* This is a 16-bit reloc containing the lower 16 bits of an address.  */

 33683 +  BFD_RELOC_M32R_LO16,

 33684 +

 33685 +/* This is a 16-bit reloc containing the small data area offset for use in

 33686 +add3, load, and store instructions.  */

 33687 +  BFD_RELOC_M32R_SDA16,

 33688 +

 33689 +/* For PIC.  */

 33690 +  BFD_RELOC_M32R_GOT24,

 33691 +  BFD_RELOC_M32R_26_PLTREL,

 33692 +  BFD_RELOC_M32R_COPY,

 33693 +  BFD_RELOC_M32R_GLOB_DAT,

 33694 +  BFD_RELOC_M32R_JMP_SLOT,

 33695 +  BFD_RELOC_M32R_RELATIVE,

 33696 +  BFD_RELOC_M32R_GOTOFF,

 33697 +  BFD_RELOC_M32R_GOTOFF_HI_ULO,

 33698 +  BFD_RELOC_M32R_GOTOFF_HI_SLO,

 33699 +  BFD_RELOC_M32R_GOTOFF_LO,

 33700 +  BFD_RELOC_M32R_GOTPC24,

 33701 +  BFD_RELOC_M32R_GOT16_HI_ULO,

 33702 +  BFD_RELOC_M32R_GOT16_HI_SLO,

 33703 +  BFD_RELOC_M32R_GOT16_LO,

 33704 +  BFD_RELOC_M32R_GOTPC_HI_ULO,

 33705 +  BFD_RELOC_M32R_GOTPC_HI_SLO,

 33706 +  BFD_RELOC_M32R_GOTPC_LO,

 33707 +

 33708 +/* This is a 9-bit reloc  */

 33709 +  BFD_RELOC_V850_9_PCREL,

 33710 +

 33711 +/* This is a 22-bit reloc  */

 33712 +  BFD_RELOC_V850_22_PCREL,

 33713 +

 33714 +/* This is a 16 bit offset from the short data area pointer.  */

 33715 +  BFD_RELOC_V850_SDA_16_16_OFFSET,

 33716 +

 33717 +/* This is a 16 bit offset (of which only 15 bits are used) from the

 33718 +short data area pointer.  */

 33719 +  BFD_RELOC_V850_SDA_15_16_OFFSET,

 33720 +

 33721 +/* This is a 16 bit offset from the zero data area pointer.  */

 33722 +  BFD_RELOC_V850_ZDA_16_16_OFFSET,

 33723 +

 33724 +/* This is a 16 bit offset (of which only 15 bits are used) from the

 33725 +zero data area pointer.  */

 33726 +  BFD_RELOC_V850_ZDA_15_16_OFFSET,

 33727 +

 33728 +/* This is an 8 bit offset (of which only 6 bits are used) from the

 33729 +tiny data area pointer.  */

 33730 +  BFD_RELOC_V850_TDA_6_8_OFFSET,

 33731 +

 33732 +/* This is an 8bit offset (of which only 7 bits are used) from the tiny

 33733 +data area pointer.  */

 33734 +  BFD_RELOC_V850_TDA_7_8_OFFSET,

 33735 +

 33736 +/* This is a 7 bit offset from the tiny data area pointer.  */

 33737 +  BFD_RELOC_V850_TDA_7_7_OFFSET,

 33738 +

 33739 +/* This is a 16 bit offset from the tiny data area pointer.  */

 33740 +  BFD_RELOC_V850_TDA_16_16_OFFSET,

 33741 +

 33742 +/* This is a 5 bit offset (of which only 4 bits are used) from the tiny

 33743 +data area pointer.  */

 33744 +  BFD_RELOC_V850_TDA_4_5_OFFSET,

 33745 +

 33746 +/* This is a 4 bit offset from the tiny data area pointer.  */

 33747 +  BFD_RELOC_V850_TDA_4_4_OFFSET,

 33748 +

 33749 +/* This is a 16 bit offset from the short data area pointer, with the

 33750 +bits placed non-contiguously in the instruction.  */

 33751 +  BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET,

 33752 +

 33753 +/* This is a 16 bit offset from the zero data area pointer, with the

 33754 +bits placed non-contiguously in the instruction.  */

 33755 +  BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET,

 33756 +

 33757 +/* This is a 6 bit offset from the call table base pointer.  */

 33758 +  BFD_RELOC_V850_CALLT_6_7_OFFSET,

 33759 +

 33760 +/* This is a 16 bit offset from the call table base pointer.  */

 33761 +  BFD_RELOC_V850_CALLT_16_16_OFFSET,

 33762 +

 33763 +/* Used for relaxing indirect function calls.  */

 33764 +  BFD_RELOC_V850_LONGCALL,

 33765 +

 33766 +/* Used for relaxing indirect jumps.  */

 33767 +  BFD_RELOC_V850_LONGJUMP,

 33768 +

 33769 +/* Used to maintain alignment whilst relaxing.  */

 33770 +  BFD_RELOC_V850_ALIGN,

 33771 +

 33772 +/* This is a variation of BFD_RELOC_LO16 that can be used in v850e ld.bu

 33773 +instructions.  */

 33774 +  BFD_RELOC_V850_LO16_SPLIT_OFFSET,

 33775 +

 33776 +/* This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the

 33777 +instruction.  */

 33778 +  BFD_RELOC_MN10300_32_PCREL,

 33779 +

 33780 +/* This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the

 33781 +instruction.  */

 33782 +  BFD_RELOC_MN10300_16_PCREL,

 33783 +

 33784 +/* This is a 8bit DP reloc for the tms320c30, where the most

 33785 +significant 8 bits of a 24 bit word are placed into the least

 33786 +significant 8 bits of the opcode.  */

 33787 +  BFD_RELOC_TIC30_LDP,

 33788 +

 33789 +/* This is a 7bit reloc for the tms320c54x, where the least

 33790 +significant 7 bits of a 16 bit word are placed into the least

 33791 +significant 7 bits of the opcode.  */

 33792 +  BFD_RELOC_TIC54X_PARTLS7,

 33793 +

 33794 +/* This is a 9bit DP reloc for the tms320c54x, where the most

 33795 +significant 9 bits of a 16 bit word are placed into the least

 33796 +significant 9 bits of the opcode.  */

 33797 +  BFD_RELOC_TIC54X_PARTMS9,

 33798 +

 33799 +/* This is an extended address 23-bit reloc for the tms320c54x.  */

 33800 +  BFD_RELOC_TIC54X_23,

 33801 +

 33802 +/* This is a 16-bit reloc for the tms320c54x, where the least

 33803 +significant 16 bits of a 23-bit extended address are placed into

 33804 +the opcode.  */

 33805 +  BFD_RELOC_TIC54X_16_OF_23,

 33806 +

 33807 +/* This is a reloc for the tms320c54x, where the most

 33808 +significant 7 bits of a 23-bit extended address are placed into

 33809 +the opcode.  */

 33810 +  BFD_RELOC_TIC54X_MS7_OF_23,

 33811 +

 33812 +/* This is a 48 bit reloc for the FR30 that stores 32 bits.  */

 33813 +  BFD_RELOC_FR30_48,

 33814 +

 33815 +/* This is a 32 bit reloc for the FR30 that stores 20 bits split up into

 33816 +two sections.  */

 33817 +  BFD_RELOC_FR30_20,

 33818 +

 33819 +/* This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in

 33820 +4 bits.  */

 33821 +  BFD_RELOC_FR30_6_IN_4,

 33822 +

 33823 +/* This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset

 33824 +into 8 bits.  */

 33825 +  BFD_RELOC_FR30_8_IN_8,

 33826 +

 33827 +/* This is a 16 bit reloc for the FR30 that stores a 9 bit short offset

 33828 +into 8 bits.  */

 33829 +  BFD_RELOC_FR30_9_IN_8,

 33830 +

 33831 +/* This is a 16 bit reloc for the FR30 that stores a 10 bit word offset

 33832 +into 8 bits.  */

 33833 +  BFD_RELOC_FR30_10_IN_8,

 33834 +

 33835 +/* This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative

 33836 +short offset into 8 bits.  */

 33837 +  BFD_RELOC_FR30_9_PCREL,

 33838 +

 33839 +/* This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative

 33840 +short offset into 11 bits.  */

 33841 +  BFD_RELOC_FR30_12_PCREL,

 33842 +

 33843 +/* Motorola Mcore relocations.  */

 33844 +  BFD_RELOC_MCORE_PCREL_IMM8BY4,

 33845 +  BFD_RELOC_MCORE_PCREL_IMM11BY2,

 33846 +  BFD_RELOC_MCORE_PCREL_IMM4BY2,

 33847 +  BFD_RELOC_MCORE_PCREL_32,

 33848 +  BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2,

 33849 +  BFD_RELOC_MCORE_RVA,

 33850 +

 33851 +/* Toshiba Media Processor Relocations.  */

 33852 +  BFD_RELOC_MEP_8,

 33853 +  BFD_RELOC_MEP_16,

 33854 +  BFD_RELOC_MEP_32,

 33855 +  BFD_RELOC_MEP_PCREL8A2,

 33856 +  BFD_RELOC_MEP_PCREL12A2,

 33857 +  BFD_RELOC_MEP_PCREL17A2,

 33858 +  BFD_RELOC_MEP_PCREL24A2,

 33859 +  BFD_RELOC_MEP_PCABS24A2,

 33860 +  BFD_RELOC_MEP_LOW16,

 33861 +  BFD_RELOC_MEP_HI16U,

 33862 +  BFD_RELOC_MEP_HI16S,

 33863 +  BFD_RELOC_MEP_GPREL,

 33864 +  BFD_RELOC_MEP_TPREL,

 33865 +  BFD_RELOC_MEP_TPREL7,

 33866 +  BFD_RELOC_MEP_TPREL7A2,

 33867 +  BFD_RELOC_MEP_TPREL7A4,

 33868 +  BFD_RELOC_MEP_UIMM24,

 33869 +  BFD_RELOC_MEP_ADDR24A4,

 33870 +  BFD_RELOC_MEP_GNU_VTINHERIT,

 33871 +  BFD_RELOC_MEP_GNU_VTENTRY,

 33872 +

 33873 +

 33874 +/* These are relocations for the GETA instruction.  */

 33875 +  BFD_RELOC_MMIX_GETA,

 33876 +  BFD_RELOC_MMIX_GETA_1,

 33877 +  BFD_RELOC_MMIX_GETA_2,

 33878 +  BFD_RELOC_MMIX_GETA_3,

 33879 +

 33880 +/* These are relocations for a conditional branch instruction.  */

 33881 +  BFD_RELOC_MMIX_CBRANCH,

 33882 +  BFD_RELOC_MMIX_CBRANCH_J,

 33883 +  BFD_RELOC_MMIX_CBRANCH_1,

 33884 +  BFD_RELOC_MMIX_CBRANCH_2,

 33885 +  BFD_RELOC_MMIX_CBRANCH_3,

 33886 +

 33887 +/* These are relocations for the PUSHJ instruction.  */

 33888 +  BFD_RELOC_MMIX_PUSHJ,

 33889 +  BFD_RELOC_MMIX_PUSHJ_1,

 33890 +  BFD_RELOC_MMIX_PUSHJ_2,

 33891 +  BFD_RELOC_MMIX_PUSHJ_3,

 33892 +  BFD_RELOC_MMIX_PUSHJ_STUBBABLE,

 33893 +

 33894 +/* These are relocations for the JMP instruction.  */

 33895 +  BFD_RELOC_MMIX_JMP,

 33896 +  BFD_RELOC_MMIX_JMP_1,

 33897 +  BFD_RELOC_MMIX_JMP_2,

 33898 +  BFD_RELOC_MMIX_JMP_3,

 33899 +

 33900 +/* This is a relocation for a relative address as in a GETA instruction or

 33901 +a branch.  */

 33902 +  BFD_RELOC_MMIX_ADDR19,

 33903 +

 33904 +/* This is a relocation for a relative address as in a JMP instruction.  */

 33905 +  BFD_RELOC_MMIX_ADDR27,

 33906 +

 33907 +/* This is a relocation for an instruction field that may be a general

 33908 +register or a value 0..255.  */

 33909 +  BFD_RELOC_MMIX_REG_OR_BYTE,

 33910 +

 33911 +/* This is a relocation for an instruction field that may be a general

 33912 +register.  */

 33913 +  BFD_RELOC_MMIX_REG,

 33914 +

 33915 +/* This is a relocation for two instruction fields holding a register and

 33916 +an offset, the equivalent of the relocation.  */

 33917 +  BFD_RELOC_MMIX_BASE_PLUS_OFFSET,

 33918 +

 33919 +/* This relocation is an assertion that the expression is not allocated as

 33920 +a global register.  It does not modify contents.  */

 33921 +  BFD_RELOC_MMIX_LOCAL,

 33922 +

 33923 +/* This is a 16 bit reloc for the AVR that stores 8 bit pc relative

 33924 +short offset into 7 bits.  */

 33925 +  BFD_RELOC_AVR_7_PCREL,

 33926 +

 33927 +/* This is a 16 bit reloc for the AVR that stores 13 bit pc relative

 33928 +short offset into 12 bits.  */

 33929 +  BFD_RELOC_AVR_13_PCREL,

 33930 +

 33931 +/* This is a 16 bit reloc for the AVR that stores 17 bit value (usually

 33932 +program memory address) into 16 bits.  */

 33933 +  BFD_RELOC_AVR_16_PM,

 33934 +

 33935 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually

 33936 +data memory address) into 8 bit immediate value of LDI insn.  */

 33937 +  BFD_RELOC_AVR_LO8_LDI,

 33938 +

 33939 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit

 33940 +of data memory address) into 8 bit immediate value of LDI insn.  */

 33941 +  BFD_RELOC_AVR_HI8_LDI,

 33942 +

 33943 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit

 33944 +of program memory address) into 8 bit immediate value of LDI insn.  */

 33945 +  BFD_RELOC_AVR_HH8_LDI,

 33946 +

 33947 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit

 33948 +of 32 bit value) into 8 bit immediate value of LDI insn.  */

 33949 +  BFD_RELOC_AVR_MS8_LDI,

 33950 +

 33951 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value

 33952 +(usually data memory address) into 8 bit immediate value of SUBI insn.  */

 33953 +  BFD_RELOC_AVR_LO8_LDI_NEG,

 33954 +

 33955 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value

 33956 +(high 8 bit of data memory address) into 8 bit immediate value of

 33957 +SUBI insn.  */

 33958 +  BFD_RELOC_AVR_HI8_LDI_NEG,

 33959 +

 33960 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value

 33961 +(most high 8 bit of program memory address) into 8 bit immediate value

 33962 +of LDI or SUBI insn.  */

 33963 +  BFD_RELOC_AVR_HH8_LDI_NEG,

 33964 +

 33965 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value (msb

 33966 +of 32 bit value) into 8 bit immediate value of LDI insn.  */

 33967 +  BFD_RELOC_AVR_MS8_LDI_NEG,

 33968 +

 33969 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually

 33970 +command address) into 8 bit immediate value of LDI insn.  */

 33971 +  BFD_RELOC_AVR_LO8_LDI_PM,

 33972 +

 33973 +/* This is a 16 bit reloc for the AVR that stores 8 bit value

 33974 +(command address) into 8 bit immediate value of LDI insn. If the address

 33975 +is beyond the 128k boundary, the linker inserts a jump stub for this reloc

 33976 +in the lower 128k.  */

 33977 +  BFD_RELOC_AVR_LO8_LDI_GS,

 33978 +

 33979 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit

 33980 +of command address) into 8 bit immediate value of LDI insn.  */

 33981 +  BFD_RELOC_AVR_HI8_LDI_PM,

 33982 +

 33983 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit

 33984 +of command address) into 8 bit immediate value of LDI insn.  If the address

 33985 +is beyond the 128k boundary, the linker inserts a jump stub for this reloc

 33986 +below 128k.  */

 33987 +  BFD_RELOC_AVR_HI8_LDI_GS,

 33988 +

 33989 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit

 33990 +of command address) into 8 bit immediate value of LDI insn.  */

 33991 +  BFD_RELOC_AVR_HH8_LDI_PM,

 33992 +

 33993 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value

 33994 +(usually command address) into 8 bit immediate value of SUBI insn.  */

 33995 +  BFD_RELOC_AVR_LO8_LDI_PM_NEG,

 33996 +

 33997 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value

 33998 +(high 8 bit of 16 bit command address) into 8 bit immediate value

 33999 +of SUBI insn.  */

 34000 +  BFD_RELOC_AVR_HI8_LDI_PM_NEG,

 34001 +

 34002 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value

 34003 +(high 6 bit of 22 bit command address) into 8 bit immediate

 34004 +value of SUBI insn.  */

 34005 +  BFD_RELOC_AVR_HH8_LDI_PM_NEG,

 34006 +

 34007 +/* This is a 32 bit reloc for the AVR that stores 23 bit value

 34008 +into 22 bits.  */

 34009 +  BFD_RELOC_AVR_CALL,

 34010 +

 34011 +/* This is a 16 bit reloc for the AVR that stores all needed bits

 34012 +for absolute addressing with ldi with overflow check to linktime  */

 34013 +  BFD_RELOC_AVR_LDI,

 34014 +

 34015 +/* This is a 6 bit reloc for the AVR that stores offset for ldd/std

 34016 +instructions  */

 34017 +  BFD_RELOC_AVR_6,

 34018 +

 34019 +/* This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw

 34020 +instructions  */

 34021 +  BFD_RELOC_AVR_6_ADIW,

 34022 +

 34023 +/* Direct 12 bit.  */

 34024 +  BFD_RELOC_390_12,

 34025 +

 34026 +/* 12 bit GOT offset.  */

 34027 +  BFD_RELOC_390_GOT12,

 34028 +

 34029 +/* 32 bit PC relative PLT address.  */

 34030 +  BFD_RELOC_390_PLT32,

 34031 +

 34032 +/* Copy symbol at runtime.  */

 34033 +  BFD_RELOC_390_COPY,

 34034 +

 34035 +/* Create GOT entry.  */

 34036 +  BFD_RELOC_390_GLOB_DAT,

 34037 +

 34038 +/* Create PLT entry.  */

 34039 +  BFD_RELOC_390_JMP_SLOT,

 34040 +

 34041 +/* Adjust by program base.  */

 34042 +  BFD_RELOC_390_RELATIVE,

 34043 +

 34044 +/* 32 bit PC relative offset to GOT.  */

 34045 +  BFD_RELOC_390_GOTPC,

 34046 +

 34047 +/* 16 bit GOT offset.  */

 34048 +  BFD_RELOC_390_GOT16,

 34049 +

 34050 +/* PC relative 16 bit shifted by 1.  */

 34051 +  BFD_RELOC_390_PC16DBL,

 34052 +

 34053 +/* 16 bit PC rel. PLT shifted by 1.  */

 34054 +  BFD_RELOC_390_PLT16DBL,

 34055 +

 34056 +/* PC relative 32 bit shifted by 1.  */

 34057 +  BFD_RELOC_390_PC32DBL,

 34058 +

 34059 +/* 32 bit PC rel. PLT shifted by 1.  */

 34060 +  BFD_RELOC_390_PLT32DBL,

 34061 +

 34062 +/* 32 bit PC rel. GOT shifted by 1.  */

 34063 +  BFD_RELOC_390_GOTPCDBL,

 34064 +

 34065 +/* 64 bit GOT offset.  */

 34066 +  BFD_RELOC_390_GOT64,

 34067 +

 34068 +/* 64 bit PC relative PLT address.  */

 34069 +  BFD_RELOC_390_PLT64,

 34070 +

 34071 +/* 32 bit rel. offset to GOT entry.  */

 34072 +  BFD_RELOC_390_GOTENT,

 34073 +

 34074 +/* 64 bit offset to GOT.  */

 34075 +  BFD_RELOC_390_GOTOFF64,

 34076 +

 34077 +/* 12-bit offset to symbol-entry within GOT, with PLT handling.  */

 34078 +  BFD_RELOC_390_GOTPLT12,

 34079 +

 34080 +/* 16-bit offset to symbol-entry within GOT, with PLT handling.  */

 34081 +  BFD_RELOC_390_GOTPLT16,

 34082 +

 34083 +/* 32-bit offset to symbol-entry within GOT, with PLT handling.  */

 34084 +  BFD_RELOC_390_GOTPLT32,

 34085 +

 34086 +/* 64-bit offset to symbol-entry within GOT, with PLT handling.  */

 34087 +  BFD_RELOC_390_GOTPLT64,

 34088 +

 34089 +/* 32-bit rel. offset to symbol-entry within GOT, with PLT handling.  */

 34090 +  BFD_RELOC_390_GOTPLTENT,

 34091 +

 34092 +/* 16-bit rel. offset from the GOT to a PLT entry.  */

 34093 +  BFD_RELOC_390_PLTOFF16,

 34094 +

 34095 +/* 32-bit rel. offset from the GOT to a PLT entry.  */

 34096 +  BFD_RELOC_390_PLTOFF32,

 34097 +

 34098 +/* 64-bit rel. offset from the GOT to a PLT entry.  */

 34099 +  BFD_RELOC_390_PLTOFF64,

 34100 +

 34101 +/* s390 tls relocations.  */

 34102 +  BFD_RELOC_390_TLS_LOAD,

 34103 +  BFD_RELOC_390_TLS_GDCALL,

 34104 +  BFD_RELOC_390_TLS_LDCALL,

 34105 +  BFD_RELOC_390_TLS_GD32,

 34106 +  BFD_RELOC_390_TLS_GD64,

 34107 +  BFD_RELOC_390_TLS_GOTIE12,

 34108 +  BFD_RELOC_390_TLS_GOTIE32,

 34109 +  BFD_RELOC_390_TLS_GOTIE64,

 34110 +  BFD_RELOC_390_TLS_LDM32,

 34111 +  BFD_RELOC_390_TLS_LDM64,

 34112 +  BFD_RELOC_390_TLS_IE32,

 34113 +  BFD_RELOC_390_TLS_IE64,

 34114 +  BFD_RELOC_390_TLS_IEENT,

 34115 +  BFD_RELOC_390_TLS_LE32,

 34116 +  BFD_RELOC_390_TLS_LE64,

 34117 +  BFD_RELOC_390_TLS_LDO32,

 34118 +  BFD_RELOC_390_TLS_LDO64,

 34119 +  BFD_RELOC_390_TLS_DTPMOD,

 34120 +  BFD_RELOC_390_TLS_DTPOFF,

 34121 +  BFD_RELOC_390_TLS_TPOFF,

 34122 +

 34123 +/* Long displacement extension.  */

 34124 +  BFD_RELOC_390_20,

 34125 +  BFD_RELOC_390_GOT20,

 34126 +  BFD_RELOC_390_GOTPLT20,

 34127 +  BFD_RELOC_390_TLS_GOTIE20,

 34128 +

 34129 +/* Score relocations  */

 34130 +  BFD_RELOC_SCORE_DUMMY1,

 34131 +

 34132 +/* Low 16 bit for load/store  */

 34133 +  BFD_RELOC_SCORE_GPREL15,

 34134 +

 34135 +/* This is a 24-bit reloc with the right 1 bit assumed to be 0  */

 34136 +  BFD_RELOC_SCORE_DUMMY2,

 34137 +  BFD_RELOC_SCORE_JMP,

 34138 +

 34139 +/* This is a 19-bit reloc with the right 1 bit assumed to be 0  */

 34140 +  BFD_RELOC_SCORE_BRANCH,

 34141 +

 34142 +/* This is a 11-bit reloc with the right 1 bit assumed to be 0  */

 34143 +  BFD_RELOC_SCORE16_JMP,

 34144 +

 34145 +/* This is a 8-bit reloc with the right 1 bit assumed to be 0  */

 34146 +  BFD_RELOC_SCORE16_BRANCH,

 34147 +

 34148 +/* Undocumented Score relocs  */

 34149 +  BFD_RELOC_SCORE_GOT15,

 34150 +  BFD_RELOC_SCORE_GOT_LO16,

 34151 +  BFD_RELOC_SCORE_CALL15,

 34152 +  BFD_RELOC_SCORE_DUMMY_HI16,

 34153 +

 34154 +/* Scenix IP2K - 9-bit register number / data address  */

 34155 +  BFD_RELOC_IP2K_FR9,

 34156 +

 34157 +/* Scenix IP2K - 4-bit register/data bank number  */

 34158 +  BFD_RELOC_IP2K_BANK,

 34159 +

 34160 +/* Scenix IP2K - low 13 bits of instruction word address  */

 34161 +  BFD_RELOC_IP2K_ADDR16CJP,

 34162 +

 34163 +/* Scenix IP2K - high 3 bits of instruction word address  */

 34164 +  BFD_RELOC_IP2K_PAGE3,

 34165 +

 34166 +/* Scenix IP2K - ext/low/high 8 bits of data address  */

 34167 +  BFD_RELOC_IP2K_LO8DATA,

 34168 +  BFD_RELOC_IP2K_HI8DATA,

 34169 +  BFD_RELOC_IP2K_EX8DATA,

 34170 +

 34171 +/* Scenix IP2K - low/high 8 bits of instruction word address  */

 34172 +  BFD_RELOC_IP2K_LO8INSN,

 34173 +  BFD_RELOC_IP2K_HI8INSN,

 34174 +

 34175 +/* Scenix IP2K - even/odd PC modifier to modify snb pcl.0  */

 34176 +  BFD_RELOC_IP2K_PC_SKIP,

 34177 +

 34178 +/* Scenix IP2K - 16 bit word address in text section.  */

 34179 +  BFD_RELOC_IP2K_TEXT,

 34180 +

 34181 +/* Scenix IP2K - 7-bit sp or dp offset  */

 34182 +  BFD_RELOC_IP2K_FR_OFFSET,

 34183 +

 34184 +/* Scenix VPE4K coprocessor - data/insn-space addressing  */

 34185 +  BFD_RELOC_VPE4KMATH_DATA,

 34186 +  BFD_RELOC_VPE4KMATH_INSN,

 34187 +

 34188 +/* These two relocations are used by the linker to determine which of

 34189 +the entries in a C++ virtual function table are actually used.  When

 34190 +the --gc-sections option is given, the linker will zero out the entries

 34191 +that are not used, so that the code for those functions need not be

 34192 +included in the output.

 34193 +

 34194 +VTABLE_INHERIT is a zero-space relocation used to describe to the

 34195 +linker the inheritance tree of a C++ virtual function table.  The

 34196 +relocation's symbol should be the parent class' vtable, and the

 34197 +relocation should be located at the child vtable.

 34198 +

 34199 +VTABLE_ENTRY is a zero-space relocation that describes the use of a

 34200 +virtual function table entry.  The reloc's symbol should refer to the

 34201 +table of the class mentioned in the code.  Off of that base, an offset

 34202 +describes the entry that is being used.  For Rela hosts, this offset

 34203 +is stored in the reloc's addend.  For Rel hosts, we are forced to put

 34204 +this offset in the reloc's section offset.  */

 34205 +  BFD_RELOC_VTABLE_INHERIT,

 34206 +  BFD_RELOC_VTABLE_ENTRY,

 34207 +

 34208 +/* Intel IA64 Relocations.  */

 34209 +  BFD_RELOC_IA64_IMM14,

 34210 +  BFD_RELOC_IA64_IMM22,

 34211 +  BFD_RELOC_IA64_IMM64,

 34212 +  BFD_RELOC_IA64_DIR32MSB,

 34213 +  BFD_RELOC_IA64_DIR32LSB,

 34214 +  BFD_RELOC_IA64_DIR64MSB,

 34215 +  BFD_RELOC_IA64_DIR64LSB,

 34216 +  BFD_RELOC_IA64_GPREL22,

 34217 +  BFD_RELOC_IA64_GPREL64I,

 34218 +  BFD_RELOC_IA64_GPREL32MSB,

 34219 +  BFD_RELOC_IA64_GPREL32LSB,

 34220 +  BFD_RELOC_IA64_GPREL64MSB,

 34221 +  BFD_RELOC_IA64_GPREL64LSB,

 34222 +  BFD_RELOC_IA64_LTOFF22,

 34223 +  BFD_RELOC_IA64_LTOFF64I,

 34224 +  BFD_RELOC_IA64_PLTOFF22,

 34225 +  BFD_RELOC_IA64_PLTOFF64I,

 34226 +  BFD_RELOC_IA64_PLTOFF64MSB,

 34227 +  BFD_RELOC_IA64_PLTOFF64LSB,

 34228 +  BFD_RELOC_IA64_FPTR64I,

 34229 +  BFD_RELOC_IA64_FPTR32MSB,

 34230 +  BFD_RELOC_IA64_FPTR32LSB,

 34231 +  BFD_RELOC_IA64_FPTR64MSB,

 34232 +  BFD_RELOC_IA64_FPTR64LSB,

 34233 +  BFD_RELOC_IA64_PCREL21B,

 34234 +  BFD_RELOC_IA64_PCREL21BI,

 34235 +  BFD_RELOC_IA64_PCREL21M,

 34236 +  BFD_RELOC_IA64_PCREL21F,

 34237 +  BFD_RELOC_IA64_PCREL22,

 34238 +  BFD_RELOC_IA64_PCREL60B,

 34239 +  BFD_RELOC_IA64_PCREL64I,

 34240 +  BFD_RELOC_IA64_PCREL32MSB,

 34241 +  BFD_RELOC_IA64_PCREL32LSB,

 34242 +  BFD_RELOC_IA64_PCREL64MSB,

 34243 +  BFD_RELOC_IA64_PCREL64LSB,

 34244 +  BFD_RELOC_IA64_LTOFF_FPTR22,

 34245 +  BFD_RELOC_IA64_LTOFF_FPTR64I,

 34246 +  BFD_RELOC_IA64_LTOFF_FPTR32MSB,

 34247 +  BFD_RELOC_IA64_LTOFF_FPTR32LSB,

 34248 +  BFD_RELOC_IA64_LTOFF_FPTR64MSB,

 34249 +  BFD_RELOC_IA64_LTOFF_FPTR64LSB,

 34250 +  BFD_RELOC_IA64_SEGREL32MSB,

 34251 +  BFD_RELOC_IA64_SEGREL32LSB,

 34252 +  BFD_RELOC_IA64_SEGREL64MSB,

 34253 +  BFD_RELOC_IA64_SEGREL64LSB,

 34254 +  BFD_RELOC_IA64_SECREL32MSB,

 34255 +  BFD_RELOC_IA64_SECREL32LSB,

 34256 +  BFD_RELOC_IA64_SECREL64MSB,

 34257 +  BFD_RELOC_IA64_SECREL64LSB,

 34258 +  BFD_RELOC_IA64_REL32MSB,

 34259 +  BFD_RELOC_IA64_REL32LSB,

 34260 +  BFD_RELOC_IA64_REL64MSB,

 34261 +  BFD_RELOC_IA64_REL64LSB,

 34262 +  BFD_RELOC_IA64_LTV32MSB,

 34263 +  BFD_RELOC_IA64_LTV32LSB,

 34264 +  BFD_RELOC_IA64_LTV64MSB,

 34265 +  BFD_RELOC_IA64_LTV64LSB,

 34266 +  BFD_RELOC_IA64_IPLTMSB,

 34267 +  BFD_RELOC_IA64_IPLTLSB,

 34268 +  BFD_RELOC_IA64_COPY,

 34269 +  BFD_RELOC_IA64_LTOFF22X,

 34270 +  BFD_RELOC_IA64_LDXMOV,

 34271 +  BFD_RELOC_IA64_TPREL14,

 34272 +  BFD_RELOC_IA64_TPREL22,

 34273 +  BFD_RELOC_IA64_TPREL64I,

 34274 +  BFD_RELOC_IA64_TPREL64MSB,

 34275 +  BFD_RELOC_IA64_TPREL64LSB,

 34276 +  BFD_RELOC_IA64_LTOFF_TPREL22,

 34277 +  BFD_RELOC_IA64_DTPMOD64MSB,

 34278 +  BFD_RELOC_IA64_DTPMOD64LSB,

 34279 +  BFD_RELOC_IA64_LTOFF_DTPMOD22,

 34280 +  BFD_RELOC_IA64_DTPREL14,

 34281 +  BFD_RELOC_IA64_DTPREL22,

 34282 +  BFD_RELOC_IA64_DTPREL64I,

 34283 +  BFD_RELOC_IA64_DTPREL32MSB,

 34284 +  BFD_RELOC_IA64_DTPREL32LSB,

 34285 +  BFD_RELOC_IA64_DTPREL64MSB,

 34286 +  BFD_RELOC_IA64_DTPREL64LSB,

 34287 +  BFD_RELOC_IA64_LTOFF_DTPREL22,

 34288 +

 34289 +/* Motorola 68HC11 reloc.

 34290 +This is the 8 bit high part of an absolute address.  */

 34291 +  BFD_RELOC_M68HC11_HI8,

 34292 +

 34293 +/* Motorola 68HC11 reloc.

 34294 +This is the 8 bit low part of an absolute address.  */

 34295 +  BFD_RELOC_M68HC11_LO8,

 34296 +

 34297 +/* Motorola 68HC11 reloc.

 34298 +This is the 3 bit of a value.  */

 34299 +  BFD_RELOC_M68HC11_3B,

 34300 +

 34301 +/* Motorola 68HC11 reloc.

 34302 +This reloc marks the beginning of a jump/call instruction.

 34303 +It is used for linker relaxation to correctly identify beginning

 34304 +of instruction and change some branches to use PC-relative

 34305 +addressing mode.  */

 34306 +  BFD_RELOC_M68HC11_RL_JUMP,

 34307 +

 34308 +/* Motorola 68HC11 reloc.

 34309 +This reloc marks a group of several instructions that gcc generates

 34310 +and for which the linker relaxation pass can modify and/or remove

 34311 +some of them.  */

 34312 +  BFD_RELOC_M68HC11_RL_GROUP,

 34313 +

 34314 +/* Motorola 68HC11 reloc.

 34315 +This is the 16-bit lower part of an address.  It is used for 'call'

 34316 +instruction to specify the symbol address without any special

 34317 +transformation (due to memory bank window).  */

 34318 +  BFD_RELOC_M68HC11_LO16,

 34319 +

 34320 +/* Motorola 68HC11 reloc.

 34321 +This is a 8-bit reloc that specifies the page number of an address.

 34322 +It is used by 'call' instruction to specify the page number of

 34323 +the symbol.  */

 34324 +  BFD_RELOC_M68HC11_PAGE,

 34325 +

 34326 +/* Motorola 68HC11 reloc.

 34327 +This is a 24-bit reloc that represents the address with a 16-bit

 34328 +value and a 8-bit page number.  The symbol address is transformed

 34329 +to follow the 16K memory bank of 68HC12 (seen as mapped in the window).  */

 34330 +  BFD_RELOC_M68HC11_24,

 34331 +

 34332 +/* Motorola 68HC12 reloc.

 34333 +This is the 5 bits of a value.  */

 34334 +  BFD_RELOC_M68HC12_5B,

 34335 +

 34336 +/* NS CR16C Relocations.  */

 34337 +  BFD_RELOC_16C_NUM08,

 34338 +  BFD_RELOC_16C_NUM08_C,

 34339 +  BFD_RELOC_16C_NUM16,

 34340 +  BFD_RELOC_16C_NUM16_C,

 34341 +  BFD_RELOC_16C_NUM32,

 34342 +  BFD_RELOC_16C_NUM32_C,

 34343 +  BFD_RELOC_16C_DISP04,

 34344 +  BFD_RELOC_16C_DISP04_C,

 34345 +  BFD_RELOC_16C_DISP08,

 34346 +  BFD_RELOC_16C_DISP08_C,

 34347 +  BFD_RELOC_16C_DISP16,

 34348 +  BFD_RELOC_16C_DISP16_C,

 34349 +  BFD_RELOC_16C_DISP24,

 34350 +  BFD_RELOC_16C_DISP24_C,

 34351 +  BFD_RELOC_16C_DISP24a,

 34352 +  BFD_RELOC_16C_DISP24a_C,

 34353 +  BFD_RELOC_16C_REG04,

 34354 +  BFD_RELOC_16C_REG04_C,

 34355 +  BFD_RELOC_16C_REG04a,

 34356 +  BFD_RELOC_16C_REG04a_C,

 34357 +  BFD_RELOC_16C_REG14,

 34358 +  BFD_RELOC_16C_REG14_C,

 34359 +  BFD_RELOC_16C_REG16,

 34360 +  BFD_RELOC_16C_REG16_C,

 34361 +  BFD_RELOC_16C_REG20,

 34362 +  BFD_RELOC_16C_REG20_C,

 34363 +  BFD_RELOC_16C_ABS20,

 34364 +  BFD_RELOC_16C_ABS20_C,

 34365 +  BFD_RELOC_16C_ABS24,

 34366 +  BFD_RELOC_16C_ABS24_C,

 34367 +  BFD_RELOC_16C_IMM04,

 34368 +  BFD_RELOC_16C_IMM04_C,

 34369 +  BFD_RELOC_16C_IMM16,

 34370 +  BFD_RELOC_16C_IMM16_C,

 34371 +  BFD_RELOC_16C_IMM20,

 34372 +  BFD_RELOC_16C_IMM20_C,

 34373 +  BFD_RELOC_16C_IMM24,

 34374 +  BFD_RELOC_16C_IMM24_C,

 34375 +  BFD_RELOC_16C_IMM32,

 34376 +  BFD_RELOC_16C_IMM32_C,

 34377 +

 34378 +/* NS CR16 Relocations.  */

 34379 +  BFD_RELOC_CR16_NUM8,

 34380 +  BFD_RELOC_CR16_NUM16,

 34381 +  BFD_RELOC_CR16_NUM32,

 34382 +  BFD_RELOC_CR16_NUM32a,

 34383 +  BFD_RELOC_CR16_REGREL0,

 34384 +  BFD_RELOC_CR16_REGREL4,

 34385 +  BFD_RELOC_CR16_REGREL4a,

 34386 +  BFD_RELOC_CR16_REGREL14,

 34387 +  BFD_RELOC_CR16_REGREL14a,

 34388 +  BFD_RELOC_CR16_REGREL16,

 34389 +  BFD_RELOC_CR16_REGREL20,

 34390 +  BFD_RELOC_CR16_REGREL20a,

 34391 +  BFD_RELOC_CR16_ABS20,

 34392 +  BFD_RELOC_CR16_ABS24,

 34393 +  BFD_RELOC_CR16_IMM4,

 34394 +  BFD_RELOC_CR16_IMM8,

 34395 +  BFD_RELOC_CR16_IMM16,

 34396 +  BFD_RELOC_CR16_IMM20,

 34397 +  BFD_RELOC_CR16_IMM24,

 34398 +  BFD_RELOC_CR16_IMM32,

 34399 +  BFD_RELOC_CR16_IMM32a,

 34400 +  BFD_RELOC_CR16_DISP4,

 34401 +  BFD_RELOC_CR16_DISP8,

 34402 +  BFD_RELOC_CR16_DISP16,

 34403 +  BFD_RELOC_CR16_DISP20,

 34404 +  BFD_RELOC_CR16_DISP24,

 34405 +  BFD_RELOC_CR16_DISP24a,

 34406 +

 34407 +/* NS CRX Relocations.  */

 34408 +  BFD_RELOC_CRX_REL4,

 34409 +  BFD_RELOC_CRX_REL8,

 34410 +  BFD_RELOC_CRX_REL8_CMP,

 34411 +  BFD_RELOC_CRX_REL16,

 34412 +  BFD_RELOC_CRX_REL24,

 34413 +  BFD_RELOC_CRX_REL32,

 34414 +  BFD_RELOC_CRX_REGREL12,

 34415 +  BFD_RELOC_CRX_REGREL22,

 34416 +  BFD_RELOC_CRX_REGREL28,

 34417 +  BFD_RELOC_CRX_REGREL32,

 34418 +  BFD_RELOC_CRX_ABS16,

 34419 +  BFD_RELOC_CRX_ABS32,

 34420 +  BFD_RELOC_CRX_NUM8,

 34421 +  BFD_RELOC_CRX_NUM16,

 34422 +  BFD_RELOC_CRX_NUM32,

 34423 +  BFD_RELOC_CRX_IMM16,

 34424 +  BFD_RELOC_CRX_IMM32,

 34425 +  BFD_RELOC_CRX_SWITCH8,

 34426 +  BFD_RELOC_CRX_SWITCH16,

 34427 +  BFD_RELOC_CRX_SWITCH32,

 34428 +

 34429 +/* These relocs are only used within the CRIS assembler.  They are not

 34430 +(at present) written to any object files.  */

 34431 +  BFD_RELOC_CRIS_BDISP8,

 34432 +  BFD_RELOC_CRIS_UNSIGNED_5,

 34433 +  BFD_RELOC_CRIS_SIGNED_6,

 34434 +  BFD_RELOC_CRIS_UNSIGNED_6,

 34435 +  BFD_RELOC_CRIS_SIGNED_8,

 34436 +  BFD_RELOC_CRIS_UNSIGNED_8,

 34437 +  BFD_RELOC_CRIS_SIGNED_16,

 34438 +  BFD_RELOC_CRIS_UNSIGNED_16,

 34439 +  BFD_RELOC_CRIS_LAPCQ_OFFSET,

 34440 +  BFD_RELOC_CRIS_UNSIGNED_4,

 34441 +

 34442 +/* Relocs used in ELF shared libraries for CRIS.  */

 34443 +  BFD_RELOC_CRIS_COPY,

 34444 +  BFD_RELOC_CRIS_GLOB_DAT,

 34445 +  BFD_RELOC_CRIS_JUMP_SLOT,

 34446 +  BFD_RELOC_CRIS_RELATIVE,

 34447 +

 34448 +/* 32-bit offset to symbol-entry within GOT.  */

 34449 +  BFD_RELOC_CRIS_32_GOT,

 34450 +

 34451 +/* 16-bit offset to symbol-entry within GOT.  */

 34452 +  BFD_RELOC_CRIS_16_GOT,

 34453 +

 34454 +/* 32-bit offset to symbol-entry within GOT, with PLT handling.  */

 34455 +  BFD_RELOC_CRIS_32_GOTPLT,

 34456 +

 34457 +/* 16-bit offset to symbol-entry within GOT, with PLT handling.  */

 34458 +  BFD_RELOC_CRIS_16_GOTPLT,

 34459 +

 34460 +/* 32-bit offset to symbol, relative to GOT.  */

 34461 +  BFD_RELOC_CRIS_32_GOTREL,

 34462 +

 34463 +/* 32-bit offset to symbol with PLT entry, relative to GOT.  */

 34464 +  BFD_RELOC_CRIS_32_PLT_GOTREL,

 34465 +

 34466 +/* 32-bit offset to symbol with PLT entry, relative to this relocation.  */

 34467 +  BFD_RELOC_CRIS_32_PLT_PCREL,

 34468 +

 34469 +/* Intel i860 Relocations.  */

 34470 +  BFD_RELOC_860_COPY,

 34471 +  BFD_RELOC_860_GLOB_DAT,

 34472 +  BFD_RELOC_860_JUMP_SLOT,

 34473 +  BFD_RELOC_860_RELATIVE,

 34474 +  BFD_RELOC_860_PC26,

 34475 +  BFD_RELOC_860_PLT26,

 34476 +  BFD_RELOC_860_PC16,

 34477 +  BFD_RELOC_860_LOW0,

 34478 +  BFD_RELOC_860_SPLIT0,

 34479 +  BFD_RELOC_860_LOW1,

 34480 +  BFD_RELOC_860_SPLIT1,

 34481 +  BFD_RELOC_860_LOW2,

 34482 +  BFD_RELOC_860_SPLIT2,

 34483 +  BFD_RELOC_860_LOW3,

 34484 +  BFD_RELOC_860_LOGOT0,

 34485 +  BFD_RELOC_860_SPGOT0,

 34486 +  BFD_RELOC_860_LOGOT1,

 34487 +  BFD_RELOC_860_SPGOT1,

 34488 +  BFD_RELOC_860_LOGOTOFF0,

 34489 +  BFD_RELOC_860_SPGOTOFF0,

 34490 +  BFD_RELOC_860_LOGOTOFF1,

 34491 +  BFD_RELOC_860_SPGOTOFF1,

 34492 +  BFD_RELOC_860_LOGOTOFF2,

 34493 +  BFD_RELOC_860_LOGOTOFF3,

 34494 +  BFD_RELOC_860_LOPC,

 34495 +  BFD_RELOC_860_HIGHADJ,

 34496 +  BFD_RELOC_860_HAGOT,

 34497 +  BFD_RELOC_860_HAGOTOFF,

 34498 +  BFD_RELOC_860_HAPC,

 34499 +  BFD_RELOC_860_HIGH,

 34500 +  BFD_RELOC_860_HIGOT,

 34501 +  BFD_RELOC_860_HIGOTOFF,

 34502 +

 34503 +/* OpenRISC Relocations.  */

 34504 +  BFD_RELOC_OPENRISC_ABS_26,

 34505 +  BFD_RELOC_OPENRISC_REL_26,

 34506 +

 34507 +/* H8 elf Relocations.  */

 34508 +  BFD_RELOC_H8_DIR16A8,

 34509 +  BFD_RELOC_H8_DIR16R8,

 34510 +  BFD_RELOC_H8_DIR24A8,

 34511 +  BFD_RELOC_H8_DIR24R8,

 34512 +  BFD_RELOC_H8_DIR32A16,

 34513 +

 34514 +/* Sony Xstormy16 Relocations.  */

 34515 +  BFD_RELOC_XSTORMY16_REL_12,

 34516 +  BFD_RELOC_XSTORMY16_12,

 34517 +  BFD_RELOC_XSTORMY16_24,

 34518 +  BFD_RELOC_XSTORMY16_FPTR16,

 34519 +

 34520 +/* Self-describing complex relocations.  */

 34521 +  BFD_RELOC_RELC,

 34522 +

 34523 +

 34524 +/* Infineon Relocations.  */

 34525 +  BFD_RELOC_XC16X_PAG,

 34526 +  BFD_RELOC_XC16X_POF,

 34527 +  BFD_RELOC_XC16X_SEG,

 34528 +  BFD_RELOC_XC16X_SOF,

 34529 +

 34530 +/* Relocations used by VAX ELF.  */

 34531 +  BFD_RELOC_VAX_GLOB_DAT,

 34532 +  BFD_RELOC_VAX_JMP_SLOT,

 34533 +  BFD_RELOC_VAX_RELATIVE,

 34534 +

 34535 +/* Morpho MT - 16 bit immediate relocation.  */

 34536 +  BFD_RELOC_MT_PC16,

 34537 +

 34538 +/* Morpho MT - Hi 16 bits of an address.  */

 34539 +  BFD_RELOC_MT_HI16,

 34540 +

 34541 +/* Morpho MT - Low 16 bits of an address.  */

 34542 +  BFD_RELOC_MT_LO16,

 34543 +

 34544 +/* Morpho MT - Used to tell the linker which vtable entries are used.  */

 34545 +  BFD_RELOC_MT_GNU_VTINHERIT,

 34546 +

 34547 +/* Morpho MT - Used to tell the linker which vtable entries are used.  */

 34548 +  BFD_RELOC_MT_GNU_VTENTRY,

 34549 +

 34550 +/* Morpho MT - 8 bit immediate relocation.  */

 34551 +  BFD_RELOC_MT_PCINSN8,

 34552 +

 34553 +/* msp430 specific relocation codes  */

 34554 +  BFD_RELOC_MSP430_10_PCREL,

 34555 +  BFD_RELOC_MSP430_16_PCREL,

 34556 +  BFD_RELOC_MSP430_16,

 34557 +  BFD_RELOC_MSP430_16_PCREL_BYTE,

 34558 +  BFD_RELOC_MSP430_16_BYTE,

 34559 +  BFD_RELOC_MSP430_2X_PCREL,

 34560 +  BFD_RELOC_MSP430_RL_PCREL,

 34561 +

 34562 +/* IQ2000 Relocations.  */

 34563 +  BFD_RELOC_IQ2000_OFFSET_16,

 34564 +  BFD_RELOC_IQ2000_OFFSET_21,

 34565 +  BFD_RELOC_IQ2000_UHI16,

 34566 +

 34567 +/* Special Xtensa relocation used only by PLT entries in ELF shared

 34568 +objects to indicate that the runtime linker should set the value

 34569 +to one of its own internal functions or data structures.  */

 34570 +  BFD_RELOC_XTENSA_RTLD,

 34571 +

 34572 +/* Xtensa relocations for ELF shared objects.  */

 34573 +  BFD_RELOC_XTENSA_GLOB_DAT,

 34574 +  BFD_RELOC_XTENSA_JMP_SLOT,

 34575 +  BFD_RELOC_XTENSA_RELATIVE,

 34576 +

 34577 +/* Xtensa relocation used in ELF object files for symbols that may require

 34578 +PLT entries.  Otherwise, this is just a generic 32-bit relocation.  */

 34579 +  BFD_RELOC_XTENSA_PLT,

 34580 +

 34581 +/* Xtensa relocations to mark the difference of two local symbols.

 34582 +These are only needed to support linker relaxation and can be ignored

 34583 +when not relaxing.  The field is set to the value of the difference

 34584 +assuming no relaxation.  The relocation encodes the position of the

 34585 +first symbol so the linker can determine whether to adjust the field

 34586 +value.  */

 34587 +  BFD_RELOC_XTENSA_DIFF8,

 34588 +  BFD_RELOC_XTENSA_DIFF16,

 34589 +  BFD_RELOC_XTENSA_DIFF32,

 34590 +

 34591 +/* Generic Xtensa relocations for instruction operands.  Only the slot

 34592 +number is encoded in the relocation.  The relocation applies to the

 34593 +last PC-relative immediate operand, or if there are no PC-relative

 34594 +immediates, to the last immediate operand.  */

 34595 +  BFD_RELOC_XTENSA_SLOT0_OP,

 34596 +  BFD_RELOC_XTENSA_SLOT1_OP,

 34597 +  BFD_RELOC_XTENSA_SLOT2_OP,

 34598 +  BFD_RELOC_XTENSA_SLOT3_OP,

 34599 +  BFD_RELOC_XTENSA_SLOT4_OP,

 34600 +  BFD_RELOC_XTENSA_SLOT5_OP,

 34601 +  BFD_RELOC_XTENSA_SLOT6_OP,

 34602 +  BFD_RELOC_XTENSA_SLOT7_OP,

 34603 +  BFD_RELOC_XTENSA_SLOT8_OP,

 34604 +  BFD_RELOC_XTENSA_SLOT9_OP,

 34605 +  BFD_RELOC_XTENSA_SLOT10_OP,

 34606 +  BFD_RELOC_XTENSA_SLOT11_OP,

 34607 +  BFD_RELOC_XTENSA_SLOT12_OP,

 34608 +  BFD_RELOC_XTENSA_SLOT13_OP,

 34609 +  BFD_RELOC_XTENSA_SLOT14_OP,

 34610 +

 34611 +/* Alternate Xtensa relocations.  Only the slot is encoded in the

 34612 +relocation.  The meaning of these relocations is opcode-specific.  */

 34613 +  BFD_RELOC_XTENSA_SLOT0_ALT,

 34614 +  BFD_RELOC_XTENSA_SLOT1_ALT,

 34615 +  BFD_RELOC_XTENSA_SLOT2_ALT,

 34616 +  BFD_RELOC_XTENSA_SLOT3_ALT,

 34617 +  BFD_RELOC_XTENSA_SLOT4_ALT,

 34618 +  BFD_RELOC_XTENSA_SLOT5_ALT,

 34619 +  BFD_RELOC_XTENSA_SLOT6_ALT,

 34620 +  BFD_RELOC_XTENSA_SLOT7_ALT,

 34621 +  BFD_RELOC_XTENSA_SLOT8_ALT,

 34622 +  BFD_RELOC_XTENSA_SLOT9_ALT,

 34623 +  BFD_RELOC_XTENSA_SLOT10_ALT,

 34624 +  BFD_RELOC_XTENSA_SLOT11_ALT,

 34625 +  BFD_RELOC_XTENSA_SLOT12_ALT,

 34626 +  BFD_RELOC_XTENSA_SLOT13_ALT,

 34627 +  BFD_RELOC_XTENSA_SLOT14_ALT,

 34628 +

 34629 +/* Xtensa relocations for backward compatibility.  These have all been

 34630 +replaced by BFD_RELOC_XTENSA_SLOT0_OP.  */

 34631 +  BFD_RELOC_XTENSA_OP0,

 34632 +  BFD_RELOC_XTENSA_OP1,

 34633 +  BFD_RELOC_XTENSA_OP2,

 34634 +

 34635 +/* Xtensa relocation to mark that the assembler expanded the

 34636 +instructions from an original target.  The expansion size is

 34637 +encoded in the reloc size.  */

 34638 +  BFD_RELOC_XTENSA_ASM_EXPAND,

 34639 +

 34640 +/* Xtensa relocation to mark that the linker should simplify

 34641 +assembler-expanded instructions.  This is commonly used

 34642 +internally by the linker after analysis of a

 34643 +BFD_RELOC_XTENSA_ASM_EXPAND.  */

 34644 +  BFD_RELOC_XTENSA_ASM_SIMPLIFY,

 34645 +

 34646 +/* 8 bit signed offset in (ix+d) or (iy+d).  */

 34647 +  BFD_RELOC_Z80_DISP8,

 34648 +

 34649 +/* DJNZ offset.  */

 34650 +  BFD_RELOC_Z8K_DISP7,

 34651 +

 34652 +/* CALR offset.  */

 34653 +  BFD_RELOC_Z8K_CALLR,

 34654 +

 34655 +/* 4 bit value.  */

 34656 +  BFD_RELOC_Z8K_IMM4L,

 34657 +  BFD_RELOC_UNUSED };

 34658 +typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;

 34659 +reloc_howto_type *bfd_reloc_type_lookup

 34660 +   (bfd *abfd, bfd_reloc_code_real_type code);

 34661 +reloc_howto_type *bfd_reloc_name_lookup

 34662 +   (bfd *abfd, const char *reloc_name);

 34663 +

 34664 +const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);

 34665 +

 34666 +/* Extracted from syms.c.  */

 34667 +

 34668 +typedef struct bfd_symbol

 34669 +{

 34670 +  /* A pointer to the BFD which owns the symbol. This information

 34671 +     is necessary so that a back end can work out what additional

 34672 +     information (invisible to the application writer) is carried

 34673 +     with the symbol.

 34674 +

 34675 +     This field is *almost* redundant, since you can use section->owner

 34676 +     instead, except that some symbols point to the global sections

 34677 +     bfd_{abs,com,und}_section.  This could be fixed by making

 34678 +     these globals be per-bfd (or per-target-flavor).  FIXME.  */

 34679 +  struct bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field.  */

 34680 +

 34681 +  /* The text of the symbol. The name is left alone, and not copied; the

 34682 +     application may not alter it.  */

 34683 +  const char *name;

 34684 +

 34685 +  /* The value of the symbol.  This really should be a union of a

 34686 +     numeric value with a pointer, since some flags indicate that

 34687 +     a pointer to another symbol is stored here.  */

 34688 +  symvalue value;

 34689 +

 34690 +  /* Attributes of a symbol.  */

 34691 +#define BSF_NO_FLAGS    0x00

 34692 +

 34693 +  /* The symbol has local scope; <<static>> in <<C>>. The value

 34694 +     is the offset into the section of the data.  */

 34695 +#define BSF_LOCAL      0x01

 34696 +

 34697 +  /* The symbol has global scope; initialized data in <<C>>. The

 34698 +     value is the offset into the section of the data.  */

 34699 +#define BSF_GLOBAL     0x02

 34700 +

 34701 +  /* The symbol has global scope and is exported. The value is

 34702 +     the offset into the section of the data.  */

 34703 +#define BSF_EXPORT     BSF_GLOBAL /* No real difference.  */

 34704 +

 34705 +  /* A normal C symbol would be one of:

 34706 +     <<BSF_LOCAL>>, <<BSF_FORT_COMM>>,  <<BSF_UNDEFINED>> or

 34707 +     <<BSF_GLOBAL>>.  */

 34708 +

 34709 +  /* The symbol is a debugging record. The value has an arbitrary

 34710 +     meaning, unless BSF_DEBUGGING_RELOC is also set.  */

 34711 +#define BSF_DEBUGGING  0x08

 34712 +

 34713 +  /* The symbol denotes a function entry point.  Used in ELF,

 34714 +     perhaps others someday.  */

 34715 +#define BSF_FUNCTION    0x10

 34716 +

 34717 +  /* Used by the linker.  */

 34718 +#define BSF_KEEP        0x20

 34719 +#define BSF_KEEP_G      0x40

 34720 +

 34721 +  /* A weak global symbol, overridable without warnings by

 34722 +     a regular global symbol of the same name.  */

 34723 +#define BSF_WEAK        0x80

 34724 +

 34725 +  /* This symbol was created to point to a section, e.g. ELF's

 34726 +     STT_SECTION symbols.  */

 34727 +#define BSF_SECTION_SYM 0x100

 34728 +

 34729 +  /* The symbol used to be a common symbol, but now it is

 34730 +     allocated.  */

 34731 +#define BSF_OLD_COMMON  0x200

 34732 +

 34733 +  /* The default value for common data.  */

 34734 +#define BFD_FORT_COMM_DEFAULT_VALUE 0

 34735 +

 34736 +  /* In some files the type of a symbol sometimes alters its

 34737 +     location in an output file - ie in coff a <<ISFCN>> symbol

 34738 +     which is also <<C_EXT>> symbol appears where it was

 34739 +     declared and not at the end of a section.  This bit is set

 34740 +     by the target BFD part to convey this information.  */

 34741 +#define BSF_NOT_AT_END    0x400

 34742 +

 34743 +  /* Signal that the symbol is the label of constructor section.  */

 34744 +#define BSF_CONSTRUCTOR   0x800

 34745 +

 34746 +  /* Signal that the symbol is a warning symbol.  The name is a

 34747 +     warning.  The name of the next symbol is the one to warn about;

 34748 +     if a reference is made to a symbol with the same name as the next

 34749 +     symbol, a warning is issued by the linker.  */

 34750 +#define BSF_WARNING       0x1000

 34751 +

 34752 +  /* Signal that the symbol is indirect.  This symbol is an indirect

 34753 +     pointer to the symbol with the same name as the next symbol.  */

 34754 +#define BSF_INDIRECT      0x2000

 34755 +

 34756 +  /* BSF_FILE marks symbols that contain a file name.  This is used

 34757 +     for ELF STT_FILE symbols.  */

 34758 +#define BSF_FILE          0x4000

 34759 +

 34760 +  /* Symbol is from dynamic linking information.  */

 34761 +#define BSF_DYNAMIC       0x8000

 34762 +

 34763 +  /* The symbol denotes a data object.  Used in ELF, and perhaps

 34764 +     others someday.  */

 34765 +#define BSF_OBJECT        0x10000

 34766 +

 34767 +  /* This symbol is a debugging symbol.  The value is the offset

 34768 +     into the section of the data.  BSF_DEBUGGING should be set

 34769 +     as well.  */

 34770 +#define BSF_DEBUGGING_RELOC 0x20000

 34771 +

 34772 +  /* This symbol is thread local.  Used in ELF.  */

 34773 +#define BSF_THREAD_LOCAL  0x40000

 34774 +

 34775 +  /* This symbol represents a complex relocation expression,

 34776 +     with the expression tree serialized in the symbol name.  */

 34777 +#define BSF_RELC 0x80000

 34778 +

 34779 +  /* This symbol represents a signed complex relocation expression,

 34780 +     with the expression tree serialized in the symbol name.  */

 34781 +#define BSF_SRELC 0x100000

 34782 +

 34783 +  flagword flags;

 34784 +

 34785 +  /* A pointer to the section to which this symbol is

 34786 +     relative.  This will always be non NULL, there are special

 34787 +     sections for undefined and absolute symbols.  */

 34788 +  struct bfd_section *section;

 34789 +

 34790 +  /* Back end special data.  */

 34791 +  union

 34792 +    {

 34793 +      void *p;

 34794 +      bfd_vma i;

 34795 +    }

 34796 +  udata;

 34797 +}

 34798 +asymbol;

 34799 +

 34800 +#define bfd_get_symtab_upper_bound(abfd) \

 34801 +     BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))

 34802 +

 34803 +bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);

 34804 +

 34805 +bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);

 34806 +

 34807 +#define bfd_is_local_label_name(abfd, name) \

 34808 +  BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))

 34809 +

 34810 +bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);

 34811 +

 34812 +#define bfd_is_target_special_symbol(abfd, sym) \

 34813 +  BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))

 34814 +

 34815 +#define bfd_canonicalize_symtab(abfd, location) \

 34816 +  BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))

 34817 +

 34818 +bfd_boolean bfd_set_symtab

 34819 +   (bfd *abfd, asymbol **location, unsigned int count);

 34820 +

 34821 +void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);

 34822 +

 34823 +#define bfd_make_empty_symbol(abfd) \

 34824 +  BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))

 34825 +

 34826 +asymbol *_bfd_generic_make_empty_symbol (bfd *);

 34827 +

 34828 +#define bfd_make_debug_symbol(abfd,ptr,size) \

 34829 +  BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))

 34830 +

 34831 +int bfd_decode_symclass (asymbol *symbol);

 34832 +

 34833 +bfd_boolean bfd_is_undefined_symclass (int symclass);

 34834 +

 34835 +void bfd_symbol_info (asymbol *symbol, symbol_info *ret);

 34836 +

 34837 +bfd_boolean bfd_copy_private_symbol_data

 34838 +   (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);

 34839 +

 34840 +#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \

 34841 +  BFD_SEND (obfd, _bfd_copy_private_symbol_data, \

 34842 +            (ibfd, isymbol, obfd, osymbol))

 34843 +

 34844 +/* Extracted from bfd.c.  */

 34845 +struct bfd

 34846 +{

 34847 +  /* A unique identifier of the BFD  */

 34848 +  unsigned int id;

 34849 +

 34850 +  /* The filename the application opened the BFD with.  */

 34851 +  const char *filename;

 34852 +

 34853 +  /* A pointer to the target jump table.  */

 34854 +  const struct bfd_target *xvec;

 34855 +

 34856 +  /* The IOSTREAM, and corresponding IO vector that provide access

 34857 +     to the file backing the BFD.  */

 34858 +  void *iostream;

 34859 +  const struct bfd_iovec *iovec;

 34860 +

 34861 +  /* Is the file descriptor being cached?  That is, can it be closed as

 34862 +     needed, and re-opened when accessed later?  */

 34863 +  bfd_boolean cacheable;

 34864 +

 34865 +  /* Marks whether there was a default target specified when the

 34866 +     BFD was opened. This is used to select which matching algorithm

 34867 +     to use to choose the back end.  */

 34868 +  bfd_boolean target_defaulted;

 34869 +

 34870 +  /* The caching routines use these to maintain a

 34871 +     least-recently-used list of BFDs.  */

 34872 +  struct bfd *lru_prev, *lru_next;

 34873 +

 34874 +  /* When a file is closed by the caching routines, BFD retains

 34875 +     state information on the file here...  */

 34876 +  ufile_ptr where;

 34877 +

 34878 +  /* ... and here: (``once'' means at least once).  */

 34879 +  bfd_boolean opened_once;

 34880 +

 34881 +  /* Set if we have a locally maintained mtime value, rather than

 34882 +     getting it from the file each time.  */

 34883 +  bfd_boolean mtime_set;

 34884 +

 34885 +  /* File modified time, if mtime_set is TRUE.  */

 34886 +  long mtime;

 34887 +

 34888 +  /* Reserved for an unimplemented file locking extension.  */

 34889 +  int ifd;

 34890 +

 34891 +  /* The format which belongs to the BFD. (object, core, etc.)  */

 34892 +  bfd_format format;

 34893 +

 34894 +  /* The direction with which the BFD was opened.  */

 34895 +  enum bfd_direction

 34896 +    {

 34897 +      no_direction = 0,

 34898 +      read_direction = 1,

 34899 +      write_direction = 2,

 34900 +      both_direction = 3

 34901 +    }

 34902 +  direction;

 34903 +

 34904 +  /* Format_specific flags.  */

 34905 +  flagword flags;

 34906 +

 34907 +  /* Currently my_archive is tested before adding origin to

 34908 +     anything. I believe that this can become always an add of

 34909 +     origin, with origin set to 0 for non archive files.  */

 34910 +  ufile_ptr origin;

 34911 +

 34912 +  /* Remember when output has begun, to stop strange things

 34913 +     from happening.  */

 34914 +  bfd_boolean output_has_begun;

 34915 +

 34916 +  /* A hash table for section names.  */

 34917 +  struct bfd_hash_table section_htab;

 34918 +

 34919 +  /* Pointer to linked list of sections.  */

 34920 +  struct bfd_section *sections;

 34921 +

 34922 +  /* The last section on the section list.  */

 34923 +  struct bfd_section *section_last;

 34924 +

 34925 +  /* The number of sections.  */

 34926 +  unsigned int section_count;

 34927 +

 34928 +  /* Stuff only useful for object files:

 34929 +     The start address.  */

 34930 +  bfd_vma start_address;

 34931 +

 34932 +  /* Used for input and output.  */

 34933 +  unsigned int symcount;

 34934 +

 34935 +  /* Symbol table for output BFD (with symcount entries).  */

 34936 +  struct bfd_symbol  **outsymbols;

 34937 +

 34938 +  /* Used for slurped dynamic symbol tables.  */

 34939 +  unsigned int dynsymcount;

 34940 +

 34941 +  /* Pointer to structure which contains architecture information.  */

 34942 +  const struct bfd_arch_info *arch_info;

 34943 +

 34944 +  /* Flag set if symbols from this BFD should not be exported.  */

 34945 +  bfd_boolean no_export;

 34946 +

 34947 +  /* Stuff only useful for archives.  */

 34948 +  void *arelt_data;

 34949 +  struct bfd *my_archive;      /* The containing archive BFD.  */

 34950 +  struct bfd *archive_next;    /* The next BFD in the archive.  */

 34951 +  struct bfd *archive_head;    /* The first BFD in the archive.  */

 34952 +  bfd_boolean has_armap;

 34953 +

 34954 +  /* A chain of BFD structures involved in a link.  */

 34955 +  struct bfd *link_next;

 34956 +

 34957 +  /* A field used by _bfd_generic_link_add_archive_symbols.  This will

 34958 +     be used only for archive elements.  */

 34959 +  int archive_pass;

 34960 +

 34961 +  /* Used by the back end to hold private data.  */

 34962 +  union

 34963 +    {

 34964 +      struct aout_data_struct *aout_data;

 34965 +      struct artdata *aout_ar_data;

 34966 +      struct _oasys_data *oasys_obj_data;

 34967 +      struct _oasys_ar_data *oasys_ar_data;

 34968 +      struct coff_tdata *coff_obj_data;

 34969 +      struct pe_tdata *pe_obj_data;

 34970 +      struct xcoff_tdata *xcoff_obj_data;

 34971 +      struct ecoff_tdata *ecoff_obj_data;

 34972 +      struct ieee_data_struct *ieee_data;

 34973 +      struct ieee_ar_data_struct *ieee_ar_data;

 34974 +      struct srec_data_struct *srec_data;

 34975 +      struct ihex_data_struct *ihex_data;

 34976 +      struct tekhex_data_struct *tekhex_data;

 34977 +      struct elf_obj_tdata *elf_obj_data;

 34978 +      struct nlm_obj_tdata *nlm_obj_data;

 34979 +      struct bout_data_struct *bout_data;

 34980 +      struct mmo_data_struct *mmo_data;

 34981 +      struct sun_core_struct *sun_core_data;

 34982 +      struct sco5_core_struct *sco5_core_data;

 34983 +      struct trad_core_struct *trad_core_data;

 34984 +      struct som_data_struct *som_data;

 34985 +      struct hpux_core_struct *hpux_core_data;

 34986 +      struct hppabsd_core_struct *hppabsd_core_data;

 34987 +      struct sgi_core_struct *sgi_core_data;

 34988 +      struct lynx_core_struct *lynx_core_data;

 34989 +      struct osf_core_struct *osf_core_data;

 34990 +      struct cisco_core_struct *cisco_core_data;

 34991 +      struct versados_data_struct *versados_data;

 34992 +      struct netbsd_core_struct *netbsd_core_data;

 34993 +      struct mach_o_data_struct *mach_o_data;

 34994 +      struct mach_o_fat_data_struct *mach_o_fat_data;

 34995 +      struct bfd_pef_data_struct *pef_data;

 34996 +      struct bfd_pef_xlib_data_struct *pef_xlib_data;

 34997 +      struct bfd_sym_data_struct *sym_data;

 34998 +      void *any;

 34999 +    }

 35000 +  tdata;

 35001 +

 35002 +  /* Used by the application to hold private data.  */

 35003 +  void *usrdata;

 35004 +

 35005 +  /* Where all the allocated stuff under this BFD goes.  This is a

 35006 +     struct objalloc *, but we use void * to avoid requiring the inclusion

 35007 +     of objalloc.h.  */

 35008 +  void *memory;

 35009 +};

 35010 +

 35011 +typedef enum bfd_error

 35012 +{

 35013 +  bfd_error_no_error = 0,

 35014 +  bfd_error_system_call,

 35015 +  bfd_error_invalid_target,

 35016 +  bfd_error_wrong_format,

 35017 +  bfd_error_wrong_object_format,

 35018 +  bfd_error_invalid_operation,

 35019 +  bfd_error_no_memory,

 35020 +  bfd_error_no_symbols,

 35021 +  bfd_error_no_armap,

 35022 +  bfd_error_no_more_archived_files,

 35023 +  bfd_error_malformed_archive,

 35024 +  bfd_error_file_not_recognized,

 35025 +  bfd_error_file_ambiguously_recognized,

 35026 +  bfd_error_no_contents,

 35027 +  bfd_error_nonrepresentable_section,

 35028 +  bfd_error_no_debug_section,

 35029 +  bfd_error_bad_value,

 35030 +  bfd_error_file_truncated,

 35031 +  bfd_error_file_too_big,

 35032 +  bfd_error_on_input,

 35033 +  bfd_error_invalid_error_code

 35034 +}

 35035 +bfd_error_type;

 35036 +

 35037 +bfd_error_type bfd_get_error (void);

 35038 +

 35039 +void bfd_set_error (bfd_error_type error_tag, ...);

 35040 +

 35041 +const char *bfd_errmsg (bfd_error_type error_tag);

 35042 +

 35043 +void bfd_perror (const char *message);

 35044 +

 35045 +typedef void (*bfd_error_handler_type) (const char *, ...);

 35046 +

 35047 +bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);

 35048 +

 35049 +void bfd_set_error_program_name (const char *);

 35050 +

 35051 +bfd_error_handler_type bfd_get_error_handler (void);

 35052 +

 35053 +long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);

 35054 +

 35055 +long bfd_canonicalize_reloc

 35056 +   (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);

 35057 +

 35058 +void bfd_set_reloc

 35059 +   (bfd *abfd, asection *sec, arelent **rel, unsigned int count);

 35060 +

 35061 +bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);

 35062 +

 35063 +int bfd_get_arch_size (bfd *abfd);

 35064 +

 35065 +int bfd_get_sign_extend_vma (bfd *abfd);

 35066 +

 35067 +bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);

 35068 +

 35069 +unsigned int bfd_get_gp_size (bfd *abfd);

 35070 +

 35071 +void bfd_set_gp_size (bfd *abfd, unsigned int i);

 35072 +

 35073 +bfd_vma bfd_scan_vma (const char *string, const char **end, int base);

 35074 +

 35075 +bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);

 35076 +

 35077 +#define bfd_copy_private_header_data(ibfd, obfd) \

 35078 +     BFD_SEND (obfd, _bfd_copy_private_header_data, \

 35079 +               (ibfd, obfd))

 35080 +bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);

 35081 +

 35082 +#define bfd_copy_private_bfd_data(ibfd, obfd) \

 35083 +     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \

 35084 +               (ibfd, obfd))

 35085 +bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);

 35086 +

 35087 +#define bfd_merge_private_bfd_data(ibfd, obfd) \

 35088 +     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \

 35089 +               (ibfd, obfd))

 35090 +bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);

 35091 +

 35092 +#define bfd_set_private_flags(abfd, flags) \

 35093 +     BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))

 35094 +#define bfd_sizeof_headers(abfd, info) \

 35095 +       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))

 35096 +

 35097 +#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \

 35098 +       BFD_SEND (abfd, _bfd_find_nearest_line, \

 35099 +                 (abfd, sec, syms, off, file, func, line))

 35100 +

 35101 +#define bfd_find_line(abfd, syms, sym, file, line) \

 35102 +       BFD_SEND (abfd, _bfd_find_line, \

 35103 +                 (abfd, syms, sym, file, line))

 35104 +

 35105 +#define bfd_find_inliner_info(abfd, file, func, line) \

 35106 +       BFD_SEND (abfd, _bfd_find_inliner_info, \

 35107 +                 (abfd, file, func, line))

 35108 +

 35109 +#define bfd_debug_info_start(abfd) \

 35110 +       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))

 35111 +

 35112 +#define bfd_debug_info_end(abfd) \

 35113 +       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))

 35114 +

 35115 +#define bfd_debug_info_accumulate(abfd, section) \

 35116 +       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))

 35117 +

 35118 +#define bfd_stat_arch_elt(abfd, stat) \

 35119 +       BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))

 35120 +

 35121 +#define bfd_update_armap_timestamp(abfd) \

 35122 +       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))

 35123 +

 35124 +#define bfd_set_arch_mach(abfd, arch, mach)\

 35125 +       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))

 35126 +

 35127 +#define bfd_relax_section(abfd, section, link_info, again) \

 35128 +       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))

 35129 +

 35130 +#define bfd_gc_sections(abfd, link_info) \

 35131 +       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))

 35132 +

 35133 +#define bfd_merge_sections(abfd, link_info) \

 35134 +       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))

 35135 +

 35136 +#define bfd_is_group_section(abfd, sec) \

 35137 +       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))

 35138 +

 35139 +#define bfd_discard_group(abfd, sec) \

 35140 +       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))

 35141 +

 35142 +#define bfd_link_hash_table_create(abfd) \

 35143 +       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))

 35144 +

 35145 +#define bfd_link_hash_table_free(abfd, hash) \

 35146 +       BFD_SEND (abfd, _bfd_link_hash_table_free, (hash))

 35147 +

 35148 +#define bfd_link_add_symbols(abfd, info) \

 35149 +       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))

 35150 +

 35151 +#define bfd_link_just_syms(abfd, sec, info) \

 35152 +       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))

 35153 +

 35154 +#define bfd_final_link(abfd, info) \

 35155 +       BFD_SEND (abfd, _bfd_final_link, (abfd, info))

 35156 +

 35157 +#define bfd_free_cached_info(abfd) \

 35158 +       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))

 35159 +

 35160 +#define bfd_get_dynamic_symtab_upper_bound(abfd) \

 35161 +       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))

 35162 +

 35163 +#define bfd_print_private_bfd_data(abfd, file)\

 35164 +       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))

 35165 +

 35166 +#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \

 35167 +       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))

 35168 +

 35169 +#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \

 35170 +       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \

 35171 +                                                   dyncount, dynsyms, ret))

 35172 +

 35173 +#define bfd_get_dynamic_reloc_upper_bound(abfd) \

 35174 +       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))

 35175 +

 35176 +#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \

 35177 +       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))

 35178 +

 35179 +extern bfd_byte *bfd_get_relocated_section_contents

 35180 +  (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,

 35181 +   bfd_boolean, asymbol **);

 35182 +

 35183 +bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);

 35184 +

 35185 +struct bfd_preserve

 35186 +{

 35187 +  void *marker;

 35188 +  void *tdata;

 35189 +  flagword flags;

 35190 +  const struct bfd_arch_info *arch_info;

 35191 +  struct bfd_section *sections;

 35192 +  struct bfd_section *section_last;

 35193 +  unsigned int section_count;

 35194 +  struct bfd_hash_table section_htab;

 35195 +};

 35196 +

 35197 +bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *);

 35198 +

 35199 +void bfd_preserve_restore (bfd *, struct bfd_preserve *);

 35200 +

 35201 +void bfd_preserve_finish (bfd *, struct bfd_preserve *);

 35202 +

 35203 +bfd_vma bfd_emul_get_maxpagesize (const char *);

 35204 +

 35205 +void bfd_emul_set_maxpagesize (const char *, bfd_vma);

 35206 +

 35207 +bfd_vma bfd_emul_get_commonpagesize (const char *);

 35208 +

 35209 +void bfd_emul_set_commonpagesize (const char *, bfd_vma);

 35210 +

 35211 +char *bfd_demangle (bfd *, const char *, int);

 35212 +

 35213 +/* Extracted from archive.c.  */

 35214 +symindex bfd_get_next_mapent

 35215 +   (bfd *abfd, symindex previous, carsym **sym);

 35216 +

 35217 +bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);

 35218 +

 35219 +bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);

 35220 +

 35221 +/* Extracted from corefile.c.  */

 35222 +const char *bfd_core_file_failing_command (bfd *abfd);

 35223 +

 35224 +int bfd_core_file_failing_signal (bfd *abfd);

 35225 +

 35226 +bfd_boolean core_file_matches_executable_p

 35227 +   (bfd *core_bfd, bfd *exec_bfd);

 35228 +

 35229 +bfd_boolean generic_core_file_matches_executable_p

 35230 +   (bfd *core_bfd, bfd *exec_bfd);

 35231 +

 35232 +/* Extracted from targets.c.  */

 35233 +#define BFD_SEND(bfd, message, arglist) \

 35234 +  ((*((bfd)->xvec->message)) arglist)

 35235 +

 35236 +#ifdef DEBUG_BFD_SEND

 35237 +#undef BFD_SEND

 35238 +#define BFD_SEND(bfd, message, arglist) \

 35239 +  (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \

 35240 +    ((*((bfd)->xvec->message)) arglist) : \

 35241 +    (bfd_assert (__FILE__,__LINE__), NULL))

 35242 +#endif

 35243 +#define BFD_SEND_FMT(bfd, message, arglist) \

 35244 +  (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist)

 35245 +

 35246 +#ifdef DEBUG_BFD_SEND

 35247 +#undef BFD_SEND_FMT

 35248 +#define BFD_SEND_FMT(bfd, message, arglist) \

 35249 +  (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \

 35250 +   (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) : \

 35251 +   (bfd_assert (__FILE__,__LINE__), NULL))

 35252 +#endif

 35253 +

 35254 +enum bfd_flavour

 35255 +{

 35256 +  bfd_target_unknown_flavour,

 35257 +  bfd_target_aout_flavour,

 35258 +  bfd_target_coff_flavour,

 35259 +  bfd_target_ecoff_flavour,

 35260 +  bfd_target_xcoff_flavour,

 35261 +  bfd_target_elf_flavour,

 35262 +  bfd_target_ieee_flavour,

 35263 +  bfd_target_nlm_flavour,

 35264 +  bfd_target_oasys_flavour,

 35265 +  bfd_target_tekhex_flavour,

 35266 +  bfd_target_srec_flavour,

 35267 +  bfd_target_ihex_flavour,

 35268 +  bfd_target_som_flavour,

 35269 +  bfd_target_os9k_flavour,

 35270 +  bfd_target_versados_flavour,

 35271 +  bfd_target_msdos_flavour,

 35272 +  bfd_target_ovax_flavour,

 35273 +  bfd_target_evax_flavour,

 35274 +  bfd_target_mmo_flavour,

 35275 +  bfd_target_mach_o_flavour,

 35276 +  bfd_target_pef_flavour,

 35277 +  bfd_target_pef_xlib_flavour,

 35278 +  bfd_target_sym_flavour

 35279 +};

 35280 +

 35281 +enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN };

 35282 +

 35283 +/* Forward declaration.  */

 35284 +typedef struct bfd_link_info _bfd_link_info;

 35285 +

 35286 +typedef struct bfd_target

 35287 +{

 35288 +  /* Identifies the kind of target, e.g., SunOS4, Ultrix, etc.  */

 35289 +  char *name;

 35290 +

 35291 + /* The "flavour" of a back end is a general indication about

 35292 +    the contents of a file.  */

 35293 +  enum bfd_flavour flavour;

 35294 +

 35295 +  /* The order of bytes within the data area of a file.  */

 35296 +  enum bfd_endian byteorder;

 35297 +

 35298 + /* The order of bytes within the header parts of a file.  */

 35299 +  enum bfd_endian header_byteorder;

 35300 +

 35301 +  /* A mask of all the flags which an executable may have set -

 35302 +     from the set <<BFD_NO_FLAGS>>, <<HAS_RELOC>>, ...<<D_PAGED>>.  */

 35303 +  flagword object_flags;

 35304 +

 35305 + /* A mask of all the flags which a section may have set - from

 35306 +    the set <<SEC_NO_FLAGS>>, <<SEC_ALLOC>>, ...<<SET_NEVER_LOAD>>.  */

 35307 +  flagword section_flags;

 35308 +

 35309 + /* The character normally found at the front of a symbol.

 35310 +    (if any), perhaps `_'.  */

 35311 +  char symbol_leading_char;

 35312 +

 35313 + /* The pad character for file names within an archive header.  */

 35314 +  char ar_pad_char;

 35315 +

 35316 +  /* The maximum number of characters in an archive header.  */

 35317 +  unsigned short ar_max_namelen;

 35318 +

 35319 +  /* Entries for byte swapping for data. These are different from the

 35320 +     other entry points, since they don't take a BFD as the first argument.

 35321 +     Certain other handlers could do the same.  */

 35322 +  bfd_uint64_t   (*bfd_getx64) (const void *);

 35323 +  bfd_int64_t    (*bfd_getx_signed_64) (const void *);

 35324 +  void           (*bfd_putx64) (bfd_uint64_t, void *);

 35325 +  bfd_vma        (*bfd_getx32) (const void *);

 35326 +  bfd_signed_vma (*bfd_getx_signed_32) (const void *);

 35327 +  void           (*bfd_putx32) (bfd_vma, void *);

 35328 +  bfd_vma        (*bfd_getx16) (const void *);

 35329 +  bfd_signed_vma (*bfd_getx_signed_16) (const void *);

 35330 +  void           (*bfd_putx16) (bfd_vma, void *);

 35331 +

 35332 +  /* Byte swapping for the headers.  */

 35333 +  bfd_uint64_t   (*bfd_h_getx64) (const void *);

 35334 +  bfd_int64_t    (*bfd_h_getx_signed_64) (const void *);

 35335 +  void           (*bfd_h_putx64) (bfd_uint64_t, void *);

 35336 +  bfd_vma        (*bfd_h_getx32) (const void *);

 35337 +  bfd_signed_vma (*bfd_h_getx_signed_32) (const void *);

 35338 +  void           (*bfd_h_putx32) (bfd_vma, void *);

 35339 +  bfd_vma        (*bfd_h_getx16) (const void *);

 35340 +  bfd_signed_vma (*bfd_h_getx_signed_16) (const void *);

 35341 +  void           (*bfd_h_putx16) (bfd_vma, void *);

 35342 +

 35343 +  /* Format dependent routines: these are vectors of entry points

 35344 +     within the target vector structure, one for each format to check.  */

 35345 +

 35346 +  /* Check the format of a file being read.  Return a <<bfd_target *>> or zero.  */

 35347 +  const struct bfd_target *(*_bfd_check_format[bfd_type_end]) (bfd *);

 35348 +

 35349 +  /* Set the format of a file being written.  */

 35350 +  bfd_boolean (*_bfd_set_format[bfd_type_end]) (bfd *);

 35351 +

 35352 +  /* Write cached information into a file being written, at <<bfd_close>>.  */

 35353 +  bfd_boolean (*_bfd_write_contents[bfd_type_end]) (bfd *);

 35354 +

 35355 +

 35356 +  /* Generic entry points.  */

 35357 +#define BFD_JUMP_TABLE_GENERIC(NAME) \

 35358 +  NAME##_close_and_cleanup, \

 35359 +  NAME##_bfd_free_cached_info, \

 35360 +  NAME##_new_section_hook, \

 35361 +  NAME##_get_section_contents, \

 35362 +  NAME##_get_section_contents_in_window

 35363 +

 35364 +  /* Called when the BFD is being closed to do any necessary cleanup.  */

 35365 +  bfd_boolean (*_close_and_cleanup) (bfd *);

 35366 +  /* Ask the BFD to free all cached information.  */

 35367 +  bfd_boolean (*_bfd_free_cached_info) (bfd *);

 35368 +  /* Called when a new section is created.  */

 35369 +  bfd_boolean (*_new_section_hook) (bfd *, sec_ptr);

 35370 +  /* Read the contents of a section.  */

 35371 +  bfd_boolean (*_bfd_get_section_contents)

 35372 +    (bfd *, sec_ptr, void *, file_ptr, bfd_size_type);

 35373 +  bfd_boolean (*_bfd_get_section_contents_in_window)

 35374 +    (bfd *, sec_ptr, bfd_window *, file_ptr, bfd_size_type);

 35375 +

 35376 +  /* Entry points to copy private data.  */

 35377 +#define BFD_JUMP_TABLE_COPY(NAME) \

 35378 +  NAME##_bfd_copy_private_bfd_data, \

 35379 +  NAME##_bfd_merge_private_bfd_data, \

 35380 +  _bfd_generic_init_private_section_data, \

 35381 +  NAME##_bfd_copy_private_section_data, \

 35382 +  NAME##_bfd_copy_private_symbol_data, \

 35383 +  NAME##_bfd_copy_private_header_data, \

 35384 +  NAME##_bfd_set_private_flags, \

 35385 +  NAME##_bfd_print_private_bfd_data

 35386 +

 35387 +  /* Called to copy BFD general private data from one object file

 35388 +     to another.  */

 35389 +  bfd_boolean (*_bfd_copy_private_bfd_data) (bfd *, bfd *);

 35390 +  /* Called to merge BFD general private data from one object file

 35391 +     to a common output file when linking.  */

 35392 +  bfd_boolean (*_bfd_merge_private_bfd_data) (bfd *, bfd *);

 35393 +  /* Called to initialize BFD private section data from one object file

 35394 +     to another.  */

 35395 +#define bfd_init_private_section_data(ibfd, isec, obfd, osec, link_info) \

 35396 +  BFD_SEND (obfd, _bfd_init_private_section_data, (ibfd, isec, obfd, osec, link_info))

 35397 +  bfd_boolean (*_bfd_init_private_section_data)

 35398 +    (bfd *, sec_ptr, bfd *, sec_ptr, struct bfd_link_info *);

 35399 +  /* Called to copy BFD private section data from one object file

 35400 +     to another.  */

 35401 +  bfd_boolean (*_bfd_copy_private_section_data)

 35402 +    (bfd *, sec_ptr, bfd *, sec_ptr);

 35403 +  /* Called to copy BFD private symbol data from one symbol

 35404 +     to another.  */

 35405 +  bfd_boolean (*_bfd_copy_private_symbol_data)

 35406 +    (bfd *, asymbol *, bfd *, asymbol *);

 35407 +  /* Called to copy BFD private header data from one object file

 35408 +     to another.  */

 35409 +  bfd_boolean (*_bfd_copy_private_header_data)

 35410 +    (bfd *, bfd *);

 35411 +  /* Called to set private backend flags.  */

 35412 +  bfd_boolean (*_bfd_set_private_flags) (bfd *, flagword);

 35413 +

 35414 +  /* Called to print private BFD data.  */

 35415 +  bfd_boolean (*_bfd_print_private_bfd_data) (bfd *, void *);

 35416 +

 35417 +  /* Core file entry points.  */

 35418 +#define BFD_JUMP_TABLE_CORE(NAME) \

 35419 +  NAME##_core_file_failing_command, \

 35420 +  NAME##_core_file_failing_signal, \

 35421 +  NAME##_core_file_matches_executable_p

 35422 +

 35423 +  char *      (*_core_file_failing_command) (bfd *);

 35424 +  int         (*_core_file_failing_signal) (bfd *);

 35425 +  bfd_boolean (*_core_file_matches_executable_p) (bfd *, bfd *);

 35426 +

 35427 +  /* Archive entry points.  */

 35428 +#define BFD_JUMP_TABLE_ARCHIVE(NAME) \

 35429 +  NAME##_slurp_armap, \

 35430 +  NAME##_slurp_extended_name_table, \

 35431 +  NAME##_construct_extended_name_table, \

 35432 +  NAME##_truncate_arname, \

 35433 +  NAME##_write_armap, \

 35434 +  NAME##_read_ar_hdr, \

 35435 +  NAME##_openr_next_archived_file, \

 35436 +  NAME##_get_elt_at_index, \

 35437 +  NAME##_generic_stat_arch_elt, \

 35438 +  NAME##_update_armap_timestamp

 35439 +

 35440 +  bfd_boolean (*_bfd_slurp_armap) (bfd *);

 35441 +  bfd_boolean (*_bfd_slurp_extended_name_table) (bfd *);

 35442 +  bfd_boolean (*_bfd_construct_extended_name_table)

 35443 +    (bfd *, char **, bfd_size_type *, const char **);

 35444 +  void        (*_bfd_truncate_arname) (bfd *, const char *, char *);

 35445 +  bfd_boolean (*write_armap)

 35446 +    (bfd *, unsigned int, struct orl *, unsigned int, int);

 35447 +  void *      (*_bfd_read_ar_hdr_fn) (bfd *);

 35448 +  bfd *       (*openr_next_archived_file) (bfd *, bfd *);

 35449 +#define bfd_get_elt_at_index(b,i) BFD_SEND (b, _bfd_get_elt_at_index, (b,i))

 35450 +  bfd *       (*_bfd_get_elt_at_index) (bfd *, symindex);

 35451 +  int         (*_bfd_stat_arch_elt) (bfd *, struct stat *);

 35452 +  bfd_boolean (*_bfd_update_armap_timestamp) (bfd *);

 35453 +

 35454 +  /* Entry points used for symbols.  */

 35455 +#define BFD_JUMP_TABLE_SYMBOLS(NAME) \

 35456 +  NAME##_get_symtab_upper_bound, \

 35457 +  NAME##_canonicalize_symtab, \

 35458 +  NAME##_make_empty_symbol, \

 35459 +  NAME##_print_symbol, \

 35460 +  NAME##_get_symbol_info, \

 35461 +  NAME##_bfd_is_local_label_name, \

 35462 +  NAME##_bfd_is_target_special_symbol, \

 35463 +  NAME##_get_lineno, \

 35464 +  NAME##_find_nearest_line, \

 35465 +  _bfd_generic_find_line, \

 35466 +  NAME##_find_inliner_info, \

 35467 +  NAME##_bfd_make_debug_symbol, \

 35468 +  NAME##_read_minisymbols, \

 35469 +  NAME##_minisymbol_to_symbol

 35470 +

 35471 +  long        (*_bfd_get_symtab_upper_bound) (bfd *);

 35472 +  long        (*_bfd_canonicalize_symtab)

 35473 +    (bfd *, struct bfd_symbol **);

 35474 +  struct bfd_symbol *

 35475 +              (*_bfd_make_empty_symbol) (bfd *);

 35476 +  void        (*_bfd_print_symbol)

 35477 +    (bfd *, void *, struct bfd_symbol *, bfd_print_symbol_type);

 35478 +#define bfd_print_symbol(b,p,s,e) BFD_SEND (b, _bfd_print_symbol, (b,p,s,e))

 35479 +  void        (*_bfd_get_symbol_info)

 35480 +    (bfd *, struct bfd_symbol *, symbol_info *);

 35481 +#define bfd_get_symbol_info(b,p,e) BFD_SEND (b, _bfd_get_symbol_info, (b,p,e))

 35482 +  bfd_boolean (*_bfd_is_local_label_name) (bfd *, const char *);

 35483 +  bfd_boolean (*_bfd_is_target_special_symbol) (bfd *, asymbol *);

 35484 +  alent *     (*_get_lineno) (bfd *, struct bfd_symbol *);

 35485 +  bfd_boolean (*_bfd_find_nearest_line)

 35486 +    (bfd *, struct bfd_section *, struct bfd_symbol **, bfd_vma,

 35487 +     const char **, const char **, unsigned int *);

 35488 +  bfd_boolean (*_bfd_find_line)

 35489 +    (bfd *, struct bfd_symbol **, struct bfd_symbol *,

 35490 +     const char **, unsigned int *);

 35491 +  bfd_boolean (*_bfd_find_inliner_info)

 35492 +    (bfd *, const char **, const char **, unsigned int *);

 35493 + /* Back-door to allow format-aware applications to create debug symbols

 35494 +    while using BFD for everything else.  Currently used by the assembler

 35495 +    when creating COFF files.  */

 35496 +  asymbol *   (*_bfd_make_debug_symbol)

 35497 +    (bfd *, void *, unsigned long size);

 35498 +#define bfd_read_minisymbols(b, d, m, s) \

 35499 +  BFD_SEND (b, _read_minisymbols, (b, d, m, s))

 35500 +  long        (*_read_minisymbols)

 35501 +    (bfd *, bfd_boolean, void **, unsigned int *);

 35502 +#define bfd_minisymbol_to_symbol(b, d, m, f) \

 35503 +  BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f))

 35504 +  asymbol *   (*_minisymbol_to_symbol)

 35505 +    (bfd *, bfd_boolean, const void *, asymbol *);

 35506 +

 35507 +  /* Routines for relocs.  */

 35508 +#define BFD_JUMP_TABLE_RELOCS(NAME) \

 35509 +  NAME##_get_reloc_upper_bound, \

 35510 +  NAME##_canonicalize_reloc, \

 35511 +  NAME##_bfd_reloc_type_lookup, \

 35512 +  NAME##_bfd_reloc_name_lookup

 35513 +

 35514 +  long        (*_get_reloc_upper_bound) (bfd *, sec_ptr);

 35515 +  long        (*_bfd_canonicalize_reloc)

 35516 +    (bfd *, sec_ptr, arelent **, struct bfd_symbol **);

 35517 +  /* See documentation on reloc types.  */

 35518 +  reloc_howto_type *

 35519 +              (*reloc_type_lookup) (bfd *, bfd_reloc_code_real_type);

 35520 +  reloc_howto_type *

 35521 +              (*reloc_name_lookup) (bfd *, const char *);

 35522 +

 35523 +

 35524 +  /* Routines used when writing an object file.  */

 35525 +#define BFD_JUMP_TABLE_WRITE(NAME) \

 35526 +  NAME##_set_arch_mach, \

 35527 +  NAME##_set_section_contents

 35528 +

 35529 +  bfd_boolean (*_bfd_set_arch_mach)

 35530 +    (bfd *, enum bfd_architecture, unsigned long);

 35531 +  bfd_boolean (*_bfd_set_section_contents)

 35532 +    (bfd *, sec_ptr, const void *, file_ptr, bfd_size_type);

 35533 +

 35534 +  /* Routines used by the linker.  */

 35535 +#define BFD_JUMP_TABLE_LINK(NAME) \

 35536 +  NAME##_sizeof_headers, \

 35537 +  NAME##_bfd_get_relocated_section_contents, \

 35538 +  NAME##_bfd_relax_section, \

 35539 +  NAME##_bfd_link_hash_table_create, \

 35540 +  NAME##_bfd_link_hash_table_free, \

 35541 +  NAME##_bfd_link_add_symbols, \

 35542 +  NAME##_bfd_link_just_syms, \

 35543 +  NAME##_bfd_final_link, \

 35544 +  NAME##_bfd_link_split_section, \

 35545 +  NAME##_bfd_gc_sections, \

 35546 +  NAME##_bfd_merge_sections, \

 35547 +  NAME##_bfd_is_group_section, \

 35548 +  NAME##_bfd_discard_group, \

 35549 +  NAME##_section_already_linked \

 35550 +

 35551 +  int         (*_bfd_sizeof_headers) (bfd *, struct bfd_link_info *);

 35552 +  bfd_byte *  (*_bfd_get_relocated_section_contents)

 35553 +    (bfd *, struct bfd_link_info *, struct bfd_link_order *,

 35554 +     bfd_byte *, bfd_boolean, struct bfd_symbol **);

 35555 +

 35556 +  bfd_boolean (*_bfd_relax_section)

 35557 +    (bfd *, struct bfd_section *, struct bfd_link_info *, bfd_boolean *);

 35558 +

 35559 +  /* Create a hash table for the linker.  Different backends store

 35560 +     different information in this table.  */

 35561 +  struct bfd_link_hash_table *

 35562 +              (*_bfd_link_hash_table_create) (bfd *);

 35563 +

 35564 +  /* Release the memory associated with the linker hash table.  */

 35565 +  void        (*_bfd_link_hash_table_free) (struct bfd_link_hash_table *);

 35566 +

 35567 +  /* Add symbols from this object file into the hash table.  */

 35568 +  bfd_boolean (*_bfd_link_add_symbols) (bfd *, struct bfd_link_info *);

 35569 +

 35570 +  /* Indicate that we are only retrieving symbol values from this section.  */

 35571 +  void        (*_bfd_link_just_syms) (asection *, struct bfd_link_info *);

 35572 +

 35573 +  /* Do a link based on the link_order structures attached to each

 35574 +     section of the BFD.  */

 35575 +  bfd_boolean (*_bfd_final_link) (bfd *, struct bfd_link_info *);

 35576 +

 35577 +  /* Should this section be split up into smaller pieces during linking.  */

 35578 +  bfd_boolean (*_bfd_link_split_section) (bfd *, struct bfd_section *);

 35579 +

 35580 +  /* Remove sections that are not referenced from the output.  */

 35581 +  bfd_boolean (*_bfd_gc_sections) (bfd *, struct bfd_link_info *);

 35582 +

 35583 +  /* Attempt to merge SEC_MERGE sections.  */

 35584 +  bfd_boolean (*_bfd_merge_sections) (bfd *, struct bfd_link_info *);

 35585 +

 35586 +  /* Is this section a member of a group?  */

 35587 +  bfd_boolean (*_bfd_is_group_section) (bfd *, const struct bfd_section *);

 35588 +

 35589 +  /* Discard members of a group.  */

 35590 +  bfd_boolean (*_bfd_discard_group) (bfd *, struct bfd_section *);

 35591 +

 35592 +  /* Check if SEC has been already linked during a reloceatable or

 35593 +     final link.  */

 35594 +  void (*_section_already_linked) (bfd *, struct bfd_section *,

 35595 +                                   struct bfd_link_info *);

 35596 +

 35597 +  /* Routines to handle dynamic symbols and relocs.  */

 35598 +#define BFD_JUMP_TABLE_DYNAMIC(NAME) \

 35599 +  NAME##_get_dynamic_symtab_upper_bound, \

 35600 +  NAME##_canonicalize_dynamic_symtab, \

 35601 +  NAME##_get_synthetic_symtab, \

 35602 +  NAME##_get_dynamic_reloc_upper_bound, \

 35603 +  NAME##_canonicalize_dynamic_reloc

 35604 +

 35605 +  /* Get the amount of memory required to hold the dynamic symbols.  */

 35606 +  long        (*_bfd_get_dynamic_symtab_upper_bound) (bfd *);

 35607 +  /* Read in the dynamic symbols.  */

 35608 +  long        (*_bfd_canonicalize_dynamic_symtab)

 35609 +    (bfd *, struct bfd_symbol **);

 35610 +  /* Create synthetized symbols.  */

 35611 +  long        (*_bfd_get_synthetic_symtab)

 35612 +    (bfd *, long, struct bfd_symbol **, long, struct bfd_symbol **,

 35613 +     struct bfd_symbol **);

 35614 +  /* Get the amount of memory required to hold the dynamic relocs.  */

 35615 +  long        (*_bfd_get_dynamic_reloc_upper_bound) (bfd *);

 35616 +  /* Read in the dynamic relocs.  */

 35617 +  long        (*_bfd_canonicalize_dynamic_reloc)

 35618 +    (bfd *, arelent **, struct bfd_symbol **);

 35619 +

 35620 +  /* Opposite endian version of this target.  */

 35621 +  const struct bfd_target * alternative_target;

 35622 +

 35623 +  /* Data for use by back-end routines, which isn't

 35624 +     generic enough to belong in this structure.  */

 35625 +  const void *backend_data;

 35626 +

 35627 +} bfd_target;

 35628 +

 35629 +bfd_boolean bfd_set_default_target (const char *name);

 35630 +

 35631 +const bfd_target *bfd_find_target (const char *target_name, bfd *abfd);

 35632 +

 35633 +const char ** bfd_target_list (void);

 35634 +

 35635 +const bfd_target *bfd_search_for_target

 35636 +   (int (*search_func) (const bfd_target *, void *),

 35637 +    void *);

 35638 +

 35639 +/* Extracted from format.c.  */

 35640 +bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);

 35641 +

 35642 +bfd_boolean bfd_check_format_matches

 35643 +   (bfd *abfd, bfd_format format, char ***matching);

 35644 +

 35645 +bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);

 35646 +

 35647 +const char *bfd_format_string (bfd_format format);

 35648 +

 35649 +/* Extracted from linker.c.  */

 35650 +bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec);

 35651 +

 35652 +#define bfd_link_split_section(abfd, sec) \

 35653 +       BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec))

 35654 +

 35655 +void bfd_section_already_linked (bfd *abfd, asection *sec,

 35656 +    struct bfd_link_info *info);

 35657 +

 35658 +#define bfd_section_already_linked(abfd, sec, info) \

 35659 +       BFD_SEND (abfd, _section_already_linked, (abfd, sec, info))

 35660 +

 35661 +/* Extracted from simple.c.  */

 35662 +bfd_byte *bfd_simple_get_relocated_section_contents

 35663 +   (bfd *abfd, asection *sec, bfd_byte *outbuf, asymbol **symbol_table);

 35664 +

 35665 +#ifdef __cplusplus

 35666 +}

 35667 +#endif

 35668 +#endif

 35669 --- /dev/null

 35670 +++ b/bfd/bfd_stdint.h

 35671 @@ -0,0 +1,47 @@

 35672 +/* generated for  gcc (GCC) 4.2.4 (Ubuntu 4.2.4-3ubuntu4) */

 35673 +

 35674 +#ifndef GCC_GENERATED_STDINT_H

 35675 +#define GCC_GENERATED_STDINT_H 1

 35676 +

 35677 +#include <sys/types.h>

 35678 +#include <stdint.h>

 35679 +/* glibc uses these symbols as guards to prevent redefinitions.  */

 35680 +#ifdef __int8_t_defined

 35681 +#define _INT8_T

 35682 +#define _INT16_T

 35683 +#define _INT32_T

 35684 +#endif

 35685 +#ifdef __uint32_t_defined

 35686 +#define _UINT32_T

 35687 +#endif

 35688 +

 35689 +

 35690 +/* Some systems have guard macros to prevent redefinitions, define them.  */

 35691 +#ifndef _INT8_T

 35692 +#define _INT8_T

 35693 +#endif

 35694 +#ifndef _INT16_T

 35695 +#define _INT16_T

 35696 +#endif

 35697 +#ifndef _INT32_T

 35698 +#define _INT32_T

 35699 +#endif

 35700 +#ifndef _UINT8_T

 35701 +#define _UINT8_T

 35702 +#endif

 35703 +#ifndef _UINT16_T

 35704 +#define _UINT16_T

 35705 +#endif

 35706 +#ifndef _UINT32_T

 35707 +#define _UINT32_T

 35708 +#endif

 35709 +

 35710 +/* system headers have good uint64_t and int64_t */

 35711 +#ifndef _INT64_T

 35712 +#define _INT64_T

 35713 +#endif

 35714 +#ifndef _UINT64_T

 35715 +#define _UINT64_T

 35716 +#endif

 35717 +

 35718 +#endif /* GCC_GENERATED_STDINT_H */

 35719 --- a/bfd/configure

 35720 +++ b/bfd/configure

 35721 @@ -2994,7 +2994,7 @@ fi

 35723  # Define the identity of the package.

 35724   PACKAGE=bfd

 35725 - VERSION=2.18

 35726 + VERSION=2.18.atmel.1.0.1.avr32linux.1

 35729  cat >>confdefs.h <<_ACEOF

 35730 @@ -19041,6 +19041,7 @@ do

 35731      bfd_efi_app_ia64_vec)	tb="$tb efi-app-ia64.lo pepigen.lo cofflink.lo"; target_size=64 ;;

 35732      bfd_elf32_am33lin_vec)	tb="$tb elf32-am33lin.lo elf32.lo $elf" ;;

 35733      bfd_elf32_avr_vec)		tb="$tb elf32-avr.lo elf32.lo $elf" ;;

 35734 +    bfd_elf32_avr32_vec)	tb="$tb elf32-avr32.lo elf32.lo $elf" ;;

 35735      bfd_elf32_bfin_vec)		tb="$tb elf32-bfin.lo elf32.lo $elf" ;;

 35736      bfd_elf32_bfinfdpic_vec)	tb="$tb elf32-bfin.lo elf32.lo $elf" ;;

 35737      bfd_elf32_big_generic_vec) 	tb="$tb elf32-gen.lo elf32.lo $elf" ;;

 35738 --- /dev/null

 35739 +++ b/bfd/doc/bfd.h

 35740 @@ -0,0 +1,5493 @@

 35741 +/* DO NOT EDIT!  -*- buffer-read-only: t -*-  This file is automatically

 35742 +   generated from "bfd-in.h", "init.c", "opncls.c", "libbfd.c",

 35743 +   "bfdio.c", "bfdwin.c", "section.c", "archures.c", "reloc.c",

 35744 +   "syms.c", "bfd.c", "archive.c", "corefile.c", "targets.c", "format.c",

 35745 +   "linker.c" and "simple.c".

 35746 +   Run "make headers" in your build bfd/ to regenerate.  */

 35747 +

 35748 +/* Main header file for the bfd library -- portable access to object files.

 35749 +

 35750 +   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

 35751 +   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007

 35752 +   Free Software Foundation, Inc.

 35753 +

 35754 +   Contributed by Cygnus Support.

 35755 +

 35756 +   This file is part of BFD, the Binary File Descriptor library.

 35757 +

 35758 +   This program is free software; you can redistribute it and/or modify

 35759 +   it under the terms of the GNU General Public License as published by

 35760 +   the Free Software Foundation; either version 3 of the License, or

 35761 +   (at your option) any later version.

 35762 +

 35763 +   This program is distributed in the hope that it will be useful,

 35764 +   but WITHOUT ANY WARRANTY; without even the implied warranty of

 35765 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 35766 +   GNU General Public License for more details.

 35767 +

 35768 +   You should have received a copy of the GNU General Public License

 35769 +   along with this program; if not, write to the Free Software

 35770 +   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */

 35771 +

 35772 +#ifndef __BFD_H_SEEN__

 35773 +#define __BFD_H_SEEN__

 35774 +

 35775 +#ifdef __cplusplus

 35776 +extern "C" {

 35777 +#endif

 35778 +

 35779 +#include "ansidecl.h"

 35780 +#include "symcat.h"

 35781 +#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)

 35782 +#ifndef SABER

 35783 +/* This hack is to avoid a problem with some strict ANSI C preprocessors.

 35784 +   The problem is, "32_" is not a valid preprocessing token, and we don't

 35785 +   want extra underscores (e.g., "nlm_32_").  The XCONCAT2 macro will

 35786 +   cause the inner CONCAT2 macros to be evaluated first, producing

 35787 +   still-valid pp-tokens.  Then the final concatenation can be done.  */

 35788 +#undef CONCAT4

 35789 +#define CONCAT4(a,b,c,d) XCONCAT2(CONCAT2(a,b),CONCAT2(c,d))

 35790 +#endif

 35791 +#endif

 35792 +

 35793 +/* This is a utility macro to handle the situation where the code

 35794 +   wants to place a constant string into the code, followed by a

 35795 +   comma and then the length of the string.  Doing this by hand

 35796 +   is error prone, so using this macro is safer.  The macro will

 35797 +   also safely handle the case where a NULL is passed as the arg.  */

 35798 +#define STRING_COMMA_LEN(STR) (STR), ((STR) ? sizeof (STR) - 1 : 0)

 35799 +/* Unfortunately it is not possible to use the STRING_COMMA_LEN macro

 35800 +   to create the arguments to another macro, since the preprocessor

 35801 +   will mis-count the number of arguments to the outer macro (by not

 35802 +   evaluating STRING_COMMA_LEN and so missing the comma).  This is a

 35803 +   problem for example when trying to use STRING_COMMA_LEN to build

 35804 +   the arguments to the strncmp() macro.  Hence this alternative

 35805 +   definition of strncmp is provided here.

 35806 +

 35807 +   Note - these macros do NOT work if STR2 is not a constant string.  */

 35808 +#define CONST_STRNEQ(STR1,STR2) (strncmp ((STR1), (STR2), sizeof (STR2) - 1) == 0)

 35809 +  /* strcpy() can have a similar problem, but since we know we are

 35810 +     copying a constant string, we can use memcpy which will be faster

 35811 +     since there is no need to check for a NUL byte inside STR.  We

 35812 +     can also save time if we do not need to copy the terminating NUL.  */

 35813 +#define LITMEMCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2) - 1)

 35814 +#define LITSTRCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2))

 35815 +

 35816 +

 35817 +/* The word size used by BFD on the host.  This may be 64 with a 32

 35818 +   bit target if the host is 64 bit, or if other 64 bit targets have

 35819 +   been selected with --enable-targets, or if --enable-64-bit-bfd.  */

 35820 +#define BFD_ARCH_SIZE @wordsize@

 35821 +

 35822 +/* The word size of the default bfd target.  */

 35823 +#define BFD_DEFAULT_TARGET_SIZE @bfd_default_target_size@

 35824 +

 35825 +#define BFD_HOST_64BIT_LONG @BFD_HOST_64BIT_LONG@

 35826 +#define BFD_HOST_64BIT_LONG_LONG @BFD_HOST_64BIT_LONG_LONG@

 35827 +#define BFD_HOST_LONG_LONG @BFD_HOST_LONG_LONG@

 35828 +#if @BFD_HOST_64_BIT_DEFINED@

 35829 +#define BFD_HOST_64_BIT @BFD_HOST_64_BIT@

 35830 +#define BFD_HOST_U_64_BIT @BFD_HOST_U_64_BIT@

 35831 +typedef BFD_HOST_64_BIT bfd_int64_t;

 35832 +typedef BFD_HOST_U_64_BIT bfd_uint64_t;

 35833 +#endif

 35834 +

 35835 +#if BFD_ARCH_SIZE >= 64

 35836 +#define BFD64

 35837 +#endif

 35838 +

 35839 +#ifndef INLINE

 35840 +#if __GNUC__ >= 2

 35841 +#define INLINE __inline__

 35842 +#else

 35843 +#define INLINE

 35844 +#endif

 35845 +#endif

 35846 +

 35847 +/* Declaring a type wide enough to hold a host long and a host pointer.  */

 35848 +#define BFD_HOSTPTR_T	@BFD_HOSTPTR_T@

 35849 +typedef BFD_HOSTPTR_T bfd_hostptr_t;

 35850 +

 35851 +/* Forward declaration.  */

 35852 +typedef struct bfd bfd;

 35853 +

 35854 +/* Boolean type used in bfd.  Too many systems define their own

 35855 +   versions of "boolean" for us to safely typedef a "boolean" of

 35856 +   our own.  Using an enum for "bfd_boolean" has its own set of

 35857 +   problems, with strange looking casts required to avoid warnings

 35858 +   on some older compilers.  Thus we just use an int.

 35859 +

 35860 +   General rule: Functions which are bfd_boolean return TRUE on

 35861 +   success and FALSE on failure (unless they're a predicate).  */

 35862 +

 35863 +typedef int bfd_boolean;

 35864 +#undef FALSE

 35865 +#undef TRUE

 35866 +#define FALSE 0

 35867 +#define TRUE 1

 35868 +

 35869 +#ifdef BFD64

 35870 +

 35871 +#ifndef BFD_HOST_64_BIT

 35872 + #error No 64 bit integer type available

 35873 +#endif /* ! defined (BFD_HOST_64_BIT) */

 35874 +

 35875 +typedef BFD_HOST_U_64_BIT bfd_vma;

 35876 +typedef BFD_HOST_64_BIT bfd_signed_vma;

 35877 +typedef BFD_HOST_U_64_BIT bfd_size_type;

 35878 +typedef BFD_HOST_U_64_BIT symvalue;

 35879 +

 35880 +#ifndef fprintf_vma

 35881 +#if BFD_HOST_64BIT_LONG

 35882 +#define sprintf_vma(s,x) sprintf (s, "%016lx", x)

 35883 +#define fprintf_vma(f,x) fprintf (f, "%016lx", x)

 35884 +#elif BFD_HOST_64BIT_LONG_LONG

 35885 +#define sprintf_vma(s,x) sprintf (s, "%016llx", x)

 35886 +#define fprintf_vma(f,x) fprintf (f, "%016llx", x)

 35887 +#else

 35888 +#define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff)))

 35889 +#define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff))

 35890 +#define fprintf_vma(s,x) \

 35891 +  fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))

 35892 +#define sprintf_vma(s,x) \

 35893 +  sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))

 35894 +#endif

 35895 +#endif

 35896 +

 35897 +#else /* not BFD64  */

 35898 +

 35899 +/* Represent a target address.  Also used as a generic unsigned type

 35900 +   which is guaranteed to be big enough to hold any arithmetic types

 35901 +   we need to deal with.  */

 35902 +typedef unsigned long bfd_vma;

 35903 +

 35904 +/* A generic signed type which is guaranteed to be big enough to hold any

 35905 +   arithmetic types we need to deal with.  Can be assumed to be compatible

 35906 +   with bfd_vma in the same way that signed and unsigned ints are compatible

 35907 +   (as parameters, in assignment, etc).  */

 35908 +typedef long bfd_signed_vma;

 35909 +

 35910 +typedef unsigned long symvalue;

 35911 +typedef unsigned long bfd_size_type;

 35912 +

 35913 +/* Print a bfd_vma x on stream s.  */

 35914 +#define fprintf_vma(s,x) fprintf (s, "%08lx", x)

 35915 +#define sprintf_vma(s,x) sprintf (s, "%08lx", x)

 35916 +

 35917 +#endif /* not BFD64  */

 35918 +

 35919 +#define HALF_BFD_SIZE_TYPE \

 35920 +  (((bfd_size_type) 1) << (8 * sizeof (bfd_size_type) / 2))

 35921 +

 35922 +#ifndef BFD_HOST_64_BIT

 35923 +/* Fall back on a 32 bit type.  The idea is to make these types always

 35924 +   available for function return types, but in the case that

 35925 +   BFD_HOST_64_BIT is undefined such a function should abort or

 35926 +   otherwise signal an error.  */

 35927 +typedef bfd_signed_vma bfd_int64_t;

 35928 +typedef bfd_vma bfd_uint64_t;

 35929 +#endif

 35930 +

 35931 +/* An offset into a file.  BFD always uses the largest possible offset

 35932 +   based on the build time availability of fseek, fseeko, or fseeko64.  */

 35933 +typedef @bfd_file_ptr@ file_ptr;

 35934 +typedef unsigned @bfd_file_ptr@ ufile_ptr;

 35935 +

 35936 +extern void bfd_sprintf_vma (bfd *, char *, bfd_vma);

 35937 +extern void bfd_fprintf_vma (bfd *, void *, bfd_vma);

 35938 +

 35939 +#define printf_vma(x) fprintf_vma(stdout,x)

 35940 +#define bfd_printf_vma(abfd,x) bfd_fprintf_vma (abfd,stdout,x)

 35941 +

 35942 +typedef unsigned int flagword;	/* 32 bits of flags */

 35943 +typedef unsigned char bfd_byte;

 35944 +

 35945 +/* File formats.  */

 35946 +

 35947 +typedef enum bfd_format

 35948 +{

 35949 +  bfd_unknown = 0,	/* File format is unknown.  */

 35950 +  bfd_object,		/* Linker/assembler/compiler output.  */

 35951 +  bfd_archive,		/* Object archive file.  */

 35952 +  bfd_core,		/* Core dump.  */

 35953 +  bfd_type_end		/* Marks the end; don't use it!  */

 35954 +}

 35955 +bfd_format;

 35956 +

 35957 +/* Values that may appear in the flags field of a BFD.  These also

 35958 +   appear in the object_flags field of the bfd_target structure, where

 35959 +   they indicate the set of flags used by that backend (not all flags

 35960 +   are meaningful for all object file formats) (FIXME: at the moment,

 35961 +   the object_flags values have mostly just been copied from backend

 35962 +   to another, and are not necessarily correct).  */

 35963 +

 35964 +/* No flags.  */

 35965 +#define BFD_NO_FLAGS   	0x00

 35966 +

 35967 +/* BFD contains relocation entries.  */

 35968 +#define HAS_RELOC   	0x01

 35969 +

 35970 +/* BFD is directly executable.  */

 35971 +#define EXEC_P      	0x02

 35972 +

 35973 +/* BFD has line number information (basically used for F_LNNO in a

 35974 +   COFF header).  */

 35975 +#define HAS_LINENO  	0x04

 35976 +

 35977 +/* BFD has debugging information.  */

 35978 +#define HAS_DEBUG   	0x08

 35979 +

 35980 +/* BFD has symbols.  */

 35981 +#define HAS_SYMS    	0x10

 35982 +

 35983 +/* BFD has local symbols (basically used for F_LSYMS in a COFF

 35984 +   header).  */

 35985 +#define HAS_LOCALS  	0x20

 35986 +

 35987 +/* BFD is a dynamic object.  */

 35988 +#define DYNAMIC     	0x40

 35989 +

 35990 +/* Text section is write protected (if D_PAGED is not set, this is

 35991 +   like an a.out NMAGIC file) (the linker sets this by default, but

 35992 +   clears it for -r or -N).  */

 35993 +#define WP_TEXT     	0x80

 35994 +

 35995 +/* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the

 35996 +   linker sets this by default, but clears it for -r or -n or -N).  */

 35997 +#define D_PAGED     	0x100

 35998 +

 35999 +/* BFD is relaxable (this means that bfd_relax_section may be able to

 36000 +   do something) (sometimes bfd_relax_section can do something even if

 36001 +   this is not set).  */

 36002 +#define BFD_IS_RELAXABLE 0x200

 36003 +

 36004 +/* This may be set before writing out a BFD to request using a

 36005 +   traditional format.  For example, this is used to request that when

 36006 +   writing out an a.out object the symbols not be hashed to eliminate

 36007 +   duplicates.  */

 36008 +#define BFD_TRADITIONAL_FORMAT 0x400

 36009 +

 36010 +/* This flag indicates that the BFD contents are actually cached in

 36011 +   memory.  If this is set, iostream points to a bfd_in_memory struct.  */

 36012 +#define BFD_IN_MEMORY 0x800

 36013 +

 36014 +/* The sections in this BFD specify a memory page.  */

 36015 +#define HAS_LOAD_PAGE 0x1000

 36016 +

 36017 +/* This BFD has been created by the linker and doesn't correspond

 36018 +   to any input file.  */

 36019 +#define BFD_LINKER_CREATED 0x2000

 36020 +

 36021 +/* Symbols and relocation.  */

 36022 +

 36023 +/* A count of carsyms (canonical archive symbols).  */

 36024 +typedef unsigned long symindex;

 36025 +

 36026 +/* How to perform a relocation.  */

 36027 +typedef const struct reloc_howto_struct reloc_howto_type;

 36028 +

 36029 +#define BFD_NO_MORE_SYMBOLS ((symindex) ~0)

 36030 +

 36031 +/* General purpose part of a symbol X;

 36032 +   target specific parts are in libcoff.h, libaout.h, etc.  */

 36033 +

 36034 +#define bfd_get_section(x) ((x)->section)

 36035 +#define bfd_get_output_section(x) ((x)->section->output_section)

 36036 +#define bfd_set_section(x,y) ((x)->section) = (y)

 36037 +#define bfd_asymbol_base(x) ((x)->section->vma)

 36038 +#define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value)

 36039 +#define bfd_asymbol_name(x) ((x)->name)

 36040 +/*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/

 36041 +#define bfd_asymbol_bfd(x) ((x)->the_bfd)

 36042 +#define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour)

 36043 +

 36044 +/* A canonical archive symbol.  */

 36045 +/* This is a type pun with struct ranlib on purpose!  */

 36046 +typedef struct carsym

 36047 +{

 36048 +  char *name;

 36049 +  file_ptr file_offset;	/* Look here to find the file.  */

 36050 +}

 36051 +carsym;			/* To make these you call a carsymogen.  */

 36052 +

 36053 +/* Used in generating armaps (archive tables of contents).

 36054 +   Perhaps just a forward definition would do?  */

 36055 +struct orl 			/* Output ranlib.  */

 36056 +{

 36057 +  char **name;		/* Symbol name.  */

 36058 +  union

 36059 +  {

 36060 +    file_ptr pos;

 36061 +    bfd *abfd;

 36062 +  } u;			/* bfd* or file position.  */

 36063 +  int namidx;		/* Index into string table.  */

 36064 +};

 36065 +

 36066 +/* Linenumber stuff.  */

 36067 +typedef struct lineno_cache_entry

 36068 +{

 36069 +  unsigned int line_number;	/* Linenumber from start of function.  */

 36070 +  union

 36071 +  {

 36072 +    struct bfd_symbol *sym;	/* Function name.  */

 36073 +    bfd_vma offset;	    		/* Offset into section.  */

 36074 +  } u;

 36075 +}

 36076 +alent;

 36077 +

 36078 +/* Object and core file sections.  */

 36079 +

 36080 +#define	align_power(addr, align)	\

 36081 +  (((addr) + ((bfd_vma) 1 << (align)) - 1) & ((bfd_vma) -1 << (align)))

 36082 +

 36083 +typedef struct bfd_section *sec_ptr;

 36084 +

 36085 +#define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0)

 36086 +#define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0)

 36087 +#define bfd_get_section_lma(bfd, ptr) ((ptr)->lma + 0)

 36088 +#define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0)

 36089 +#define bfd_section_name(bfd, ptr) ((ptr)->name)

 36090 +#define bfd_section_size(bfd, ptr) ((ptr)->size)

 36091 +#define bfd_get_section_size(ptr) ((ptr)->size)

 36092 +#define bfd_section_vma(bfd, ptr) ((ptr)->vma)

 36093 +#define bfd_section_lma(bfd, ptr) ((ptr)->lma)

 36094 +#define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)

 36095 +#define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0)

 36096 +#define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)

 36097 +

 36098 +#define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)

 36099 +

 36100 +#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = TRUE), TRUE)

 36101 +#define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),TRUE)

 36102 +#define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),TRUE)

 36103 +/* Find the address one past the end of SEC.  */

 36104 +#define bfd_get_section_limit(bfd, sec) \

 36105 +  (((sec)->rawsize ? (sec)->rawsize : (sec)->size) \

 36106 +   / bfd_octets_per_byte (bfd))

 36107 +

 36108 +/* Return TRUE if section has been discarded.  */

 36109 +#define elf_discarded_section(sec)				\

 36110 +  (!bfd_is_abs_section (sec)					\

 36111 +   && bfd_is_abs_section ((sec)->output_section)		\

 36112 +   && (sec)->sec_info_type != ELF_INFO_TYPE_MERGE		\

 36113 +   && (sec)->sec_info_type != ELF_INFO_TYPE_JUST_SYMS)

 36114 +

 36115 +/* Forward define.  */

 36116 +struct stat;

 36117 +

 36118 +typedef enum bfd_print_symbol

 36119 +{

 36120 +  bfd_print_symbol_name,

 36121 +  bfd_print_symbol_more,

 36122 +  bfd_print_symbol_all

 36123 +} bfd_print_symbol_type;

 36124 +

 36125 +/* Information about a symbol that nm needs.  */

 36126 +

 36127 +typedef struct _symbol_info

 36128 +{

 36129 +  symvalue value;

 36130 +  char type;

 36131 +  const char *name;            /* Symbol name.  */

 36132 +  unsigned char stab_type;     /* Stab type.  */

 36133 +  char stab_other;             /* Stab other.  */

 36134 +  short stab_desc;             /* Stab desc.  */

 36135 +  const char *stab_name;       /* String for stab type.  */

 36136 +} symbol_info;

 36137 +

 36138 +/* Get the name of a stabs type code.  */

 36139 +

 36140 +extern const char *bfd_get_stab_name (int);

 36141 +

 36142 +/* Hash table routines.  There is no way to free up a hash table.  */

 36143 +

 36144 +/* An element in the hash table.  Most uses will actually use a larger

 36145 +   structure, and an instance of this will be the first field.  */

 36146 +

 36147 +struct bfd_hash_entry

 36148 +{

 36149 +  /* Next entry for this hash code.  */

 36150 +  struct bfd_hash_entry *next;

 36151 +  /* String being hashed.  */

 36152 +  const char *string;

 36153 +  /* Hash code.  This is the full hash code, not the index into the

 36154 +     table.  */

 36155 +  unsigned long hash;

 36156 +};

 36157 +

 36158 +/* A hash table.  */

 36159 +

 36160 +struct bfd_hash_table

 36161 +{

 36162 +  /* The hash array.  */

 36163 +  struct bfd_hash_entry **table;

 36164 +  /* A function used to create new elements in the hash table.  The

 36165 +     first entry is itself a pointer to an element.  When this

 36166 +     function is first invoked, this pointer will be NULL.  However,

 36167 +     having the pointer permits a hierarchy of method functions to be

 36168 +     built each of which calls the function in the superclass.  Thus

 36169 +     each function should be written to allocate a new block of memory

 36170 +     only if the argument is NULL.  */

 36171 +  struct bfd_hash_entry *(*newfunc)

 36172 +    (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);

 36173 +   /* An objalloc for this hash table.  This is a struct objalloc *,

 36174 +     but we use void * to avoid requiring the inclusion of objalloc.h.  */

 36175 +  void *memory;

 36176 +  /* The number of slots in the hash table.  */

 36177 +  unsigned int size;

 36178 +  /* The number of entries in the hash table.  */

 36179 +  unsigned int count;

 36180 +  /* The size of elements.  */

 36181 +  unsigned int entsize;

 36182 +  /* If non-zero, don't grow the hash table.  */

 36183 +  unsigned int frozen:1;

 36184 +};

 36185 +

 36186 +/* Initialize a hash table.  */

 36187 +extern bfd_boolean bfd_hash_table_init

 36188 +  (struct bfd_hash_table *,

 36189 +   struct bfd_hash_entry *(*) (struct bfd_hash_entry *,

 36190 +			       struct bfd_hash_table *,

 36191 +			       const char *),

 36192 +   unsigned int);

 36193 +

 36194 +/* Initialize a hash table specifying a size.  */

 36195 +extern bfd_boolean bfd_hash_table_init_n

 36196 +  (struct bfd_hash_table *,

 36197 +   struct bfd_hash_entry *(*) (struct bfd_hash_entry *,

 36198 +			       struct bfd_hash_table *,

 36199 +			       const char *),

 36200 +   unsigned int, unsigned int);

 36201 +

 36202 +/* Free up a hash table.  */

 36203 +extern void bfd_hash_table_free

 36204 +  (struct bfd_hash_table *);

 36205 +

 36206 +/* Look up a string in a hash table.  If CREATE is TRUE, a new entry

 36207 +   will be created for this string if one does not already exist.  The

 36208 +   COPY argument must be TRUE if this routine should copy the string

 36209 +   into newly allocated memory when adding an entry.  */

 36210 +extern struct bfd_hash_entry *bfd_hash_lookup

 36211 +  (struct bfd_hash_table *, const char *, bfd_boolean create,

 36212 +   bfd_boolean copy);

 36213 +

 36214 +/* Replace an entry in a hash table.  */

 36215 +extern void bfd_hash_replace

 36216 +  (struct bfd_hash_table *, struct bfd_hash_entry *old,

 36217 +   struct bfd_hash_entry *nw);

 36218 +

 36219 +/* Base method for creating a hash table entry.  */

 36220 +extern struct bfd_hash_entry *bfd_hash_newfunc

 36221 +  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);

 36222 +

 36223 +/* Grab some space for a hash table entry.  */

 36224 +extern void *bfd_hash_allocate

 36225 +  (struct bfd_hash_table *, unsigned int);

 36226 +

 36227 +/* Traverse a hash table in a random order, calling a function on each

 36228 +   element.  If the function returns FALSE, the traversal stops.  The

 36229 +   INFO argument is passed to the function.  */

 36230 +extern void bfd_hash_traverse

 36231 +  (struct bfd_hash_table *,

 36232 +   bfd_boolean (*) (struct bfd_hash_entry *, void *),

 36233 +   void *info);

 36234 +

 36235 +/* Allows the default size of a hash table to be configured. New hash

 36236 +   tables allocated using bfd_hash_table_init will be created with

 36237 +   this size.  */

 36238 +extern void bfd_hash_set_default_size (bfd_size_type);

 36239 +

 36240 +/* This structure is used to keep track of stabs in sections

 36241 +   information while linking.  */

 36242 +

 36243 +struct stab_info

 36244 +{

 36245 +  /* A hash table used to hold stabs strings.  */

 36246 +  struct bfd_strtab_hash *strings;

 36247 +  /* The header file hash table.  */

 36248 +  struct bfd_hash_table includes;

 36249 +  /* The first .stabstr section.  */

 36250 +  struct bfd_section *stabstr;

 36251 +};

 36252 +

 36253 +#define COFF_SWAP_TABLE (void *) &bfd_coff_std_swap_table

 36254 +

 36255 +/* User program access to BFD facilities.  */

 36256 +

 36257 +/* Direct I/O routines, for programs which know more about the object

 36258 +   file than BFD does.  Use higher level routines if possible.  */

 36259 +

 36260 +extern bfd_size_type bfd_bread (void *, bfd_size_type, bfd *);

 36261 +extern bfd_size_type bfd_bwrite (const void *, bfd_size_type, bfd *);

 36262 +extern int bfd_seek (bfd *, file_ptr, int);

 36263 +extern file_ptr bfd_tell (bfd *);

 36264 +extern int bfd_flush (bfd *);

 36265 +extern int bfd_stat (bfd *, struct stat *);

 36266 +

 36267 +/* Deprecated old routines.  */

 36268 +#if __GNUC__

 36269 +#define bfd_read(BUF, ELTSIZE, NITEMS, ABFD)				\

 36270 +  (warn_deprecated ("bfd_read", __FILE__, __LINE__, __FUNCTION__),	\

 36271 +   bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))

 36272 +#define bfd_write(BUF, ELTSIZE, NITEMS, ABFD)				\

 36273 +  (warn_deprecated ("bfd_write", __FILE__, __LINE__, __FUNCTION__),	\

 36274 +   bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))

 36275 +#else

 36276 +#define bfd_read(BUF, ELTSIZE, NITEMS, ABFD)				\

 36277 +  (warn_deprecated ("bfd_read", (const char *) 0, 0, (const char *) 0), \

 36278 +   bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))

 36279 +#define bfd_write(BUF, ELTSIZE, NITEMS, ABFD)				\

 36280 +  (warn_deprecated ("bfd_write", (const char *) 0, 0, (const char *) 0),\

 36281 +   bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))

 36282 +#endif

 36283 +extern void warn_deprecated (const char *, const char *, int, const char *);

 36284 +

 36285 +/* Cast from const char * to char * so that caller can assign to

 36286 +   a char * without a warning.  */

 36287 +#define bfd_get_filename(abfd) ((char *) (abfd)->filename)

 36288 +#define bfd_get_cacheable(abfd) ((abfd)->cacheable)

 36289 +#define bfd_get_format(abfd) ((abfd)->format)

 36290 +#define bfd_get_target(abfd) ((abfd)->xvec->name)

 36291 +#define bfd_get_flavour(abfd) ((abfd)->xvec->flavour)

 36292 +#define bfd_family_coff(abfd) \

 36293 +  (bfd_get_flavour (abfd) == bfd_target_coff_flavour || \

 36294 +   bfd_get_flavour (abfd) == bfd_target_xcoff_flavour)

 36295 +#define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)

 36296 +#define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE)

 36297 +#define bfd_header_big_endian(abfd) \

 36298 +  ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG)

 36299 +#define bfd_header_little_endian(abfd) \

 36300 +  ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE)

 36301 +#define bfd_get_file_flags(abfd) ((abfd)->flags)

 36302 +#define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)

 36303 +#define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)

 36304 +#define bfd_my_archive(abfd) ((abfd)->my_archive)

 36305 +#define bfd_has_map(abfd) ((abfd)->has_armap)

 36306 +

 36307 +#define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)

 36308 +#define bfd_usrdata(abfd) ((abfd)->usrdata)

 36309 +

 36310 +#define bfd_get_start_address(abfd) ((abfd)->start_address)

 36311 +#define bfd_get_symcount(abfd) ((abfd)->symcount)

 36312 +#define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)

 36313 +#define bfd_count_sections(abfd) ((abfd)->section_count)

 36314 +

 36315 +#define bfd_get_dynamic_symcount(abfd) ((abfd)->dynsymcount)

 36316 +

 36317 +#define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char)

 36318 +

 36319 +#define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = bool), TRUE)

 36320 +

 36321 +extern bfd_boolean bfd_cache_close

 36322 +  (bfd *abfd);

 36323 +/* NB: This declaration should match the autogenerated one in libbfd.h.  */

 36324 +

 36325 +extern bfd_boolean bfd_cache_close_all (void);

 36326 +

 36327 +extern bfd_boolean bfd_record_phdr

 36328 +  (bfd *, unsigned long, bfd_boolean, flagword, bfd_boolean, bfd_vma,

 36329 +   bfd_boolean, bfd_boolean, unsigned int, struct bfd_section **);

 36330 +

 36331 +/* Byte swapping routines.  */

 36332 +

 36333 +bfd_uint64_t bfd_getb64 (const void *);

 36334 +bfd_uint64_t bfd_getl64 (const void *);

 36335 +bfd_int64_t bfd_getb_signed_64 (const void *);

 36336 +bfd_int64_t bfd_getl_signed_64 (const void *);

 36337 +bfd_vma bfd_getb32 (const void *);

 36338 +bfd_vma bfd_getl32 (const void *);

 36339 +bfd_signed_vma bfd_getb_signed_32 (const void *);

 36340 +bfd_signed_vma bfd_getl_signed_32 (const void *);

 36341 +bfd_vma bfd_getb16 (const void *);

 36342 +bfd_vma bfd_getl16 (const void *);

 36343 +bfd_signed_vma bfd_getb_signed_16 (const void *);

 36344 +bfd_signed_vma bfd_getl_signed_16 (const void *);

 36345 +void bfd_putb64 (bfd_uint64_t, void *);

 36346 +void bfd_putl64 (bfd_uint64_t, void *);

 36347 +void bfd_putb32 (bfd_vma, void *);

 36348 +void bfd_putl32 (bfd_vma, void *);

 36349 +void bfd_putb16 (bfd_vma, void *);

 36350 +void bfd_putl16 (bfd_vma, void *);

 36351 +

 36352 +/* Byte swapping routines which take size and endiannes as arguments.  */

 36353 +

 36354 +bfd_uint64_t bfd_get_bits (const void *, int, bfd_boolean);

 36355 +void bfd_put_bits (bfd_uint64_t, void *, int, bfd_boolean);

 36356 +

 36357 +extern bfd_boolean bfd_section_already_linked_table_init (void);

 36358 +extern void bfd_section_already_linked_table_free (void);

 36359 +

 36360 +/* Externally visible ECOFF routines.  */

 36361 +

 36362 +#if defined(__STDC__) || defined(ALMOST_STDC)

 36363 +struct ecoff_debug_info;

 36364 +struct ecoff_debug_swap;

 36365 +struct ecoff_extr;

 36366 +struct bfd_symbol;

 36367 +struct bfd_link_info;

 36368 +struct bfd_link_hash_entry;

 36369 +struct bfd_elf_version_tree;

 36370 +#endif

 36371 +extern bfd_vma bfd_ecoff_get_gp_value

 36372 +  (bfd * abfd);

 36373 +extern bfd_boolean bfd_ecoff_set_gp_value

 36374 +  (bfd *abfd, bfd_vma gp_value);

 36375 +extern bfd_boolean bfd_ecoff_set_regmasks

 36376 +  (bfd *abfd, unsigned long gprmask, unsigned long fprmask,

 36377 +   unsigned long *cprmask);

 36378 +extern void *bfd_ecoff_debug_init

 36379 +  (bfd *output_bfd, struct ecoff_debug_info *output_debug,

 36380 +   const struct ecoff_debug_swap *output_swap, struct bfd_link_info *);

 36381 +extern void bfd_ecoff_debug_free

 36382 +  (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,

 36383 +   const struct ecoff_debug_swap *output_swap, struct bfd_link_info *);

 36384 +extern bfd_boolean bfd_ecoff_debug_accumulate

 36385 +  (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,

 36386 +   const struct ecoff_debug_swap *output_swap, bfd *input_bfd,

 36387 +   struct ecoff_debug_info *input_debug,

 36388 +   const struct ecoff_debug_swap *input_swap, struct bfd_link_info *);

 36389 +extern bfd_boolean bfd_ecoff_debug_accumulate_other

 36390 +  (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,

 36391 +   const struct ecoff_debug_swap *output_swap, bfd *input_bfd,

 36392 +   struct bfd_link_info *);

 36393 +extern bfd_boolean bfd_ecoff_debug_externals

 36394 +  (bfd *abfd, struct ecoff_debug_info *debug,

 36395 +   const struct ecoff_debug_swap *swap, bfd_boolean relocatable,

 36396 +   bfd_boolean (*get_extr) (struct bfd_symbol *, struct ecoff_extr *),

 36397 +   void (*set_index) (struct bfd_symbol *, bfd_size_type));

 36398 +extern bfd_boolean bfd_ecoff_debug_one_external

 36399 +  (bfd *abfd, struct ecoff_debug_info *debug,

 36400 +   const struct ecoff_debug_swap *swap, const char *name,

 36401 +   struct ecoff_extr *esym);

 36402 +extern bfd_size_type bfd_ecoff_debug_size

 36403 +  (bfd *abfd, struct ecoff_debug_info *debug,

 36404 +   const struct ecoff_debug_swap *swap);

 36405 +extern bfd_boolean bfd_ecoff_write_debug

 36406 +  (bfd *abfd, struct ecoff_debug_info *debug,

 36407 +   const struct ecoff_debug_swap *swap, file_ptr where);

 36408 +extern bfd_boolean bfd_ecoff_write_accumulated_debug

 36409 +  (void *handle, bfd *abfd, struct ecoff_debug_info *debug,

 36410 +   const struct ecoff_debug_swap *swap,

 36411 +   struct bfd_link_info *info, file_ptr where);

 36412 +

 36413 +/* Externally visible ELF routines.  */

 36414 +

 36415 +struct bfd_link_needed_list

 36416 +{

 36417 +  struct bfd_link_needed_list *next;

 36418 +  bfd *by;

 36419 +  const char *name;

 36420 +};

 36421 +

 36422 +enum dynamic_lib_link_class {

 36423 +  DYN_NORMAL = 0,

 36424 +  DYN_AS_NEEDED = 1,

 36425 +  DYN_DT_NEEDED = 2,

 36426 +  DYN_NO_ADD_NEEDED = 4,

 36427 +  DYN_NO_NEEDED = 8

 36428 +};

 36429 +

 36430 +enum notice_asneeded_action {

 36431 +  notice_as_needed,

 36432 +  notice_not_needed,

 36433 +  notice_needed

 36434 +};

 36435 +

 36436 +extern bfd_boolean bfd_elf_record_link_assignment

 36437 +  (bfd *, struct bfd_link_info *, const char *, bfd_boolean,

 36438 +   bfd_boolean);

 36439 +extern struct bfd_link_needed_list *bfd_elf_get_needed_list

 36440 +  (bfd *, struct bfd_link_info *);

 36441 +extern bfd_boolean bfd_elf_get_bfd_needed_list

 36442 +  (bfd *, struct bfd_link_needed_list **);

 36443 +extern bfd_boolean bfd_elf_size_dynamic_sections

 36444 +  (bfd *, const char *, const char *, const char *, const char * const *,

 36445 +   struct bfd_link_info *, struct bfd_section **,

 36446 +   struct bfd_elf_version_tree *);

 36447 +extern bfd_boolean bfd_elf_size_dynsym_hash_dynstr

 36448 +  (bfd *, struct bfd_link_info *);

 36449 +extern void bfd_elf_set_dt_needed_name

 36450 +  (bfd *, const char *);

 36451 +extern const char *bfd_elf_get_dt_soname

 36452 +  (bfd *);

 36453 +extern void bfd_elf_set_dyn_lib_class

 36454 +  (bfd *, enum dynamic_lib_link_class);

 36455 +extern int bfd_elf_get_dyn_lib_class

 36456 +  (bfd *);

 36457 +extern struct bfd_link_needed_list *bfd_elf_get_runpath_list

 36458 +  (bfd *, struct bfd_link_info *);

 36459 +extern bfd_boolean bfd_elf_discard_info

 36460 +  (bfd *, struct bfd_link_info *);

 36461 +extern unsigned int _bfd_elf_default_action_discarded

 36462 +  (struct bfd_section *);

 36463 +

 36464 +/* Return an upper bound on the number of bytes required to store a

 36465 +   copy of ABFD's program header table entries.  Return -1 if an error

 36466 +   occurs; bfd_get_error will return an appropriate code.  */

 36467 +extern long bfd_get_elf_phdr_upper_bound

 36468 +  (bfd *abfd);

 36469 +

 36470 +/* Copy ABFD's program header table entries to *PHDRS.  The entries

 36471 +   will be stored as an array of Elf_Internal_Phdr structures, as

 36472 +   defined in include/elf/internal.h.  To find out how large the

 36473 +   buffer needs to be, call bfd_get_elf_phdr_upper_bound.

 36474 +

 36475 +   Return the number of program header table entries read, or -1 if an

 36476 +   error occurs; bfd_get_error will return an appropriate code.  */

 36477 +extern int bfd_get_elf_phdrs

 36478 +  (bfd *abfd, void *phdrs);

 36479 +

 36480 +/* Create a new BFD as if by bfd_openr.  Rather than opening a file,

 36481 +   reconstruct an ELF file by reading the segments out of remote memory

 36482 +   based on the ELF file header at EHDR_VMA and the ELF program headers it

 36483 +   points to.  If not null, *LOADBASEP is filled in with the difference

 36484 +   between the VMAs from which the segments were read, and the VMAs the

 36485 +   file headers (and hence BFD's idea of each section's VMA) put them at.

 36486 +

 36487 +   The function TARGET_READ_MEMORY is called to copy LEN bytes from the

 36488 +   remote memory at target address VMA into the local buffer at MYADDR; it

 36489 +   should return zero on success or an `errno' code on failure.  TEMPL must

 36490 +   be a BFD for an ELF target with the word size and byte order found in

 36491 +   the remote memory.  */

 36492 +extern bfd *bfd_elf_bfd_from_remote_memory

 36493 +  (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,

 36494 +   int (*target_read_memory) (bfd_vma vma, bfd_byte *myaddr, int len));

 36495 +

 36496 +/* Return the arch_size field of an elf bfd, or -1 if not elf.  */

 36497 +extern int bfd_get_arch_size

 36498 +  (bfd *);

 36499 +

 36500 +/* Return TRUE if address "naturally" sign extends, or -1 if not elf.  */

 36501 +extern int bfd_get_sign_extend_vma

 36502 +  (bfd *);

 36503 +

 36504 +extern struct bfd_section *_bfd_elf_tls_setup

 36505 +  (bfd *, struct bfd_link_info *);

 36506 +

 36507 +extern void _bfd_fix_excluded_sec_syms

 36508 +  (bfd *, struct bfd_link_info *);

 36509 +

 36510 +extern unsigned bfd_m68k_mach_to_features (int);

 36511 +

 36512 +extern int bfd_m68k_features_to_mach (unsigned);

 36513 +

 36514 +extern bfd_boolean bfd_m68k_elf32_create_embedded_relocs

 36515 +  (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *,

 36516 +   char **);

 36517 +

 36518 +extern bfd_boolean bfd_bfin_elf32_create_embedded_relocs

 36519 +  (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *,

 36520 +   char **);

 36521 +

 36522 +/* SunOS shared library support routines for the linker.  */

 36523 +

 36524 +extern struct bfd_link_needed_list *bfd_sunos_get_needed_list

 36525 +  (bfd *, struct bfd_link_info *);

 36526 +extern bfd_boolean bfd_sunos_record_link_assignment

 36527 +  (bfd *, struct bfd_link_info *, const char *);

 36528 +extern bfd_boolean bfd_sunos_size_dynamic_sections

 36529 +  (bfd *, struct bfd_link_info *, struct bfd_section **,

 36530 +   struct bfd_section **, struct bfd_section **);

 36531 +

 36532 +/* Linux shared library support routines for the linker.  */

 36533 +

 36534 +extern bfd_boolean bfd_i386linux_size_dynamic_sections

 36535 +  (bfd *, struct bfd_link_info *);

 36536 +extern bfd_boolean bfd_m68klinux_size_dynamic_sections

 36537 +  (bfd *, struct bfd_link_info *);

 36538 +extern bfd_boolean bfd_sparclinux_size_dynamic_sections

 36539 +  (bfd *, struct bfd_link_info *);

 36540 +

 36541 +/* mmap hacks */

 36542 +

 36543 +struct _bfd_window_internal;

 36544 +typedef struct _bfd_window_internal bfd_window_internal;

 36545 +

 36546 +typedef struct _bfd_window

 36547 +{

 36548 +  /* What the user asked for.  */

 36549 +  void *data;

 36550 +  bfd_size_type size;

 36551 +  /* The actual window used by BFD.  Small user-requested read-only

 36552 +     regions sharing a page may share a single window into the object

 36553 +     file.  Read-write versions shouldn't until I've fixed things to

 36554 +     keep track of which portions have been claimed by the

 36555 +     application; don't want to give the same region back when the

 36556 +     application wants two writable copies!  */

 36557 +  struct _bfd_window_internal *i;

 36558 +}

 36559 +bfd_window;

 36560 +

 36561 +extern void bfd_init_window

 36562 +  (bfd_window *);

 36563 +extern void bfd_free_window

 36564 +  (bfd_window *);

 36565 +extern bfd_boolean bfd_get_file_window

 36566 +  (bfd *, file_ptr, bfd_size_type, bfd_window *, bfd_boolean);

 36567 +

 36568 +/* XCOFF support routines for the linker.  */

 36569 +

 36570 +extern bfd_boolean bfd_xcoff_link_record_set

 36571 +  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_size_type);

 36572 +extern bfd_boolean bfd_xcoff_import_symbol

 36573 +  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_vma,

 36574 +   const char *, const char *, const char *, unsigned int);

 36575 +extern bfd_boolean bfd_xcoff_export_symbol

 36576 +  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *);

 36577 +extern bfd_boolean bfd_xcoff_link_count_reloc

 36578 +  (bfd *, struct bfd_link_info *, const char *);

 36579 +extern bfd_boolean bfd_xcoff_record_link_assignment

 36580 +  (bfd *, struct bfd_link_info *, const char *);

 36581 +extern bfd_boolean bfd_xcoff_size_dynamic_sections

 36582 +  (bfd *, struct bfd_link_info *, const char *, const char *,

 36583 +   unsigned long, unsigned long, unsigned long, bfd_boolean,

 36584 +   int, bfd_boolean, bfd_boolean, struct bfd_section **, bfd_boolean);

 36585 +extern bfd_boolean bfd_xcoff_link_generate_rtinit

 36586 +  (bfd *, const char *, const char *, bfd_boolean);

 36587 +

 36588 +/* XCOFF support routines for ar.  */

 36589 +extern bfd_boolean bfd_xcoff_ar_archive_set_magic

 36590 +  (bfd *, char *);

 36591 +

 36592 +/* Externally visible COFF routines.  */

 36593 +

 36594 +#if defined(__STDC__) || defined(ALMOST_STDC)

 36595 +struct internal_syment;

 36596 +union internal_auxent;

 36597 +#endif

 36598 +

 36599 +extern bfd_boolean bfd_coff_get_syment

 36600 +  (bfd *, struct bfd_symbol *, struct internal_syment *);

 36601 +

 36602 +extern bfd_boolean bfd_coff_get_auxent

 36603 +  (bfd *, struct bfd_symbol *, int, union internal_auxent *);

 36604 +

 36605 +extern bfd_boolean bfd_coff_set_symbol_class

 36606 +  (bfd *, struct bfd_symbol *, unsigned int);

 36607 +

 36608 +extern bfd_boolean bfd_m68k_coff_create_embedded_relocs

 36609 +  (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, char **);

 36610 +

 36611 +/* ARM VFP11 erratum workaround support.  */

 36612 +typedef enum

 36613 +{

 36614 +  BFD_ARM_VFP11_FIX_DEFAULT,

 36615 +  BFD_ARM_VFP11_FIX_NONE,

 36616 +  BFD_ARM_VFP11_FIX_SCALAR,

 36617 +  BFD_ARM_VFP11_FIX_VECTOR

 36618 +} bfd_arm_vfp11_fix;

 36619 +

 36620 +extern void bfd_elf32_arm_init_maps

 36621 +  (bfd *);

 36622 +

 36623 +extern void bfd_elf32_arm_set_vfp11_fix

 36624 +  (bfd *, struct bfd_link_info *);

 36625 +

 36626 +extern bfd_boolean bfd_elf32_arm_vfp11_erratum_scan

 36627 +  (bfd *, struct bfd_link_info *);

 36628 +

 36629 +extern void bfd_elf32_arm_vfp11_fix_veneer_locations

 36630 +  (bfd *, struct bfd_link_info *);

 36631 +

 36632 +/* ARM Interworking support.  Called from linker.  */

 36633 +extern bfd_boolean bfd_arm_allocate_interworking_sections

 36634 +  (struct bfd_link_info *);

 36635 +

 36636 +extern bfd_boolean bfd_arm_process_before_allocation

 36637 +  (bfd *, struct bfd_link_info *, int);

 36638 +

 36639 +extern bfd_boolean bfd_arm_get_bfd_for_interworking

 36640 +  (bfd *, struct bfd_link_info *);

 36641 +

 36642 +/* PE ARM Interworking support.  Called from linker.  */

 36643 +extern bfd_boolean bfd_arm_pe_allocate_interworking_sections

 36644 +  (struct bfd_link_info *);

 36645 +

 36646 +extern bfd_boolean bfd_arm_pe_process_before_allocation

 36647 +  (bfd *, struct bfd_link_info *, int);

 36648 +

 36649 +extern bfd_boolean bfd_arm_pe_get_bfd_for_interworking

 36650 +  (bfd *, struct bfd_link_info *);

 36651 +

 36652 +/* ELF ARM Interworking support.  Called from linker.  */

 36653 +extern bfd_boolean bfd_elf32_arm_allocate_interworking_sections

 36654 +  (struct bfd_link_info *);

 36655 +

 36656 +extern bfd_boolean bfd_elf32_arm_process_before_allocation

 36657 +  (bfd *, struct bfd_link_info *);

 36658 +

 36659 +void bfd_elf32_arm_set_target_relocs

 36660 +  (bfd *, struct bfd_link_info *, int, char *, int, int, bfd_arm_vfp11_fix,

 36661 +   int, int);

 36662 +

 36663 +extern bfd_boolean bfd_elf32_arm_get_bfd_for_interworking

 36664 +  (bfd *, struct bfd_link_info *);

 36665 +

 36666 +extern bfd_boolean bfd_elf32_arm_add_glue_sections_to_bfd

 36667 +  (bfd *, struct bfd_link_info *);

 36668 +

 36669 +/* ELF ARM mapping symbol support */

 36670 +#define BFD_ARM_SPECIAL_SYM_TYPE_MAP	(1 << 0)

 36671 +#define BFD_ARM_SPECIAL_SYM_TYPE_TAG	(1 << 1)

 36672 +#define BFD_ARM_SPECIAL_SYM_TYPE_OTHER  (1 << 2)

 36673 +#define BFD_ARM_SPECIAL_SYM_TYPE_ANY	(~0)

 36674 +extern bfd_boolean bfd_is_arm_special_symbol_name

 36675 +  (const char * name, int type);

 36676 +

 36677 +extern void bfd_elf32_arm_set_byteswap_code (struct bfd_link_info *, int);

 36678 +

 36679 +/* ARM Note section processing.  */

 36680 +extern bfd_boolean bfd_arm_merge_machines

 36681 +  (bfd *, bfd *);

 36682 +

 36683 +extern bfd_boolean bfd_arm_update_notes

 36684 +  (bfd *, const char *);

 36685 +

 36686 +extern unsigned int bfd_arm_get_mach_from_notes

 36687 +  (bfd *, const char *);

 36688 +

 36689 +/* TI COFF load page support.  */

 36690 +extern void bfd_ticoff_set_section_load_page

 36691 +  (struct bfd_section *, int);

 36692 +

 36693 +extern int bfd_ticoff_get_section_load_page

 36694 +  (struct bfd_section *);

 36695 +

 36696 +/* H8/300 functions.  */

 36697 +extern bfd_vma bfd_h8300_pad_address

 36698 +  (bfd *, bfd_vma);

 36699 +

 36700 +/* IA64 Itanium code generation.  Called from linker.  */

 36701 +extern void bfd_elf32_ia64_after_parse

 36702 +  (int);

 36703 +

 36704 +extern void bfd_elf64_ia64_after_parse

 36705 +  (int);

 36706 +

 36707 +/* This structure is used for a comdat section, as in PE.  A comdat

 36708 +   section is associated with a particular symbol.  When the linker

 36709 +   sees a comdat section, it keeps only one of the sections with a

 36710 +   given name and associated with a given symbol.  */

 36711 +

 36712 +struct coff_comdat_info

 36713 +{

 36714 +  /* The name of the symbol associated with a comdat section.  */

 36715 +  const char *name;

 36716 +

 36717 +  /* The local symbol table index of the symbol associated with a

 36718 +     comdat section.  This is only meaningful to the object file format

 36719 +     specific code; it is not an index into the list returned by

 36720 +     bfd_canonicalize_symtab.  */

 36721 +  long symbol;

 36722 +};

 36723 +

 36724 +extern struct coff_comdat_info *bfd_coff_get_comdat_section

 36725 +  (bfd *, struct bfd_section *);

 36726 +

 36727 +/* Extracted from init.c.  */

 36728 +void bfd_init (void);

 36729 +

 36730 +/* Extracted from opncls.c.  */

 36731 +bfd *bfd_fopen (const char *filename, const char *target,

 36732 +    const char *mode, int fd);

 36733 +

 36734 +bfd *bfd_openr (const char *filename, const char *target);

 36735 +

 36736 +bfd *bfd_fdopenr (const char *filename, const char *target, int fd);

 36737 +

 36738 +bfd *bfd_openstreamr (const char *, const char *, void *);

 36739 +

 36740 +bfd *bfd_openr_iovec (const char *filename, const char *target,

 36741 +    void *(*open) (struct bfd *nbfd,

 36742 +    void *open_closure),

 36743 +    void *open_closure,

 36744 +    file_ptr (*pread) (struct bfd *nbfd,

 36745 +    void *stream,

 36746 +    void *buf,

 36747 +    file_ptr nbytes,

 36748 +    file_ptr offset),

 36749 +    int (*close) (struct bfd *nbfd,

 36750 +    void *stream),

 36751 +    int (*stat) (struct bfd *abfd,

 36752 +    void *stream,

 36753 +    struct stat *sb));

 36754 +

 36755 +bfd *bfd_openw (const char *filename, const char *target);

 36756 +

 36757 +bfd_boolean bfd_close (bfd *abfd);

 36758 +

 36759 +bfd_boolean bfd_close_all_done (bfd *);

 36760 +

 36761 +bfd *bfd_create (const char *filename, bfd *templ);

 36762 +

 36763 +bfd_boolean bfd_make_writable (bfd *abfd);

 36764 +

 36765 +bfd_boolean bfd_make_readable (bfd *abfd);

 36766 +

 36767 +unsigned long bfd_calc_gnu_debuglink_crc32

 36768 +   (unsigned long crc, const unsigned char *buf, bfd_size_type len);

 36769 +

 36770 +char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);

 36771 +

 36772 +struct bfd_section *bfd_create_gnu_debuglink_section

 36773 +   (bfd *abfd, const char *filename);

 36774 +

 36775 +bfd_boolean bfd_fill_in_gnu_debuglink_section

 36776 +   (bfd *abfd, struct bfd_section *sect, const char *filename);

 36777 +

 36778 +/* Extracted from libbfd.c.  */

 36779 +

 36780 +/* Byte swapping macros for user section data.  */

 36781 +

 36782 +#define bfd_put_8(abfd, val, ptr) \

 36783 +  ((void) (*((unsigned char *) (ptr)) = (val) & 0xff))

 36784 +#define bfd_put_signed_8 \

 36785 +  bfd_put_8

 36786 +#define bfd_get_8(abfd, ptr) \

 36787 +  (*(unsigned char *) (ptr) & 0xff)

 36788 +#define bfd_get_signed_8(abfd, ptr) \

 36789 +  (((*(unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)

 36790 +

 36791 +#define bfd_put_16(abfd, val, ptr) \

 36792 +  BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))

 36793 +#define bfd_put_signed_16 \

 36794 +  bfd_put_16

 36795 +#define bfd_get_16(abfd, ptr) \

 36796 +  BFD_SEND (abfd, bfd_getx16, (ptr))

 36797 +#define bfd_get_signed_16(abfd, ptr) \

 36798 +  BFD_SEND (abfd, bfd_getx_signed_16, (ptr))

 36799 +

 36800 +#define bfd_put_32(abfd, val, ptr) \

 36801 +  BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))

 36802 +#define bfd_put_signed_32 \

 36803 +  bfd_put_32

 36804 +#define bfd_get_32(abfd, ptr) \

 36805 +  BFD_SEND (abfd, bfd_getx32, (ptr))

 36806 +#define bfd_get_signed_32(abfd, ptr) \

 36807 +  BFD_SEND (abfd, bfd_getx_signed_32, (ptr))

 36808 +

 36809 +#define bfd_put_64(abfd, val, ptr) \

 36810 +  BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))

 36811 +#define bfd_put_signed_64 \

 36812 +  bfd_put_64

 36813 +#define bfd_get_64(abfd, ptr) \

 36814 +  BFD_SEND (abfd, bfd_getx64, (ptr))

 36815 +#define bfd_get_signed_64(abfd, ptr) \

 36816 +  BFD_SEND (abfd, bfd_getx_signed_64, (ptr))

 36817 +

 36818 +#define bfd_get(bits, abfd, ptr)                       \

 36819 +  ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr)       \

 36820 +   : (bits) == 16 ? bfd_get_16 (abfd, ptr)             \

 36821 +   : (bits) == 32 ? bfd_get_32 (abfd, ptr)             \

 36822 +   : (bits) == 64 ? bfd_get_64 (abfd, ptr)             \

 36823 +   : (abort (), (bfd_vma) - 1))

 36824 +

 36825 +#define bfd_put(bits, abfd, val, ptr)                  \

 36826 +  ((bits) == 8 ? bfd_put_8  (abfd, val, ptr)           \

 36827 +   : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)                \

 36828 +   : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)                \

 36829 +   : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)                \

 36830 +   : (abort (), (void) 0))

 36831 +

 36832 +

 36833 +/* Byte swapping macros for file header data.  */

 36834 +

 36835 +#define bfd_h_put_8(abfd, val, ptr) \

 36836 +  bfd_put_8 (abfd, val, ptr)

 36837 +#define bfd_h_put_signed_8(abfd, val, ptr) \

 36838 +  bfd_put_8 (abfd, val, ptr)

 36839 +#define bfd_h_get_8(abfd, ptr) \

 36840 +  bfd_get_8 (abfd, ptr)

 36841 +#define bfd_h_get_signed_8(abfd, ptr) \

 36842 +  bfd_get_signed_8 (abfd, ptr)

 36843 +

 36844 +#define bfd_h_put_16(abfd, val, ptr) \

 36845 +  BFD_SEND (abfd, bfd_h_putx16, (val, ptr))

 36846 +#define bfd_h_put_signed_16 \

 36847 +  bfd_h_put_16

 36848 +#define bfd_h_get_16(abfd, ptr) \

 36849 +  BFD_SEND (abfd, bfd_h_getx16, (ptr))

 36850 +#define bfd_h_get_signed_16(abfd, ptr) \

 36851 +  BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))

 36852 +

 36853 +#define bfd_h_put_32(abfd, val, ptr) \

 36854 +  BFD_SEND (abfd, bfd_h_putx32, (val, ptr))

 36855 +#define bfd_h_put_signed_32 \

 36856 +  bfd_h_put_32

 36857 +#define bfd_h_get_32(abfd, ptr) \

 36858 +  BFD_SEND (abfd, bfd_h_getx32, (ptr))

 36859 +#define bfd_h_get_signed_32(abfd, ptr) \

 36860 +  BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))

 36861 +

 36862 +#define bfd_h_put_64(abfd, val, ptr) \

 36863 +  BFD_SEND (abfd, bfd_h_putx64, (val, ptr))

 36864 +#define bfd_h_put_signed_64 \

 36865 +  bfd_h_put_64

 36866 +#define bfd_h_get_64(abfd, ptr) \

 36867 +  BFD_SEND (abfd, bfd_h_getx64, (ptr))

 36868 +#define bfd_h_get_signed_64(abfd, ptr) \

 36869 +  BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))

 36870 +

 36871 +/* Aliases for the above, which should eventually go away.  */

 36872 +

 36873 +#define H_PUT_64  bfd_h_put_64

 36874 +#define H_PUT_32  bfd_h_put_32

 36875 +#define H_PUT_16  bfd_h_put_16

 36876 +#define H_PUT_8   bfd_h_put_8

 36877 +#define H_PUT_S64 bfd_h_put_signed_64

 36878 +#define H_PUT_S32 bfd_h_put_signed_32

 36879 +#define H_PUT_S16 bfd_h_put_signed_16

 36880 +#define H_PUT_S8  bfd_h_put_signed_8

 36881 +#define H_GET_64  bfd_h_get_64

 36882 +#define H_GET_32  bfd_h_get_32

 36883 +#define H_GET_16  bfd_h_get_16

 36884 +#define H_GET_8   bfd_h_get_8

 36885 +#define H_GET_S64 bfd_h_get_signed_64

 36886 +#define H_GET_S32 bfd_h_get_signed_32

 36887 +#define H_GET_S16 bfd_h_get_signed_16

 36888 +#define H_GET_S8  bfd_h_get_signed_8

 36889 +

 36890 +

 36891 +/* Extracted from bfdio.c.  */

 36892 +long bfd_get_mtime (bfd *abfd);

 36893 +

 36894 +file_ptr bfd_get_size (bfd *abfd);

 36895 +

 36896 +/* Extracted from bfdwin.c.  */

 36897 +/* Extracted from section.c.  */

 36898 +typedef struct bfd_section

 36899 +{

 36900 +  /* The name of the section; the name isn't a copy, the pointer is

 36901 +     the same as that passed to bfd_make_section.  */

 36902 +  const char *name;

 36903 +

 36904 +  /* A unique sequence number.  */

 36905 +  int id;

 36906 +

 36907 +  /* Which section in the bfd; 0..n-1 as sections are created in a bfd.  */

 36908 +  int index;

 36909 +

 36910 +  /* The next section in the list belonging to the BFD, or NULL.  */

 36911 +  struct bfd_section *next;

 36912 +

 36913 +  /* The previous section in the list belonging to the BFD, or NULL.  */

 36914 +  struct bfd_section *prev;

 36915 +

 36916 +  /* The field flags contains attributes of the section. Some

 36917 +     flags are read in from the object file, and some are

 36918 +     synthesized from other information.  */

 36919 +  flagword flags;

 36920 +

 36921 +#define SEC_NO_FLAGS   0x000

 36922 +

 36923 +  /* Tells the OS to allocate space for this section when loading.

 36924 +     This is clear for a section containing debug information only.  */

 36925 +#define SEC_ALLOC      0x001

 36926 +

 36927 +  /* Tells the OS to load the section from the file when loading.

 36928 +     This is clear for a .bss section.  */

 36929 +#define SEC_LOAD       0x002

 36930 +

 36931 +  /* The section contains data still to be relocated, so there is

 36932 +     some relocation information too.  */

 36933 +#define SEC_RELOC      0x004

 36934 +

 36935 +  /* A signal to the OS that the section contains read only data.  */

 36936 +#define SEC_READONLY   0x008

 36937 +

 36938 +  /* The section contains code only.  */

 36939 +#define SEC_CODE       0x010

 36940 +

 36941 +  /* The section contains data only.  */

 36942 +#define SEC_DATA       0x020

 36943 +

 36944 +  /* The section will reside in ROM.  */

 36945 +#define SEC_ROM        0x040

 36946 +

 36947 +  /* The section contains constructor information. This section

 36948 +     type is used by the linker to create lists of constructors and

 36949 +     destructors used by <<g++>>. When a back end sees a symbol

 36950 +     which should be used in a constructor list, it creates a new

 36951 +     section for the type of name (e.g., <<__CTOR_LIST__>>), attaches

 36952 +     the symbol to it, and builds a relocation. To build the lists

 36953 +     of constructors, all the linker has to do is catenate all the

 36954 +     sections called <<__CTOR_LIST__>> and relocate the data

 36955 +     contained within - exactly the operations it would peform on

 36956 +     standard data.  */

 36957 +#define SEC_CONSTRUCTOR 0x080

 36958 +

 36959 +  /* The section has contents - a data section could be

 36960 +     <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>; a debug section could be

 36961 +     <<SEC_HAS_CONTENTS>>  */

 36962 +#define SEC_HAS_CONTENTS 0x100

 36963 +

 36964 +  /* An instruction to the linker to not output the section

 36965 +     even if it has information which would normally be written.  */

 36966 +#define SEC_NEVER_LOAD 0x200

 36967 +

 36968 +  /* The section contains thread local data.  */

 36969 +#define SEC_THREAD_LOCAL 0x400

 36970 +

 36971 +  /* The section has GOT references.  This flag is only for the

 36972 +     linker, and is currently only used by the elf32-hppa back end.

 36973 +     It will be set if global offset table references were detected

 36974 +     in this section, which indicate to the linker that the section

 36975 +     contains PIC code, and must be handled specially when doing a

 36976 +     static link.  */

 36977 +#define SEC_HAS_GOT_REF 0x800

 36978 +

 36979 +  /* The section contains common symbols (symbols may be defined

 36980 +     multiple times, the value of a symbol is the amount of

 36981 +     space it requires, and the largest symbol value is the one

 36982 +     used).  Most targets have exactly one of these (which we

 36983 +     translate to bfd_com_section_ptr), but ECOFF has two.  */

 36984 +#define SEC_IS_COMMON 0x1000

 36985 +

 36986 +  /* The section contains only debugging information.  For

 36987 +     example, this is set for ELF .debug and .stab sections.

 36988 +     strip tests this flag to see if a section can be

 36989 +     discarded.  */

 36990 +#define SEC_DEBUGGING 0x2000

 36991 +

 36992 +  /* The contents of this section are held in memory pointed to

 36993 +     by the contents field.  This is checked by bfd_get_section_contents,

 36994 +     and the data is retrieved from memory if appropriate.  */

 36995 +#define SEC_IN_MEMORY 0x4000

 36996 +

 36997 +  /* The contents of this section are to be excluded by the

 36998 +     linker for executable and shared objects unless those

 36999 +     objects are to be further relocated.  */

 37000 +#define SEC_EXCLUDE 0x8000

 37001 +

 37002 +  /* The contents of this section are to be sorted based on the sum of

 37003 +     the symbol and addend values specified by the associated relocation

 37004 +     entries.  Entries without associated relocation entries will be

 37005 +     appended to the end of the section in an unspecified order.  */

 37006 +#define SEC_SORT_ENTRIES 0x10000

 37007 +

 37008 +  /* When linking, duplicate sections of the same name should be

 37009 +     discarded, rather than being combined into a single section as

 37010 +     is usually done.  This is similar to how common symbols are

 37011 +     handled.  See SEC_LINK_DUPLICATES below.  */

 37012 +#define SEC_LINK_ONCE 0x20000

 37013 +

 37014 +  /* If SEC_LINK_ONCE is set, this bitfield describes how the linker

 37015 +     should handle duplicate sections.  */

 37016 +#define SEC_LINK_DUPLICATES 0x40000

 37017 +

 37018 +  /* This value for SEC_LINK_DUPLICATES means that duplicate

 37019 +     sections with the same name should simply be discarded.  */

 37020 +#define SEC_LINK_DUPLICATES_DISCARD 0x0

 37021 +

 37022 +  /* This value for SEC_LINK_DUPLICATES means that the linker

 37023 +     should warn if there are any duplicate sections, although

 37024 +     it should still only link one copy.  */

 37025 +#define SEC_LINK_DUPLICATES_ONE_ONLY 0x80000

 37026 +

 37027 +  /* This value for SEC_LINK_DUPLICATES means that the linker

 37028 +     should warn if any duplicate sections are a different size.  */

 37029 +#define SEC_LINK_DUPLICATES_SAME_SIZE 0x100000

 37030 +

 37031 +  /* This value for SEC_LINK_DUPLICATES means that the linker

 37032 +     should warn if any duplicate sections contain different

 37033 +     contents.  */

 37034 +#define SEC_LINK_DUPLICATES_SAME_CONTENTS \

 37035 +  (SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE)

 37036 +

 37037 +  /* This section was created by the linker as part of dynamic

 37038 +     relocation or other arcane processing.  It is skipped when

 37039 +     going through the first-pass output, trusting that someone

 37040 +     else up the line will take care of it later.  */

 37041 +#define SEC_LINKER_CREATED 0x200000

 37042 +

 37043 +  /* This section should not be subject to garbage collection.

 37044 +     Also set to inform the linker that this section should not be

 37045 +     listed in the link map as discarded.  */

 37046 +#define SEC_KEEP 0x400000

 37047 +

 37048 +  /* This section contains "short" data, and should be placed

 37049 +     "near" the GP.  */

 37050 +#define SEC_SMALL_DATA 0x800000

 37051 +

 37052 +  /* Attempt to merge identical entities in the section.

 37053 +     Entity size is given in the entsize field.  */

 37054 +#define SEC_MERGE 0x1000000

 37055 +

 37056 +  /* If given with SEC_MERGE, entities to merge are zero terminated

 37057 +     strings where entsize specifies character size instead of fixed

 37058 +     size entries.  */

 37059 +#define SEC_STRINGS 0x2000000

 37060 +

 37061 +  /* This section contains data about section groups.  */

 37062 +#define SEC_GROUP 0x4000000

 37063 +

 37064 +  /* The section is a COFF shared library section.  This flag is

 37065 +     only for the linker.  If this type of section appears in

 37066 +     the input file, the linker must copy it to the output file

 37067 +     without changing the vma or size.  FIXME: Although this

 37068 +     was originally intended to be general, it really is COFF

 37069 +     specific (and the flag was renamed to indicate this).  It

 37070 +     might be cleaner to have some more general mechanism to

 37071 +     allow the back end to control what the linker does with

 37072 +     sections.  */

 37073 +#define SEC_COFF_SHARED_LIBRARY 0x10000000

 37074 +

 37075 +  /* This section contains data which may be shared with other

 37076 +     executables or shared objects. This is for COFF only.  */

 37077 +#define SEC_COFF_SHARED 0x20000000

 37078 +

 37079 +  /* When a section with this flag is being linked, then if the size of

 37080 +     the input section is less than a page, it should not cross a page

 37081 +     boundary.  If the size of the input section is one page or more,

 37082 +     it should be aligned on a page boundary.  This is for TI

 37083 +     TMS320C54X only.  */

 37084 +#define SEC_TIC54X_BLOCK 0x40000000

 37085 +

 37086 +  /* Conditionally link this section; do not link if there are no

 37087 +     references found to any symbol in the section.  This is for TI

 37088 +     TMS320C54X only.  */

 37089 +#define SEC_TIC54X_CLINK 0x80000000

 37090 +

 37091 +  /*  End of section flags.  */

 37092 +

 37093 +  /* Some internal packed boolean fields.  */

 37094 +

 37095 +  /* See the vma field.  */

 37096 +  unsigned int user_set_vma : 1;

 37097 +

 37098 +  /* A mark flag used by some of the linker backends.  */

 37099 +  unsigned int linker_mark : 1;

 37100 +

 37101 +  /* Another mark flag used by some of the linker backends.  Set for

 37102 +     output sections that have an input section.  */

 37103 +  unsigned int linker_has_input : 1;

 37104 +

 37105 +  /* Mark flags used by some linker backends for garbage collection.  */

 37106 +  unsigned int gc_mark : 1;

 37107 +  unsigned int gc_mark_from_eh : 1;

 37108 +

 37109 +  /* The following flags are used by the ELF linker. */

 37110 +

 37111 +  /* Mark sections which have been allocated to segments.  */

 37112 +  unsigned int segment_mark : 1;

 37113 +

 37114 +  /* Type of sec_info information.  */

 37115 +  unsigned int sec_info_type:3;

 37116 +#define ELF_INFO_TYPE_NONE      0

 37117 +#define ELF_INFO_TYPE_STABS     1

 37118 +#define ELF_INFO_TYPE_MERGE     2

 37119 +#define ELF_INFO_TYPE_EH_FRAME  3

 37120 +#define ELF_INFO_TYPE_JUST_SYMS 4

 37121 +

 37122 +  /* Nonzero if this section uses RELA relocations, rather than REL.  */

 37123 +  unsigned int use_rela_p:1;

 37124 +

 37125 +  /* Bits used by various backends.  The generic code doesn't touch

 37126 +     these fields.  */

 37127 +

 37128 +  /* Nonzero if this section has TLS related relocations.  */

 37129 +  unsigned int has_tls_reloc:1;

 37130 +

 37131 +  /* Nonzero if this section has a gp reloc.  */

 37132 +  unsigned int has_gp_reloc:1;

 37133 +

 37134 +  /* Nonzero if this section needs the relax finalize pass.  */

 37135 +  unsigned int need_finalize_relax:1;

 37136 +

 37137 +  /* Whether relocations have been processed.  */

 37138 +  unsigned int reloc_done : 1;

 37139 +

 37140 +  /* End of internal packed boolean fields.  */

 37141 +

 37142 +  /*  The virtual memory address of the section - where it will be

 37143 +      at run time.  The symbols are relocated against this.  The

 37144 +      user_set_vma flag is maintained by bfd; if it's not set, the

 37145 +      backend can assign addresses (for example, in <<a.out>>, where

 37146 +      the default address for <<.data>> is dependent on the specific

 37147 +      target and various flags).  */

 37148 +  bfd_vma vma;

 37149 +

 37150 +  /*  The load address of the section - where it would be in a

 37151 +      rom image; really only used for writing section header

 37152 +      information.  */

 37153 +  bfd_vma lma;

 37154 +

 37155 +  /* The size of the section in octets, as it will be output.

 37156 +     Contains a value even if the section has no contents (e.g., the

 37157 +     size of <<.bss>>).  */

 37158 +  bfd_size_type size;

 37159 +

 37160 +  /* For input sections, the original size on disk of the section, in

 37161 +     octets.  This field is used by the linker relaxation code.  It is

 37162 +     currently only set for sections where the linker relaxation scheme

 37163 +     doesn't cache altered section and reloc contents (stabs, eh_frame,

 37164 +     SEC_MERGE, some coff relaxing targets), and thus the original size

 37165 +     needs to be kept to read the section multiple times.

 37166 +     For output sections, rawsize holds the section size calculated on

 37167 +     a previous linker relaxation pass.  */

 37168 +  bfd_size_type rawsize;

 37169 +

 37170 +  /* If this section is going to be output, then this value is the

 37171 +     offset in *bytes* into the output section of the first byte in the

 37172 +     input section (byte ==> smallest addressable unit on the

 37173 +     target).  In most cases, if this was going to start at the

 37174 +     100th octet (8-bit quantity) in the output section, this value

 37175 +     would be 100.  However, if the target byte size is 16 bits

 37176 +     (bfd_octets_per_byte is "2"), this value would be 50.  */

 37177 +  bfd_vma output_offset;

 37178 +

 37179 +  /* The output section through which to map on output.  */

 37180 +  struct bfd_section *output_section;

 37181 +

 37182 +  /* The alignment requirement of the section, as an exponent of 2 -

 37183 +     e.g., 3 aligns to 2^3 (or 8).  */

 37184 +  unsigned int alignment_power;

 37185 +

 37186 +  /* If an input section, a pointer to a vector of relocation

 37187 +     records for the data in this section.  */

 37188 +  struct reloc_cache_entry *relocation;

 37189 +

 37190 +  /* If an output section, a pointer to a vector of pointers to

 37191 +     relocation records for the data in this section.  */

 37192 +  struct reloc_cache_entry **orelocation;

 37193 +

 37194 +  /* The number of relocation records in one of the above.  */

 37195 +  unsigned reloc_count;

 37196 +

 37197 +  /* Information below is back end specific - and not always used

 37198 +     or updated.  */

 37199 +

 37200 +  /* File position of section data.  */

 37201 +  file_ptr filepos;

 37202 +

 37203 +  /* File position of relocation info.  */

 37204 +  file_ptr rel_filepos;

 37205 +

 37206 +  /* File position of line data.  */

 37207 +  file_ptr line_filepos;

 37208 +

 37209 +  /* Pointer to data for applications.  */

 37210 +  void *userdata;

 37211 +

 37212 +  /* If the SEC_IN_MEMORY flag is set, this points to the actual

 37213 +     contents.  */

 37214 +  unsigned char *contents;

 37215 +

 37216 +  /* Attached line number information.  */

 37217 +  alent *lineno;

 37218 +

 37219 +  /* Number of line number records.  */

 37220 +  unsigned int lineno_count;

 37221 +

 37222 +  /* Entity size for merging purposes.  */

 37223 +  unsigned int entsize;

 37224 +

 37225 +  /* Points to the kept section if this section is a link-once section,

 37226 +     and is discarded.  */

 37227 +  struct bfd_section *kept_section;

 37228 +

 37229 +  /* When a section is being output, this value changes as more

 37230 +     linenumbers are written out.  */

 37231 +  file_ptr moving_line_filepos;

 37232 +

 37233 +  /* What the section number is in the target world.  */

 37234 +  int target_index;

 37235 +

 37236 +  void *used_by_bfd;

 37237 +

 37238 +  /* If this is a constructor section then here is a list of the

 37239 +     relocations created to relocate items within it.  */

 37240 +  struct relent_chain *constructor_chain;

 37241 +

 37242 +  /* The BFD which owns the section.  */

 37243 +  bfd *owner;

 37244 +

 37245 +  /* A symbol which points at this section only.  */

 37246 +  struct bfd_symbol *symbol;

 37247 +  struct bfd_symbol **symbol_ptr_ptr;

 37248 +

 37249 +  /* Early in the link process, map_head and map_tail are used to build

 37250 +     a list of input sections attached to an output section.  Later,

 37251 +     output sections use these fields for a list of bfd_link_order

 37252 +     structs.  */

 37253 +  union {

 37254 +    struct bfd_link_order *link_order;

 37255 +    struct bfd_section *s;

 37256 +  } map_head, map_tail;

 37257 +} asection;

 37258 +

 37259 +/* These sections are global, and are managed by BFD.  The application

 37260 +   and target back end are not permitted to change the values in

 37261 +   these sections.  New code should use the section_ptr macros rather

 37262 +   than referring directly to the const sections.  The const sections

 37263 +   may eventually vanish.  */

 37264 +#define BFD_ABS_SECTION_NAME "*ABS*"

 37265 +#define BFD_UND_SECTION_NAME "*UND*"

 37266 +#define BFD_COM_SECTION_NAME "*COM*"

 37267 +#define BFD_IND_SECTION_NAME "*IND*"

 37268 +

 37269 +/* The absolute section.  */

 37270 +extern asection bfd_abs_section;

 37271 +#define bfd_abs_section_ptr ((asection *) &bfd_abs_section)

 37272 +#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr)

 37273 +/* Pointer to the undefined section.  */

 37274 +extern asection bfd_und_section;

 37275 +#define bfd_und_section_ptr ((asection *) &bfd_und_section)

 37276 +#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr)

 37277 +/* Pointer to the common section.  */

 37278 +extern asection bfd_com_section;

 37279 +#define bfd_com_section_ptr ((asection *) &bfd_com_section)

 37280 +/* Pointer to the indirect section.  */

 37281 +extern asection bfd_ind_section;

 37282 +#define bfd_ind_section_ptr ((asection *) &bfd_ind_section)

 37283 +#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr)

 37284 +

 37285 +#define bfd_is_const_section(SEC)              \

 37286 + (   ((SEC) == bfd_abs_section_ptr)            \

 37287 +  || ((SEC) == bfd_und_section_ptr)            \

 37288 +  || ((SEC) == bfd_com_section_ptr)            \

 37289 +  || ((SEC) == bfd_ind_section_ptr))

 37290 +

 37291 +/* Macros to handle insertion and deletion of a bfd's sections.  These

 37292 +   only handle the list pointers, ie. do not adjust section_count,

 37293 +   target_index etc.  */

 37294 +#define bfd_section_list_remove(ABFD, S) \

 37295 +  do                                                   \

 37296 +    {                                                  \

 37297 +      asection *_s = S;                                \

 37298 +      asection *_next = _s->next;                      \

 37299 +      asection *_prev = _s->prev;                      \

 37300 +      if (_prev)                                       \

 37301 +        _prev->next = _next;                           \

 37302 +      else                                             \

 37303 +        (ABFD)->sections = _next;                      \

 37304 +      if (_next)                                       \

 37305 +        _next->prev = _prev;                           \

 37306 +      else                                             \

 37307 +        (ABFD)->section_last = _prev;                  \

 37308 +    }                                                  \

 37309 +  while (0)

 37310 +#define bfd_section_list_append(ABFD, S) \

 37311 +  do                                                   \

 37312 +    {                                                  \

 37313 +      asection *_s = S;                                \

 37314 +      bfd *_abfd = ABFD;                               \

 37315 +      _s->next = NULL;                                 \

 37316 +      if (_abfd->section_last)                         \

 37317 +        {                                              \

 37318 +          _s->prev = _abfd->section_last;              \

 37319 +          _abfd->section_last->next = _s;              \

 37320 +        }                                              \

 37321 +      else                                             \

 37322 +        {                                              \

 37323 +          _s->prev = NULL;                             \

 37324 +          _abfd->sections = _s;                        \

 37325 +        }                                              \

 37326 +      _abfd->section_last = _s;                        \

 37327 +    }                                                  \

 37328 +  while (0)

 37329 +#define bfd_section_list_prepend(ABFD, S) \

 37330 +  do                                                   \

 37331 +    {                                                  \

 37332 +      asection *_s = S;                                \

 37333 +      bfd *_abfd = ABFD;                               \

 37334 +      _s->prev = NULL;                                 \

 37335 +      if (_abfd->sections)                             \

 37336 +        {                                              \

 37337 +          _s->next = _abfd->sections;                  \

 37338 +          _abfd->sections->prev = _s;                  \

 37339 +        }                                              \

 37340 +      else                                             \

 37341 +        {                                              \

 37342 +          _s->next = NULL;                             \

 37343 +          _abfd->section_last = _s;                    \

 37344 +        }                                              \

 37345 +      _abfd->sections = _s;                            \

 37346 +    }                                                  \

 37347 +  while (0)

 37348 +#define bfd_section_list_insert_after(ABFD, A, S) \

 37349 +  do                                                   \

 37350 +    {                                                  \

 37351 +      asection *_a = A;                                \

 37352 +      asection *_s = S;                                \

 37353 +      asection *_next = _a->next;                      \

 37354 +      _s->next = _next;                                \

 37355 +      _s->prev = _a;                                   \

 37356 +      _a->next = _s;                                   \

 37357 +      if (_next)                                       \

 37358 +        _next->prev = _s;                              \

 37359 +      else                                             \

 37360 +        (ABFD)->section_last = _s;                     \

 37361 +    }                                                  \

 37362 +  while (0)

 37363 +#define bfd_section_list_insert_before(ABFD, B, S) \

 37364 +  do                                                   \

 37365 +    {                                                  \

 37366 +      asection *_b = B;                                \

 37367 +      asection *_s = S;                                \

 37368 +      asection *_prev = _b->prev;                      \

 37369 +      _s->prev = _prev;                                \

 37370 +      _s->next = _b;                                   \

 37371 +      _b->prev = _s;                                   \

 37372 +      if (_prev)                                       \

 37373 +        _prev->next = _s;                              \

 37374 +      else                                             \

 37375 +        (ABFD)->sections = _s;                         \

 37376 +    }                                                  \

 37377 +  while (0)

 37378 +#define bfd_section_removed_from_list(ABFD, S) \

 37379 +  ((S)->next == NULL ? (ABFD)->section_last != (S) : (S)->next->prev != (S))

 37380 +

 37381 +#define BFD_FAKE_SECTION(SEC, FLAGS, SYM, NAME, IDX)                   \

 37382 +  /* name, id,  index, next, prev, flags, user_set_vma,            */  \

 37383 +  { NAME,  IDX, 0,     NULL, NULL, FLAGS, 0,                           \

 37384 +                                                                       \

 37385 +  /* linker_mark, linker_has_input, gc_mark, gc_mark_from_eh,      */  \

 37386 +     0,           0,                1,       0,                        \

 37387 +                                                                       \

 37388 +  /* segment_mark, sec_info_type, use_rela_p, has_tls_reloc,       */  \

 37389 +     0,            0,             0,          0,                       \

 37390 +                                                                       \

 37391 +  /* has_gp_reloc, need_finalize_relax, reloc_done,                */  \

 37392 +     0,            0,                   0,                             \

 37393 +                                                                       \

 37394 +  /* vma, lma, size, rawsize                                       */  \

 37395 +     0,   0,   0,    0,                                                \

 37396 +                                                                       \

 37397 +  /* output_offset, output_section,              alignment_power,  */  \

 37398 +     0,             (struct bfd_section *) &SEC, 0,                    \

 37399 +                                                                       \

 37400 +  /* relocation, orelocation, reloc_count, filepos, rel_filepos,   */  \

 37401 +     NULL,       NULL,        0,           0,       0,                 \

 37402 +                                                                       \

 37403 +  /* line_filepos, userdata, contents, lineno, lineno_count,       */  \

 37404 +     0,            NULL,     NULL,     NULL,   0,                      \

 37405 +                                                                       \

 37406 +  /* entsize, kept_section, moving_line_filepos,                    */ \

 37407 +     0,       NULL,          0,                                        \

 37408 +                                                                       \

 37409 +  /* target_index, used_by_bfd, constructor_chain, owner,          */  \

 37410 +     0,            NULL,        NULL,              NULL,               \

 37411 +                                                                       \

 37412 +  /* symbol,                    symbol_ptr_ptr,                    */  \

 37413 +     (struct bfd_symbol *) SYM, &SEC.symbol,                           \

 37414 +                                                                       \

 37415 +  /* map_head, map_tail                                            */  \

 37416 +     { NULL }, { NULL }                                                \

 37417 +    }

 37418 +

 37419 +void bfd_section_list_clear (bfd *);

 37420 +

 37421 +asection *bfd_get_section_by_name (bfd *abfd, const char *name);

 37422 +

 37423 +asection *bfd_get_section_by_name_if

 37424 +   (bfd *abfd,

 37425 +    const char *name,

 37426 +    bfd_boolean (*func) (bfd *abfd, asection *sect, void *obj),

 37427 +    void *obj);

 37428 +

 37429 +char *bfd_get_unique_section_name

 37430 +   (bfd *abfd, const char *templat, int *count);

 37431 +

 37432 +asection *bfd_make_section_old_way (bfd *abfd, const char *name);

 37433 +

 37434 +asection *bfd_make_section_anyway_with_flags

 37435 +   (bfd *abfd, const char *name, flagword flags);

 37436 +

 37437 +asection *bfd_make_section_anyway (bfd *abfd, const char *name);

 37438 +

 37439 +asection *bfd_make_section_with_flags

 37440 +   (bfd *, const char *name, flagword flags);

 37441 +

 37442 +asection *bfd_make_section (bfd *, const char *name);

 37443 +

 37444 +bfd_boolean bfd_set_section_flags

 37445 +   (bfd *abfd, asection *sec, flagword flags);

 37446 +

 37447 +void bfd_map_over_sections

 37448 +   (bfd *abfd,

 37449 +    void (*func) (bfd *abfd, asection *sect, void *obj),

 37450 +    void *obj);

 37451 +

 37452 +asection *bfd_sections_find_if

 37453 +   (bfd *abfd,

 37454 +    bfd_boolean (*operation) (bfd *abfd, asection *sect, void *obj),

 37455 +    void *obj);

 37456 +

 37457 +bfd_boolean bfd_set_section_size

 37458 +   (bfd *abfd, asection *sec, bfd_size_type val);

 37459 +

 37460 +bfd_boolean bfd_set_section_contents

 37461 +   (bfd *abfd, asection *section, const void *data,

 37462 +    file_ptr offset, bfd_size_type count);

 37463 +

 37464 +bfd_boolean bfd_get_section_contents

 37465 +   (bfd *abfd, asection *section, void *location, file_ptr offset,

 37466 +    bfd_size_type count);

 37467 +

 37468 +bfd_boolean bfd_malloc_and_get_section

 37469 +   (bfd *abfd, asection *section, bfd_byte **buf);

 37470 +

 37471 +bfd_boolean bfd_copy_private_section_data

 37472 +   (bfd *ibfd, asection *isec, bfd *obfd, asection *osec);

 37473 +

 37474 +#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \

 37475 +     BFD_SEND (obfd, _bfd_copy_private_section_data, \

 37476 +               (ibfd, isection, obfd, osection))

 37477 +bfd_boolean bfd_generic_is_group_section (bfd *, const asection *sec);

 37478 +

 37479 +bfd_boolean bfd_generic_discard_group (bfd *abfd, asection *group);

 37480 +

 37481 +/* Extracted from archures.c.  */

 37482 +enum bfd_architecture

 37483 +{

 37484 +  bfd_arch_unknown,   /* File arch not known.  */

 37485 +  bfd_arch_obscure,   /* Arch known, not one of these.  */

 37486 +  bfd_arch_m68k,      /* Motorola 68xxx */

 37487 +#define bfd_mach_m68000 1

 37488 +#define bfd_mach_m68008 2

 37489 +#define bfd_mach_m68010 3

 37490 +#define bfd_mach_m68020 4

 37491 +#define bfd_mach_m68030 5

 37492 +#define bfd_mach_m68040 6

 37493 +#define bfd_mach_m68060 7

 37494 +#define bfd_mach_cpu32  8

 37495 +#define bfd_mach_fido   9

 37496 +#define bfd_mach_mcf_isa_a_nodiv 10

 37497 +#define bfd_mach_mcf_isa_a 11

 37498 +#define bfd_mach_mcf_isa_a_mac 12

 37499 +#define bfd_mach_mcf_isa_a_emac 13

 37500 +#define bfd_mach_mcf_isa_aplus 14

 37501 +#define bfd_mach_mcf_isa_aplus_mac 15

 37502 +#define bfd_mach_mcf_isa_aplus_emac 16

 37503 +#define bfd_mach_mcf_isa_b_nousp 17

 37504 +#define bfd_mach_mcf_isa_b_nousp_mac 18

 37505 +#define bfd_mach_mcf_isa_b_nousp_emac 19

 37506 +#define bfd_mach_mcf_isa_b 20

 37507 +#define bfd_mach_mcf_isa_b_mac 21

 37508 +#define bfd_mach_mcf_isa_b_emac 22

 37509 +#define bfd_mach_mcf_isa_b_float 23

 37510 +#define bfd_mach_mcf_isa_b_float_mac 24

 37511 +#define bfd_mach_mcf_isa_b_float_emac 25

 37512 +#define bfd_mach_mcf_isa_c 26

 37513 +#define bfd_mach_mcf_isa_c_mac 27

 37514 +#define bfd_mach_mcf_isa_c_emac 28

 37515 +  bfd_arch_vax,       /* DEC Vax */

 37516 +  bfd_arch_i960,      /* Intel 960 */

 37517 +    /* The order of the following is important.

 37518 +       lower number indicates a machine type that

 37519 +       only accepts a subset of the instructions

 37520 +       available to machines with higher numbers.

 37521 +       The exception is the "ca", which is

 37522 +       incompatible with all other machines except

 37523 +       "core".  */

 37524 +

 37525 +#define bfd_mach_i960_core      1

 37526 +#define bfd_mach_i960_ka_sa     2

 37527 +#define bfd_mach_i960_kb_sb     3

 37528 +#define bfd_mach_i960_mc        4

 37529 +#define bfd_mach_i960_xa        5

 37530 +#define bfd_mach_i960_ca        6

 37531 +#define bfd_mach_i960_jx        7

 37532 +#define bfd_mach_i960_hx        8

 37533 +

 37534 +  bfd_arch_or32,      /* OpenRISC 32 */

 37535 +

 37536 +  bfd_arch_sparc,     /* SPARC */

 37537 +#define bfd_mach_sparc                 1

 37538 +/* The difference between v8plus and v9 is that v9 is a true 64 bit env.  */

 37539 +#define bfd_mach_sparc_sparclet        2

 37540 +#define bfd_mach_sparc_sparclite       3

 37541 +#define bfd_mach_sparc_v8plus          4

 37542 +#define bfd_mach_sparc_v8plusa         5 /* with ultrasparc add'ns.  */

 37543 +#define bfd_mach_sparc_sparclite_le    6

 37544 +#define bfd_mach_sparc_v9              7

 37545 +#define bfd_mach_sparc_v9a             8 /* with ultrasparc add'ns.  */

 37546 +#define bfd_mach_sparc_v8plusb         9 /* with cheetah add'ns.  */

 37547 +#define bfd_mach_sparc_v9b             10 /* with cheetah add'ns.  */

 37548 +/* Nonzero if MACH has the v9 instruction set.  */

 37549 +#define bfd_mach_sparc_v9_p(mach) \

 37550 +  ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9b \

 37551 +   && (mach) != bfd_mach_sparc_sparclite_le)

 37552 +/* Nonzero if MACH is a 64 bit sparc architecture.  */

 37553 +#define bfd_mach_sparc_64bit_p(mach) \

 37554 +  ((mach) >= bfd_mach_sparc_v9 && (mach) != bfd_mach_sparc_v8plusb)

 37555 +  bfd_arch_spu,       /* PowerPC SPU */

 37556 +#define bfd_mach_spu           256

 37557 +  bfd_arch_mips,      /* MIPS Rxxxx */

 37558 +#define bfd_mach_mips3000              3000

 37559 +#define bfd_mach_mips3900              3900

 37560 +#define bfd_mach_mips4000              4000

 37561 +#define bfd_mach_mips4010              4010

 37562 +#define bfd_mach_mips4100              4100

 37563 +#define bfd_mach_mips4111              4111

 37564 +#define bfd_mach_mips4120              4120

 37565 +#define bfd_mach_mips4300              4300

 37566 +#define bfd_mach_mips4400              4400

 37567 +#define bfd_mach_mips4600              4600

 37568 +#define bfd_mach_mips4650              4650

 37569 +#define bfd_mach_mips5000              5000

 37570 +#define bfd_mach_mips5400              5400

 37571 +#define bfd_mach_mips5500              5500

 37572 +#define bfd_mach_mips6000              6000

 37573 +#define bfd_mach_mips7000              7000

 37574 +#define bfd_mach_mips8000              8000

 37575 +#define bfd_mach_mips9000              9000

 37576 +#define bfd_mach_mips10000             10000

 37577 +#define bfd_mach_mips12000             12000

 37578 +#define bfd_mach_mips16                16

 37579 +#define bfd_mach_mips5                 5

 37580 +#define bfd_mach_mips_sb1              12310201 /* octal 'SB', 01 */

 37581 +#define bfd_mach_mipsisa32             32

 37582 +#define bfd_mach_mipsisa32r2           33

 37583 +#define bfd_mach_mipsisa64             64

 37584 +#define bfd_mach_mipsisa64r2           65

 37585 +  bfd_arch_i386,      /* Intel 386 */

 37586 +#define bfd_mach_i386_i386 1

 37587 +#define bfd_mach_i386_i8086 2

 37588 +#define bfd_mach_i386_i386_intel_syntax 3

 37589 +#define bfd_mach_x86_64 64

 37590 +#define bfd_mach_x86_64_intel_syntax 65

 37591 +  bfd_arch_we32k,     /* AT&T WE32xxx */

 37592 +  bfd_arch_tahoe,     /* CCI/Harris Tahoe */

 37593 +  bfd_arch_i860,      /* Intel 860 */

 37594 +  bfd_arch_i370,      /* IBM 360/370 Mainframes */

 37595 +  bfd_arch_romp,      /* IBM ROMP PC/RT */

 37596 +  bfd_arch_convex,    /* Convex */

 37597 +  bfd_arch_m88k,      /* Motorola 88xxx */

 37598 +  bfd_arch_m98k,      /* Motorola 98xxx */

 37599 +  bfd_arch_pyramid,   /* Pyramid Technology */

 37600 +  bfd_arch_h8300,     /* Renesas H8/300 (formerly Hitachi H8/300) */

 37601 +#define bfd_mach_h8300    1

 37602 +#define bfd_mach_h8300h   2

 37603 +#define bfd_mach_h8300s   3

 37604 +#define bfd_mach_h8300hn  4

 37605 +#define bfd_mach_h8300sn  5

 37606 +#define bfd_mach_h8300sx  6

 37607 +#define bfd_mach_h8300sxn 7

 37608 +  bfd_arch_pdp11,     /* DEC PDP-11 */

 37609 +  bfd_arch_powerpc,   /* PowerPC */

 37610 +#define bfd_mach_ppc           32

 37611 +#define bfd_mach_ppc64         64

 37612 +#define bfd_mach_ppc_403       403

 37613 +#define bfd_mach_ppc_403gc     4030

 37614 +#define bfd_mach_ppc_505       505

 37615 +#define bfd_mach_ppc_601       601

 37616 +#define bfd_mach_ppc_602       602

 37617 +#define bfd_mach_ppc_603       603

 37618 +#define bfd_mach_ppc_ec603e    6031

 37619 +#define bfd_mach_ppc_604       604

 37620 +#define bfd_mach_ppc_620       620

 37621 +#define bfd_mach_ppc_630       630

 37622 +#define bfd_mach_ppc_750       750

 37623 +#define bfd_mach_ppc_860       860

 37624 +#define bfd_mach_ppc_a35       35

 37625 +#define bfd_mach_ppc_rs64ii    642

 37626 +#define bfd_mach_ppc_rs64iii   643

 37627 +#define bfd_mach_ppc_7400      7400

 37628 +#define bfd_mach_ppc_e500      500

 37629 +  bfd_arch_rs6000,    /* IBM RS/6000 */

 37630 +#define bfd_mach_rs6k          6000

 37631 +#define bfd_mach_rs6k_rs1      6001

 37632 +#define bfd_mach_rs6k_rsc      6003

 37633 +#define bfd_mach_rs6k_rs2      6002

 37634 +  bfd_arch_hppa,      /* HP PA RISC */

 37635 +#define bfd_mach_hppa10        10

 37636 +#define bfd_mach_hppa11        11

 37637 +#define bfd_mach_hppa20        20

 37638 +#define bfd_mach_hppa20w       25

 37639 +  bfd_arch_d10v,      /* Mitsubishi D10V */

 37640 +#define bfd_mach_d10v          1

 37641 +#define bfd_mach_d10v_ts2      2

 37642 +#define bfd_mach_d10v_ts3      3

 37643 +  bfd_arch_d30v,      /* Mitsubishi D30V */

 37644 +  bfd_arch_dlx,       /* DLX */

 37645 +  bfd_arch_m68hc11,   /* Motorola 68HC11 */

 37646 +  bfd_arch_m68hc12,   /* Motorola 68HC12 */

 37647 +#define bfd_mach_m6812_default 0

 37648 +#define bfd_mach_m6812         1

 37649 +#define bfd_mach_m6812s        2

 37650 +  bfd_arch_z8k,       /* Zilog Z8000 */

 37651 +#define bfd_mach_z8001         1

 37652 +#define bfd_mach_z8002         2

 37653 +  bfd_arch_h8500,     /* Renesas H8/500 (formerly Hitachi H8/500) */

 37654 +  bfd_arch_sh,        /* Renesas / SuperH SH (formerly Hitachi SH) */

 37655 +#define bfd_mach_sh            1

 37656 +#define bfd_mach_sh2        0x20

 37657 +#define bfd_mach_sh_dsp     0x2d

 37658 +#define bfd_mach_sh2a       0x2a

 37659 +#define bfd_mach_sh2a_nofpu 0x2b

 37660 +#define bfd_mach_sh2a_nofpu_or_sh4_nommu_nofpu 0x2a1

 37661 +#define bfd_mach_sh2a_nofpu_or_sh3_nommu 0x2a2

 37662 +#define bfd_mach_sh2a_or_sh4  0x2a3

 37663 +#define bfd_mach_sh2a_or_sh3e 0x2a4

 37664 +#define bfd_mach_sh2e       0x2e

 37665 +#define bfd_mach_sh3        0x30

 37666 +#define bfd_mach_sh3_nommu  0x31

 37667 +#define bfd_mach_sh3_dsp    0x3d

 37668 +#define bfd_mach_sh3e       0x3e

 37669 +#define bfd_mach_sh4        0x40

 37670 +#define bfd_mach_sh4_nofpu  0x41

 37671 +#define bfd_mach_sh4_nommu_nofpu  0x42

 37672 +#define bfd_mach_sh4a       0x4a

 37673 +#define bfd_mach_sh4a_nofpu 0x4b

 37674 +#define bfd_mach_sh4al_dsp  0x4d

 37675 +#define bfd_mach_sh5        0x50

 37676 +  bfd_arch_alpha,     /* Dec Alpha */

 37677 +#define bfd_mach_alpha_ev4  0x10

 37678 +#define bfd_mach_alpha_ev5  0x20

 37679 +#define bfd_mach_alpha_ev6  0x30

 37680 +  bfd_arch_arm,       /* Advanced Risc Machines ARM.  */

 37681 +#define bfd_mach_arm_unknown   0

 37682 +#define bfd_mach_arm_2         1

 37683 +#define bfd_mach_arm_2a        2

 37684 +#define bfd_mach_arm_3         3

 37685 +#define bfd_mach_arm_3M        4

 37686 +#define bfd_mach_arm_4         5

 37687 +#define bfd_mach_arm_4T        6

 37688 +#define bfd_mach_arm_5         7

 37689 +#define bfd_mach_arm_5T        8

 37690 +#define bfd_mach_arm_5TE       9

 37691 +#define bfd_mach_arm_XScale    10

 37692 +#define bfd_mach_arm_ep9312    11

 37693 +#define bfd_mach_arm_iWMMXt    12

 37694 +#define bfd_mach_arm_iWMMXt2   13

 37695 +  bfd_arch_ns32k,     /* National Semiconductors ns32000 */

 37696 +  bfd_arch_w65,       /* WDC 65816 */

 37697 +  bfd_arch_tic30,     /* Texas Instruments TMS320C30 */

 37698 +  bfd_arch_tic4x,     /* Texas Instruments TMS320C3X/4X */

 37699 +#define bfd_mach_tic3x         30

 37700 +#define bfd_mach_tic4x         40

 37701 +  bfd_arch_tic54x,    /* Texas Instruments TMS320C54X */

 37702 +  bfd_arch_tic80,     /* TI TMS320c80 (MVP) */

 37703 +  bfd_arch_v850,      /* NEC V850 */

 37704 +#define bfd_mach_v850          1

 37705 +#define bfd_mach_v850e         'E'

 37706 +#define bfd_mach_v850e1        '1'

 37707 +  bfd_arch_arc,       /* ARC Cores */

 37708 +#define bfd_mach_arc_5         5

 37709 +#define bfd_mach_arc_6         6

 37710 +#define bfd_mach_arc_7         7

 37711 +#define bfd_mach_arc_8         8

 37712 + bfd_arch_m32c,     /* Renesas M16C/M32C.  */

 37713 +#define bfd_mach_m16c        0x75

 37714 +#define bfd_mach_m32c        0x78

 37715 +  bfd_arch_m32r,      /* Renesas M32R (formerly Mitsubishi M32R/D) */

 37716 +#define bfd_mach_m32r          1 /* For backwards compatibility.  */

 37717 +#define bfd_mach_m32rx         'x'

 37718 +#define bfd_mach_m32r2         '2'

 37719 +  bfd_arch_mn10200,   /* Matsushita MN10200 */

 37720 +  bfd_arch_mn10300,   /* Matsushita MN10300 */

 37721 +#define bfd_mach_mn10300               300

 37722 +#define bfd_mach_am33          330

 37723 +#define bfd_mach_am33_2        332

 37724 +  bfd_arch_fr30,

 37725 +#define bfd_mach_fr30          0x46523330

 37726 +  bfd_arch_frv,

 37727 +#define bfd_mach_frv           1

 37728 +#define bfd_mach_frvsimple     2

 37729 +#define bfd_mach_fr300         300

 37730 +#define bfd_mach_fr400         400

 37731 +#define bfd_mach_fr450         450

 37732 +#define bfd_mach_frvtomcat     499     /* fr500 prototype */

 37733 +#define bfd_mach_fr500         500

 37734 +#define bfd_mach_fr550         550

 37735 +  bfd_arch_mcore,

 37736 +  bfd_arch_mep,

 37737 +#define bfd_mach_mep           1

 37738 +#define bfd_mach_mep_h1        0x6831

 37739 +  bfd_arch_ia64,      /* HP/Intel ia64 */

 37740 +#define bfd_mach_ia64_elf64    64

 37741 +#define bfd_mach_ia64_elf32    32

 37742 +  bfd_arch_ip2k,      /* Ubicom IP2K microcontrollers. */

 37743 +#define bfd_mach_ip2022        1

 37744 +#define bfd_mach_ip2022ext     2

 37745 + bfd_arch_iq2000,     /* Vitesse IQ2000.  */

 37746 +#define bfd_mach_iq2000        1

 37747 +#define bfd_mach_iq10          2

 37748 +  bfd_arch_mt,

 37749 +#define bfd_mach_ms1           1

 37750 +#define bfd_mach_mrisc2        2

 37751 +#define bfd_mach_ms2           3

 37752 +  bfd_arch_pj,

 37753 +  bfd_arch_avr,       /* Atmel AVR microcontrollers.  */

 37754 +#define bfd_mach_avr1          1

 37755 +#define bfd_mach_avr2          2

 37756 +#define bfd_mach_avr3          3

 37757 +#define bfd_mach_avr4          4

 37758 +#define bfd_mach_avr5          5

 37759 +#define bfd_mach_avr6          6

 37760 +  bfd_arch_avr32,     /* Atmel AVR32 */

 37761 +#define bfd_mach_avr32_ap      7000

 37762 +#define bfd_mach_avr32_uc      3000

 37763 +#define bfd_mach_avr32_ucr1    3001

 37764 +#define bfd_mach_avr32_ucr2    3002

 37765 +  bfd_arch_bfin,        /* ADI Blackfin */

 37766 +#define bfd_mach_bfin          1

 37767 +  bfd_arch_cr16,       /* National Semiconductor CompactRISC (ie CR16). */

 37768 +#define bfd_mach_cr16          1

 37769 +  bfd_arch_cr16c,       /* National Semiconductor CompactRISC. */

 37770 +#define bfd_mach_cr16c         1

 37771 +  bfd_arch_crx,       /*  National Semiconductor CRX.  */

 37772 +#define bfd_mach_crx           1

 37773 +  bfd_arch_cris,      /* Axis CRIS */

 37774 +#define bfd_mach_cris_v0_v10   255

 37775 +#define bfd_mach_cris_v32      32

 37776 +#define bfd_mach_cris_v10_v32  1032

 37777 +  bfd_arch_s390,      /* IBM s390 */

 37778 +#define bfd_mach_s390_31       31

 37779 +#define bfd_mach_s390_64       64

 37780 +  bfd_arch_score,     /* Sunplus score */

 37781 +  bfd_arch_openrisc,  /* OpenRISC */

 37782 +  bfd_arch_mmix,      /* Donald Knuth's educational processor.  */

 37783 +  bfd_arch_xstormy16,

 37784 +#define bfd_mach_xstormy16     1

 37785 +  bfd_arch_msp430,    /* Texas Instruments MSP430 architecture.  */

 37786 +#define bfd_mach_msp11          11

 37787 +#define bfd_mach_msp110         110

 37788 +#define bfd_mach_msp12          12

 37789 +#define bfd_mach_msp13          13

 37790 +#define bfd_mach_msp14          14

 37791 +#define bfd_mach_msp15          15

 37792 +#define bfd_mach_msp16          16

 37793 +#define bfd_mach_msp21          21

 37794 +#define bfd_mach_msp31          31

 37795 +#define bfd_mach_msp32          32

 37796 +#define bfd_mach_msp33          33

 37797 +#define bfd_mach_msp41          41

 37798 +#define bfd_mach_msp42          42

 37799 +#define bfd_mach_msp43          43

 37800 +#define bfd_mach_msp44          44

 37801 +  bfd_arch_xc16x,     /* Infineon's XC16X Series.               */

 37802 +#define bfd_mach_xc16x         1

 37803 +#define bfd_mach_xc16xl        2

 37804 +#define bfd_mach_xc16xs         3

 37805 +  bfd_arch_xtensa,    /* Tensilica's Xtensa cores.  */

 37806 +#define bfd_mach_xtensa        1

 37807 +   bfd_arch_maxq,     /* Dallas MAXQ 10/20 */

 37808 +#define bfd_mach_maxq10    10

 37809 +#define bfd_mach_maxq20    20

 37810 +  bfd_arch_z80,

 37811 +#define bfd_mach_z80strict      1 /* No undocumented opcodes.  */

 37812 +#define bfd_mach_z80            3 /* With ixl, ixh, iyl, and iyh.  */

 37813 +#define bfd_mach_z80full        7 /* All undocumented instructions.  */

 37814 +#define bfd_mach_r800           11 /* R800: successor with multiplication.  */

 37815 +  bfd_arch_last

 37816 +  };

 37817 +

 37818 +typedef struct bfd_arch_info

 37819 +{

 37820 +  int bits_per_word;

 37821 +  int bits_per_address;

 37822 +  int bits_per_byte;

 37823 +  enum bfd_architecture arch;

 37824 +  unsigned long mach;

 37825 +  const char *arch_name;

 37826 +  const char *printable_name;

 37827 +  unsigned int section_align_power;

 37828 +  /* TRUE if this is the default machine for the architecture.

 37829 +     The default arch should be the first entry for an arch so that

 37830 +     all the entries for that arch can be accessed via <<next>>.  */

 37831 +  bfd_boolean the_default;

 37832 +  const struct bfd_arch_info * (*compatible)

 37833 +    (const struct bfd_arch_info *a, const struct bfd_arch_info *b);

 37834 +

 37835 +  bfd_boolean (*scan) (const struct bfd_arch_info *, const char *);

 37836 +

 37837 +  const struct bfd_arch_info *next;

 37838 +}

 37839 +bfd_arch_info_type;

 37840 +

 37841 +const char *bfd_printable_name (bfd *abfd);

 37842 +

 37843 +const bfd_arch_info_type *bfd_scan_arch (const char *string);

 37844 +

 37845 +const char **bfd_arch_list (void);

 37846 +

 37847 +const bfd_arch_info_type *bfd_arch_get_compatible

 37848 +   (const bfd *abfd, const bfd *bbfd, bfd_boolean accept_unknowns);

 37849 +

 37850 +void bfd_set_arch_info (bfd *abfd, const bfd_arch_info_type *arg);

 37851 +

 37852 +enum bfd_architecture bfd_get_arch (bfd *abfd);

 37853 +

 37854 +unsigned long bfd_get_mach (bfd *abfd);

 37855 +

 37856 +unsigned int bfd_arch_bits_per_byte (bfd *abfd);

 37857 +

 37858 +unsigned int bfd_arch_bits_per_address (bfd *abfd);

 37859 +

 37860 +const bfd_arch_info_type *bfd_get_arch_info (bfd *abfd);

 37861 +

 37862 +const bfd_arch_info_type *bfd_lookup_arch

 37863 +   (enum bfd_architecture arch, unsigned long machine);

 37864 +

 37865 +const char *bfd_printable_arch_mach

 37866 +   (enum bfd_architecture arch, unsigned long machine);

 37867 +

 37868 +unsigned int bfd_octets_per_byte (bfd *abfd);

 37869 +

 37870 +unsigned int bfd_arch_mach_octets_per_byte

 37871 +   (enum bfd_architecture arch, unsigned long machine);

 37872 +

 37873 +/* Extracted from reloc.c.  */

 37874 +typedef enum bfd_reloc_status

 37875 +{

 37876 +  /* No errors detected.  */

 37877 +  bfd_reloc_ok,

 37878 +

 37879 +  /* The relocation was performed, but there was an overflow.  */

 37880 +  bfd_reloc_overflow,

 37881 +

 37882 +  /* The address to relocate was not within the section supplied.  */

 37883 +  bfd_reloc_outofrange,

 37884 +

 37885 +  /* Used by special functions.  */

 37886 +  bfd_reloc_continue,

 37887 +

 37888 +  /* Unsupported relocation size requested.  */

 37889 +  bfd_reloc_notsupported,

 37890 +

 37891 +  /* Unused.  */

 37892 +  bfd_reloc_other,

 37893 +

 37894 +  /* The symbol to relocate against was undefined.  */

 37895 +  bfd_reloc_undefined,

 37896 +

 37897 +  /* The relocation was performed, but may not be ok - presently

 37898 +     generated only when linking i960 coff files with i960 b.out

 37899 +     symbols.  If this type is returned, the error_message argument

 37900 +     to bfd_perform_relocation will be set.  */

 37901 +  bfd_reloc_dangerous

 37902 + }

 37903 + bfd_reloc_status_type;

 37904 +

 37905 +

 37906 +typedef struct reloc_cache_entry

 37907 +{

 37908 +  /* A pointer into the canonical table of pointers.  */

 37909 +  struct bfd_symbol **sym_ptr_ptr;

 37910 +

 37911 +  /* offset in section.  */

 37912 +  bfd_size_type address;

 37913 +

 37914 +  /* addend for relocation value.  */

 37915 +  bfd_vma addend;

 37916 +

 37917 +  /* Pointer to how to perform the required relocation.  */

 37918 +  reloc_howto_type *howto;

 37919 +

 37920 +}

 37921 +arelent;

 37922 +

 37923 +enum complain_overflow

 37924 +{

 37925 +  /* Do not complain on overflow.  */

 37926 +  complain_overflow_dont,

 37927 +

 37928 +  /* Complain if the value overflows when considered as a signed

 37929 +     number one bit larger than the field.  ie. A bitfield of N bits

 37930 +     is allowed to represent -2**n to 2**n-1.  */

 37931 +  complain_overflow_bitfield,

 37932 +

 37933 +  /* Complain if the value overflows when considered as a signed

 37934 +     number.  */

 37935 +  complain_overflow_signed,

 37936 +

 37937 +  /* Complain if the value overflows when considered as an

 37938 +     unsigned number.  */

 37939 +  complain_overflow_unsigned

 37940 +};

 37941 +

 37942 +struct reloc_howto_struct

 37943 +{

 37944 +  /*  The type field has mainly a documentary use - the back end can

 37945 +      do what it wants with it, though normally the back end's

 37946 +      external idea of what a reloc number is stored

 37947 +      in this field.  For example, a PC relative word relocation

 37948 +      in a coff environment has the type 023 - because that's

 37949 +      what the outside world calls a R_PCRWORD reloc.  */

 37950 +  unsigned int type;

 37951 +

 37952 +  /*  The value the final relocation is shifted right by.  This drops

 37953 +      unwanted data from the relocation.  */

 37954 +  unsigned int rightshift;

 37955 +

 37956 +  /*  The size of the item to be relocated.  This is *not* a

 37957 +      power-of-two measure.  To get the number of bytes operated

 37958 +      on by a type of relocation, use bfd_get_reloc_size.  */

 37959 +  int size;

 37960 +

 37961 +  /*  The number of bits in the item to be relocated.  This is used

 37962 +      when doing overflow checking.  */

 37963 +  unsigned int bitsize;

 37964 +

 37965 +  /*  Notes that the relocation is relative to the location in the

 37966 +      data section of the addend.  The relocation function will

 37967 +      subtract from the relocation value the address of the location

 37968 +      being relocated.  */

 37969 +  bfd_boolean pc_relative;

 37970 +

 37971 +  /*  The bit position of the reloc value in the destination.

 37972 +      The relocated value is left shifted by this amount.  */

 37973 +  unsigned int bitpos;

 37974 +

 37975 +  /* What type of overflow error should be checked for when

 37976 +     relocating.  */

 37977 +  enum complain_overflow complain_on_overflow;

 37978 +

 37979 +  /* If this field is non null, then the supplied function is

 37980 +     called rather than the normal function.  This allows really

 37981 +     strange relocation methods to be accommodated (e.g., i960 callj

 37982 +     instructions).  */

 37983 +  bfd_reloc_status_type (*special_function)

 37984 +    (bfd *, arelent *, struct bfd_symbol *, void *, asection *,

 37985 +     bfd *, char **);

 37986 +

 37987 +  /* The textual name of the relocation type.  */

 37988 +  char *name;

 37989 +

 37990 +  /* Some formats record a relocation addend in the section contents

 37991 +     rather than with the relocation.  For ELF formats this is the

 37992 +     distinction between USE_REL and USE_RELA (though the code checks

 37993 +     for USE_REL == 1/0).  The value of this field is TRUE if the

 37994 +     addend is recorded with the section contents; when performing a

 37995 +     partial link (ld -r) the section contents (the data) will be

 37996 +     modified.  The value of this field is FALSE if addends are

 37997 +     recorded with the relocation (in arelent.addend); when performing

 37998 +     a partial link the relocation will be modified.

 37999 +     All relocations for all ELF USE_RELA targets should set this field

 38000 +     to FALSE (values of TRUE should be looked on with suspicion).

 38001 +     However, the converse is not true: not all relocations of all ELF

 38002 +     USE_REL targets set this field to TRUE.  Why this is so is peculiar

 38003 +     to each particular target.  For relocs that aren't used in partial

 38004 +     links (e.g. GOT stuff) it doesn't matter what this is set to.  */

 38005 +  bfd_boolean partial_inplace;

 38006 +

 38007 +  /* src_mask selects the part of the instruction (or data) to be used

 38008 +     in the relocation sum.  If the target relocations don't have an

 38009 +     addend in the reloc, eg. ELF USE_REL, src_mask will normally equal

 38010 +     dst_mask to extract the addend from the section contents.  If

 38011 +     relocations do have an addend in the reloc, eg. ELF USE_RELA, this

 38012 +     field should be zero.  Non-zero values for ELF USE_RELA targets are

 38013 +     bogus as in those cases the value in the dst_mask part of the

 38014 +     section contents should be treated as garbage.  */

 38015 +  bfd_vma src_mask;

 38016 +

 38017 +  /* dst_mask selects which parts of the instruction (or data) are

 38018 +     replaced with a relocated value.  */

 38019 +  bfd_vma dst_mask;

 38020 +

 38021 +  /* When some formats create PC relative instructions, they leave

 38022 +     the value of the pc of the place being relocated in the offset

 38023 +     slot of the instruction, so that a PC relative relocation can

 38024 +     be made just by adding in an ordinary offset (e.g., sun3 a.out).

 38025 +     Some formats leave the displacement part of an instruction

 38026 +     empty (e.g., m88k bcs); this flag signals the fact.  */

 38027 +  bfd_boolean pcrel_offset;

 38028 +};

 38029 +

 38030 +#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \

 38031 +  { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC }

 38032 +#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \

 38033 +  HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \

 38034 +         NAME, FALSE, 0, 0, IN)

 38035 +

 38036 +#define EMPTY_HOWTO(C) \

 38037 +  HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \

 38038 +         NULL, FALSE, 0, 0, FALSE)

 38039 +

 38040 +#define HOWTO_PREPARE(relocation, symbol)               \

 38041 +  {                                                     \

 38042 +    if (symbol != NULL)                                 \

 38043 +      {                                                 \

 38044 +        if (bfd_is_com_section (symbol->section))       \

 38045 +          {                                             \

 38046 +            relocation = 0;                             \

 38047 +          }                                             \

 38048 +        else                                            \

 38049 +          {                                             \

 38050 +            relocation = symbol->value;                 \

 38051 +          }                                             \

 38052 +      }                                                 \

 38053 +  }

 38054 +

 38055 +unsigned int bfd_get_reloc_size (reloc_howto_type *);

 38056 +

 38057 +typedef struct relent_chain

 38058 +{

 38059 +  arelent relent;

 38060 +  struct relent_chain *next;

 38061 +}

 38062 +arelent_chain;

 38063 +

 38064 +bfd_reloc_status_type bfd_check_overflow

 38065 +   (enum complain_overflow how,

 38066 +    unsigned int bitsize,

 38067 +    unsigned int rightshift,

 38068 +    unsigned int addrsize,

 38069 +    bfd_vma relocation);

 38070 +

 38071 +bfd_reloc_status_type bfd_perform_relocation

 38072 +   (bfd *abfd,

 38073 +    arelent *reloc_entry,

 38074 +    void *data,

 38075 +    asection *input_section,

 38076 +    bfd *output_bfd,

 38077 +    char **error_message);

 38078 +

 38079 +bfd_reloc_status_type bfd_install_relocation

 38080 +   (bfd *abfd,

 38081 +    arelent *reloc_entry,

 38082 +    void *data, bfd_vma data_start,

 38083 +    asection *input_section,

 38084 +    char **error_message);

 38085 +

 38086 +enum bfd_reloc_code_real {

 38087 +  _dummy_first_bfd_reloc_code_real,

 38088 +

 38089 +

 38090 +/* Basic absolute relocations of N bits.  */

 38091 +  BFD_RELOC_64,

 38092 +  BFD_RELOC_32,

 38093 +  BFD_RELOC_26,

 38094 +  BFD_RELOC_24,

 38095 +  BFD_RELOC_16,

 38096 +  BFD_RELOC_14,

 38097 +  BFD_RELOC_8,

 38098 +

 38099 +/* PC-relative relocations.  Sometimes these are relative to the address

 38100 +of the relocation itself; sometimes they are relative to the start of

 38101 +the section containing the relocation.  It depends on the specific target.

 38102 +

 38103 +The 24-bit relocation is used in some Intel 960 configurations.  */

 38104 +  BFD_RELOC_64_PCREL,

 38105 +  BFD_RELOC_32_PCREL,

 38106 +  BFD_RELOC_24_PCREL,

 38107 +  BFD_RELOC_16_PCREL,

 38108 +  BFD_RELOC_12_PCREL,

 38109 +  BFD_RELOC_8_PCREL,

 38110 +

 38111 +/* Section relative relocations.  Some targets need this for DWARF2.  */

 38112 +  BFD_RELOC_32_SECREL,

 38113 +

 38114 +/* For ELF.  */

 38115 +  BFD_RELOC_32_GOT_PCREL,

 38116 +  BFD_RELOC_16_GOT_PCREL,

 38117 +  BFD_RELOC_8_GOT_PCREL,

 38118 +  BFD_RELOC_32_GOTOFF,

 38119 +  BFD_RELOC_16_GOTOFF,

 38120 +  BFD_RELOC_LO16_GOTOFF,

 38121 +  BFD_RELOC_HI16_GOTOFF,

 38122 +  BFD_RELOC_HI16_S_GOTOFF,

 38123 +  BFD_RELOC_8_GOTOFF,

 38124 +  BFD_RELOC_64_PLT_PCREL,

 38125 +  BFD_RELOC_32_PLT_PCREL,

 38126 +  BFD_RELOC_24_PLT_PCREL,

 38127 +  BFD_RELOC_16_PLT_PCREL,

 38128 +  BFD_RELOC_8_PLT_PCREL,

 38129 +  BFD_RELOC_64_PLTOFF,

 38130 +  BFD_RELOC_32_PLTOFF,

 38131 +  BFD_RELOC_16_PLTOFF,

 38132 +  BFD_RELOC_LO16_PLTOFF,

 38133 +  BFD_RELOC_HI16_PLTOFF,

 38134 +  BFD_RELOC_HI16_S_PLTOFF,

 38135 +  BFD_RELOC_8_PLTOFF,

 38136 +

 38137 +/* Relocations used by 68K ELF.  */

 38138 +  BFD_RELOC_68K_GLOB_DAT,

 38139 +  BFD_RELOC_68K_JMP_SLOT,

 38140 +  BFD_RELOC_68K_RELATIVE,

 38141 +

 38142 +/* Linkage-table relative.  */

 38143 +  BFD_RELOC_32_BASEREL,

 38144 +  BFD_RELOC_16_BASEREL,

 38145 +  BFD_RELOC_LO16_BASEREL,

 38146 +  BFD_RELOC_HI16_BASEREL,

 38147 +  BFD_RELOC_HI16_S_BASEREL,

 38148 +  BFD_RELOC_8_BASEREL,

 38149 +  BFD_RELOC_RVA,

 38150 +

 38151 +/* Absolute 8-bit relocation, but used to form an address like 0xFFnn.  */

 38152 +  BFD_RELOC_8_FFnn,

 38153 +

 38154 +/* These PC-relative relocations are stored as word displacements --

 38155 +i.e., byte displacements shifted right two bits.  The 30-bit word

 38156 +displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the

 38157 +SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The

 38158 +signed 16-bit displacement is used on the MIPS, and the 23-bit

 38159 +displacement is used on the Alpha.  */

 38160 +  BFD_RELOC_32_PCREL_S2,

 38161 +  BFD_RELOC_16_PCREL_S2,

 38162 +  BFD_RELOC_23_PCREL_S2,

 38163 +

 38164 +/* High 22 bits and low 10 bits of 32-bit value, placed into lower bits of

 38165 +the target word.  These are used on the SPARC.  */

 38166 +  BFD_RELOC_HI22,

 38167 +  BFD_RELOC_LO10,

 38168 +

 38169 +/* For systems that allocate a Global Pointer register, these are

 38170 +displacements off that register.  These relocation types are

 38171 +handled specially, because the value the register will have is

 38172 +decided relatively late.  */

 38173 +  BFD_RELOC_GPREL16,

 38174 +  BFD_RELOC_GPREL32,

 38175 +

 38176 +/* Reloc types used for i960/b.out.  */

 38177 +  BFD_RELOC_I960_CALLJ,

 38178 +

 38179 +/* SPARC ELF relocations.  There is probably some overlap with other

 38180 +relocation types already defined.  */

 38181 +  BFD_RELOC_NONE,

 38182 +  BFD_RELOC_SPARC_WDISP22,

 38183 +  BFD_RELOC_SPARC22,

 38184 +  BFD_RELOC_SPARC13,

 38185 +  BFD_RELOC_SPARC_GOT10,

 38186 +  BFD_RELOC_SPARC_GOT13,

 38187 +  BFD_RELOC_SPARC_GOT22,

 38188 +  BFD_RELOC_SPARC_PC10,

 38189 +  BFD_RELOC_SPARC_PC22,

 38190 +  BFD_RELOC_SPARC_WPLT30,

 38191 +  BFD_RELOC_SPARC_COPY,

 38192 +  BFD_RELOC_SPARC_GLOB_DAT,

 38193 +  BFD_RELOC_SPARC_JMP_SLOT,

 38194 +  BFD_RELOC_SPARC_RELATIVE,

 38195 +  BFD_RELOC_SPARC_UA16,

 38196 +  BFD_RELOC_SPARC_UA32,

 38197 +  BFD_RELOC_SPARC_UA64,

 38198 +

 38199 +/* I think these are specific to SPARC a.out (e.g., Sun 4).  */

 38200 +  BFD_RELOC_SPARC_BASE13,

 38201 +  BFD_RELOC_SPARC_BASE22,

 38202 +

 38203 +/* SPARC64 relocations  */

 38204 +#define BFD_RELOC_SPARC_64 BFD_RELOC_64

 38205 +  BFD_RELOC_SPARC_10,

 38206 +  BFD_RELOC_SPARC_11,

 38207 +  BFD_RELOC_SPARC_OLO10,

 38208 +  BFD_RELOC_SPARC_HH22,

 38209 +  BFD_RELOC_SPARC_HM10,

 38210 +  BFD_RELOC_SPARC_LM22,

 38211 +  BFD_RELOC_SPARC_PC_HH22,

 38212 +  BFD_RELOC_SPARC_PC_HM10,

 38213 +  BFD_RELOC_SPARC_PC_LM22,

 38214 +  BFD_RELOC_SPARC_WDISP16,

 38215 +  BFD_RELOC_SPARC_WDISP19,

 38216 +  BFD_RELOC_SPARC_7,

 38217 +  BFD_RELOC_SPARC_6,

 38218 +  BFD_RELOC_SPARC_5,

 38219 +#define BFD_RELOC_SPARC_DISP64 BFD_RELOC_64_PCREL

 38220 +  BFD_RELOC_SPARC_PLT32,

 38221 +  BFD_RELOC_SPARC_PLT64,

 38222 +  BFD_RELOC_SPARC_HIX22,

 38223 +  BFD_RELOC_SPARC_LOX10,

 38224 +  BFD_RELOC_SPARC_H44,

 38225 +  BFD_RELOC_SPARC_M44,

 38226 +  BFD_RELOC_SPARC_L44,

 38227 +  BFD_RELOC_SPARC_REGISTER,

 38228 +

 38229 +/* SPARC little endian relocation  */

 38230 +  BFD_RELOC_SPARC_REV32,

 38231 +

 38232 +/* SPARC TLS relocations  */

 38233 +  BFD_RELOC_SPARC_TLS_GD_HI22,

 38234 +  BFD_RELOC_SPARC_TLS_GD_LO10,

 38235 +  BFD_RELOC_SPARC_TLS_GD_ADD,

 38236 +  BFD_RELOC_SPARC_TLS_GD_CALL,

 38237 +  BFD_RELOC_SPARC_TLS_LDM_HI22,

 38238 +  BFD_RELOC_SPARC_TLS_LDM_LO10,

 38239 +  BFD_RELOC_SPARC_TLS_LDM_ADD,

 38240 +  BFD_RELOC_SPARC_TLS_LDM_CALL,

 38241 +  BFD_RELOC_SPARC_TLS_LDO_HIX22,

 38242 +  BFD_RELOC_SPARC_TLS_LDO_LOX10,

 38243 +  BFD_RELOC_SPARC_TLS_LDO_ADD,

 38244 +  BFD_RELOC_SPARC_TLS_IE_HI22,

 38245 +  BFD_RELOC_SPARC_TLS_IE_LO10,

 38246 +  BFD_RELOC_SPARC_TLS_IE_LD,

 38247 +  BFD_RELOC_SPARC_TLS_IE_LDX,

 38248 +  BFD_RELOC_SPARC_TLS_IE_ADD,

 38249 +  BFD_RELOC_SPARC_TLS_LE_HIX22,

 38250 +  BFD_RELOC_SPARC_TLS_LE_LOX10,

 38251 +  BFD_RELOC_SPARC_TLS_DTPMOD32,

 38252 +  BFD_RELOC_SPARC_TLS_DTPMOD64,

 38253 +  BFD_RELOC_SPARC_TLS_DTPOFF32,

 38254 +  BFD_RELOC_SPARC_TLS_DTPOFF64,

 38255 +  BFD_RELOC_SPARC_TLS_TPOFF32,

 38256 +  BFD_RELOC_SPARC_TLS_TPOFF64,

 38257 +

 38258 +/* SPU Relocations.  */

 38259 +  BFD_RELOC_SPU_IMM7,

 38260 +  BFD_RELOC_SPU_IMM8,

 38261 +  BFD_RELOC_SPU_IMM10,

 38262 +  BFD_RELOC_SPU_IMM10W,

 38263 +  BFD_RELOC_SPU_IMM16,

 38264 +  BFD_RELOC_SPU_IMM16W,

 38265 +  BFD_RELOC_SPU_IMM18,

 38266 +  BFD_RELOC_SPU_PCREL9a,

 38267 +  BFD_RELOC_SPU_PCREL9b,

 38268 +  BFD_RELOC_SPU_PCREL16,

 38269 +  BFD_RELOC_SPU_LO16,

 38270 +  BFD_RELOC_SPU_HI16,

 38271 +  BFD_RELOC_SPU_PPU32,

 38272 +  BFD_RELOC_SPU_PPU64,

 38273 +

 38274 +/* Alpha ECOFF and ELF relocations.  Some of these treat the symbol or

 38275 +"addend" in some special way.

 38276 +For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when

 38277 +writing; when reading, it will be the absolute section symbol.  The

 38278 +addend is the displacement in bytes of the "lda" instruction from

 38279 +the "ldah" instruction (which is at the address of this reloc).  */

 38280 +  BFD_RELOC_ALPHA_GPDISP_HI16,

 38281 +

 38282 +/* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as

 38283 +with GPDISP_HI16 relocs.  The addend is ignored when writing the

 38284 +relocations out, and is filled in with the file's GP value on

 38285 +reading, for convenience.  */

 38286 +  BFD_RELOC_ALPHA_GPDISP_LO16,

 38287 +

 38288 +/* The ELF GPDISP relocation is exactly the same as the GPDISP_HI16

 38289 +relocation except that there is no accompanying GPDISP_LO16

 38290 +relocation.  */

 38291 +  BFD_RELOC_ALPHA_GPDISP,

 38292 +

 38293 +/* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;

 38294 +the assembler turns it into a LDQ instruction to load the address of

 38295 +the symbol, and then fills in a register in the real instruction.

 38296 +

 38297 +The LITERAL reloc, at the LDQ instruction, refers to the .lita

 38298 +section symbol.  The addend is ignored when writing, but is filled

 38299 +in with the file's GP value on reading, for convenience, as with the

 38300 +GPDISP_LO16 reloc.

 38301 +

 38302 +The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.

 38303 +It should refer to the symbol to be referenced, as with 16_GOTOFF,

 38304 +but it generates output not based on the position within the .got

 38305 +section, but relative to the GP value chosen for the file during the

 38306 +final link stage.

 38307 +

 38308 +The LITUSE reloc, on the instruction using the loaded address, gives

 38309 +information to the linker that it might be able to use to optimize

 38310 +away some literal section references.  The symbol is ignored (read

 38311 +as the absolute section symbol), and the "addend" indicates the type

 38312 +of instruction using the register:

 38313 +1 - "memory" fmt insn

 38314 +2 - byte-manipulation (byte offset reg)

 38315 +3 - jsr (target of branch)  */

 38316 +  BFD_RELOC_ALPHA_LITERAL,

 38317 +  BFD_RELOC_ALPHA_ELF_LITERAL,

 38318 +  BFD_RELOC_ALPHA_LITUSE,

 38319 +

 38320 +/* The HINT relocation indicates a value that should be filled into the

 38321 +"hint" field of a jmp/jsr/ret instruction, for possible branch-

 38322 +prediction logic which may be provided on some processors.  */

 38323 +  BFD_RELOC_ALPHA_HINT,

 38324 +

 38325 +/* The LINKAGE relocation outputs a linkage pair in the object file,

 38326 +which is filled by the linker.  */

 38327 +  BFD_RELOC_ALPHA_LINKAGE,

 38328 +

 38329 +/* The CODEADDR relocation outputs a STO_CA in the object file,

 38330 +which is filled by the linker.  */

 38331 +  BFD_RELOC_ALPHA_CODEADDR,

 38332 +

 38333 +/* The GPREL_HI/LO relocations together form a 32-bit offset from the

 38334 +GP register.  */

 38335 +  BFD_RELOC_ALPHA_GPREL_HI16,

 38336 +  BFD_RELOC_ALPHA_GPREL_LO16,

 38337 +

 38338 +/* Like BFD_RELOC_23_PCREL_S2, except that the source and target must

 38339 +share a common GP, and the target address is adjusted for

 38340 +STO_ALPHA_STD_GPLOAD.  */

 38341 +  BFD_RELOC_ALPHA_BRSGP,

 38342 +

 38343 +/* Alpha thread-local storage relocations.  */

 38344 +  BFD_RELOC_ALPHA_TLSGD,

 38345 +  BFD_RELOC_ALPHA_TLSLDM,

 38346 +  BFD_RELOC_ALPHA_DTPMOD64,

 38347 +  BFD_RELOC_ALPHA_GOTDTPREL16,

 38348 +  BFD_RELOC_ALPHA_DTPREL64,

 38349 +  BFD_RELOC_ALPHA_DTPREL_HI16,

 38350 +  BFD_RELOC_ALPHA_DTPREL_LO16,

 38351 +  BFD_RELOC_ALPHA_DTPREL16,

 38352 +  BFD_RELOC_ALPHA_GOTTPREL16,

 38353 +  BFD_RELOC_ALPHA_TPREL64,

 38354 +  BFD_RELOC_ALPHA_TPREL_HI16,

 38355 +  BFD_RELOC_ALPHA_TPREL_LO16,

 38356 +  BFD_RELOC_ALPHA_TPREL16,

 38357 +

 38358 +/* Bits 27..2 of the relocation address shifted right 2 bits;

 38359 +simple reloc otherwise.  */

 38360 +  BFD_RELOC_MIPS_JMP,

 38361 +

 38362 +/* The MIPS16 jump instruction.  */

 38363 +  BFD_RELOC_MIPS16_JMP,

 38364 +

 38365 +/* MIPS16 GP relative reloc.  */

 38366 +  BFD_RELOC_MIPS16_GPREL,

 38367 +

 38368 +/* High 16 bits of 32-bit value; simple reloc.  */

 38369 +  BFD_RELOC_HI16,

 38370 +

 38371 +/* High 16 bits of 32-bit value but the low 16 bits will be sign

 38372 +extended and added to form the final result.  If the low 16

 38373 +bits form a negative number, we need to add one to the high value

 38374 +to compensate for the borrow when the low bits are added.  */

 38375 +  BFD_RELOC_HI16_S,

 38376 +

 38377 +/* Low 16 bits.  */

 38378 +  BFD_RELOC_LO16,

 38379 +

 38380 +/* High 16 bits of 32-bit pc-relative value  */

 38381 +  BFD_RELOC_HI16_PCREL,

 38382 +

 38383 +/* High 16 bits of 32-bit pc-relative value, adjusted  */

 38384 +  BFD_RELOC_HI16_S_PCREL,

 38385 +

 38386 +/* Low 16 bits of pc-relative value  */

 38387 +  BFD_RELOC_LO16_PCREL,

 38388 +

 38389 +/* MIPS16 high 16 bits of 32-bit value.  */

 38390 +  BFD_RELOC_MIPS16_HI16,

 38391 +

 38392 +/* MIPS16 high 16 bits of 32-bit value but the low 16 bits will be sign

 38393 +extended and added to form the final result.  If the low 16

 38394 +bits form a negative number, we need to add one to the high value

 38395 +to compensate for the borrow when the low bits are added.  */

 38396 +  BFD_RELOC_MIPS16_HI16_S,

 38397 +

 38398 +/* MIPS16 low 16 bits.  */

 38399 +  BFD_RELOC_MIPS16_LO16,

 38400 +

 38401 +/* Relocation against a MIPS literal section.  */

 38402 +  BFD_RELOC_MIPS_LITERAL,

 38403 +

 38404 +/* MIPS ELF relocations.  */

 38405 +  BFD_RELOC_MIPS_GOT16,

 38406 +  BFD_RELOC_MIPS_CALL16,

 38407 +  BFD_RELOC_MIPS_GOT_HI16,

 38408 +  BFD_RELOC_MIPS_GOT_LO16,

 38409 +  BFD_RELOC_MIPS_CALL_HI16,

 38410 +  BFD_RELOC_MIPS_CALL_LO16,

 38411 +  BFD_RELOC_MIPS_SUB,

 38412 +  BFD_RELOC_MIPS_GOT_PAGE,

 38413 +  BFD_RELOC_MIPS_GOT_OFST,

 38414 +  BFD_RELOC_MIPS_GOT_DISP,

 38415 +  BFD_RELOC_MIPS_SHIFT5,

 38416 +  BFD_RELOC_MIPS_SHIFT6,

 38417 +  BFD_RELOC_MIPS_INSERT_A,

 38418 +  BFD_RELOC_MIPS_INSERT_B,

 38419 +  BFD_RELOC_MIPS_DELETE,

 38420 +  BFD_RELOC_MIPS_HIGHEST,

 38421 +  BFD_RELOC_MIPS_HIGHER,

 38422 +  BFD_RELOC_MIPS_SCN_DISP,

 38423 +  BFD_RELOC_MIPS_REL16,

 38424 +  BFD_RELOC_MIPS_RELGOT,

 38425 +  BFD_RELOC_MIPS_JALR,

 38426 +  BFD_RELOC_MIPS_TLS_DTPMOD32,

 38427 +  BFD_RELOC_MIPS_TLS_DTPREL32,

 38428 +  BFD_RELOC_MIPS_TLS_DTPMOD64,

 38429 +  BFD_RELOC_MIPS_TLS_DTPREL64,

 38430 +  BFD_RELOC_MIPS_TLS_GD,

 38431 +  BFD_RELOC_MIPS_TLS_LDM,

 38432 +  BFD_RELOC_MIPS_TLS_DTPREL_HI16,

 38433 +  BFD_RELOC_MIPS_TLS_DTPREL_LO16,

 38434 +  BFD_RELOC_MIPS_TLS_GOTTPREL,

 38435 +  BFD_RELOC_MIPS_TLS_TPREL32,

 38436 +  BFD_RELOC_MIPS_TLS_TPREL64,

 38437 +  BFD_RELOC_MIPS_TLS_TPREL_HI16,

 38438 +  BFD_RELOC_MIPS_TLS_TPREL_LO16,

 38439 +

 38440 +

 38441 +/* MIPS ELF relocations (VxWorks extensions).  */

 38442 +  BFD_RELOC_MIPS_COPY,

 38443 +  BFD_RELOC_MIPS_JUMP_SLOT,

 38444 +

 38445 +

 38446 +/* Fujitsu Frv Relocations.  */

 38447 +  BFD_RELOC_FRV_LABEL16,

 38448 +  BFD_RELOC_FRV_LABEL24,

 38449 +  BFD_RELOC_FRV_LO16,

 38450 +  BFD_RELOC_FRV_HI16,

 38451 +  BFD_RELOC_FRV_GPREL12,

 38452 +  BFD_RELOC_FRV_GPRELU12,

 38453 +  BFD_RELOC_FRV_GPREL32,

 38454 +  BFD_RELOC_FRV_GPRELHI,

 38455 +  BFD_RELOC_FRV_GPRELLO,

 38456 +  BFD_RELOC_FRV_GOT12,

 38457 +  BFD_RELOC_FRV_GOTHI,

 38458 +  BFD_RELOC_FRV_GOTLO,

 38459 +  BFD_RELOC_FRV_FUNCDESC,

 38460 +  BFD_RELOC_FRV_FUNCDESC_GOT12,

 38461 +  BFD_RELOC_FRV_FUNCDESC_GOTHI,

 38462 +  BFD_RELOC_FRV_FUNCDESC_GOTLO,

 38463 +  BFD_RELOC_FRV_FUNCDESC_VALUE,

 38464 +  BFD_RELOC_FRV_FUNCDESC_GOTOFF12,

 38465 +  BFD_RELOC_FRV_FUNCDESC_GOTOFFHI,

 38466 +  BFD_RELOC_FRV_FUNCDESC_GOTOFFLO,

 38467 +  BFD_RELOC_FRV_GOTOFF12,

 38468 +  BFD_RELOC_FRV_GOTOFFHI,

 38469 +  BFD_RELOC_FRV_GOTOFFLO,

 38470 +  BFD_RELOC_FRV_GETTLSOFF,

 38471 +  BFD_RELOC_FRV_TLSDESC_VALUE,

 38472 +  BFD_RELOC_FRV_GOTTLSDESC12,

 38473 +  BFD_RELOC_FRV_GOTTLSDESCHI,

 38474 +  BFD_RELOC_FRV_GOTTLSDESCLO,

 38475 +  BFD_RELOC_FRV_TLSMOFF12,

 38476 +  BFD_RELOC_FRV_TLSMOFFHI,

 38477 +  BFD_RELOC_FRV_TLSMOFFLO,

 38478 +  BFD_RELOC_FRV_GOTTLSOFF12,

 38479 +  BFD_RELOC_FRV_GOTTLSOFFHI,

 38480 +  BFD_RELOC_FRV_GOTTLSOFFLO,

 38481 +  BFD_RELOC_FRV_TLSOFF,

 38482 +  BFD_RELOC_FRV_TLSDESC_RELAX,

 38483 +  BFD_RELOC_FRV_GETTLSOFF_RELAX,

 38484 +  BFD_RELOC_FRV_TLSOFF_RELAX,

 38485 +  BFD_RELOC_FRV_TLSMOFF,

 38486 +

 38487 +

 38488 +/* This is a 24bit GOT-relative reloc for the mn10300.  */

 38489 +  BFD_RELOC_MN10300_GOTOFF24,

 38490 +

 38491 +/* This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes

 38492 +in the instruction.  */

 38493 +  BFD_RELOC_MN10300_GOT32,

 38494 +

 38495 +/* This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes

 38496 +in the instruction.  */

 38497 +  BFD_RELOC_MN10300_GOT24,

 38498 +

 38499 +/* This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes

 38500 +in the instruction.  */

 38501 +  BFD_RELOC_MN10300_GOT16,

 38502 +

 38503 +/* Copy symbol at runtime.  */

 38504 +  BFD_RELOC_MN10300_COPY,

 38505 +

 38506 +/* Create GOT entry.  */

 38507 +  BFD_RELOC_MN10300_GLOB_DAT,

 38508 +

 38509 +/* Create PLT entry.  */

 38510 +  BFD_RELOC_MN10300_JMP_SLOT,

 38511 +

 38512 +/* Adjust by program base.  */

 38513 +  BFD_RELOC_MN10300_RELATIVE,

 38514 +

 38515 +

 38516 +/* i386/elf relocations  */

 38517 +  BFD_RELOC_386_GOT32,

 38518 +  BFD_RELOC_386_PLT32,

 38519 +  BFD_RELOC_386_COPY,

 38520 +  BFD_RELOC_386_GLOB_DAT,

 38521 +  BFD_RELOC_386_JUMP_SLOT,

 38522 +  BFD_RELOC_386_RELATIVE,

 38523 +  BFD_RELOC_386_GOTOFF,

 38524 +  BFD_RELOC_386_GOTPC,

 38525 +  BFD_RELOC_386_TLS_TPOFF,

 38526 +  BFD_RELOC_386_TLS_IE,

 38527 +  BFD_RELOC_386_TLS_GOTIE,

 38528 +  BFD_RELOC_386_TLS_LE,

 38529 +  BFD_RELOC_386_TLS_GD,

 38530 +  BFD_RELOC_386_TLS_LDM,

 38531 +  BFD_RELOC_386_TLS_LDO_32,

 38532 +  BFD_RELOC_386_TLS_IE_32,

 38533 +  BFD_RELOC_386_TLS_LE_32,

 38534 +  BFD_RELOC_386_TLS_DTPMOD32,

 38535 +  BFD_RELOC_386_TLS_DTPOFF32,

 38536 +  BFD_RELOC_386_TLS_TPOFF32,

 38537 +  BFD_RELOC_386_TLS_GOTDESC,

 38538 +  BFD_RELOC_386_TLS_DESC_CALL,

 38539 +  BFD_RELOC_386_TLS_DESC,

 38540 +

 38541 +/* x86-64/elf relocations  */

 38542 +  BFD_RELOC_X86_64_GOT32,

 38543 +  BFD_RELOC_X86_64_PLT32,

 38544 +  BFD_RELOC_X86_64_COPY,

 38545 +  BFD_RELOC_X86_64_GLOB_DAT,

 38546 +  BFD_RELOC_X86_64_JUMP_SLOT,

 38547 +  BFD_RELOC_X86_64_RELATIVE,

 38548 +  BFD_RELOC_X86_64_GOTPCREL,

 38549 +  BFD_RELOC_X86_64_32S,

 38550 +  BFD_RELOC_X86_64_DTPMOD64,

 38551 +  BFD_RELOC_X86_64_DTPOFF64,

 38552 +  BFD_RELOC_X86_64_TPOFF64,

 38553 +  BFD_RELOC_X86_64_TLSGD,

 38554 +  BFD_RELOC_X86_64_TLSLD,

 38555 +  BFD_RELOC_X86_64_DTPOFF32,

 38556 +  BFD_RELOC_X86_64_GOTTPOFF,

 38557 +  BFD_RELOC_X86_64_TPOFF32,

 38558 +  BFD_RELOC_X86_64_GOTOFF64,

 38559 +  BFD_RELOC_X86_64_GOTPC32,

 38560 +  BFD_RELOC_X86_64_GOT64,

 38561 +  BFD_RELOC_X86_64_GOTPCREL64,

 38562 +  BFD_RELOC_X86_64_GOTPC64,

 38563 +  BFD_RELOC_X86_64_GOTPLT64,

 38564 +  BFD_RELOC_X86_64_PLTOFF64,

 38565 +  BFD_RELOC_X86_64_GOTPC32_TLSDESC,

 38566 +  BFD_RELOC_X86_64_TLSDESC_CALL,

 38567 +  BFD_RELOC_X86_64_TLSDESC,

 38568 +

 38569 +/* ns32k relocations  */

 38570 +  BFD_RELOC_NS32K_IMM_8,

 38571 +  BFD_RELOC_NS32K_IMM_16,

 38572 +  BFD_RELOC_NS32K_IMM_32,

 38573 +  BFD_RELOC_NS32K_IMM_8_PCREL,

 38574 +  BFD_RELOC_NS32K_IMM_16_PCREL,

 38575 +  BFD_RELOC_NS32K_IMM_32_PCREL,

 38576 +  BFD_RELOC_NS32K_DISP_8,

 38577 +  BFD_RELOC_NS32K_DISP_16,

 38578 +  BFD_RELOC_NS32K_DISP_32,

 38579 +  BFD_RELOC_NS32K_DISP_8_PCREL,

 38580 +  BFD_RELOC_NS32K_DISP_16_PCREL,

 38581 +  BFD_RELOC_NS32K_DISP_32_PCREL,

 38582 +

 38583 +/* PDP11 relocations  */

 38584 +  BFD_RELOC_PDP11_DISP_8_PCREL,

 38585 +  BFD_RELOC_PDP11_DISP_6_PCREL,

 38586 +

 38587 +/* Picojava relocs.  Not all of these appear in object files.  */

 38588 +  BFD_RELOC_PJ_CODE_HI16,

 38589 +  BFD_RELOC_PJ_CODE_LO16,

 38590 +  BFD_RELOC_PJ_CODE_DIR16,

 38591 +  BFD_RELOC_PJ_CODE_DIR32,

 38592 +  BFD_RELOC_PJ_CODE_REL16,

 38593 +  BFD_RELOC_PJ_CODE_REL32,

 38594 +

 38595 +/* Power(rs6000) and PowerPC relocations.  */

 38596 +  BFD_RELOC_PPC_B26,

 38597 +  BFD_RELOC_PPC_BA26,

 38598 +  BFD_RELOC_PPC_TOC16,

 38599 +  BFD_RELOC_PPC_B16,

 38600 +  BFD_RELOC_PPC_B16_BRTAKEN,

 38601 +  BFD_RELOC_PPC_B16_BRNTAKEN,

 38602 +  BFD_RELOC_PPC_BA16,

 38603 +  BFD_RELOC_PPC_BA16_BRTAKEN,

 38604 +  BFD_RELOC_PPC_BA16_BRNTAKEN,

 38605 +  BFD_RELOC_PPC_COPY,

 38606 +  BFD_RELOC_PPC_GLOB_DAT,

 38607 +  BFD_RELOC_PPC_JMP_SLOT,

 38608 +  BFD_RELOC_PPC_RELATIVE,

 38609 +  BFD_RELOC_PPC_LOCAL24PC,

 38610 +  BFD_RELOC_PPC_EMB_NADDR32,

 38611 +  BFD_RELOC_PPC_EMB_NADDR16,

 38612 +  BFD_RELOC_PPC_EMB_NADDR16_LO,

 38613 +  BFD_RELOC_PPC_EMB_NADDR16_HI,

 38614 +  BFD_RELOC_PPC_EMB_NADDR16_HA,

 38615 +  BFD_RELOC_PPC_EMB_SDAI16,

 38616 +  BFD_RELOC_PPC_EMB_SDA2I16,

 38617 +  BFD_RELOC_PPC_EMB_SDA2REL,

 38618 +  BFD_RELOC_PPC_EMB_SDA21,

 38619 +  BFD_RELOC_PPC_EMB_MRKREF,

 38620 +  BFD_RELOC_PPC_EMB_RELSEC16,

 38621 +  BFD_RELOC_PPC_EMB_RELST_LO,

 38622 +  BFD_RELOC_PPC_EMB_RELST_HI,

 38623 +  BFD_RELOC_PPC_EMB_RELST_HA,

 38624 +  BFD_RELOC_PPC_EMB_BIT_FLD,

 38625 +  BFD_RELOC_PPC_EMB_RELSDA,

 38626 +  BFD_RELOC_PPC64_HIGHER,

 38627 +  BFD_RELOC_PPC64_HIGHER_S,

 38628 +  BFD_RELOC_PPC64_HIGHEST,

 38629 +  BFD_RELOC_PPC64_HIGHEST_S,

 38630 +  BFD_RELOC_PPC64_TOC16_LO,

 38631 +  BFD_RELOC_PPC64_TOC16_HI,

 38632 +  BFD_RELOC_PPC64_TOC16_HA,

 38633 +  BFD_RELOC_PPC64_TOC,

 38634 +  BFD_RELOC_PPC64_PLTGOT16,

 38635 +  BFD_RELOC_PPC64_PLTGOT16_LO,

 38636 +  BFD_RELOC_PPC64_PLTGOT16_HI,

 38637 +  BFD_RELOC_PPC64_PLTGOT16_HA,

 38638 +  BFD_RELOC_PPC64_ADDR16_DS,

 38639 +  BFD_RELOC_PPC64_ADDR16_LO_DS,

 38640 +  BFD_RELOC_PPC64_GOT16_DS,

 38641 +  BFD_RELOC_PPC64_GOT16_LO_DS,

 38642 +  BFD_RELOC_PPC64_PLT16_LO_DS,

 38643 +  BFD_RELOC_PPC64_SECTOFF_DS,

 38644 +  BFD_RELOC_PPC64_SECTOFF_LO_DS,

 38645 +  BFD_RELOC_PPC64_TOC16_DS,

 38646 +  BFD_RELOC_PPC64_TOC16_LO_DS,

 38647 +  BFD_RELOC_PPC64_PLTGOT16_DS,

 38648 +  BFD_RELOC_PPC64_PLTGOT16_LO_DS,

 38649 +

 38650 +/* PowerPC and PowerPC64 thread-local storage relocations.  */

 38651 +  BFD_RELOC_PPC_TLS,

 38652 +  BFD_RELOC_PPC_DTPMOD,

 38653 +  BFD_RELOC_PPC_TPREL16,

 38654 +  BFD_RELOC_PPC_TPREL16_LO,

 38655 +  BFD_RELOC_PPC_TPREL16_HI,

 38656 +  BFD_RELOC_PPC_TPREL16_HA,

 38657 +  BFD_RELOC_PPC_TPREL,

 38658 +  BFD_RELOC_PPC_DTPREL16,

 38659 +  BFD_RELOC_PPC_DTPREL16_LO,

 38660 +  BFD_RELOC_PPC_DTPREL16_HI,

 38661 +  BFD_RELOC_PPC_DTPREL16_HA,

 38662 +  BFD_RELOC_PPC_DTPREL,

 38663 +  BFD_RELOC_PPC_GOT_TLSGD16,

 38664 +  BFD_RELOC_PPC_GOT_TLSGD16_LO,

 38665 +  BFD_RELOC_PPC_GOT_TLSGD16_HI,

 38666 +  BFD_RELOC_PPC_GOT_TLSGD16_HA,

 38667 +  BFD_RELOC_PPC_GOT_TLSLD16,

 38668 +  BFD_RELOC_PPC_GOT_TLSLD16_LO,

 38669 +  BFD_RELOC_PPC_GOT_TLSLD16_HI,

 38670 +  BFD_RELOC_PPC_GOT_TLSLD16_HA,

 38671 +  BFD_RELOC_PPC_GOT_TPREL16,

 38672 +  BFD_RELOC_PPC_GOT_TPREL16_LO,

 38673 +  BFD_RELOC_PPC_GOT_TPREL16_HI,

 38674 +  BFD_RELOC_PPC_GOT_TPREL16_HA,

 38675 +  BFD_RELOC_PPC_GOT_DTPREL16,

 38676 +  BFD_RELOC_PPC_GOT_DTPREL16_LO,

 38677 +  BFD_RELOC_PPC_GOT_DTPREL16_HI,

 38678 +  BFD_RELOC_PPC_GOT_DTPREL16_HA,

 38679 +  BFD_RELOC_PPC64_TPREL16_DS,

 38680 +  BFD_RELOC_PPC64_TPREL16_LO_DS,

 38681 +  BFD_RELOC_PPC64_TPREL16_HIGHER,

 38682 +  BFD_RELOC_PPC64_TPREL16_HIGHERA,

 38683 +  BFD_RELOC_PPC64_TPREL16_HIGHEST,

 38684 +  BFD_RELOC_PPC64_TPREL16_HIGHESTA,

 38685 +  BFD_RELOC_PPC64_DTPREL16_DS,

 38686 +  BFD_RELOC_PPC64_DTPREL16_LO_DS,

 38687 +  BFD_RELOC_PPC64_DTPREL16_HIGHER,

 38688 +  BFD_RELOC_PPC64_DTPREL16_HIGHERA,

 38689 +  BFD_RELOC_PPC64_DTPREL16_HIGHEST,

 38690 +  BFD_RELOC_PPC64_DTPREL16_HIGHESTA,

 38691 +

 38692 +/* IBM 370/390 relocations  */

 38693 +  BFD_RELOC_I370_D12,

 38694 +

 38695 +/* The type of reloc used to build a constructor table - at the moment

 38696 +probably a 32 bit wide absolute relocation, but the target can choose.

 38697 +It generally does map to one of the other relocation types.  */

 38698 +  BFD_RELOC_CTOR,

 38699 +

 38700 +/* ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are

 38701 +not stored in the instruction.  */

 38702 +  BFD_RELOC_ARM_PCREL_BRANCH,

 38703 +

 38704 +/* ARM 26 bit pc-relative branch.  The lowest bit must be zero and is

 38705 +not stored in the instruction.  The 2nd lowest bit comes from a 1 bit

 38706 +field in the instruction.  */

 38707 +  BFD_RELOC_ARM_PCREL_BLX,

 38708 +

 38709 +/* Thumb 22 bit pc-relative branch.  The lowest bit must be zero and is

 38710 +not stored in the instruction.  The 2nd lowest bit comes from a 1 bit

 38711 +field in the instruction.  */

 38712 +  BFD_RELOC_THUMB_PCREL_BLX,

 38713 +

 38714 +/* ARM 26-bit pc-relative branch for an unconditional BL or BLX instruction.  */

 38715 +  BFD_RELOC_ARM_PCREL_CALL,

 38716 +

 38717 +/* ARM 26-bit pc-relative branch for B or conditional BL instruction.  */

 38718 +  BFD_RELOC_ARM_PCREL_JUMP,

 38719 +

 38720 +/* Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches.

 38721 +The lowest bit must be zero and is not stored in the instruction.

 38722 +Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an

 38723 +"nn" one smaller in all cases.  Note further that BRANCH23

 38724 +corresponds to R_ARM_THM_CALL.  */

 38725 +  BFD_RELOC_THUMB_PCREL_BRANCH7,

 38726 +  BFD_RELOC_THUMB_PCREL_BRANCH9,

 38727 +  BFD_RELOC_THUMB_PCREL_BRANCH12,

 38728 +  BFD_RELOC_THUMB_PCREL_BRANCH20,

 38729 +  BFD_RELOC_THUMB_PCREL_BRANCH23,

 38730 +  BFD_RELOC_THUMB_PCREL_BRANCH25,

 38731 +

 38732 +/* 12-bit immediate offset, used in ARM-format ldr and str instructions.  */

 38733 +  BFD_RELOC_ARM_OFFSET_IMM,

 38734 +

 38735 +/* 5-bit immediate offset, used in Thumb-format ldr and str instructions.  */

 38736 +  BFD_RELOC_ARM_THUMB_OFFSET,

 38737 +

 38738 +/* Pc-relative or absolute relocation depending on target.  Used for

 38739 +entries in .init_array sections.  */

 38740 +  BFD_RELOC_ARM_TARGET1,

 38741 +

 38742 +/* Read-only segment base relative address.  */

 38743 +  BFD_RELOC_ARM_ROSEGREL32,

 38744 +

 38745 +/* Data segment base relative address.  */

 38746 +  BFD_RELOC_ARM_SBREL32,

 38747 +

 38748 +/* This reloc is used for references to RTTI data from exception handling

 38749 +tables.  The actual definition depends on the target.  It may be a

 38750 +pc-relative or some form of GOT-indirect relocation.  */

 38751 +  BFD_RELOC_ARM_TARGET2,

 38752 +

 38753 +/* 31-bit PC relative address.  */

 38754 +  BFD_RELOC_ARM_PREL31,

 38755 +

 38756 +/* Low and High halfword relocations for MOVW and MOVT instructions.  */

 38757 +  BFD_RELOC_ARM_MOVW,

 38758 +  BFD_RELOC_ARM_MOVT,

 38759 +  BFD_RELOC_ARM_MOVW_PCREL,

 38760 +  BFD_RELOC_ARM_MOVT_PCREL,

 38761 +  BFD_RELOC_ARM_THUMB_MOVW,

 38762 +  BFD_RELOC_ARM_THUMB_MOVT,

 38763 +  BFD_RELOC_ARM_THUMB_MOVW_PCREL,

 38764 +  BFD_RELOC_ARM_THUMB_MOVT_PCREL,

 38765 +

 38766 +/* Relocations for setting up GOTs and PLTs for shared libraries.  */

 38767 +  BFD_RELOC_ARM_JUMP_SLOT,

 38768 +  BFD_RELOC_ARM_GLOB_DAT,

 38769 +  BFD_RELOC_ARM_GOT32,

 38770 +  BFD_RELOC_ARM_PLT32,

 38771 +  BFD_RELOC_ARM_RELATIVE,

 38772 +  BFD_RELOC_ARM_GOTOFF,

 38773 +  BFD_RELOC_ARM_GOTPC,

 38774 +

 38775 +/* ARM thread-local storage relocations.  */

 38776 +  BFD_RELOC_ARM_TLS_GD32,

 38777 +  BFD_RELOC_ARM_TLS_LDO32,

 38778 +  BFD_RELOC_ARM_TLS_LDM32,

 38779 +  BFD_RELOC_ARM_TLS_DTPOFF32,

 38780 +  BFD_RELOC_ARM_TLS_DTPMOD32,

 38781 +  BFD_RELOC_ARM_TLS_TPOFF32,

 38782 +  BFD_RELOC_ARM_TLS_IE32,

 38783 +  BFD_RELOC_ARM_TLS_LE32,

 38784 +

 38785 +/* ARM group relocations.  */

 38786 +  BFD_RELOC_ARM_ALU_PC_G0_NC,

 38787 +  BFD_RELOC_ARM_ALU_PC_G0,

 38788 +  BFD_RELOC_ARM_ALU_PC_G1_NC,

 38789 +  BFD_RELOC_ARM_ALU_PC_G1,

 38790 +  BFD_RELOC_ARM_ALU_PC_G2,

 38791 +  BFD_RELOC_ARM_LDR_PC_G0,

 38792 +  BFD_RELOC_ARM_LDR_PC_G1,

 38793 +  BFD_RELOC_ARM_LDR_PC_G2,

 38794 +  BFD_RELOC_ARM_LDRS_PC_G0,

 38795 +  BFD_RELOC_ARM_LDRS_PC_G1,

 38796 +  BFD_RELOC_ARM_LDRS_PC_G2,

 38797 +  BFD_RELOC_ARM_LDC_PC_G0,

 38798 +  BFD_RELOC_ARM_LDC_PC_G1,

 38799 +  BFD_RELOC_ARM_LDC_PC_G2,

 38800 +  BFD_RELOC_ARM_ALU_SB_G0_NC,

 38801 +  BFD_RELOC_ARM_ALU_SB_G0,

 38802 +  BFD_RELOC_ARM_ALU_SB_G1_NC,

 38803 +  BFD_RELOC_ARM_ALU_SB_G1,

 38804 +  BFD_RELOC_ARM_ALU_SB_G2,

 38805 +  BFD_RELOC_ARM_LDR_SB_G0,

 38806 +  BFD_RELOC_ARM_LDR_SB_G1,

 38807 +  BFD_RELOC_ARM_LDR_SB_G2,

 38808 +  BFD_RELOC_ARM_LDRS_SB_G0,

 38809 +  BFD_RELOC_ARM_LDRS_SB_G1,

 38810 +  BFD_RELOC_ARM_LDRS_SB_G2,

 38811 +  BFD_RELOC_ARM_LDC_SB_G0,

 38812 +  BFD_RELOC_ARM_LDC_SB_G1,

 38813 +  BFD_RELOC_ARM_LDC_SB_G2,

 38814 +

 38815 +/* These relocs are only used within the ARM assembler.  They are not

 38816 +(at present) written to any object files.  */

 38817 +  BFD_RELOC_ARM_IMMEDIATE,

 38818 +  BFD_RELOC_ARM_ADRL_IMMEDIATE,

 38819 +  BFD_RELOC_ARM_T32_IMMEDIATE,

 38820 +  BFD_RELOC_ARM_T32_ADD_IMM,

 38821 +  BFD_RELOC_ARM_T32_IMM12,

 38822 +  BFD_RELOC_ARM_T32_ADD_PC12,

 38823 +  BFD_RELOC_ARM_SHIFT_IMM,

 38824 +  BFD_RELOC_ARM_SMC,

 38825 +  BFD_RELOC_ARM_SWI,

 38826 +  BFD_RELOC_ARM_MULTI,

 38827 +  BFD_RELOC_ARM_CP_OFF_IMM,

 38828 +  BFD_RELOC_ARM_CP_OFF_IMM_S2,

 38829 +  BFD_RELOC_ARM_T32_CP_OFF_IMM,

 38830 +  BFD_RELOC_ARM_T32_CP_OFF_IMM_S2,

 38831 +  BFD_RELOC_ARM_ADR_IMM,

 38832 +  BFD_RELOC_ARM_LDR_IMM,

 38833 +  BFD_RELOC_ARM_LITERAL,

 38834 +  BFD_RELOC_ARM_IN_POOL,

 38835 +  BFD_RELOC_ARM_OFFSET_IMM8,

 38836 +  BFD_RELOC_ARM_T32_OFFSET_U8,

 38837 +  BFD_RELOC_ARM_T32_OFFSET_IMM,

 38838 +  BFD_RELOC_ARM_HWLITERAL,

 38839 +  BFD_RELOC_ARM_THUMB_ADD,

 38840 +  BFD_RELOC_ARM_THUMB_IMM,

 38841 +  BFD_RELOC_ARM_THUMB_SHIFT,

 38842 +

 38843 +/* Renesas / SuperH SH relocs.  Not all of these appear in object files.  */

 38844 +  BFD_RELOC_SH_PCDISP8BY2,

 38845 +  BFD_RELOC_SH_PCDISP12BY2,

 38846 +  BFD_RELOC_SH_IMM3,

 38847 +  BFD_RELOC_SH_IMM3U,

 38848 +  BFD_RELOC_SH_DISP12,

 38849 +  BFD_RELOC_SH_DISP12BY2,

 38850 +  BFD_RELOC_SH_DISP12BY4,

 38851 +  BFD_RELOC_SH_DISP12BY8,

 38852 +  BFD_RELOC_SH_DISP20,

 38853 +  BFD_RELOC_SH_DISP20BY8,

 38854 +  BFD_RELOC_SH_IMM4,

 38855 +  BFD_RELOC_SH_IMM4BY2,

 38856 +  BFD_RELOC_SH_IMM4BY4,

 38857 +  BFD_RELOC_SH_IMM8,

 38858 +  BFD_RELOC_SH_IMM8BY2,

 38859 +  BFD_RELOC_SH_IMM8BY4,

 38860 +  BFD_RELOC_SH_PCRELIMM8BY2,

 38861 +  BFD_RELOC_SH_PCRELIMM8BY4,

 38862 +  BFD_RELOC_SH_SWITCH16,

 38863 +  BFD_RELOC_SH_SWITCH32,

 38864 +  BFD_RELOC_SH_USES,

 38865 +  BFD_RELOC_SH_COUNT,

 38866 +  BFD_RELOC_SH_ALIGN,

 38867 +  BFD_RELOC_SH_CODE,

 38868 +  BFD_RELOC_SH_DATA,

 38869 +  BFD_RELOC_SH_LABEL,

 38870 +  BFD_RELOC_SH_LOOP_START,

 38871 +  BFD_RELOC_SH_LOOP_END,

 38872 +  BFD_RELOC_SH_COPY,

 38873 +  BFD_RELOC_SH_GLOB_DAT,

 38874 +  BFD_RELOC_SH_JMP_SLOT,

 38875 +  BFD_RELOC_SH_RELATIVE,

 38876 +  BFD_RELOC_SH_GOTPC,

 38877 +  BFD_RELOC_SH_GOT_LOW16,

 38878 +  BFD_RELOC_SH_GOT_MEDLOW16,

 38879 +  BFD_RELOC_SH_GOT_MEDHI16,

 38880 +  BFD_RELOC_SH_GOT_HI16,

 38881 +  BFD_RELOC_SH_GOTPLT_LOW16,

 38882 +  BFD_RELOC_SH_GOTPLT_MEDLOW16,

 38883 +  BFD_RELOC_SH_GOTPLT_MEDHI16,

 38884 +  BFD_RELOC_SH_GOTPLT_HI16,

 38885 +  BFD_RELOC_SH_PLT_LOW16,

 38886 +  BFD_RELOC_SH_PLT_MEDLOW16,

 38887 +  BFD_RELOC_SH_PLT_MEDHI16,

 38888 +  BFD_RELOC_SH_PLT_HI16,

 38889 +  BFD_RELOC_SH_GOTOFF_LOW16,

 38890 +  BFD_RELOC_SH_GOTOFF_MEDLOW16,

 38891 +  BFD_RELOC_SH_GOTOFF_MEDHI16,

 38892 +  BFD_RELOC_SH_GOTOFF_HI16,

 38893 +  BFD_RELOC_SH_GOTPC_LOW16,

 38894 +  BFD_RELOC_SH_GOTPC_MEDLOW16,

 38895 +  BFD_RELOC_SH_GOTPC_MEDHI16,

 38896 +  BFD_RELOC_SH_GOTPC_HI16,

 38897 +  BFD_RELOC_SH_COPY64,

 38898 +  BFD_RELOC_SH_GLOB_DAT64,

 38899 +  BFD_RELOC_SH_JMP_SLOT64,

 38900 +  BFD_RELOC_SH_RELATIVE64,

 38901 +  BFD_RELOC_SH_GOT10BY4,

 38902 +  BFD_RELOC_SH_GOT10BY8,

 38903 +  BFD_RELOC_SH_GOTPLT10BY4,

 38904 +  BFD_RELOC_SH_GOTPLT10BY8,

 38905 +  BFD_RELOC_SH_GOTPLT32,

 38906 +  BFD_RELOC_SH_SHMEDIA_CODE,

 38907 +  BFD_RELOC_SH_IMMU5,

 38908 +  BFD_RELOC_SH_IMMS6,

 38909 +  BFD_RELOC_SH_IMMS6BY32,

 38910 +  BFD_RELOC_SH_IMMU6,

 38911 +  BFD_RELOC_SH_IMMS10,

 38912 +  BFD_RELOC_SH_IMMS10BY2,

 38913 +  BFD_RELOC_SH_IMMS10BY4,

 38914 +  BFD_RELOC_SH_IMMS10BY8,

 38915 +  BFD_RELOC_SH_IMMS16,

 38916 +  BFD_RELOC_SH_IMMU16,

 38917 +  BFD_RELOC_SH_IMM_LOW16,

 38918 +  BFD_RELOC_SH_IMM_LOW16_PCREL,

 38919 +  BFD_RELOC_SH_IMM_MEDLOW16,

 38920 +  BFD_RELOC_SH_IMM_MEDLOW16_PCREL,

 38921 +  BFD_RELOC_SH_IMM_MEDHI16,

 38922 +  BFD_RELOC_SH_IMM_MEDHI16_PCREL,

 38923 +  BFD_RELOC_SH_IMM_HI16,

 38924 +  BFD_RELOC_SH_IMM_HI16_PCREL,

 38925 +  BFD_RELOC_SH_PT_16,

 38926 +  BFD_RELOC_SH_TLS_GD_32,

 38927 +  BFD_RELOC_SH_TLS_LD_32,

 38928 +  BFD_RELOC_SH_TLS_LDO_32,

 38929 +  BFD_RELOC_SH_TLS_IE_32,

 38930 +  BFD_RELOC_SH_TLS_LE_32,

 38931 +  BFD_RELOC_SH_TLS_DTPMOD32,

 38932 +  BFD_RELOC_SH_TLS_DTPOFF32,

 38933 +  BFD_RELOC_SH_TLS_TPOFF32,

 38934 +

 38935 +/* ARC Cores relocs.

 38936 +ARC 22 bit pc-relative branch.  The lowest two bits must be zero and are

 38937 +not stored in the instruction.  The high 20 bits are installed in bits 26

 38938 +through 7 of the instruction.  */

 38939 +  BFD_RELOC_ARC_B22_PCREL,

 38940 +

 38941 +/* ARC 26 bit absolute branch.  The lowest two bits must be zero and are not

 38942 +stored in the instruction.  The high 24 bits are installed in bits 23

 38943 +through 0.  */

 38944 +  BFD_RELOC_ARC_B26,

 38945 +

 38946 +/* ADI Blackfin 16 bit immediate absolute reloc.  */

 38947 +  BFD_RELOC_BFIN_16_IMM,

 38948 +

 38949 +/* ADI Blackfin 16 bit immediate absolute reloc higher 16 bits.  */

 38950 +  BFD_RELOC_BFIN_16_HIGH,

 38951 +

 38952 +/* ADI Blackfin 'a' part of LSETUP.  */

 38953 +  BFD_RELOC_BFIN_4_PCREL,

 38954 +

 38955 +/* ADI Blackfin.  */

 38956 +  BFD_RELOC_BFIN_5_PCREL,

 38957 +

 38958 +/* ADI Blackfin 16 bit immediate absolute reloc lower 16 bits.  */

 38959 +  BFD_RELOC_BFIN_16_LOW,

 38960 +

 38961 +/* ADI Blackfin.  */

 38962 +  BFD_RELOC_BFIN_10_PCREL,

 38963 +

 38964 +/* ADI Blackfin 'b' part of LSETUP.  */

 38965 +  BFD_RELOC_BFIN_11_PCREL,

 38966 +

 38967 +/* ADI Blackfin.  */

 38968 +  BFD_RELOC_BFIN_12_PCREL_JUMP,

 38969 +

 38970 +/* ADI Blackfin Short jump, pcrel.  */

 38971 +  BFD_RELOC_BFIN_12_PCREL_JUMP_S,

 38972 +

 38973 +/* ADI Blackfin Call.x not implemented.  */

 38974 +  BFD_RELOC_BFIN_24_PCREL_CALL_X,

 38975 +

 38976 +/* ADI Blackfin Long Jump pcrel.  */

 38977 +  BFD_RELOC_BFIN_24_PCREL_JUMP_L,

 38978 +

 38979 +/* ADI Blackfin FD-PIC relocations.  */

 38980 +  BFD_RELOC_BFIN_GOT17M4,

 38981 +  BFD_RELOC_BFIN_GOTHI,

 38982 +  BFD_RELOC_BFIN_GOTLO,

 38983 +  BFD_RELOC_BFIN_FUNCDESC,

 38984 +  BFD_RELOC_BFIN_FUNCDESC_GOT17M4,

 38985 +  BFD_RELOC_BFIN_FUNCDESC_GOTHI,

 38986 +  BFD_RELOC_BFIN_FUNCDESC_GOTLO,

 38987 +  BFD_RELOC_BFIN_FUNCDESC_VALUE,

 38988 +  BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4,

 38989 +  BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI,

 38990 +  BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO,

 38991 +  BFD_RELOC_BFIN_GOTOFF17M4,

 38992 +  BFD_RELOC_BFIN_GOTOFFHI,

 38993 +  BFD_RELOC_BFIN_GOTOFFLO,

 38994 +

 38995 +/* ADI Blackfin GOT relocation.  */

 38996 +  BFD_RELOC_BFIN_GOT,

 38997 +

 38998 +/* ADI Blackfin PLTPC relocation.  */

 38999 +  BFD_RELOC_BFIN_PLTPC,

 39000 +

 39001 +/* ADI Blackfin arithmetic relocation.  */

 39002 +  BFD_ARELOC_BFIN_PUSH,

 39003 +

 39004 +/* ADI Blackfin arithmetic relocation.  */

 39005 +  BFD_ARELOC_BFIN_CONST,

 39006 +

 39007 +/* ADI Blackfin arithmetic relocation.  */

 39008 +  BFD_ARELOC_BFIN_ADD,

 39009 +

 39010 +/* ADI Blackfin arithmetic relocation.  */

 39011 +  BFD_ARELOC_BFIN_SUB,

 39012 +

 39013 +/* ADI Blackfin arithmetic relocation.  */

 39014 +  BFD_ARELOC_BFIN_MULT,

 39015 +

 39016 +/* ADI Blackfin arithmetic relocation.  */

 39017 +  BFD_ARELOC_BFIN_DIV,

 39018 +

 39019 +/* ADI Blackfin arithmetic relocation.  */

 39020 +  BFD_ARELOC_BFIN_MOD,

 39021 +

 39022 +/* ADI Blackfin arithmetic relocation.  */

 39023 +  BFD_ARELOC_BFIN_LSHIFT,

 39024 +

 39025 +/* ADI Blackfin arithmetic relocation.  */

 39026 +  BFD_ARELOC_BFIN_RSHIFT,

 39027 +

 39028 +/* ADI Blackfin arithmetic relocation.  */

 39029 +  BFD_ARELOC_BFIN_AND,

 39030 +

 39031 +/* ADI Blackfin arithmetic relocation.  */

 39032 +  BFD_ARELOC_BFIN_OR,

 39033 +

 39034 +/* ADI Blackfin arithmetic relocation.  */

 39035 +  BFD_ARELOC_BFIN_XOR,

 39036 +

 39037 +/* ADI Blackfin arithmetic relocation.  */

 39038 +  BFD_ARELOC_BFIN_LAND,

 39039 +

 39040 +/* ADI Blackfin arithmetic relocation.  */

 39041 +  BFD_ARELOC_BFIN_LOR,

 39042 +

 39043 +/* ADI Blackfin arithmetic relocation.  */

 39044 +  BFD_ARELOC_BFIN_LEN,

 39045 +

 39046 +/* ADI Blackfin arithmetic relocation.  */

 39047 +  BFD_ARELOC_BFIN_NEG,

 39048 +

 39049 +/* ADI Blackfin arithmetic relocation.  */

 39050 +  BFD_ARELOC_BFIN_COMP,

 39051 +

 39052 +/* ADI Blackfin arithmetic relocation.  */

 39053 +  BFD_ARELOC_BFIN_PAGE,

 39054 +

 39055 +/* ADI Blackfin arithmetic relocation.  */

 39056 +  BFD_ARELOC_BFIN_HWPAGE,

 39057 +

 39058 +/* ADI Blackfin arithmetic relocation.  */

 39059 +  BFD_ARELOC_BFIN_ADDR,

 39060 +

 39061 +/* Mitsubishi D10V relocs.

 39062 +This is a 10-bit reloc with the right 2 bits

 39063 +assumed to be 0.  */

 39064 +  BFD_RELOC_D10V_10_PCREL_R,

 39065 +

 39066 +/* Mitsubishi D10V relocs.

 39067 +This is a 10-bit reloc with the right 2 bits

 39068 +assumed to be 0.  This is the same as the previous reloc

 39069 +except it is in the left container, i.e.,

 39070 +shifted left 15 bits.  */

 39071 +  BFD_RELOC_D10V_10_PCREL_L,

 39072 +

 39073 +/* This is an 18-bit reloc with the right 2 bits

 39074 +assumed to be 0.  */

 39075 +  BFD_RELOC_D10V_18,

 39076 +

 39077 +/* This is an 18-bit reloc with the right 2 bits

 39078 +assumed to be 0.  */

 39079 +  BFD_RELOC_D10V_18_PCREL,

 39080 +

 39081 +/* Mitsubishi D30V relocs.

 39082 +This is a 6-bit absolute reloc.  */

 39083 +  BFD_RELOC_D30V_6,

 39084 +

 39085 +/* This is a 6-bit pc-relative reloc with

 39086 +the right 3 bits assumed to be 0.  */

 39087 +  BFD_RELOC_D30V_9_PCREL,

 39088 +

 39089 +/* This is a 6-bit pc-relative reloc with

 39090 +the right 3 bits assumed to be 0. Same

 39091 +as the previous reloc but on the right side

 39092 +of the container.  */

 39093 +  BFD_RELOC_D30V_9_PCREL_R,

 39094 +

 39095 +/* This is a 12-bit absolute reloc with the

 39096 +right 3 bitsassumed to be 0.  */

 39097 +  BFD_RELOC_D30V_15,

 39098 +

 39099 +/* This is a 12-bit pc-relative reloc with

 39100 +the right 3 bits assumed to be 0.  */

 39101 +  BFD_RELOC_D30V_15_PCREL,

 39102 +

 39103 +/* This is a 12-bit pc-relative reloc with

 39104 +the right 3 bits assumed to be 0. Same

 39105 +as the previous reloc but on the right side

 39106 +of the container.  */

 39107 +  BFD_RELOC_D30V_15_PCREL_R,

 39108 +

 39109 +/* This is an 18-bit absolute reloc with

 39110 +the right 3 bits assumed to be 0.  */

 39111 +  BFD_RELOC_D30V_21,

 39112 +

 39113 +/* This is an 18-bit pc-relative reloc with

 39114 +the right 3 bits assumed to be 0.  */

 39115 +  BFD_RELOC_D30V_21_PCREL,

 39116 +

 39117 +/* This is an 18-bit pc-relative reloc with

 39118 +the right 3 bits assumed to be 0. Same

 39119 +as the previous reloc but on the right side

 39120 +of the container.  */

 39121 +  BFD_RELOC_D30V_21_PCREL_R,

 39122 +

 39123 +/* This is a 32-bit absolute reloc.  */

 39124 +  BFD_RELOC_D30V_32,

 39125 +

 39126 +/* This is a 32-bit pc-relative reloc.  */

 39127 +  BFD_RELOC_D30V_32_PCREL,

 39128 +

 39129 +/* DLX relocs  */

 39130 +  BFD_RELOC_DLX_HI16_S,

 39131 +

 39132 +/* DLX relocs  */

 39133 +  BFD_RELOC_DLX_LO16,

 39134 +

 39135 +/* DLX relocs  */

 39136 +  BFD_RELOC_DLX_JMP26,

 39137 +

 39138 +/* Renesas M16C/M32C Relocations.  */

 39139 +  BFD_RELOC_M32C_HI8,

 39140 +  BFD_RELOC_M32C_RL_JUMP,

 39141 +  BFD_RELOC_M32C_RL_1ADDR,

 39142 +  BFD_RELOC_M32C_RL_2ADDR,

 39143 +

 39144 +/* Renesas M32R (formerly Mitsubishi M32R) relocs.

 39145 +This is a 24 bit absolute address.  */

 39146 +  BFD_RELOC_M32R_24,

 39147 +

 39148 +/* This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.  */

 39149 +  BFD_RELOC_M32R_10_PCREL,

 39150 +

 39151 +/* This is an 18-bit reloc with the right 2 bits assumed to be 0.  */

 39152 +  BFD_RELOC_M32R_18_PCREL,

 39153 +

 39154 +/* This is a 26-bit reloc with the right 2 bits assumed to be 0.  */

 39155 +  BFD_RELOC_M32R_26_PCREL,

 39156 +

 39157 +/* This is a 16-bit reloc containing the high 16 bits of an address

 39158 +used when the lower 16 bits are treated as unsigned.  */

 39159 +  BFD_RELOC_M32R_HI16_ULO,

 39160 +

 39161 +/* This is a 16-bit reloc containing the high 16 bits of an address

 39162 +used when the lower 16 bits are treated as signed.  */

 39163 +  BFD_RELOC_M32R_HI16_SLO,

 39164 +

 39165 +/* This is a 16-bit reloc containing the lower 16 bits of an address.  */

 39166 +  BFD_RELOC_M32R_LO16,

 39167 +

 39168 +/* This is a 16-bit reloc containing the small data area offset for use in

 39169 +add3, load, and store instructions.  */

 39170 +  BFD_RELOC_M32R_SDA16,

 39171 +

 39172 +/* For PIC.  */

 39173 +  BFD_RELOC_M32R_GOT24,

 39174 +  BFD_RELOC_M32R_26_PLTREL,

 39175 +  BFD_RELOC_M32R_COPY,

 39176 +  BFD_RELOC_M32R_GLOB_DAT,

 39177 +  BFD_RELOC_M32R_JMP_SLOT,

 39178 +  BFD_RELOC_M32R_RELATIVE,

 39179 +  BFD_RELOC_M32R_GOTOFF,

 39180 +  BFD_RELOC_M32R_GOTOFF_HI_ULO,

 39181 +  BFD_RELOC_M32R_GOTOFF_HI_SLO,

 39182 +  BFD_RELOC_M32R_GOTOFF_LO,

 39183 +  BFD_RELOC_M32R_GOTPC24,

 39184 +  BFD_RELOC_M32R_GOT16_HI_ULO,

 39185 +  BFD_RELOC_M32R_GOT16_HI_SLO,

 39186 +  BFD_RELOC_M32R_GOT16_LO,

 39187 +  BFD_RELOC_M32R_GOTPC_HI_ULO,

 39188 +  BFD_RELOC_M32R_GOTPC_HI_SLO,

 39189 +  BFD_RELOC_M32R_GOTPC_LO,

 39190 +

 39191 +/* This is a 9-bit reloc  */

 39192 +  BFD_RELOC_V850_9_PCREL,

 39193 +

 39194 +/* This is a 22-bit reloc  */

 39195 +  BFD_RELOC_V850_22_PCREL,

 39196 +

 39197 +/* This is a 16 bit offset from the short data area pointer.  */

 39198 +  BFD_RELOC_V850_SDA_16_16_OFFSET,

 39199 +

 39200 +/* This is a 16 bit offset (of which only 15 bits are used) from the

 39201 +short data area pointer.  */

 39202 +  BFD_RELOC_V850_SDA_15_16_OFFSET,

 39203 +

 39204 +/* This is a 16 bit offset from the zero data area pointer.  */

 39205 +  BFD_RELOC_V850_ZDA_16_16_OFFSET,

 39206 +

 39207 +/* This is a 16 bit offset (of which only 15 bits are used) from the

 39208 +zero data area pointer.  */

 39209 +  BFD_RELOC_V850_ZDA_15_16_OFFSET,

 39210 +

 39211 +/* This is an 8 bit offset (of which only 6 bits are used) from the

 39212 +tiny data area pointer.  */

 39213 +  BFD_RELOC_V850_TDA_6_8_OFFSET,

 39214 +

 39215 +/* This is an 8bit offset (of which only 7 bits are used) from the tiny

 39216 +data area pointer.  */

 39217 +  BFD_RELOC_V850_TDA_7_8_OFFSET,

 39218 +

 39219 +/* This is a 7 bit offset from the tiny data area pointer.  */

 39220 +  BFD_RELOC_V850_TDA_7_7_OFFSET,

 39221 +

 39222 +/* This is a 16 bit offset from the tiny data area pointer.  */

 39223 +  BFD_RELOC_V850_TDA_16_16_OFFSET,

 39224 +

 39225 +/* This is a 5 bit offset (of which only 4 bits are used) from the tiny

 39226 +data area pointer.  */

 39227 +  BFD_RELOC_V850_TDA_4_5_OFFSET,

 39228 +

 39229 +/* This is a 4 bit offset from the tiny data area pointer.  */

 39230 +  BFD_RELOC_V850_TDA_4_4_OFFSET,

 39231 +

 39232 +/* This is a 16 bit offset from the short data area pointer, with the

 39233 +bits placed non-contiguously in the instruction.  */

 39234 +  BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET,

 39235 +

 39236 +/* This is a 16 bit offset from the zero data area pointer, with the

 39237 +bits placed non-contiguously in the instruction.  */

 39238 +  BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET,

 39239 +

 39240 +/* This is a 6 bit offset from the call table base pointer.  */

 39241 +  BFD_RELOC_V850_CALLT_6_7_OFFSET,

 39242 +

 39243 +/* This is a 16 bit offset from the call table base pointer.  */

 39244 +  BFD_RELOC_V850_CALLT_16_16_OFFSET,

 39245 +

 39246 +/* Used for relaxing indirect function calls.  */

 39247 +  BFD_RELOC_V850_LONGCALL,

 39248 +

 39249 +/* Used for relaxing indirect jumps.  */

 39250 +  BFD_RELOC_V850_LONGJUMP,

 39251 +

 39252 +/* Used to maintain alignment whilst relaxing.  */

 39253 +  BFD_RELOC_V850_ALIGN,

 39254 +

 39255 +/* This is a variation of BFD_RELOC_LO16 that can be used in v850e ld.bu

 39256 +instructions.  */

 39257 +  BFD_RELOC_V850_LO16_SPLIT_OFFSET,

 39258 +

 39259 +/* This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the

 39260 +instruction.  */

 39261 +  BFD_RELOC_MN10300_32_PCREL,

 39262 +

 39263 +/* This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the

 39264 +instruction.  */

 39265 +  BFD_RELOC_MN10300_16_PCREL,

 39266 +

 39267 +/* This is a 8bit DP reloc for the tms320c30, where the most

 39268 +significant 8 bits of a 24 bit word are placed into the least

 39269 +significant 8 bits of the opcode.  */

 39270 +  BFD_RELOC_TIC30_LDP,

 39271 +

 39272 +/* This is a 7bit reloc for the tms320c54x, where the least

 39273 +significant 7 bits of a 16 bit word are placed into the least

 39274 +significant 7 bits of the opcode.  */

 39275 +  BFD_RELOC_TIC54X_PARTLS7,

 39276 +

 39277 +/* This is a 9bit DP reloc for the tms320c54x, where the most

 39278 +significant 9 bits of a 16 bit word are placed into the least

 39279 +significant 9 bits of the opcode.  */

 39280 +  BFD_RELOC_TIC54X_PARTMS9,

 39281 +

 39282 +/* This is an extended address 23-bit reloc for the tms320c54x.  */

 39283 +  BFD_RELOC_TIC54X_23,

 39284 +

 39285 +/* This is a 16-bit reloc for the tms320c54x, where the least

 39286 +significant 16 bits of a 23-bit extended address are placed into

 39287 +the opcode.  */

 39288 +  BFD_RELOC_TIC54X_16_OF_23,

 39289 +

 39290 +/* This is a reloc for the tms320c54x, where the most

 39291 +significant 7 bits of a 23-bit extended address are placed into

 39292 +the opcode.  */

 39293 +  BFD_RELOC_TIC54X_MS7_OF_23,

 39294 +

 39295 +/* This is a 48 bit reloc for the FR30 that stores 32 bits.  */

 39296 +  BFD_RELOC_FR30_48,

 39297 +

 39298 +/* This is a 32 bit reloc for the FR30 that stores 20 bits split up into

 39299 +two sections.  */

 39300 +  BFD_RELOC_FR30_20,

 39301 +

 39302 +/* This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in

 39303 +4 bits.  */

 39304 +  BFD_RELOC_FR30_6_IN_4,

 39305 +

 39306 +/* This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset

 39307 +into 8 bits.  */

 39308 +  BFD_RELOC_FR30_8_IN_8,

 39309 +

 39310 +/* This is a 16 bit reloc for the FR30 that stores a 9 bit short offset

 39311 +into 8 bits.  */

 39312 +  BFD_RELOC_FR30_9_IN_8,

 39313 +

 39314 +/* This is a 16 bit reloc for the FR30 that stores a 10 bit word offset

 39315 +into 8 bits.  */

 39316 +  BFD_RELOC_FR30_10_IN_8,

 39317 +

 39318 +/* This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative

 39319 +short offset into 8 bits.  */

 39320 +  BFD_RELOC_FR30_9_PCREL,

 39321 +

 39322 +/* This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative

 39323 +short offset into 11 bits.  */

 39324 +  BFD_RELOC_FR30_12_PCREL,

 39325 +

 39326 +/* Motorola Mcore relocations.  */

 39327 +  BFD_RELOC_MCORE_PCREL_IMM8BY4,

 39328 +  BFD_RELOC_MCORE_PCREL_IMM11BY2,

 39329 +  BFD_RELOC_MCORE_PCREL_IMM4BY2,

 39330 +  BFD_RELOC_MCORE_PCREL_32,

 39331 +  BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2,

 39332 +  BFD_RELOC_MCORE_RVA,

 39333 +

 39334 +/* Toshiba Media Processor Relocations.  */

 39335 +  BFD_RELOC_MEP_8,

 39336 +  BFD_RELOC_MEP_16,

 39337 +  BFD_RELOC_MEP_32,

 39338 +  BFD_RELOC_MEP_PCREL8A2,

 39339 +  BFD_RELOC_MEP_PCREL12A2,

 39340 +  BFD_RELOC_MEP_PCREL17A2,

 39341 +  BFD_RELOC_MEP_PCREL24A2,

 39342 +  BFD_RELOC_MEP_PCABS24A2,

 39343 +  BFD_RELOC_MEP_LOW16,

 39344 +  BFD_RELOC_MEP_HI16U,

 39345 +  BFD_RELOC_MEP_HI16S,

 39346 +  BFD_RELOC_MEP_GPREL,

 39347 +  BFD_RELOC_MEP_TPREL,

 39348 +  BFD_RELOC_MEP_TPREL7,

 39349 +  BFD_RELOC_MEP_TPREL7A2,

 39350 +  BFD_RELOC_MEP_TPREL7A4,

 39351 +  BFD_RELOC_MEP_UIMM24,

 39352 +  BFD_RELOC_MEP_ADDR24A4,

 39353 +  BFD_RELOC_MEP_GNU_VTINHERIT,

 39354 +  BFD_RELOC_MEP_GNU_VTENTRY,

 39355 +

 39356 +

 39357 +/* These are relocations for the GETA instruction.  */

 39358 +  BFD_RELOC_MMIX_GETA,

 39359 +  BFD_RELOC_MMIX_GETA_1,

 39360 +  BFD_RELOC_MMIX_GETA_2,

 39361 +  BFD_RELOC_MMIX_GETA_3,

 39362 +

 39363 +/* These are relocations for a conditional branch instruction.  */

 39364 +  BFD_RELOC_MMIX_CBRANCH,

 39365 +  BFD_RELOC_MMIX_CBRANCH_J,

 39366 +  BFD_RELOC_MMIX_CBRANCH_1,

 39367 +  BFD_RELOC_MMIX_CBRANCH_2,

 39368 +  BFD_RELOC_MMIX_CBRANCH_3,

 39369 +

 39370 +/* These are relocations for the PUSHJ instruction.  */

 39371 +  BFD_RELOC_MMIX_PUSHJ,

 39372 +  BFD_RELOC_MMIX_PUSHJ_1,

 39373 +  BFD_RELOC_MMIX_PUSHJ_2,

 39374 +  BFD_RELOC_MMIX_PUSHJ_3,

 39375 +  BFD_RELOC_MMIX_PUSHJ_STUBBABLE,

 39376 +

 39377 +/* These are relocations for the JMP instruction.  */

 39378 +  BFD_RELOC_MMIX_JMP,

 39379 +  BFD_RELOC_MMIX_JMP_1,

 39380 +  BFD_RELOC_MMIX_JMP_2,

 39381 +  BFD_RELOC_MMIX_JMP_3,

 39382 +

 39383 +/* This is a relocation for a relative address as in a GETA instruction or

 39384 +a branch.  */

 39385 +  BFD_RELOC_MMIX_ADDR19,

 39386 +

 39387 +/* This is a relocation for a relative address as in a JMP instruction.  */

 39388 +  BFD_RELOC_MMIX_ADDR27,

 39389 +

 39390 +/* This is a relocation for an instruction field that may be a general

 39391 +register or a value 0..255.  */

 39392 +  BFD_RELOC_MMIX_REG_OR_BYTE,

 39393 +

 39394 +/* This is a relocation for an instruction field that may be a general

 39395 +register.  */

 39396 +  BFD_RELOC_MMIX_REG,

 39397 +

 39398 +/* This is a relocation for two instruction fields holding a register and

 39399 +an offset, the equivalent of the relocation.  */

 39400 +  BFD_RELOC_MMIX_BASE_PLUS_OFFSET,

 39401 +

 39402 +/* This relocation is an assertion that the expression is not allocated as

 39403 +a global register.  It does not modify contents.  */

 39404 +  BFD_RELOC_MMIX_LOCAL,

 39405 +

 39406 +/* This is a 16 bit reloc for the AVR that stores 8 bit pc relative

 39407 +short offset into 7 bits.  */

 39408 +  BFD_RELOC_AVR_7_PCREL,

 39409 +

 39410 +/* This is a 16 bit reloc for the AVR that stores 13 bit pc relative

 39411 +short offset into 12 bits.  */

 39412 +  BFD_RELOC_AVR_13_PCREL,

 39413 +

 39414 +/* This is a 16 bit reloc for the AVR that stores 17 bit value (usually

 39415 +program memory address) into 16 bits.  */

 39416 +  BFD_RELOC_AVR_16_PM,

 39417 +

 39418 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually

 39419 +data memory address) into 8 bit immediate value of LDI insn.  */

 39420 +  BFD_RELOC_AVR_LO8_LDI,

 39421 +

 39422 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit

 39423 +of data memory address) into 8 bit immediate value of LDI insn.  */

 39424 +  BFD_RELOC_AVR_HI8_LDI,

 39425 +

 39426 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit

 39427 +of program memory address) into 8 bit immediate value of LDI insn.  */

 39428 +  BFD_RELOC_AVR_HH8_LDI,

 39429 +

 39430 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit

 39431 +of 32 bit value) into 8 bit immediate value of LDI insn.  */

 39432 +  BFD_RELOC_AVR_MS8_LDI,

 39433 +

 39434 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value

 39435 +(usually data memory address) into 8 bit immediate value of SUBI insn.  */

 39436 +  BFD_RELOC_AVR_LO8_LDI_NEG,

 39437 +

 39438 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value

 39439 +(high 8 bit of data memory address) into 8 bit immediate value of

 39440 +SUBI insn.  */

 39441 +  BFD_RELOC_AVR_HI8_LDI_NEG,

 39442 +

 39443 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value

 39444 +(most high 8 bit of program memory address) into 8 bit immediate value

 39445 +of LDI or SUBI insn.  */

 39446 +  BFD_RELOC_AVR_HH8_LDI_NEG,

 39447 +

 39448 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value (msb

 39449 +of 32 bit value) into 8 bit immediate value of LDI insn.  */

 39450 +  BFD_RELOC_AVR_MS8_LDI_NEG,

 39451 +

 39452 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually

 39453 +command address) into 8 bit immediate value of LDI insn.  */

 39454 +  BFD_RELOC_AVR_LO8_LDI_PM,

 39455 +

 39456 +/* This is a 16 bit reloc for the AVR that stores 8 bit value

 39457 +(command address) into 8 bit immediate value of LDI insn. If the address

 39458 +is beyond the 128k boundary, the linker inserts a jump stub for this reloc

 39459 +in the lower 128k.  */

 39460 +  BFD_RELOC_AVR_LO8_LDI_GS,

 39461 +

 39462 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit

 39463 +of command address) into 8 bit immediate value of LDI insn.  */

 39464 +  BFD_RELOC_AVR_HI8_LDI_PM,

 39465 +

 39466 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit

 39467 +of command address) into 8 bit immediate value of LDI insn.  If the address

 39468 +is beyond the 128k boundary, the linker inserts a jump stub for this reloc

 39469 +below 128k.  */

 39470 +  BFD_RELOC_AVR_HI8_LDI_GS,

 39471 +

 39472 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit

 39473 +of command address) into 8 bit immediate value of LDI insn.  */

 39474 +  BFD_RELOC_AVR_HH8_LDI_PM,

 39475 +

 39476 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value

 39477 +(usually command address) into 8 bit immediate value of SUBI insn.  */

 39478 +  BFD_RELOC_AVR_LO8_LDI_PM_NEG,

 39479 +

 39480 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value

 39481 +(high 8 bit of 16 bit command address) into 8 bit immediate value

 39482 +of SUBI insn.  */

 39483 +  BFD_RELOC_AVR_HI8_LDI_PM_NEG,

 39484 +

 39485 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value

 39486 +(high 6 bit of 22 bit command address) into 8 bit immediate

 39487 +value of SUBI insn.  */

 39488 +  BFD_RELOC_AVR_HH8_LDI_PM_NEG,

 39489 +

 39490 +/* This is a 32 bit reloc for the AVR that stores 23 bit value

 39491 +into 22 bits.  */

 39492 +  BFD_RELOC_AVR_CALL,

 39493 +

 39494 +/* This is a 16 bit reloc for the AVR that stores all needed bits

 39495 +for absolute addressing with ldi with overflow check to linktime  */

 39496 +  BFD_RELOC_AVR_LDI,

 39497 +

 39498 +/* This is a 6 bit reloc for the AVR that stores offset for ldd/std

 39499 +instructions  */

 39500 +  BFD_RELOC_AVR_6,

 39501 +

 39502 +/* This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw

 39503 +instructions  */

 39504 +  BFD_RELOC_AVR_6_ADIW,

 39505 +

 39506 +/* Difference between two labels: L2 - L1. The value of L1 is encoded

 39507 +as sym + addend, while the initial difference after assembly is

 39508 +inserted into the object file by the assembler.  */

 39509 +  BFD_RELOC_AVR32_DIFF32,

 39510 +  BFD_RELOC_AVR32_DIFF16,

 39511 +  BFD_RELOC_AVR32_DIFF8,

 39512 +

 39513 +/* Reference to a symbol through the Global Offset Table. The linker

 39514 +will allocate an entry for symbol in the GOT and insert the offset

 39515 +of this entry as the relocation value.  */

 39516 +  BFD_RELOC_AVR32_GOT32,

 39517 +  BFD_RELOC_AVR32_GOT16,

 39518 +  BFD_RELOC_AVR32_GOT8,

 39519 +

 39520 +/* Normal (non-pc-relative) code relocations. Alignment and signedness

 39521 +is indicated by the suffixes. S means signed, U means unsigned. W

 39522 +means word-aligned, H means halfword-aligned, neither means

 39523 +byte-aligned (no alignment.) SUB5 is the same relocation as 16S.  */

 39524 +  BFD_RELOC_AVR32_21S,

 39525 +  BFD_RELOC_AVR32_16U,

 39526 +  BFD_RELOC_AVR32_16S,

 39527 +  BFD_RELOC_AVR32_SUB5,

 39528 +  BFD_RELOC_AVR32_8S_EXT,

 39529 +  BFD_RELOC_AVR32_8S,

 39530 +  BFD_RELOC_AVR32_15S,

 39531 +

 39532 +/* PC-relative relocations are signed if neither 'U' nor 'S' is

 39533 +specified. However, we explicitly tack on a 'B' to indicate no

 39534 +alignment, to avoid confusion with data relocs. All of these resolve

 39535 +to sym + addend - offset, except the one with 'N' (negated) suffix.

 39536 +This particular one resolves to offset - sym - addend.  */

 39537 +  BFD_RELOC_AVR32_22H_PCREL,

 39538 +  BFD_RELOC_AVR32_18W_PCREL,

 39539 +  BFD_RELOC_AVR32_16B_PCREL,

 39540 +  BFD_RELOC_AVR32_16N_PCREL,

 39541 +  BFD_RELOC_AVR32_14UW_PCREL,

 39542 +  BFD_RELOC_AVR32_11H_PCREL,

 39543 +  BFD_RELOC_AVR32_10UW_PCREL,

 39544 +  BFD_RELOC_AVR32_9H_PCREL,

 39545 +  BFD_RELOC_AVR32_9UW_PCREL,

 39546 +

 39547 +/* Subtract the link-time address of the GOT from (symbol + addend)

 39548 +and insert the result.  */

 39549 +  BFD_RELOC_AVR32_GOTPC,

 39550 +

 39551 +/* Reference to a symbol through the GOT. The linker will allocate an

 39552 +entry for symbol in the GOT and insert the offset of this entry as

 39553 +the relocation value. addend must be zero. As usual, 'S' means

 39554 +signed, 'W' means word-aligned, etc.  */

 39555 +  BFD_RELOC_AVR32_GOTCALL,

 39556 +  BFD_RELOC_AVR32_LDA_GOT,

 39557 +  BFD_RELOC_AVR32_GOT21S,

 39558 +  BFD_RELOC_AVR32_GOT18SW,

 39559 +  BFD_RELOC_AVR32_GOT16S,

 39560 +

 39561 +/* 32-bit constant pool entry. I don't think 8- and 16-bit entries make

 39562 +a whole lot of sense.  */

 39563 +  BFD_RELOC_AVR32_32_CPENT,

 39564 +

 39565 +/* Constant pool references. Some of these relocations are signed,

 39566 +others are unsigned. It doesn't really matter, since the constant

 39567 +pool always comes after the code that references it.  */

 39568 +  BFD_RELOC_AVR32_CPCALL,

 39569 +  BFD_RELOC_AVR32_16_CP,

 39570 +  BFD_RELOC_AVR32_9W_CP,

 39571 +

 39572 +/* sym must be the absolute symbol. The addend specifies the alignment

 39573 +order, e.g. if addend is 2, the linker must add padding so that the

 39574 +next address is aligned to a 4-byte boundary.  */

 39575 +  BFD_RELOC_AVR32_ALIGN,

 39576 +

 39577 +/* Code relocations that will never make it to the output file.  */

 39578 +  BFD_RELOC_AVR32_14UW,

 39579 +  BFD_RELOC_AVR32_10UW,

 39580 +  BFD_RELOC_AVR32_10SW,

 39581 +  BFD_RELOC_AVR32_STHH_W,

 39582 +  BFD_RELOC_AVR32_7UW,

 39583 +  BFD_RELOC_AVR32_6S,

 39584 +  BFD_RELOC_AVR32_6UW,

 39585 +  BFD_RELOC_AVR32_4UH,

 39586 +  BFD_RELOC_AVR32_3U,

 39587 +

 39588 +/* Direct 12 bit.  */

 39589 +  BFD_RELOC_390_12,

 39590 +

 39591 +/* 12 bit GOT offset.  */

 39592 +  BFD_RELOC_390_GOT12,

 39593 +

 39594 +/* 32 bit PC relative PLT address.  */

 39595 +  BFD_RELOC_390_PLT32,

 39596 +

 39597 +/* Copy symbol at runtime.  */

 39598 +  BFD_RELOC_390_COPY,

 39599 +

 39600 +/* Create GOT entry.  */

 39601 +  BFD_RELOC_390_GLOB_DAT,

 39602 +

 39603 +/* Create PLT entry.  */

 39604 +  BFD_RELOC_390_JMP_SLOT,

 39605 +

 39606 +/* Adjust by program base.  */

 39607 +  BFD_RELOC_390_RELATIVE,

 39608 +

 39609 +/* 32 bit PC relative offset to GOT.  */

 39610 +  BFD_RELOC_390_GOTPC,

 39611 +

 39612 +/* 16 bit GOT offset.  */

 39613 +  BFD_RELOC_390_GOT16,

 39614 +

 39615 +/* PC relative 16 bit shifted by 1.  */

 39616 +  BFD_RELOC_390_PC16DBL,

 39617 +

 39618 +/* 16 bit PC rel. PLT shifted by 1.  */

 39619 +  BFD_RELOC_390_PLT16DBL,

 39620 +

 39621 +/* PC relative 32 bit shifted by 1.  */

 39622 +  BFD_RELOC_390_PC32DBL,

 39623 +

 39624 +/* 32 bit PC rel. PLT shifted by 1.  */

 39625 +  BFD_RELOC_390_PLT32DBL,

 39626 +

 39627 +/* 32 bit PC rel. GOT shifted by 1.  */

 39628 +  BFD_RELOC_390_GOTPCDBL,

 39629 +

 39630 +/* 64 bit GOT offset.  */

 39631 +  BFD_RELOC_390_GOT64,

 39632 +

 39633 +/* 64 bit PC relative PLT address.  */

 39634 +  BFD_RELOC_390_PLT64,

 39635 +

 39636 +/* 32 bit rel. offset to GOT entry.  */

 39637 +  BFD_RELOC_390_GOTENT,

 39638 +

 39639 +/* 64 bit offset to GOT.  */

 39640 +  BFD_RELOC_390_GOTOFF64,

 39641 +

 39642 +/* 12-bit offset to symbol-entry within GOT, with PLT handling.  */

 39643 +  BFD_RELOC_390_GOTPLT12,

 39644 +

 39645 +/* 16-bit offset to symbol-entry within GOT, with PLT handling.  */

 39646 +  BFD_RELOC_390_GOTPLT16,

 39647 +

 39648 +/* 32-bit offset to symbol-entry within GOT, with PLT handling.  */

 39649 +  BFD_RELOC_390_GOTPLT32,

 39650 +

 39651 +/* 64-bit offset to symbol-entry within GOT, with PLT handling.  */

 39652 +  BFD_RELOC_390_GOTPLT64,

 39653 +

 39654 +/* 32-bit rel. offset to symbol-entry within GOT, with PLT handling.  */

 39655 +  BFD_RELOC_390_GOTPLTENT,

 39656 +

 39657 +/* 16-bit rel. offset from the GOT to a PLT entry.  */

 39658 +  BFD_RELOC_390_PLTOFF16,

 39659 +

 39660 +/* 32-bit rel. offset from the GOT to a PLT entry.  */

 39661 +  BFD_RELOC_390_PLTOFF32,

 39662 +

 39663 +/* 64-bit rel. offset from the GOT to a PLT entry.  */

 39664 +  BFD_RELOC_390_PLTOFF64,

 39665 +

 39666 +/* s390 tls relocations.  */

 39667 +  BFD_RELOC_390_TLS_LOAD,

 39668 +  BFD_RELOC_390_TLS_GDCALL,

 39669 +  BFD_RELOC_390_TLS_LDCALL,

 39670 +  BFD_RELOC_390_TLS_GD32,

 39671 +  BFD_RELOC_390_TLS_GD64,

 39672 +  BFD_RELOC_390_TLS_GOTIE12,

 39673 +  BFD_RELOC_390_TLS_GOTIE32,

 39674 +  BFD_RELOC_390_TLS_GOTIE64,

 39675 +  BFD_RELOC_390_TLS_LDM32,

 39676 +  BFD_RELOC_390_TLS_LDM64,

 39677 +  BFD_RELOC_390_TLS_IE32,

 39678 +  BFD_RELOC_390_TLS_IE64,

 39679 +  BFD_RELOC_390_TLS_IEENT,

 39680 +  BFD_RELOC_390_TLS_LE32,

 39681 +  BFD_RELOC_390_TLS_LE64,

 39682 +  BFD_RELOC_390_TLS_LDO32,

 39683 +  BFD_RELOC_390_TLS_LDO64,

 39684 +  BFD_RELOC_390_TLS_DTPMOD,

 39685 +  BFD_RELOC_390_TLS_DTPOFF,

 39686 +  BFD_RELOC_390_TLS_TPOFF,

 39687 +

 39688 +/* Long displacement extension.  */

 39689 +  BFD_RELOC_390_20,

 39690 +  BFD_RELOC_390_GOT20,

 39691 +  BFD_RELOC_390_GOTPLT20,

 39692 +  BFD_RELOC_390_TLS_GOTIE20,

 39693 +

 39694 +/* Score relocations  */

 39695 +  BFD_RELOC_SCORE_DUMMY1,

 39696 +

 39697 +/* Low 16 bit for load/store  */

 39698 +  BFD_RELOC_SCORE_GPREL15,

 39699 +

 39700 +/* This is a 24-bit reloc with the right 1 bit assumed to be 0  */

 39701 +  BFD_RELOC_SCORE_DUMMY2,

 39702 +  BFD_RELOC_SCORE_JMP,

 39703 +

 39704 +/* This is a 19-bit reloc with the right 1 bit assumed to be 0  */

 39705 +  BFD_RELOC_SCORE_BRANCH,

 39706 +

 39707 +/* This is a 11-bit reloc with the right 1 bit assumed to be 0  */

 39708 +  BFD_RELOC_SCORE16_JMP,

 39709 +

 39710 +/* This is a 8-bit reloc with the right 1 bit assumed to be 0  */

 39711 +  BFD_RELOC_SCORE16_BRANCH,

 39712 +

 39713 +/* Undocumented Score relocs  */

 39714 +  BFD_RELOC_SCORE_GOT15,

 39715 +  BFD_RELOC_SCORE_GOT_LO16,

 39716 +  BFD_RELOC_SCORE_CALL15,

 39717 +  BFD_RELOC_SCORE_DUMMY_HI16,

 39718 +

 39719 +/* Scenix IP2K - 9-bit register number / data address  */

 39720 +  BFD_RELOC_IP2K_FR9,

 39721 +

 39722 +/* Scenix IP2K - 4-bit register/data bank number  */

 39723 +  BFD_RELOC_IP2K_BANK,

 39724 +

 39725 +/* Scenix IP2K - low 13 bits of instruction word address  */

 39726 +  BFD_RELOC_IP2K_ADDR16CJP,

 39727 +

 39728 +/* Scenix IP2K - high 3 bits of instruction word address  */

 39729 +  BFD_RELOC_IP2K_PAGE3,

 39730 +

 39731 +/* Scenix IP2K - ext/low/high 8 bits of data address  */

 39732 +  BFD_RELOC_IP2K_LO8DATA,

 39733 +  BFD_RELOC_IP2K_HI8DATA,

 39734 +  BFD_RELOC_IP2K_EX8DATA,

 39735 +

 39736 +/* Scenix IP2K - low/high 8 bits of instruction word address  */

 39737 +  BFD_RELOC_IP2K_LO8INSN,

 39738 +  BFD_RELOC_IP2K_HI8INSN,

 39739 +

 39740 +/* Scenix IP2K - even/odd PC modifier to modify snb pcl.0  */

 39741 +  BFD_RELOC_IP2K_PC_SKIP,

 39742 +

 39743 +/* Scenix IP2K - 16 bit word address in text section.  */

 39744 +  BFD_RELOC_IP2K_TEXT,

 39745 +

 39746 +/* Scenix IP2K - 7-bit sp or dp offset  */

 39747 +  BFD_RELOC_IP2K_FR_OFFSET,

 39748 +

 39749 +/* Scenix VPE4K coprocessor - data/insn-space addressing  */

 39750 +  BFD_RELOC_VPE4KMATH_DATA,

 39751 +  BFD_RELOC_VPE4KMATH_INSN,

 39752 +

 39753 +/* These two relocations are used by the linker to determine which of

 39754 +the entries in a C++ virtual function table are actually used.  When

 39755 +the --gc-sections option is given, the linker will zero out the entries

 39756 +that are not used, so that the code for those functions need not be

 39757 +included in the output.

 39758 +

 39759 +VTABLE_INHERIT is a zero-space relocation used to describe to the

 39760 +linker the inheritance tree of a C++ virtual function table.  The

 39761 +relocation's symbol should be the parent class' vtable, and the

 39762 +relocation should be located at the child vtable.

 39763 +

 39764 +VTABLE_ENTRY is a zero-space relocation that describes the use of a

 39765 +virtual function table entry.  The reloc's symbol should refer to the

 39766 +table of the class mentioned in the code.  Off of that base, an offset

 39767 +describes the entry that is being used.  For Rela hosts, this offset

 39768 +is stored in the reloc's addend.  For Rel hosts, we are forced to put

 39769 +this offset in the reloc's section offset.  */

 39770 +  BFD_RELOC_VTABLE_INHERIT,

 39771 +  BFD_RELOC_VTABLE_ENTRY,

 39772 +

 39773 +/* Intel IA64 Relocations.  */

 39774 +  BFD_RELOC_IA64_IMM14,

 39775 +  BFD_RELOC_IA64_IMM22,

 39776 +  BFD_RELOC_IA64_IMM64,

 39777 +  BFD_RELOC_IA64_DIR32MSB,

 39778 +  BFD_RELOC_IA64_DIR32LSB,

 39779 +  BFD_RELOC_IA64_DIR64MSB,

 39780 +  BFD_RELOC_IA64_DIR64LSB,

 39781 +  BFD_RELOC_IA64_GPREL22,

 39782 +  BFD_RELOC_IA64_GPREL64I,

 39783 +  BFD_RELOC_IA64_GPREL32MSB,

 39784 +  BFD_RELOC_IA64_GPREL32LSB,

 39785 +  BFD_RELOC_IA64_GPREL64MSB,

 39786 +  BFD_RELOC_IA64_GPREL64LSB,

 39787 +  BFD_RELOC_IA64_LTOFF22,

 39788 +  BFD_RELOC_IA64_LTOFF64I,

 39789 +  BFD_RELOC_IA64_PLTOFF22,

 39790 +  BFD_RELOC_IA64_PLTOFF64I,

 39791 +  BFD_RELOC_IA64_PLTOFF64MSB,

 39792 +  BFD_RELOC_IA64_PLTOFF64LSB,

 39793 +  BFD_RELOC_IA64_FPTR64I,

 39794 +  BFD_RELOC_IA64_FPTR32MSB,

 39795 +  BFD_RELOC_IA64_FPTR32LSB,

 39796 +  BFD_RELOC_IA64_FPTR64MSB,

 39797 +  BFD_RELOC_IA64_FPTR64LSB,

 39798 +  BFD_RELOC_IA64_PCREL21B,

 39799 +  BFD_RELOC_IA64_PCREL21BI,

 39800 +  BFD_RELOC_IA64_PCREL21M,

 39801 +  BFD_RELOC_IA64_PCREL21F,

 39802 +  BFD_RELOC_IA64_PCREL22,

 39803 +  BFD_RELOC_IA64_PCREL60B,

 39804 +  BFD_RELOC_IA64_PCREL64I,

 39805 +  BFD_RELOC_IA64_PCREL32MSB,

 39806 +  BFD_RELOC_IA64_PCREL32LSB,

 39807 +  BFD_RELOC_IA64_PCREL64MSB,

 39808 +  BFD_RELOC_IA64_PCREL64LSB,

 39809 +  BFD_RELOC_IA64_LTOFF_FPTR22,

 39810 +  BFD_RELOC_IA64_LTOFF_FPTR64I,

 39811 +  BFD_RELOC_IA64_LTOFF_FPTR32MSB,

 39812 +  BFD_RELOC_IA64_LTOFF_FPTR32LSB,

 39813 +  BFD_RELOC_IA64_LTOFF_FPTR64MSB,

 39814 +  BFD_RELOC_IA64_LTOFF_FPTR64LSB,

 39815 +  BFD_RELOC_IA64_SEGREL32MSB,

 39816 +  BFD_RELOC_IA64_SEGREL32LSB,

 39817 +  BFD_RELOC_IA64_SEGREL64MSB,

 39818 +  BFD_RELOC_IA64_SEGREL64LSB,

 39819 +  BFD_RELOC_IA64_SECREL32MSB,

 39820 +  BFD_RELOC_IA64_SECREL32LSB,

 39821 +  BFD_RELOC_IA64_SECREL64MSB,

 39822 +  BFD_RELOC_IA64_SECREL64LSB,

 39823 +  BFD_RELOC_IA64_REL32MSB,

 39824 +  BFD_RELOC_IA64_REL32LSB,

 39825 +  BFD_RELOC_IA64_REL64MSB,

 39826 +  BFD_RELOC_IA64_REL64LSB,

 39827 +  BFD_RELOC_IA64_LTV32MSB,

 39828 +  BFD_RELOC_IA64_LTV32LSB,

 39829 +  BFD_RELOC_IA64_LTV64MSB,

 39830 +  BFD_RELOC_IA64_LTV64LSB,

 39831 +  BFD_RELOC_IA64_IPLTMSB,

 39832 +  BFD_RELOC_IA64_IPLTLSB,

 39833 +  BFD_RELOC_IA64_COPY,

 39834 +  BFD_RELOC_IA64_LTOFF22X,

 39835 +  BFD_RELOC_IA64_LDXMOV,

 39836 +  BFD_RELOC_IA64_TPREL14,

 39837 +  BFD_RELOC_IA64_TPREL22,

 39838 +  BFD_RELOC_IA64_TPREL64I,

 39839 +  BFD_RELOC_IA64_TPREL64MSB,

 39840 +  BFD_RELOC_IA64_TPREL64LSB,

 39841 +  BFD_RELOC_IA64_LTOFF_TPREL22,

 39842 +  BFD_RELOC_IA64_DTPMOD64MSB,

 39843 +  BFD_RELOC_IA64_DTPMOD64LSB,

 39844 +  BFD_RELOC_IA64_LTOFF_DTPMOD22,

 39845 +  BFD_RELOC_IA64_DTPREL14,

 39846 +  BFD_RELOC_IA64_DTPREL22,

 39847 +  BFD_RELOC_IA64_DTPREL64I,

 39848 +  BFD_RELOC_IA64_DTPREL32MSB,

 39849 +  BFD_RELOC_IA64_DTPREL32LSB,

 39850 +  BFD_RELOC_IA64_DTPREL64MSB,

 39851 +  BFD_RELOC_IA64_DTPREL64LSB,

 39852 +  BFD_RELOC_IA64_LTOFF_DTPREL22,

 39853 +

 39854 +/* Motorola 68HC11 reloc.

 39855 +This is the 8 bit high part of an absolute address.  */

 39856 +  BFD_RELOC_M68HC11_HI8,

 39857 +

 39858 +/* Motorola 68HC11 reloc.

 39859 +This is the 8 bit low part of an absolute address.  */

 39860 +  BFD_RELOC_M68HC11_LO8,

 39861 +

 39862 +/* Motorola 68HC11 reloc.

 39863 +This is the 3 bit of a value.  */

 39864 +  BFD_RELOC_M68HC11_3B,

 39865 +

 39866 +/* Motorola 68HC11 reloc.

 39867 +This reloc marks the beginning of a jump/call instruction.

 39868 +It is used for linker relaxation to correctly identify beginning

 39869 +of instruction and change some branches to use PC-relative

 39870 +addressing mode.  */

 39871 +  BFD_RELOC_M68HC11_RL_JUMP,

 39872 +

 39873 +/* Motorola 68HC11 reloc.

 39874 +This reloc marks a group of several instructions that gcc generates

 39875 +and for which the linker relaxation pass can modify and/or remove

 39876 +some of them.  */

 39877 +  BFD_RELOC_M68HC11_RL_GROUP,

 39878 +

 39879 +/* Motorola 68HC11 reloc.

 39880 +This is the 16-bit lower part of an address.  It is used for 'call'

 39881 +instruction to specify the symbol address without any special

 39882 +transformation (due to memory bank window).  */

 39883 +  BFD_RELOC_M68HC11_LO16,

 39884 +

 39885 +/* Motorola 68HC11 reloc.

 39886 +This is a 8-bit reloc that specifies the page number of an address.

 39887 +It is used by 'call' instruction to specify the page number of

 39888 +the symbol.  */

 39889 +  BFD_RELOC_M68HC11_PAGE,

 39890 +

 39891 +/* Motorola 68HC11 reloc.

 39892 +This is a 24-bit reloc that represents the address with a 16-bit

 39893 +value and a 8-bit page number.  The symbol address is transformed

 39894 +to follow the 16K memory bank of 68HC12 (seen as mapped in the window).  */

 39895 +  BFD_RELOC_M68HC11_24,

 39896 +

 39897 +/* Motorola 68HC12 reloc.

 39898 +This is the 5 bits of a value.  */

 39899 +  BFD_RELOC_M68HC12_5B,

 39900 +

 39901 +/* NS CR16C Relocations.  */

 39902 +  BFD_RELOC_16C_NUM08,

 39903 +  BFD_RELOC_16C_NUM08_C,

 39904 +  BFD_RELOC_16C_NUM16,

 39905 +  BFD_RELOC_16C_NUM16_C,

 39906 +  BFD_RELOC_16C_NUM32,

 39907 +  BFD_RELOC_16C_NUM32_C,

 39908 +  BFD_RELOC_16C_DISP04,

 39909 +  BFD_RELOC_16C_DISP04_C,

 39910 +  BFD_RELOC_16C_DISP08,

 39911 +  BFD_RELOC_16C_DISP08_C,

 39912 +  BFD_RELOC_16C_DISP16,

 39913 +  BFD_RELOC_16C_DISP16_C,

 39914 +  BFD_RELOC_16C_DISP24,

 39915 +  BFD_RELOC_16C_DISP24_C,

 39916 +  BFD_RELOC_16C_DISP24a,

 39917 +  BFD_RELOC_16C_DISP24a_C,

 39918 +  BFD_RELOC_16C_REG04,

 39919 +  BFD_RELOC_16C_REG04_C,

 39920 +  BFD_RELOC_16C_REG04a,

 39921 +  BFD_RELOC_16C_REG04a_C,

 39922 +  BFD_RELOC_16C_REG14,

 39923 +  BFD_RELOC_16C_REG14_C,

 39924 +  BFD_RELOC_16C_REG16,

 39925 +  BFD_RELOC_16C_REG16_C,

 39926 +  BFD_RELOC_16C_REG20,

 39927 +  BFD_RELOC_16C_REG20_C,

 39928 +  BFD_RELOC_16C_ABS20,

 39929 +  BFD_RELOC_16C_ABS20_C,

 39930 +  BFD_RELOC_16C_ABS24,

 39931 +  BFD_RELOC_16C_ABS24_C,

 39932 +  BFD_RELOC_16C_IMM04,

 39933 +  BFD_RELOC_16C_IMM04_C,

 39934 +  BFD_RELOC_16C_IMM16,

 39935 +  BFD_RELOC_16C_IMM16_C,

 39936 +  BFD_RELOC_16C_IMM20,

 39937 +  BFD_RELOC_16C_IMM20_C,

 39938 +  BFD_RELOC_16C_IMM24,

 39939 +  BFD_RELOC_16C_IMM24_C,

 39940 +  BFD_RELOC_16C_IMM32,

 39941 +  BFD_RELOC_16C_IMM32_C,

 39942 +

 39943 +/* NS CR16 Relocations.  */

 39944 +  BFD_RELOC_CR16_NUM8,

 39945 +  BFD_RELOC_CR16_NUM16,

 39946 +  BFD_RELOC_CR16_NUM32,

 39947 +  BFD_RELOC_CR16_NUM32a,

 39948 +  BFD_RELOC_CR16_REGREL0,

 39949 +  BFD_RELOC_CR16_REGREL4,

 39950 +  BFD_RELOC_CR16_REGREL4a,

 39951 +  BFD_RELOC_CR16_REGREL14,

 39952 +  BFD_RELOC_CR16_REGREL14a,

 39953 +  BFD_RELOC_CR16_REGREL16,

 39954 +  BFD_RELOC_CR16_REGREL20,

 39955 +  BFD_RELOC_CR16_REGREL20a,

 39956 +  BFD_RELOC_CR16_ABS20,

 39957 +  BFD_RELOC_CR16_ABS24,

 39958 +  BFD_RELOC_CR16_IMM4,

 39959 +  BFD_RELOC_CR16_IMM8,

 39960 +  BFD_RELOC_CR16_IMM16,

 39961 +  BFD_RELOC_CR16_IMM20,

 39962 +  BFD_RELOC_CR16_IMM24,

 39963 +  BFD_RELOC_CR16_IMM32,

 39964 +  BFD_RELOC_CR16_IMM32a,

 39965 +  BFD_RELOC_CR16_DISP4,

 39966 +  BFD_RELOC_CR16_DISP8,

 39967 +  BFD_RELOC_CR16_DISP16,

 39968 +  BFD_RELOC_CR16_DISP20,

 39969 +  BFD_RELOC_CR16_DISP24,

 39970 +  BFD_RELOC_CR16_DISP24a,

 39971 +

 39972 +/* NS CRX Relocations.  */

 39973 +  BFD_RELOC_CRX_REL4,

 39974 +  BFD_RELOC_CRX_REL8,

 39975 +  BFD_RELOC_CRX_REL8_CMP,

 39976 +  BFD_RELOC_CRX_REL16,

 39977 +  BFD_RELOC_CRX_REL24,

 39978 +  BFD_RELOC_CRX_REL32,

 39979 +  BFD_RELOC_CRX_REGREL12,

 39980 +  BFD_RELOC_CRX_REGREL22,

 39981 +  BFD_RELOC_CRX_REGREL28,

 39982 +  BFD_RELOC_CRX_REGREL32,

 39983 +  BFD_RELOC_CRX_ABS16,

 39984 +  BFD_RELOC_CRX_ABS32,

 39985 +  BFD_RELOC_CRX_NUM8,

 39986 +  BFD_RELOC_CRX_NUM16,

 39987 +  BFD_RELOC_CRX_NUM32,

 39988 +  BFD_RELOC_CRX_IMM16,

 39989 +  BFD_RELOC_CRX_IMM32,

 39990 +  BFD_RELOC_CRX_SWITCH8,

 39991 +  BFD_RELOC_CRX_SWITCH16,

 39992 +  BFD_RELOC_CRX_SWITCH32,

 39993 +

 39994 +/* These relocs are only used within the CRIS assembler.  They are not

 39995 +(at present) written to any object files.  */

 39996 +  BFD_RELOC_CRIS_BDISP8,

 39997 +  BFD_RELOC_CRIS_UNSIGNED_5,

 39998 +  BFD_RELOC_CRIS_SIGNED_6,

 39999 +  BFD_RELOC_CRIS_UNSIGNED_6,

 40000 +  BFD_RELOC_CRIS_SIGNED_8,

 40001 +  BFD_RELOC_CRIS_UNSIGNED_8,

 40002 +  BFD_RELOC_CRIS_SIGNED_16,

 40003 +  BFD_RELOC_CRIS_UNSIGNED_16,

 40004 +  BFD_RELOC_CRIS_LAPCQ_OFFSET,

 40005 +  BFD_RELOC_CRIS_UNSIGNED_4,

 40006 +

 40007 +/* Relocs used in ELF shared libraries for CRIS.  */

 40008 +  BFD_RELOC_CRIS_COPY,

 40009 +  BFD_RELOC_CRIS_GLOB_DAT,

 40010 +  BFD_RELOC_CRIS_JUMP_SLOT,

 40011 +  BFD_RELOC_CRIS_RELATIVE,

 40012 +

 40013 +/* 32-bit offset to symbol-entry within GOT.  */

 40014 +  BFD_RELOC_CRIS_32_GOT,

 40015 +

 40016 +/* 16-bit offset to symbol-entry within GOT.  */

 40017 +  BFD_RELOC_CRIS_16_GOT,

 40018 +

 40019 +/* 32-bit offset to symbol-entry within GOT, with PLT handling.  */

 40020 +  BFD_RELOC_CRIS_32_GOTPLT,

 40021 +

 40022 +/* 16-bit offset to symbol-entry within GOT, with PLT handling.  */

 40023 +  BFD_RELOC_CRIS_16_GOTPLT,

 40024 +

 40025 +/* 32-bit offset to symbol, relative to GOT.  */

 40026 +  BFD_RELOC_CRIS_32_GOTREL,

 40027 +

 40028 +/* 32-bit offset to symbol with PLT entry, relative to GOT.  */

 40029 +  BFD_RELOC_CRIS_32_PLT_GOTREL,

 40030 +

 40031 +/* 32-bit offset to symbol with PLT entry, relative to this relocation.  */

 40032 +  BFD_RELOC_CRIS_32_PLT_PCREL,

 40033 +

 40034 +/* Intel i860 Relocations.  */

 40035 +  BFD_RELOC_860_COPY,

 40036 +  BFD_RELOC_860_GLOB_DAT,

 40037 +  BFD_RELOC_860_JUMP_SLOT,

 40038 +  BFD_RELOC_860_RELATIVE,

 40039 +  BFD_RELOC_860_PC26,

 40040 +  BFD_RELOC_860_PLT26,

 40041 +  BFD_RELOC_860_PC16,

 40042 +  BFD_RELOC_860_LOW0,

 40043 +  BFD_RELOC_860_SPLIT0,

 40044 +  BFD_RELOC_860_LOW1,

 40045 +  BFD_RELOC_860_SPLIT1,

 40046 +  BFD_RELOC_860_LOW2,

 40047 +  BFD_RELOC_860_SPLIT2,

 40048 +  BFD_RELOC_860_LOW3,

 40049 +  BFD_RELOC_860_LOGOT0,

 40050 +  BFD_RELOC_860_SPGOT0,

 40051 +  BFD_RELOC_860_LOGOT1,

 40052 +  BFD_RELOC_860_SPGOT1,

 40053 +  BFD_RELOC_860_LOGOTOFF0,

 40054 +  BFD_RELOC_860_SPGOTOFF0,

 40055 +  BFD_RELOC_860_LOGOTOFF1,

 40056 +  BFD_RELOC_860_SPGOTOFF1,

 40057 +  BFD_RELOC_860_LOGOTOFF2,

 40058 +  BFD_RELOC_860_LOGOTOFF3,

 40059 +  BFD_RELOC_860_LOPC,

 40060 +  BFD_RELOC_860_HIGHADJ,

 40061 +  BFD_RELOC_860_HAGOT,

 40062 +  BFD_RELOC_860_HAGOTOFF,

 40063 +  BFD_RELOC_860_HAPC,

 40064 +  BFD_RELOC_860_HIGH,

 40065 +  BFD_RELOC_860_HIGOT,

 40066 +  BFD_RELOC_860_HIGOTOFF,

 40067 +

 40068 +/* OpenRISC Relocations.  */

 40069 +  BFD_RELOC_OPENRISC_ABS_26,

 40070 +  BFD_RELOC_OPENRISC_REL_26,

 40071 +

 40072 +/* H8 elf Relocations.  */

 40073 +  BFD_RELOC_H8_DIR16A8,

 40074 +  BFD_RELOC_H8_DIR16R8,

 40075 +  BFD_RELOC_H8_DIR24A8,

 40076 +  BFD_RELOC_H8_DIR24R8,

 40077 +  BFD_RELOC_H8_DIR32A16,

 40078 +

 40079 +/* Sony Xstormy16 Relocations.  */

 40080 +  BFD_RELOC_XSTORMY16_REL_12,

 40081 +  BFD_RELOC_XSTORMY16_12,

 40082 +  BFD_RELOC_XSTORMY16_24,

 40083 +  BFD_RELOC_XSTORMY16_FPTR16,

 40084 +

 40085 +/* Self-describing complex relocations.  */

 40086 +  BFD_RELOC_RELC,

 40087 +

 40088 +

 40089 +/* Infineon Relocations.  */

 40090 +  BFD_RELOC_XC16X_PAG,

 40091 +  BFD_RELOC_XC16X_POF,

 40092 +  BFD_RELOC_XC16X_SEG,

 40093 +  BFD_RELOC_XC16X_SOF,

 40094 +

 40095 +/* Relocations used by VAX ELF.  */

 40096 +  BFD_RELOC_VAX_GLOB_DAT,

 40097 +  BFD_RELOC_VAX_JMP_SLOT,

 40098 +  BFD_RELOC_VAX_RELATIVE,

 40099 +

 40100 +/* Morpho MT - 16 bit immediate relocation.  */

 40101 +  BFD_RELOC_MT_PC16,

 40102 +

 40103 +/* Morpho MT - Hi 16 bits of an address.  */

 40104 +  BFD_RELOC_MT_HI16,

 40105 +

 40106 +/* Morpho MT - Low 16 bits of an address.  */

 40107 +  BFD_RELOC_MT_LO16,

 40108 +

 40109 +/* Morpho MT - Used to tell the linker which vtable entries are used.  */

 40110 +  BFD_RELOC_MT_GNU_VTINHERIT,

 40111 +

 40112 +/* Morpho MT - Used to tell the linker which vtable entries are used.  */

 40113 +  BFD_RELOC_MT_GNU_VTENTRY,

 40114 +

 40115 +/* Morpho MT - 8 bit immediate relocation.  */

 40116 +  BFD_RELOC_MT_PCINSN8,

 40117 +

 40118 +/* msp430 specific relocation codes  */

 40119 +  BFD_RELOC_MSP430_10_PCREL,

 40120 +  BFD_RELOC_MSP430_16_PCREL,

 40121 +  BFD_RELOC_MSP430_16,

 40122 +  BFD_RELOC_MSP430_16_PCREL_BYTE,

 40123 +  BFD_RELOC_MSP430_16_BYTE,

 40124 +  BFD_RELOC_MSP430_2X_PCREL,

 40125 +  BFD_RELOC_MSP430_RL_PCREL,

 40126 +

 40127 +/* IQ2000 Relocations.  */

 40128 +  BFD_RELOC_IQ2000_OFFSET_16,

 40129 +  BFD_RELOC_IQ2000_OFFSET_21,

 40130 +  BFD_RELOC_IQ2000_UHI16,

 40131 +

 40132 +/* Special Xtensa relocation used only by PLT entries in ELF shared

 40133 +objects to indicate that the runtime linker should set the value

 40134 +to one of its own internal functions or data structures.  */

 40135 +  BFD_RELOC_XTENSA_RTLD,

 40136 +

 40137 +/* Xtensa relocations for ELF shared objects.  */

 40138 +  BFD_RELOC_XTENSA_GLOB_DAT,

 40139 +  BFD_RELOC_XTENSA_JMP_SLOT,

 40140 +  BFD_RELOC_XTENSA_RELATIVE,

 40141 +

 40142 +/* Xtensa relocation used in ELF object files for symbols that may require

 40143 +PLT entries.  Otherwise, this is just a generic 32-bit relocation.  */

 40144 +  BFD_RELOC_XTENSA_PLT,

 40145 +

 40146 +/* Xtensa relocations to mark the difference of two local symbols.

 40147 +These are only needed to support linker relaxation and can be ignored

 40148 +when not relaxing.  The field is set to the value of the difference

 40149 +assuming no relaxation.  The relocation encodes the position of the

 40150 +first symbol so the linker can determine whether to adjust the field

 40151 +value.  */

 40152 +  BFD_RELOC_XTENSA_DIFF8,

 40153 +  BFD_RELOC_XTENSA_DIFF16,

 40154 +  BFD_RELOC_XTENSA_DIFF32,

 40155 +

 40156 +/* Generic Xtensa relocations for instruction operands.  Only the slot

 40157 +number is encoded in the relocation.  The relocation applies to the

 40158 +last PC-relative immediate operand, or if there are no PC-relative

 40159 +immediates, to the last immediate operand.  */

 40160 +  BFD_RELOC_XTENSA_SLOT0_OP,

 40161 +  BFD_RELOC_XTENSA_SLOT1_OP,

 40162 +  BFD_RELOC_XTENSA_SLOT2_OP,

 40163 +  BFD_RELOC_XTENSA_SLOT3_OP,

 40164 +  BFD_RELOC_XTENSA_SLOT4_OP,

 40165 +  BFD_RELOC_XTENSA_SLOT5_OP,

 40166 +  BFD_RELOC_XTENSA_SLOT6_OP,

 40167 +  BFD_RELOC_XTENSA_SLOT7_OP,

 40168 +  BFD_RELOC_XTENSA_SLOT8_OP,

 40169 +  BFD_RELOC_XTENSA_SLOT9_OP,

 40170 +  BFD_RELOC_XTENSA_SLOT10_OP,

 40171 +  BFD_RELOC_XTENSA_SLOT11_OP,

 40172 +  BFD_RELOC_XTENSA_SLOT12_OP,

 40173 +  BFD_RELOC_XTENSA_SLOT13_OP,

 40174 +  BFD_RELOC_XTENSA_SLOT14_OP,

 40175 +

 40176 +/* Alternate Xtensa relocations.  Only the slot is encoded in the

 40177 +relocation.  The meaning of these relocations is opcode-specific.  */

 40178 +  BFD_RELOC_XTENSA_SLOT0_ALT,

 40179 +  BFD_RELOC_XTENSA_SLOT1_ALT,

 40180 +  BFD_RELOC_XTENSA_SLOT2_ALT,

 40181 +  BFD_RELOC_XTENSA_SLOT3_ALT,

 40182 +  BFD_RELOC_XTENSA_SLOT4_ALT,

 40183 +  BFD_RELOC_XTENSA_SLOT5_ALT,

 40184 +  BFD_RELOC_XTENSA_SLOT6_ALT,

 40185 +  BFD_RELOC_XTENSA_SLOT7_ALT,

 40186 +  BFD_RELOC_XTENSA_SLOT8_ALT,

 40187 +  BFD_RELOC_XTENSA_SLOT9_ALT,

 40188 +  BFD_RELOC_XTENSA_SLOT10_ALT,

 40189 +  BFD_RELOC_XTENSA_SLOT11_ALT,

 40190 +  BFD_RELOC_XTENSA_SLOT12_ALT,

 40191 +  BFD_RELOC_XTENSA_SLOT13_ALT,

 40192 +  BFD_RELOC_XTENSA_SLOT14_ALT,

 40193 +

 40194 +/* Xtensa relocations for backward compatibility.  These have all been

 40195 +replaced by BFD_RELOC_XTENSA_SLOT0_OP.  */

 40196 +  BFD_RELOC_XTENSA_OP0,

 40197 +  BFD_RELOC_XTENSA_OP1,

 40198 +  BFD_RELOC_XTENSA_OP2,

 40199 +

 40200 +/* Xtensa relocation to mark that the assembler expanded the

 40201 +instructions from an original target.  The expansion size is

 40202 +encoded in the reloc size.  */

 40203 +  BFD_RELOC_XTENSA_ASM_EXPAND,

 40204 +

 40205 +/* Xtensa relocation to mark that the linker should simplify

 40206 +assembler-expanded instructions.  This is commonly used

 40207 +internally by the linker after analysis of a

 40208 +BFD_RELOC_XTENSA_ASM_EXPAND.  */

 40209 +  BFD_RELOC_XTENSA_ASM_SIMPLIFY,

 40210 +

 40211 +/* 8 bit signed offset in (ix+d) or (iy+d).  */

 40212 +  BFD_RELOC_Z80_DISP8,

 40213 +

 40214 +/* DJNZ offset.  */

 40215 +  BFD_RELOC_Z8K_DISP7,

 40216 +

 40217 +/* CALR offset.  */

 40218 +  BFD_RELOC_Z8K_CALLR,

 40219 +

 40220 +/* 4 bit value.  */

 40221 +  BFD_RELOC_Z8K_IMM4L,

 40222 +  BFD_RELOC_UNUSED };

 40223 +typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;

 40224 +reloc_howto_type *bfd_reloc_type_lookup

 40225 +   (bfd *abfd, bfd_reloc_code_real_type code);

 40226 +reloc_howto_type *bfd_reloc_name_lookup

 40227 +   (bfd *abfd, const char *reloc_name);

 40228 +

 40229 +const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);

 40230 +

 40231 +/* Extracted from syms.c.  */

 40232 +

 40233 +typedef struct bfd_symbol

 40234 +{

 40235 +  /* A pointer to the BFD which owns the symbol. This information

 40236 +     is necessary so that a back end can work out what additional

 40237 +     information (invisible to the application writer) is carried

 40238 +     with the symbol.

 40239 +

 40240 +     This field is *almost* redundant, since you can use section->owner

 40241 +     instead, except that some symbols point to the global sections

 40242 +     bfd_{abs,com,und}_section.  This could be fixed by making

 40243 +     these globals be per-bfd (or per-target-flavor).  FIXME.  */

 40244 +  struct bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field.  */

 40245 +

 40246 +  /* The text of the symbol. The name is left alone, and not copied; the

 40247 +     application may not alter it.  */

 40248 +  const char *name;

 40249 +

 40250 +  /* The value of the symbol.  This really should be a union of a

 40251 +     numeric value with a pointer, since some flags indicate that

 40252 +     a pointer to another symbol is stored here.  */

 40253 +  symvalue value;

 40254 +

 40255 +  /* Attributes of a symbol.  */

 40256 +#define BSF_NO_FLAGS    0x00

 40257 +

 40258 +  /* The symbol has local scope; <<static>> in <<C>>. The value

 40259 +     is the offset into the section of the data.  */

 40260 +#define BSF_LOCAL      0x01

 40261 +

 40262 +  /* The symbol has global scope; initialized data in <<C>>. The

 40263 +     value is the offset into the section of the data.  */

 40264 +#define BSF_GLOBAL     0x02

 40265 +

 40266 +  /* The symbol has global scope and is exported. The value is

 40267 +     the offset into the section of the data.  */

 40268 +#define BSF_EXPORT     BSF_GLOBAL /* No real difference.  */

 40269 +

 40270 +  /* A normal C symbol would be one of:

 40271 +     <<BSF_LOCAL>>, <<BSF_FORT_COMM>>,  <<BSF_UNDEFINED>> or

 40272 +     <<BSF_GLOBAL>>.  */

 40273 +

 40274 +  /* The symbol is a debugging record. The value has an arbitrary

 40275 +     meaning, unless BSF_DEBUGGING_RELOC is also set.  */

 40276 +#define BSF_DEBUGGING  0x08

 40277 +

 40278 +  /* The symbol denotes a function entry point.  Used in ELF,

 40279 +     perhaps others someday.  */

 40280 +#define BSF_FUNCTION    0x10

 40281 +

 40282 +  /* Used by the linker.  */

 40283 +#define BSF_KEEP        0x20

 40284 +#define BSF_KEEP_G      0x40

 40285 +

 40286 +  /* A weak global symbol, overridable without warnings by

 40287 +     a regular global symbol of the same name.  */

 40288 +#define BSF_WEAK        0x80

 40289 +

 40290 +  /* This symbol was created to point to a section, e.g. ELF's

 40291 +     STT_SECTION symbols.  */

 40292 +#define BSF_SECTION_SYM 0x100

 40293 +

 40294 +  /* The symbol used to be a common symbol, but now it is

 40295 +     allocated.  */

 40296 +#define BSF_OLD_COMMON  0x200

 40297 +

 40298 +  /* The default value for common data.  */

 40299 +#define BFD_FORT_COMM_DEFAULT_VALUE 0

 40300 +

 40301 +  /* In some files the type of a symbol sometimes alters its

 40302 +     location in an output file - ie in coff a <<ISFCN>> symbol

 40303 +     which is also <<C_EXT>> symbol appears where it was

 40304 +     declared and not at the end of a section.  This bit is set

 40305 +     by the target BFD part to convey this information.  */

 40306 +#define BSF_NOT_AT_END    0x400

 40307 +

 40308 +  /* Signal that the symbol is the label of constructor section.  */

 40309 +#define BSF_CONSTRUCTOR   0x800

 40310 +

 40311 +  /* Signal that the symbol is a warning symbol.  The name is a

 40312 +     warning.  The name of the next symbol is the one to warn about;

 40313 +     if a reference is made to a symbol with the same name as the next

 40314 +     symbol, a warning is issued by the linker.  */

 40315 +#define BSF_WARNING       0x1000

 40316 +

 40317 +  /* Signal that the symbol is indirect.  This symbol is an indirect

 40318 +     pointer to the symbol with the same name as the next symbol.  */

 40319 +#define BSF_INDIRECT      0x2000

 40320 +

 40321 +  /* BSF_FILE marks symbols that contain a file name.  This is used

 40322 +     for ELF STT_FILE symbols.  */

 40323 +#define BSF_FILE          0x4000

 40324 +

 40325 +  /* Symbol is from dynamic linking information.  */

 40326 +#define BSF_DYNAMIC       0x8000

 40327 +

 40328 +  /* The symbol denotes a data object.  Used in ELF, and perhaps

 40329 +     others someday.  */

 40330 +#define BSF_OBJECT        0x10000

 40331 +

 40332 +  /* This symbol is a debugging symbol.  The value is the offset

 40333 +     into the section of the data.  BSF_DEBUGGING should be set

 40334 +     as well.  */

 40335 +#define BSF_DEBUGGING_RELOC 0x20000

 40336 +

 40337 +  /* This symbol is thread local.  Used in ELF.  */

 40338 +#define BSF_THREAD_LOCAL  0x40000

 40339 +

 40340 +  /* This symbol represents a complex relocation expression,

 40341 +     with the expression tree serialized in the symbol name.  */

 40342 +#define BSF_RELC 0x80000

 40343 +

 40344 +  /* This symbol represents a signed complex relocation expression,

 40345 +     with the expression tree serialized in the symbol name.  */

 40346 +#define BSF_SRELC 0x100000

 40347 +

 40348 +  flagword flags;

 40349 +

 40350 +  /* A pointer to the section to which this symbol is

 40351 +     relative.  This will always be non NULL, there are special

 40352 +     sections for undefined and absolute symbols.  */

 40353 +  struct bfd_section *section;

 40354 +

 40355 +  /* Back end special data.  */

 40356 +  union

 40357 +    {

 40358 +      void *p;

 40359 +      bfd_vma i;

 40360 +    }

 40361 +  udata;

 40362 +}

 40363 +asymbol;

 40364 +

 40365 +#define bfd_get_symtab_upper_bound(abfd) \

 40366 +     BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))

 40367 +

 40368 +bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);

 40369 +

 40370 +bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);

 40371 +

 40372 +#define bfd_is_local_label_name(abfd, name) \

 40373 +  BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))

 40374 +

 40375 +bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);

 40376 +

 40377 +#define bfd_is_target_special_symbol(abfd, sym) \

 40378 +  BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))

 40379 +

 40380 +#define bfd_canonicalize_symtab(abfd, location) \

 40381 +  BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))

 40382 +

 40383 +bfd_boolean bfd_set_symtab

 40384 +   (bfd *abfd, asymbol **location, unsigned int count);

 40385 +

 40386 +void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);

 40387 +

 40388 +#define bfd_make_empty_symbol(abfd) \

 40389 +  BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))

 40390 +

 40391 +asymbol *_bfd_generic_make_empty_symbol (bfd *);

 40392 +

 40393 +#define bfd_make_debug_symbol(abfd,ptr,size) \

 40394 +  BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))

 40395 +

 40396 +int bfd_decode_symclass (asymbol *symbol);

 40397 +

 40398 +bfd_boolean bfd_is_undefined_symclass (int symclass);

 40399 +

 40400 +void bfd_symbol_info (asymbol *symbol, symbol_info *ret);

 40401 +

 40402 +bfd_boolean bfd_copy_private_symbol_data

 40403 +   (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);

 40404 +

 40405 +#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \

 40406 +  BFD_SEND (obfd, _bfd_copy_private_symbol_data, \

 40407 +            (ibfd, isymbol, obfd, osymbol))

 40408 +

 40409 +/* Extracted from bfd.c.  */

 40410 +struct bfd

 40411 +{

 40412 +  /* A unique identifier of the BFD  */

 40413 +  unsigned int id;

 40414 +

 40415 +  /* The filename the application opened the BFD with.  */

 40416 +  const char *filename;

 40417 +

 40418 +  /* A pointer to the target jump table.  */

 40419 +  const struct bfd_target *xvec;

 40420 +

 40421 +  /* The IOSTREAM, and corresponding IO vector that provide access

 40422 +     to the file backing the BFD.  */

 40423 +  void *iostream;

 40424 +  const struct bfd_iovec *iovec;

 40425 +

 40426 +  /* Is the file descriptor being cached?  That is, can it be closed as

 40427 +     needed, and re-opened when accessed later?  */

 40428 +  bfd_boolean cacheable;

 40429 +

 40430 +  /* Marks whether there was a default target specified when the

 40431 +     BFD was opened. This is used to select which matching algorithm

 40432 +     to use to choose the back end.  */

 40433 +  bfd_boolean target_defaulted;

 40434 +

 40435 +  /* The caching routines use these to maintain a

 40436 +     least-recently-used list of BFDs.  */

 40437 +  struct bfd *lru_prev, *lru_next;

 40438 +

 40439 +  /* When a file is closed by the caching routines, BFD retains

 40440 +     state information on the file here...  */

 40441 +  ufile_ptr where;

 40442 +

 40443 +  /* ... and here: (``once'' means at least once).  */

 40444 +  bfd_boolean opened_once;

 40445 +

 40446 +  /* Set if we have a locally maintained mtime value, rather than

 40447 +     getting it from the file each time.  */

 40448 +  bfd_boolean mtime_set;

 40449 +

 40450 +  /* File modified time, if mtime_set is TRUE.  */

 40451 +  long mtime;

 40452 +

 40453 +  /* Reserved for an unimplemented file locking extension.  */

 40454 +  int ifd;

 40455 +

 40456 +  /* The format which belongs to the BFD. (object, core, etc.)  */

 40457 +  bfd_format format;

 40458 +

 40459 +  /* The direction with which the BFD was opened.  */

 40460 +  enum bfd_direction

 40461 +    {

 40462 +      no_direction = 0,

 40463 +      read_direction = 1,

 40464 +      write_direction = 2,

 40465 +      both_direction = 3

 40466 +    }

 40467 +  direction;

 40468 +

 40469 +  /* Format_specific flags.  */

 40470 +  flagword flags;

 40471 +

 40472 +  /* Currently my_archive is tested before adding origin to

 40473 +     anything. I believe that this can become always an add of

 40474 +     origin, with origin set to 0 for non archive files.  */

 40475 +  ufile_ptr origin;

 40476 +

 40477 +  /* Remember when output has begun, to stop strange things

 40478 +     from happening.  */

 40479 +  bfd_boolean output_has_begun;

 40480 +

 40481 +  /* A hash table for section names.  */

 40482 +  struct bfd_hash_table section_htab;

 40483 +

 40484 +  /* Pointer to linked list of sections.  */

 40485 +  struct bfd_section *sections;

 40486 +

 40487 +  /* The last section on the section list.  */

 40488 +  struct bfd_section *section_last;

 40489 +

 40490 +  /* The number of sections.  */

 40491 +  unsigned int section_count;

 40492 +

 40493 +  /* Stuff only useful for object files:

 40494 +     The start address.  */

 40495 +  bfd_vma start_address;

 40496 +

 40497 +  /* Used for input and output.  */

 40498 +  unsigned int symcount;

 40499 +

 40500 +  /* Symbol table for output BFD (with symcount entries).  */

 40501 +  struct bfd_symbol  **outsymbols;

 40502 +

 40503 +  /* Used for slurped dynamic symbol tables.  */

 40504 +  unsigned int dynsymcount;

 40505 +

 40506 +  /* Pointer to structure which contains architecture information.  */

 40507 +  const struct bfd_arch_info *arch_info;

 40508 +

 40509 +  /* Flag set if symbols from this BFD should not be exported.  */

 40510 +  bfd_boolean no_export;

 40511 +

 40512 +  /* Stuff only useful for archives.  */

 40513 +  void *arelt_data;

 40514 +  struct bfd *my_archive;      /* The containing archive BFD.  */

 40515 +  struct bfd *archive_next;    /* The next BFD in the archive.  */

 40516 +  struct bfd *archive_head;    /* The first BFD in the archive.  */

 40517 +  bfd_boolean has_armap;

 40518 +

 40519 +  /* A chain of BFD structures involved in a link.  */

 40520 +  struct bfd *link_next;

 40521 +

 40522 +  /* A field used by _bfd_generic_link_add_archive_symbols.  This will

 40523 +     be used only for archive elements.  */

 40524 +  int archive_pass;

 40525 +

 40526 +  /* Used by the back end to hold private data.  */

 40527 +  union

 40528 +    {

 40529 +      struct aout_data_struct *aout_data;

 40530 +      struct artdata *aout_ar_data;

 40531 +      struct _oasys_data *oasys_obj_data;

 40532 +      struct _oasys_ar_data *oasys_ar_data;

 40533 +      struct coff_tdata *coff_obj_data;

 40534 +      struct pe_tdata *pe_obj_data;

 40535 +      struct xcoff_tdata *xcoff_obj_data;

 40536 +      struct ecoff_tdata *ecoff_obj_data;

 40537 +      struct ieee_data_struct *ieee_data;

 40538 +      struct ieee_ar_data_struct *ieee_ar_data;

 40539 +      struct srec_data_struct *srec_data;

 40540 +      struct ihex_data_struct *ihex_data;

 40541 +      struct tekhex_data_struct *tekhex_data;

 40542 +      struct elf_obj_tdata *elf_obj_data;

 40543 +      struct nlm_obj_tdata *nlm_obj_data;

 40544 +      struct bout_data_struct *bout_data;

 40545 +      struct mmo_data_struct *mmo_data;

 40546 +      struct sun_core_struct *sun_core_data;

 40547 +      struct sco5_core_struct *sco5_core_data;

 40548 +      struct trad_core_struct *trad_core_data;

 40549 +      struct som_data_struct *som_data;

 40550 +      struct hpux_core_struct *hpux_core_data;

 40551 +      struct hppabsd_core_struct *hppabsd_core_data;

 40552 +      struct sgi_core_struct *sgi_core_data;

 40553 +      struct lynx_core_struct *lynx_core_data;

 40554 +      struct osf_core_struct *osf_core_data;

 40555 +      struct cisco_core_struct *cisco_core_data;

 40556 +      struct versados_data_struct *versados_data;

 40557 +      struct netbsd_core_struct *netbsd_core_data;

 40558 +      struct mach_o_data_struct *mach_o_data;

 40559 +      struct mach_o_fat_data_struct *mach_o_fat_data;

 40560 +      struct bfd_pef_data_struct *pef_data;

 40561 +      struct bfd_pef_xlib_data_struct *pef_xlib_data;

 40562 +      struct bfd_sym_data_struct *sym_data;

 40563 +      void *any;

 40564 +    }

 40565 +  tdata;

 40566 +

 40567 +  /* Used by the application to hold private data.  */

 40568 +  void *usrdata;

 40569 +

 40570 +  /* Where all the allocated stuff under this BFD goes.  This is a

 40571 +     struct objalloc *, but we use void * to avoid requiring the inclusion

 40572 +     of objalloc.h.  */

 40573 +  void *memory;

 40574 +};

 40575 +

 40576 +typedef enum bfd_error

 40577 +{

 40578 +  bfd_error_no_error = 0,

 40579 +  bfd_error_system_call,

 40580 +  bfd_error_invalid_target,

 40581 +  bfd_error_wrong_format,

 40582 +  bfd_error_wrong_object_format,

 40583 +  bfd_error_invalid_operation,

 40584 +  bfd_error_no_memory,

 40585 +  bfd_error_no_symbols,

 40586 +  bfd_error_no_armap,

 40587 +  bfd_error_no_more_archived_files,

 40588 +  bfd_error_malformed_archive,

 40589 +  bfd_error_file_not_recognized,

 40590 +  bfd_error_file_ambiguously_recognized,

 40591 +  bfd_error_no_contents,

 40592 +  bfd_error_nonrepresentable_section,

 40593 +  bfd_error_no_debug_section,

 40594 +  bfd_error_bad_value,

 40595 +  bfd_error_file_truncated,

 40596 +  bfd_error_file_too_big,

 40597 +  bfd_error_on_input,

 40598 +  bfd_error_invalid_error_code

 40599 +}

 40600 +bfd_error_type;

 40601 +

 40602 +bfd_error_type bfd_get_error (void);

 40603 +

 40604 +void bfd_set_error (bfd_error_type error_tag, ...);

 40605 +

 40606 +const char *bfd_errmsg (bfd_error_type error_tag);

 40607 +

 40608 +void bfd_perror (const char *message);

 40609 +

 40610 +typedef void (*bfd_error_handler_type) (const char *, ...);

 40611 +

 40612 +bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);

 40613 +

 40614 +void bfd_set_error_program_name (const char *);

 40615 +

 40616 +bfd_error_handler_type bfd_get_error_handler (void);

 40617 +

 40618 +long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);

 40619 +

 40620 +long bfd_canonicalize_reloc

 40621 +   (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);

 40622 +

 40623 +void bfd_set_reloc

 40624 +   (bfd *abfd, asection *sec, arelent **rel, unsigned int count);

 40625 +

 40626 +bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);

 40627 +

 40628 +int bfd_get_arch_size (bfd *abfd);

 40629 +

 40630 +int bfd_get_sign_extend_vma (bfd *abfd);

 40631 +

 40632 +bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);

 40633 +

 40634 +unsigned int bfd_get_gp_size (bfd *abfd);

 40635 +

 40636 +void bfd_set_gp_size (bfd *abfd, unsigned int i);

 40637 +

 40638 +bfd_vma bfd_scan_vma (const char *string, const char **end, int base);

 40639 +

 40640 +bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);

 40641 +

 40642 +#define bfd_copy_private_header_data(ibfd, obfd) \

 40643 +     BFD_SEND (obfd, _bfd_copy_private_header_data, \

 40644 +               (ibfd, obfd))

 40645 +bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);

 40646 +

 40647 +#define bfd_copy_private_bfd_data(ibfd, obfd) \

 40648 +     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \

 40649 +               (ibfd, obfd))

 40650 +bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);

 40651 +

 40652 +#define bfd_merge_private_bfd_data(ibfd, obfd) \

 40653 +     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \

 40654 +               (ibfd, obfd))

 40655 +bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);

 40656 +

 40657 +#define bfd_set_private_flags(abfd, flags) \

 40658 +     BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))

 40659 +#define bfd_sizeof_headers(abfd, info) \

 40660 +       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))

 40661 +

 40662 +#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \

 40663 +       BFD_SEND (abfd, _bfd_find_nearest_line, \

 40664 +                 (abfd, sec, syms, off, file, func, line))

 40665 +

 40666 +#define bfd_find_line(abfd, syms, sym, file, line) \

 40667 +       BFD_SEND (abfd, _bfd_find_line, \

 40668 +                 (abfd, syms, sym, file, line))

 40669 +

 40670 +#define bfd_find_inliner_info(abfd, file, func, line) \

 40671 +       BFD_SEND (abfd, _bfd_find_inliner_info, \

 40672 +                 (abfd, file, func, line))

 40673 +

 40674 +#define bfd_debug_info_start(abfd) \

 40675 +       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))

 40676 +

 40677 +#define bfd_debug_info_end(abfd) \

 40678 +       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))

 40679 +

 40680 +#define bfd_debug_info_accumulate(abfd, section) \

 40681 +       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))

 40682 +

 40683 +#define bfd_stat_arch_elt(abfd, stat) \

 40684 +       BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))

 40685 +

 40686 +#define bfd_update_armap_timestamp(abfd) \

 40687 +       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))

 40688 +

 40689 +#define bfd_set_arch_mach(abfd, arch, mach)\

 40690 +       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))

 40691 +

 40692 +#define bfd_relax_section(abfd, section, link_info, again) \

 40693 +       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))

 40694 +

 40695 +#define bfd_gc_sections(abfd, link_info) \

 40696 +       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))

 40697 +

 40698 +#define bfd_merge_sections(abfd, link_info) \

 40699 +       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))

 40700 +

 40701 +#define bfd_is_group_section(abfd, sec) \

 40702 +       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))

 40703 +

 40704 +#define bfd_discard_group(abfd, sec) \

 40705 +       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))

 40706 +

 40707 +#define bfd_link_hash_table_create(abfd) \

 40708 +       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))

 40709 +

 40710 +#define bfd_link_hash_table_free(abfd, hash) \

 40711 +       BFD_SEND (abfd, _bfd_link_hash_table_free, (hash))

 40712 +

 40713 +#define bfd_link_add_symbols(abfd, info) \

 40714 +       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))

 40715 +

 40716 +#define bfd_link_just_syms(abfd, sec, info) \

 40717 +       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))

 40718 +

 40719 +#define bfd_final_link(abfd, info) \

 40720 +       BFD_SEND (abfd, _bfd_final_link, (abfd, info))

 40721 +

 40722 +#define bfd_free_cached_info(abfd) \

 40723 +       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))

 40724 +

 40725 +#define bfd_get_dynamic_symtab_upper_bound(abfd) \

 40726 +       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))

 40727 +

 40728 +#define bfd_print_private_bfd_data(abfd, file)\

 40729 +       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))

 40730 +

 40731 +#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \

 40732 +       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))

 40733 +

 40734 +#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \

 40735 +       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \

 40736 +                                                   dyncount, dynsyms, ret))

 40737 +

 40738 +#define bfd_get_dynamic_reloc_upper_bound(abfd) \

 40739 +       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))

 40740 +

 40741 +#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \

 40742 +       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))

 40743 +

 40744 +extern bfd_byte *bfd_get_relocated_section_contents

 40745 +  (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,

 40746 +   bfd_boolean, asymbol **);

 40747 +

 40748 +bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);

 40749 +

 40750 +struct bfd_preserve

 40751 +{

 40752 +  void *marker;

 40753 +  void *tdata;

 40754 +  flagword flags;

 40755 +  const struct bfd_arch_info *arch_info;

 40756 +  struct bfd_section *sections;

 40757 +  struct bfd_section *section_last;

 40758 +  unsigned int section_count;

 40759 +  struct bfd_hash_table section_htab;

 40760 +};

 40761 +

 40762 +bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *);

 40763 +

 40764 +void bfd_preserve_restore (bfd *, struct bfd_preserve *);

 40765 +

 40766 +void bfd_preserve_finish (bfd *, struct bfd_preserve *);

 40767 +

 40768 +bfd_vma bfd_emul_get_maxpagesize (const char *);

 40769 +

 40770 +void bfd_emul_set_maxpagesize (const char *, bfd_vma);

 40771 +

 40772 +bfd_vma bfd_emul_get_commonpagesize (const char *);

 40773 +

 40774 +void bfd_emul_set_commonpagesize (const char *, bfd_vma);

 40775 +

 40776 +char *bfd_demangle (bfd *, const char *, int);

 40777 +

 40778 +/* Extracted from archive.c.  */

 40779 +symindex bfd_get_next_mapent

 40780 +   (bfd *abfd, symindex previous, carsym **sym);

 40781 +

 40782 +bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);

 40783 +

 40784 +bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);

 40785 +

 40786 +/* Extracted from corefile.c.  */

 40787 +const char *bfd_core_file_failing_command (bfd *abfd);

 40788 +

 40789 +int bfd_core_file_failing_signal (bfd *abfd);

 40790 +

 40791 +bfd_boolean core_file_matches_executable_p

 40792 +   (bfd *core_bfd, bfd *exec_bfd);

 40793 +

 40794 +bfd_boolean generic_core_file_matches_executable_p

 40795 +   (bfd *core_bfd, bfd *exec_bfd);

 40796 +

 40797 +/* Extracted from targets.c.  */

 40798 +#define BFD_SEND(bfd, message, arglist) \

 40799 +  ((*((bfd)->xvec->message)) arglist)

 40800 +

 40801 +#ifdef DEBUG_BFD_SEND

 40802 +#undef BFD_SEND

 40803 +#define BFD_SEND(bfd, message, arglist) \

 40804 +  (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \

 40805 +    ((*((bfd)->xvec->message)) arglist) : \

 40806 +    (bfd_assert (__FILE__,__LINE__), NULL))

 40807 +#endif

 40808 +#define BFD_SEND_FMT(bfd, message, arglist) \

 40809 +  (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist)

 40810 +

 40811 +#ifdef DEBUG_BFD_SEND

 40812 +#undef BFD_SEND_FMT

 40813 +#define BFD_SEND_FMT(bfd, message, arglist) \

 40814 +  (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \

 40815 +   (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) : \

 40816 +   (bfd_assert (__FILE__,__LINE__), NULL))

 40817 +#endif

 40818 +

 40819 +enum bfd_flavour

 40820 +{

 40821 +  bfd_target_unknown_flavour,

 40822 +  bfd_target_aout_flavour,

 40823 +  bfd_target_coff_flavour,

 40824 +  bfd_target_ecoff_flavour,

 40825 +  bfd_target_xcoff_flavour,

 40826 +  bfd_target_elf_flavour,

 40827 +  bfd_target_ieee_flavour,

 40828 +  bfd_target_nlm_flavour,

 40829 +  bfd_target_oasys_flavour,

 40830 +  bfd_target_tekhex_flavour,

 40831 +  bfd_target_srec_flavour,

 40832 +  bfd_target_ihex_flavour,

 40833 +  bfd_target_som_flavour,

 40834 +  bfd_target_os9k_flavour,

 40835 +  bfd_target_versados_flavour,

 40836 +  bfd_target_msdos_flavour,

 40837 +  bfd_target_ovax_flavour,

 40838 +  bfd_target_evax_flavour,

 40839 +  bfd_target_mmo_flavour,

 40840 +  bfd_target_mach_o_flavour,

 40841 +  bfd_target_pef_flavour,

 40842 +  bfd_target_pef_xlib_flavour,

 40843 +  bfd_target_sym_flavour

 40844 +};

 40845 +

 40846 +enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN };

 40847 +

 40848 +/* Forward declaration.  */

 40849 +typedef struct bfd_link_info _bfd_link_info;

 40850 +

 40851 +typedef struct bfd_target

 40852 +{

 40853 +  /* Identifies the kind of target, e.g., SunOS4, Ultrix, etc.  */

 40854 +  char *name;

 40855 +

 40856 + /* The "flavour" of a back end is a general indication about

 40857 +    the contents of a file.  */

 40858 +  enum bfd_flavour flavour;

 40859 +

 40860 +  /* The order of bytes within the data area of a file.  */

 40861 +  enum bfd_endian byteorder;

 40862 +

 40863 + /* The order of bytes within the header parts of a file.  */

 40864 +  enum bfd_endian header_byteorder;

 40865 +

 40866 +  /* A mask of all the flags which an executable may have set -

 40867 +     from the set <<BFD_NO_FLAGS>>, <<HAS_RELOC>>, ...<<D_PAGED>>.  */

 40868 +  flagword object_flags;

 40869 +

 40870 + /* A mask of all the flags which a section may have set - from

 40871 +    the set <<SEC_NO_FLAGS>>, <<SEC_ALLOC>>, ...<<SET_NEVER_LOAD>>.  */

 40872 +  flagword section_flags;

 40873 +

 40874 + /* The character normally found at the front of a symbol.

 40875 +    (if any), perhaps `_'.  */

 40876 +  char symbol_leading_char;

 40877 +

 40878 + /* The pad character for file names within an archive header.  */

 40879 +  char ar_pad_char;

 40880 +

 40881 +  /* The maximum number of characters in an archive header.  */

 40882 +  unsigned short ar_max_namelen;

 40883 +

 40884 +  /* Entries for byte swapping for data. These are different from the

 40885 +     other entry points, since they don't take a BFD as the first argument.

 40886 +     Certain other handlers could do the same.  */

 40887 +  bfd_uint64_t   (*bfd_getx64) (const void *);

 40888 +  bfd_int64_t    (*bfd_getx_signed_64) (const void *);

 40889 +  void           (*bfd_putx64) (bfd_uint64_t, void *);

 40890 +  bfd_vma        (*bfd_getx32) (const void *);

 40891 +  bfd_signed_vma (*bfd_getx_signed_32) (const void *);

 40892 +  void           (*bfd_putx32) (bfd_vma, void *);

 40893 +  bfd_vma        (*bfd_getx16) (const void *);

 40894 +  bfd_signed_vma (*bfd_getx_signed_16) (const void *);

 40895 +  void           (*bfd_putx16) (bfd_vma, void *);

 40896 +

 40897 +  /* Byte swapping for the headers.  */

 40898 +  bfd_uint64_t   (*bfd_h_getx64) (const void *);

 40899 +  bfd_int64_t    (*bfd_h_getx_signed_64) (const void *);

 40900 +  void           (*bfd_h_putx64) (bfd_uint64_t, void *);

 40901 +  bfd_vma        (*bfd_h_getx32) (const void *);

 40902 +  bfd_signed_vma (*bfd_h_getx_signed_32) (const void *);

 40903 +  void           (*bfd_h_putx32) (bfd_vma, void *);

 40904 +  bfd_vma        (*bfd_h_getx16) (const void *);

 40905 +  bfd_signed_vma (*bfd_h_getx_signed_16) (const void *);

 40906 +  void           (*bfd_h_putx16) (bfd_vma, void *);

 40907 +

 40908 +  /* Format dependent routines: these are vectors of entry points

 40909 +     within the target vector structure, one for each format to check.  */

 40910 +

 40911 +  /* Check the format of a file being read.  Return a <<bfd_target *>> or zero.  */

 40912 +  const struct bfd_target *(*_bfd_check_format[bfd_type_end]) (bfd *);

 40913 +

 40914 +  /* Set the format of a file being written.  */

 40915 +  bfd_boolean (*_bfd_set_format[bfd_type_end]) (bfd *);

 40916 +

 40917 +  /* Write cached information into a file being written, at <<bfd_close>>.  */

 40918 +  bfd_boolean (*_bfd_write_contents[bfd_type_end]) (bfd *);

 40919 +

 40920 +

 40921 +  /* Generic entry points.  */

 40922 +#define BFD_JUMP_TABLE_GENERIC(NAME) \

 40923 +  NAME##_close_and_cleanup, \

 40924 +  NAME##_bfd_free_cached_info, \

 40925 +  NAME##_new_section_hook, \

 40926 +  NAME##_get_section_contents, \

 40927 +  NAME##_get_section_contents_in_window

 40928 +

 40929 +  /* Called when the BFD is being closed to do any necessary cleanup.  */

 40930 +  bfd_boolean (*_close_and_cleanup) (bfd *);

 40931 +  /* Ask the BFD to free all cached information.  */

 40932 +  bfd_boolean (*_bfd_free_cached_info) (bfd *);

 40933 +  /* Called when a new section is created.  */

 40934 +  bfd_boolean (*_new_section_hook) (bfd *, sec_ptr);

 40935 +  /* Read the contents of a section.  */

 40936 +  bfd_boolean (*_bfd_get_section_contents)

 40937 +    (bfd *, sec_ptr, void *, file_ptr, bfd_size_type);

 40938 +  bfd_boolean (*_bfd_get_section_contents_in_window)

 40939 +    (bfd *, sec_ptr, bfd_window *, file_ptr, bfd_size_type);

 40940 +

 40941 +  /* Entry points to copy private data.  */

 40942 +#define BFD_JUMP_TABLE_COPY(NAME) \

 40943 +  NAME##_bfd_copy_private_bfd_data, \

 40944 +  NAME##_bfd_merge_private_bfd_data, \

 40945 +  _bfd_generic_init_private_section_data, \

 40946 +  NAME##_bfd_copy_private_section_data, \

 40947 +  NAME##_bfd_copy_private_symbol_data, \

 40948 +  NAME##_bfd_copy_private_header_data, \

 40949 +  NAME##_bfd_set_private_flags, \

 40950 +  NAME##_bfd_print_private_bfd_data

 40951 +

 40952 +  /* Called to copy BFD general private data from one object file

 40953 +     to another.  */

 40954 +  bfd_boolean (*_bfd_copy_private_bfd_data) (bfd *, bfd *);

 40955 +  /* Called to merge BFD general private data from one object file

 40956 +     to a common output file when linking.  */

 40957 +  bfd_boolean (*_bfd_merge_private_bfd_data) (bfd *, bfd *);

 40958 +  /* Called to initialize BFD private section data from one object file

 40959 +     to another.  */

 40960 +#define bfd_init_private_section_data(ibfd, isec, obfd, osec, link_info) \

 40961 +  BFD_SEND (obfd, _bfd_init_private_section_data, (ibfd, isec, obfd, osec, link_info))

 40962 +  bfd_boolean (*_bfd_init_private_section_data)

 40963 +    (bfd *, sec_ptr, bfd *, sec_ptr, struct bfd_link_info *);

 40964 +  /* Called to copy BFD private section data from one object file

 40965 +     to another.  */

 40966 +  bfd_boolean (*_bfd_copy_private_section_data)

 40967 +    (bfd *, sec_ptr, bfd *, sec_ptr);

 40968 +  /* Called to copy BFD private symbol data from one symbol

 40969 +     to another.  */

 40970 +  bfd_boolean (*_bfd_copy_private_symbol_data)

 40971 +    (bfd *, asymbol *, bfd *, asymbol *);

 40972 +  /* Called to copy BFD private header data from one object file

 40973 +     to another.  */

 40974 +  bfd_boolean (*_bfd_copy_private_header_data)

 40975 +    (bfd *, bfd *);

 40976 +  /* Called to set private backend flags.  */

 40977 +  bfd_boolean (*_bfd_set_private_flags) (bfd *, flagword);

 40978 +

 40979 +  /* Called to print private BFD data.  */

 40980 +  bfd_boolean (*_bfd_print_private_bfd_data) (bfd *, void *);

 40981 +

 40982 +  /* Core file entry points.  */

 40983 +#define BFD_JUMP_TABLE_CORE(NAME) \

 40984 +  NAME##_core_file_failing_command, \

 40985 +  NAME##_core_file_failing_signal, \

 40986 +  NAME##_core_file_matches_executable_p

 40987 +

 40988 +  char *      (*_core_file_failing_command) (bfd *);

 40989 +  int         (*_core_file_failing_signal) (bfd *);

 40990 +  bfd_boolean (*_core_file_matches_executable_p) (bfd *, bfd *);

 40991 +

 40992 +  /* Archive entry points.  */

 40993 +#define BFD_JUMP_TABLE_ARCHIVE(NAME) \

 40994 +  NAME##_slurp_armap, \

 40995 +  NAME##_slurp_extended_name_table, \

 40996 +  NAME##_construct_extended_name_table, \

 40997 +  NAME##_truncate_arname, \

 40998 +  NAME##_write_armap, \

 40999 +  NAME##_read_ar_hdr, \

 41000 +  NAME##_openr_next_archived_file, \

 41001 +  NAME##_get_elt_at_index, \

 41002 +  NAME##_generic_stat_arch_elt, \

 41003 +  NAME##_update_armap_timestamp

 41004 +

 41005 +  bfd_boolean (*_bfd_slurp_armap) (bfd *);

 41006 +  bfd_boolean (*_bfd_slurp_extended_name_table) (bfd *);

 41007 +  bfd_boolean (*_bfd_construct_extended_name_table)

 41008 +    (bfd *, char **, bfd_size_type *, const char **);

 41009 +  void        (*_bfd_truncate_arname) (bfd *, const char *, char *);

 41010 +  bfd_boolean (*write_armap)

 41011 +    (bfd *, unsigned int, struct orl *, unsigned int, int);

 41012 +  void *      (*_bfd_read_ar_hdr_fn) (bfd *);

 41013 +  bfd *       (*openr_next_archived_file) (bfd *, bfd *);

 41014 +#define bfd_get_elt_at_index(b,i) BFD_SEND (b, _bfd_get_elt_at_index, (b,i))

 41015 +  bfd *       (*_bfd_get_elt_at_index) (bfd *, symindex);

 41016 +  int         (*_bfd_stat_arch_elt) (bfd *, struct stat *);

 41017 +  bfd_boolean (*_bfd_update_armap_timestamp) (bfd *);

 41018 +

 41019 +  /* Entry points used for symbols.  */

 41020 +#define BFD_JUMP_TABLE_SYMBOLS(NAME) \

 41021 +  NAME##_get_symtab_upper_bound, \

 41022 +  NAME##_canonicalize_symtab, \

 41023 +  NAME##_make_empty_symbol, \

 41024 +  NAME##_print_symbol, \

 41025 +  NAME##_get_symbol_info, \

 41026 +  NAME##_bfd_is_local_label_name, \

 41027 +  NAME##_bfd_is_target_special_symbol, \

 41028 +  NAME##_get_lineno, \

 41029 +  NAME##_find_nearest_line, \

 41030 +  _bfd_generic_find_line, \

 41031 +  NAME##_find_inliner_info, \

 41032 +  NAME##_bfd_make_debug_symbol, \

 41033 +  NAME##_read_minisymbols, \

 41034 +  NAME##_minisymbol_to_symbol

 41035 +

 41036 +  long        (*_bfd_get_symtab_upper_bound) (bfd *);

 41037 +  long        (*_bfd_canonicalize_symtab)

 41038 +    (bfd *, struct bfd_symbol **);

 41039 +  struct bfd_symbol *

 41040 +              (*_bfd_make_empty_symbol) (bfd *);

 41041 +  void        (*_bfd_print_symbol)

 41042 +    (bfd *, void *, struct bfd_symbol *, bfd_print_symbol_type);

 41043 +#define bfd_print_symbol(b,p,s,e) BFD_SEND (b, _bfd_print_symbol, (b,p,s,e))

 41044 +  void        (*_bfd_get_symbol_info)

 41045 +    (bfd *, struct bfd_symbol *, symbol_info *);

 41046 +#define bfd_get_symbol_info(b,p,e) BFD_SEND (b, _bfd_get_symbol_info, (b,p,e))

 41047 +  bfd_boolean (*_bfd_is_local_label_name) (bfd *, const char *);

 41048 +  bfd_boolean (*_bfd_is_target_special_symbol) (bfd *, asymbol *);

 41049 +  alent *     (*_get_lineno) (bfd *, struct bfd_symbol *);

 41050 +  bfd_boolean (*_bfd_find_nearest_line)

 41051 +    (bfd *, struct bfd_section *, struct bfd_symbol **, bfd_vma,

 41052 +     const char **, const char **, unsigned int *);

 41053 +  bfd_boolean (*_bfd_find_line)

 41054 +    (bfd *, struct bfd_symbol **, struct bfd_symbol *,

 41055 +     const char **, unsigned int *);

 41056 +  bfd_boolean (*_bfd_find_inliner_info)

 41057 +    (bfd *, const char **, const char **, unsigned int *);

 41058 + /* Back-door to allow format-aware applications to create debug symbols

 41059 +    while using BFD for everything else.  Currently used by the assembler

 41060 +    when creating COFF files.  */

 41061 +  asymbol *   (*_bfd_make_debug_symbol)

 41062 +    (bfd *, void *, unsigned long size);

 41063 +#define bfd_read_minisymbols(b, d, m, s) \

 41064 +  BFD_SEND (b, _read_minisymbols, (b, d, m, s))

 41065 +  long        (*_read_minisymbols)

 41066 +    (bfd *, bfd_boolean, void **, unsigned int *);

 41067 +#define bfd_minisymbol_to_symbol(b, d, m, f) \

 41068 +  BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f))

 41069 +  asymbol *   (*_minisymbol_to_symbol)

 41070 +    (bfd *, bfd_boolean, const void *, asymbol *);

 41071 +

 41072 +  /* Routines for relocs.  */

 41073 +#define BFD_JUMP_TABLE_RELOCS(NAME) \

 41074 +  NAME##_get_reloc_upper_bound, \

 41075 +  NAME##_canonicalize_reloc, \

 41076 +  NAME##_bfd_reloc_type_lookup, \

 41077 +  NAME##_bfd_reloc_name_lookup

 41078 +

 41079 +  long        (*_get_reloc_upper_bound) (bfd *, sec_ptr);

 41080 +  long        (*_bfd_canonicalize_reloc)

 41081 +    (bfd *, sec_ptr, arelent **, struct bfd_symbol **);

 41082 +  /* See documentation on reloc types.  */

 41083 +  reloc_howto_type *

 41084 +              (*reloc_type_lookup) (bfd *, bfd_reloc_code_real_type);

 41085 +  reloc_howto_type *

 41086 +              (*reloc_name_lookup) (bfd *, const char *);

 41087 +

 41088 +

 41089 +  /* Routines used when writing an object file.  */

 41090 +#define BFD_JUMP_TABLE_WRITE(NAME) \

 41091 +  NAME##_set_arch_mach, \

 41092 +  NAME##_set_section_contents

 41093 +

 41094 +  bfd_boolean (*_bfd_set_arch_mach)

 41095 +    (bfd *, enum bfd_architecture, unsigned long);

 41096 +  bfd_boolean (*_bfd_set_section_contents)

 41097 +    (bfd *, sec_ptr, const void *, file_ptr, bfd_size_type);

 41098 +

 41099 +  /* Routines used by the linker.  */

 41100 +#define BFD_JUMP_TABLE_LINK(NAME) \

 41101 +  NAME##_sizeof_headers, \

 41102 +  NAME##_bfd_get_relocated_section_contents, \

 41103 +  NAME##_bfd_relax_section, \

 41104 +  NAME##_bfd_link_hash_table_create, \

 41105 +  NAME##_bfd_link_hash_table_free, \

 41106 +  NAME##_bfd_link_add_symbols, \

 41107 +  NAME##_bfd_link_just_syms, \

 41108 +  NAME##_bfd_final_link, \

 41109 +  NAME##_bfd_link_split_section, \

 41110 +  NAME##_bfd_gc_sections, \

 41111 +  NAME##_bfd_merge_sections, \

 41112 +  NAME##_bfd_is_group_section, \

 41113 +  NAME##_bfd_discard_group, \

 41114 +  NAME##_section_already_linked \

 41115 +

 41116 +  int         (*_bfd_sizeof_headers) (bfd *, struct bfd_link_info *);

 41117 +  bfd_byte *  (*_bfd_get_relocated_section_contents)

 41118 +    (bfd *, struct bfd_link_info *, struct bfd_link_order *,

 41119 +     bfd_byte *, bfd_boolean, struct bfd_symbol **);

 41120 +

 41121 +  bfd_boolean (*_bfd_relax_section)

 41122 +    (bfd *, struct bfd_section *, struct bfd_link_info *, bfd_boolean *);

 41123 +

 41124 +  /* Create a hash table for the linker.  Different backends store

 41125 +     different information in this table.  */

 41126 +  struct bfd_link_hash_table *

 41127 +              (*_bfd_link_hash_table_create) (bfd *);

 41128 +

 41129 +  /* Release the memory associated with the linker hash table.  */

 41130 +  void        (*_bfd_link_hash_table_free) (struct bfd_link_hash_table *);

 41131 +

 41132 +  /* Add symbols from this object file into the hash table.  */

 41133 +  bfd_boolean (*_bfd_link_add_symbols) (bfd *, struct bfd_link_info *);

 41134 +

 41135 +  /* Indicate that we are only retrieving symbol values from this section.  */

 41136 +  void        (*_bfd_link_just_syms) (asection *, struct bfd_link_info *);

 41137 +

 41138 +  /* Do a link based on the link_order structures attached to each

 41139 +     section of the BFD.  */

 41140 +  bfd_boolean (*_bfd_final_link) (bfd *, struct bfd_link_info *);

 41141 +

 41142 +  /* Should this section be split up into smaller pieces during linking.  */

 41143 +  bfd_boolean (*_bfd_link_split_section) (bfd *, struct bfd_section *);

 41144 +

 41145 +  /* Remove sections that are not referenced from the output.  */

 41146 +  bfd_boolean (*_bfd_gc_sections) (bfd *, struct bfd_link_info *);

 41147 +

 41148 +  /* Attempt to merge SEC_MERGE sections.  */

 41149 +  bfd_boolean (*_bfd_merge_sections) (bfd *, struct bfd_link_info *);

 41150 +

 41151 +  /* Is this section a member of a group?  */

 41152 +  bfd_boolean (*_bfd_is_group_section) (bfd *, const struct bfd_section *);

 41153 +

 41154 +  /* Discard members of a group.  */

 41155 +  bfd_boolean (*_bfd_discard_group) (bfd *, struct bfd_section *);

 41156 +

 41157 +  /* Check if SEC has been already linked during a reloceatable or

 41158 +     final link.  */

 41159 +  void (*_section_already_linked) (bfd *, struct bfd_section *,

 41160 +                                   struct bfd_link_info *);

 41161 +

 41162 +  /* Routines to handle dynamic symbols and relocs.  */

 41163 +#define BFD_JUMP_TABLE_DYNAMIC(NAME) \

 41164 +  NAME##_get_dynamic_symtab_upper_bound, \

 41165 +  NAME##_canonicalize_dynamic_symtab, \

 41166 +  NAME##_get_synthetic_symtab, \

 41167 +  NAME##_get_dynamic_reloc_upper_bound, \

 41168 +  NAME##_canonicalize_dynamic_reloc

 41169 +

 41170 +  /* Get the amount of memory required to hold the dynamic symbols.  */

 41171 +  long        (*_bfd_get_dynamic_symtab_upper_bound) (bfd *);

 41172 +  /* Read in the dynamic symbols.  */

 41173 +  long        (*_bfd_canonicalize_dynamic_symtab)

 41174 +    (bfd *, struct bfd_symbol **);

 41175 +  /* Create synthetized symbols.  */

 41176 +  long        (*_bfd_get_synthetic_symtab)

 41177 +    (bfd *, long, struct bfd_symbol **, long, struct bfd_symbol **,

 41178 +     struct bfd_symbol **);

 41179 +  /* Get the amount of memory required to hold the dynamic relocs.  */

 41180 +  long        (*_bfd_get_dynamic_reloc_upper_bound) (bfd *);

 41181 +  /* Read in the dynamic relocs.  */

 41182 +  long        (*_bfd_canonicalize_dynamic_reloc)

 41183 +    (bfd *, arelent **, struct bfd_symbol **);

 41184 +

 41185 +  /* Opposite endian version of this target.  */

 41186 +  const struct bfd_target * alternative_target;

 41187 +

 41188 +  /* Data for use by back-end routines, which isn't

 41189 +     generic enough to belong in this structure.  */

 41190 +  const void *backend_data;

 41191 +

 41192 +} bfd_target;

 41193 +

 41194 +bfd_boolean bfd_set_default_target (const char *name);

 41195 +

 41196 +const bfd_target *bfd_find_target (const char *target_name, bfd *abfd);

 41197 +

 41198 +const char ** bfd_target_list (void);

 41199 +

 41200 +const bfd_target *bfd_search_for_target

 41201 +   (int (*search_func) (const bfd_target *, void *),

 41202 +    void *);

 41203 +

 41204 +/* Extracted from format.c.  */

 41205 +bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);

 41206 +

 41207 +bfd_boolean bfd_check_format_matches

 41208 +   (bfd *abfd, bfd_format format, char ***matching);

 41209 +

 41210 +bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);

 41211 +

 41212 +const char *bfd_format_string (bfd_format format);

 41213 +

 41214 +/* Extracted from linker.c.  */

 41215 +bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec);

 41216 +

 41217 +#define bfd_link_split_section(abfd, sec) \

 41218 +       BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec))

 41219 +

 41220 +void bfd_section_already_linked (bfd *abfd, asection *sec,

 41221 +    struct bfd_link_info *info);

 41222 +

 41223 +#define bfd_section_already_linked(abfd, sec, info) \

 41224 +       BFD_SEND (abfd, _section_already_linked, (abfd, sec, info))

 41225 +

 41226 +/* Extracted from simple.c.  */

 41227 +bfd_byte *bfd_simple_get_relocated_section_contents

 41228 +   (bfd *abfd, asection *sec, bfd_byte *outbuf, asymbol **symbol_table);

 41229 +

 41230 +#ifdef __cplusplus

 41231 +}

 41232 +#endif

 41233 +#endif

 41234 --- /dev/null

 41235 +++ b/bfd/doc/libbfd.h

 41236 @@ -0,0 +1,2074 @@

 41237 +/* DO NOT EDIT!  -*- buffer-read-only: t -*-  This file is automatically

 41238 +   generated from "libbfd-in.h", "init.c", "libbfd.c", "bfdio.c",

 41239 +   "bfdwin.c", "cache.c", "reloc.c", "archures.c" and "elf.c".

 41240 +   Run "make headers" in your build bfd/ to regenerate.  */

 41241 +

 41242 +/* libbfd.h -- Declarations used by bfd library *implementation*.

 41243 +   (This include file is not for users of the library.)

 41244 +

 41245 +   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

 41246 +   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007

 41247 +   Free Software Foundation, Inc.

 41248 +

 41249 +   Written by Cygnus Support.

 41250 +

 41251 +   This file is part of BFD, the Binary File Descriptor library.

 41252 +

 41253 +   This program is free software; you can redistribute it and/or modify

 41254 +   it under the terms of the GNU General Public License as published by

 41255 +   the Free Software Foundation; either version 3 of the License, or

 41256 +   (at your option) any later version.

 41257 +

 41258 +   This program is distributed in the hope that it will be useful,

 41259 +   but WITHOUT ANY WARRANTY; without even the implied warranty of

 41260 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 41261 +   GNU General Public License for more details.

 41262 +

 41263 +   You should have received a copy of the GNU General Public License

 41264 +   along with this program; if not, write to the Free Software

 41265 +   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

 41266 +   MA 02110-1301, USA.  */

 41267 +

 41268 +#include "hashtab.h"

 41269 +

 41270 +/* Align an address upward to a boundary, expressed as a number of bytes.

 41271 +   E.g. align to an 8-byte boundary with argument of 8.  Take care never

 41272 +   to wrap around if the address is within boundary-1 of the end of the

 41273 +   address space.  */

 41274 +#define BFD_ALIGN(this, boundary)					  \

 41275 +  ((((bfd_vma) (this) + (boundary) - 1) >= (bfd_vma) (this))		  \

 41276 +   ? (((bfd_vma) (this) + ((boundary) - 1)) & ~ (bfd_vma) ((boundary)-1)) \

 41277 +   : ~ (bfd_vma) 0)

 41278 +

 41279 +/* If you want to read and write large blocks, you might want to do it

 41280 +   in quanta of this amount */

 41281 +#define DEFAULT_BUFFERSIZE 8192

 41282 +

 41283 +/* Set a tdata field.  Can't use the other macros for this, since they

 41284 +   do casts, and casting to the left of assignment isn't portable.  */

 41285 +#define set_tdata(bfd, v) ((bfd)->tdata.any = (v))

 41286 +

 41287 +/* If BFD_IN_MEMORY is set for a BFD, then the iostream fields points

 41288 +   to an instance of this structure.  */

 41289 +

 41290 +struct bfd_in_memory

 41291 +{

 41292 +  /* Size of buffer.  */

 41293 +  bfd_size_type size;

 41294 +  /* Buffer holding contents of BFD.  */

 41295 +  bfd_byte *buffer;

 41296 +};

 41297 +

 41298 +struct section_hash_entry

 41299 +{

 41300 +  struct bfd_hash_entry root;

 41301 +  asection section;

 41302 +};

 41303 +

 41304 +/* tdata for an archive.  For an input archive, cache

 41305 +   needs to be free()'d.  For an output archive, symdefs do.  */

 41306 +

 41307 +struct artdata {

 41308 +  file_ptr first_file_filepos;

 41309 +  /* Speed up searching the armap */

 41310 +  htab_t cache;

 41311 +  bfd *archive_head;		/* Only interesting in output routines */

 41312 +  carsym *symdefs;		/* the symdef entries */

 41313 +  symindex symdef_count;	/* how many there are */

 41314 +  char *extended_names;		/* clever intel extension */

 41315 +  bfd_size_type extended_names_size; /* Size of extended names */

 41316 +  /* when more compilers are standard C, this can be a time_t */

 41317 +  long  armap_timestamp;	/* Timestamp value written into armap.

 41318 +				   This is used for BSD archives to check

 41319 +				   that the timestamp is recent enough

 41320 +				   for the BSD linker to not complain,

 41321 +				   just before we finish writing an

 41322 +				   archive.  */

 41323 +  file_ptr armap_datepos;	/* Position within archive to seek to

 41324 +				   rewrite the date field.  */

 41325 +  void *tdata;			/* Backend specific information.  */

 41326 +};

 41327 +

 41328 +#define bfd_ardata(bfd) ((bfd)->tdata.aout_ar_data)

 41329 +

 41330 +/* Goes in bfd's arelt_data slot */

 41331 +struct areltdata {

 41332 +  char * arch_header;		/* it's actually a string */

 41333 +  unsigned int parsed_size;	/* octets of filesize not including ar_hdr */

 41334 +  char *filename;		/* null-terminated */

 41335 +};

 41336 +

 41337 +#define arelt_size(bfd) (((struct areltdata *)((bfd)->arelt_data))->parsed_size)

 41338 +

 41339 +extern void *bfd_malloc

 41340 +  (bfd_size_type);

 41341 +extern void *bfd_realloc

 41342 +  (void *, bfd_size_type);

 41343 +extern void *bfd_zmalloc

 41344 +  (bfd_size_type);

 41345 +extern void *bfd_malloc2

 41346 +  (bfd_size_type, bfd_size_type);

 41347 +extern void *bfd_realloc2

 41348 +  (void *, bfd_size_type, bfd_size_type);

 41349 +extern void *bfd_zmalloc2

 41350 +  (bfd_size_type, bfd_size_type);

 41351 +

 41352 +extern void _bfd_default_error_handler (const char *s, ...);

 41353 +extern bfd_error_handler_type _bfd_error_handler;

 41354 +

 41355 +/* These routines allocate and free things on the BFD's objalloc.  */

 41356 +

 41357 +extern void *bfd_alloc

 41358 +  (bfd *, bfd_size_type);

 41359 +extern void *bfd_zalloc

 41360 +  (bfd *, bfd_size_type);

 41361 +extern void *bfd_alloc2

 41362 +  (bfd *, bfd_size_type, bfd_size_type);

 41363 +extern void *bfd_zalloc2

 41364 +  (bfd *, bfd_size_type, bfd_size_type);

 41365 +extern void bfd_release

 41366 +  (bfd *, void *);

 41367 +

 41368 +bfd * _bfd_create_empty_archive_element_shell

 41369 +  (bfd *obfd);

 41370 +bfd * _bfd_look_for_bfd_in_cache

 41371 +  (bfd *, file_ptr);

 41372 +bfd_boolean _bfd_add_bfd_to_archive_cache

 41373 +  (bfd *, file_ptr, bfd *);

 41374 +bfd_boolean _bfd_generic_mkarchive

 41375 +  (bfd *abfd);

 41376 +const bfd_target *bfd_generic_archive_p

 41377 +  (bfd *abfd);

 41378 +bfd_boolean bfd_slurp_armap

 41379 +  (bfd *abfd);

 41380 +bfd_boolean bfd_slurp_bsd_armap_f2

 41381 +  (bfd *abfd);

 41382 +#define bfd_slurp_bsd_armap bfd_slurp_armap

 41383 +#define bfd_slurp_coff_armap bfd_slurp_armap

 41384 +bfd_boolean _bfd_slurp_extended_name_table

 41385 +  (bfd *abfd);

 41386 +extern bfd_boolean _bfd_construct_extended_name_table

 41387 +  (bfd *, bfd_boolean, char **, bfd_size_type *);

 41388 +bfd_boolean _bfd_write_archive_contents

 41389 +  (bfd *abfd);

 41390 +bfd_boolean _bfd_compute_and_write_armap

 41391 +  (bfd *, unsigned int elength);

 41392 +bfd *_bfd_get_elt_at_filepos

 41393 +  (bfd *archive, file_ptr filepos);

 41394 +extern bfd *_bfd_generic_get_elt_at_index

 41395 +  (bfd *, symindex);

 41396 +bfd * _bfd_new_bfd

 41397 +  (void);

 41398 +void _bfd_delete_bfd

 41399 +  (bfd *);

 41400 +bfd_boolean _bfd_free_cached_info

 41401 +  (bfd *);

 41402 +

 41403 +bfd_boolean bfd_false

 41404 +  (bfd *ignore);

 41405 +bfd_boolean bfd_true

 41406 +  (bfd *ignore);

 41407 +void *bfd_nullvoidptr

 41408 +  (bfd *ignore);

 41409 +int bfd_0

 41410 +  (bfd *ignore);

 41411 +unsigned int bfd_0u

 41412 +  (bfd *ignore);

 41413 +long bfd_0l

 41414 +  (bfd *ignore);

 41415 +long _bfd_n1

 41416 +  (bfd *ignore);

 41417 +void bfd_void

 41418 +  (bfd *ignore);

 41419 +

 41420 +bfd *_bfd_new_bfd_contained_in

 41421 +  (bfd *);

 41422 +const bfd_target *_bfd_dummy_target

 41423 +  (bfd *abfd);

 41424 +

 41425 +void bfd_dont_truncate_arname

 41426 +  (bfd *abfd, const char *filename, char *hdr);

 41427 +void bfd_bsd_truncate_arname

 41428 +  (bfd *abfd, const char *filename, char *hdr);

 41429 +void bfd_gnu_truncate_arname

 41430 +  (bfd *abfd, const char *filename, char *hdr);

 41431 +

 41432 +bfd_boolean bsd_write_armap

 41433 +  (bfd *arch, unsigned int elength, struct orl *map, unsigned int orl_count,

 41434 +   int stridx);

 41435 +

 41436 +bfd_boolean coff_write_armap

 41437 +  (bfd *arch, unsigned int elength, struct orl *map, unsigned int orl_count,

 41438 +   int stridx);

 41439 +

 41440 +extern void *_bfd_generic_read_ar_hdr

 41441 +  (bfd *);

 41442 +extern void _bfd_ar_spacepad

 41443 +  (char *, size_t, const char *, long);

 41444 +

 41445 +extern void *_bfd_generic_read_ar_hdr_mag

 41446 +  (bfd *, const char *);

 41447 +

 41448 +bfd * bfd_generic_openr_next_archived_file

 41449 +  (bfd *archive, bfd *last_file);

 41450 +

 41451 +int bfd_generic_stat_arch_elt

 41452 +  (bfd *, struct stat *);

 41453 +

 41454 +#define _bfd_read_ar_hdr(abfd) \

 41455 +  BFD_SEND (abfd, _bfd_read_ar_hdr_fn, (abfd))

 41456 +

 41457 +/* Generic routines to use for BFD_JUMP_TABLE_GENERIC.  Use

 41458 +   BFD_JUMP_TABLE_GENERIC (_bfd_generic).  */

 41459 +

 41460 +#define _bfd_generic_close_and_cleanup bfd_true

 41461 +#define _bfd_generic_bfd_free_cached_info bfd_true

 41462 +extern bfd_boolean _bfd_generic_new_section_hook

 41463 +  (bfd *, asection *);

 41464 +extern bfd_boolean _bfd_generic_get_section_contents

 41465 +  (bfd *, asection *, void *, file_ptr, bfd_size_type);

 41466 +extern bfd_boolean _bfd_generic_get_section_contents_in_window

 41467 +  (bfd *, asection *, bfd_window *, file_ptr, bfd_size_type);

 41468 +

 41469 +/* Generic routines to use for BFD_JUMP_TABLE_COPY.  Use

 41470 +   BFD_JUMP_TABLE_COPY (_bfd_generic).  */

 41471 +

 41472 +#define _bfd_generic_bfd_copy_private_bfd_data \

 41473 +  ((bfd_boolean (*) (bfd *, bfd *)) bfd_true)

 41474 +#define _bfd_generic_bfd_merge_private_bfd_data \

 41475 +  ((bfd_boolean (*) (bfd *, bfd *)) bfd_true)

 41476 +#define _bfd_generic_bfd_set_private_flags \

 41477 +  ((bfd_boolean (*) (bfd *, flagword)) bfd_true)

 41478 +#define _bfd_generic_bfd_copy_private_section_data \

 41479 +  ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true)

 41480 +#define _bfd_generic_bfd_copy_private_symbol_data \

 41481 +  ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true)

 41482 +#define _bfd_generic_bfd_copy_private_header_data \

 41483 +  ((bfd_boolean (*) (bfd *, bfd *)) bfd_true)

 41484 +#define _bfd_generic_bfd_print_private_bfd_data \

 41485 +  ((bfd_boolean (*) (bfd *, void *)) bfd_true)

 41486 +

 41487 +extern bfd_boolean _bfd_generic_init_private_section_data

 41488 +  (bfd *, asection *, bfd *, asection *, struct bfd_link_info *);

 41489 +

 41490 +/* Routines to use for BFD_JUMP_TABLE_CORE when there is no core file

 41491 +   support.  Use BFD_JUMP_TABLE_CORE (_bfd_nocore).  */

 41492 +

 41493 +extern char *_bfd_nocore_core_file_failing_command

 41494 +  (bfd *);

 41495 +extern int _bfd_nocore_core_file_failing_signal

 41496 +  (bfd *);

 41497 +extern bfd_boolean _bfd_nocore_core_file_matches_executable_p

 41498 +  (bfd *, bfd *);

 41499 +

 41500 +/* Routines to use for BFD_JUMP_TABLE_ARCHIVE when there is no archive

 41501 +   file support.  Use BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive).  */

 41502 +

 41503 +#define _bfd_noarchive_slurp_armap bfd_false

 41504 +#define _bfd_noarchive_slurp_extended_name_table bfd_false

 41505 +#define _bfd_noarchive_construct_extended_name_table \

 41506 +  ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) \

 41507 +   bfd_false)

 41508 +#define _bfd_noarchive_truncate_arname \

 41509 +  ((void (*) (bfd *, const char *, char *)) bfd_void)

 41510 +#define _bfd_noarchive_write_armap \

 41511 +  ((bfd_boolean (*) (bfd *, unsigned int, struct orl *, unsigned int, int)) \

 41512 +   bfd_false)

 41513 +#define _bfd_noarchive_read_ar_hdr bfd_nullvoidptr

 41514 +#define _bfd_noarchive_openr_next_archived_file \

 41515 +  ((bfd *(*) (bfd *, bfd *)) bfd_nullvoidptr)

 41516 +#define _bfd_noarchive_get_elt_at_index \

 41517 +  ((bfd *(*) (bfd *, symindex)) bfd_nullvoidptr)

 41518 +#define _bfd_noarchive_generic_stat_arch_elt bfd_generic_stat_arch_elt

 41519 +#define _bfd_noarchive_update_armap_timestamp bfd_false

 41520 +

 41521 +/* Routines to use for BFD_JUMP_TABLE_ARCHIVE to get BSD style

 41522 +   archives.  Use BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd).  */

 41523 +

 41524 +#define _bfd_archive_bsd_slurp_armap bfd_slurp_bsd_armap

 41525 +#define _bfd_archive_bsd_slurp_extended_name_table \

 41526 +  _bfd_slurp_extended_name_table

 41527 +extern bfd_boolean _bfd_archive_bsd_construct_extended_name_table

 41528 +  (bfd *, char **, bfd_size_type *, const char **);

 41529 +#define _bfd_archive_bsd_truncate_arname bfd_bsd_truncate_arname

 41530 +#define _bfd_archive_bsd_write_armap bsd_write_armap

 41531 +#define _bfd_archive_bsd_read_ar_hdr _bfd_generic_read_ar_hdr

 41532 +#define _bfd_archive_bsd_openr_next_archived_file \

 41533 +  bfd_generic_openr_next_archived_file

 41534 +#define _bfd_archive_bsd_get_elt_at_index _bfd_generic_get_elt_at_index

 41535 +#define _bfd_archive_bsd_generic_stat_arch_elt \

 41536 +  bfd_generic_stat_arch_elt

 41537 +extern bfd_boolean _bfd_archive_bsd_update_armap_timestamp

 41538 +  (bfd *);

 41539 +

 41540 +/* Routines to use for BFD_JUMP_TABLE_ARCHIVE to get COFF style

 41541 +   archives.  Use BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff).  */

 41542 +

 41543 +#define _bfd_archive_coff_slurp_armap bfd_slurp_coff_armap

 41544 +#define _bfd_archive_coff_slurp_extended_name_table \

 41545 +  _bfd_slurp_extended_name_table

 41546 +extern bfd_boolean _bfd_archive_coff_construct_extended_name_table

 41547 +  (bfd *, char **, bfd_size_type *, const char **);

 41548 +#define _bfd_archive_coff_truncate_arname bfd_dont_truncate_arname

 41549 +#define _bfd_archive_coff_write_armap coff_write_armap

 41550 +#define _bfd_archive_coff_read_ar_hdr _bfd_generic_read_ar_hdr

 41551 +#define _bfd_archive_coff_openr_next_archived_file \

 41552 +  bfd_generic_openr_next_archived_file

 41553 +#define _bfd_archive_coff_get_elt_at_index _bfd_generic_get_elt_at_index

 41554 +#define _bfd_archive_coff_generic_stat_arch_elt \

 41555 +  bfd_generic_stat_arch_elt

 41556 +#define _bfd_archive_coff_update_armap_timestamp bfd_true

 41557 +

 41558 +/* Routines to use for BFD_JUMP_TABLE_SYMBOLS where there is no symbol

 41559 +   support.  Use BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols).  */

 41560 +

 41561 +#define _bfd_nosymbols_get_symtab_upper_bound _bfd_n1

 41562 +#define _bfd_nosymbols_canonicalize_symtab \

 41563 +  ((long (*) (bfd *, asymbol **)) _bfd_n1)

 41564 +#define _bfd_nosymbols_make_empty_symbol _bfd_generic_make_empty_symbol

 41565 +#define _bfd_nosymbols_print_symbol \

 41566 +  ((void (*) (bfd *, void *, asymbol *, bfd_print_symbol_type)) bfd_void)

 41567 +#define _bfd_nosymbols_get_symbol_info \

 41568 +  ((void (*) (bfd *, asymbol *, symbol_info *)) bfd_void)

 41569 +#define _bfd_nosymbols_bfd_is_local_label_name \

 41570 +  ((bfd_boolean (*) (bfd *, const char *)) bfd_false)

 41571 +#define _bfd_nosymbols_bfd_is_target_special_symbol \

 41572 +  ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)

 41573 +#define _bfd_nosymbols_get_lineno \

 41574 +  ((alent *(*) (bfd *, asymbol *)) bfd_nullvoidptr)

 41575 +#define _bfd_nosymbols_find_nearest_line \

 41576 +  ((bfd_boolean (*) (bfd *, asection *, asymbol **, bfd_vma, const char **, \

 41577 +		     const char **, unsigned int *)) \

 41578 +   bfd_false)

 41579 +#define _bfd_nosymbols_find_inliner_info \

 41580 +  ((bfd_boolean (*) (bfd *, const char **, const char **, unsigned int *)) \

 41581 +   bfd_false)

 41582 +#define _bfd_nosymbols_bfd_make_debug_symbol \

 41583 +  ((asymbol *(*) (bfd *, void *, unsigned long)) bfd_nullvoidptr)

 41584 +#define _bfd_nosymbols_read_minisymbols \

 41585 +  ((long (*) (bfd *, bfd_boolean, void **, unsigned int *)) _bfd_n1)

 41586 +#define _bfd_nosymbols_minisymbol_to_symbol \

 41587 +  ((asymbol *(*) (bfd *, bfd_boolean, const void *, asymbol *)) \

 41588 +   bfd_nullvoidptr)

 41589 +

 41590 +/* Routines to use for BFD_JUMP_TABLE_RELOCS when there is no reloc

 41591 +   support.  Use BFD_JUMP_TABLE_RELOCS (_bfd_norelocs).  */

 41592 +

 41593 +extern long _bfd_norelocs_get_reloc_upper_bound (bfd *, asection *);

 41594 +extern long _bfd_norelocs_canonicalize_reloc (bfd *, asection *,

 41595 +					      arelent **, asymbol **);

 41596 +#define _bfd_norelocs_bfd_reloc_type_lookup \

 41597 +  ((reloc_howto_type *(*) (bfd *, bfd_reloc_code_real_type)) bfd_nullvoidptr)

 41598 +#define _bfd_norelocs_bfd_reloc_name_lookup \

 41599 +  ((reloc_howto_type *(*) (bfd *, const char *)) bfd_nullvoidptr)

 41600 +

 41601 +/* Routines to use for BFD_JUMP_TABLE_WRITE for targets which may not

 41602 +   be written.  Use BFD_JUMP_TABLE_WRITE (_bfd_nowrite).  */

 41603 +

 41604 +#define _bfd_nowrite_set_arch_mach \

 41605 +  ((bfd_boolean (*) (bfd *, enum bfd_architecture, unsigned long)) \

 41606 +   bfd_false)

 41607 +#define _bfd_nowrite_set_section_contents \

 41608 +  ((bfd_boolean (*) (bfd *, asection *, const void *, file_ptr, bfd_size_type)) \

 41609 +   bfd_false)

 41610 +

 41611 +/* Generic routines to use for BFD_JUMP_TABLE_WRITE.  Use

 41612 +   BFD_JUMP_TABLE_WRITE (_bfd_generic).  */

 41613 +

 41614 +#define _bfd_generic_set_arch_mach bfd_default_set_arch_mach

 41615 +extern bfd_boolean _bfd_generic_set_section_contents

 41616 +  (bfd *, asection *, const void *, file_ptr, bfd_size_type);

 41617 +

 41618 +/* Routines to use for BFD_JUMP_TABLE_LINK for targets which do not

 41619 +   support linking.  Use BFD_JUMP_TABLE_LINK (_bfd_nolink).  */

 41620 +

 41621 +#define _bfd_nolink_sizeof_headers \

 41622 +  ((int (*) (bfd *, struct bfd_link_info *)) bfd_0)

 41623 +#define _bfd_nolink_bfd_get_relocated_section_contents \

 41624 +  ((bfd_byte *(*) (bfd *, struct bfd_link_info *, struct bfd_link_order *, \

 41625 +		   bfd_byte *, bfd_boolean, asymbol **)) \

 41626 +   bfd_nullvoidptr)

 41627 +#define _bfd_nolink_bfd_relax_section \

 41628 +  ((bfd_boolean (*) \

 41629 +    (bfd *, asection *, struct bfd_link_info *, bfd_boolean *)) \

 41630 +   bfd_false)

 41631 +#define _bfd_nolink_bfd_gc_sections \

 41632 +  ((bfd_boolean (*) (bfd *, struct bfd_link_info *)) \

 41633 +   bfd_false)

 41634 +#define _bfd_nolink_bfd_merge_sections \

 41635 +  ((bfd_boolean (*) (bfd *, struct bfd_link_info *)) \

 41636 +   bfd_false)

 41637 +#define _bfd_nolink_bfd_is_group_section \

 41638 +  ((bfd_boolean (*) (bfd *, const struct bfd_section *)) \

 41639 +   bfd_false)

 41640 +#define _bfd_nolink_bfd_discard_group \

 41641 +  ((bfd_boolean (*) (bfd *, struct bfd_section *)) \

 41642 +   bfd_false)

 41643 +#define _bfd_nolink_bfd_link_hash_table_create \

 41644 +  ((struct bfd_link_hash_table *(*) (bfd *)) bfd_nullvoidptr)

 41645 +#define _bfd_nolink_bfd_link_hash_table_free \

 41646 +  ((void (*) (struct bfd_link_hash_table *)) bfd_void)

 41647 +#define _bfd_nolink_bfd_link_add_symbols \

 41648 +  ((bfd_boolean (*) (bfd *, struct bfd_link_info *)) bfd_false)

 41649 +#define _bfd_nolink_bfd_link_just_syms \

 41650 +  ((void (*) (asection *, struct bfd_link_info *)) bfd_void)

 41651 +#define _bfd_nolink_bfd_final_link \

 41652 +  ((bfd_boolean (*) (bfd *, struct bfd_link_info *)) bfd_false)

 41653 +#define _bfd_nolink_bfd_link_split_section \

 41654 +  ((bfd_boolean (*) (bfd *, struct bfd_section *)) bfd_false)

 41655 +#define _bfd_nolink_section_already_linked \

 41656 +  ((void (*) (bfd *, struct bfd_section *, struct bfd_link_info *)) bfd_void)

 41657 +

 41658 +/* Routines to use for BFD_JUMP_TABLE_DYNAMIC for targets which do not

 41659 +   have dynamic symbols or relocs.  Use BFD_JUMP_TABLE_DYNAMIC

 41660 +   (_bfd_nodynamic).  */

 41661 +

 41662 +#define _bfd_nodynamic_get_dynamic_symtab_upper_bound _bfd_n1

 41663 +#define _bfd_nodynamic_canonicalize_dynamic_symtab \

 41664 +  ((long (*) (bfd *, asymbol **)) _bfd_n1)

 41665 +#define _bfd_nodynamic_get_synthetic_symtab \

 41666 +  ((long (*) (bfd *, long, asymbol **, long, asymbol **, asymbol **)) _bfd_n1)

 41667 +#define _bfd_nodynamic_get_dynamic_reloc_upper_bound _bfd_n1

 41668 +#define _bfd_nodynamic_canonicalize_dynamic_reloc \

 41669 +  ((long (*) (bfd *, arelent **, asymbol **)) _bfd_n1)

 41670 +

 41671 +/* Generic routine to determine of the given symbol is a local

 41672 +   label.  */

 41673 +extern bfd_boolean bfd_generic_is_local_label_name

 41674 +  (bfd *, const char *);

 41675 +

 41676 +/* Generic minisymbol routines.  */

 41677 +extern long _bfd_generic_read_minisymbols

 41678 +  (bfd *, bfd_boolean, void **, unsigned int *);

 41679 +extern asymbol *_bfd_generic_minisymbol_to_symbol

 41680 +  (bfd *, bfd_boolean, const void *, asymbol *);

 41681 +

 41682 +/* Find the nearest line using .stab/.stabstr sections.  */

 41683 +extern bfd_boolean _bfd_stab_section_find_nearest_line

 41684 +  (bfd *, asymbol **, asection *, bfd_vma, bfd_boolean *,

 41685 +   const char **, const char **, unsigned int *, void **);

 41686 +

 41687 +/* Find the nearest line using DWARF 1 debugging information.  */

 41688 +extern bfd_boolean _bfd_dwarf1_find_nearest_line

 41689 +  (bfd *, asection *, asymbol **, bfd_vma, const char **,

 41690 +   const char **, unsigned int *);

 41691 +

 41692 +/* Find the nearest line using DWARF 2 debugging information.  */

 41693 +extern bfd_boolean _bfd_dwarf2_find_nearest_line

 41694 +  (bfd *, asection *, asymbol **, bfd_vma, const char **, const char **,

 41695 +   unsigned int *, unsigned int, void **);

 41696 +

 41697 +/* Find the line using DWARF 2 debugging information.  */

 41698 +extern bfd_boolean _bfd_dwarf2_find_line

 41699 +  (bfd *, asymbol **, asymbol *, const char **,

 41700 +   unsigned int *, unsigned int, void **);

 41701 +

 41702 +bfd_boolean _bfd_generic_find_line

 41703 +  (bfd *, asymbol **, asymbol *, const char **, unsigned int *);

 41704 +

 41705 +/* Find inliner info after calling bfd_find_nearest_line. */

 41706 +extern bfd_boolean _bfd_dwarf2_find_inliner_info

 41707 +  (bfd *, const char **, const char **, unsigned int *, void **);

 41708 +

 41709 +/* Create a new section entry.  */

 41710 +extern struct bfd_hash_entry *bfd_section_hash_newfunc

 41711 +  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);

 41712 +

 41713 +/* A routine to create entries for a bfd_link_hash_table.  */

 41714 +extern struct bfd_hash_entry *_bfd_link_hash_newfunc

 41715 +  (struct bfd_hash_entry *entry, struct bfd_hash_table *table,

 41716 +   const char *string);

 41717 +

 41718 +/* Initialize a bfd_link_hash_table.  */

 41719 +extern bfd_boolean _bfd_link_hash_table_init

 41720 +  (struct bfd_link_hash_table *, bfd *,

 41721 +   struct bfd_hash_entry *(*) (struct bfd_hash_entry *,

 41722 +			       struct bfd_hash_table *,

 41723 +			       const char *),

 41724 +   unsigned int);

 41725 +

 41726 +/* Generic link hash table creation routine.  */

 41727 +extern struct bfd_link_hash_table *_bfd_generic_link_hash_table_create

 41728 +  (bfd *);

 41729 +

 41730 +/* Generic link hash table destruction routine.  */

 41731 +extern void _bfd_generic_link_hash_table_free

 41732 +  (struct bfd_link_hash_table *);

 41733 +

 41734 +/* Generic add symbol routine.  */

 41735 +extern bfd_boolean _bfd_generic_link_add_symbols

 41736 +  (bfd *, struct bfd_link_info *);

 41737 +

 41738 +/* Generic add symbol routine.  This version is used by targets for

 41739 +   which the linker must collect constructors and destructors by name,

 41740 +   as the collect2 program does.  */

 41741 +extern bfd_boolean _bfd_generic_link_add_symbols_collect

 41742 +  (bfd *, struct bfd_link_info *);

 41743 +

 41744 +/* Generic archive add symbol routine.  */

 41745 +extern bfd_boolean _bfd_generic_link_add_archive_symbols

 41746 +  (bfd *, struct bfd_link_info *,

 41747 +   bfd_boolean (*) (bfd *, struct bfd_link_info *, bfd_boolean *));

 41748 +

 41749 +/* Forward declaration to avoid prototype errors.  */

 41750 +typedef struct bfd_link_hash_entry _bfd_link_hash_entry;

 41751 +

 41752 +/* Generic routine to add a single symbol.  */

 41753 +extern bfd_boolean _bfd_generic_link_add_one_symbol

 41754 +  (struct bfd_link_info *, bfd *, const char *name, flagword,

 41755 +   asection *, bfd_vma, const char *, bfd_boolean copy,

 41756 +   bfd_boolean constructor, struct bfd_link_hash_entry **);

 41757 +

 41758 +/* Generic routine to mark section as supplying symbols only.  */

 41759 +extern void _bfd_generic_link_just_syms

 41760 +  (asection *, struct bfd_link_info *);

 41761 +

 41762 +/* Generic link routine.  */

 41763 +extern bfd_boolean _bfd_generic_final_link

 41764 +  (bfd *, struct bfd_link_info *);

 41765 +

 41766 +extern bfd_boolean _bfd_generic_link_split_section

 41767 +  (bfd *, struct bfd_section *);

 41768 +

 41769 +extern void _bfd_generic_section_already_linked

 41770 +  (bfd *, struct bfd_section *, struct bfd_link_info *);

 41771 +

 41772 +/* Generic reloc_link_order processing routine.  */

 41773 +extern bfd_boolean _bfd_generic_reloc_link_order

 41774 +  (bfd *, struct bfd_link_info *, asection *, struct bfd_link_order *);

 41775 +

 41776 +/* Default link order processing routine.  */

 41777 +extern bfd_boolean _bfd_default_link_order

 41778 +  (bfd *, struct bfd_link_info *, asection *, struct bfd_link_order *);

 41779 +

 41780 +/* Count the number of reloc entries in a link order list.  */

 41781 +extern unsigned int _bfd_count_link_order_relocs

 41782 +  (struct bfd_link_order *);

 41783 +

 41784 +/* Final link relocation routine.  */

 41785 +extern bfd_reloc_status_type _bfd_final_link_relocate

 41786 +  (reloc_howto_type *, bfd *, asection *, bfd_byte *,

 41787 +   bfd_vma, bfd_vma, bfd_vma);

 41788 +

 41789 +/* Relocate a particular location by a howto and a value.  */

 41790 +extern bfd_reloc_status_type _bfd_relocate_contents

 41791 +  (reloc_howto_type *, bfd *, bfd_vma, bfd_byte *);

 41792 +

 41793 +/* Clear a given location using a given howto.  */

 41794 +extern void _bfd_clear_contents (reloc_howto_type *howto, bfd *input_bfd,

 41795 +				 bfd_byte *location);

 41796 +

 41797 +/* Link stabs in sections in the first pass.  */

 41798 +

 41799 +extern bfd_boolean _bfd_link_section_stabs

 41800 +  (bfd *, struct stab_info *, asection *, asection *, void **,

 41801 +   bfd_size_type *);

 41802 +

 41803 +/* Eliminate stabs for discarded functions and symbols.  */

 41804 +extern bfd_boolean _bfd_discard_section_stabs

 41805 +  (bfd *, asection *, void *, bfd_boolean (*) (bfd_vma, void *), void *);

 41806 +

 41807 +/* Write out the .stab section when linking stabs in sections.  */

 41808 +

 41809 +extern bfd_boolean _bfd_write_section_stabs

 41810 +  (bfd *, struct stab_info *, asection *, void **, bfd_byte *);

 41811 +

 41812 +/* Write out the .stabstr string table when linking stabs in sections.  */

 41813 +

 41814 +extern bfd_boolean _bfd_write_stab_strings

 41815 +  (bfd *, struct stab_info *);

 41816 +

 41817 +/* Find an offset within a .stab section when linking stabs in

 41818 +   sections.  */

 41819 +

 41820 +extern bfd_vma _bfd_stab_section_offset

 41821 +  (asection *, void *, bfd_vma);

 41822 +

 41823 +/* Register a SEC_MERGE section as a candidate for merging.  */

 41824 +

 41825 +extern bfd_boolean _bfd_add_merge_section

 41826 +  (bfd *, void **, asection *, void **);

 41827 +

 41828 +/* Attempt to merge SEC_MERGE sections.  */

 41829 +

 41830 +extern bfd_boolean _bfd_merge_sections

 41831 +  (bfd *, struct bfd_link_info *, void *, void (*) (bfd *, asection *));

 41832 +

 41833 +/* Write out a merged section.  */

 41834 +

 41835 +extern bfd_boolean _bfd_write_merged_section

 41836 +  (bfd *, asection *, void *);

 41837 +

 41838 +/* Find an offset within a modified SEC_MERGE section.  */

 41839 +

 41840 +extern bfd_vma _bfd_merged_section_offset

 41841 +  (bfd *, asection **, void *, bfd_vma);

 41842 +

 41843 +/* Create a string table.  */

 41844 +extern struct bfd_strtab_hash *_bfd_stringtab_init

 41845 +  (void);

 41846 +

 41847 +/* Create an XCOFF .debug section style string table.  */

 41848 +extern struct bfd_strtab_hash *_bfd_xcoff_stringtab_init

 41849 +  (void);

 41850 +

 41851 +/* Free a string table.  */

 41852 +extern void _bfd_stringtab_free

 41853 +  (struct bfd_strtab_hash *);

 41854 +

 41855 +/* Get the size of a string table.  */

 41856 +extern bfd_size_type _bfd_stringtab_size

 41857 +  (struct bfd_strtab_hash *);

 41858 +

 41859 +/* Add a string to a string table.  */

 41860 +extern bfd_size_type _bfd_stringtab_add

 41861 +  (struct bfd_strtab_hash *, const char *, bfd_boolean hash, bfd_boolean copy);

 41862 +

 41863 +/* Write out a string table.  */

 41864 +extern bfd_boolean _bfd_stringtab_emit

 41865 +  (bfd *, struct bfd_strtab_hash *);

 41866 +

 41867 +/* Check that endianness of input and output file match.  */

 41868 +extern bfd_boolean _bfd_generic_verify_endian_match

 41869 +  (bfd *, bfd *);

 41870 +

 41871 +/* Macros to tell if bfds are read or write enabled.

 41872 +

 41873 +   Note that bfds open for read may be scribbled into if the fd passed

 41874 +   to bfd_fdopenr is actually open both for read and write

 41875 +   simultaneously.  However an output bfd will never be open for

 41876 +   read.  Therefore sometimes you want to check bfd_read_p or

 41877 +   !bfd_read_p, and only sometimes bfd_write_p.

 41878 +*/

 41879 +

 41880 +#define	bfd_read_p(abfd) \

 41881 +  ((abfd)->direction == read_direction || (abfd)->direction == both_direction)

 41882 +#define	bfd_write_p(abfd) \

 41883 +  ((abfd)->direction == write_direction || (abfd)->direction == both_direction)

 41884 +

 41885 +void bfd_assert

 41886 +  (const char*,int);

 41887 +

 41888 +#define BFD_ASSERT(x) \

 41889 +  do { if (!(x)) bfd_assert(__FILE__,__LINE__); } while (0)

 41890 +

 41891 +#define BFD_FAIL() \

 41892 +  do { bfd_assert(__FILE__,__LINE__); } while (0)

 41893 +

 41894 +extern void _bfd_abort

 41895 +  (const char *, int, const char *) ATTRIBUTE_NORETURN;

 41896 +

 41897 +/* if gcc >= 2.6, we can give a function name, too */

 41898 +#if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 6)

 41899 +#define __PRETTY_FUNCTION__  ((char *) NULL)

 41900 +#endif

 41901 +

 41902 +#undef abort

 41903 +#define abort() _bfd_abort (__FILE__, __LINE__, __PRETTY_FUNCTION__)

 41904 +

 41905 +/* Manipulate a system FILE but using BFD's "file_ptr", rather than

 41906 +   the system "off_t" or "off64_t", as the offset.  */

 41907 +extern file_ptr real_ftell (FILE *file);

 41908 +extern int real_fseek (FILE *file, file_ptr offset, int whence);

 41909 +extern FILE *real_fopen (const char *filename, const char *modes);

 41910 +

 41911 +/* List of supported target vectors, and the default vector (if

 41912 +   bfd_default_vector[0] is NULL, there is no default).  */

 41913 +extern const bfd_target * const *bfd_target_vector;

 41914 +extern const bfd_target *bfd_default_vector[];

 41915 +

 41916 +/* List of associated target vectors.  */

 41917 +extern const bfd_target * const *bfd_associated_vector;

 41918 +

 41919 +/* Functions shared by the ECOFF and MIPS ELF backends, which have no

 41920 +   other common header files.  */

 41921 +

 41922 +#if defined(__STDC__) || defined(ALMOST_STDC)

 41923 +struct ecoff_find_line;

 41924 +#endif

 41925 +

 41926 +extern bfd_boolean _bfd_ecoff_locate_line

 41927 +  (bfd *, asection *, bfd_vma, struct ecoff_debug_info * const,

 41928 +   const struct ecoff_debug_swap * const, struct ecoff_find_line *,

 41929 +   const char **, const char **, unsigned int *);

 41930 +extern bfd_boolean _bfd_ecoff_get_accumulated_pdr

 41931 +  (void *, bfd_byte *);

 41932 +extern bfd_boolean _bfd_ecoff_get_accumulated_sym

 41933 +  (void *, bfd_byte *);

 41934 +extern bfd_boolean _bfd_ecoff_get_accumulated_ss

 41935 +  (void *, bfd_byte *);

 41936 +

 41937 +extern bfd_vma _bfd_get_gp_value

 41938 +  (bfd *);

 41939 +extern void _bfd_set_gp_value

 41940 +  (bfd *, bfd_vma);

 41941 +

 41942 +/* Function shared by the COFF and ELF SH backends, which have no

 41943 +   other common header files.  */

 41944 +

 41945 +#ifndef _bfd_sh_align_load_span

 41946 +extern bfd_boolean _bfd_sh_align_load_span

 41947 +  (bfd *, asection *, bfd_byte *,

 41948 +   bfd_boolean (*) (bfd *, asection *, void *, bfd_byte *, bfd_vma),

 41949 +   void *, bfd_vma **, bfd_vma *, bfd_vma, bfd_vma, bfd_boolean *);

 41950 +#endif

 41951 +

 41952 +/* This is the shape of the elements inside the already_linked hash

 41953 +   table. It maps a name onto a list of already_linked elements with

 41954 +   the same name.  */

 41955 +

 41956 +struct bfd_section_already_linked_hash_entry

 41957 +{

 41958 +  struct bfd_hash_entry root;

 41959 +  struct bfd_section_already_linked *entry;

 41960 +};

 41961 +

 41962 +struct bfd_section_already_linked

 41963 +{

 41964 +  struct bfd_section_already_linked *next;

 41965 +  asection *sec;

 41966 +};

 41967 +

 41968 +extern struct bfd_section_already_linked_hash_entry *

 41969 +  bfd_section_already_linked_table_lookup (const char *);

 41970 +extern bfd_boolean bfd_section_already_linked_table_insert

 41971 +  (struct bfd_section_already_linked_hash_entry *, asection *);

 41972 +extern void bfd_section_already_linked_table_traverse

 41973 +  (bfd_boolean (*) (struct bfd_section_already_linked_hash_entry *,

 41974 +		    void *), void *);

 41975 +

 41976 +extern bfd_vma read_unsigned_leb128 (bfd *, bfd_byte *, unsigned int *);

 41977 +extern bfd_signed_vma read_signed_leb128 (bfd *, bfd_byte *, unsigned int *);

 41978 +

 41979 +/* Extracted from init.c.  */

 41980 +/* Extracted from libbfd.c.  */

 41981 +bfd_boolean bfd_write_bigendian_4byte_int (bfd *, unsigned int);

 41982 +

 41983 +unsigned int bfd_log2 (bfd_vma x);

 41984 +

 41985 +/* Extracted from bfdio.c.  */

 41986 +struct bfd_iovec

 41987 +{

 41988 +  /* To avoid problems with macros, a "b" rather than "f"

 41989 +     prefix is prepended to each method name.  */

 41990 +  /* Attempt to read/write NBYTES on ABFD's IOSTREAM storing/fetching

 41991 +     bytes starting at PTR.  Return the number of bytes actually

 41992 +     transfered (a read past end-of-file returns less than NBYTES),

 41993 +     or -1 (setting <<bfd_error>>) if an error occurs.  */

 41994 +  file_ptr (*bread) (struct bfd *abfd, void *ptr, file_ptr nbytes);

 41995 +  file_ptr (*bwrite) (struct bfd *abfd, const void *ptr,

 41996 +                      file_ptr nbytes);

 41997 +  /* Return the current IOSTREAM file offset, or -1 (setting <<bfd_error>>

 41998 +     if an error occurs.  */

 41999 +  file_ptr (*btell) (struct bfd *abfd);

 42000 +  /* For the following, on successful completion a value of 0 is returned.

 42001 +     Otherwise, a value of -1 is returned (and  <<bfd_error>> is set).  */

 42002 +  int (*bseek) (struct bfd *abfd, file_ptr offset, int whence);

 42003 +  int (*bclose) (struct bfd *abfd);

 42004 +  int (*bflush) (struct bfd *abfd);

 42005 +  int (*bstat) (struct bfd *abfd, struct stat *sb);

 42006 +};

 42007 +/* Extracted from bfdwin.c.  */

 42008 +struct _bfd_window_internal {

 42009 +  struct _bfd_window_internal *next;

 42010 +  void *data;

 42011 +  bfd_size_type size;

 42012 +  int refcount : 31;           /* should be enough...  */

 42013 +  unsigned mapped : 1;         /* 1 = mmap, 0 = malloc */

 42014 +};

 42015 +/* Extracted from cache.c.  */

 42016 +bfd_boolean bfd_cache_init (bfd *abfd);

 42017 +

 42018 +bfd_boolean bfd_cache_close (bfd *abfd);

 42019 +

 42020 +FILE* bfd_open_file (bfd *abfd);

 42021 +

 42022 +/* Extracted from reloc.c.  */

 42023 +#ifdef _BFD_MAKE_TABLE_bfd_reloc_code_real

 42024 +

 42025 +static const char *const bfd_reloc_code_real_names[] = { "@@uninitialized@@",

 42026 +

 42027 +  "BFD_RELOC_64",

 42028 +  "BFD_RELOC_32",

 42029 +  "BFD_RELOC_26",

 42030 +  "BFD_RELOC_24",

 42031 +  "BFD_RELOC_16",

 42032 +  "BFD_RELOC_14",

 42033 +  "BFD_RELOC_8",

 42034 +  "BFD_RELOC_64_PCREL",

 42035 +  "BFD_RELOC_32_PCREL",

 42036 +  "BFD_RELOC_24_PCREL",

 42037 +  "BFD_RELOC_16_PCREL",

 42038 +  "BFD_RELOC_12_PCREL",

 42039 +  "BFD_RELOC_8_PCREL",

 42040 +  "BFD_RELOC_32_SECREL",

 42041 +  "BFD_RELOC_32_GOT_PCREL",

 42042 +  "BFD_RELOC_16_GOT_PCREL",

 42043 +  "BFD_RELOC_8_GOT_PCREL",

 42044 +  "BFD_RELOC_32_GOTOFF",

 42045 +  "BFD_RELOC_16_GOTOFF",

 42046 +  "BFD_RELOC_LO16_GOTOFF",

 42047 +  "BFD_RELOC_HI16_GOTOFF",

 42048 +  "BFD_RELOC_HI16_S_GOTOFF",

 42049 +  "BFD_RELOC_8_GOTOFF",

 42050 +  "BFD_RELOC_64_PLT_PCREL",

 42051 +  "BFD_RELOC_32_PLT_PCREL",

 42052 +  "BFD_RELOC_24_PLT_PCREL",

 42053 +  "BFD_RELOC_16_PLT_PCREL",

 42054 +  "BFD_RELOC_8_PLT_PCREL",

 42055 +  "BFD_RELOC_64_PLTOFF",

 42056 +  "BFD_RELOC_32_PLTOFF",

 42057 +  "BFD_RELOC_16_PLTOFF",

 42058 +  "BFD_RELOC_LO16_PLTOFF",

 42059 +  "BFD_RELOC_HI16_PLTOFF",

 42060 +  "BFD_RELOC_HI16_S_PLTOFF",

 42061 +  "BFD_RELOC_8_PLTOFF",

 42062 +  "BFD_RELOC_68K_GLOB_DAT",

 42063 +  "BFD_RELOC_68K_JMP_SLOT",

 42064 +  "BFD_RELOC_68K_RELATIVE",

 42065 +  "BFD_RELOC_32_BASEREL",

 42066 +  "BFD_RELOC_16_BASEREL",

 42067 +  "BFD_RELOC_LO16_BASEREL",

 42068 +  "BFD_RELOC_HI16_BASEREL",

 42069 +  "BFD_RELOC_HI16_S_BASEREL",

 42070 +  "BFD_RELOC_8_BASEREL",

 42071 +  "BFD_RELOC_RVA",

 42072 +  "BFD_RELOC_8_FFnn",

 42073 +  "BFD_RELOC_32_PCREL_S2",

 42074 +  "BFD_RELOC_16_PCREL_S2",

 42075 +  "BFD_RELOC_23_PCREL_S2",

 42076 +  "BFD_RELOC_HI22",

 42077 +  "BFD_RELOC_LO10",

 42078 +  "BFD_RELOC_GPREL16",

 42079 +  "BFD_RELOC_GPREL32",

 42080 +  "BFD_RELOC_I960_CALLJ",

 42081 +  "BFD_RELOC_NONE",

 42082 +  "BFD_RELOC_SPARC_WDISP22",

 42083 +  "BFD_RELOC_SPARC22",

 42084 +  "BFD_RELOC_SPARC13",

 42085 +  "BFD_RELOC_SPARC_GOT10",

 42086 +  "BFD_RELOC_SPARC_GOT13",

 42087 +  "BFD_RELOC_SPARC_GOT22",

 42088 +  "BFD_RELOC_SPARC_PC10",

 42089 +  "BFD_RELOC_SPARC_PC22",

 42090 +  "BFD_RELOC_SPARC_WPLT30",

 42091 +  "BFD_RELOC_SPARC_COPY",

 42092 +  "BFD_RELOC_SPARC_GLOB_DAT",

 42093 +  "BFD_RELOC_SPARC_JMP_SLOT",

 42094 +  "BFD_RELOC_SPARC_RELATIVE",

 42095 +  "BFD_RELOC_SPARC_UA16",

 42096 +  "BFD_RELOC_SPARC_UA32",

 42097 +  "BFD_RELOC_SPARC_UA64",

 42098 +  "BFD_RELOC_SPARC_BASE13",

 42099 +  "BFD_RELOC_SPARC_BASE22",

 42100 +  "BFD_RELOC_SPARC_10",

 42101 +  "BFD_RELOC_SPARC_11",

 42102 +  "BFD_RELOC_SPARC_OLO10",

 42103 +  "BFD_RELOC_SPARC_HH22",

 42104 +  "BFD_RELOC_SPARC_HM10",

 42105 +  "BFD_RELOC_SPARC_LM22",

 42106 +  "BFD_RELOC_SPARC_PC_HH22",

 42107 +  "BFD_RELOC_SPARC_PC_HM10",

 42108 +  "BFD_RELOC_SPARC_PC_LM22",

 42109 +  "BFD_RELOC_SPARC_WDISP16",

 42110 +  "BFD_RELOC_SPARC_WDISP19",

 42111 +  "BFD_RELOC_SPARC_7",

 42112 +  "BFD_RELOC_SPARC_6",

 42113 +  "BFD_RELOC_SPARC_5",

 42114 +  "BFD_RELOC_SPARC_PLT32",

 42115 +  "BFD_RELOC_SPARC_PLT64",

 42116 +  "BFD_RELOC_SPARC_HIX22",

 42117 +  "BFD_RELOC_SPARC_LOX10",

 42118 +  "BFD_RELOC_SPARC_H44",

 42119 +  "BFD_RELOC_SPARC_M44",

 42120 +  "BFD_RELOC_SPARC_L44",

 42121 +  "BFD_RELOC_SPARC_REGISTER",

 42122 +  "BFD_RELOC_SPARC_REV32",

 42123 +  "BFD_RELOC_SPARC_TLS_GD_HI22",

 42124 +  "BFD_RELOC_SPARC_TLS_GD_LO10",

 42125 +  "BFD_RELOC_SPARC_TLS_GD_ADD",

 42126 +  "BFD_RELOC_SPARC_TLS_GD_CALL",

 42127 +  "BFD_RELOC_SPARC_TLS_LDM_HI22",

 42128 +  "BFD_RELOC_SPARC_TLS_LDM_LO10",

 42129 +  "BFD_RELOC_SPARC_TLS_LDM_ADD",

 42130 +  "BFD_RELOC_SPARC_TLS_LDM_CALL",

 42131 +  "BFD_RELOC_SPARC_TLS_LDO_HIX22",

 42132 +  "BFD_RELOC_SPARC_TLS_LDO_LOX10",

 42133 +  "BFD_RELOC_SPARC_TLS_LDO_ADD",

 42134 +  "BFD_RELOC_SPARC_TLS_IE_HI22",

 42135 +  "BFD_RELOC_SPARC_TLS_IE_LO10",

 42136 +  "BFD_RELOC_SPARC_TLS_IE_LD",

 42137 +  "BFD_RELOC_SPARC_TLS_IE_LDX",

 42138 +  "BFD_RELOC_SPARC_TLS_IE_ADD",

 42139 +  "BFD_RELOC_SPARC_TLS_LE_HIX22",

 42140 +  "BFD_RELOC_SPARC_TLS_LE_LOX10",

 42141 +  "BFD_RELOC_SPARC_TLS_DTPMOD32",

 42142 +  "BFD_RELOC_SPARC_TLS_DTPMOD64",

 42143 +  "BFD_RELOC_SPARC_TLS_DTPOFF32",

 42144 +  "BFD_RELOC_SPARC_TLS_DTPOFF64",

 42145 +  "BFD_RELOC_SPARC_TLS_TPOFF32",

 42146 +  "BFD_RELOC_SPARC_TLS_TPOFF64",

 42147 +  "BFD_RELOC_SPU_IMM7",

 42148 +  "BFD_RELOC_SPU_IMM8",

 42149 +  "BFD_RELOC_SPU_IMM10",

 42150 +  "BFD_RELOC_SPU_IMM10W",

 42151 +  "BFD_RELOC_SPU_IMM16",

 42152 +  "BFD_RELOC_SPU_IMM16W",

 42153 +  "BFD_RELOC_SPU_IMM18",

 42154 +  "BFD_RELOC_SPU_PCREL9a",

 42155 +  "BFD_RELOC_SPU_PCREL9b",

 42156 +  "BFD_RELOC_SPU_PCREL16",

 42157 +  "BFD_RELOC_SPU_LO16",

 42158 +  "BFD_RELOC_SPU_HI16",

 42159 +  "BFD_RELOC_SPU_PPU32",

 42160 +  "BFD_RELOC_SPU_PPU64",

 42161 +  "BFD_RELOC_ALPHA_GPDISP_HI16",

 42162 +  "BFD_RELOC_ALPHA_GPDISP_LO16",

 42163 +  "BFD_RELOC_ALPHA_GPDISP",

 42164 +  "BFD_RELOC_ALPHA_LITERAL",

 42165 +  "BFD_RELOC_ALPHA_ELF_LITERAL",

 42166 +  "BFD_RELOC_ALPHA_LITUSE",

 42167 +  "BFD_RELOC_ALPHA_HINT",

 42168 +  "BFD_RELOC_ALPHA_LINKAGE",

 42169 +  "BFD_RELOC_ALPHA_CODEADDR",

 42170 +  "BFD_RELOC_ALPHA_GPREL_HI16",

 42171 +  "BFD_RELOC_ALPHA_GPREL_LO16",

 42172 +  "BFD_RELOC_ALPHA_BRSGP",

 42173 +  "BFD_RELOC_ALPHA_TLSGD",

 42174 +  "BFD_RELOC_ALPHA_TLSLDM",

 42175 +  "BFD_RELOC_ALPHA_DTPMOD64",

 42176 +  "BFD_RELOC_ALPHA_GOTDTPREL16",

 42177 +  "BFD_RELOC_ALPHA_DTPREL64",

 42178 +  "BFD_RELOC_ALPHA_DTPREL_HI16",

 42179 +  "BFD_RELOC_ALPHA_DTPREL_LO16",

 42180 +  "BFD_RELOC_ALPHA_DTPREL16",

 42181 +  "BFD_RELOC_ALPHA_GOTTPREL16",

 42182 +  "BFD_RELOC_ALPHA_TPREL64",

 42183 +  "BFD_RELOC_ALPHA_TPREL_HI16",

 42184 +  "BFD_RELOC_ALPHA_TPREL_LO16",

 42185 +  "BFD_RELOC_ALPHA_TPREL16",

 42186 +  "BFD_RELOC_MIPS_JMP",

 42187 +  "BFD_RELOC_MIPS16_JMP",

 42188 +  "BFD_RELOC_MIPS16_GPREL",

 42189 +  "BFD_RELOC_HI16",

 42190 +  "BFD_RELOC_HI16_S",

 42191 +  "BFD_RELOC_LO16",

 42192 +  "BFD_RELOC_HI16_PCREL",

 42193 +  "BFD_RELOC_HI16_S_PCREL",

 42194 +  "BFD_RELOC_LO16_PCREL",

 42195 +  "BFD_RELOC_MIPS16_HI16",

 42196 +  "BFD_RELOC_MIPS16_HI16_S",

 42197 +  "BFD_RELOC_MIPS16_LO16",

 42198 +  "BFD_RELOC_MIPS_LITERAL",

 42199 +  "BFD_RELOC_MIPS_GOT16",

 42200 +  "BFD_RELOC_MIPS_CALL16",

 42201 +  "BFD_RELOC_MIPS_GOT_HI16",

 42202 +  "BFD_RELOC_MIPS_GOT_LO16",

 42203 +  "BFD_RELOC_MIPS_CALL_HI16",

 42204 +  "BFD_RELOC_MIPS_CALL_LO16",

 42205 +  "BFD_RELOC_MIPS_SUB",

 42206 +  "BFD_RELOC_MIPS_GOT_PAGE",

 42207 +  "BFD_RELOC_MIPS_GOT_OFST",

 42208 +  "BFD_RELOC_MIPS_GOT_DISP",

 42209 +  "BFD_RELOC_MIPS_SHIFT5",

 42210 +  "BFD_RELOC_MIPS_SHIFT6",

 42211 +  "BFD_RELOC_MIPS_INSERT_A",

 42212 +  "BFD_RELOC_MIPS_INSERT_B",

 42213 +  "BFD_RELOC_MIPS_DELETE",

 42214 +  "BFD_RELOC_MIPS_HIGHEST",

 42215 +  "BFD_RELOC_MIPS_HIGHER",

 42216 +  "BFD_RELOC_MIPS_SCN_DISP",

 42217 +  "BFD_RELOC_MIPS_REL16",

 42218 +  "BFD_RELOC_MIPS_RELGOT",

 42219 +  "BFD_RELOC_MIPS_JALR",

 42220 +  "BFD_RELOC_MIPS_TLS_DTPMOD32",

 42221 +  "BFD_RELOC_MIPS_TLS_DTPREL32",

 42222 +  "BFD_RELOC_MIPS_TLS_DTPMOD64",

 42223 +  "BFD_RELOC_MIPS_TLS_DTPREL64",

 42224 +  "BFD_RELOC_MIPS_TLS_GD",

 42225 +  "BFD_RELOC_MIPS_TLS_LDM",

 42226 +  "BFD_RELOC_MIPS_TLS_DTPREL_HI16",

 42227 +  "BFD_RELOC_MIPS_TLS_DTPREL_LO16",

 42228 +  "BFD_RELOC_MIPS_TLS_GOTTPREL",

 42229 +  "BFD_RELOC_MIPS_TLS_TPREL32",

 42230 +  "BFD_RELOC_MIPS_TLS_TPREL64",

 42231 +  "BFD_RELOC_MIPS_TLS_TPREL_HI16",

 42232 +  "BFD_RELOC_MIPS_TLS_TPREL_LO16",

 42233 +

 42234 +  "BFD_RELOC_MIPS_COPY",

 42235 +  "BFD_RELOC_MIPS_JUMP_SLOT",

 42236 +

 42237 +  "BFD_RELOC_FRV_LABEL16",

 42238 +  "BFD_RELOC_FRV_LABEL24",

 42239 +  "BFD_RELOC_FRV_LO16",

 42240 +  "BFD_RELOC_FRV_HI16",

 42241 +  "BFD_RELOC_FRV_GPREL12",

 42242 +  "BFD_RELOC_FRV_GPRELU12",

 42243 +  "BFD_RELOC_FRV_GPREL32",

 42244 +  "BFD_RELOC_FRV_GPRELHI",

 42245 +  "BFD_RELOC_FRV_GPRELLO",

 42246 +  "BFD_RELOC_FRV_GOT12",

 42247 +  "BFD_RELOC_FRV_GOTHI",

 42248 +  "BFD_RELOC_FRV_GOTLO",

 42249 +  "BFD_RELOC_FRV_FUNCDESC",

 42250 +  "BFD_RELOC_FRV_FUNCDESC_GOT12",

 42251 +  "BFD_RELOC_FRV_FUNCDESC_GOTHI",

 42252 +  "BFD_RELOC_FRV_FUNCDESC_GOTLO",

 42253 +  "BFD_RELOC_FRV_FUNCDESC_VALUE",

 42254 +  "BFD_RELOC_FRV_FUNCDESC_GOTOFF12",

 42255 +  "BFD_RELOC_FRV_FUNCDESC_GOTOFFHI",

 42256 +  "BFD_RELOC_FRV_FUNCDESC_GOTOFFLO",

 42257 +  "BFD_RELOC_FRV_GOTOFF12",

 42258 +  "BFD_RELOC_FRV_GOTOFFHI",

 42259 +  "BFD_RELOC_FRV_GOTOFFLO",

 42260 +  "BFD_RELOC_FRV_GETTLSOFF",

 42261 +  "BFD_RELOC_FRV_TLSDESC_VALUE",

 42262 +  "BFD_RELOC_FRV_GOTTLSDESC12",

 42263 +  "BFD_RELOC_FRV_GOTTLSDESCHI",

 42264 +  "BFD_RELOC_FRV_GOTTLSDESCLO",

 42265 +  "BFD_RELOC_FRV_TLSMOFF12",

 42266 +  "BFD_RELOC_FRV_TLSMOFFHI",

 42267 +  "BFD_RELOC_FRV_TLSMOFFLO",

 42268 +  "BFD_RELOC_FRV_GOTTLSOFF12",

 42269 +  "BFD_RELOC_FRV_GOTTLSOFFHI",

 42270 +  "BFD_RELOC_FRV_GOTTLSOFFLO",

 42271 +  "BFD_RELOC_FRV_TLSOFF",

 42272 +  "BFD_RELOC_FRV_TLSDESC_RELAX",

 42273 +  "BFD_RELOC_FRV_GETTLSOFF_RELAX",

 42274 +  "BFD_RELOC_FRV_TLSOFF_RELAX",

 42275 +  "BFD_RELOC_FRV_TLSMOFF",

 42276 +

 42277 +  "BFD_RELOC_MN10300_GOTOFF24",

 42278 +  "BFD_RELOC_MN10300_GOT32",

 42279 +  "BFD_RELOC_MN10300_GOT24",

 42280 +  "BFD_RELOC_MN10300_GOT16",

 42281 +  "BFD_RELOC_MN10300_COPY",

 42282 +  "BFD_RELOC_MN10300_GLOB_DAT",

 42283 +  "BFD_RELOC_MN10300_JMP_SLOT",

 42284 +  "BFD_RELOC_MN10300_RELATIVE",

 42285 +

 42286 +  "BFD_RELOC_386_GOT32",

 42287 +  "BFD_RELOC_386_PLT32",

 42288 +  "BFD_RELOC_386_COPY",

 42289 +  "BFD_RELOC_386_GLOB_DAT",

 42290 +  "BFD_RELOC_386_JUMP_SLOT",

 42291 +  "BFD_RELOC_386_RELATIVE",

 42292 +  "BFD_RELOC_386_GOTOFF",

 42293 +  "BFD_RELOC_386_GOTPC",

 42294 +  "BFD_RELOC_386_TLS_TPOFF",

 42295 +  "BFD_RELOC_386_TLS_IE",

 42296 +  "BFD_RELOC_386_TLS_GOTIE",

 42297 +  "BFD_RELOC_386_TLS_LE",

 42298 +  "BFD_RELOC_386_TLS_GD",

 42299 +  "BFD_RELOC_386_TLS_LDM",

 42300 +  "BFD_RELOC_386_TLS_LDO_32",

 42301 +  "BFD_RELOC_386_TLS_IE_32",

 42302 +  "BFD_RELOC_386_TLS_LE_32",

 42303 +  "BFD_RELOC_386_TLS_DTPMOD32",

 42304 +  "BFD_RELOC_386_TLS_DTPOFF32",

 42305 +  "BFD_RELOC_386_TLS_TPOFF32",

 42306 +  "BFD_RELOC_386_TLS_GOTDESC",

 42307 +  "BFD_RELOC_386_TLS_DESC_CALL",

 42308 +  "BFD_RELOC_386_TLS_DESC",

 42309 +  "BFD_RELOC_X86_64_GOT32",

 42310 +  "BFD_RELOC_X86_64_PLT32",

 42311 +  "BFD_RELOC_X86_64_COPY",

 42312 +  "BFD_RELOC_X86_64_GLOB_DAT",

 42313 +  "BFD_RELOC_X86_64_JUMP_SLOT",

 42314 +  "BFD_RELOC_X86_64_RELATIVE",

 42315 +  "BFD_RELOC_X86_64_GOTPCREL",

 42316 +  "BFD_RELOC_X86_64_32S",

 42317 +  "BFD_RELOC_X86_64_DTPMOD64",

 42318 +  "BFD_RELOC_X86_64_DTPOFF64",

 42319 +  "BFD_RELOC_X86_64_TPOFF64",

 42320 +  "BFD_RELOC_X86_64_TLSGD",

 42321 +  "BFD_RELOC_X86_64_TLSLD",

 42322 +  "BFD_RELOC_X86_64_DTPOFF32",

 42323 +  "BFD_RELOC_X86_64_GOTTPOFF",

 42324 +  "BFD_RELOC_X86_64_TPOFF32",

 42325 +  "BFD_RELOC_X86_64_GOTOFF64",

 42326 +  "BFD_RELOC_X86_64_GOTPC32",

 42327 +  "BFD_RELOC_X86_64_GOT64",

 42328 +  "BFD_RELOC_X86_64_GOTPCREL64",

 42329 +  "BFD_RELOC_X86_64_GOTPC64",

 42330 +  "BFD_RELOC_X86_64_GOTPLT64",

 42331 +  "BFD_RELOC_X86_64_PLTOFF64",

 42332 +  "BFD_RELOC_X86_64_GOTPC32_TLSDESC",

 42333 +  "BFD_RELOC_X86_64_TLSDESC_CALL",

 42334 +  "BFD_RELOC_X86_64_TLSDESC",

 42335 +  "BFD_RELOC_NS32K_IMM_8",

 42336 +  "BFD_RELOC_NS32K_IMM_16",

 42337 +  "BFD_RELOC_NS32K_IMM_32",

 42338 +  "BFD_RELOC_NS32K_IMM_8_PCREL",

 42339 +  "BFD_RELOC_NS32K_IMM_16_PCREL",

 42340 +  "BFD_RELOC_NS32K_IMM_32_PCREL",

 42341 +  "BFD_RELOC_NS32K_DISP_8",

 42342 +  "BFD_RELOC_NS32K_DISP_16",

 42343 +  "BFD_RELOC_NS32K_DISP_32",

 42344 +  "BFD_RELOC_NS32K_DISP_8_PCREL",

 42345 +  "BFD_RELOC_NS32K_DISP_16_PCREL",

 42346 +  "BFD_RELOC_NS32K_DISP_32_PCREL",

 42347 +  "BFD_RELOC_PDP11_DISP_8_PCREL",

 42348 +  "BFD_RELOC_PDP11_DISP_6_PCREL",

 42349 +  "BFD_RELOC_PJ_CODE_HI16",

 42350 +  "BFD_RELOC_PJ_CODE_LO16",

 42351 +  "BFD_RELOC_PJ_CODE_DIR16",

 42352 +  "BFD_RELOC_PJ_CODE_DIR32",

 42353 +  "BFD_RELOC_PJ_CODE_REL16",

 42354 +  "BFD_RELOC_PJ_CODE_REL32",

 42355 +  "BFD_RELOC_PPC_B26",

 42356 +  "BFD_RELOC_PPC_BA26",

 42357 +  "BFD_RELOC_PPC_TOC16",

 42358 +  "BFD_RELOC_PPC_B16",

 42359 +  "BFD_RELOC_PPC_B16_BRTAKEN",

 42360 +  "BFD_RELOC_PPC_B16_BRNTAKEN",

 42361 +  "BFD_RELOC_PPC_BA16",

 42362 +  "BFD_RELOC_PPC_BA16_BRTAKEN",

 42363 +  "BFD_RELOC_PPC_BA16_BRNTAKEN",

 42364 +  "BFD_RELOC_PPC_COPY",

 42365 +  "BFD_RELOC_PPC_GLOB_DAT",

 42366 +  "BFD_RELOC_PPC_JMP_SLOT",

 42367 +  "BFD_RELOC_PPC_RELATIVE",

 42368 +  "BFD_RELOC_PPC_LOCAL24PC",

 42369 +  "BFD_RELOC_PPC_EMB_NADDR32",

 42370 +  "BFD_RELOC_PPC_EMB_NADDR16",

 42371 +  "BFD_RELOC_PPC_EMB_NADDR16_LO",

 42372 +  "BFD_RELOC_PPC_EMB_NADDR16_HI",

 42373 +  "BFD_RELOC_PPC_EMB_NADDR16_HA",

 42374 +  "BFD_RELOC_PPC_EMB_SDAI16",

 42375 +  "BFD_RELOC_PPC_EMB_SDA2I16",

 42376 +  "BFD_RELOC_PPC_EMB_SDA2REL",

 42377 +  "BFD_RELOC_PPC_EMB_SDA21",

 42378 +  "BFD_RELOC_PPC_EMB_MRKREF",

 42379 +  "BFD_RELOC_PPC_EMB_RELSEC16",

 42380 +  "BFD_RELOC_PPC_EMB_RELST_LO",

 42381 +  "BFD_RELOC_PPC_EMB_RELST_HI",

 42382 +  "BFD_RELOC_PPC_EMB_RELST_HA",

 42383 +  "BFD_RELOC_PPC_EMB_BIT_FLD",

 42384 +  "BFD_RELOC_PPC_EMB_RELSDA",

 42385 +  "BFD_RELOC_PPC64_HIGHER",

 42386 +  "BFD_RELOC_PPC64_HIGHER_S",

 42387 +  "BFD_RELOC_PPC64_HIGHEST",

 42388 +  "BFD_RELOC_PPC64_HIGHEST_S",

 42389 +  "BFD_RELOC_PPC64_TOC16_LO",

 42390 +  "BFD_RELOC_PPC64_TOC16_HI",

 42391 +  "BFD_RELOC_PPC64_TOC16_HA",

 42392 +  "BFD_RELOC_PPC64_TOC",

 42393 +  "BFD_RELOC_PPC64_PLTGOT16",

 42394 +  "BFD_RELOC_PPC64_PLTGOT16_LO",

 42395 +  "BFD_RELOC_PPC64_PLTGOT16_HI",

 42396 +  "BFD_RELOC_PPC64_PLTGOT16_HA",

 42397 +  "BFD_RELOC_PPC64_ADDR16_DS",

 42398 +  "BFD_RELOC_PPC64_ADDR16_LO_DS",

 42399 +  "BFD_RELOC_PPC64_GOT16_DS",

 42400 +  "BFD_RELOC_PPC64_GOT16_LO_DS",

 42401 +  "BFD_RELOC_PPC64_PLT16_LO_DS",

 42402 +  "BFD_RELOC_PPC64_SECTOFF_DS",

 42403 +  "BFD_RELOC_PPC64_SECTOFF_LO_DS",

 42404 +  "BFD_RELOC_PPC64_TOC16_DS",

 42405 +  "BFD_RELOC_PPC64_TOC16_LO_DS",

 42406 +  "BFD_RELOC_PPC64_PLTGOT16_DS",

 42407 +  "BFD_RELOC_PPC64_PLTGOT16_LO_DS",

 42408 +  "BFD_RELOC_PPC_TLS",

 42409 +  "BFD_RELOC_PPC_DTPMOD",

 42410 +  "BFD_RELOC_PPC_TPREL16",

 42411 +  "BFD_RELOC_PPC_TPREL16_LO",

 42412 +  "BFD_RELOC_PPC_TPREL16_HI",

 42413 +  "BFD_RELOC_PPC_TPREL16_HA",

 42414 +  "BFD_RELOC_PPC_TPREL",

 42415 +  "BFD_RELOC_PPC_DTPREL16",

 42416 +  "BFD_RELOC_PPC_DTPREL16_LO",

 42417 +  "BFD_RELOC_PPC_DTPREL16_HI",

 42418 +  "BFD_RELOC_PPC_DTPREL16_HA",

 42419 +  "BFD_RELOC_PPC_DTPREL",

 42420 +  "BFD_RELOC_PPC_GOT_TLSGD16",

 42421 +  "BFD_RELOC_PPC_GOT_TLSGD16_LO",

 42422 +  "BFD_RELOC_PPC_GOT_TLSGD16_HI",

 42423 +  "BFD_RELOC_PPC_GOT_TLSGD16_HA",

 42424 +  "BFD_RELOC_PPC_GOT_TLSLD16",

 42425 +  "BFD_RELOC_PPC_GOT_TLSLD16_LO",

 42426 +  "BFD_RELOC_PPC_GOT_TLSLD16_HI",

 42427 +  "BFD_RELOC_PPC_GOT_TLSLD16_HA",

 42428 +  "BFD_RELOC_PPC_GOT_TPREL16",

 42429 +  "BFD_RELOC_PPC_GOT_TPREL16_LO",

 42430 +  "BFD_RELOC_PPC_GOT_TPREL16_HI",

 42431 +  "BFD_RELOC_PPC_GOT_TPREL16_HA",

 42432 +  "BFD_RELOC_PPC_GOT_DTPREL16",

 42433 +  "BFD_RELOC_PPC_GOT_DTPREL16_LO",

 42434 +  "BFD_RELOC_PPC_GOT_DTPREL16_HI",

 42435 +  "BFD_RELOC_PPC_GOT_DTPREL16_HA",

 42436 +  "BFD_RELOC_PPC64_TPREL16_DS",

 42437 +  "BFD_RELOC_PPC64_TPREL16_LO_DS",

 42438 +  "BFD_RELOC_PPC64_TPREL16_HIGHER",

 42439 +  "BFD_RELOC_PPC64_TPREL16_HIGHERA",

 42440 +  "BFD_RELOC_PPC64_TPREL16_HIGHEST",

 42441 +  "BFD_RELOC_PPC64_TPREL16_HIGHESTA",

 42442 +  "BFD_RELOC_PPC64_DTPREL16_DS",

 42443 +  "BFD_RELOC_PPC64_DTPREL16_LO_DS",

 42444 +  "BFD_RELOC_PPC64_DTPREL16_HIGHER",

 42445 +  "BFD_RELOC_PPC64_DTPREL16_HIGHERA",

 42446 +  "BFD_RELOC_PPC64_DTPREL16_HIGHEST",

 42447 +  "BFD_RELOC_PPC64_DTPREL16_HIGHESTA",

 42448 +  "BFD_RELOC_I370_D12",

 42449 +  "BFD_RELOC_CTOR",

 42450 +  "BFD_RELOC_ARM_PCREL_BRANCH",

 42451 +  "BFD_RELOC_ARM_PCREL_BLX",

 42452 +  "BFD_RELOC_THUMB_PCREL_BLX",

 42453 +  "BFD_RELOC_ARM_PCREL_CALL",

 42454 +  "BFD_RELOC_ARM_PCREL_JUMP",

 42455 +  "BFD_RELOC_THUMB_PCREL_BRANCH7",

 42456 +  "BFD_RELOC_THUMB_PCREL_BRANCH9",

 42457 +  "BFD_RELOC_THUMB_PCREL_BRANCH12",

 42458 +  "BFD_RELOC_THUMB_PCREL_BRANCH20",

 42459 +  "BFD_RELOC_THUMB_PCREL_BRANCH23",

 42460 +  "BFD_RELOC_THUMB_PCREL_BRANCH25",

 42461 +  "BFD_RELOC_ARM_OFFSET_IMM",

 42462 +  "BFD_RELOC_ARM_THUMB_OFFSET",

 42463 +  "BFD_RELOC_ARM_TARGET1",

 42464 +  "BFD_RELOC_ARM_ROSEGREL32",

 42465 +  "BFD_RELOC_ARM_SBREL32",

 42466 +  "BFD_RELOC_ARM_TARGET2",

 42467 +  "BFD_RELOC_ARM_PREL31",

 42468 +  "BFD_RELOC_ARM_MOVW",

 42469 +  "BFD_RELOC_ARM_MOVT",

 42470 +  "BFD_RELOC_ARM_MOVW_PCREL",

 42471 +  "BFD_RELOC_ARM_MOVT_PCREL",

 42472 +  "BFD_RELOC_ARM_THUMB_MOVW",

 42473 +  "BFD_RELOC_ARM_THUMB_MOVT",

 42474 +  "BFD_RELOC_ARM_THUMB_MOVW_PCREL",

 42475 +  "BFD_RELOC_ARM_THUMB_MOVT_PCREL",

 42476 +  "BFD_RELOC_ARM_JUMP_SLOT",

 42477 +  "BFD_RELOC_ARM_GLOB_DAT",

 42478 +  "BFD_RELOC_ARM_GOT32",

 42479 +  "BFD_RELOC_ARM_PLT32",

 42480 +  "BFD_RELOC_ARM_RELATIVE",

 42481 +  "BFD_RELOC_ARM_GOTOFF",

 42482 +  "BFD_RELOC_ARM_GOTPC",

 42483 +  "BFD_RELOC_ARM_TLS_GD32",

 42484 +  "BFD_RELOC_ARM_TLS_LDO32",

 42485 +  "BFD_RELOC_ARM_TLS_LDM32",

 42486 +  "BFD_RELOC_ARM_TLS_DTPOFF32",

 42487 +  "BFD_RELOC_ARM_TLS_DTPMOD32",

 42488 +  "BFD_RELOC_ARM_TLS_TPOFF32",

 42489 +  "BFD_RELOC_ARM_TLS_IE32",

 42490 +  "BFD_RELOC_ARM_TLS_LE32",

 42491 +  "BFD_RELOC_ARM_ALU_PC_G0_NC",

 42492 +  "BFD_RELOC_ARM_ALU_PC_G0",

 42493 +  "BFD_RELOC_ARM_ALU_PC_G1_NC",

 42494 +  "BFD_RELOC_ARM_ALU_PC_G1",

 42495 +  "BFD_RELOC_ARM_ALU_PC_G2",

 42496 +  "BFD_RELOC_ARM_LDR_PC_G0",

 42497 +  "BFD_RELOC_ARM_LDR_PC_G1",

 42498 +  "BFD_RELOC_ARM_LDR_PC_G2",

 42499 +  "BFD_RELOC_ARM_LDRS_PC_G0",

 42500 +  "BFD_RELOC_ARM_LDRS_PC_G1",

 42501 +  "BFD_RELOC_ARM_LDRS_PC_G2",

 42502 +  "BFD_RELOC_ARM_LDC_PC_G0",

 42503 +  "BFD_RELOC_ARM_LDC_PC_G1",

 42504 +  "BFD_RELOC_ARM_LDC_PC_G2",

 42505 +  "BFD_RELOC_ARM_ALU_SB_G0_NC",

 42506 +  "BFD_RELOC_ARM_ALU_SB_G0",

 42507 +  "BFD_RELOC_ARM_ALU_SB_G1_NC",

 42508 +  "BFD_RELOC_ARM_ALU_SB_G1",

 42509 +  "BFD_RELOC_ARM_ALU_SB_G2",

 42510 +  "BFD_RELOC_ARM_LDR_SB_G0",

 42511 +  "BFD_RELOC_ARM_LDR_SB_G1",

 42512 +  "BFD_RELOC_ARM_LDR_SB_G2",

 42513 +  "BFD_RELOC_ARM_LDRS_SB_G0",

 42514 +  "BFD_RELOC_ARM_LDRS_SB_G1",

 42515 +  "BFD_RELOC_ARM_LDRS_SB_G2",

 42516 +  "BFD_RELOC_ARM_LDC_SB_G0",

 42517 +  "BFD_RELOC_ARM_LDC_SB_G1",

 42518 +  "BFD_RELOC_ARM_LDC_SB_G2",

 42519 +  "BFD_RELOC_ARM_IMMEDIATE",

 42520 +  "BFD_RELOC_ARM_ADRL_IMMEDIATE",

 42521 +  "BFD_RELOC_ARM_T32_IMMEDIATE",

 42522 +  "BFD_RELOC_ARM_T32_ADD_IMM",

 42523 +  "BFD_RELOC_ARM_T32_IMM12",

 42524 +  "BFD_RELOC_ARM_T32_ADD_PC12",

 42525 +  "BFD_RELOC_ARM_SHIFT_IMM",

 42526 +  "BFD_RELOC_ARM_SMC",

 42527 +  "BFD_RELOC_ARM_SWI",

 42528 +  "BFD_RELOC_ARM_MULTI",

 42529 +  "BFD_RELOC_ARM_CP_OFF_IMM",

 42530 +  "BFD_RELOC_ARM_CP_OFF_IMM_S2",

 42531 +  "BFD_RELOC_ARM_T32_CP_OFF_IMM",

 42532 +  "BFD_RELOC_ARM_T32_CP_OFF_IMM_S2",

 42533 +  "BFD_RELOC_ARM_ADR_IMM",

 42534 +  "BFD_RELOC_ARM_LDR_IMM",

 42535 +  "BFD_RELOC_ARM_LITERAL",

 42536 +  "BFD_RELOC_ARM_IN_POOL",

 42537 +  "BFD_RELOC_ARM_OFFSET_IMM8",

 42538 +  "BFD_RELOC_ARM_T32_OFFSET_U8",

 42539 +  "BFD_RELOC_ARM_T32_OFFSET_IMM",

 42540 +  "BFD_RELOC_ARM_HWLITERAL",

 42541 +  "BFD_RELOC_ARM_THUMB_ADD",

 42542 +  "BFD_RELOC_ARM_THUMB_IMM",

 42543 +  "BFD_RELOC_ARM_THUMB_SHIFT",

 42544 +  "BFD_RELOC_SH_PCDISP8BY2",

 42545 +  "BFD_RELOC_SH_PCDISP12BY2",

 42546 +  "BFD_RELOC_SH_IMM3",

 42547 +  "BFD_RELOC_SH_IMM3U",

 42548 +  "BFD_RELOC_SH_DISP12",

 42549 +  "BFD_RELOC_SH_DISP12BY2",

 42550 +  "BFD_RELOC_SH_DISP12BY4",

 42551 +  "BFD_RELOC_SH_DISP12BY8",

 42552 +  "BFD_RELOC_SH_DISP20",

 42553 +  "BFD_RELOC_SH_DISP20BY8",

 42554 +  "BFD_RELOC_SH_IMM4",

 42555 +  "BFD_RELOC_SH_IMM4BY2",

 42556 +  "BFD_RELOC_SH_IMM4BY4",

 42557 +  "BFD_RELOC_SH_IMM8",

 42558 +  "BFD_RELOC_SH_IMM8BY2",

 42559 +  "BFD_RELOC_SH_IMM8BY4",

 42560 +  "BFD_RELOC_SH_PCRELIMM8BY2",

 42561 +  "BFD_RELOC_SH_PCRELIMM8BY4",

 42562 +  "BFD_RELOC_SH_SWITCH16",

 42563 +  "BFD_RELOC_SH_SWITCH32",

 42564 +  "BFD_RELOC_SH_USES",

 42565 +  "BFD_RELOC_SH_COUNT",

 42566 +  "BFD_RELOC_SH_ALIGN",

 42567 +  "BFD_RELOC_SH_CODE",

 42568 +  "BFD_RELOC_SH_DATA",

 42569 +  "BFD_RELOC_SH_LABEL",

 42570 +  "BFD_RELOC_SH_LOOP_START",

 42571 +  "BFD_RELOC_SH_LOOP_END",

 42572 +  "BFD_RELOC_SH_COPY",

 42573 +  "BFD_RELOC_SH_GLOB_DAT",

 42574 +  "BFD_RELOC_SH_JMP_SLOT",

 42575 +  "BFD_RELOC_SH_RELATIVE",

 42576 +  "BFD_RELOC_SH_GOTPC",

 42577 +  "BFD_RELOC_SH_GOT_LOW16",

 42578 +  "BFD_RELOC_SH_GOT_MEDLOW16",

 42579 +  "BFD_RELOC_SH_GOT_MEDHI16",

 42580 +  "BFD_RELOC_SH_GOT_HI16",

 42581 +  "BFD_RELOC_SH_GOTPLT_LOW16",

 42582 +  "BFD_RELOC_SH_GOTPLT_MEDLOW16",

 42583 +  "BFD_RELOC_SH_GOTPLT_MEDHI16",

 42584 +  "BFD_RELOC_SH_GOTPLT_HI16",

 42585 +  "BFD_RELOC_SH_PLT_LOW16",

 42586 +  "BFD_RELOC_SH_PLT_MEDLOW16",

 42587 +  "BFD_RELOC_SH_PLT_MEDHI16",

 42588 +  "BFD_RELOC_SH_PLT_HI16",

 42589 +  "BFD_RELOC_SH_GOTOFF_LOW16",

 42590 +  "BFD_RELOC_SH_GOTOFF_MEDLOW16",

 42591 +  "BFD_RELOC_SH_GOTOFF_MEDHI16",

 42592 +  "BFD_RELOC_SH_GOTOFF_HI16",

 42593 +  "BFD_RELOC_SH_GOTPC_LOW16",

 42594 +  "BFD_RELOC_SH_GOTPC_MEDLOW16",

 42595 +  "BFD_RELOC_SH_GOTPC_MEDHI16",

 42596 +  "BFD_RELOC_SH_GOTPC_HI16",

 42597 +  "BFD_RELOC_SH_COPY64",

 42598 +  "BFD_RELOC_SH_GLOB_DAT64",

 42599 +  "BFD_RELOC_SH_JMP_SLOT64",

 42600 +  "BFD_RELOC_SH_RELATIVE64",

 42601 +  "BFD_RELOC_SH_GOT10BY4",

 42602 +  "BFD_RELOC_SH_GOT10BY8",

 42603 +  "BFD_RELOC_SH_GOTPLT10BY4",

 42604 +  "BFD_RELOC_SH_GOTPLT10BY8",

 42605 +  "BFD_RELOC_SH_GOTPLT32",

 42606 +  "BFD_RELOC_SH_SHMEDIA_CODE",

 42607 +  "BFD_RELOC_SH_IMMU5",

 42608 +  "BFD_RELOC_SH_IMMS6",

 42609 +  "BFD_RELOC_SH_IMMS6BY32",

 42610 +  "BFD_RELOC_SH_IMMU6",

 42611 +  "BFD_RELOC_SH_IMMS10",

 42612 +  "BFD_RELOC_SH_IMMS10BY2",

 42613 +  "BFD_RELOC_SH_IMMS10BY4",

 42614 +  "BFD_RELOC_SH_IMMS10BY8",

 42615 +  "BFD_RELOC_SH_IMMS16",

 42616 +  "BFD_RELOC_SH_IMMU16",

 42617 +  "BFD_RELOC_SH_IMM_LOW16",

 42618 +  "BFD_RELOC_SH_IMM_LOW16_PCREL",

 42619 +  "BFD_RELOC_SH_IMM_MEDLOW16",

 42620 +  "BFD_RELOC_SH_IMM_MEDLOW16_PCREL",

 42621 +  "BFD_RELOC_SH_IMM_MEDHI16",

 42622 +  "BFD_RELOC_SH_IMM_MEDHI16_PCREL",

 42623 +  "BFD_RELOC_SH_IMM_HI16",

 42624 +  "BFD_RELOC_SH_IMM_HI16_PCREL",

 42625 +  "BFD_RELOC_SH_PT_16",

 42626 +  "BFD_RELOC_SH_TLS_GD_32",

 42627 +  "BFD_RELOC_SH_TLS_LD_32",

 42628 +  "BFD_RELOC_SH_TLS_LDO_32",

 42629 +  "BFD_RELOC_SH_TLS_IE_32",

 42630 +  "BFD_RELOC_SH_TLS_LE_32",

 42631 +  "BFD_RELOC_SH_TLS_DTPMOD32",

 42632 +  "BFD_RELOC_SH_TLS_DTPOFF32",

 42633 +  "BFD_RELOC_SH_TLS_TPOFF32",

 42634 +  "BFD_RELOC_ARC_B22_PCREL",

 42635 +  "BFD_RELOC_ARC_B26",

 42636 +  "BFD_RELOC_BFIN_16_IMM",

 42637 +  "BFD_RELOC_BFIN_16_HIGH",

 42638 +  "BFD_RELOC_BFIN_4_PCREL",

 42639 +  "BFD_RELOC_BFIN_5_PCREL",

 42640 +  "BFD_RELOC_BFIN_16_LOW",

 42641 +  "BFD_RELOC_BFIN_10_PCREL",

 42642 +  "BFD_RELOC_BFIN_11_PCREL",

 42643 +  "BFD_RELOC_BFIN_12_PCREL_JUMP",

 42644 +  "BFD_RELOC_BFIN_12_PCREL_JUMP_S",

 42645 +  "BFD_RELOC_BFIN_24_PCREL_CALL_X",

 42646 +  "BFD_RELOC_BFIN_24_PCREL_JUMP_L",

 42647 +  "BFD_RELOC_BFIN_GOT17M4",

 42648 +  "BFD_RELOC_BFIN_GOTHI",

 42649 +  "BFD_RELOC_BFIN_GOTLO",

 42650 +  "BFD_RELOC_BFIN_FUNCDESC",

 42651 +  "BFD_RELOC_BFIN_FUNCDESC_GOT17M4",

 42652 +  "BFD_RELOC_BFIN_FUNCDESC_GOTHI",

 42653 +  "BFD_RELOC_BFIN_FUNCDESC_GOTLO",

 42654 +  "BFD_RELOC_BFIN_FUNCDESC_VALUE",

 42655 +  "BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4",

 42656 +  "BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI",

 42657 +  "BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO",

 42658 +  "BFD_RELOC_BFIN_GOTOFF17M4",

 42659 +  "BFD_RELOC_BFIN_GOTOFFHI",

 42660 +  "BFD_RELOC_BFIN_GOTOFFLO",

 42661 +  "BFD_RELOC_BFIN_GOT",

 42662 +  "BFD_RELOC_BFIN_PLTPC",

 42663 +  "BFD_ARELOC_BFIN_PUSH",

 42664 +  "BFD_ARELOC_BFIN_CONST",

 42665 +  "BFD_ARELOC_BFIN_ADD",

 42666 +  "BFD_ARELOC_BFIN_SUB",

 42667 +  "BFD_ARELOC_BFIN_MULT",

 42668 +  "BFD_ARELOC_BFIN_DIV",

 42669 +  "BFD_ARELOC_BFIN_MOD",

 42670 +  "BFD_ARELOC_BFIN_LSHIFT",

 42671 +  "BFD_ARELOC_BFIN_RSHIFT",

 42672 +  "BFD_ARELOC_BFIN_AND",

 42673 +  "BFD_ARELOC_BFIN_OR",

 42674 +  "BFD_ARELOC_BFIN_XOR",

 42675 +  "BFD_ARELOC_BFIN_LAND",

 42676 +  "BFD_ARELOC_BFIN_LOR",

 42677 +  "BFD_ARELOC_BFIN_LEN",

 42678 +  "BFD_ARELOC_BFIN_NEG",

 42679 +  "BFD_ARELOC_BFIN_COMP",

 42680 +  "BFD_ARELOC_BFIN_PAGE",

 42681 +  "BFD_ARELOC_BFIN_HWPAGE",

 42682 +  "BFD_ARELOC_BFIN_ADDR",

 42683 +  "BFD_RELOC_D10V_10_PCREL_R",

 42684 +  "BFD_RELOC_D10V_10_PCREL_L",

 42685 +  "BFD_RELOC_D10V_18",

 42686 +  "BFD_RELOC_D10V_18_PCREL",

 42687 +  "BFD_RELOC_D30V_6",

 42688 +  "BFD_RELOC_D30V_9_PCREL",

 42689 +  "BFD_RELOC_D30V_9_PCREL_R",

 42690 +  "BFD_RELOC_D30V_15",

 42691 +  "BFD_RELOC_D30V_15_PCREL",

 42692 +  "BFD_RELOC_D30V_15_PCREL_R",

 42693 +  "BFD_RELOC_D30V_21",

 42694 +  "BFD_RELOC_D30V_21_PCREL",

 42695 +  "BFD_RELOC_D30V_21_PCREL_R",

 42696 +  "BFD_RELOC_D30V_32",

 42697 +  "BFD_RELOC_D30V_32_PCREL",

 42698 +  "BFD_RELOC_DLX_HI16_S",

 42699 +  "BFD_RELOC_DLX_LO16",

 42700 +  "BFD_RELOC_DLX_JMP26",

 42701 +  "BFD_RELOC_M32C_HI8",

 42702 +  "BFD_RELOC_M32C_RL_JUMP",

 42703 +  "BFD_RELOC_M32C_RL_1ADDR",

 42704 +  "BFD_RELOC_M32C_RL_2ADDR",

 42705 +  "BFD_RELOC_M32R_24",

 42706 +  "BFD_RELOC_M32R_10_PCREL",

 42707 +  "BFD_RELOC_M32R_18_PCREL",

 42708 +  "BFD_RELOC_M32R_26_PCREL",

 42709 +  "BFD_RELOC_M32R_HI16_ULO",

 42710 +  "BFD_RELOC_M32R_HI16_SLO",

 42711 +  "BFD_RELOC_M32R_LO16",

 42712 +  "BFD_RELOC_M32R_SDA16",

 42713 +  "BFD_RELOC_M32R_GOT24",

 42714 +  "BFD_RELOC_M32R_26_PLTREL",

 42715 +  "BFD_RELOC_M32R_COPY",

 42716 +  "BFD_RELOC_M32R_GLOB_DAT",

 42717 +  "BFD_RELOC_M32R_JMP_SLOT",

 42718 +  "BFD_RELOC_M32R_RELATIVE",

 42719 +  "BFD_RELOC_M32R_GOTOFF",

 42720 +  "BFD_RELOC_M32R_GOTOFF_HI_ULO",

 42721 +  "BFD_RELOC_M32R_GOTOFF_HI_SLO",

 42722 +  "BFD_RELOC_M32R_GOTOFF_LO",

 42723 +  "BFD_RELOC_M32R_GOTPC24",

 42724 +  "BFD_RELOC_M32R_GOT16_HI_ULO",

 42725 +  "BFD_RELOC_M32R_GOT16_HI_SLO",

 42726 +  "BFD_RELOC_M32R_GOT16_LO",

 42727 +  "BFD_RELOC_M32R_GOTPC_HI_ULO",

 42728 +  "BFD_RELOC_M32R_GOTPC_HI_SLO",

 42729 +  "BFD_RELOC_M32R_GOTPC_LO",

 42730 +  "BFD_RELOC_V850_9_PCREL",

 42731 +  "BFD_RELOC_V850_22_PCREL",

 42732 +  "BFD_RELOC_V850_SDA_16_16_OFFSET",

 42733 +  "BFD_RELOC_V850_SDA_15_16_OFFSET",

 42734 +  "BFD_RELOC_V850_ZDA_16_16_OFFSET",

 42735 +  "BFD_RELOC_V850_ZDA_15_16_OFFSET",

 42736 +  "BFD_RELOC_V850_TDA_6_8_OFFSET",

 42737 +  "BFD_RELOC_V850_TDA_7_8_OFFSET",

 42738 +  "BFD_RELOC_V850_TDA_7_7_OFFSET",

 42739 +  "BFD_RELOC_V850_TDA_16_16_OFFSET",

 42740 +  "BFD_RELOC_V850_TDA_4_5_OFFSET",

 42741 +  "BFD_RELOC_V850_TDA_4_4_OFFSET",

 42742 +  "BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET",

 42743 +  "BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET",

 42744 +  "BFD_RELOC_V850_CALLT_6_7_OFFSET",

 42745 +  "BFD_RELOC_V850_CALLT_16_16_OFFSET",

 42746 +  "BFD_RELOC_V850_LONGCALL",

 42747 +  "BFD_RELOC_V850_LONGJUMP",

 42748 +  "BFD_RELOC_V850_ALIGN",

 42749 +  "BFD_RELOC_V850_LO16_SPLIT_OFFSET",

 42750 +  "BFD_RELOC_MN10300_32_PCREL",

 42751 +  "BFD_RELOC_MN10300_16_PCREL",

 42752 +  "BFD_RELOC_TIC30_LDP",

 42753 +  "BFD_RELOC_TIC54X_PARTLS7",

 42754 +  "BFD_RELOC_TIC54X_PARTMS9",

 42755 +  "BFD_RELOC_TIC54X_23",

 42756 +  "BFD_RELOC_TIC54X_16_OF_23",

 42757 +  "BFD_RELOC_TIC54X_MS7_OF_23",

 42758 +  "BFD_RELOC_FR30_48",

 42759 +  "BFD_RELOC_FR30_20",

 42760 +  "BFD_RELOC_FR30_6_IN_4",

 42761 +  "BFD_RELOC_FR30_8_IN_8",

 42762 +  "BFD_RELOC_FR30_9_IN_8",

 42763 +  "BFD_RELOC_FR30_10_IN_8",

 42764 +  "BFD_RELOC_FR30_9_PCREL",

 42765 +  "BFD_RELOC_FR30_12_PCREL",

 42766 +  "BFD_RELOC_MCORE_PCREL_IMM8BY4",

 42767 +  "BFD_RELOC_MCORE_PCREL_IMM11BY2",

 42768 +  "BFD_RELOC_MCORE_PCREL_IMM4BY2",

 42769 +  "BFD_RELOC_MCORE_PCREL_32",

 42770 +  "BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2",

 42771 +  "BFD_RELOC_MCORE_RVA",

 42772 +  "BFD_RELOC_MEP_8",

 42773 +  "BFD_RELOC_MEP_16",

 42774 +  "BFD_RELOC_MEP_32",

 42775 +  "BFD_RELOC_MEP_PCREL8A2",

 42776 +  "BFD_RELOC_MEP_PCREL12A2",

 42777 +  "BFD_RELOC_MEP_PCREL17A2",

 42778 +  "BFD_RELOC_MEP_PCREL24A2",

 42779 +  "BFD_RELOC_MEP_PCABS24A2",

 42780 +  "BFD_RELOC_MEP_LOW16",

 42781 +  "BFD_RELOC_MEP_HI16U",

 42782 +  "BFD_RELOC_MEP_HI16S",

 42783 +  "BFD_RELOC_MEP_GPREL",

 42784 +  "BFD_RELOC_MEP_TPREL",

 42785 +  "BFD_RELOC_MEP_TPREL7",

 42786 +  "BFD_RELOC_MEP_TPREL7A2",

 42787 +  "BFD_RELOC_MEP_TPREL7A4",

 42788 +  "BFD_RELOC_MEP_UIMM24",

 42789 +  "BFD_RELOC_MEP_ADDR24A4",

 42790 +  "BFD_RELOC_MEP_GNU_VTINHERIT",

 42791 +  "BFD_RELOC_MEP_GNU_VTENTRY",

 42792 +

 42793 +  "BFD_RELOC_MMIX_GETA",

 42794 +  "BFD_RELOC_MMIX_GETA_1",

 42795 +  "BFD_RELOC_MMIX_GETA_2",

 42796 +  "BFD_RELOC_MMIX_GETA_3",

 42797 +  "BFD_RELOC_MMIX_CBRANCH",

 42798 +  "BFD_RELOC_MMIX_CBRANCH_J",

 42799 +  "BFD_RELOC_MMIX_CBRANCH_1",

 42800 +  "BFD_RELOC_MMIX_CBRANCH_2",

 42801 +  "BFD_RELOC_MMIX_CBRANCH_3",

 42802 +  "BFD_RELOC_MMIX_PUSHJ",

 42803 +  "BFD_RELOC_MMIX_PUSHJ_1",

 42804 +  "BFD_RELOC_MMIX_PUSHJ_2",

 42805 +  "BFD_RELOC_MMIX_PUSHJ_3",

 42806 +  "BFD_RELOC_MMIX_PUSHJ_STUBBABLE",

 42807 +  "BFD_RELOC_MMIX_JMP",

 42808 +  "BFD_RELOC_MMIX_JMP_1",

 42809 +  "BFD_RELOC_MMIX_JMP_2",

 42810 +  "BFD_RELOC_MMIX_JMP_3",

 42811 +  "BFD_RELOC_MMIX_ADDR19",

 42812 +  "BFD_RELOC_MMIX_ADDR27",

 42813 +  "BFD_RELOC_MMIX_REG_OR_BYTE",

 42814 +  "BFD_RELOC_MMIX_REG",

 42815 +  "BFD_RELOC_MMIX_BASE_PLUS_OFFSET",

 42816 +  "BFD_RELOC_MMIX_LOCAL",

 42817 +  "BFD_RELOC_AVR_7_PCREL",

 42818 +  "BFD_RELOC_AVR_13_PCREL",

 42819 +  "BFD_RELOC_AVR_16_PM",

 42820 +  "BFD_RELOC_AVR_LO8_LDI",

 42821 +  "BFD_RELOC_AVR_HI8_LDI",

 42822 +  "BFD_RELOC_AVR_HH8_LDI",

 42823 +  "BFD_RELOC_AVR_MS8_LDI",

 42824 +  "BFD_RELOC_AVR_LO8_LDI_NEG",

 42825 +  "BFD_RELOC_AVR_HI8_LDI_NEG",

 42826 +  "BFD_RELOC_AVR_HH8_LDI_NEG",

 42827 +  "BFD_RELOC_AVR_MS8_LDI_NEG",

 42828 +  "BFD_RELOC_AVR_LO8_LDI_PM",

 42829 +  "BFD_RELOC_AVR_LO8_LDI_GS",

 42830 +  "BFD_RELOC_AVR_HI8_LDI_PM",

 42831 +  "BFD_RELOC_AVR_HI8_LDI_GS",

 42832 +  "BFD_RELOC_AVR_HH8_LDI_PM",

 42833 +  "BFD_RELOC_AVR_LO8_LDI_PM_NEG",

 42834 +  "BFD_RELOC_AVR_HI8_LDI_PM_NEG",

 42835 +  "BFD_RELOC_AVR_HH8_LDI_PM_NEG",

 42836 +  "BFD_RELOC_AVR_CALL",

 42837 +  "BFD_RELOC_AVR_LDI",

 42838 +  "BFD_RELOC_AVR_6",

 42839 +  "BFD_RELOC_AVR_6_ADIW",

 42840 +  "BFD_RELOC_AVR32_DIFF32",

 42841 +  "BFD_RELOC_AVR32_DIFF16",

 42842 +  "BFD_RELOC_AVR32_DIFF8",

 42843 +  "BFD_RELOC_AVR32_GOT32",

 42844 +  "BFD_RELOC_AVR32_GOT16",

 42845 +  "BFD_RELOC_AVR32_GOT8",

 42846 +  "BFD_RELOC_AVR32_21S",

 42847 +  "BFD_RELOC_AVR32_16U",

 42848 +  "BFD_RELOC_AVR32_16S",

 42849 +  "BFD_RELOC_AVR32_SUB5",

 42850 +  "BFD_RELOC_AVR32_8S_EXT",

 42851 +  "BFD_RELOC_AVR32_8S",

 42852 +  "BFD_RELOC_AVR32_15S",

 42853 +  "BFD_RELOC_AVR32_22H_PCREL",

 42854 +  "BFD_RELOC_AVR32_18W_PCREL",

 42855 +  "BFD_RELOC_AVR32_16B_PCREL",

 42856 +  "BFD_RELOC_AVR32_16N_PCREL",

 42857 +  "BFD_RELOC_AVR32_14UW_PCREL",

 42858 +  "BFD_RELOC_AVR32_11H_PCREL",

 42859 +  "BFD_RELOC_AVR32_10UW_PCREL",

 42860 +  "BFD_RELOC_AVR32_9H_PCREL",

 42861 +  "BFD_RELOC_AVR32_9UW_PCREL",

 42862 +  "BFD_RELOC_AVR32_GOTPC",

 42863 +  "BFD_RELOC_AVR32_GOTCALL",

 42864 +  "BFD_RELOC_AVR32_LDA_GOT",

 42865 +  "BFD_RELOC_AVR32_GOT21S",

 42866 +  "BFD_RELOC_AVR32_GOT18SW",

 42867 +  "BFD_RELOC_AVR32_GOT16S",

 42868 +  "BFD_RELOC_AVR32_32_CPENT",

 42869 +  "BFD_RELOC_AVR32_CPCALL",

 42870 +  "BFD_RELOC_AVR32_16_CP",

 42871 +  "BFD_RELOC_AVR32_9W_CP",

 42872 +  "BFD_RELOC_AVR32_ALIGN",

 42873 +  "BFD_RELOC_AVR32_14UW",

 42874 +  "BFD_RELOC_AVR32_10UW",

 42875 +  "BFD_RELOC_AVR32_10SW",

 42876 +  "BFD_RELOC_AVR32_STHH_W",

 42877 +  "BFD_RELOC_AVR32_7UW",

 42878 +  "BFD_RELOC_AVR32_6S",

 42879 +  "BFD_RELOC_AVR32_6UW",

 42880 +  "BFD_RELOC_AVR32_4UH",

 42881 +  "BFD_RELOC_AVR32_3U",

 42882 +  "BFD_RELOC_390_12",

 42883 +  "BFD_RELOC_390_GOT12",

 42884 +  "BFD_RELOC_390_PLT32",

 42885 +  "BFD_RELOC_390_COPY",

 42886 +  "BFD_RELOC_390_GLOB_DAT",

 42887 +  "BFD_RELOC_390_JMP_SLOT",

 42888 +  "BFD_RELOC_390_RELATIVE",

 42889 +  "BFD_RELOC_390_GOTPC",

 42890 +  "BFD_RELOC_390_GOT16",

 42891 +  "BFD_RELOC_390_PC16DBL",

 42892 +  "BFD_RELOC_390_PLT16DBL",

 42893 +  "BFD_RELOC_390_PC32DBL",

 42894 +  "BFD_RELOC_390_PLT32DBL",

 42895 +  "BFD_RELOC_390_GOTPCDBL",

 42896 +  "BFD_RELOC_390_GOT64",

 42897 +  "BFD_RELOC_390_PLT64",

 42898 +  "BFD_RELOC_390_GOTENT",

 42899 +  "BFD_RELOC_390_GOTOFF64",

 42900 +  "BFD_RELOC_390_GOTPLT12",

 42901 +  "BFD_RELOC_390_GOTPLT16",

 42902 +  "BFD_RELOC_390_GOTPLT32",

 42903 +  "BFD_RELOC_390_GOTPLT64",

 42904 +  "BFD_RELOC_390_GOTPLTENT",

 42905 +  "BFD_RELOC_390_PLTOFF16",

 42906 +  "BFD_RELOC_390_PLTOFF32",

 42907 +  "BFD_RELOC_390_PLTOFF64",

 42908 +  "BFD_RELOC_390_TLS_LOAD",

 42909 +  "BFD_RELOC_390_TLS_GDCALL",

 42910 +  "BFD_RELOC_390_TLS_LDCALL",

 42911 +  "BFD_RELOC_390_TLS_GD32",

 42912 +  "BFD_RELOC_390_TLS_GD64",

 42913 +  "BFD_RELOC_390_TLS_GOTIE12",

 42914 +  "BFD_RELOC_390_TLS_GOTIE32",

 42915 +  "BFD_RELOC_390_TLS_GOTIE64",

 42916 +  "BFD_RELOC_390_TLS_LDM32",

 42917 +  "BFD_RELOC_390_TLS_LDM64",

 42918 +  "BFD_RELOC_390_TLS_IE32",

 42919 +  "BFD_RELOC_390_TLS_IE64",

 42920 +  "BFD_RELOC_390_TLS_IEENT",

 42921 +  "BFD_RELOC_390_TLS_LE32",

 42922 +  "BFD_RELOC_390_TLS_LE64",

 42923 +  "BFD_RELOC_390_TLS_LDO32",

 42924 +  "BFD_RELOC_390_TLS_LDO64",

 42925 +  "BFD_RELOC_390_TLS_DTPMOD",

 42926 +  "BFD_RELOC_390_TLS_DTPOFF",

 42927 +  "BFD_RELOC_390_TLS_TPOFF",

 42928 +  "BFD_RELOC_390_20",

 42929 +  "BFD_RELOC_390_GOT20",

 42930 +  "BFD_RELOC_390_GOTPLT20",

 42931 +  "BFD_RELOC_390_TLS_GOTIE20",

 42932 +  "BFD_RELOC_SCORE_DUMMY1",

 42933 +  "BFD_RELOC_SCORE_GPREL15",

 42934 +  "BFD_RELOC_SCORE_DUMMY2",

 42935 +  "BFD_RELOC_SCORE_JMP",

 42936 +  "BFD_RELOC_SCORE_BRANCH",

 42937 +  "BFD_RELOC_SCORE16_JMP",

 42938 +  "BFD_RELOC_SCORE16_BRANCH",

 42939 +  "BFD_RELOC_SCORE_GOT15",

 42940 +  "BFD_RELOC_SCORE_GOT_LO16",

 42941 +  "BFD_RELOC_SCORE_CALL15",

 42942 +  "BFD_RELOC_SCORE_DUMMY_HI16",

 42943 +  "BFD_RELOC_IP2K_FR9",

 42944 +  "BFD_RELOC_IP2K_BANK",

 42945 +  "BFD_RELOC_IP2K_ADDR16CJP",

 42946 +  "BFD_RELOC_IP2K_PAGE3",

 42947 +  "BFD_RELOC_IP2K_LO8DATA",

 42948 +  "BFD_RELOC_IP2K_HI8DATA",

 42949 +  "BFD_RELOC_IP2K_EX8DATA",

 42950 +  "BFD_RELOC_IP2K_LO8INSN",

 42951 +  "BFD_RELOC_IP2K_HI8INSN",

 42952 +  "BFD_RELOC_IP2K_PC_SKIP",

 42953 +  "BFD_RELOC_IP2K_TEXT",

 42954 +  "BFD_RELOC_IP2K_FR_OFFSET",

 42955 +  "BFD_RELOC_VPE4KMATH_DATA",

 42956 +  "BFD_RELOC_VPE4KMATH_INSN",

 42957 +  "BFD_RELOC_VTABLE_INHERIT",

 42958 +  "BFD_RELOC_VTABLE_ENTRY",

 42959 +  "BFD_RELOC_IA64_IMM14",

 42960 +  "BFD_RELOC_IA64_IMM22",

 42961 +  "BFD_RELOC_IA64_IMM64",

 42962 +  "BFD_RELOC_IA64_DIR32MSB",

 42963 +  "BFD_RELOC_IA64_DIR32LSB",

 42964 +  "BFD_RELOC_IA64_DIR64MSB",

 42965 +  "BFD_RELOC_IA64_DIR64LSB",

 42966 +  "BFD_RELOC_IA64_GPREL22",

 42967 +  "BFD_RELOC_IA64_GPREL64I",

 42968 +  "BFD_RELOC_IA64_GPREL32MSB",

 42969 +  "BFD_RELOC_IA64_GPREL32LSB",

 42970 +  "BFD_RELOC_IA64_GPREL64MSB",

 42971 +  "BFD_RELOC_IA64_GPREL64LSB",

 42972 +  "BFD_RELOC_IA64_LTOFF22",

 42973 +  "BFD_RELOC_IA64_LTOFF64I",

 42974 +  "BFD_RELOC_IA64_PLTOFF22",

 42975 +  "BFD_RELOC_IA64_PLTOFF64I",

 42976 +  "BFD_RELOC_IA64_PLTOFF64MSB",

 42977 +  "BFD_RELOC_IA64_PLTOFF64LSB",

 42978 +  "BFD_RELOC_IA64_FPTR64I",

 42979 +  "BFD_RELOC_IA64_FPTR32MSB",

 42980 +  "BFD_RELOC_IA64_FPTR32LSB",

 42981 +  "BFD_RELOC_IA64_FPTR64MSB",

 42982 +  "BFD_RELOC_IA64_FPTR64LSB",

 42983 +  "BFD_RELOC_IA64_PCREL21B",

 42984 +  "BFD_RELOC_IA64_PCREL21BI",

 42985 +  "BFD_RELOC_IA64_PCREL21M",

 42986 +  "BFD_RELOC_IA64_PCREL21F",

 42987 +  "BFD_RELOC_IA64_PCREL22",

 42988 +  "BFD_RELOC_IA64_PCREL60B",

 42989 +  "BFD_RELOC_IA64_PCREL64I",

 42990 +  "BFD_RELOC_IA64_PCREL32MSB",

 42991 +  "BFD_RELOC_IA64_PCREL32LSB",

 42992 +  "BFD_RELOC_IA64_PCREL64MSB",

 42993 +  "BFD_RELOC_IA64_PCREL64LSB",

 42994 +  "BFD_RELOC_IA64_LTOFF_FPTR22",

 42995 +  "BFD_RELOC_IA64_LTOFF_FPTR64I",

 42996 +  "BFD_RELOC_IA64_LTOFF_FPTR32MSB",

 42997 +  "BFD_RELOC_IA64_LTOFF_FPTR32LSB",

 42998 +  "BFD_RELOC_IA64_LTOFF_FPTR64MSB",

 42999 +  "BFD_RELOC_IA64_LTOFF_FPTR64LSB",

 43000 +  "BFD_RELOC_IA64_SEGREL32MSB",

 43001 +  "BFD_RELOC_IA64_SEGREL32LSB",

 43002 +  "BFD_RELOC_IA64_SEGREL64MSB",

 43003 +  "BFD_RELOC_IA64_SEGREL64LSB",

 43004 +  "BFD_RELOC_IA64_SECREL32MSB",

 43005 +  "BFD_RELOC_IA64_SECREL32LSB",

 43006 +  "BFD_RELOC_IA64_SECREL64MSB",

 43007 +  "BFD_RELOC_IA64_SECREL64LSB",

 43008 +  "BFD_RELOC_IA64_REL32MSB",

 43009 +  "BFD_RELOC_IA64_REL32LSB",

 43010 +  "BFD_RELOC_IA64_REL64MSB",

 43011 +  "BFD_RELOC_IA64_REL64LSB",

 43012 +  "BFD_RELOC_IA64_LTV32MSB",

 43013 +  "BFD_RELOC_IA64_LTV32LSB",

 43014 +  "BFD_RELOC_IA64_LTV64MSB",

 43015 +  "BFD_RELOC_IA64_LTV64LSB",

 43016 +  "BFD_RELOC_IA64_IPLTMSB",

 43017 +  "BFD_RELOC_IA64_IPLTLSB",

 43018 +  "BFD_RELOC_IA64_COPY",

 43019 +  "BFD_RELOC_IA64_LTOFF22X",

 43020 +  "BFD_RELOC_IA64_LDXMOV",

 43021 +  "BFD_RELOC_IA64_TPREL14",

 43022 +  "BFD_RELOC_IA64_TPREL22",

 43023 +  "BFD_RELOC_IA64_TPREL64I",

 43024 +  "BFD_RELOC_IA64_TPREL64MSB",

 43025 +  "BFD_RELOC_IA64_TPREL64LSB",

 43026 +  "BFD_RELOC_IA64_LTOFF_TPREL22",

 43027 +  "BFD_RELOC_IA64_DTPMOD64MSB",

 43028 +  "BFD_RELOC_IA64_DTPMOD64LSB",

 43029 +  "BFD_RELOC_IA64_LTOFF_DTPMOD22",

 43030 +  "BFD_RELOC_IA64_DTPREL14",

 43031 +  "BFD_RELOC_IA64_DTPREL22",

 43032 +  "BFD_RELOC_IA64_DTPREL64I",

 43033 +  "BFD_RELOC_IA64_DTPREL32MSB",

 43034 +  "BFD_RELOC_IA64_DTPREL32LSB",

 43035 +  "BFD_RELOC_IA64_DTPREL64MSB",

 43036 +  "BFD_RELOC_IA64_DTPREL64LSB",

 43037 +  "BFD_RELOC_IA64_LTOFF_DTPREL22",

 43038 +  "BFD_RELOC_M68HC11_HI8",

 43039 +  "BFD_RELOC_M68HC11_LO8",

 43040 +  "BFD_RELOC_M68HC11_3B",

 43041 +  "BFD_RELOC_M68HC11_RL_JUMP",

 43042 +  "BFD_RELOC_M68HC11_RL_GROUP",

 43043 +  "BFD_RELOC_M68HC11_LO16",

 43044 +  "BFD_RELOC_M68HC11_PAGE",

 43045 +  "BFD_RELOC_M68HC11_24",

 43046 +  "BFD_RELOC_M68HC12_5B",

 43047 +  "BFD_RELOC_16C_NUM08",

 43048 +  "BFD_RELOC_16C_NUM08_C",

 43049 +  "BFD_RELOC_16C_NUM16",

 43050 +  "BFD_RELOC_16C_NUM16_C",

 43051 +  "BFD_RELOC_16C_NUM32",

 43052 +  "BFD_RELOC_16C_NUM32_C",

 43053 +  "BFD_RELOC_16C_DISP04",

 43054 +  "BFD_RELOC_16C_DISP04_C",

 43055 +  "BFD_RELOC_16C_DISP08",

 43056 +  "BFD_RELOC_16C_DISP08_C",

 43057 +  "BFD_RELOC_16C_DISP16",

 43058 +  "BFD_RELOC_16C_DISP16_C",

 43059 +  "BFD_RELOC_16C_DISP24",

 43060 +  "BFD_RELOC_16C_DISP24_C",

 43061 +  "BFD_RELOC_16C_DISP24a",

 43062 +  "BFD_RELOC_16C_DISP24a_C",

 43063 +  "BFD_RELOC_16C_REG04",

 43064 +  "BFD_RELOC_16C_REG04_C",

 43065 +  "BFD_RELOC_16C_REG04a",

 43066 +  "BFD_RELOC_16C_REG04a_C",

 43067 +  "BFD_RELOC_16C_REG14",

 43068 +  "BFD_RELOC_16C_REG14_C",

 43069 +  "BFD_RELOC_16C_REG16",

 43070 +  "BFD_RELOC_16C_REG16_C",

 43071 +  "BFD_RELOC_16C_REG20",

 43072 +  "BFD_RELOC_16C_REG20_C",

 43073 +  "BFD_RELOC_16C_ABS20",

 43074 +  "BFD_RELOC_16C_ABS20_C",

 43075 +  "BFD_RELOC_16C_ABS24",

 43076 +  "BFD_RELOC_16C_ABS24_C",

 43077 +  "BFD_RELOC_16C_IMM04",

 43078 +  "BFD_RELOC_16C_IMM04_C",

 43079 +  "BFD_RELOC_16C_IMM16",

 43080 +  "BFD_RELOC_16C_IMM16_C",

 43081 +  "BFD_RELOC_16C_IMM20",

 43082 +  "BFD_RELOC_16C_IMM20_C",

 43083 +  "BFD_RELOC_16C_IMM24",

 43084 +  "BFD_RELOC_16C_IMM24_C",

 43085 +  "BFD_RELOC_16C_IMM32",

 43086 +  "BFD_RELOC_16C_IMM32_C",

 43087 +  "BFD_RELOC_CR16_NUM8",

 43088 +  "BFD_RELOC_CR16_NUM16",

 43089 +  "BFD_RELOC_CR16_NUM32",

 43090 +  "BFD_RELOC_CR16_NUM32a",

 43091 +  "BFD_RELOC_CR16_REGREL0",

 43092 +  "BFD_RELOC_CR16_REGREL4",

 43093 +  "BFD_RELOC_CR16_REGREL4a",

 43094 +  "BFD_RELOC_CR16_REGREL14",

 43095 +  "BFD_RELOC_CR16_REGREL14a",

 43096 +  "BFD_RELOC_CR16_REGREL16",

 43097 +  "BFD_RELOC_CR16_REGREL20",

 43098 +  "BFD_RELOC_CR16_REGREL20a",

 43099 +  "BFD_RELOC_CR16_ABS20",

 43100 +  "BFD_RELOC_CR16_ABS24",

 43101 +  "BFD_RELOC_CR16_IMM4",

 43102 +  "BFD_RELOC_CR16_IMM8",

 43103 +  "BFD_RELOC_CR16_IMM16",

 43104 +  "BFD_RELOC_CR16_IMM20",

 43105 +  "BFD_RELOC_CR16_IMM24",

 43106 +  "BFD_RELOC_CR16_IMM32",

 43107 +  "BFD_RELOC_CR16_IMM32a",

 43108 +  "BFD_RELOC_CR16_DISP4",

 43109 +  "BFD_RELOC_CR16_DISP8",

 43110 +  "BFD_RELOC_CR16_DISP16",

 43111 +  "BFD_RELOC_CR16_DISP20",

 43112 +  "BFD_RELOC_CR16_DISP24",

 43113 +  "BFD_RELOC_CR16_DISP24a",

 43114 +  "BFD_RELOC_CRX_REL4",

 43115 +  "BFD_RELOC_CRX_REL8",

 43116 +  "BFD_RELOC_CRX_REL8_CMP",

 43117 +  "BFD_RELOC_CRX_REL16",

 43118 +  "BFD_RELOC_CRX_REL24",

 43119 +  "BFD_RELOC_CRX_REL32",

 43120 +  "BFD_RELOC_CRX_REGREL12",

 43121 +  "BFD_RELOC_CRX_REGREL22",

 43122 +  "BFD_RELOC_CRX_REGREL28",

 43123 +  "BFD_RELOC_CRX_REGREL32",

 43124 +  "BFD_RELOC_CRX_ABS16",

 43125 +  "BFD_RELOC_CRX_ABS32",

 43126 +  "BFD_RELOC_CRX_NUM8",

 43127 +  "BFD_RELOC_CRX_NUM16",

 43128 +  "BFD_RELOC_CRX_NUM32",

 43129 +  "BFD_RELOC_CRX_IMM16",

 43130 +  "BFD_RELOC_CRX_IMM32",

 43131 +  "BFD_RELOC_CRX_SWITCH8",

 43132 +  "BFD_RELOC_CRX_SWITCH16",

 43133 +  "BFD_RELOC_CRX_SWITCH32",

 43134 +  "BFD_RELOC_CRIS_BDISP8",

 43135 +  "BFD_RELOC_CRIS_UNSIGNED_5",

 43136 +  "BFD_RELOC_CRIS_SIGNED_6",

 43137 +  "BFD_RELOC_CRIS_UNSIGNED_6",

 43138 +  "BFD_RELOC_CRIS_SIGNED_8",

 43139 +  "BFD_RELOC_CRIS_UNSIGNED_8",

 43140 +  "BFD_RELOC_CRIS_SIGNED_16",

 43141 +  "BFD_RELOC_CRIS_UNSIGNED_16",

 43142 +  "BFD_RELOC_CRIS_LAPCQ_OFFSET",

 43143 +  "BFD_RELOC_CRIS_UNSIGNED_4",

 43144 +  "BFD_RELOC_CRIS_COPY",

 43145 +  "BFD_RELOC_CRIS_GLOB_DAT",

 43146 +  "BFD_RELOC_CRIS_JUMP_SLOT",

 43147 +  "BFD_RELOC_CRIS_RELATIVE",

 43148 +  "BFD_RELOC_CRIS_32_GOT",

 43149 +  "BFD_RELOC_CRIS_16_GOT",

 43150 +  "BFD_RELOC_CRIS_32_GOTPLT",

 43151 +  "BFD_RELOC_CRIS_16_GOTPLT",

 43152 +  "BFD_RELOC_CRIS_32_GOTREL",

 43153 +  "BFD_RELOC_CRIS_32_PLT_GOTREL",

 43154 +  "BFD_RELOC_CRIS_32_PLT_PCREL",

 43155 +  "BFD_RELOC_860_COPY",

 43156 +  "BFD_RELOC_860_GLOB_DAT",

 43157 +  "BFD_RELOC_860_JUMP_SLOT",

 43158 +  "BFD_RELOC_860_RELATIVE",

 43159 +  "BFD_RELOC_860_PC26",

 43160 +  "BFD_RELOC_860_PLT26",

 43161 +  "BFD_RELOC_860_PC16",

 43162 +  "BFD_RELOC_860_LOW0",

 43163 +  "BFD_RELOC_860_SPLIT0",

 43164 +  "BFD_RELOC_860_LOW1",

 43165 +  "BFD_RELOC_860_SPLIT1",

 43166 +  "BFD_RELOC_860_LOW2",

 43167 +  "BFD_RELOC_860_SPLIT2",

 43168 +  "BFD_RELOC_860_LOW3",

 43169 +  "BFD_RELOC_860_LOGOT0",

 43170 +  "BFD_RELOC_860_SPGOT0",

 43171 +  "BFD_RELOC_860_LOGOT1",

 43172 +  "BFD_RELOC_860_SPGOT1",

 43173 +  "BFD_RELOC_860_LOGOTOFF0",

 43174 +  "BFD_RELOC_860_SPGOTOFF0",

 43175 +  "BFD_RELOC_860_LOGOTOFF1",

 43176 +  "BFD_RELOC_860_SPGOTOFF1",

 43177 +  "BFD_RELOC_860_LOGOTOFF2",

 43178 +  "BFD_RELOC_860_LOGOTOFF3",

 43179 +  "BFD_RELOC_860_LOPC",

 43180 +  "BFD_RELOC_860_HIGHADJ",

 43181 +  "BFD_RELOC_860_HAGOT",

 43182 +  "BFD_RELOC_860_HAGOTOFF",

 43183 +  "BFD_RELOC_860_HAPC",

 43184 +  "BFD_RELOC_860_HIGH",

 43185 +  "BFD_RELOC_860_HIGOT",

 43186 +  "BFD_RELOC_860_HIGOTOFF",

 43187 +  "BFD_RELOC_OPENRISC_ABS_26",

 43188 +  "BFD_RELOC_OPENRISC_REL_26",

 43189 +  "BFD_RELOC_H8_DIR16A8",

 43190 +  "BFD_RELOC_H8_DIR16R8",

 43191 +  "BFD_RELOC_H8_DIR24A8",

 43192 +  "BFD_RELOC_H8_DIR24R8",

 43193 +  "BFD_RELOC_H8_DIR32A16",

 43194 +  "BFD_RELOC_XSTORMY16_REL_12",

 43195 +  "BFD_RELOC_XSTORMY16_12",

 43196 +  "BFD_RELOC_XSTORMY16_24",

 43197 +  "BFD_RELOC_XSTORMY16_FPTR16",

 43198 +  "BFD_RELOC_RELC",

 43199 +

 43200 +  "BFD_RELOC_XC16X_PAG",

 43201 +  "BFD_RELOC_XC16X_POF",

 43202 +  "BFD_RELOC_XC16X_SEG",

 43203 +  "BFD_RELOC_XC16X_SOF",

 43204 +  "BFD_RELOC_VAX_GLOB_DAT",

 43205 +  "BFD_RELOC_VAX_JMP_SLOT",

 43206 +  "BFD_RELOC_VAX_RELATIVE",

 43207 +  "BFD_RELOC_MT_PC16",

 43208 +  "BFD_RELOC_MT_HI16",

 43209 +  "BFD_RELOC_MT_LO16",

 43210 +  "BFD_RELOC_MT_GNU_VTINHERIT",

 43211 +  "BFD_RELOC_MT_GNU_VTENTRY",

 43212 +  "BFD_RELOC_MT_PCINSN8",

 43213 +  "BFD_RELOC_MSP430_10_PCREL",

 43214 +  "BFD_RELOC_MSP430_16_PCREL",

 43215 +  "BFD_RELOC_MSP430_16",

 43216 +  "BFD_RELOC_MSP430_16_PCREL_BYTE",

 43217 +  "BFD_RELOC_MSP430_16_BYTE",

 43218 +  "BFD_RELOC_MSP430_2X_PCREL",

 43219 +  "BFD_RELOC_MSP430_RL_PCREL",

 43220 +  "BFD_RELOC_IQ2000_OFFSET_16",

 43221 +  "BFD_RELOC_IQ2000_OFFSET_21",

 43222 +  "BFD_RELOC_IQ2000_UHI16",

 43223 +  "BFD_RELOC_XTENSA_RTLD",

 43224 +  "BFD_RELOC_XTENSA_GLOB_DAT",

 43225 +  "BFD_RELOC_XTENSA_JMP_SLOT",

 43226 +  "BFD_RELOC_XTENSA_RELATIVE",

 43227 +  "BFD_RELOC_XTENSA_PLT",

 43228 +  "BFD_RELOC_XTENSA_DIFF8",

 43229 +  "BFD_RELOC_XTENSA_DIFF16",

 43230 +  "BFD_RELOC_XTENSA_DIFF32",

 43231 +  "BFD_RELOC_XTENSA_SLOT0_OP",

 43232 +  "BFD_RELOC_XTENSA_SLOT1_OP",

 43233 +  "BFD_RELOC_XTENSA_SLOT2_OP",

 43234 +  "BFD_RELOC_XTENSA_SLOT3_OP",

 43235 +  "BFD_RELOC_XTENSA_SLOT4_OP",

 43236 +  "BFD_RELOC_XTENSA_SLOT5_OP",

 43237 +  "BFD_RELOC_XTENSA_SLOT6_OP",

 43238 +  "BFD_RELOC_XTENSA_SLOT7_OP",

 43239 +  "BFD_RELOC_XTENSA_SLOT8_OP",

 43240 +  "BFD_RELOC_XTENSA_SLOT9_OP",

 43241 +  "BFD_RELOC_XTENSA_SLOT10_OP",

 43242 +  "BFD_RELOC_XTENSA_SLOT11_OP",

 43243 +  "BFD_RELOC_XTENSA_SLOT12_OP",

 43244 +  "BFD_RELOC_XTENSA_SLOT13_OP",

 43245 +  "BFD_RELOC_XTENSA_SLOT14_OP",

 43246 +  "BFD_RELOC_XTENSA_SLOT0_ALT",

 43247 +  "BFD_RELOC_XTENSA_SLOT1_ALT",

 43248 +  "BFD_RELOC_XTENSA_SLOT2_ALT",

 43249 +  "BFD_RELOC_XTENSA_SLOT3_ALT",

 43250 +  "BFD_RELOC_XTENSA_SLOT4_ALT",

 43251 +  "BFD_RELOC_XTENSA_SLOT5_ALT",

 43252 +  "BFD_RELOC_XTENSA_SLOT6_ALT",

 43253 +  "BFD_RELOC_XTENSA_SLOT7_ALT",

 43254 +  "BFD_RELOC_XTENSA_SLOT8_ALT",

 43255 +  "BFD_RELOC_XTENSA_SLOT9_ALT",

 43256 +  "BFD_RELOC_XTENSA_SLOT10_ALT",

 43257 +  "BFD_RELOC_XTENSA_SLOT11_ALT",

 43258 +  "BFD_RELOC_XTENSA_SLOT12_ALT",

 43259 +  "BFD_RELOC_XTENSA_SLOT13_ALT",

 43260 +  "BFD_RELOC_XTENSA_SLOT14_ALT",

 43261 +  "BFD_RELOC_XTENSA_OP0",

 43262 +  "BFD_RELOC_XTENSA_OP1",

 43263 +  "BFD_RELOC_XTENSA_OP2",

 43264 +  "BFD_RELOC_XTENSA_ASM_EXPAND",

 43265 +  "BFD_RELOC_XTENSA_ASM_SIMPLIFY",

 43266 +  "BFD_RELOC_Z80_DISP8",

 43267 +  "BFD_RELOC_Z8K_DISP7",

 43268 +  "BFD_RELOC_Z8K_CALLR",

 43269 +  "BFD_RELOC_Z8K_IMM4L",

 43270 + "@@overflow: BFD_RELOC_UNUSED@@",

 43271 +};

 43272 +#endif

 43273 +

 43274 +reloc_howto_type *bfd_default_reloc_type_lookup

 43275 +   (bfd *abfd, bfd_reloc_code_real_type  code);

 43276 +

 43277 +bfd_boolean bfd_generic_relax_section

 43278 +   (bfd *abfd,

 43279 +    asection *section,

 43280 +    struct bfd_link_info *,

 43281 +    bfd_boolean *);

 43282 +

 43283 +bfd_boolean bfd_generic_gc_sections

 43284 +   (bfd *, struct bfd_link_info *);

 43285 +

 43286 +bfd_boolean bfd_generic_merge_sections

 43287 +   (bfd *, struct bfd_link_info *);

 43288 +

 43289 +bfd_byte *bfd_generic_get_relocated_section_contents

 43290 +   (bfd *abfd,

 43291 +    struct bfd_link_info *link_info,

 43292 +    struct bfd_link_order *link_order,

 43293 +    bfd_byte *data,

 43294 +    bfd_boolean relocatable,

 43295 +    asymbol **symbols);

 43296 +

 43297 +/* Extracted from archures.c.  */

 43298 +extern const bfd_arch_info_type bfd_default_arch_struct;

 43299 +bfd_boolean bfd_default_set_arch_mach

 43300 +   (bfd *abfd, enum bfd_architecture arch, unsigned long mach);

 43301 +

 43302 +const bfd_arch_info_type *bfd_default_compatible

 43303 +   (const bfd_arch_info_type *a, const bfd_arch_info_type *b);

 43304 +

 43305 +bfd_boolean bfd_default_scan

 43306 +   (const struct bfd_arch_info *info, const char *string);

 43307 +

 43308 +/* Extracted from elf.c.  */

 43309 +struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);

 43310 +

 43311 --- /dev/null

 43312 +++ b/bfd/doc/libcoff.h

 43313 @@ -0,0 +1,936 @@

 43314 +/* DO NOT EDIT!  -*- buffer-read-only: t -*-  This file is automatically

 43315 +   generated from "libcoff-in.h" and "coffcode.h".

 43316 +   Run "make headers" in your build bfd/ to regenerate.  */

 43317 +

 43318 +/* BFD COFF object file private structure.

 43319 +   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,

 43320 +   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007

 43321 +   Free Software Foundation, Inc.

 43322 +   Written by Cygnus Support.

 43323 +

 43324 +   This file is part of BFD, the Binary File Descriptor library.

 43325 +

 43326 +   This program is free software; you can redistribute it and/or modify

 43327 +   it under the terms of the GNU General Public License as published by

 43328 +   the Free Software Foundation; either version 3 of the License, or

 43329 +   (at your option) any later version.

 43330 +

 43331 +   This program is distributed in the hope that it will be useful,

 43332 +   but WITHOUT ANY WARRANTY; without even the implied warranty of

 43333 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 43334 +   GNU General Public License for more details.

 43335 +

 43336 +   You should have received a copy of the GNU General Public License

 43337 +   along with this program; if not, write to the Free Software

 43338 +   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

 43339 +   MA 02110-1301, USA.  */

 43340 +

 43341 +#include "bfdlink.h"

 43342 +

 43343 +/* Object file tdata; access macros.  */

 43344 +

 43345 +#define coff_data(bfd)		      ((bfd)->tdata.coff_obj_data)

 43346 +#define exec_hdr(bfd)		      (coff_data (bfd)->hdr)

 43347 +#define obj_pe(bfd)                   (coff_data (bfd)->pe)

 43348 +#define obj_symbols(bfd)	      (coff_data (bfd)->symbols)

 43349 +#define	obj_sym_filepos(bfd)	      (coff_data (bfd)->sym_filepos)

 43350 +#define obj_relocbase(bfd)	      (coff_data (bfd)->relocbase)

 43351 +#define obj_raw_syments(bfd)	      (coff_data (bfd)->raw_syments)

 43352 +#define obj_raw_syment_count(bfd)     (coff_data (bfd)->raw_syment_count)

 43353 +#define obj_convert(bfd)	      (coff_data (bfd)->conversion_table)

 43354 +#define obj_conv_table_size(bfd)      (coff_data (bfd)->conv_table_size)

 43355 +#define obj_coff_external_syms(bfd)   (coff_data (bfd)->external_syms)

 43356 +#define obj_coff_keep_syms(bfd)	      (coff_data (bfd)->keep_syms)

 43357 +#define obj_coff_strings(bfd)	      (coff_data (bfd)->strings)

 43358 +#define obj_coff_keep_strings(bfd)    (coff_data (bfd)->keep_strings)

 43359 +#define obj_coff_sym_hashes(bfd)      (coff_data (bfd)->sym_hashes)

 43360 +#define obj_coff_strings_written(bfd) (coff_data (bfd)->strings_written)

 43361 +#define obj_coff_local_toc_table(bfd) (coff_data (bfd)->local_toc_sym_map)

 43362 +

 43363 +/* `Tdata' information kept for COFF files.  */

 43364 +

 43365 +typedef struct coff_tdata

 43366 +{

 43367 +  struct coff_symbol_struct *symbols;	/* Symtab for input bfd.  */

 43368 +  unsigned int *conversion_table;

 43369 +  int conv_table_size;

 43370 +  file_ptr sym_filepos;

 43371 +

 43372 +  struct coff_ptr_struct *raw_syments;

 43373 +  unsigned long raw_syment_count;

 43374 +

 43375 +  /* These are only valid once writing has begun.  */

 43376 +  long int relocbase;

 43377 +

 43378 +  /* These members communicate important constants about the symbol table

 43379 +     to GDB's symbol-reading code.  These `constants' unfortunately vary

 43380 +     from coff implementation to implementation...  */

 43381 +  unsigned local_n_btmask;

 43382 +  unsigned local_n_btshft;

 43383 +  unsigned local_n_tmask;

 43384 +  unsigned local_n_tshift;

 43385 +  unsigned local_symesz;

 43386 +  unsigned local_auxesz;

 43387 +  unsigned local_linesz;

 43388 +

 43389 +  /* The unswapped external symbols.  May be NULL.  Read by

 43390 +     _bfd_coff_get_external_symbols.  */

 43391 +  void * external_syms;

 43392 +  /* If this is TRUE, the external_syms may not be freed.  */

 43393 +  bfd_boolean keep_syms;

 43394 +

 43395 +  /* The string table.  May be NULL.  Read by

 43396 +     _bfd_coff_read_string_table.  */

 43397 +  char *strings;

 43398 +  /* If this is TRUE, the strings may not be freed.  */

 43399 +  bfd_boolean keep_strings;

 43400 +  /* If this is TRUE, the strings have been written out already.  */

 43401 +  bfd_boolean strings_written;

 43402 +

 43403 +  /* Is this a PE format coff file?  */

 43404 +  int pe;

 43405 +  /* Used by the COFF backend linker.  */

 43406 +  struct coff_link_hash_entry **sym_hashes;

 43407 +

 43408 +  /* Used by the pe linker for PowerPC.  */

 43409 +  int *local_toc_sym_map;

 43410 +

 43411 +  struct bfd_link_info *link_info;

 43412 +

 43413 +  /* Used by coff_find_nearest_line.  */

 43414 +  void * line_info;

 43415 +

 43416 +  /* A place to stash dwarf2 info for this bfd.  */

 43417 +  void * dwarf2_find_line_info;

 43418 +

 43419 +  /* The timestamp from the COFF file header.  */

 43420 +  long timestamp;

 43421 +

 43422 +  /* Copy of some of the f_flags bits in the COFF filehdr structure,

 43423 +     used by ARM code.  */

 43424 +  flagword flags;

 43425 +

 43426 +} coff_data_type;

 43427 +

 43428 +/* Tdata for pe image files.  */

 43429 +typedef struct pe_tdata

 43430 +{

 43431 +  coff_data_type coff;

 43432 +  struct internal_extra_pe_aouthdr pe_opthdr;

 43433 +  int dll;

 43434 +  int has_reloc_section;

 43435 +  bfd_boolean (*in_reloc_p) (bfd *, reloc_howto_type *);

 43436 +  flagword real_flags;

 43437 +  int target_subsystem;

 43438 +  bfd_boolean force_minimum_alignment;

 43439 +} pe_data_type;

 43440 +

 43441 +#define pe_data(bfd)		((bfd)->tdata.pe_obj_data)

 43442 +

 43443 +/* Tdata for XCOFF files.  */

 43444 +

 43445 +struct xcoff_tdata

 43446 +{

 43447 +  /* Basic COFF information.  */

 43448 +  coff_data_type coff;

 43449 +

 43450 +  /* TRUE if this is an XCOFF64 file. */

 43451 +  bfd_boolean xcoff64;

 43452 +

 43453 +  /* TRUE if a large a.out header should be generated.  */

 43454 +  bfd_boolean full_aouthdr;

 43455 +

 43456 +  /* TOC value.  */

 43457 +  bfd_vma toc;

 43458 +

 43459 +  /* Index of section holding TOC.  */

 43460 +  int sntoc;

 43461 +

 43462 +  /* Index of section holding entry point.  */

 43463 +  int snentry;

 43464 +

 43465 +  /* .text alignment from optional header.  */

 43466 +  int text_align_power;

 43467 +

 43468 +  /* .data alignment from optional header.  */

 43469 +  int data_align_power;

 43470 +

 43471 +  /* modtype from optional header.  */

 43472 +  short modtype;

 43473 +

 43474 +  /* cputype from optional header.  */

 43475 +  short cputype;

 43476 +

 43477 +  /* maxdata from optional header.  */

 43478 +  bfd_vma maxdata;

 43479 +

 43480 +  /* maxstack from optional header.  */

 43481 +  bfd_vma maxstack;

 43482 +

 43483 +  /* Used by the XCOFF backend linker.  */

 43484 +  asection **csects;

 43485 +  unsigned long *debug_indices;

 43486 +  unsigned int import_file_id;

 43487 +};

 43488 +

 43489 +#define xcoff_data(abfd) ((abfd)->tdata.xcoff_obj_data)

 43490 +

 43491 +/* We take the address of the first element of an asymbol to ensure that the

 43492 +   macro is only ever applied to an asymbol.  */

 43493 +#define coffsymbol(asymbol) ((coff_symbol_type *)(&((asymbol)->the_bfd)))

 43494 +

 43495 +/* The used_by_bfd field of a section may be set to a pointer to this

 43496 +   structure.  */

 43497 +

 43498 +struct coff_section_tdata

 43499 +{

 43500 +  /* The relocs, swapped into COFF internal form.  This may be NULL.  */

 43501 +  struct internal_reloc *relocs;

 43502 +  /* If this is TRUE, the relocs entry may not be freed.  */

 43503 +  bfd_boolean keep_relocs;

 43504 +  /* The section contents.  This may be NULL.  */

 43505 +  bfd_byte *contents;

 43506 +  /* If this is TRUE, the contents entry may not be freed.  */

 43507 +  bfd_boolean keep_contents;

 43508 +  /* Information cached by coff_find_nearest_line.  */

 43509 +  bfd_vma offset;

 43510 +  unsigned int i;

 43511 +  const char *function;

 43512 +  /* Optional information about a COMDAT entry; NULL if not COMDAT. */

 43513 +  struct coff_comdat_info *comdat;

 43514 +  int line_base;

 43515 +  /* A pointer used for .stab linking optimizations.  */

 43516 +  void * stab_info;

 43517 +  /* Available for individual backends.  */

 43518 +  void * tdata;

 43519 +};

 43520 +

 43521 +/* An accessor macro for the coff_section_tdata structure.  */

 43522 +#define coff_section_data(abfd, sec) \

 43523 +  ((struct coff_section_tdata *) (sec)->used_by_bfd)

 43524 +

 43525 +/* Tdata for sections in XCOFF files.  This is used by the linker.  */

 43526 +

 43527 +struct xcoff_section_tdata

 43528 +{

 43529 +  /* Used for XCOFF csects created by the linker; points to the real

 43530 +     XCOFF section which contains this csect.  */

 43531 +  asection *enclosing;

 43532 +  /* The lineno_count field for the enclosing section, because we are

 43533 +     going to clobber it there.  */

 43534 +  unsigned int lineno_count;

 43535 +  /* The first and one past the last symbol indices for symbols used

 43536 +     by this csect.  */

 43537 +  unsigned long first_symndx;

 43538 +  unsigned long last_symndx;

 43539 +};

 43540 +

 43541 +/* An accessor macro the xcoff_section_tdata structure.  */

 43542 +#define xcoff_section_data(abfd, sec) \

 43543 +  ((struct xcoff_section_tdata *) coff_section_data ((abfd), (sec))->tdata)

 43544 +

 43545 +/* Tdata for sections in PE files.  */

 43546 +

 43547 +struct pei_section_tdata

 43548 +{

 43549 +  /* The virtual size of the section.  */

 43550 +  bfd_size_type virt_size;

 43551 +  /* The PE section flags.  */

 43552 +  long pe_flags;

 43553 +};

 43554 +

 43555 +/* An accessor macro for the pei_section_tdata structure.  */

 43556 +#define pei_section_data(abfd, sec) \

 43557 +  ((struct pei_section_tdata *) coff_section_data ((abfd), (sec))->tdata)

 43558 +

 43559 +/* COFF linker hash table entries.  */

 43560 +

 43561 +struct coff_link_hash_entry

 43562 +{

 43563 +  struct bfd_link_hash_entry root;

 43564 +

 43565 +  /* Symbol index in output file.  Set to -1 initially.  Set to -2 if

 43566 +     there is a reloc against this symbol.  */

 43567 +  long indx;

 43568 +

 43569 +  /* Symbol type.  */

 43570 +  unsigned short type;

 43571 +

 43572 +  /* Symbol class.  */

 43573 +  unsigned char class;

 43574 +

 43575 +  /* Number of auxiliary entries.  */

 43576 +  char numaux;

 43577 +

 43578 +  /* BFD to take auxiliary entries from.  */

 43579 +  bfd *auxbfd;

 43580 +

 43581 +  /* Pointer to array of auxiliary entries, if any.  */

 43582 +  union internal_auxent *aux;

 43583 +

 43584 +  /* Flag word; legal values follow.  */

 43585 +  unsigned short coff_link_hash_flags;

 43586 +  /* Symbol is a PE section symbol.  */

 43587 +#define COFF_LINK_HASH_PE_SECTION_SYMBOL (01)

 43588 +};

 43589 +

 43590 +/* COFF linker hash table.  */

 43591 +

 43592 +struct coff_link_hash_table

 43593 +{

 43594 +  struct bfd_link_hash_table root;

 43595 +  /* A pointer to information used to link stabs in sections.  */

 43596 +  struct stab_info stab_info;

 43597 +};

 43598 +

 43599 +/* Look up an entry in a COFF linker hash table.  */

 43600 +

 43601 +#define coff_link_hash_lookup(table, string, create, copy, follow)	\

 43602 +  ((struct coff_link_hash_entry *)					\

 43603 +   bfd_link_hash_lookup (&(table)->root, (string), (create),		\

 43604 +			 (copy), (follow)))

 43605 +

 43606 +/* Traverse a COFF linker hash table.  */

 43607 +

 43608 +#define coff_link_hash_traverse(table, func, info)			\

 43609 +  (bfd_link_hash_traverse						\

 43610 +   (&(table)->root,							\

 43611 +    (bfd_boolean (*) (struct bfd_link_hash_entry *, void *)) (func), \

 43612 +    (info)))

 43613 +

 43614 +/* Get the COFF linker hash table from a link_info structure.  */

 43615 +

 43616 +#define coff_hash_table(p) ((struct coff_link_hash_table *) ((p)->hash))

 43617 +

 43618 +/* Functions in coffgen.c.  */

 43619 +extern const bfd_target *coff_object_p

 43620 +  (bfd *);

 43621 +extern struct bfd_section *coff_section_from_bfd_index

 43622 +  (bfd *, int);

 43623 +extern long coff_get_symtab_upper_bound

 43624 +  (bfd *);

 43625 +extern long coff_canonicalize_symtab

 43626 +  (bfd *, asymbol **);

 43627 +extern int coff_count_linenumbers

 43628 +  (bfd *);

 43629 +extern struct coff_symbol_struct *coff_symbol_from

 43630 +  (bfd *, asymbol *);

 43631 +extern bfd_boolean coff_renumber_symbols

 43632 +  (bfd *, int *);

 43633 +extern void coff_mangle_symbols

 43634 +  (bfd *);

 43635 +extern bfd_boolean coff_write_symbols

 43636 +  (bfd *);

 43637 +extern bfd_boolean coff_write_linenumbers

 43638 +  (bfd *);

 43639 +extern alent *coff_get_lineno

 43640 +  (bfd *, asymbol *);

 43641 +extern asymbol *coff_section_symbol

 43642 +  (bfd *, char *);

 43643 +extern bfd_boolean _bfd_coff_get_external_symbols

 43644 +  (bfd *);

 43645 +extern const char *_bfd_coff_read_string_table

 43646 +  (bfd *);

 43647 +extern bfd_boolean _bfd_coff_free_symbols

 43648 +  (bfd *);

 43649 +extern struct coff_ptr_struct *coff_get_normalized_symtab

 43650 +  (bfd *);

 43651 +extern long coff_get_reloc_upper_bound

 43652 +  (bfd *, sec_ptr);

 43653 +extern asymbol *coff_make_empty_symbol

 43654 +  (bfd *);

 43655 +extern void coff_print_symbol

 43656 +  (bfd *, void * filep, asymbol *, bfd_print_symbol_type);

 43657 +extern void coff_get_symbol_info

 43658 +  (bfd *, asymbol *, symbol_info *ret);

 43659 +extern bfd_boolean _bfd_coff_is_local_label_name

 43660 +  (bfd *, const char *);

 43661 +extern asymbol *coff_bfd_make_debug_symbol

 43662 +  (bfd *, void *, unsigned long);

 43663 +extern bfd_boolean coff_find_nearest_line

 43664 +  (bfd *, asection *, asymbol **, bfd_vma, const char **,

 43665 +   const char **, unsigned int *);

 43666 +extern bfd_boolean coff_find_inliner_info

 43667 +  (bfd *, const char **, const char **, unsigned int *);

 43668 +extern int coff_sizeof_headers

 43669 +  (bfd *, struct bfd_link_info *);

 43670 +extern bfd_boolean bfd_coff_reloc16_relax_section

 43671 +  (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);

 43672 +extern bfd_byte *bfd_coff_reloc16_get_relocated_section_contents

 43673 +  (bfd *, struct bfd_link_info *, struct bfd_link_order *,

 43674 +   bfd_byte *, bfd_boolean, asymbol **);

 43675 +extern bfd_vma bfd_coff_reloc16_get_value

 43676 +  (arelent *, struct bfd_link_info *, asection *);

 43677 +extern void bfd_perform_slip

 43678 +  (bfd *, unsigned int, asection *, bfd_vma);

 43679 +

 43680 +/* Functions and types in cofflink.c.  */

 43681 +

 43682 +#define STRING_SIZE_SIZE 4

 43683 +

 43684 +/* We use a hash table to merge identical enum, struct, and union

 43685 +   definitions in the linker.  */

 43686 +

 43687 +/* Information we keep for a single element (an enum value, a

 43688 +   structure or union field) in the debug merge hash table.  */

 43689 +

 43690 +struct coff_debug_merge_element

 43691 +{

 43692 +  /* Next element.  */

 43693 +  struct coff_debug_merge_element *next;

 43694 +

 43695 +  /* Name.  */

 43696 +  const char *name;

 43697 +

 43698 +  /* Type.  */

 43699 +  unsigned int type;

 43700 +

 43701 +  /* Symbol index for complex type.  */

 43702 +  long tagndx;

 43703 +};

 43704 +

 43705 +/* A linked list of debug merge entries for a given name.  */

 43706 +

 43707 +struct coff_debug_merge_type

 43708 +{

 43709 +  /* Next type with the same name.  */

 43710 +  struct coff_debug_merge_type *next;

 43711 +

 43712 +  /* Class of type.  */

 43713 +  int class;

 43714 +

 43715 +  /* Symbol index where this type is defined.  */

 43716 +  long indx;

 43717 +

 43718 +  /* List of elements.  */

 43719 +  struct coff_debug_merge_element *elements;

 43720 +};

 43721 +

 43722 +/* Information we store in the debug merge hash table.  */

 43723 +

 43724 +struct coff_debug_merge_hash_entry

 43725 +{

 43726 +  struct bfd_hash_entry root;

 43727 +

 43728 +  /* A list of types with this name.  */

 43729 +  struct coff_debug_merge_type *types;

 43730 +};

 43731 +

 43732 +/* The debug merge hash table.  */

 43733 +

 43734 +struct coff_debug_merge_hash_table

 43735 +{

 43736 +  struct bfd_hash_table root;

 43737 +};

 43738 +

 43739 +/* Initialize a COFF debug merge hash table.  */

 43740 +

 43741 +#define coff_debug_merge_hash_table_init(table) \

 43742 +  (bfd_hash_table_init (&(table)->root, _bfd_coff_debug_merge_hash_newfunc, \

 43743 +			sizeof (struct coff_debug_merge_hash_entry)))

 43744 +

 43745 +/* Free a COFF debug merge hash table.  */

 43746 +

 43747 +#define coff_debug_merge_hash_table_free(table) \

 43748 +  (bfd_hash_table_free (&(table)->root))

 43749 +

 43750 +/* Look up an entry in a COFF debug merge hash table.  */

 43751 +

 43752 +#define coff_debug_merge_hash_lookup(table, string, create, copy) \

 43753 +  ((struct coff_debug_merge_hash_entry *) \

 43754 +   bfd_hash_lookup (&(table)->root, (string), (create), (copy)))

 43755 +

 43756 +/* Information we keep for each section in the output file when doing

 43757 +   a relocatable link.  */

 43758 +

 43759 +struct coff_link_section_info

 43760 +{

 43761 +  /* The relocs to be output.  */

 43762 +  struct internal_reloc *relocs;

 43763 +  /* For each reloc against a global symbol whose index was not known

 43764 +     when the reloc was handled, the global hash table entry.  */

 43765 +  struct coff_link_hash_entry **rel_hashes;

 43766 +};

 43767 +

 43768 +/* Information that we pass around while doing the final link step.  */

 43769 +

 43770 +struct coff_final_link_info

 43771 +{

 43772 +  /* General link information.  */

 43773 +  struct bfd_link_info *info;

 43774 +  /* Output BFD.  */

 43775 +  bfd *output_bfd;

 43776 +  /* Used to indicate failure in traversal routine.  */

 43777 +  bfd_boolean failed;

 43778 +  /* If doing "task linking" set only during the time when we want the

 43779 +     global symbol writer to convert the storage class of defined global

 43780 +     symbols from global to static. */

 43781 +  bfd_boolean global_to_static;

 43782 +  /* Hash table for long symbol names.  */

 43783 +  struct bfd_strtab_hash *strtab;

 43784 +  /* When doing a relocatable link, an array of information kept for

 43785 +     each output section, indexed by the target_index field.  */

 43786 +  struct coff_link_section_info *section_info;

 43787 +  /* Symbol index of last C_FILE symbol (-1 if none).  */

 43788 +  long last_file_index;

 43789 +  /* Contents of last C_FILE symbol.  */

 43790 +  struct internal_syment last_file;

 43791 +  /* Symbol index of first aux entry of last .bf symbol with an empty

 43792 +     endndx field (-1 if none).  */

 43793 +  long last_bf_index;

 43794 +  /* Contents of last_bf_index aux entry.  */

 43795 +  union internal_auxent last_bf;

 43796 +  /* Hash table used to merge debug information.  */

 43797 +  struct coff_debug_merge_hash_table debug_merge;

 43798 +  /* Buffer large enough to hold swapped symbols of any input file.  */

 43799 +  struct internal_syment *internal_syms;

 43800 +  /* Buffer large enough to hold sections of symbols of any input file.  */

 43801 +  asection **sec_ptrs;

 43802 +  /* Buffer large enough to hold output indices of symbols of any

 43803 +     input file.  */

 43804 +  long *sym_indices;

 43805 +  /* Buffer large enough to hold output symbols for any input file.  */

 43806 +  bfd_byte *outsyms;

 43807 +  /* Buffer large enough to hold external line numbers for any input

 43808 +     section.  */

 43809 +  bfd_byte *linenos;

 43810 +  /* Buffer large enough to hold any input section.  */

 43811 +  bfd_byte *contents;

 43812 +  /* Buffer large enough to hold external relocs of any input section.  */

 43813 +  bfd_byte *external_relocs;

 43814 +  /* Buffer large enough to hold swapped relocs of any input section.  */

 43815 +  struct internal_reloc *internal_relocs;

 43816 +};

 43817 +

 43818 +/* Most COFF variants have no way to record the alignment of a

 43819 +   section.  This struct is used to set a specific alignment based on

 43820 +   the name of the section.  */

 43821 +

 43822 +struct coff_section_alignment_entry

 43823 +{

 43824 +  /* The section name.  */

 43825 +  const char *name;

 43826 +

 43827 +  /* This is either (unsigned int) -1, indicating that the section

 43828 +     name must match exactly, or it is the number of letters which

 43829 +     must match at the start of the name.  */

 43830 +  unsigned int comparison_length;

 43831 +

 43832 +  /* These macros may be used to fill in the first two fields in a

 43833 +     structure initialization.  */

 43834 +#define COFF_SECTION_NAME_EXACT_MATCH(name) (name), ((unsigned int) -1)

 43835 +#define COFF_SECTION_NAME_PARTIAL_MATCH(name) (name), (sizeof (name) - 1)

 43836 +

 43837 +  /* Only use this entry if the default section alignment for this

 43838 +     target is at least that much (as a power of two).  If this field

 43839 +     is COFF_ALIGNMENT_FIELD_EMPTY, it should be ignored.  */

 43840 +  unsigned int default_alignment_min;

 43841 +

 43842 +  /* Only use this entry if the default section alignment for this

 43843 +     target is no greater than this (as a power of two).  If this

 43844 +     field is COFF_ALIGNMENT_FIELD_EMPTY, it should be ignored.  */

 43845 +  unsigned int default_alignment_max;

 43846 +

 43847 +#define COFF_ALIGNMENT_FIELD_EMPTY ((unsigned int) -1)

 43848 +

 43849 +  /* The desired alignment for this section (as a power of two).  */

 43850 +  unsigned int alignment_power;

 43851 +};

 43852 +

 43853 +extern struct bfd_hash_entry *_bfd_coff_link_hash_newfunc

 43854 +  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);

 43855 +extern bfd_boolean _bfd_coff_link_hash_table_init

 43856 +  (struct coff_link_hash_table *, bfd *,

 43857 +   struct bfd_hash_entry *(*) (struct bfd_hash_entry *,

 43858 +			       struct bfd_hash_table *,

 43859 +			       const char *),

 43860 +   unsigned int);

 43861 +extern struct bfd_link_hash_table *_bfd_coff_link_hash_table_create

 43862 +  (bfd *);

 43863 +extern const char *_bfd_coff_internal_syment_name

 43864 +  (bfd *, const struct internal_syment *, char *);

 43865 +extern bfd_boolean _bfd_coff_link_add_symbols

 43866 +  (bfd *, struct bfd_link_info *);

 43867 +extern bfd_boolean _bfd_coff_final_link

 43868 +  (bfd *, struct bfd_link_info *);

 43869 +extern struct internal_reloc *_bfd_coff_read_internal_relocs

 43870 +  (bfd *, asection *, bfd_boolean, bfd_byte *, bfd_boolean,

 43871 +   struct internal_reloc *);

 43872 +extern bfd_boolean _bfd_coff_generic_relocate_section

 43873 +  (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,

 43874 +   struct internal_reloc *, struct internal_syment *, asection **);

 43875 +extern struct bfd_hash_entry *_bfd_coff_debug_merge_hash_newfunc

 43876 +  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);

 43877 +extern bfd_boolean _bfd_coff_write_global_sym

 43878 +  (struct coff_link_hash_entry *, void *);

 43879 +extern bfd_boolean _bfd_coff_write_task_globals

 43880 +  (struct coff_link_hash_entry *, void *);

 43881 +extern bfd_boolean _bfd_coff_link_input_bfd

 43882 +  (struct coff_final_link_info *, bfd *);

 43883 +extern bfd_boolean _bfd_coff_reloc_link_order

 43884 +  (bfd *, struct coff_final_link_info *, asection *,

 43885 +   struct bfd_link_order *);

 43886 +

 43887 +

 43888 +#define coff_get_section_contents_in_window \

 43889 +  _bfd_generic_get_section_contents_in_window

 43890 +

 43891 +/* Functions in xcofflink.c.  */

 43892 +

 43893 +extern long _bfd_xcoff_get_dynamic_symtab_upper_bound

 43894 +  (bfd *);

 43895 +extern long _bfd_xcoff_canonicalize_dynamic_symtab

 43896 +  (bfd *, asymbol **);

 43897 +extern long _bfd_xcoff_get_dynamic_reloc_upper_bound

 43898 +  (bfd *);

 43899 +extern long _bfd_xcoff_canonicalize_dynamic_reloc

 43900 +  (bfd *, arelent **, asymbol **);

 43901 +extern struct bfd_link_hash_table *_bfd_xcoff_bfd_link_hash_table_create

 43902 +  (bfd *);

 43903 +extern void _bfd_xcoff_bfd_link_hash_table_free

 43904 +  (struct bfd_link_hash_table *);

 43905 +extern bfd_boolean _bfd_xcoff_bfd_link_add_symbols

 43906 +  (bfd *, struct bfd_link_info *);

 43907 +extern bfd_boolean _bfd_xcoff_bfd_final_link

 43908 +  (bfd *, struct bfd_link_info *);

 43909 +extern bfd_boolean _bfd_ppc_xcoff_relocate_section

 43910 +  (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,

 43911 +   struct internal_reloc *, struct internal_syment *, asection **);

 43912 +

 43913 +/* Functions in coff-ppc.c.  FIXME: These are called be pe.em in the

 43914 +   linker, and so should start with bfd and be declared in bfd.h.  */

 43915 +

 43916 +extern bfd_boolean ppc_allocate_toc_section

 43917 +  (struct bfd_link_info *);

 43918 +extern bfd_boolean ppc_process_before_allocation

 43919 +  (bfd *, struct bfd_link_info *);

 43920 +

 43921 +/* Extracted from coffcode.h.  */

 43922 +typedef struct coff_ptr_struct

 43923 +{

 43924 +  /* Remembers the offset from the first symbol in the file for

 43925 +     this symbol. Generated by coff_renumber_symbols. */

 43926 +  unsigned int offset;

 43927 +

 43928 +  /* Should the value of this symbol be renumbered.  Used for

 43929 +     XCOFF C_BSTAT symbols.  Set by coff_slurp_symbol_table.  */

 43930 +  unsigned int fix_value : 1;

 43931 +

 43932 +  /* Should the tag field of this symbol be renumbered.

 43933 +     Created by coff_pointerize_aux. */

 43934 +  unsigned int fix_tag : 1;

 43935 +

 43936 +  /* Should the endidx field of this symbol be renumbered.

 43937 +     Created by coff_pointerize_aux. */

 43938 +  unsigned int fix_end : 1;

 43939 +

 43940 +  /* Should the x_csect.x_scnlen field be renumbered.

 43941 +     Created by coff_pointerize_aux. */

 43942 +  unsigned int fix_scnlen : 1;

 43943 +

 43944 +  /* Fix up an XCOFF C_BINCL/C_EINCL symbol.  The value is the

 43945 +     index into the line number entries.  Set by coff_slurp_symbol_table.  */

 43946 +  unsigned int fix_line : 1;

 43947 +

 43948 +  /* The container for the symbol structure as read and translated

 43949 +     from the file. */

 43950 +  union

 43951 +  {

 43952 +    union internal_auxent auxent;

 43953 +    struct internal_syment syment;

 43954 +  } u;

 43955 +} combined_entry_type;

 43956 +

 43957 +

 43958 +/* Each canonical asymbol really looks like this: */

 43959 +

 43960 +typedef struct coff_symbol_struct

 43961 +{

 43962 +  /* The actual symbol which the rest of BFD works with */

 43963 +  asymbol symbol;

 43964 +

 43965 +  /* A pointer to the hidden information for this symbol */

 43966 +  combined_entry_type *native;

 43967 +

 43968 +  /* A pointer to the linenumber information for this symbol */

 43969 +  struct lineno_cache_entry *lineno;

 43970 +

 43971 +  /* Have the line numbers been relocated yet ? */

 43972 +  bfd_boolean done_lineno;

 43973 +} coff_symbol_type;

 43974 +/* COFF symbol classifications.  */

 43975 +

 43976 +enum coff_symbol_classification

 43977 +{

 43978 +  /* Global symbol.  */

 43979 +  COFF_SYMBOL_GLOBAL,

 43980 +  /* Common symbol.  */

 43981 +  COFF_SYMBOL_COMMON,

 43982 +  /* Undefined symbol.  */

 43983 +  COFF_SYMBOL_UNDEFINED,

 43984 +  /* Local symbol.  */

 43985 +  COFF_SYMBOL_LOCAL,

 43986 +  /* PE section symbol.  */

 43987 +  COFF_SYMBOL_PE_SECTION

 43988 +};

 43989 +

 43990 +typedef struct

 43991 +{

 43992 +  void (*_bfd_coff_swap_aux_in)

 43993 +    (bfd *, void *, int, int, int, int, void *);

 43994 +

 43995 +  void (*_bfd_coff_swap_sym_in)

 43996 +    (bfd *, void *, void *);

 43997 +

 43998 +  void (*_bfd_coff_swap_lineno_in)

 43999 +    (bfd *, void *, void *);

 44000 +

 44001 +  unsigned int (*_bfd_coff_swap_aux_out)

 44002 +    (bfd *, void *, int, int, int, int, void *);

 44003 +

 44004 +  unsigned int (*_bfd_coff_swap_sym_out)

 44005 +    (bfd *, void *, void *);

 44006 +

 44007 +  unsigned int (*_bfd_coff_swap_lineno_out)

 44008 +    (bfd *, void *, void *);

 44009 +

 44010 +  unsigned int (*_bfd_coff_swap_reloc_out)

 44011 +    (bfd *, void *, void *);

 44012 +

 44013 +  unsigned int (*_bfd_coff_swap_filehdr_out)

 44014 +    (bfd *, void *, void *);

 44015 +

 44016 +  unsigned int (*_bfd_coff_swap_aouthdr_out)

 44017 +    (bfd *, void *, void *);

 44018 +

 44019 +  unsigned int (*_bfd_coff_swap_scnhdr_out)

 44020 +    (bfd *, void *, void *);

 44021 +

 44022 +  unsigned int _bfd_filhsz;

 44023 +  unsigned int _bfd_aoutsz;

 44024 +  unsigned int _bfd_scnhsz;

 44025 +  unsigned int _bfd_symesz;

 44026 +  unsigned int _bfd_auxesz;

 44027 +  unsigned int _bfd_relsz;

 44028 +  unsigned int _bfd_linesz;

 44029 +  unsigned int _bfd_filnmlen;

 44030 +  bfd_boolean _bfd_coff_long_filenames;

 44031 +  bfd_boolean _bfd_coff_long_section_names;

 44032 +  unsigned int _bfd_coff_default_section_alignment_power;

 44033 +  bfd_boolean _bfd_coff_force_symnames_in_strings;

 44034 +  unsigned int _bfd_coff_debug_string_prefix_length;

 44035 +

 44036 +  void (*_bfd_coff_swap_filehdr_in)

 44037 +    (bfd *, void *, void *);

 44038 +

 44039 +  void (*_bfd_coff_swap_aouthdr_in)

 44040 +    (bfd *, void *, void *);

 44041 +

 44042 +  void (*_bfd_coff_swap_scnhdr_in)

 44043 +    (bfd *, void *, void *);

 44044 +

 44045 +  void (*_bfd_coff_swap_reloc_in)

 44046 +    (bfd *abfd, void *, void *);

 44047 +

 44048 +  bfd_boolean (*_bfd_coff_bad_format_hook)

 44049 +    (bfd *, void *);

 44050 +

 44051 +  bfd_boolean (*_bfd_coff_set_arch_mach_hook)

 44052 +    (bfd *, void *);

 44053 +

 44054 +  void * (*_bfd_coff_mkobject_hook)

 44055 +    (bfd *, void *, void *);

 44056 +

 44057 +  bfd_boolean (*_bfd_styp_to_sec_flags_hook)

 44058 +    (bfd *, void *, const char *, asection *, flagword *);

 44059 +

 44060 +  void (*_bfd_set_alignment_hook)

 44061 +    (bfd *, asection *, void *);

 44062 +

 44063 +  bfd_boolean (*_bfd_coff_slurp_symbol_table)

 44064 +    (bfd *);

 44065 +

 44066 +  bfd_boolean (*_bfd_coff_symname_in_debug)

 44067 +    (bfd *, struct internal_syment *);

 44068 +

 44069 +  bfd_boolean (*_bfd_coff_pointerize_aux_hook)

 44070 +    (bfd *, combined_entry_type *, combined_entry_type *,

 44071 +            unsigned int, combined_entry_type *);

 44072 +

 44073 +  bfd_boolean (*_bfd_coff_print_aux)

 44074 +    (bfd *, FILE *, combined_entry_type *, combined_entry_type *,

 44075 +            combined_entry_type *, unsigned int);

 44076 +

 44077 +  void (*_bfd_coff_reloc16_extra_cases)

 44078 +    (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,

 44079 +           bfd_byte *, unsigned int *, unsigned int *);

 44080 +

 44081 +  int (*_bfd_coff_reloc16_estimate)

 44082 +    (bfd *, asection *, arelent *, unsigned int,

 44083 +            struct bfd_link_info *);

 44084 +

 44085 +  enum coff_symbol_classification (*_bfd_coff_classify_symbol)

 44086 +    (bfd *, struct internal_syment *);

 44087 +

 44088 +  bfd_boolean (*_bfd_coff_compute_section_file_positions)

 44089 +    (bfd *);

 44090 +

 44091 +  bfd_boolean (*_bfd_coff_start_final_link)

 44092 +    (bfd *, struct bfd_link_info *);

 44093 +

 44094 +  bfd_boolean (*_bfd_coff_relocate_section)

 44095 +    (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,

 44096 +            struct internal_reloc *, struct internal_syment *, asection **);

 44097 +

 44098 +  reloc_howto_type *(*_bfd_coff_rtype_to_howto)

 44099 +    (bfd *, asection *, struct internal_reloc *,

 44100 +            struct coff_link_hash_entry *, struct internal_syment *,

 44101 +            bfd_vma *);

 44102 +

 44103 +  bfd_boolean (*_bfd_coff_adjust_symndx)

 44104 +    (bfd *, struct bfd_link_info *, bfd *, asection *,

 44105 +            struct internal_reloc *, bfd_boolean *);

 44106 +

 44107 +  bfd_boolean (*_bfd_coff_link_add_one_symbol)

 44108 +    (struct bfd_link_info *, bfd *, const char *, flagword,

 44109 +            asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,

 44110 +            struct bfd_link_hash_entry **);

 44111 +

 44112 +  bfd_boolean (*_bfd_coff_link_output_has_begun)

 44113 +    (bfd *, struct coff_final_link_info *);

 44114 +

 44115 +  bfd_boolean (*_bfd_coff_final_link_postscript)

 44116 +    (bfd *, struct coff_final_link_info *);

 44117 +

 44118 +} bfd_coff_backend_data;

 44119 +

 44120 +#define coff_backend_info(abfd) \

 44121 +  ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)

 44122 +

 44123 +#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \

 44124 +  ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))

 44125 +

 44126 +#define bfd_coff_swap_sym_in(a,e,i) \

 44127 +  ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))

 44128 +

 44129 +#define bfd_coff_swap_lineno_in(a,e,i) \

 44130 +  ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))

 44131 +

 44132 +#define bfd_coff_swap_reloc_out(abfd, i, o) \

 44133 +  ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))

 44134 +

 44135 +#define bfd_coff_swap_lineno_out(abfd, i, o) \

 44136 +  ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))

 44137 +

 44138 +#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \

 44139 +  ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))

 44140 +

 44141 +#define bfd_coff_swap_sym_out(abfd, i,o) \

 44142 +  ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))

 44143 +

 44144 +#define bfd_coff_swap_scnhdr_out(abfd, i,o) \

 44145 +  ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))

 44146 +

 44147 +#define bfd_coff_swap_filehdr_out(abfd, i,o) \

 44148 +  ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))

 44149 +

 44150 +#define bfd_coff_swap_aouthdr_out(abfd, i,o) \

 44151 +  ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))

 44152 +

 44153 +#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)

 44154 +#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)

 44155 +#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)

 44156 +#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)

 44157 +#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)

 44158 +#define bfd_coff_relsz(abfd)  (coff_backend_info (abfd)->_bfd_relsz)

 44159 +#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)

 44160 +#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)

 44161 +#define bfd_coff_long_filenames(abfd) \

 44162 +  (coff_backend_info (abfd)->_bfd_coff_long_filenames)

 44163 +#define bfd_coff_long_section_names(abfd) \

 44164 +  (coff_backend_info (abfd)->_bfd_coff_long_section_names)

 44165 +#define bfd_coff_default_section_alignment_power(abfd) \

 44166 +  (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)

 44167 +#define bfd_coff_swap_filehdr_in(abfd, i,o) \

 44168 +  ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))

 44169 +

 44170 +#define bfd_coff_swap_aouthdr_in(abfd, i,o) \

 44171 +  ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))

 44172 +

 44173 +#define bfd_coff_swap_scnhdr_in(abfd, i,o) \

 44174 +  ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))

 44175 +

 44176 +#define bfd_coff_swap_reloc_in(abfd, i, o) \

 44177 +  ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))

 44178 +

 44179 +#define bfd_coff_bad_format_hook(abfd, filehdr) \

 44180 +  ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))

 44181 +

 44182 +#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\

 44183 +  ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))

 44184 +#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\

 44185 +  ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\

 44186 +   (abfd, filehdr, aouthdr))

 44187 +

 44188 +#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\

 44189 +  ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\

 44190 +   (abfd, scnhdr, name, section, flags_ptr))

 44191 +

 44192 +#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\

 44193 +  ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))

 44194 +

 44195 +#define bfd_coff_slurp_symbol_table(abfd)\

 44196 +  ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))

 44197 +

 44198 +#define bfd_coff_symname_in_debug(abfd, sym)\

 44199 +  ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))

 44200 +

 44201 +#define bfd_coff_force_symnames_in_strings(abfd)\

 44202 +  (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)

 44203 +

 44204 +#define bfd_coff_debug_string_prefix_length(abfd)\

 44205 +  (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)

 44206 +

 44207 +#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\

 44208 +  ((coff_backend_info (abfd)->_bfd_coff_print_aux)\

 44209 +   (abfd, file, base, symbol, aux, indaux))

 44210 +

 44211 +#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\

 44212 +                                     reloc, data, src_ptr, dst_ptr)\

 44213 +  ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\

 44214 +   (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))

 44215 +

 44216 +#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\

 44217 +  ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\

 44218 +   (abfd, section, reloc, shrink, link_info))

 44219 +

 44220 +#define bfd_coff_classify_symbol(abfd, sym)\

 44221 +  ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\

 44222 +   (abfd, sym))

 44223 +

 44224 +#define bfd_coff_compute_section_file_positions(abfd)\

 44225 +  ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\

 44226 +   (abfd))

 44227 +

 44228 +#define bfd_coff_start_final_link(obfd, info)\

 44229 +  ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\

 44230 +   (obfd, info))

 44231 +#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\

 44232 +  ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\

 44233 +   (obfd, info, ibfd, o, con, rel, isyms, secs))

 44234 +#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\

 44235 +  ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\

 44236 +   (abfd, sec, rel, h, sym, addendp))

 44237 +#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\

 44238 +  ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\

 44239 +   (obfd, info, ibfd, sec, rel, adjustedp))

 44240 +#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\

 44241 +                                     value, string, cp, coll, hashp)\

 44242 +  ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\

 44243 +   (info, abfd, name, flags, section, value, string, cp, coll, hashp))

 44244 +

 44245 +#define bfd_coff_link_output_has_begun(a,p) \

 44246 +  ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))

 44247 +#define bfd_coff_final_link_postscript(a,p) \

 44248 +  ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))

 44249 +

 44250 --- a/bfd/libbfd.h

 44251 +++ b/bfd/libbfd.h

 44252 @@ -1601,6 +1601,48 @@ static const char *const bfd_reloc_code_

 44253    "BFD_RELOC_AVR_LDI",

 44254    "BFD_RELOC_AVR_6",

 44255    "BFD_RELOC_AVR_6_ADIW",

 44256 +  "BFD_RELOC_AVR32_DIFF32",

 44257 +  "BFD_RELOC_AVR32_DIFF16",

 44258 +  "BFD_RELOC_AVR32_DIFF8",

 44259 +  "BFD_RELOC_AVR32_GOT32",

 44260 +  "BFD_RELOC_AVR32_GOT16",

 44261 +  "BFD_RELOC_AVR32_GOT8",

 44262 +  "BFD_RELOC_AVR32_21S",

 44263 +  "BFD_RELOC_AVR32_16U",

 44264 +  "BFD_RELOC_AVR32_16S",

 44265 +  "BFD_RELOC_AVR32_SUB5",

 44266 +  "BFD_RELOC_AVR32_8S_EXT",

 44267 +  "BFD_RELOC_AVR32_8S",

 44268 +  "BFD_RELOC_AVR32_15S",

 44269 +  "BFD_RELOC_AVR32_22H_PCREL",

 44270 +  "BFD_RELOC_AVR32_18W_PCREL",

 44271 +  "BFD_RELOC_AVR32_16B_PCREL",

 44272 +  "BFD_RELOC_AVR32_16N_PCREL",

 44273 +  "BFD_RELOC_AVR32_14UW_PCREL",

 44274 +  "BFD_RELOC_AVR32_11H_PCREL",

 44275 +  "BFD_RELOC_AVR32_10UW_PCREL",

 44276 +  "BFD_RELOC_AVR32_9H_PCREL",

 44277 +  "BFD_RELOC_AVR32_9UW_PCREL",

 44278 +  "BFD_RELOC_AVR32_GOTPC",

 44279 +  "BFD_RELOC_AVR32_GOTCALL",

 44280 +  "BFD_RELOC_AVR32_LDA_GOT",

 44281 +  "BFD_RELOC_AVR32_GOT21S",

 44282 +  "BFD_RELOC_AVR32_GOT18SW",

 44283 +  "BFD_RELOC_AVR32_GOT16S",

 44284 +  "BFD_RELOC_AVR32_32_CPENT",

 44285 +  "BFD_RELOC_AVR32_CPCALL",

 44286 +  "BFD_RELOC_AVR32_16_CP",

 44287 +  "BFD_RELOC_AVR32_9W_CP",

 44288 +  "BFD_RELOC_AVR32_ALIGN",

 44289 +  "BFD_RELOC_AVR32_14UW",

 44290 +  "BFD_RELOC_AVR32_10UW",

 44291 +  "BFD_RELOC_AVR32_10SW",

 44292 +  "BFD_RELOC_AVR32_STHH_W",

 44293 +  "BFD_RELOC_AVR32_7UW",

 44294 +  "BFD_RELOC_AVR32_6S",

 44295 +  "BFD_RELOC_AVR32_6UW",

 44296 +  "BFD_RELOC_AVR32_4UH",

 44297 +  "BFD_RELOC_AVR32_3U",

 44298    "BFD_RELOC_390_12",

 44299    "BFD_RELOC_390_GOT12",

 44300    "BFD_RELOC_390_PLT32",

 44301 --- /dev/null

 44302 +++ b/bfd/libtool

 44303 @@ -0,0 +1,7871 @@

 44304 +#! /bin/bash

 44305 +

 44306 +# libtool - Provide generalized library-building support services.

 44307 +# Generated automatically by config.status (bfd) 2.18.atmel.1.0.1

 44308 +# Libtool was configured on host hcegtvedt:

 44309 +# NOTE: Changes made to this file will be lost: look at ltmain.sh.

 44310 +#

 44311 +#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,

 44312 +#                 2006, 2007, 2008 Free Software Foundation, Inc.

 44313 +#   Written by Gordon Matzigkeit, 1996

 44314 +#

 44315 +#   This file is part of GNU Libtool.

 44316 +#

 44317 +# GNU Libtool is free software; you can redistribute it and/or

 44318 +# modify it under the terms of the GNU General Public License as

 44319 +# published by the Free Software Foundation; either version 2 of

 44320 +# the License, or (at your option) any later version.

 44321 +#

 44322 +# As a special exception to the GNU General Public License,

 44323 +# if you distribute this file as part of a program or library that

 44324 +# is built using GNU Libtool, you may include this file under the

 44325 +# same distribution terms that you use for the rest of that program.

 44326 +#

 44327 +# GNU Libtool is distributed in the hope that it will be useful,

 44328 +# but WITHOUT ANY WARRANTY; without even the implied warranty of

 44329 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 44330 +# GNU General Public License for more details.

 44331 +#

 44332 +# You should have received a copy of the GNU General Public License

 44333 +# along with GNU Libtool; see the file COPYING.  If not, a copy

 44334 +# can be downloaded from http://www.gnu.org/licenses/gpl.html, or

 44335 +# obtained by writing to the Free Software Foundation, Inc.,

 44336 +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 44337 +

 44338 +

 44339 +# The names of the tagged configurations supported by this script.

 44340 +available_tags=""

 44341 +

 44342 +# ### BEGIN LIBTOOL CONFIG

 44343 +

 44344 +# Whether or not to build shared libraries.

 44345 +build_libtool_libs=no

 44346 +

 44347 +# Which release of libtool.m4 was used?

 44348 +macro_version=2.2.4

 44349 +macro_revision=1.2976

 44350 +

 44351 +# Whether or not to build static libraries.

 44352 +build_old_libs=yes

 44353 +

 44354 +# What type of objects to build.

 44355 +pic_mode=default

 44356 +

 44357 +# Whether or not to optimize for fast installation.

 44358 +fast_install=needless

 44359 +

 44360 +# The host system.

 44361 +host_alias=i686-pc-linux-gnu

 44362 +host=i686-pc-linux-gnu

 44363 +host_os=linux-gnu

 44364 +

 44365 +# The build system.

 44366 +build_alias=i686-pc-linux-gnu

 44367 +build=i686-pc-linux-gnu

 44368 +build_os=linux-gnu

 44369 +

 44370 +# A sed program that does not truncate output.

 44371 +SED="/bin/sed"

 44372 +

 44373 +# Sed that helps us avoid accidentally triggering echo(1) options like -n.

 44374 +Xsed="$SED -e 1s/^X//"

 44375 +

 44376 +# A grep program that handles long lines.

 44377 +GREP="/bin/grep"

 44378 +

 44379 +# An ERE matcher.

 44380 +EGREP="/bin/grep -E"

 44381 +

 44382 +# A literal string matcher.

 44383 +FGREP="/bin/grep -F"

 44384 +

 44385 +# A BSD- or MS-compatible name lister.

 44386 +NM="nm"

 44387 +

 44388 +# Whether we need soft or hard links.

 44389 +LN_S="ln -s"

 44390 +

 44391 +# What is the maximum length of a command?

 44392 +max_cmd_len=805306365

 44393 +

 44394 +# Object file suffix (normally "o").

 44395 +objext=o

 44396 +

 44397 +# Executable file suffix (normally "").

 44398 +exeext=

 44399 +

 44400 +# whether the shell understands "unset".

 44401 +lt_unset=unset

 44402 +

 44403 +# turn spaces into newlines.

 44404 +SP2NL="tr \\040 \\012"

 44405 +

 44406 +# turn newlines into spaces.

 44407 +NL2SP="tr \\015\\012 \\040\\040"

 44408 +

 44409 +# How to create reloadable object files.

 44410 +reload_flag=" -r"

 44411 +reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs"

 44412 +

 44413 +# Method to check whether dependent libraries are shared objects.

 44414 +deplibs_check_method="pass_all"

 44415 +

 44416 +# Command to use when deplibs_check_method == "file_magic".

 44417 +file_magic_cmd="\$MAGIC_CMD"

 44418 +

 44419 +# The archiver.

 44420 +AR="ar"

 44421 +AR_FLAGS="cru"

 44422 +

 44423 +# A symbol stripping program.

 44424 +STRIP="strip"

 44425 +

 44426 +# Commands used to install an old-style archive.

 44427 +RANLIB="ranlib"

 44428 +old_postinstall_cmds="chmod 644 \$oldlib~\$RANLIB \$oldlib"

 44429 +old_postuninstall_cmds=""

 44430 +

 44431 +# A C compiler.

 44432 +LTCC="gcc"

 44433 +

 44434 +# LTCC compiler flags.

 44435 +LTCFLAGS="-g -O2"

 44436 +

 44437 +# Take the output of nm and produce a listing of raw symbols and C names.

 44438 +global_symbol_pipe="sed -n -e 's/^.*[	 ]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[	 ][	 ]*\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 \\2 \\2/p'"

 44439 +

 44440 +# Transform the output of nm in a proper C declaration.

 44441 +global_symbol_to_cdecl="sed -n -e 's/^T .* \\(.*\\)\$/extern int \\1();/p' -e 's/^[ABCDGIRSTW]* .* \\(.*\\)\$/extern char \\1;/p'"

 44442 +

 44443 +# Transform the output of nm in a C name address pair.

 44444 +global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\) \$/  {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/  {\"\\2\", (void *) \\&\\2},/p'"

 44445 +

 44446 +# Transform the output of nm in a C name address pair when lib prefix is needed.

 44447 +global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \\([^ ]*\\) \$/  {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\(lib[^ ]*\\)\$/  {\"\\2\", (void *) \\&\\2},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/  {\"lib\\2\", (void *) \\&\\2},/p'"

 44448 +

 44449 +# The name of the directory that contains temporary libtool files.

 44450 +objdir=.libs

 44451 +

 44452 +# Shell to use when invoking shell scripts.

 44453 +SHELL="/bin/bash"

 44454 +

 44455 +# An echo program that does not interpret backslashes.

 44456 +ECHO="echo"

 44457 +

 44458 +# Used to examine libraries when file_magic_cmd begins with "file".

 44459 +MAGIC_CMD=file

 44460 +

 44461 +# Must we lock files when doing compilation?

 44462 +need_locks="no"

 44463 +

 44464 +# Tool to manipulate archived DWARF debug symbol files on Mac OS X.

 44465 +DSYMUTIL=""

 44466 +

 44467 +# Tool to change global to local symbols on Mac OS X.

 44468 +NMEDIT=""

 44469 +

 44470 +# Tool to manipulate fat objects and archives on Mac OS X.

 44471 +LIPO=""

 44472 +

 44473 +# ldd/readelf like tool for Mach-O binaries on Mac OS X.

 44474 +OTOOL=""

 44475 +

 44476 +# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.

 44477 +OTOOL64=""

 44478 +

 44479 +# Old archive suffix (normally "a").

 44480 +libext=a

 44481 +

 44482 +# Shared library suffix (normally ".so").

 44483 +shrext_cmds=".so"

 44484 +

 44485 +# The commands to extract the exported symbol list from a shared archive.

 44486 +extract_expsyms_cmds=""

 44487 +

 44488 +# Variables whose values should be saved in libtool wrapper scripts and

 44489 +# restored at link time.

 44490 +variables_saved_for_relink="PATH LD_LIBRARY_PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"

 44491 +

 44492 +# Do we need the "lib" prefix for modules?

 44493 +need_lib_prefix=no

 44494 +

 44495 +# Do we need a version for libraries?

 44496 +need_version=no

 44497 +

 44498 +# Library versioning type.

 44499 +version_type=linux

 44500 +

 44501 +# Shared library runtime path variable.

 44502 +runpath_var=LD_RUN_PATH

 44503 +

 44504 +# Shared library path variable.

 44505 +shlibpath_var=LD_LIBRARY_PATH

 44506 +

 44507 +# Is shlibpath searched before the hard-coded library search path?

 44508 +shlibpath_overrides_runpath=no

 44509 +

 44510 +# Format of library name prefix.

 44511 +libname_spec="lib\$name"

 44512 +

 44513 +# List of archive names.  First name is the real one, the rest are links.

 44514 +# The last name is the one that the linker finds with -lNAME

 44515 +library_names_spec="\${libname}\${release}\${shared_ext}\$versuffix \${libname}\${release}\${shared_ext}\$major \$libname\${shared_ext}"

 44516 +

 44517 +# The coded name of the library, if different from the real name.

 44518 +soname_spec="\${libname}\${release}\${shared_ext}\$major"

 44519 +

 44520 +# Command to use after installation of a shared archive.

 44521 +postinstall_cmds=""

 44522 +

 44523 +# Command to use after uninstallation of a shared archive.

 44524 +postuninstall_cmds=""

 44525 +

 44526 +# Commands used to finish a libtool library installation in a directory.

 44527 +finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir"

 44528 +

 44529 +# As "finish_cmds", except a single script fragment to be evaled but

 44530 +# not shown.

 44531 +finish_eval=""

 44532 +

 44533 +# Whether we should hardcode library paths into libraries.

 44534 +hardcode_into_libs=yes

 44535 +

 44536 +# Compile-time system search path for libraries.

 44537 +sys_lib_search_path_spec="/usr/lib/gcc/i486-linux-gnu/4.2.4 /usr/lib /lib"

 44538 +

 44539 +# Run-time system search path for libraries.

 44540 +sys_lib_dlsearch_path_spec="/lib /usr/lib /lib/i486-linux-gnu /usr/lib/i486-linux-gnu /usr/lib/alsa-lib /usr/local/lib "

 44541 +

 44542 +# Whether dlopen is supported.

 44543 +dlopen_support=unknown

 44544 +

 44545 +# Whether dlopen of programs is supported.

 44546 +dlopen_self=unknown

 44547 +

 44548 +# Whether dlopen of statically linked programs is supported.

 44549 +dlopen_self_static=unknown

 44550 +

 44551 +# Commands to strip libraries.

 44552 +old_striplib="strip --strip-debug"

 44553 +striplib="strip --strip-unneeded"

 44554 +

 44555 +

 44556 +# The linker used to build libraries.

 44557 +LD="ld"

 44558 +

 44559 +# Commands used to build an old-style archive.

 44560 +old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs~\$RANLIB \$oldlib"

 44561 +

 44562 +# A language specific compiler.

 44563 +CC="gcc"

 44564 +

 44565 +# Is the compiler the GNU compiler?

 44566 +with_gcc=yes

 44567 +

 44568 +# Compiler flag to turn off builtin functions.

 44569 +no_builtin_flag=" -fno-builtin"

 44570 +

 44571 +# How to pass a linker flag through the compiler.

 44572 +wl="-Wl,"

 44573 +

 44574 +# Additional compiler flags for building library objects.

 44575 +pic_flag=" -fPIC -DPIC"

 44576 +

 44577 +# Compiler flag to prevent dynamic linking.

 44578 +link_static_flag="-static"

 44579 +

 44580 +# Does compiler simultaneously support -c and -o options?

 44581 +compiler_c_o="yes"

 44582 +

 44583 +# Whether or not to add -lc for building shared libraries.

 44584 +build_libtool_need_lc=yes

 44585 +

 44586 +# Whether or not to disallow shared libs when runtime libs are static.

 44587 +allow_libtool_libs_with_static_runtimes=no

 44588 +

 44589 +# Compiler flag to allow reflexive dlopens.

 44590 +export_dynamic_flag_spec="\${wl}--export-dynamic"

 44591 +

 44592 +# Compiler flag to generate shared objects directly from archives.

 44593 +whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive"

 44594 +

 44595 +# Whether the compiler copes with passing no objects directly.

 44596 +compiler_needs_object="no"

 44597 +

 44598 +# Create an old-style archive from a shared archive.

 44599 +old_archive_from_new_cmds=""

 44600 +

 44601 +# Create a temporary old-style archive to link instead of a shared archive.

 44602 +old_archive_from_expsyms_cmds=""

 44603 +

 44604 +# Commands used to build a shared archive.

 44605 +archive_cmds="\$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib"

 44606 +archive_expsym_cmds="echo \\\"{ global:\\\" > \$output_objdir/\$libname.ver~

 44607 +	    cat \$export_symbols | sed -e \\\"s/\\\\(.*\\\\)/\\\\1;/\\\" >> \$output_objdir/\$libname.ver~

 44608 +	    echo \\\"local: *; };\\\" >> \$output_objdir/\$libname.ver~

 44609 +	    \$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-version-script \${wl}\$output_objdir/\$libname.ver -o \$lib"

 44610 +

 44611 +# Commands used to build a loadable module if different from building

 44612 +# a shared archive.

 44613 +module_cmds=""

 44614 +module_expsym_cmds=""

 44615 +

 44616 +# Whether we are building with GNU ld or not.

 44617 +with_gnu_ld="yes"

 44618 +

 44619 +# Flag that allows shared libraries with undefined symbols to be built.

 44620 +allow_undefined_flag=""

 44621 +

 44622 +# Flag that enforces no undefined symbols.

 44623 +no_undefined_flag=""

 44624 +

 44625 +# Flag to hardcode $libdir into a binary during linking.

 44626 +# This must work even if $libdir does not exist

 44627 +hardcode_libdir_flag_spec="\${wl}-rpath \${wl}\$libdir"

 44628 +

 44629 +# If ld is used when linking, flag to hardcode $libdir into a binary

 44630 +# during linking.  This must work even if $libdir does not exist.

 44631 +hardcode_libdir_flag_spec_ld=""

 44632 +

 44633 +# Whether we need a single "-rpath" flag with a separated argument.

 44634 +hardcode_libdir_separator=""

 44635 +

 44636 +# Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes

 44637 +# DIR into the resulting binary.

 44638 +hardcode_direct=no

 44639 +

 44640 +# Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes

 44641 +# DIR into the resulting binary and the resulting library dependency is

 44642 +# "absolute",i.e impossible to change by setting ${shlibpath_var} if the

 44643 +# library is relocated.

 44644 +hardcode_direct_absolute=no

 44645 +

 44646 +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR

 44647 +# into the resulting binary.

 44648 +hardcode_minus_L=no

 44649 +

 44650 +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR

 44651 +# into the resulting binary.

 44652 +hardcode_shlibpath_var=unsupported

 44653 +

 44654 +# Set to "yes" if building a shared library automatically hardcodes DIR

 44655 +# into the library and all subsequent libraries and executables linked

 44656 +# against it.

 44657 +hardcode_automatic=no

 44658 +

 44659 +# Set to yes if linker adds runtime paths of dependent libraries

 44660 +# to runtime path list.

 44661 +inherit_rpath=no

 44662 +

 44663 +# Whether libtool must link a program against all its dependency libraries.

 44664 +link_all_deplibs=unknown

 44665 +

 44666 +# Fix the shell variable $srcfile for the compiler.

 44667 +fix_srcfile_path=""

 44668 +

 44669 +# Set to "yes" if exported symbols are required.

 44670 +always_export_symbols=no

 44671 +

 44672 +# The commands to list exported symbols.

 44673 +export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols"

 44674 +

 44675 +# Symbols that should not be listed in the preloaded symbols.

 44676 +exclude_expsyms="_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*"

 44677 +

 44678 +# Symbols that must always be exported.

 44679 +include_expsyms=""

 44680 +

 44681 +# Commands necessary for linking programs (against libraries) with templates.

 44682 +prelink_cmds=""

 44683 +

 44684 +# Specify filename containing input files.

 44685 +file_list_spec=""

 44686 +

 44687 +# How to hardcode a shared library path into an executable.

 44688 +hardcode_action=immediate

 44689 +

 44690 +# ### END LIBTOOL CONFIG

 44691 +

 44692 +# Generated from ltmain.m4sh; do not edit by hand

 44693 +

 44694 +# ltmain.sh (GNU libtool 1.2435 2007/03/18 18:44:42) 2.1a

 44695 +# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996

 44696 +

 44697 +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.

 44698 +# This is free software; see the source for copying conditions.  There is NO

 44699 +# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 44700 +

 44701 +# This program is free software; you can redistribute it and/or modify

 44702 +# it under the terms of the GNU General Public License as published by

 44703 +# the Free Software Foundation; either version 2 of the License, or

 44704 +# (at your option) any later version.

 44705 +#

 44706 +# This program is distributed in the hope that it will be useful, but

 44707 +# WITHOUT ANY WARRANTY; without even the implied warranty of

 44708 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 44709 +# General Public License for more details.

 44710 +#

 44711 +# You should have received a copy of the GNU General Public License

 44712 +# along with this program; if not, write to the Free Software

 44713 +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 44714 +#

 44715 +# As a special exception to the GNU General Public License, if you

 44716 +# distribute this file as part of a program that contains a

 44717 +# configuration script generated by Autoconf, you may include it under

 44718 +# the same distribution terms that you use for the rest of that program.

 44719 +

 44720 +# Usage: $progname [OPTION]... [MODE-ARG]...

 44721 +#

 44722 +# Provide generalized library-building support services.

 44723 +#

 44724 +#     --config             show all configuration variables

 44725 +#     --debug              enable verbose shell tracing

 44726 +# -n, --dry-run            display commands without modifying any files

 44727 +#     --features           display basic configuration information and exit

 44728 +#     --mode=MODE          use operation mode MODE

 44729 +#     --preserve-dup-deps  don't remove duplicate dependency libraries

 44730 +#     --quiet, --silent    don't print informational messages

 44731 +#     --tag=TAG            use configuration variables from tag TAG

 44732 +# -v, --verbose            print informational messages (default)

 44733 +#     --version            print version information

 44734 +# -h, --help               print short or long help message

 44735 +#

 44736 +# MODE must be one of the following:

 44737 +#

 44738 +#       clean              remove files from the build directory

 44739 +#       compile            compile a source file into a libtool object

 44740 +#       execute            automatically set library path, then run a program

 44741 +#       finish             complete the installation of libtool libraries

 44742 +#       install            install libraries or executables

 44743 +#       link               create a library or an executable

 44744 +#       uninstall          remove libraries from an installed directory

 44745 +#

 44746 +# MODE-ARGS vary depending on the MODE.

 44747 +# Try `$progname --help --mode=MODE' for a more detailed description of MODE.

 44748 +#

 44749 +# When reporting a bug, please describe a test case to reproduce it and

 44750 +# include the following information:

 44751 +#

 44752 +#       host-triplet:	$host

 44753 +#       shell:		$SHELL

 44754 +#       compiler:		$LTCC

 44755 +#       compiler flags:		$LTCFLAGS

 44756 +#       linker:		$LD (gnu? $with_gnu_ld)

 44757 +#       $progname:		(GNU libtool 1.2435 2007/03/18 18:44:42) 2.1a

 44758 +#       automake:		$automake_version

 44759 +#       autoconf:		$autoconf_version

 44760 +#

 44761 +# Report bugs to <bug-libtool@gnu.org>.

 44762 +

 44763 +PROGRAM=ltmain.sh

 44764 +PACKAGE=libtool

 44765 +VERSION=2.1a

 44766 +TIMESTAMP=" 1.2435 2007/03/18 18:44:42"

 44767 +package_revision=1.2435

 44768 +

 44769 +# Be Bourne compatible

 44770 +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then

 44771 +  emulate sh

 44772 +  NULLCMD=:

 44773 +  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which

 44774 +  # is contrary to our usage.  Disable this feature.

 44775 +  alias -g '${1+"$@"}'='"$@"'

 44776 +  setopt NO_GLOB_SUBST

 44777 +else

 44778 +  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac

 44779 +fi

 44780 +BIN_SH=xpg4; export BIN_SH # for Tru64

 44781 +DUALCASE=1; export DUALCASE # for MKS sh

 44782 +

 44783 +# NLS nuisances: We save the old values to restore during execute mode.

 44784 +# Only set LANG and LC_ALL to C if already set.

 44785 +# These must not be set unconditionally because not all systems understand

 44786 +# e.g. LANG=C (notably SCO).

 44787 +for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

 44788 +do

 44789 +  eval "if test \"\${$lt_var+set}\" = set; then

 44790 +          save_$lt_var=\$$lt_var

 44791 +          $lt_var=C

 44792 +	  export $lt_var

 44793 +	fi"

 44794 +done

 44795 +

 44796 +$lt_unset CDPATH

 44797 +

 44798 +

 44799 +

 44800 +

 44801 +

 44802 +: ${CP="cp -f"}

 44803 +: ${ECHO="echo"}

 44804 +: ${EGREP="/bin/grep -E"}

 44805 +: ${FGREP="/bin/grep -F"}

 44806 +: ${GREP="/bin/grep"}

 44807 +: ${LN_S="ln -s"}

 44808 +: ${MAKE="make"}

 44809 +: ${MKDIR="mkdir"}

 44810 +: ${MV="mv -f"}

 44811 +: ${RM="rm -f"}

 44812 +: ${SED="/bin/sed"}

 44813 +: ${SHELL="${CONFIG_SHELL-/bin/sh}"}

 44814 +: ${Xsed="$SED -e 1s/^X//"}

 44815 +

 44816 +# Global variables:

 44817 +EXIT_SUCCESS=0

 44818 +EXIT_FAILURE=1

 44819 +EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.

 44820 +EXIT_SKIP=77	  # $? = 77 is used to indicate a skipped test to automake.

 44821 +

 44822 +exit_status=$EXIT_SUCCESS

 44823 +

 44824 +# Make sure IFS has a sensible default

 44825 +lt_nl='

 44826 +'

 44827 +IFS=" 	$lt_nl"

 44828 +

 44829 +dirname="s,/[^/]*$,,"

 44830 +basename="s,^.*/,,"

 44831 +

 44832 +# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh

 44833 +# is ksh but when the shell is invoked as "sh" and the current value of

 44834 +# the _XPG environment variable is not equal to 1 (one), the special

 44835 +# positional parameter $0, within a function call, is the name of the

 44836 +# function.

 44837 +progpath="$0"

 44838 +

 44839 +# The name of this program:

 44840 +# In the unlikely event $progname began with a '-', it would play havoc with

 44841 +# func_echo (imagine progname=-n), so we prepend ./ in that case:

 44842 +progname=`$ECHO "X$progpath" | $Xsed -e "$basename" -e 's,^-,./-,'`

 44843 +

 44844 +# Make sure we have an absolute path for reexecution:

 44845 +case $progpath in

 44846 +  [\\/]*|[A-Za-z]:\\*) ;;

 44847 +  *[\\/]*)

 44848 +     progdir=`$ECHO "X$progpath" | $Xsed -e "$dirname"`

 44849 +     progdir=`cd "$progdir" && pwd`

 44850 +     progpath="$progdir/$progname"

 44851 +     ;;

 44852 +  *)

 44853 +     save_IFS="$IFS"

 44854 +     IFS=:

 44855 +     for progdir in $PATH; do

 44856 +       IFS="$save_IFS"

 44857 +       test -x "$progdir/$progname" && break

 44858 +     done

 44859 +     IFS="$save_IFS"

 44860 +     test -n "$progdir" || progdir=`pwd`

 44861 +     progpath="$progdir/$progname"

 44862 +     ;;

 44863 +esac

 44864 +

 44865 +# Sed substitution that helps us do robust quoting.  It backslashifies

 44866 +# metacharacters that are still active within double-quoted strings.

 44867 +Xsed="${SED}"' -e 1s/^X//'

 44868 +sed_quote_subst='s/\([`"$\\]\)/\\\1/g'

 44869 +

 44870 +# Same as above, but do not quote variable references.

 44871 +double_quote_subst='s/\(["`\\]\)/\\\1/g'

 44872 +

 44873 +# Re-`\' parameter expansions in output of double_quote_subst that were

 44874 +# `\'-ed in input to the same.  If an odd number of `\' preceded a '$'

 44875 +# in input to double_quote_subst, that '$' was protected from expansion.

 44876 +# Since each input `\' is now two `\'s, look for any number of runs of

 44877 +# four `\'s followed by two `\'s and then a '$'.  `\' that '$'.

 44878 +bs='\\'

 44879 +bs2='\\\\'

 44880 +bs4='\\\\\\\\'

 44881 +dollar='\$'

 44882 +sed_double_backslash="\

 44883 +  s/$bs4/&\\

 44884 +/g

 44885 +  s/^$bs2$dollar/$bs&/

 44886 +  s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g

 44887 +  s/\n//g"

 44888 +

 44889 +# Standard options:

 44890 +opt_dry_run=false

 44891 +opt_help=false

 44892 +opt_quiet=false

 44893 +opt_verbose=false

 44894 +

 44895 +# func_echo arg...

 44896 +# Echo program name prefixed message, along with the current mode

 44897 +# name if it has been set yet.

 44898 +func_echo ()

 44899 +{

 44900 +    $ECHO "$progname${mode+: }$mode: "${1+"$@"}

 44901 +}

 44902 +

 44903 +# func_verbose arg...

 44904 +# Echo program name prefixed message in verbose mode only.

 44905 +func_verbose ()

 44906 +{

 44907 +    $opt_verbose && func_echo ${1+"$@"}

 44908 +

 44909 +    # A bug in bash halts the script if the last line of a function

 44910 +    # fails when set -e is in force, so we need another command to

 44911 +    # work around that:

 44912 +    :

 44913 +}

 44914 +

 44915 +# func_error arg...

 44916 +# Echo program name prefixed message to standard error.

 44917 +func_error ()

 44918 +{

 44919 +    $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2

 44920 +}

 44921 +

 44922 +# func_warning arg...

 44923 +# Echo program name prefixed warning message to standard error.

 44924 +func_warning ()

 44925 +{

 44926 +    $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2

 44927 +}

 44928 +

 44929 +# func_fatal_error arg...

 44930 +# Echo program name prefixed message to standard error, and exit.

 44931 +func_fatal_error ()

 44932 +{

 44933 +    func_error ${1+"$@"}

 44934 +    exit $EXIT_FAILURE

 44935 +}

 44936 +

 44937 +# func_fatal_help arg...

 44938 +# Echo program name prefixed message to standard error, followed by

 44939 +# a help hint, and exit.

 44940 +func_fatal_help ()

 44941 +{

 44942 +    func_error ${1+"$@"}

 44943 +    func_fatal_error "$help"

 44944 +}

 44945 +help="Try \`$progname --help' for more information."  ## default

 44946 +

 44947 +

 44948 +# func_grep expression filename

 44949 +# Check whether EXPRESSION matches any line of FILENAME, without output.

 44950 +func_grep ()

 44951 +{

 44952 +    $GREP "$1" "$2" >/dev/null 2>&1

 44953 +}

 44954 +

 44955 +

 44956 +# func_mkdir_p directory-path

 44957 +# Make sure the entire path to DIRECTORY-PATH is available.

 44958 +func_mkdir_p ()

 44959 +{

 44960 +    my_directory_path="$1"

 44961 +    my_dir_list=

 44962 +

 44963 +    if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then

 44964 +

 44965 +      # Protect directory names starting with `-'

 44966 +      case $my_directory_path in

 44967 +        -*) my_directory_path="./$my_directory_path" ;;

 44968 +      esac

 44969 +

 44970 +      # While some portion of DIR does not yet exist...

 44971 +      while test ! -d "$my_directory_path"; do

 44972 +        # ...make a list in topmost first order.  Use a colon delimited

 44973 +	# list incase some portion of path contains whitespace.

 44974 +        my_dir_list="$my_directory_path:$my_dir_list"

 44975 +

 44976 +        # If the last portion added has no slash in it, the list is done

 44977 +        case $my_directory_path in */*) ;; *) break ;; esac

 44978 +

 44979 +        # ...otherwise throw away the child directory and loop

 44980 +        my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`

 44981 +      done

 44982 +      my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`

 44983 +

 44984 +      save_mkdir_p_IFS="$IFS"; IFS=':'

 44985 +      for my_dir in $my_dir_list; do

 44986 +	IFS="$save_mkdir_p_IFS"

 44987 +        # mkdir can fail with a `File exist' error if two processes

 44988 +        # try to create one of the directories concurrently.  Don't

 44989 +        # stop in that case!

 44990 +        $MKDIR "$my_dir" 2>/dev/null || :

 44991 +      done

 44992 +      IFS="$save_mkdir_p_IFS"

 44993 +

 44994 +      # Bail out if we (or some other process) failed to create a directory.

 44995 +      test -d "$my_directory_path" || \

 44996 +        func_fatal_error "Failed to create \`$1'"

 44997 +    fi

 44998 +}

 44999 +

 45000 +

 45001 +# func_mktempdir [string]

 45002 +# Make a temporary directory that won't clash with other running

 45003 +# libtool processes, and avoids race conditions if possible.  If

 45004 +# given, STRING is the basename for that directory.

 45005 +func_mktempdir ()

 45006 +{

 45007 +    my_template="${TMPDIR-/tmp}/${1-$progname}"

 45008 +

 45009 +    if test "$opt_dry_run" = ":"; then

 45010 +      # Return a directory name, but don't create it in dry-run mode

 45011 +      my_tmpdir="${my_template}-$$"

 45012 +    else

 45013 +

 45014 +      # If mktemp works, use that first and foremost

 45015 +      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`

 45016 +

 45017 +      if test ! -d "$my_tmpdir"; then

 45018 +        # Failing that, at least try and use $RANDOM to avoid a race

 45019 +        my_tmpdir="${my_template}-${RANDOM-0}$$"

 45020 +

 45021 +        save_mktempdir_umask=`umask`

 45022 +        umask 0077

 45023 +        $MKDIR "$my_tmpdir"

 45024 +        umask $save_mktempdir_umask

 45025 +      fi

 45026 +

 45027 +      # If we're not in dry-run mode, bomb out on failure

 45028 +      test -d "$my_tmpdir" || \

 45029 +        func_fatal_error "cannot create temporary directory \`$my_tmpdir'"

 45030 +    fi

 45031 +

 45032 +    $ECHO "X$my_tmpdir" | $Xsed

 45033 +}

 45034 +

 45035 +

 45036 +# func_quote_for_eval arg

 45037 +# Aesthetically quote ARG to be evaled later.

 45038 +# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT

 45039 +# is double-quoted, suitable for a subsequent eval, whereas

 45040 +# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters

 45041 +# which are still active within double quotes backslashified.

 45042 +func_quote_for_eval ()

 45043 +{

 45044 +    case $1 in

 45045 +      *[\\\`\"\$]*)

 45046 +	func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;

 45047 +      *)

 45048 +        func_quote_for_eval_unquoted_result="$1" ;;

 45049 +    esac

 45050 +

 45051 +    case $func_quote_for_eval_unquoted_result in

 45052 +      # Double-quote args containing shell metacharacters to delay

 45053 +      # word splitting, command substitution and and variable

 45054 +      # expansion for a subsequent eval.

 45055 +      # Many Bourne shells cannot handle close brackets correctly

 45056 +      # in scan sets, so we specify it separately.

 45057 +      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

 45058 +        func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""

 45059 +        ;;

 45060 +      *)

 45061 +        func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"

 45062 +    esac

 45063 +}

 45064 +

 45065 +

 45066 +# func_quote_for_expand arg

 45067 +# Aesthetically quote ARG to be evaled later; same as above,

 45068 +# but do not quote variable references.

 45069 +func_quote_for_expand ()

 45070 +{

 45071 +    case $1 in

 45072 +      *[\\\`\"]*)

 45073 +	my_arg=`$ECHO "X$1" | $Xsed \

 45074 +	    -e "$double_quote_subst" -e "$sed_double_backslash"` ;;

 45075 +      *)

 45076 +        my_arg="$1" ;;

 45077 +    esac

 45078 +

 45079 +    case $my_arg in

 45080 +      # Double-quote args containing shell metacharacters to delay

 45081 +      # word splitting and command substitution for a subsequent eval.

 45082 +      # Many Bourne shells cannot handle close brackets correctly

 45083 +      # in scan sets, so we specify it separately.

 45084 +      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

 45085 +        my_arg="\"$my_arg\""

 45086 +        ;;

 45087 +    esac

 45088 +

 45089 +    func_quote_for_expand_result="$my_arg"

 45090 +}

 45091 +

 45092 +

 45093 +# func_show_eval cmd [fail_exp]

 45094 +# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is

 45095 +# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP

 45096 +# is given, then evaluate it.

 45097 +func_show_eval ()

 45098 +{

 45099 +    my_cmd="$1"

 45100 +    my_fail_exp="${2-:}"

 45101 +

 45102 +    ${opt_silent-false} || {

 45103 +      func_quote_for_expand "$my_cmd"

 45104 +      eval "func_echo $func_quote_for_expand_result"

 45105 +    }

 45106 +

 45107 +    if ${opt_dry_run-false}; then :; else

 45108 +      eval "$my_cmd"

 45109 +      my_status=$?

 45110 +      if test "$my_status" -eq 0; then :; else

 45111 +	eval "(exit $my_status); $my_fail_exp"

 45112 +      fi

 45113 +    fi

 45114 +}

 45115 +

 45116 +

 45117 +

 45118 +

 45119 +

 45120 +# func_version

 45121 +# Echo version message to standard output and exit.

 45122 +func_version ()

 45123 +{

 45124 +    $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {

 45125 +        s/^# //

 45126 +	s/^# *$//

 45127 +        s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/

 45128 +        p

 45129 +     }' < "$progpath"

 45130 +     exit $?

 45131 +}

 45132 +

 45133 +# func_usage

 45134 +# Echo short help message to standard output and exit.

 45135 +func_usage ()

 45136 +{

 45137 +    $SED -n '/^# Usage:/,/# -h/ {

 45138 +        s/^# //

 45139 +	s/^# *$//

 45140 +	s/\$progname/'$progname'/

 45141 +	p

 45142 +    }' < "$progpath"

 45143 +    $ECHO

 45144 +    $ECHO "run \`$progname --help | more' for full usage"

 45145 +    exit $?

 45146 +}

 45147 +

 45148 +# func_help

 45149 +# Echo long help message to standard output and exit.

 45150 +func_help ()

 45151 +{

 45152 +    $SED -n '/^# Usage:/,/# Report bugs to/ {

 45153 +        s/^# //

 45154 +	s/^# *$//

 45155 +	s*\$progname*'$progname'*

 45156 +	s*\$host*'"$host"'*

 45157 +	s*\$SHELL*'"$SHELL"'*

 45158 +	s*\$LTCC*'"$LTCC"'*

 45159 +	s*\$LTCFLAGS*'"$LTCFLAGS"'*

 45160 +	s*\$LD*'"$LD"'*

 45161 +	s/\$with_gnu_ld/'"$with_gnu_ld"'/

 45162 +	s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/

 45163 +	s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/

 45164 +	p

 45165 +     }' < "$progpath"

 45166 +    exit $?

 45167 +}

 45168 +

 45169 +# func_missing_arg argname

 45170 +# Echo program name prefixed message to standard error and set global

 45171 +# exit_cmd.

 45172 +func_missing_arg ()

 45173 +{

 45174 +    func_error "missing argument for $1"

 45175 +    exit_cmd=exit

 45176 +}

 45177 +

 45178 +exit_cmd=:

 45179 +

 45180 +

 45181 +

 45182 +

 45183 +

 45184 +# Check that we have a working $ECHO.

 45185 +if test "X$1" = X--no-reexec; then

 45186 +  # Discard the --no-reexec flag, and continue.

 45187 +  shift

 45188 +elif test "X$1" = X--fallback-echo; then

 45189 +  # Avoid inline document here, it may be left over

 45190 +  :

 45191 +elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then

 45192 +  # Yippee, $ECHO works!

 45193 +  :

 45194 +else

 45195 +  # Restart under the correct shell, and then maybe $ECHO will work.

 45196 +  exec $SHELL "$progpath" --no-reexec ${1+"$@"}

 45197 +fi

 45198 +

 45199 +if test "X$1" = X--fallback-echo; then

 45200 +  # used as fallback echo

 45201 +  shift

 45202 +  cat <<EOF

 45203 +$*

 45204 +EOF

 45205 +  exit $EXIT_SUCCESS

 45206 +fi

 45207 +

 45208 +magic="%%%MAGIC variable%%%"

 45209 +

 45210 +

 45211 +# Global variables.

 45212 +# $mode is unset

 45213 +nonopt=

 45214 +execute_dlfiles=

 45215 +preserve_args=

 45216 +lo2o="s/\\.lo\$/.${objext}/"

 45217 +o2lo="s/\\.${objext}\$/.lo/"

 45218 +extracted_archives=

 45219 +extracted_serial=0

 45220 +

 45221 +opt_dry_run=false

 45222 +opt_duplicate_deps=false

 45223 +opt_silent=false

 45224 +opt_debug=:

 45225 +

 45226 +# If this variable is set in any of the actions, the command in it

 45227 +# will be execed at the end.  This prevents here-documents from being

 45228 +# left over by shells.

 45229 +exec_cmd=

 45230 +

 45231 +# func_fatal_configuration arg...

 45232 +# Echo program name prefixed message to standard error, followed by

 45233 +# a configuration failure hint, and exit.

 45234 +func_fatal_configuration ()

 45235 +{

 45236 +    func_error ${1+"$@"}

 45237 +    func_error "See the $PACKAGE documentation for more information."

 45238 +    func_fatal_error "Fatal configuration error."

 45239 +}

 45240 +

 45241 +

 45242 +# func_config

 45243 +# Display the configuration for all the tags in this script.

 45244 +func_config ()

 45245 +{

 45246 +    re_begincf='^# ### BEGIN LIBTOOL'

 45247 +    re_endcf='^# ### END LIBTOOL'

 45248 +

 45249 +    # Default configuration.

 45250 +    $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"

 45251 +

 45252 +    # Now print the configurations for the tags.

 45253 +    for tagname in $taglist; do

 45254 +      $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"

 45255 +    done

 45256 +

 45257 +    exit $?

 45258 +}

 45259 +

 45260 +# func_features

 45261 +# Display the features supported by this script.

 45262 +func_features ()

 45263 +{

 45264 +    $ECHO "host: $host"

 45265 +    if test "$build_libtool_libs" = yes; then

 45266 +      $ECHO "enable shared libraries"

 45267 +    else

 45268 +      $ECHO "disable shared libraries"

 45269 +    fi

 45270 +    if test "$build_old_libs" = yes; then

 45271 +      $ECHO "enable static libraries"

 45272 +    else

 45273 +      $ECHO "disable static libraries"

 45274 +    fi

 45275 +

 45276 +    exit $?

 45277 +}

 45278 +

 45279 +# func_enable_tag tagname

 45280 +# Verify that TAGNAME is valid, and either flag an error and exit, or

 45281 +# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist

 45282 +# variable here.

 45283 +func_enable_tag ()

 45284 +{

 45285 +  # Global variable:

 45286 +  tagname="$1"

 45287 +

 45288 +  re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"

 45289 +  re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"

 45290 +  sed_extractcf="/$re_begincf/,/$re_endcf/p"

 45291 +

 45292 +  # Validate tagname.

 45293 +  case $tagname in

 45294 +    *[!-_A-Za-z0-9,/]*)

 45295 +      func_fatal_error "invalid tag name: $tagname"

 45296 +      ;;

 45297 +  esac

 45298 +

 45299 +  # Don't test for the "default" C tag, as we know it's

 45300 +  # there but not specially marked.

 45301 +  case $tagname in

 45302 +    CC) ;;

 45303 +    *)

 45304 +      if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then

 45305 +	taglist="$taglist $tagname"

 45306 +

 45307 +	# Evaluate the configuration.  Be careful to quote the path

 45308 +	# and the sed script, to avoid splitting on whitespace, but

 45309 +	# also don't use non-portable quotes within backquotes within

 45310 +	# quotes we have to do it in 2 steps:

 45311 +	extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`

 45312 +	eval "$extractedcf"

 45313 +      else

 45314 +	func_error "ignoring unknown tag $tagname"

 45315 +      fi

 45316 +      ;;

 45317 +  esac

 45318 +}

 45319 +

 45320 +

 45321 +func_mode_help ()

 45322 +{

 45323 +    # We need to display help for each of the modes.

 45324 +    case $mode in

 45325 +      "")

 45326 +        # Generic help is extracted from the usage comments

 45327 +        # at the start of this file.

 45328 +        func_help

 45329 +        ;;

 45330 +

 45331 +      clean)

 45332 +        $ECHO \

 45333 +"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...

 45334 +

 45335 +Remove files from the build directory.

 45336 +

 45337 +RM is the name of the program to use to delete files associated with each FILE

 45338 +(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed

 45339 +to RM.

 45340 +

 45341 +If FILE is a libtool library, object or program, all the files associated

 45342 +with it are deleted. Otherwise, only FILE itself is deleted using RM."

 45343 +        ;;

 45344 +

 45345 +      compile)

 45346 +      $ECHO \

 45347 +"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE

 45348 +

 45349 +Compile a source file into a libtool library object.

 45350 +

 45351 +This mode accepts the following additional options:

 45352 +

 45353 +  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE

 45354 +  -no-suppress      do not suppress compiler output for multiple passes

 45355 +  -prefer-pic       try to building PIC objects only

 45356 +  -prefer-non-pic   try to building non-PIC objects only

 45357 +  -shared           do not build a \`.o' file suitable for static linking

 45358 +  -static           only build a \`.o' file suitable for static linking

 45359 +

 45360 +COMPILE-COMMAND is a command to be used in creating a \`standard' object file

 45361 +from the given SOURCEFILE.

 45362 +

 45363 +The output file name is determined by removing the directory component from

 45364 +SOURCEFILE, then substituting the C source code suffix \`.c' with the

 45365 +library object suffix, \`.lo'."

 45366 +        ;;

 45367 +

 45368 +      execute)

 45369 +        $ECHO \

 45370 +"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...

 45371 +

 45372 +Automatically set library path, then run a program.

 45373 +

 45374 +This mode accepts the following additional options:

 45375 +

 45376 +  -dlopen FILE      add the directory containing FILE to the library path

 45377 +

 45378 +This mode sets the library path environment variable according to \`-dlopen'

 45379 +flags.

 45380 +

 45381 +If any of the ARGS are libtool executable wrappers, then they are translated

 45382 +into their corresponding uninstalled binary, and any of their required library

 45383 +directories are added to the library path.

 45384 +

 45385 +Then, COMMAND is executed, with ARGS as arguments."

 45386 +        ;;

 45387 +

 45388 +      finish)

 45389 +        $ECHO \

 45390 +"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...

 45391 +

 45392 +Complete the installation of libtool libraries.

 45393 +

 45394 +Each LIBDIR is a directory that contains libtool libraries.

 45395 +

 45396 +The commands that this mode executes may require superuser privileges.  Use

 45397 +the \`--dry-run' option if you just want to see what would be executed."

 45398 +        ;;

 45399 +

 45400 +      install)

 45401 +        $ECHO \

 45402 +"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...

 45403 +

 45404 +Install executables or libraries.

 45405 +

 45406 +INSTALL-COMMAND is the installation command.  The first component should be

 45407 +either the \`install' or \`cp' program.

 45408 +

 45409 +The following components of INSTALL-COMMAND are treated specially:

 45410 +

 45411 +  -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation

 45412 +

 45413 +The rest of the components are interpreted as arguments to that command (only

 45414 +BSD-compatible install options are recognized)."

 45415 +        ;;

 45416 +

 45417 +      link)

 45418 +        $ECHO \

 45419 +"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...

 45420 +

 45421 +Link object files or libraries together to form another library, or to

 45422 +create an executable program.

 45423 +

 45424 +LINK-COMMAND is a command using the C compiler that you would use to create

 45425 +a program from several object files.

 45426 +

 45427 +The following components of LINK-COMMAND are treated specially:

 45428 +

 45429 +  -all-static       do not do any dynamic linking at all

 45430 +  -avoid-version    do not add a version suffix if possible

 45431 +  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime

 45432 +  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols

 45433 +  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)

 45434 +  -export-symbols SYMFILE

 45435 +                    try to export only the symbols listed in SYMFILE

 45436 +  -export-symbols-regex REGEX

 45437 +                    try to export only the symbols matching REGEX

 45438 +  -LLIBDIR          search LIBDIR for required installed libraries

 45439 +  -lNAME            OUTPUT-FILE requires the installed library libNAME

 45440 +  -module           build a library that can dlopened

 45441 +  -no-fast-install  disable the fast-install mode

 45442 +  -no-install       link a not-installable executable

 45443 +  -no-undefined     declare that a library does not refer to external symbols

 45444 +  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects

 45445 +  -objectlist FILE  Use a list of object files found in FILE to specify objects

 45446 +  -precious-files-regex REGEX

 45447 +                    don't remove output files matching REGEX

 45448 +  -release RELEASE  specify package release information

 45449 +  -rpath LIBDIR     the created library will eventually be installed in LIBDIR

 45450 +  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries

 45451 +  -shared           only do dynamic linking of libtool libraries

 45452 +  -shrext SUFFIX    override the standard shared library file extension

 45453 +  -static           do not do any dynamic linking of uninstalled libtool libraries

 45454 +  -static-libtool-libs

 45455 +                    do not do any dynamic linking of libtool libraries

 45456 +  -version-info CURRENT[:REVISION[:AGE]]

 45457 +                    specify library version info [each variable defaults to 0]

 45458 +  -weak LIBNAME     declare that the target provides the LIBNAME interface

 45459 +

 45460 +All other options (arguments beginning with \`-') are ignored.

 45461 +

 45462 +Every other argument is treated as a filename.  Files ending in \`.la' are

 45463 +treated as uninstalled libtool libraries, other files are standard or library

 45464 +object files.

 45465 +

 45466 +If the OUTPUT-FILE ends in \`.la', then a libtool library is created,

 45467 +only library objects (\`.lo' files) may be specified, and \`-rpath' is

 45468 +required, except when creating a convenience library.

 45469 +

 45470 +If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created

 45471 +using \`ar' and \`ranlib', or on Windows using \`lib'.

 45472 +

 45473 +If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file

 45474 +is created, otherwise an executable program is created."

 45475 +        ;;

 45476 +

 45477 +      uninstall)

 45478 +        $ECHO \

 45479 +"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...

 45480 +

 45481 +Remove libraries from an installation directory.

 45482 +

 45483 +RM is the name of the program to use to delete files associated with each FILE

 45484 +(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed

 45485 +to RM.

 45486 +

 45487 +If FILE is a libtool library, all the files associated with it are deleted.

 45488 +Otherwise, only FILE itself is deleted using RM."

 45489 +        ;;

 45490 +

 45491 +      *)

 45492 +        func_fatal_help "invalid operation mode \`$mode'"

 45493 +        ;;

 45494 +    esac

 45495 +

 45496 +    $ECHO

 45497 +    $ECHO "Try \`$progname --help' for more information about other modes."

 45498 +

 45499 +    exit $?

 45500 +}

 45501 +

 45502 +# Generated shell functions inserted here.

 45503 +

 45504 +# func_dirname file append nondir_replacement

 45505 +# Compute the dirname of FILE.  If nonempty, add APPEND to the result,

 45506 +# otherwise set result to NONDIR_REPLACEMENT.

 45507 +func_dirname ()

 45508 +{

 45509 +  case ${1} in

 45510 +    */*) func_dirname_result="${1%/*}${2}" ;;

 45511 +    *  ) func_dirname_result="${3}" ;;

 45512 +  esac

 45513 +}

 45514 +

 45515 +# func_basename file

 45516 +func_basename ()

 45517 +{

 45518 +  func_basename_result="${1##*/}"

 45519 +}

 45520 +

 45521 +# func_dirname_and_basename file append nondir_replacement

 45522 +# perform func_basename and func_dirname in a single function

 45523 +# call:

 45524 +#   dirname:  Compute the dirname of FILE.  If nonempty,

 45525 +#             add APPEND to the result, otherwise set result

 45526 +#             to NONDIR_REPLACEMENT.

 45527 +#             value returned in "$func_dirname_result"

 45528 +#   basename: Compute filename of FILE.

 45529 +#             value retuned in "$func_basename_result"

 45530 +# Implementation must be kept synchronized with func_dirname

 45531 +# and func_basename. For efficiency, we do not delegate to

 45532 +# those functions but instead duplicate the functionality here.

 45533 +func_dirname_and_basename ()

 45534 +{

 45535 +  case ${1} in

 45536 +    */*) func_dirname_result="${1%/*}${2}" ;;

 45537 +    *  ) func_dirname_result="${3}" ;;

 45538 +  esac

 45539 +  func_basename_result="${1##*/}"

 45540 +}

 45541 +

 45542 +# func_stripname prefix suffix name

 45543 +# strip PREFIX and SUFFIX off of NAME.

 45544 +# PREFIX and SUFFIX must not contain globbing or regex special

 45545 +# characters, hashes, percent signs, but SUFFIX may contain a leading

 45546 +# dot (in which case that matches only a dot).

 45547 +func_stripname ()

 45548 +{

 45549 +  # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are

 45550 +  # positional parameters, so assign one to ordinary parameter first.

 45551 +  func_stripname_result=${3}

 45552 +  func_stripname_result=${func_stripname_result#"${1}"}

 45553 +  func_stripname_result=${func_stripname_result%"${2}"}

 45554 +}

 45555 +

 45556 +# func_opt_split

 45557 +func_opt_split ()

 45558 +{

 45559 +  func_opt_split_opt=${1%%=*}

 45560 +  func_opt_split_arg=${1#*=}

 45561 +}

 45562 +

 45563 +# func_lo2o object

 45564 +func_lo2o ()

 45565 +{

 45566 +  case ${1} in

 45567 +    *.lo) func_lo2o_result=${1%.lo}.${objext} ;;

 45568 +    *)    func_lo2o_result=${1} ;;

 45569 +  esac

 45570 +}

 45571 +

 45572 +# func_xform libobj-or-source

 45573 +func_xform ()

 45574 +{

 45575 +  func_xform_result=${1%.*}.lo

 45576 +}

 45577 +

 45578 +# func_arith arithmetic-term...

 45579 +func_arith ()

 45580 +{

 45581 +  func_arith_result=$(( $* ))

 45582 +}

 45583 +

 45584 +# func_len string

 45585 +# STRING may not start with a hyphen.

 45586 +func_len ()

 45587 +{

 45588 +  func_len_result=${#1}

 45589 +}

 45590 +

 45591 +

 45592 +# func_append var value

 45593 +# Append VALUE to the end of shell variable VAR.

 45594 +func_append ()

 45595 +{

 45596 +  eval "$1+=\$2"

 45597 +}

 45598 +# Generated shell functions inserted here.

 45599 +

 45600 +

 45601 +# Parse options once, thoroughly.  This comes as soon as possible in

 45602 +# the script to make things like `libtool --version' happen quickly.

 45603 +{

 45604 +

 45605 +  # Shorthand for --mode=foo, only valid as the first argument

 45606 +  case $1 in

 45607 +  clean|clea|cle|cl)

 45608 +    shift; set dummy --mode clean ${1+"$@"}; shift

 45609 +    ;;

 45610 +  compile|compil|compi|comp|com|co|c)

 45611 +    shift; set dummy --mode compile ${1+"$@"}; shift

 45612 +    ;;

 45613 +  execute|execut|execu|exec|exe|ex|e)

 45614 +    shift; set dummy --mode execute ${1+"$@"}; shift

 45615 +    ;;

 45616 +  finish|finis|fini|fin|fi|f)

 45617 +    shift; set dummy --mode finish ${1+"$@"}; shift

 45618 +    ;;

 45619 +  install|instal|insta|inst|ins|in|i)

 45620 +    shift; set dummy --mode install ${1+"$@"}; shift

 45621 +    ;;

 45622 +  link|lin|li|l)

 45623 +    shift; set dummy --mode link ${1+"$@"}; shift

 45624 +    ;;

 45625 +  uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)

 45626 +    shift; set dummy --mode uninstall ${1+"$@"}; shift

 45627 +    ;;

 45628 +  esac

 45629 +

 45630 +  # Parse non-mode specific arguments:

 45631 +  while test "$#" -gt 0; do

 45632 +    opt="$1"

 45633 +    shift

 45634 +

 45635 +    case $opt in

 45636 +      --config)		func_config 					;;

 45637 +

 45638 +      --debug)		preserve_args="$preserve_args $opt"

 45639 +	    		func_echo "enabling shell trace mode"

 45640 +	    		opt_debug='set -x'

 45641 +			$opt_debug

 45642 +			;;

 45643 +

 45644 +      -dlopen)		test "$#" -eq 0 && func_missing_arg "$opt" && break

 45645 +			execute_dlfiles="$execute_dlfiles $1"

 45646 +			shift

 45647 +			;;

 45648 +

 45649 +      --dry-run | -n)	opt_dry_run=:					;;

 45650 +      --features)       func_features					;;

 45651 +      --finish)		mode="finish"					;;

 45652 +

 45653 +      --mode)		test "$#" -eq 0 && func_missing_arg "$opt" && break

 45654 +	    		case $1 in

 45655 +			  # Valid mode arguments:

 45656 +			  clean)	;;

 45657 +			  compile)	;;

 45658 +			  execute)	;;

 45659 +			  finish)	;;

 45660 +			  install)	;;

 45661 +			  link)		;;

 45662 +			  relink)	;;

 45663 +			  uninstall)	;;

 45664 +

 45665 +			  # Catch anything else as an error

 45666 +			  *) func_error "invalid argument for $opt"

 45667 +			     exit_cmd=exit

 45668 +			     break

 45669 +			     ;;

 45670 +		        esac

 45671 +

 45672 +	    		mode="$1"

 45673 +			shift

 45674 +			;;

 45675 +

 45676 +      --preserve-dup-deps)

 45677 +      			opt_duplicate_deps=:				;;

 45678 +

 45679 +      --quiet|--silent)	preserve_args="$preserve_args $opt"

 45680 +	    		opt_silent=:

 45681 +			;;

 45682 +

 45683 +      --verbose| -v)	preserve_args="$preserve_args $opt"

 45684 +	    		opt_silent=false

 45685 +			;;

 45686 +

 45687 +      --tag)		test "$#" -eq 0 && func_missing_arg "$opt" && break

 45688 +			preserve_args="$preserve_args $opt $1"

 45689 +			func_enable_tag "$1"	# tagname is set here

 45690 +			shift

 45691 +			;;

 45692 +

 45693 +      # Separate optargs to long options:

 45694 +      -dlopen=*|--mode=*|--tag=*)

 45695 +			func_opt_split "$opt"

 45696 +			set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}

 45697 +			shift

 45698 +			;;

 45699 +

 45700 +      -\?|-h)		func_usage					;;

 45701 +      --help)		opt_help=:					;;

 45702 +      --version)	func_version					;;

 45703 +

 45704 +      -*)		func_fatal_help "unrecognized option \`$opt'"	;;

 45705 +

 45706 +      *)		nonopt="$opt"

 45707 +      			break

 45708 +			;;

 45709 +    esac

 45710 +  done

 45711 +

 45712 +  # Now that we've collected a possible --mode arg, show help if necessary

 45713 +  $opt_help && func_mode_help

 45714 +

 45715 +  case $host in

 45716 +    *cygwin* | *mingw* | *pw32*)

 45717 +      # don't eliminate duplications in $postdeps and $predeps

 45718 +      opt_duplicate_compiler_generated_deps=:

 45719 +      ;;

 45720 +    *)

 45721 +      opt_duplicate_compiler_generated_deps=$opt_duplicate_deps

 45722 +      ;;

 45723 +  esac

 45724 +

 45725 +  # Having warned about all mis-specified options, bail out if

 45726 +  # anything was wrong.

 45727 +  $exit_cmd $EXIT_FAILURE

 45728 +}

 45729 +

 45730 +# func_check_version_match

 45731 +# Ensure that we are using m4 macros, and libtool script from the same

 45732 +# release of libtool.

 45733 +func_check_version_match ()

 45734 +{

 45735 +  if test "$package_revision" != "$macro_revision"; then

 45736 +    if test "$VERSION" != "$macro_version"; then

 45737 +      if test -z "$macro_version"; then

 45738 +        cat >&2 <<_LT_EOF

 45739 +$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the

 45740 +$progname: definition of this LT_INIT comes from an older release.

 45741 +$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION

 45742 +$progname: and run autoconf again.

 45743 +_LT_EOF

 45744 +      else

 45745 +        cat >&2 <<_LT_EOF

 45746 +$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the

 45747 +$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.

 45748 +$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION

 45749 +$progname: and run autoconf again.

 45750 +_LT_EOF

 45751 +      fi

 45752 +    else

 45753 +      cat >&2 <<_LT_EOF

 45754 +$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,

 45755 +$progname: but the definition of this LT_INIT comes from revision $macro_revision.

 45756 +$progname: You should recreate aclocal.m4 with macros from revision $package_revision

 45757 +$progname: of $PACKAGE $VERSION and run autoconf again.

 45758 +_LT_EOF

 45759 +    fi

 45760 +

 45761 +    exit $EXIT_MISMATCH

 45762 +  fi

 45763 +}

 45764 +

 45765 +

 45766 +## ----------- ##

 45767 +##    Main.    ##

 45768 +## ----------- ##

 45769 +

 45770 +{

 45771 +  # Sanity checks first:

 45772 +  func_check_version_match

 45773 +

 45774 +  if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then

 45775 +    func_fatal_configuration "not configured to build any kind of library"

 45776 +  fi

 45777 +

 45778 +  test -z "$mode" && func_fatal_error "error: you must specify a MODE."

 45779 +

 45780 +

 45781 +  # Darwin sucks

 45782 +  eval std_shrext=\"$shrext_cmds\"

 45783 +

 45784 +

 45785 +  # Only execute mode is allowed to have -dlopen flags.

 45786 +  if test -n "$execute_dlfiles" && test "$mode" != execute; then

 45787 +    func_error "unrecognized option \`-dlopen'"

 45788 +    $ECHO "$help" 1>&2

 45789 +    exit $EXIT_FAILURE

 45790 +  fi

 45791 +

 45792 +  # Change the help message to a mode-specific one.

 45793 +  generic_help="$help"

 45794 +  help="Try \`$progname --help --mode=$mode' for more information."

 45795 +}

 45796 +

 45797 +

 45798 +# func_lalib_p file

 45799 +# True iff FILE is a libtool `.la' library or `.lo' object file.

 45800 +# This function is only a basic sanity check; it will hardly flush out

 45801 +# determined imposters.

 45802 +func_lalib_p ()

 45803 +{

 45804 +    $SED -e 4q "$1" 2>/dev/null \

 45805 +      | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1

 45806 +}

 45807 +

 45808 +# func_lalib_unsafe_p file

 45809 +# True iff FILE is a libtool `.la' library or `.lo' object file.

 45810 +# This function implements the same check as func_lalib_p without

 45811 +# resorting to external programs.  To this end, it redirects stdin and

 45812 +# closes it afterwards, without saving the original file descriptor.

 45813 +# As a safety measure, use it only where a negative result would be

 45814 +# fatal anyway.  Works if `file' does not exist.

 45815 +func_lalib_unsafe_p ()

 45816 +{

 45817 +    lalib_p=no

 45818 +    if test -r "$1" && exec 5<&1 <"$1"; then

 45819 +	for lalib_p_l in 1 2 3 4

 45820 +	do

 45821 +	    read lalib_p_line

 45822 +	    case "$lalib_p_line" in

 45823 +		\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;

 45824 +	    esac

 45825 +	done

 45826 +	exec 1<&5 5<&-

 45827 +    fi

 45828 +    test "$lalib_p" = yes

 45829 +}

 45830 +

 45831 +# func_ltwrapper_p file

 45832 +# True iff FILE is a libtool wrapper script.

 45833 +# This function is only a basic sanity check; it will hardly flush out

 45834 +# determined imposters.

 45835 +func_ltwrapper_p ()

 45836 +{

 45837 +    func_lalib_p "$1"

 45838 +}

 45839 +

 45840 +

 45841 +# func_execute_cmds commands fail_cmd

 45842 +# Execute tilde-delimited COMMANDS.

 45843 +# If FAIL_CMD is given, eval that upon failure.

 45844 +# FAIL_CMD may read-access the current command in variable CMD!

 45845 +func_execute_cmds ()

 45846 +{

 45847 +    $opt_debug

 45848 +    save_ifs=$IFS; IFS='~'

 45849 +    for cmd in $1; do

 45850 +      IFS=$save_ifs

 45851 +      eval cmd=\"$cmd\"

 45852 +      func_show_eval "$cmd" "${2-:}"

 45853 +    done

 45854 +    IFS=$save_ifs

 45855 +}

 45856 +

 45857 +

 45858 +# func_source file

 45859 +# Source FILE, adding directory component if necessary.

 45860 +# Note that it is not necessary on cygwin/mingw to append a dot to

 45861 +# FILE even if both FILE and FILE.exe exist: automatic-append-.exe

 45862 +# behavior happens only for exec(3), not for open(2)!  Also, sourcing

 45863 +# `FILE.' does not work on cygwin managed mounts.

 45864 +func_source ()

 45865 +{

 45866 +    $opt_debug

 45867 +    case $1 in

 45868 +    */* | *\\*)	. "$1" ;;

 45869 +    *)		. "./$1" ;;

 45870 +    esac

 45871 +}

 45872 +

 45873 +

 45874 +# func_win32_libid arg

 45875 +# return the library type of file 'arg'

 45876 +#

 45877 +# Need a lot of goo to handle *both* DLLs and import libs

 45878 +# Has to be a shell function in order to 'eat' the argument

 45879 +# that is supplied when $file_magic_command is called.

 45880 +func_win32_libid ()

 45881 +{

 45882 +  $opt_debug

 45883 +  win32_libid_type="unknown"

 45884 +  win32_fileres=`file -L $1 2>/dev/null`

 45885 +  case $win32_fileres in

 45886 +  *ar\ archive\ import\ library*) # definitely import

 45887 +    win32_libid_type="x86 archive import"

 45888 +    ;;

 45889 +  *ar\ archive*) # could be an import, or static

 45890 +    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |

 45891 +       $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then

 45892 +      win32_nmres=`eval $NM -f posix -A $1 |

 45893 +	$SED -n -e '

 45894 +	    1,100{

 45895 +		/ I /{

 45896 +		    s,.*,import,

 45897 +		    p

 45898 +		    q

 45899 +		}

 45900 +	    }'`

 45901 +      case $win32_nmres in

 45902 +      import*)  win32_libid_type="x86 archive import";;

 45903 +      *)        win32_libid_type="x86 archive static";;

 45904 +      esac

 45905 +    fi

 45906 +    ;;

 45907 +  *DLL*)

 45908 +    win32_libid_type="x86 DLL"

 45909 +    ;;

 45910 +  *executable*) # but shell scripts are "executable" too...

 45911 +    case $win32_fileres in

 45912 +    *MS\ Windows\ PE\ Intel*)

 45913 +      win32_libid_type="x86 DLL"

 45914 +      ;;

 45915 +    esac

 45916 +    ;;

 45917 +  esac

 45918 +  $ECHO "$win32_libid_type"

 45919 +}

 45920 +

 45921 +

 45922 +

 45923 +# func_infer_tag arg

 45924 +# Infer tagged configuration to use if any are available and

 45925 +# if one wasn't chosen via the "--tag" command line option.

 45926 +# Only attempt this if the compiler in the base compile

 45927 +# command doesn't match the default compiler.

 45928 +# arg is usually of the form 'gcc ...'

 45929 +func_infer_tag ()

 45930 +{

 45931 +    $opt_debug

 45932 +    if test -n "$available_tags" && test -z "$tagname"; then

 45933 +      CC_quoted=

 45934 +      for arg in $CC; do

 45935 +        func_quote_for_eval "$arg"

 45936 +	CC_quoted="$CC_quoted $func_quote_for_eval_result"

 45937 +      done

 45938 +      case $@ in

 45939 +      # Blanks in the command may have been stripped by the calling shell,

 45940 +      # but not from the CC environment variable when configure was run.

 45941 +      " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;

 45942 +      # Blanks at the start of $base_compile will cause this to fail

 45943 +      # if we don't check for them as well.

 45944 +      *)

 45945 +	for z in $available_tags; do

 45946 +	  if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then

 45947 +	    # Evaluate the configuration.

 45948 +	    eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"

 45949 +	    CC_quoted=

 45950 +	    for arg in $CC; do

 45951 +	      # Double-quote args containing other shell metacharacters.

 45952 +	      func_quote_for_eval "$arg"

 45953 +	      CC_quoted="$CC_quoted $func_quote_for_eval_result"

 45954 +	    done

 45955 +	    case "$@ " in

 45956 +	      " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)

 45957 +	      # The compiler in the base compile command matches

 45958 +	      # the one in the tagged configuration.

 45959 +	      # Assume this is the tagged configuration we want.

 45960 +	      tagname=$z

 45961 +	      break

 45962 +	      ;;

 45963 +	    esac

 45964 +	  fi

 45965 +	done

 45966 +	# If $tagname still isn't set, then no tagged configuration

 45967 +	# was found and let the user know that the "--tag" command

 45968 +	# line option must be used.

 45969 +	if test -z "$tagname"; then

 45970 +	  func_echo "unable to infer tagged configuration"

 45971 +	  func_fatal_error "specify a tag with \`--tag'"

 45972 +#	else

 45973 +#	  func_verbose "using $tagname tagged configuration"

 45974 +	fi

 45975 +	;;

 45976 +      esac

 45977 +    fi

 45978 +}

 45979 +

 45980 +

 45981 +

 45982 +# func_generate_dlsyms outputname originator pic_p

 45983 +# Extract symbols from dlprefiles and create ${outputname}S.o with

 45984 +# a dlpreopen symbol table.

 45985 +func_generate_dlsyms ()

 45986 +{

 45987 +    $opt_debug

 45988 +    my_outputname="$1"

 45989 +    my_originator="$2"

 45990 +    my_pic_p="${3-no}"

 45991 +    my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`

 45992 +    my_dlsyms=

 45993 +

 45994 +    if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

 45995 +      if test -n "$NM" && test -n "$global_symbol_pipe"; then

 45996 +	my_dlsyms="${my_outputname}S.c"

 45997 +      else

 45998 +	func_error "not configured to extract global symbols from dlpreopened files"

 45999 +      fi

 46000 +    fi

 46001 +

 46002 +    if test -n "$my_dlsyms"; then

 46003 +      case $my_dlsyms in

 46004 +      "") ;;

 46005 +      *.c)

 46006 +	# Discover the nlist of each of the dlfiles.

 46007 +	nlist="$output_objdir/${my_outputname}.nm"

 46008 +

 46009 +	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"

 46010 +

 46011 +	# Parse the name list into a source file.

 46012 +	func_echo "creating $output_objdir/$my_dlsyms"

 46013 +

 46014 +	$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\

 46015 +/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */

 46016 +/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */

 46017 +

 46018 +#ifdef __cplusplus

 46019 +extern \"C\" {

 46020 +#endif

 46021 +

 46022 +/* External symbol declarations for the compiler. */\

 46023 +"

 46024 +

 46025 +	if test "$dlself" = yes; then

 46026 +	  func_echo "generating symbol list for \`$output'"

 46027 +

 46028 +	  $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"

 46029 +

 46030 +	  # Add our own program objects to the symbol list.

 46031 +	  progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

 46032 +	  for progfile in $progfiles; do

 46033 +	    func_echo "extracting global C symbols from \`$progfile'"

 46034 +	    $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"

 46035 +	  done

 46036 +

 46037 +	  if test -n "$exclude_expsyms"; then

 46038 +	    $opt_dry_run || {

 46039 +	      eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'

 46040 +	      eval '$MV "$nlist"T "$nlist"'

 46041 +	    }

 46042 +	  fi

 46043 +

 46044 +	  if test -n "$export_symbols_regex"; then

 46045 +	    $opt_dry_run || {

 46046 +	      eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'

 46047 +	      eval '$MV "$nlist"T "$nlist"'

 46048 +	    }

 46049 +	  fi

 46050 +

 46051 +	  # Prepare the list of exported symbols

 46052 +	  if test -z "$export_symbols"; then

 46053 +	    export_symbols="$output_objdir/$outputname.exp"

 46054 +	    $opt_dry_run || {

 46055 +	      $RM $export_symbols

 46056 +	      eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'

 46057 +	      case $host in

 46058 +	      *cygwin* | *mingw* )

 46059 +                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'

 46060 +                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'

 46061 +	        ;;

 46062 +	      esac

 46063 +	    }

 46064 +	  else

 46065 +	    $opt_dry_run || {

 46066 +	      eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'

 46067 +	      eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'

 46068 +	      eval '$MV "$nlist"T "$nlist"'

 46069 +	      case $host in

 46070 +	        *cygwin | *mingw* )

 46071 +	          eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'

 46072 +	          eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'

 46073 +	          ;;

 46074 +	      esac

 46075 +	    }

 46076 +	  fi

 46077 +	fi

 46078 +

 46079 +	for dlprefile in $dlprefiles; do

 46080 +	  func_echo "extracting global C symbols from \`$dlprefile'"

 46081 +	  func_basename "$dlprefile"

 46082 +	  name="$func_basename_result"

 46083 +	  $opt_dry_run || {

 46084 +	    eval '$ECHO ": $name " >> "$nlist"'

 46085 +	    eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"

 46086 +	  }

 46087 +	done

 46088 +

 46089 +	$opt_dry_run || {

 46090 +	  # Make sure we have at least an empty file.

 46091 +	  test -f "$nlist" || : > "$nlist"

 46092 +

 46093 +	  if test -n "$exclude_expsyms"; then

 46094 +	    $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T

 46095 +	    $MV "$nlist"T "$nlist"

 46096 +	  fi

 46097 +

 46098 +	  # Try sorting and uniquifying the output.

 46099 +	  if $GREP -v "^: " < "$nlist" |

 46100 +	      if sort -k 3 </dev/null >/dev/null 2>&1; then

 46101 +		sort -k 3

 46102 +	      else

 46103 +		sort +2

 46104 +	      fi |

 46105 +	      uniq > "$nlist"S; then

 46106 +	    :

 46107 +	  else

 46108 +	    $GREP -v "^: " < "$nlist" > "$nlist"S

 46109 +	  fi

 46110 +

 46111 +	  if test -f "$nlist"S; then

 46112 +	    eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'

 46113 +	  else

 46114 +	    $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"

 46115 +	  fi

 46116 +

 46117 +	  $ECHO >> "$output_objdir/$my_dlsyms" "\

 46118 +

 46119 +/* The mapping between symbol names and symbols.  */

 46120 +typedef struct {

 46121 +  const char *name;

 46122 +  void *address;

 46123 +} lt_dlsymlist;

 46124 +"

 46125 +	  case $host in

 46126 +	  *cygwin* | *mingw* )

 46127 +	    $ECHO >> "$output_objdir/$my_dlsyms" "\

 46128 +/* DATA imports from DLLs on WIN32 con't be const, because

 46129 +   runtime relocations are performed -- see ld's documentation

 46130 +   on pseudo-relocs.  */"

 46131 +	    lt_dlsym_const= ;;

 46132 +	  *osf5*)

 46133 +	    echo >> "$output_objdir/$my_dlsyms" "\

 46134 +/* This system does not cope well with relocations in const data */"

 46135 +	    lt_dlsym_const= ;;

 46136 +	  *)

 46137 +	    lt_dlsym_const=const ;;

 46138 +	  esac

 46139 +

 46140 +	  $ECHO >> "$output_objdir/$my_dlsyms" "\

 46141 +extern $lt_dlsym_const lt_dlsymlist

 46142 +lt_${my_prefix}_LTX_preloaded_symbols[];

 46143 +$lt_dlsym_const lt_dlsymlist

 46144 +lt_${my_prefix}_LTX_preloaded_symbols[] =

 46145 +{\

 46146 +  { \"$my_originator\", (void *) 0 },"

 46147 +

 46148 +	  eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"

 46149 +

 46150 +	  $ECHO >> "$output_objdir/$my_dlsyms" "\

 46151 +  {0, (void *) 0}

 46152 +};

 46153 +

 46154 +/* This works around a problem in FreeBSD linker */

 46155 +#ifdef FREEBSD_WORKAROUND

 46156 +static const void *lt_preloaded_setup() {

 46157 +  return lt_${my_prefix}_LTX_preloaded_symbols;

 46158 +}

 46159 +#endif

 46160 +

 46161 +#ifdef __cplusplus

 46162 +}

 46163 +#endif\

 46164 +"

 46165 +	} # !$opt_dry_run

 46166 +

 46167 +  	pic_flag_for_symtable=

 46168 +	case "$compile_command " in

 46169 +	*" -static "*) ;;

 46170 +	*)

 46171 +	  case $host in

 46172 +	  # compiling the symbol table file with pic_flag works around

 46173 +	  # a FreeBSD bug that causes programs to crash when -lm is

 46174 +	  # linked before any other PIC object.  But we must not use

 46175 +	  # pic_flag when linking with -static.  The problem exists in

 46176 +	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.

 46177 +	  *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)

 46178 +	    pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;

 46179 +	  *-*-hpux*)

 46180 +	    pic_flag_for_symtable=" $pic_flag"  ;;

 46181 +	  *)

 46182 +	    if test "X$my_pic_p" != Xno; then

 46183 +	      pic_flag_for_symtable=" $pic_flag"

 46184 +	    fi

 46185 +	    ;;

 46186 +	  esac

 46187 +	  ;;

 46188 +	esac

 46189 +	symtab_cflags=

 46190 +	for arg in $LTCFLAGS; do

 46191 +	  case $arg in

 46192 +	  -pie | -fpie | -fPIE) ;;

 46193 +	  *) symtab_cflags="$symtab_cflags $arg" ;;

 46194 +	  esac

 46195 +	done

 46196 +

 46197 +	# Now compile the dynamic symbol file.

 46198 +	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'

 46199 +

 46200 +	# Clean up the generated files.

 46201 +	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'

 46202 +

 46203 +	# Transform the symbol file into the correct name.

 46204 +	symfileobj="$output_objdir/${my_outputname}S.$objext"

 46205 +	case $host in

 46206 +	*cygwin* | *mingw* )

 46207 +	  if test -f "$output_objdir/$my_outputname.def"; then

 46208 +	    compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`

 46209 +	    finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`

 46210 +	  else

 46211 +	    compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`

 46212 +	    finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`

 46213 +	  fi

 46214 +	  ;;

 46215 +	*)

 46216 +	  compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`

 46217 +	  finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`

 46218 +	  ;;

 46219 +	esac

 46220 +	;;

 46221 +      *)

 46222 +	func_fatal_error "unknown suffix for \`$my_dlsyms'"

 46223 +	;;

 46224 +      esac

 46225 +    else

 46226 +      # We keep going just in case the user didn't refer to

 46227 +      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe

 46228 +      # really was required.

 46229 +

 46230 +      # Nullify the symbol file.

 46231 +      compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`

 46232 +      finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`

 46233 +    fi

 46234 +}

 46235 +

 46236 +# func_extract_an_archive dir oldlib

 46237 +func_extract_an_archive ()

 46238 +{

 46239 +    $opt_debug

 46240 +    f_ex_an_ar_dir="$1"; shift

 46241 +    f_ex_an_ar_oldlib="$1"

 46242 +    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" 'exit $?'

 46243 +    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then

 46244 +     :

 46245 +    else

 46246 +      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"

 46247 +    fi

 46248 +}

 46249 +

 46250 +

 46251 +# func_extract_archives gentop oldlib ...

 46252 +func_extract_archives ()

 46253 +{

 46254 +    $opt_debug

 46255 +    my_gentop="$1"; shift

 46256 +    my_oldlibs=${1+"$@"}

 46257 +    my_oldobjs=""

 46258 +    my_xlib=""

 46259 +    my_xabs=""

 46260 +    my_xdir=""

 46261 +

 46262 +    for my_xlib in $my_oldlibs; do

 46263 +      # Extract the objects.

 46264 +      case $my_xlib in

 46265 +	[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;

 46266 +	*) my_xabs=`pwd`"/$my_xlib" ;;

 46267 +      esac

 46268 +      func_basename "$my_xlib"

 46269 +      my_xlib="$func_basename_result"

 46270 +      my_xlib_u=$my_xlib

 46271 +      while :; do

 46272 +        case " $extracted_archives " in

 46273 +	*" $my_xlib_u "*)

 46274 +	  extracted_serial=`expr $extracted_serial + 1`

 46275 +	  my_xlib_u=lt$extracted_serial-$my_xlib ;;

 46276 +	*) break ;;

 46277 +	esac

 46278 +      done

 46279 +      extracted_archives="$extracted_archives $my_xlib_u"

 46280 +      my_xdir="$my_gentop/$my_xlib_u"

 46281 +

 46282 +      func_mkdir_p "$my_xdir"

 46283 +

 46284 +      case $host in

 46285 +      *-darwin*)

 46286 +	func_echo "Extracting $my_xabs"

 46287 +	# Do not bother doing anything if just a dry run

 46288 +	$opt_dry_run || {

 46289 +	  darwin_orig_dir=`pwd`

 46290 +	  cd $my_xdir || exit $?

 46291 +	  darwin_archive=$my_xabs

 46292 +	  darwin_curdir=`pwd`

 46293 +	  darwin_base_archive=`basename $darwin_archive`

 46294 +	  darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`

 46295 +	  if test -n "$darwin_arches"; then

 46296 +	    darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`

 46297 +	    darwin_arch=

 46298 +	    func_echo "$darwin_base_archive has multiple architectures $darwin_arches"

 46299 +	    for darwin_arch in  $darwin_arches ; do

 46300 +	      func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"

 46301 +	      lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"

 46302 +	      cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"

 46303 +	      func_extract_an_archive "`pwd`" "${darwin_base_archive}"

 46304 +	      cd "$darwin_curdir"

 46305 +	      $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"

 46306 +	    done # $darwin_arches

 46307 +            ## Okay now we've a bunch of thin objects, gotta fatten them up :)

 46308 +	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`

 46309 +	    darwin_file=

 46310 +	    darwin_files=

 46311 +	    for darwin_file in $darwin_filelist; do

 46312 +	      darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`

 46313 +	      lipo -create -output "$darwin_file" $darwin_files

 46314 +	    done # $darwin_filelist

 46315 +	    $RM -rf unfat-$$

 46316 +	    cd "$darwin_orig_dir"

 46317 +	  else

 46318 +	    cd $darwin_orig_dir

 46319 +	    func_extract_an_archive "$my_xdir" "$my_xabs"

 46320 +	  fi # $darwin_arches

 46321 +	} # !$opt_dry_run

 46322 +	;;

 46323 +      *)

 46324 +        func_extract_an_archive "$my_xdir" "$my_xabs"

 46325 +	;;

 46326 +      esac

 46327 +      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`

 46328 +    done

 46329 +

 46330 +    func_extract_archives_result="$my_oldobjs"

 46331 +}

 46332 +

 46333 +

 46334 +

 46335 +# func_write_libtool_object output_name pic_name nonpic_name

 46336 +# Create a libtool object file (analogous to a ".la" file),

 46337 +# but don't create it if we're doing a dry run.

 46338 +func_write_libtool_object ()

 46339 +{

 46340 +    write_libobj=${1}

 46341 +    if test "$build_libtool_libs" = yes; then

 46342 +      write_lobj=\'${2}\'

 46343 +    else

 46344 +      write_lobj=none

 46345 +    fi

 46346 +

 46347 +    if test "$build_old_libs" = yes; then

 46348 +      write_oldobj=\'${3}\'

 46349 +    else

 46350 +      write_oldobj=none

 46351 +    fi

 46352 +

 46353 +    $opt_dry_run || {

 46354 +      cat >${write_libobj}T <<EOF

 46355 +# $write_libobj - a libtool object file

 46356 +# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

 46357 +#

 46358 +# Please DO NOT delete this file!

 46359 +# It is necessary for linking the library.

 46360 +

 46361 +# Name of the PIC object.

 46362 +pic_object=$write_lobj

 46363 +

 46364 +# Name of the non-PIC object

 46365 +non_pic_object=$write_oldobj

 46366 +

 46367 +EOF

 46368 +      mv -f "${write_libobj}T" "${write_libobj}"

 46369 +    }

 46370 +}

 46371 +

 46372 +# func_mode_compile arg...

 46373 +func_mode_compile ()

 46374 +{

 46375 +    $opt_debug

 46376 +    # Get the compilation command and the source file.

 46377 +    base_compile=

 46378 +    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"

 46379 +    suppress_opt=yes

 46380 +    suppress_output=

 46381 +    arg_mode=normal

 46382 +    libobj=

 46383 +    later=

 46384 +    pie_flag=

 46385 +

 46386 +    for arg

 46387 +    do

 46388 +      case $arg_mode in

 46389 +      arg  )

 46390 +	# do not "continue".  Instead, add this to base_compile

 46391 +	lastarg="$arg"

 46392 +	arg_mode=normal

 46393 +	;;

 46394 +

 46395 +      target )

 46396 +	libobj="$arg"

 46397 +	arg_mode=normal

 46398 +	continue

 46399 +	;;

 46400 +

 46401 +      normal )

 46402 +	# Accept any command-line options.

 46403 +	case $arg in

 46404 +	-o)

 46405 +	  test -n "$libobj" && \

 46406 +	    func_fatal_error "you cannot specify \`-o' more than once"

 46407 +	  arg_mode=target

 46408 +	  continue

 46409 +	  ;;

 46410 +

 46411 +	-pie | -fpie | -fPIE)

 46412 +          pie_flag="$pie_flag $arg"

 46413 +	  continue

 46414 +	  ;;

 46415 +

 46416 +	-shared | -static | -prefer-pic | -prefer-non-pic)

 46417 +	  later="$later $arg"

 46418 +	  continue

 46419 +	  ;;

 46420 +

 46421 +	-no-suppress)

 46422 +	  suppress_opt=no

 46423 +	  continue

 46424 +	  ;;

 46425 +

 46426 +	-Xcompiler)

 46427 +	  arg_mode=arg  #  the next one goes into the "base_compile" arg list

 46428 +	  continue      #  The current "srcfile" will either be retained or

 46429 +	  ;;            #  replaced later.  I would guess that would be a bug.

 46430 +

 46431 +	-Wc,*)

 46432 +	  func_stripname '-Wc,' '' "$arg"

 46433 +	  args=$func_stripname_result

 46434 +	  lastarg=

 46435 +	  save_ifs="$IFS"; IFS=','

 46436 +	  for arg in $args; do

 46437 +	    IFS="$save_ifs"

 46438 +	    func_quote_for_eval "$arg"

 46439 +	    lastarg="$lastarg $func_quote_for_eval_result"

 46440 +	  done

 46441 +	  IFS="$save_ifs"

 46442 +	  func_stripname ' ' '' "$lastarg"

 46443 +	  lastarg=$func_stripname_result

 46444 +

 46445 +	  # Add the arguments to base_compile.

 46446 +	  base_compile="$base_compile $lastarg"

 46447 +	  continue

 46448 +	  ;;

 46449 +

 46450 +	*)

 46451 +	  # Accept the current argument as the source file.

 46452 +	  # The previous "srcfile" becomes the current argument.

 46453 +	  #

 46454 +	  lastarg="$srcfile"

 46455 +	  srcfile="$arg"

 46456 +	  ;;

 46457 +	esac  #  case $arg

 46458 +	;;

 46459 +      esac    #  case $arg_mode

 46460 +

 46461 +      # Aesthetically quote the previous argument.

 46462 +      func_quote_for_eval "$lastarg"

 46463 +      base_compile="$base_compile $func_quote_for_eval_result"

 46464 +    done # for arg

 46465 +

 46466 +    case $arg_mode in

 46467 +    arg)

 46468 +      func_fatal_error "you must specify an argument for -Xcompile"

 46469 +      ;;

 46470 +    target)

 46471 +      func_fatal_error "you must specify a target with \`-o'"

 46472 +      ;;

 46473 +    *)

 46474 +      # Get the name of the library object.

 46475 +      test -z "$libobj" && {

 46476 +	func_basename "$srcfile"

 46477 +	libobj="$func_basename_result"

 46478 +      }

 46479 +      ;;

 46480 +    esac

 46481 +

 46482 +    # Recognize several different file suffixes.

 46483 +    # If the user specifies -o file.o, it is replaced with file.lo

 46484 +    xform='[cCFSifmso]'

 46485 +    case $libobj in

 46486 +    *.ada) xform=ada ;;

 46487 +    *.adb) xform=adb ;;

 46488 +    *.ads) xform=ads ;;

 46489 +    *.asm) xform=asm ;;

 46490 +    *.c++) xform=c++ ;;

 46491 +    *.cc) xform=cc ;;

 46492 +    *.ii) xform=ii ;;

 46493 +    *.class) xform=class ;;

 46494 +    *.cpp) xform=cpp ;;

 46495 +    *.cxx) xform=cxx ;;

 46496 +    *.[fF][09]?) xform='[fF][09].' ;;

 46497 +    *.for) xform=for ;;

 46498 +    *.java) xform=java ;;

 46499 +    *.obj) xform=obj ;;

 46500 +    esac

 46501 +

 46502 +    libobj=`$ECHO "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`

 46503 +

 46504 +    case $libobj in

 46505 +    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;

 46506 +    *)

 46507 +      func_fatal_error "cannot determine name of library object from \`$libobj'"

 46508 +      ;;

 46509 +    esac

 46510 +

 46511 +    func_infer_tag $base_compile

 46512 +

 46513 +    for arg in $later; do

 46514 +      case $arg in

 46515 +      -shared)

 46516 +	test "$build_libtool_libs" != yes && \

 46517 +	  func_fatal_configuration "can not build a shared library"

 46518 +	build_old_libs=no

 46519 +	continue

 46520 +	;;

 46521 +

 46522 +      -static)

 46523 +	build_libtool_libs=no

 46524 +	build_old_libs=yes

 46525 +	continue

 46526 +	;;

 46527 +

 46528 +      -prefer-pic)

 46529 +	pic_mode=yes

 46530 +	continue

 46531 +	;;

 46532 +

 46533 +      -prefer-non-pic)

 46534 +	pic_mode=no

 46535 +	continue

 46536 +	;;

 46537 +      esac

 46538 +    done

 46539 +

 46540 +    func_quote_for_eval "$libobj"

 46541 +    test "X$libobj" != "X$func_quote_for_eval_result" \

 46542 +      && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' 	&()|`$[]' \

 46543 +      && func_warning "libobj name \`$libobj' may not contain shell special characters."

 46544 +    func_basename "$obj"

 46545 +    objname="$func_basename_result"

 46546 +    func_dirname "$obj" "/" ""

 46547 +    xdir="$func_dirname_result"

 46548 +    lobj=${xdir}$objdir/$objname

 46549 +

 46550 +    test -z "$base_compile" && \

 46551 +      func_fatal_help "you must specify a compilation command"

 46552 +

 46553 +    # Delete any leftover library objects.

 46554 +    if test "$build_old_libs" = yes; then

 46555 +      removelist="$obj $lobj $libobj ${libobj}T"

 46556 +    else

 46557 +      removelist="$lobj $libobj ${libobj}T"

 46558 +    fi

 46559 +

 46560 +    $opt_dry_run || $RM $removelist

 46561 +    trap "$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE" 1 2 15

 46562 +

 46563 +    # On Cygwin there's no "real" PIC flag so we must build both object types

 46564 +    case $host_os in

 46565 +    cygwin* | mingw* | pw32* | os2*)

 46566 +      pic_mode=default

 46567 +      ;;

 46568 +    esac

 46569 +    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then

 46570 +      # non-PIC code in shared libraries is not supported

 46571 +      pic_mode=default

 46572 +    fi

 46573 +

 46574 +    # Calculate the filename of the output object if compiler does

 46575 +    # not support -o with -c

 46576 +    if test "$compiler_c_o" = no; then

 46577 +      output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}

 46578 +      lockfile="$output_obj.lock"

 46579 +      removelist="$removelist $output_obj $lockfile"

 46580 +      trap "$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE" 1 2 15

 46581 +    else

 46582 +      output_obj=

 46583 +      need_locks=no

 46584 +      lockfile=

 46585 +    fi

 46586 +

 46587 +    # Lock this critical section if it is needed

 46588 +    # We use this script file to make the link, it avoids creating a new file

 46589 +    if test "$need_locks" = yes; then

 46590 +      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do

 46591 +	func_echo "Waiting for $lockfile to be removed"

 46592 +	sleep 2

 46593 +      done

 46594 +    elif test "$need_locks" = warn; then

 46595 +      if test -f "$lockfile"; then

 46596 +	$ECHO "\

 46597 +*** ERROR, $lockfile exists and contains:

 46598 +`cat $lockfile 2>/dev/null`

 46599 +

 46600 +This indicates that another process is trying to use the same

 46601 +temporary object file, and libtool could not work around it because

 46602 +your compiler does not support \`-c' and \`-o' together.  If you

 46603 +repeat this compilation, it may succeed, by chance, but you had better

 46604 +avoid parallel builds (make -j) in this platform, or get a better

 46605 +compiler."

 46606 +

 46607 +	$opt_dry_run || $RM $removelist

 46608 +	exit $EXIT_FAILURE

 46609 +      fi

 46610 +      $ECHO "$srcfile" > "$lockfile"

 46611 +    fi

 46612 +

 46613 +    if test -n "$fix_srcfile_path"; then

 46614 +      eval srcfile=\"$fix_srcfile_path\"

 46615 +    fi

 46616 +    func_quote_for_eval "$srcfile"

 46617 +    qsrcfile=$func_quote_for_eval_result

 46618 +

 46619 +    $opt_dry_run || $RM "$libobj" "${libobj}T"

 46620 +

 46621 +    # Only build a PIC object if we are building libtool libraries.

 46622 +    if test "$build_libtool_libs" = yes; then

 46623 +      # Without this assignment, base_compile gets emptied.

 46624 +      fbsd_hideous_sh_bug=$base_compile

 46625 +

 46626 +      if test "$pic_mode" != no; then

 46627 +	command="$base_compile $qsrcfile $pic_flag"

 46628 +      else

 46629 +	# Don't build PIC code

 46630 +	command="$base_compile $qsrcfile"

 46631 +      fi

 46632 +

 46633 +      func_mkdir_p "$xdir$objdir"

 46634 +

 46635 +      if test -z "$output_obj"; then

 46636 +	# Place PIC objects in $objdir

 46637 +	command="$command -o $lobj"

 46638 +      fi

 46639 +

 46640 +      $opt_dry_run || $RM "$lobj" "$output_obj"

 46641 +

 46642 +      func_show_eval "$command"	\

 46643 +          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'

 46644 +

 46645 +      if test "$need_locks" = warn &&

 46646 +	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then

 46647 +	$ECHO "\

 46648 +*** ERROR, $lockfile contains:

 46649 +`cat $lockfile 2>/dev/null`

 46650 +

 46651 +but it should contain:

 46652 +$srcfile

 46653 +

 46654 +This indicates that another process is trying to use the same

 46655 +temporary object file, and libtool could not work around it because

 46656 +your compiler does not support \`-c' and \`-o' together.  If you

 46657 +repeat this compilation, it may succeed, by chance, but you had better

 46658 +avoid parallel builds (make -j) in this platform, or get a better

 46659 +compiler."

 46660 +

 46661 +	$opt_dry_run || $RM $removelist

 46662 +	exit $EXIT_FAILURE

 46663 +      fi

 46664 +

 46665 +      # Just move the object if needed, then go on to compile the next one

 46666 +      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then

 46667 +	func_show_eval '$MV "$output_obj" "$lobj"' \

 46668 +	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'

 46669 +      fi

 46670 +

 46671 +      # Allow error messages only from the first compilation.

 46672 +      if test "$suppress_opt" = yes; then

 46673 +	suppress_output=' >/dev/null 2>&1'

 46674 +      fi

 46675 +    fi

 46676 +

 46677 +    # Only build a position-dependent object if we build old libraries.

 46678 +    if test "$build_old_libs" = yes; then

 46679 +      if test "$pic_mode" != yes; then

 46680 +	# Don't build PIC code

 46681 +	command="$base_compile $qsrcfile$pie_flag"

 46682 +      else

 46683 +	command="$base_compile $qsrcfile $pic_flag"

 46684 +      fi

 46685 +      if test "$compiler_c_o" = yes; then

 46686 +	command="$command -o $obj"

 46687 +      fi

 46688 +

 46689 +      # Suppress compiler output if we already did a PIC compilation.

 46690 +      command="$command$suppress_output"

 46691 +      $opt_dry_run || $RM "$obj" "$output_obj"

 46692 +      func_show_eval "$command" \

 46693 +        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'

 46694 +

 46695 +      if test "$need_locks" = warn &&

 46696 +	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then

 46697 +	$ECHO "\

 46698 +*** ERROR, $lockfile contains:

 46699 +`cat $lockfile 2>/dev/null`

 46700 +

 46701 +but it should contain:

 46702 +$srcfile

 46703 +

 46704 +This indicates that another process is trying to use the same

 46705 +temporary object file, and libtool could not work around it because

 46706 +your compiler does not support \`-c' and \`-o' together.  If you

 46707 +repeat this compilation, it may succeed, by chance, but you had better

 46708 +avoid parallel builds (make -j) in this platform, or get a better

 46709 +compiler."

 46710 +

 46711 +	$opt_dry_run || $RM $removelist

 46712 +	exit $EXIT_FAILURE

 46713 +      fi

 46714 +

 46715 +      # Just move the object if needed

 46716 +      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then

 46717 +	func_show_eval '$MV "$output_obj" "$obj"' \

 46718 +	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'

 46719 +      fi

 46720 +    fi

 46721 +

 46722 +    $opt_dry_run || {

 46723 +      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"

 46724 +

 46725 +      # Unlock the critical section if it was locked

 46726 +      if test "$need_locks" != no; then

 46727 +        $RM "$lockfile"

 46728 +      fi

 46729 +    }

 46730 +

 46731 +    exit $EXIT_SUCCESS

 46732 +}

 46733 +

 46734 +test "$mode" = compile && func_mode_compile ${1+"$@"}

 46735 +

 46736 +

 46737 +# func_mode_execute arg...

 46738 +func_mode_execute ()

 46739 +{

 46740 +    $opt_debug

 46741 +    # The first argument is the command name.

 46742 +    cmd="$nonopt"

 46743 +    test -z "$cmd" && \

 46744 +      func_fatal_help "you must specify a COMMAND"

 46745 +

 46746 +    # Handle -dlopen flags immediately.

 46747 +    for file in $execute_dlfiles; do

 46748 +      test -f "$file" \

 46749 +	|| func_fatal_help "\`$file' is not a file"

 46750 +

 46751 +      dir=

 46752 +      case $file in

 46753 +      *.la)

 46754 +	# Check to see that this really is a libtool archive.

 46755 +	func_lalib_unsafe_p "$file" \

 46756 +	  || func_fatal_help "\`$lib' is not a valid libtool archive"

 46757 +

 46758 +	# Read the libtool library.

 46759 +	dlname=

 46760 +	library_names=

 46761 +	func_source "$file"

 46762 +

 46763 +	# Skip this library if it cannot be dlopened.

 46764 +	if test -z "$dlname"; then

 46765 +	  # Warn if it was a shared library.

 46766 +	  test -n "$library_names" && \

 46767 +	    func_warning "\`$file' was not linked with \`-export-dynamic'"

 46768 +	  continue

 46769 +	fi

 46770 +

 46771 +	func_dirname "$file" "" "."

 46772 +	dir="$func_dirname_result"

 46773 +

 46774 +	if test -f "$dir/$objdir/$dlname"; then

 46775 +	  dir="$dir/$objdir"

 46776 +	else

 46777 +	  if test ! -f "$dir/$dlname"; then

 46778 +	    func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"

 46779 +	  fi

 46780 +	fi

 46781 +	;;

 46782 +

 46783 +      *.lo)

 46784 +	# Just add the directory containing the .lo file.

 46785 +	func_dirname "$file" "" "."

 46786 +	dir="$func_dirname_result"

 46787 +	;;

 46788 +

 46789 +      *)

 46790 +	func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"

 46791 +	continue

 46792 +	;;

 46793 +      esac

 46794 +

 46795 +      # Get the absolute pathname.

 46796 +      absdir=`cd "$dir" && pwd`

 46797 +      test -n "$absdir" && dir="$absdir"

 46798 +

 46799 +      # Now add the directory to shlibpath_var.

 46800 +      if eval "test -z \"\$$shlibpath_var\""; then

 46801 +	eval "$shlibpath_var=\"\$dir\""

 46802 +      else

 46803 +	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""

 46804 +      fi

 46805 +    done

 46806 +

 46807 +    # This variable tells wrapper scripts just to set shlibpath_var

 46808 +    # rather than running their programs.

 46809 +    libtool_execute_magic="$magic"

 46810 +

 46811 +    # Check if any of the arguments is a wrapper script.

 46812 +    args=

 46813 +    for file

 46814 +    do

 46815 +      case $file in

 46816 +      -*) ;;

 46817 +      *)

 46818 +	# Do a test to see if this is really a libtool program.

 46819 +	if func_ltwrapper_p "$file"; then

 46820 +	  func_source "$file"

 46821 +

 46822 +	  # Transform arg to wrapped name.

 46823 +	  file="$progdir/$program"

 46824 +	fi

 46825 +	;;

 46826 +      esac

 46827 +      # Quote arguments (to preserve shell metacharacters).

 46828 +      func_quote_for_eval "$file"

 46829 +      args="$args $func_quote_for_eval_result"

 46830 +    done

 46831 +

 46832 +    if test "X$opt_dry_run" = Xfalse; then

 46833 +      if test -n "$shlibpath_var"; then

 46834 +	# Export the shlibpath_var.

 46835 +	eval "export $shlibpath_var"

 46836 +      fi

 46837 +

 46838 +      # Restore saved environment variables

 46839 +      for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

 46840 +      do

 46841 +	eval "if test \"\${save_$lt_var+set}\" = set; then

 46842 +                $lt_var=\$save_$lt_var; export $lt_var

 46843 +	      else

 46844 +		$lt_unset $lt_var

 46845 +	      fi"

 46846 +      done

 46847 +

 46848 +      # Now prepare to actually exec the command.

 46849 +      exec_cmd="\$cmd$args"

 46850 +    else

 46851 +      # Display what would be done.

 46852 +      if test -n "$shlibpath_var"; then

 46853 +	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""

 46854 +	$ECHO "export $shlibpath_var"

 46855 +      fi

 46856 +      $ECHO "$cmd$args"

 46857 +      exit $EXIT_SUCCESS

 46858 +    fi

 46859 +}

 46860 +

 46861 +test "$mode" = execute && func_mode_execute ${1+"$@"}

 46862 +

 46863 +

 46864 +# func_mode_finish arg...

 46865 +func_mode_finish ()

 46866 +{

 46867 +    $opt_debug

 46868 +    libdirs="$nonopt"

 46869 +    admincmds=

 46870 +

 46871 +    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then

 46872 +      for dir

 46873 +      do

 46874 +	libdirs="$libdirs $dir"

 46875 +      done

 46876 +

 46877 +      for libdir in $libdirs; do

 46878 +	if test -n "$finish_cmds"; then

 46879 +	  # Do each command in the finish commands.

 46880 +	  func_execute_cmds "$finish_cmds" 'admincmds="$admincmds

 46881 +'"$cmd"'"'

 46882 +	fi

 46883 +	if test -n "$finish_eval"; then

 46884 +	  # Do the single finish_eval.

 46885 +	  eval cmds=\"$finish_eval\"

 46886 +	  $opt_dry_run || eval "$cmds" || admincmds="$admincmds

 46887 +       $cmds"

 46888 +	fi

 46889 +      done

 46890 +    fi

 46891 +

 46892 +    # Exit here if they wanted silent mode.

 46893 +    $opt_silent && exit $EXIT_SUCCESS

 46894 +

 46895 +    $ECHO "X----------------------------------------------------------------------" | $Xsed

 46896 +    $ECHO "Libraries have been installed in:"

 46897 +    for libdir in $libdirs; do

 46898 +      $ECHO "   $libdir"

 46899 +    done

 46900 +    $ECHO

 46901 +    $ECHO "If you ever happen to want to link against installed libraries"

 46902 +    $ECHO "in a given directory, LIBDIR, you must either use libtool, and"

 46903 +    $ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"

 46904 +    $ECHO "flag during linking and do at least one of the following:"

 46905 +    if test -n "$shlibpath_var"; then

 46906 +      $ECHO "   - add LIBDIR to the \`$shlibpath_var' environment variable"

 46907 +      $ECHO "     during execution"

 46908 +    fi

 46909 +    if test -n "$runpath_var"; then

 46910 +      $ECHO "   - add LIBDIR to the \`$runpath_var' environment variable"

 46911 +      $ECHO "     during linking"

 46912 +    fi

 46913 +    if test -n "$hardcode_libdir_flag_spec"; then

 46914 +      libdir=LIBDIR

 46915 +      eval flag=\"$hardcode_libdir_flag_spec\"

 46916 +

 46917 +      $ECHO "   - use the \`$flag' linker flag"

 46918 +    fi

 46919 +    if test -n "$admincmds"; then

 46920 +      $ECHO "   - have your system administrator run these commands:$admincmds"

 46921 +    fi

 46922 +    if test -f /etc/ld.so.conf; then

 46923 +      $ECHO "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"

 46924 +    fi

 46925 +    $ECHO

 46926 +

 46927 +    $ECHO "See any operating system documentation about shared libraries for"

 46928 +    case $host in

 46929 +      solaris2.[6789]|solaris2.1[0-9])

 46930 +        $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"

 46931 +	$ECHO "pages."

 46932 +	;;

 46933 +      *)

 46934 +        $ECHO "more information, such as the ld(1) and ld.so(8) manual pages."

 46935 +        ;;

 46936 +    esac

 46937 +    $ECHO "X----------------------------------------------------------------------" | $Xsed

 46938 +    exit $EXIT_SUCCESS

 46939 +}

 46940 +

 46941 +test "$mode" = finish && func_mode_finish ${1+"$@"}

 46942 +

 46943 +

 46944 +# func_mode_install arg...

 46945 +func_mode_install ()

 46946 +{

 46947 +    $opt_debug

 46948 +    # There may be an optional sh(1) argument at the beginning of

 46949 +    # install_prog (especially on Windows NT).

 46950 +    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||

 46951 +       # Allow the use of GNU shtool's install command.

 46952 +       $ECHO "X$nonopt" | $GREP shtool >/dev/null; then

 46953 +      # Aesthetically quote it.

 46954 +      func_quote_for_eval "$nonopt"

 46955 +      install_prog="$func_quote_for_eval_result "

 46956 +      arg=$1

 46957 +      shift

 46958 +    else

 46959 +      install_prog=

 46960 +      arg=$nonopt

 46961 +    fi

 46962 +

 46963 +    # The real first argument should be the name of the installation program.

 46964 +    # Aesthetically quote it.

 46965 +    func_quote_for_eval "$arg"

 46966 +    install_prog="$install_prog$func_quote_for_eval_result"

 46967 +

 46968 +    # We need to accept at least all the BSD install flags.

 46969 +    dest=

 46970 +    files=

 46971 +    opts=

 46972 +    prev=

 46973 +    install_type=

 46974 +    isdir=no

 46975 +    stripme=

 46976 +    for arg

 46977 +    do

 46978 +      if test -n "$dest"; then

 46979 +	files="$files $dest"

 46980 +	dest=$arg

 46981 +	continue

 46982 +      fi

 46983 +

 46984 +      case $arg in

 46985 +      -d) isdir=yes ;;

 46986 +      -f)

 46987 +      	case " $install_prog " in

 46988 +	*[\\\ /]cp\ *) ;;

 46989 +	*) prev=$arg ;;

 46990 +	esac

 46991 +	;;

 46992 +      -g | -m | -o)

 46993 +	prev=$arg

 46994 +	;;

 46995 +      -s)

 46996 +	stripme=" -s"

 46997 +	continue

 46998 +	;;

 46999 +      -*)

 47000 +	;;

 47001 +      *)

 47002 +	# If the previous option needed an argument, then skip it.

 47003 +	if test -n "$prev"; then

 47004 +	  prev=

 47005 +	else

 47006 +	  dest=$arg

 47007 +	  continue

 47008 +	fi

 47009 +	;;

 47010 +      esac

 47011 +

 47012 +      # Aesthetically quote the argument.

 47013 +      func_quote_for_eval "$arg"

 47014 +      install_prog="$install_prog $func_quote_for_eval_result"

 47015 +    done

 47016 +

 47017 +    test -z "$install_prog" && \

 47018 +      func_fatal_help "you must specify an install program"

 47019 +

 47020 +    test -n "$prev" && \

 47021 +      func_fatal_help "the \`$prev' option requires an argument"

 47022 +

 47023 +    if test -z "$files"; then

 47024 +      if test -z "$dest"; then

 47025 +	func_fatal_help "no file or destination specified"

 47026 +      else

 47027 +	func_fatal_help "you must specify a destination"

 47028 +      fi

 47029 +    fi

 47030 +

 47031 +    # Strip any trailing slash from the destination.

 47032 +    func_stripname '' '/' "$dest"

 47033 +    dest=$func_stripname_result

 47034 +

 47035 +    # Check to see that the destination is a directory.

 47036 +    test -d "$dest" && isdir=yes

 47037 +    if test "$isdir" = yes; then

 47038 +      destdir="$dest"

 47039 +      destname=

 47040 +    else

 47041 +      func_dirname "$dest" "" "."

 47042 +      destdir="$func_dirname_result"

 47043 +      func_basename "$dest"

 47044 +      destname="$func_basename_result"

 47045 +

 47046 +      # Not a directory, so check to see that there is only one file specified.

 47047 +      set dummy $files; shift

 47048 +      test "$#" -gt 1 && \

 47049 +	func_fatal_help "\`$dest' is not a directory"

 47050 +    fi

 47051 +    case $destdir in

 47052 +    [\\/]* | [A-Za-z]:[\\/]*) ;;

 47053 +    *)

 47054 +      for file in $files; do

 47055 +	case $file in

 47056 +	*.lo) ;;

 47057 +	*)

 47058 +	  func_fatal_help "\`$destdir' must be an absolute directory name"

 47059 +	  ;;

 47060 +	esac

 47061 +      done

 47062 +      ;;

 47063 +    esac

 47064 +

 47065 +    # This variable tells wrapper scripts just to set variables rather

 47066 +    # than running their programs.

 47067 +    libtool_install_magic="$magic"

 47068 +

 47069 +    staticlibs=

 47070 +    future_libdirs=

 47071 +    current_libdirs=

 47072 +    for file in $files; do

 47073 +

 47074 +      # Do each installation.

 47075 +      case $file in

 47076 +      *.$libext)

 47077 +	# Do the static libraries later.

 47078 +	staticlibs="$staticlibs $file"

 47079 +	;;

 47080 +

 47081 +      *.la)

 47082 +	# Check to see that this really is a libtool archive.

 47083 +	func_lalib_unsafe_p "$file" \

 47084 +	  || func_fatal_help "\`$file' is not a valid libtool archive"

 47085 +

 47086 +	library_names=

 47087 +	old_library=

 47088 +	relink_command=

 47089 +	func_source "$file"

 47090 +

 47091 +	# Add the libdir to current_libdirs if it is the destination.

 47092 +	if test "X$destdir" = "X$libdir"; then

 47093 +	  case "$current_libdirs " in

 47094 +	  *" $libdir "*) ;;

 47095 +	  *) current_libdirs="$current_libdirs $libdir" ;;

 47096 +	  esac

 47097 +	else

 47098 +	  # Note the libdir as a future libdir.

 47099 +	  case "$future_libdirs " in

 47100 +	  *" $libdir "*) ;;

 47101 +	  *) future_libdirs="$future_libdirs $libdir" ;;

 47102 +	  esac

 47103 +	fi

 47104 +

 47105 +	func_dirname "$file" "/" ""

 47106 +	dir="$func_dirname_result"

 47107 +	dir="$dir$objdir"

 47108 +

 47109 +	if test -n "$relink_command"; then

 47110 +	  # Determine the prefix the user has applied to our future dir.

 47111 +	  inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`

 47112 +

 47113 +	  # Don't allow the user to place us outside of our expected

 47114 +	  # location b/c this prevents finding dependent libraries that

 47115 +	  # are installed to the same prefix.

 47116 +	  # At present, this check doesn't affect windows .dll's that

 47117 +	  # are installed into $libdir/../bin (currently, that works fine)

 47118 +	  # but it's something to keep an eye on.

 47119 +	  test "$inst_prefix_dir" = "$destdir" && \

 47120 +	    func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"

 47121 +

 47122 +	  if test -n "$inst_prefix_dir"; then

 47123 +	    # Stick the inst_prefix_dir data into the link command.

 47124 +	    relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`

 47125 +	  else

 47126 +	    relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`

 47127 +	  fi

 47128 +

 47129 +	  func_warning "relinking \`$file'"

 47130 +	  func_show_eval "$relink_command" \

 47131 +	    'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'

 47132 +	fi

 47133 +

 47134 +	# See the names of the shared library.

 47135 +	set dummy $library_names; shift

 47136 +	if test -n "$1"; then

 47137 +	  realname="$1"

 47138 +	  shift

 47139 +

 47140 +	  srcname="$realname"

 47141 +	  test -n "$relink_command" && srcname="$realname"T

 47142 +

 47143 +	  # Install the shared library and build the symlinks.

 47144 +	  func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \

 47145 +	      'exit $?'

 47146 +	  tstripme="$stripme"

 47147 +	  case $host_os in

 47148 +	  cygwin* | mingw* | pw32*)

 47149 +	    case $realname in

 47150 +	    *.dll.a)

 47151 +	      tstripme=""

 47152 +	      ;;

 47153 +	    esac

 47154 +	    ;;

 47155 +	  esac

 47156 +	  if test -n "$tstripme" && test -n "$striplib"; then

 47157 +	    func_show_eval "$striplib $destdir/$realname" 'exit $?'

 47158 +	  fi

 47159 +

 47160 +	  if test "$#" -gt 0; then

 47161 +	    # Delete the old symlinks, and create new ones.

 47162 +	    # Try `ln -sf' first, because the `ln' binary might depend on

 47163 +	    # the symlink we replace!  Solaris /bin/ln does not understand -f,

 47164 +	    # so we also need to try rm && ln -s.

 47165 +	    for linkname

 47166 +	    do

 47167 +	      test "$linkname" != "$realname" \

 47168 +		&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"

 47169 +	    done

 47170 +	  fi

 47171 +

 47172 +	  # Do each command in the postinstall commands.

 47173 +	  lib="$destdir/$realname"

 47174 +	  func_execute_cmds "$postinstall_cmds" 'exit $?'

 47175 +	fi

 47176 +

 47177 +	# Install the pseudo-library for information purposes.

 47178 +	func_basename "$file"

 47179 +	name="$func_basename_result"

 47180 +	instname="$dir/$name"i

 47181 +	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'

 47182 +

 47183 +	# Maybe install the static library, too.

 47184 +	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"

 47185 +	;;

 47186 +

 47187 +      *.lo)

 47188 +	# Install (i.e. copy) a libtool object.

 47189 +

 47190 +	# Figure out destination file name, if it wasn't already specified.

 47191 +	if test -n "$destname"; then

 47192 +	  destfile="$destdir/$destname"

 47193 +	else

 47194 +	  func_basename "$file"

 47195 +	  destfile="$func_basename_result"

 47196 +	  destfile="$destdir/$destfile"

 47197 +	fi

 47198 +

 47199 +	# Deduce the name of the destination old-style object file.

 47200 +	case $destfile in

 47201 +	*.lo)

 47202 +	  func_lo2o "$destfile"

 47203 +	  staticdest=$func_lo2o_result

 47204 +	  ;;

 47205 +	*.$objext)

 47206 +	  staticdest="$destfile"

 47207 +	  destfile=

 47208 +	  ;;

 47209 +	*)

 47210 +	  func_fatal_help "cannot copy a libtool object to \`$destfile'"

 47211 +	  ;;

 47212 +	esac

 47213 +

 47214 +	# Install the libtool object if requested.

 47215 +	test -n "$destfile" && \

 47216 +	  func_show_eval "$install_prog $file $destfile" 'exit $?'

 47217 +

 47218 +	# Install the old object if enabled.

 47219 +	if test "$build_old_libs" = yes; then

 47220 +	  # Deduce the name of the old-style object file.

 47221 +	  func_lo2o "$file"

 47222 +	  staticobj=$func_lo2o_result

 47223 +	  func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'

 47224 +	fi

 47225 +	exit $EXIT_SUCCESS

 47226 +	;;

 47227 +

 47228 +      *)

 47229 +	# Figure out destination file name, if it wasn't already specified.

 47230 +	if test -n "$destname"; then

 47231 +	  destfile="$destdir/$destname"

 47232 +	else

 47233 +	  func_basename "$file"

 47234 +	  destfile="$func_basename_result"

 47235 +	  destfile="$destdir/$destfile"

 47236 +	fi

 47237 +

 47238 +	# If the file is missing, and there is a .exe on the end, strip it

 47239 +	# because it is most likely a libtool script we actually want to

 47240 +	# install

 47241 +	stripped_ext=""

 47242 +	case $file in

 47243 +	  *.exe)

 47244 +	    if test ! -f "$file"; then

 47245 +	      func_stripname '' '.exe' "$file"

 47246 +	      file=$func_stripname_result

 47247 +	      stripped_ext=".exe"

 47248 +	    fi

 47249 +	    ;;

 47250 +	esac

 47251 +

 47252 +	# Do a test to see if this is really a libtool program.

 47253 +	case $host in

 47254 +	*cygwin*|*mingw*)

 47255 +	    func_stripname '' '.exe' "$file"

 47256 +	    wrapper=$func_stripname_result

 47257 +	    ;;

 47258 +	*)

 47259 +	    wrapper=$file

 47260 +	    ;;

 47261 +	esac

 47262 +	if func_ltwrapper_p "$wrapper"; then

 47263 +	  notinst_deplibs=

 47264 +	  relink_command=

 47265 +

 47266 +	  func_source "$wrapper"

 47267 +

 47268 +	  # Check the variables that should have been set.

 47269 +	  test -z "$generated_by_libtool_version" && \

 47270 +	    func_fatal_error "invalid libtool wrapper script \`$wrapper'"

 47271 +

 47272 +	  finalize=yes

 47273 +	  for lib in $notinst_deplibs; do

 47274 +	    # Check to see that each library is installed.

 47275 +	    libdir=

 47276 +	    if test -f "$lib"; then

 47277 +	      func_source "$lib"

 47278 +	    fi

 47279 +	    libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test

 47280 +	    if test -n "$libdir" && test ! -f "$libfile"; then

 47281 +	      func_warning "\`$lib' has not been installed in \`$libdir'"

 47282 +	      finalize=no

 47283 +	    fi

 47284 +	  done

 47285 +

 47286 +	  relink_command=

 47287 +	  func_source "$wrapper"

 47288 +

 47289 +	  outputname=

 47290 +	  if test "$fast_install" = no && test -n "$relink_command"; then

 47291 +	    $opt_dry_run || {

 47292 +	      if test "$finalize" = yes; then

 47293 +	        tmpdir=`func_mktempdir`

 47294 +		func_basename "$file$stripped_ext"

 47295 +		file="$func_basename_result"

 47296 +	        outputname="$tmpdir/$file"

 47297 +	        # Replace the output file specification.

 47298 +	        relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`

 47299 +

 47300 +	        $opt_silent || {

 47301 +	          func_quote_for_expand "$relink_command"

 47302 +		  eval "func_echo $func_quote_for_expand_result"

 47303 +	        }

 47304 +	        if eval "$relink_command"; then :

 47305 +	          else

 47306 +		  func_error "error: relink \`$file' with the above command before installing it"

 47307 +		  $opt_dry_run || ${RM}r "$tmpdir"

 47308 +		  continue

 47309 +	        fi

 47310 +	        file="$outputname"

 47311 +	      else

 47312 +	        func_warning "cannot relink \`$file'"

 47313 +	      fi

 47314 +	    }

 47315 +	  else

 47316 +	    # Install the binary that we compiled earlier.

 47317 +	    file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`

 47318 +	  fi

 47319 +	fi

 47320 +

 47321 +	# remove .exe since cygwin /usr/bin/install will append another

 47322 +	# one anyway

 47323 +	case $install_prog,$host in

 47324 +	*/usr/bin/install*,*cygwin*)

 47325 +	  case $file:$destfile in

 47326 +	  *.exe:*.exe)

 47327 +	    # this is ok

 47328 +	    ;;

 47329 +	  *.exe:*)

 47330 +	    destfile=$destfile.exe

 47331 +	    ;;

 47332 +	  *:*.exe)

 47333 +	    func_stripname '' '.exe' "$destfile"

 47334 +	    destfile=$func_stripname_result

 47335 +	    ;;

 47336 +	  esac

 47337 +	  ;;

 47338 +	esac

 47339 +	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'

 47340 +	$opt_dry_run || if test -n "$outputname"; then

 47341 +	  ${RM}r "$tmpdir"

 47342 +	fi

 47343 +	;;

 47344 +      esac

 47345 +    done

 47346 +

 47347 +    for file in $staticlibs; do

 47348 +      func_basename "$file"

 47349 +      name="$func_basename_result"

 47350 +

 47351 +      # Set up the ranlib parameters.

 47352 +      oldlib="$destdir/$name"

 47353 +

 47354 +      func_show_eval "$install_prog \$file \$oldlib" 'exit $?'

 47355 +

 47356 +      if test -n "$stripme" && test -n "$old_striplib"; then

 47357 +	func_show_eval "$old_striplib $oldlib" 'exit $?'

 47358 +      fi

 47359 +

 47360 +      # Do each command in the postinstall commands.

 47361 +      func_execute_cmds "$old_postinstall_cmds" 'exit $?'

 47362 +    done

 47363 +

 47364 +    test -n "$future_libdirs" && \

 47365 +      func_warning "remember to run \`$progname --finish$future_libdirs'"

 47366 +

 47367 +    if test -n "$current_libdirs"; then

 47368 +      # Maybe just do a dry run.

 47369 +      $opt_dry_run && current_libdirs=" -n$current_libdirs"

 47370 +      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'

 47371 +    else

 47372 +      exit $EXIT_SUCCESS

 47373 +    fi

 47374 +}

 47375 +

 47376 +test "$mode" = install && func_mode_install ${1+"$@"}

 47377 +

 47378 +

 47379 +# func_mode_link arg...

 47380 +func_mode_link ()

 47381 +{

 47382 +    $opt_debug

 47383 +    case $host in

 47384 +    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)

 47385 +      # It is impossible to link a dll without this setting, and

 47386 +      # we shouldn't force the makefile maintainer to figure out

 47387 +      # which system we are compiling for in order to pass an extra

 47388 +      # flag for every libtool invocation.

 47389 +      # allow_undefined=no

 47390 +

 47391 +      # FIXME: Unfortunately, there are problems with the above when trying

 47392 +      # to make a dll which has undefined symbols, in which case not

 47393 +      # even a static library is built.  For now, we need to specify

 47394 +      # -no-undefined on the libtool link line when we can be certain

 47395 +      # that all symbols are satisfied, otherwise we get a static library.

 47396 +      allow_undefined=yes

 47397 +      ;;

 47398 +    *)

 47399 +      allow_undefined=yes

 47400 +      ;;

 47401 +    esac

 47402 +    libtool_args=$nonopt

 47403 +    base_compile="$nonopt $@"

 47404 +    compile_command=$nonopt

 47405 +    finalize_command=$nonopt

 47406 +

 47407 +    compile_rpath=

 47408 +    finalize_rpath=

 47409 +    compile_shlibpath=

 47410 +    finalize_shlibpath=

 47411 +    convenience=

 47412 +    old_convenience=

 47413 +    deplibs=

 47414 +    old_deplibs=

 47415 +    compiler_flags=

 47416 +    linker_flags=

 47417 +    dllsearchpath=

 47418 +    lib_search_path=`pwd`

 47419 +    inst_prefix_dir=

 47420 +    new_inherited_linker_flags=

 47421 +

 47422 +    avoid_version=no

 47423 +    dlfiles=

 47424 +    dlprefiles=

 47425 +    dlself=no

 47426 +    export_dynamic=no

 47427 +    export_symbols=

 47428 +    export_symbols_regex=

 47429 +    generated=

 47430 +    libobjs=

 47431 +    ltlibs=

 47432 +    module=no

 47433 +    no_install=no

 47434 +    objs=

 47435 +    non_pic_objects=

 47436 +    precious_files_regex=

 47437 +    prefer_static_libs=no

 47438 +    preload=no

 47439 +    prev=

 47440 +    prevarg=

 47441 +    release=

 47442 +    rpath=

 47443 +    xrpath=

 47444 +    perm_rpath=

 47445 +    temp_rpath=

 47446 +    thread_safe=no

 47447 +    vinfo=

 47448 +    vinfo_number=no

 47449 +    weak_libs=

 47450 +    single_module="${wl}-single_module"

 47451 +    func_infer_tag $base_compile

 47452 +

 47453 +    # We need to know -static, to get the right output filenames.

 47454 +    for arg

 47455 +    do

 47456 +      case $arg in

 47457 +      -shared)

 47458 +	test "$build_libtool_libs" != yes && \

 47459 +	  func_fatal_configuration "can not build a shared library"

 47460 +	build_old_libs=no

 47461 +	break

 47462 +	;;

 47463 +      -all-static | -static | -static-libtool-libs)

 47464 +	case $arg in

 47465 +	-all-static)

 47466 +	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then

 47467 +	    func_warning "complete static linking is impossible in this configuration"

 47468 +	  fi

 47469 +	  if test -n "$link_static_flag"; then

 47470 +	    dlopen_self=$dlopen_self_static

 47471 +	    # See comment for -static flag below, for more details.

 47472 +	    func_append compile_command " $link_static_flag"

 47473 +	    func_append finalize_command " $link_static_flag"

 47474 +	  fi

 47475 +	  prefer_static_libs=yes

 47476 +	  ;;

 47477 +	-static)

 47478 +	  if test -z "$pic_flag" && test -n "$link_static_flag"; then

 47479 +	    dlopen_self=$dlopen_self_static

 47480 +	  fi

 47481 +	  prefer_static_libs=built

 47482 +	  ;;

 47483 +	-static-libtool-libs)

 47484 +	  if test -z "$pic_flag" && test -n "$link_static_flag"; then

 47485 +	    dlopen_self=$dlopen_self_static

 47486 +	  fi

 47487 +	  prefer_static_libs=yes

 47488 +	  ;;

 47489 +	esac

 47490 +	build_libtool_libs=no

 47491 +	build_old_libs=yes

 47492 +	break

 47493 +	;;

 47494 +      esac

 47495 +    done

 47496 +

 47497 +    # See if our shared archives depend on static archives.

 47498 +    test -n "$old_archive_from_new_cmds" && build_old_libs=yes

 47499 +

 47500 +    # Go through the arguments, transforming them on the way.

 47501 +    while test "$#" -gt 0; do

 47502 +      arg="$1"

 47503 +      shift

 47504 +      func_quote_for_eval "$arg"

 47505 +      qarg=$func_quote_for_eval_unquoted_result

 47506 +      func_append libtool_args " $func_quote_for_eval_result"

 47507 +

 47508 +      # If the previous option needs an argument, assign it.

 47509 +      if test -n "$prev"; then

 47510 +	case $prev in

 47511 +	output)

 47512 +	  func_append compile_command " @OUTPUT@"

 47513 +	  func_append finalize_command " @OUTPUT@"

 47514 +	  ;;

 47515 +	esac

 47516 +

 47517 +	case $prev in

 47518 +	dlfiles|dlprefiles)

 47519 +	  if test "$preload" = no; then

 47520 +	    # Add the symbol object into the linking commands.

 47521 +	    func_append compile_command " @SYMFILE@"

 47522 +	    func_append finalize_command " @SYMFILE@"

 47523 +	    preload=yes

 47524 +	  fi

 47525 +	  case $arg in

 47526 +	  *.la | *.lo) ;;  # We handle these cases below.

 47527 +	  force)

 47528 +	    if test "$dlself" = no; then

 47529 +	      dlself=needless

 47530 +	      export_dynamic=yes

 47531 +	    fi

 47532 +	    prev=

 47533 +	    continue

 47534 +	    ;;

 47535 +	  self)

 47536 +	    if test "$prev" = dlprefiles; then

 47537 +	      dlself=yes

 47538 +	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then

 47539 +	      dlself=yes

 47540 +	    else

 47541 +	      dlself=needless

 47542 +	      export_dynamic=yes

 47543 +	    fi

 47544 +	    prev=

 47545 +	    continue

 47546 +	    ;;

 47547 +	  *)

 47548 +	    if test "$prev" = dlfiles; then

 47549 +	      dlfiles="$dlfiles $arg"

 47550 +	    else

 47551 +	      dlprefiles="$dlprefiles $arg"

 47552 +	    fi

 47553 +	    prev=

 47554 +	    continue

 47555 +	    ;;

 47556 +	  esac

 47557 +	  ;;

 47558 +	expsyms)

 47559 +	  export_symbols="$arg"

 47560 +	  test -f "$arg" \

 47561 +	    || func_fatal_error "symbol file \`$arg' does not exist"

 47562 +	  prev=

 47563 +	  continue

 47564 +	  ;;

 47565 +	expsyms_regex)

 47566 +	  export_symbols_regex="$arg"

 47567 +	  prev=

 47568 +	  continue

 47569 +	  ;;

 47570 +	framework)

 47571 +	  case $host in

 47572 +	    *-*-darwin*)

 47573 +	      case "$deplibs " in

 47574 +		*" $qarg.ltframework "*) ;;

 47575 +		*) deplibs="$deplibs $qarg.ltframework" # this is fixed later

 47576 +		   ;;

 47577 +	      esac

 47578 +	      ;;

 47579 +   	  esac

 47580 +	  prev=

 47581 +	  continue

 47582 +	  ;;

 47583 +	inst_prefix)

 47584 +	  inst_prefix_dir="$arg"

 47585 +	  prev=

 47586 +	  continue

 47587 +	  ;;

 47588 +	objectlist)

 47589 +	  if test -f "$arg"; then

 47590 +	    save_arg=$arg

 47591 +	    moreargs=

 47592 +	    for fil in `cat "$save_arg"`

 47593 +	    do

 47594 +#	      moreargs="$moreargs $fil"

 47595 +	      arg=$fil

 47596 +	      # A libtool-controlled object.

 47597 +

 47598 +	      # Check to see that this really is a libtool object.

 47599 +	      if func_lalib_unsafe_p "$arg"; then

 47600 +		pic_object=

 47601 +		non_pic_object=

 47602 +

 47603 +		# Read the .lo file

 47604 +		func_source "$arg"

 47605 +

 47606 +		if test -z "$pic_object" ||

 47607 +		   test -z "$non_pic_object" ||

 47608 +		   test "$pic_object" = none &&

 47609 +		   test "$non_pic_object" = none; then

 47610 +		  func_fatal_error "cannot find name of object for \`$arg'"

 47611 +		fi

 47612 +

 47613 +		# Extract subdirectory from the argument.

 47614 +		func_dirname "$arg" "/" ""

 47615 +		xdir="$func_dirname_result"

 47616 +

 47617 +		if test "$pic_object" != none; then

 47618 +		  # Prepend the subdirectory the object is found in.

 47619 +		  pic_object="$xdir$pic_object"

 47620 +

 47621 +		  if test "$prev" = dlfiles; then

 47622 +		    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then

 47623 +		      dlfiles="$dlfiles $pic_object"

 47624 +		      prev=

 47625 +		      continue

 47626 +		    else

 47627 +		      # If libtool objects are unsupported, then we need to preload.

 47628 +		      prev=dlprefiles

 47629 +		    fi

 47630 +		  fi

 47631 +

 47632 +		  # CHECK ME:  I think I busted this.  -Ossama

 47633 +		  if test "$prev" = dlprefiles; then

 47634 +		    # Preload the old-style object.

 47635 +		    dlprefiles="$dlprefiles $pic_object"

 47636 +		    prev=

 47637 +		  fi

 47638 +

 47639 +		  # A PIC object.

 47640 +		  func_append libobjs " $pic_object"

 47641 +		  arg="$pic_object"

 47642 +		fi

 47643 +

 47644 +		# Non-PIC object.

 47645 +		if test "$non_pic_object" != none; then

 47646 +		  # Prepend the subdirectory the object is found in.

 47647 +		  non_pic_object="$xdir$non_pic_object"

 47648 +

 47649 +		  # A standard non-PIC object

 47650 +		  func_append non_pic_objects " $non_pic_object"

 47651 +		  if test -z "$pic_object" || test "$pic_object" = none ; then

 47652 +		    arg="$non_pic_object"

 47653 +		  fi

 47654 +		else

 47655 +		  # If the PIC object exists, use it instead.

 47656 +		  # $xdir was prepended to $pic_object above.

 47657 +		  non_pic_object="$pic_object"

 47658 +		  func_append non_pic_objects " $non_pic_object"

 47659 +		fi

 47660 +	      else

 47661 +		# Only an error if not doing a dry-run.

 47662 +		if $opt_dry_run; then

 47663 +		  # Extract subdirectory from the argument.

 47664 +		  func_dirname "$arg" "/" ""

 47665 +		  xdir="$func_dirname_result"

 47666 +

 47667 +		  func_lo2o "$arg"

 47668 +		  pic_object=$xdir$objdir/$func_lo2o_result

 47669 +		  non_pic_object=$xdir$func_lo2o_result

 47670 +		  func_append libobjs " $pic_object"

 47671 +		  func_append non_pic_objects " $non_pic_object"

 47672 +	        else

 47673 +		  func_fatal_error "\`$arg' is not a valid libtool object"

 47674 +		fi

 47675 +	      fi

 47676 +	    done

 47677 +	  else

 47678 +	    func_fatal_error "link input file \`$arg' does not exist"

 47679 +	  fi

 47680 +	  arg=$save_arg

 47681 +	  prev=

 47682 +	  continue

 47683 +	  ;;

 47684 +	precious_regex)

 47685 +	  precious_files_regex="$arg"

 47686 +	  prev=

 47687 +	  continue

 47688 +	  ;;

 47689 +	release)

 47690 +	  release="-$arg"

 47691 +	  prev=

 47692 +	  continue

 47693 +	  ;;

 47694 +	rpath | xrpath)

 47695 +	  # We need an absolute path.

 47696 +	  case $arg in

 47697 +	  [\\/]* | [A-Za-z]:[\\/]*) ;;

 47698 +	  *)

 47699 +	    func_fatal_error "only absolute run-paths are allowed"

 47700 +	    ;;

 47701 +	  esac

 47702 +	  if test "$prev" = rpath; then

 47703 +	    case "$rpath " in

 47704 +	    *" $arg "*) ;;

 47705 +	    *) rpath="$rpath $arg" ;;

 47706 +	    esac

 47707 +	  else

 47708 +	    case "$xrpath " in

 47709 +	    *" $arg "*) ;;

 47710 +	    *) xrpath="$xrpath $arg" ;;

 47711 +	    esac

 47712 +	  fi

 47713 +	  prev=

 47714 +	  continue

 47715 +	  ;;

 47716 +	shrext)

 47717 +  	  shrext_cmds="$arg"

 47718 +	  prev=

 47719 +	  continue

 47720 +	  ;;

 47721 +	weak)

 47722 +	  weak_libs="$weak_libs $arg"

 47723 +	  prev=

 47724 +	  continue

 47725 +	  ;;

 47726 +	xcclinker)

 47727 +	  linker_flags="$linker_flags $qarg"

 47728 +	  compiler_flags="$compiler_flags $qarg"

 47729 +	  prev=

 47730 +	  func_append compile_command " $qarg"

 47731 +	  func_append finalize_command " $qarg"

 47732 +	  continue

 47733 +	  ;;

 47734 +	xcompiler)

 47735 +	  compiler_flags="$compiler_flags $qarg"

 47736 +	  prev=

 47737 +	  func_append compile_command " $qarg"

 47738 +	  func_append finalize_command " $qarg"

 47739 +	  continue

 47740 +	  ;;

 47741 +	xlinker)

 47742 +	  linker_flags="$linker_flags $qarg"

 47743 +	  compiler_flags="$compiler_flags $wl$qarg"

 47744 +	  prev=

 47745 +	  func_append compile_command " $wl$qarg"

 47746 +	  func_append finalize_command " $wl$qarg"

 47747 +	  continue

 47748 +	  ;;

 47749 +	*)

 47750 +	  eval "$prev=\"\$arg\""

 47751 +	  prev=

 47752 +	  continue

 47753 +	  ;;

 47754 +	esac

 47755 +      fi # test -n "$prev"

 47756 +

 47757 +      prevarg="$arg"

 47758 +

 47759 +      case $arg in

 47760 +      -all-static)

 47761 +	# The effects of -all-static are defined in a previous loop.

 47762 +	continue

 47763 +	;;

 47764 +

 47765 +      -allow-undefined)

 47766 +	# FIXME: remove this flag sometime in the future.

 47767 +	func_fatal_error "\`-allow-undefined' must not be used because it is the default"

 47768 +	;;

 47769 +

 47770 +      -avoid-version)

 47771 +	avoid_version=yes

 47772 +	continue

 47773 +	;;

 47774 +

 47775 +      -dlopen)

 47776 +	prev=dlfiles

 47777 +	continue

 47778 +	;;

 47779 +

 47780 +      -dlpreopen)

 47781 +	prev=dlprefiles

 47782 +	continue

 47783 +	;;

 47784 +

 47785 +      -export-dynamic)

 47786 +	export_dynamic=yes

 47787 +	continue

 47788 +	;;

 47789 +

 47790 +      -export-symbols | -export-symbols-regex)

 47791 +	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then

 47792 +	  func_fatal_error "more than one -exported-symbols argument is not allowed"

 47793 +	fi

 47794 +	if test "X$arg" = "X-export-symbols"; then

 47795 +	  prev=expsyms

 47796 +	else

 47797 +	  prev=expsyms_regex

 47798 +	fi

 47799 +	continue

 47800 +	;;

 47801 +

 47802 +      -framework)

 47803 +	prev=framework

 47804 +	continue

 47805 +	;;

 47806 +

 47807 +      -inst-prefix-dir)

 47808 +	prev=inst_prefix

 47809 +	continue

 47810 +	;;

 47811 +

 47812 +      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*

 47813 +      # so, if we see these flags be careful not to treat them like -L

 47814 +      -L[A-Z][A-Z]*:*)

 47815 +	case $with_gcc/$host in

 47816 +	no/*-*-irix* | /*-*-irix*)

 47817 +	  func_append compile_command " $arg"

 47818 +	  func_append finalize_command " $arg"

 47819 +	  ;;

 47820 +	esac

 47821 +	continue

 47822 +	;;

 47823 +

 47824 +      -L*)

 47825 +	func_stripname '-L' '' "$arg"

 47826 +	dir=$func_stripname_result

 47827 +	# We need an absolute path.

 47828 +	case $dir in

 47829 +	[\\/]* | [A-Za-z]:[\\/]*) ;;

 47830 +	*)

 47831 +	  absdir=`cd "$dir" && pwd`

 47832 +	  test -z "$absdir" && \

 47833 +	    func_fatal_error "cannot determine absolute directory name of \`$dir'"

 47834 +	  dir="$absdir"

 47835 +	  ;;

 47836 +	esac

 47837 +	case "$deplibs " in

 47838 +	*" -L$dir "*) ;;

 47839 +	*)

 47840 +	  deplibs="$deplibs -L$dir"

 47841 +	  lib_search_path="$lib_search_path $dir"

 47842 +	  ;;

 47843 +	esac

 47844 +	case $host in

 47845 +	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)

 47846 +	  testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`

 47847 +	  case :$dllsearchpath: in

 47848 +	  *":$dir:"*) ;;

 47849 +	  *) dllsearchpath="$dllsearchpath:$dir";;

 47850 +	  esac

 47851 +	  case :$dllsearchpath: in

 47852 +	  *":$testbindir:"*) ;;

 47853 +	  *) dllsearchpath="$dllsearchpath:$testbindir";;

 47854 +	  esac

 47855 +	  ;;

 47856 +	esac

 47857 +	continue

 47858 +	;;

 47859 +

 47860 +      -l*)

 47861 +	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then

 47862 +	  case $host in

 47863 +	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)

 47864 +	    # These systems don't actually have a C or math library (as such)

 47865 +	    continue

 47866 +	    ;;

 47867 +	  *-*-os2*)

 47868 +	    # These systems don't actually have a C library (as such)

 47869 +	    test "X$arg" = "X-lc" && continue

 47870 +	    ;;

 47871 +	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

 47872 +	    # Do not include libc due to us having libc/libc_r.

 47873 +	    test "X$arg" = "X-lc" && continue

 47874 +	    ;;

 47875 +	  *-*-rhapsody* | *-*-darwin1.[012])

 47876 +	    # Rhapsody C and math libraries are in the System framework

 47877 +	    deplibs="$deplibs System.ltframework"

 47878 +	    continue

 47879 +	    ;;

 47880 +	  *-*-sco3.2v5* | *-*-sco5v6*)

 47881 +	    # Causes problems with __ctype

 47882 +	    test "X$arg" = "X-lc" && continue

 47883 +	    ;;

 47884 +	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)

 47885 +	    # Compiler inserts libc in the correct place for threads to work

 47886 +	    test "X$arg" = "X-lc" && continue

 47887 +	    ;;

 47888 +	  esac

 47889 +	elif test "X$arg" = "X-lc_r"; then

 47890 +	 case $host in

 47891 +	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

 47892 +	   # Do not include libc_r directly, use -pthread flag.

 47893 +	   continue

 47894 +	   ;;

 47895 +	 esac

 47896 +	fi

 47897 +	deplibs="$deplibs $arg"

 47898 +	continue

 47899 +	;;

 47900 +

 47901 +      -module)

 47902 +	module=yes

 47903 +	continue

 47904 +	;;

 47905 +

 47906 +      # Tru64 UNIX uses -model [arg] to determine the layout of C++

 47907 +      # classes, name mangling, and exception handling.

 47908 +      # Darwin uses the -arch flag to determine output architecture.

 47909 +      -model|-arch|-isysroot)

 47910 +	compiler_flags="$compiler_flags $arg"

 47911 +	func_append compile_command " $arg"

 47912 +	func_append finalize_command " $arg"

 47913 +	prev=xcompiler

 47914 +	continue

 47915 +	;;

 47916 +

 47917 +      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)

 47918 +	compiler_flags="$compiler_flags $arg"

 47919 +	func_append compile_command " $arg"

 47920 +	func_append finalize_command " $arg"

 47921 +	case "$new_inherited_linker_flags " in

 47922 +	    *" $arg "*) ;;

 47923 +	    * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;

 47924 +	esac

 47925 +	continue

 47926 +	;;

 47927 +

 47928 +      -multi_module)

 47929 +	single_module="${wl}-multi_module"

 47930 +	continue

 47931 +	;;

 47932 +

 47933 +      -no-fast-install)

 47934 +	fast_install=no

 47935 +	continue

 47936 +	;;

 47937 +

 47938 +      -no-install)

 47939 +	case $host in

 47940 +	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)

 47941 +	  # The PATH hackery in wrapper scripts is required on Windows

 47942 +	  # in order for the loader to find any dlls it needs.

 47943 +	  func_warning "\`-no-install' is ignored for $host"

 47944 +	  func_warning "assuming \`-no-fast-install' instead"

 47945 +	  fast_install=no

 47946 +	  ;;

 47947 +	*) no_install=yes ;;

 47948 +	esac

 47949 +	continue

 47950 +	;;

 47951 +

 47952 +      -no-undefined)

 47953 +	allow_undefined=no

 47954 +	continue

 47955 +	;;

 47956 +

 47957 +      -objectlist)

 47958 +	prev=objectlist

 47959 +	continue

 47960 +	;;

 47961 +

 47962 +      -o) prev=output ;;

 47963 +

 47964 +      -precious-files-regex)

 47965 +	prev=precious_regex

 47966 +	continue

 47967 +	;;

 47968 +

 47969 +      -release)

 47970 +	prev=release

 47971 +	continue

 47972 +	;;

 47973 +

 47974 +      -rpath)

 47975 +	prev=rpath

 47976 +	continue

 47977 +	;;

 47978 +

 47979 +      -R)

 47980 +	prev=xrpath

 47981 +	continue

 47982 +	;;

 47983 +

 47984 +      -R*)

 47985 +	func_stripname '-R' '' "$arg"

 47986 +	dir=$func_stripname_result

 47987 +	# We need an absolute path.

 47988 +	case $dir in

 47989 +	[\\/]* | [A-Za-z]:[\\/]*) ;;

 47990 +	*)

 47991 +	  func_fatal_error "only absolute run-paths are allowed"

 47992 +	  ;;

 47993 +	esac

 47994 +	case "$xrpath " in

 47995 +	*" $dir "*) ;;

 47996 +	*) xrpath="$xrpath $dir" ;;

 47997 +	esac

 47998 +	continue

 47999 +	;;

 48000 +

 48001 +      -shared)

 48002 +	# The effects of -shared are defined in a previous loop.

 48003 +	continue

 48004 +	;;

 48005 +

 48006 +      -shrext)

 48007 +	prev=shrext

 48008 +	continue

 48009 +	;;

 48010 +

 48011 +      -static | -static-libtool-libs)

 48012 +	# The effects of -static are defined in a previous loop.

 48013 +	# We used to do the same as -all-static on platforms that

 48014 +	# didn't have a PIC flag, but the assumption that the effects

 48015 +	# would be equivalent was wrong.  It would break on at least

 48016 +	# Digital Unix and AIX.

 48017 +	continue

 48018 +	;;

 48019 +

 48020 +      -thread-safe)

 48021 +	thread_safe=yes

 48022 +	continue

 48023 +	;;

 48024 +

 48025 +      -version-info)

 48026 +	prev=vinfo

 48027 +	continue

 48028 +	;;

 48029 +

 48030 +      -version-number)

 48031 +	prev=vinfo

 48032 +	vinfo_number=yes

 48033 +	continue

 48034 +	;;

 48035 +

 48036 +      -weak)

 48037 +        prev=weak

 48038 +	continue

 48039 +	;;

 48040 +

 48041 +      -Wc,*)

 48042 +	func_stripname '-Wc,' '' "$arg"

 48043 +	args=$func_stripname_result

 48044 +	arg=

 48045 +	save_ifs="$IFS"; IFS=','

 48046 +	for flag in $args; do

 48047 +	  IFS="$save_ifs"

 48048 +          func_quote_for_eval "$flag"

 48049 +	  arg="$arg $wl$func_quote_for_eval_result"

 48050 +	  compiler_flags="$compiler_flags $func_quote_for_eval_result"

 48051 +	done

 48052 +	IFS="$save_ifs"

 48053 +	func_stripname ' ' '' "$arg"

 48054 +	arg=$func_stripname_result

 48055 +	;;

 48056 +

 48057 +      -Wl,*)

 48058 +	func_stripname '-Wl,' '' "$arg"

 48059 +	args=$func_stripname_result

 48060 +	arg=

 48061 +	save_ifs="$IFS"; IFS=','

 48062 +	for flag in $args; do

 48063 +	  IFS="$save_ifs"

 48064 +          func_quote_for_eval "$flag"

 48065 +	  arg="$arg $wl$func_quote_for_eval_result"

 48066 +	  compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"

 48067 +	  linker_flags="$linker_flags $func_quote_for_eval_result"

 48068 +	done

 48069 +	IFS="$save_ifs"

 48070 +	func_stripname ' ' '' "$arg"

 48071 +	arg=$func_stripname_result

 48072 +	;;

 48073 +

 48074 +      -Xcompiler)

 48075 +	prev=xcompiler

 48076 +	continue

 48077 +	;;

 48078 +

 48079 +      -Xlinker)

 48080 +	prev=xlinker

 48081 +	continue

 48082 +	;;

 48083 +

 48084 +      -XCClinker)

 48085 +	prev=xcclinker

 48086 +	continue

 48087 +	;;

 48088 +

 48089 +      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler

 48090 +      # -r[0-9][0-9]* specifies the processor on the SGI compiler

 48091 +      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler

 48092 +      # +DA*, +DD* enable 64-bit mode on the HP compiler

 48093 +      # -q* pass through compiler args for the IBM compiler

 48094 +      # -m*, -t[45]*, -txscale* pass through architecture-specific

 48095 +      # compiler args for GCC

 48096 +      # -F/path gives path to uninstalled frameworks, gcc on darwin

 48097 +      # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC

 48098 +      # @file GCC response files

 48099 +      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \

 48100 +      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)

 48101 +        func_quote_for_eval "$arg"

 48102 +	arg="$func_quote_for_eval_result"

 48103 +        func_append compile_command " $arg"

 48104 +        func_append finalize_command " $arg"

 48105 +        compiler_flags="$compiler_flags $arg"

 48106 +        continue

 48107 +        ;;

 48108 +

 48109 +      # Some other compiler flag.

 48110 +      -* | +*)

 48111 +        func_quote_for_eval "$arg"

 48112 +	arg="$func_quote_for_eval_result"

 48113 +	;;

 48114 +

 48115 +      *.$objext)

 48116 +	# A standard object.

 48117 +	objs="$objs $arg"

 48118 +	;;

 48119 +

 48120 +      *.lo)

 48121 +	# A libtool-controlled object.

 48122 +

 48123 +	# Check to see that this really is a libtool object.

 48124 +	if func_lalib_unsafe_p "$arg"; then

 48125 +	  pic_object=

 48126 +	  non_pic_object=

 48127 +

 48128 +	  # Read the .lo file

 48129 +	  func_source "$arg"

 48130 +

 48131 +	  if test -z "$pic_object" ||

 48132 +	     test -z "$non_pic_object" ||

 48133 +	     test "$pic_object" = none &&

 48134 +	     test "$non_pic_object" = none; then

 48135 +	    func_fatal_error "cannot find name of object for \`$arg'"

 48136 +	  fi

 48137 +

 48138 +	  # Extract subdirectory from the argument.

 48139 +	  func_dirname "$arg" "/" ""

 48140 +	  xdir="$func_dirname_result"

 48141 +

 48142 +	  if test "$pic_object" != none; then

 48143 +	    # Prepend the subdirectory the object is found in.

 48144 +	    pic_object="$xdir$pic_object"

 48145 +

 48146 +	    if test "$prev" = dlfiles; then

 48147 +	      if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then

 48148 +		dlfiles="$dlfiles $pic_object"

 48149 +		prev=

 48150 +		continue

 48151 +	      else

 48152 +		# If libtool objects are unsupported, then we need to preload.

 48153 +		prev=dlprefiles

 48154 +	      fi

 48155 +	    fi

 48156 +

 48157 +	    # CHECK ME:  I think I busted this.  -Ossama

 48158 +	    if test "$prev" = dlprefiles; then

 48159 +	      # Preload the old-style object.

 48160 +	      dlprefiles="$dlprefiles $pic_object"

 48161 +	      prev=

 48162 +	    fi

 48163 +

 48164 +	    # A PIC object.

 48165 +	    func_append libobjs " $pic_object"

 48166 +	    arg="$pic_object"

 48167 +	  fi

 48168 +

 48169 +	  # Non-PIC object.

 48170 +	  if test "$non_pic_object" != none; then

 48171 +	    # Prepend the subdirectory the object is found in.

 48172 +	    non_pic_object="$xdir$non_pic_object"

 48173 +

 48174 +	    # A standard non-PIC object

 48175 +	    func_append non_pic_objects " $non_pic_object"

 48176 +	    if test -z "$pic_object" || test "$pic_object" = none ; then

 48177 +	      arg="$non_pic_object"

 48178 +	    fi

 48179 +	  else

 48180 +	    # If the PIC object exists, use it instead.

 48181 +	    # $xdir was prepended to $pic_object above.

 48182 +	    non_pic_object="$pic_object"

 48183 +	    func_append non_pic_objects " $non_pic_object"

 48184 +	  fi

 48185 +	else

 48186 +	  # Only an error if not doing a dry-run.

 48187 +	  if $opt_dry_run; then

 48188 +	    # Extract subdirectory from the argument.

 48189 +	    func_dirname "$arg" "/" ""

 48190 +	    xdir="$func_dirname_result"

 48191 +

 48192 +	    func_lo2o "$arg"

 48193 +	    pic_object=$xdir$objdir/$func_lo2o_result

 48194 +	    non_pic_object=$xdir$func_lo2o_result

 48195 +	    func_append libobjs " $pic_object"

 48196 +	    func_append non_pic_objects " $non_pic_object"

 48197 +	  else

 48198 +	    func_fatal_error "\`$arg' is not a valid libtool object"

 48199 +	  fi

 48200 +	fi

 48201 +	;;

 48202 +

 48203 +      *.$libext)

 48204 +	# An archive.

 48205 +	deplibs="$deplibs $arg"

 48206 +	old_deplibs="$old_deplibs $arg"

 48207 +	continue

 48208 +	;;

 48209 +

 48210 +      *.la)

 48211 +	# A libtool-controlled library.

 48212 +

 48213 +	if test "$prev" = dlfiles; then

 48214 +	  # This library was specified with -dlopen.

 48215 +	  dlfiles="$dlfiles $arg"

 48216 +	  prev=

 48217 +	elif test "$prev" = dlprefiles; then

 48218 +	  # The library was specified with -dlpreopen.

 48219 +	  dlprefiles="$dlprefiles $arg"

 48220 +	  prev=

 48221 +	else

 48222 +	  deplibs="$deplibs $arg"

 48223 +	fi

 48224 +	continue

 48225 +	;;

 48226 +

 48227 +      # Some other compiler argument.

 48228 +      *)

 48229 +	# Unknown arguments in both finalize_command and compile_command need

 48230 +	# to be aesthetically quoted because they are evaled later.

 48231 +	func_quote_for_eval "$arg"

 48232 +	arg="$func_quote_for_eval_result"

 48233 +	;;

 48234 +      esac # arg

 48235 +

 48236 +      # Now actually substitute the argument into the commands.

 48237 +      if test -n "$arg"; then

 48238 +	func_append compile_command " $arg"

 48239 +	func_append finalize_command " $arg"

 48240 +      fi

 48241 +    done # argument parsing loop

 48242 +

 48243 +    test -n "$prev" && \

 48244 +      func_fatal_help "the \`$prevarg' option requires an argument"

 48245 +

 48246 +    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then

 48247 +      eval arg=\"$export_dynamic_flag_spec\"

 48248 +      func_append compile_command " $arg"

 48249 +      func_append finalize_command " $arg"

 48250 +    fi

 48251 +

 48252 +    oldlibs=

 48253 +    # calculate the name of the file, without its directory

 48254 +    func_basename "$output"

 48255 +    outputname="$func_basename_result"

 48256 +    libobjs_save="$libobjs"

 48257 +

 48258 +    if test -n "$shlibpath_var"; then

 48259 +      # get the directories listed in $shlibpath_var

 48260 +      eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`

 48261 +    else

 48262 +      shlib_search_path=

 48263 +    fi

 48264 +    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"

 48265 +    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"

 48266 +

 48267 +    func_dirname "$output" "/" ""

 48268 +    output_objdir="$func_dirname_result$objdir"

 48269 +    # Create the object directory.

 48270 +    func_mkdir_p "$output_objdir"

 48271 +

 48272 +    # Determine the type of output

 48273 +    case $output in

 48274 +    "")

 48275 +      func_fatal_help "you must specify an output file"

 48276 +      ;;

 48277 +    *.$libext) linkmode=oldlib ;;

 48278 +    *.lo | *.$objext) linkmode=obj ;;

 48279 +    *.la) linkmode=lib ;;

 48280 +    *) linkmode=prog ;; # Anything else should be a program.

 48281 +    esac

 48282 +

 48283 +    specialdeplibs=

 48284 +

 48285 +    libs=

 48286 +    # Find all interdependent deplibs by searching for libraries

 48287 +    # that are linked more than once (e.g. -la -lb -la)

 48288 +    for deplib in $deplibs; do

 48289 +      if $opt_duplicate_deps ; then

 48290 +	case "$libs " in

 48291 +	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

 48292 +	esac

 48293 +      fi

 48294 +      libs="$libs $deplib"

 48295 +    done

 48296 +

 48297 +    if test "$linkmode" = lib; then

 48298 +      libs="$predeps $libs $compiler_lib_search_path $postdeps"

 48299 +

 48300 +      # Compute libraries that are listed more than once in $predeps

 48301 +      # $postdeps and mark them as special (i.e., whose duplicates are

 48302 +      # not to be eliminated).

 48303 +      pre_post_deps=

 48304 +      if $opt_duplicate_compiler_generated_deps; then

 48305 +	for pre_post_dep in $predeps $postdeps; do

 48306 +	  case "$pre_post_deps " in

 48307 +	  *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;

 48308 +	  esac

 48309 +	  pre_post_deps="$pre_post_deps $pre_post_dep"

 48310 +	done

 48311 +      fi

 48312 +      pre_post_deps=

 48313 +    fi

 48314 +

 48315 +    deplibs=

 48316 +    newdependency_libs=

 48317 +    newlib_search_path=

 48318 +    need_relink=no # whether we're linking any uninstalled libtool libraries

 48319 +    notinst_deplibs= # not-installed libtool libraries

 48320 +    notinst_path= # paths that contain not-installed libtool libraries

 48321 +

 48322 +    case $linkmode in

 48323 +    lib)

 48324 +	passes="conv dlpreopen link"

 48325 +	for file in $dlfiles $dlprefiles; do

 48326 +	  case $file in

 48327 +	  *.la) ;;

 48328 +	  *)

 48329 +	    func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"

 48330 +	    ;;

 48331 +	  esac

 48332 +	done

 48333 +	;;

 48334 +    prog)

 48335 +	compile_deplibs=

 48336 +	finalize_deplibs=

 48337 +	alldeplibs=no

 48338 +	newdlfiles=

 48339 +	newdlprefiles=

 48340 +	passes="conv scan dlopen dlpreopen link"

 48341 +	;;

 48342 +    *)  passes="conv"

 48343 +	;;

 48344 +    esac

 48345 +

 48346 +    for pass in $passes; do

 48347 +      # The preopen pass in lib mode reverses $deplibs; put it back here

 48348 +      # so that -L comes before libs that need it for instance...

 48349 +      if test "$linkmode,$pass" = "lib,link"; then

 48350 +	## FIXME: Find the place where the list is rebuilt in the wrong

 48351 +	##        order, and fix it there properly

 48352 +        tmp_deplibs=

 48353 +	for deplib in $deplibs; do

 48354 +	  tmp_deplibs="$deplib $tmp_deplibs"

 48355 +	done

 48356 +	deplibs="$tmp_deplibs"

 48357 +      fi

 48358 +

 48359 +      if test "$linkmode,$pass" = "lib,link" ||

 48360 +	 test "$linkmode,$pass" = "prog,scan"; then

 48361 +	libs="$deplibs"

 48362 +	deplibs=

 48363 +      fi

 48364 +      if test "$linkmode" = prog; then

 48365 +	case $pass in

 48366 +	dlopen) libs="$dlfiles" ;;

 48367 +	dlpreopen) libs="$dlprefiles" ;;

 48368 +	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;

 48369 +	esac

 48370 +      fi

 48371 +      if test "$linkmode,$pass" = "lib,dlpreopen"; then

 48372 +	# Collect and forward deplibs of preopened libtool libs

 48373 +	for lib in $dlprefiles; do

 48374 +	  # Ignore non-libtool-libs

 48375 +	  dependency_libs=

 48376 +	  case $lib in

 48377 +	  *.la)	func_source "$lib" ;;

 48378 +	  esac

 48379 +

 48380 +	  # Collect preopened libtool deplibs, except any this library

 48381 +	  # has declared as weak libs

 48382 +	  for deplib in $dependency_libs; do

 48383 +            deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`

 48384 +	    case " $weak_libs " in

 48385 +	    *" $deplib_base "*) ;;

 48386 +	    *) deplibs="$deplibs $deplib" ;;

 48387 +	    esac

 48388 +	  done

 48389 +	done

 48390 +	libs="$dlprefiles"

 48391 +      fi

 48392 +      if test "$pass" = dlopen; then

 48393 +	# Collect dlpreopened libraries

 48394 +	save_deplibs="$deplibs"

 48395 +	deplibs=

 48396 +      fi

 48397 +

 48398 +      for deplib in $libs; do

 48399 +	lib=

 48400 +	found=no

 48401 +	case $deplib in

 48402 +	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)

 48403 +	  if test "$linkmode,$pass" = "prog,link"; then

 48404 +	    compile_deplibs="$deplib $compile_deplibs"

 48405 +	    finalize_deplibs="$deplib $finalize_deplibs"

 48406 +	  else

 48407 +	    compiler_flags="$compiler_flags $deplib"

 48408 +	    if test "$linkmode" = lib ; then

 48409 +		case "$new_inherited_linker_flags " in

 48410 +		    *" $deplib "*) ;;

 48411 +		    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;

 48412 +		esac

 48413 +	    fi

 48414 +	  fi

 48415 +	  continue

 48416 +	  ;;

 48417 +	-l*)

 48418 +	  if test "$linkmode" != lib && test "$linkmode" != prog; then

 48419 +	    func_warning "\`-l' is ignored for archives/objects"

 48420 +	    continue

 48421 +	  fi

 48422 +	  func_stripname '-l' '' "$deplib"

 48423 +	  name=$func_stripname_result

 48424 +	  for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do

 48425 +	    for search_ext in .la $std_shrext .so .a; do

 48426 +	      # Search the libtool library

 48427 +	      lib="$searchdir/lib${name}${search_ext}"

 48428 +	      if test -f "$lib"; then

 48429 +		if test "$search_ext" = ".la"; then

 48430 +		  found=yes

 48431 +		else

 48432 +		  found=no

 48433 +		fi

 48434 +		break 2

 48435 +	      fi

 48436 +	    done

 48437 +	  done

 48438 +	  if test "$found" != yes; then

 48439 +	    # deplib doesn't seem to be a libtool library

 48440 +	    if test "$linkmode,$pass" = "prog,link"; then

 48441 +	      compile_deplibs="$deplib $compile_deplibs"

 48442 +	      finalize_deplibs="$deplib $finalize_deplibs"

 48443 +	    else

 48444 +	      deplibs="$deplib $deplibs"

 48445 +	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

 48446 +	    fi

 48447 +	    continue

 48448 +	  else # deplib is a libtool library

 48449 +	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,

 48450 +	    # We need to do some special things here, and not later.

 48451 +	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

 48452 +	      case " $predeps $postdeps " in

 48453 +	      *" $deplib "*)

 48454 +		if func_lalib_p "$lib"; then

 48455 +		  library_names=

 48456 +		  old_library=

 48457 +		  func_source "$lib"

 48458 +		  for l in $old_library $library_names; do

 48459 +		    ll="$l"

 48460 +		  done

 48461 +		  if test "X$ll" = "X$old_library" ; then # only static version available

 48462 +		    found=no

 48463 +		    func_dirname "$lib" "" "."

 48464 +		    ladir="$func_dirname_result"

 48465 +		    lib=$ladir/$old_library

 48466 +		    if test "$linkmode,$pass" = "prog,link"; then

 48467 +		      compile_deplibs="$deplib $compile_deplibs"

 48468 +		      finalize_deplibs="$deplib $finalize_deplibs"

 48469 +		    else

 48470 +		      deplibs="$deplib $deplibs"

 48471 +		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

 48472 +		    fi

 48473 +		    continue

 48474 +		  fi

 48475 +		fi

 48476 +		;;

 48477 +	      *) ;;

 48478 +	      esac

 48479 +	    fi

 48480 +	  fi

 48481 +	  ;; # -l

 48482 +	*.ltframework)

 48483 +	  if test "$linkmode,$pass" = "prog,link"; then

 48484 +	    compile_deplibs="$deplib $compile_deplibs"

 48485 +	    finalize_deplibs="$deplib $finalize_deplibs"

 48486 +	  else

 48487 +	    deplibs="$deplib $deplibs"

 48488 +	    if test "$linkmode" = lib ; then

 48489 +		case "$new_inherited_linker_flags " in

 48490 +		    *" $deplib "*) ;;

 48491 +		    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;

 48492 +		esac

 48493 +	    fi

 48494 +	  fi

 48495 +	  continue

 48496 +	  ;;

 48497 +	-L*)

 48498 +	  case $linkmode in

 48499 +	  lib)

 48500 +	    deplibs="$deplib $deplibs"

 48501 +	    test "$pass" = conv && continue

 48502 +	    newdependency_libs="$deplib $newdependency_libs"

 48503 +	    func_stripname '-L' '' "$deplib"

 48504 +	    newlib_search_path="$newlib_search_path $func_stripname_result"

 48505 +	    ;;

 48506 +	  prog)

 48507 +	    if test "$pass" = conv; then

 48508 +	      deplibs="$deplib $deplibs"

 48509 +	      continue

 48510 +	    fi

 48511 +	    if test "$pass" = scan; then

 48512 +	      deplibs="$deplib $deplibs"

 48513 +	    else

 48514 +	      compile_deplibs="$deplib $compile_deplibs"

 48515 +	      finalize_deplibs="$deplib $finalize_deplibs"

 48516 +	    fi

 48517 +	    func_stripname '-L' '' "$deplib"

 48518 +	    newlib_search_path="$newlib_search_path $func_stripname_result"

 48519 +	    ;;

 48520 +	  *)

 48521 +	    func_warning "\`-L' is ignored for archives/objects"

 48522 +	    ;;

 48523 +	  esac # linkmode

 48524 +	  continue

 48525 +	  ;; # -L

 48526 +	-R*)

 48527 +	  if test "$pass" = link; then

 48528 +	    func_stripname '-R' '' "$deplib"

 48529 +	    dir=$func_stripname_result

 48530 +	    # Make sure the xrpath contains only unique directories.

 48531 +	    case "$xrpath " in

 48532 +	    *" $dir "*) ;;

 48533 +	    *) xrpath="$xrpath $dir" ;;

 48534 +	    esac

 48535 +	  fi

 48536 +	  deplibs="$deplib $deplibs"

 48537 +	  continue

 48538 +	  ;;

 48539 +	*.la) lib="$deplib" ;;

 48540 +	*.$libext)

 48541 +	  if test "$pass" = conv; then

 48542 +	    deplibs="$deplib $deplibs"

 48543 +	    continue

 48544 +	  fi

 48545 +	  case $linkmode in

 48546 +	  lib)

 48547 +	    # Linking convenience modules into shared libraries is allowed,

 48548 +	    # but linking other static libraries is non-portable.

 48549 +	    case " $dlpreconveniencelibs " in

 48550 +	    *" $deplib "*) ;;

 48551 +	    *)

 48552 +	      valid_a_lib=no

 48553 +	      case $deplibs_check_method in

 48554 +		match_pattern*)

 48555 +		  set dummy $deplibs_check_method; shift

 48556 +		  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`

 48557 +		  if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \

 48558 +		    | $EGREP "$match_pattern_regex" > /dev/null; then

 48559 +		    valid_a_lib=yes

 48560 +		  fi

 48561 +		;;

 48562 +		pass_all)

 48563 +		  valid_a_lib=yes

 48564 +		;;

 48565 +	      esac

 48566 +	      if test "$valid_a_lib" != yes; then

 48567 +		$ECHO

 48568 +		$ECHO "*** Warning: Trying to link with static lib archive $deplib."

 48569 +		$ECHO "*** I have the capability to make that library automatically link in when"

 48570 +		$ECHO "*** you link to this library.  But I can only do this if you have a"

 48571 +		$ECHO "*** shared version of the library, which you do not appear to have"

 48572 +		$ECHO "*** because the file extensions .$libext of this argument makes me believe"

 48573 +		$ECHO "*** that it is just a static archive that I should not use here."

 48574 +	      else

 48575 +		$ECHO

 48576 +		$ECHO "*** Warning: Linking the shared library $output against the"

 48577 +		$ECHO "*** static library $deplib is not portable!"

 48578 +		deplibs="$deplib $deplibs"

 48579 +	      fi

 48580 +	      ;;

 48581 +	    esac

 48582 +	    continue

 48583 +	    ;;

 48584 +	  prog)

 48585 +	    if test "$pass" != link; then

 48586 +	      deplibs="$deplib $deplibs"

 48587 +	    else

 48588 +	      compile_deplibs="$deplib $compile_deplibs"

 48589 +	      finalize_deplibs="$deplib $finalize_deplibs"

 48590 +	    fi

 48591 +	    continue

 48592 +	    ;;

 48593 +	  esac # linkmode

 48594 +	  ;; # *.$libext

 48595 +	*.lo | *.$objext)

 48596 +	  if test "$pass" = conv; then

 48597 +	    deplibs="$deplib $deplibs"

 48598 +	  elif test "$linkmode" = prog; then

 48599 +	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then

 48600 +	      # If there is no dlopen support or we're linking statically,

 48601 +	      # we need to preload.

 48602 +	      newdlprefiles="$newdlprefiles $deplib"

 48603 +	      compile_deplibs="$deplib $compile_deplibs"

 48604 +	      finalize_deplibs="$deplib $finalize_deplibs"

 48605 +	    else

 48606 +	      newdlfiles="$newdlfiles $deplib"

 48607 +	    fi

 48608 +	  fi

 48609 +	  continue

 48610 +	  ;;

 48611 +	%DEPLIBS%)

 48612 +	  alldeplibs=yes

 48613 +	  continue

 48614 +	  ;;

 48615 +	esac # case $deplib

 48616 +

 48617 +	if test "$found" = yes || test -f "$lib"; then :

 48618 +	else

 48619 +	  func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"

 48620 +	fi

 48621 +

 48622 +	# Check to see that this really is a libtool archive.

 48623 +	func_lalib_unsafe_p "$lib" \

 48624 +	  || func_fatal_error "\`$lib' is not a valid libtool archive"

 48625 +

 48626 +	func_dirname "$lib" "" "."

 48627 +	ladir="$func_dirname_result"

 48628 +

 48629 +	dlname=

 48630 +	dlopen=

 48631 +	dlpreopen=

 48632 +	libdir=

 48633 +	library_names=

 48634 +	old_library=

 48635 +	inherited_linker_flags=

 48636 +	# If the library was installed with an old release of libtool,

 48637 +	# it will not redefine variables installed, or shouldnotlink

 48638 +	installed=yes

 48639 +	shouldnotlink=no

 48640 +	avoidtemprpath=

 48641 +

 48642 +

 48643 +	# Read the .la file

 48644 +	func_source "$lib"

 48645 +

 48646 +	# Convert "-framework foo" to "foo.ltframework"

 48647 +	if test -n "$inherited_linker_flags"; then

 48648 +	  tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`

 48649 +	  for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do

 48650 +	    case " $new_inherited_linker_flags " in

 48651 +	      *" $tmp_inherited_linker_flag "*) ;;

 48652 +	      *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;

 48653 +	    esac

 48654 +	  done

 48655 +	fi

 48656 +	dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`

 48657 +	if test "$linkmode,$pass" = "prog,link"; then

 48658 +	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"

 48659 +	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"

 48660 +	else

 48661 +	  compiler_flags="$compiler_flags $inherited_linker_flags"

 48662 +	fi

 48663 +	if test "$linkmode,$pass" = "lib,link" ||

 48664 +	   test "$linkmode,$pass" = "prog,scan" ||

 48665 +	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then

 48666 +	  test -n "$dlopen" && dlfiles="$dlfiles $dlopen"

 48667 +	  test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"

 48668 +	fi

 48669 +

 48670 +	if test "$pass" = conv; then

 48671 +	  # Only check for convenience libraries

 48672 +	  deplibs="$lib $deplibs"

 48673 +	  if test -z "$libdir"; then

 48674 +	    if test -z "$old_library"; then

 48675 +	      func_fatal_error "cannot find name of link library for \`$lib'"

 48676 +	    fi

 48677 +	    # It is a libtool convenience library, so add in its objects.

 48678 +	    convenience="$convenience $ladir/$objdir/$old_library"

 48679 +	    old_convenience="$old_convenience $ladir/$objdir/$old_library"

 48680 +	  elif test "$linkmode" != prog && test "$linkmode" != lib; then

 48681 +	    func_fatal_error "\`$lib' is not a convenience library"

 48682 +	  fi

 48683 +	  tmp_libs=

 48684 +	  for deplib in $dependency_libs; do

 48685 +	    deplibs="$deplib $deplibs"

 48686 +	    if $opt_duplicate_deps ; then

 48687 +	      case "$tmp_libs " in

 48688 +	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

 48689 +	      esac

 48690 +	    fi

 48691 +	    tmp_libs="$tmp_libs $deplib"

 48692 +	  done

 48693 +	  continue

 48694 +	fi # $pass = conv

 48695 +

 48696 +

 48697 +	# Get the name of the library we link against.

 48698 +	linklib=

 48699 +	for l in $old_library $library_names; do

 48700 +	  linklib="$l"

 48701 +	done

 48702 +	if test -z "$linklib"; then

 48703 +	  func_fatal_error "cannot find name of link library for \`$lib'"

 48704 +	fi

 48705 +

 48706 +	# This library was specified with -dlopen.

 48707 +	if test "$pass" = dlopen; then

 48708 +	  if test -z "$libdir"; then

 48709 +	    func_fatal_error "cannot -dlopen a convenience library: \`$lib'"

 48710 +	  fi

 48711 +	  if test -z "$dlname" ||

 48712 +	     test "$dlopen_support" != yes ||

 48713 +	     test "$build_libtool_libs" = no; then

 48714 +	    # If there is no dlname, no dlopen support or we're linking

 48715 +	    # statically, we need to preload.  We also need to preload any

 48716 +	    # dependent libraries so libltdl's deplib preloader doesn't

 48717 +	    # bomb out in the load deplibs phase.

 48718 +	    dlprefiles="$dlprefiles $lib $dependency_libs"

 48719 +	  else

 48720 +	    newdlfiles="$newdlfiles $lib"

 48721 +	  fi

 48722 +	  continue

 48723 +	fi # $pass = dlopen

 48724 +

 48725 +	# We need an absolute path.

 48726 +	case $ladir in

 48727 +	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;

 48728 +	*)

 48729 +	  abs_ladir=`cd "$ladir" && pwd`

 48730 +	  if test -z "$abs_ladir"; then

 48731 +	    func_warning "cannot determine absolute directory name of \`$ladir'"

 48732 +	    func_warning "passing it literally to the linker, although it might fail"

 48733 +	    abs_ladir="$ladir"

 48734 +	  fi

 48735 +	  ;;

 48736 +	esac

 48737 +	func_basename "$lib"

 48738 +	laname="$func_basename_result"

 48739 +

 48740 +	# Find the relevant object directory and library name.

 48741 +	if test "X$installed" = Xyes; then

 48742 +	  if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then

 48743 +	    func_warning "library \`$lib' was moved."

 48744 +	    dir="$ladir"

 48745 +	    absdir="$abs_ladir"

 48746 +	    libdir="$abs_ladir"

 48747 +	  else

 48748 +	    dir="$libdir"

 48749 +	    absdir="$libdir"

 48750 +	  fi

 48751 +	  test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes

 48752 +	else

 48753 +	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then

 48754 +	    dir="$ladir"

 48755 +	    absdir="$abs_ladir"

 48756 +	    # Remove this search path later

 48757 +	    notinst_path="$notinst_path $abs_ladir"

 48758 +	  else

 48759 +	    dir="$ladir/$objdir"

 48760 +	    absdir="$abs_ladir/$objdir"

 48761 +	    # Remove this search path later

 48762 +	    notinst_path="$notinst_path $abs_ladir"

 48763 +	  fi

 48764 +	fi # $installed = yes

 48765 +	func_stripname 'lib' '.la' "$laname"

 48766 +	name=$func_stripname_result

 48767 +

 48768 +	# This library was specified with -dlpreopen.

 48769 +	if test "$pass" = dlpreopen; then

 48770 +	  if test -z "$libdir" && test "$linkmode" = prog; then

 48771 +	    func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"

 48772 +	  fi

 48773 +	  # Prefer using a static library (so that no silly _DYNAMIC symbols

 48774 +	  # are required to link).

 48775 +	  if test -n "$old_library"; then

 48776 +	    newdlprefiles="$newdlprefiles $dir/$old_library"

 48777 +	    # Keep a list of preopened convenience libraries to check

 48778 +	    # that they are being used correctly in the link pass.

 48779 +	    test -z "$libdir" && \

 48780 +		dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"

 48781 +	  # Otherwise, use the dlname, so that lt_dlopen finds it.

 48782 +	  elif test -n "$dlname"; then

 48783 +	    newdlprefiles="$newdlprefiles $dir/$dlname"

 48784 +	  else

 48785 +	    newdlprefiles="$newdlprefiles $dir/$linklib"

 48786 +	  fi

 48787 +	fi # $pass = dlpreopen

 48788 +

 48789 +	if test -z "$libdir"; then

 48790 +	  # Link the convenience library

 48791 +	  if test "$linkmode" = lib; then

 48792 +	    deplibs="$dir/$old_library $deplibs"

 48793 +	  elif test "$linkmode,$pass" = "prog,link"; then

 48794 +	    compile_deplibs="$dir/$old_library $compile_deplibs"

 48795 +	    finalize_deplibs="$dir/$old_library $finalize_deplibs"

 48796 +	  else

 48797 +	    deplibs="$lib $deplibs" # used for prog,scan pass

 48798 +	  fi

 48799 +	  continue

 48800 +	fi

 48801 +

 48802 +

 48803 +	if test "$linkmode" = prog && test "$pass" != link; then

 48804 +	  newlib_search_path="$newlib_search_path $ladir"

 48805 +	  deplibs="$lib $deplibs"

 48806 +

 48807 +	  linkalldeplibs=no

 48808 +	  if test "$link_all_deplibs" != no || test -z "$library_names" ||

 48809 +	     test "$build_libtool_libs" = no; then

 48810 +	    linkalldeplibs=yes

 48811 +	  fi

 48812 +

 48813 +	  tmp_libs=

 48814 +	  for deplib in $dependency_libs; do

 48815 +	    case $deplib in

 48816 +	    -L*) func_stripname '-L' '' "$deplib"

 48817 +	         newlib_search_path="$newlib_search_path $func_stripname_result"

 48818 +		 ;;

 48819 +	    esac

 48820 +	    # Need to link against all dependency_libs?

 48821 +	    if test "$linkalldeplibs" = yes; then

 48822 +	      deplibs="$deplib $deplibs"

 48823 +	    else

 48824 +	      # Need to hardcode shared library paths

 48825 +	      # or/and link against static libraries

 48826 +	      newdependency_libs="$deplib $newdependency_libs"

 48827 +	    fi

 48828 +	    if $opt_duplicate_deps ; then

 48829 +	      case "$tmp_libs " in

 48830 +	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

 48831 +	      esac

 48832 +	    fi

 48833 +	    tmp_libs="$tmp_libs $deplib"

 48834 +	  done # for deplib

 48835 +	  continue

 48836 +	fi # $linkmode = prog...

 48837 +

 48838 +	if test "$linkmode,$pass" = "prog,link"; then

 48839 +	  if test -n "$library_names" &&

 48840 +	     { { test "$prefer_static_libs" = no ||

 48841 +	         test "$prefer_static_libs,$installed" = "built,yes"; } ||

 48842 +	       test -z "$old_library"; }; then

 48843 +	    # We need to hardcode the library path

 48844 +	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then

 48845 +	      # Make sure the rpath contains only unique directories.

 48846 +	      case "$temp_rpath:" in

 48847 +	      *"$absdir:"*) ;;

 48848 +	      *) temp_rpath="$temp_rpath$absdir:" ;;

 48849 +	      esac

 48850 +	    fi

 48851 +

 48852 +	    # Hardcode the library path.

 48853 +	    # Skip directories that are in the system default run-time

 48854 +	    # search path.

 48855 +	    case " $sys_lib_dlsearch_path " in

 48856 +	    *" $absdir "*) ;;

 48857 +	    *)

 48858 +	      case "$compile_rpath " in

 48859 +	      *" $absdir "*) ;;

 48860 +	      *) compile_rpath="$compile_rpath $absdir"

 48861 +	      esac

 48862 +	      ;;

 48863 +	    esac

 48864 +	    case " $sys_lib_dlsearch_path " in

 48865 +	    *" $libdir "*) ;;

 48866 +	    *)

 48867 +	      case "$finalize_rpath " in

 48868 +	      *" $libdir "*) ;;

 48869 +	      *) finalize_rpath="$finalize_rpath $libdir"

 48870 +	      esac

 48871 +	      ;;

 48872 +	    esac

 48873 +	  fi # $linkmode,$pass = prog,link...

 48874 +

 48875 +	  if test "$alldeplibs" = yes &&

 48876 +	     { test "$deplibs_check_method" = pass_all ||

 48877 +	       { test "$build_libtool_libs" = yes &&

 48878 +		 test -n "$library_names"; }; }; then

 48879 +	    # We only need to search for static libraries

 48880 +	    continue

 48881 +	  fi

 48882 +	fi

 48883 +

 48884 +	link_static=no # Whether the deplib will be linked statically

 48885 +	use_static_libs=$prefer_static_libs

 48886 +	if test "$use_static_libs" = built && test "$installed" = yes; then

 48887 +	  use_static_libs=no

 48888 +	fi

 48889 +	if test -n "$library_names" &&

 48890 +	   { test "$use_static_libs" = no || test -z "$old_library"; }; then

 48891 +	  case $host in

 48892 +	  *cygwin* | *mingw*)

 48893 +	      # No point in relinking DLLs because paths are not encoded

 48894 +	      notinst_deplibs="$notinst_deplibs $lib"

 48895 +	      need_relink=no

 48896 +	    ;;

 48897 +	  *)

 48898 +	    if test "$installed" = no; then

 48899 +	      notinst_deplibs="$notinst_deplibs $lib"

 48900 +	      need_relink=yes

 48901 +	    fi

 48902 +	    ;;

 48903 +	  esac

 48904 +	  # This is a shared library

 48905 +

 48906 +	  # Warn about portability, can't link against -module's on some

 48907 +	  # systems (darwin).  Don't bleat about dlopened modules though!

 48908 +	  dlopenmodule=""

 48909 +	  for dlpremoduletest in $dlprefiles; do

 48910 +	    if test "X$dlpremoduletest" = "X$lib"; then

 48911 +	      dlopenmodule="$dlpremoduletest"

 48912 +	      break

 48913 +	    fi

 48914 +	  done

 48915 +	  if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then

 48916 +	    $ECHO

 48917 +	    if test "$linkmode" = prog; then

 48918 +	      $ECHO "*** Warning: Linking the executable $output against the loadable module"

 48919 +	    else

 48920 +	      $ECHO "*** Warning: Linking the shared library $output against the loadable module"

 48921 +	    fi

 48922 +	    $ECHO "*** $linklib is not portable!"

 48923 +	  fi

 48924 +	  if test "$linkmode" = lib &&

 48925 +	     test "$hardcode_into_libs" = yes; then

 48926 +	    # Hardcode the library path.

 48927 +	    # Skip directories that are in the system default run-time

 48928 +	    # search path.

 48929 +	    case " $sys_lib_dlsearch_path " in

 48930 +	    *" $absdir "*) ;;

 48931 +	    *)

 48932 +	      case "$compile_rpath " in

 48933 +	      *" $absdir "*) ;;

 48934 +	      *) compile_rpath="$compile_rpath $absdir"

 48935 +	      esac

 48936 +	      ;;

 48937 +	    esac

 48938 +	    case " $sys_lib_dlsearch_path " in

 48939 +	    *" $libdir "*) ;;

 48940 +	    *)

 48941 +	      case "$finalize_rpath " in

 48942 +	      *" $libdir "*) ;;

 48943 +	      *) finalize_rpath="$finalize_rpath $libdir"

 48944 +	      esac

 48945 +	      ;;

 48946 +	    esac

 48947 +	  fi

 48948 +

 48949 +	  if test -n "$old_archive_from_expsyms_cmds"; then

 48950 +	    # figure out the soname

 48951 +	    set dummy $library_names

 48952 +	    shift

 48953 +	    realname="$1"

 48954 +	    shift

 48955 +	    libname=`eval "\\$ECHO \"$libname_spec\""`

 48956 +	    # use dlname if we got it. it's perfectly good, no?

 48957 +	    if test -n "$dlname"; then

 48958 +	      soname="$dlname"

 48959 +	    elif test -n "$soname_spec"; then

 48960 +	      # bleh windows

 48961 +	      case $host in

 48962 +	      *cygwin* | mingw*)

 48963 +		major=`expr $current - $age`

 48964 +		versuffix="-$major"

 48965 +		;;

 48966 +	      esac

 48967 +	      eval soname=\"$soname_spec\"

 48968 +	    else

 48969 +	      soname="$realname"

 48970 +	    fi

 48971 +

 48972 +	    # Make a new name for the extract_expsyms_cmds to use

 48973 +	    soroot="$soname"

 48974 +	    func_basename "$soroot"

 48975 +	    soname="$func_basename_result"

 48976 +	    func_stripname 'lib' '.dll' "$soname"

 48977 +	    newlib=libimp-$func_stripname_result.a

 48978 +

 48979 +	    # If the library has no export list, then create one now

 48980 +	    if test -f "$output_objdir/$soname-def"; then :

 48981 +	    else

 48982 +	      func_echo "extracting exported symbol list from \`$soname'"

 48983 +	      func_execute_cmds "$extract_expsyms_cmds" 'exit $?'

 48984 +	    fi

 48985 +

 48986 +	    # Create $newlib

 48987 +	    if test -f "$output_objdir/$newlib"; then :; else

 48988 +	      func_echo "generating import library for \`$soname'"

 48989 +	      func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'

 48990 +	    fi

 48991 +	    # make sure the library variables are pointing to the new library

 48992 +	    dir=$output_objdir

 48993 +	    linklib=$newlib

 48994 +	  fi # test -n "$old_archive_from_expsyms_cmds"

 48995 +

 48996 +	  if test "$linkmode" = prog || test "$mode" != relink; then

 48997 +	    add_shlibpath=

 48998 +	    add_dir=

 48999 +	    add=

 49000 +	    lib_linked=yes

 49001 +	    case $hardcode_action in

 49002 +	    immediate | unsupported)

 49003 +	      if test "$hardcode_direct" = no; then

 49004 +		add="$dir/$linklib"

 49005 +		case $host in

 49006 +		  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;

 49007 +		  *-*-sysv4*uw2*) add_dir="-L$dir" ;;

 49008 +		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \

 49009 +		    *-*-unixware7*) add_dir="-L$dir" ;;

 49010 +		  *-*-darwin* )

 49011 +		    # if the lib is a (non-dlopened) module then we can not

 49012 +		    # link against it, someone is ignoring the earlier warnings

 49013 +		    if /usr/bin/file -L $add 2> /dev/null |

 49014 +			 $GREP ": [^:]* bundle" >/dev/null ; then

 49015 +		      if test "X$dlopenmodule" != "X$lib"; then

 49016 +			$ECHO "*** Warning: lib $linklib is a module, not a shared library"

 49017 +			if test -z "$old_library" ; then

 49018 +			  $ECHO

 49019 +			  $ECHO "*** And there doesn't seem to be a static archive available"

 49020 +			  $ECHO "*** The link will probably fail, sorry"

 49021 +			else

 49022 +			  add="$dir/$old_library"

 49023 +			fi

 49024 +		      elif test -n "$old_library"; then

 49025 +			add="$dir/$old_library"

 49026 +		      fi

 49027 +		    fi

 49028 +		esac

 49029 +	      elif test "$hardcode_minus_L" = no; then

 49030 +		case $host in

 49031 +		*-*-sunos*) add_shlibpath="$dir" ;;

 49032 +		esac

 49033 +		add_dir="-L$dir"

 49034 +		add="-l$name"

 49035 +	      elif test "$hardcode_shlibpath_var" = no; then

 49036 +		add_shlibpath="$dir"

 49037 +		add="-l$name"

 49038 +	      else

 49039 +		lib_linked=no

 49040 +	      fi

 49041 +	      ;;

 49042 +	    relink)

 49043 +	      if test "$hardcode_direct" = yes &&

 49044 +	         test "$hardcode_direct_absolute" = no; then

 49045 +		add="$dir/$linklib"

 49046 +	      elif test "$hardcode_minus_L" = yes; then

 49047 +		add_dir="-L$dir"

 49048 +		# Try looking first in the location we're being installed to.

 49049 +		if test -n "$inst_prefix_dir"; then

 49050 +		  case $libdir in

 49051 +		    [\\/]*)

 49052 +		      add_dir="$add_dir -L$inst_prefix_dir$libdir"

 49053 +		      ;;

 49054 +		  esac

 49055 +		fi

 49056 +		add="-l$name"

 49057 +	      elif test "$hardcode_shlibpath_var" = yes; then

 49058 +		add_shlibpath="$dir"

 49059 +		add="-l$name"

 49060 +	      else

 49061 +		lib_linked=no

 49062 +	      fi

 49063 +	      ;;

 49064 +	    *) lib_linked=no ;;

 49065 +	    esac

 49066 +

 49067 +	    if test "$lib_linked" != yes; then

 49068 +	      func_fatal_configuration "unsupported hardcode properties"

 49069 +	    fi

 49070 +

 49071 +	    if test -n "$add_shlibpath"; then

 49072 +	      case :$compile_shlibpath: in

 49073 +	      *":$add_shlibpath:"*) ;;

 49074 +	      *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;

 49075 +	      esac

 49076 +	    fi

 49077 +	    if test "$linkmode" = prog; then

 49078 +	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"

 49079 +	      test -n "$add" && compile_deplibs="$add $compile_deplibs"

 49080 +	    else

 49081 +	      test -n "$add_dir" && deplibs="$add_dir $deplibs"

 49082 +	      test -n "$add" && deplibs="$add $deplibs"

 49083 +	      if test "$hardcode_direct" != yes &&

 49084 +		 test "$hardcode_minus_L" != yes &&

 49085 +		 test "$hardcode_shlibpath_var" = yes; then

 49086 +		case :$finalize_shlibpath: in

 49087 +		*":$libdir:"*) ;;

 49088 +		*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;

 49089 +		esac

 49090 +	      fi

 49091 +	    fi

 49092 +	  fi

 49093 +

 49094 +	  if test "$linkmode" = prog || test "$mode" = relink; then

 49095 +	    add_shlibpath=

 49096 +	    add_dir=

 49097 +	    add=

 49098 +	    # Finalize command for both is simple: just hardcode it.

 49099 +	    if test "$hardcode_direct" = yes &&

 49100 +	       test "$hardcode_direct_absolute" = no; then

 49101 +	      add="$libdir/$linklib"

 49102 +	    elif test "$hardcode_minus_L" = yes; then

 49103 +	      add_dir="-L$libdir"

 49104 +	      add="-l$name"

 49105 +	    elif test "$hardcode_shlibpath_var" = yes; then

 49106 +	      case :$finalize_shlibpath: in

 49107 +	      *":$libdir:"*) ;;

 49108 +	      *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;

 49109 +	      esac

 49110 +	      add="-l$name"

 49111 +	    elif test "$hardcode_automatic" = yes; then

 49112 +	      if test -n "$inst_prefix_dir" &&

 49113 +		 test -f "$inst_prefix_dir$libdir/$linklib" ; then

 49114 +		add="$inst_prefix_dir$libdir/$linklib"

 49115 +	      else

 49116 +		add="$libdir/$linklib"

 49117 +	      fi

 49118 +	    else

 49119 +	      # We cannot seem to hardcode it, guess we'll fake it.

 49120 +	      add_dir="-L$libdir"

 49121 +	      # Try looking first in the location we're being installed to.

 49122 +	      if test -n "$inst_prefix_dir"; then

 49123 +		case $libdir in

 49124 +		  [\\/]*)

 49125 +		    add_dir="$add_dir -L$inst_prefix_dir$libdir"

 49126 +		    ;;

 49127 +		esac

 49128 +	      fi

 49129 +	      add="-l$name"

 49130 +	    fi

 49131 +

 49132 +	    if test "$linkmode" = prog; then

 49133 +	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"

 49134 +	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"

 49135 +	    else

 49136 +	      test -n "$add_dir" && deplibs="$add_dir $deplibs"

 49137 +	      test -n "$add" && deplibs="$add $deplibs"

 49138 +	    fi

 49139 +	  fi

 49140 +	elif test "$linkmode" = prog; then

 49141 +	  # Here we assume that one of hardcode_direct or hardcode_minus_L

 49142 +	  # is not unsupported.  This is valid on all known static and

 49143 +	  # shared platforms.

 49144 +	  if test "$hardcode_direct" != unsupported; then

 49145 +	    test -n "$old_library" && linklib="$old_library"

 49146 +	    compile_deplibs="$dir/$linklib $compile_deplibs"

 49147 +	    finalize_deplibs="$dir/$linklib $finalize_deplibs"

 49148 +	  else

 49149 +	    compile_deplibs="-l$name -L$dir $compile_deplibs"

 49150 +	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"

 49151 +	  fi

 49152 +	elif test "$build_libtool_libs" = yes; then

 49153 +	  # Not a shared library

 49154 +	  if test "$deplibs_check_method" != pass_all; then

 49155 +	    # We're trying link a shared library against a static one

 49156 +	    # but the system doesn't support it.

 49157 +

 49158 +	    # Just print a warning and add the library to dependency_libs so

 49159 +	    # that the program can be linked against the static library.

 49160 +	    $ECHO

 49161 +	    $ECHO "*** Warning: This system can not link to static lib archive $lib."

 49162 +	    $ECHO "*** I have the capability to make that library automatically link in when"

 49163 +	    $ECHO "*** you link to this library.  But I can only do this if you have a"

 49164 +	    $ECHO "*** shared version of the library, which you do not appear to have."

 49165 +	    if test "$module" = yes; then

 49166 +	      $ECHO "*** But as you try to build a module library, libtool will still create "

 49167 +	      $ECHO "*** a static module, that should work as long as the dlopening application"

 49168 +	      $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."

 49169 +	      if test -z "$global_symbol_pipe"; then

 49170 +		$ECHO

 49171 +		$ECHO "*** However, this would only work if libtool was able to extract symbol"

 49172 +		$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"

 49173 +		$ECHO "*** not find such a program.  So, this module is probably useless."

 49174 +		$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."

 49175 +	      fi

 49176 +	      if test "$build_old_libs" = no; then

 49177 +		build_libtool_libs=module

 49178 +		build_old_libs=yes

 49179 +	      else

 49180 +		build_libtool_libs=no

 49181 +	      fi

 49182 +	    fi

 49183 +	  else

 49184 +	    deplibs="$dir/$old_library $deplibs"

 49185 +	    link_static=yes

 49186 +	  fi

 49187 +	fi # link shared/static library?

 49188 +

 49189 +	if test "$linkmode" = lib; then

 49190 +	  if test -n "$dependency_libs" &&

 49191 +	     { test "$hardcode_into_libs" != yes ||

 49192 +	       test "$build_old_libs" = yes ||

 49193 +	       test "$link_static" = yes; }; then

 49194 +	    # Extract -R from dependency_libs

 49195 +	    temp_deplibs=

 49196 +	    for libdir in $dependency_libs; do

 49197 +	      case $libdir in

 49198 +	      -R*) func_stripname '-R' '' "$libdir"

 49199 +	           temp_xrpath=$func_stripname_result

 49200 +		   case " $xrpath " in

 49201 +		   *" $temp_xrpath "*) ;;

 49202 +		   *) xrpath="$xrpath $temp_xrpath";;

 49203 +		   esac;;

 49204 +	      *) temp_deplibs="$temp_deplibs $libdir";;

 49205 +	      esac

 49206 +	    done

 49207 +	    dependency_libs="$temp_deplibs"

 49208 +	  fi

 49209 +

 49210 +	  newlib_search_path="$newlib_search_path $absdir"

 49211 +	  # Link against this library

 49212 +	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"

 49213 +	  # ... and its dependency_libs

 49214 +	  tmp_libs=

 49215 +	  for deplib in $dependency_libs; do

 49216 +	    newdependency_libs="$deplib $newdependency_libs"

 49217 +	    if $opt_duplicate_deps ; then

 49218 +	      case "$tmp_libs " in

 49219 +	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

 49220 +	      esac

 49221 +	    fi

 49222 +	    tmp_libs="$tmp_libs $deplib"

 49223 +	  done

 49224 +

 49225 +	  if test "$link_all_deplibs" != no; then

 49226 +	    # Add the search paths of all dependency libraries

 49227 +	    for deplib in $dependency_libs; do

 49228 +	      case $deplib in

 49229 +	      -L*) path="$deplib" ;;

 49230 +	      *.la)

 49231 +	        func_dirname "$deplib" "" "."

 49232 +		dir="$func_dirname_result"

 49233 +		# We need an absolute path.

 49234 +		case $dir in

 49235 +		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;

 49236 +		*)

 49237 +		  absdir=`cd "$dir" && pwd`

 49238 +		  if test -z "$absdir"; then

 49239 +		    func_warning "cannot determine absolute directory name of \`$dir'"

 49240 +		    absdir="$dir"

 49241 +		  fi

 49242 +		  ;;

 49243 +		esac

 49244 +		if $GREP "^installed=no" $deplib > /dev/null; then

 49245 +		case $host in

 49246 +		*-*-darwin*)

 49247 +		  depdepl=

 49248 +		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`

 49249 +		  if test -n "$deplibrary_names" ; then

 49250 +		    for tmp in $deplibrary_names ; do

 49251 +		      depdepl=$tmp

 49252 +		    done

 49253 +		    if test -f "$absdir/$objdir/$depdepl" ; then

 49254 +		      depdepl="$absdir/$objdir/$depdepl"

 49255 +		      darwin_install_name=`otool -L $depdepl | $SED -n -e '3q;2,2p' | $SED -e 's/(.*//'`

 49256 +		      darwin_install_name=`$ECHO $darwin_install_name`

 49257 +                      if test -z "$darwin_install_name"; then

 49258 +                          darwin_install_name=`otool64 -L $depdepl | $SED -n -e '3q;2,2p' | $SED -e 's/(.*//'`

 49259 +                          darwin_install_name=`$ECHO $darwin_install_name`

 49260 +                      fi

 49261 +		      compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"

 49262 +		      linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"

 49263 +		      path=

 49264 +		    fi

 49265 +		  fi

 49266 +		  ;;

 49267 +		*)

 49268 +		  path="-L$absdir/$objdir"

 49269 +		  ;;

 49270 +		esac

 49271 +		else

 49272 +		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`

 49273 +		  test -z "$libdir" && \

 49274 +		    func_fatal_error "\`$deplib' is not a valid libtool archive"

 49275 +		  test "$absdir" != "$libdir" && \

 49276 +		    func_warning "\`$deplib' seems to be moved"

 49277 +

 49278 +		  path="-L$absdir"

 49279 +		fi

 49280 +		;;

 49281 +	      esac

 49282 +	      case " $deplibs " in

 49283 +	      *" $path "*) ;;

 49284 +	      *) deplibs="$path $deplibs" ;;

 49285 +	      esac

 49286 +	    done

 49287 +	  fi # link_all_deplibs != no

 49288 +	fi # linkmode = lib

 49289 +      done # for deplib in $libs

 49290 +      dependency_libs="$newdependency_libs"

 49291 +      if test "$pass" = dlpreopen; then

 49292 +	# Link the dlpreopened libraries before other libraries

 49293 +	for deplib in $save_deplibs; do

 49294 +	  deplibs="$deplib $deplibs"

 49295 +	done

 49296 +      fi

 49297 +      if test "$pass" != dlopen; then

 49298 +	if test "$pass" != conv; then

 49299 +	  # Make sure lib_search_path contains only unique directories.

 49300 +	  lib_search_path=

 49301 +	  for dir in $newlib_search_path; do

 49302 +	    case "$lib_search_path " in

 49303 +	    *" $dir "*) ;;

 49304 +	    *) lib_search_path="$lib_search_path $dir" ;;

 49305 +	    esac

 49306 +	  done

 49307 +	  newlib_search_path=

 49308 +	fi

 49309 +

 49310 +	if test "$linkmode,$pass" != "prog,link"; then

 49311 +	  vars="deplibs"

 49312 +	else

 49313 +	  vars="compile_deplibs finalize_deplibs"

 49314 +	fi

 49315 +	for var in $vars dependency_libs; do

 49316 +	  # Add libraries to $var in reverse order

 49317 +	  eval tmp_libs=\"\$$var\"

 49318 +	  new_libs=

 49319 +	  for deplib in $tmp_libs; do

 49320 +	    # FIXME: Pedantically, this is the right thing to do, so

 49321 +	    #        that some nasty dependency loop isn't accidentally

 49322 +	    #        broken:

 49323 +	    #new_libs="$deplib $new_libs"

 49324 +	    # Pragmatically, this seems to cause very few problems in

 49325 +	    # practice:

 49326 +	    case $deplib in

 49327 +	    -L*) new_libs="$deplib $new_libs" ;;

 49328 +	    -R*) ;;

 49329 +	    *)

 49330 +	      # And here is the reason: when a library appears more

 49331 +	      # than once as an explicit dependence of a library, or

 49332 +	      # is implicitly linked in more than once by the

 49333 +	      # compiler, it is considered special, and multiple

 49334 +	      # occurrences thereof are not removed.  Compare this

 49335 +	      # with having the same library being listed as a

 49336 +	      # dependency of multiple other libraries: in this case,

 49337 +	      # we know (pedantically, we assume) the library does not

 49338 +	      # need to be listed more than once, so we keep only the

 49339 +	      # last copy.  This is not always right, but it is rare

 49340 +	      # enough that we require users that really mean to play

 49341 +	      # such unportable linking tricks to link the library

 49342 +	      # using -Wl,-lname, so that libtool does not consider it

 49343 +	      # for duplicate removal.

 49344 +	      case " $specialdeplibs " in

 49345 +	      *" $deplib "*) new_libs="$deplib $new_libs" ;;

 49346 +	      *)

 49347 +		case " $new_libs " in

 49348 +		*" $deplib "*) ;;

 49349 +		*) new_libs="$deplib $new_libs" ;;

 49350 +		esac

 49351 +		;;

 49352 +	      esac

 49353 +	      ;;

 49354 +	    esac

 49355 +	  done

 49356 +	  tmp_libs=

 49357 +	  for deplib in $new_libs; do

 49358 +	    case $deplib in

 49359 +	    -L*)

 49360 +	      case " $tmp_libs " in

 49361 +	      *" $deplib "*) ;;

 49362 +	      *) tmp_libs="$tmp_libs $deplib" ;;

 49363 +	      esac

 49364 +	      ;;

 49365 +	    *) tmp_libs="$tmp_libs $deplib" ;;

 49366 +	    esac

 49367 +	  done

 49368 +	  eval $var=\"$tmp_libs\"

 49369 +	done # for var

 49370 +      fi

 49371 +      # Last step: remove runtime libs from dependency_libs

 49372 +      # (they stay in deplibs)

 49373 +      tmp_libs=

 49374 +      for i in $dependency_libs ; do

 49375 +	case " $predeps $postdeps $compiler_lib_search_path " in

 49376 +	*" $i "*)

 49377 +	  i=""

 49378 +	  ;;

 49379 +	esac

 49380 +	if test -n "$i" ; then

 49381 +	  tmp_libs="$tmp_libs $i"

 49382 +	fi

 49383 +      done

 49384 +      dependency_libs=$tmp_libs

 49385 +    done # for pass

 49386 +    if test "$linkmode" = prog; then

 49387 +      dlfiles="$newdlfiles"

 49388 +    fi

 49389 +    if test "$linkmode" = prog || test "$linkmode" = lib; then

 49390 +      dlprefiles="$newdlprefiles"

 49391 +    fi

 49392 +

 49393 +    case $linkmode in

 49394 +    oldlib)

 49395 +      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

 49396 +	func_warning "\`-dlopen' is ignored for archives"

 49397 +      fi

 49398 +

 49399 +      test -n "$deplibs" && \

 49400 +	func_warning "\`-l' and \`-L' are ignored for archives"

 49401 +

 49402 +

 49403 +      test -n "$rpath" && \

 49404 +	func_warning "\`-rpath' is ignored for archives"

 49405 +

 49406 +      test -n "$xrpath" && \

 49407 +	func_warning "\`-R' is ignored for archives"

 49408 +

 49409 +      test -n "$vinfo" && \

 49410 +	func_warning "\`-version-info/-version-number' is ignored for archives"

 49411 +

 49412 +      test -n "$release" && \

 49413 +	func_warning "\`-release' is ignored for archives"

 49414 +

 49415 +      test -n "$export_symbols$export_symbols_regex" && \

 49416 +	func_warning "\`-export-symbols' is ignored for archives"

 49417 +

 49418 +      # Now set the variables for building old libraries.

 49419 +      build_libtool_libs=no

 49420 +      oldlibs="$output"

 49421 +      objs="$objs$old_deplibs"

 49422 +      ;;

 49423 +

 49424 +    lib)

 49425 +      # Make sure we only generate libraries of the form `libNAME.la'.

 49426 +      case $outputname in

 49427 +      lib*)

 49428 +	func_stripname 'lib' '.la' "$outputname"

 49429 +	name=$func_stripname_result

 49430 +	eval shared_ext=\"$shrext_cmds\"

 49431 +	eval libname=\"$libname_spec\"

 49432 +	;;

 49433 +      *)

 49434 +	test "$module" = no && \

 49435 +	  func_fatal_help "libtool library \`$output' must begin with \`lib'"

 49436 +

 49437 +	if test "$need_lib_prefix" != no; then

 49438 +	  # Add the "lib" prefix for modules if required

 49439 +	  func_stripname '' '.la' "$outputname"

 49440 +	  name=$func_stripname_result

 49441 +	  eval shared_ext=\"$shrext_cmds\"

 49442 +	  eval libname=\"$libname_spec\"

 49443 +	else

 49444 +	  func_stripname '' '.la' "$outputname"

 49445 +	  libname=$func_stripname_result

 49446 +	fi

 49447 +	;;

 49448 +      esac

 49449 +

 49450 +      if test -n "$objs"; then

 49451 +	if test "$deplibs_check_method" != pass_all; then

 49452 +	  func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"

 49453 +	else

 49454 +	  $ECHO

 49455 +	  $ECHO "*** Warning: Linking the shared library $output against the non-libtool"

 49456 +	  $ECHO "*** objects $objs is not portable!"

 49457 +	  libobjs="$libobjs $objs"

 49458 +	fi

 49459 +      fi

 49460 +

 49461 +      test "$dlself" != no && \

 49462 +	func_warning "\`-dlopen self' is ignored for libtool libraries"

 49463 +

 49464 +      set dummy $rpath

 49465 +      shift

 49466 +      test "$#" -gt 1 && \

 49467 +	func_warning "ignoring multiple \`-rpath's for a libtool library"

 49468 +

 49469 +      install_libdir="$1"

 49470 +

 49471 +      oldlibs=

 49472 +      if test -z "$rpath"; then

 49473 +	if test "$build_libtool_libs" = yes; then

 49474 +	  # Building a libtool convenience library.

 49475 +	  # Some compilers have problems with a `.al' extension so

 49476 +	  # convenience libraries should have the same extension an

 49477 +	  # archive normally would.

 49478 +	  oldlibs="$output_objdir/$libname.$libext $oldlibs"

 49479 +	  build_libtool_libs=convenience

 49480 +	  build_old_libs=yes

 49481 +	fi

 49482 +

 49483 +	test -n "$vinfo" && \

 49484 +	  func_warning "\`-version-info/-version-number' is ignored for convenience libraries"

 49485 +

 49486 +	test -n "$release" && \

 49487 +	  func_warning "\`-release' is ignored for convenience libraries"

 49488 +      else

 49489 +

 49490 +	# Parse the version information argument.

 49491 +	save_ifs="$IFS"; IFS=':'

 49492 +	set dummy $vinfo 0 0 0

 49493 +	shift

 49494 +	IFS="$save_ifs"

 49495 +

 49496 +	test -n "$7" && \

 49497 +	  func_fatal_help "too many parameters to \`-version-info'"

 49498 +

 49499 +	# convert absolute version numbers to libtool ages

 49500 +	# this retains compatibility with .la files and attempts

 49501 +	# to make the code below a bit more comprehensible

 49502 +

 49503 +	case $vinfo_number in

 49504 +	yes)

 49505 +	  number_major="$1"

 49506 +	  number_minor="$2"

 49507 +	  number_revision="$3"

 49508 +	  #

 49509 +	  # There are really only two kinds -- those that

 49510 +	  # use the current revision as the major version

 49511 +	  # and those that subtract age and use age as

 49512 +	  # a minor version.  But, then there is irix

 49513 +	  # which has an extra 1 added just for fun

 49514 +	  #

 49515 +	  case $version_type in

 49516 +	  darwin|linux|osf|windows|none)

 49517 +	    current=`expr $number_major + $number_minor`

 49518 +	    age="$number_minor"

 49519 +	    revision="$number_revision"

 49520 +	    ;;

 49521 +	  freebsd-aout|freebsd-elf|sunos)

 49522 +	    current="$number_major"

 49523 +	    revision="$number_minor"

 49524 +	    age="0"

 49525 +	    ;;

 49526 +	  irix|nonstopux)

 49527 +	    current=`expr $number_major + $number_minor - 1`

 49528 +	    age="$number_minor"

 49529 +	    revision="$number_minor"

 49530 +	    ;;

 49531 +	  esac

 49532 +	  ;;

 49533 +	no)

 49534 +	  current="$1"

 49535 +	  revision="$2"

 49536 +	  age="$3"

 49537 +	  ;;

 49538 +	esac

 49539 +

 49540 +	# Check that each of the things are valid numbers.

 49541 +	case $current in

 49542 +	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;

 49543 +	*)

 49544 +	  func_error "CURRENT \`$current' must be a nonnegative integer"

 49545 +	  func_fatal_error "\`$vinfo' is not valid version information"

 49546 +	  ;;

 49547 +	esac

 49548 +

 49549 +	case $revision in

 49550 +	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;

 49551 +	*)

 49552 +	  func_error "REVISION \`$revision' must be a nonnegative integer"

 49553 +	  func_fatal_error "\`$vinfo' is not valid version information"

 49554 +	  ;;

 49555 +	esac

 49556 +

 49557 +	case $age in

 49558 +	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;

 49559 +	*)

 49560 +	  func_error "AGE \`$age' must be a nonnegative integer"

 49561 +	  func_fatal_error "\`$vinfo' is not valid version information"

 49562 +	  ;;

 49563 +	esac

 49564 +

 49565 +	if test "$age" -gt "$current"; then

 49566 +	  func_error "AGE \`$age' is greater than the current interface number \`$current'"

 49567 +	  func_fatal_error "\`$vinfo' is not valid version information"

 49568 +	fi

 49569 +

 49570 +	# Calculate the version variables.

 49571 +	major=

 49572 +	versuffix=

 49573 +	verstring=

 49574 +	case $version_type in

 49575 +	none) ;;

 49576 +

 49577 +	darwin)

 49578 +	  # Like Linux, but with the current version available in

 49579 +	  # verstring for coding it into the library header

 49580 +	  major=.`expr $current - $age`

 49581 +	  versuffix="$major.$age.$revision"

 49582 +	  # Darwin ld doesn't like 0 for these options...

 49583 +	  minor_current=`expr $current + 1`

 49584 +	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"

 49585 +	  ;;

 49586 +

 49587 +	freebsd-aout)

 49588 +	  major=".$current"

 49589 +	  versuffix=".$current.$revision";

 49590 +	  ;;

 49591 +

 49592 +	freebsd-elf)

 49593 +	  major=".$current"

 49594 +	  versuffix=".$current"

 49595 +	  ;;

 49596 +

 49597 +	irix | nonstopux)

 49598 +	  major=`expr $current - $age + 1`

 49599 +

 49600 +	  case $version_type in

 49601 +	    nonstopux) verstring_prefix=nonstopux ;;

 49602 +	    *)         verstring_prefix=sgi ;;

 49603 +	  esac

 49604 +	  verstring="$verstring_prefix$major.$revision"

 49605 +

 49606 +	  # Add in all the interfaces that we are compatible with.

 49607 +	  loop=$revision

 49608 +	  while test "$loop" -ne 0; do

 49609 +	    iface=`expr $revision - $loop`

 49610 +	    loop=`expr $loop - 1`

 49611 +	    verstring="$verstring_prefix$major.$iface:$verstring"

 49612 +	  done

 49613 +

 49614 +	  # Before this point, $major must not contain `.'.

 49615 +	  major=.$major

 49616 +	  versuffix="$major.$revision"

 49617 +	  ;;

 49618 +

 49619 +	linux)

 49620 +	  major=.`expr $current - $age`

 49621 +	  versuffix="$major.$age.$revision"

 49622 +	  ;;

 49623 +

 49624 +	osf)

 49625 +	  major=.`expr $current - $age`

 49626 +	  versuffix=".$current.$age.$revision"

 49627 +	  verstring="$current.$age.$revision"

 49628 +

 49629 +	  # Add in all the interfaces that we are compatible with.

 49630 +	  loop=$age

 49631 +	  while test "$loop" -ne 0; do

 49632 +	    iface=`expr $current - $loop`

 49633 +	    loop=`expr $loop - 1`

 49634 +	    verstring="$verstring:${iface}.0"

 49635 +	  done

 49636 +

 49637 +	  # Make executables depend on our current version.

 49638 +	  verstring="$verstring:${current}.0"

 49639 +	  ;;

 49640 +

 49641 +	qnx)

 49642 +	  major=".$current"

 49643 +	  versuffix=".$current"

 49644 +	  ;;

 49645 +

 49646 +	sunos)

 49647 +	  major=".$current"

 49648 +	  versuffix=".$current.$revision"

 49649 +	  ;;

 49650 +

 49651 +	windows)

 49652 +	  # Use '-' rather than '.', since we only want one

 49653 +	  # extension on DOS 8.3 filesystems.

 49654 +	  major=`expr $current - $age`

 49655 +	  versuffix="-$major"

 49656 +	  ;;

 49657 +

 49658 +	*)

 49659 +	  func_fatal_configuration "unknown library version type \`$version_type'"

 49660 +	  ;;

 49661 +	esac

 49662 +

 49663 +	# Clear the version info if we defaulted, and they specified a release.

 49664 +	if test -z "$vinfo" && test -n "$release"; then

 49665 +	  major=

 49666 +	  case $version_type in

 49667 +	  darwin)

 49668 +	    # we can't check for "0.0" in archive_cmds due to quoting

 49669 +	    # problems, so we reset it completely

 49670 +	    verstring=

 49671 +	    ;;

 49672 +	  *)

 49673 +	    verstring="0.0"

 49674 +	    ;;

 49675 +	  esac

 49676 +	  if test "$need_version" = no; then

 49677 +	    versuffix=

 49678 +	  else

 49679 +	    versuffix=".0.0"

 49680 +	  fi

 49681 +	fi

 49682 +

 49683 +	# Remove version info from name if versioning should be avoided

 49684 +	if test "$avoid_version" = yes && test "$need_version" = no; then

 49685 +	  major=

 49686 +	  versuffix=

 49687 +	  verstring=""

 49688 +	fi

 49689 +

 49690 +	# Check to see if the archive will have undefined symbols.

 49691 +	if test "$allow_undefined" = yes; then

 49692 +	  if test "$allow_undefined_flag" = unsupported; then

 49693 +	    func_warning "undefined symbols not allowed in $host shared libraries"

 49694 +	    build_libtool_libs=no

 49695 +	    build_old_libs=yes

 49696 +	  fi

 49697 +	else

 49698 +	  # Don't allow undefined symbols.

 49699 +	  allow_undefined_flag="$no_undefined_flag"

 49700 +	fi

 49701 +

 49702 +      fi

 49703 +

 49704 +      func_generate_dlsyms "$libname" "$libname" "yes"

 49705 +      libobjs="$libobjs $symfileobj"

 49706 +      test "X$libobjs" = "X " && libobjs=

 49707 +

 49708 +      if test "$mode" != relink; then

 49709 +	# Remove our outputs, but don't remove object files since they

 49710 +	# may have been created when compiling PIC objects.

 49711 +	removelist=

 49712 +	tempremovelist=`$ECHO "$output_objdir/*"`

 49713 +	for p in $tempremovelist; do

 49714 +	  case $p in

 49715 +	    *.$objext)

 49716 +	       ;;

 49717 +	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)

 49718 +	       if test "X$precious_files_regex" != "X"; then

 49719 +		 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1

 49720 +		 then

 49721 +		   continue

 49722 +		 fi

 49723 +	       fi

 49724 +	       removelist="$removelist $p"

 49725 +	       ;;

 49726 +	    *) ;;

 49727 +	  esac

 49728 +	done

 49729 +	test -n "$removelist" && \

 49730 +	  func_show_eval "${RM}r \$removelist"

 49731 +      fi

 49732 +

 49733 +      # Now set the variables for building old libraries.

 49734 +      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then

 49735 +	oldlibs="$oldlibs $output_objdir/$libname.$libext"

 49736 +

 49737 +	# Transform .lo files to .o files.

 49738 +	oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`

 49739 +      fi

 49740 +

 49741 +      # Eliminate all temporary directories.

 49742 +      #for path in $notinst_path; do

 49743 +      #	lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`

 49744 +      #	deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`

 49745 +      #	dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`

 49746 +      #done

 49747 +

 49748 +      if test -n "$xrpath"; then

 49749 +	# If the user specified any rpath flags, then add them.

 49750 +	temp_xrpath=

 49751 +	for libdir in $xrpath; do

 49752 +	  temp_xrpath="$temp_xrpath -R$libdir"

 49753 +	  case "$finalize_rpath " in

 49754 +	  *" $libdir "*) ;;

 49755 +	  *) finalize_rpath="$finalize_rpath $libdir" ;;

 49756 +	  esac

 49757 +	done

 49758 +	if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then

 49759 +	  dependency_libs="$temp_xrpath $dependency_libs"

 49760 +	fi

 49761 +      fi

 49762 +

 49763 +      # Make sure dlfiles contains only unique files that won't be dlpreopened

 49764 +      old_dlfiles="$dlfiles"

 49765 +      dlfiles=

 49766 +      for lib in $old_dlfiles; do

 49767 +	case " $dlprefiles $dlfiles " in

 49768 +	*" $lib "*) ;;

 49769 +	*) dlfiles="$dlfiles $lib" ;;

 49770 +	esac

 49771 +      done

 49772 +

 49773 +      # Make sure dlprefiles contains only unique files

 49774 +      old_dlprefiles="$dlprefiles"

 49775 +      dlprefiles=

 49776 +      for lib in $old_dlprefiles; do

 49777 +	case "$dlprefiles " in

 49778 +	*" $lib "*) ;;

 49779 +	*) dlprefiles="$dlprefiles $lib" ;;

 49780 +	esac

 49781 +      done

 49782 +

 49783 +      if test "$build_libtool_libs" = yes; then

 49784 +	if test -n "$rpath"; then

 49785 +	  case $host in

 49786 +	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)

 49787 +	    # these systems don't actually have a c library (as such)!

 49788 +	    ;;

 49789 +	  *-*-rhapsody* | *-*-darwin1.[012])

 49790 +	    # Rhapsody C library is in the System framework

 49791 +	    deplibs="$deplibs System.ltframework"

 49792 +	    ;;

 49793 +	  *-*-netbsd*)

 49794 +	    # Don't link with libc until the a.out ld.so is fixed.

 49795 +	    ;;

 49796 +	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

 49797 +	    # Do not include libc due to us having libc/libc_r.

 49798 +	    ;;

 49799 +	  *-*-sco3.2v5* | *-*-sco5v6*)

 49800 +	    # Causes problems with __ctype

 49801 +	    ;;

 49802 +	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)

 49803 +	    # Compiler inserts libc in the correct place for threads to work

 49804 + 	    ;;

 49805 + 	  *)

 49806 +	    # Add libc to deplibs on all other systems if necessary.

 49807 +	    if test "$build_libtool_need_lc" = "yes"; then

 49808 +	      deplibs="$deplibs -lc"

 49809 +	    fi

 49810 +	    ;;

 49811 +	  esac

 49812 +	fi

 49813 +

 49814 +	# Transform deplibs into only deplibs that can be linked in shared.

 49815 +	name_save=$name

 49816 +	libname_save=$libname

 49817 +	release_save=$release

 49818 +	versuffix_save=$versuffix

 49819 +	major_save=$major

 49820 +	# I'm not sure if I'm treating the release correctly.  I think

 49821 +	# release should show up in the -l (ie -lgmp5) so we don't want to

 49822 +	# add it in twice.  Is that correct?

 49823 +	release=""

 49824 +	versuffix=""

 49825 +	major=""

 49826 +	newdeplibs=

 49827 +	droppeddeps=no

 49828 +	case $deplibs_check_method in

 49829 +	pass_all)

 49830 +	  # Don't check for shared/static.  Everything works.

 49831 +	  # This might be a little naive.  We might want to check

 49832 +	  # whether the library exists or not.  But this is on

 49833 +	  # osf3 & osf4 and I'm not really sure... Just

 49834 +	  # implementing what was already the behavior.

 49835 +	  newdeplibs=$deplibs

 49836 +	  ;;

 49837 +	test_compile)

 49838 +	  # This code stresses the "libraries are programs" paradigm to its

 49839 +	  # limits. Maybe even breaks it.  We compile a program, linking it

 49840 +	  # against the deplibs as a proxy for the library.  Then we can check

 49841 +	  # whether they linked in statically or dynamically with ldd.

 49842 +	  $opt_dry_run || $RM conftest.c

 49843 +	  cat > conftest.c <<EOF

 49844 +	  int main() { return 0; }

 49845 +EOF

 49846 +	  $opt_dry_run || $RM conftest

 49847 +	  if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then

 49848 +	    ldd_output=`ldd conftest`

 49849 +	    for i in $deplibs; do

 49850 +	      name=`expr $i : '-l\(.*\)'`

 49851 +	      # If $name is empty we are operating on a -L argument.

 49852 +	      if test "$name" != "" && test "$name" != "0"; then

 49853 +		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

 49854 +		  case " $predeps $postdeps " in

 49855 +		  *" $i "*)

 49856 +		    newdeplibs="$newdeplibs $i"

 49857 +		    i=""

 49858 +		    ;;

 49859 +		  esac

 49860 +		fi

 49861 +		if test -n "$i" ; then

 49862 +		  libname=`eval "\\$ECHO \"$libname_spec\""`

 49863 +		  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`

 49864 +		  set dummy $deplib_matches; shift

 49865 +		  deplib_match=$1

 49866 +		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

 49867 +		    newdeplibs="$newdeplibs $i"

 49868 +		  else

 49869 +		    droppeddeps=yes

 49870 +		    $ECHO

 49871 +		    $ECHO "*** Warning: dynamic linker does not accept needed library $i."

 49872 +		    $ECHO "*** I have the capability to make that library automatically link in when"

 49873 +		    $ECHO "*** you link to this library.  But I can only do this if you have a"

 49874 +		    $ECHO "*** shared version of the library, which I believe you do not have"

 49875 +		    $ECHO "*** because a test_compile did reveal that the linker did not use it for"

 49876 +		    $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."

 49877 +		  fi

 49878 +		fi

 49879 +	      else

 49880 +		newdeplibs="$newdeplibs $i"

 49881 +	      fi

 49882 +	    done

 49883 +	  else

 49884 +	    # Error occurred in the first compile.  Let's try to salvage

 49885 +	    # the situation: Compile a separate program for each library.

 49886 +	    for i in $deplibs; do

 49887 +	      name=`expr $i : '-l\(.*\)'`

 49888 +	      # If $name is empty we are operating on a -L argument.

 49889 +	      if test "$name" != "" && test "$name" != "0"; then

 49890 +		$opt_dry_run || $RM conftest

 49891 +		if $LTCC $LTCFLAGS -o conftest conftest.c $i; then

 49892 +		  ldd_output=`ldd conftest`

 49893 +		  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

 49894 +		    case " $predeps $postdeps " in

 49895 +		    *" $i "*)

 49896 +		      newdeplibs="$newdeplibs $i"

 49897 +		      i=""

 49898 +		      ;;

 49899 +		    esac

 49900 +		  fi

 49901 +		  if test -n "$i" ; then

 49902 +		    libname=`eval "\\$ECHO \"$libname_spec\""`

 49903 +		    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`

 49904 +		    set dummy $deplib_matches; shift

 49905 +		    deplib_match=$1

 49906 +		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

 49907 +		      newdeplibs="$newdeplibs $i"

 49908 +		    else

 49909 +		      droppeddeps=yes

 49910 +		      $ECHO

 49911 +		      $ECHO "*** Warning: dynamic linker does not accept needed library $i."

 49912 +		      $ECHO "*** I have the capability to make that library automatically link in when"

 49913 +		      $ECHO "*** you link to this library.  But I can only do this if you have a"

 49914 +		      $ECHO "*** shared version of the library, which you do not appear to have"

 49915 +		      $ECHO "*** because a test_compile did reveal that the linker did not use this one"

 49916 +		      $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."

 49917 +		    fi

 49918 +		  fi

 49919 +		else

 49920 +		  droppeddeps=yes

 49921 +		  $ECHO

 49922 +		  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"

 49923 +		  $ECHO "*** make it link in!  You will probably need to install it or some"

 49924 +		  $ECHO "*** library that it depends on before this library will be fully"

 49925 +		  $ECHO "*** functional.  Installing it before continuing would be even better."

 49926 +		fi

 49927 +	      else

 49928 +		newdeplibs="$newdeplibs $i"

 49929 +	      fi

 49930 +	    done

 49931 +	  fi

 49932 +	  ;;

 49933 +	file_magic*)

 49934 +	  set dummy $deplibs_check_method; shift

 49935 +	  file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`

 49936 +	  for a_deplib in $deplibs; do

 49937 +	    name=`expr $a_deplib : '-l\(.*\)'`

 49938 +	    # If $name is empty we are operating on a -L argument.

 49939 +	    if test "$name" != "" && test  "$name" != "0"; then

 49940 +	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

 49941 +		case " $predeps $postdeps " in

 49942 +		*" $a_deplib "*)

 49943 +		  newdeplibs="$newdeplibs $a_deplib"

 49944 +		  a_deplib=""

 49945 +		  ;;

 49946 +		esac

 49947 +	      fi

 49948 +	      if test -n "$a_deplib" ; then

 49949 +		libname=`eval "\\$ECHO \"$libname_spec\""`

 49950 +		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

 49951 +		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`

 49952 +		  for potent_lib in $potential_libs; do

 49953 +		      # Follow soft links.

 49954 +		      if ls -lLd "$potent_lib" 2>/dev/null |

 49955 +			 $GREP " -> " >/dev/null; then

 49956 +			continue

 49957 +		      fi

 49958 +		      # The statement above tries to avoid entering an

 49959 +		      # endless loop below, in case of cyclic links.

 49960 +		      # We might still enter an endless loop, since a link

 49961 +		      # loop can be closed while we follow links,

 49962 +		      # but so what?

 49963 +		      potlib="$potent_lib"

 49964 +		      while test -h "$potlib" 2>/dev/null; do

 49965 +			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`

 49966 +			case $potliblink in

 49967 +			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;

 49968 +			*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;

 49969 +			esac

 49970 +		      done

 49971 +		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |

 49972 +			 $SED -e 10q |

 49973 +			 $EGREP "$file_magic_regex" > /dev/null; then

 49974 +			newdeplibs="$newdeplibs $a_deplib"

 49975 +			a_deplib=""

 49976 +			break 2

 49977 +		      fi

 49978 +		  done

 49979 +		done

 49980 +	      fi

 49981 +	      if test -n "$a_deplib" ; then

 49982 +		droppeddeps=yes

 49983 +		$ECHO

 49984 +		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."

 49985 +		$ECHO "*** I have the capability to make that library automatically link in when"

 49986 +		$ECHO "*** you link to this library.  But I can only do this if you have a"

 49987 +		$ECHO "*** shared version of the library, which you do not appear to have"

 49988 +		$ECHO "*** because I did check the linker path looking for a file starting"

 49989 +		if test -z "$potlib" ; then

 49990 +		  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"

 49991 +		else

 49992 +		  $ECHO "*** with $libname and none of the candidates passed a file format test"

 49993 +		  $ECHO "*** using a file magic. Last file checked: $potlib"

 49994 +		fi

 49995 +	      fi

 49996 +	    else

 49997 +	      # Add a -L argument.

 49998 +	      newdeplibs="$newdeplibs $a_deplib"

 49999 +	    fi

 50000 +	  done # Gone through all deplibs.

 50001 +	  ;;

 50002 +	match_pattern*)

 50003 +	  set dummy $deplibs_check_method; shift

 50004 +	  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`

 50005 +	  for a_deplib in $deplibs; do

 50006 +	    name=`expr $a_deplib : '-l\(.*\)'`

 50007 +	    # If $name is empty we are operating on a -L argument.

 50008 +	    if test -n "$name" && test "$name" != "0"; then

 50009 +	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

 50010 +		case " $predeps $postdeps " in

 50011 +		*" $a_deplib "*)

 50012 +		  newdeplibs="$newdeplibs $a_deplib"

 50013 +		  a_deplib=""

 50014 +		  ;;

 50015 +		esac

 50016 +	      fi

 50017 +	      if test -n "$a_deplib" ; then

 50018 +		libname=`eval "\\$ECHO \"$libname_spec\""`

 50019 +		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

 50020 +		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`

 50021 +		  for potent_lib in $potential_libs; do

 50022 +		    potlib="$potent_lib" # see symlink-check above in file_magic test

 50023 +		    if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \

 50024 +		       $EGREP "$match_pattern_regex" > /dev/null; then

 50025 +		      newdeplibs="$newdeplibs $a_deplib"

 50026 +		      a_deplib=""

 50027 +		      break 2

 50028 +		    fi

 50029 +		  done

 50030 +		done

 50031 +	      fi

 50032 +	      if test -n "$a_deplib" ; then

 50033 +		droppeddeps=yes

 50034 +		$ECHO

 50035 +		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."

 50036 +		$ECHO "*** I have the capability to make that library automatically link in when"

 50037 +		$ECHO "*** you link to this library.  But I can only do this if you have a"

 50038 +		$ECHO "*** shared version of the library, which you do not appear to have"

 50039 +		$ECHO "*** because I did check the linker path looking for a file starting"

 50040 +		if test -z "$potlib" ; then

 50041 +		  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"

 50042 +		else

 50043 +		  $ECHO "*** with $libname and none of the candidates passed a file format test"

 50044 +		  $ECHO "*** using a regex pattern. Last file checked: $potlib"

 50045 +		fi

 50046 +	      fi

 50047 +	    else

 50048 +	      # Add a -L argument.

 50049 +	      newdeplibs="$newdeplibs $a_deplib"

 50050 +	    fi

 50051 +	  done # Gone through all deplibs.

 50052 +	  ;;

 50053 +	none | unknown | *)

 50054 +	  newdeplibs=""

 50055 +	  tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \

 50056 +	      -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`

 50057 +	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

 50058 +	    for i in $predeps $postdeps ; do

 50059 +	      # can't use Xsed below, because $i might contain '/'

 50060 +	      tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`

 50061 +	    done

 50062 +	  fi

 50063 +	  if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ 	]//g' |

 50064 +	     $GREP . >/dev/null; then

 50065 +	    $ECHO

 50066 +	    if test "X$deplibs_check_method" = "Xnone"; then

 50067 +	      $ECHO "*** Warning: inter-library dependencies are not supported in this platform."

 50068 +	    else

 50069 +	      $ECHO "*** Warning: inter-library dependencies are not known to be supported."

 50070 +	    fi

 50071 +	    $ECHO "*** All declared inter-library dependencies are being dropped."

 50072 +	    droppeddeps=yes

 50073 +	  fi

 50074 +	  ;;

 50075 +	esac

 50076 +	versuffix=$versuffix_save

 50077 +	major=$major_save

 50078 +	release=$release_save

 50079 +	libname=$libname_save

 50080 +	name=$name_save

 50081 +

 50082 +	case $host in

 50083 +	*-*-rhapsody* | *-*-darwin1.[012])

 50084 +	  # On Rhapsody replace the C library with the System framework

 50085 +	  newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`

 50086 +	  ;;

 50087 +	esac

 50088 +

 50089 +	if test "$droppeddeps" = yes; then

 50090 +	  if test "$module" = yes; then

 50091 +	    $ECHO

 50092 +	    $ECHO "*** Warning: libtool could not satisfy all declared inter-library"

 50093 +	    $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"

 50094 +	    $ECHO "*** a static module, that should work as long as the dlopening"

 50095 +	    $ECHO "*** application is linked with the -dlopen flag."

 50096 +	    if test -z "$global_symbol_pipe"; then

 50097 +	      $ECHO

 50098 +	      $ECHO "*** However, this would only work if libtool was able to extract symbol"

 50099 +	      $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"

 50100 +	      $ECHO "*** not find such a program.  So, this module is probably useless."

 50101 +	      $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."

 50102 +	    fi

 50103 +	    if test "$build_old_libs" = no; then

 50104 +	      oldlibs="$output_objdir/$libname.$libext"

 50105 +	      build_libtool_libs=module

 50106 +	      build_old_libs=yes

 50107 +	    else

 50108 +	      build_libtool_libs=no

 50109 +	    fi

 50110 +	  else

 50111 +	    $ECHO "*** The inter-library dependencies that have been dropped here will be"

 50112 +	    $ECHO "*** automatically added whenever a program is linked with this library"

 50113 +	    $ECHO "*** or is declared to -dlopen it."

 50114 +

 50115 +	    if test "$allow_undefined" = no; then

 50116 +	      $ECHO

 50117 +	      $ECHO "*** Since this library must not contain undefined symbols,"

 50118 +	      $ECHO "*** because either the platform does not support them or"

 50119 +	      $ECHO "*** it was explicitly requested with -no-undefined,"

 50120 +	      $ECHO "*** libtool will only create a static version of it."

 50121 +	      if test "$build_old_libs" = no; then

 50122 +		oldlibs="$output_objdir/$libname.$libext"

 50123 +		build_libtool_libs=module

 50124 +		build_old_libs=yes

 50125 +	      else

 50126 +		build_libtool_libs=no

 50127 +	      fi

 50128 +	    fi

 50129 +	  fi

 50130 +	fi

 50131 +	# Done checking deplibs!

 50132 +	deplibs=$newdeplibs

 50133 +      fi

 50134 +      # Time to change all our "foo.ltframework" stuff back to "-framework foo"

 50135 +      case $host in

 50136 +	*-*-darwin*)

 50137 +	  newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`

 50138 +	  new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`

 50139 +	  deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`

 50140 +	  ;;

 50141 +      esac

 50142 +

 50143 +      # move library search paths that coincide with paths to not yet

 50144 +      # installed libraries to the beginning of the library search list

 50145 +      new_libs=

 50146 +      for path in $notinst_path; do

 50147 +	case " $new_libs " in

 50148 +	*" -L$path/$objdir "*) ;;

 50149 +	*)

 50150 +	  case " $deplibs " in

 50151 +	  *" -L$path/$objdir "*)

 50152 +	    new_libs="$new_libs -L$path/$objdir" ;;

 50153 +	  esac

 50154 +	  ;;

 50155 +	esac

 50156 +      done

 50157 +      for deplib in $deplibs; do

 50158 +	case $deplib in

 50159 +	-L*)

 50160 +	  case " $new_libs " in

 50161 +	  *" $deplib "*) ;;

 50162 +	  *) new_libs="$new_libs $deplib" ;;

 50163 +	  esac

 50164 +	  ;;

 50165 +	*) new_libs="$new_libs $deplib" ;;

 50166 +	esac

 50167 +      done

 50168 +      deplibs="$new_libs"

 50169 +

 50170 +      # All the library-specific variables (install_libdir is set above).

 50171 +      library_names=

 50172 +      old_library=

 50173 +      dlname=

 50174 +

 50175 +      # Test again, we may have decided not to build it any more

 50176 +      if test "$build_libtool_libs" = yes; then

 50177 +	if test "$hardcode_into_libs" = yes; then

 50178 +	  # Hardcode the library paths

 50179 +	  hardcode_libdirs=

 50180 +	  dep_rpath=

 50181 +	  rpath="$finalize_rpath"

 50182 +	  test "$mode" != relink && rpath="$compile_rpath$rpath"

 50183 +	  for libdir in $rpath; do

 50184 +	    if test -n "$hardcode_libdir_flag_spec"; then

 50185 +	      if test -n "$hardcode_libdir_separator"; then

 50186 +		if test -z "$hardcode_libdirs"; then

 50187 +		  hardcode_libdirs="$libdir"

 50188 +		else

 50189 +		  # Just accumulate the unique libdirs.

 50190 +		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

 50191 +		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

 50192 +		    ;;

 50193 +		  *)

 50194 +		    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

 50195 +		    ;;

 50196 +		  esac

 50197 +		fi

 50198 +	      else

 50199 +		eval flag=\"$hardcode_libdir_flag_spec\"

 50200 +		dep_rpath="$dep_rpath $flag"

 50201 +	      fi

 50202 +	    elif test -n "$runpath_var"; then

 50203 +	      case "$perm_rpath " in

 50204 +	      *" $libdir "*) ;;

 50205 +	      *) perm_rpath="$perm_rpath $libdir" ;;

 50206 +	      esac

 50207 +	    fi

 50208 +	  done

 50209 +	  # Substitute the hardcoded libdirs into the rpath.

 50210 +	  if test -n "$hardcode_libdir_separator" &&

 50211 +	     test -n "$hardcode_libdirs"; then

 50212 +	    libdir="$hardcode_libdirs"

 50213 +	    if test -n "$hardcode_libdir_flag_spec_ld"; then

 50214 +	      eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"

 50215 +	    else

 50216 +	      eval dep_rpath=\"$hardcode_libdir_flag_spec\"

 50217 +	    fi

 50218 +	  fi

 50219 +	  if test -n "$runpath_var" && test -n "$perm_rpath"; then

 50220 +	    # We should set the runpath_var.

 50221 +	    rpath=

 50222 +	    for dir in $perm_rpath; do

 50223 +	      rpath="$rpath$dir:"

 50224 +	    done

 50225 +	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"

 50226 +	  fi

 50227 +	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"

 50228 +	fi

 50229 +

 50230 +	shlibpath="$finalize_shlibpath"

 50231 +	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"

 50232 +	if test -n "$shlibpath"; then

 50233 +	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"

 50234 +	fi

 50235 +

 50236 +	# Get the real and link names of the library.

 50237 +	eval shared_ext=\"$shrext_cmds\"

 50238 +	eval library_names=\"$library_names_spec\"

 50239 +	set dummy $library_names

 50240 +	shift

 50241 +	realname="$1"

 50242 +	shift

 50243 +

 50244 +	if test -n "$soname_spec"; then

 50245 +	  eval soname=\"$soname_spec\"

 50246 +	else

 50247 +	  soname="$realname"

 50248 +	fi

 50249 +	if test -z "$dlname"; then

 50250 +	  dlname=$soname

 50251 +	fi

 50252 +

 50253 +	lib="$output_objdir/$realname"

 50254 +	linknames=

 50255 +	for link

 50256 +	do

 50257 +	  linknames="$linknames $link"

 50258 +	done

 50259 +

 50260 +	# Use standard objects if they are pic

 50261 +	test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

 50262 +	test "X$libobjs" = "X " && libobjs=

 50263 +

 50264 +	delfiles=

 50265 +	if test -n "$export_symbols" && test -n "$include_expsyms"; then

 50266 +	  $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"

 50267 +	  export_symbols="$output_objdir/$libname.uexp"

 50268 +	  delfiles="$delfiles $export_symbols"

 50269 +	fi

 50270 +

 50271 +	orig_export_symbols=

 50272 +	case $host_os in

 50273 +	cygwin* | mingw*)

 50274 +	  if test -n "$export_symbols" && test -z "$export_symbols_regex"; then

 50275 +	    # exporting using user supplied symfile

 50276 +	    if test "x`$SED 1q $export_symbols`" != xEXPORTS; then

 50277 +	      # and it's NOT already a .def file. Must figure out

 50278 +	      # which of the given symbols are data symbols and tag

 50279 +	      # them as such. So, trigger use of export_symbols_cmds.

 50280 +	      # export_symbols gets reassigned inside the "prepare

 50281 +	      # the list of exported symbols" if statement, so the

 50282 +	      # include_expsyms logic still works.

 50283 +	      orig_export_symbols="$export_symbols"

 50284 +	      export_symbols=

 50285 +	      always_export_symbols=yes

 50286 +	    fi

 50287 +	  fi

 50288 +	  ;;

 50289 +	esac

 50290 +

 50291 +	# Prepare the list of exported symbols

 50292 +	if test -z "$export_symbols"; then

 50293 +	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then

 50294 +	    func_echo "generating symbol list for \`$libname.la'"

 50295 +	    export_symbols="$output_objdir/$libname.exp"

 50296 +	    $opt_dry_run || $RM $export_symbols

 50297 +	    cmds=$export_symbols_cmds

 50298 +	    save_ifs="$IFS"; IFS='~'

 50299 +	    for cmd in $cmds; do

 50300 +	      IFS="$save_ifs"

 50301 +	      eval cmd=\"$cmd\"

 50302 +	      if len=`expr "X$cmd" : ".*"` &&

 50303 +	       test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then

 50304 +		func_show_eval "$cmd" 'exit $?'

 50305 +		skipped_export=false

 50306 +	      else

 50307 +		# The command line is too long to execute in one step.

 50308 +		func_echo "using reloadable object file for export list..."

 50309 +		skipped_export=:

 50310 +		# Break out early, otherwise skipped_export may be

 50311 +		# set to false by a later but shorter cmd.

 50312 +		break

 50313 +	      fi

 50314 +	    done

 50315 +	    IFS="$save_ifs"

 50316 +	    if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then

 50317 +	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

 50318 +	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'

 50319 +	    fi

 50320 +	  fi

 50321 +	fi

 50322 +

 50323 +	if test -n "$export_symbols" && test -n "$include_expsyms"; then

 50324 +	  tmp_export_symbols="$export_symbols"

 50325 +	  test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

 50326 +	  $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'

 50327 +	fi

 50328 +

 50329 +	if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then

 50330 +	  # The given exports_symbols file has to be filtered, so filter it.

 50331 +	  func_echo "filter symbol list for \`$libname.la' to tag DATA exports"

 50332 +	  # FIXME: $output_objdir/$libname.filter potentially contains lots of

 50333 +	  # 's' commands which not all seds can handle. GNU sed should be fine

 50334 +	  # though. Also, the filter scales superlinearly with the number of

 50335 +	  # global variables. join(1) would be nice here, but unfortunately

 50336 +	  # isn't a blessed tool.

 50337 +	  $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

 50338 +	  delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"

 50339 +	  export_symbols=$output_objdir/$libname.def

 50340 +	  $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

 50341 +	fi

 50342 +

 50343 +	tmp_deplibs=

 50344 +	for test_deplib in $deplibs; do

 50345 +	  case " $convenience " in

 50346 +	  *" $test_deplib "*) ;;

 50347 +	  *)

 50348 +	    tmp_deplibs="$tmp_deplibs $test_deplib"

 50349 +	    ;;

 50350 +	  esac

 50351 +	done

 50352 +	deplibs="$tmp_deplibs"

 50353 +

 50354 +	if test -n "$convenience"; then

 50355 +	  if test -n "$whole_archive_flag_spec" &&

 50356 +	    test "$compiler_needs_object" = yes &&

 50357 +	    test -z "$libobjs"; then

 50358 +	    # extract the archives, so we have objects to list.

 50359 +	    # TODO: could optimize this to just extract one archive.

 50360 +	    whole_archive_flag_spec=

 50361 +	  fi

 50362 +	  if test -n "$whole_archive_flag_spec"; then

 50363 +	    save_libobjs=$libobjs

 50364 +	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"

 50365 +	    test "X$libobjs" = "X " && libobjs=

 50366 +	  else

 50367 +	    gentop="$output_objdir/${outputname}x"

 50368 +	    generated="$generated $gentop"

 50369 +

 50370 +	    func_extract_archives $gentop $convenience

 50371 +	    libobjs="$libobjs $func_extract_archives_result"

 50372 +	    test "X$libobjs" = "X " && libobjs=

 50373 +	  fi

 50374 +	fi

 50375 +

 50376 +	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then

 50377 +	  eval flag=\"$thread_safe_flag_spec\"

 50378 +	  linker_flags="$linker_flags $flag"

 50379 +	fi

 50380 +

 50381 +	# Make a backup of the uninstalled library when relinking

 50382 +	if test "$mode" = relink; then

 50383 +	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?

 50384 +	fi

 50385 +

 50386 +	# Do each of the archive commands.

 50387 +	if test "$module" = yes && test -n "$module_cmds" ; then

 50388 +	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then

 50389 +	    eval test_cmds=\"$module_expsym_cmds\"

 50390 +	    cmds=$module_expsym_cmds

 50391 +	  else

 50392 +	    eval test_cmds=\"$module_cmds\"

 50393 +	    cmds=$module_cmds

 50394 +	  fi

 50395 +	else

 50396 +	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then

 50397 +	    eval test_cmds=\"$archive_expsym_cmds\"

 50398 +	    cmds=$archive_expsym_cmds

 50399 +	  else

 50400 +	    eval test_cmds=\"$archive_cmds\"

 50401 +	    cmds=$archive_cmds

 50402 +	  fi

 50403 +	fi

 50404 +

 50405 +	if test "X$skipped_export" != "X:" &&

 50406 +	   len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&

 50407 +	   test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then

 50408 +	  :

 50409 +	else

 50410 +	  # The command line is too long to link in one step, link piecewise

 50411 +	  # or, if using GNU ld and skipped_export is not :, use a linker

 50412 +	  # script.

 50413 +

 50414 +	  # Save the value of $output and $libobjs because we want to

 50415 +	  # use them later.  If we have whole_archive_flag_spec, we

 50416 +	  # want to use save_libobjs as it was before

 50417 +	  # whole_archive_flag_spec was expanded, because we can't

 50418 +	  # assume the linker understands whole_archive_flag_spec.

 50419 +	  # This may have to be revisited, in case too many

 50420 +	  # convenience libraries get linked in and end up exceeding

 50421 +	  # the spec.

 50422 +	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then

 50423 +	    save_libobjs=$libobjs

 50424 +	  fi

 50425 +	  save_output=$output

 50426 +	  output_la=`$ECHO "X$output" | $Xsed -e "$basename"`

 50427 +

 50428 +	  # Clear the reloadable object creation command queue and

 50429 +	  # initialize k to one.

 50430 +	  test_cmds=

 50431 +	  concat_cmds=

 50432 +	  objlist=

 50433 +	  last_robj=

 50434 +	  k=1

 50435 +

 50436 +	  if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then

 50437 +	    output=${output_objdir}/${output_la}.lnkscript

 50438 +	    func_echo "creating GNU ld script: $output"

 50439 +	    $ECHO 'INPUT (' > $output

 50440 +	    for obj in $save_libobjs

 50441 +	    do

 50442 +	      $ECHO "$obj" >> $output

 50443 +	    done

 50444 +	    $ECHO ')' >> $output

 50445 +	    delfiles="$delfiles $output"

 50446 +	  elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then

 50447 +	    output=${output_objdir}/${output_la}.lnk

 50448 +	    func_echo "creating linker input file list: $output"

 50449 +	    : > $output

 50450 +	    set x $save_libobjs

 50451 +	    shift

 50452 +	    firstobj=

 50453 +	    if test "$compiler_needs_object" = yes; then

 50454 +	      firstobj="$1 "

 50455 +	      shift

 50456 +	    fi

 50457 +	    for obj

 50458 +	    do

 50459 +	      $ECHO "$obj" >> $output

 50460 +	    done

 50461 +	    delfiles="$delfiles $output"

 50462 +	    output=$firstobj\"$file_list_spec$output\"

 50463 +	  else

 50464 +	    if test -n "$save_libobjs"; then

 50465 +	      func_echo "creating reloadable object files..."

 50466 +	      output=$output_objdir/$output_la-${k}.$objext

 50467 +	      # Loop over the list of objects to be linked.

 50468 +	      for obj in $save_libobjs

 50469 +	      do

 50470 +		eval test_cmds=\"$reload_cmds $objlist $last_robj\"

 50471 +		if test "X$objlist" = X ||

 50472 +		   { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&

 50473 +		     test "$len" -le "$max_cmd_len"; }; then

 50474 +		  objlist="$objlist $obj"

 50475 +		else

 50476 +		  # The command $test_cmds is almost too long, add a

 50477 +		  # command to the queue.

 50478 +		  if test "$k" -eq 1 ; then

 50479 +		    # The first file doesn't have a previous command to add.

 50480 +		    eval concat_cmds=\"$reload_cmds $objlist $last_robj\"

 50481 +		  else

 50482 +		    # All subsequent reloadable object files will link in

 50483 +		    # the last one created.

 50484 +		    eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"

 50485 +		  fi

 50486 +		  last_robj=$output_objdir/$output_la-${k}.$objext

 50487 +		  k=`expr $k + 1`

 50488 +		  output=$output_objdir/$output_la-${k}.$objext

 50489 +		  objlist=$obj

 50490 +		  len=1

 50491 +		fi

 50492 +	      done

 50493 +	      # Handle the remaining objects by creating one last

 50494 +	      # reloadable object file.  All subsequent reloadable object

 50495 +	      # files will link in the last one created.

 50496 +	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~

 50497 +	      eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"

 50498 +

 50499 +	      # Set up a command to remove the reloadable object files

 50500 +	      # after they are used.

 50501 +	      i=0

 50502 +	      while test "$i" -lt "$k"

 50503 +	      do

 50504 +		i=`expr $i + 1`

 50505 +		delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"

 50506 +	      done

 50507 +	    else

 50508 +	      output=

 50509 +	    fi

 50510 +

 50511 +	    if ${skipped_export-false}; then

 50512 +	      func_echo "generating symbol list for \`$libname.la'"

 50513 +	      export_symbols="$output_objdir/$libname.exp"

 50514 +	      $opt_dry_run || $RM $export_symbols

 50515 +	      libobjs=$output

 50516 +	      # Append the command to create the export file.

 50517 +	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~

 50518 +	      eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"

 50519 +	    fi

 50520 +

 50521 +	    test -n "$save_libobjs" &&

 50522 +	      func_echo "creating a temporary reloadable object file: $output"

 50523 +

 50524 +	    # Loop through the commands generated above and execute them.

 50525 +	    save_ifs="$IFS"; IFS='~'

 50526 +	    for cmd in $concat_cmds; do

 50527 +	      IFS="$save_ifs"

 50528 +	      $opt_silent || {

 50529 +		  func_quote_for_expand "$cmd"

 50530 +		  eval "func_echo $func_quote_for_expand_result"

 50531 +	      }

 50532 +	      $opt_dry_run || eval "$cmd" || {

 50533 +		lt_exit=$?

 50534 +

 50535 +		# Restore the uninstalled library and exit

 50536 +		if test "$mode" = relink; then

 50537 +		  ( cd "$output_objdir" && \

 50538 +		    $RM "${realname}T" && \

 50539 +		    $MV "${realname}U" "$realname" )

 50540 +		fi

 50541 +

 50542 +		exit $lt_exit

 50543 +	      }

 50544 +	    done

 50545 +	    IFS="$save_ifs"

 50546 +

 50547 +	    if test -n "$export_symbols_regex" && ${skipped_export-false}; then

 50548 +	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

 50549 +	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'

 50550 +	    fi

 50551 +	  fi

 50552 +

 50553 +          if ${skipped_export-false}; then

 50554 +	    if test -n "$export_symbols" && test -n "$include_expsyms"; then

 50555 +	      tmp_export_symbols="$export_symbols"

 50556 +	      test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

 50557 +	      $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'

 50558 +	    fi

 50559 +

 50560 +	    if test -n "$orig_export_symbols"; then

 50561 +	      # The given exports_symbols file has to be filtered, so filter it.

 50562 +	      func_echo "filter symbol list for \`$libname.la' to tag DATA exports"

 50563 +	      # FIXME: $output_objdir/$libname.filter potentially contains lots of

 50564 +	      # 's' commands which not all seds can handle. GNU sed should be fine

 50565 +	      # though. Also, the filter scales superlinearly with the number of

 50566 +	      # global variables. join(1) would be nice here, but unfortunately

 50567 +	      # isn't a blessed tool.

 50568 +	      $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

 50569 +	      delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"

 50570 +	      export_symbols=$output_objdir/$libname.def

 50571 +	      $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

 50572 +	    fi

 50573 +	  fi

 50574 +

 50575 +	  libobjs=$output

 50576 +	  # Restore the value of output.

 50577 +	  output=$save_output

 50578 +

 50579 +	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then

 50580 +	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"

 50581 +	    test "X$libobjs" = "X " && libobjs=

 50582 +	  fi

 50583 +	  # Expand the library linking commands again to reset the

 50584 +	  # value of $libobjs for piecewise linking.

 50585 +

 50586 +	  # Do each of the archive commands.

 50587 +	  if test "$module" = yes && test -n "$module_cmds" ; then

 50588 +	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then

 50589 +	      cmds=$module_expsym_cmds

 50590 +	    else

 50591 +	      cmds=$module_cmds

 50592 +	    fi

 50593 +	  else

 50594 +	    if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then

 50595 +	      cmds=$archive_expsym_cmds

 50596 +	    else

 50597 +	      cmds=$archive_cmds

 50598 +	    fi

 50599 +	  fi

 50600 +	fi

 50601 +

 50602 +	if test -n "$delfiles"; then

 50603 +	  # Append the command to remove temporary files to $cmds.

 50604 +	  eval cmds=\"\$cmds~\$RM $delfiles\"

 50605 +	fi

 50606 +

 50607 +	# Add any objects from preloaded convenience libraries

 50608 +	if test -n "$dlprefiles"; then

 50609 +	  gentop="$output_objdir/${outputname}x"

 50610 +	  generated="$generated $gentop"

 50611 +

 50612 +	  func_extract_archives $gentop $dlprefiles

 50613 +	  libobjs="$libobjs $func_extract_archives_result"

 50614 +	  test "X$libobjs" = "X " && libobjs=

 50615 +	fi

 50616 +

 50617 +	save_ifs="$IFS"; IFS='~'

 50618 +	for cmd in $cmds; do

 50619 +	  IFS="$save_ifs"

 50620 +	  eval cmd=\"$cmd\"

 50621 +	  $opt_silent || {

 50622 +	    func_quote_for_expand "$cmd"

 50623 +	    eval "func_echo $func_quote_for_expand_result"

 50624 +	  }

 50625 +	  $opt_dry_run || eval "$cmd" || {

 50626 +	    lt_exit=$?

 50627 +

 50628 +	    # Restore the uninstalled library and exit

 50629 +	    if test "$mode" = relink; then

 50630 +	      ( cd "$output_objdir" && \

 50631 +	        $RM "${realname}T" && \

 50632 +		$MV "${realname}U" "$realname" )

 50633 +	    fi

 50634 +

 50635 +	    exit $lt_exit

 50636 +	  }

 50637 +	done

 50638 +	IFS="$save_ifs"

 50639 +

 50640 +	# Restore the uninstalled library and exit

 50641 +	if test "$mode" = relink; then

 50642 +	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?

 50643 +

 50644 +	  if test -n "$convenience"; then

 50645 +	    if test -z "$whole_archive_flag_spec"; then

 50646 +	      func_show_eval '${RM}r "$gentop"'

 50647 +	    fi

 50648 +	  fi

 50649 +

 50650 +	  exit $EXIT_SUCCESS

 50651 +	fi

 50652 +

 50653 +	# Create links to the real library.

 50654 +	for linkname in $linknames; do

 50655 +	  if test "$realname" != "$linkname"; then

 50656 +	    func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'

 50657 +	  fi

 50658 +	done

 50659 +

 50660 +	# If -module or -export-dynamic was specified, set the dlname.

 50661 +	if test "$module" = yes || test "$export_dynamic" = yes; then

 50662 +	  # On all known operating systems, these are identical.

 50663 +	  dlname="$soname"

 50664 +	fi

 50665 +      fi

 50666 +      ;;

 50667 +

 50668 +    obj)

 50669 +      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

 50670 +	func_warning "\`-dlopen' is ignored for objects"

 50671 +      fi

 50672 +

 50673 +      test -n "$deplibs" && \

 50674 +	func_warning "\`-l' and \`-L' are ignored for objects"

 50675 +

 50676 +      test -n "$rpath" && \

 50677 +	func_warning "\`-rpath' is ignored for objects"

 50678 +

 50679 +      test -n "$xrpath" && \

 50680 +	func_warning "\`-R' is ignored for objects"

 50681 +

 50682 +      test -n "$vinfo" && \

 50683 +	func_warning "\`-version-info' is ignored for objects"

 50684 +

 50685 +      test -n "$release" && \

 50686 +	func_warning "\`-release' is ignored for objects"

 50687 +

 50688 +      case $output in

 50689 +      *.lo)

 50690 +	test -n "$objs$old_deplibs" && \

 50691 +	  func_fatal_error "cannot build library object \`$output' from non-libtool objects"

 50692 +

 50693 +	libobj=$output

 50694 +	func_lo2o "$libobj"

 50695 +	obj=$func_lo2o_result

 50696 +	;;

 50697 +      *)

 50698 +	libobj=

 50699 +	obj="$output"

 50700 +	;;

 50701 +      esac

 50702 +

 50703 +      # Delete the old objects.

 50704 +      $opt_dry_run || $RM $obj $libobj

 50705 +

 50706 +      # Objects from convenience libraries.  This assumes

 50707 +      # single-version convenience libraries.  Whenever we create

 50708 +      # different ones for PIC/non-PIC, this we'll have to duplicate

 50709 +      # the extraction.

 50710 +      reload_conv_objs=

 50711 +      gentop=

 50712 +      # reload_cmds runs $LD directly, so let us get rid of

 50713 +      # -Wl from whole_archive_flag_spec and hope we can get by with

 50714 +      # turning comma into space..

 50715 +      wl=

 50716 +

 50717 +      if test -n "$convenience"; then

 50718 +	if test -n "$whole_archive_flag_spec"; then

 50719 +	  eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"

 50720 +	  reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`

 50721 +	else

 50722 +	  gentop="$output_objdir/${obj}x"

 50723 +	  generated="$generated $gentop"

 50724 +

 50725 +	  func_extract_archives $gentop $convenience

 50726 +	  reload_conv_objs="$reload_objs $func_extract_archives_result"

 50727 +	fi

 50728 +      fi

 50729 +

 50730 +      # Create the old-style object.

 50731 +      reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test

 50732 +

 50733 +      output="$obj"

 50734 +      func_execute_cmds "$reload_cmds" 'exit $?'

 50735 +

 50736 +      # Exit if we aren't doing a library object file.

 50737 +      if test -z "$libobj"; then

 50738 +	if test -n "$gentop"; then

 50739 +	  func_show_eval '${RM}r "$gentop"'

 50740 +	fi

 50741 +

 50742 +	exit $EXIT_SUCCESS

 50743 +      fi

 50744 +

 50745 +      if test "$build_libtool_libs" != yes; then

 50746 +	if test -n "$gentop"; then

 50747 +	  func_show_eval '${RM}r "$gentop"'

 50748 +	fi

 50749 +

 50750 +	# Create an invalid libtool object if no PIC, so that we don't

 50751 +	# accidentally link it into a program.

 50752 +	# $show "echo timestamp > $libobj"

 50753 +	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?

 50754 +	exit $EXIT_SUCCESS

 50755 +      fi

 50756 +

 50757 +      if test -n "$pic_flag" || test "$pic_mode" != default; then

 50758 +	# Only do commands if we really have different PIC objects.

 50759 +	reload_objs="$libobjs $reload_conv_objs"

 50760 +	output="$libobj"

 50761 +	func_execute_cmds "$reload_cmds" 'exit $?'

 50762 +      fi

 50763 +

 50764 +      if test -n "$gentop"; then

 50765 +	func_show_eval '${RM}r "$gentop"'

 50766 +      fi

 50767 +

 50768 +      exit $EXIT_SUCCESS

 50769 +      ;;

 50770 +

 50771 +    prog)

 50772 +      case $host in

 50773 +	*cygwin*) func_stripname '' '.exe' "$output"

 50774 +	          output=$func_stripname_result.exe;;

 50775 +      esac

 50776 +      test -n "$vinfo" && \

 50777 +	func_warning "\`-version-info' is ignored for programs"

 50778 +

 50779 +      test -n "$release" && \

 50780 +	func_warning "\`-release' is ignored for programs"

 50781 +

 50782 +      test "$preload" = yes \

 50783 +        && test "$dlopen_support" = unknown \

 50784 +	&& test "$dlopen_self" = unknown \

 50785 +	&& test "$dlopen_self_static" = unknown && \

 50786 +	  func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."

 50787 +

 50788 +      case $host in

 50789 +      *-*-rhapsody* | *-*-darwin1.[012])

 50790 +	# On Rhapsody replace the C library is the System framework

 50791 +	compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`

 50792 +	finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`

 50793 +	;;

 50794 +      esac

 50795 +

 50796 +      case $host in

 50797 +      *-*-darwin*)

 50798 +	# Don't allow lazy linking, it breaks C++ global constructors

 50799 +	# But is supposedly fixed on 10.4 or later (yay!).

 50800 +	if test "$tagname" = CXX ; then

 50801 +	  case ${MACOSX_DEPLOYMENT_TARGET-10.0} in

 50802 +	    10.[0123])

 50803 +	      compile_command="$compile_command ${wl}-bind_at_load"

 50804 +	      finalize_command="$finalize_command ${wl}-bind_at_load"

 50805 +	    ;;

 50806 +	  esac

 50807 +	fi

 50808 +	# Time to change all our "foo.ltframework" stuff back to "-framework foo"

 50809 +	compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`

 50810 +	finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`

 50811 +	;;

 50812 +      esac

 50813 +

 50814 +

 50815 +      # move library search paths that coincide with paths to not yet

 50816 +      # installed libraries to the beginning of the library search list

 50817 +      new_libs=

 50818 +      for path in $notinst_path; do

 50819 +	case " $new_libs " in

 50820 +	*" -L$path/$objdir "*) ;;

 50821 +	*)

 50822 +	  case " $compile_deplibs " in

 50823 +	  *" -L$path/$objdir "*)

 50824 +	    new_libs="$new_libs -L$path/$objdir" ;;

 50825 +	  esac

 50826 +	  ;;

 50827 +	esac

 50828 +      done

 50829 +      for deplib in $compile_deplibs; do

 50830 +	case $deplib in

 50831 +	-L*)

 50832 +	  case " $new_libs " in

 50833 +	  *" $deplib "*) ;;

 50834 +	  *) new_libs="$new_libs $deplib" ;;

 50835 +	  esac

 50836 +	  ;;

 50837 +	*) new_libs="$new_libs $deplib" ;;

 50838 +	esac

 50839 +      done

 50840 +      compile_deplibs="$new_libs"

 50841 +

 50842 +

 50843 +      compile_command="$compile_command $compile_deplibs"

 50844 +      finalize_command="$finalize_command $finalize_deplibs"

 50845 +

 50846 +      if test -n "$rpath$xrpath"; then

 50847 +	# If the user specified any rpath flags, then add them.

 50848 +	for libdir in $rpath $xrpath; do

 50849 +	  # This is the magic to use -rpath.

 50850 +	  case "$finalize_rpath " in

 50851 +	  *" $libdir "*) ;;

 50852 +	  *) finalize_rpath="$finalize_rpath $libdir" ;;

 50853 +	  esac

 50854 +	done

 50855 +      fi

 50856 +

 50857 +      # Now hardcode the library paths

 50858 +      rpath=

 50859 +      hardcode_libdirs=

 50860 +      for libdir in $compile_rpath $finalize_rpath; do

 50861 +	if test -n "$hardcode_libdir_flag_spec"; then

 50862 +	  if test -n "$hardcode_libdir_separator"; then

 50863 +	    if test -z "$hardcode_libdirs"; then

 50864 +	      hardcode_libdirs="$libdir"

 50865 +	    else

 50866 +	      # Just accumulate the unique libdirs.

 50867 +	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

 50868 +	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

 50869 +		;;

 50870 +	      *)

 50871 +		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

 50872 +		;;

 50873 +	      esac

 50874 +	    fi

 50875 +	  else

 50876 +	    eval flag=\"$hardcode_libdir_flag_spec\"

 50877 +	    rpath="$rpath $flag"

 50878 +	  fi

 50879 +	elif test -n "$runpath_var"; then

 50880 +	  case "$perm_rpath " in

 50881 +	  *" $libdir "*) ;;

 50882 +	  *) perm_rpath="$perm_rpath $libdir" ;;

 50883 +	  esac

 50884 +	fi

 50885 +	case $host in

 50886 +	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)

 50887 +	  testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`

 50888 +	  case :$dllsearchpath: in

 50889 +	  *":$libdir:"*) ;;

 50890 +	  *) dllsearchpath="$dllsearchpath:$libdir";;

 50891 +	  esac

 50892 +	  case :$dllsearchpath: in

 50893 +	  *":$testbindir:"*) ;;

 50894 +	  *) dllsearchpath="$dllsearchpath:$testbindir";;

 50895 +	  esac

 50896 +	  ;;

 50897 +	esac

 50898 +      done

 50899 +      # Substitute the hardcoded libdirs into the rpath.

 50900 +      if test -n "$hardcode_libdir_separator" &&

 50901 +	 test -n "$hardcode_libdirs"; then

 50902 +	libdir="$hardcode_libdirs"

 50903 +	eval rpath=\" $hardcode_libdir_flag_spec\"

 50904 +      fi

 50905 +      compile_rpath="$rpath"

 50906 +

 50907 +      rpath=

 50908 +      hardcode_libdirs=

 50909 +      for libdir in $finalize_rpath; do

 50910 +	if test -n "$hardcode_libdir_flag_spec"; then

 50911 +	  if test -n "$hardcode_libdir_separator"; then

 50912 +	    if test -z "$hardcode_libdirs"; then

 50913 +	      hardcode_libdirs="$libdir"

 50914 +	    else

 50915 +	      # Just accumulate the unique libdirs.

 50916 +	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

 50917 +	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

 50918 +		;;

 50919 +	      *)

 50920 +		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

 50921 +		;;

 50922 +	      esac

 50923 +	    fi

 50924 +	  else

 50925 +	    eval flag=\"$hardcode_libdir_flag_spec\"

 50926 +	    rpath="$rpath $flag"

 50927 +	  fi

 50928 +	elif test -n "$runpath_var"; then

 50929 +	  case "$finalize_perm_rpath " in

 50930 +	  *" $libdir "*) ;;

 50931 +	  *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;

 50932 +	  esac

 50933 +	fi

 50934 +      done

 50935 +      # Substitute the hardcoded libdirs into the rpath.

 50936 +      if test -n "$hardcode_libdir_separator" &&

 50937 +	 test -n "$hardcode_libdirs"; then

 50938 +	libdir="$hardcode_libdirs"

 50939 +	eval rpath=\" $hardcode_libdir_flag_spec\"

 50940 +      fi

 50941 +      finalize_rpath="$rpath"

 50942 +

 50943 +      if test -n "$libobjs" && test "$build_old_libs" = yes; then

 50944 +	# Transform all the library objects into standard objects.

 50945 +	compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

 50946 +	finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

 50947 +      fi

 50948 +

 50949 +      func_generate_dlsyms "$outputname" "@PROGRAM@" "no"

 50950 +

 50951 +      # template prelinking step

 50952 +      if test -n "$prelink_cmds"; then

 50953 +	func_execute_cmds "$prelink_cmds" 'exit $?'

 50954 +      fi

 50955 +

 50956 +      wrappers_required=yes

 50957 +      case $host in

 50958 +      *cygwin* | *mingw* )

 50959 +        if test "$build_libtool_libs" != yes; then

 50960 +          wrappers_required=no

 50961 +        fi

 50962 +        ;;

 50963 +      *)

 50964 +        if test "$need_relink" = no || test "$build_libtool_libs" != yes; then

 50965 +          wrappers_required=no

 50966 +        fi

 50967 +        ;;

 50968 +      esac

 50969 +      if test "$wrappers_required" = no; then

 50970 +	# Replace the output file specification.

 50971 +	compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`

 50972 +	link_command="$compile_command$compile_rpath"

 50973 +

 50974 +	# We have no uninstalled library dependencies, so finalize right now.

 50975 +	exit_status=0

 50976 +	func_show_eval "$link_command" 'exit_status=$?'

 50977 +

 50978 +	# Delete the generated files.

 50979 +	if test -f "$output_objdir/${outputname}S.${objext}"; then

 50980 +	  func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'

 50981 +	fi

 50982 +

 50983 +	exit $exit_status

 50984 +      fi

 50985 +

 50986 +      if test -n "$compile_shlibpath$finalize_shlibpath"; then

 50987 +	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"

 50988 +      fi

 50989 +      if test -n "$finalize_shlibpath"; then

 50990 +	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"

 50991 +      fi

 50992 +

 50993 +      compile_var=

 50994 +      finalize_var=

 50995 +      if test -n "$runpath_var"; then

 50996 +	if test -n "$perm_rpath"; then

 50997 +	  # We should set the runpath_var.

 50998 +	  rpath=

 50999 +	  for dir in $perm_rpath; do

 51000 +	    rpath="$rpath$dir:"

 51001 +	  done

 51002 +	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "

 51003 +	fi

 51004 +	if test -n "$finalize_perm_rpath"; then

 51005 +	  # We should set the runpath_var.

 51006 +	  rpath=

 51007 +	  for dir in $finalize_perm_rpath; do

 51008 +	    rpath="$rpath$dir:"

 51009 +	  done

 51010 +	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "

 51011 +	fi

 51012 +      fi

 51013 +

 51014 +      if test "$no_install" = yes; then

 51015 +	# We don't need to create a wrapper script.

 51016 +	link_command="$compile_var$compile_command$compile_rpath"

 51017 +	# Replace the output file specification.

 51018 +	link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`

 51019 +	# Delete the old output file.

 51020 +	$opt_dry_run || $RM $output

 51021 +	# Link the executable and exit

 51022 +	func_show_eval "$link_command" 'exit $?'

 51023 +	exit $EXIT_SUCCESS

 51024 +      fi

 51025 +

 51026 +      if test "$hardcode_action" = relink; then

 51027 +	# Fast installation is not supported

 51028 +	link_command="$compile_var$compile_command$compile_rpath"

 51029 +	relink_command="$finalize_var$finalize_command$finalize_rpath"

 51030 +

 51031 +	func_warning "this platform does not like uninstalled shared libraries"

 51032 +	func_warning "\`$output' will be relinked during installation"

 51033 +      else

 51034 +	if test "$fast_install" != no; then

 51035 +	  link_command="$finalize_var$compile_command$finalize_rpath"

 51036 +	  if test "$fast_install" = yes; then

 51037 +	    relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`

 51038 +	  else

 51039 +	    # fast_install is set to needless

 51040 +	    relink_command=

 51041 +	  fi

 51042 +	else

 51043 +	  link_command="$compile_var$compile_command$compile_rpath"

 51044 +	  relink_command="$finalize_var$finalize_command$finalize_rpath"

 51045 +	fi

 51046 +      fi

 51047 +

 51048 +      # Replace the output file specification.

 51049 +      link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`

 51050 +

 51051 +      # Delete the old output files.

 51052 +      $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname

 51053 +

 51054 +      func_show_eval "$link_command" 'exit $?'

 51055 +

 51056 +      # Now create the wrapper script.

 51057 +      func_echo "creating $output"

 51058 +

 51059 +      # Quote the relink command for shipping.

 51060 +      if test -n "$relink_command"; then

 51061 +	# Preserve any variables that may affect compiler behavior

 51062 +	for var in $variables_saved_for_relink; do

 51063 +	  if eval test -z \"\${$var+set}\"; then

 51064 +	    relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"

 51065 +	  elif eval var_value=\$$var; test -z "$var_value"; then

 51066 +	    relink_command="$var=; export $var; $relink_command"

 51067 +	  else

 51068 +	    func_quote_for_eval "$var_value"

 51069 +	    relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"

 51070 +	  fi

 51071 +	done

 51072 +	relink_command="(cd `pwd`; $relink_command)"

 51073 +	relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`

 51074 +      fi

 51075 +

 51076 +      # Quote $ECHO for shipping.

 51077 +      if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then

 51078 +	case $progpath in

 51079 +	[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;

 51080 +	*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;

 51081 +	esac

 51082 +	qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`

 51083 +      else

 51084 +	qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`

 51085 +      fi

 51086 +

 51087 +      # Only actually do things if not in dry run mode.

 51088 +      $opt_dry_run || {

 51089 +	# win32 will think the script is a binary if it has

 51090 +	# a .exe suffix, so we strip it off here.

 51091 +	case $output in

 51092 +	  *.exe) func_stripname '' '.exe' "$output"

 51093 +	         output=$func_stripname_result ;;

 51094 +	esac

 51095 +	# test for cygwin because mv fails w/o .exe extensions

 51096 +	case $host in

 51097 +	  *cygwin*)

 51098 +	    exeext=.exe

 51099 +	    func_stripname '' '.exe' "$outputname"

 51100 +	    outputname=$func_stripname_result ;;

 51101 +	  *) exeext= ;;

 51102 +	esac

 51103 +	case $host in

 51104 +	  *cygwin* | *mingw* )

 51105 +	    output_name=`basename $output`

 51106 +	    output_path=`dirname $output`

 51107 +	    cwrappersource="$output_path/$objdir/lt-$output_name.c"

 51108 +	    cwrapper="$output_path/$output_name.exe"

 51109 +	    $RM $cwrappersource $cwrapper

 51110 +	    trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15

 51111 +

 51112 +	    cat > $cwrappersource <<EOF

 51113 +

 51114 +/* $cwrappersource - temporary wrapper executable for $objdir/$outputname

 51115 +   Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

 51116 +

 51117 +   The $output program cannot be directly executed until all the libtool

 51118 +   libraries that it depends on are installed.

 51119 +

 51120 +   This wrapper executable should never be moved out of the build directory.

 51121 +   If it is, it will not operate correctly.

 51122 +

 51123 +   Currently, it simply execs the wrapper *script* "/bin/sh $output",

 51124 +   but could eventually absorb all of the scripts functionality and

 51125 +   exec $objdir/$outputname directly.

 51126 +*/

 51127 +EOF

 51128 +	    cat >> $cwrappersource<<"EOF"

 51129 +#include <stdio.h>

 51130 +#include <stdlib.h>

 51131 +#include <unistd.h>

 51132 +#include <malloc.h>

 51133 +#include <stdarg.h>

 51134 +#include <assert.h>

 51135 +#include <string.h>

 51136 +#include <ctype.h>

 51137 +#include <sys/stat.h>

 51138 +

 51139 +#if defined(PATH_MAX)

 51140 +# define LT_PATHMAX PATH_MAX

 51141 +#elif defined(MAXPATHLEN)

 51142 +# define LT_PATHMAX MAXPATHLEN

 51143 +#else

 51144 +# define LT_PATHMAX 1024

 51145 +#endif

 51146 +

 51147 +#ifndef DIR_SEPARATOR

 51148 +# define DIR_SEPARATOR '/'

 51149 +# define PATH_SEPARATOR ':'

 51150 +#endif

 51151 +

 51152 +#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \

 51153 +  defined (__OS2__)

 51154 +# define HAVE_DOS_BASED_FILE_SYSTEM

 51155 +# ifndef DIR_SEPARATOR_2

 51156 +#  define DIR_SEPARATOR_2 '\\'

 51157 +# endif

 51158 +# ifndef PATH_SEPARATOR_2

 51159 +#  define PATH_SEPARATOR_2 ';'

 51160 +# endif

 51161 +#endif

 51162 +

 51163 +#ifndef DIR_SEPARATOR_2

 51164 +# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)

 51165 +#else /* DIR_SEPARATOR_2 */

 51166 +# define IS_DIR_SEPARATOR(ch) \

 51167 +	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))

 51168 +#endif /* DIR_SEPARATOR_2 */

 51169 +

 51170 +#ifndef PATH_SEPARATOR_2

 51171 +# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)

 51172 +#else /* PATH_SEPARATOR_2 */

 51173 +# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)

 51174 +#endif /* PATH_SEPARATOR_2 */

 51175 +

 51176 +#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))

 51177 +#define XFREE(stale) do { \

 51178 +  if (stale) { free ((void *) stale); stale = 0; } \

 51179 +} while (0)

 51180 +

 51181 +/* -DDEBUG is fairly common in CFLAGS.  */

 51182 +#undef DEBUG

 51183 +#if defined DEBUGWRAPPER

 51184 +# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)

 51185 +#else

 51186 +# define DEBUG(format, ...)

 51187 +#endif

 51188 +

 51189 +const char *program_name = NULL;

 51190 +

 51191 +void * xmalloc (size_t num);

 51192 +char * xstrdup (const char *string);

 51193 +const char * base_name (const char *name);

 51194 +char * find_executable(const char *wrapper);

 51195 +int    check_executable(const char *path);

 51196 +char * strendzap(char *str, const char *pat);

 51197 +void lt_fatal (const char *message, ...);

 51198 +

 51199 +int

 51200 +main (int argc, char *argv[])

 51201 +{

 51202 +  char **newargz;

 51203 +  int i;

 51204 +

 51205 +  program_name = (char *) xstrdup (base_name (argv[0]));

 51206 +  DEBUG("(main) argv[0]      : %s\n",argv[0]);

 51207 +  DEBUG("(main) program_name : %s\n",program_name);

 51208 +  newargz = XMALLOC(char *, argc+2);

 51209 +EOF

 51210 +

 51211 +	    cat >> $cwrappersource <<EOF

 51212 +  newargz[0] = (char *) xstrdup("$SHELL");

 51213 +EOF

 51214 +

 51215 +	    cat >> $cwrappersource <<"EOF"

 51216 +  newargz[1] = find_executable(argv[0]);

 51217 +  if (newargz[1] == NULL)

 51218 +    lt_fatal("Couldn't find %s", argv[0]);

 51219 +  DEBUG("(main) found exe at : %s\n",newargz[1]);

 51220 +  /* we know the script has the same name, without the .exe */

 51221 +  /* so make sure newargz[1] doesn't end in .exe */

 51222 +  strendzap(newargz[1],".exe");

 51223 +  for (i = 1; i < argc; i++)

 51224 +    newargz[i+1] = xstrdup(argv[i]);

 51225 +  newargz[argc+1] = NULL;

 51226 +

 51227 +  for (i=0; i<argc+1; i++)

 51228 +  {

 51229 +    DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);

 51230 +    ;

 51231 +  }

 51232 +

 51233 +EOF

 51234 +

 51235 +	    case $host_os in

 51236 +	      mingw*)

 51237 +		cat >> $cwrappersource <<EOF

 51238 +  execv("$SHELL",(char const **)newargz);

 51239 +EOF

 51240 +	      ;;

 51241 +	      *)

 51242 +		cat >> $cwrappersource <<EOF

 51243 +  execv("$SHELL",newargz);

 51244 +EOF

 51245 +	      ;;

 51246 +	    esac

 51247 +

 51248 +	    cat >> $cwrappersource <<"EOF"

 51249 +  return 127;

 51250 +}

 51251 +

 51252 +void *

 51253 +xmalloc (size_t num)

 51254 +{

 51255 +  void * p = (void *) malloc (num);

 51256 +  if (!p)

 51257 +    lt_fatal ("Memory exhausted");

 51258 +

 51259 +  return p;

 51260 +}

 51261 +

 51262 +char *

 51263 +xstrdup (const char *string)

 51264 +{

 51265 +  return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL

 51266 +;

 51267 +}

 51268 +

 51269 +const char *

 51270 +base_name (const char *name)

 51271 +{

 51272 +  const char *base;

 51273 +

 51274 +#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

 51275 +  /* Skip over the disk name in MSDOS pathnames. */

 51276 +  if (isalpha ((unsigned char)name[0]) && name[1] == ':')

 51277 +    name += 2;

 51278 +#endif

 51279 +

 51280 +  for (base = name; *name; name++)

 51281 +    if (IS_DIR_SEPARATOR (*name))

 51282 +      base = name + 1;

 51283 +  return base;

 51284 +}

 51285 +

 51286 +int

 51287 +check_executable(const char * path)

 51288 +{

 51289 +  struct stat st;

 51290 +

 51291 +  DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");

 51292 +  if ((!path) || (!*path))

 51293 +    return 0;

 51294 +

 51295 +  if ((stat (path, &st) >= 0) &&

 51296 +      (

 51297 +	/* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */

 51298 +#if defined (S_IXOTH)

 51299 +       ((st.st_mode & S_IXOTH) == S_IXOTH) ||

 51300 +#endif

 51301 +#if defined (S_IXGRP)

 51302 +       ((st.st_mode & S_IXGRP) == S_IXGRP) ||

 51303 +#endif

 51304 +       ((st.st_mode & S_IXUSR) == S_IXUSR))

 51305 +      )

 51306 +    return 1;

 51307 +  else

 51308 +    return 0;

 51309 +}

 51310 +

 51311 +/* Searches for the full path of the wrapper.  Returns

 51312 +   newly allocated full path name if found, NULL otherwise */

 51313 +char *

 51314 +find_executable (const char* wrapper)

 51315 +{

 51316 +  int has_slash = 0;

 51317 +  const char* p;

 51318 +  const char* p_next;

 51319 +  /* static buffer for getcwd */

 51320 +  char tmp[LT_PATHMAX + 1];

 51321 +  int tmp_len;

 51322 +  char* concat_name;

 51323 +

 51324 +  DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");

 51325 +

 51326 +  if ((wrapper == NULL) || (*wrapper == '\0'))

 51327 +    return NULL;

 51328 +

 51329 +  /* Absolute path? */

 51330 +#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

 51331 +  if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')

 51332 +  {

 51333 +    concat_name = xstrdup (wrapper);

 51334 +    if (check_executable(concat_name))

 51335 +      return concat_name;

 51336 +    XFREE(concat_name);

 51337 +  }

 51338 +  else

 51339 +  {

 51340 +#endif

 51341 +    if (IS_DIR_SEPARATOR (wrapper[0]))

 51342 +    {

 51343 +      concat_name = xstrdup (wrapper);

 51344 +      if (check_executable(concat_name))

 51345 +	return concat_name;

 51346 +      XFREE(concat_name);

 51347 +    }

 51348 +#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

 51349 +  }

 51350 +#endif

 51351 +

 51352 +  for (p = wrapper; *p; p++)

 51353 +    if (*p == '/')

 51354 +    {

 51355 +      has_slash = 1;

 51356 +      break;

 51357 +    }

 51358 +  if (!has_slash)

 51359 +  {

 51360 +    /* no slashes; search PATH */

 51361 +    const char* path = getenv ("PATH");

 51362 +    if (path != NULL)

 51363 +    {

 51364 +      for (p = path; *p; p = p_next)

 51365 +      {

 51366 +	const char* q;

 51367 +	size_t p_len;

 51368 +	for (q = p; *q; q++)

 51369 +	  if (IS_PATH_SEPARATOR(*q))

 51370 +	    break;

 51371 +	p_len = q - p;

 51372 +	p_next = (*q == '\0' ? q : q + 1);

 51373 +	if (p_len == 0)

 51374 +	{

 51375 +	  /* empty path: current directory */

 51376 +	  if (getcwd (tmp, LT_PATHMAX) == NULL)

 51377 +	    lt_fatal ("getcwd failed");

 51378 +	  tmp_len = strlen(tmp);

 51379 +	  concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);

 51380 +	  memcpy (concat_name, tmp, tmp_len);

 51381 +	  concat_name[tmp_len] = '/';

 51382 +	  strcpy (concat_name + tmp_len + 1, wrapper);

 51383 +	}

 51384 +	else

 51385 +	{

 51386 +	  concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);

 51387 +	  memcpy (concat_name, p, p_len);

 51388 +	  concat_name[p_len] = '/';

 51389 +	  strcpy (concat_name + p_len + 1, wrapper);

 51390 +	}

 51391 +	if (check_executable(concat_name))

 51392 +	  return concat_name;

 51393 +	XFREE(concat_name);

 51394 +      }

 51395 +    }

 51396 +    /* not found in PATH; assume curdir */

 51397 +  }

 51398 +  /* Relative path | not found in path: prepend cwd */

 51399 +  if (getcwd (tmp, LT_PATHMAX) == NULL)

 51400 +    lt_fatal ("getcwd failed");

 51401 +  tmp_len = strlen(tmp);

 51402 +  concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);

 51403 +  memcpy (concat_name, tmp, tmp_len);

 51404 +  concat_name[tmp_len] = '/';

 51405 +  strcpy (concat_name + tmp_len + 1, wrapper);

 51406 +

 51407 +  if (check_executable(concat_name))

 51408 +    return concat_name;

 51409 +  XFREE(concat_name);

 51410 +  return NULL;

 51411 +}

 51412 +

 51413 +char *

 51414 +strendzap(char *str, const char *pat)

 51415 +{

 51416 +  size_t len, patlen;

 51417 +

 51418 +  assert(str != NULL);

 51419 +  assert(pat != NULL);

 51420 +

 51421 +  len = strlen(str);

 51422 +  patlen = strlen(pat);

 51423 +

 51424 +  if (patlen <= len)

 51425 +  {

 51426 +    str += len - patlen;

 51427 +    if (strcmp(str, pat) == 0)

 51428 +      *str = '\0';

 51429 +  }

 51430 +  return str;

 51431 +}

 51432 +

 51433 +static void

 51434 +lt_error_core (int exit_status, const char * mode,

 51435 +	  const char * message, va_list ap)

 51436 +{

 51437 +  fprintf (stderr, "%s: %s: ", program_name, mode);

 51438 +  vfprintf (stderr, message, ap);

 51439 +  fprintf (stderr, ".\n");

 51440 +

 51441 +  if (exit_status >= 0)

 51442 +    exit (exit_status);

 51443 +}

 51444 +

 51445 +void

 51446 +lt_fatal (const char *message, ...)

 51447 +{

 51448 +  va_list ap;

 51449 +  va_start (ap, message);

 51450 +  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);

 51451 +  va_end (ap);

 51452 +}

 51453 +EOF

 51454 +	  # we should really use a build-platform specific compiler

 51455 +	  # here, but OTOH, the wrappers (shell script and this C one)

 51456 +	  # are only useful if you want to execute the "real" binary.

 51457 +	  # Since the "real" binary is built for $host, then this

 51458 +	  # wrapper might as well be built for $host, too.

 51459 +	  $opt_dry_run || $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource

 51460 +	  ;;

 51461 +	esac

 51462 +	$RM $output

 51463 +	trap "$RM $output; exit $EXIT_FAILURE" 1 2 15

 51464 +

 51465 +	$ECHO > $output "\

 51466 +#! $SHELL

 51467 +

 51468 +# $output - temporary wrapper script for $objdir/$outputname

 51469 +# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

 51470 +#

 51471 +# The $output program cannot be directly executed until all the libtool

 51472 +# libraries that it depends on are installed.

 51473 +#

 51474 +# This wrapper script should never be moved out of the build directory.

 51475 +# If it is, it will not operate correctly.

 51476 +

 51477 +# Sed substitution that helps us do robust quoting.  It backslashifies

 51478 +# metacharacters that are still active within double-quoted strings.

 51479 +Xsed='${SED} -e 1s/^X//'

 51480 +sed_quote_subst='$sed_quote_subst'

 51481 +

 51482 +# Be Bourne compatible

 51483 +if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then

 51484 +  emulate sh

 51485 +  NULLCMD=:

 51486 +  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which

 51487 +  # is contrary to our usage.  Disable this feature.

 51488 +  alias -g '\${1+\"\$@\"}'='\"\$@\"'

 51489 +  setopt NO_GLOB_SUBST

 51490 +else

 51491 +  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac

 51492 +fi

 51493 +BIN_SH=xpg4; export BIN_SH # for Tru64

 51494 +DUALCASE=1; export DUALCASE # for MKS sh

 51495 +

 51496 +# The HP-UX ksh and POSIX shell print the target directory to stdout

 51497 +# if CDPATH is set.

 51498 +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

 51499 +

 51500 +relink_command=\"$relink_command\"

 51501 +

 51502 +# This environment variable determines our operation mode.

 51503 +if test \"\$libtool_install_magic\" = \"$magic\"; then

 51504 +  # install mode needs the following variables:

 51505 +  generated_by_libtool_version='$macro_version'

 51506 +  notinst_deplibs='$notinst_deplibs'

 51507 +else

 51508 +  # When we are sourced in execute mode, \$file and \$ECHO are already set.

 51509 +  if test \"\$libtool_execute_magic\" != \"$magic\"; then

 51510 +    ECHO=\"$qecho\"

 51511 +    file=\"\$0\"

 51512 +    # Make sure echo works.

 51513 +    if test \"X\$1\" = X--no-reexec; then

 51514 +      # Discard the --no-reexec flag, and continue.

 51515 +      shift

 51516 +    elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then

 51517 +      # Yippee, \$ECHO works!

 51518 +      :

 51519 +    else

 51520 +      # Restart under the correct shell, and then maybe \$ECHO will work.

 51521 +      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}

 51522 +    fi

 51523 +  fi\

 51524 +"

 51525 +	$ECHO >> $output "\

 51526 +

 51527 +  # Find the directory that this script lives in.

 51528 +  thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`

 51529 +  test \"x\$thisdir\" = \"x\$file\" && thisdir=.

 51530 +

 51531 +  # Follow symbolic links until we get to the real thisdir.

 51532 +  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`

 51533 +  while test -n \"\$file\"; do

 51534 +    destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`

 51535 +

 51536 +    # If there was a directory component, then change thisdir.

 51537 +    if test \"x\$destdir\" != \"x\$file\"; then

 51538 +      case \"\$destdir\" in

 51539 +      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;

 51540 +      *) thisdir=\"\$thisdir/\$destdir\" ;;

 51541 +      esac

 51542 +    fi

 51543 +

 51544 +    file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`

 51545 +    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`

 51546 +  done

 51547 +

 51548 +  # Try to get the absolute directory name.

 51549 +  absdir=\`cd \"\$thisdir\" && pwd\`

 51550 +  test -n \"\$absdir\" && thisdir=\"\$absdir\"

 51551 +"

 51552 +

 51553 +	if test "$fast_install" = yes; then

 51554 +	  $ECHO >> $output "\

 51555 +  program=lt-'$outputname'$exeext

 51556 +  progdir=\"\$thisdir/$objdir\"

 51557 +

 51558 +  if test ! -f \"\$progdir/\$program\" ||

 51559 +     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\

 51560 +       test \"X\$file\" != \"X\$progdir/\$program\"; }; then

 51561 +

 51562 +    file=\"\$\$-\$program\"

 51563 +

 51564 +    if test ! -d \"\$progdir\"; then

 51565 +      $MKDIR \"\$progdir\"

 51566 +    else

 51567 +      $RM \"\$progdir/\$file\"

 51568 +    fi"

 51569 +

 51570 +	  $ECHO >> $output "\

 51571 +

 51572 +    # relink executable if necessary

 51573 +    if test -n \"\$relink_command\"; then

 51574 +      if relink_command_output=\`eval \$relink_command 2>&1\`; then :

 51575 +      else

 51576 +	$ECHO \"\$relink_command_output\" >&2

 51577 +	$RM \"\$progdir/\$file\"

 51578 +	exit 1

 51579 +      fi

 51580 +    fi

 51581 +

 51582 +    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||

 51583 +    { $RM \"\$progdir/\$program\";

 51584 +      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }

 51585 +    $RM \"\$progdir/\$file\"

 51586 +  fi"

 51587 +	else

 51588 +	  $ECHO >> $output "\

 51589 +  program='$outputname'

 51590 +  progdir=\"\$thisdir/$objdir\"

 51591 +"

 51592 +	fi

 51593 +

 51594 +	$ECHO >> $output "\

 51595 +

 51596 +  if test -f \"\$progdir/\$program\"; then"

 51597 +

 51598 +	# Export our shlibpath_var if we have one.

 51599 +	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

 51600 +	  $ECHO >> $output "\

 51601 +    # Add our own library path to $shlibpath_var

 51602 +    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"

 51603 +

 51604 +    # Some systems cannot cope with colon-terminated $shlibpath_var

 51605 +    # The second colon is a workaround for a bug in BeOS R4 sed

 51606 +    $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`

 51607 +

 51608 +    export $shlibpath_var

 51609 +"

 51610 +	fi

 51611 +

 51612 +	# fixup the dll searchpath if we need to.

 51613 +	if test -n "$dllsearchpath"; then

 51614 +	  $ECHO >> $output "\

 51615 +    # Add the dll search path components to the executable PATH

 51616 +    PATH=$dllsearchpath:\$PATH

 51617 +"

 51618 +	fi

 51619 +

 51620 +	$ECHO >> $output "\

 51621 +    if test \"\$libtool_execute_magic\" != \"$magic\"; then

 51622 +      # Run the actual program with our arguments.

 51623 +"

 51624 +	case $host in

 51625 +	# Backslashes separate directories on plain windows

 51626 +	*-*-mingw | *-*-os2*)

 51627 +	  $ECHO >> $output "\

 51628 +      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}

 51629 +"

 51630 +	  ;;

 51631 +

 51632 +	*)

 51633 +	  $ECHO >> $output "\

 51634 +      exec \"\$progdir/\$program\" \${1+\"\$@\"}

 51635 +"

 51636 +	  ;;

 51637 +	esac

 51638 +	$ECHO >> $output "\

 51639 +      \$ECHO \"\$0: cannot exec \$program \$*\"

 51640 +      exit 1

 51641 +    fi

 51642 +  else

 51643 +    # The program doesn't exist.

 51644 +    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2

 51645 +    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2

 51646 +    $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2

 51647 +    exit 1

 51648 +  fi

 51649 +fi\

 51650 +"

 51651 +	chmod +x $output

 51652 +      }

 51653 +      exit $EXIT_SUCCESS

 51654 +      ;;

 51655 +    esac

 51656 +

 51657 +    # See if we need to build an old-fashioned archive.

 51658 +    for oldlib in $oldlibs; do

 51659 +

 51660 +      if test "$build_libtool_libs" = convenience; then

 51661 +	oldobjs="$libobjs_save $symfileobj"

 51662 +	addlibs="$convenience"

 51663 +	build_libtool_libs=no

 51664 +      else

 51665 +	if test "$build_libtool_libs" = module; then

 51666 +	  oldobjs="$libobjs_save"

 51667 +	  build_libtool_libs=no

 51668 +	else

 51669 +	  oldobjs="$old_deplibs $non_pic_objects"

 51670 +	  if test "$preload" = yes && test -f "$symfileobj"; then

 51671 +	    oldobjs="$oldobjs $symfileobj"

 51672 +	  fi

 51673 +	fi

 51674 +	addlibs="$old_convenience"

 51675 +      fi

 51676 +

 51677 +      if test -n "$addlibs"; then

 51678 +	gentop="$output_objdir/${outputname}x"

 51679 +	generated="$generated $gentop"

 51680 +

 51681 +	func_extract_archives $gentop $addlibs

 51682 +	oldobjs="$oldobjs $func_extract_archives_result"

 51683 +      fi

 51684 +

 51685 +      # Do each command in the archive commands.

 51686 +      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then

 51687 +	cmds=$old_archive_from_new_cmds

 51688 +      else

 51689 +

 51690 +	# Add any objects from preloaded convenience libraries

 51691 +	if test -n "$dlprefiles"; then

 51692 +	  gentop="$output_objdir/${outputname}x"

 51693 +	  generated="$generated $gentop"

 51694 +

 51695 +	  func_extract_archives $gentop $dlprefiles

 51696 +	  oldobjs="$oldobjs $func_extract_archives_result"

 51697 +	fi

 51698 +

 51699 +	# POSIX demands no paths to be encoded in archives.  We have

 51700 +	# to avoid creating archives with duplicate basenames if we

 51701 +	# might have to extract them afterwards, e.g., when creating a

 51702 +	# static archive out of a convenience library, or when linking

 51703 +	# the entirety of a libtool archive into another (currently

 51704 +	# not supported by libtool).

 51705 +	if (for obj in $oldobjs

 51706 +	    do

 51707 +	      func_basename "$obj"

 51708 +	      $ECHO "$func_basename_result"

 51709 +	    done | sort | sort -uc >/dev/null 2>&1); then

 51710 +	  :

 51711 +	else

 51712 +	  $ECHO "copying selected object files to avoid basename conflicts..."

 51713 +	  gentop="$output_objdir/${outputname}x"

 51714 +	  generated="$generated $gentop"

 51715 +	  func_mkdir_p "$gentop"

 51716 +	  save_oldobjs=$oldobjs

 51717 +	  oldobjs=

 51718 +	  counter=1

 51719 +	  for obj in $save_oldobjs

 51720 +	  do

 51721 +	    func_basename "$obj"

 51722 +	    objbase="$func_basename_result"

 51723 +	    case " $oldobjs " in

 51724 +	    " ") oldobjs=$obj ;;

 51725 +	    *[\ /]"$objbase "*)

 51726 +	      while :; do

 51727 +		# Make sure we don't pick an alternate name that also

 51728 +		# overlaps.

 51729 +		newobj=lt$counter-$objbase

 51730 +		counter=`expr $counter + 1`

 51731 +		case " $oldobjs " in

 51732 +		*[\ /]"$newobj "*) ;;

 51733 +		*) if test ! -f "$gentop/$newobj"; then break; fi ;;

 51734 +		esac

 51735 +	      done

 51736 +	      func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"

 51737 +	      oldobjs="$oldobjs $gentop/$newobj"

 51738 +	      ;;

 51739 +	    *) oldobjs="$oldobjs $obj" ;;

 51740 +	    esac

 51741 +	  done

 51742 +	fi

 51743 +	eval cmds=\"$old_archive_cmds\"

 51744 +

 51745 +	if len=`expr "X$cmds" : ".*" 2>/dev/null` &&

 51746 +	   test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then

 51747 +	  cmds=$old_archive_cmds

 51748 +	else

 51749 +	  # the command line is too long to link in one step, link in parts

 51750 +	  func_echo "using piecewise archive linking..."

 51751 +	  save_RANLIB=$RANLIB

 51752 +	  RANLIB=:

 51753 +	  objlist=

 51754 +	  concat_cmds=

 51755 +	  save_oldobjs=$oldobjs

 51756 +	  # Is there a better way of finding the last object in the list?

 51757 +	  for obj in $save_oldobjs

 51758 +	  do

 51759 +	    last_oldobj=$obj

 51760 +	  done

 51761 +	  for obj in $save_oldobjs

 51762 +	  do

 51763 +	    oldobjs="$objlist $obj"

 51764 +	    objlist="$objlist $obj"

 51765 +	    eval test_cmds=\"$old_archive_cmds\"

 51766 +	    if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&

 51767 +	       test "$len" -le "$max_cmd_len"; then

 51768 +	      :

 51769 +	    else

 51770 +	      # the above command should be used before it gets too long

 51771 +	      oldobjs=$objlist

 51772 +	      if test "$obj" = "$last_oldobj" ; then

 51773 +		RANLIB=$save_RANLIB

 51774 +	      fi

 51775 +	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~

 51776 +	      eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"

 51777 +	      objlist=

 51778 +	    fi

 51779 +	  done

 51780 +	  RANLIB=$save_RANLIB

 51781 +	  oldobjs=$objlist

 51782 +	  if test "X$oldobjs" = "X" ; then

 51783 +	    eval cmds=\"\$concat_cmds\"

 51784 +	  else

 51785 +	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"

 51786 +	  fi

 51787 +	fi

 51788 +      fi

 51789 +      func_execute_cmds "$cmds" 'exit $?'

 51790 +    done

 51791 +

 51792 +    test -n "$generated" && \

 51793 +      func_show_eval "${RM}r$generated"

 51794 +

 51795 +    # Now create the libtool archive.

 51796 +    case $output in

 51797 +    *.la)

 51798 +      old_library=

 51799 +      test "$build_old_libs" = yes && old_library="$libname.$libext"

 51800 +      func_echo "creating $output"

 51801 +

 51802 +      # Preserve any variables that may affect compiler behavior

 51803 +      for var in $variables_saved_for_relink; do

 51804 +	if eval test -z \"\${$var+set}\"; then

 51805 +	  relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"

 51806 +	elif eval var_value=\$$var; test -z "$var_value"; then

 51807 +	  relink_command="$var=; export $var; $relink_command"

 51808 +	else

 51809 +	  func_quote_for_eval "$var_value"

 51810 +	  relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"

 51811 +	fi

 51812 +      done

 51813 +      # Quote the link command for shipping.

 51814 +      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"

 51815 +      relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`

 51816 +      if test "$hardcode_automatic" = yes ; then

 51817 +	relink_command=

 51818 +      fi

 51819 +

 51820 +      # Only create the output if not a dry run.

 51821 +      $opt_dry_run || {

 51822 +	for installed in no yes; do

 51823 +	  if test "$installed" = yes; then

 51824 +	    if test -z "$install_libdir"; then

 51825 +	      break

 51826 +	    fi

 51827 +	    output="$output_objdir/$outputname"i

 51828 +	    # Replace all uninstalled libtool libraries with the installed ones

 51829 +	    newdependency_libs=

 51830 +	    for deplib in $dependency_libs; do

 51831 +	      case $deplib in

 51832 +	      *.la)

 51833 +		func_basename "$deplib"

 51834 +		name="$func_basename_result"

 51835 +		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`

 51836 +		test -z "$libdir" && \

 51837 +		  func_fatal_error "\`$deplib' is not a valid libtool archive"

 51838 +		newdependency_libs="$newdependency_libs $libdir/$name"

 51839 +		;;

 51840 +	      *) newdependency_libs="$newdependency_libs $deplib" ;;

 51841 +	      esac

 51842 +	    done

 51843 +	    dependency_libs="$newdependency_libs"

 51844 +	    newdlfiles=

 51845 +

 51846 +	    for lib in $dlfiles; do

 51847 +	      case $lib in

 51848 +	      *.la)

 51849 +	        func_basename "$lib"

 51850 +		name="$func_basename_result"

 51851 +		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`

 51852 +		test -z "$libdir" && \

 51853 +		  func_fatal_error "\`$lib' is not a valid libtool archive"

 51854 +		newdlfiles="$newdlfiles $libdir/$name"

 51855 +		;;

 51856 +	      *) newdlfiles="$newdlfiles $lib" ;;

 51857 +	      esac

 51858 +	    done

 51859 +	    dlfiles="$newdlfiles"

 51860 +	    newdlprefiles=

 51861 +	    for lib in $dlprefiles; do

 51862 +	      case $lib in

 51863 +	      *.la)

 51864 +		# Only pass preopened files to the pseudo-archive (for

 51865 +		# eventual linking with the app. that links it) if we

 51866 +		# didn't already link the preopened objects directly into

 51867 +		# the library:

 51868 +		func_basename "$lib"

 51869 +		name="$func_basename_result"

 51870 +		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`

 51871 +		test -z "$libdir" && \

 51872 +		  func_fatal_error "\`$lib' is not a valid libtool archive"

 51873 +		newdlprefiles="$newdlprefiles $libdir/$name"

 51874 +		;;

 51875 +	      esac

 51876 +	    done

 51877 +	    dlprefiles="$newdlprefiles"

 51878 +	  else

 51879 +	    newdlfiles=

 51880 +	    for lib in $dlfiles; do

 51881 +	      case $lib in

 51882 +		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

 51883 +		*) abs=`pwd`"/$lib" ;;

 51884 +	      esac

 51885 +	      newdlfiles="$newdlfiles $abs"

 51886 +	    done

 51887 +	    dlfiles="$newdlfiles"

 51888 +	    newdlprefiles=

 51889 +	    for lib in $dlprefiles; do

 51890 +	      case $lib in

 51891 +		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

 51892 +		*) abs=`pwd`"/$lib" ;;

 51893 +	      esac

 51894 +	      newdlprefiles="$newdlprefiles $abs"

 51895 +	    done

 51896 +	    dlprefiles="$newdlprefiles"

 51897 +	  fi

 51898 +	  $RM $output

 51899 +	  # place dlname in correct position for cygwin

 51900 +	  tdlname=$dlname

 51901 +	  case $host,$output,$installed,$module,$dlname in

 51902 +	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;

 51903 +	  esac

 51904 +	  $ECHO > $output "\

 51905 +# $outputname - a libtool library file

 51906 +# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

 51907 +#

 51908 +# Please DO NOT delete this file!

 51909 +# It is necessary for linking the library.

 51910 +

 51911 +# The name that we can dlopen(3).

 51912 +dlname='$tdlname'

 51913 +

 51914 +# Names of this library.

 51915 +library_names='$library_names'

 51916 +

 51917 +# The name of the static archive.

 51918 +old_library='$old_library'

 51919 +

 51920 +# Linker flags that can not go in dependency_libs.

 51921 +inherited_linker_flags='$new_inherited_linker_flags'

 51922 +

 51923 +# Libraries that this one depends upon.

 51924 +dependency_libs='$dependency_libs'

 51925 +

 51926 +# Names of additional weak libraries provided by this library

 51927 +weak_library_names='$weak_libs'

 51928 +

 51929 +# Version information for $libname.

 51930 +current=$current

 51931 +age=$age

 51932 +revision=$revision

 51933 +

 51934 +# Is this an already installed library?

 51935 +installed=$installed

 51936 +

 51937 +# Should we warn about portability when linking against -modules?

 51938 +shouldnotlink=$module

 51939 +

 51940 +# Files to dlopen/dlpreopen

 51941 +dlopen='$dlfiles'

 51942 +dlpreopen='$dlprefiles'

 51943 +

 51944 +# Directory that this library needs to be installed in:

 51945 +libdir='$install_libdir'"

 51946 +	  if test "$installed" = no && test "$need_relink" = yes; then

 51947 +	    $ECHO >> $output "\

 51948 +relink_command=\"$relink_command\""

 51949 +	  fi

 51950 +	done

 51951 +      }

 51952 +

 51953 +      # Do a symbolic link so that the libtool archive can be found in

 51954 +      # LD_LIBRARY_PATH before the program is installed.

 51955 +      func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'

 51956 +      ;;

 51957 +    esac

 51958 +    exit $EXIT_SUCCESS

 51959 +}

 51960 +

 51961 +{ test "$mode" = link || test "$mode" = relink; } &&

 51962 +    func_mode_link ${1+"$@"}

 51963 +

 51964 +

 51965 +# func_mode_uninstall arg...

 51966 +func_mode_uninstall ()

 51967 +{

 51968 +    $opt_debug

 51969 +    RM="$nonopt"

 51970 +    files=

 51971 +    rmforce=

 51972 +    exit_status=0

 51973 +

 51974 +    # This variable tells wrapper scripts just to set variables rather

 51975 +    # than running their programs.

 51976 +    libtool_install_magic="$magic"

 51977 +

 51978 +    for arg

 51979 +    do

 51980 +      case $arg in

 51981 +      -f) RM="$RM $arg"; rmforce=yes ;;

 51982 +      -*) RM="$RM $arg" ;;

 51983 +      *) files="$files $arg" ;;

 51984 +      esac

 51985 +    done

 51986 +

 51987 +    test -z "$RM" && \

 51988 +      func_fatal_help "you must specify an RM program"

 51989 +

 51990 +    rmdirs=

 51991 +

 51992 +    origobjdir="$objdir"

 51993 +    for file in $files; do

 51994 +      func_dirname "$file" "" "."

 51995 +      dir="$func_dirname_result"

 51996 +      if test "X$dir" = X.; then

 51997 +	objdir="$origobjdir"

 51998 +      else

 51999 +	objdir="$dir/$origobjdir"

 52000 +      fi

 52001 +      func_basename "$file"

 52002 +      name="$func_basename_result"

 52003 +      test "$mode" = uninstall && objdir="$dir"

 52004 +

 52005 +      # Remember objdir for removal later, being careful to avoid duplicates

 52006 +      if test "$mode" = clean; then

 52007 +	case " $rmdirs " in

 52008 +	  *" $objdir "*) ;;

 52009 +	  *) rmdirs="$rmdirs $objdir" ;;

 52010 +	esac

 52011 +      fi

 52012 +

 52013 +      # Don't error if the file doesn't exist and rm -f was used.

 52014 +      if { test -L "$file"; } >/dev/null 2>&1 ||

 52015 +	 { test -h "$file"; } >/dev/null 2>&1 ||

 52016 +	 test -f "$file"; then

 52017 +	:

 52018 +      elif test -d "$file"; then

 52019 +	exit_status=1

 52020 +	continue

 52021 +      elif test "$rmforce" = yes; then

 52022 +	continue

 52023 +      fi

 52024 +

 52025 +      rmfiles="$file"

 52026 +

 52027 +      case $name in

 52028 +      *.la)

 52029 +	# Possibly a libtool archive, so verify it.

 52030 +	if func_lalib_p "$file"; then

 52031 +	  func_source $dir/$name

 52032 +

 52033 +	  # Delete the libtool libraries and symlinks.

 52034 +	  for n in $library_names; do

 52035 +	    rmfiles="$rmfiles $objdir/$n"

 52036 +	  done

 52037 +	  test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"

 52038 +

 52039 +	  case "$mode" in

 52040 +	  clean)

 52041 +	    case "  $library_names " in

 52042 +	    # "  " in the beginning catches empty $dlname

 52043 +	    *" $dlname "*) ;;

 52044 +	    *) rmfiles="$rmfiles $objdir/$dlname" ;;

 52045 +	    esac

 52046 +	    test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"

 52047 +	    ;;

 52048 +	  uninstall)

 52049 +	    if test -n "$library_names"; then

 52050 +	      # Do each command in the postuninstall commands.

 52051 +	      func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'

 52052 +	    fi

 52053 +

 52054 +	    if test -n "$old_library"; then

 52055 +	      # Do each command in the old_postuninstall commands.

 52056 +	      func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'

 52057 +	    fi

 52058 +	    # FIXME: should reinstall the best remaining shared library.

 52059 +	    ;;

 52060 +	  esac

 52061 +	fi

 52062 +	;;

 52063 +

 52064 +      *.lo)

 52065 +	# Possibly a libtool object, so verify it.

 52066 +	if func_lalib_p "$file"; then

 52067 +

 52068 +	  # Read the .lo file

 52069 +	  func_source $dir/$name

 52070 +

 52071 +	  # Add PIC object to the list of files to remove.

 52072 +	  if test -n "$pic_object" &&

 52073 +	     test "$pic_object" != none; then

 52074 +	    rmfiles="$rmfiles $dir/$pic_object"

 52075 +	  fi

 52076 +

 52077 +	  # Add non-PIC object to the list of files to remove.

 52078 +	  if test -n "$non_pic_object" &&

 52079 +	     test "$non_pic_object" != none; then

 52080 +	    rmfiles="$rmfiles $dir/$non_pic_object"

 52081 +	  fi

 52082 +	fi

 52083 +	;;

 52084 +

 52085 +      *)

 52086 +	if test "$mode" = clean ; then

 52087 +	  noexename=$name

 52088 +	  case $file in

 52089 +	  *.exe)

 52090 +	    func_stripname '' '.exe' "$file"

 52091 +	    file=$func_stripname_result

 52092 +	    func_stripname '' '.exe' "$name"

 52093 +	    noexename=$func_stripname_result

 52094 +	    # $file with .exe has already been added to rmfiles,

 52095 +	    # add $file without .exe

 52096 +	    rmfiles="$rmfiles $file"

 52097 +	    ;;

 52098 +	  esac

 52099 +	  # Do a test to see if this is a libtool program.

 52100 +	  if func_ltwrapper_p "$file"; then

 52101 +	    relink_command=

 52102 +	    func_source $dir/$noexename

 52103 +

 52104 +	    # note $name still contains .exe if it was in $file originally

 52105 +	    # as does the version of $file that was added into $rmfiles

 52106 +	    rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"

 52107 +	    if test "$fast_install" = yes && test -n "$relink_command"; then

 52108 +	      rmfiles="$rmfiles $objdir/lt-$name"

 52109 +	    fi

 52110 +	    if test "X$noexename" != "X$name" ; then

 52111 +	      rmfiles="$rmfiles $objdir/lt-${noexename}.c"

 52112 +	    fi

 52113 +	  fi

 52114 +	fi

 52115 +	;;

 52116 +      esac

 52117 +      func_show_eval "$RM $rmfiles" 'exit_status=1'

 52118 +    done

 52119 +    objdir="$origobjdir"

 52120 +

 52121 +    # Try to remove the ${objdir}s in the directories where we deleted files

 52122 +    for dir in $rmdirs; do

 52123 +      if test -d "$dir"; then

 52124 +	func_show_eval "rmdir $dir >/dev/null 2>&1"

 52125 +      fi

 52126 +    done

 52127 +

 52128 +    exit $exit_status

 52129 +}

 52130 +

 52131 +{ test "$mode" = uninstall || test "$mode" = clean; } &&

 52132 +    func_mode_uninstall ${1+"$@"}

 52133 +

 52134 +test -z "$mode" && {

 52135 +  help="$generic_help"

 52136 +  func_fatal_help "you must specify a MODE"

 52137 +}

 52138 +

 52139 +test -z "$exec_cmd" && \

 52140 +  func_fatal_help "invalid operation mode \`$mode'"

 52141 +

 52142 +if test -n "$exec_cmd"; then

 52143 +  eval exec "$exec_cmd"

 52144 +  exit $EXIT_FAILURE

 52145 +fi

 52146 +

 52147 +exit $exit_status

 52148 +

 52149 +

 52150 +# The TAGs below are defined such that we never get into a situation

 52151 +# in which we disable both kinds of libraries.  Given conflicting

 52152 +# choices, we go for a static library, that is the most portable,

 52153 +# since we can't tell whether shared libraries were disabled because

 52154 +# the user asked for that or because the platform doesn't support

 52155 +# them.  This is particularly important on AIX, because we don't

 52156 +# support having both static and shared libraries enabled at the same

 52157 +# time on that platform, so we default to a shared-only configuration.

 52158 +# If a disable-shared tag is given, we'll fallback to a static-only

 52159 +# configuration.  But we'll never go from static-only to shared-only.

 52160 +

 52161 +# ### BEGIN LIBTOOL TAG CONFIG: disable-shared

 52162 +build_libtool_libs=no

 52163 +build_old_libs=yes

 52164 +# ### END LIBTOOL TAG CONFIG: disable-shared

 52165 +

 52166 +# ### BEGIN LIBTOOL TAG CONFIG: disable-static

 52167 +build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`

 52168 +# ### END LIBTOOL TAG CONFIG: disable-static

 52169 +

 52170 +# Local Variables:

 52171 +# mode:shell-script

 52172 +# sh-indentation:2

 52173 +# End:

 52174 +# vi:sw=2

 52175 --- a/bfd/Makefile.in

 52176 +++ b/bfd/Makefile.in

 52177 @@ -312,6 +312,7 @@ ALL_MACHINES = \

 52178  	cpu-arc.lo \

 52179  	cpu-arm.lo \

 52180  	cpu-avr.lo \

 52181 +	cpu-avr32.lo \

 52182  	cpu-bfin.lo \

 52183  	cpu-cr16.lo \

 52184  	cpu-cr16c.lo \

 52185 @@ -493,6 +494,7 @@ BFD32_BACKENDS = \

 52186  	elf32-arc.lo \

 52187  	elf32-arm.lo \

 52188  	elf32-avr.lo \

 52189 +	elf32-avr32.lo \

 52190  	elf32-bfin.lo \

 52191  	elf32-cr16.lo \

 52192  	elf32-cr16c.lo \

 52193 @@ -1908,6 +1910,10 @@ elf32-cr16.lo: elf32-cr16.c $(INCDIR)/fi

 52194    $(INCDIR)/hashtab.h $(INCDIR)/libiberty.h elf-bfd.h \

 52195    $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \

 52196    $(INCDIR)/elf/cr16.h $(INCDIR)/elf/reloc-macros.h elf32-target.h

 52197 +elf32-avr32.lo: elf32-avr32.c $(INCDIR)/filenames.h elf-bfd.h \

 52198 +  $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \

 52199 +  $(INCDIR)/bfdlink.h $(INCDIR)/elf/avr32.h $(INCDIR)/elf/reloc-macros.h \

 52200 +  elf32-target.h

 52201  elf32-cr16c.lo: elf32-cr16c.c $(INCDIR)/filenames.h \

 52202    $(INCDIR)/hashtab.h $(INCDIR)/bfdlink.h $(INCDIR)/elf/cr16c.h \

 52203    $(INCDIR)/elf/reloc-macros.h elf-bfd.h $(INCDIR)/elf/common.h \

 52204 --- /dev/null

 52205 +++ b/bfd/po/Makefile.in

 52206 @@ -0,0 +1,297 @@

 52207 +# Makefile for program source directory in GNU NLS utilities package.

 52208 +# Copyright (C) 1995, 1996, 1997 by Ulrich Drepper <drepper@gnu.ai.mit.edu>

 52209 +# Copyright 2001, 2003, 2006 Free Software Foundation, Inc.

 52210 +#

 52211 +# This file may be copied and used freely without restrictions.  It can

 52212 +# be used in projects which are not available under the GNU Public License

 52213 +# but which still want to provide support for the GNU gettext functionality.

 52214 +# Please note that the actual code is *not* freely available.

 52215 +

 52216 +PACKAGE = bfd

 52217 +VERSION = 2.18.atmel.1.0.1.avr32linux.1

 52218 +

 52219 +SHELL = /bin/sh

 52220 +

 52221 +

 52222 +srcdir = .

 52223 +top_srcdir = ..

 52224 +

 52225 +top_builddir = ..

 52226 +

 52227 +prefix = /usr

 52228 +exec_prefix = ${prefix}

 52229 +datadir = $(prefix)/share

 52230 +localedir = $(datadir)/locale

 52231 +gnulocaledir = $(prefix)/share/locale

 52232 +gettextsrcdir = $(prefix)/share/gettext/po

 52233 +subdir = po

 52234 +

 52235 +DESTDIR =

 52236 +

 52237 +INSTALL = /usr/bin/install -c

 52238 +INSTALL_DATA = ${INSTALL} -m 644

 52239 +MKINSTALLDIRS = $(top_builddir)/./../mkinstalldirs

 52240 +

 52241 +CC = gcc

 52242 +GENCAT = gencat

 52243 +GMSGFMT = PATH=../src:$$PATH /usr/bin/msgfmt

 52244 +MSGFMT = /usr/bin/msgfmt

 52245 +XGETTEXT = PATH=../src:$$PATH /usr/bin/xgettext

 52246 +MSGMERGE = PATH=../src:$$PATH msgmerge

 52247 +

 52248 +DEFS = -DHAVE_CONFIG_H

 52249 +CFLAGS = -g -O2

 52250 +CPPFLAGS =

 52251 +

 52252 +INCLUDES = -I.. -I$(top_srcdir)/intl

 52253 +

 52254 +COMPILE = $(CC) -c $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS) $(XCFLAGS)

 52255 +

 52256 +SOURCES = cat-id-tbl.c

 52257 +POFILES = @POFILES@

 52258 +GMOFILES = @GMOFILES@

 52259 +DISTFILES = ChangeLog Makefile.in.in SRC-POTFILES.in BLD-POTFILES.in $(PACKAGE).pot \

 52260 +stamp-cat-id $(POFILES) $(GMOFILES) $(SOURCES)

 52261 +

 52262 +# Note - the following line gets processed by bfd/configure and amended

 52263 +# to contain the full list of source dir POTFILES.

 52264 +SRC-POTFILES = \

 52265 +

 52266 +# Note - the following line gets processed by bfd/configure and amended

 52267 +# to contain the full list of build dir POTFILES.

 52268 +BLD-POTFILES = \

 52269 +

 52270 +CATALOGS =  da.gmo es.gmo fr.gmo ja.gmo ro.gmo rw.gmo sv.gmo tr.gmo vi.gmo zh_CN.gmo da.gmo es.gmo fr.gmo ja.gmo ro.gmo rw.gmo sv.gmo tr.gmo vi.gmo zh_CN.gmo

 52271 +CATOBJEXT = .gmo

 52272 +INSTOBJEXT = .mo

 52273 +

 52274 +.SUFFIXES:

 52275 +.SUFFIXES: .c .o .po .pox .gmo .mo .msg .cat

 52276 +

 52277 +.c.o:

 52278 +	$(COMPILE) $<

 52279 +

 52280 +.po.pox:

 52281 +	$(MAKE) $(PACKAGE).pot

 52282 +	$(MSGMERGE) $< $(srcdir)/$(PACKAGE).pot -o $*.pox

 52283 +

 52284 +.po.mo:

 52285 +	$(MSGFMT) -o $@ $<

 52286 +

 52287 +.po.gmo:

 52288 +	file=`echo $* | sed 's,.*/,,'`.gmo \

 52289 +	  && rm -f $$file && $(GMSGFMT) -o $$file $<

 52290 +

 52291 +.po.cat:

 52292 +	sed -f ../intl/po2msg.sed < $< > $*.msg \

 52293 +	  && rm -f $@ && $(GENCAT) $@ $*.msg

 52294 +

 52295 +

 52296 +all: all-yes

 52297 +

 52298 +all-yes: $(CATALOGS) # $(PACKAGE).pot

 52299 +all-no:

 52300 +

 52301 +$(srcdir)/$(PACKAGE).pot: $(SRC-POTFILES) $(BLD-POTFILES)

 52302 +	$(XGETTEXT) --default-domain=$(PACKAGE) \

 52303 +	  --directory=$(top_srcdir) \

 52304 +	  --add-comments --keyword=_ --keyword=N_ \

 52305 +	  --msgid-bugs-address=bug-binutils@gnu.org \

 52306 +	  --files-from=$(srcdir)/SRC-POTFILES.in

 52307 +	$(XGETTEXT) --default-domain=$(PACKAGE) \

 52308 +	  --directory=.. \

 52309 +	  --directory=. \

 52310 +	  --add-comments --keyword=_ --keyword=N_ \

 52311 +	  --join-existing \

 52312 +	  --msgid-bugs-address=bug-binutils@gnu.org \

 52313 +	  --files-from=$(srcdir)/BLD-POTFILES.in

 52314 +	rm -f $(srcdir)/$(PACKAGE).pot

 52315 +	mv $(PACKAGE).po $(srcdir)/$(PACKAGE).pot

 52316 +

 52317 +$(srcdir)/cat-id-tbl.c: stamp-cat-id; @:

 52318 +$(srcdir)/stamp-cat-id: $(PACKAGE).pot

 52319 +	rm -f cat-id-tbl.tmp

 52320 +	sed -f ../intl/po2tbl.sed $(srcdir)/$(PACKAGE).pot \

 52321 +		| sed -e "s/@PACKAGE NAME@/$(PACKAGE)/" > cat-id-tbl.tmp

 52322 +	if cmp -s cat-id-tbl.tmp $(srcdir)/cat-id-tbl.c; then \

 52323 +	  rm cat-id-tbl.tmp; \

 52324 +	else \

 52325 +	  echo cat-id-tbl.c changed; \

 52326 +	  rm -f $(srcdir)/cat-id-tbl.c; \

 52327 +	  mv cat-id-tbl.tmp $(srcdir)/cat-id-tbl.c; \

 52328 +	fi

 52329 +	cd $(srcdir) && rm -f stamp-cat-id && echo timestamp > stamp-cat-id

 52330 +

 52331 +

 52332 +install: install-exec install-data

 52333 +install-exec:

 52334 +install-info:

 52335 +install-html:

 52336 +install-data: install-data-yes

 52337 +install-data-no: all

 52338 +install-data-yes: all

 52339 +	if test -r $(MKINSTALLDIRS); then \

 52340 +	  $(MKINSTALLDIRS) $(DESTDIR)$(datadir); \

 52341 +	else \

 52342 +	  $(top_srcdir)/mkinstalldirs $(DESTDIR)$(datadir); \

 52343 +	fi

 52344 +	@catalogs='$(CATALOGS)'; \

 52345 +	for cat in $$catalogs; do \

 52346 +	  cat=`basename $$cat`; \

 52347 +	  case "$$cat" in \

 52348 +	    *.gmo) destdir=$(gnulocaledir);; \

 52349 +	    *)     destdir=$(localedir);; \

 52350 +	  esac; \

 52351 +	  lang=`echo $$cat | sed 's/\$(CATOBJEXT)$$//'`; \

 52352 +	  dir=$(DESTDIR)$$destdir/$$lang/LC_MESSAGES; \

 52353 +	  if test -r $(MKINSTALLDIRS); then \

 52354 +	    $(MKINSTALLDIRS) $$dir; \

 52355 +	  else \

 52356 +	    $(top_srcdir)/mkinstalldirs $$dir; \

 52357 +	  fi; \

 52358 +	  if test -r $$cat; then \

 52359 +	    $(INSTALL_DATA) $$cat $$dir/$(PACKAGE)$(INSTOBJEXT); \

 52360 +	    echo "installing $$cat as $$dir/$(PACKAGE)$(INSTOBJEXT)"; \

 52361 +	  else \

 52362 +	    $(INSTALL_DATA) $(srcdir)/$$cat $$dir/$(PACKAGE)$(INSTOBJEXT); \

 52363 +	    echo "installing $(srcdir)/$$cat as" \

 52364 +		 "$$dir/$(PACKAGE)$(INSTOBJEXT)"; \

 52365 +	  fi; \

 52366 +	  if test -r $$cat.m; then \

 52367 +	    $(INSTALL_DATA) $$cat.m $$dir/$(PACKAGE)$(INSTOBJEXT).m; \

 52368 +	    echo "installing $$cat.m as $$dir/$(PACKAGE)$(INSTOBJEXT).m"; \

 52369 +	  else \

 52370 +	    if test -r $(srcdir)/$$cat.m ; then \

 52371 +	      $(INSTALL_DATA) $(srcdir)/$$cat.m \

 52372 +		$$dir/$(PACKAGE)$(INSTOBJEXT).m; \

 52373 +	      echo "installing $(srcdir)/$$cat as" \

 52374 +		   "$$dir/$(PACKAGE)$(INSTOBJEXT).m"; \

 52375 +	    else \

 52376 +	      true; \

 52377 +	    fi; \

 52378 +	  fi; \

 52379 +	done

 52380 +	if test "$(PACKAGE)" = "gettext"; then \

 52381 +	  if test -r $(MKINSTALLDIRS); then \

 52382 +	    $(MKINSTALLDIRS) $(DESTDIR)$(gettextsrcdir); \

 52383 +	  else \

 52384 +	    $(top_srcdir)/mkinstalldirs $(DESTDIR)$(gettextsrcdir); \

 52385 +	  fi; \

 52386 +	  $(INSTALL_DATA) $(srcdir)/Makefile.in.in \

 52387 +			  $(DESTDIR)$(gettextsrcdir)/Makefile.in.in; \

 52388 +	else \

 52389 +	  : ; \

 52390 +	fi

 52391 +

 52392 +# Define this as empty until I found a useful application.

 52393 +installcheck:

 52394 +

 52395 +uninstall:

 52396 +	catalogs='$(CATALOGS)'; \

 52397 +	for cat in $$catalogs; do \

 52398 +	  cat=`basename $$cat`; \

 52399 +	  lang=`echo $$cat | sed 's/\$(CATOBJEXT)$$//'`; \

 52400 +	  rm -f $(DESTDIR)$(localedir)/$$lang/LC_MESSAGES/$(PACKAGE)$(INSTOBJEXT); \

 52401 +	  rm -f $(DESTDIR)$(localedir)/$$lang/LC_MESSAGES/$(PACKAGE)$(INSTOBJEXT).m; \

 52402 +	  rm -f $(DESTDIR)$(gnulocaledir)/$$lang/LC_MESSAGES/$(PACKAGE)$(INSTOBJEXT); \

 52403 +	  rm -f $(DESTDIR)$(gnulocaledir)/$$lang/LC_MESSAGES/$(PACKAGE)$(INSTOBJEXT).m; \

 52404 +	done

 52405 +	rm -f $(DESTDIR)$(gettextsrcdir)/po-Makefile.in.in

 52406 +

 52407 +check: all

 52408 +

 52409 +cat-id-tbl.o: ../intl/libgettext.h

 52410 +

 52411 +html dvi pdf ps info tags TAGS ID:

 52412 +

 52413 +mostlyclean:

 52414 +	rm -f core core.* *.pox $(PACKAGE).po *.old.po cat-id-tbl.tmp

 52415 +	rm -fr *.o

 52416 +

 52417 +clean: mostlyclean

 52418 +

 52419 +distclean: clean

 52420 +	rm -f Makefile Makefile.in *.mo *.msg *.cat *.cat.m

 52421 +	rm -f SRC-POTFILES BLD-POTFILES

 52422 +

 52423 +maintainer-clean: distclean

 52424 +	@echo "This command is intended for maintainers to use;"

 52425 +	@echo "it deletes files that may require special tools to rebuild."

 52426 +	rm -f $(GMOFILES) SRC-POTFILES.in BLD-POTFILES.in

 52427 +

 52428 +distdir = ../$(PACKAGE)-$(VERSION)/$(subdir)

 52429 +dist distdir: update-po $(DISTFILES)

 52430 +	dists="$(DISTFILES)"; \

 52431 +	for file in $$dists; do \

 52432 +	  ln $(srcdir)/$$file $(distdir) 2> /dev/null \

 52433 +	    || cp -p $(srcdir)/$$file $(distdir); \

 52434 +	done

 52435 +

 52436 +update-po: Makefile

 52437 +	$(MAKE) $(PACKAGE).pot

 52438 +	PATH=`pwd`/../src:$$PATH; \

 52439 +	cd $(srcdir); \

 52440 +	catalogs='$(CATALOGS)'; \

 52441 +	for cat in $$catalogs; do \

 52442 +	  cat=`basename $$cat`; \

 52443 +	  lang=`echo $$cat | sed 's/\$(CATOBJEXT)$$//'`; \

 52444 +	  mv $$lang.po $$lang.old.po; \

 52445 +	  echo "$$lang:"; \

 52446 +	  if $(MSGMERGE) $$lang.old.po $(PACKAGE).pot -o $$lang.po; then \

 52447 +	    rm -f $$lang.old.po; \

 52448 +	  else \

 52449 +	    echo "msgmerge for $$cat failed!"; \

 52450 +	    rm -f $$lang.po; \

 52451 +	    mv $$lang.old.po $$lang.po; \

 52452 +	  fi; \

 52453 +	done

 52454 +

 52455 +SRC-POTFILES: SRC-POTFILES.in

 52456 +	( if test 'x$(srcdir)' != 'x.'; then \

 52457 +	    posrcprefix='$(top_srcdir)/'; \

 52458 +	  else \

 52459 +	    posrcprefix="../"; \

 52460 +	  fi; \

 52461 +	  rm -f $@-t $@ \

 52462 +	    && (sed -e '/^#/d' \

 52463 +	            -e '/^[ 	]*$$/d' \

 52464 +		    -e "s@.*@	$$posrcprefix& \\\\@" < $(srcdir)/$@.in \

 52465 +		| sed -e '$$s/\\$$//') > $@-t \

 52466 +	    && chmod a-w $@-t \

 52467 +	    && mv $@-t $@ )

 52468 +

 52469 +BLD-POTFILES: BLD-POTFILES.in

 52470 +	  ( rm -f $@-t $@ \

 52471 +	    && (sed -e '/^#/d' \

 52472 +	            -e '/^[ 	]*$$/d' \

 52473 +		    -e "s@.*@	../& \\\\@" < $(srcdir)/$@.in \

 52474 +		| sed -e '$$s/\\$$//') > $@-t \

 52475 +	    && chmod a-w $@-t \

 52476 +	    && mv $@-t $@ )

 52477 +

 52478 +SRC-POTFILES.in: # ../Makefile

 52479 +	cd .. && $(MAKE) po/SRC-POTFILES.in

 52480 +

 52481 +BLD-POTFILES.in: # ../Makefile

 52482 +	cd .. && $(MAKE) po/BLD-POTFILES.in

 52483 +

 52484 +# Note - The presence of SRC-POTFILES and BLD-POTFILES as dependencies

 52485 +# here breaks the implementation of the 'distclean' rule for maintainers.

 52486 +# This is because if 'make distclean' is run in the BFD directory, the

 52487 +# Makefile there will be deleted before 'distclean' is made here, and so

 52488 +# the dependency SRC-POTFILES -> SRC-POTFILES.in -> ../Makefile cannot

 52489 +# be satisfied.

 52490 +#

 52491 +# The SRC-POTFILES and BLD-POTFILES dependencies cannot be removed,

 52492 +# however since it is necessary that these files be built during

 52493 +# *configure* time, so that configure can insert them into the

 52494 +# po/Makefile that it is creating, so that the Makefile will have

 52495 +# the correct dependencies.

 52496 +Makefile: Make-in ../config.status SRC-POTFILES BLD-POTFILES

 52497 +	cd .. \

 52498 +	  && CONFIG_FILES=$(subdir)/Makefile.in:$(subdir)/Make-in \

 52499 +	     CONFIG_HEADERS= $(SHELL) ./config.status

 52500 +

 52501 +# Tell versions [3.59,3.63) of GNU make not to export all variables.

 52502 +# Otherwise a system limit (for SysV at least) may be exceeded.

 52503 +.NOEXPORT:

 52504 --- a/binutils/Makefile.in

 52505 +++ b/binutils/Makefile.in

 52506 @@ -1327,7 +1327,7 @@ readelf.o: readelf.c sysdep.h $(INCDIR)/

 52507    $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h bucomm.h dwarf.h \

 52508    $(INCDIR)/elf/common.h $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h \

 52509    $(INCDIR)/elf/h8.h $(INCDIR)/elf/reloc-macros.h $(INCDIR)/elf/alpha.h \

 52510 -  $(INCDIR)/elf/arc.h $(INCDIR)/elf/arm.h $(INCDIR)/elf/avr.h \

 52511 +  $(INCDIR)/elf/arc.h $(INCDIR)/elf/arm.h $(INCDIR)/elf/avr.h $(INCDIR)/elf/avr32.h\

 52512    $(INCDIR)/elf/bfin.h $(INCDIR)/elf/cris.h $(INCDIR)/elf/crx.h \

 52513    $(INCDIR)/elf/d10v.h $(INCDIR)/elf/d30v.h $(INCDIR)/elf/dlx.h \

 52514    $(INCDIR)/elf/fr30.h $(INCDIR)/elf/frv.h $(INCDIR)/elf/hppa.h \

 52515 --- a/ld/Makefile.in

 52516 +++ b/ld/Makefile.in

 52517 @@ -384,7 +384,34 @@ ALL_EMULATIONS = \

 52518  	eavr3.o \

 52519  	eavr4.o \

 52520  	eavr5.o \

 52521 -	eavr6.o \

 52522 +    eavr6.o \

 52523 +	eavr32elf_ap7000.o \

 52524 +	eavr32elf_ap7001.o \

 52525 +	eavr32elf_ap7002.o \

 52526 +	eavr32elf_ap7200.o \

 52527 +	eavr32elf_uc3a0128.o \

 52528 +	eavr32elf_uc3a0256.o \

 52529 +	eavr32elf_uc3a0512.o \

 52530 +	eavr32elf_uc3a0512es.o \

 52531 +	eavr32elf_uc3a1128.o \

 52532 +	eavr32elf_uc3a1256.o \

 52533 +	eavr32elf_uc3a1512es.o \

 52534 +	eavr32elf_uc3a1512.o \

 52535 +	eavr32elf_uc3a364.o \

 52536 +	eavr32elf_uc3a364s.o \

 52537 +	eavr32elf_uc3a3128.o \

 52538 +	eavr32elf_uc3a3128s.o \

 52539 +	eavr32elf_uc3a3256.o \

 52540 +	eavr32elf_uc3a3256s.o \

 52541 +	eavr32elf_uc3b064.o \

 52542 +	eavr32elf_uc3b0128.o \

 52543 +	eavr32elf_uc3b0256es.o \

 52544 +	eavr32elf_uc3b0256.o \

 52545 +	eavr32elf_uc3b164.o \

 52546 +	eavr32elf_uc3b1128.o \

 52547 +	eavr32elf_uc3b1256es.o \

 52548 +	eavr32elf_uc3b1256.o \

 52549 +	eavr32linux.o \

 52550  	ecoff_i860.o \

 52551  	ecoff_sparc.o \

 52552  	eelf32_spu.o \

 52553 @@ -1448,6 +1475,114 @@ eavr6.c: $(srcdir)/emulparams/avr6.sh $(

 52554    $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \

 52555    ${GEN_DEPENDS}

 52556  	${GENSCRIPTS} avr6 "$(tdir_avr2)"

 52557 +eavr32elf_ap7000.c: $(srcdir)/emulparams/avr32elf.sh \

 52558 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52559 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52560 +	${GENSCRIPTS} avr32elf_ap7000 "$(tdir_avr32)" avr32elf

 52561 +eavr32elf_ap7001.c: $(srcdir)/emulparams/avr32elf.sh \

 52562 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52563 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52564 +	${GENSCRIPTS} avr32elf_ap7001 "$(tdir_avr32)" avr32elf

 52565 +eavr32elf_ap7002.c: $(srcdir)/emulparams/avr32elf.sh \

 52566 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52567 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52568 +	${GENSCRIPTS} avr32elf_ap7002 "$(tdir_avr32)" avr32elf

 52569 +eavr32elf_ap7200.c: $(srcdir)/emulparams/avr32elf.sh \

 52570 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52571 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52572 +	${GENSCRIPTS} avr32elf_ap7200 "$(tdir_avr32)" avr32elf

 52573 +eavr32elf_uc3a0128.c: $(srcdir)/emulparams/avr32elf.sh \

 52574 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52575 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52576 +	${GENSCRIPTS} avr32elf_uc3a0128 "$(tdir_avr32)" avr32elf

 52577 +eavr32elf_uc3a0256.c: $(srcdir)/emulparams/avr32elf.sh \

 52578 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52579 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52580 +	${GENSCRIPTS} avr32elf_uc3a0256 "$(tdir_avr32)" avr32elf

 52581 +eavr32elf_uc3a0512.c: $(srcdir)/emulparams/avr32elf.sh \

 52582 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52583 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52584 +	${GENSCRIPTS} avr32elf_uc3a0512 "$(tdir_avr32)" avr32elf

 52585 +eavr32elf_uc3a0512es.c: $(srcdir)/emulparams/avr32elf.sh \

 52586 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52587 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52588 +	${GENSCRIPTS} avr32elf_uc3a0512es "$(tdir_avr32)" avr32elf

 52589 +eavr32elf_uc3a1128.c: $(srcdir)/emulparams/avr32elf.sh \

 52590 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52591 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52592 +	${GENSCRIPTS} avr32elf_uc3a1128 "$(tdir_avr32)" avr32elf

 52593 +eavr32elf_uc3a1256.c: $(srcdir)/emulparams/avr32elf.sh \

 52594 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52595 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52596 +	${GENSCRIPTS} avr32elf_uc3a1256 "$(tdir_avr32)" avr32elf

 52597 +eavr32elf_uc3a1512.c: $(srcdir)/emulparams/avr32elf.sh \

 52598 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52599 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52600 +	${GENSCRIPTS} avr32elf_uc3a1512 "$(tdir_avr32)" avr32elf

 52601 +eavr32elf_uc3a1512es.c: $(srcdir)/emulparams/avr32elf.sh \

 52602 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52603 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52604 +	${GENSCRIPTS} avr32elf_uc3a1512es "$(tdir_avr32)" avr32elf

 52605 +eavr32elf_uc3a364.c: $(srcdir)/emulparams/avr32elf.sh \

 52606 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52607 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52608 +	${GENSCRIPTS} avr32elf_uc3a364 "$(tdir_avr32)" avr32elf

 52609 +eavr32elf_uc3a364s.c: $(srcdir)/emulparams/avr32elf.sh \

 52610 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52611 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52612 +	${GENSCRIPTS} avr32elf_uc3a364s "$(tdir_avr32)" avr32elf

 52613 +eavr32elf_uc3a3128.c: $(srcdir)/emulparams/avr32elf.sh \

 52614 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52615 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52616 +	${GENSCRIPTS} avr32elf_uc3a3128 "$(tdir_avr32)" avr32elf

 52617 +eavr32elf_uc3a3128s.c: $(srcdir)/emulparams/avr32elf.sh \

 52618 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52619 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52620 +	${GENSCRIPTS} avr32elf_uc3a3128s "$(tdir_avr32)" avr32elf

 52621 +eavr32elf_uc3a3256.c: $(srcdir)/emulparams/avr32elf.sh \

 52622 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52623 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52624 +	${GENSCRIPTS} avr32elf_uc3a3256 "$(tdir_avr32)" avr32elf

 52625 +eavr32elf_uc3a3256s.c: $(srcdir)/emulparams/avr32elf.sh \

 52626 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52627 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52628 +	${GENSCRIPTS} avr32elf_uc3a3256s "$(tdir_avr32)" avr32elf

 52629 +eavr32elf_uc3b064.c: $(srcdir)/emulparams/avr32elf.sh \

 52630 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52631 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52632 +	${GENSCRIPTS} avr32elf_uc3b064 "$(tdir_avr32)" avr32elf

 52633 +eavr32elf_uc3b0128.c: $(srcdir)/emulparams/avr32elf.sh \

 52634 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52635 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52636 +	${GENSCRIPTS} avr32elf_uc3b0128 "$(tdir_avr32)" avr32elf

 52637 +eavr32elf_uc3b0256.c: $(srcdir)/emulparams/avr32elf.sh \

 52638 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52639 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52640 +	${GENSCRIPTS} avr32elf_uc3b0256 "$(tdir_avr32)" avr32elf

 52641 +eavr32elf_uc3b0256es.c: $(srcdir)/emulparams/avr32elf.sh \

 52642 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52643 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52644 +	${GENSCRIPTS} avr32elf_uc3b0256es "$(tdir_avr32)" avr32elf

 52645 +eavr32elf_uc3b164.c: $(srcdir)/emulparams/avr32elf.sh \

 52646 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52647 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52648 +	${GENSCRIPTS} avr32elf_uc3b164 "$(tdir_avr32)" avr32elf

 52649 +eavr32elf_uc3b1128.c: $(srcdir)/emulparams/avr32elf.sh \

 52650 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52651 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52652 +	${GENSCRIPTS} avr32elf_uc3b1128 "$(tdir_avr32)" avr32elf

 52653 +eavr32elf_uc3b1256.c: $(srcdir)/emulparams/avr32elf.sh \

 52654 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52655 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52656 +	${GENSCRIPTS} avr32elf_uc3b1256 "$(tdir_avr32)" avr32elf

 52657 +eavr32elf_uc3b1256es.c: $(srcdir)/emulparams/avr32elf.sh \

 52658 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52659 +  $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}

 52660 +	${GENSCRIPTS} avr32elf_uc3b1256es "$(tdir_avr32)" avr32elf

 52661 +eavr32linux.c: $(srcdir)/emulparams/avr32linux.sh \

 52662 +  $(srcdir)/emultempl/elf32.em $(srcdir)/emultempl/avr32elf.em \

 52663 +  $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS}

 52664 +	${GENSCRIPTS} avr32linux "$(tdir_avr32)"

 52665  ecoff_i860.c: $(srcdir)/emulparams/coff_i860.sh \

 52666    $(srcdir)/emultempl/generic.em $(srcdir)/scripttempl/i860coff.sc ${GEN_DEPENDS}

 52667  	${GENSCRIPTS} coff_i860 "$(tdir_coff_i860)"

 52668 @@ -2679,7 +2814,9 @@ install-exec-local: ld-new$(EXEEXT)

 52669  	  || $(LIBTOOL) --mode=install $(INSTALL_PROGRAM) ld-new$(EXEEXT) $(DESTDIR)$(tooldir)/bin/ld$(EXEEXT); \

 52670  	fi

 52672 -install-data-local:

 52673 +# We want install to imply install-info as per GNU standards, despite the

 52674 +# cygnus option.

 52675 +install-data-local: install-info

 52676  	$(mkinstalldirs) $(DESTDIR)$(scriptdir)/ldscripts

 52677  	for f in ldscripts/*; do \

 52678  	  $(INSTALL_DATA) $$f $(DESTDIR)$(scriptdir)/$$f ; \

 52679 --- /dev/null

 52680 +++ b/libiberty/required-list

 52681 @@ -0,0 +1 @@

 52682 +./regex.o ./cplus-dem.o ./cp-demangle.o ./md5.o ./alloca.o ./argv.o ./choose-temp.o ./concat.o ./cp-demint.o ./dyn-string.o ./fdmatch.o ./fibheap.o ./filename_cmp.o ./floatformat.o ./fnmatch.o ./fopen_unlocked.o ./getopt.o ./getopt1.o ./getpwd.o ./getruntime.o ./hashtab.o ./hex.o ./lbasename.o ./lrealpath.o ./make-relative-prefix.o ./make-temp-file.o ./objalloc.o ./obstack.o ./partition.o ./pexecute.o ./physmem.o ./pex-common.o ./pex-one.o ./pex-unix.o ./safe-ctype.o ./sort.o ./spaces.o ./splay-tree.o ./strerror.o ./strsignal.o ./unlink-if-ordinary.o ./xatexit.o ./xexit.o ./xmalloc.o ./xmemdup.o ./xstrdup.o ./xstrerror.o ./xstrndup.o

 52683 --- a/opcodes/configure

 52684 +++ b/opcodes/configure

 52685 @@ -11418,6 +11418,7 @@ if test x${all_targets} = xfalse ; then

 52686  	bfd_arc_arch)		ta="$ta arc-dis.lo arc-opc.lo arc-ext.lo" ;;

 52687  	bfd_arm_arch)		ta="$ta arm-dis.lo" ;;

 52688  	bfd_avr_arch)		ta="$ta avr-dis.lo" ;;

 52689 +	bfd_avr32_arch)		ta="$ta avr32-asm.lo avr32-dis.lo avr32-opc.lo" ;;

 52690  	bfd_bfin_arch)		ta="$ta bfin-dis.lo" ;;

 52691  	bfd_cr16_arch)    	ta="$ta cr16-dis.lo cr16-opc.lo" ;;

 52692  	bfd_cris_arch)		ta="$ta cris-dis.lo cris-opc.lo cgen-bitset.lo" ;;

 52693 @@ -11476,7 +11477,7 @@ if test x${all_targets} = xfalse ; then

 52694  				ta="$ta sh64-dis.lo sh64-opc.lo"

 52695  				archdefs="$archdefs -DINCLUDE_SHMEDIA"

 52696  				break;;

 52697 -	    esac;

 52698 +	    esac

 52699  	  done

 52700  				ta="$ta sh-dis.lo cgen-bitset.lo" ;;

 52701  	bfd_sparc_arch)		ta="$ta sparc-dis.lo sparc-opc.lo" ;;

 52702 --- a/opcodes/Makefile.in

 52703 +++ b/opcodes/Makefile.in

 52704 @@ -257,6 +257,7 @@ LIBIBERTY = ../libiberty/libiberty.a

 52705  # Header files.

 52706  HFILES = \

 52707  	cgen-ops.h cgen-types.h \

 52708 +	avr32-asm.h avr32-opc.h \

 52709  	fr30-desc.h fr30-opc.h \

 52710  	frv-desc.h frv-opc.h \

 52711  	h8500-opc.h \

 52712 @@ -291,6 +292,9 @@ CFILES = \

 52713  	arc-ext.c \

 52714  	arm-dis.c \

 52715  	avr-dis.c \

 52716 +	avr32-asm.c \

 52717 +	avr32-dis.c \

 52718 +	avr32-opc.c \

 52719  	bfin-dis.c \

 52720  	cgen-asm.c \

 52721  	cgen-bitset.c \

 52722 @@ -445,6 +449,9 @@ ALL_MACHINES = \

 52723  	arc-ext.lo \

 52724  	arm-dis.lo \

 52725  	avr-dis.lo \

 52726 +	avr32-asm.lo \

 52727 +	avr32-dis.lo \

 52728 +	avr32-opc.lo \

 52729  	bfin-dis.lo \

 52730  	cgen-asm.lo \

 52731  	cgen-bitset.lo \

 52732 @@ -1225,6 +1232,15 @@ avr-dis.lo: avr-dis.c sysdep.h config.h

 52733    $(INCDIR)/dis-asm.h $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h \

 52734    opintl.h $(INCDIR)/libiberty.h $(INCDIR)/ansidecl.h \

 52735    $(INCDIR)/opcode/avr.h

 52736 +avr32-asm.lo: avr32-asm.c sysdep.h config.h $(INCDIR)/ansidecl.h \

 52737 +  $(BFD_H) $(INCDIR)/symcat.h avr32-opc.h opintl.h \

 52738 +  $(INCDIR)/xregex.h $(INCDIR)/xregex2.h \

 52739 +  $(INCDIR)/libiberty.h $(INCDIR)/safe-ctype.h

 52740 +avr32-dis.lo: avr32-dis.c sysdep.h config.h $(INCDIR)/ansidecl.h \

 52741 +  $(INCDIR)/dis-asm.h $(BFD_H) $(INCDIR)/symcat.h $(INCDIR)/libiberty.h \

 52742 +  avr32-opc.h opintl.h

 52743 +avr32-opc.lo: avr32-opc.c sysdep.h config.h $(INCDIR)/ansidecl.h \

 52744 +  $(BFD_H) $(INCDIR)/symcat.h avr32-opc.h $(INCDIR)/libiberty.h

 52745  bfin-dis.lo: bfin-dis.c $(INCDIR)/opcode/bfin.h $(INCDIR)/dis-asm.h \

 52746    $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h

 52747  cgen-asm.lo: cgen-asm.c sysdep.h config.h $(INCDIR)/ansidecl.h \

author	"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
	Sun Sep 11 18:18:53 2011 +0200 (2011-09-11)
changeset 2664	346263a07115
parent 1371	patches/binutils/2.18/130-avr32-atmel-v1.0.1.patch@802c132f1f71
permissions	-rw-r--r--