bfd/elf32-xtensa.c

   1 /* Xtensa-specific support for 32-bit ELF.
   2    Copyright 2003 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU General Public License as
   8    published by the Free Software Foundation; either version 2 of the
   9    License, or (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19    02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23
  24 #ifdef ANSI_PROTOTYPES
  25 #include <stdarg.h>
  26 #else
  27 #include <varargs.h>
  28 #endif
  29 #include <strings.h>
  30
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/xtensa.h"
  35 #include "xtensa-isa.h"
  36 #include "xtensa-config.h"
  37
  38 /* Main interface functions.  */
  39 static void elf_xtensa_info_to_howto_rela
  40   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  41 static reloc_howto_type *elf_xtensa_reloc_type_lookup
  42   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
  43 extern int xtensa_read_table_entries
  44   PARAMS ((bfd *, asection *, property_table_entry **, const char *));
  45 static bfd_boolean elf_xtensa_check_relocs
  46   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  47            const Elf_Internal_Rela *));
  48 static void elf_xtensa_hide_symbol
  49   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
  50 static void elf_xtensa_copy_indirect_symbol
  51   PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
  52            struct elf_link_hash_entry *));
  53 static asection *elf_xtensa_gc_mark_hook
  54   PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
  55            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  56 static bfd_boolean elf_xtensa_gc_sweep_hook
  57   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  58            const Elf_Internal_Rela *));
  59 static bfd_boolean elf_xtensa_create_dynamic_sections
  60   PARAMS ((bfd *, struct bfd_link_info *));
  61 static bfd_boolean elf_xtensa_adjust_dynamic_symbol
  62   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  63 static bfd_boolean elf_xtensa_size_dynamic_sections
  64   PARAMS ((bfd *, struct bfd_link_info *));
  65 static bfd_boolean elf_xtensa_modify_segment_map
  66   PARAMS ((bfd *));
  67 static bfd_boolean elf_xtensa_relocate_section
  68   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  69            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  70 static bfd_boolean elf_xtensa_relax_section
  71   PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *again));
  72 static bfd_boolean elf_xtensa_finish_dynamic_symbol
  73   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  74            Elf_Internal_Sym *));
  75 static bfd_boolean elf_xtensa_finish_dynamic_sections
  76   PARAMS ((bfd *, struct bfd_link_info *));
  77 static bfd_boolean elf_xtensa_merge_private_bfd_data
  78   PARAMS ((bfd *, bfd *));
  79 static bfd_boolean elf_xtensa_set_private_flags
  80   PARAMS ((bfd *, flagword));
  81 extern flagword elf_xtensa_get_private_bfd_flags
  82   PARAMS ((bfd *));
  83 static bfd_boolean elf_xtensa_print_private_bfd_data
  84   PARAMS ((bfd *, PTR));
  85 static bfd_boolean elf_xtensa_object_p
  86   PARAMS ((bfd *));
  87 static void elf_xtensa_final_write_processing
  88   PARAMS ((bfd *, bfd_boolean));
  89 static enum elf_reloc_type_class elf_xtensa_reloc_type_class
  90   PARAMS ((const Elf_Internal_Rela *));
  91 static bfd_boolean elf_xtensa_discard_info
  92   PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *));
  93 static bfd_boolean elf_xtensa_ignore_discarded_relocs
  94   PARAMS ((asection *));
  95 static bfd_boolean elf_xtensa_grok_prstatus
  96   PARAMS ((bfd *, Elf_Internal_Note *));
  97 static bfd_boolean elf_xtensa_grok_psinfo
  98   PARAMS ((bfd *, Elf_Internal_Note *));
  99 static bfd_boolean elf_xtensa_new_section_hook
 100   PARAMS ((bfd *, asection *));
 101
 102
 103 /* Local helper functions.  */
 104
 105 static int property_table_compare
 106   PARAMS ((const PTR, const PTR));
 107 static bfd_boolean elf_xtensa_in_literal_pool
 108   PARAMS ((property_table_entry *, int, bfd_vma));
 109 static void elf_xtensa_make_sym_local
 110   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
 111 static bfd_boolean add_extra_plt_sections
 112   PARAMS ((bfd *, int));
 113 static bfd_boolean elf_xtensa_fix_refcounts
 114   PARAMS ((struct elf_link_hash_entry *, PTR));
 115 static bfd_boolean elf_xtensa_allocate_plt_size
 116   PARAMS ((struct elf_link_hash_entry *, PTR));
 117 static bfd_boolean elf_xtensa_allocate_got_size
 118   PARAMS ((struct elf_link_hash_entry *, PTR));
 119 static void elf_xtensa_allocate_local_got_size
 120   PARAMS ((struct bfd_link_info *, asection *));
 121 static bfd_reloc_status_type elf_xtensa_do_reloc
 122   PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_vma, bfd_byte *,
 123            bfd_vma, bfd_boolean, char **));
 124 static char * vsprint_msg
 125   VPARAMS ((const char *, const char *, int, ...));
 126 static char *build_encoding_error_message
 127   PARAMS ((xtensa_opcode, xtensa_encode_result));
 128 static bfd_reloc_status_type bfd_elf_xtensa_reloc
 129   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 130 static void do_fix_for_relocateable_link
 131   PARAMS ((Elf_Internal_Rela *, bfd *, asection *));
 132 static void do_fix_for_final_link
 133   PARAMS ((Elf_Internal_Rela *, asection *, bfd_vma *));
 134 static bfd_boolean xtensa_elf_dynamic_symbol_p
 135   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
 136 static bfd_vma elf_xtensa_create_plt_entry
 137   PARAMS ((bfd *, bfd *, unsigned));
 138 static int elf_xtensa_combine_prop_entries
 139   PARAMS ((bfd *, const char *));
 140 static bfd_boolean elf_xtensa_discard_info_for_section
 141   PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *,
 142            asection *));
 143
 144 /* Local functions to handle Xtensa configurability.  */
 145
 146 static void init_call_opcodes
 147   PARAMS ((void));
 148 static bfd_boolean is_indirect_call_opcode
 149   PARAMS ((xtensa_opcode));
 150 static bfd_boolean is_direct_call_opcode
 151   PARAMS ((xtensa_opcode));
 152 static bfd_boolean is_windowed_call_opcode
 153   PARAMS ((xtensa_opcode));
 154 static xtensa_opcode get_l32r_opcode
 155   PARAMS ((void));
 156 static bfd_vma l32r_offset
 157   PARAMS ((bfd_vma, bfd_vma));
 158 static int get_relocation_opnd
 159   PARAMS ((Elf_Internal_Rela *));
 160 static xtensa_opcode get_relocation_opcode
 161   PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *));
 162 static bfd_boolean is_l32r_relocation
 163   PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *));
 164
 165 /* Functions for link-time code simplifications.  */
 166
 167 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
 168   PARAMS ((bfd_byte *, bfd_vma, bfd_vma));
 169 static bfd_reloc_status_type contract_asm_expansion
 170   PARAMS ((bfd_byte *, bfd_vma, Elf_Internal_Rela *));
 171 static xtensa_opcode swap_callx_for_call_opcode
 172   PARAMS ((xtensa_opcode));
 173 static xtensa_opcode get_expanded_call_opcode
 174   PARAMS ((bfd_byte *, int));
 175
 176 /* Access to internal relocations, section contents and symbols.  */
 177
 178 static Elf_Internal_Rela *retrieve_internal_relocs
 179   PARAMS ((bfd *, asection *, bfd_boolean));
 180 static void pin_internal_relocs
 181   PARAMS ((asection *, Elf_Internal_Rela *));
 182 static void release_internal_relocs
 183   PARAMS ((asection *, Elf_Internal_Rela *));
 184 static bfd_byte *retrieve_contents
 185   PARAMS ((bfd *, asection *, bfd_boolean));
 186 static void pin_contents
 187   PARAMS ((asection *, bfd_byte *));
 188 static void release_contents
 189   PARAMS ((asection *, bfd_byte *));
 190 static Elf_Internal_Sym *retrieve_local_syms
 191   PARAMS ((bfd *));
 192
 193 /* Miscellaneous utility functions.  */
 194
 195 static asection *elf_xtensa_get_plt_section
 196   PARAMS ((bfd *, int));
 197 static asection *elf_xtensa_get_gotplt_section
 198   PARAMS ((bfd *, int));
 199 static asection *get_elf_r_symndx_section
 200   PARAMS ((bfd *, unsigned long));
 201 static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
 202   PARAMS ((bfd *, unsigned long));
 203 static bfd_vma get_elf_r_symndx_offset
 204   PARAMS ((bfd *, unsigned long));
 205 static bfd_boolean pcrel_reloc_fits
 206   PARAMS ((xtensa_operand, bfd_vma, bfd_vma));
 207 static bfd_boolean xtensa_is_property_section
 208   PARAMS ((asection *));
 209 static bfd_boolean is_literal_section
 210   PARAMS ((asection *));
 211 static int internal_reloc_compare
 212   PARAMS ((const PTR, const PTR));
 213 static bfd_boolean get_is_linkonce_section
 214   PARAMS ((bfd *, asection *));
 215 extern char *xtensa_get_property_section_name
 216   PARAMS ((bfd *, asection *, const char *));
 217
 218 /* Other functions called directly by the linker.  */
 219
 220 typedef void (*deps_callback_t)
 221   PARAMS ((asection *, bfd_vma, asection *, bfd_vma, PTR));
 222 extern bfd_boolean xtensa_callback_required_dependence
 223   PARAMS ((bfd *, asection *, struct bfd_link_info *,
 224            deps_callback_t, PTR));
 225
 226
 227 typedef struct xtensa_relax_info_struct xtensa_relax_info;
 228
 229
 230 /* Total count of PLT relocations seen during check_relocs.
 231    The actual PLT code must be split into multiple sections and all
 232    the sections have to be created before size_dynamic_sections,
 233    where we figure out the exact number of PLT entries that will be
 234    needed.  It is OK is this count is an overestimate, e.g., some
 235    relocations may be removed by GC.  */
 236
 237 static int plt_reloc_count = 0;
 238
 239
 240 /* When this is true, relocations may have been modified to refer to
 241    symbols from other input files.  The per-section list of "fix"
 242    records needs to be checked when resolving relocations.  */
 243
 244 static bfd_boolean relaxing_section = FALSE;
 245
 246 \f
 247 static reloc_howto_type elf_howto_table[] =
 248 {
 249   HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 250          bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
 251          FALSE, 0x00000000, 0x00000000, FALSE),
 252   HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 253          bfd_elf_xtensa_reloc, "R_XTENSA_32",
 254          TRUE, 0xffffffff, 0xffffffff, FALSE),
 255   /* Replace a 32-bit value with a value from the runtime linker (only
 256      used by linker-generated stub functions).  The r_addend value is
 257      special: 1 means to substitute a pointer to the runtime linker's
 258      dynamic resolver function; 2 means to substitute the link map for
 259      the shared object.  */
 260   HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
 261          NULL, "R_XTENSA_RTLD",
 262          FALSE, 0x00000000, 0x00000000, FALSE),
 263   HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 264          bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
 265          FALSE, 0xffffffff, 0xffffffff, FALSE),
 266   HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 267          bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
 268          FALSE, 0xffffffff, 0xffffffff, FALSE),
 269   HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 270          bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
 271          FALSE, 0xffffffff, 0xffffffff, FALSE),
 272   HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 273          bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
 274          FALSE, 0xffffffff, 0xffffffff, FALSE),
 275   EMPTY_HOWTO (7),
 276   HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 277          bfd_elf_xtensa_reloc, "R_XTENSA_OP0",
 278          FALSE, 0x00000000, 0x00000000, TRUE),
 279   HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 280          bfd_elf_xtensa_reloc, "R_XTENSA_OP1",
 281          FALSE, 0x00000000, 0x00000000, TRUE),
 282   HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 283          bfd_elf_xtensa_reloc, "R_XTENSA_OP2",
 284          FALSE, 0x00000000, 0x00000000, TRUE),
 285   /* Assembly auto-expansion.  */
 286   HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 287          bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND",
 288          FALSE, 0x00000000, 0x00000000, FALSE),
 289   /* Relax assembly auto-expansion.  */
 290   HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 291          bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY",
 292          FALSE, 0x00000000, 0x00000000, TRUE),
 293   EMPTY_HOWTO (13),
 294   EMPTY_HOWTO (14),
 295   /* GNU extension to record C++ vtable hierarchy.  */
 296   HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
 297          NULL, "R_XTENSA_GNU_VTINHERIT",
 298          FALSE, 0x00000000, 0x00000000, FALSE),
 299   /* GNU extension to record C++ vtable member usage.  */
 300   HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
 301          _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
 302          FALSE, 0x00000000, 0x00000000, FALSE)
 303 };
 304
 305 #ifdef DEBUG_GEN_RELOC
 306 #define TRACE(str) \
 307   fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
 308 #else
 309 #define TRACE(str)
 310 #endif
 311
 312 static reloc_howto_type *
 313 elf_xtensa_reloc_type_lookup (abfd, code)
 314      bfd *abfd ATTRIBUTE_UNUSED;
 315      bfd_reloc_code_real_type code;
 316 {
 317   switch (code)
 318     {
 319     case BFD_RELOC_NONE:
 320       TRACE ("BFD_RELOC_NONE");
 321       return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
 322
 323     case BFD_RELOC_32:
 324       TRACE ("BFD_RELOC_32");
 325       return &elf_howto_table[(unsigned) R_XTENSA_32 ];
 326
 327     case BFD_RELOC_XTENSA_RTLD:
 328       TRACE ("BFD_RELOC_XTENSA_RTLD");
 329       return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
 330
 331     case BFD_RELOC_XTENSA_GLOB_DAT:
 332       TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
 333       return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
 334
 335     case BFD_RELOC_XTENSA_JMP_SLOT:
 336       TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
 337       return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
 338
 339     case BFD_RELOC_XTENSA_RELATIVE:
 340       TRACE ("BFD_RELOC_XTENSA_RELATIVE");
 341       return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
 342
 343     case BFD_RELOC_XTENSA_PLT:
 344       TRACE ("BFD_RELOC_XTENSA_PLT");
 345       return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
 346
 347     case BFD_RELOC_XTENSA_OP0:
 348       TRACE ("BFD_RELOC_XTENSA_OP0");
 349       return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
 350
 351     case BFD_RELOC_XTENSA_OP1:
 352       TRACE ("BFD_RELOC_XTENSA_OP1");
 353       return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
 354
 355     case BFD_RELOC_XTENSA_OP2:
 356       TRACE ("BFD_RELOC_XTENSA_OP2");
 357       return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
 358
 359     case BFD_RELOC_XTENSA_ASM_EXPAND:
 360       TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
 361       return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
 362
 363     case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
 364       TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
 365       return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
 366
 367     case BFD_RELOC_VTABLE_INHERIT:
 368       TRACE ("BFD_RELOC_VTABLE_INHERIT");
 369       return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
 370
 371     case BFD_RELOC_VTABLE_ENTRY:
 372       TRACE ("BFD_RELOC_VTABLE_ENTRY");
 373       return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
 374
 375     default:
 376       break;
 377     }
 378
 379   TRACE ("Unknown");
 380   return NULL;
 381 }
 382
 383
 384 /* Given an ELF "rela" relocation, find the corresponding howto and record
 385    it in the BFD internal arelent representation of the relocation.  */
 386
 387 static void
 388 elf_xtensa_info_to_howto_rela (abfd, cache_ptr, dst)
 389      bfd *abfd ATTRIBUTE_UNUSED;
 390      arelent *cache_ptr;
 391      Elf_Internal_Rela *dst;
 392 {
 393   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 394
 395   BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max);
 396   cache_ptr->howto = &elf_howto_table[r_type];
 397 }
 398
 399 \f
 400 /* Functions for the Xtensa ELF linker.  */
 401
 402 /* The name of the dynamic interpreter.  This is put in the .interp
 403    section.  */
 404
 405 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
 406
 407 /* The size in bytes of an entry in the procedure linkage table.
 408    (This does _not_ include the space for the literals associated with
 409    the PLT entry.) */
 410
 411 #define PLT_ENTRY_SIZE 16
 412
 413 /* For _really_ large PLTs, we may need to alternate between literals
 414    and code to keep the literals within the 256K range of the L32R
 415    instructions in the code.  It's unlikely that anyone would ever need
 416    such a big PLT, but an arbitrary limit on the PLT size would be bad.
 417    Thus, we split the PLT into chunks.  Since there's very little
 418    overhead (2 extra literals) for each chunk, the chunk size is kept
 419    small so that the code for handling multiple chunks get used and
 420    tested regularly.  With 254 entries, there are 1K of literals for
 421    each chunk, and that seems like a nice round number.  */
 422
 423 #define PLT_ENTRIES_PER_CHUNK 254
 424
 425 /* PLT entries are actually used as stub functions for lazy symbol
 426    resolution.  Once the symbol is resolved, the stub function is never
 427    invoked.  Note: the 32-byte frame size used here cannot be changed
 428    without a corresponding change in the runtime linker.  */
 429
 430 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
 431 {
 432   0x6c, 0x10, 0x04,     /* entry sp, 32 */
 433   0x18, 0x00, 0x00,     /* l32r  a8, [got entry for rtld's resolver] */
 434   0x1a, 0x00, 0x00,     /* l32r  a10, [got entry for rtld's link map] */
 435   0x1b, 0x00, 0x00,     /* l32r  a11, [literal for reloc index] */
 436   0x0a, 0x80, 0x00,     /* jx    a8 */
 437   0                     /* unused */
 438 };
 439
 440 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
 441 {
 442   0x36, 0x41, 0x00,     /* entry sp, 32 */
 443   0x81, 0x00, 0x00,     /* l32r  a8, [got entry for rtld's resolver] */
 444   0xa1, 0x00, 0x00,     /* l32r  a10, [got entry for rtld's link map] */
 445   0xb1, 0x00, 0x00,     /* l32r  a11, [literal for reloc index] */
 446   0xa0, 0x08, 0x00,     /* jx    a8 */
 447   0                     /* unused */
 448 };
 449
 450 \f
 451 static int
 452 property_table_compare (ap, bp)
 453      const PTR ap;
 454      const PTR bp;
 455 {
 456   const property_table_entry *a = (const property_table_entry *) ap;
 457   const property_table_entry *b = (const property_table_entry *) bp;
 458
 459   /* Check if one entry overlaps with the other; this shouldn't happen
 460      except when searching for a match.  */
 461   if ((b->address >= a->address && b->address < (a->address + a->size))
 462       || (a->address >= b->address && a->address < (b->address + b->size)))
 463     return 0;
 464
 465   return (a->address - b->address);
 466 }
 467
 468
 469 /* Get the literal table or instruction table entries for the given
 470    section.  Sets TABLE_P and returns the number of entries.  On error,
 471    returns a negative value.  */
 472
 473 int
 474 xtensa_read_table_entries (abfd, section, table_p, sec_name)
 475      bfd *abfd;
 476      asection *section;
 477      property_table_entry **table_p;
 478      const char *sec_name;
 479 {
 480   asection *table_section;
 481   char *table_section_name;
 482   bfd_size_type table_size = 0;
 483   bfd_byte *table_data;
 484   property_table_entry *blocks;
 485   int block_count;
 486   bfd_size_type num_records;
 487   Elf_Internal_Rela *internal_relocs;
 488
 489   table_section_name =
 490     xtensa_get_property_section_name (abfd, section, sec_name);
 491   table_section = bfd_get_section_by_name (abfd, table_section_name);
 492   if (table_section != NULL)
 493     table_size = bfd_get_section_size_before_reloc (table_section);
 494
 495   if (table_size == 0)
 496     {
 497       *table_p = NULL;
 498       return 0;
 499     }
 500
 501   num_records = table_size / sizeof (property_table_entry);
 502   table_data = retrieve_contents (abfd, table_section, TRUE);
 503   blocks = (property_table_entry *)
 504     bfd_malloc (num_records * sizeof (property_table_entry));
 505   block_count = 0;
 506
 507   /* If the file has not yet been relocated, process the relocations
 508      and sort out the table entries that apply to the specified section.  */
 509   internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
 510   if (internal_relocs)
 511     {
 512       unsigned i;
 513
 514       for (i = 0; i < table_section->reloc_count; i++)
 515         {
 516           Elf_Internal_Rela *rel = &internal_relocs[i];
 517           unsigned long r_symndx;
 518
 519           if (ELF32_R_TYPE (rel->r_info) == R_XTENSA_NONE)
 520             continue;
 521
 522           BFD_ASSERT (ELF32_R_TYPE (rel->r_info) == R_XTENSA_32);
 523           r_symndx = ELF32_R_SYM (rel->r_info);
 524
 525           if (get_elf_r_symndx_section (abfd, r_symndx) == section)
 526             {
 527               bfd_vma sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
 528               blocks[block_count].address =
 529                 (section->vma + sym_off + rel->r_addend
 530                  + bfd_get_32 (abfd, table_data + rel->r_offset));
 531               blocks[block_count].size =
 532                 bfd_get_32 (abfd, table_data + rel->r_offset + 4);
 533               block_count++;
 534             }
 535         }
 536     }
 537   else
 538     {
 539       /* No relocations.  Presumably the file has been relocated
 540          and the addresses are already in the table.  */
 541       bfd_vma off;
 542
 543       for (off = 0; off < table_size; off += sizeof (property_table_entry))
 544         {
 545           bfd_vma address = bfd_get_32 (abfd, table_data + off);
 546
 547           if (address >= section->vma
 548               && address < ( section->vma + section->_raw_size))
 549             {
 550               blocks[block_count].address = address;
 551               blocks[block_count].size =
 552                 bfd_get_32 (abfd, table_data + off + 4);
 553               block_count++;
 554             }
 555         }
 556     }
 557
 558   release_contents (table_section, table_data);
 559   release_internal_relocs (table_section, internal_relocs);
 560
 561   if (block_count > 0)
 562     {
 563       /* Now sort them into address order for easy reference.  */
 564       qsort (blocks, block_count, sizeof (property_table_entry),
 565              property_table_compare);
 566     }
 567
 568   *table_p = blocks;
 569   return block_count;
 570 }
 571
 572
 573 static bfd_boolean
 574 elf_xtensa_in_literal_pool (lit_table, lit_table_size, addr)
 575      property_table_entry *lit_table;
 576      int lit_table_size;
 577      bfd_vma addr;
 578 {
 579   property_table_entry entry;
 580
 581   if (lit_table_size == 0)
 582     return FALSE;
 583
 584   entry.address = addr;
 585   entry.size = 1;
 586
 587   if (bsearch (&entry, lit_table, lit_table_size,
 588                sizeof (property_table_entry), property_table_compare))
 589     return TRUE;
 590
 591   return FALSE;
 592 }
 593
 594 \f
 595 /* Look through the relocs for a section during the first phase, and
 596    calculate needed space in the dynamic reloc sections.  */
 597
 598 static bfd_boolean
 599 elf_xtensa_check_relocs (abfd, info, sec, relocs)
 600      bfd *abfd;
 601      struct bfd_link_info *info;
 602      asection *sec;
 603      const Elf_Internal_Rela *relocs;
 604 {
 605   Elf_Internal_Shdr *symtab_hdr;
 606   struct elf_link_hash_entry **sym_hashes;
 607   const Elf_Internal_Rela *rel;
 608   const Elf_Internal_Rela *rel_end;
 609   property_table_entry *lit_table;
 610   int ltblsize;
 611
 612   if (info->relocateable)
 613     return TRUE;
 614
 615   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 616   sym_hashes = elf_sym_hashes (abfd);
 617
 618   ltblsize = xtensa_read_table_entries (abfd, sec, &lit_table,
 619                                         XTENSA_LIT_SEC_NAME);
 620   if (ltblsize < 0)
 621     return FALSE;
 622
 623   rel_end = relocs + sec->reloc_count;
 624   for (rel = relocs; rel < rel_end; rel++)
 625     {
 626       unsigned int r_type;
 627       unsigned long r_symndx;
 628       struct elf_link_hash_entry *h;
 629
 630       r_symndx = ELF32_R_SYM (rel->r_info);
 631       r_type = ELF32_R_TYPE (rel->r_info);
 632
 633       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 634         {
 635           (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
 636                                  bfd_archive_filename (abfd),
 637                                  r_symndx);
 638           return FALSE;
 639         }
 640
 641       if (r_symndx < symtab_hdr->sh_info)
 642         h = NULL;
 643       else
 644         {
 645           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 646           while (h->root.type == bfd_link_hash_indirect
 647                  || h->root.type == bfd_link_hash_warning)
 648             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 649         }
 650
 651       switch (r_type)
 652         {
 653         case R_XTENSA_32:
 654           if (h == NULL)
 655             goto local_literal;
 656
 657           if ((sec->flags & SEC_ALLOC) != 0)
 658             {
 659               if ((sec->flags & SEC_READONLY) != 0
 660                   && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
 661                                                   sec->vma + rel->r_offset))
 662                 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
 663
 664               if (h->got.refcount <= 0)
 665                 h->got.refcount = 1;
 666               else
 667                 h->got.refcount += 1;
 668             }
 669           break;
 670
 671         case R_XTENSA_PLT:
 672           /* If this relocation is against a local symbol, then it's
 673              exactly the same as a normal local GOT entry.  */
 674           if (h == NULL)
 675             goto local_literal;
 676
 677           if ((sec->flags & SEC_ALLOC) != 0)
 678             {
 679               if ((sec->flags & SEC_READONLY) != 0
 680                   && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
 681                                                   sec->vma + rel->r_offset))
 682                 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
 683
 684               if (h->plt.refcount <= 0)
 685                 {
 686                   h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 687                   h->plt.refcount = 1;
 688                 }
 689               else
 690                 h->plt.refcount += 1;
 691
 692               /* Keep track of the total PLT relocation count even if we
 693                  don't yet know whether the dynamic sections will be
 694                  created.  */
 695               plt_reloc_count += 1;
 696
 697               if (elf_hash_table (info)->dynamic_sections_created)
 698                 {
 699                   if (!add_extra_plt_sections (elf_hash_table (info)->dynobj,
 700                                                plt_reloc_count))
 701                     return FALSE;
 702                 }
 703             }
 704           break;
 705
 706         local_literal:
 707           if ((sec->flags & SEC_ALLOC) != 0)
 708             {
 709               bfd_signed_vma *local_got_refcounts;
 710
 711               /* This is a global offset table entry for a local symbol.  */
 712               local_got_refcounts = elf_local_got_refcounts (abfd);
 713               if (local_got_refcounts == NULL)
 714                 {
 715                   bfd_size_type size;
 716
 717                   size = symtab_hdr->sh_info;
 718                   size *= sizeof (bfd_signed_vma);
 719                   local_got_refcounts = ((bfd_signed_vma *)
 720                                          bfd_zalloc (abfd, size));
 721                   if (local_got_refcounts == NULL)
 722                     return FALSE;
 723                   elf_local_got_refcounts (abfd) = local_got_refcounts;
 724                 }
 725               local_got_refcounts[r_symndx] += 1;
 726
 727               /* If the relocation is not inside the GOT, the DF_TEXTREL
 728                  flag needs to be set.  */
 729               if (info->shared
 730                   && (sec->flags & SEC_READONLY) != 0
 731                   && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
 732                                                   sec->vma + rel->r_offset))
 733                 info->flags |= DF_TEXTREL;
 734             }
 735           break;
 736
 737         case R_XTENSA_OP0:
 738         case R_XTENSA_OP1:
 739         case R_XTENSA_OP2:
 740         case R_XTENSA_ASM_EXPAND:
 741         case R_XTENSA_ASM_SIMPLIFY:
 742           /* Nothing to do for these.  */
 743           break;
 744
 745         case R_XTENSA_GNU_VTINHERIT:
 746           /* This relocation describes the C++ object vtable hierarchy.
 747              Reconstruct it for later use during GC.  */
 748           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 749             return FALSE;
 750           break;
 751
 752         case R_XTENSA_GNU_VTENTRY:
 753           /* This relocation describes which C++ vtable entries are actually
 754              used.  Record for later use during GC.  */
 755           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 756             return FALSE;
 757           break;
 758
 759         default:
 760           break;
 761         }
 762     }
 763
 764   free (lit_table);
 765   return TRUE;
 766 }
 767
 768
 769 static void
 770 elf_xtensa_hide_symbol (info, h, force_local)
 771      struct bfd_link_info *info;
 772      struct elf_link_hash_entry *h;
 773      bfd_boolean force_local;
 774 {
 775   /* For a shared link, move the plt refcount to the got refcount to leave
 776      space for RELATIVE relocs.  */
 777   elf_xtensa_make_sym_local (info, h);
 778
 779   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
 780 }
 781
 782
 783 static void
 784 elf_xtensa_copy_indirect_symbol (bed, dir, ind)
 785      struct elf_backend_data *bed;
 786      struct elf_link_hash_entry *dir, *ind;
 787 {
 788   _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
 789
 790   /* The standard function doesn't copy the NEEDS_PLT flag.  */
 791   dir->elf_link_hash_flags |=
 792     (ind->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT);
 793 }
 794
 795
 796 /* Return the section that should be marked against GC for a given
 797    relocation.  */
 798
 799 static asection *
 800 elf_xtensa_gc_mark_hook (sec, info, rel, h, sym)
 801      asection *sec;
 802      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 803      Elf_Internal_Rela *rel;
 804      struct elf_link_hash_entry *h;
 805      Elf_Internal_Sym *sym;
 806 {
 807   if (h != NULL)
 808     {
 809       switch (ELF32_R_TYPE (rel->r_info))
 810         {
 811         case R_XTENSA_GNU_VTINHERIT:
 812         case R_XTENSA_GNU_VTENTRY:
 813           break;
 814
 815         default:
 816           switch (h->root.type)
 817             {
 818             case bfd_link_hash_defined:
 819             case bfd_link_hash_defweak:
 820               return h->root.u.def.section;
 821
 822             case bfd_link_hash_common:
 823               return h->root.u.c.p->section;
 824
 825             default:
 826               break;
 827             }
 828         }
 829     }
 830   else
 831     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 832
 833   return NULL;
 834 }
 835
 836 /* Update the GOT & PLT entry reference counts
 837    for the section being removed.  */
 838
 839 static bfd_boolean
 840 elf_xtensa_gc_sweep_hook (abfd, info, sec, relocs)
 841      bfd *abfd;
 842      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 843      asection *sec;
 844      const Elf_Internal_Rela *relocs;
 845 {
 846   Elf_Internal_Shdr *symtab_hdr;
 847   struct elf_link_hash_entry **sym_hashes;
 848   bfd_signed_vma *local_got_refcounts;
 849   const Elf_Internal_Rela *rel, *relend;
 850
 851   if ((sec->flags & SEC_ALLOC) == 0)
 852     return TRUE;
 853
 854   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 855   sym_hashes = elf_sym_hashes (abfd);
 856   local_got_refcounts = elf_local_got_refcounts (abfd);
 857
 858   relend = relocs + sec->reloc_count;
 859   for (rel = relocs; rel < relend; rel++)
 860     {
 861       unsigned long r_symndx;
 862       unsigned int r_type;
 863       struct elf_link_hash_entry *h = NULL;
 864
 865       r_symndx = ELF32_R_SYM (rel->r_info);
 866       if (r_symndx >= symtab_hdr->sh_info)
 867         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 868
 869       r_type = ELF32_R_TYPE (rel->r_info);
 870       switch (r_type)
 871         {
 872         case R_XTENSA_32:
 873           if (h == NULL)
 874             goto local_literal;
 875           if (h->got.refcount > 0)
 876             h->got.refcount--;
 877           break;
 878
 879         case R_XTENSA_PLT:
 880           if (h == NULL)
 881             goto local_literal;
 882           if (h->plt.refcount > 0)
 883             h->plt.refcount--;
 884           break;
 885
 886         local_literal:
 887           if (local_got_refcounts[r_symndx] > 0)
 888             local_got_refcounts[r_symndx] -= 1;
 889           break;
 890
 891         default:
 892           break;
 893         }
 894     }
 895
 896   return TRUE;
 897 }
 898
 899
 900 /* Create all the dynamic sections.  */
 901
 902 static bfd_boolean
 903 elf_xtensa_create_dynamic_sections (dynobj, info)
 904      bfd *dynobj;
 905      struct bfd_link_info *info;
 906 {
 907   flagword flags;
 908   asection *s;
 909
 910   /* First do all the standard stuff.  */
 911   if (! _bfd_elf_create_dynamic_sections (dynobj, info))
 912     return FALSE;
 913
 914   /* Create any extra PLT sections in case check_relocs has already
 915      been called on all the non-dynamic input files.  */
 916   if (!add_extra_plt_sections (dynobj, plt_reloc_count))
 917     return FALSE;
 918
 919   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 920            | SEC_LINKER_CREATED | SEC_READONLY);
 921
 922   /* Mark the ".got.plt" section READONLY.  */
 923   s = bfd_get_section_by_name (dynobj, ".got.plt");
 924   if (s == NULL
 925       || ! bfd_set_section_flags (dynobj, s, flags))
 926     return FALSE;
 927
 928   /* Create ".rela.got".  */
 929   s = bfd_make_section (dynobj, ".rela.got");
 930   if (s == NULL
 931       || ! bfd_set_section_flags (dynobj, s, flags)
 932       || ! bfd_set_section_alignment (dynobj, s, 2))
 933     return FALSE;
 934
 935   /* Create ".xt.lit.plt" (literal table for ".got.plt*").  */
 936   s = bfd_make_section (dynobj, ".xt.lit.plt");
 937   if (s == NULL
 938       || ! bfd_set_section_flags (dynobj, s, flags)
 939       || ! bfd_set_section_alignment (dynobj, s, 2))
 940     return FALSE;
 941
 942   return TRUE;
 943 }
 944
 945
 946 static bfd_boolean
 947 add_extra_plt_sections (dynobj, count)
 948      bfd *dynobj;
 949      int count;
 950 {
 951   int chunk;
 952
 953   /* Iterate over all chunks except 0 which uses the standard ".plt" and
 954      ".got.plt" sections.  */
 955   for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
 956     {
 957       char *sname;
 958       flagword flags;
 959       asection *s;
 960
 961       /* Stop when we find a section has already been created.  */
 962       if (elf_xtensa_get_plt_section (dynobj, chunk))
 963         break;
 964
 965       flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 966                | SEC_LINKER_CREATED | SEC_READONLY);
 967
 968       sname = (char *) bfd_malloc (10);
 969       sprintf (sname, ".plt.%u", chunk);
 970       s = bfd_make_section (dynobj, sname);
 971       if (s == NULL
 972           || ! bfd_set_section_flags (dynobj, s, flags | SEC_CODE)
 973           || ! bfd_set_section_alignment (dynobj, s, 2))
 974         return FALSE;
 975
 976       sname = (char *) bfd_malloc (14);
 977       sprintf (sname, ".got.plt.%u", chunk);
 978       s = bfd_make_section (dynobj, sname);
 979       if (s == NULL
 980           || ! bfd_set_section_flags (dynobj, s, flags)
 981           || ! bfd_set_section_alignment (dynobj, s, 2))
 982         return FALSE;
 983     }
 984
 985   return TRUE;
 986 }
 987
 988
 989 /* Adjust a symbol defined by a dynamic object and referenced by a
 990    regular object.  The current definition is in some section of the
 991    dynamic object, but we're not including those sections.  We have to
 992    change the definition to something the rest of the link can
 993    understand.  */
 994
 995 static bfd_boolean
 996 elf_xtensa_adjust_dynamic_symbol (info, h)
 997      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 998      struct elf_link_hash_entry *h;
 999 {
1000   /* If this is a weak symbol, and there is a real definition, the
1001      processor independent code will have arranged for us to see the
1002      real definition first, and we can just use the same value.  */
1003   if (h->weakdef != NULL)
1004     {
1005       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1006                   || h->weakdef->root.type == bfd_link_hash_defweak);
1007       h->root.u.def.section = h->weakdef->root.u.def.section;
1008       h->root.u.def.value = h->weakdef->root.u.def.value;
1009       return TRUE;
1010     }
1011
1012   /* This is a reference to a symbol defined by a dynamic object.  The
1013      reference must go through the GOT, so there's no need for COPY relocs,
1014      .dynbss, etc.  */
1015
1016   return TRUE;
1017 }
1018
1019
1020 static void
1021 elf_xtensa_make_sym_local (info, h)
1022      struct bfd_link_info *info;
1023      struct elf_link_hash_entry *h;
1024 {
1025   if (info->shared)
1026     {
1027       if (h->plt.refcount > 0)
1028         {
1029           /* Will use RELATIVE relocs instead of JMP_SLOT relocs.  */
1030           if (h->got.refcount < 0)
1031             h->got.refcount = 0;
1032           h->got.refcount += h->plt.refcount;
1033           h->plt.refcount = 0;
1034         }
1035     }
1036   else
1037     {
1038       /* Don't need any dynamic relocations at all.  */
1039       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1040       h->plt.refcount = 0;
1041       h->got.refcount = 0;
1042     }
1043 }
1044
1045
1046 static bfd_boolean
1047 elf_xtensa_fix_refcounts (h, arg)
1048      struct elf_link_hash_entry *h;
1049      PTR arg;
1050 {
1051   struct bfd_link_info *info = (struct bfd_link_info *) arg;
1052
1053   if (h->root.type == bfd_link_hash_warning)
1054     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1055
1056   if (! xtensa_elf_dynamic_symbol_p (info, h))
1057     elf_xtensa_make_sym_local (info, h);
1058
1059   /* If the symbol has a relocation outside the GOT, set the
1060      DF_TEXTREL flag.  */
1061   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) != 0)
1062     info->flags |= DF_TEXTREL;
1063
1064   return TRUE;
1065 }
1066
1067
1068 static bfd_boolean
1069 elf_xtensa_allocate_plt_size (h, arg)
1070      struct elf_link_hash_entry *h;
1071      PTR arg;
1072 {
1073   asection *srelplt = (asection *) arg;
1074
1075   if (h->root.type == bfd_link_hash_warning)
1076     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1077
1078   if (h->plt.refcount > 0)
1079     srelplt->_raw_size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1080
1081   return TRUE;
1082 }
1083
1084
1085 static bfd_boolean
1086 elf_xtensa_allocate_got_size (h, arg)
1087      struct elf_link_hash_entry *h;
1088      PTR arg;
1089 {
1090   asection *srelgot = (asection *) arg;
1091
1092   if (h->root.type == bfd_link_hash_warning)
1093     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1094
1095   if (h->got.refcount > 0)
1096     srelgot->_raw_size += (h->got.refcount * sizeof (Elf32_External_Rela));
1097
1098   return TRUE;
1099 }
1100
1101
1102 static void
1103 elf_xtensa_allocate_local_got_size (info, srelgot)
1104      struct bfd_link_info *info;
1105      asection *srelgot;
1106 {
1107   bfd *i;
1108
1109   for (i = info->input_bfds; i; i = i->link_next)
1110     {
1111       bfd_signed_vma *local_got_refcounts;
1112       bfd_size_type j, cnt;
1113       Elf_Internal_Shdr *symtab_hdr;
1114
1115       local_got_refcounts = elf_local_got_refcounts (i);
1116       if (!local_got_refcounts)
1117         continue;
1118
1119       symtab_hdr = &elf_tdata (i)->symtab_hdr;
1120       cnt = symtab_hdr->sh_info;
1121
1122       for (j = 0; j < cnt; ++j)
1123         {
1124           if (local_got_refcounts[j] > 0)
1125             srelgot->_raw_size += (local_got_refcounts[j]
1126                                    * sizeof (Elf32_External_Rela));
1127         }
1128     }
1129 }
1130
1131
1132 /* Set the sizes of the dynamic sections.  */
1133
1134 static bfd_boolean
1135 elf_xtensa_size_dynamic_sections (output_bfd, info)
1136      bfd *output_bfd ATTRIBUTE_UNUSED;
1137      struct bfd_link_info *info;
1138 {
1139   bfd *dynobj;
1140   asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl;
1141   bfd_boolean relplt, relgot;
1142   int plt_entries, plt_chunks, chunk;
1143
1144   plt_entries = 0;
1145   plt_chunks = 0;
1146   srelgot = 0;
1147
1148   dynobj = elf_hash_table (info)->dynobj;
1149   if (dynobj == NULL)
1150     abort ();
1151
1152   if (elf_hash_table (info)->dynamic_sections_created)
1153     {
1154       /* Set the contents of the .interp section to the interpreter.  */
1155       if (! info->shared)
1156         {
1157           s = bfd_get_section_by_name (dynobj, ".interp");
1158           if (s == NULL)
1159             abort ();
1160           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1161           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1162         }
1163
1164       /* Allocate room for one word in ".got".  */
1165       s = bfd_get_section_by_name (dynobj, ".got");
1166       if (s == NULL)
1167         abort ();
1168       s->_raw_size = 4;
1169
1170       /* Adjust refcounts for symbols that we now know are not "dynamic".  */
1171       elf_link_hash_traverse (elf_hash_table (info),
1172                               elf_xtensa_fix_refcounts,
1173                               (PTR) info);
1174
1175       /* Allocate space in ".rela.got" for literals that reference
1176          global symbols.  */
1177       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1178       if (srelgot == NULL)
1179         abort ();
1180       elf_link_hash_traverse (elf_hash_table (info),
1181                               elf_xtensa_allocate_got_size,
1182                               (PTR) srelgot);
1183
1184       /* If we are generating a shared object, we also need space in
1185          ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1186          reference local symbols.  */
1187       if (info->shared)
1188         elf_xtensa_allocate_local_got_size (info, srelgot);
1189
1190       /* Allocate space in ".rela.plt" for literals that have PLT entries.  */
1191       srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1192       if (srelplt == NULL)
1193         abort ();
1194       elf_link_hash_traverse (elf_hash_table (info),
1195                               elf_xtensa_allocate_plt_size,
1196                               (PTR) srelplt);
1197
1198       /* Allocate space in ".plt" to match the size of ".rela.plt".  For
1199          each PLT entry, we need the PLT code plus a 4-byte literal.
1200          For each chunk of ".plt", we also need two more 4-byte
1201          literals, two corresponding entries in ".rela.got", and an
1202          8-byte entry in ".xt.lit.plt".  */
1203       spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt");
1204       if (spltlittbl == NULL)
1205         abort ();
1206
1207       plt_entries = srelplt->_raw_size / sizeof (Elf32_External_Rela);
1208       plt_chunks =
1209         (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1210
1211       /* Iterate over all the PLT chunks, including any extra sections
1212          created earlier because the initial count of PLT relocations
1213          was an overestimate.  */
1214       for (chunk = 0;
1215            (splt = elf_xtensa_get_plt_section (dynobj, chunk)) != NULL;
1216            chunk++)
1217         {
1218           int chunk_entries;
1219
1220           sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
1221           if (sgotplt == NULL)
1222             abort ();
1223
1224           if (chunk < plt_chunks - 1)
1225             chunk_entries = PLT_ENTRIES_PER_CHUNK;
1226           else if (chunk == plt_chunks - 1)
1227             chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1228           else
1229             chunk_entries = 0;
1230
1231           if (chunk_entries != 0)
1232             {
1233               sgotplt->_raw_size = 4 * (chunk_entries + 2);
1234               splt->_raw_size = PLT_ENTRY_SIZE * chunk_entries;
1235               srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela);
1236               spltlittbl->_raw_size += 8;
1237             }
1238           else
1239             {
1240               sgotplt->_raw_size = 0;
1241               splt->_raw_size = 0;
1242             }
1243         }
1244     }
1245
1246   /* Allocate memory for dynamic sections.  */
1247   relplt = FALSE;
1248   relgot = FALSE;
1249   for (s = dynobj->sections; s != NULL; s = s->next)
1250     {
1251       const char *name;
1252       bfd_boolean strip;
1253
1254       if ((s->flags & SEC_LINKER_CREATED) == 0)
1255         continue;
1256
1257       /* It's OK to base decisions on the section name, because none
1258          of the dynobj section names depend upon the input files.  */
1259       name = bfd_get_section_name (dynobj, s);
1260
1261       strip = FALSE;
1262
1263       if (strncmp (name, ".rela", 5) == 0)
1264         {
1265           if (strcmp (name, ".rela.plt") == 0)
1266             relplt = TRUE;
1267           else if (strcmp (name, ".rela.got") == 0)
1268             relgot = TRUE;
1269
1270           /* We use the reloc_count field as a counter if we need
1271              to copy relocs into the output file.  */
1272           s->reloc_count = 0;
1273         }
1274       else if (strncmp (name, ".plt.", 5) == 0
1275                || strncmp (name, ".got.plt.", 9) == 0)
1276         {
1277           if (s->_raw_size == 0)
1278             {
1279               /* If we don't need this section, strip it from the output
1280                  file.  We must create the ".plt*" and ".got.plt*"
1281                  sections in create_dynamic_sections and/or check_relocs
1282                  based on a conservative estimate of the PLT relocation
1283                  count, because the sections must be created before the
1284                  linker maps input sections to output sections.  The
1285                  linker does that before size_dynamic_sections, where we
1286                  compute the exact size of the PLT, so there may be more
1287                  of these sections than are actually needed.  */
1288               strip = TRUE;
1289             }
1290         }
1291       else if (strcmp (name, ".got") != 0
1292                && strcmp (name, ".plt") != 0
1293                && strcmp (name, ".got.plt") != 0
1294                && strcmp (name, ".xt.lit.plt") != 0)
1295         {
1296           /* It's not one of our sections, so don't allocate space.  */
1297           continue;
1298         }
1299
1300       if (strip)
1301         _bfd_strip_section_from_output (info, s);
1302       else
1303         {
1304           /* Allocate memory for the section contents.  */
1305           s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1306           if (s->contents == NULL && s->_raw_size != 0)
1307             return FALSE;
1308         }
1309     }
1310
1311   if (elf_hash_table (info)->dynamic_sections_created)
1312     {
1313       /* Add the special XTENSA_RTLD relocations now.  The offsets won't be
1314          known until finish_dynamic_sections, but we need to get the relocs
1315          in place before they are sorted.  */
1316       if (srelgot == NULL)
1317         abort ();
1318       for (chunk = 0; chunk < plt_chunks; chunk++)
1319         {
1320           Elf_Internal_Rela irela;
1321           bfd_byte *loc;
1322
1323           irela.r_offset = 0;
1324           irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1325           irela.r_addend = 0;
1326
1327           loc = (srelgot->contents
1328                  + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1329           bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1330           bfd_elf32_swap_reloca_out (output_bfd, &irela,
1331                                      loc + sizeof (Elf32_External_Rela));
1332           srelgot->reloc_count += 2;
1333         }
1334
1335       /* Add some entries to the .dynamic section.  We fill in the
1336          values later, in elf_xtensa_finish_dynamic_sections, but we
1337          must add the entries now so that we get the correct size for
1338          the .dynamic section.  The DT_DEBUG entry is filled in by the
1339          dynamic linker and used by the debugger.  */
1340 #define add_dynamic_entry(TAG, VAL) \
1341   bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1342
1343       if (! info->shared)
1344         {
1345           if (!add_dynamic_entry (DT_DEBUG, 0))
1346             return FALSE;
1347         }
1348
1349       if (relplt)
1350         {
1351           if (!add_dynamic_entry (DT_PLTGOT, 0)
1352               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1353               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1354               || !add_dynamic_entry (DT_JMPREL, 0))
1355             return FALSE;
1356         }
1357
1358       if (relgot)
1359         {
1360           if (!add_dynamic_entry (DT_RELA, 0)
1361               || !add_dynamic_entry (DT_RELASZ, 0)
1362               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1363             return FALSE;
1364         }
1365
1366       if ((info->flags & DF_TEXTREL) != 0)
1367         {
1368           if (!add_dynamic_entry (DT_TEXTREL, 0))
1369             return FALSE;
1370         }
1371
1372       if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1373           || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1374         return FALSE;
1375     }
1376 #undef add_dynamic_entry
1377
1378   return TRUE;
1379 }
1380
1381 \f
1382 /* Remove any PT_LOAD segments with no allocated sections.  Prior to
1383    binutils 2.13, this function used to remove the non-SEC_ALLOC
1384    sections from PT_LOAD segments, but that task has now been moved
1385    into elf.c.  We still need this function to remove any empty
1386    segments that result, but there's nothing Xtensa-specific about
1387    this and it probably ought to be moved into elf.c as well.  */
1388
1389 static bfd_boolean
1390 elf_xtensa_modify_segment_map (abfd)
1391      bfd *abfd;
1392 {
1393   struct elf_segment_map **m_p;
1394
1395   m_p = &elf_tdata (abfd)->segment_map;
1396   while (*m_p != NULL)
1397     {
1398       if ((*m_p)->p_type == PT_LOAD && (*m_p)->count == 0)
1399         *m_p = (*m_p)->next;
1400       else
1401         m_p = &(*m_p)->next;
1402     }
1403   return TRUE;
1404 }
1405
1406 \f
1407 /* Perform the specified relocation.  The instruction at (contents + address)
1408    is modified to set one operand to represent the value in "relocation".  The
1409    operand position is determined by the relocation type recorded in the
1410    howto.  */
1411
1412 #define CALL_SEGMENT_BITS (30)
1413 #define CALL_SEGMENT_SIZE (1<<CALL_SEGMENT_BITS)
1414
1415 static bfd_reloc_status_type
1416 elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
1417                      contents, address, is_weak_undef, error_message)
1418      reloc_howto_type *howto;
1419      bfd *abfd;
1420      asection *input_section;
1421      bfd_vma relocation;
1422      bfd_byte *contents;
1423      bfd_vma address;
1424      bfd_boolean is_weak_undef;
1425      char **error_message;
1426 {
1427   xtensa_opcode opcode;
1428   xtensa_operand operand;
1429   xtensa_encode_result encode_result;
1430   xtensa_isa isa = xtensa_default_isa;
1431   xtensa_insnbuf ibuff;
1432   bfd_vma self_address;
1433   int opnd;
1434   uint32 newval;
1435
1436   switch (howto->type)
1437     {
1438     case R_XTENSA_NONE:
1439       return bfd_reloc_ok;
1440
1441     case R_XTENSA_ASM_EXPAND:
1442       if (!is_weak_undef)
1443         {
1444           /* Check for windowed CALL across a 1GB boundary.  */
1445           xtensa_opcode opcode =
1446             get_expanded_call_opcode (contents + address,
1447                                       input_section->_raw_size - address);
1448           if (is_windowed_call_opcode (opcode))
1449             {
1450               self_address = (input_section->output_section->vma
1451                               + input_section->output_offset
1452                               + address);
1453               if ((self_address >> CALL_SEGMENT_BITS) !=
1454                   (relocation >> CALL_SEGMENT_BITS))
1455                 {
1456                   *error_message = "windowed longcall crosses 1GB boundary; "
1457                     "return may fail";
1458                   return bfd_reloc_dangerous;
1459                 }
1460             }
1461         }
1462       return bfd_reloc_ok;
1463
1464     case R_XTENSA_ASM_SIMPLIFY:
1465       {
1466         /* Convert the L32R/CALLX to CALL.  */
1467         bfd_reloc_status_type retval =
1468           elf_xtensa_do_asm_simplify (contents, address,
1469                                       input_section->_raw_size);
1470         if (retval != bfd_reloc_ok)
1471           return retval;
1472
1473         /* The CALL needs to be relocated.  Continue below for that part.  */
1474         address += 3;
1475         howto = &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
1476       }
1477       break;
1478
1479     case R_XTENSA_32:
1480     case R_XTENSA_PLT:
1481       {
1482         bfd_vma x;
1483         x = bfd_get_32 (abfd, contents + address);
1484         x = x + relocation;
1485         bfd_put_32 (abfd, x, contents + address);
1486       }
1487       return bfd_reloc_ok;
1488     }
1489
1490   /* Read the instruction into a buffer and decode the opcode.  */
1491   ibuff = xtensa_insnbuf_alloc (isa);
1492   xtensa_insnbuf_from_chars (isa, ibuff, contents + address);
1493   opcode = xtensa_decode_insn (isa, ibuff);
1494
1495   /* Determine which operand is being relocated.  */
1496   if (opcode == XTENSA_UNDEFINED)
1497     {
1498       *error_message = "cannot decode instruction";
1499       return bfd_reloc_dangerous;
1500     }
1501
1502   if (howto->type < R_XTENSA_OP0 || howto->type > R_XTENSA_OP2)
1503     {
1504       *error_message = "unexpected relocation";
1505       return bfd_reloc_dangerous;
1506     }
1507
1508   opnd = howto->type - R_XTENSA_OP0;
1509
1510   /* Calculate the PC address for this instruction.  */
1511   if (!howto->pc_relative)
1512     {
1513       *error_message = "expected PC-relative relocation";
1514       return bfd_reloc_dangerous;
1515     }
1516
1517   self_address = (input_section->output_section->vma
1518                   + input_section->output_offset
1519                   + address);
1520
1521   /* Apply the relocation.  */
1522   operand = xtensa_get_operand (isa, opcode, opnd);
1523   newval = xtensa_operand_do_reloc (operand, relocation, self_address);
1524   encode_result = xtensa_operand_encode (operand, &newval);
1525   xtensa_operand_set_field (operand, ibuff, newval);
1526
1527   /* Write the modified instruction back out of the buffer.  */
1528   xtensa_insnbuf_to_chars (isa, ibuff, contents + address);
1529   free (ibuff);
1530
1531   if (encode_result != xtensa_encode_result_ok)
1532     {
1533       char *message = build_encoding_error_message (opcode, encode_result);
1534       *error_message = message;
1535       return bfd_reloc_dangerous;
1536     }
1537
1538   /* Final check for call.  */
1539   if (is_direct_call_opcode (opcode)
1540       && is_windowed_call_opcode (opcode))
1541     {
1542       if ((self_address >> CALL_SEGMENT_BITS) !=
1543           (relocation >> CALL_SEGMENT_BITS))
1544         {
1545           *error_message = "windowed call crosses 1GB boundary; "
1546             "return may fail";
1547           return bfd_reloc_dangerous;
1548         }
1549     }
1550
1551   return bfd_reloc_ok;
1552 }
1553
1554
1555 static char *
1556 vsprint_msg VPARAMS ((const char *origmsg, const char *fmt, int arglen, ...))
1557 {
1558   /* To reduce the size of the memory leak,
1559      we only use a single message buffer.  */
1560   static bfd_size_type alloc_size = 0;
1561   static char *message = NULL;
1562   bfd_size_type orig_len, len = 0;
1563   bfd_boolean is_append;
1564
1565   VA_OPEN (ap, arglen);
1566   VA_FIXEDARG (ap, const char *, origmsg);
1567
1568   is_append = (origmsg == message);
1569
1570   orig_len = strlen (origmsg);
1571   len = orig_len + strlen (fmt) + arglen + 20;
1572   if (len > alloc_size)
1573     {
1574       message = (char *) bfd_realloc (message, len);
1575       alloc_size = len;
1576     }
1577   if (!is_append)
1578     memcpy (message, origmsg, orig_len);
1579   vsprintf (message + orig_len, fmt, ap);
1580   VA_CLOSE (ap);
1581   return message;
1582 }
1583
1584
1585 static char *
1586 build_encoding_error_message (opcode, encode_result)
1587      xtensa_opcode opcode;
1588      xtensa_encode_result encode_result;
1589 {
1590   const char *opname = xtensa_opcode_name (xtensa_default_isa, opcode);
1591   const char *msg = NULL;
1592
1593   switch (encode_result)
1594     {
1595     case xtensa_encode_result_ok:
1596       msg = "unexpected valid encoding";
1597       break;
1598     case xtensa_encode_result_align:
1599       msg = "misaligned encoding";
1600       break;
1601     case xtensa_encode_result_not_in_table:
1602       msg = "encoding not in lookup table";
1603       break;
1604     case xtensa_encode_result_too_low:
1605       msg = "encoding out of range: too low";
1606       break;
1607     case xtensa_encode_result_too_high:
1608       msg = "encoding out of range: too high";
1609       break;
1610     case xtensa_encode_result_not_ok:
1611     default:
1612       msg = "could not encode";
1613       break;
1614     }
1615
1616   if (is_direct_call_opcode (opcode)
1617       && (encode_result == xtensa_encode_result_too_low
1618           || encode_result == xtensa_encode_result_too_high))
1619
1620     msg = "direct call out of range";
1621
1622   else if (opcode == get_l32r_opcode ())
1623     {
1624       /* L32Rs have the strange interaction with encoding in that they
1625          have an unsigned immediate field, so libisa returns "too high"
1626          when the absolute value is out of range and never returns "too
1627          low", but I leave the "too low" message in case anything
1628          changes.  */
1629       if (encode_result == xtensa_encode_result_too_low)
1630         msg = "literal out of range";
1631       else if (encode_result == xtensa_encode_result_too_high)
1632         msg = "literal placed after use";
1633     }
1634
1635   return vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
1636 }
1637
1638
1639 /* This function is registered as the "special_function" in the
1640    Xtensa howto for handling simplify operations.
1641    bfd_perform_relocation / bfd_install_relocation use it to
1642    perform (install) the specified relocation.  Since this replaces the code
1643    in bfd_perform_relocation, it is basically an Xtensa-specific,
1644    stripped-down version of bfd_perform_relocation.  */
1645
1646 static bfd_reloc_status_type
1647 bfd_elf_xtensa_reloc (abfd, reloc_entry, symbol, data, input_section,
1648                       output_bfd, error_message)
1649      bfd *abfd;
1650      arelent *reloc_entry;
1651      asymbol *symbol;
1652      PTR data;
1653      asection *input_section;
1654      bfd *output_bfd;
1655      char **error_message;
1656 {
1657   bfd_vma relocation;
1658   bfd_reloc_status_type flag;
1659   bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1660   bfd_vma output_base = 0;
1661   reloc_howto_type *howto = reloc_entry->howto;
1662   asection *reloc_target_output_section;
1663   bfd_boolean is_weak_undef;
1664
1665   /* ELF relocs are against symbols.  If we are producing relocateable
1666      output, and the reloc is against an external symbol, the resulting
1667      reloc will also be against the same symbol.  In such a case, we
1668      don't want to change anything about the way the reloc is handled,
1669      since it will all be done at final link time.  This test is similar
1670      to what bfd_elf_generic_reloc does except that it lets relocs with
1671      howto->partial_inplace go through even if the addend is non-zero.
1672      (The real problem is that partial_inplace is set for XTENSA_32
1673      relocs to begin with, but that's a long story and there's little we
1674      can do about it now....)  */
1675
1676   if (output_bfd != (bfd *) NULL
1677       && (symbol->flags & BSF_SECTION_SYM) == 0)
1678     {
1679       reloc_entry->address += input_section->output_offset;
1680       return bfd_reloc_ok;
1681     }
1682
1683   /* Is the address of the relocation really within the section?  */
1684   if (reloc_entry->address > (input_section->_cooked_size
1685                               / bfd_octets_per_byte (abfd)))
1686     return bfd_reloc_outofrange;
1687
1688   /* Work out which section the relocation is targetted at and the
1689      initial relocation command value.  */
1690
1691   /* Get symbol value.  (Common symbols are special.)  */
1692   if (bfd_is_com_section (symbol->section))
1693     relocation = 0;
1694   else
1695     relocation = symbol->value;
1696
1697   reloc_target_output_section = symbol->section->output_section;
1698
1699   /* Convert input-section-relative symbol value to absolute.  */
1700   if ((output_bfd && !howto->partial_inplace)
1701       || reloc_target_output_section == NULL)
1702     output_base = 0;
1703   else
1704     output_base = reloc_target_output_section->vma;
1705
1706   relocation += output_base + symbol->section->output_offset;
1707
1708   /* Add in supplied addend.  */
1709   relocation += reloc_entry->addend;
1710
1711   /* Here the variable relocation holds the final address of the
1712      symbol we are relocating against, plus any addend.  */
1713   if (output_bfd)
1714     {
1715       if (!howto->partial_inplace)
1716         {
1717           /* This is a partial relocation, and we want to apply the relocation
1718              to the reloc entry rather than the raw data.  Everything except
1719              relocations against section symbols has already been handled
1720              above.  */
1721
1722           BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
1723           reloc_entry->addend = relocation;
1724           reloc_entry->address += input_section->output_offset;
1725           return bfd_reloc_ok;
1726         }
1727       else
1728         {
1729           reloc_entry->address += input_section->output_offset;
1730           reloc_entry->addend = 0;
1731         }
1732     }
1733
1734   is_weak_undef = (bfd_is_und_section (symbol->section)
1735                    && (symbol->flags & BSF_WEAK) != 0);
1736   flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
1737                               (bfd_byte *) data, (bfd_vma) octets,
1738                               is_weak_undef, error_message);
1739
1740   if (flag == bfd_reloc_dangerous)
1741     {
1742       /* Add the symbol name to the error message.  */
1743       if (! *error_message)
1744         *error_message = "";
1745       *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
1746                                     strlen (symbol->name) + 17,
1747                                     symbol->name, reloc_entry->addend);
1748     }
1749
1750   return flag;
1751 }
1752
1753
1754 /* Set up an entry in the procedure linkage table.  */
1755
1756 static bfd_vma
1757 elf_xtensa_create_plt_entry (dynobj, output_bfd, reloc_index)
1758       bfd *dynobj;
1759       bfd *output_bfd;
1760       unsigned reloc_index;
1761 {
1762   asection *splt, *sgotplt;
1763   bfd_vma plt_base, got_base;
1764   bfd_vma code_offset, lit_offset;
1765   int chunk;
1766
1767   chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
1768   splt = elf_xtensa_get_plt_section (dynobj, chunk);
1769   sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
1770   BFD_ASSERT (splt != NULL && sgotplt != NULL);
1771
1772   plt_base = splt->output_section->vma + splt->output_offset;
1773   got_base = sgotplt->output_section->vma + sgotplt->output_offset;
1774
1775   lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
1776   code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
1777
1778   /* Fill in the literal entry.  This is the offset of the dynamic
1779      relocation entry.  */
1780   bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
1781               sgotplt->contents + lit_offset);
1782
1783   /* Fill in the entry in the procedure linkage table.  */
1784   memcpy (splt->contents + code_offset,
1785           (bfd_big_endian (output_bfd)
1786            ? elf_xtensa_be_plt_entry
1787            : elf_xtensa_le_plt_entry),
1788           PLT_ENTRY_SIZE);
1789   bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
1790                                        plt_base + code_offset + 3),
1791               splt->contents + code_offset + 4);
1792   bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
1793                                        plt_base + code_offset + 6),
1794               splt->contents + code_offset + 7);
1795   bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
1796                                        plt_base + code_offset + 9),
1797               splt->contents + code_offset + 10);
1798
1799   return plt_base + code_offset;
1800 }
1801
1802
1803 static bfd_boolean
1804 xtensa_elf_dynamic_symbol_p (info, h)
1805      struct bfd_link_info *info;
1806      struct elf_link_hash_entry *h;
1807 {
1808   if (h == NULL)
1809     return FALSE;
1810
1811   while (h->root.type == bfd_link_hash_indirect
1812          || h->root.type == bfd_link_hash_warning)
1813     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1814
1815   if (h->dynindx == -1)
1816     return FALSE;
1817
1818   if (h->root.type == bfd_link_hash_undefweak
1819       || h->root.type == bfd_link_hash_defweak)
1820     return TRUE;
1821
1822   switch (ELF_ST_VISIBILITY (h->other))
1823     {
1824     case STV_DEFAULT:
1825       break;
1826     case STV_HIDDEN:
1827     case STV_INTERNAL:
1828       return FALSE;
1829     case STV_PROTECTED:
1830       if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
1831         return FALSE;
1832       break;
1833     }
1834
1835   if ((info->shared && !info->symbolic)
1836       || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1837     return TRUE;
1838
1839   return FALSE;
1840 }
1841
1842
1843 /* Relocate an Xtensa ELF section.  This is invoked by the linker for
1844    both relocateable and final links.  */
1845
1846 static bfd_boolean
1847 elf_xtensa_relocate_section (output_bfd, info, input_bfd,
1848                              input_section, contents, relocs,
1849                              local_syms, local_sections)
1850      bfd *output_bfd;
1851      struct bfd_link_info *info;
1852      bfd *input_bfd;
1853      asection *input_section;
1854      bfd_byte *contents;
1855      Elf_Internal_Rela *relocs;
1856      Elf_Internal_Sym *local_syms;
1857      asection **local_sections;
1858 {
1859   Elf_Internal_Shdr *symtab_hdr;
1860   Elf_Internal_Rela *rel;
1861   Elf_Internal_Rela *relend;
1862   struct elf_link_hash_entry **sym_hashes;
1863   asection *srelgot, *srelplt;
1864   bfd *dynobj;
1865   char *error_message = NULL;
1866
1867   if (xtensa_default_isa == NULL)
1868     xtensa_isa_init ();
1869
1870   dynobj = elf_hash_table (info)->dynobj;
1871   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1872   sym_hashes = elf_sym_hashes (input_bfd);
1873
1874   srelgot = NULL;
1875   srelplt = NULL;
1876   if (dynobj != NULL)
1877     {
1878       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
1879       srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1880     }
1881
1882   rel = relocs;
1883   relend = relocs + input_section->reloc_count;
1884   for (; rel < relend; rel++)
1885     {
1886       int r_type;
1887       reloc_howto_type *howto;
1888       unsigned long r_symndx;
1889       struct elf_link_hash_entry *h;
1890       Elf_Internal_Sym *sym;
1891       asection *sec;
1892       bfd_vma relocation;
1893       bfd_reloc_status_type r;
1894       bfd_boolean is_weak_undef;
1895       bfd_boolean unresolved_reloc;
1896
1897       r_type = ELF32_R_TYPE (rel->r_info);
1898       if (r_type == (int) R_XTENSA_GNU_VTINHERIT
1899           || r_type == (int) R_XTENSA_GNU_VTENTRY)
1900         continue;
1901
1902       if (r_type < 0 || r_type >= (int) R_XTENSA_max)
1903         {
1904           bfd_set_error (bfd_error_bad_value);
1905           return FALSE;
1906         }
1907       howto = &elf_howto_table[r_type];
1908
1909       r_symndx = ELF32_R_SYM (rel->r_info);
1910
1911       if (info->relocateable)
1912         {
1913           /* This is a relocateable link.
1914              1) If the reloc is against a section symbol, adjust
1915              according to the output section.
1916              2) If there is a new target for this relocation,
1917              the new target will be in the same output section.
1918              We adjust the relocation by the output section
1919              difference.  */
1920
1921           if (relaxing_section)
1922             {
1923               /* Check if this references a section in another input file.  */
1924               do_fix_for_relocateable_link (rel, input_bfd, input_section);
1925               r_type = ELF32_R_TYPE (rel->r_info);
1926             }
1927
1928           if (r_type == R_XTENSA_ASM_SIMPLIFY)
1929             {
1930               /* Convert ASM_SIMPLIFY into the simpler relocation
1931                  so that they never escape a relaxing link.  */
1932               contract_asm_expansion (contents, input_section->_raw_size, rel);
1933               r_type = ELF32_R_TYPE (rel->r_info);
1934             }
1935
1936           /* This is a relocateable link, so we don't have to change
1937              anything unless the reloc is against a section symbol,
1938              in which case we have to adjust according to where the
1939              section symbol winds up in the output section.  */
1940           if (r_symndx < symtab_hdr->sh_info)
1941             {
1942               sym = local_syms + r_symndx;
1943               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1944                 {
1945                   sec = local_sections[r_symndx];
1946                   rel->r_addend += sec->output_offset + sym->st_value;
1947                 }
1948             }
1949
1950           /* If there is an addend with a partial_inplace howto,
1951              then move the addend to the contents.  This is a hack
1952              to work around problems with DWARF in relocateable links
1953              with some previous version of BFD.  Now we can't easily get
1954              rid of the hack without breaking backward compatibility.... */
1955           if (rel->r_addend)
1956             {
1957               howto = &elf_howto_table[r_type];
1958               if (howto->partial_inplace)
1959                 {
1960                   r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
1961                                            rel->r_addend, contents,
1962                                            rel->r_offset, FALSE,
1963                                            &error_message);
1964                   if (r != bfd_reloc_ok)
1965                     {
1966                       if (!((*info->callbacks->reloc_dangerous)
1967                             (info, error_message, input_bfd, input_section,
1968                              rel->r_offset)))
1969                         return FALSE;
1970                     }
1971                   rel->r_addend = 0;
1972                 }
1973             }
1974
1975           /* Done with work for relocateable link; continue with next reloc.  */
1976           continue;
1977         }
1978
1979       /* This is a final link.  */
1980
1981       h = NULL;
1982       sym = NULL;
1983       sec = NULL;
1984       is_weak_undef = FALSE;
1985       unresolved_reloc = FALSE;
1986
1987       if (howto->partial_inplace)
1988         {
1989           /* Because R_XTENSA_32 was made partial_inplace to fix some
1990              problems with DWARF info in partial links, there may be
1991              an addend stored in the contents.  Take it out of there
1992              and move it back into the addend field of the reloc.  */
1993           rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
1994           bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
1995         }
1996
1997       if (r_symndx < symtab_hdr->sh_info)
1998         {
1999           sym = local_syms + r_symndx;
2000           sec = local_sections[r_symndx];
2001           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
2002         }
2003       else
2004         {
2005           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2006
2007           while (h->root.type == bfd_link_hash_indirect
2008                  || h->root.type == bfd_link_hash_warning)
2009             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2010
2011           relocation = 0;
2012           if (h->root.type == bfd_link_hash_defined
2013               || h->root.type == bfd_link_hash_defweak)
2014             {
2015               sec = h->root.u.def.section;
2016
2017               if (sec->output_section == NULL)
2018                 /* Set a flag that will be cleared later if we find a
2019                    relocation value for this symbol.  output_section
2020                    is typically NULL for symbols satisfied by a shared
2021                    library.  */
2022                 unresolved_reloc = TRUE;
2023               else
2024                 relocation = (h->root.u.def.value
2025                               + sec->output_section->vma
2026                               + sec->output_offset);
2027             }
2028           else if (h->root.type == bfd_link_hash_undefweak)
2029             is_weak_undef = TRUE;
2030           else if (info->shared
2031                    && !info->no_undefined
2032                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2033             ;
2034           else
2035             {
2036               if (! ((*info->callbacks->undefined_symbol)
2037                      (info, h->root.root.string, input_bfd,
2038                       input_section, rel->r_offset,
2039                       (!info->shared || info->no_undefined
2040                        || ELF_ST_VISIBILITY (h->other)))))
2041                 return FALSE;
2042
2043               /* To avoid any more warning messages, like "call out of
2044                  range", we continue immediately to the next relocation.  */
2045               continue;
2046             }
2047         }
2048
2049       if (relaxing_section)
2050         {
2051           /* Check if this references a section in another input file.  */
2052           do_fix_for_final_link (rel, input_section, &relocation);
2053
2054           /* Update some already cached values.  */
2055           r_type = ELF32_R_TYPE (rel->r_info);
2056           howto = &elf_howto_table[r_type];
2057         }
2058
2059       /* Sanity check the address.  */
2060       if (rel->r_offset >= input_section->_raw_size
2061           && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2062         {
2063           bfd_set_error (bfd_error_bad_value);
2064           return FALSE;
2065         }
2066
2067       /* Generate dynamic relocations.  */
2068       if (elf_hash_table (info)->dynamic_sections_created)
2069         {
2070           bfd_boolean dynamic_symbol = xtensa_elf_dynamic_symbol_p (info, h);
2071
2072           if (dynamic_symbol && (r_type == R_XTENSA_OP0
2073                                  || r_type == R_XTENSA_OP1
2074                                  || r_type == R_XTENSA_OP2))
2075             {
2076               /* This is an error.  The symbol's real value won't be known
2077                  until runtime and it's likely to be out of range anyway.  */
2078               const char *name = h->root.root.string;
2079               error_message = vsprint_msg ("invalid relocation for dynamic "
2080                                            "symbol", ": %s",
2081                                            strlen (name) + 2, name);
2082               if (!((*info->callbacks->reloc_dangerous)
2083                     (info, error_message, input_bfd, input_section,
2084                      rel->r_offset)))
2085                 return FALSE;
2086             }
2087           else if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
2088                    && (input_section->flags & SEC_ALLOC) != 0
2089                    && (dynamic_symbol || info->shared))
2090             {
2091               Elf_Internal_Rela outrel;
2092               bfd_byte *loc;
2093               asection *srel;
2094
2095               if (dynamic_symbol && r_type == R_XTENSA_PLT)
2096                 srel = srelplt;
2097               else
2098                 srel = srelgot;
2099
2100               BFD_ASSERT (srel != NULL);
2101
2102               outrel.r_offset =
2103                 _bfd_elf_section_offset (output_bfd, info,
2104                                          input_section, rel->r_offset);
2105
2106               if ((outrel.r_offset | 1) == (bfd_vma) -1)
2107                 memset (&outrel, 0, sizeof outrel);
2108               else
2109                 {
2110                   outrel.r_offset = (input_section->output_section->vma
2111                                      + input_section->output_offset);
2112
2113                   if (dynamic_symbol)
2114                     {
2115                       outrel.r_addend = rel->r_addend;
2116                       rel->r_addend = 0;
2117
2118                       if (r_type == R_XTENSA_32)
2119                         {
2120                           outrel.r_info =
2121                             ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2122                           relocation = 0;
2123                         }
2124                       else /* r_type == R_XTENSA_PLT */
2125                         {
2126                           outrel.r_info =
2127                             ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2128
2129                           /* Create the PLT entry and set the initial
2130                              contents of the literal entry to the address of
2131                              the PLT entry.  */
2132                           relocation =
2133                             elf_xtensa_create_plt_entry (dynobj, output_bfd,
2134                                                          srel->reloc_count);
2135                         }
2136                       unresolved_reloc = FALSE;
2137                     }
2138                   else
2139                     {
2140                       /* Generate a RELATIVE relocation.  */
2141                       outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2142                       outrel.r_addend = 0;
2143                     }
2144                 }
2145
2146               loc = (srel->contents
2147                      + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2148               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2149               BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2150                           <= srel->_cooked_size);
2151             }
2152         }
2153
2154       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2155          because such sections are not SEC_ALLOC and thus ld.so will
2156          not process them.  */
2157       if (unresolved_reloc
2158           && !((input_section->flags & SEC_DEBUGGING) != 0
2159                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2160         (*_bfd_error_handler)
2161           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2162            bfd_archive_filename (input_bfd),
2163            bfd_get_section_name (input_bfd, input_section),
2164            (long) rel->r_offset,
2165            h->root.root.string);
2166
2167       /* There's no point in calling bfd_perform_relocation here.
2168          Just go directly to our "special function".  */
2169       r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2170                                relocation + rel->r_addend,
2171                                contents, rel->r_offset, is_weak_undef,
2172                                &error_message);
2173
2174       if (r != bfd_reloc_ok)
2175         {
2176           const char *name;
2177
2178           BFD_ASSERT (r == bfd_reloc_dangerous);
2179           BFD_ASSERT (error_message != (char *) NULL);
2180
2181           if (h != NULL)
2182             name = h->root.root.string;
2183           else
2184             {
2185               name = bfd_elf_string_from_elf_section
2186                 (input_bfd, symtab_hdr->sh_link, sym->st_name);
2187               if (name && *name == '\0')
2188                 name = bfd_section_name (input_bfd, sec);
2189             }
2190           if (name)
2191             error_message = vsprint_msg (error_message, ": %s",
2192                                          strlen (name), name);
2193           if (!((*info->callbacks->reloc_dangerous)
2194                 (info, error_message, input_bfd, input_section,
2195                  rel->r_offset)))
2196             return FALSE;
2197         }
2198     }
2199
2200   return TRUE;
2201 }
2202
2203
2204 /* Finish up dynamic symbol handling.  There's not much to do here since
2205    the PLT and GOT entries are all set up by relocate_section.  */
2206
2207 static bfd_boolean
2208 elf_xtensa_finish_dynamic_symbol (output_bfd, info, h, sym)
2209      bfd *output_bfd ATTRIBUTE_UNUSED;
2210      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2211      struct elf_link_hash_entry *h;
2212      Elf_Internal_Sym *sym;
2213 {
2214   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
2215       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2216     {
2217       /* Mark the symbol as undefined, rather than as defined in
2218          the .plt section.  Leave the value alone.  */
2219       sym->st_shndx = SHN_UNDEF;
2220     }
2221
2222   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2223   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2224       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2225     sym->st_shndx = SHN_ABS;
2226
2227   return TRUE;
2228 }
2229
2230
2231 /* Combine adjacent literal table entries in the output.  Adjacent
2232    entries within each input section may have been removed during
2233    relaxation, but we repeat the process here, even though it's too late
2234    to shrink the output section, because it's important to minimize the
2235    number of literal table entries to reduce the start-up work for the
2236    runtime linker.  Returns the number of remaining table entries or -1
2237    on error.  */
2238
2239 static int
2240 elf_xtensa_combine_prop_entries (output_bfd, secname)
2241      bfd *output_bfd;
2242      const char *secname;
2243 {
2244   asection *sec;
2245   bfd_byte *contents;
2246   property_table_entry *table;
2247   bfd_size_type section_size;
2248   bfd_vma offset;
2249   int n, m, num;
2250
2251   sec = bfd_get_section_by_name (output_bfd, secname);
2252   if (!sec)
2253     return -1;
2254
2255   section_size = (sec->_cooked_size != 0 ? sec->_cooked_size : sec->_raw_size);
2256   BFD_ASSERT (section_size % 8 == 0);
2257   num = section_size / 8;
2258
2259   contents = (bfd_byte *) bfd_malloc (section_size);
2260   table = (property_table_entry *)
2261     bfd_malloc (num * sizeof (property_table_entry));
2262   if (contents == 0 || table == 0)
2263     return -1;
2264
2265   /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
2266      propagates to the output section, where it doesn't really apply and
2267      where it breaks the following call to bfd_get_section_contents.  */
2268   sec->flags &= ~SEC_IN_MEMORY;
2269
2270   if (! bfd_get_section_contents (output_bfd, sec, contents, 0, section_size))
2271     return -1;
2272
2273   /* There should never be any relocations left at this point, so this
2274      is quite a bit easier than what is done during relaxation.  */
2275
2276   /* Copy the raw contents into a property table array and sort it.  */
2277   offset = 0;
2278   for (n = 0; n < num; n++)
2279     {
2280       table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
2281       table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
2282       offset += 8;
2283     }
2284   qsort (table, num, sizeof (property_table_entry), property_table_compare);
2285
2286   for (n = 0; n < num; n++)
2287     {
2288       bfd_boolean remove = FALSE;
2289
2290       if (table[n].size == 0)
2291         remove = TRUE;
2292       else if (n > 0 &&
2293                (table[n-1].address + table[n-1].size == table[n].address))
2294         {
2295           table[n-1].size += table[n].size;
2296           remove = TRUE;
2297         }
2298
2299       if (remove)
2300         {
2301           for (m = n; m < num - 1; m++)
2302             {
2303               table[m].address = table[m+1].address;
2304               table[m].size = table[m+1].size;
2305             }
2306
2307           n--;
2308           num--;
2309         }
2310     }
2311
2312   /* Copy the data back to the raw contents.  */
2313   offset = 0;
2314   for (n = 0; n < num; n++)
2315     {
2316       bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
2317       bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
2318       offset += 8;
2319     }
2320
2321   /* Clear the removed bytes.  */
2322   if ((bfd_size_type) (num * 8) < section_size)
2323     {
2324       memset (&contents[num * 8], 0, section_size - num * 8);
2325       sec->_cooked_size = num * 8;
2326     }
2327
2328   if (! bfd_set_section_contents (output_bfd, sec, contents, 0, section_size))
2329     return -1;
2330
2331   free (contents);
2332   return num;
2333 }
2334
2335
2336 /* Finish up the dynamic sections.  */
2337
2338 static bfd_boolean
2339 elf_xtensa_finish_dynamic_sections (output_bfd, info)
2340      bfd *output_bfd;
2341      struct bfd_link_info *info;
2342 {
2343   bfd *dynobj;
2344   asection *sdyn, *srelplt, *sgot;
2345   Elf32_External_Dyn *dyncon, *dynconend;
2346   int num_xtlit_entries;
2347
2348   if (! elf_hash_table (info)->dynamic_sections_created)
2349     return TRUE;
2350
2351   dynobj = elf_hash_table (info)->dynobj;
2352   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2353   BFD_ASSERT (sdyn != NULL);
2354
2355   /* Set the first entry in the global offset table to the address of
2356      the dynamic section.  */
2357   sgot = bfd_get_section_by_name (dynobj, ".got");
2358   if (sgot)
2359     {
2360       BFD_ASSERT (sgot->_raw_size == 4);
2361       if (sdyn == NULL)
2362         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2363       else
2364         bfd_put_32 (output_bfd,
2365                     sdyn->output_section->vma + sdyn->output_offset,
2366                     sgot->contents);
2367     }
2368
2369   srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
2370   if (srelplt != NULL && srelplt->_raw_size != 0)
2371     {
2372       asection *sgotplt, *srelgot, *spltlittbl;
2373       int chunk, plt_chunks, plt_entries;
2374       Elf_Internal_Rela irela;
2375       bfd_byte *loc;
2376       unsigned rtld_reloc;
2377
2378       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
2379       BFD_ASSERT (srelgot != NULL);
2380
2381       spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt");
2382       BFD_ASSERT (spltlittbl != NULL);
2383
2384       /* Find the first XTENSA_RTLD relocation.  Presumably the rest
2385          of them follow immediately after....  */
2386       for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
2387         {
2388           loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2389           bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2390           if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
2391             break;
2392         }
2393       BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
2394
2395       plt_entries = (srelplt->_raw_size / sizeof (Elf32_External_Rela));
2396       plt_chunks =
2397         (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
2398
2399       for (chunk = 0; chunk < plt_chunks; chunk++)
2400         {
2401           int chunk_entries = 0;
2402
2403           sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
2404           BFD_ASSERT (sgotplt != NULL);
2405
2406           /* Emit special RTLD relocations for the first two entries in
2407              each chunk of the .got.plt section.  */
2408
2409           loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2410           bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2411           BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2412           irela.r_offset = (sgotplt->output_section->vma
2413                             + sgotplt->output_offset);
2414           irela.r_addend = 1; /* tell rtld to set value to resolver function */
2415           bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2416           rtld_reloc += 1;
2417           BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2418
2419           /* Next literal immediately follows the first.  */
2420           loc += sizeof (Elf32_External_Rela);
2421           bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2422           BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2423           irela.r_offset = (sgotplt->output_section->vma
2424                             + sgotplt->output_offset + 4);
2425           /* Tell rtld to set value to object's link map.  */
2426           irela.r_addend = 2;
2427           bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2428           rtld_reloc += 1;
2429           BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2430
2431           /* Fill in the literal table.  */
2432           if (chunk < plt_chunks - 1)
2433             chunk_entries = PLT_ENTRIES_PER_CHUNK;
2434           else
2435             chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
2436
2437           BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->_cooked_size);
2438           bfd_put_32 (output_bfd,
2439                       sgotplt->output_section->vma + sgotplt->output_offset,
2440                       spltlittbl->contents + (chunk * 8) + 0);
2441           bfd_put_32 (output_bfd,
2442                       8 + (chunk_entries * 4),
2443                       spltlittbl->contents + (chunk * 8) + 4);
2444         }
2445
2446       /* All the dynamic relocations have been emitted at this point.
2447          Make sure the relocation sections are the correct size.  */
2448       if (srelgot->_cooked_size != (sizeof (Elf32_External_Rela)
2449                                     * srelgot->reloc_count)
2450           || srelplt->_cooked_size != (sizeof (Elf32_External_Rela)
2451                                        * srelplt->reloc_count))
2452         abort ();
2453
2454      /* The .xt.lit.plt section has just been modified.  This must
2455         happen before the code below which combines adjacent literal
2456         table entries, and the .xt.lit.plt contents have to be forced to
2457         the output here.  */
2458       if (! bfd_set_section_contents (output_bfd,
2459                                       spltlittbl->output_section,
2460                                       spltlittbl->contents,
2461                                       spltlittbl->output_offset,
2462                                       spltlittbl->_raw_size))
2463         return FALSE;
2464       /* Clear SEC_HAS_CONTENTS so the contents won't be output again.  */
2465       spltlittbl->flags &= ~SEC_HAS_CONTENTS;
2466     }
2467
2468   /* Combine adjacent literal table entries.  */
2469   BFD_ASSERT (! info->relocateable);
2470   num_xtlit_entries = elf_xtensa_combine_prop_entries (output_bfd, ".xt.lit");
2471   if (num_xtlit_entries < 0)
2472     return FALSE;
2473
2474   dyncon = (Elf32_External_Dyn *) sdyn->contents;
2475   dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2476   for (; dyncon < dynconend; dyncon++)
2477     {
2478       Elf_Internal_Dyn dyn;
2479       const char *name;
2480       asection *s;
2481
2482       bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2483
2484       switch (dyn.d_tag)
2485         {
2486         default:
2487           break;
2488
2489         case DT_XTENSA_GOT_LOC_SZ:
2490           s = bfd_get_section_by_name (output_bfd, ".xt.lit");
2491           BFD_ASSERT (s);
2492           dyn.d_un.d_val = num_xtlit_entries;
2493           break;
2494
2495         case DT_XTENSA_GOT_LOC_OFF:
2496           name = ".xt.lit";
2497           goto get_vma;
2498         case DT_PLTGOT:
2499           name = ".got";
2500           goto get_vma;
2501         case DT_JMPREL:
2502           name = ".rela.plt";
2503         get_vma:
2504           s = bfd_get_section_by_name (output_bfd, name);
2505           BFD_ASSERT (s);
2506           dyn.d_un.d_ptr = s->vma;
2507           break;
2508
2509         case DT_PLTRELSZ:
2510           s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2511           BFD_ASSERT (s);
2512           dyn.d_un.d_val = (s->_cooked_size ? s->_cooked_size : s->_raw_size);
2513           break;
2514
2515         case DT_RELASZ:
2516           /* Adjust RELASZ to not include JMPREL.  This matches what
2517              glibc expects and what is done for several other ELF
2518              targets (e.g., i386, alpha), but the "correct" behavior
2519              seems to be unresolved.  Since the linker script arranges
2520              for .rela.plt to follow all other relocation sections, we
2521              don't have to worry about changing the DT_RELA entry.  */
2522           s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2523           if (s)
2524             {
2525               dyn.d_un.d_val -=
2526                 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
2527             }
2528           break;
2529         }
2530
2531       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2532     }
2533
2534   return TRUE;
2535 }
2536
2537 \f
2538 /* Functions for dealing with the e_flags field.  */
2539
2540 /* Merge backend specific data from an object file to the output
2541    object file when linking.  */
2542
2543 static bfd_boolean
2544 elf_xtensa_merge_private_bfd_data (ibfd, obfd)
2545      bfd *ibfd;
2546      bfd *obfd;
2547 {
2548   unsigned out_mach, in_mach;
2549   flagword out_flag, in_flag;
2550
2551   /* Check if we have the same endianess.  */
2552   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
2553     return FALSE;
2554
2555   /* Don't even pretend to support mixed-format linking.  */
2556   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2557       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2558     return FALSE;
2559
2560   out_flag = elf_elfheader (obfd)->e_flags;
2561   in_flag = elf_elfheader (ibfd)->e_flags;
2562
2563   out_mach = out_flag & EF_XTENSA_MACH;
2564   in_mach = in_flag & EF_XTENSA_MACH;
2565   if (out_mach != in_mach)
2566     {
2567       (*_bfd_error_handler)
2568         ("%s: incompatible machine type. Output is 0x%x. Input is 0x%x\n",
2569          bfd_archive_filename (ibfd), out_mach, in_mach);
2570       bfd_set_error (bfd_error_wrong_format);
2571       return FALSE;
2572     }
2573
2574   if (! elf_flags_init (obfd))
2575     {
2576       elf_flags_init (obfd) = TRUE;
2577       elf_elfheader (obfd)->e_flags = in_flag;
2578
2579       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2580           && bfd_get_arch_info (obfd)->the_default)
2581         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2582                                   bfd_get_mach (ibfd));
2583
2584       return TRUE;
2585     }
2586
2587   if ((out_flag & EF_XTENSA_XT_INSN) !=
2588       (in_flag & EF_XTENSA_XT_INSN))
2589     elf_elfheader(obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
2590
2591   if ((out_flag & EF_XTENSA_XT_LIT) !=
2592       (in_flag & EF_XTENSA_XT_LIT))
2593     elf_elfheader(obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
2594
2595   return TRUE;
2596 }
2597
2598
2599 static bfd_boolean
2600 elf_xtensa_set_private_flags (abfd, flags)
2601      bfd *abfd;
2602      flagword flags;
2603 {
2604   BFD_ASSERT (!elf_flags_init (abfd)
2605               || elf_elfheader (abfd)->e_flags == flags);
2606
2607   elf_elfheader (abfd)->e_flags |= flags;
2608   elf_flags_init (abfd) = TRUE;
2609
2610   return TRUE;
2611 }
2612
2613
2614 extern flagword
2615 elf_xtensa_get_private_bfd_flags (abfd)
2616      bfd *abfd;
2617 {
2618   return elf_elfheader (abfd)->e_flags;
2619 }
2620
2621
2622 static bfd_boolean
2623 elf_xtensa_print_private_bfd_data (abfd, farg)
2624      bfd *abfd;
2625      PTR farg;
2626 {
2627   FILE *f = (FILE *) farg;
2628   flagword e_flags = elf_elfheader (abfd)->e_flags;
2629
2630   fprintf (f, "\nXtensa header:\n");
2631   if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
2632     fprintf (f, "\nMachine     = Base\n");
2633   else
2634     fprintf (f, "\nMachine Id  = 0x%x\n", e_flags & EF_XTENSA_MACH);
2635
2636   fprintf (f, "Insn tables = %s\n",
2637            (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
2638
2639   fprintf (f, "Literal tables = %s\n",
2640            (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
2641
2642   return _bfd_elf_print_private_bfd_data (abfd, farg);
2643 }
2644
2645
2646 /* Set the right machine number for an Xtensa ELF file.  */
2647
2648 static bfd_boolean
2649 elf_xtensa_object_p (abfd)
2650      bfd *abfd;
2651 {
2652   int mach;
2653   unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
2654
2655   switch (arch)
2656     {
2657     case E_XTENSA_MACH:
2658       mach = bfd_mach_xtensa;
2659       break;
2660     default:
2661       return FALSE;
2662     }
2663
2664   (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
2665   return TRUE;
2666 }
2667
2668
2669 /* The final processing done just before writing out an Xtensa ELF object
2670    file.  This gets the Xtensa architecture right based on the machine
2671    number.  */
2672
2673 static void
2674 elf_xtensa_final_write_processing (abfd, linker)
2675      bfd *abfd;
2676      bfd_boolean linker ATTRIBUTE_UNUSED;
2677 {
2678   int mach;
2679   unsigned long val;
2680
2681   switch (mach = bfd_get_mach (abfd))
2682     {
2683     case bfd_mach_xtensa:
2684       val = E_XTENSA_MACH;
2685       break;
2686     default:
2687       return;
2688     }
2689
2690   elf_elfheader (abfd)->e_flags &=  (~ EF_XTENSA_MACH);
2691   elf_elfheader (abfd)->e_flags |= val;
2692 }
2693
2694
2695 static enum elf_reloc_type_class
2696 elf_xtensa_reloc_type_class (rela)
2697      const Elf_Internal_Rela *rela;
2698 {
2699   switch ((int) ELF32_R_TYPE (rela->r_info))
2700     {
2701     case R_XTENSA_RELATIVE:
2702       return reloc_class_relative;
2703     case R_XTENSA_JMP_SLOT:
2704       return reloc_class_plt;
2705     default:
2706       return reloc_class_normal;
2707     }
2708 }
2709
2710 \f
2711 static bfd_boolean
2712 elf_xtensa_discard_info_for_section (abfd, cookie, info, sec)
2713      bfd *abfd;
2714      struct elf_reloc_cookie *cookie;
2715      struct bfd_link_info *info;
2716      asection *sec;
2717 {
2718   bfd_byte *contents;
2719   bfd_vma section_size;
2720   bfd_vma offset, actual_offset;
2721   size_t removed_bytes = 0;
2722
2723   section_size = (sec->_cooked_size ? sec->_cooked_size : sec->_raw_size);
2724   if (section_size == 0 || section_size % 8 != 0)
2725     return FALSE;
2726
2727   if (sec->output_section
2728       && bfd_is_abs_section (sec->output_section))
2729     return FALSE;
2730
2731   contents = retrieve_contents (abfd, sec, info->keep_memory);
2732   if (!contents)
2733     return FALSE;
2734
2735   cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
2736   if (!cookie->rels)
2737     {
2738       release_contents (sec, contents);
2739       return FALSE;
2740     }
2741
2742   cookie->rel = cookie->rels;
2743   cookie->relend = cookie->rels + sec->reloc_count;
2744
2745   for (offset = 0; offset < section_size; offset += 8)
2746     {
2747       actual_offset = offset - removed_bytes;
2748
2749       /* The ...symbol_deleted_p function will skip over relocs but it
2750          won't adjust their offsets, so do that here.  */
2751       while (cookie->rel < cookie->relend
2752              && cookie->rel->r_offset < offset)
2753         {
2754           cookie->rel->r_offset -= removed_bytes;
2755           cookie->rel++;
2756         }
2757
2758       while (cookie->rel < cookie->relend
2759              && cookie->rel->r_offset == offset)
2760         {
2761           if (_bfd_elf32_reloc_symbol_deleted_p (offset, cookie))
2762             {
2763               /* Remove the table entry.  (If the reloc type is NONE, then
2764                  the entry has already been merged with another and deleted
2765                  during relaxation.)  */
2766               if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
2767                 {
2768                   /* Shift the contents up.  */
2769                   if (offset + 8 < section_size)
2770                     memmove (&contents[actual_offset],
2771                              &contents[actual_offset+8],
2772                              section_size - offset - 8);
2773                   removed_bytes += 8;
2774                 }
2775
2776               /* Remove this relocation.  */
2777               cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
2778             }
2779
2780           /* Adjust the relocation offset for previous removals.  This
2781              should not be done before calling ...symbol_deleted_p
2782              because it might mess up the offset comparisons there.
2783              Make sure the offset doesn't underflow in the case where
2784              the first entry is removed.  */
2785           if (cookie->rel->r_offset >= removed_bytes)
2786             cookie->rel->r_offset -= removed_bytes;
2787           else
2788             cookie->rel->r_offset = 0;
2789
2790           cookie->rel++;
2791         }
2792     }
2793
2794   if (removed_bytes != 0)
2795     {
2796       /* Adjust any remaining relocs (shouldn't be any).  */
2797       for (; cookie->rel < cookie->relend; cookie->rel++)
2798         {
2799           if (cookie->rel->r_offset >= removed_bytes)
2800             cookie->rel->r_offset -= removed_bytes;
2801           else
2802             cookie->rel->r_offset = 0;
2803         }
2804
2805       /* Clear the removed bytes.  */
2806       memset (&contents[section_size - removed_bytes], 0, removed_bytes);
2807
2808       pin_contents (sec, contents);
2809       pin_internal_relocs (sec, cookie->rels);
2810
2811       sec->_cooked_size = section_size - removed_bytes;
2812       /* Also shrink _raw_size.  See comments in relax_property_section.  */
2813       sec->_raw_size = sec->_cooked_size;
2814     }
2815   else
2816     {
2817       release_contents (sec, contents);
2818       release_internal_relocs (sec, cookie->rels);
2819     }
2820
2821   return (removed_bytes != 0);
2822 }
2823
2824
2825 static bfd_boolean
2826 elf_xtensa_discard_info (abfd, cookie, info)
2827      bfd *abfd;
2828      struct elf_reloc_cookie *cookie;
2829      struct bfd_link_info *info;
2830 {
2831   asection *sec;
2832   bfd_boolean changed = FALSE;
2833
2834   for (sec = abfd->sections; sec != NULL; sec = sec->next)
2835     {
2836       if (xtensa_is_property_section (sec))
2837         {
2838           if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
2839             changed = TRUE;
2840         }
2841     }
2842
2843   return changed;
2844 }
2845
2846
2847 static bfd_boolean
2848 elf_xtensa_ignore_discarded_relocs (sec)
2849      asection *sec;
2850 {
2851   return xtensa_is_property_section (sec);
2852 }
2853
2854 \f
2855 /* Support for core dump NOTE sections.  */
2856
2857 static bfd_boolean
2858 elf_xtensa_grok_prstatus (abfd, note)
2859      bfd *abfd;
2860      Elf_Internal_Note *note;
2861 {
2862   int offset;
2863   unsigned int raw_size;
2864
2865   /* The size for Xtensa is variable, so don't try to recognize the format
2866      based on the size.  Just assume this is GNU/Linux.  */
2867
2868   /* pr_cursig */
2869   elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2870
2871   /* pr_pid */
2872   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
2873
2874   /* pr_reg */
2875   offset = 72;
2876   raw_size = note->descsz - offset - 4;
2877
2878   /* Make a ".reg/999" section.  */
2879   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2880                                           raw_size, note->descpos + offset);
2881 }
2882
2883
2884 static bfd_boolean
2885 elf_xtensa_grok_psinfo (abfd, note)
2886      bfd *abfd;
2887      Elf_Internal_Note *note;
2888 {
2889   switch (note->descsz)
2890     {
2891       default:
2892         return FALSE;
2893
2894       case 128:         /* GNU/Linux elf_prpsinfo */
2895         elf_tdata (abfd)->core_program
2896          = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
2897         elf_tdata (abfd)->core_command
2898          = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
2899     }
2900
2901   /* Note that for some reason, a spurious space is tacked
2902      onto the end of the args in some (at least one anyway)
2903      implementations, so strip it off if it exists.  */
2904
2905   {
2906     char *command = elf_tdata (abfd)->core_command;
2907     int n = strlen (command);
2908
2909     if (0 < n && command[n - 1] == ' ')
2910       command[n - 1] = '\0';
2911   }
2912
2913   return TRUE;
2914 }
2915
2916 \f
2917 /* Generic Xtensa configurability stuff.  */
2918
2919 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
2920 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
2921 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
2922 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
2923 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
2924 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
2925 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
2926 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
2927
2928 static void
2929 init_call_opcodes ()
2930 {
2931   if (callx0_op == XTENSA_UNDEFINED)
2932     {
2933       callx0_op  = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
2934       callx4_op  = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
2935       callx8_op  = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
2936       callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
2937       call0_op   = xtensa_opcode_lookup (xtensa_default_isa, "call0");
2938       call4_op   = xtensa_opcode_lookup (xtensa_default_isa, "call4");
2939       call8_op   = xtensa_opcode_lookup (xtensa_default_isa, "call8");
2940       call12_op  = xtensa_opcode_lookup (xtensa_default_isa, "call12");
2941     }
2942 }
2943
2944
2945 static bfd_boolean
2946 is_indirect_call_opcode (opcode)
2947      xtensa_opcode opcode;
2948 {
2949   init_call_opcodes ();
2950   return (opcode == callx0_op
2951           || opcode == callx4_op
2952           || opcode == callx8_op
2953           || opcode == callx12_op);
2954 }
2955
2956
2957 static bfd_boolean
2958 is_direct_call_opcode (opcode)
2959      xtensa_opcode opcode;
2960 {
2961   init_call_opcodes ();
2962   return (opcode == call0_op
2963           || opcode == call4_op
2964           || opcode == call8_op
2965           || opcode == call12_op);
2966 }
2967
2968
2969 static bfd_boolean
2970 is_windowed_call_opcode (opcode)
2971      xtensa_opcode opcode;
2972 {
2973   init_call_opcodes ();
2974   return (opcode == call4_op
2975           || opcode == call8_op
2976           || opcode == call12_op
2977           || opcode == callx4_op
2978           || opcode == callx8_op
2979           || opcode == callx12_op);
2980 }
2981
2982
2983 static xtensa_opcode
2984 get_l32r_opcode (void)
2985 {
2986   static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
2987   if (l32r_opcode == XTENSA_UNDEFINED)
2988     {
2989       l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
2990       BFD_ASSERT (l32r_opcode != XTENSA_UNDEFINED);
2991     }
2992   return l32r_opcode;
2993 }
2994
2995
2996 static bfd_vma
2997 l32r_offset (addr, pc)
2998      bfd_vma addr;
2999      bfd_vma pc;
3000 {
3001   bfd_vma offset;
3002
3003   offset = addr - ((pc+3) & -4);
3004   BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3005   offset = (signed int) offset >> 2;
3006   BFD_ASSERT ((signed int) offset >> 16 == -1);
3007   return offset;
3008 }
3009
3010
3011 /* Get the operand number for a PC-relative relocation.
3012    If the relocation is not a PC-relative one, return (-1).  */
3013
3014 static int
3015 get_relocation_opnd (irel)
3016      Elf_Internal_Rela *irel;
3017 {
3018   if (ELF32_R_TYPE (irel->r_info) < R_XTENSA_OP0
3019       || ELF32_R_TYPE (irel->r_info) >= R_XTENSA_max)
3020     return -1;
3021   return ELF32_R_TYPE (irel->r_info) - R_XTENSA_OP0;
3022 }
3023
3024
3025 /* Get the opcode for a relocation.  */
3026
3027 static xtensa_opcode
3028 get_relocation_opcode (sec, contents, irel)
3029      asection *sec;
3030      bfd_byte *contents;
3031      Elf_Internal_Rela *irel;
3032 {
3033   static xtensa_insnbuf ibuff = NULL;
3034   xtensa_isa isa = xtensa_default_isa;
3035
3036   if (get_relocation_opnd (irel) == -1)
3037     return XTENSA_UNDEFINED;
3038
3039   if (contents == NULL)
3040     return XTENSA_UNDEFINED;
3041
3042   if (sec->_raw_size <= irel->r_offset)
3043     return XTENSA_UNDEFINED;
3044
3045   if (ibuff == NULL)
3046     ibuff = xtensa_insnbuf_alloc (isa);
3047
3048   /* Decode the instruction.  */
3049   xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset]);
3050   return xtensa_decode_insn (isa, ibuff);
3051 }
3052
3053
3054 bfd_boolean
3055 is_l32r_relocation (sec, contents, irel)
3056      asection *sec;
3057      bfd_byte *contents;
3058      Elf_Internal_Rela *irel;
3059 {
3060   xtensa_opcode opcode;
3061
3062   if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_OP1)
3063     return FALSE;
3064
3065   opcode = get_relocation_opcode (sec, contents, irel);
3066   return (opcode == get_l32r_opcode ());
3067 }
3068
3069 \f
3070 /* Code for transforming CALLs at link-time.  */
3071
3072 static bfd_reloc_status_type
3073 elf_xtensa_do_asm_simplify (contents, address, content_length)
3074      bfd_byte *contents;
3075      bfd_vma address;
3076      bfd_vma content_length;
3077 {
3078   static xtensa_insnbuf insnbuf = NULL;
3079   xtensa_opcode opcode;
3080   xtensa_operand operand;
3081   xtensa_opcode direct_call_opcode;
3082   xtensa_isa isa = xtensa_default_isa;
3083   bfd_byte *chbuf = contents + address;
3084   int opn;
3085
3086   if (insnbuf == NULL)
3087     insnbuf = xtensa_insnbuf_alloc (isa);
3088
3089   if (content_length < address)
3090     {
3091       (*_bfd_error_handler)
3092         ("Attempt to convert L32R/CALLX to CALL failed\n");
3093       return bfd_reloc_other;
3094     }
3095
3096   opcode = get_expanded_call_opcode (chbuf, content_length - address);
3097   direct_call_opcode = swap_callx_for_call_opcode (opcode);
3098   if (direct_call_opcode == XTENSA_UNDEFINED)
3099     {
3100       (*_bfd_error_handler)
3101         ("Attempt to convert L32R/CALLX to CALL failed\n");
3102       return bfd_reloc_other;
3103     }
3104
3105   /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset.  */
3106   opcode = xtensa_opcode_lookup (isa, "or");
3107   xtensa_encode_insn (isa, opcode, insnbuf);
3108   for (opn = 0; opn < 3; opn++)
3109     {
3110       operand = xtensa_get_operand (isa, opcode, opn);
3111       xtensa_operand_set_field (operand, insnbuf, 1);
3112     }
3113   xtensa_insnbuf_to_chars (isa, insnbuf, chbuf);
3114
3115   /* Assemble a CALL ("callN 0") into the 3 byte offset.  */
3116   xtensa_encode_insn (isa, direct_call_opcode, insnbuf);
3117   operand = xtensa_get_operand (isa, opcode, 0);
3118   xtensa_operand_set_field (operand, insnbuf, 0);
3119   xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3);
3120
3121   return bfd_reloc_ok;
3122 }
3123
3124
3125 static bfd_reloc_status_type
3126 contract_asm_expansion (contents, content_length, irel)
3127      bfd_byte *contents;
3128      bfd_vma content_length;
3129      Elf_Internal_Rela *irel;
3130 {
3131   bfd_reloc_status_type retval =
3132     elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length);
3133
3134   if (retval != bfd_reloc_ok)
3135     return retval;
3136
3137   /* Update the irel->r_offset field so that the right immediate and
3138      the right instruction are modified during the relocation.  */
3139   irel->r_offset += 3;
3140   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_OP0);
3141   return bfd_reloc_ok;
3142 }
3143
3144
3145 static xtensa_opcode
3146 swap_callx_for_call_opcode (opcode)
3147      xtensa_opcode opcode;
3148 {
3149   init_call_opcodes ();
3150
3151   if (opcode == callx0_op) return call0_op;
3152   if (opcode == callx4_op) return call4_op;
3153   if (opcode == callx8_op) return call8_op;
3154   if (opcode == callx12_op) return call12_op;
3155
3156   /* Return XTENSA_UNDEFINED if the opcode is not an indirect call.  */
3157   return XTENSA_UNDEFINED;
3158 }
3159
3160
3161 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" sequence, and
3162    if so, return the CALLX opcode.  If not, return XTENSA_UNDEFINED.  */
3163
3164 #define L32R_TARGET_REG_OPERAND 0
3165 #define CALLN_SOURCE_OPERAND 0
3166
3167 static xtensa_opcode
3168 get_expanded_call_opcode (buf, bufsize)
3169      bfd_byte *buf;
3170      int bufsize;
3171 {
3172   static xtensa_insnbuf insnbuf = NULL;
3173   xtensa_opcode opcode;
3174   xtensa_operand operand;
3175   xtensa_isa isa = xtensa_default_isa;
3176   uint32 regno, call_regno;
3177
3178   /* Buffer must be at least 6 bytes.  */
3179   if (bufsize < 6)
3180     return XTENSA_UNDEFINED;
3181
3182   if (insnbuf == NULL)
3183     insnbuf = xtensa_insnbuf_alloc (isa);
3184
3185   xtensa_insnbuf_from_chars (isa, insnbuf, buf);
3186   opcode = xtensa_decode_insn (isa, insnbuf);
3187
3188   if (opcode != get_l32r_opcode ())
3189     return XTENSA_UNDEFINED;
3190
3191   operand = xtensa_get_operand (isa, opcode, L32R_TARGET_REG_OPERAND);
3192   regno = xtensa_operand_decode
3193     (operand, xtensa_operand_get_field (operand, insnbuf));
3194
3195   /* Next instruction should be an CALLXn with operand 0 == regno.  */
3196   xtensa_insnbuf_from_chars (isa, insnbuf,
3197                              buf + xtensa_insn_length (isa, opcode));
3198   opcode = xtensa_decode_insn (isa, insnbuf);
3199
3200   if (!is_indirect_call_opcode (opcode))
3201     return XTENSA_UNDEFINED;
3202
3203   operand = xtensa_get_operand (isa, opcode, CALLN_SOURCE_OPERAND);
3204   call_regno = xtensa_operand_decode
3205     (operand, xtensa_operand_get_field (operand, insnbuf));
3206   if (call_regno != regno)
3207     return XTENSA_UNDEFINED;
3208
3209   return opcode;
3210 }
3211
3212 \f
3213 /* Data structures used during relaxation.  */
3214
3215 /* r_reloc: relocation values.  */
3216
3217 /* Through the relaxation process, we need to keep track of the values
3218    that will result from evaluating relocations.  The standard ELF
3219    relocation structure is not sufficient for this purpose because we're
3220    operating on multiple input files at once, so we need to know which
3221    input file a relocation refers to.  The r_reloc structure thus
3222    records both the input file (bfd) and ELF relocation.
3223
3224    For efficiency, an r_reloc also contains a "target_offset" field to
3225    cache the target-section-relative offset value that is represented by
3226    the relocation.  */
3227
3228 typedef struct r_reloc_struct r_reloc;
3229
3230 struct r_reloc_struct
3231 {
3232   bfd *abfd;
3233   Elf_Internal_Rela rela;
3234   bfd_vma target_offset;
3235 };
3236
3237 static bfd_boolean r_reloc_is_const
3238   PARAMS ((const r_reloc *));
3239 static void r_reloc_init
3240   PARAMS ((r_reloc *, bfd *, Elf_Internal_Rela *));
3241 static bfd_vma r_reloc_get_target_offset
3242   PARAMS ((const r_reloc *));
3243 static asection *r_reloc_get_section
3244   PARAMS ((const r_reloc *));
3245 static bfd_boolean r_reloc_is_defined
3246   PARAMS ((const r_reloc *));
3247 static struct elf_link_hash_entry *r_reloc_get_hash_entry
3248   PARAMS ((const r_reloc *));
3249
3250
3251 /* The r_reloc structure is included by value in literal_value, but not
3252    every literal_value has an associated relocation -- some are simple
3253    constants.  In such cases, we set all the fields in the r_reloc
3254    struct to zero.  The r_reloc_is_const function should be used to
3255    detect this case.  */
3256
3257 static bfd_boolean
3258 r_reloc_is_const (r_rel)
3259      const r_reloc *r_rel;
3260 {
3261   return (r_rel->abfd == NULL);
3262 }
3263
3264
3265 static void
3266 r_reloc_init (r_rel, abfd, irel)
3267      r_reloc *r_rel;
3268      bfd *abfd;
3269      Elf_Internal_Rela *irel;
3270 {
3271   if (irel != NULL)
3272     {
3273       r_rel->rela = *irel;
3274       r_rel->abfd = abfd;
3275       r_rel->target_offset = r_reloc_get_target_offset (r_rel);
3276     }
3277   else
3278     memset (r_rel, 0, sizeof (r_reloc));
3279 }
3280
3281
3282 static bfd_vma
3283 r_reloc_get_target_offset (r_rel)
3284      const r_reloc *r_rel;
3285 {
3286   bfd_vma target_offset;
3287   unsigned long r_symndx;
3288
3289   BFD_ASSERT (!r_reloc_is_const (r_rel));
3290   r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
3291   target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
3292   return (target_offset + r_rel->rela.r_addend);
3293 }
3294
3295
3296 static struct elf_link_hash_entry *
3297 r_reloc_get_hash_entry (r_rel)
3298      const r_reloc *r_rel;
3299 {
3300   unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
3301   return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
3302 }
3303
3304
3305 static asection *
3306 r_reloc_get_section (r_rel)
3307      const r_reloc *r_rel;
3308 {
3309   unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
3310   return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
3311 }
3312
3313
3314 static bfd_boolean
3315 r_reloc_is_defined (r_rel)
3316      const r_reloc *r_rel;
3317 {
3318   asection *sec = r_reloc_get_section (r_rel);
3319   if (sec == bfd_abs_section_ptr
3320       || sec == bfd_com_section_ptr
3321       || sec == bfd_und_section_ptr)
3322     return FALSE;
3323   return TRUE;
3324 }
3325
3326 \f
3327 /* source_reloc: relocations that reference literal sections.  */
3328
3329 /* To determine whether literals can be coalesced, we need to first
3330    record all the relocations that reference the literals.  The
3331    source_reloc structure below is used for this purpose.  The
3332    source_reloc entries are kept in a per-literal-section array, sorted
3333    by offset within the literal section (i.e., target offset).
3334
3335    The source_sec and r_rel.rela.r_offset fields identify the source of
3336    the relocation.  The r_rel field records the relocation value, i.e.,
3337    the offset of the literal being referenced.  The opnd field is needed
3338    to determine the range of the immediate field to which the relocation
3339    applies, so we can determine whether another literal with the same
3340    value is within range.  The is_null field is true when the relocation
3341    is being removed (e.g., when an L32R is being removed due to a CALLX
3342    that is converted to a direct CALL).  */
3343
3344 typedef struct source_reloc_struct source_reloc;
3345
3346 struct source_reloc_struct
3347 {
3348   asection *source_sec;
3349   r_reloc r_rel;
3350   xtensa_operand opnd;
3351   bfd_boolean is_null;
3352 };
3353
3354
3355 static void init_source_reloc
3356   PARAMS ((source_reloc *, asection *, const r_reloc *, xtensa_operand));
3357 static source_reloc *find_source_reloc
3358   PARAMS ((source_reloc *, int, asection *, Elf_Internal_Rela *));
3359 static int source_reloc_compare
3360   PARAMS ((const PTR, const PTR));
3361
3362
3363 static void
3364 init_source_reloc (reloc, source_sec, r_rel, opnd)
3365      source_reloc *reloc;
3366      asection *source_sec;
3367      const r_reloc *r_rel;
3368      xtensa_operand opnd;
3369 {
3370   reloc->source_sec = source_sec;
3371   reloc->r_rel = *r_rel;
3372   reloc->opnd = opnd;
3373   reloc->is_null = FALSE;
3374 }
3375
3376
3377 /* Find the source_reloc for a particular source offset and relocation
3378    type.  Note that the array is sorted by _target_ offset, so this is
3379    just a linear search.  */
3380
3381 static source_reloc *
3382 find_source_reloc (src_relocs, src_count, sec, irel)
3383      source_reloc *src_relocs;
3384      int src_count;
3385      asection *sec;
3386      Elf_Internal_Rela *irel;
3387 {
3388   int i;
3389
3390   for (i = 0; i < src_count; i++)
3391     {
3392       if (src_relocs[i].source_sec == sec
3393           && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
3394           && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
3395               == ELF32_R_TYPE (irel->r_info)))
3396         return &src_relocs[i];
3397     }
3398
3399   return NULL;
3400 }
3401
3402
3403 static int
3404 source_reloc_compare (ap, bp)
3405      const PTR ap;
3406      const PTR bp;
3407 {
3408   const source_reloc *a = (const source_reloc *) ap;
3409   const source_reloc *b = (const source_reloc *) bp;
3410
3411   return (a->r_rel.target_offset - b->r_rel.target_offset);
3412 }
3413
3414 \f
3415 /* Literal values and value hash tables.  */
3416
3417 /* Literals with the same value can be coalesced.  The literal_value
3418    structure records the value of a literal: the "r_rel" field holds the
3419    information from the relocation on the literal (if there is one) and
3420    the "value" field holds the contents of the literal word itself.
3421
3422    The value_map structure records a literal value along with the
3423    location of a literal holding that value.  The value_map hash table
3424    is indexed by the literal value, so that we can quickly check if a
3425    particular literal value has been seen before and is thus a candidate
3426    for coalescing.  */
3427
3428 typedef struct literal_value_struct literal_value;
3429 typedef struct value_map_struct value_map;
3430 typedef struct value_map_hash_table_struct value_map_hash_table;
3431
3432 struct literal_value_struct
3433 {
3434   r_reloc r_rel;
3435   unsigned long value;
3436 };
3437
3438 struct value_map_struct
3439 {
3440   literal_value val;                    /* The literal value.  */
3441   r_reloc loc;                          /* Location of the literal.  */
3442   value_map *next;
3443 };
3444
3445 struct value_map_hash_table_struct
3446 {
3447   unsigned bucket_count;
3448   value_map **buckets;
3449   unsigned count;
3450 };
3451
3452
3453 static bfd_boolean is_same_value
3454   PARAMS ((const literal_value *, const literal_value *));
3455 static value_map_hash_table *value_map_hash_table_init
3456   PARAMS ((void));
3457 static unsigned hash_literal_value
3458   PARAMS ((const literal_value *));
3459 static unsigned hash_bfd_vma
3460   PARAMS ((bfd_vma));
3461 static value_map *get_cached_value
3462   PARAMS ((value_map_hash_table *, const literal_value *));
3463 static value_map *add_value_map
3464   PARAMS ((value_map_hash_table *, const literal_value *, const r_reloc *));
3465
3466
3467 static bfd_boolean
3468 is_same_value (src1, src2)
3469      const literal_value *src1;
3470      const literal_value *src2;
3471 {
3472   if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
3473     return FALSE;
3474
3475   if (r_reloc_is_const (&src1->r_rel))
3476     return (src1->value == src2->value);
3477
3478   if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
3479       != ELF32_R_TYPE (src2->r_rel.rela.r_info))
3480     return FALSE;
3481
3482   if (r_reloc_get_target_offset (&src1->r_rel)
3483       != r_reloc_get_target_offset (&src2->r_rel))
3484     return FALSE;
3485
3486   if (src1->value != src2->value)
3487     return FALSE;
3488
3489   /* Now check for the same section and the same elf_hash.  */
3490   if (r_reloc_is_defined (&src1->r_rel))
3491     {
3492       if (r_reloc_get_section (&src1->r_rel)
3493           != r_reloc_get_section (&src2->r_rel))
3494         return FALSE;
3495     }
3496   else
3497     {
3498       if (r_reloc_get_hash_entry (&src1->r_rel)
3499           != r_reloc_get_hash_entry (&src2->r_rel))
3500         return FALSE;
3501
3502       if (r_reloc_get_hash_entry (&src1->r_rel) == 0)
3503         return FALSE;
3504     }
3505
3506   return TRUE;
3507 }
3508
3509
3510 /* Must be power of 2.  */
3511 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
3512
3513 static value_map_hash_table *
3514 value_map_hash_table_init ()
3515 {
3516   value_map_hash_table *values;
3517
3518   values = (value_map_hash_table *)
3519     bfd_malloc (sizeof (value_map_hash_table));
3520
3521   values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
3522   values->count = 0;
3523   values->buckets = (value_map **)
3524     bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
3525
3526   return values;
3527 }
3528
3529
3530 static unsigned
3531 hash_bfd_vma (val)
3532      bfd_vma val;
3533 {
3534   return (val >> 2) + (val >> 10);
3535 }
3536
3537
3538 static unsigned
3539 hash_literal_value (src)
3540      const literal_value *src;
3541 {
3542   unsigned hash_val;
3543   if (r_reloc_is_const (&src->r_rel))
3544     return hash_bfd_vma (src->value);
3545
3546   hash_val = (hash_bfd_vma (r_reloc_get_target_offset (&src->r_rel))
3547               + hash_bfd_vma (src->value));
3548
3549   /* Now check for the same section and the same elf_hash.  */
3550   if (r_reloc_is_defined (&src->r_rel))
3551     hash_val += hash_bfd_vma ((bfd_vma) r_reloc_get_section (&src->r_rel));
3552   else
3553     hash_val += hash_bfd_vma ((bfd_vma) r_reloc_get_hash_entry (&src->r_rel));
3554
3555   return hash_val;
3556 }
3557
3558
3559 /* Check if the specified literal_value has been seen before.  */
3560
3561 static value_map *
3562 get_cached_value (map, val)
3563      value_map_hash_table *map;
3564      const literal_value *val;
3565 {
3566   value_map *map_e;
3567   value_map *bucket;
3568   unsigned idx;
3569
3570   idx = hash_literal_value (val);
3571   idx = idx & (map->bucket_count - 1);
3572   bucket = map->buckets[idx];
3573   for (map_e = bucket; map_e; map_e = map_e->next)
3574     {
3575       if (is_same_value (&map_e->val, val))
3576         return map_e;
3577     }
3578   return NULL;
3579 }
3580
3581
3582 /* Record a new literal value.  It is illegal to call this if VALUE
3583    already has an entry here.  */
3584
3585 static value_map *
3586 add_value_map (map, val, loc)
3587      value_map_hash_table *map;
3588      const literal_value *val;
3589      const r_reloc *loc;
3590 {
3591   value_map **bucket_p;
3592   unsigned idx;
3593
3594   value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
3595
3596   BFD_ASSERT (get_cached_value (map, val) == NULL);
3597   val_e->val = *val;
3598   val_e->loc = *loc;
3599
3600   idx = hash_literal_value (val);
3601   idx = idx & (map->bucket_count - 1);
3602   bucket_p = &map->buckets[idx];
3603
3604   val_e->next = *bucket_p;
3605   *bucket_p = val_e;
3606   map->count++;
3607   /* FIXME: consider resizing the hash table if we get too many entries */
3608
3609   return val_e;
3610 }
3611
3612 \f
3613 /* Lists of literals being coalesced or removed.  */
3614
3615 /* In the usual case, the literal identified by "from" is being
3616    coalesced with another literal identified by "to".  If the literal is
3617    unused and is being removed altogether, "to.abfd" will be NULL.
3618    The removed_literal entries are kept on a per-section list, sorted
3619    by the "from" offset field.  */
3620
3621 typedef struct removed_literal_struct removed_literal;
3622 typedef struct removed_literal_list_struct removed_literal_list;
3623
3624 struct removed_literal_struct
3625 {
3626   r_reloc from;
3627   r_reloc to;
3628   removed_literal *next;
3629 };
3630
3631 struct removed_literal_list_struct
3632 {
3633   removed_literal *head;
3634   removed_literal *tail;
3635 };
3636
3637
3638 static void add_removed_literal
3639   PARAMS ((removed_literal_list *, const r_reloc *, const r_reloc *));
3640 static removed_literal *find_removed_literal
3641   PARAMS ((removed_literal_list *, bfd_vma));
3642 static bfd_vma offset_with_removed_literals
3643   PARAMS ((removed_literal_list *, bfd_vma));
3644
3645
3646 /* Record that the literal at "from" is being removed.  If "to" is not
3647    NULL, the "from" literal is being coalesced with the "to" literal.  */
3648
3649 static void
3650 add_removed_literal (removed_list, from, to)
3651      removed_literal_list *removed_list;
3652      const r_reloc *from;
3653      const r_reloc *to;
3654 {
3655   removed_literal *r, *new_r, *next_r;
3656
3657   new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
3658
3659   new_r->from = *from;
3660   if (to)
3661     new_r->to = *to;
3662   else
3663     new_r->to.abfd = NULL;
3664   new_r->next = NULL;
3665
3666   r = removed_list->head;
3667   if (r == NULL)
3668     {
3669       removed_list->head = new_r;
3670       removed_list->tail = new_r;
3671     }
3672   /* Special check for common case of append.  */
3673   else if (removed_list->tail->from.target_offset < from->target_offset)
3674     {
3675       removed_list->tail->next = new_r;
3676       removed_list->tail = new_r;
3677     }
3678   else
3679     {
3680       while (r->from.target_offset < from->target_offset
3681              && r->next != NULL)
3682         {
3683           r = r->next;
3684         }
3685       next_r = r->next;
3686       r->next = new_r;
3687       new_r->next = next_r;
3688       if (next_r == NULL)
3689         removed_list->tail = new_r;
3690     }
3691 }
3692
3693
3694 /* Check if the list of removed literals contains an entry for the
3695    given address.  Return the entry if found.  */
3696
3697 static removed_literal *
3698 find_removed_literal (removed_list, addr)
3699      removed_literal_list *removed_list;
3700      bfd_vma addr;
3701 {
3702   removed_literal *r = removed_list->head;
3703   while (r && r->from.target_offset < addr)
3704     r = r->next;
3705   if (r && r->from.target_offset == addr)
3706     return r;
3707   return NULL;
3708 }
3709
3710
3711 /* Adjust an offset in a section to compensate for literals that are
3712    being removed.  Search the list of removed literals and subtract
3713    4 bytes for every removed literal prior to the given address.  */
3714
3715 static bfd_vma
3716 offset_with_removed_literals (removed_list, addr)
3717      removed_literal_list *removed_list;
3718      bfd_vma addr;
3719 {
3720   removed_literal *r = removed_list->head;
3721   unsigned num_bytes = 0;
3722
3723   if (r == NULL)
3724     return addr;
3725
3726   while (r && r->from.target_offset <= addr)
3727     {
3728       num_bytes += 4;
3729       r = r->next;
3730     }
3731   if (num_bytes > addr)
3732     return 0;
3733   return (addr - num_bytes);
3734 }
3735
3736 \f
3737 /* Coalescing literals may require a relocation to refer to a section in
3738    a different input file, but the standard relocation information
3739    cannot express that.  Instead, the reloc_bfd_fix structures are used
3740    to "fix" the relocations that refer to sections in other input files.
3741    These structures are kept on per-section lists.  The "src_type" field
3742    records the relocation type in case there are multiple relocations on
3743    the same location.  FIXME: This is ugly; an alternative might be to
3744    add new symbols with the "owner" field to some other input file.  */
3745
3746 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
3747
3748 struct reloc_bfd_fix_struct
3749 {
3750   asection *src_sec;
3751   bfd_vma src_offset;
3752   unsigned src_type;                    /* Relocation type.  */
3753
3754   bfd *target_abfd;
3755   asection *target_sec;
3756   bfd_vma target_offset;
3757
3758   reloc_bfd_fix *next;
3759 };
3760
3761
3762 static reloc_bfd_fix *reloc_bfd_fix_init
3763   PARAMS ((asection *, bfd_vma, unsigned, bfd *, asection *, bfd_vma));
3764 static reloc_bfd_fix *get_bfd_fix
3765   PARAMS ((reloc_bfd_fix *, asection *, bfd_vma, unsigned));
3766
3767
3768 static reloc_bfd_fix *
3769 reloc_bfd_fix_init (src_sec, src_offset, src_type,
3770                     target_abfd, target_sec, target_offset)
3771      asection *src_sec;
3772      bfd_vma src_offset;
3773      unsigned src_type;
3774      bfd *target_abfd;
3775      asection *target_sec;
3776      bfd_vma target_offset;
3777 {
3778   reloc_bfd_fix *fix;
3779
3780   fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
3781   fix->src_sec = src_sec;
3782   fix->src_offset = src_offset;
3783   fix->src_type = src_type;
3784   fix->target_abfd = target_abfd;
3785   fix->target_sec = target_sec;
3786   fix->target_offset = target_offset;
3787
3788   return fix;
3789 }
3790
3791
3792 static reloc_bfd_fix *
3793 get_bfd_fix (fix_list, sec, offset, type)
3794      reloc_bfd_fix *fix_list;
3795      asection *sec;
3796      bfd_vma offset;
3797      unsigned type;
3798 {
3799   reloc_bfd_fix *r;
3800
3801   for (r = fix_list; r != NULL; r = r->next)
3802     {
3803       if (r->src_sec == sec
3804           && r->src_offset == offset
3805           && r->src_type == type)
3806         return r;
3807     }
3808   return NULL;
3809 }
3810
3811 \f
3812 /* Per-section data for relaxation.  */
3813
3814 struct xtensa_relax_info_struct
3815 {
3816   bfd_boolean is_relaxable_literal_section;
3817   int visited;                          /* Number of times visited.  */
3818
3819   source_reloc *src_relocs;             /* Array[src_count].  */
3820   int src_count;
3821   int src_next;                         /* Next src_relocs entry to assign.  */
3822
3823   removed_literal_list removed_list;
3824
3825   reloc_bfd_fix *fix_list;
3826 };
3827
3828 struct elf_xtensa_section_data
3829 {
3830   struct bfd_elf_section_data elf;
3831   xtensa_relax_info relax_info;
3832 };
3833
3834 static void init_xtensa_relax_info
3835   PARAMS ((asection *));
3836 static xtensa_relax_info *get_xtensa_relax_info
3837   PARAMS ((asection *));
3838 static void add_fix
3839   PARAMS ((asection *, reloc_bfd_fix *));
3840
3841
3842 static bfd_boolean
3843 elf_xtensa_new_section_hook (abfd, sec)
3844      bfd *abfd;
3845      asection *sec;
3846 {
3847   struct elf_xtensa_section_data *sdata;
3848   bfd_size_type amt = sizeof (*sdata);
3849
3850   sdata = (struct elf_xtensa_section_data *) bfd_zalloc (abfd, amt);
3851   if (sdata == NULL)
3852     return FALSE;
3853   sec->used_by_bfd = (PTR) sdata;
3854
3855   return _bfd_elf_new_section_hook (abfd, sec);
3856 }
3857
3858
3859 static void
3860 init_xtensa_relax_info (sec)
3861      asection *sec;
3862 {
3863   xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
3864
3865   relax_info->is_relaxable_literal_section = FALSE;
3866   relax_info->visited = 0;
3867
3868   relax_info->src_relocs = NULL;
3869   relax_info->src_count = 0;
3870   relax_info->src_next = 0;
3871
3872   relax_info->removed_list.head = NULL;
3873   relax_info->removed_list.tail = NULL;
3874
3875   relax_info->fix_list = NULL;
3876 }
3877
3878
3879 static xtensa_relax_info *
3880 get_xtensa_relax_info (sec)
3881      asection *sec;
3882 {
3883   struct elf_xtensa_section_data *section_data;
3884
3885   /* No info available if no section or if it is an output section.  */
3886   if (!sec || sec == sec->output_section)
3887     return NULL;
3888
3889   section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
3890   return &section_data->relax_info;
3891 }
3892
3893
3894 static void
3895 add_fix (src_sec, fix)
3896      asection *src_sec;
3897      reloc_bfd_fix *fix;
3898 {
3899   xtensa_relax_info *relax_info;
3900
3901   relax_info = get_xtensa_relax_info (src_sec);
3902   fix->next = relax_info->fix_list;
3903   relax_info->fix_list = fix;
3904 }
3905
3906 \f
3907 /* Access to internal relocations, section contents and symbols.  */
3908
3909 /* During relaxation, we need to modify relocations, section contents,
3910    and symbol definitions, and we need to keep the original values from
3911    being reloaded from the input files, i.e., we need to "pin" the
3912    modified values in memory.  We also want to continue to observe the
3913    setting of the "keep-memory" flag.  The following functions wrap the
3914    standard BFD functions to take care of this for us.  */
3915
3916 static Elf_Internal_Rela *
3917 retrieve_internal_relocs (abfd, sec, keep_memory)
3918      bfd *abfd;
3919      asection *sec;
3920      bfd_boolean keep_memory;
3921 {
3922   Elf_Internal_Rela *internal_relocs;
3923
3924   if ((sec->flags & SEC_LINKER_CREATED) != 0)
3925     return NULL;
3926
3927   internal_relocs = elf_section_data (sec)->relocs;
3928   if (internal_relocs == NULL)
3929     internal_relocs = (_bfd_elf32_link_read_relocs
3930                        (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
3931                         keep_memory));
3932   return internal_relocs;
3933 }
3934
3935
3936 static void
3937 pin_internal_relocs (sec, internal_relocs)
3938      asection *sec;
3939      Elf_Internal_Rela *internal_relocs;
3940 {
3941   elf_section_data (sec)->relocs = internal_relocs;
3942 }
3943
3944
3945 static void
3946 release_internal_relocs (sec, internal_relocs)
3947      asection *sec;
3948      Elf_Internal_Rela *internal_relocs;
3949 {
3950   if (internal_relocs
3951       && elf_section_data (sec)->relocs != internal_relocs)
3952     free (internal_relocs);
3953 }
3954
3955
3956 static bfd_byte *
3957 retrieve_contents (abfd, sec, keep_memory)
3958      bfd *abfd;
3959      asection *sec;
3960      bfd_boolean keep_memory;
3961 {
3962   bfd_byte *contents;
3963
3964   contents = elf_section_data (sec)->this_hdr.contents;
3965
3966   if (contents == NULL && sec->_raw_size != 0)
3967     {
3968       contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
3969       if (contents != NULL)
3970         {
3971           if (! bfd_get_section_contents (abfd, sec, contents,
3972                                           (file_ptr) 0, sec->_raw_size))
3973             {
3974               free (contents);
3975               return NULL;
3976             }
3977           if (keep_memory)
3978             elf_section_data (sec)->this_hdr.contents = contents;
3979         }
3980     }
3981   return contents;
3982 }
3983
3984
3985 static void
3986 pin_contents (sec, contents)
3987      asection *sec;
3988      bfd_byte *contents;
3989 {
3990   elf_section_data (sec)->this_hdr.contents = contents;
3991 }
3992
3993
3994 static void
3995 release_contents (sec, contents)
3996      asection *sec;
3997      bfd_byte *contents;
3998 {
3999   if (contents &&
4000       elf_section_data (sec)->this_hdr.contents != contents)
4001     free (contents);
4002 }
4003
4004
4005 static Elf_Internal_Sym *
4006 retrieve_local_syms (input_bfd)
4007      bfd *input_bfd;
4008 {
4009   Elf_Internal_Shdr *symtab_hdr;
4010   Elf_Internal_Sym *isymbuf;
4011   size_t locsymcount;
4012
4013   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4014   locsymcount = symtab_hdr->sh_info;
4015
4016   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4017   if (isymbuf == NULL && locsymcount != 0)
4018     isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
4019                                     NULL, NULL, NULL);
4020
4021   /* Save the symbols for this input file so they won't be read again.  */
4022   if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
4023     symtab_hdr->contents = (unsigned char *) isymbuf;
4024
4025   return isymbuf;
4026 }
4027
4028 \f
4029 /* Code for link-time relaxation.  */
4030
4031 /* Local helper functions.  */
4032 static bfd_boolean analyze_relocations
4033   PARAMS ((struct bfd_link_info *));
4034 static bfd_boolean find_relaxable_sections
4035   PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
4036 static bfd_boolean collect_source_relocs
4037   PARAMS ((bfd *, asection *, struct bfd_link_info *));
4038 static bfd_boolean is_resolvable_asm_expansion
4039   PARAMS ((bfd *, asection *, bfd_byte *, Elf_Internal_Rela *,
4040            struct bfd_link_info *, bfd_boolean *));
4041 static bfd_boolean remove_literals
4042   PARAMS ((bfd *, asection *, struct bfd_link_info *, value_map_hash_table *));
4043 static bfd_boolean relax_section
4044   PARAMS ((bfd *, asection *, struct bfd_link_info *));
4045 static bfd_boolean relax_property_section
4046   PARAMS ((bfd *, asection *, struct bfd_link_info *));
4047 static bfd_boolean relax_section_symbols
4048   PARAMS ((bfd *, asection *));
4049 static bfd_boolean relocations_reach
4050   PARAMS ((source_reloc *, int, const r_reloc *));
4051 static void translate_reloc
4052   PARAMS ((const r_reloc *, r_reloc *));
4053 static Elf_Internal_Rela *get_irel_at_offset
4054   PARAMS ((asection *, Elf_Internal_Rela *, bfd_vma));
4055 static Elf_Internal_Rela *find_associated_l32r_irel
4056   PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *,
4057            Elf_Internal_Rela *));
4058 static void shrink_dynamic_reloc_sections
4059   PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *));
4060
4061
4062 static bfd_boolean
4063 elf_xtensa_relax_section (abfd, sec, link_info, again)
4064      bfd *abfd;
4065      asection *sec;
4066      struct bfd_link_info *link_info;
4067      bfd_boolean *again;
4068 {
4069   static value_map_hash_table *values = NULL;
4070   xtensa_relax_info *relax_info;
4071
4072   if (!values)
4073     {
4074       /* Do some overall initialization for relaxation.  */
4075       values = value_map_hash_table_init ();
4076       relaxing_section = TRUE;
4077       if (!analyze_relocations (link_info))
4078         return FALSE;
4079     }
4080   *again = FALSE;
4081
4082   /* Don't mess with linker-created sections.  */
4083   if ((sec->flags & SEC_LINKER_CREATED) != 0)
4084     return TRUE;
4085
4086   relax_info = get_xtensa_relax_info (sec);
4087   BFD_ASSERT (relax_info != NULL);
4088
4089   switch (relax_info->visited)
4090     {
4091     case 0:
4092       /* Note: It would be nice to fold this pass into
4093          analyze_relocations, but it is important for this step that the
4094          sections be examined in link order.  */
4095       if (!remove_literals (abfd, sec, link_info, values))
4096         return FALSE;
4097       *again = TRUE;
4098       break;
4099
4100     case 1:
4101       if (!relax_section (abfd, sec, link_info))
4102         return FALSE;
4103       *again = TRUE;
4104       break;
4105
4106     case 2:
4107       if (!relax_section_symbols (abfd, sec))
4108         return FALSE;
4109       break;
4110     }
4111
4112   relax_info->visited++;
4113   return TRUE;
4114 }
4115
4116 /* Initialization for relaxation.  */
4117
4118 /* This function is called once at the start of relaxation.  It scans
4119    all the input sections and marks the ones that are relaxable (i.e.,
4120    literal sections with L32R relocations against them).  It then
4121    collect source_reloc information for all the relocations against
4122    those relaxable sections.  */
4123
4124 static bfd_boolean
4125 analyze_relocations (link_info)
4126      struct bfd_link_info *link_info;
4127 {
4128   bfd *abfd;
4129   asection *sec;
4130   bfd_boolean is_relaxable = FALSE;
4131
4132   /* Initialize the per-section relaxation info.  */
4133   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4134     for (sec = abfd->sections; sec != NULL; sec = sec->next)
4135       {
4136         init_xtensa_relax_info (sec);
4137       }
4138
4139   /* Mark relaxable sections (and count relocations against each one).  */
4140   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4141     for (sec = abfd->sections; sec != NULL; sec = sec->next)
4142       {
4143         if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
4144           return FALSE;
4145       }
4146
4147   /* Bail out if there are no relaxable sections.  */
4148   if (!is_relaxable)
4149     return TRUE;
4150
4151   /* Allocate space for source_relocs.  */
4152   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4153     for (sec = abfd->sections; sec != NULL; sec = sec->next)
4154       {
4155         xtensa_relax_info *relax_info;
4156
4157         relax_info = get_xtensa_relax_info (sec);
4158         if (relax_info->is_relaxable_literal_section)
4159           {
4160             relax_info->src_relocs = (source_reloc *)
4161               bfd_malloc (relax_info->src_count * sizeof (source_reloc));
4162           }
4163       }
4164
4165   /* Collect info on relocations against each relaxable section.  */
4166   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4167     for (sec = abfd->sections; sec != NULL; sec = sec->next)
4168       {
4169         if (!collect_source_relocs (abfd, sec, link_info))
4170           return FALSE;
4171       }
4172
4173   return TRUE;
4174 }
4175
4176
4177 /* Find all the literal sections that might be relaxed.  The motivation
4178    for this pass is that collect_source_relocs() needs to record _all_
4179    the relocations that target each relaxable section.  That is
4180    expensive and unnecessary unless the target section is actually going
4181    to be relaxed.  This pass identifies all such sections by checking if
4182    they have L32Rs pointing to them.  In the process, the total number
4183    of relocations targetting each section is also counted so that we
4184    know how much space to allocate for source_relocs against each
4185    relaxable literal section.  */
4186
4187 static bfd_boolean
4188 find_relaxable_sections (abfd, sec, link_info, is_relaxable_p)
4189      bfd *abfd;
4190      asection *sec;
4191      struct bfd_link_info *link_info;
4192      bfd_boolean *is_relaxable_p;
4193 {
4194   Elf_Internal_Rela *internal_relocs;
4195   bfd_byte *contents;
4196   bfd_boolean ok = TRUE;
4197   unsigned i;
4198
4199   internal_relocs = retrieve_internal_relocs (abfd, sec,
4200                                               link_info->keep_memory);
4201   if (internal_relocs == NULL)
4202     return ok;
4203
4204   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4205   if (contents == NULL && sec->_raw_size != 0)
4206     {
4207       ok = FALSE;
4208       goto error_return;
4209     }
4210
4211   for (i = 0; i < sec->reloc_count; i++)
4212     {
4213       Elf_Internal_Rela *irel = &internal_relocs[i];
4214       r_reloc r_rel;
4215       asection *target_sec;
4216       xtensa_relax_info *target_relax_info;
4217
4218       r_reloc_init (&r_rel, abfd, irel);
4219
4220       target_sec = r_reloc_get_section (&r_rel);
4221       target_relax_info = get_xtensa_relax_info (target_sec);
4222       if (!target_relax_info)
4223         continue;
4224
4225       /* Count relocations against the target section.  */
4226       target_relax_info->src_count++;
4227
4228       if (is_literal_section (target_sec)
4229           && is_l32r_relocation (sec, contents, irel)
4230           && r_reloc_is_defined (&r_rel))
4231         {
4232           /* Mark the target section as relaxable.  */
4233           target_relax_info->is_relaxable_literal_section = TRUE;
4234           *is_relaxable_p = TRUE;
4235         }
4236     }
4237
4238  error_return:
4239   release_contents (sec, contents);
4240   release_internal_relocs (sec, internal_relocs);
4241   return ok;
4242 }
4243
4244
4245 /* Record _all_ the relocations that point to relaxable literal
4246    sections, and get rid of ASM_EXPAND relocs by either converting them
4247    to ASM_SIMPLIFY or by removing them.  */
4248
4249 static bfd_boolean
4250 collect_source_relocs (abfd, sec, link_info)
4251      bfd *abfd;
4252      asection *sec;
4253      struct bfd_link_info *link_info;
4254 {
4255   Elf_Internal_Rela *internal_relocs;
4256   bfd_byte *contents;
4257   bfd_boolean ok = TRUE;
4258   unsigned i;
4259
4260   internal_relocs = retrieve_internal_relocs (abfd, sec,
4261                                               link_info->keep_memory);
4262   if (internal_relocs == NULL)
4263     return ok;
4264
4265   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4266   if (contents == NULL && sec->_raw_size != 0)
4267     {
4268       ok = FALSE;
4269       goto error_return;
4270     }
4271
4272   /* Record relocations against relaxable literal sections.  */
4273   for (i = 0; i < sec->reloc_count; i++)
4274     {
4275       Elf_Internal_Rela *irel = &internal_relocs[i];
4276       r_reloc r_rel;
4277       asection *target_sec;
4278       xtensa_relax_info *target_relax_info;
4279
4280       r_reloc_init (&r_rel, abfd, irel);
4281
4282       target_sec = r_reloc_get_section (&r_rel);
4283       target_relax_info = get_xtensa_relax_info (target_sec);
4284
4285       if (target_relax_info
4286           && target_relax_info->is_relaxable_literal_section)
4287         {
4288           xtensa_opcode opcode;
4289           xtensa_operand opnd;
4290           source_reloc *s_reloc;
4291           int src_next;
4292
4293           src_next = target_relax_info->src_next++;
4294           s_reloc = &target_relax_info->src_relocs[src_next];
4295
4296           opcode = get_relocation_opcode (sec, contents, irel);
4297           if (opcode == XTENSA_UNDEFINED)
4298             opnd = NULL;
4299           else
4300             opnd = xtensa_get_operand (xtensa_default_isa, opcode,
4301                                        get_relocation_opnd (irel));
4302
4303           init_source_reloc (s_reloc, sec, &r_rel, opnd);
4304         }
4305     }
4306
4307   /* Now get rid of ASM_EXPAND relocations.  At this point, the
4308      src_relocs array for the target literal section may still be
4309      incomplete, but it must at least contain the entries for the L32R
4310      relocations associated with ASM_EXPANDs because they were just
4311      added in the preceding loop over the relocations.  */
4312
4313   for (i = 0; i < sec->reloc_count; i++)
4314     {
4315       Elf_Internal_Rela *irel = &internal_relocs[i];
4316       bfd_boolean is_reachable;
4317
4318       if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
4319                                         &is_reachable))
4320         continue;
4321
4322       if (is_reachable)
4323         {
4324           Elf_Internal_Rela *l32r_irel;
4325           r_reloc r_rel;
4326           asection *target_sec;
4327           xtensa_relax_info *target_relax_info;
4328
4329           /* Mark the source_reloc for the L32R so that it will be
4330              removed in remove_literals(), along with the associated
4331              literal.  */
4332           l32r_irel = find_associated_l32r_irel (sec, contents,
4333                                                  irel, internal_relocs);
4334           if (l32r_irel == NULL)
4335             continue;
4336
4337           r_reloc_init (&r_rel, abfd, l32r_irel);
4338
4339           target_sec = r_reloc_get_section (&r_rel);
4340           target_relax_info = get_xtensa_relax_info (target_sec);
4341
4342           if (target_relax_info
4343               && target_relax_info->is_relaxable_literal_section)
4344             {
4345               source_reloc *s_reloc;
4346
4347               /* Search the source_relocs for the entry corresponding to
4348                  the l32r_irel.  Note: The src_relocs array is not yet
4349                  sorted, but it wouldn't matter anyway because we're
4350                  searching by source offset instead of target offset.  */
4351               s_reloc = find_source_reloc (target_relax_info->src_relocs,
4352                                            target_relax_info->src_next,
4353                                            sec, l32r_irel);
4354               BFD_ASSERT (s_reloc);
4355               s_reloc->is_null = TRUE;
4356             }
4357
4358           /* Convert this reloc to ASM_SIMPLIFY.  */
4359           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4360                                        R_XTENSA_ASM_SIMPLIFY);
4361           l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4362
4363           pin_internal_relocs (sec, internal_relocs);
4364         }
4365       else
4366         {
4367           /* It is resolvable but doesn't reach.  We resolve now
4368              by eliminating the relocation -- the call will remain
4369              expanded into L32R/CALLX.  */
4370           irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4371           pin_internal_relocs (sec, internal_relocs);
4372         }
4373     }
4374
4375  error_return:
4376   release_contents (sec, contents);
4377   release_internal_relocs (sec, internal_relocs);
4378   return ok;
4379 }
4380
4381
4382 /* Return TRUE if the asm expansion can be resolved.  Generally it can
4383    be resolved on a final link or when a partial link locates it in the
4384    same section as the target.  Set "is_reachable" flag if the target of
4385    the call is within the range of a direct call, given the current VMA
4386    for this section and the target section.  */
4387
4388 bfd_boolean
4389 is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
4390                              is_reachable_p)
4391      bfd *abfd;
4392      asection *sec;
4393      bfd_byte *contents;
4394      Elf_Internal_Rela *irel;
4395      struct bfd_link_info *link_info;
4396      bfd_boolean *is_reachable_p;
4397 {
4398   asection *target_sec;
4399   bfd_vma target_offset;
4400   r_reloc r_rel;
4401   xtensa_opcode opcode, direct_call_opcode;
4402   bfd_vma self_address;
4403   bfd_vma dest_address;
4404
4405   *is_reachable_p = FALSE;
4406
4407   if (contents == NULL)
4408     return FALSE;
4409
4410   if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
4411     return FALSE;
4412
4413   opcode = get_expanded_call_opcode (contents + irel->r_offset,
4414                                      sec->_raw_size - irel->r_offset);
4415
4416   direct_call_opcode = swap_callx_for_call_opcode (opcode);
4417   if (direct_call_opcode == XTENSA_UNDEFINED)
4418     return FALSE;
4419
4420   /* Check and see that the target resolves.  */
4421   r_reloc_init (&r_rel, abfd, irel);
4422   if (!r_reloc_is_defined (&r_rel))
4423     return FALSE;
4424
4425   target_sec = r_reloc_get_section (&r_rel);
4426   target_offset = r_reloc_get_target_offset (&r_rel);
4427
4428   /* If the target is in a shared library, then it doesn't reach.  This
4429      isn't supposed to come up because the compiler should never generate
4430      non-PIC calls on systems that use shared libraries, but the linker
4431      shouldn't crash regardless.  */
4432   if (!target_sec->output_section)
4433     return FALSE;
4434
4435   /* For relocateable sections, we can only simplify when the output
4436      section of the target is the same as the output section of the
4437      source.  */
4438   if (link_info->relocateable
4439       && (target_sec->output_section != sec->output_section))
4440     return FALSE;
4441
4442   self_address = (sec->output_section->vma
4443                   + sec->output_offset + irel->r_offset + 3);
4444   dest_address = (target_sec->output_section->vma
4445                   + target_sec->output_offset + target_offset);
4446
4447   *is_reachable_p = pcrel_reloc_fits
4448     (xtensa_get_operand (xtensa_default_isa, direct_call_opcode, 0),
4449      self_address, dest_address);
4450
4451   if ((self_address >> CALL_SEGMENT_BITS) !=
4452       (dest_address >> CALL_SEGMENT_BITS))
4453     return FALSE;
4454
4455   return TRUE;
4456 }
4457
4458
4459 static Elf_Internal_Rela *
4460 find_associated_l32r_irel (sec, contents, other_irel, internal_relocs)
4461      asection *sec;
4462      bfd_byte *contents;
4463      Elf_Internal_Rela *other_irel;
4464      Elf_Internal_Rela *internal_relocs;
4465 {
4466   unsigned i;
4467
4468   for (i = 0; i < sec->reloc_count; i++)
4469     {
4470       Elf_Internal_Rela *irel = &internal_relocs[i];
4471
4472       if (irel == other_irel)
4473         continue;
4474       if (irel->r_offset != other_irel->r_offset)
4475         continue;
4476       if (is_l32r_relocation (sec, contents, irel))
4477         return irel;
4478     }
4479
4480   return NULL;
4481 }
4482
4483 /* First relaxation pass.  */
4484
4485 /* If the section is relaxable (i.e., a literal section), check each
4486    literal to see if it has the same value as another literal that has
4487    already been seen, either in the current section or a previous one.
4488    If so, add an entry to the per-section list of removed literals.  The
4489    actual changes are deferred until the next pass.  */
4490
4491 static bfd_boolean
4492 remove_literals (abfd, sec, link_info, values)
4493      bfd *abfd;
4494      asection *sec;
4495      struct bfd_link_info *link_info;
4496      value_map_hash_table *values;
4497 {
4498   xtensa_relax_info *relax_info;
4499   bfd_byte *contents;
4500   Elf_Internal_Rela *internal_relocs;
4501   source_reloc *src_relocs;
4502   bfd_boolean ok = TRUE;
4503   int i;
4504
4505   /* Do nothing if it is not a relaxable literal section.  */
4506   relax_info = get_xtensa_relax_info (sec);
4507   BFD_ASSERT (relax_info);
4508
4509   if (!relax_info->is_relaxable_literal_section)
4510     return ok;
4511
4512   internal_relocs = retrieve_internal_relocs (abfd, sec,
4513                                               link_info->keep_memory);
4514
4515   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4516   if (contents == NULL && sec->_raw_size != 0)
4517     {
4518       ok = FALSE;
4519       goto error_return;
4520     }
4521
4522   /* Sort the source_relocs by target offset.  */
4523   src_relocs = relax_info->src_relocs;
4524   qsort (src_relocs, relax_info->src_count,
4525          sizeof (source_reloc), source_reloc_compare);
4526
4527   for (i = 0; i < relax_info->src_count; i++)
4528     {
4529       source_reloc *rel;
4530       Elf_Internal_Rela *irel = NULL;
4531       literal_value val;
4532       value_map *val_map;
4533
4534       rel = &src_relocs[i];
4535       irel = get_irel_at_offset (sec, internal_relocs,
4536                                  rel->r_rel.target_offset);
4537
4538       /* If the target_offset for this relocation is the same as the
4539          previous relocation, then we've already considered whether the
4540          literal can be coalesced.  Skip to the next one....  */
4541       if (i != 0 && (src_relocs[i-1].r_rel.target_offset
4542                      == rel->r_rel.target_offset))
4543         continue;
4544
4545       /* Check if the relocation was from an L32R that is being removed
4546          because a CALLX was converted to a direct CALL, and check if
4547          there are no other relocations to the literal.  */
4548       if (rel->is_null
4549           && (i == relax_info->src_count - 1
4550               || (src_relocs[i+1].r_rel.target_offset
4551                   != rel->r_rel.target_offset)))
4552         {
4553           /* Mark the unused literal so that it will be removed.  */
4554           add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
4555
4556           /* Zero out the relocation on this literal location.  */
4557           if (irel)
4558             {
4559               if (elf_hash_table (link_info)->dynamic_sections_created)
4560                 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
4561
4562               irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4563             }
4564
4565           continue;
4566         }
4567
4568       /* Find the literal value.  */
4569       r_reloc_init (&val.r_rel, abfd, irel);
4570       BFD_ASSERT (rel->r_rel.target_offset < sec->_raw_size);
4571       val.value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
4572
4573       /* Check if we've seen another literal with the same value.  */
4574       val_map = get_cached_value (values, &val);
4575       if (val_map != NULL)
4576         {
4577           /* First check that THIS and all the other relocs to this
4578              literal will FIT if we move them to the new address.  */
4579
4580           if (relocations_reach (rel, relax_info->src_count - i,
4581                                  &val_map->loc))
4582             {
4583               /* Mark that the literal will be coalesced.  */
4584               add_removed_literal (&relax_info->removed_list,
4585                                    &rel->r_rel, &val_map->loc);
4586             }
4587           else
4588             {
4589               /* Relocations do not reach -- do not remove this literal.  */
4590               val_map->loc = rel->r_rel;
4591             }
4592         }
4593       else
4594         {
4595           /* This is the first time we've seen this literal value.  */
4596           BFD_ASSERT (sec == r_reloc_get_section (&rel->r_rel));
4597           add_value_map (values, &val, &rel->r_rel);
4598         }
4599     }
4600
4601 error_return:
4602   release_contents (sec, contents);
4603   release_internal_relocs (sec, internal_relocs);
4604   return ok;
4605 }
4606
4607
4608 /* Check if the original relocations (presumably on L32R instructions)
4609    identified by reloc[0..N] can be changed to reference the literal
4610    identified by r_rel.  If r_rel is out of range for any of the
4611    original relocations, then we don't want to coalesce the original
4612    literal with the one at r_rel.  We only check reloc[0..N], where the
4613    offsets are all the same as for reloc[0] (i.e., they're all
4614    referencing the same literal) and where N is also bounded by the
4615    number of remaining entries in the "reloc" array.  The "reloc" array
4616    is sorted by target offset so we know all the entries for the same
4617    literal will be contiguous.  */
4618
4619 static bfd_boolean
4620 relocations_reach (reloc, remaining_relocs, r_rel)
4621      source_reloc *reloc;
4622      int remaining_relocs;
4623      const r_reloc *r_rel;
4624 {
4625   bfd_vma from_offset, source_address, dest_address;
4626   asection *sec;
4627   int i;
4628
4629   if (!r_reloc_is_defined (r_rel))
4630     return FALSE;
4631
4632   sec = r_reloc_get_section (r_rel);
4633   from_offset = reloc[0].r_rel.target_offset;
4634
4635   for (i = 0; i < remaining_relocs; i++)
4636     {
4637       if (reloc[i].r_rel.target_offset != from_offset)
4638         break;
4639
4640       /* Ignore relocations that have been removed.  */
4641       if (reloc[i].is_null)
4642         continue;
4643
4644       /* The original and new output section for these must be the same
4645          in order to coalesce.  */
4646       if (r_reloc_get_section (&reloc[i].r_rel)->output_section
4647           != sec->output_section)
4648         return FALSE;
4649
4650       /* A NULL operand means it is not a PC-relative relocation, so
4651          the literal can be moved anywhere.  */
4652       if (reloc[i].opnd)
4653         {
4654           /* Otherwise, check to see that it fits.  */
4655           source_address = (reloc[i].source_sec->output_section->vma
4656                             + reloc[i].source_sec->output_offset
4657                             + reloc[i].r_rel.rela.r_offset);
4658           dest_address = (sec->output_section->vma
4659                           + sec->output_offset
4660                           + r_rel->target_offset);
4661
4662           if (!pcrel_reloc_fits (reloc[i].opnd, source_address, dest_address))
4663             return FALSE;
4664         }
4665     }
4666
4667   return TRUE;
4668 }
4669
4670
4671 /* WARNING: linear search here.  If the relocation are in order by
4672    address, we can use a faster binary search.  ALSO, we assume that
4673    there is only 1 non-NONE relocation per address.  */
4674
4675 static Elf_Internal_Rela *
4676 get_irel_at_offset (sec, internal_relocs, offset)
4677      asection *sec;
4678      Elf_Internal_Rela *internal_relocs;
4679      bfd_vma offset;
4680 {
4681   unsigned i;
4682   if (!internal_relocs)
4683     return NULL;
4684   for (i = 0; i < sec->reloc_count; i++)
4685     {
4686       Elf_Internal_Rela *irel = &internal_relocs[i];
4687       if (irel->r_offset == offset
4688           && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
4689         return irel;
4690     }
4691   return NULL;
4692 }
4693
4694 \f
4695 /* Second relaxation pass.  */
4696
4697 /* Modify all of the relocations to point to the right spot, and if this
4698    is a relaxable section, delete the unwanted literals and fix the
4699    cooked_size.  */
4700
4701 bfd_boolean
4702 relax_section (abfd, sec, link_info)
4703      bfd *abfd;
4704      asection *sec;
4705      struct bfd_link_info *link_info;
4706 {
4707   Elf_Internal_Rela *internal_relocs;
4708   xtensa_relax_info *relax_info;
4709   bfd_byte *contents;
4710   bfd_boolean ok = TRUE;
4711   unsigned i;
4712
4713   relax_info = get_xtensa_relax_info (sec);
4714   BFD_ASSERT (relax_info);
4715
4716   /* Handle property sections (e.g., literal tables) specially.  */
4717   if (xtensa_is_property_section (sec))
4718     {
4719       BFD_ASSERT (!relax_info->is_relaxable_literal_section);
4720       return relax_property_section (abfd, sec, link_info);
4721     }
4722
4723   internal_relocs = retrieve_internal_relocs (abfd, sec,
4724                                               link_info->keep_memory);
4725   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4726   if (contents == NULL && sec->_raw_size != 0)
4727     {
4728       ok = FALSE;
4729       goto error_return;
4730     }
4731
4732   if (internal_relocs)
4733     {
4734       for (i = 0; i < sec->reloc_count; i++)
4735         {
4736           Elf_Internal_Rela *irel;
4737           xtensa_relax_info *target_relax_info;
4738           bfd_vma source_offset;
4739           r_reloc r_rel;
4740           unsigned r_type;
4741           asection *target_sec;
4742
4743           /* Locally change the source address.
4744              Translate the target to the new target address.
4745              If it points to this section and has been removed,
4746              NULLify it.
4747              Write it back.  */
4748
4749           irel = &internal_relocs[i];
4750           source_offset = irel->r_offset;
4751
4752           r_type = ELF32_R_TYPE (irel->r_info);
4753           r_reloc_init (&r_rel, abfd, irel);
4754
4755           if (relax_info->is_relaxable_literal_section)
4756             {
4757               if (r_type != R_XTENSA_NONE
4758                   && find_removed_literal (&relax_info->removed_list,
4759                                            irel->r_offset))
4760                 {
4761                   /* Remove this relocation.  */
4762                   if (elf_hash_table (link_info)->dynamic_sections_created)
4763                     shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
4764                   irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4765                   irel->r_offset = offset_with_removed_literals
4766                     (&relax_info->removed_list, irel->r_offset);
4767                   continue;
4768                 }
4769               source_offset =
4770                 offset_with_removed_literals (&relax_info->removed_list,
4771                                               irel->r_offset);
4772               irel->r_offset = source_offset;
4773             }
4774
4775           target_sec = r_reloc_get_section (&r_rel);
4776           target_relax_info = get_xtensa_relax_info (target_sec);
4777
4778           if (target_relax_info
4779               && target_relax_info->is_relaxable_literal_section)
4780             {
4781               r_reloc new_rel;
4782               reloc_bfd_fix *fix;
4783
4784               translate_reloc (&r_rel, &new_rel);
4785
4786               /* FIXME: If the relocation still references a section in
4787                  the same input file, the relocation should be modified
4788                  directly instead of adding a "fix" record.  */
4789
4790               fix = reloc_bfd_fix_init (sec, source_offset, r_type, 0,
4791                                         r_reloc_get_section (&new_rel),
4792                                         new_rel.target_offset);
4793               add_fix (sec, fix);
4794             }
4795
4796           pin_internal_relocs (sec, internal_relocs);
4797         }
4798     }
4799
4800   if (relax_info->is_relaxable_literal_section)
4801     {
4802       /* Walk through the contents and delete literals that are not needed
4803          anymore.  */
4804
4805       unsigned long size = sec->_cooked_size;
4806       unsigned long removed = 0;
4807
4808       removed_literal *reloc = relax_info->removed_list.head;
4809       for (; reloc; reloc = reloc->next)
4810         {
4811           unsigned long upper = sec->_raw_size;
4812           bfd_vma start = reloc->from.target_offset + 4;
4813           if (reloc->next)
4814             upper = reloc->next->from.target_offset;
4815           if (upper - start != 0)
4816             {
4817               BFD_ASSERT (start <= upper);
4818               memmove (contents + start - removed - 4,
4819                        contents + start,
4820                        upper - start );
4821               pin_contents (sec, contents);
4822             }
4823           removed += 4;
4824           size -= 4;
4825         }
4826
4827       /* Change the section size.  */
4828       sec->_cooked_size = size;
4829       /* Also shrink _raw_size.  (The code in relocate_section that
4830          checks that relocations are within the section must use
4831          _raw_size because of the way the stabs sections are relaxed;
4832          shrinking _raw_size means that these checks will not be
4833          unnecessarily lax.)  */
4834       sec->_raw_size = size;
4835     }
4836
4837  error_return:
4838   release_internal_relocs (sec, internal_relocs);
4839   release_contents (sec, contents);
4840   return ok;
4841 }
4842
4843
4844 /* Fix up a relocation to take account of removed literals.  */
4845
4846 static void
4847 translate_reloc (orig_rel, new_rel)
4848      const r_reloc *orig_rel;
4849      r_reloc *new_rel;
4850 {
4851   asection *sec;
4852   xtensa_relax_info *relax_info;
4853   removed_literal *removed;
4854   unsigned long new_offset;
4855
4856   *new_rel = *orig_rel;
4857
4858   if (!r_reloc_is_defined (orig_rel))
4859     return;
4860   sec = r_reloc_get_section (orig_rel);
4861
4862   relax_info = get_xtensa_relax_info (sec);
4863   BFD_ASSERT (relax_info);
4864
4865   if (!relax_info->is_relaxable_literal_section)
4866     return;
4867
4868   /* Check if the original relocation is against a literal being removed.  */
4869   removed = find_removed_literal (&relax_info->removed_list,
4870                                   orig_rel->target_offset);
4871   if (removed)
4872     {
4873       asection *new_sec;
4874
4875       /* The fact that there is still a relocation to this literal indicates
4876          that the literal is being coalesced, not simply removed.  */
4877       BFD_ASSERT (removed->to.abfd != NULL);
4878
4879       /* This was moved to some other address (possibly in another section). */
4880       *new_rel = removed->to;
4881       new_sec = r_reloc_get_section (new_rel);
4882       if (new_sec != sec)
4883         {
4884           sec = new_sec;
4885           relax_info = get_xtensa_relax_info (sec);
4886           if (!relax_info || !relax_info->is_relaxable_literal_section)
4887             return;
4888         }
4889     }
4890
4891   /* ...and the target address may have been moved within its section.  */
4892   new_offset = offset_with_removed_literals (&relax_info->removed_list,
4893                                              new_rel->target_offset);
4894
4895   /* Modify the offset and addend.  */
4896   new_rel->target_offset = new_offset;
4897   new_rel->rela.r_addend += (new_offset - new_rel->target_offset);
4898 }
4899
4900
4901 /* For dynamic links, there may be a dynamic relocation for each
4902    literal.  The number of dynamic relocations must be computed in
4903    size_dynamic_sections, which occurs before relaxation.  When a
4904    literal is removed, this function checks if there is a corresponding
4905    dynamic relocation and shrinks the size of the appropriate dynamic
4906    relocation section accordingly.  At this point, the contents of the
4907    dynamic relocation sections have not yet been filled in, so there's
4908    nothing else that needs to be done.  */
4909
4910 static void
4911 shrink_dynamic_reloc_sections (info, abfd, input_section, rel)
4912      struct bfd_link_info *info;
4913      bfd *abfd;
4914      asection *input_section;
4915      Elf_Internal_Rela *rel;
4916 {
4917   Elf_Internal_Shdr *symtab_hdr;
4918   struct elf_link_hash_entry **sym_hashes;
4919   unsigned long r_symndx;
4920   int r_type;
4921   struct elf_link_hash_entry *h;
4922   bfd_boolean dynamic_symbol;
4923
4924   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4925   sym_hashes = elf_sym_hashes (abfd);
4926
4927   r_type = ELF32_R_TYPE (rel->r_info);
4928   r_symndx = ELF32_R_SYM (rel->r_info);
4929
4930   if (r_symndx < symtab_hdr->sh_info)
4931     h = NULL;
4932   else
4933     h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4934
4935   dynamic_symbol = xtensa_elf_dynamic_symbol_p (info, h);
4936
4937   if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
4938       && (input_section->flags & SEC_ALLOC) != 0
4939       && (dynamic_symbol || info->shared))
4940     {
4941       bfd *dynobj;
4942       const char *srel_name;
4943       asection *srel;
4944       bfd_boolean is_plt = FALSE;
4945
4946       dynobj = elf_hash_table (info)->dynobj;
4947       BFD_ASSERT (dynobj != NULL);
4948
4949       if (dynamic_symbol && r_type == R_XTENSA_PLT)
4950         {
4951           srel_name = ".rela.plt";
4952           is_plt = TRUE;
4953         }
4954       else
4955         srel_name = ".rela.got";
4956
4957       /* Reduce size of the .rela.* section by one reloc.  */
4958       srel = bfd_get_section_by_name (dynobj, srel_name);
4959       BFD_ASSERT (srel != NULL);
4960       BFD_ASSERT (srel->_cooked_size >= sizeof (Elf32_External_Rela));
4961       srel->_cooked_size -= sizeof (Elf32_External_Rela);
4962
4963       /* Also shrink _raw_size.  (This seems wrong but other bfd code seems
4964          to assume that linker-created sections will never be relaxed and
4965          hence _raw_size must always equal _cooked_size.) */
4966       srel->_raw_size = srel->_cooked_size;
4967
4968       if (is_plt)
4969         {
4970           asection *splt, *sgotplt, *srelgot;
4971           int reloc_index, chunk;
4972
4973           /* Find the PLT reloc index of the entry being removed.  This
4974              is computed from the size of ".rela.plt".  It is needed to
4975              figure out which PLT chunk to resize.  Usually "last index
4976              = size - 1" since the index starts at zero, but in this
4977              context, the size has just been decremented so there's no
4978              need to subtract one.  */
4979           reloc_index = srel->_cooked_size / sizeof (Elf32_External_Rela);
4980
4981           chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
4982           splt = elf_xtensa_get_plt_section (dynobj, chunk);
4983           sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
4984           BFD_ASSERT (splt != NULL && sgotplt != NULL);
4985
4986           /* Check if an entire PLT chunk has just been eliminated.  */
4987           if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
4988             {
4989               /* The two magic GOT entries for that chunk can go away.  */
4990               srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4991               BFD_ASSERT (srelgot != NULL);
4992               srelgot->reloc_count -= 2;
4993               srelgot->_cooked_size -= 2 * sizeof (Elf32_External_Rela);
4994               /* Shrink _raw_size (see comment above).  */
4995               srelgot->_raw_size = srelgot->_cooked_size;
4996
4997               sgotplt->_cooked_size -= 8;
4998
4999               /* There should be only one entry left (and it will be
5000                  removed below).  */
5001               BFD_ASSERT (sgotplt->_cooked_size == 4);
5002               BFD_ASSERT (splt->_cooked_size == PLT_ENTRY_SIZE);
5003             }
5004
5005           BFD_ASSERT (sgotplt->_cooked_size >= 4);
5006           BFD_ASSERT (splt->_cooked_size >= PLT_ENTRY_SIZE);
5007
5008           sgotplt->_cooked_size -= 4;
5009           splt->_cooked_size -= PLT_ENTRY_SIZE;
5010
5011           /* Shrink _raw_sizes (see comment above).  */
5012           sgotplt->_raw_size = sgotplt->_cooked_size;
5013           splt->_raw_size = splt->_cooked_size;
5014         }
5015     }
5016 }
5017
5018
5019 /* This is similar to relax_section except that when a target is moved,
5020    we shift addresses up.  We also need to modify the size.  This
5021    algorithm does NOT allow for relocations into the middle of the
5022    property sections.  */
5023
5024 static bfd_boolean
5025 relax_property_section (abfd, sec, link_info)
5026      bfd *abfd;
5027      asection *sec;
5028      struct bfd_link_info *link_info;
5029 {
5030   Elf_Internal_Rela *internal_relocs;
5031   bfd_byte *contents;
5032   unsigned i, nexti;
5033   bfd_boolean ok = TRUE;
5034
5035   internal_relocs = retrieve_internal_relocs (abfd, sec,
5036                                               link_info->keep_memory);
5037   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5038   if (contents == NULL && sec->_raw_size != 0)
5039     {
5040       ok = FALSE;
5041       goto error_return;
5042     }
5043
5044   if (internal_relocs)
5045     {
5046       for (i = 0; i < sec->reloc_count; i++)
5047         {
5048           Elf_Internal_Rela *irel;
5049           xtensa_relax_info *target_relax_info;
5050           r_reloc r_rel;
5051           unsigned r_type;
5052           asection *target_sec;
5053
5054           /* Locally change the source address.
5055              Translate the target to the new target address.
5056              If it points to this section and has been removed, MOVE IT.
5057              Also, don't forget to modify the associated SIZE at
5058              (offset + 4).  */
5059
5060           irel = &internal_relocs[i];
5061           r_type = ELF32_R_TYPE (irel->r_info);
5062           if (r_type == R_XTENSA_NONE)
5063             continue;
5064
5065           r_reloc_init (&r_rel, abfd, irel);
5066
5067           target_sec = r_reloc_get_section (&r_rel);
5068           target_relax_info = get_xtensa_relax_info (target_sec);
5069
5070           if (target_relax_info
5071               && target_relax_info->is_relaxable_literal_section)
5072             {
5073               /* Translate the relocation's destination.  */
5074               bfd_vma new_offset;
5075               bfd_vma new_end_offset;
5076               bfd_byte *size_p;
5077               long old_size, new_size;
5078
5079               new_offset =
5080                 offset_with_removed_literals (&target_relax_info->removed_list,
5081                                               r_rel.target_offset);
5082
5083               /* Assert that we are not out of bounds.  */
5084               size_p = &contents[irel->r_offset + 4];
5085               old_size = bfd_get_32 (abfd, &contents[irel->r_offset + 4]);
5086
5087               new_end_offset =
5088                 offset_with_removed_literals (&target_relax_info->removed_list,
5089                                               r_rel.target_offset + old_size);
5090
5091               new_size = new_end_offset - new_offset;
5092               if (new_size != old_size)
5093                 {
5094                   bfd_put_32 (abfd, new_size, size_p);
5095                   pin_contents (sec, contents);
5096                 }
5097
5098               if (new_offset != r_rel.target_offset)
5099                 {
5100                   bfd_vma diff = new_offset - r_rel.target_offset;
5101                   irel->r_addend += diff;
5102                   pin_internal_relocs (sec, internal_relocs);
5103                 }
5104             }
5105         }
5106     }
5107
5108   /* Combine adjacent property table entries.  This is also done in
5109      finish_dynamic_sections() but at that point it's too late to
5110      reclaim the space in the output section, so we do this twice.  */
5111
5112   if (internal_relocs)
5113     {
5114       Elf_Internal_Rela *last_irel = NULL;
5115       int removed_bytes = 0;
5116       bfd_vma offset, last_irel_offset;
5117       bfd_vma section_size;
5118
5119       /* Walk over memory and irels at the same time.
5120          This REQUIRES that the internal_relocs be sorted by offset.  */
5121       qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
5122              internal_reloc_compare);
5123       nexti = 0; /* Index into internal_relocs.  */
5124
5125       pin_internal_relocs (sec, internal_relocs);
5126       pin_contents (sec, contents);
5127
5128       last_irel_offset = (bfd_vma) -1;
5129       section_size = (sec->_cooked_size ? sec->_cooked_size : sec->_raw_size);
5130       BFD_ASSERT (section_size % 8 == 0);
5131
5132       for (offset = 0; offset < section_size; offset += 8)
5133         {
5134           Elf_Internal_Rela *irel, *next_irel;
5135           bfd_vma bytes_to_remove, size, actual_offset;
5136           bfd_boolean remove_this_irel;
5137
5138           irel = NULL;
5139           next_irel = NULL;
5140
5141           /* Find the next two relocations (if there are that many left),
5142              skipping over any R_XTENSA_NONE relocs.  On entry, "nexti" is
5143              the starting reloc index.  After these two loops, "i"
5144              is the index of the first non-NONE reloc past that starting
5145              index, and "nexti" is the index for the next non-NONE reloc
5146              after "i".  */
5147
5148           for (i = nexti; i < sec->reloc_count; i++)
5149             {
5150               if (ELF32_R_TYPE (internal_relocs[i].r_info) != R_XTENSA_NONE)
5151                 {
5152                   irel = &internal_relocs[i];
5153                   break;
5154                 }
5155               internal_relocs[i].r_offset -= removed_bytes;
5156             }
5157
5158           for (nexti = i + 1; nexti < sec->reloc_count; nexti++)
5159             {
5160               if (ELF32_R_TYPE (internal_relocs[nexti].r_info)
5161                   != R_XTENSA_NONE)
5162                 {
5163                   next_irel = &internal_relocs[nexti];
5164                   break;
5165                 }
5166               internal_relocs[nexti].r_offset -= removed_bytes;
5167             }
5168
5169           remove_this_irel = FALSE;
5170           bytes_to_remove = 0;
5171           actual_offset = offset - removed_bytes;
5172           size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
5173
5174           /* Check that the irels are sorted by offset,
5175              with only one per address.  */
5176           BFD_ASSERT (!irel || (int) irel->r_offset > (int) last_irel_offset);
5177           BFD_ASSERT (!next_irel || next_irel->r_offset > irel->r_offset);
5178
5179           /* Make sure there isn't a reloc on the size field.  */
5180           if (irel && irel->r_offset == offset + 4)
5181             {
5182               irel->r_offset -= removed_bytes;
5183               last_irel_offset = irel->r_offset;
5184             }
5185           else if (next_irel && next_irel->r_offset == offset + 4)
5186             {
5187               nexti += 1;
5188               irel->r_offset -= removed_bytes;
5189               next_irel->r_offset -= removed_bytes;
5190               last_irel_offset = next_irel->r_offset;
5191             }
5192           else if (size == 0)
5193             {
5194               /* Always remove entries with zero size.  */
5195               bytes_to_remove = 8;
5196               if (irel && irel->r_offset == offset)
5197                 {
5198                   remove_this_irel = TRUE;
5199
5200                   irel->r_offset -= removed_bytes;
5201                   last_irel_offset = irel->r_offset;
5202                 }
5203             }
5204           else if (irel && irel->r_offset == offset)
5205             {
5206               if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32)
5207                 {
5208                   if (last_irel)
5209                     {
5210                       bfd_vma old_size =
5211                         bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
5212                       bfd_vma old_address =
5213                         (last_irel->r_addend
5214                          + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
5215                       bfd_vma new_address =
5216                         (irel->r_addend
5217                          + bfd_get_32 (abfd, &contents[actual_offset]));
5218
5219                       if ((ELF32_R_SYM (irel->r_info) ==
5220                            ELF32_R_SYM (last_irel->r_info))
5221                           && (old_address + old_size == new_address))
5222                         {
5223                           /* fix the old size */
5224                           bfd_put_32 (abfd, old_size + size,
5225                                       &contents[last_irel->r_offset + 4]);
5226                           bytes_to_remove = 8;
5227                           remove_this_irel = TRUE;
5228                         }
5229                       else
5230                         last_irel = irel;
5231                     }
5232                   else
5233                     last_irel = irel;
5234                 }
5235
5236               irel->r_offset -= removed_bytes;
5237               last_irel_offset = irel->r_offset;
5238             }
5239
5240           if (remove_this_irel)
5241             {
5242               irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
5243               irel->r_offset -= bytes_to_remove;
5244             }
5245
5246           if (bytes_to_remove != 0)
5247             {
5248               removed_bytes += bytes_to_remove;
5249               if (offset + 8 < section_size)
5250                 memmove (&contents[actual_offset],
5251                          &contents[actual_offset+8],
5252                          section_size - offset - 8);
5253             }
5254         }
5255
5256       if (removed_bytes)
5257         {
5258           /* Clear the removed bytes.  */
5259           memset (&contents[section_size - removed_bytes], 0, removed_bytes);
5260
5261           sec->_cooked_size = section_size - removed_bytes;
5262           /* Also shrink _raw_size.  (The code in relocate_section that
5263              checks that relocations are within the section must use
5264              _raw_size because of the way the stabs sections are
5265              relaxed; shrinking _raw_size means that these checks will
5266              not be unnecessarily lax.)  */
5267           sec->_raw_size = sec->_cooked_size;
5268         }
5269     }
5270
5271  error_return:
5272   release_internal_relocs (sec, internal_relocs);
5273   release_contents (sec, contents);
5274   return ok;
5275 }
5276
5277 \f
5278 /* Third relaxation pass.  */
5279
5280 /* Change symbol values to account for removed literals.  */
5281
5282 bfd_boolean
5283 relax_section_symbols (abfd, sec)
5284      bfd *abfd;
5285      asection *sec;
5286 {
5287   xtensa_relax_info *relax_info;
5288   unsigned int sec_shndx;
5289   Elf_Internal_Shdr *symtab_hdr;
5290   Elf_Internal_Sym *isymbuf;
5291   unsigned i, num_syms, num_locals;
5292
5293   relax_info = get_xtensa_relax_info (sec);
5294   BFD_ASSERT (relax_info);
5295
5296   if (!relax_info->is_relaxable_literal_section)
5297     return TRUE;
5298
5299   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5300
5301   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5302   isymbuf = retrieve_local_syms (abfd);
5303
5304   num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
5305   num_locals = symtab_hdr->sh_info;
5306
5307   /* Adjust the local symbols defined in this section.  */
5308   for (i = 0; i < num_locals; i++)
5309     {
5310       Elf_Internal_Sym *isym = &isymbuf[i];
5311
5312       if (isym->st_shndx == sec_shndx)
5313         {
5314           bfd_vma new_address = offset_with_removed_literals
5315             (&relax_info->removed_list, isym->st_value);
5316           if (new_address != isym->st_value)
5317             isym->st_value = new_address;
5318         }
5319     }
5320
5321   /* Now adjust the global symbols defined in this section.  */
5322   for (i = 0; i < (num_syms - num_locals); i++)
5323     {
5324       struct elf_link_hash_entry *sym_hash;
5325
5326       sym_hash = elf_sym_hashes (abfd)[i];
5327
5328       if (sym_hash->root.type == bfd_link_hash_warning)
5329         sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
5330
5331       if ((sym_hash->root.type == bfd_link_hash_defined
5332            || sym_hash->root.type == bfd_link_hash_defweak)
5333           && sym_hash->root.u.def.section == sec)
5334         {
5335           bfd_vma new_address = offset_with_removed_literals
5336             (&relax_info->removed_list, sym_hash->root.u.def.value);
5337           if (new_address != sym_hash->root.u.def.value)
5338             sym_hash->root.u.def.value = new_address;
5339         }
5340     }
5341
5342   return TRUE;
5343 }
5344
5345 \f
5346 /* "Fix" handling functions, called while performing relocations.  */
5347
5348 static void
5349 do_fix_for_relocateable_link (rel, input_bfd, input_section)
5350      Elf_Internal_Rela *rel;
5351      bfd *input_bfd;
5352      asection *input_section;
5353 {
5354   r_reloc r_rel;
5355   asection *sec, *old_sec;
5356   bfd_vma old_offset;
5357   int r_type = ELF32_R_TYPE (rel->r_info);
5358   reloc_bfd_fix *fix_list;
5359   reloc_bfd_fix *fix;
5360
5361   if (r_type == R_XTENSA_NONE)
5362     return;
5363
5364   fix_list = (get_xtensa_relax_info (input_section))->fix_list;
5365   if (fix_list == NULL)
5366     return;
5367
5368   fix = get_bfd_fix (fix_list, input_section, rel->r_offset, r_type);
5369   if (fix == NULL)
5370     return;
5371
5372   r_reloc_init (&r_rel, input_bfd, rel);
5373   old_sec = r_reloc_get_section (&r_rel);
5374   old_offset = r_reloc_get_target_offset (&r_rel);
5375
5376   if (old_sec == NULL || !r_reloc_is_defined (&r_rel))
5377     {
5378       BFD_ASSERT (r_type == R_XTENSA_ASM_EXPAND);
5379       /* Leave it be.  Resolution will happen in a later stage.  */
5380     }
5381   else
5382     {
5383       sec = fix->target_sec;
5384       rel->r_addend += ((sec->output_offset + fix->target_offset)
5385                         - (old_sec->output_offset + old_offset));
5386     }
5387 }
5388
5389
5390 static void
5391 do_fix_for_final_link (rel, input_section, relocationp)
5392      Elf_Internal_Rela *rel;
5393      asection *input_section;
5394      bfd_vma *relocationp;
5395 {
5396   asection *sec;
5397   int r_type = ELF32_R_TYPE (rel->r_info);
5398   reloc_bfd_fix *fix_list;
5399   reloc_bfd_fix *fix;
5400
5401   if (r_type == R_XTENSA_NONE)
5402     return;
5403
5404   fix_list = (get_xtensa_relax_info (input_section))->fix_list;
5405   if (fix_list == NULL)
5406     return;
5407
5408   fix = get_bfd_fix (fix_list, input_section, rel->r_offset, r_type);
5409   if (fix == NULL)
5410     return;
5411
5412   sec = fix->target_sec;
5413   *relocationp = (sec->output_section->vma
5414                   + sec->output_offset
5415                   + fix->target_offset - rel->r_addend);
5416 }
5417
5418 \f
5419 /* Miscellaneous utility functions....  */
5420
5421 static asection *
5422 elf_xtensa_get_plt_section (dynobj, chunk)
5423      bfd *dynobj;
5424      int chunk;
5425 {
5426   char plt_name[10];
5427
5428   if (chunk == 0)
5429     return bfd_get_section_by_name (dynobj, ".plt");
5430
5431   sprintf (plt_name, ".plt.%u", chunk);
5432   return bfd_get_section_by_name (dynobj, plt_name);
5433 }
5434
5435
5436 static asection *
5437 elf_xtensa_get_gotplt_section (dynobj, chunk)
5438      bfd *dynobj;
5439      int chunk;
5440 {
5441   char got_name[14];
5442
5443   if (chunk == 0)
5444     return bfd_get_section_by_name (dynobj, ".got.plt");
5445
5446   sprintf (got_name, ".got.plt.%u", chunk);
5447   return bfd_get_section_by_name (dynobj, got_name);
5448 }
5449
5450
5451 /* Get the input section for a given symbol index.
5452    If the symbol is:
5453    . a section symbol, return the section;
5454    . a common symbol, return the common section;
5455    . an undefined symbol, return the undefined section;
5456    . an indirect symbol, follow the links;
5457    . an absolute value, return the absolute section.  */
5458
5459 static asection *
5460 get_elf_r_symndx_section (abfd, r_symndx)
5461      bfd *abfd;
5462      unsigned long r_symndx;
5463 {
5464   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5465   asection *target_sec = NULL;
5466   if (r_symndx < symtab_hdr->sh_info)
5467     {
5468       Elf_Internal_Sym *isymbuf;
5469       unsigned int section_index;
5470
5471       isymbuf = retrieve_local_syms (abfd);
5472       section_index = isymbuf[r_symndx].st_shndx;
5473
5474       if (section_index == SHN_UNDEF)
5475         target_sec = bfd_und_section_ptr;
5476       else if (section_index > 0 && section_index < SHN_LORESERVE)
5477         target_sec = bfd_section_from_elf_index (abfd, section_index);
5478       else if (section_index == SHN_ABS)
5479         target_sec = bfd_abs_section_ptr;
5480       else if (section_index == SHN_COMMON)
5481         target_sec = bfd_com_section_ptr;
5482       else
5483         /* Who knows?  */
5484         target_sec = NULL;
5485     }
5486   else
5487     {
5488       unsigned long indx = r_symndx - symtab_hdr->sh_info;
5489       struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
5490
5491       while (h->root.type == bfd_link_hash_indirect
5492              || h->root.type == bfd_link_hash_warning)
5493         h = (struct elf_link_hash_entry *) h->root.u.i.link;
5494
5495       switch (h->root.type)
5496         {
5497         case bfd_link_hash_defined:
5498         case  bfd_link_hash_defweak:
5499           target_sec = h->root.u.def.section;
5500           break;
5501         case bfd_link_hash_common:
5502           target_sec = bfd_com_section_ptr;
5503           break;
5504         case bfd_link_hash_undefined:
5505         case bfd_link_hash_undefweak:
5506           target_sec = bfd_und_section_ptr;
5507           break;
5508         default: /* New indirect warning.  */
5509           target_sec = bfd_und_section_ptr;
5510           break;
5511         }
5512     }
5513   return target_sec;
5514 }
5515
5516
5517 static struct elf_link_hash_entry *
5518 get_elf_r_symndx_hash_entry (abfd, r_symndx)
5519      bfd *abfd;
5520      unsigned long r_symndx;
5521 {
5522   unsigned long indx;
5523   struct elf_link_hash_entry *h;
5524   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5525
5526   if (r_symndx < symtab_hdr->sh_info)
5527     return NULL;
5528
5529   indx = r_symndx - symtab_hdr->sh_info;
5530   h = elf_sym_hashes (abfd)[indx];
5531   while (h->root.type == bfd_link_hash_indirect
5532          || h->root.type == bfd_link_hash_warning)
5533     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5534   return h;
5535 }
5536
5537
5538 /* Get the section-relative offset for a symbol number.  */
5539
5540 static bfd_vma
5541 get_elf_r_symndx_offset (abfd, r_symndx)
5542      bfd *abfd;
5543      unsigned long r_symndx;
5544 {
5545   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5546   bfd_vma offset = 0;
5547
5548   if (r_symndx < symtab_hdr->sh_info)
5549     {
5550       Elf_Internal_Sym *isymbuf;
5551       isymbuf = retrieve_local_syms (abfd);
5552       offset = isymbuf[r_symndx].st_value;
5553     }
5554   else
5555     {
5556       unsigned long indx = r_symndx - symtab_hdr->sh_info;
5557       struct elf_link_hash_entry *h =
5558         elf_sym_hashes (abfd)[indx];
5559
5560       while (h->root.type == bfd_link_hash_indirect
5561              || h->root.type == bfd_link_hash_warning)
5562         h = (struct elf_link_hash_entry *) h->root.u.i.link;
5563       if (h->root.type == bfd_link_hash_defined
5564           || h->root.type == bfd_link_hash_defweak)
5565         offset = h->root.u.def.value;
5566     }
5567   return offset;
5568 }
5569
5570
5571 static bfd_boolean
5572 pcrel_reloc_fits (opnd, self_address, dest_address)
5573      xtensa_operand opnd;
5574      bfd_vma self_address;
5575      bfd_vma dest_address;
5576 {
5577   uint32 new_address =
5578     xtensa_operand_do_reloc (opnd, dest_address, self_address);
5579   return (xtensa_operand_encode (opnd, &new_address)
5580           == xtensa_encode_result_ok);
5581 }
5582
5583
5584 static bfd_boolean
5585 xtensa_is_property_section (sec)
5586      asection *sec;
5587 {
5588   static int len = sizeof (".gnu.linkonce.t.") - 1;
5589
5590   return (strcmp (".xt.insn", sec->name) == 0
5591           || strcmp (".xt.lit", sec->name) == 0
5592           || strncmp (".gnu.linkonce.x.", sec->name, len) == 0
5593           || strncmp (".gnu.linkonce.p.", sec->name, len) == 0);
5594 }
5595
5596
5597 static bfd_boolean
5598 is_literal_section (sec)
5599      asection *sec;
5600 {
5601   /* FIXME: the current definition of this leaves a lot to be desired....  */
5602   if (sec == NULL || sec->name == NULL)
5603     return FALSE;
5604   return (strstr (sec->name, "literal") != NULL);
5605 }
5606
5607
5608 static int
5609 internal_reloc_compare (ap, bp)
5610      const PTR ap;
5611      const PTR bp;
5612 {
5613   const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
5614   const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
5615
5616   return (a->r_offset - b->r_offset);
5617 }
5618
5619
5620 static bfd_boolean
5621 get_is_linkonce_section (abfd, sec)
5622      bfd *abfd ATTRIBUTE_UNUSED;
5623      asection *sec;
5624 {
5625   flagword flags, link_once_flags;
5626   bfd_boolean is_linkonce = FALSE;;
5627
5628   flags = bfd_get_section_flags (abfd, sec);
5629   link_once_flags = (flags & SEC_LINK_ONCE);
5630   if (link_once_flags != 0)
5631     is_linkonce = TRUE;
5632
5633   /* In order for this to be useful to the assembler
5634      before the linkonce flag is set we need to
5635      check for the GNU extension name.  */
5636   if (!is_linkonce &&
5637       strncmp (sec->name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
5638     is_linkonce = TRUE;
5639
5640   return is_linkonce;
5641 }
5642
5643
5644 char *
5645 xtensa_get_property_section_name (abfd, sec, base_name)
5646      bfd *abfd;
5647      asection *sec;
5648      const char * base_name;
5649 {
5650   char *table_sec_name = NULL;
5651   bfd_boolean is_linkonce;
5652
5653   is_linkonce = get_is_linkonce_section (abfd, sec);
5654
5655   if (!is_linkonce)
5656     {
5657       table_sec_name = strdup (base_name);
5658     }
5659   else
5660     {
5661       static size_t prefix_len = sizeof (".gnu.linkonce.t.") - 1;
5662       size_t len = strlen (sec->name) + 1;
5663       char repl_char = '\0';
5664       const char *segname = sec->name;
5665
5666       if (strncmp (segname, ".gnu.linkonce.t.", prefix_len) == 0)
5667         {
5668           if (strcmp (base_name, ".xt.insn") == 0)
5669             repl_char = 'x';
5670           else if (strcmp (base_name, ".xt.lit") == 0)
5671             repl_char = 'p';
5672         }
5673
5674       if (repl_char != '\0')
5675         {
5676           char *name = (char *) bfd_malloc (len);
5677           memcpy (name, sec->name, len);
5678           name[prefix_len - 2] = repl_char;
5679           table_sec_name = name;
5680         }
5681       else
5682         {
5683           size_t base_len = strlen (base_name) + 1;
5684           char *name = (char *) bfd_malloc (len + base_len);
5685           memcpy (name, sec->name, len - 1);
5686           memcpy (name + len - 1, base_name, base_len);
5687           table_sec_name = name;
5688         }
5689     }
5690
5691   return table_sec_name;
5692 }
5693
5694 \f
5695 /* Other functions called directly by the linker.  */
5696
5697 bfd_boolean
5698 xtensa_callback_required_dependence (abfd, sec, link_info, callback, closure)
5699      bfd *abfd;
5700      asection *sec;
5701      struct bfd_link_info *link_info;
5702      deps_callback_t callback;
5703      PTR closure;
5704 {
5705   Elf_Internal_Rela *internal_relocs;
5706   bfd_byte *contents;
5707   unsigned i;
5708   bfd_boolean ok = TRUE;
5709
5710   /* ".plt*" sections have no explicit relocations but they contain L32R
5711      instructions that reference the corresponding ".got.plt*" sections.  */
5712   if ((sec->flags & SEC_LINKER_CREATED) != 0
5713       && strncmp (sec->name, ".plt", 4) == 0)
5714     {
5715       asection *sgotplt;
5716
5717       /* Find the corresponding ".got.plt*" section.  */
5718       if (sec->name[4] == '\0')
5719         sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
5720       else
5721         {
5722           char got_name[14];
5723           int chunk = 0;
5724
5725           BFD_ASSERT (sec->name[4] == '.');
5726           chunk = strtol (&sec->name[5], NULL, 10);
5727
5728           sprintf (got_name, ".got.plt.%u", chunk);
5729           sgotplt = bfd_get_section_by_name (sec->owner, got_name);
5730         }
5731       BFD_ASSERT (sgotplt);
5732
5733       /* Assume worst-case offsets: L32R at the very end of the ".plt"
5734          section referencing a literal at the very beginning of
5735          ".got.plt".  This is very close to the real dependence, anyway.  */
5736       (*callback) (sec, sec->_raw_size, sgotplt, 0, closure);
5737     }
5738
5739   internal_relocs = retrieve_internal_relocs (abfd, sec,
5740                                               link_info->keep_memory);
5741   if (internal_relocs == NULL
5742       || sec->reloc_count == 0)
5743     return ok;
5744
5745   /* Cache the contents for the duration of this scan.  */
5746   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5747   if (contents == NULL && sec->_raw_size != 0)
5748     {
5749       ok = FALSE;
5750       goto error_return;
5751     }
5752
5753   if (xtensa_default_isa == NULL)
5754     xtensa_isa_init ();
5755
5756   for (i = 0; i < sec->reloc_count; i++)
5757     {
5758       Elf_Internal_Rela *irel = &internal_relocs[i];
5759       if (is_l32r_relocation (sec, contents, irel))
5760         {
5761           r_reloc l32r_rel;
5762           asection *target_sec;
5763           bfd_vma target_offset;
5764
5765           r_reloc_init (&l32r_rel, abfd, irel);
5766           target_sec = NULL;
5767           target_offset = 0;
5768           /* L32Rs must be local to the input file.  */
5769           if (r_reloc_is_defined (&l32r_rel))
5770             {
5771               target_sec = r_reloc_get_section (&l32r_rel);
5772               target_offset = r_reloc_get_target_offset (&l32r_rel);
5773             }
5774           (*callback) (sec, irel->r_offset, target_sec, target_offset,
5775                        closure);
5776         }
5777     }
5778
5779  error_return:
5780   release_internal_relocs (sec, internal_relocs);
5781   release_contents (sec, contents);
5782   return ok;
5783 }
5784
5785 \f
5786 #ifndef ELF_ARCH
5787 #define TARGET_LITTLE_SYM               bfd_elf32_xtensa_le_vec
5788 #define TARGET_LITTLE_NAME              "elf32-xtensa-le"
5789 #define TARGET_BIG_SYM                  bfd_elf32_xtensa_be_vec
5790 #define TARGET_BIG_NAME                 "elf32-xtensa-be"
5791 #define ELF_ARCH                        bfd_arch_xtensa
5792
5793 /* The new EM_XTENSA value will be recognized beginning in the Xtensa T1040
5794    release. However, we still have to generate files with the EM_XTENSA_OLD
5795    value so that pre-T1040 tools can read the files.  As soon as we stop
5796    caring about pre-T1040 tools, the following two values should be
5797    swapped. At the same time, any other code that uses EM_XTENSA_OLD
5798    (e.g., prep_headers() in elf.c) should be changed to use EM_XTENSA.  */
5799 #define ELF_MACHINE_CODE                EM_XTENSA_OLD
5800 #define ELF_MACHINE_ALT1                EM_XTENSA
5801
5802 #if XCHAL_HAVE_MMU
5803 #define ELF_MAXPAGESIZE                 (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
5804 #else /* !XCHAL_HAVE_MMU */
5805 #define ELF_MAXPAGESIZE                 1
5806 #endif /* !XCHAL_HAVE_MMU */
5807 #endif /* ELF_ARCH */
5808
5809 #define elf_backend_can_gc_sections     1
5810 #define elf_backend_can_refcount        1
5811 #define elf_backend_plt_readonly        1
5812 #define elf_backend_got_header_size     4
5813 #define elf_backend_want_dynbss         0
5814 #define elf_backend_want_got_plt        1
5815
5816 #define elf_info_to_howto                    elf_xtensa_info_to_howto_rela
5817
5818 #define bfd_elf32_bfd_final_link             bfd_elf32_bfd_final_link
5819 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
5820 #define bfd_elf32_new_section_hook           elf_xtensa_new_section_hook
5821 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
5822 #define bfd_elf32_bfd_relax_section          elf_xtensa_relax_section
5823 #define bfd_elf32_bfd_reloc_type_lookup      elf_xtensa_reloc_type_lookup
5824 #define bfd_elf32_bfd_set_private_flags      elf_xtensa_set_private_flags
5825
5826 #define elf_backend_adjust_dynamic_symbol    elf_xtensa_adjust_dynamic_symbol
5827 #define elf_backend_check_relocs             elf_xtensa_check_relocs
5828 #define elf_backend_copy_indirect_symbol     elf_xtensa_copy_indirect_symbol
5829 #define elf_backend_create_dynamic_sections  elf_xtensa_create_dynamic_sections
5830 #define elf_backend_discard_info             elf_xtensa_discard_info
5831 #define elf_backend_ignore_discarded_relocs  elf_xtensa_ignore_discarded_relocs
5832 #define elf_backend_final_write_processing   elf_xtensa_final_write_processing
5833 #define elf_backend_finish_dynamic_sections  elf_xtensa_finish_dynamic_sections
5834 #define elf_backend_finish_dynamic_symbol    elf_xtensa_finish_dynamic_symbol
5835 #define elf_backend_gc_mark_hook             elf_xtensa_gc_mark_hook
5836 #define elf_backend_gc_sweep_hook            elf_xtensa_gc_sweep_hook
5837 #define elf_backend_grok_prstatus            elf_xtensa_grok_prstatus
5838 #define elf_backend_grok_psinfo              elf_xtensa_grok_psinfo
5839 #define elf_backend_hide_symbol              elf_xtensa_hide_symbol
5840 #define elf_backend_modify_segment_map       elf_xtensa_modify_segment_map
5841 #define elf_backend_object_p                 elf_xtensa_object_p
5842 #define elf_backend_reloc_type_class         elf_xtensa_reloc_type_class
5843 #define elf_backend_relocate_section         elf_xtensa_relocate_section
5844 #define elf_backend_size_dynamic_sections    elf_xtensa_size_dynamic_sections
5845
5846 #include "elf32-target.h"