bfd/elf32-xtensa.c

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