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