bfd/elf32-xtensa.c

   1 /* Xtensa-specific support for 32-bit ELF.
   2    Copyright (C) 2003-2016 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 3 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., 51 Franklin Street - Fifth Floor, Boston, MA
  19    02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23
  24 #include <stdarg.h>
  25 #include <strings.h>
  26
  27 #include "bfdlink.h"
  28 #include "libbfd.h"
  29 #include "elf-bfd.h"
  30 #include "elf/xtensa.h"
  31 #include "splay-tree.h"
  32 #include "xtensa-isa.h"
  33 #include "xtensa-config.h"
  34
  35 #define XTENSA_NO_NOP_REMOVAL 0
  36
  37 /* Local helper functions.  */
  38
  39 static bfd_boolean add_extra_plt_sections (struct bfd_link_info *, int);
  40 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
  41 static bfd_reloc_status_type bfd_elf_xtensa_reloc
  42   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  43 static bfd_boolean do_fix_for_relocatable_link
  44   (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *);
  45 static void do_fix_for_final_link
  46   (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *, bfd_vma *);
  47
  48 /* Local functions to handle Xtensa configurability.  */
  49
  50 static bfd_boolean is_indirect_call_opcode (xtensa_opcode);
  51 static bfd_boolean is_direct_call_opcode (xtensa_opcode);
  52 static bfd_boolean is_windowed_call_opcode (xtensa_opcode);
  53 static xtensa_opcode get_const16_opcode (void);
  54 static xtensa_opcode get_l32r_opcode (void);
  55 static bfd_vma l32r_offset (bfd_vma, bfd_vma);
  56 static int get_relocation_opnd (xtensa_opcode, int);
  57 static int get_relocation_slot (int);
  58 static xtensa_opcode get_relocation_opcode
  59   (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
  60 static bfd_boolean is_l32r_relocation
  61   (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
  62 static bfd_boolean is_alt_relocation (int);
  63 static bfd_boolean is_operand_relocation (int);
  64 static bfd_size_type insn_decode_len
  65   (bfd_byte *, bfd_size_type, bfd_size_type);
  66 static xtensa_opcode insn_decode_opcode
  67   (bfd_byte *, bfd_size_type, bfd_size_type, int);
  68 static bfd_boolean check_branch_target_aligned
  69   (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
  70 static bfd_boolean check_loop_aligned
  71   (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
  72 static bfd_boolean check_branch_target_aligned_address (bfd_vma, int);
  73 static bfd_size_type get_asm_simplify_size
  74   (bfd_byte *, bfd_size_type, bfd_size_type);
  75
  76 /* Functions for link-time code simplifications.  */
  77
  78 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
  79   (bfd_byte *, bfd_vma, bfd_vma, char **);
  80 static bfd_reloc_status_type contract_asm_expansion
  81   (bfd_byte *, bfd_vma, Elf_Internal_Rela *, char **);
  82 static xtensa_opcode swap_callx_for_call_opcode (xtensa_opcode);
  83 static xtensa_opcode get_expanded_call_opcode (bfd_byte *, int, bfd_boolean *);
  84
  85 /* Access to internal relocations, section contents and symbols.  */
  86
  87 static Elf_Internal_Rela *retrieve_internal_relocs
  88   (bfd *, asection *, bfd_boolean);
  89 static void pin_internal_relocs (asection *, Elf_Internal_Rela *);
  90 static void release_internal_relocs (asection *, Elf_Internal_Rela *);
  91 static bfd_byte *retrieve_contents (bfd *, asection *, bfd_boolean);
  92 static void pin_contents (asection *, bfd_byte *);
  93 static void release_contents (asection *, bfd_byte *);
  94 static Elf_Internal_Sym *retrieve_local_syms (bfd *);
  95
  96 /* Miscellaneous utility functions.  */
  97
  98 static asection *elf_xtensa_get_plt_section (struct bfd_link_info *, int);
  99 static asection *elf_xtensa_get_gotplt_section (struct bfd_link_info *, int);
 100 static asection *get_elf_r_symndx_section (bfd *, unsigned long);
 101 static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
 102   (bfd *, unsigned long);
 103 static bfd_vma get_elf_r_symndx_offset (bfd *, unsigned long);
 104 static bfd_boolean is_reloc_sym_weak (bfd *, Elf_Internal_Rela *);
 105 static bfd_boolean pcrel_reloc_fits (xtensa_opcode, int, bfd_vma, bfd_vma);
 106 static bfd_boolean xtensa_is_property_section (asection *);
 107 static bfd_boolean xtensa_is_insntable_section (asection *);
 108 static bfd_boolean xtensa_is_littable_section (asection *);
 109 static bfd_boolean xtensa_is_proptable_section (asection *);
 110 static int internal_reloc_compare (const void *, const void *);
 111 static int internal_reloc_matches (const void *, const void *);
 112 static asection *xtensa_get_property_section (asection *, const char *);
 113 extern asection *xtensa_make_property_section (asection *, const char *);
 114 static flagword xtensa_get_property_predef_flags (asection *);
 115
 116 /* Other functions called directly by the linker.  */
 117
 118 typedef void (*deps_callback_t)
 119   (asection *, bfd_vma, asection *, bfd_vma, void *);
 120 extern bfd_boolean xtensa_callback_required_dependence
 121   (bfd *, asection *, struct bfd_link_info *, deps_callback_t, void *);
 122
 123
 124 /* Globally visible flag for choosing size optimization of NOP removal
 125    instead of branch-target-aware minimization for NOP removal.
 126    When nonzero, narrow all instructions and remove all NOPs possible
 127    around longcall expansions.  */
 128
 129 int elf32xtensa_size_opt;
 130
 131
 132 /* The "new_section_hook" is used to set up a per-section
 133    "xtensa_relax_info" data structure with additional information used
 134    during relaxation.  */
 135
 136 typedef struct xtensa_relax_info_struct xtensa_relax_info;
 137
 138
 139 /* The GNU tools do not easily allow extending interfaces to pass around
 140    the pointer to the Xtensa ISA information, so instead we add a global
 141    variable here (in BFD) that can be used by any of the tools that need
 142    this information. */
 143
 144 xtensa_isa xtensa_default_isa;
 145
 146
 147 /* When this is true, relocations may have been modified to refer to
 148    symbols from other input files.  The per-section list of "fix"
 149    records needs to be checked when resolving relocations.  */
 150
 151 static bfd_boolean relaxing_section = FALSE;
 152
 153 /* When this is true, during final links, literals that cannot be
 154    coalesced and their relocations may be moved to other sections.  */
 155
 156 int elf32xtensa_no_literal_movement = 1;
 157
 158 /* Rename one of the generic section flags to better document how it
 159    is used here.  */
 160 /* Whether relocations have been processed.  */
 161 #define reloc_done sec_flg0
 162 \f
 163 static reloc_howto_type elf_howto_table[] =
 164 {
 165   HOWTO (R_XTENSA_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
 166          bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
 167          FALSE, 0, 0, FALSE),
 168   HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 169          bfd_elf_xtensa_reloc, "R_XTENSA_32",
 170          TRUE, 0xffffffff, 0xffffffff, FALSE),
 171
 172   /* Replace a 32-bit value with a value from the runtime linker (only
 173      used by linker-generated stub functions).  The r_addend value is
 174      special: 1 means to substitute a pointer to the runtime linker's
 175      dynamic resolver function; 2 means to substitute the link map for
 176      the shared object.  */
 177   HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
 178          NULL, "R_XTENSA_RTLD", FALSE, 0, 0, FALSE),
 179
 180   HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 181          bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
 182          FALSE, 0, 0xffffffff, FALSE),
 183   HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 184          bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
 185          FALSE, 0, 0xffffffff, FALSE),
 186   HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 187          bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
 188          FALSE, 0, 0xffffffff, FALSE),
 189   HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 190          bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
 191          FALSE, 0, 0xffffffff, FALSE),
 192
 193   EMPTY_HOWTO (7),
 194
 195   /* Old relocations for backward compatibility.  */
 196   HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 197          bfd_elf_xtensa_reloc, "R_XTENSA_OP0", FALSE, 0, 0, TRUE),
 198   HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 199          bfd_elf_xtensa_reloc, "R_XTENSA_OP1", FALSE, 0, 0, TRUE),
 200   HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 201          bfd_elf_xtensa_reloc, "R_XTENSA_OP2", FALSE, 0, 0, TRUE),
 202
 203   /* Assembly auto-expansion.  */
 204   HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 205          bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND", FALSE, 0, 0, TRUE),
 206   /* Relax assembly auto-expansion.  */
 207   HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 208          bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY", FALSE, 0, 0, TRUE),
 209
 210   EMPTY_HOWTO (13),
 211
 212   HOWTO (R_XTENSA_32_PCREL, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
 213          bfd_elf_xtensa_reloc, "R_XTENSA_32_PCREL",
 214          FALSE, 0, 0xffffffff, TRUE),
 215
 216   /* GNU extension to record C++ vtable hierarchy.  */
 217   HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
 218          NULL, "R_XTENSA_GNU_VTINHERIT",
 219          FALSE, 0, 0, FALSE),
 220   /* GNU extension to record C++ vtable member usage.  */
 221   HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
 222          _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
 223          FALSE, 0, 0, FALSE),
 224
 225   /* Relocations for supporting difference of symbols.  */
 226   HOWTO (R_XTENSA_DIFF8, 0, 0, 8, FALSE, 0, complain_overflow_signed,
 227          bfd_elf_xtensa_reloc, "R_XTENSA_DIFF8", FALSE, 0, 0xff, FALSE),
 228   HOWTO (R_XTENSA_DIFF16, 0, 1, 16, FALSE, 0, complain_overflow_signed,
 229          bfd_elf_xtensa_reloc, "R_XTENSA_DIFF16", FALSE, 0, 0xffff, FALSE),
 230   HOWTO (R_XTENSA_DIFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
 231          bfd_elf_xtensa_reloc, "R_XTENSA_DIFF32", FALSE, 0, 0xffffffff, FALSE),
 232
 233   /* General immediate operand relocations.  */
 234   HOWTO (R_XTENSA_SLOT0_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 235          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_OP", FALSE, 0, 0, TRUE),
 236   HOWTO (R_XTENSA_SLOT1_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 237          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_OP", FALSE, 0, 0, TRUE),
 238   HOWTO (R_XTENSA_SLOT2_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 239          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_OP", FALSE, 0, 0, TRUE),
 240   HOWTO (R_XTENSA_SLOT3_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 241          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_OP", FALSE, 0, 0, TRUE),
 242   HOWTO (R_XTENSA_SLOT4_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 243          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_OP", FALSE, 0, 0, TRUE),
 244   HOWTO (R_XTENSA_SLOT5_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 245          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_OP", FALSE, 0, 0, TRUE),
 246   HOWTO (R_XTENSA_SLOT6_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 247          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_OP", FALSE, 0, 0, TRUE),
 248   HOWTO (R_XTENSA_SLOT7_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 249          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_OP", FALSE, 0, 0, TRUE),
 250   HOWTO (R_XTENSA_SLOT8_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 251          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_OP", FALSE, 0, 0, TRUE),
 252   HOWTO (R_XTENSA_SLOT9_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 253          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_OP", FALSE, 0, 0, TRUE),
 254   HOWTO (R_XTENSA_SLOT10_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 255          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_OP", FALSE, 0, 0, TRUE),
 256   HOWTO (R_XTENSA_SLOT11_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 257          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_OP", FALSE, 0, 0, TRUE),
 258   HOWTO (R_XTENSA_SLOT12_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 259          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_OP", FALSE, 0, 0, TRUE),
 260   HOWTO (R_XTENSA_SLOT13_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 261          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_OP", FALSE, 0, 0, TRUE),
 262   HOWTO (R_XTENSA_SLOT14_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 263          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_OP", FALSE, 0, 0, TRUE),
 264
 265   /* "Alternate" relocations.  The meaning of these is opcode-specific.  */
 266   HOWTO (R_XTENSA_SLOT0_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 267          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_ALT", FALSE, 0, 0, TRUE),
 268   HOWTO (R_XTENSA_SLOT1_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 269          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_ALT", FALSE, 0, 0, TRUE),
 270   HOWTO (R_XTENSA_SLOT2_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 271          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_ALT", FALSE, 0, 0, TRUE),
 272   HOWTO (R_XTENSA_SLOT3_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 273          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_ALT", FALSE, 0, 0, TRUE),
 274   HOWTO (R_XTENSA_SLOT4_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 275          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_ALT", FALSE, 0, 0, TRUE),
 276   HOWTO (R_XTENSA_SLOT5_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 277          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_ALT", FALSE, 0, 0, TRUE),
 278   HOWTO (R_XTENSA_SLOT6_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 279          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_ALT", FALSE, 0, 0, TRUE),
 280   HOWTO (R_XTENSA_SLOT7_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 281          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_ALT", FALSE, 0, 0, TRUE),
 282   HOWTO (R_XTENSA_SLOT8_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 283          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_ALT", FALSE, 0, 0, TRUE),
 284   HOWTO (R_XTENSA_SLOT9_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 285          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_ALT", FALSE, 0, 0, TRUE),
 286   HOWTO (R_XTENSA_SLOT10_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 287          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_ALT", FALSE, 0, 0, TRUE),
 288   HOWTO (R_XTENSA_SLOT11_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 289          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_ALT", FALSE, 0, 0, TRUE),
 290   HOWTO (R_XTENSA_SLOT12_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 291          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_ALT", FALSE, 0, 0, TRUE),
 292   HOWTO (R_XTENSA_SLOT13_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 293          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_ALT", FALSE, 0, 0, TRUE),
 294   HOWTO (R_XTENSA_SLOT14_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
 295          bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_ALT", FALSE, 0, 0, TRUE),
 296
 297   /* TLS relocations.  */
 298   HOWTO (R_XTENSA_TLSDESC_FN, 0, 2, 32, FALSE, 0, complain_overflow_dont,
 299          bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_FN",
 300          FALSE, 0, 0xffffffff, FALSE),
 301   HOWTO (R_XTENSA_TLSDESC_ARG, 0, 2, 32, FALSE, 0, complain_overflow_dont,
 302          bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_ARG",
 303          FALSE, 0, 0xffffffff, FALSE),
 304   HOWTO (R_XTENSA_TLS_DTPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
 305          bfd_elf_xtensa_reloc, "R_XTENSA_TLS_DTPOFF",
 306          FALSE, 0, 0xffffffff, FALSE),
 307   HOWTO (R_XTENSA_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
 308          bfd_elf_xtensa_reloc, "R_XTENSA_TLS_TPOFF",
 309          FALSE, 0, 0xffffffff, FALSE),
 310   HOWTO (R_XTENSA_TLS_FUNC, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 311          bfd_elf_xtensa_reloc, "R_XTENSA_TLS_FUNC",
 312          FALSE, 0, 0, FALSE),
 313   HOWTO (R_XTENSA_TLS_ARG, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 314          bfd_elf_xtensa_reloc, "R_XTENSA_TLS_ARG",
 315          FALSE, 0, 0, FALSE),
 316   HOWTO (R_XTENSA_TLS_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 317          bfd_elf_xtensa_reloc, "R_XTENSA_TLS_CALL",
 318          FALSE, 0, 0, FALSE),
 319 };
 320
 321 #if DEBUG_GEN_RELOC
 322 #define TRACE(str) \
 323   fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
 324 #else
 325 #define TRACE(str)
 326 #endif
 327
 328 static reloc_howto_type *
 329 elf_xtensa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 330                               bfd_reloc_code_real_type code)
 331 {
 332   switch (code)
 333     {
 334     case BFD_RELOC_NONE:
 335       TRACE ("BFD_RELOC_NONE");
 336       return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
 337
 338     case BFD_RELOC_32:
 339       TRACE ("BFD_RELOC_32");
 340       return &elf_howto_table[(unsigned) R_XTENSA_32 ];
 341
 342     case BFD_RELOC_32_PCREL:
 343       TRACE ("BFD_RELOC_32_PCREL");
 344       return &elf_howto_table[(unsigned) R_XTENSA_32_PCREL ];
 345
 346     case BFD_RELOC_XTENSA_DIFF8:
 347       TRACE ("BFD_RELOC_XTENSA_DIFF8");
 348       return &elf_howto_table[(unsigned) R_XTENSA_DIFF8 ];
 349
 350     case BFD_RELOC_XTENSA_DIFF16:
 351       TRACE ("BFD_RELOC_XTENSA_DIFF16");
 352       return &elf_howto_table[(unsigned) R_XTENSA_DIFF16 ];
 353
 354     case BFD_RELOC_XTENSA_DIFF32:
 355       TRACE ("BFD_RELOC_XTENSA_DIFF32");
 356       return &elf_howto_table[(unsigned) R_XTENSA_DIFF32 ];
 357
 358     case BFD_RELOC_XTENSA_RTLD:
 359       TRACE ("BFD_RELOC_XTENSA_RTLD");
 360       return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
 361
 362     case BFD_RELOC_XTENSA_GLOB_DAT:
 363       TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
 364       return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
 365
 366     case BFD_RELOC_XTENSA_JMP_SLOT:
 367       TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
 368       return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
 369
 370     case BFD_RELOC_XTENSA_RELATIVE:
 371       TRACE ("BFD_RELOC_XTENSA_RELATIVE");
 372       return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
 373
 374     case BFD_RELOC_XTENSA_PLT:
 375       TRACE ("BFD_RELOC_XTENSA_PLT");
 376       return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
 377
 378     case BFD_RELOC_XTENSA_OP0:
 379       TRACE ("BFD_RELOC_XTENSA_OP0");
 380       return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
 381
 382     case BFD_RELOC_XTENSA_OP1:
 383       TRACE ("BFD_RELOC_XTENSA_OP1");
 384       return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
 385
 386     case BFD_RELOC_XTENSA_OP2:
 387       TRACE ("BFD_RELOC_XTENSA_OP2");
 388       return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
 389
 390     case BFD_RELOC_XTENSA_ASM_EXPAND:
 391       TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
 392       return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
 393
 394     case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
 395       TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
 396       return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
 397
 398     case BFD_RELOC_VTABLE_INHERIT:
 399       TRACE ("BFD_RELOC_VTABLE_INHERIT");
 400       return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
 401
 402     case BFD_RELOC_VTABLE_ENTRY:
 403       TRACE ("BFD_RELOC_VTABLE_ENTRY");
 404       return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
 405
 406     case BFD_RELOC_XTENSA_TLSDESC_FN:
 407       TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
 408       return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_FN ];
 409
 410     case BFD_RELOC_XTENSA_TLSDESC_ARG:
 411       TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
 412       return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_ARG ];
 413
 414     case BFD_RELOC_XTENSA_TLS_DTPOFF:
 415       TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
 416       return &elf_howto_table[(unsigned) R_XTENSA_TLS_DTPOFF ];
 417
 418     case BFD_RELOC_XTENSA_TLS_TPOFF:
 419       TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
 420       return &elf_howto_table[(unsigned) R_XTENSA_TLS_TPOFF ];
 421
 422     case BFD_RELOC_XTENSA_TLS_FUNC:
 423       TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
 424       return &elf_howto_table[(unsigned) R_XTENSA_TLS_FUNC ];
 425
 426     case BFD_RELOC_XTENSA_TLS_ARG:
 427       TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
 428       return &elf_howto_table[(unsigned) R_XTENSA_TLS_ARG ];
 429
 430     case BFD_RELOC_XTENSA_TLS_CALL:
 431       TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
 432       return &elf_howto_table[(unsigned) R_XTENSA_TLS_CALL ];
 433
 434     default:
 435       if (code >= BFD_RELOC_XTENSA_SLOT0_OP
 436           && code <= BFD_RELOC_XTENSA_SLOT14_OP)
 437         {
 438           unsigned n = (R_XTENSA_SLOT0_OP +
 439                         (code - BFD_RELOC_XTENSA_SLOT0_OP));
 440           return &elf_howto_table[n];
 441         }
 442
 443       if (code >= BFD_RELOC_XTENSA_SLOT0_ALT
 444           && code <= BFD_RELOC_XTENSA_SLOT14_ALT)
 445         {
 446           unsigned n = (R_XTENSA_SLOT0_ALT +
 447                         (code - BFD_RELOC_XTENSA_SLOT0_ALT));
 448           return &elf_howto_table[n];
 449         }
 450
 451       break;
 452     }
 453
 454   TRACE ("Unknown");
 455   return NULL;
 456 }
 457
 458 static reloc_howto_type *
 459 elf_xtensa_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 460                               const char *r_name)
 461 {
 462   unsigned int i;
 463
 464   for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
 465     if (elf_howto_table[i].name != NULL
 466         && strcasecmp (elf_howto_table[i].name, r_name) == 0)
 467       return &elf_howto_table[i];
 468
 469   return NULL;
 470 }
 471
 472
 473 /* Given an ELF "rela" relocation, find the corresponding howto and record
 474    it in the BFD internal arelent representation of the relocation.  */
 475
 476 static void
 477 elf_xtensa_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
 478                                arelent *cache_ptr,
 479                                Elf_Internal_Rela *dst)
 480 {
 481   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 482
 483   if (r_type >= (unsigned int) R_XTENSA_max)
 484     {
 485       _bfd_error_handler (_("%B: invalid XTENSA reloc number: %d"), abfd, r_type);
 486       r_type = 0;
 487     }
 488   cache_ptr->howto = &elf_howto_table[r_type];
 489 }
 490
 491 \f
 492 /* Functions for the Xtensa ELF linker.  */
 493
 494 /* The name of the dynamic interpreter.  This is put in the .interp
 495    section.  */
 496
 497 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
 498
 499 /* The size in bytes of an entry in the procedure linkage table.
 500    (This does _not_ include the space for the literals associated with
 501    the PLT entry.) */
 502
 503 #define PLT_ENTRY_SIZE 16
 504
 505 /* For _really_ large PLTs, we may need to alternate between literals
 506    and code to keep the literals within the 256K range of the L32R
 507    instructions in the code.  It's unlikely that anyone would ever need
 508    such a big PLT, but an arbitrary limit on the PLT size would be bad.
 509    Thus, we split the PLT into chunks.  Since there's very little
 510    overhead (2 extra literals) for each chunk, the chunk size is kept
 511    small so that the code for handling multiple chunks get used and
 512    tested regularly.  With 254 entries, there are 1K of literals for
 513    each chunk, and that seems like a nice round number.  */
 514
 515 #define PLT_ENTRIES_PER_CHUNK 254
 516
 517 /* PLT entries are actually used as stub functions for lazy symbol
 518    resolution.  Once the symbol is resolved, the stub function is never
 519    invoked.  Note: the 32-byte frame size used here cannot be changed
 520    without a corresponding change in the runtime linker.  */
 521
 522 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
 523 {
 524 #if XSHAL_ABI == XTHAL_ABI_WINDOWED
 525   0x6c, 0x10, 0x04,     /* entry sp, 32 */
 526 #endif
 527   0x18, 0x00, 0x00,     /* l32r  a8, [got entry for rtld's resolver] */
 528   0x1a, 0x00, 0x00,     /* l32r  a10, [got entry for rtld's link map] */
 529   0x1b, 0x00, 0x00,     /* l32r  a11, [literal for reloc index] */
 530   0x0a, 0x80, 0x00,     /* jx    a8 */
 531   0                     /* unused */
 532 };
 533
 534 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
 535 {
 536 #if XSHAL_ABI == XTHAL_ABI_WINDOWED
 537   0x36, 0x41, 0x00,     /* entry sp, 32 */
 538 #endif
 539   0x81, 0x00, 0x00,     /* l32r  a8, [got entry for rtld's resolver] */
 540   0xa1, 0x00, 0x00,     /* l32r  a10, [got entry for rtld's link map] */
 541   0xb1, 0x00, 0x00,     /* l32r  a11, [literal for reloc index] */
 542   0xa0, 0x08, 0x00,     /* jx    a8 */
 543   0                     /* unused */
 544 };
 545
 546 /* The size of the thread control block.  */
 547 #define TCB_SIZE        8
 548
 549 struct elf_xtensa_link_hash_entry
 550 {
 551   struct elf_link_hash_entry elf;
 552
 553   bfd_signed_vma tlsfunc_refcount;
 554
 555 #define GOT_UNKNOWN     0
 556 #define GOT_NORMAL      1
 557 #define GOT_TLS_GD      2       /* global or local dynamic */
 558 #define GOT_TLS_IE      4       /* initial or local exec */
 559 #define GOT_TLS_ANY     (GOT_TLS_GD | GOT_TLS_IE)
 560   unsigned char tls_type;
 561 };
 562
 563 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
 564
 565 struct elf_xtensa_obj_tdata
 566 {
 567   struct elf_obj_tdata root;
 568
 569   /* tls_type for each local got entry.  */
 570   char *local_got_tls_type;
 571
 572   bfd_signed_vma *local_tlsfunc_refcounts;
 573 };
 574
 575 #define elf_xtensa_tdata(abfd) \
 576   ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
 577
 578 #define elf_xtensa_local_got_tls_type(abfd) \
 579   (elf_xtensa_tdata (abfd)->local_got_tls_type)
 580
 581 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
 582   (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
 583
 584 #define is_xtensa_elf(bfd) \
 585   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
 586    && elf_tdata (bfd) != NULL \
 587    && elf_object_id (bfd) == XTENSA_ELF_DATA)
 588
 589 static bfd_boolean
 590 elf_xtensa_mkobject (bfd *abfd)
 591 {
 592   return bfd_elf_allocate_object (abfd, sizeof (struct elf_xtensa_obj_tdata),
 593                                   XTENSA_ELF_DATA);
 594 }
 595
 596 /* Xtensa ELF linker hash table.  */
 597
 598 struct elf_xtensa_link_hash_table
 599 {
 600   struct elf_link_hash_table elf;
 601
 602   /* Short-cuts to get to dynamic linker sections.  */
 603   asection *sgot;
 604   asection *sgotplt;
 605   asection *srelgot;
 606   asection *splt;
 607   asection *srelplt;
 608   asection *sgotloc;
 609   asection *spltlittbl;
 610
 611   /* Total count of PLT relocations seen during check_relocs.
 612      The actual PLT code must be split into multiple sections and all
 613      the sections have to be created before size_dynamic_sections,
 614      where we figure out the exact number of PLT entries that will be
 615      needed.  It is OK if this count is an overestimate, e.g., some
 616      relocations may be removed by GC.  */
 617   int plt_reloc_count;
 618
 619   struct elf_xtensa_link_hash_entry *tlsbase;
 620 };
 621
 622 /* Get the Xtensa ELF linker hash table from a link_info structure.  */
 623
 624 #define elf_xtensa_hash_table(p) \
 625   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 626   == XTENSA_ELF_DATA ? ((struct elf_xtensa_link_hash_table *) ((p)->hash)) : NULL)
 627
 628 /* Create an entry in an Xtensa ELF linker hash table.  */
 629
 630 static struct bfd_hash_entry *
 631 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry *entry,
 632                               struct bfd_hash_table *table,
 633                               const char *string)
 634 {
 635   /* Allocate the structure if it has not already been allocated by a
 636      subclass.  */
 637   if (entry == NULL)
 638     {
 639       entry = bfd_hash_allocate (table,
 640                                  sizeof (struct elf_xtensa_link_hash_entry));
 641       if (entry == NULL)
 642         return entry;
 643     }
 644
 645   /* Call the allocation method of the superclass.  */
 646   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 647   if (entry != NULL)
 648     {
 649       struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (entry);
 650       eh->tlsfunc_refcount = 0;
 651       eh->tls_type = GOT_UNKNOWN;
 652     }
 653
 654   return entry;
 655 }
 656
 657 /* Create an Xtensa ELF linker hash table.  */
 658
 659 static struct bfd_link_hash_table *
 660 elf_xtensa_link_hash_table_create (bfd *abfd)
 661 {
 662   struct elf_link_hash_entry *tlsbase;
 663   struct elf_xtensa_link_hash_table *ret;
 664   bfd_size_type amt = sizeof (struct elf_xtensa_link_hash_table);
 665
 666   ret = bfd_zmalloc (amt);
 667   if (ret == NULL)
 668     return NULL;
 669
 670   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
 671                                       elf_xtensa_link_hash_newfunc,
 672                                       sizeof (struct elf_xtensa_link_hash_entry),
 673                                       XTENSA_ELF_DATA))
 674     {
 675       free (ret);
 676       return NULL;
 677     }
 678
 679   /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
 680      for it later.  */
 681   tlsbase = elf_link_hash_lookup (&ret->elf, "_TLS_MODULE_BASE_",
 682                                   TRUE, FALSE, FALSE);
 683   tlsbase->root.type = bfd_link_hash_new;
 684   tlsbase->root.u.undef.abfd = NULL;
 685   tlsbase->non_elf = 0;
 686   ret->tlsbase = elf_xtensa_hash_entry (tlsbase);
 687   ret->tlsbase->tls_type = GOT_UNKNOWN;
 688
 689   return &ret->elf.root;
 690 }
 691
 692 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 693
 694 static void
 695 elf_xtensa_copy_indirect_symbol (struct bfd_link_info *info,
 696                                  struct elf_link_hash_entry *dir,
 697                                  struct elf_link_hash_entry *ind)
 698 {
 699   struct elf_xtensa_link_hash_entry *edir, *eind;
 700
 701   edir = elf_xtensa_hash_entry (dir);
 702   eind = elf_xtensa_hash_entry (ind);
 703
 704   if (ind->root.type == bfd_link_hash_indirect)
 705     {
 706       edir->tlsfunc_refcount += eind->tlsfunc_refcount;
 707       eind->tlsfunc_refcount = 0;
 708
 709       if (dir->got.refcount <= 0)
 710         {
 711           edir->tls_type = eind->tls_type;
 712           eind->tls_type = GOT_UNKNOWN;
 713         }
 714     }
 715
 716   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
 717 }
 718
 719 static inline bfd_boolean
 720 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry *h,
 721                              struct bfd_link_info *info)
 722 {
 723   /* Check if we should do dynamic things to this symbol.  The
 724      "ignore_protected" argument need not be set, because Xtensa code
 725      does not require special handling of STV_PROTECTED to make function
 726      pointer comparisons work properly.  The PLT addresses are never
 727      used for function pointers.  */
 728
 729   return _bfd_elf_dynamic_symbol_p (h, info, 0);
 730 }
 731
 732 \f
 733 static int
 734 property_table_compare (const void *ap, const void *bp)
 735 {
 736   const property_table_entry *a = (const property_table_entry *) ap;
 737   const property_table_entry *b = (const property_table_entry *) bp;
 738
 739   if (a->address == b->address)
 740     {
 741       if (a->size != b->size)
 742         return (a->size - b->size);
 743
 744       if ((a->flags & XTENSA_PROP_ALIGN) != (b->flags & XTENSA_PROP_ALIGN))
 745         return ((b->flags & XTENSA_PROP_ALIGN)
 746                 - (a->flags & XTENSA_PROP_ALIGN));
 747
 748       if ((a->flags & XTENSA_PROP_ALIGN)
 749           && (GET_XTENSA_PROP_ALIGNMENT (a->flags)
 750               != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
 751         return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
 752                 - GET_XTENSA_PROP_ALIGNMENT (b->flags));
 753
 754       if ((a->flags & XTENSA_PROP_UNREACHABLE)
 755           != (b->flags & XTENSA_PROP_UNREACHABLE))
 756         return ((b->flags & XTENSA_PROP_UNREACHABLE)
 757                 - (a->flags & XTENSA_PROP_UNREACHABLE));
 758
 759       return (a->flags - b->flags);
 760     }
 761
 762   return (a->address - b->address);
 763 }
 764
 765
 766 static int
 767 property_table_matches (const void *ap, const void *bp)
 768 {
 769   const property_table_entry *a = (const property_table_entry *) ap;
 770   const property_table_entry *b = (const property_table_entry *) bp;
 771
 772   /* Check if one entry overlaps with the other.  */
 773   if ((b->address >= a->address && b->address < (a->address + a->size))
 774       || (a->address >= b->address && a->address < (b->address + b->size)))
 775     return 0;
 776
 777   return (a->address - b->address);
 778 }
 779
 780
 781 /* Get the literal table or property table entries for the given
 782    section.  Sets TABLE_P and returns the number of entries.  On
 783    error, returns a negative value.  */
 784
 785 static int
 786 xtensa_read_table_entries (bfd *abfd,
 787                            asection *section,
 788                            property_table_entry **table_p,
 789                            const char *sec_name,
 790                            bfd_boolean output_addr)
 791 {
 792   asection *table_section;
 793   bfd_size_type table_size = 0;
 794   bfd_byte *table_data;
 795   property_table_entry *blocks;
 796   int blk, block_count;
 797   bfd_size_type num_records;
 798   Elf_Internal_Rela *internal_relocs, *irel, *rel_end;
 799   bfd_vma section_addr, off;
 800   flagword predef_flags;
 801   bfd_size_type table_entry_size, section_limit;
 802
 803   if (!section
 804       || !(section->flags & SEC_ALLOC)
 805       || (section->flags & SEC_DEBUGGING))
 806     {
 807       *table_p = NULL;
 808       return 0;
 809     }
 810
 811   table_section = xtensa_get_property_section (section, sec_name);
 812   if (table_section)
 813     table_size = table_section->size;
 814
 815   if (table_size == 0)
 816     {
 817       *table_p = NULL;
 818       return 0;
 819     }
 820
 821   predef_flags = xtensa_get_property_predef_flags (table_section);
 822   table_entry_size = 12;
 823   if (predef_flags)
 824     table_entry_size -= 4;
 825
 826   num_records = table_size / table_entry_size;
 827   table_data = retrieve_contents (abfd, table_section, TRUE);
 828   blocks = (property_table_entry *)
 829     bfd_malloc (num_records * sizeof (property_table_entry));
 830   block_count = 0;
 831
 832   if (output_addr)
 833     section_addr = section->output_section->vma + section->output_offset;
 834   else
 835     section_addr = section->vma;
 836
 837   internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
 838   if (internal_relocs && !table_section->reloc_done)
 839     {
 840       qsort (internal_relocs, table_section->reloc_count,
 841              sizeof (Elf_Internal_Rela), internal_reloc_compare);
 842       irel = internal_relocs;
 843     }
 844   else
 845     irel = NULL;
 846
 847   section_limit = bfd_get_section_limit (abfd, section);
 848   rel_end = internal_relocs + table_section->reloc_count;
 849
 850   for (off = 0; off < table_size; off += table_entry_size)
 851     {
 852       bfd_vma address = bfd_get_32 (abfd, table_data + off);
 853
 854       /* Skip any relocations before the current offset.  This should help
 855          avoid confusion caused by unexpected relocations for the preceding
 856          table entry.  */
 857       while (irel &&
 858              (irel->r_offset < off
 859               || (irel->r_offset == off
 860                   && ELF32_R_TYPE (irel->r_info) == R_XTENSA_NONE)))
 861         {
 862           irel += 1;
 863           if (irel >= rel_end)
 864             irel = 0;
 865         }
 866
 867       if (irel && irel->r_offset == off)
 868         {
 869           bfd_vma sym_off;
 870           unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
 871           BFD_ASSERT (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32);
 872
 873           if (get_elf_r_symndx_section (abfd, r_symndx) != section)
 874             continue;
 875
 876           sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
 877           BFD_ASSERT (sym_off == 0);
 878           address += (section_addr + sym_off + irel->r_addend);
 879         }
 880       else
 881         {
 882           if (address < section_addr
 883               || address >= section_addr + section_limit)
 884             continue;
 885         }
 886
 887       blocks[block_count].address = address;
 888       blocks[block_count].size = bfd_get_32 (abfd, table_data + off + 4);
 889       if (predef_flags)
 890         blocks[block_count].flags = predef_flags;
 891       else
 892         blocks[block_count].flags = bfd_get_32 (abfd, table_data + off + 8);
 893       block_count++;
 894     }
 895
 896   release_contents (table_section, table_data);
 897   release_internal_relocs (table_section, internal_relocs);
 898
 899   if (block_count > 0)
 900     {
 901       /* Now sort them into address order for easy reference.  */
 902       qsort (blocks, block_count, sizeof (property_table_entry),
 903              property_table_compare);
 904
 905       /* Check that the table contents are valid.  Problems may occur,
 906          for example, if an unrelocated object file is stripped.  */
 907       for (blk = 1; blk < block_count; blk++)
 908         {
 909           /* The only circumstance where two entries may legitimately
 910              have the same address is when one of them is a zero-size
 911              placeholder to mark a place where fill can be inserted.
 912              The zero-size entry should come first.  */
 913           if (blocks[blk - 1].address == blocks[blk].address &&
 914               blocks[blk - 1].size != 0)
 915             {
 916               (*_bfd_error_handler) (_("%B(%A): invalid property table"),
 917                                      abfd, section);
 918               bfd_set_error (bfd_error_bad_value);
 919               free (blocks);
 920               return -1;
 921             }
 922         }
 923     }
 924
 925   *table_p = blocks;
 926   return block_count;
 927 }
 928
 929
 930 static property_table_entry *
 931 elf_xtensa_find_property_entry (property_table_entry *property_table,
 932                                 int property_table_size,
 933                                 bfd_vma addr)
 934 {
 935   property_table_entry entry;
 936   property_table_entry *rv;
 937
 938   if (property_table_size == 0)
 939     return NULL;
 940
 941   entry.address = addr;
 942   entry.size = 1;
 943   entry.flags = 0;
 944
 945   rv = bsearch (&entry, property_table, property_table_size,
 946                 sizeof (property_table_entry), property_table_matches);
 947   return rv;
 948 }
 949
 950
 951 static bfd_boolean
 952 elf_xtensa_in_literal_pool (property_table_entry *lit_table,
 953                             int lit_table_size,
 954                             bfd_vma addr)
 955 {
 956   if (elf_xtensa_find_property_entry (lit_table, lit_table_size, addr))
 957     return TRUE;
 958
 959   return FALSE;
 960 }
 961
 962 \f
 963 /* Look through the relocs for a section during the first phase, and
 964    calculate needed space in the dynamic reloc sections.  */
 965
 966 static bfd_boolean
 967 elf_xtensa_check_relocs (bfd *abfd,
 968                          struct bfd_link_info *info,
 969                          asection *sec,
 970                          const Elf_Internal_Rela *relocs)
 971 {
 972   struct elf_xtensa_link_hash_table *htab;
 973   Elf_Internal_Shdr *symtab_hdr;
 974   struct elf_link_hash_entry **sym_hashes;
 975   const Elf_Internal_Rela *rel;
 976   const Elf_Internal_Rela *rel_end;
 977
 978   if (bfd_link_relocatable (info) || (sec->flags & SEC_ALLOC) == 0)
 979     return TRUE;
 980
 981   BFD_ASSERT (is_xtensa_elf (abfd));
 982
 983   htab = elf_xtensa_hash_table (info);
 984   if (htab == NULL)
 985     return FALSE;
 986
 987   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 988   sym_hashes = elf_sym_hashes (abfd);
 989
 990   rel_end = relocs + sec->reloc_count;
 991   for (rel = relocs; rel < rel_end; rel++)
 992     {
 993       unsigned int r_type;
 994       unsigned long r_symndx;
 995       struct elf_link_hash_entry *h = NULL;
 996       struct elf_xtensa_link_hash_entry *eh;
 997       int tls_type, old_tls_type;
 998       bfd_boolean is_got = FALSE;
 999       bfd_boolean is_plt = FALSE;
1000       bfd_boolean is_tlsfunc = FALSE;
1001
1002       r_symndx = ELF32_R_SYM (rel->r_info);
1003       r_type = ELF32_R_TYPE (rel->r_info);
1004
1005       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1006         {
1007           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1008                                  abfd, r_symndx);
1009           return FALSE;
1010         }
1011
1012       if (r_symndx >= symtab_hdr->sh_info)
1013         {
1014           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1015           while (h->root.type == bfd_link_hash_indirect
1016                  || h->root.type == bfd_link_hash_warning)
1017             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1018
1019           /* PR15323, ref flags aren't set for references in the same
1020              object.  */
1021           h->root.non_ir_ref = 1;
1022         }
1023       eh = elf_xtensa_hash_entry (h);
1024
1025       switch (r_type)
1026         {
1027         case R_XTENSA_TLSDESC_FN:
1028           if (bfd_link_pic (info))
1029             {
1030               tls_type = GOT_TLS_GD;
1031               is_got = TRUE;
1032               is_tlsfunc = TRUE;
1033             }
1034           else
1035             tls_type = GOT_TLS_IE;
1036           break;
1037
1038         case R_XTENSA_TLSDESC_ARG:
1039           if (bfd_link_pic (info))
1040             {
1041               tls_type = GOT_TLS_GD;
1042               is_got = TRUE;
1043             }
1044           else
1045             {
1046               tls_type = GOT_TLS_IE;
1047               if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1048                 is_got = TRUE;
1049             }
1050           break;
1051
1052         case R_XTENSA_TLS_DTPOFF:
1053           if (bfd_link_pic (info))
1054             tls_type = GOT_TLS_GD;
1055           else
1056             tls_type = GOT_TLS_IE;
1057           break;
1058
1059         case R_XTENSA_TLS_TPOFF:
1060           tls_type = GOT_TLS_IE;
1061           if (bfd_link_pic (info))
1062             info->flags |= DF_STATIC_TLS;
1063           if (bfd_link_pic (info) || h)
1064             is_got = TRUE;
1065           break;
1066
1067         case R_XTENSA_32:
1068           tls_type = GOT_NORMAL;
1069           is_got = TRUE;
1070           break;
1071
1072         case R_XTENSA_PLT:
1073           tls_type = GOT_NORMAL;
1074           is_plt = TRUE;
1075           break;
1076
1077         case R_XTENSA_GNU_VTINHERIT:
1078           /* This relocation describes the C++ object vtable hierarchy.
1079              Reconstruct it for later use during GC.  */
1080           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1081             return FALSE;
1082           continue;
1083
1084         case R_XTENSA_GNU_VTENTRY:
1085           /* This relocation describes which C++ vtable entries are actually
1086              used.  Record for later use during GC.  */
1087           BFD_ASSERT (h != NULL);
1088           if (h != NULL
1089               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1090             return FALSE;
1091           continue;
1092
1093         default:
1094           /* Nothing to do for any other relocations.  */
1095           continue;
1096         }
1097
1098       if (h)
1099         {
1100           if (is_plt)
1101             {
1102               if (h->plt.refcount <= 0)
1103                 {
1104                   h->needs_plt = 1;
1105                   h->plt.refcount = 1;
1106                 }
1107               else
1108                 h->plt.refcount += 1;
1109
1110               /* Keep track of the total PLT relocation count even if we
1111                  don't yet know whether the dynamic sections will be
1112                  created.  */
1113               htab->plt_reloc_count += 1;
1114
1115               if (elf_hash_table (info)->dynamic_sections_created)
1116                 {
1117                   if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1118                     return FALSE;
1119                 }
1120             }
1121           else if (is_got)
1122             {
1123               if (h->got.refcount <= 0)
1124                 h->got.refcount = 1;
1125               else
1126                 h->got.refcount += 1;
1127             }
1128
1129           if (is_tlsfunc)
1130             eh->tlsfunc_refcount += 1;
1131
1132           old_tls_type = eh->tls_type;
1133         }
1134       else
1135         {
1136           /* Allocate storage the first time.  */
1137           if (elf_local_got_refcounts (abfd) == NULL)
1138             {
1139               bfd_size_type size = symtab_hdr->sh_info;
1140               void *mem;
1141
1142               mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1143               if (mem == NULL)
1144                 return FALSE;
1145               elf_local_got_refcounts (abfd) = (bfd_signed_vma *) mem;
1146
1147               mem = bfd_zalloc (abfd, size);
1148               if (mem == NULL)
1149                 return FALSE;
1150               elf_xtensa_local_got_tls_type (abfd) = (char *) mem;
1151
1152               mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1153               if (mem == NULL)
1154                 return FALSE;
1155               elf_xtensa_local_tlsfunc_refcounts (abfd)
1156                 = (bfd_signed_vma *) mem;
1157             }
1158
1159           /* This is a global offset table entry for a local symbol.  */
1160           if (is_got || is_plt)
1161             elf_local_got_refcounts (abfd) [r_symndx] += 1;
1162
1163           if (is_tlsfunc)
1164             elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx] += 1;
1165
1166           old_tls_type = elf_xtensa_local_got_tls_type (abfd) [r_symndx];
1167         }
1168
1169       if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1170         tls_type |= old_tls_type;
1171       /* If a TLS symbol is accessed using IE at least once,
1172          there is no point to use a dynamic model for it.  */
1173       else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1174                && ((old_tls_type & GOT_TLS_GD) == 0
1175                    || (tls_type & GOT_TLS_IE) == 0))
1176         {
1177           if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_GD))
1178             tls_type = old_tls_type;
1179           else if ((old_tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_GD))
1180             tls_type |= old_tls_type;
1181           else
1182             {
1183               (*_bfd_error_handler)
1184                 (_("%B: `%s' accessed both as normal and thread local symbol"),
1185                  abfd,
1186                  h ? h->root.root.string : "<local>");
1187               return FALSE;
1188             }
1189         }
1190
1191       if (old_tls_type != tls_type)
1192         {
1193           if (eh)
1194             eh->tls_type = tls_type;
1195           else
1196             elf_xtensa_local_got_tls_type (abfd) [r_symndx] = tls_type;
1197         }
1198     }
1199
1200   return TRUE;
1201 }
1202
1203
1204 static void
1205 elf_xtensa_make_sym_local (struct bfd_link_info *info,
1206                            struct elf_link_hash_entry *h)
1207 {
1208   if (bfd_link_pic (info))
1209     {
1210       if (h->plt.refcount > 0)
1211         {
1212           /* For shared objects, there's no need for PLT entries for local
1213              symbols (use RELATIVE relocs instead of JMP_SLOT relocs).  */
1214           if (h->got.refcount < 0)
1215             h->got.refcount = 0;
1216           h->got.refcount += h->plt.refcount;
1217           h->plt.refcount = 0;
1218         }
1219     }
1220   else
1221     {
1222       /* Don't need any dynamic relocations at all.  */
1223       h->plt.refcount = 0;
1224       h->got.refcount = 0;
1225     }
1226 }
1227
1228
1229 static void
1230 elf_xtensa_hide_symbol (struct bfd_link_info *info,
1231                         struct elf_link_hash_entry *h,
1232                         bfd_boolean force_local)
1233 {
1234   /* For a shared link, move the plt refcount to the got refcount to leave
1235      space for RELATIVE relocs.  */
1236   elf_xtensa_make_sym_local (info, h);
1237
1238   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
1239 }
1240
1241
1242 /* Return the section that should be marked against GC for a given
1243    relocation.  */
1244
1245 static asection *
1246 elf_xtensa_gc_mark_hook (asection *sec,
1247                          struct bfd_link_info *info,
1248                          Elf_Internal_Rela *rel,
1249                          struct elf_link_hash_entry *h,
1250                          Elf_Internal_Sym *sym)
1251 {
1252   /* Property sections are marked "KEEP" in the linker scripts, but they
1253      should not cause other sections to be marked.  (This approach relies
1254      on elf_xtensa_discard_info to remove property table entries that
1255      describe discarded sections.  Alternatively, it might be more
1256      efficient to avoid using "KEEP" in the linker scripts and instead use
1257      the gc_mark_extra_sections hook to mark only the property sections
1258      that describe marked sections.  That alternative does not work well
1259      with the current property table sections, which do not correspond
1260      one-to-one with the sections they describe, but that should be fixed
1261      someday.) */
1262   if (xtensa_is_property_section (sec))
1263     return NULL;
1264
1265   if (h != NULL)
1266     switch (ELF32_R_TYPE (rel->r_info))
1267       {
1268       case R_XTENSA_GNU_VTINHERIT:
1269       case R_XTENSA_GNU_VTENTRY:
1270         return NULL;
1271       }
1272
1273   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1274 }
1275
1276
1277 /* Update the GOT & PLT entry reference counts
1278    for the section being removed.  */
1279
1280 static bfd_boolean
1281 elf_xtensa_gc_sweep_hook (bfd *abfd,
1282                           struct bfd_link_info *info,
1283                           asection *sec,
1284                           const Elf_Internal_Rela *relocs)
1285 {
1286   Elf_Internal_Shdr *symtab_hdr;
1287   struct elf_link_hash_entry **sym_hashes;
1288   const Elf_Internal_Rela *rel, *relend;
1289   struct elf_xtensa_link_hash_table *htab;
1290
1291   htab = elf_xtensa_hash_table (info);
1292   if (htab == NULL)
1293     return FALSE;
1294
1295   if (bfd_link_relocatable (info))
1296     return TRUE;
1297
1298   if ((sec->flags & SEC_ALLOC) == 0)
1299     return TRUE;
1300
1301   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1302   sym_hashes = elf_sym_hashes (abfd);
1303
1304   relend = relocs + sec->reloc_count;
1305   for (rel = relocs; rel < relend; rel++)
1306     {
1307       unsigned long r_symndx;
1308       unsigned int r_type;
1309       struct elf_link_hash_entry *h = NULL;
1310       struct elf_xtensa_link_hash_entry *eh;
1311       bfd_boolean is_got = FALSE;
1312       bfd_boolean is_plt = FALSE;
1313       bfd_boolean is_tlsfunc = FALSE;
1314
1315       r_symndx = ELF32_R_SYM (rel->r_info);
1316       if (r_symndx >= symtab_hdr->sh_info)
1317         {
1318           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1319           while (h->root.type == bfd_link_hash_indirect
1320                  || h->root.type == bfd_link_hash_warning)
1321             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1322         }
1323       eh = elf_xtensa_hash_entry (h);
1324
1325       r_type = ELF32_R_TYPE (rel->r_info);
1326       switch (r_type)
1327         {
1328         case R_XTENSA_TLSDESC_FN:
1329           if (bfd_link_pic (info))
1330             {
1331               is_got = TRUE;
1332               is_tlsfunc = TRUE;
1333             }
1334           break;
1335
1336         case R_XTENSA_TLSDESC_ARG:
1337           if (bfd_link_pic (info))
1338             is_got = TRUE;
1339           else
1340             {
1341               if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1342                 is_got = TRUE;
1343             }
1344           break;
1345
1346         case R_XTENSA_TLS_TPOFF:
1347           if (bfd_link_pic (info) || h)
1348             is_got = TRUE;
1349           break;
1350
1351         case R_XTENSA_32:
1352           is_got = TRUE;
1353           break;
1354
1355         case R_XTENSA_PLT:
1356           is_plt = TRUE;
1357           break;
1358
1359         default:
1360           continue;
1361         }
1362
1363       if (h)
1364         {
1365           if (is_plt)
1366             {
1367               /* If the symbol has been localized its plt.refcount got moved
1368                  to got.refcount.  Handle it as GOT.  */
1369               if (h->plt.refcount > 0)
1370                 h->plt.refcount--;
1371               else
1372                 is_got = TRUE;
1373             }
1374           if (is_got)
1375             {
1376               if (h->got.refcount > 0)
1377                 h->got.refcount--;
1378             }
1379           if (is_tlsfunc)
1380             {
1381               if (eh->tlsfunc_refcount > 0)
1382                 eh->tlsfunc_refcount--;
1383             }
1384         }
1385       else
1386         {
1387           if (is_got || is_plt)
1388             {
1389               bfd_signed_vma *got_refcount
1390                 = &elf_local_got_refcounts (abfd) [r_symndx];
1391               if (*got_refcount > 0)
1392                 *got_refcount -= 1;
1393             }
1394           if (is_tlsfunc)
1395             {
1396               bfd_signed_vma *tlsfunc_refcount
1397                 = &elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx];
1398               if (*tlsfunc_refcount > 0)
1399                 *tlsfunc_refcount -= 1;
1400             }
1401         }
1402     }
1403
1404   return TRUE;
1405 }
1406
1407
1408 /* Create all the dynamic sections.  */
1409
1410 static bfd_boolean
1411 elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1412 {
1413   struct elf_xtensa_link_hash_table *htab;
1414   flagword flags, noalloc_flags;
1415
1416   htab = elf_xtensa_hash_table (info);
1417   if (htab == NULL)
1418     return FALSE;
1419
1420   /* First do all the standard stuff.  */
1421   if (! _bfd_elf_create_dynamic_sections (dynobj, info))
1422     return FALSE;
1423   htab->splt = bfd_get_linker_section (dynobj, ".plt");
1424   htab->srelplt = bfd_get_linker_section (dynobj, ".rela.plt");
1425   htab->sgot = bfd_get_linker_section (dynobj, ".got");
1426   htab->sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
1427   htab->srelgot = bfd_get_linker_section (dynobj, ".rela.got");
1428
1429   /* Create any extra PLT sections in case check_relocs has already
1430      been called on all the non-dynamic input files.  */
1431   if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1432     return FALSE;
1433
1434   noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
1435                    | SEC_LINKER_CREATED | SEC_READONLY);
1436   flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
1437
1438   /* Mark the ".got.plt" section READONLY.  */
1439   if (htab->sgotplt == NULL
1440       || ! bfd_set_section_flags (dynobj, htab->sgotplt, flags))
1441     return FALSE;
1442
1443   /* Create ".got.loc" (literal tables for use by dynamic linker).  */
1444   htab->sgotloc = bfd_make_section_anyway_with_flags (dynobj, ".got.loc",
1445                                                       flags);
1446   if (htab->sgotloc == NULL
1447       || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2))
1448     return FALSE;
1449
1450   /* Create ".xt.lit.plt" (literal table for ".got.plt*").  */
1451   htab->spltlittbl = bfd_make_section_anyway_with_flags (dynobj, ".xt.lit.plt",
1452                                                          noalloc_flags);
1453   if (htab->spltlittbl == NULL
1454       || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2))
1455     return FALSE;
1456
1457   return TRUE;
1458 }
1459
1460
1461 static bfd_boolean
1462 add_extra_plt_sections (struct bfd_link_info *info, int count)
1463 {
1464   bfd *dynobj = elf_hash_table (info)->dynobj;
1465   int chunk;
1466
1467   /* Iterate over all chunks except 0 which uses the standard ".plt" and
1468      ".got.plt" sections.  */
1469   for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
1470     {
1471       char *sname;
1472       flagword flags;
1473       asection *s;
1474
1475       /* Stop when we find a section has already been created.  */
1476       if (elf_xtensa_get_plt_section (info, chunk))
1477         break;
1478
1479       flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1480                | SEC_LINKER_CREATED | SEC_READONLY);
1481
1482       sname = (char *) bfd_malloc (10);
1483       sprintf (sname, ".plt.%u", chunk);
1484       s = bfd_make_section_anyway_with_flags (dynobj, sname, flags | SEC_CODE);
1485       if (s == NULL
1486           || ! bfd_set_section_alignment (dynobj, s, 2))
1487         return FALSE;
1488
1489       sname = (char *) bfd_malloc (14);
1490       sprintf (sname, ".got.plt.%u", chunk);
1491       s = bfd_make_section_anyway_with_flags (dynobj, sname, flags);
1492       if (s == NULL
1493           || ! bfd_set_section_alignment (dynobj, s, 2))
1494         return FALSE;
1495     }
1496
1497   return TRUE;
1498 }
1499
1500
1501 /* Adjust a symbol defined by a dynamic object and referenced by a
1502    regular object.  The current definition is in some section of the
1503    dynamic object, but we're not including those sections.  We have to
1504    change the definition to something the rest of the link can
1505    understand.  */
1506
1507 static bfd_boolean
1508 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1509                                   struct elf_link_hash_entry *h)
1510 {
1511   /* If this is a weak symbol, and there is a real definition, the
1512      processor independent code will have arranged for us to see the
1513      real definition first, and we can just use the same value.  */
1514   if (h->u.weakdef)
1515     {
1516       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1517                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1518       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1519       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1520       return TRUE;
1521     }
1522
1523   /* This is a reference to a symbol defined by a dynamic object.  The
1524      reference must go through the GOT, so there's no need for COPY relocs,
1525      .dynbss, etc.  */
1526
1527   return TRUE;
1528 }
1529
1530
1531 static bfd_boolean
1532 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry *h, void *arg)
1533 {
1534   struct bfd_link_info *info;
1535   struct elf_xtensa_link_hash_table *htab;
1536   struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (h);
1537
1538   if (h->root.type == bfd_link_hash_indirect)
1539     return TRUE;
1540
1541   info = (struct bfd_link_info *) arg;
1542   htab = elf_xtensa_hash_table (info);
1543   if (htab == NULL)
1544     return FALSE;
1545
1546   /* If we saw any use of an IE model for this symbol, we can then optimize
1547      away GOT entries for any TLSDESC_FN relocs.  */
1548   if ((eh->tls_type & GOT_TLS_IE) != 0)
1549     {
1550       BFD_ASSERT (h->got.refcount >= eh->tlsfunc_refcount);
1551       h->got.refcount -= eh->tlsfunc_refcount;
1552     }
1553
1554   if (! elf_xtensa_dynamic_symbol_p (h, info))
1555     elf_xtensa_make_sym_local (info, h);
1556
1557   if (h->plt.refcount > 0)
1558     htab->srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1559
1560   if (h->got.refcount > 0)
1561     htab->srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
1562
1563   return TRUE;
1564 }
1565
1566
1567 static void
1568 elf_xtensa_allocate_local_got_size (struct bfd_link_info *info)
1569 {
1570   struct elf_xtensa_link_hash_table *htab;
1571   bfd *i;
1572
1573   htab = elf_xtensa_hash_table (info);
1574   if (htab == NULL)
1575     return;
1576
1577   for (i = info->input_bfds; i; i = i->link.next)
1578     {
1579       bfd_signed_vma *local_got_refcounts;
1580       bfd_size_type j, cnt;
1581       Elf_Internal_Shdr *symtab_hdr;
1582
1583       local_got_refcounts = elf_local_got_refcounts (i);
1584       if (!local_got_refcounts)
1585         continue;
1586
1587       symtab_hdr = &elf_tdata (i)->symtab_hdr;
1588       cnt = symtab_hdr->sh_info;
1589
1590       for (j = 0; j < cnt; ++j)
1591         {
1592           /* If we saw any use of an IE model for this symbol, we can
1593              then optimize away GOT entries for any TLSDESC_FN relocs.  */
1594           if ((elf_xtensa_local_got_tls_type (i) [j] & GOT_TLS_IE) != 0)
1595             {
1596               bfd_signed_vma *tlsfunc_refcount
1597                 = &elf_xtensa_local_tlsfunc_refcounts (i) [j];
1598               BFD_ASSERT (local_got_refcounts[j] >= *tlsfunc_refcount);
1599               local_got_refcounts[j] -= *tlsfunc_refcount;
1600             }
1601
1602           if (local_got_refcounts[j] > 0)
1603             htab->srelgot->size += (local_got_refcounts[j]
1604                                     * sizeof (Elf32_External_Rela));
1605         }
1606     }
1607 }
1608
1609
1610 /* Set the sizes of the dynamic sections.  */
1611
1612 static bfd_boolean
1613 elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1614                                   struct bfd_link_info *info)
1615 {
1616   struct elf_xtensa_link_hash_table *htab;
1617   bfd *dynobj, *abfd;
1618   asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
1619   bfd_boolean relplt, relgot;
1620   int plt_entries, plt_chunks, chunk;
1621
1622   plt_entries = 0;
1623   plt_chunks = 0;
1624
1625   htab = elf_xtensa_hash_table (info);
1626   if (htab == NULL)
1627     return FALSE;
1628
1629   dynobj = elf_hash_table (info)->dynobj;
1630   if (dynobj == NULL)
1631     abort ();
1632   srelgot = htab->srelgot;
1633   srelplt = htab->srelplt;
1634
1635   if (elf_hash_table (info)->dynamic_sections_created)
1636     {
1637       BFD_ASSERT (htab->srelgot != NULL
1638                   && htab->srelplt != NULL
1639                   && htab->sgot != NULL
1640                   && htab->spltlittbl != NULL
1641                   && htab->sgotloc != NULL);
1642
1643       /* Set the contents of the .interp section to the interpreter.  */
1644       if (bfd_link_executable (info) && !info->nointerp)
1645         {
1646           s = bfd_get_linker_section (dynobj, ".interp");
1647           if (s == NULL)
1648             abort ();
1649           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1650           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1651         }
1652
1653       /* Allocate room for one word in ".got".  */
1654       htab->sgot->size = 4;
1655
1656       /* Allocate space in ".rela.got" for literals that reference global
1657          symbols and space in ".rela.plt" for literals that have PLT
1658          entries.  */
1659       elf_link_hash_traverse (elf_hash_table (info),
1660                               elf_xtensa_allocate_dynrelocs,
1661                               (void *) info);
1662
1663       /* If we are generating a shared object, we also need space in
1664          ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1665          reference local symbols.  */
1666       if (bfd_link_pic (info))
1667         elf_xtensa_allocate_local_got_size (info);
1668
1669       /* Allocate space in ".plt" to match the size of ".rela.plt".  For
1670          each PLT entry, we need the PLT code plus a 4-byte literal.
1671          For each chunk of ".plt", we also need two more 4-byte
1672          literals, two corresponding entries in ".rela.got", and an
1673          8-byte entry in ".xt.lit.plt".  */
1674       spltlittbl = htab->spltlittbl;
1675       plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
1676       plt_chunks =
1677         (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1678
1679       /* Iterate over all the PLT chunks, including any extra sections
1680          created earlier because the initial count of PLT relocations
1681          was an overestimate.  */
1682       for (chunk = 0;
1683            (splt = elf_xtensa_get_plt_section (info, chunk)) != NULL;
1684            chunk++)
1685         {
1686           int chunk_entries;
1687
1688           sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
1689           BFD_ASSERT (sgotplt != NULL);
1690
1691           if (chunk < plt_chunks - 1)
1692             chunk_entries = PLT_ENTRIES_PER_CHUNK;
1693           else if (chunk == plt_chunks - 1)
1694             chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1695           else
1696             chunk_entries = 0;
1697
1698           if (chunk_entries != 0)
1699             {
1700               sgotplt->size = 4 * (chunk_entries + 2);
1701               splt->size = PLT_ENTRY_SIZE * chunk_entries;
1702               srelgot->size += 2 * sizeof (Elf32_External_Rela);
1703               spltlittbl->size += 8;
1704             }
1705           else
1706             {
1707               sgotplt->size = 0;
1708               splt->size = 0;
1709             }
1710         }
1711
1712       /* Allocate space in ".got.loc" to match the total size of all the
1713          literal tables.  */
1714       sgotloc = htab->sgotloc;
1715       sgotloc->size = spltlittbl->size;
1716       for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
1717         {
1718           if (abfd->flags & DYNAMIC)
1719             continue;
1720           for (s = abfd->sections; s != NULL; s = s->next)
1721             {
1722               if (! discarded_section (s)
1723                   && xtensa_is_littable_section (s)
1724                   && s != spltlittbl)
1725                 sgotloc->size += s->size;
1726             }
1727         }
1728     }
1729
1730   /* Allocate memory for dynamic sections.  */
1731   relplt = FALSE;
1732   relgot = FALSE;
1733   for (s = dynobj->sections; s != NULL; s = s->next)
1734     {
1735       const char *name;
1736
1737       if ((s->flags & SEC_LINKER_CREATED) == 0)
1738         continue;
1739
1740       /* It's OK to base decisions on the section name, because none
1741          of the dynobj section names depend upon the input files.  */
1742       name = bfd_get_section_name (dynobj, s);
1743
1744       if (CONST_STRNEQ (name, ".rela"))
1745         {
1746           if (s->size != 0)
1747             {
1748               if (strcmp (name, ".rela.plt") == 0)
1749                 relplt = TRUE;
1750               else if (strcmp (name, ".rela.got") == 0)
1751                 relgot = TRUE;
1752
1753               /* We use the reloc_count field as a counter if we need
1754                  to copy relocs into the output file.  */
1755               s->reloc_count = 0;
1756             }
1757         }
1758       else if (! CONST_STRNEQ (name, ".plt.")
1759                && ! CONST_STRNEQ (name, ".got.plt.")
1760                && strcmp (name, ".got") != 0
1761                && strcmp (name, ".plt") != 0
1762                && strcmp (name, ".got.plt") != 0
1763                && strcmp (name, ".xt.lit.plt") != 0
1764                && strcmp (name, ".got.loc") != 0)
1765         {
1766           /* It's not one of our sections, so don't allocate space.  */
1767           continue;
1768         }
1769
1770       if (s->size == 0)
1771         {
1772           /* If we don't need this section, strip it from the output
1773              file.  We must create the ".plt*" and ".got.plt*"
1774              sections in create_dynamic_sections and/or check_relocs
1775              based on a conservative estimate of the PLT relocation
1776              count, because the sections must be created before the
1777              linker maps input sections to output sections.  The
1778              linker does that before size_dynamic_sections, where we
1779              compute the exact size of the PLT, so there may be more
1780              of these sections than are actually needed.  */
1781           s->flags |= SEC_EXCLUDE;
1782         }
1783       else if ((s->flags & SEC_HAS_CONTENTS) != 0)
1784         {
1785           /* Allocate memory for the section contents.  */
1786           s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1787           if (s->contents == NULL)
1788             return FALSE;
1789         }
1790     }
1791
1792   if (elf_hash_table (info)->dynamic_sections_created)
1793     {
1794       /* Add the special XTENSA_RTLD relocations now.  The offsets won't be
1795          known until finish_dynamic_sections, but we need to get the relocs
1796          in place before they are sorted.  */
1797       for (chunk = 0; chunk < plt_chunks; chunk++)
1798         {
1799           Elf_Internal_Rela irela;
1800           bfd_byte *loc;
1801
1802           irela.r_offset = 0;
1803           irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1804           irela.r_addend = 0;
1805
1806           loc = (srelgot->contents
1807                  + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1808           bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1809           bfd_elf32_swap_reloca_out (output_bfd, &irela,
1810                                      loc + sizeof (Elf32_External_Rela));
1811           srelgot->reloc_count += 2;
1812         }
1813
1814       /* Add some entries to the .dynamic section.  We fill in the
1815          values later, in elf_xtensa_finish_dynamic_sections, but we
1816          must add the entries now so that we get the correct size for
1817          the .dynamic section.  The DT_DEBUG entry is filled in by the
1818          dynamic linker and used by the debugger.  */
1819 #define add_dynamic_entry(TAG, VAL) \
1820   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1821
1822       if (bfd_link_executable (info))
1823         {
1824           if (!add_dynamic_entry (DT_DEBUG, 0))
1825             return FALSE;
1826         }
1827
1828       if (relplt)
1829         {
1830           if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1831               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1832               || !add_dynamic_entry (DT_JMPREL, 0))
1833             return FALSE;
1834         }
1835
1836       if (relgot)
1837         {
1838           if (!add_dynamic_entry (DT_RELA, 0)
1839               || !add_dynamic_entry (DT_RELASZ, 0)
1840               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1841             return FALSE;
1842         }
1843
1844       if (!add_dynamic_entry (DT_PLTGOT, 0)
1845           || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1846           || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1847         return FALSE;
1848     }
1849 #undef add_dynamic_entry
1850
1851   return TRUE;
1852 }
1853
1854 static bfd_boolean
1855 elf_xtensa_always_size_sections (bfd *output_bfd,
1856                                  struct bfd_link_info *info)
1857 {
1858   struct elf_xtensa_link_hash_table *htab;
1859   asection *tls_sec;
1860
1861   htab = elf_xtensa_hash_table (info);
1862   if (htab == NULL)
1863     return FALSE;
1864
1865   tls_sec = htab->elf.tls_sec;
1866
1867   if (tls_sec && (htab->tlsbase->tls_type & GOT_TLS_ANY) != 0)
1868     {
1869       struct elf_link_hash_entry *tlsbase = &htab->tlsbase->elf;
1870       struct bfd_link_hash_entry *bh = &tlsbase->root;
1871       const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
1872
1873       tlsbase->type = STT_TLS;
1874       if (!(_bfd_generic_link_add_one_symbol
1875             (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1876              tls_sec, 0, NULL, FALSE,
1877              bed->collect, &bh)))
1878         return FALSE;
1879       tlsbase->def_regular = 1;
1880       tlsbase->other = STV_HIDDEN;
1881       (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1882     }
1883
1884   return TRUE;
1885 }
1886
1887 \f
1888 /* Return the base VMA address which should be subtracted from real addresses
1889    when resolving @dtpoff relocation.
1890    This is PT_TLS segment p_vaddr.  */
1891
1892 static bfd_vma
1893 dtpoff_base (struct bfd_link_info *info)
1894 {
1895   /* If tls_sec is NULL, we should have signalled an error already.  */
1896   if (elf_hash_table (info)->tls_sec == NULL)
1897     return 0;
1898   return elf_hash_table (info)->tls_sec->vma;
1899 }
1900
1901 /* Return the relocation value for @tpoff relocation
1902    if STT_TLS virtual address is ADDRESS.  */
1903
1904 static bfd_vma
1905 tpoff (struct bfd_link_info *info, bfd_vma address)
1906 {
1907   struct elf_link_hash_table *htab = elf_hash_table (info);
1908   bfd_vma base;
1909
1910   /* If tls_sec is NULL, we should have signalled an error already.  */
1911   if (htab->tls_sec == NULL)
1912     return 0;
1913   base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
1914   return address - htab->tls_sec->vma + base;
1915 }
1916
1917 /* Perform the specified relocation.  The instruction at (contents + address)
1918    is modified to set one operand to represent the value in "relocation".  The
1919    operand position is determined by the relocation type recorded in the
1920    howto.  */
1921
1922 #define CALL_SEGMENT_BITS (30)
1923 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1924
1925 static bfd_reloc_status_type
1926 elf_xtensa_do_reloc (reloc_howto_type *howto,
1927                      bfd *abfd,
1928                      asection *input_section,
1929                      bfd_vma relocation,
1930                      bfd_byte *contents,
1931                      bfd_vma address,
1932                      bfd_boolean is_weak_undef,
1933                      char **error_message)
1934 {
1935   xtensa_format fmt;
1936   xtensa_opcode opcode;
1937   xtensa_isa isa = xtensa_default_isa;
1938   static xtensa_insnbuf ibuff = NULL;
1939   static xtensa_insnbuf sbuff = NULL;
1940   bfd_vma self_address;
1941   bfd_size_type input_size;
1942   int opnd, slot;
1943   uint32 newval;
1944
1945   if (!ibuff)
1946     {
1947       ibuff = xtensa_insnbuf_alloc (isa);
1948       sbuff = xtensa_insnbuf_alloc (isa);
1949     }
1950
1951   input_size = bfd_get_section_limit (abfd, input_section);
1952
1953   /* Calculate the PC address for this instruction.  */
1954   self_address = (input_section->output_section->vma
1955                   + input_section->output_offset
1956                   + address);
1957
1958   switch (howto->type)
1959     {
1960     case R_XTENSA_NONE:
1961     case R_XTENSA_DIFF8:
1962     case R_XTENSA_DIFF16:
1963     case R_XTENSA_DIFF32:
1964     case R_XTENSA_TLS_FUNC:
1965     case R_XTENSA_TLS_ARG:
1966     case R_XTENSA_TLS_CALL:
1967       return bfd_reloc_ok;
1968
1969     case R_XTENSA_ASM_EXPAND:
1970       if (!is_weak_undef)
1971         {
1972           /* Check for windowed CALL across a 1GB boundary.  */
1973           opcode = get_expanded_call_opcode (contents + address,
1974                                              input_size - address, 0);
1975           if (is_windowed_call_opcode (opcode))
1976             {
1977               if ((self_address >> CALL_SEGMENT_BITS)
1978                   != (relocation >> CALL_SEGMENT_BITS))
1979                 {
1980                   *error_message = "windowed longcall crosses 1GB boundary; "
1981                     "return may fail";
1982                   return bfd_reloc_dangerous;
1983                 }
1984             }
1985         }
1986       return bfd_reloc_ok;
1987
1988     case R_XTENSA_ASM_SIMPLIFY:
1989       {
1990         /* Convert the L32R/CALLX to CALL.  */
1991         bfd_reloc_status_type retval =
1992           elf_xtensa_do_asm_simplify (contents, address, input_size,
1993                                       error_message);
1994         if (retval != bfd_reloc_ok)
1995           return bfd_reloc_dangerous;
1996
1997         /* The CALL needs to be relocated.  Continue below for that part.  */
1998         address += 3;
1999         self_address += 3;
2000         howto = &elf_howto_table[(unsigned) R_XTENSA_SLOT0_OP ];
2001       }
2002       break;
2003
2004     case R_XTENSA_32:
2005       {
2006         bfd_vma x;
2007         x = bfd_get_32 (abfd, contents + address);
2008         x = x + relocation;
2009         bfd_put_32 (abfd, x, contents + address);
2010       }
2011       return bfd_reloc_ok;
2012
2013     case R_XTENSA_32_PCREL:
2014       bfd_put_32 (abfd, relocation - self_address, contents + address);
2015       return bfd_reloc_ok;
2016
2017     case R_XTENSA_PLT:
2018     case R_XTENSA_TLSDESC_FN:
2019     case R_XTENSA_TLSDESC_ARG:
2020     case R_XTENSA_TLS_DTPOFF:
2021     case R_XTENSA_TLS_TPOFF:
2022       bfd_put_32 (abfd, relocation, contents + address);
2023       return bfd_reloc_ok;
2024     }
2025
2026   /* Only instruction slot-specific relocations handled below.... */
2027   slot = get_relocation_slot (howto->type);
2028   if (slot == XTENSA_UNDEFINED)
2029     {
2030       *error_message = "unexpected relocation";
2031       return bfd_reloc_dangerous;
2032     }
2033
2034   /* Read the instruction into a buffer and decode the opcode.  */
2035   xtensa_insnbuf_from_chars (isa, ibuff, contents + address,
2036                              input_size - address);
2037   fmt = xtensa_format_decode (isa, ibuff);
2038   if (fmt == XTENSA_UNDEFINED)
2039     {
2040       *error_message = "cannot decode instruction format";
2041       return bfd_reloc_dangerous;
2042     }
2043
2044   xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
2045
2046   opcode = xtensa_opcode_decode (isa, fmt, slot, sbuff);
2047   if (opcode == XTENSA_UNDEFINED)
2048     {
2049       *error_message = "cannot decode instruction opcode";
2050       return bfd_reloc_dangerous;
2051     }
2052
2053   /* Check for opcode-specific "alternate" relocations.  */
2054   if (is_alt_relocation (howto->type))
2055     {
2056       if (opcode == get_l32r_opcode ())
2057         {
2058           /* Handle the special-case of non-PC-relative L32R instructions.  */
2059           bfd *output_bfd = input_section->output_section->owner;
2060           asection *lit4_sec = bfd_get_section_by_name (output_bfd, ".lit4");
2061           if (!lit4_sec)
2062             {
2063               *error_message = "relocation references missing .lit4 section";
2064               return bfd_reloc_dangerous;
2065             }
2066           self_address = ((lit4_sec->vma & ~0xfff)
2067                           + 0x40000 - 3); /* -3 to compensate for do_reloc */
2068           newval = relocation;
2069           opnd = 1;
2070         }
2071       else if (opcode == get_const16_opcode ())
2072         {
2073           /* ALT used for high 16 bits.  */
2074           newval = relocation >> 16;
2075           opnd = 1;
2076         }
2077       else
2078         {
2079           /* No other "alternate" relocations currently defined.  */
2080           *error_message = "unexpected relocation";
2081           return bfd_reloc_dangerous;
2082         }
2083     }
2084   else /* Not an "alternate" relocation.... */
2085     {
2086       if (opcode == get_const16_opcode ())
2087         {
2088           newval = relocation & 0xffff;
2089           opnd = 1;
2090         }
2091       else
2092         {
2093           /* ...normal PC-relative relocation.... */
2094
2095           /* Determine which operand is being relocated.  */
2096           opnd = get_relocation_opnd (opcode, howto->type);
2097           if (opnd == XTENSA_UNDEFINED)
2098             {
2099               *error_message = "unexpected relocation";
2100               return bfd_reloc_dangerous;
2101             }
2102
2103           if (!howto->pc_relative)
2104             {
2105               *error_message = "expected PC-relative relocation";
2106               return bfd_reloc_dangerous;
2107             }
2108
2109           newval = relocation;
2110         }
2111     }
2112
2113   /* Apply the relocation.  */
2114   if (xtensa_operand_do_reloc (isa, opcode, opnd, &newval, self_address)
2115       || xtensa_operand_encode (isa, opcode, opnd, &newval)
2116       || xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
2117                                    sbuff, newval))
2118     {
2119       const char *opname = xtensa_opcode_name (isa, opcode);
2120       const char *msg;
2121
2122       msg = "cannot encode";
2123       if (is_direct_call_opcode (opcode))
2124         {
2125           if ((relocation & 0x3) != 0)
2126             msg = "misaligned call target";
2127           else
2128             msg = "call target out of range";
2129         }
2130       else if (opcode == get_l32r_opcode ())
2131         {
2132           if ((relocation & 0x3) != 0)
2133             msg = "misaligned literal target";
2134           else if (is_alt_relocation (howto->type))
2135             msg = "literal target out of range (too many literals)";
2136           else if (self_address > relocation)
2137             msg = "literal target out of range (try using text-section-literals)";
2138           else
2139             msg = "literal placed after use";
2140         }
2141
2142       *error_message = vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
2143       return bfd_reloc_dangerous;
2144     }
2145
2146   /* Check for calls across 1GB boundaries.  */
2147   if (is_direct_call_opcode (opcode)
2148       && is_windowed_call_opcode (opcode))
2149     {
2150       if ((self_address >> CALL_SEGMENT_BITS)
2151           != (relocation >> CALL_SEGMENT_BITS))
2152         {
2153           *error_message =
2154             "windowed call crosses 1GB boundary; return may fail";
2155           return bfd_reloc_dangerous;
2156         }
2157     }
2158
2159   /* Write the modified instruction back out of the buffer.  */
2160   xtensa_format_set_slot (isa, fmt, slot, ibuff, sbuff);
2161   xtensa_insnbuf_to_chars (isa, ibuff, contents + address,
2162                            input_size - address);
2163   return bfd_reloc_ok;
2164 }
2165
2166
2167 static char *
2168 vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
2169 {
2170   /* To reduce the size of the memory leak,
2171      we only use a single message buffer.  */
2172   static bfd_size_type alloc_size = 0;
2173   static char *message = NULL;
2174   bfd_size_type orig_len, len = 0;
2175   bfd_boolean is_append;
2176   va_list ap;
2177
2178   va_start (ap, arglen);
2179
2180   is_append = (origmsg == message);
2181
2182   orig_len = strlen (origmsg);
2183   len = orig_len + strlen (fmt) + arglen + 20;
2184   if (len > alloc_size)
2185     {
2186       message = (char *) bfd_realloc_or_free (message, len);
2187       alloc_size = len;
2188     }
2189   if (message != NULL)
2190     {
2191       if (!is_append)
2192         memcpy (message, origmsg, orig_len);
2193       vsprintf (message + orig_len, fmt, ap);
2194     }
2195   va_end (ap);
2196   return message;
2197 }
2198
2199
2200 /* This function is registered as the "special_function" in the
2201    Xtensa howto for handling simplify operations.
2202    bfd_perform_relocation / bfd_install_relocation use it to
2203    perform (install) the specified relocation.  Since this replaces the code
2204    in bfd_perform_relocation, it is basically an Xtensa-specific,
2205    stripped-down version of bfd_perform_relocation.  */
2206
2207 static bfd_reloc_status_type
2208 bfd_elf_xtensa_reloc (bfd *abfd,
2209                       arelent *reloc_entry,
2210                       asymbol *symbol,
2211                       void *data,
2212                       asection *input_section,
2213                       bfd *output_bfd,
2214                       char **error_message)
2215 {
2216   bfd_vma relocation;
2217   bfd_reloc_status_type flag;
2218   bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2219   bfd_vma output_base = 0;
2220   reloc_howto_type *howto = reloc_entry->howto;
2221   asection *reloc_target_output_section;
2222   bfd_boolean is_weak_undef;
2223
2224   if (!xtensa_default_isa)
2225     xtensa_default_isa = xtensa_isa_init (0, 0);
2226
2227   /* ELF relocs are against symbols.  If we are producing relocatable
2228      output, and the reloc is against an external symbol, the resulting
2229      reloc will also be against the same symbol.  In such a case, we
2230      don't want to change anything about the way the reloc is handled,
2231      since it will all be done at final link time.  This test is similar
2232      to what bfd_elf_generic_reloc does except that it lets relocs with
2233      howto->partial_inplace go through even if the addend is non-zero.
2234      (The real problem is that partial_inplace is set for XTENSA_32
2235      relocs to begin with, but that's a long story and there's little we
2236      can do about it now....)  */
2237
2238   if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
2239     {
2240       reloc_entry->address += input_section->output_offset;
2241       return bfd_reloc_ok;
2242     }
2243
2244   /* Is the address of the relocation really within the section?  */
2245   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2246     return bfd_reloc_outofrange;
2247
2248   /* Work out which section the relocation is targeted at and the
2249      initial relocation command value.  */
2250
2251   /* Get symbol value.  (Common symbols are special.)  */
2252   if (bfd_is_com_section (symbol->section))
2253     relocation = 0;
2254   else
2255     relocation = symbol->value;
2256
2257   reloc_target_output_section = symbol->section->output_section;
2258
2259   /* Convert input-section-relative symbol value to absolute.  */
2260   if ((output_bfd && !howto->partial_inplace)
2261       || reloc_target_output_section == NULL)
2262     output_base = 0;
2263   else
2264     output_base = reloc_target_output_section->vma;
2265
2266   relocation += output_base + symbol->section->output_offset;
2267
2268   /* Add in supplied addend.  */
2269   relocation += reloc_entry->addend;
2270
2271   /* Here the variable relocation holds the final address of the
2272      symbol we are relocating against, plus any addend.  */
2273   if (output_bfd)
2274     {
2275       if (!howto->partial_inplace)
2276         {
2277           /* This is a partial relocation, and we want to apply the relocation
2278              to the reloc entry rather than the raw data.  Everything except
2279              relocations against section symbols has already been handled
2280              above.  */
2281
2282           BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
2283           reloc_entry->addend = relocation;
2284           reloc_entry->address += input_section->output_offset;
2285           return bfd_reloc_ok;
2286         }
2287       else
2288         {
2289           reloc_entry->address += input_section->output_offset;
2290           reloc_entry->addend = 0;
2291         }
2292     }
2293
2294   is_weak_undef = (bfd_is_und_section (symbol->section)
2295                    && (symbol->flags & BSF_WEAK) != 0);
2296   flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
2297                               (bfd_byte *) data, (bfd_vma) octets,
2298                               is_weak_undef, error_message);
2299
2300   if (flag == bfd_reloc_dangerous)
2301     {
2302       /* Add the symbol name to the error message.  */
2303       if (! *error_message)
2304         *error_message = "";
2305       *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
2306                                     strlen (symbol->name) + 17,
2307                                     symbol->name,
2308                                     (unsigned long) reloc_entry->addend);
2309     }
2310
2311   return flag;
2312 }
2313
2314
2315 /* Set up an entry in the procedure linkage table.  */
2316
2317 static bfd_vma
2318 elf_xtensa_create_plt_entry (struct bfd_link_info *info,
2319                              bfd *output_bfd,
2320                              unsigned reloc_index)
2321 {
2322   asection *splt, *sgotplt;
2323   bfd_vma plt_base, got_base;
2324   bfd_vma code_offset, lit_offset, abi_offset;
2325   int chunk;
2326
2327   chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
2328   splt = elf_xtensa_get_plt_section (info, chunk);
2329   sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
2330   BFD_ASSERT (splt != NULL && sgotplt != NULL);
2331
2332   plt_base = splt->output_section->vma + splt->output_offset;
2333   got_base = sgotplt->output_section->vma + sgotplt->output_offset;
2334
2335   lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
2336   code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
2337
2338   /* Fill in the literal entry.  This is the offset of the dynamic
2339      relocation entry.  */
2340   bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
2341               sgotplt->contents + lit_offset);
2342
2343   /* Fill in the entry in the procedure linkage table.  */
2344   memcpy (splt->contents + code_offset,
2345           (bfd_big_endian (output_bfd)
2346            ? elf_xtensa_be_plt_entry
2347            : elf_xtensa_le_plt_entry),
2348           PLT_ENTRY_SIZE);
2349   abi_offset = XSHAL_ABI == XTHAL_ABI_WINDOWED ? 3 : 0;
2350   bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
2351                                        plt_base + code_offset + abi_offset),
2352               splt->contents + code_offset + abi_offset + 1);
2353   bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
2354                                        plt_base + code_offset + abi_offset + 3),
2355               splt->contents + code_offset + abi_offset + 4);
2356   bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
2357                                        plt_base + code_offset + abi_offset + 6),
2358               splt->contents + code_offset + abi_offset + 7);
2359
2360   return plt_base + code_offset;
2361 }
2362
2363
2364 static bfd_boolean get_indirect_call_dest_reg (xtensa_opcode, unsigned *);
2365
2366 static bfd_boolean
2367 replace_tls_insn (Elf_Internal_Rela *rel,
2368                   bfd *abfd,
2369                   asection *input_section,
2370                   bfd_byte *contents,
2371                   bfd_boolean is_ld_model,
2372                   char **error_message)
2373 {
2374   static xtensa_insnbuf ibuff = NULL;
2375   static xtensa_insnbuf sbuff = NULL;
2376   xtensa_isa isa = xtensa_default_isa;
2377   xtensa_format fmt;
2378   xtensa_opcode old_op, new_op;
2379   bfd_size_type input_size;
2380   int r_type;
2381   unsigned dest_reg, src_reg;
2382
2383   if (ibuff == NULL)
2384     {
2385       ibuff = xtensa_insnbuf_alloc (isa);
2386       sbuff = xtensa_insnbuf_alloc (isa);
2387     }
2388
2389   input_size = bfd_get_section_limit (abfd, input_section);
2390
2391   /* Read the instruction into a buffer and decode the opcode.  */
2392   xtensa_insnbuf_from_chars (isa, ibuff, contents + rel->r_offset,
2393                              input_size - rel->r_offset);
2394   fmt = xtensa_format_decode (isa, ibuff);
2395   if (fmt == XTENSA_UNDEFINED)
2396     {
2397       *error_message = "cannot decode instruction format";
2398       return FALSE;
2399     }
2400
2401   BFD_ASSERT (xtensa_format_num_slots (isa, fmt) == 1);
2402   xtensa_format_get_slot (isa, fmt, 0, ibuff, sbuff);
2403
2404   old_op = xtensa_opcode_decode (isa, fmt, 0, sbuff);
2405   if (old_op == XTENSA_UNDEFINED)
2406     {
2407       *error_message = "cannot decode instruction opcode";
2408       return FALSE;
2409     }
2410
2411   r_type = ELF32_R_TYPE (rel->r_info);
2412   switch (r_type)
2413     {
2414     case R_XTENSA_TLS_FUNC:
2415     case R_XTENSA_TLS_ARG:
2416       if (old_op != get_l32r_opcode ()
2417           || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2418                                        sbuff, &dest_reg) != 0)
2419         {
2420           *error_message = "cannot extract L32R destination for TLS access";
2421           return FALSE;
2422         }
2423       break;
2424
2425     case R_XTENSA_TLS_CALL:
2426       if (! get_indirect_call_dest_reg (old_op, &dest_reg)
2427           || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2428                                        sbuff, &src_reg) != 0)
2429         {
2430           *error_message = "cannot extract CALLXn operands for TLS access";
2431           return FALSE;
2432         }
2433       break;
2434
2435     default:
2436       abort ();
2437     }
2438
2439   if (is_ld_model)
2440     {
2441       switch (r_type)
2442         {
2443         case R_XTENSA_TLS_FUNC:
2444         case R_XTENSA_TLS_ARG:
2445           /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2446              versions of Xtensa).  */
2447           new_op = xtensa_opcode_lookup (isa, "nop");
2448           if (new_op == XTENSA_UNDEFINED)
2449             {
2450               new_op = xtensa_opcode_lookup (isa, "or");
2451               if (new_op == XTENSA_UNDEFINED
2452                   || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2453                   || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2454                                                sbuff, 1) != 0
2455                   || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2456                                                sbuff, 1) != 0
2457                   || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2458                                                sbuff, 1) != 0)
2459                 {
2460                   *error_message = "cannot encode OR for TLS access";
2461                   return FALSE;
2462                 }
2463             }
2464           else
2465             {
2466               if (xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0)
2467                 {
2468                   *error_message = "cannot encode NOP for TLS access";
2469                   return FALSE;
2470                 }
2471             }
2472           break;
2473
2474         case R_XTENSA_TLS_CALL:
2475           /* Read THREADPTR into the CALLX's return value register.  */
2476           new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2477           if (new_op == XTENSA_UNDEFINED
2478               || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2479               || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2480                                            sbuff, dest_reg + 2) != 0)
2481             {
2482               *error_message = "cannot encode RUR.THREADPTR for TLS access";
2483               return FALSE;
2484             }
2485           break;
2486         }
2487     }
2488   else
2489     {
2490       switch (r_type)
2491         {
2492         case R_XTENSA_TLS_FUNC:
2493           new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2494           if (new_op == XTENSA_UNDEFINED
2495               || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2496               || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2497                                            sbuff, dest_reg) != 0)
2498             {
2499               *error_message = "cannot encode RUR.THREADPTR for TLS access";
2500               return FALSE;
2501             }
2502           break;
2503
2504         case R_XTENSA_TLS_ARG:
2505           /* Nothing to do.  Keep the original L32R instruction.  */
2506           return TRUE;
2507
2508         case R_XTENSA_TLS_CALL:
2509           /* Add the CALLX's src register (holding the THREADPTR value)
2510              to the first argument register (holding the offset) and put
2511              the result in the CALLX's return value register.  */
2512           new_op = xtensa_opcode_lookup (isa, "add");
2513           if (new_op == XTENSA_UNDEFINED
2514               || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2515               || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2516                                            sbuff, dest_reg + 2) != 0
2517               || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2518                                            sbuff, dest_reg + 2) != 0
2519               || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2520                                            sbuff, src_reg) != 0)
2521             {
2522               *error_message = "cannot encode ADD for TLS access";
2523               return FALSE;
2524             }
2525           break;
2526         }
2527     }
2528
2529   xtensa_format_set_slot (isa, fmt, 0, ibuff, sbuff);
2530   xtensa_insnbuf_to_chars (isa, ibuff, contents + rel->r_offset,
2531                            input_size - rel->r_offset);
2532
2533   return TRUE;
2534 }
2535
2536
2537 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2538   ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2539    || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2540    || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2541    || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2542    || (R_TYPE) == R_XTENSA_TLS_FUNC \
2543    || (R_TYPE) == R_XTENSA_TLS_ARG \
2544    || (R_TYPE) == R_XTENSA_TLS_CALL)
2545
2546 /* Relocate an Xtensa ELF section.  This is invoked by the linker for
2547    both relocatable and final links.  */
2548
2549 static bfd_boolean
2550 elf_xtensa_relocate_section (bfd *output_bfd,
2551                              struct bfd_link_info *info,
2552                              bfd *input_bfd,
2553                              asection *input_section,
2554                              bfd_byte *contents,
2555                              Elf_Internal_Rela *relocs,
2556                              Elf_Internal_Sym *local_syms,
2557                              asection **local_sections)
2558 {
2559   struct elf_xtensa_link_hash_table *htab;
2560   Elf_Internal_Shdr *symtab_hdr;
2561   Elf_Internal_Rela *rel;
2562   Elf_Internal_Rela *relend;
2563   struct elf_link_hash_entry **sym_hashes;
2564   property_table_entry *lit_table = 0;
2565   int ltblsize = 0;
2566   char *local_got_tls_types;
2567   char *error_message = NULL;
2568   bfd_size_type input_size;
2569   int tls_type;
2570
2571   if (!xtensa_default_isa)
2572     xtensa_default_isa = xtensa_isa_init (0, 0);
2573
2574   BFD_ASSERT (is_xtensa_elf (input_bfd));
2575
2576   htab = elf_xtensa_hash_table (info);
2577   if (htab == NULL)
2578     return FALSE;
2579
2580   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2581   sym_hashes = elf_sym_hashes (input_bfd);
2582   local_got_tls_types = elf_xtensa_local_got_tls_type (input_bfd);
2583
2584   if (elf_hash_table (info)->dynamic_sections_created)
2585     {
2586       ltblsize = xtensa_read_table_entries (input_bfd, input_section,
2587                                             &lit_table, XTENSA_LIT_SEC_NAME,
2588                                             TRUE);
2589       if (ltblsize < 0)
2590         return FALSE;
2591     }
2592
2593   input_size = bfd_get_section_limit (input_bfd, input_section);
2594
2595   rel = relocs;
2596   relend = relocs + input_section->reloc_count;
2597   for (; rel < relend; rel++)
2598     {
2599       int r_type;
2600       reloc_howto_type *howto;
2601       unsigned long r_symndx;
2602       struct elf_link_hash_entry *h;
2603       Elf_Internal_Sym *sym;
2604       char sym_type;
2605       const char *name;
2606       asection *sec;
2607       bfd_vma relocation;
2608       bfd_reloc_status_type r;
2609       bfd_boolean is_weak_undef;
2610       bfd_boolean unresolved_reloc;
2611       bfd_boolean warned;
2612       bfd_boolean dynamic_symbol;
2613
2614       r_type = ELF32_R_TYPE (rel->r_info);
2615       if (r_type == (int) R_XTENSA_GNU_VTINHERIT
2616           || r_type == (int) R_XTENSA_GNU_VTENTRY)
2617         continue;
2618
2619       if (r_type < 0 || r_type >= (int) R_XTENSA_max)
2620         {
2621           bfd_set_error (bfd_error_bad_value);
2622           return FALSE;
2623         }
2624       howto = &elf_howto_table[r_type];
2625
2626       r_symndx = ELF32_R_SYM (rel->r_info);
2627
2628       h = NULL;
2629       sym = NULL;
2630       sec = NULL;
2631       is_weak_undef = FALSE;
2632       unresolved_reloc = FALSE;
2633       warned = FALSE;
2634
2635       if (howto->partial_inplace && !bfd_link_relocatable (info))
2636         {
2637           /* Because R_XTENSA_32 was made partial_inplace to fix some
2638              problems with DWARF info in partial links, there may be
2639              an addend stored in the contents.  Take it out of there
2640              and move it back into the addend field of the reloc.  */
2641           rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2642           bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2643         }
2644
2645       if (r_symndx < symtab_hdr->sh_info)
2646         {
2647           sym = local_syms + r_symndx;
2648           sym_type = ELF32_ST_TYPE (sym->st_info);
2649           sec = local_sections[r_symndx];
2650           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2651         }
2652       else
2653         {
2654           bfd_boolean ignored;
2655
2656           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2657                                    r_symndx, symtab_hdr, sym_hashes,
2658                                    h, sec, relocation,
2659                                    unresolved_reloc, warned, ignored);
2660
2661           if (relocation == 0
2662               && !unresolved_reloc
2663               && h->root.type == bfd_link_hash_undefweak)
2664             is_weak_undef = TRUE;
2665
2666           sym_type = h->type;
2667         }
2668
2669       if (sec != NULL && discarded_section (sec))
2670         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2671                                          rel, 1, relend, howto, 0, contents);
2672
2673       if (bfd_link_relocatable (info))
2674         {
2675           bfd_vma dest_addr;
2676           asection * sym_sec = get_elf_r_symndx_section (input_bfd, r_symndx);
2677
2678           /* This is a relocatable link.
2679              1) If the reloc is against a section symbol, adjust
2680              according to the output section.
2681              2) If there is a new target for this relocation,
2682              the new target will be in the same output section.
2683              We adjust the relocation by the output section
2684              difference.  */
2685
2686           if (relaxing_section)
2687             {
2688               /* Check if this references a section in another input file.  */
2689               if (!do_fix_for_relocatable_link (rel, input_bfd, input_section,
2690                                                 contents))
2691                 return FALSE;
2692             }
2693
2694           dest_addr = sym_sec->output_section->vma + sym_sec->output_offset
2695             + get_elf_r_symndx_offset (input_bfd, r_symndx) + rel->r_addend;
2696
2697           if (r_type == R_XTENSA_ASM_SIMPLIFY)
2698             {
2699               error_message = NULL;
2700               /* Convert ASM_SIMPLIFY into the simpler relocation
2701                  so that they never escape a relaxing link.  */
2702               r = contract_asm_expansion (contents, input_size, rel,
2703                                           &error_message);
2704               if (r != bfd_reloc_ok)
2705                 {
2706                   if (!((*info->callbacks->reloc_dangerous)
2707                         (info, error_message, input_bfd, input_section,
2708                          rel->r_offset)))
2709                     return FALSE;
2710                 }
2711               r_type = ELF32_R_TYPE (rel->r_info);
2712             }
2713
2714           /* This is a relocatable link, so we don't have to change
2715              anything unless the reloc is against a section symbol,
2716              in which case we have to adjust according to where the
2717              section symbol winds up in the output section.  */
2718           if (r_symndx < symtab_hdr->sh_info)
2719             {
2720               sym = local_syms + r_symndx;
2721               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2722                 {
2723                   sec = local_sections[r_symndx];
2724                   rel->r_addend += sec->output_offset + sym->st_value;
2725                 }
2726             }
2727
2728           /* If there is an addend with a partial_inplace howto,
2729              then move the addend to the contents.  This is a hack
2730              to work around problems with DWARF in relocatable links
2731              with some previous version of BFD.  Now we can't easily get
2732              rid of the hack without breaking backward compatibility.... */
2733           r = bfd_reloc_ok;
2734           howto = &elf_howto_table[r_type];
2735           if (howto->partial_inplace && rel->r_addend)
2736             {
2737               r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2738                                        rel->r_addend, contents,
2739                                        rel->r_offset, FALSE,
2740                                        &error_message);
2741               rel->r_addend = 0;
2742             }
2743           else
2744             {
2745               /* Put the correct bits in the target instruction, even
2746                  though the relocation will still be present in the output
2747                  file.  This makes disassembly clearer, as well as
2748                  allowing loadable kernel modules to work without needing
2749                  relocations on anything other than calls and l32r's.  */
2750
2751               /* If it is not in the same section, there is nothing we can do.  */
2752               if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP &&
2753                   sym_sec->output_section == input_section->output_section)
2754                 {
2755                   r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2756                                            dest_addr, contents,
2757                                            rel->r_offset, FALSE,
2758                                            &error_message);
2759                 }
2760             }
2761           if (r != bfd_reloc_ok)
2762             {
2763               if (!((*info->callbacks->reloc_dangerous)
2764                     (info, error_message, input_bfd, input_section,
2765                      rel->r_offset)))
2766                 return FALSE;
2767             }
2768
2769           /* Done with work for relocatable link; continue with next reloc.  */
2770           continue;
2771         }
2772
2773       /* This is a final link.  */
2774
2775       if (relaxing_section)
2776         {
2777           /* Check if this references a section in another input file.  */
2778           do_fix_for_final_link (rel, input_bfd, input_section, contents,
2779                                  &relocation);
2780         }
2781
2782       /* Sanity check the address.  */
2783       if (rel->r_offset >= input_size
2784           && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2785         {
2786           (*_bfd_error_handler)
2787             (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2788              input_bfd, input_section, rel->r_offset, input_size);
2789           bfd_set_error (bfd_error_bad_value);
2790           return FALSE;
2791         }
2792
2793       if (h != NULL)
2794         name = h->root.root.string;
2795       else
2796         {
2797           name = (bfd_elf_string_from_elf_section
2798                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
2799           if (name == NULL || *name == '\0')
2800             name = bfd_section_name (input_bfd, sec);
2801         }
2802
2803       if (r_symndx != STN_UNDEF
2804           && r_type != R_XTENSA_NONE
2805           && (h == NULL
2806               || h->root.type == bfd_link_hash_defined
2807               || h->root.type == bfd_link_hash_defweak)
2808           && IS_XTENSA_TLS_RELOC (r_type) != (sym_type == STT_TLS))
2809         {
2810           (*_bfd_error_handler)
2811             ((sym_type == STT_TLS
2812               ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
2813               : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
2814              input_bfd,
2815              input_section,
2816              (long) rel->r_offset,
2817              howto->name,
2818              name);
2819         }
2820
2821       dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
2822
2823       tls_type = GOT_UNKNOWN;
2824       if (h)
2825         tls_type = elf_xtensa_hash_entry (h)->tls_type;
2826       else if (local_got_tls_types)
2827         tls_type = local_got_tls_types [r_symndx];
2828
2829       switch (r_type)
2830         {
2831         case R_XTENSA_32:
2832         case R_XTENSA_PLT:
2833           if (elf_hash_table (info)->dynamic_sections_created
2834               && (input_section->flags & SEC_ALLOC) != 0
2835               && (dynamic_symbol || bfd_link_pic (info)))
2836             {
2837               Elf_Internal_Rela outrel;
2838               bfd_byte *loc;
2839               asection *srel;
2840
2841               if (dynamic_symbol && r_type == R_XTENSA_PLT)
2842                 srel = htab->srelplt;
2843               else
2844                 srel = htab->srelgot;
2845
2846               BFD_ASSERT (srel != NULL);
2847
2848               outrel.r_offset =
2849                 _bfd_elf_section_offset (output_bfd, info,
2850                                          input_section, rel->r_offset);
2851
2852               if ((outrel.r_offset | 1) == (bfd_vma) -1)
2853                 memset (&outrel, 0, sizeof outrel);
2854               else
2855                 {
2856                   outrel.r_offset += (input_section->output_section->vma
2857                                       + input_section->output_offset);
2858
2859                   /* Complain if the relocation is in a read-only section
2860                      and not in a literal pool.  */
2861                   if ((input_section->flags & SEC_READONLY) != 0
2862                       && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
2863                                                       outrel.r_offset))
2864                     {
2865                       error_message =
2866                         _("dynamic relocation in read-only section");
2867                       if (!((*info->callbacks->reloc_dangerous)
2868                             (info, error_message, input_bfd, input_section,
2869                              rel->r_offset)))
2870                         return FALSE;
2871                     }
2872
2873                   if (dynamic_symbol)
2874                     {
2875                       outrel.r_addend = rel->r_addend;
2876                       rel->r_addend = 0;
2877
2878                       if (r_type == R_XTENSA_32)
2879                         {
2880                           outrel.r_info =
2881                             ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2882                           relocation = 0;
2883                         }
2884                       else /* r_type == R_XTENSA_PLT */
2885                         {
2886                           outrel.r_info =
2887                             ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2888
2889                           /* Create the PLT entry and set the initial
2890                              contents of the literal entry to the address of
2891                              the PLT entry.  */
2892                           relocation =
2893                             elf_xtensa_create_plt_entry (info, output_bfd,
2894                                                          srel->reloc_count);
2895                         }
2896                       unresolved_reloc = FALSE;
2897                     }
2898                   else
2899                     {
2900                       /* Generate a RELATIVE relocation.  */
2901                       outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2902                       outrel.r_addend = 0;
2903                     }
2904                 }
2905
2906               loc = (srel->contents
2907                      + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2908               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2909               BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2910                           <= srel->size);
2911             }
2912           else if (r_type == R_XTENSA_ASM_EXPAND && dynamic_symbol)
2913             {
2914               /* This should only happen for non-PIC code, which is not
2915                  supposed to be used on systems with dynamic linking.
2916                  Just ignore these relocations.  */
2917               continue;
2918             }
2919           break;
2920
2921         case R_XTENSA_TLS_TPOFF:
2922           /* Switch to LE model for local symbols in an executable.  */
2923           if (! bfd_link_pic (info) && ! dynamic_symbol)
2924             {
2925               relocation = tpoff (info, relocation);
2926               break;
2927             }
2928           /* fall through */
2929
2930         case R_XTENSA_TLSDESC_FN:
2931         case R_XTENSA_TLSDESC_ARG:
2932           {
2933             if (r_type == R_XTENSA_TLSDESC_FN)
2934               {
2935                 if (! bfd_link_pic (info) || (tls_type & GOT_TLS_IE) != 0)
2936                   r_type = R_XTENSA_NONE;
2937               }
2938             else if (r_type == R_XTENSA_TLSDESC_ARG)
2939               {
2940                 if (bfd_link_pic (info))
2941                   {
2942                     if ((tls_type & GOT_TLS_IE) != 0)
2943                       r_type = R_XTENSA_TLS_TPOFF;
2944                   }
2945                 else
2946                   {
2947                     r_type = R_XTENSA_TLS_TPOFF;
2948                     if (! dynamic_symbol)
2949                       {
2950                         relocation = tpoff (info, relocation);
2951                         break;
2952                       }
2953                   }
2954               }
2955
2956             if (r_type == R_XTENSA_NONE)
2957               /* Nothing to do here; skip to the next reloc.  */
2958               continue;
2959
2960             if (! elf_hash_table (info)->dynamic_sections_created)
2961               {
2962                 error_message =
2963                   _("TLS relocation invalid without dynamic sections");
2964                 if (!((*info->callbacks->reloc_dangerous)
2965                       (info, error_message, input_bfd, input_section,
2966                        rel->r_offset)))
2967                   return FALSE;
2968               }
2969             else
2970               {
2971                 Elf_Internal_Rela outrel;
2972                 bfd_byte *loc;
2973                 asection *srel = htab->srelgot;
2974                 int indx;
2975
2976                 outrel.r_offset = (input_section->output_section->vma
2977                                    + input_section->output_offset
2978                                    + rel->r_offset);
2979
2980                 /* Complain if the relocation is in a read-only section
2981                    and not in a literal pool.  */
2982                 if ((input_section->flags & SEC_READONLY) != 0
2983                     && ! elf_xtensa_in_literal_pool (lit_table, ltblsize,
2984                                                      outrel.r_offset))
2985                   {
2986                     error_message =
2987                       _("dynamic relocation in read-only section");
2988                     if (!((*info->callbacks->reloc_dangerous)
2989                           (info, error_message, input_bfd, input_section,
2990                            rel->r_offset)))
2991                       return FALSE;
2992                   }
2993
2994                 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2995                 if (indx == 0)
2996                   outrel.r_addend = relocation - dtpoff_base (info);
2997                 else
2998                   outrel.r_addend = 0;
2999                 rel->r_addend = 0;
3000
3001                 outrel.r_info = ELF32_R_INFO (indx, r_type);
3002                 relocation = 0;
3003                 unresolved_reloc = FALSE;
3004
3005                 BFD_ASSERT (srel);
3006                 loc = (srel->contents
3007                        + srel->reloc_count++ * sizeof (Elf32_External_Rela));
3008                 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3009                 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
3010                             <= srel->size);
3011               }
3012           }
3013           break;
3014
3015         case R_XTENSA_TLS_DTPOFF:
3016           if (! bfd_link_pic (info))
3017             /* Switch from LD model to LE model.  */
3018             relocation = tpoff (info, relocation);
3019           else
3020             relocation -= dtpoff_base (info);
3021           break;
3022
3023         case R_XTENSA_TLS_FUNC:
3024         case R_XTENSA_TLS_ARG:
3025         case R_XTENSA_TLS_CALL:
3026           /* Check if optimizing to IE or LE model.  */
3027           if ((tls_type & GOT_TLS_IE) != 0)
3028             {
3029               bfd_boolean is_ld_model =
3030                 (h && elf_xtensa_hash_entry (h) == htab->tlsbase);
3031               if (! replace_tls_insn (rel, input_bfd, input_section, contents,
3032                                       is_ld_model, &error_message))
3033                 {
3034                   if (!((*info->callbacks->reloc_dangerous)
3035                         (info, error_message, input_bfd, input_section,
3036                          rel->r_offset)))
3037                     return FALSE;
3038                 }
3039
3040               if (r_type != R_XTENSA_TLS_ARG || is_ld_model)
3041                 {
3042                   /* Skip subsequent relocations on the same instruction.  */
3043                   while (rel + 1 < relend && rel[1].r_offset == rel->r_offset)
3044                     rel++;
3045                 }
3046             }
3047           continue;
3048
3049         default:
3050           if (elf_hash_table (info)->dynamic_sections_created
3051               && dynamic_symbol && (is_operand_relocation (r_type)
3052                                     || r_type == R_XTENSA_32_PCREL))
3053             {
3054               error_message =
3055                 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3056                              strlen (name) + 2, name);
3057               if (!((*info->callbacks->reloc_dangerous)
3058                     (info, error_message, input_bfd, input_section,
3059                      rel->r_offset)))
3060                 return FALSE;
3061               continue;
3062             }
3063           break;
3064         }
3065
3066       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3067          because such sections are not SEC_ALLOC and thus ld.so will
3068          not process them.  */
3069       if (unresolved_reloc
3070           && !((input_section->flags & SEC_DEBUGGING) != 0
3071                && h->def_dynamic)
3072           && _bfd_elf_section_offset (output_bfd, info, input_section,
3073                                       rel->r_offset) != (bfd_vma) -1)
3074         {
3075           (*_bfd_error_handler)
3076             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3077              input_bfd,
3078              input_section,
3079              (long) rel->r_offset,
3080              howto->name,
3081              name);
3082           return FALSE;
3083         }
3084
3085       /* TLS optimizations may have changed r_type; update "howto".  */
3086       howto = &elf_howto_table[r_type];
3087
3088       /* There's no point in calling bfd_perform_relocation here.
3089          Just go directly to our "special function".  */
3090       r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
3091                                relocation + rel->r_addend,
3092                                contents, rel->r_offset, is_weak_undef,
3093                                &error_message);
3094
3095       if (r != bfd_reloc_ok && !warned)
3096         {
3097           BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
3098           BFD_ASSERT (error_message != NULL);
3099
3100           if (rel->r_addend == 0)
3101             error_message = vsprint_msg (error_message, ": %s",
3102                                          strlen (name) + 2, name);
3103           else
3104             error_message = vsprint_msg (error_message, ": (%s+0x%x)",
3105                                          strlen (name) + 22,
3106                                          name, (int) rel->r_addend);
3107
3108           if (!((*info->callbacks->reloc_dangerous)
3109                 (info, error_message, input_bfd, input_section,
3110                  rel->r_offset)))
3111             return FALSE;
3112         }
3113     }
3114
3115   if (lit_table)
3116     free (lit_table);
3117
3118   input_section->reloc_done = TRUE;
3119
3120   return TRUE;
3121 }
3122
3123
3124 /* Finish up dynamic symbol handling.  There's not much to do here since
3125    the PLT and GOT entries are all set up by relocate_section.  */
3126
3127 static bfd_boolean
3128 elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
3129                                   struct bfd_link_info *info ATTRIBUTE_UNUSED,
3130                                   struct elf_link_hash_entry *h,
3131                                   Elf_Internal_Sym *sym)
3132 {
3133   if (h->needs_plt && !h->def_regular)
3134     {
3135       /* Mark the symbol as undefined, rather than as defined in
3136          the .plt section.  Leave the value alone.  */
3137       sym->st_shndx = SHN_UNDEF;
3138       /* If the symbol is weak, we do need to clear the value.
3139          Otherwise, the PLT entry would provide a definition for
3140          the symbol even if the symbol wasn't defined anywhere,
3141          and so the symbol would never be NULL.  */
3142       if (!h->ref_regular_nonweak)
3143         sym->st_value = 0;
3144     }
3145
3146   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3147   if (h == elf_hash_table (info)->hdynamic
3148       || h == elf_hash_table (info)->hgot)
3149     sym->st_shndx = SHN_ABS;
3150
3151   return TRUE;
3152 }
3153
3154
3155 /* Combine adjacent literal table entries in the output.  Adjacent
3156    entries within each input section may have been removed during
3157    relaxation, but we repeat the process here, even though it's too late
3158    to shrink the output section, because it's important to minimize the
3159    number of literal table entries to reduce the start-up work for the
3160    runtime linker.  Returns the number of remaining table entries or -1
3161    on error.  */
3162
3163 static int
3164 elf_xtensa_combine_prop_entries (bfd *output_bfd,
3165                                  asection *sxtlit,
3166                                  asection *sgotloc)
3167 {
3168   bfd_byte *contents;
3169   property_table_entry *table;
3170   bfd_size_type section_size, sgotloc_size;
3171   bfd_vma offset;
3172   int n, m, num;
3173
3174   section_size = sxtlit->size;
3175   BFD_ASSERT (section_size % 8 == 0);
3176   num = section_size / 8;
3177
3178   sgotloc_size = sgotloc->size;
3179   if (sgotloc_size != section_size)
3180     {
3181       (*_bfd_error_handler)
3182         (_("internal inconsistency in size of .got.loc section"));
3183       return -1;
3184     }
3185
3186   table = bfd_malloc (num * sizeof (property_table_entry));
3187   if (table == 0)
3188     return -1;
3189
3190   /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3191      propagates to the output section, where it doesn't really apply and
3192      where it breaks the following call to bfd_malloc_and_get_section.  */
3193   sxtlit->flags &= ~SEC_IN_MEMORY;
3194
3195   if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
3196     {
3197       if (contents != 0)
3198         free (contents);
3199       free (table);
3200       return -1;
3201     }
3202
3203   /* There should never be any relocations left at this point, so this
3204      is quite a bit easier than what is done during relaxation.  */
3205
3206   /* Copy the raw contents into a property table array and sort it.  */
3207   offset = 0;
3208   for (n = 0; n < num; n++)
3209     {
3210       table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
3211       table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
3212       offset += 8;
3213     }
3214   qsort (table, num, sizeof (property_table_entry), property_table_compare);
3215
3216   for (n = 0; n < num; n++)
3217     {
3218       bfd_boolean remove_entry = FALSE;
3219
3220       if (table[n].size == 0)
3221         remove_entry = TRUE;
3222       else if (n > 0
3223                && (table[n-1].address + table[n-1].size == table[n].address))
3224         {
3225           table[n-1].size += table[n].size;
3226           remove_entry = TRUE;
3227         }
3228
3229       if (remove_entry)
3230         {
3231           for (m = n; m < num - 1; m++)
3232             {
3233               table[m].address = table[m+1].address;
3234               table[m].size = table[m+1].size;
3235             }
3236
3237           n--;
3238           num--;
3239         }
3240     }
3241
3242   /* Copy the data back to the raw contents.  */
3243   offset = 0;
3244   for (n = 0; n < num; n++)
3245     {
3246       bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
3247       bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
3248       offset += 8;
3249     }
3250
3251   /* Clear the removed bytes.  */
3252   if ((bfd_size_type) (num * 8) < section_size)
3253     memset (&contents[num * 8], 0, section_size - num * 8);
3254
3255   if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
3256                                   section_size))
3257     return -1;
3258
3259   /* Copy the contents to ".got.loc".  */
3260   memcpy (sgotloc->contents, contents, section_size);
3261
3262   free (contents);
3263   free (table);
3264   return num;
3265 }
3266
3267
3268 /* Finish up the dynamic sections.  */
3269
3270 static bfd_boolean
3271 elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
3272                                     struct bfd_link_info *info)
3273 {
3274   struct elf_xtensa_link_hash_table *htab;
3275   bfd *dynobj;
3276   asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
3277   Elf32_External_Dyn *dyncon, *dynconend;
3278   int num_xtlit_entries = 0;
3279
3280   if (! elf_hash_table (info)->dynamic_sections_created)
3281     return TRUE;
3282
3283   htab = elf_xtensa_hash_table (info);
3284   if (htab == NULL)
3285     return FALSE;
3286
3287   dynobj = elf_hash_table (info)->dynobj;
3288   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3289   BFD_ASSERT (sdyn != NULL);
3290
3291   /* Set the first entry in the global offset table to the address of
3292      the dynamic section.  */
3293   sgot = htab->sgot;
3294   if (sgot)
3295     {
3296       BFD_ASSERT (sgot->size == 4);
3297       if (sdyn == NULL)
3298         bfd_put_32 (output_bfd, 0, sgot->contents);
3299       else
3300         bfd_put_32 (output_bfd,
3301                     sdyn->output_section->vma + sdyn->output_offset,
3302                     sgot->contents);
3303     }
3304
3305   srelplt = htab->srelplt;
3306   if (srelplt && srelplt->size != 0)
3307     {
3308       asection *sgotplt, *srelgot, *spltlittbl;
3309       int chunk, plt_chunks, plt_entries;
3310       Elf_Internal_Rela irela;
3311       bfd_byte *loc;
3312       unsigned rtld_reloc;
3313
3314       srelgot = htab->srelgot;
3315       spltlittbl = htab->spltlittbl;
3316       BFD_ASSERT (srelgot != NULL && spltlittbl != NULL);
3317
3318       /* Find the first XTENSA_RTLD relocation.  Presumably the rest
3319          of them follow immediately after....  */
3320       for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
3321         {
3322           loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3323           bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3324           if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
3325             break;
3326         }
3327       BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
3328
3329       plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
3330       plt_chunks =
3331         (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
3332
3333       for (chunk = 0; chunk < plt_chunks; chunk++)
3334         {
3335           int chunk_entries = 0;
3336
3337           sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
3338           BFD_ASSERT (sgotplt != NULL);
3339
3340           /* Emit special RTLD relocations for the first two entries in
3341              each chunk of the .got.plt section.  */
3342
3343           loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3344           bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3345           BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3346           irela.r_offset = (sgotplt->output_section->vma
3347                             + sgotplt->output_offset);
3348           irela.r_addend = 1; /* tell rtld to set value to resolver function */
3349           bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3350           rtld_reloc += 1;
3351           BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3352
3353           /* Next literal immediately follows the first.  */
3354           loc += sizeof (Elf32_External_Rela);
3355           bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3356           BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3357           irela.r_offset = (sgotplt->output_section->vma
3358                             + sgotplt->output_offset + 4);
3359           /* Tell rtld to set value to object's link map.  */
3360           irela.r_addend = 2;
3361           bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3362           rtld_reloc += 1;
3363           BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3364
3365           /* Fill in the literal table.  */
3366           if (chunk < plt_chunks - 1)
3367             chunk_entries = PLT_ENTRIES_PER_CHUNK;
3368           else
3369             chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
3370
3371           BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
3372           bfd_put_32 (output_bfd,
3373                       sgotplt->output_section->vma + sgotplt->output_offset,
3374                       spltlittbl->contents + (chunk * 8) + 0);
3375           bfd_put_32 (output_bfd,
3376                       8 + (chunk_entries * 4),
3377                       spltlittbl->contents + (chunk * 8) + 4);
3378         }
3379
3380       /* All the dynamic relocations have been emitted at this point.
3381          Make sure the relocation sections are the correct size.  */
3382       if (srelgot->size != (sizeof (Elf32_External_Rela)
3383                             * srelgot->reloc_count)
3384           || srelplt->size != (sizeof (Elf32_External_Rela)
3385                                * srelplt->reloc_count))
3386         abort ();
3387
3388      /* The .xt.lit.plt section has just been modified.  This must
3389         happen before the code below which combines adjacent literal
3390         table entries, and the .xt.lit.plt contents have to be forced to
3391         the output here.  */
3392       if (! bfd_set_section_contents (output_bfd,
3393                                       spltlittbl->output_section,
3394                                       spltlittbl->contents,
3395                                       spltlittbl->output_offset,
3396                                       spltlittbl->size))
3397         return FALSE;
3398       /* Clear SEC_HAS_CONTENTS so the contents won't be output again.  */
3399       spltlittbl->flags &= ~SEC_HAS_CONTENTS;
3400     }
3401
3402   /* Combine adjacent literal table entries.  */
3403   BFD_ASSERT (! bfd_link_relocatable (info));
3404   sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
3405   sgotloc = htab->sgotloc;
3406   BFD_ASSERT (sgotloc);
3407   if (sxtlit)
3408     {
3409       num_xtlit_entries =
3410         elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
3411       if (num_xtlit_entries < 0)
3412         return FALSE;
3413     }
3414
3415   dyncon = (Elf32_External_Dyn *) sdyn->contents;
3416   dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3417   for (; dyncon < dynconend; dyncon++)
3418     {
3419       Elf_Internal_Dyn dyn;
3420
3421       bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3422
3423       switch (dyn.d_tag)
3424         {
3425         default:
3426           break;
3427
3428         case DT_XTENSA_GOT_LOC_SZ:
3429           dyn.d_un.d_val = num_xtlit_entries;
3430           break;
3431
3432         case DT_XTENSA_GOT_LOC_OFF:
3433           dyn.d_un.d_ptr = (htab->sgotloc->output_section->vma
3434                             + htab->sgotloc->output_offset);
3435           break;
3436
3437         case DT_PLTGOT:
3438           dyn.d_un.d_ptr = (htab->sgot->output_section->vma
3439                             + htab->sgot->output_offset);
3440           break;
3441
3442         case DT_JMPREL:
3443           dyn.d_un.d_ptr = (htab->srelplt->output_section->vma
3444                             + htab->srelplt->output_offset);
3445           break;
3446
3447         case DT_PLTRELSZ:
3448           dyn.d_un.d_val = htab->srelplt->size;
3449           break;
3450
3451         case DT_RELASZ:
3452           /* Adjust RELASZ to not include JMPREL.  This matches what
3453              glibc expects and what is done for several other ELF
3454              targets (e.g., i386, alpha), but the "correct" behavior
3455              seems to be unresolved.  Since the linker script arranges
3456              for .rela.plt to follow all other relocation sections, we
3457              don't have to worry about changing the DT_RELA entry.  */
3458           if (htab->srelplt)
3459             dyn.d_un.d_val -= htab->srelplt->size;
3460           break;
3461         }
3462
3463       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3464     }
3465
3466   return TRUE;
3467 }
3468
3469 \f
3470 /* Functions for dealing with the e_flags field.  */
3471
3472 /* Merge backend specific data from an object file to the output
3473    object file when linking.  */
3474
3475 static bfd_boolean
3476 elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3477 {
3478   unsigned out_mach, in_mach;
3479   flagword out_flag, in_flag;
3480
3481   /* Check if we have the same endianness.  */
3482   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
3483     return FALSE;
3484
3485   /* Don't even pretend to support mixed-format linking.  */
3486   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3487       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3488     return FALSE;
3489
3490   out_flag = elf_elfheader (obfd)->e_flags;
3491   in_flag = elf_elfheader (ibfd)->e_flags;
3492
3493   out_mach = out_flag & EF_XTENSA_MACH;
3494   in_mach = in_flag & EF_XTENSA_MACH;
3495   if (out_mach != in_mach)
3496     {
3497       (*_bfd_error_handler)
3498         (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
3499          ibfd, out_mach, in_mach);
3500       bfd_set_error (bfd_error_wrong_format);
3501       return FALSE;
3502     }
3503
3504   if (! elf_flags_init (obfd))
3505     {
3506       elf_flags_init (obfd) = TRUE;
3507       elf_elfheader (obfd)->e_flags = in_flag;
3508
3509       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3510           && bfd_get_arch_info (obfd)->the_default)
3511         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3512                                   bfd_get_mach (ibfd));
3513
3514       return TRUE;
3515     }
3516
3517   if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
3518     elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
3519
3520   if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
3521     elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
3522
3523   return TRUE;
3524 }
3525
3526
3527 static bfd_boolean
3528 elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
3529 {
3530   BFD_ASSERT (!elf_flags_init (abfd)
3531               || elf_elfheader (abfd)->e_flags == flags);
3532
3533   elf_elfheader (abfd)->e_flags |= flags;
3534   elf_flags_init (abfd) = TRUE;
3535
3536   return TRUE;
3537 }
3538
3539
3540 static bfd_boolean
3541 elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
3542 {
3543   FILE *f = (FILE *) farg;
3544   flagword e_flags = elf_elfheader (abfd)->e_flags;
3545
3546   fprintf (f, "\nXtensa header:\n");
3547   if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
3548     fprintf (f, "\nMachine     = Base\n");
3549   else
3550     fprintf (f, "\nMachine Id  = 0x%x\n", e_flags & EF_XTENSA_MACH);
3551
3552   fprintf (f, "Insn tables = %s\n",
3553            (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
3554
3555   fprintf (f, "Literal tables = %s\n",
3556            (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
3557
3558   return _bfd_elf_print_private_bfd_data (abfd, farg);
3559 }
3560
3561
3562 /* Set the right machine number for an Xtensa ELF file.  */
3563
3564 static bfd_boolean
3565 elf_xtensa_object_p (bfd *abfd)
3566 {
3567   int mach;
3568   unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
3569
3570   switch (arch)
3571     {
3572     case E_XTENSA_MACH:
3573       mach = bfd_mach_xtensa;
3574       break;
3575     default:
3576       return FALSE;
3577     }
3578
3579   (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
3580   return TRUE;
3581 }
3582
3583
3584 /* The final processing done just before writing out an Xtensa ELF object
3585    file.  This gets the Xtensa architecture right based on the machine
3586    number.  */
3587
3588 static void
3589 elf_xtensa_final_write_processing (bfd *abfd,
3590                                    bfd_boolean linker ATTRIBUTE_UNUSED)
3591 {
3592   int mach;
3593   unsigned long val;
3594
3595   switch (mach = bfd_get_mach (abfd))
3596     {
3597     case bfd_mach_xtensa:
3598       val = E_XTENSA_MACH;
3599       break;
3600     default:
3601       return;
3602     }
3603
3604   elf_elfheader (abfd)->e_flags &=  (~ EF_XTENSA_MACH);
3605   elf_elfheader (abfd)->e_flags |= val;
3606 }
3607
3608
3609 static enum elf_reloc_type_class
3610 elf_xtensa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3611                              const asection *rel_sec ATTRIBUTE_UNUSED,
3612                              const Elf_Internal_Rela *rela)
3613 {
3614   switch ((int) ELF32_R_TYPE (rela->r_info))
3615     {
3616     case R_XTENSA_RELATIVE:
3617       return reloc_class_relative;
3618     case R_XTENSA_JMP_SLOT:
3619       return reloc_class_plt;
3620     default:
3621       return reloc_class_normal;
3622     }
3623 }
3624
3625 \f
3626 static bfd_boolean
3627 elf_xtensa_discard_info_for_section (bfd *abfd,
3628                                      struct elf_reloc_cookie *cookie,
3629                                      struct bfd_link_info *info,
3630                                      asection *sec)
3631 {
3632   bfd_byte *contents;
3633   bfd_vma offset, actual_offset;
3634   bfd_size_type removed_bytes = 0;
3635   bfd_size_type entry_size;
3636
3637   if (sec->output_section
3638       && bfd_is_abs_section (sec->output_section))
3639     return FALSE;
3640
3641   if (xtensa_is_proptable_section (sec))
3642     entry_size = 12;
3643   else
3644     entry_size = 8;
3645
3646   if (sec->size == 0 || sec->size % entry_size != 0)
3647     return FALSE;
3648
3649   contents = retrieve_contents (abfd, sec, info->keep_memory);
3650   if (!contents)
3651     return FALSE;
3652
3653   cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
3654   if (!cookie->rels)
3655     {
3656       release_contents (sec, contents);
3657       return FALSE;
3658     }
3659
3660   /* Sort the relocations.  They should already be in order when
3661      relaxation is enabled, but it might not be.  */
3662   qsort (cookie->rels, sec->reloc_count, sizeof (Elf_Internal_Rela),
3663          internal_reloc_compare);
3664
3665   cookie->rel = cookie->rels;
3666   cookie->relend = cookie->rels + sec->reloc_count;
3667
3668   for (offset = 0; offset < sec->size; offset += entry_size)
3669     {
3670       actual_offset = offset - removed_bytes;
3671
3672       /* The ...symbol_deleted_p function will skip over relocs but it
3673          won't adjust their offsets, so do that here.  */
3674       while (cookie->rel < cookie->relend
3675              && cookie->rel->r_offset < offset)
3676         {
3677           cookie->rel->r_offset -= removed_bytes;
3678           cookie->rel++;
3679         }
3680
3681       while (cookie->rel < cookie->relend
3682              && cookie->rel->r_offset == offset)
3683         {
3684           if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
3685             {
3686               /* Remove the table entry.  (If the reloc type is NONE, then
3687                  the entry has already been merged with another and deleted
3688                  during relaxation.)  */
3689               if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
3690                 {
3691                   /* Shift the contents up.  */
3692                   if (offset + entry_size < sec->size)
3693                     memmove (&contents[actual_offset],
3694                              &contents[actual_offset + entry_size],
3695                              sec->size - offset - entry_size);
3696                   removed_bytes += entry_size;
3697                 }
3698
3699               /* Remove this relocation.  */
3700               cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
3701             }
3702
3703           /* Adjust the relocation offset for previous removals.  This
3704              should not be done before calling ...symbol_deleted_p
3705              because it might mess up the offset comparisons there.
3706              Make sure the offset doesn't underflow in the case where
3707              the first entry is removed.  */
3708           if (cookie->rel->r_offset >= removed_bytes)
3709             cookie->rel->r_offset -= removed_bytes;
3710           else
3711             cookie->rel->r_offset = 0;
3712
3713           cookie->rel++;
3714         }
3715     }
3716
3717   if (removed_bytes != 0)
3718     {
3719       /* Adjust any remaining relocs (shouldn't be any).  */
3720       for (; cookie->rel < cookie->relend; cookie->rel++)
3721         {
3722           if (cookie->rel->r_offset >= removed_bytes)
3723             cookie->rel->r_offset -= removed_bytes;
3724           else
3725             cookie->rel->r_offset = 0;
3726         }
3727
3728       /* Clear the removed bytes.  */
3729       memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
3730
3731       pin_contents (sec, contents);
3732       pin_internal_relocs (sec, cookie->rels);
3733
3734       /* Shrink size.  */
3735       if (sec->rawsize == 0)
3736         sec->rawsize = sec->size;
3737       sec->size -= removed_bytes;
3738
3739       if (xtensa_is_littable_section (sec))
3740         {
3741           asection *sgotloc = elf_xtensa_hash_table (info)->sgotloc;
3742           if (sgotloc)
3743             sgotloc->size -= removed_bytes;
3744         }
3745     }
3746   else
3747     {
3748       release_contents (sec, contents);
3749       release_internal_relocs (sec, cookie->rels);
3750     }
3751
3752   return (removed_bytes != 0);
3753 }
3754
3755
3756 static bfd_boolean
3757 elf_xtensa_discard_info (bfd *abfd,
3758                          struct elf_reloc_cookie *cookie,
3759                          struct bfd_link_info *info)
3760 {
3761   asection *sec;
3762   bfd_boolean changed = FALSE;
3763
3764   for (sec = abfd->sections; sec != NULL; sec = sec->next)
3765     {
3766       if (xtensa_is_property_section (sec))
3767         {
3768           if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
3769             changed = TRUE;
3770         }
3771     }
3772
3773   return changed;
3774 }
3775
3776
3777 static bfd_boolean
3778 elf_xtensa_ignore_discarded_relocs (asection *sec)
3779 {
3780   return xtensa_is_property_section (sec);
3781 }
3782
3783
3784 static unsigned int
3785 elf_xtensa_action_discarded (asection *sec)
3786 {
3787   if (strcmp (".xt_except_table", sec->name) == 0)
3788     return 0;
3789
3790   if (strcmp (".xt_except_desc", sec->name) == 0)
3791     return 0;
3792
3793   return _bfd_elf_default_action_discarded (sec);
3794 }
3795
3796 \f
3797 /* Support for core dump NOTE sections.  */
3798
3799 static bfd_boolean
3800 elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3801 {
3802   int offset;
3803   unsigned int size;
3804
3805   /* The size for Xtensa is variable, so don't try to recognize the format
3806      based on the size.  Just assume this is GNU/Linux.  */
3807
3808   /* pr_cursig */
3809   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3810
3811   /* pr_pid */
3812   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
3813
3814   /* pr_reg */
3815   offset = 72;
3816   size = note->descsz - offset - 4;
3817
3818   /* Make a ".reg/999" section.  */
3819   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3820                                           size, note->descpos + offset);
3821 }
3822
3823
3824 static bfd_boolean
3825 elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3826 {
3827   switch (note->descsz)
3828     {
3829       default:
3830         return FALSE;
3831
3832       case 128:         /* GNU/Linux elf_prpsinfo */
3833         elf_tdata (abfd)->core->program
3834          = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
3835         elf_tdata (abfd)->core->command
3836          = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3837     }
3838
3839   /* Note that for some reason, a spurious space is tacked
3840      onto the end of the args in some (at least one anyway)
3841      implementations, so strip it off if it exists.  */
3842
3843   {
3844     char *command = elf_tdata (abfd)->core->command;
3845     int n = strlen (command);
3846
3847     if (0 < n && command[n - 1] == ' ')
3848       command[n - 1] = '\0';
3849   }
3850
3851   return TRUE;
3852 }
3853
3854 \f
3855 /* Generic Xtensa configurability stuff.  */
3856
3857 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3858 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3859 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3860 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3861 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3862 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3863 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3864 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3865
3866 static void
3867 init_call_opcodes (void)
3868 {
3869   if (callx0_op == XTENSA_UNDEFINED)
3870     {
3871       callx0_op  = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3872       callx4_op  = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3873       callx8_op  = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3874       callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3875       call0_op   = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3876       call4_op   = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3877       call8_op   = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3878       call12_op  = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3879     }
3880 }
3881
3882
3883 static bfd_boolean
3884 is_indirect_call_opcode (xtensa_opcode opcode)
3885 {
3886   init_call_opcodes ();
3887   return (opcode == callx0_op
3888           || opcode == callx4_op
3889           || opcode == callx8_op
3890           || opcode == callx12_op);
3891 }
3892
3893
3894 static bfd_boolean
3895 is_direct_call_opcode (xtensa_opcode opcode)
3896 {
3897   init_call_opcodes ();
3898   return (opcode == call0_op
3899           || opcode == call4_op
3900           || opcode == call8_op
3901           || opcode == call12_op);
3902 }
3903
3904
3905 static bfd_boolean
3906 is_windowed_call_opcode (xtensa_opcode opcode)
3907 {
3908   init_call_opcodes ();
3909   return (opcode == call4_op
3910           || opcode == call8_op
3911           || opcode == call12_op
3912           || opcode == callx4_op
3913           || opcode == callx8_op
3914           || opcode == callx12_op);
3915 }
3916
3917
3918 static bfd_boolean
3919 get_indirect_call_dest_reg (xtensa_opcode opcode, unsigned *pdst)
3920 {
3921   unsigned dst = (unsigned) -1;
3922
3923   init_call_opcodes ();
3924   if (opcode == callx0_op)
3925     dst = 0;
3926   else if (opcode == callx4_op)
3927     dst = 4;
3928   else if (opcode == callx8_op)
3929     dst = 8;
3930   else if (opcode == callx12_op)
3931     dst = 12;
3932
3933   if (dst == (unsigned) -1)
3934     return FALSE;
3935
3936   *pdst = dst;
3937   return TRUE;
3938 }
3939
3940
3941 static xtensa_opcode
3942 get_const16_opcode (void)
3943 {
3944   static bfd_boolean done_lookup = FALSE;
3945   static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3946   if (!done_lookup)
3947     {
3948       const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3949       done_lookup = TRUE;
3950     }
3951   return const16_opcode;
3952 }
3953
3954
3955 static xtensa_opcode
3956 get_l32r_opcode (void)
3957 {
3958   static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
3959   static bfd_boolean done_lookup = FALSE;
3960
3961   if (!done_lookup)
3962     {
3963       l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
3964       done_lookup = TRUE;
3965     }
3966   return l32r_opcode;
3967 }
3968
3969
3970 static bfd_vma
3971 l32r_offset (bfd_vma addr, bfd_vma pc)
3972 {
3973   bfd_vma offset;
3974
3975   offset = addr - ((pc+3) & -4);
3976   BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3977   offset = (signed int) offset >> 2;
3978   BFD_ASSERT ((signed int) offset >> 16 == -1);
3979   return offset;
3980 }
3981
3982
3983 static int
3984 get_relocation_opnd (xtensa_opcode opcode, int r_type)
3985 {
3986   xtensa_isa isa = xtensa_default_isa;
3987   int last_immed, last_opnd, opi;
3988
3989   if (opcode == XTENSA_UNDEFINED)
3990     return XTENSA_UNDEFINED;
3991
3992   /* Find the last visible PC-relative immediate operand for the opcode.
3993      If there are no PC-relative immediates, then choose the last visible
3994      immediate; otherwise, fail and return XTENSA_UNDEFINED.  */
3995   last_immed = XTENSA_UNDEFINED;
3996   last_opnd = xtensa_opcode_num_operands (isa, opcode);
3997   for (opi = last_opnd - 1; opi >= 0; opi--)
3998     {
3999       if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
4000         continue;
4001       if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
4002         {
4003           last_immed = opi;
4004           break;
4005         }
4006       if (last_immed == XTENSA_UNDEFINED
4007           && xtensa_operand_is_register (isa, opcode, opi) == 0)
4008         last_immed = opi;
4009     }
4010   if (last_immed < 0)
4011     return XTENSA_UNDEFINED;
4012
4013   /* If the operand number was specified in an old-style relocation,
4014      check for consistency with the operand computed above.  */
4015   if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
4016     {
4017       int reloc_opnd = r_type - R_XTENSA_OP0;
4018       if (reloc_opnd != last_immed)
4019         return XTENSA_UNDEFINED;
4020     }
4021
4022   return last_immed;
4023 }
4024
4025
4026 int
4027 get_relocation_slot (int r_type)
4028 {
4029   switch (r_type)
4030     {
4031     case R_XTENSA_OP0:
4032     case R_XTENSA_OP1:
4033     case R_XTENSA_OP2:
4034       return 0;
4035
4036     default:
4037       if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4038         return r_type - R_XTENSA_SLOT0_OP;
4039       if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4040         return r_type - R_XTENSA_SLOT0_ALT;
4041       break;
4042     }
4043
4044   return XTENSA_UNDEFINED;
4045 }
4046
4047
4048 /* Get the opcode for a relocation.  */
4049
4050 static xtensa_opcode
4051 get_relocation_opcode (bfd *abfd,
4052                        asection *sec,
4053                        bfd_byte *contents,
4054                        Elf_Internal_Rela *irel)
4055 {
4056   static xtensa_insnbuf ibuff = NULL;
4057   static xtensa_insnbuf sbuff = NULL;
4058   xtensa_isa isa = xtensa_default_isa;
4059   xtensa_format fmt;
4060   int slot;
4061
4062   if (contents == NULL)
4063     return XTENSA_UNDEFINED;
4064
4065   if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
4066     return XTENSA_UNDEFINED;
4067
4068   if (ibuff == NULL)
4069     {
4070       ibuff = xtensa_insnbuf_alloc (isa);
4071       sbuff = xtensa_insnbuf_alloc (isa);
4072     }
4073
4074   /* Decode the instruction.  */
4075   xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
4076                              sec->size - irel->r_offset);
4077   fmt = xtensa_format_decode (isa, ibuff);
4078   slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
4079   if (slot == XTENSA_UNDEFINED)
4080     return XTENSA_UNDEFINED;
4081   xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
4082   return xtensa_opcode_decode (isa, fmt, slot, sbuff);
4083 }
4084
4085
4086 bfd_boolean
4087 is_l32r_relocation (bfd *abfd,
4088                     asection *sec,
4089                     bfd_byte *contents,
4090                     Elf_Internal_Rela *irel)
4091 {
4092   xtensa_opcode opcode;
4093   if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
4094     return FALSE;
4095   opcode = get_relocation_opcode (abfd, sec, contents, irel);
4096   return (opcode == get_l32r_opcode ());
4097 }
4098
4099
4100 static bfd_size_type
4101 get_asm_simplify_size (bfd_byte *contents,
4102                        bfd_size_type content_len,
4103                        bfd_size_type offset)
4104 {
4105   bfd_size_type insnlen, size = 0;
4106
4107   /* Decode the size of the next two instructions.  */
4108   insnlen = insn_decode_len (contents, content_len, offset);
4109   if (insnlen == 0)
4110     return 0;
4111
4112   size += insnlen;
4113
4114   insnlen = insn_decode_len (contents, content_len, offset + size);
4115   if (insnlen == 0)
4116     return 0;
4117
4118   size += insnlen;
4119   return size;
4120 }
4121
4122
4123 bfd_boolean
4124 is_alt_relocation (int r_type)
4125 {
4126   return (r_type >= R_XTENSA_SLOT0_ALT
4127           && r_type <= R_XTENSA_SLOT14_ALT);
4128 }
4129
4130
4131 bfd_boolean
4132 is_operand_relocation (int r_type)
4133 {
4134   switch (r_type)
4135     {
4136     case R_XTENSA_OP0:
4137     case R_XTENSA_OP1:
4138     case R_XTENSA_OP2:
4139       return TRUE;
4140
4141     default:
4142       if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4143         return TRUE;
4144       if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4145         return TRUE;
4146       break;
4147     }
4148
4149   return FALSE;
4150 }
4151
4152
4153 #define MIN_INSN_LENGTH 2
4154
4155 /* Return 0 if it fails to decode.  */
4156
4157 bfd_size_type
4158 insn_decode_len (bfd_byte *contents,
4159                  bfd_size_type content_len,
4160                  bfd_size_type offset)
4161 {
4162   int insn_len;
4163   xtensa_isa isa = xtensa_default_isa;
4164   xtensa_format fmt;
4165   static xtensa_insnbuf ibuff = NULL;
4166
4167   if (offset + MIN_INSN_LENGTH > content_len)
4168     return 0;
4169
4170   if (ibuff == NULL)
4171     ibuff = xtensa_insnbuf_alloc (isa);
4172   xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
4173                              content_len - offset);
4174   fmt = xtensa_format_decode (isa, ibuff);
4175   if (fmt == XTENSA_UNDEFINED)
4176     return 0;
4177   insn_len = xtensa_format_length (isa, fmt);
4178   if (insn_len ==  XTENSA_UNDEFINED)
4179     return 0;
4180   return insn_len;
4181 }
4182
4183
4184 /* Decode the opcode for a single slot instruction.
4185    Return 0 if it fails to decode or the instruction is multi-slot.  */
4186
4187 xtensa_opcode
4188 insn_decode_opcode (bfd_byte *contents,
4189                     bfd_size_type content_len,
4190                     bfd_size_type offset,
4191                     int slot)
4192 {
4193   xtensa_isa isa = xtensa_default_isa;
4194   xtensa_format fmt;
4195   static xtensa_insnbuf insnbuf = NULL;
4196   static xtensa_insnbuf slotbuf = NULL;
4197
4198   if (offset + MIN_INSN_LENGTH > content_len)
4199     return XTENSA_UNDEFINED;
4200
4201   if (insnbuf == NULL)
4202     {
4203       insnbuf = xtensa_insnbuf_alloc (isa);
4204       slotbuf = xtensa_insnbuf_alloc (isa);
4205     }
4206
4207   xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4208                              content_len - offset);
4209   fmt = xtensa_format_decode (isa, insnbuf);
4210   if (fmt == XTENSA_UNDEFINED)
4211     return XTENSA_UNDEFINED;
4212
4213   if (slot >= xtensa_format_num_slots (isa, fmt))
4214     return XTENSA_UNDEFINED;
4215
4216   xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
4217   return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
4218 }
4219
4220
4221 /* The offset is the offset in the contents.
4222    The address is the address of that offset.  */
4223
4224 static bfd_boolean
4225 check_branch_target_aligned (bfd_byte *contents,
4226                              bfd_size_type content_length,
4227                              bfd_vma offset,
4228                              bfd_vma address)
4229 {
4230   bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
4231   if (insn_len == 0)
4232     return FALSE;
4233   return check_branch_target_aligned_address (address, insn_len);
4234 }
4235
4236
4237 static bfd_boolean
4238 check_loop_aligned (bfd_byte *contents,
4239                     bfd_size_type content_length,
4240                     bfd_vma offset,
4241                     bfd_vma address)
4242 {
4243   bfd_size_type loop_len, insn_len;
4244   xtensa_opcode opcode;
4245
4246   opcode = insn_decode_opcode (contents, content_length, offset, 0);
4247   if (opcode == XTENSA_UNDEFINED
4248       || xtensa_opcode_is_loop (xtensa_default_isa, opcode) != 1)
4249     {
4250       BFD_ASSERT (FALSE);
4251       return FALSE;
4252     }
4253
4254   loop_len = insn_decode_len (contents, content_length, offset);
4255   insn_len = insn_decode_len (contents, content_length, offset + loop_len);
4256   if (loop_len == 0 || insn_len == 0)
4257     {
4258       BFD_ASSERT (FALSE);
4259       return FALSE;
4260     }
4261
4262   return check_branch_target_aligned_address (address + loop_len, insn_len);
4263 }
4264
4265
4266 static bfd_boolean
4267 check_branch_target_aligned_address (bfd_vma addr, int len)
4268 {
4269   if (len == 8)
4270     return (addr % 8 == 0);
4271   return ((addr >> 2) == ((addr + len - 1) >> 2));
4272 }
4273
4274 \f
4275 /* Instruction widening and narrowing.  */
4276
4277 /* When FLIX is available we need to access certain instructions only
4278    when they are 16-bit or 24-bit instructions.  This table caches
4279    information about such instructions by walking through all the
4280    opcodes and finding the smallest single-slot format into which each
4281    can be encoded.  */
4282
4283 static xtensa_format *op_single_fmt_table = NULL;
4284
4285
4286 static void
4287 init_op_single_format_table (void)
4288 {
4289   xtensa_isa isa = xtensa_default_isa;
4290   xtensa_insnbuf ibuf;
4291   xtensa_opcode opcode;
4292   xtensa_format fmt;
4293   int num_opcodes;
4294
4295   if (op_single_fmt_table)
4296     return;
4297
4298   ibuf = xtensa_insnbuf_alloc (isa);
4299   num_opcodes = xtensa_isa_num_opcodes (isa);
4300
4301   op_single_fmt_table = (xtensa_format *)
4302     bfd_malloc (sizeof (xtensa_format) * num_opcodes);
4303   for (opcode = 0; opcode < num_opcodes; opcode++)
4304     {
4305       op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
4306       for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
4307         {
4308           if (xtensa_format_num_slots (isa, fmt) == 1
4309               && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
4310             {
4311               xtensa_opcode old_fmt = op_single_fmt_table[opcode];
4312               int fmt_length = xtensa_format_length (isa, fmt);
4313               if (old_fmt == XTENSA_UNDEFINED
4314                   || fmt_length < xtensa_format_length (isa, old_fmt))
4315                 op_single_fmt_table[opcode] = fmt;
4316             }
4317         }
4318     }
4319   xtensa_insnbuf_free (isa, ibuf);
4320 }
4321
4322
4323 static xtensa_format
4324 get_single_format (xtensa_opcode opcode)
4325 {
4326   init_op_single_format_table ();
4327   return op_single_fmt_table[opcode];
4328 }
4329
4330
4331 /* For the set of narrowable instructions we do NOT include the
4332    narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4333    involved during linker relaxation that may require these to
4334    re-expand in some conditions.  Also, the narrowing "or" -> mov.n
4335    requires special case code to ensure it only works when op1 == op2.  */
4336
4337 struct string_pair
4338 {
4339   const char *wide;
4340   const char *narrow;
4341 };
4342
4343 struct string_pair narrowable[] =
4344 {
4345   { "add", "add.n" },
4346   { "addi", "addi.n" },
4347   { "addmi", "addi.n" },
4348   { "l32i", "l32i.n" },
4349   { "movi", "movi.n" },
4350   { "ret", "ret.n" },
4351   { "retw", "retw.n" },
4352   { "s32i", "s32i.n" },
4353   { "or", "mov.n" } /* special case only when op1 == op2 */
4354 };
4355
4356 struct string_pair widenable[] =
4357 {
4358   { "add", "add.n" },
4359   { "addi", "addi.n" },
4360   { "addmi", "addi.n" },
4361   { "beqz", "beqz.n" },
4362   { "bnez", "bnez.n" },
4363   { "l32i", "l32i.n" },
4364   { "movi", "movi.n" },
4365   { "ret", "ret.n" },
4366   { "retw", "retw.n" },
4367   { "s32i", "s32i.n" },
4368   { "or", "mov.n" } /* special case only when op1 == op2 */
4369 };
4370
4371
4372 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4373    3-byte instruction to a 2-byte "density" instruction.  If it is valid,
4374    return the instruction buffer holding the narrow instruction.  Otherwise,
4375    return 0.  The set of valid narrowing are specified by a string table
4376    but require some special case operand checks in some cases.  */
4377
4378 static xtensa_insnbuf
4379 can_narrow_instruction (xtensa_insnbuf slotbuf,
4380                         xtensa_format fmt,
4381                         xtensa_opcode opcode)
4382 {
4383   xtensa_isa isa = xtensa_default_isa;
4384   xtensa_format o_fmt;
4385   unsigned opi;
4386
4387   static xtensa_insnbuf o_insnbuf = NULL;
4388   static xtensa_insnbuf o_slotbuf = NULL;
4389
4390   if (o_insnbuf == NULL)
4391     {
4392       o_insnbuf = xtensa_insnbuf_alloc (isa);
4393       o_slotbuf = xtensa_insnbuf_alloc (isa);
4394     }
4395
4396   for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); opi++)
4397     {
4398       bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
4399
4400       if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
4401         {
4402           uint32 value, newval;
4403           int i, operand_count, o_operand_count;
4404           xtensa_opcode o_opcode;
4405
4406           /* Address does not matter in this case.  We might need to
4407              fix it to handle branches/jumps.  */
4408           bfd_vma self_address = 0;
4409
4410           o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
4411           if (o_opcode == XTENSA_UNDEFINED)
4412             return 0;
4413           o_fmt = get_single_format (o_opcode);
4414           if (o_fmt == XTENSA_UNDEFINED)
4415             return 0;
4416
4417           if (xtensa_format_length (isa, fmt) != 3
4418               || xtensa_format_length (isa, o_fmt) != 2)
4419             return 0;
4420
4421           xtensa_format_encode (isa, o_fmt, o_insnbuf);
4422           operand_count = xtensa_opcode_num_operands (isa, opcode);
4423           o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4424
4425           if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4426             return 0;
4427
4428           if (!is_or)
4429             {
4430               if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4431                 return 0;
4432             }
4433           else
4434             {
4435               uint32 rawval0, rawval1, rawval2;
4436
4437               if (o_operand_count + 1 != operand_count
4438                   || xtensa_operand_get_field (isa, opcode, 0,
4439                                                fmt, 0, slotbuf, &rawval0) != 0
4440                   || xtensa_operand_get_field (isa, opcode, 1,
4441                                                fmt, 0, slotbuf, &rawval1) != 0
4442                   || xtensa_operand_get_field (isa, opcode, 2,
4443                                                fmt, 0, slotbuf, &rawval2) != 0
4444                   || rawval1 != rawval2
4445                   || rawval0 == rawval1 /* it is a nop */)
4446                 return 0;
4447             }
4448
4449           for (i = 0; i < o_operand_count; ++i)
4450             {
4451               if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
4452                                             slotbuf, &value)
4453                   || xtensa_operand_decode (isa, opcode, i, &value))
4454                 return 0;
4455
4456               /* PC-relative branches need adjustment, but
4457                  the PC-rel operand will always have a relocation.  */
4458               newval = value;
4459               if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4460                                            self_address)
4461                   || xtensa_operand_encode (isa, o_opcode, i, &newval)
4462                   || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4463                                                o_slotbuf, newval))
4464                 return 0;
4465             }
4466
4467           if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4468             return 0;
4469
4470           return o_insnbuf;
4471         }
4472     }
4473   return 0;
4474 }
4475
4476
4477 /* Attempt to narrow an instruction.  If the narrowing is valid, perform
4478    the action in-place directly into the contents and return TRUE.  Otherwise,
4479    the return value is FALSE and the contents are not modified.  */
4480
4481 static bfd_boolean
4482 narrow_instruction (bfd_byte *contents,
4483                     bfd_size_type content_length,
4484                     bfd_size_type offset)
4485 {
4486   xtensa_opcode opcode;
4487   bfd_size_type insn_len;
4488   xtensa_isa isa = xtensa_default_isa;
4489   xtensa_format fmt;
4490   xtensa_insnbuf o_insnbuf;
4491
4492   static xtensa_insnbuf insnbuf = NULL;
4493   static xtensa_insnbuf slotbuf = NULL;
4494
4495   if (insnbuf == NULL)
4496     {
4497       insnbuf = xtensa_insnbuf_alloc (isa);
4498       slotbuf = xtensa_insnbuf_alloc (isa);
4499     }
4500
4501   BFD_ASSERT (offset < content_length);
4502
4503   if (content_length < 2)
4504     return FALSE;
4505
4506   /* We will hand-code a few of these for a little while.
4507      These have all been specified in the assembler aleady.  */
4508   xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4509                              content_length - offset);
4510   fmt = xtensa_format_decode (isa, insnbuf);
4511   if (xtensa_format_num_slots (isa, fmt) != 1)
4512     return FALSE;
4513
4514   if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4515     return FALSE;
4516
4517   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4518   if (opcode == XTENSA_UNDEFINED)
4519     return FALSE;
4520   insn_len = xtensa_format_length (isa, fmt);
4521   if (insn_len > content_length)
4522     return FALSE;
4523
4524   o_insnbuf = can_narrow_instruction (slotbuf, fmt, opcode);
4525   if (o_insnbuf)
4526     {
4527       xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4528                                content_length - offset);
4529       return TRUE;
4530     }
4531
4532   return FALSE;
4533 }
4534
4535
4536 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4537    "density" instruction to a standard 3-byte instruction.  If it is valid,
4538    return the instruction buffer holding the wide instruction.  Otherwise,
4539    return 0.  The set of valid widenings are specified by a string table
4540    but require some special case operand checks in some cases.  */
4541
4542 static xtensa_insnbuf
4543 can_widen_instruction (xtensa_insnbuf slotbuf,
4544                        xtensa_format fmt,
4545                        xtensa_opcode opcode)
4546 {
4547   xtensa_isa isa = xtensa_default_isa;
4548   xtensa_format o_fmt;
4549   unsigned opi;
4550
4551   static xtensa_insnbuf o_insnbuf = NULL;
4552   static xtensa_insnbuf o_slotbuf = NULL;
4553
4554   if (o_insnbuf == NULL)
4555     {
4556       o_insnbuf = xtensa_insnbuf_alloc (isa);
4557       o_slotbuf = xtensa_insnbuf_alloc (isa);
4558     }
4559
4560   for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); opi++)
4561     {
4562       bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
4563       bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
4564                                || strcmp ("bnez", widenable[opi].wide) == 0);
4565
4566       if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
4567         {
4568           uint32 value, newval;
4569           int i, operand_count, o_operand_count, check_operand_count;
4570           xtensa_opcode o_opcode;
4571
4572           /* Address does not matter in this case.  We might need to fix it
4573              to handle branches/jumps.  */
4574           bfd_vma self_address = 0;
4575
4576           o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
4577           if (o_opcode == XTENSA_UNDEFINED)
4578             return 0;
4579           o_fmt = get_single_format (o_opcode);
4580           if (o_fmt == XTENSA_UNDEFINED)
4581             return 0;
4582
4583           if (xtensa_format_length (isa, fmt) != 2
4584               || xtensa_format_length (isa, o_fmt) != 3)
4585             return 0;
4586
4587           xtensa_format_encode (isa, o_fmt, o_insnbuf);
4588           operand_count = xtensa_opcode_num_operands (isa, opcode);
4589           o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4590           check_operand_count = o_operand_count;
4591
4592           if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4593             return 0;
4594
4595           if (!is_or)
4596             {
4597               if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4598                 return 0;
4599             }
4600           else
4601             {
4602               uint32 rawval0, rawval1;
4603
4604               if (o_operand_count != operand_count + 1
4605                   || xtensa_operand_get_field (isa, opcode, 0,
4606                                                fmt, 0, slotbuf, &rawval0) != 0
4607                   || xtensa_operand_get_field (isa, opcode, 1,
4608                                                fmt, 0, slotbuf, &rawval1) != 0
4609                   || rawval0 == rawval1 /* it is a nop */)
4610                 return 0;
4611             }
4612           if (is_branch)
4613             check_operand_count--;
4614
4615           for (i = 0; i < check_operand_count; i++)
4616             {
4617               int new_i = i;
4618               if (is_or && i == o_operand_count - 1)
4619                 new_i = i - 1;
4620               if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
4621                                             slotbuf, &value)
4622                   || xtensa_operand_decode (isa, opcode, new_i, &value))
4623                 return 0;
4624
4625               /* PC-relative branches need adjustment, but
4626                  the PC-rel operand will always have a relocation.  */
4627               newval = value;
4628               if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4629                                            self_address)
4630                   || xtensa_operand_encode (isa, o_opcode, i, &newval)
4631                   || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4632                                                o_slotbuf, newval))
4633                 return 0;
4634             }
4635
4636           if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4637             return 0;
4638
4639           return o_insnbuf;
4640         }
4641     }
4642   return 0;
4643 }
4644
4645
4646 /* Attempt to widen an instruction.  If the widening is valid, perform
4647    the action in-place directly into the contents and return TRUE.  Otherwise,
4648    the return value is FALSE and the contents are not modified.  */
4649
4650 static bfd_boolean
4651 widen_instruction (bfd_byte *contents,
4652                    bfd_size_type content_length,
4653                    bfd_size_type offset)
4654 {
4655   xtensa_opcode opcode;
4656   bfd_size_type insn_len;
4657   xtensa_isa isa = xtensa_default_isa;
4658   xtensa_format fmt;
4659   xtensa_insnbuf o_insnbuf;
4660
4661   static xtensa_insnbuf insnbuf = NULL;
4662   static xtensa_insnbuf slotbuf = NULL;
4663
4664   if (insnbuf == NULL)
4665     {
4666       insnbuf = xtensa_insnbuf_alloc (isa);
4667       slotbuf = xtensa_insnbuf_alloc (isa);
4668     }
4669
4670   BFD_ASSERT (offset < content_length);
4671
4672   if (content_length < 2)
4673     return FALSE;
4674
4675   /* We will hand-code a few of these for a little while.
4676      These have all been specified in the assembler aleady.  */
4677   xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4678                              content_length - offset);
4679   fmt = xtensa_format_decode (isa, insnbuf);
4680   if (xtensa_format_num_slots (isa, fmt) != 1)
4681     return FALSE;
4682
4683   if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4684     return FALSE;
4685
4686   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4687   if (opcode == XTENSA_UNDEFINED)
4688     return FALSE;
4689   insn_len = xtensa_format_length (isa, fmt);
4690   if (insn_len > content_length)
4691     return FALSE;
4692
4693   o_insnbuf = can_widen_instruction (slotbuf, fmt, opcode);
4694   if (o_insnbuf)
4695     {
4696       xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4697                                content_length - offset);
4698       return TRUE;
4699     }
4700   return FALSE;
4701 }
4702
4703 \f
4704 /* Code for transforming CALLs at link-time.  */
4705
4706 static bfd_reloc_status_type
4707 elf_xtensa_do_asm_simplify (bfd_byte *contents,
4708                             bfd_vma address,
4709                             bfd_vma content_length,
4710                             char **error_message)
4711 {
4712   static xtensa_insnbuf insnbuf = NULL;
4713   static xtensa_insnbuf slotbuf = NULL;
4714   xtensa_format core_format = XTENSA_UNDEFINED;
4715   xtensa_opcode opcode;
4716   xtensa_opcode direct_call_opcode;
4717   xtensa_isa isa = xtensa_default_isa;
4718   bfd_byte *chbuf = contents + address;
4719   int opn;
4720
4721   if (insnbuf == NULL)
4722     {
4723       insnbuf = xtensa_insnbuf_alloc (isa);
4724       slotbuf = xtensa_insnbuf_alloc (isa);
4725     }
4726
4727   if (content_length < address)
4728     {
4729       *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4730       return bfd_reloc_other;
4731     }
4732
4733   opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
4734   direct_call_opcode = swap_callx_for_call_opcode (opcode);
4735   if (direct_call_opcode == XTENSA_UNDEFINED)
4736     {
4737       *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4738       return bfd_reloc_other;
4739     }
4740
4741   /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset.  */
4742   core_format = xtensa_format_lookup (isa, "x24");
4743   opcode = xtensa_opcode_lookup (isa, "or");
4744   xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
4745   for (opn = 0; opn < 3; opn++)
4746     {
4747       uint32 regno = 1;
4748       xtensa_operand_encode (isa, opcode, opn, &regno);
4749       xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
4750                                 slotbuf, regno);
4751     }
4752   xtensa_format_encode (isa, core_format, insnbuf);
4753   xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4754   xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
4755
4756   /* Assemble a CALL ("callN 0") into the 3 byte offset.  */
4757   xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
4758   xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
4759
4760   xtensa_format_encode (isa, core_format, insnbuf);
4761   xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4762   xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
4763                            content_length - address - 3);
4764
4765   return bfd_reloc_ok;
4766 }
4767
4768
4769 static bfd_reloc_status_type
4770 contract_asm_expansion (bfd_byte *contents,
4771                         bfd_vma content_length,
4772                         Elf_Internal_Rela *irel,
4773                         char **error_message)
4774 {
4775   bfd_reloc_status_type retval =
4776     elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
4777                                 error_message);
4778
4779   if (retval != bfd_reloc_ok)
4780     return bfd_reloc_dangerous;
4781
4782   /* Update the irel->r_offset field so that the right immediate and
4783      the right instruction are modified during the relocation.  */
4784   irel->r_offset += 3;
4785   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
4786   return bfd_reloc_ok;
4787 }
4788
4789
4790 static xtensa_opcode
4791 swap_callx_for_call_opcode (xtensa_opcode opcode)
4792 {
4793   init_call_opcodes ();
4794
4795   if (opcode == callx0_op) return call0_op;
4796   if (opcode == callx4_op) return call4_op;
4797   if (opcode == callx8_op) return call8_op;
4798   if (opcode == callx12_op) return call12_op;
4799
4800   /* Return XTENSA_UNDEFINED if the opcode is not an indirect call.  */
4801   return XTENSA_UNDEFINED;
4802 }
4803
4804
4805 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4806    CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4807    If not, return XTENSA_UNDEFINED.  */
4808
4809 #define L32R_TARGET_REG_OPERAND 0
4810 #define CONST16_TARGET_REG_OPERAND 0
4811 #define CALLN_SOURCE_OPERAND 0
4812
4813 static xtensa_opcode
4814 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
4815 {
4816   static xtensa_insnbuf insnbuf = NULL;
4817   static xtensa_insnbuf slotbuf = NULL;
4818   xtensa_format fmt;
4819   xtensa_opcode opcode;
4820   xtensa_isa isa = xtensa_default_isa;
4821   uint32 regno, const16_regno, call_regno;
4822   int offset = 0;
4823
4824   if (insnbuf == NULL)
4825     {
4826       insnbuf = xtensa_insnbuf_alloc (isa);
4827       slotbuf = xtensa_insnbuf_alloc (isa);
4828     }
4829
4830   xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
4831   fmt = xtensa_format_decode (isa, insnbuf);
4832   if (fmt == XTENSA_UNDEFINED
4833       || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4834     return XTENSA_UNDEFINED;
4835
4836   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4837   if (opcode == XTENSA_UNDEFINED)
4838     return XTENSA_UNDEFINED;
4839
4840   if (opcode == get_l32r_opcode ())
4841     {
4842       if (p_uses_l32r)
4843         *p_uses_l32r = TRUE;
4844       if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
4845                                     fmt, 0, slotbuf, &regno)
4846           || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
4847                                     &regno))
4848         return XTENSA_UNDEFINED;
4849     }
4850   else if (opcode == get_const16_opcode ())
4851     {
4852       if (p_uses_l32r)
4853         *p_uses_l32r = FALSE;
4854       if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4855                                     fmt, 0, slotbuf, &regno)
4856           || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4857                                     &regno))
4858         return XTENSA_UNDEFINED;
4859
4860       /* Check that the next instruction is also CONST16.  */
4861       offset += xtensa_format_length (isa, fmt);
4862       xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4863       fmt = xtensa_format_decode (isa, insnbuf);
4864       if (fmt == XTENSA_UNDEFINED
4865           || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4866         return XTENSA_UNDEFINED;
4867       opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4868       if (opcode != get_const16_opcode ())
4869         return XTENSA_UNDEFINED;
4870
4871       if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4872                                     fmt, 0, slotbuf, &const16_regno)
4873           || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4874                                     &const16_regno)
4875           || const16_regno != regno)
4876         return XTENSA_UNDEFINED;
4877     }
4878   else
4879     return XTENSA_UNDEFINED;
4880
4881   /* Next instruction should be an CALLXn with operand 0 == regno.  */
4882   offset += xtensa_format_length (isa, fmt);
4883   xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4884   fmt = xtensa_format_decode (isa, insnbuf);
4885   if (fmt == XTENSA_UNDEFINED
4886       || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4887     return XTENSA_UNDEFINED;
4888   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4889   if (opcode == XTENSA_UNDEFINED
4890       || !is_indirect_call_opcode (opcode))
4891     return XTENSA_UNDEFINED;
4892
4893   if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4894                                 fmt, 0, slotbuf, &call_regno)
4895       || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4896                                 &call_regno))
4897     return XTENSA_UNDEFINED;
4898
4899   if (call_regno != regno)
4900     return XTENSA_UNDEFINED;
4901
4902   return opcode;
4903 }
4904
4905 \f
4906 /* Data structures used during relaxation.  */
4907
4908 /* r_reloc: relocation values.  */
4909
4910 /* Through the relaxation process, we need to keep track of the values
4911    that will result from evaluating relocations.  The standard ELF
4912    relocation structure is not sufficient for this purpose because we're
4913    operating on multiple input files at once, so we need to know which
4914    input file a relocation refers to.  The r_reloc structure thus
4915    records both the input file (bfd) and ELF relocation.
4916
4917    For efficiency, an r_reloc also contains a "target_offset" field to
4918    cache the target-section-relative offset value that is represented by
4919    the relocation.
4920
4921    The r_reloc also contains a virtual offset that allows multiple
4922    inserted literals to be placed at the same "address" with
4923    different offsets.  */
4924
4925 typedef struct r_reloc_struct r_reloc;
4926
4927 struct r_reloc_struct
4928 {
4929   bfd *abfd;
4930   Elf_Internal_Rela rela;
4931   bfd_vma target_offset;
4932   bfd_vma virtual_offset;
4933 };
4934
4935
4936 /* The r_reloc structure is included by value in literal_value, but not
4937    every literal_value has an associated relocation -- some are simple
4938    constants.  In such cases, we set all the fields in the r_reloc
4939    struct to zero.  The r_reloc_is_const function should be used to
4940    detect this case.  */
4941
4942 static bfd_boolean
4943 r_reloc_is_const (const r_reloc *r_rel)
4944 {
4945   return (r_rel->abfd == NULL);
4946 }
4947
4948
4949 static bfd_vma
4950 r_reloc_get_target_offset (const r_reloc *r_rel)
4951 {
4952   bfd_vma target_offset;
4953   unsigned long r_symndx;
4954
4955   BFD_ASSERT (!r_reloc_is_const (r_rel));
4956   r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4957   target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4958   return (target_offset + r_rel->rela.r_addend);
4959 }
4960
4961
4962 static struct elf_link_hash_entry *
4963 r_reloc_get_hash_entry (const r_reloc *r_rel)
4964 {
4965   unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4966   return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4967 }
4968
4969
4970 static asection *
4971 r_reloc_get_section (const r_reloc *r_rel)
4972 {
4973   unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4974   return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4975 }
4976
4977
4978 static bfd_boolean
4979 r_reloc_is_defined (const r_reloc *r_rel)
4980 {
4981   asection *sec;
4982   if (r_rel == NULL)
4983     return FALSE;
4984
4985   sec = r_reloc_get_section (r_rel);
4986   if (sec == bfd_abs_section_ptr
4987       || sec == bfd_com_section_ptr
4988       || sec == bfd_und_section_ptr)
4989     return FALSE;
4990   return TRUE;
4991 }
4992
4993
4994 static void
4995 r_reloc_init (r_reloc *r_rel,
4996               bfd *abfd,
4997               Elf_Internal_Rela *irel,
4998               bfd_byte *contents,
4999               bfd_size_type content_length)
5000 {
5001   int r_type;
5002   reloc_howto_type *howto;
5003
5004   if (irel)
5005     {
5006       r_rel->rela = *irel;
5007       r_rel->abfd = abfd;
5008       r_rel->target_offset = r_reloc_get_target_offset (r_rel);
5009       r_rel->virtual_offset = 0;
5010       r_type = ELF32_R_TYPE (r_rel->rela.r_info);
5011       howto = &elf_howto_table[r_type];
5012       if (howto->partial_inplace)
5013         {
5014           bfd_vma inplace_val;
5015           BFD_ASSERT (r_rel->rela.r_offset < content_length);
5016
5017           inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
5018           r_rel->target_offset += inplace_val;
5019         }
5020     }
5021   else
5022     memset (r_rel, 0, sizeof (r_reloc));
5023 }
5024
5025
5026 #if DEBUG
5027
5028 static void
5029 print_r_reloc (FILE *fp, const r_reloc *r_rel)
5030 {
5031   if (r_reloc_is_defined (r_rel))
5032     {
5033       asection *sec = r_reloc_get_section (r_rel);
5034       fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
5035     }
5036   else if (r_reloc_get_hash_entry (r_rel))
5037     fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
5038   else
5039     fprintf (fp, " ?? + ");
5040
5041   fprintf_vma (fp, r_rel->target_offset);
5042   if (r_rel->virtual_offset)
5043     {
5044       fprintf (fp, " + ");
5045       fprintf_vma (fp, r_rel->virtual_offset);
5046     }
5047
5048   fprintf (fp, ")");
5049 }
5050
5051 #endif /* DEBUG */
5052
5053 \f
5054 /* source_reloc: relocations that reference literals.  */
5055
5056 /* To determine whether literals can be coalesced, we need to first
5057    record all the relocations that reference the literals.  The
5058    source_reloc structure below is used for this purpose.  The
5059    source_reloc entries are kept in a per-literal-section array, sorted
5060    by offset within the literal section (i.e., target offset).
5061
5062    The source_sec and r_rel.rela.r_offset fields identify the source of
5063    the relocation.  The r_rel field records the relocation value, i.e.,
5064    the offset of the literal being referenced.  The opnd field is needed
5065    to determine the range of the immediate field to which the relocation
5066    applies, so we can determine whether another literal with the same
5067    value is within range.  The is_null field is true when the relocation
5068    is being removed (e.g., when an L32R is being removed due to a CALLX
5069    that is converted to a direct CALL).  */
5070
5071 typedef struct source_reloc_struct source_reloc;
5072
5073 struct source_reloc_struct
5074 {
5075   asection *source_sec;
5076   r_reloc r_rel;
5077   xtensa_opcode opcode;
5078   int opnd;
5079   bfd_boolean is_null;
5080   bfd_boolean is_abs_literal;
5081 };
5082
5083
5084 static void
5085 init_source_reloc (source_reloc *reloc,
5086                    asection *source_sec,
5087                    const r_reloc *r_rel,
5088                    xtensa_opcode opcode,
5089                    int opnd,
5090                    bfd_boolean is_abs_literal)
5091 {
5092   reloc->source_sec = source_sec;
5093   reloc->r_rel = *r_rel;
5094   reloc->opcode = opcode;
5095   reloc->opnd = opnd;
5096   reloc->is_null = FALSE;
5097   reloc->is_abs_literal = is_abs_literal;
5098 }
5099
5100
5101 /* Find the source_reloc for a particular source offset and relocation
5102    type.  Note that the array is sorted by _target_ offset, so this is
5103    just a linear search.  */
5104
5105 static source_reloc *
5106 find_source_reloc (source_reloc *src_relocs,
5107                    int src_count,
5108                    asection *sec,
5109                    Elf_Internal_Rela *irel)
5110 {
5111   int i;
5112
5113   for (i = 0; i < src_count; i++)
5114     {
5115       if (src_relocs[i].source_sec == sec
5116           && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
5117           && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
5118               == ELF32_R_TYPE (irel->r_info)))
5119         return &src_relocs[i];
5120     }
5121
5122   return NULL;
5123 }
5124
5125
5126 static int
5127 source_reloc_compare (const void *ap, const void *bp)
5128 {
5129   const source_reloc *a = (const source_reloc *) ap;
5130   const source_reloc *b = (const source_reloc *) bp;
5131
5132   if (a->r_rel.target_offset != b->r_rel.target_offset)
5133     return (a->r_rel.target_offset - b->r_rel.target_offset);
5134
5135   /* We don't need to sort on these criteria for correctness,
5136      but enforcing a more strict ordering prevents unstable qsort
5137      from behaving differently with different implementations.
5138      Without the code below we get correct but different results
5139      on Solaris 2.7 and 2.8.  We would like to always produce the
5140      same results no matter the host. */
5141
5142   if ((!a->is_null) - (!b->is_null))
5143     return ((!a->is_null) - (!b->is_null));
5144   return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
5145 }
5146
5147 \f
5148 /* Literal values and value hash tables.  */
5149
5150 /* Literals with the same value can be coalesced.  The literal_value
5151    structure records the value of a literal: the "r_rel" field holds the
5152    information from the relocation on the literal (if there is one) and
5153    the "value" field holds the contents of the literal word itself.
5154
5155    The value_map structure records a literal value along with the
5156    location of a literal holding that value.  The value_map hash table
5157    is indexed by the literal value, so that we can quickly check if a
5158    particular literal value has been seen before and is thus a candidate
5159    for coalescing.  */
5160
5161 typedef struct literal_value_struct literal_value;
5162 typedef struct value_map_struct value_map;
5163 typedef struct value_map_hash_table_struct value_map_hash_table;
5164
5165 struct literal_value_struct
5166 {
5167   r_reloc r_rel;
5168   unsigned long value;
5169   bfd_boolean is_abs_literal;
5170 };
5171
5172 struct value_map_struct
5173 {
5174   literal_value val;                    /* The literal value.  */
5175   r_reloc loc;                          /* Location of the literal.  */
5176   value_map *next;
5177 };
5178
5179 struct value_map_hash_table_struct
5180 {
5181   unsigned bucket_count;
5182   value_map **buckets;
5183   unsigned count;
5184   bfd_boolean has_last_loc;
5185   r_reloc last_loc;
5186 };
5187
5188
5189 static void
5190 init_literal_value (literal_value *lit,
5191                     const r_reloc *r_rel,
5192                     unsigned long value,
5193                     bfd_boolean is_abs_literal)
5194 {
5195   lit->r_rel = *r_rel;
5196   lit->value = value;
5197   lit->is_abs_literal = is_abs_literal;
5198 }
5199
5200
5201 static bfd_boolean
5202 literal_value_equal (const literal_value *src1,
5203                      const literal_value *src2,
5204                      bfd_boolean final_static_link)
5205 {
5206   struct elf_link_hash_entry *h1, *h2;
5207
5208   if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
5209     return FALSE;
5210
5211   if (r_reloc_is_const (&src1->r_rel))
5212     return (src1->value == src2->value);
5213
5214   if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
5215       != ELF32_R_TYPE (src2->r_rel.rela.r_info))
5216     return FALSE;
5217
5218   if (src1->r_rel.target_offset != src2->r_rel.target_offset)
5219     return FALSE;
5220
5221   if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
5222     return FALSE;
5223
5224   if (src1->value != src2->value)
5225     return FALSE;
5226
5227   /* Now check for the same section (if defined) or the same elf_hash
5228      (if undefined or weak).  */
5229   h1 = r_reloc_get_hash_entry (&src1->r_rel);
5230   h2 = r_reloc_get_hash_entry (&src2->r_rel);
5231   if (r_reloc_is_defined (&src1->r_rel)
5232       && (final_static_link
5233           || ((!h1 || h1->root.type != bfd_link_hash_defweak)
5234               && (!h2 || h2->root.type != bfd_link_hash_defweak))))
5235     {
5236       if (r_reloc_get_section (&src1->r_rel)
5237           != r_reloc_get_section (&src2->r_rel))
5238         return FALSE;
5239     }
5240   else
5241     {
5242       /* Require that the hash entries (i.e., symbols) be identical.  */
5243       if (h1 != h2 || h1 == 0)
5244         return FALSE;
5245     }
5246
5247   if (src1->is_abs_literal != src2->is_abs_literal)
5248     return FALSE;
5249
5250   return TRUE;
5251 }
5252
5253
5254 /* Must be power of 2.  */
5255 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5256
5257 static value_map_hash_table *
5258 value_map_hash_table_init (void)
5259 {
5260   value_map_hash_table *values;
5261
5262   values = (value_map_hash_table *)
5263     bfd_zmalloc (sizeof (value_map_hash_table));
5264   values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
5265   values->count = 0;
5266   values->buckets = (value_map **)
5267     bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
5268   if (values->buckets == NULL)
5269     {
5270       free (values);
5271       return NULL;
5272     }
5273   values->has_last_loc = FALSE;
5274
5275   return values;
5276 }
5277
5278
5279 static void
5280 value_map_hash_table_delete (value_map_hash_table *table)
5281 {
5282   free (table->buckets);
5283   free (table);
5284 }
5285
5286
5287 static unsigned
5288 hash_bfd_vma (bfd_vma val)
5289 {
5290   return (val >> 2) + (val >> 10);
5291 }
5292
5293
5294 static unsigned
5295 literal_value_hash (const literal_value *src)
5296 {
5297   unsigned hash_val;
5298
5299   hash_val = hash_bfd_vma (src->value);
5300   if (!r_reloc_is_const (&src->r_rel))
5301     {
5302       void *sec_or_hash;
5303
5304       hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
5305       hash_val += hash_bfd_vma (src->r_rel.target_offset);
5306       hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
5307
5308       /* Now check for the same section and the same elf_hash.  */
5309       if (r_reloc_is_defined (&src->r_rel))
5310         sec_or_hash = r_reloc_get_section (&src->r_rel);
5311       else
5312         sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
5313       hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
5314     }
5315   return hash_val;
5316 }
5317
5318
5319 /* Check if the specified literal_value has been seen before.  */
5320
5321 static value_map *
5322 value_map_get_cached_value (value_map_hash_table *map,
5323                             const literal_value *val,
5324                             bfd_boolean final_static_link)
5325 {
5326   value_map *map_e;
5327   value_map *bucket;
5328   unsigned idx;
5329
5330   idx = literal_value_hash (val);
5331   idx = idx & (map->bucket_count - 1);
5332   bucket = map->buckets[idx];
5333   for (map_e = bucket; map_e; map_e = map_e->next)
5334     {
5335       if (literal_value_equal (&map_e->val, val, final_static_link))
5336         return map_e;
5337     }
5338   return NULL;
5339 }
5340
5341
5342 /* Record a new literal value.  It is illegal to call this if VALUE
5343    already has an entry here.  */
5344
5345 static value_map *
5346 add_value_map (value_map_hash_table *map,
5347                const literal_value *val,
5348                const r_reloc *loc,
5349                bfd_boolean final_static_link)
5350 {
5351   value_map **bucket_p;
5352   unsigned idx;
5353
5354   value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
5355   if (val_e == NULL)
5356     {
5357       bfd_set_error (bfd_error_no_memory);
5358       return NULL;
5359     }
5360
5361   BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
5362   val_e->val = *val;
5363   val_e->loc = *loc;
5364
5365   idx = literal_value_hash (val);
5366   idx = idx & (map->bucket_count - 1);
5367   bucket_p = &map->buckets[idx];
5368
5369   val_e->next = *bucket_p;
5370   *bucket_p = val_e;
5371   map->count++;
5372   /* FIXME: Consider resizing the hash table if we get too many entries.  */
5373
5374   return val_e;
5375 }
5376
5377 \f
5378 /* Lists of text actions (ta_) for narrowing, widening, longcall
5379    conversion, space fill, code & literal removal, etc.  */
5380
5381 /* The following text actions are generated:
5382
5383    "ta_remove_insn"         remove an instruction or instructions
5384    "ta_remove_longcall"     convert longcall to call
5385    "ta_convert_longcall"    convert longcall to nop/call
5386    "ta_narrow_insn"         narrow a wide instruction
5387    "ta_widen"               widen a narrow instruction
5388    "ta_fill"                add fill or remove fill
5389       removed < 0 is a fill; branches to the fill address will be
5390         changed to address + fill size (e.g., address - removed)
5391       removed >= 0 branches to the fill address will stay unchanged
5392    "ta_remove_literal"      remove a literal; this action is
5393                             indicated when a literal is removed
5394                             or replaced.
5395    "ta_add_literal"         insert a new literal; this action is
5396                             indicated when a literal has been moved.
5397                             It may use a virtual_offset because
5398                             multiple literals can be placed at the
5399                             same location.
5400
5401    For each of these text actions, we also record the number of bytes
5402    removed by performing the text action.  In the case of a "ta_widen"
5403    or a "ta_fill" that adds space, the removed_bytes will be negative.  */
5404
5405 typedef struct text_action_struct text_action;
5406 typedef struct text_action_list_struct text_action_list;
5407 typedef enum text_action_enum_t text_action_t;
5408
5409 enum text_action_enum_t
5410 {
5411   ta_none,
5412   ta_remove_insn,        /* removed = -size */
5413   ta_remove_longcall,    /* removed = -size */
5414   ta_convert_longcall,   /* removed = 0 */
5415   ta_narrow_insn,        /* removed = -1 */
5416   ta_widen_insn,         /* removed = +1 */
5417   ta_fill,               /* removed = +size */
5418   ta_remove_literal,
5419   ta_add_literal
5420 };
5421
5422
5423 /* Structure for a text action record.  */
5424 struct text_action_struct
5425 {
5426   text_action_t action;
5427   asection *sec;        /* Optional */
5428   bfd_vma offset;
5429   bfd_vma virtual_offset;  /* Zero except for adding literals.  */
5430   int removed_bytes;
5431   literal_value value;  /* Only valid when adding literals.  */
5432 };
5433
5434 struct removal_by_action_entry_struct
5435 {
5436   bfd_vma offset;
5437   int removed;
5438   int eq_removed;
5439   int eq_removed_before_fill;
5440 };
5441 typedef struct removal_by_action_entry_struct removal_by_action_entry;
5442
5443 struct removal_by_action_map_struct
5444 {
5445   unsigned n_entries;
5446   removal_by_action_entry *entry;
5447 };
5448 typedef struct removal_by_action_map_struct removal_by_action_map;
5449
5450
5451 /* List of all of the actions taken on a text section.  */
5452 struct text_action_list_struct
5453 {
5454   unsigned count;
5455   splay_tree tree;
5456   removal_by_action_map map;
5457 };
5458
5459
5460 static text_action *
5461 find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
5462 {
5463   text_action a;
5464
5465   /* It is not necessary to fill at the end of a section.  */
5466   if (sec->size == offset)
5467     return NULL;
5468
5469   a.offset = offset;
5470   a.action = ta_fill;
5471
5472   splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a);
5473   if (node)
5474     return (text_action *)node->value;
5475   return NULL;
5476 }
5477
5478
5479 static int
5480 compute_removed_action_diff (const text_action *ta,
5481                              asection *sec,
5482                              bfd_vma offset,
5483                              int removed,
5484                              int removable_space)
5485 {
5486   int new_removed;
5487   int current_removed = 0;
5488
5489   if (ta)
5490     current_removed = ta->removed_bytes;
5491
5492   BFD_ASSERT (ta == NULL || ta->offset == offset);
5493   BFD_ASSERT (ta == NULL || ta->action == ta_fill);
5494
5495   /* It is not necessary to fill at the end of a section.  Clean this up.  */
5496   if (sec->size == offset)
5497     new_removed = removable_space - 0;
5498   else
5499     {
5500       int space;
5501       int added = -removed - current_removed;
5502       /* Ignore multiples of the section alignment.  */
5503       added = ((1 << sec->alignment_power) - 1) & added;
5504       new_removed = (-added);
5505
5506       /* Modify for removable.  */
5507       space = removable_space - new_removed;
5508       new_removed = (removable_space
5509                      - (((1 << sec->alignment_power) - 1) & space));
5510     }
5511   return (new_removed - current_removed);
5512 }
5513
5514
5515 static void
5516 adjust_fill_action (text_action *ta, int fill_diff)
5517 {
5518   ta->removed_bytes += fill_diff;
5519 }
5520
5521
5522 static int
5523 text_action_compare (splay_tree_key a, splay_tree_key b)
5524 {
5525   text_action *pa = (text_action *)a;
5526   text_action *pb = (text_action *)b;
5527   static const int action_priority[] =
5528     {
5529       [ta_fill] = 0,
5530       [ta_none] = 1,
5531       [ta_convert_longcall] = 2,
5532       [ta_narrow_insn] = 3,
5533       [ta_remove_insn] = 4,
5534       [ta_remove_longcall] = 5,
5535       [ta_remove_literal] = 6,
5536       [ta_widen_insn] = 7,
5537       [ta_add_literal] = 8,
5538     };
5539
5540   if (pa->offset == pb->offset)
5541     {
5542       if (pa->action == pb->action)
5543           return 0;
5544       return action_priority[pa->action] - action_priority[pb->action];
5545     }
5546   else
5547     return pa->offset < pb->offset ? -1 : 1;
5548 }
5549
5550 static text_action *
5551 action_first (text_action_list *action_list)
5552 {
5553   splay_tree_node node = splay_tree_min (action_list->tree);
5554   return node ? (text_action *)node->value : NULL;
5555 }
5556
5557 static text_action *
5558 action_next (text_action_list *action_list, text_action *action)
5559 {
5560   splay_tree_node node = splay_tree_successor (action_list->tree,
5561                                                (splay_tree_key)action);
5562   return node ? (text_action *)node->value : NULL;
5563 }
5564
5565 /* Add a modification action to the text.  For the case of adding or
5566    removing space, modify any current fill and assume that
5567    "unreachable_space" bytes can be freely contracted.  Note that a
5568    negative removed value is a fill.  */
5569
5570 static void
5571 text_action_add (text_action_list *l,
5572                  text_action_t action,
5573                  asection *sec,
5574                  bfd_vma offset,
5575                  int removed)
5576 {
5577   text_action *ta;
5578   text_action a;
5579
5580   /* It is not necessary to fill at the end of a section.  */
5581   if (action == ta_fill && sec->size == offset)
5582     return;
5583
5584   /* It is not necessary to fill 0 bytes.  */
5585   if (action == ta_fill && removed == 0)
5586     return;
5587
5588   a.action = action;
5589   a.offset = offset;
5590
5591   if (action == ta_fill)
5592     {
5593       splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a);
5594
5595       if (node)
5596         {
5597           ta = (text_action *)node->value;
5598           ta->removed_bytes += removed;
5599           return;
5600         }
5601     }
5602   else
5603     BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)&a) == NULL);
5604
5605   ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5606   ta->action = action;
5607   ta->sec = sec;
5608   ta->offset = offset;
5609   ta->removed_bytes = removed;
5610   splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta);
5611   ++l->count;
5612 }
5613
5614
5615 static void
5616 text_action_add_literal (text_action_list *l,
5617                          text_action_t action,
5618                          const r_reloc *loc,
5619                          const literal_value *value,
5620                          int removed)
5621 {
5622   text_action *ta;
5623   asection *sec = r_reloc_get_section (loc);
5624   bfd_vma offset = loc->target_offset;
5625   bfd_vma virtual_offset = loc->virtual_offset;
5626
5627   BFD_ASSERT (action == ta_add_literal);
5628
5629   /* Create a new record and fill it up.  */
5630   ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5631   ta->action = action;
5632   ta->sec = sec;
5633   ta->offset = offset;
5634   ta->virtual_offset = virtual_offset;
5635   ta->value = *value;
5636   ta->removed_bytes = removed;
5637
5638   BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)ta) == NULL);
5639   splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta);
5640   ++l->count;
5641 }
5642
5643
5644 /* Find the total offset adjustment for the relaxations specified by
5645    text_actions, beginning from a particular starting action.  This is
5646    typically used from offset_with_removed_text to search an entire list of
5647    actions, but it may also be called directly when adjusting adjacent offsets
5648    so that each search may begin where the previous one left off.  */
5649
5650 static int
5651 removed_by_actions (text_action_list *action_list,
5652                     text_action **p_start_action,
5653                     bfd_vma offset,
5654                     bfd_boolean before_fill)
5655 {
5656   text_action *r;
5657   int removed = 0;
5658
5659   r = *p_start_action;
5660   if (r)
5661     {
5662       splay_tree_node node = splay_tree_lookup (action_list->tree,
5663                                                 (splay_tree_key)r);
5664       BFD_ASSERT (node != NULL && r == (text_action *)node->value);
5665     }
5666
5667   while (r)
5668     {
5669       if (r->offset > offset)
5670         break;
5671
5672       if (r->offset == offset
5673           && (before_fill || r->action != ta_fill || r->removed_bytes >= 0))
5674         break;
5675
5676       removed += r->removed_bytes;
5677
5678       r = action_next (action_list, r);
5679     }
5680
5681   *p_start_action = r;
5682   return removed;
5683 }
5684
5685
5686 static bfd_vma
5687 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
5688 {
5689   text_action *r = action_first (action_list);
5690
5691   return offset - removed_by_actions (action_list, &r, offset, FALSE);
5692 }
5693
5694
5695 static unsigned
5696 action_list_count (text_action_list *action_list)
5697 {
5698   return action_list->count;
5699 }
5700
5701 typedef struct map_action_fn_context_struct map_action_fn_context;
5702 struct map_action_fn_context_struct
5703 {
5704   int removed;
5705   removal_by_action_map map;
5706   bfd_boolean eq_complete;
5707 };
5708
5709 static int
5710 map_action_fn (splay_tree_node node, void *p)
5711 {
5712   map_action_fn_context *ctx = p;
5713   text_action *r = (text_action *)node->value;
5714   removal_by_action_entry *ientry = ctx->map.entry + ctx->map.n_entries;
5715
5716   if (ctx->map.n_entries && (ientry - 1)->offset == r->offset)
5717     {
5718       --ientry;
5719     }
5720   else
5721     {
5722       ++ctx->map.n_entries;
5723       ctx->eq_complete = FALSE;
5724       ientry->offset = r->offset;
5725       ientry->eq_removed_before_fill = ctx->removed;
5726     }
5727
5728   if (!ctx->eq_complete)
5729     {
5730       if (r->action != ta_fill || r->removed_bytes >= 0)
5731         {
5732           ientry->eq_removed = ctx->removed;
5733           ctx->eq_complete = TRUE;
5734         }
5735       else
5736         ientry->eq_removed = ctx->removed + r->removed_bytes;
5737     }
5738
5739   ctx->removed += r->removed_bytes;
5740   ientry->removed = ctx->removed;
5741   return 0;
5742 }
5743
5744 static void
5745 map_removal_by_action (text_action_list *action_list)
5746 {
5747   map_action_fn_context ctx;
5748
5749   ctx.removed = 0;
5750   ctx.map.n_entries = 0;
5751   ctx.map.entry = bfd_malloc (action_list_count (action_list) *
5752                               sizeof (removal_by_action_entry));
5753   ctx.eq_complete = FALSE;
5754
5755   splay_tree_foreach (action_list->tree, map_action_fn, &ctx);
5756   action_list->map = ctx.map;
5757 }
5758
5759 static int
5760 removed_by_actions_map (text_action_list *action_list, bfd_vma offset,
5761                         bfd_boolean before_fill)
5762 {
5763   unsigned a, b;
5764
5765   if (!action_list->map.entry)
5766     map_removal_by_action (action_list);
5767
5768   if (!action_list->map.n_entries)
5769     return 0;
5770
5771   a = 0;
5772   b = action_list->map.n_entries;
5773
5774   while (b - a > 1)
5775     {
5776       unsigned c = (a + b) / 2;
5777
5778       if (action_list->map.entry[c].offset <= offset)
5779         a = c;
5780       else
5781         b = c;
5782     }
5783
5784   if (action_list->map.entry[a].offset < offset)
5785     {
5786       return action_list->map.entry[a].removed;
5787     }
5788   else if (action_list->map.entry[a].offset == offset)
5789     {
5790       return before_fill ?
5791         action_list->map.entry[a].eq_removed_before_fill :
5792         action_list->map.entry[a].eq_removed;
5793     }
5794   else
5795     {
5796       return 0;
5797     }
5798 }
5799
5800 static bfd_vma
5801 offset_with_removed_text_map (text_action_list *action_list, bfd_vma offset)
5802 {
5803   int removed = removed_by_actions_map (action_list, offset, FALSE);
5804   return offset - removed;
5805 }
5806
5807
5808 /* The find_insn_action routine will only find non-fill actions.  */
5809
5810 static text_action *
5811 find_insn_action (text_action_list *action_list, bfd_vma offset)
5812 {
5813   static const text_action_t action[] =
5814     {
5815       ta_convert_longcall,
5816       ta_remove_longcall,
5817       ta_widen_insn,
5818       ta_narrow_insn,
5819       ta_remove_insn,
5820     };
5821   text_action a;
5822   unsigned i;
5823
5824   a.offset = offset;
5825   for (i = 0; i < sizeof (action) / sizeof (*action); ++i)
5826     {
5827       splay_tree_node node;
5828
5829       a.action = action[i];
5830       node = splay_tree_lookup (action_list->tree, (splay_tree_key)&a);
5831       if (node)
5832         return (text_action *)node->value;
5833     }
5834   return NULL;
5835 }
5836
5837
5838 #if DEBUG
5839
5840 static void
5841 print_action (FILE *fp, text_action *r)
5842 {
5843   const char *t = "unknown";
5844   switch (r->action)
5845     {
5846     case ta_remove_insn:
5847       t = "remove_insn"; break;
5848     case ta_remove_longcall:
5849       t = "remove_longcall"; break;
5850     case ta_convert_longcall:
5851       t = "convert_longcall"; break;
5852     case ta_narrow_insn:
5853       t = "narrow_insn"; break;
5854     case ta_widen_insn:
5855       t = "widen_insn"; break;
5856     case ta_fill:
5857       t = "fill"; break;
5858     case ta_none:
5859       t = "none"; break;
5860     case ta_remove_literal:
5861       t = "remove_literal"; break;
5862     case ta_add_literal:
5863       t = "add_literal"; break;
5864     }
5865
5866   fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
5867            r->sec->owner->filename,
5868            r->sec->name, (unsigned long) r->offset, t, r->removed_bytes);
5869 }
5870
5871 static int
5872 print_action_list_fn (splay_tree_node node, void *p)
5873 {
5874   text_action *r = (text_action *)node->value;
5875
5876   print_action (p, r);
5877   return 0;
5878 }
5879
5880 static void
5881 print_action_list (FILE *fp, text_action_list *action_list)
5882 {
5883   fprintf (fp, "Text Action\n");
5884   splay_tree_foreach (action_list->tree, print_action_list_fn, fp);
5885 }
5886
5887 #endif /* DEBUG */
5888
5889 \f
5890 /* Lists of literals being coalesced or removed.  */
5891
5892 /* In the usual case, the literal identified by "from" is being
5893    coalesced with another literal identified by "to".  If the literal is
5894    unused and is being removed altogether, "to.abfd" will be NULL.
5895    The removed_literal entries are kept on a per-section list, sorted
5896    by the "from" offset field.  */
5897
5898 typedef struct removed_literal_struct removed_literal;
5899 typedef struct removed_literal_map_entry_struct removed_literal_map_entry;
5900 typedef struct removed_literal_list_struct removed_literal_list;
5901
5902 struct removed_literal_struct
5903 {
5904   r_reloc from;
5905   r_reloc to;
5906   removed_literal *next;
5907 };
5908
5909 struct removed_literal_map_entry_struct
5910 {
5911   bfd_vma addr;
5912   removed_literal *literal;
5913 };
5914
5915 struct removed_literal_list_struct
5916 {
5917   removed_literal *head;
5918   removed_literal *tail;
5919
5920   unsigned n_map;
5921   removed_literal_map_entry *map;
5922 };
5923
5924
5925 /* Record that the literal at "from" is being removed.  If "to" is not
5926    NULL, the "from" literal is being coalesced with the "to" literal.  */
5927
5928 static void
5929 add_removed_literal (removed_literal_list *removed_list,
5930                      const r_reloc *from,
5931                      const r_reloc *to)
5932 {
5933   removed_literal *r, *new_r, *next_r;
5934
5935   new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
5936
5937   new_r->from = *from;
5938   if (to)
5939     new_r->to = *to;
5940   else
5941     new_r->to.abfd = NULL;
5942   new_r->next = NULL;
5943
5944   r = removed_list->head;
5945   if (r == NULL)
5946     {
5947       removed_list->head = new_r;
5948       removed_list->tail = new_r;
5949     }
5950   /* Special check for common case of append.  */
5951   else if (removed_list->tail->from.target_offset < from->target_offset)
5952     {
5953       removed_list->tail->next = new_r;
5954       removed_list->tail = new_r;
5955     }
5956   else
5957     {
5958       while (r->from.target_offset < from->target_offset && r->next)
5959         {
5960           r = r->next;
5961         }
5962       next_r = r->next;
5963       r->next = new_r;
5964       new_r->next = next_r;
5965       if (next_r == NULL)
5966         removed_list->tail = new_r;
5967     }
5968 }
5969
5970 static void
5971 map_removed_literal (removed_literal_list *removed_list)
5972 {
5973   unsigned n_map = 0;
5974   unsigned i;
5975   removed_literal_map_entry *map = NULL;
5976   removed_literal *r = removed_list->head;
5977
5978   for (i = 0; r; ++i, r = r->next)
5979     {
5980       if (i == n_map)
5981         {
5982           n_map = (n_map * 2) + 2;
5983           map = bfd_realloc (map, n_map * sizeof (*map));
5984         }
5985       map[i].addr = r->from.target_offset;
5986       map[i].literal = r;
5987     }
5988   removed_list->map = map;
5989   removed_list->n_map = i;
5990 }
5991
5992 static int
5993 removed_literal_compare (const void *a, const void *b)
5994 {
5995   const removed_literal_map_entry *pa = a;
5996   const removed_literal_map_entry *pb = b;
5997
5998   if (pa->addr == pb->addr)
5999     return 0;
6000   else
6001     return pa->addr < pb->addr ? -1 : 1;
6002 }
6003
6004 /* Check if the list of removed literals contains an entry for the
6005    given address.  Return the entry if found.  */
6006
6007 static removed_literal *
6008 find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
6009 {
6010   removed_literal_map_entry *p;
6011   removed_literal *r = NULL;
6012
6013   if (removed_list->map == NULL)
6014     map_removed_literal (removed_list);
6015
6016   p = bsearch (&addr, removed_list->map, removed_list->n_map,
6017                sizeof (*removed_list->map), removed_literal_compare);
6018   if (p)
6019     {
6020       while (p != removed_list->map && (p - 1)->addr == addr)
6021         --p;
6022       r = p->literal;
6023     }
6024   return r;
6025 }
6026
6027
6028 #if DEBUG
6029
6030 static void
6031 print_removed_literals (FILE *fp, removed_literal_list *removed_list)
6032 {
6033   removed_literal *r;
6034   r = removed_list->head;
6035   if (r)
6036     fprintf (fp, "Removed Literals\n");
6037   for (; r != NULL; r = r->next)
6038     {
6039       print_r_reloc (fp, &r->from);
6040       fprintf (fp, " => ");
6041       if (r->to.abfd == NULL)
6042         fprintf (fp, "REMOVED");
6043       else
6044         print_r_reloc (fp, &r->to);
6045       fprintf (fp, "\n");
6046     }
6047 }
6048
6049 #endif /* DEBUG */
6050
6051 \f
6052 /* Per-section data for relaxation.  */
6053
6054 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
6055
6056 struct xtensa_relax_info_struct
6057 {
6058   bfd_boolean is_relaxable_literal_section;
6059   bfd_boolean is_relaxable_asm_section;
6060   int visited;                          /* Number of times visited.  */
6061
6062   source_reloc *src_relocs;             /* Array[src_count].  */
6063   int src_count;
6064   int src_next;                         /* Next src_relocs entry to assign.  */
6065
6066   removed_literal_list removed_list;
6067   text_action_list action_list;
6068
6069   reloc_bfd_fix *fix_list;
6070   reloc_bfd_fix *fix_array;
6071   unsigned fix_array_count;
6072
6073   /* Support for expanding the reloc array that is stored
6074      in the section structure.  If the relocations have been
6075      reallocated, the newly allocated relocations will be referenced
6076      here along with the actual size allocated.  The relocation
6077      count will always be found in the section structure.  */
6078   Elf_Internal_Rela *allocated_relocs;
6079   unsigned relocs_count;
6080   unsigned allocated_relocs_count;
6081 };
6082
6083 struct elf_xtensa_section_data
6084 {
6085   struct bfd_elf_section_data elf;
6086   xtensa_relax_info relax_info;
6087 };
6088
6089
6090 static bfd_boolean
6091 elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
6092 {
6093   if (!sec->used_by_bfd)
6094     {
6095       struct elf_xtensa_section_data *sdata;
6096       bfd_size_type amt = sizeof (*sdata);
6097
6098       sdata = bfd_zalloc (abfd, amt);
6099       if (sdata == NULL)
6100         return FALSE;
6101       sec->used_by_bfd = sdata;
6102     }
6103
6104   return _bfd_elf_new_section_hook (abfd, sec);
6105 }
6106
6107
6108 static xtensa_relax_info *
6109 get_xtensa_relax_info (asection *sec)
6110 {
6111   struct elf_xtensa_section_data *section_data;
6112
6113   /* No info available if no section or if it is an output section.  */
6114   if (!sec || sec == sec->output_section)
6115     return NULL;
6116
6117   section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
6118   return &section_data->relax_info;
6119 }
6120
6121
6122 static void
6123 init_xtensa_relax_info (asection *sec)
6124 {
6125   xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6126
6127   relax_info->is_relaxable_literal_section = FALSE;
6128   relax_info->is_relaxable_asm_section = FALSE;
6129   relax_info->visited = 0;
6130
6131   relax_info->src_relocs = NULL;
6132   relax_info->src_count = 0;
6133   relax_info->src_next = 0;
6134
6135   relax_info->removed_list.head = NULL;
6136   relax_info->removed_list.tail = NULL;
6137
6138   relax_info->action_list.tree = splay_tree_new (text_action_compare,
6139                                                  NULL, NULL);
6140   relax_info->action_list.map.n_entries = 0;
6141   relax_info->action_list.map.entry = NULL;
6142
6143   relax_info->fix_list = NULL;
6144   relax_info->fix_array = NULL;
6145   relax_info->fix_array_count = 0;
6146
6147   relax_info->allocated_relocs = NULL;
6148   relax_info->relocs_count = 0;
6149   relax_info->allocated_relocs_count = 0;
6150 }
6151
6152 \f
6153 /* Coalescing literals may require a relocation to refer to a section in
6154    a different input file, but the standard relocation information
6155    cannot express that.  Instead, the reloc_bfd_fix structures are used
6156    to "fix" the relocations that refer to sections in other input files.
6157    These structures are kept on per-section lists.  The "src_type" field
6158    records the relocation type in case there are multiple relocations on
6159    the same location.  FIXME: This is ugly; an alternative might be to
6160    add new symbols with the "owner" field to some other input file.  */
6161
6162 struct reloc_bfd_fix_struct
6163 {
6164   asection *src_sec;
6165   bfd_vma src_offset;
6166   unsigned src_type;                    /* Relocation type.  */
6167
6168   asection *target_sec;
6169   bfd_vma target_offset;
6170   bfd_boolean translated;
6171
6172   reloc_bfd_fix *next;
6173 };
6174
6175
6176 static reloc_bfd_fix *
6177 reloc_bfd_fix_init (asection *src_sec,
6178                     bfd_vma src_offset,
6179                     unsigned src_type,
6180                     asection *target_sec,
6181                     bfd_vma target_offset,
6182                     bfd_boolean translated)
6183 {
6184   reloc_bfd_fix *fix;
6185
6186   fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
6187   fix->src_sec = src_sec;
6188   fix->src_offset = src_offset;
6189   fix->src_type = src_type;
6190   fix->target_sec = target_sec;
6191   fix->target_offset = target_offset;
6192   fix->translated = translated;
6193
6194   return fix;
6195 }
6196
6197
6198 static void
6199 add_fix (asection *src_sec, reloc_bfd_fix *fix)
6200 {
6201   xtensa_relax_info *relax_info;
6202
6203   relax_info = get_xtensa_relax_info (src_sec);
6204   fix->next = relax_info->fix_list;
6205   relax_info->fix_list = fix;
6206 }
6207
6208
6209 static int
6210 fix_compare (const void *ap, const void *bp)
6211 {
6212   const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
6213   const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
6214
6215   if (a->src_offset != b->src_offset)
6216     return (a->src_offset - b->src_offset);
6217   return (a->src_type - b->src_type);
6218 }
6219
6220
6221 static void
6222 cache_fix_array (asection *sec)
6223 {
6224   unsigned i, count = 0;
6225   reloc_bfd_fix *r;
6226   xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6227
6228   if (relax_info == NULL)
6229     return;
6230   if (relax_info->fix_list == NULL)
6231     return;
6232
6233   for (r = relax_info->fix_list; r != NULL; r = r->next)
6234     count++;
6235
6236   relax_info->fix_array =
6237     (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
6238   relax_info->fix_array_count = count;
6239
6240   r = relax_info->fix_list;
6241   for (i = 0; i < count; i++, r = r->next)
6242     {
6243       relax_info->fix_array[count - 1 - i] = *r;
6244       relax_info->fix_array[count - 1 - i].next = NULL;
6245     }
6246
6247   qsort (relax_info->fix_array, relax_info->fix_array_count,
6248          sizeof (reloc_bfd_fix), fix_compare);
6249 }
6250
6251
6252 static reloc_bfd_fix *
6253 get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
6254 {
6255   xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6256   reloc_bfd_fix *rv;
6257   reloc_bfd_fix key;
6258
6259   if (relax_info == NULL)
6260     return NULL;
6261   if (relax_info->fix_list == NULL)
6262     return NULL;
6263
6264   if (relax_info->fix_array == NULL)
6265     cache_fix_array (sec);
6266
6267   key.src_offset = offset;
6268   key.src_type = type;
6269   rv = bsearch (&key, relax_info->fix_array,  relax_info->fix_array_count,
6270                 sizeof (reloc_bfd_fix), fix_compare);
6271   return rv;
6272 }
6273
6274 \f
6275 /* Section caching.  */
6276
6277 typedef struct section_cache_struct section_cache_t;
6278
6279 struct section_cache_struct
6280 {
6281   asection *sec;
6282
6283   bfd_byte *contents;           /* Cache of the section contents.  */
6284   bfd_size_type content_length;
6285
6286   property_table_entry *ptbl;   /* Cache of the section property table.  */
6287   unsigned pte_count;
6288
6289   Elf_Internal_Rela *relocs;    /* Cache of the section relocations.  */
6290   unsigned reloc_count;
6291 };
6292
6293
6294 static void
6295 init_section_cache (section_cache_t *sec_cache)
6296 {
6297   memset (sec_cache, 0, sizeof (*sec_cache));
6298 }
6299
6300
6301 static void
6302 free_section_cache (section_cache_t *sec_cache)
6303 {
6304   if (sec_cache->sec)
6305     {
6306       release_contents (sec_cache->sec, sec_cache->contents);
6307       release_internal_relocs (sec_cache->sec, sec_cache->relocs);
6308       if (sec_cache->ptbl)
6309         free (sec_cache->ptbl);
6310     }
6311 }
6312
6313
6314 static bfd_boolean
6315 section_cache_section (section_cache_t *sec_cache,
6316                        asection *sec,
6317                        struct bfd_link_info *link_info)
6318 {
6319   bfd *abfd;
6320   property_table_entry *prop_table = NULL;
6321   int ptblsize = 0;
6322   bfd_byte *contents = NULL;
6323   Elf_Internal_Rela *internal_relocs = NULL;
6324   bfd_size_type sec_size;
6325
6326   if (sec == NULL)
6327     return FALSE;
6328   if (sec == sec_cache->sec)
6329     return TRUE;
6330
6331   abfd = sec->owner;
6332   sec_size = bfd_get_section_limit (abfd, sec);
6333
6334   /* Get the contents.  */
6335   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6336   if (contents == NULL && sec_size != 0)
6337     goto err;
6338
6339   /* Get the relocations.  */
6340   internal_relocs = retrieve_internal_relocs (abfd, sec,
6341                                               link_info->keep_memory);
6342
6343   /* Get the entry table.  */
6344   ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6345                                         XTENSA_PROP_SEC_NAME, FALSE);
6346   if (ptblsize < 0)
6347     goto err;
6348
6349   /* Fill in the new section cache.  */
6350   free_section_cache (sec_cache);
6351   init_section_cache (sec_cache);
6352
6353   sec_cache->sec = sec;
6354   sec_cache->contents = contents;
6355   sec_cache->content_length = sec_size;
6356   sec_cache->relocs = internal_relocs;
6357   sec_cache->reloc_count = sec->reloc_count;
6358   sec_cache->pte_count = ptblsize;
6359   sec_cache->ptbl = prop_table;
6360
6361   return TRUE;
6362
6363  err:
6364   release_contents (sec, contents);
6365   release_internal_relocs (sec, internal_relocs);
6366   if (prop_table)
6367     free (prop_table);
6368   return FALSE;
6369 }
6370
6371 \f
6372 /* Extended basic blocks.  */
6373
6374 /* An ebb_struct represents an Extended Basic Block.  Within this
6375    range, we guarantee that all instructions are decodable, the
6376    property table entries are contiguous, and no property table
6377    specifies a segment that cannot have instructions moved.  This
6378    structure contains caches of the contents, property table and
6379    relocations for the specified section for easy use.  The range is
6380    specified by ranges of indices for the byte offset, property table
6381    offsets and relocation offsets.  These must be consistent.  */
6382
6383 typedef struct ebb_struct ebb_t;
6384
6385 struct ebb_struct
6386 {
6387   asection *sec;
6388
6389   bfd_byte *contents;           /* Cache of the section contents.  */
6390   bfd_size_type content_length;
6391
6392   property_table_entry *ptbl;   /* Cache of the section property table.  */
6393   unsigned pte_count;
6394
6395   Elf_Internal_Rela *relocs;    /* Cache of the section relocations.  */
6396   unsigned reloc_count;
6397
6398   bfd_vma start_offset;         /* Offset in section.  */
6399   unsigned start_ptbl_idx;      /* Offset in the property table.  */
6400   unsigned start_reloc_idx;     /* Offset in the relocations.  */
6401
6402   bfd_vma end_offset;
6403   unsigned end_ptbl_idx;
6404   unsigned end_reloc_idx;
6405
6406   bfd_boolean ends_section;     /* Is this the last ebb in a section?  */
6407
6408   /* The unreachable property table at the end of this set of blocks;
6409      NULL if the end is not an unreachable block.  */
6410   property_table_entry *ends_unreachable;
6411 };
6412
6413
6414 enum ebb_target_enum
6415 {
6416   EBB_NO_ALIGN = 0,
6417   EBB_DESIRE_TGT_ALIGN,
6418   EBB_REQUIRE_TGT_ALIGN,
6419   EBB_REQUIRE_LOOP_ALIGN,
6420   EBB_REQUIRE_ALIGN
6421 };
6422
6423
6424 /* proposed_action_struct is similar to the text_action_struct except
6425    that is represents a potential transformation, not one that will
6426    occur.  We build a list of these for an extended basic block
6427    and use them to compute the actual actions desired.  We must be
6428    careful that the entire set of actual actions we perform do not
6429    break any relocations that would fit if the actions were not
6430    performed.  */
6431
6432 typedef struct proposed_action_struct proposed_action;
6433
6434 struct proposed_action_struct
6435 {
6436   enum ebb_target_enum align_type; /* for the target alignment */
6437   bfd_vma alignment_pow;
6438   text_action_t action;
6439   bfd_vma offset;
6440   int removed_bytes;
6441   bfd_boolean do_action; /* If false, then we will not perform the action.  */
6442 };
6443
6444
6445 /* The ebb_constraint_struct keeps a set of proposed actions for an
6446    extended basic block.   */
6447
6448 typedef struct ebb_constraint_struct ebb_constraint;
6449
6450 struct ebb_constraint_struct
6451 {
6452   ebb_t ebb;
6453   bfd_boolean start_movable;
6454
6455   /* Bytes of extra space at the beginning if movable.  */
6456   int start_extra_space;
6457
6458   enum ebb_target_enum start_align;
6459
6460   bfd_boolean end_movable;
6461
6462   /* Bytes of extra space at the end if movable.  */
6463   int end_extra_space;
6464
6465   unsigned action_count;
6466   unsigned action_allocated;
6467
6468   /* Array of proposed actions.  */
6469   proposed_action *actions;
6470
6471   /* Action alignments -- one for each proposed action.  */
6472   enum ebb_target_enum *action_aligns;
6473 };
6474
6475
6476 static void
6477 init_ebb_constraint (ebb_constraint *c)
6478 {
6479   memset (c, 0, sizeof (ebb_constraint));
6480 }
6481
6482
6483 static void
6484 free_ebb_constraint (ebb_constraint *c)
6485 {
6486   if (c->actions)
6487     free (c->actions);
6488 }
6489
6490
6491 static void
6492 init_ebb (ebb_t *ebb,
6493           asection *sec,
6494           bfd_byte *contents,
6495           bfd_size_type content_length,
6496           property_table_entry *prop_table,
6497           unsigned ptblsize,
6498           Elf_Internal_Rela *internal_relocs,
6499           unsigned reloc_count)
6500 {
6501   memset (ebb, 0, sizeof (ebb_t));
6502   ebb->sec = sec;
6503   ebb->contents = contents;
6504   ebb->content_length = content_length;
6505   ebb->ptbl = prop_table;
6506   ebb->pte_count = ptblsize;
6507   ebb->relocs = internal_relocs;
6508   ebb->reloc_count = reloc_count;
6509   ebb->start_offset = 0;
6510   ebb->end_offset = ebb->content_length - 1;
6511   ebb->start_ptbl_idx = 0;
6512   ebb->end_ptbl_idx = ptblsize;
6513   ebb->start_reloc_idx = 0;
6514   ebb->end_reloc_idx = reloc_count;
6515 }
6516
6517
6518 /* Extend the ebb to all decodable contiguous sections.  The algorithm
6519    for building a basic block around an instruction is to push it
6520    forward until we hit the end of a section, an unreachable block or
6521    a block that cannot be transformed.  Then we push it backwards
6522    searching for similar conditions.  */
6523
6524 static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
6525 static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
6526 static bfd_size_type insn_block_decodable_len
6527   (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
6528
6529 static bfd_boolean
6530 extend_ebb_bounds (ebb_t *ebb)
6531 {
6532   if (!extend_ebb_bounds_forward (ebb))
6533     return FALSE;
6534   if (!extend_ebb_bounds_backward (ebb))
6535     return FALSE;
6536   return TRUE;
6537 }
6538
6539
6540 static bfd_boolean
6541 extend_ebb_bounds_forward (ebb_t *ebb)
6542 {
6543   property_table_entry *the_entry, *new_entry;
6544
6545   the_entry = &ebb->ptbl[ebb->end_ptbl_idx];
6546
6547   /* Stop when (1) we cannot decode an instruction, (2) we are at
6548      the end of the property tables, (3) we hit a non-contiguous property
6549      table entry, (4) we hit a NO_TRANSFORM region.  */
6550
6551   while (1)
6552     {
6553       bfd_vma entry_end;
6554       bfd_size_type insn_block_len;
6555
6556       entry_end = the_entry->address - ebb->sec->vma + the_entry->size;
6557       insn_block_len =
6558         insn_block_decodable_len (ebb->contents, ebb->content_length,
6559                                   ebb->end_offset,
6560                                   entry_end - ebb->end_offset);
6561       if (insn_block_len != (entry_end - ebb->end_offset))
6562         {
6563           (*_bfd_error_handler)
6564             (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6565              ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6566           return FALSE;
6567         }
6568       ebb->end_offset += insn_block_len;
6569
6570       if (ebb->end_offset == ebb->sec->size)
6571         ebb->ends_section = TRUE;
6572
6573       /* Update the reloc counter.  */
6574       while (ebb->end_reloc_idx + 1 < ebb->reloc_count
6575              && (ebb->relocs[ebb->end_reloc_idx + 1].r_offset
6576                  < ebb->end_offset))
6577         {
6578           ebb->end_reloc_idx++;
6579         }
6580
6581       if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6582         return TRUE;
6583
6584       new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6585       if (((new_entry->flags & XTENSA_PROP_INSN) == 0)
6586           || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6587           || ((the_entry->flags & XTENSA_PROP_ALIGN) != 0))
6588         break;
6589
6590       if (the_entry->address + the_entry->size != new_entry->address)
6591         break;
6592
6593       the_entry = new_entry;
6594       ebb->end_ptbl_idx++;
6595     }
6596
6597   /* Quick check for an unreachable or end of file just at the end.  */
6598   if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6599     {
6600       if (ebb->end_offset == ebb->content_length)
6601         ebb->ends_section = TRUE;
6602     }
6603   else
6604     {
6605       new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6606       if ((new_entry->flags & XTENSA_PROP_UNREACHABLE) != 0
6607           && the_entry->address + the_entry->size == new_entry->address)
6608         ebb->ends_unreachable = new_entry;
6609     }
6610
6611   /* Any other ending requires exact alignment.  */
6612   return TRUE;
6613 }
6614
6615
6616 static bfd_boolean
6617 extend_ebb_bounds_backward (ebb_t *ebb)
6618 {
6619   property_table_entry *the_entry, *new_entry;
6620
6621   the_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6622
6623   /* Stop when (1) we cannot decode the instructions in the current entry.
6624      (2) we are at the beginning of the property tables, (3) we hit a
6625      non-contiguous property table entry, (4) we hit a NO_TRANSFORM region.  */
6626
6627   while (1)
6628     {
6629       bfd_vma block_begin;
6630       bfd_size_type insn_block_len;
6631
6632       block_begin = the_entry->address - ebb->sec->vma;
6633       insn_block_len =
6634         insn_block_decodable_len (ebb->contents, ebb->content_length,
6635                                   block_begin,
6636                                   ebb->start_offset - block_begin);
6637       if (insn_block_len != ebb->start_offset - block_begin)
6638         {
6639           (*_bfd_error_handler)
6640             (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6641              ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6642           return FALSE;
6643         }
6644       ebb->start_offset -= insn_block_len;
6645
6646       /* Update the reloc counter.  */
6647       while (ebb->start_reloc_idx > 0
6648              && (ebb->relocs[ebb->start_reloc_idx - 1].r_offset
6649                  >= ebb->start_offset))
6650         {
6651           ebb->start_reloc_idx--;
6652         }
6653
6654       if (ebb->start_ptbl_idx == 0)
6655         return TRUE;
6656
6657       new_entry = &ebb->ptbl[ebb->start_ptbl_idx - 1];
6658       if ((new_entry->flags & XTENSA_PROP_INSN) == 0
6659           || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6660           || ((new_entry->flags & XTENSA_PROP_ALIGN) != 0))
6661         return TRUE;
6662       if (new_entry->address + new_entry->size != the_entry->address)
6663         return TRUE;
6664
6665       the_entry = new_entry;
6666       ebb->start_ptbl_idx--;
6667     }
6668   return TRUE;
6669 }
6670
6671
6672 static bfd_size_type
6673 insn_block_decodable_len (bfd_byte *contents,
6674                           bfd_size_type content_len,
6675                           bfd_vma block_offset,
6676                           bfd_size_type block_len)
6677 {
6678   bfd_vma offset = block_offset;
6679
6680   while (offset < block_offset + block_len)
6681     {
6682       bfd_size_type insn_len = 0;
6683
6684       insn_len = insn_decode_len (contents, content_len, offset);
6685       if (insn_len == 0)
6686         return (offset - block_offset);
6687       offset += insn_len;
6688     }
6689   return (offset - block_offset);
6690 }
6691
6692
6693 static void
6694 ebb_propose_action (ebb_constraint *c,
6695                     enum ebb_target_enum align_type,
6696                     bfd_vma alignment_pow,
6697                     text_action_t action,
6698                     bfd_vma offset,
6699                     int removed_bytes,
6700                     bfd_boolean do_action)
6701 {
6702   proposed_action *act;
6703
6704   if (c->action_allocated <= c->action_count)
6705     {
6706       unsigned new_allocated, i;
6707       proposed_action *new_actions;
6708
6709       new_allocated = (c->action_count + 2) * 2;
6710       new_actions = (proposed_action *)
6711         bfd_zmalloc (sizeof (proposed_action) * new_allocated);
6712
6713       for (i = 0; i < c->action_count; i++)
6714         new_actions[i] = c->actions[i];
6715       if (c->actions)
6716         free (c->actions);
6717       c->actions = new_actions;
6718       c->action_allocated = new_allocated;
6719     }
6720
6721   act = &c->actions[c->action_count];
6722   act->align_type = align_type;
6723   act->alignment_pow = alignment_pow;
6724   act->action = action;
6725   act->offset = offset;
6726   act->removed_bytes = removed_bytes;
6727   act->do_action = do_action;
6728
6729   c->action_count++;
6730 }
6731
6732 \f
6733 /* Access to internal relocations, section contents and symbols.  */
6734
6735 /* During relaxation, we need to modify relocations, section contents,
6736    and symbol definitions, and we need to keep the original values from
6737    being reloaded from the input files, i.e., we need to "pin" the
6738    modified values in memory.  We also want to continue to observe the
6739    setting of the "keep-memory" flag.  The following functions wrap the
6740    standard BFD functions to take care of this for us.  */
6741
6742 static Elf_Internal_Rela *
6743 retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6744 {
6745   Elf_Internal_Rela *internal_relocs;
6746
6747   if ((sec->flags & SEC_LINKER_CREATED) != 0)
6748     return NULL;
6749
6750   internal_relocs = elf_section_data (sec)->relocs;
6751   if (internal_relocs == NULL)
6752     internal_relocs = (_bfd_elf_link_read_relocs
6753                        (abfd, sec, NULL, NULL, keep_memory));
6754   return internal_relocs;
6755 }
6756
6757
6758 static void
6759 pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6760 {
6761   elf_section_data (sec)->relocs = internal_relocs;
6762 }
6763
6764
6765 static void
6766 release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6767 {
6768   if (internal_relocs
6769       && elf_section_data (sec)->relocs != internal_relocs)
6770     free (internal_relocs);
6771 }
6772
6773
6774 static bfd_byte *
6775 retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6776 {
6777   bfd_byte *contents;
6778   bfd_size_type sec_size;
6779
6780   sec_size = bfd_get_section_limit (abfd, sec);
6781   contents = elf_section_data (sec)->this_hdr.contents;
6782
6783   if (contents == NULL && sec_size != 0)
6784     {
6785       if (!bfd_malloc_and_get_section (abfd, sec, &contents))
6786         {
6787           if (contents)
6788             free (contents);
6789           return NULL;
6790         }
6791       if (keep_memory)
6792         elf_section_data (sec)->this_hdr.contents = contents;
6793     }
6794   return contents;
6795 }
6796
6797
6798 static void
6799 pin_contents (asection *sec, bfd_byte *contents)
6800 {
6801   elf_section_data (sec)->this_hdr.contents = contents;
6802 }
6803
6804
6805 static void
6806 release_contents (asection *sec, bfd_byte *contents)
6807 {
6808   if (contents && elf_section_data (sec)->this_hdr.contents != contents)
6809     free (contents);
6810 }
6811
6812
6813 static Elf_Internal_Sym *
6814 retrieve_local_syms (bfd *input_bfd)
6815 {
6816   Elf_Internal_Shdr *symtab_hdr;
6817   Elf_Internal_Sym *isymbuf;
6818   size_t locsymcount;
6819
6820   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6821   locsymcount = symtab_hdr->sh_info;
6822
6823   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6824   if (isymbuf == NULL && locsymcount != 0)
6825     isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
6826                                     NULL, NULL, NULL);
6827
6828   /* Save the symbols for this input file so they won't be read again.  */
6829   if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
6830     symtab_hdr->contents = (unsigned char *) isymbuf;
6831
6832   return isymbuf;
6833 }
6834
6835 \f
6836 /* Code for link-time relaxation.  */
6837
6838 /* Initialization for relaxation: */
6839 static bfd_boolean analyze_relocations (struct bfd_link_info *);
6840 static bfd_boolean find_relaxable_sections
6841   (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
6842 static bfd_boolean collect_source_relocs
6843   (bfd *, asection *, struct bfd_link_info *);
6844 static bfd_boolean is_resolvable_asm_expansion
6845   (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
6846    bfd_boolean *);
6847 static Elf_Internal_Rela *find_associated_l32r_irel
6848   (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
6849 static bfd_boolean compute_text_actions
6850   (bfd *, asection *, struct bfd_link_info *);
6851 static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
6852 static bfd_boolean compute_ebb_actions (ebb_constraint *);
6853 typedef struct reloc_range_list_struct reloc_range_list;
6854 static bfd_boolean check_section_ebb_pcrels_fit
6855   (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *,
6856    reloc_range_list *, const ebb_constraint *,
6857    const xtensa_opcode *);
6858 static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
6859 static void text_action_add_proposed
6860   (text_action_list *, const ebb_constraint *, asection *);
6861 static int compute_fill_extra_space (property_table_entry *);
6862
6863 /* First pass: */
6864 static bfd_boolean compute_removed_literals
6865   (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
6866 static Elf_Internal_Rela *get_irel_at_offset
6867   (asection *, Elf_Internal_Rela *, bfd_vma);
6868 static bfd_boolean is_removable_literal
6869   (const source_reloc *, int, const source_reloc *, int, asection *,
6870    property_table_entry *, int);
6871 static bfd_boolean remove_dead_literal
6872   (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
6873    Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
6874 static bfd_boolean identify_literal_placement
6875   (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
6876    value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
6877    source_reloc *, property_table_entry *, int, section_cache_t *,
6878    bfd_boolean);
6879 static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
6880 static bfd_boolean coalesce_shared_literal
6881   (asection *, source_reloc *, property_table_entry *, int, value_map *);
6882 static bfd_boolean move_shared_literal
6883   (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
6884    int, const r_reloc *, const literal_value *, section_cache_t *);
6885
6886 /* Second pass: */
6887 static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
6888 static bfd_boolean translate_section_fixes (asection *);
6889 static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
6890 static asection *translate_reloc (const r_reloc *, r_reloc *, asection *);
6891 static void shrink_dynamic_reloc_sections
6892   (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
6893 static bfd_boolean move_literal
6894   (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
6895    xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
6896 static bfd_boolean relax_property_section
6897   (bfd *, asection *, struct bfd_link_info *);
6898
6899 /* Third pass: */
6900 static bfd_boolean relax_section_symbols (bfd *, asection *);
6901
6902
6903 static bfd_boolean
6904 elf_xtensa_relax_section (bfd *abfd,
6905                           asection *sec,
6906                           struct bfd_link_info *link_info,
6907                           bfd_boolean *again)
6908 {
6909   static value_map_hash_table *values = NULL;
6910   static bfd_boolean relocations_analyzed = FALSE;
6911   xtensa_relax_info *relax_info;
6912
6913   if (!relocations_analyzed)
6914     {
6915       /* Do some overall initialization for relaxation.  */
6916       values = value_map_hash_table_init ();
6917       if (values == NULL)
6918         return FALSE;
6919       relaxing_section = TRUE;
6920       if (!analyze_relocations (link_info))
6921         return FALSE;
6922       relocations_analyzed = TRUE;
6923     }
6924   *again = FALSE;
6925
6926   /* Don't mess with linker-created sections.  */
6927   if ((sec->flags & SEC_LINKER_CREATED) != 0)
6928     return TRUE;
6929
6930   relax_info = get_xtensa_relax_info (sec);
6931   BFD_ASSERT (relax_info != NULL);
6932
6933   switch (relax_info->visited)
6934     {
6935     case 0:
6936       /* Note: It would be nice to fold this pass into
6937          analyze_relocations, but it is important for this step that the
6938          sections be examined in link order.  */
6939       if (!compute_removed_literals (abfd, sec, link_info, values))
6940         return FALSE;
6941       *again = TRUE;
6942       break;
6943
6944     case 1:
6945       if (values)
6946         value_map_hash_table_delete (values);
6947       values = NULL;
6948       if (!relax_section (abfd, sec, link_info))
6949         return FALSE;
6950       *again = TRUE;
6951       break;
6952
6953     case 2:
6954       if (!relax_section_symbols (abfd, sec))
6955         return FALSE;
6956       break;
6957     }
6958
6959   relax_info->visited++;
6960   return TRUE;
6961 }
6962
6963 \f
6964 /* Initialization for relaxation.  */
6965
6966 /* This function is called once at the start of relaxation.  It scans
6967    all the input sections and marks the ones that are relaxable (i.e.,
6968    literal sections with L32R relocations against them), and then
6969    collects source_reloc information for all the relocations against
6970    those relaxable sections.  During this process, it also detects
6971    longcalls, i.e., calls relaxed by the assembler into indirect
6972    calls, that can be optimized back into direct calls.  Within each
6973    extended basic block (ebb) containing an optimized longcall, it
6974    computes a set of "text actions" that can be performed to remove
6975    the L32R associated with the longcall while optionally preserving
6976    branch target alignments.  */
6977
6978 static bfd_boolean
6979 analyze_relocations (struct bfd_link_info *link_info)
6980 {
6981   bfd *abfd;
6982   asection *sec;
6983   bfd_boolean is_relaxable = FALSE;
6984
6985   /* Initialize the per-section relaxation info.  */
6986   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
6987     for (sec = abfd->sections; sec != NULL; sec = sec->next)
6988       {
6989         init_xtensa_relax_info (sec);
6990       }
6991
6992   /* Mark relaxable sections (and count relocations against each one).  */
6993   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
6994     for (sec = abfd->sections; sec != NULL; sec = sec->next)
6995       {
6996         if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
6997           return FALSE;
6998       }
6999
7000   /* Bail out if there are no relaxable sections.  */
7001   if (!is_relaxable)
7002     return TRUE;
7003
7004   /* Allocate space for source_relocs.  */
7005   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
7006     for (sec = abfd->sections; sec != NULL; sec = sec->next)
7007       {
7008         xtensa_relax_info *relax_info;
7009
7010         relax_info = get_xtensa_relax_info (sec);
7011         if (relax_info->is_relaxable_literal_section
7012             || relax_info->is_relaxable_asm_section)
7013           {
7014             relax_info->src_relocs = (source_reloc *)
7015               bfd_malloc (relax_info->src_count * sizeof (source_reloc));
7016           }
7017         else
7018           relax_info->src_count = 0;
7019       }
7020
7021   /* Collect info on relocations against each relaxable section.  */
7022   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
7023     for (sec = abfd->sections; sec != NULL; sec = sec->next)
7024       {
7025         if (!collect_source_relocs (abfd, sec, link_info))
7026           return FALSE;
7027       }
7028
7029   /* Compute the text actions.  */
7030   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
7031     for (sec = abfd->sections; sec != NULL; sec = sec->next)
7032       {
7033         if (!compute_text_actions (abfd, sec, link_info))
7034           return FALSE;
7035       }
7036
7037   return TRUE;
7038 }
7039
7040
7041 /* Find all the sections that might be relaxed.  The motivation for
7042    this pass is that collect_source_relocs() needs to record _all_ the
7043    relocations that target each relaxable section.  That is expensive
7044    and unnecessary unless the target section is actually going to be
7045    relaxed.  This pass identifies all such sections by checking if
7046    they have L32Rs pointing to them.  In the process, the total number
7047    of relocations targeting each section is also counted so that we
7048    know how much space to allocate for source_relocs against each
7049    relaxable literal section.  */
7050
7051 static bfd_boolean
7052 find_relaxable_sections (bfd *abfd,
7053                          asection *sec,
7054                          struct bfd_link_info *link_info,
7055                          bfd_boolean *is_relaxable_p)
7056 {
7057   Elf_Internal_Rela *internal_relocs;
7058   bfd_byte *contents;
7059   bfd_boolean ok = TRUE;
7060   unsigned i;
7061   xtensa_relax_info *source_relax_info;
7062   bfd_boolean is_l32r_reloc;
7063
7064   internal_relocs = retrieve_internal_relocs (abfd, sec,
7065                                               link_info->keep_memory);
7066   if (internal_relocs == NULL)
7067     return ok;
7068
7069   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7070   if (contents == NULL && sec->size != 0)
7071     {
7072       ok = FALSE;
7073       goto error_return;
7074     }
7075
7076   source_relax_info = get_xtensa_relax_info (sec);
7077   for (i = 0; i < sec->reloc_count; i++)
7078     {
7079       Elf_Internal_Rela *irel = &internal_relocs[i];
7080       r_reloc r_rel;
7081       asection *target_sec;
7082       xtensa_relax_info *target_relax_info;
7083
7084       /* If this section has not already been marked as "relaxable", and
7085          if it contains any ASM_EXPAND relocations (marking expanded
7086          longcalls) that can be optimized into direct calls, then mark
7087          the section as "relaxable".  */
7088       if (source_relax_info
7089           && !source_relax_info->is_relaxable_asm_section
7090           && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
7091         {
7092           bfd_boolean is_reachable = FALSE;
7093           if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
7094                                            link_info, &is_reachable)
7095               && is_reachable)
7096             {
7097               source_relax_info->is_relaxable_asm_section = TRUE;
7098               *is_relaxable_p = TRUE;
7099             }
7100         }
7101
7102       r_reloc_init (&r_rel, abfd, irel, contents,
7103                     bfd_get_section_limit (abfd, sec));
7104
7105       target_sec = r_reloc_get_section (&r_rel);
7106       target_relax_info = get_xtensa_relax_info (target_sec);
7107       if (!target_relax_info)
7108         continue;
7109
7110       /* Count PC-relative operand relocations against the target section.
7111          Note: The conditions tested here must match the conditions under
7112          which init_source_reloc is called in collect_source_relocs().  */
7113       is_l32r_reloc = FALSE;
7114       if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
7115         {
7116           xtensa_opcode opcode =
7117             get_relocation_opcode (abfd, sec, contents, irel);
7118           if (opcode != XTENSA_UNDEFINED)
7119             {
7120               is_l32r_reloc = (opcode == get_l32r_opcode ());
7121               if (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
7122                   || is_l32r_reloc)
7123                 target_relax_info->src_count++;
7124             }
7125         }
7126
7127       if (is_l32r_reloc && r_reloc_is_defined (&r_rel))
7128         {
7129           /* Mark the target section as relaxable.  */
7130           target_relax_info->is_relaxable_literal_section = TRUE;
7131           *is_relaxable_p = TRUE;
7132         }
7133     }
7134
7135  error_return:
7136   release_contents (sec, contents);
7137   release_internal_relocs (sec, internal_relocs);
7138   return ok;
7139 }
7140
7141
7142 /* Record _all_ the relocations that point to relaxable sections, and
7143    get rid of ASM_EXPAND relocs by either converting them to
7144    ASM_SIMPLIFY or by removing them.  */
7145
7146 static bfd_boolean
7147 collect_source_relocs (bfd *abfd,
7148                        asection *sec,
7149                        struct bfd_link_info *link_info)
7150 {
7151   Elf_Internal_Rela *internal_relocs;
7152   bfd_byte *contents;
7153   bfd_boolean ok = TRUE;
7154   unsigned i;
7155   bfd_size_type sec_size;
7156
7157   internal_relocs = retrieve_internal_relocs (abfd, sec,
7158                                               link_info->keep_memory);
7159   if (internal_relocs == NULL)
7160     return ok;
7161
7162   sec_size = bfd_get_section_limit (abfd, sec);
7163   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7164   if (contents == NULL && sec_size != 0)
7165     {
7166       ok = FALSE;
7167       goto error_return;
7168     }
7169
7170   /* Record relocations against relaxable literal sections.  */
7171   for (i = 0; i < sec->reloc_count; i++)
7172     {
7173       Elf_Internal_Rela *irel = &internal_relocs[i];
7174       r_reloc r_rel;
7175       asection *target_sec;
7176       xtensa_relax_info *target_relax_info;
7177
7178       r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7179
7180       target_sec = r_reloc_get_section (&r_rel);
7181       target_relax_info = get_xtensa_relax_info (target_sec);
7182
7183       if (target_relax_info
7184           && (target_relax_info->is_relaxable_literal_section
7185               || target_relax_info->is_relaxable_asm_section))
7186         {
7187           xtensa_opcode opcode = XTENSA_UNDEFINED;
7188           int opnd = -1;
7189           bfd_boolean is_abs_literal = FALSE;
7190
7191           if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7192             {
7193               /* None of the current alternate relocs are PC-relative,
7194                  and only PC-relative relocs matter here.  However, we
7195                  still need to record the opcode for literal
7196                  coalescing.  */
7197               opcode = get_relocation_opcode (abfd, sec, contents, irel);
7198               if (opcode == get_l32r_opcode ())
7199                 {
7200                   is_abs_literal = TRUE;
7201                   opnd = 1;
7202                 }
7203               else
7204                 opcode = XTENSA_UNDEFINED;
7205             }
7206           else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
7207             {
7208               opcode = get_relocation_opcode (abfd, sec, contents, irel);
7209               opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
7210             }
7211
7212           if (opcode != XTENSA_UNDEFINED)
7213             {
7214               int src_next = target_relax_info->src_next++;
7215               source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
7216
7217               init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
7218                                  is_abs_literal);
7219             }
7220         }
7221     }
7222
7223   /* Now get rid of ASM_EXPAND relocations.  At this point, the
7224      src_relocs array for the target literal section may still be
7225      incomplete, but it must at least contain the entries for the L32R
7226      relocations associated with ASM_EXPANDs because they were just
7227      added in the preceding loop over the relocations.  */
7228
7229   for (i = 0; i < sec->reloc_count; i++)
7230     {
7231       Elf_Internal_Rela *irel = &internal_relocs[i];
7232       bfd_boolean is_reachable;
7233
7234       if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
7235                                         &is_reachable))
7236         continue;
7237
7238       if (is_reachable)
7239         {
7240           Elf_Internal_Rela *l32r_irel;
7241           r_reloc r_rel;
7242           asection *target_sec;
7243           xtensa_relax_info *target_relax_info;
7244
7245           /* Mark the source_reloc for the L32R so that it will be
7246              removed in compute_removed_literals(), along with the
7247              associated literal.  */
7248           l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
7249                                                  irel, internal_relocs);
7250           if (l32r_irel == NULL)
7251             continue;
7252
7253           r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
7254
7255           target_sec = r_reloc_get_section (&r_rel);
7256           target_relax_info = get_xtensa_relax_info (target_sec);
7257
7258           if (target_relax_info
7259               && (target_relax_info->is_relaxable_literal_section
7260                   || target_relax_info->is_relaxable_asm_section))
7261             {
7262               source_reloc *s_reloc;
7263
7264               /* Search the source_relocs for the entry corresponding to
7265                  the l32r_irel.  Note: The src_relocs array is not yet
7266                  sorted, but it wouldn't matter anyway because we're
7267                  searching by source offset instead of target offset.  */
7268               s_reloc = find_source_reloc (target_relax_info->src_relocs,
7269                                            target_relax_info->src_next,
7270                                            sec, l32r_irel);
7271               BFD_ASSERT (s_reloc);
7272               s_reloc->is_null = TRUE;
7273             }
7274
7275           /* Convert this reloc to ASM_SIMPLIFY.  */
7276           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
7277                                        R_XTENSA_ASM_SIMPLIFY);
7278           l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7279
7280           pin_internal_relocs (sec, internal_relocs);
7281         }
7282       else
7283         {
7284           /* It is resolvable but doesn't reach.  We resolve now
7285              by eliminating the relocation -- the call will remain
7286              expanded into L32R/CALLX.  */
7287           irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7288           pin_internal_relocs (sec, internal_relocs);
7289         }
7290     }
7291
7292  error_return:
7293   release_contents (sec, contents);
7294   release_internal_relocs (sec, internal_relocs);
7295   return ok;
7296 }
7297
7298
7299 /* Return TRUE if the asm expansion can be resolved.  Generally it can
7300    be resolved on a final link or when a partial link locates it in the
7301    same section as the target.  Set "is_reachable" flag if the target of
7302    the call is within the range of a direct call, given the current VMA
7303    for this section and the target section.  */
7304
7305 bfd_boolean
7306 is_resolvable_asm_expansion (bfd *abfd,
7307                              asection *sec,
7308                              bfd_byte *contents,
7309                              Elf_Internal_Rela *irel,
7310                              struct bfd_link_info *link_info,
7311                              bfd_boolean *is_reachable_p)
7312 {
7313   asection *target_sec;
7314   bfd_vma target_offset;
7315   r_reloc r_rel;
7316   xtensa_opcode opcode, direct_call_opcode;
7317   bfd_vma self_address;
7318   bfd_vma dest_address;
7319   bfd_boolean uses_l32r;
7320   bfd_size_type sec_size;
7321
7322   *is_reachable_p = FALSE;
7323
7324   if (contents == NULL)
7325     return FALSE;
7326
7327   if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
7328     return FALSE;
7329
7330   sec_size = bfd_get_section_limit (abfd, sec);
7331   opcode = get_expanded_call_opcode (contents + irel->r_offset,
7332                                      sec_size - irel->r_offset, &uses_l32r);
7333   /* Optimization of longcalls that use CONST16 is not yet implemented.  */
7334   if (!uses_l32r)
7335     return FALSE;
7336
7337   direct_call_opcode = swap_callx_for_call_opcode (opcode);
7338   if (direct_call_opcode == XTENSA_UNDEFINED)
7339     return FALSE;
7340
7341   /* Check and see that the target resolves.  */
7342   r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7343   if (!r_reloc_is_defined (&r_rel))
7344     return FALSE;
7345
7346   target_sec = r_reloc_get_section (&r_rel);
7347   target_offset = r_rel.target_offset;
7348
7349   /* If the target is in a shared library, then it doesn't reach.  This
7350      isn't supposed to come up because the compiler should never generate
7351      non-PIC calls on systems that use shared libraries, but the linker
7352      shouldn't crash regardless.  */
7353   if (!target_sec->output_section)
7354     return FALSE;
7355
7356   /* For relocatable sections, we can only simplify when the output
7357      section of the target is the same as the output section of the
7358      source.  */
7359   if (bfd_link_relocatable (link_info)
7360       && (target_sec->output_section != sec->output_section
7361           || is_reloc_sym_weak (abfd, irel)))
7362     return FALSE;
7363
7364   if (target_sec->output_section != sec->output_section)
7365     {
7366       /* If the two sections are sufficiently far away that relaxation
7367          might take the call out of range, we can't simplify.  For
7368          example, a positive displacement call into another memory
7369          could get moved to a lower address due to literal removal,
7370          but the destination won't move, and so the displacment might
7371          get larger.
7372
7373          If the displacement is negative, assume the destination could
7374          move as far back as the start of the output section.  The
7375          self_address will be at least as far into the output section
7376          as it is prior to relaxation.
7377
7378          If the displacement is postive, assume the destination will be in
7379          it's pre-relaxed location (because relaxation only makes sections
7380          smaller).  The self_address could go all the way to the beginning
7381          of the output section.  */
7382
7383       dest_address = target_sec->output_section->vma;
7384       self_address = sec->output_section->vma;
7385
7386       if (sec->output_section->vma > target_sec->output_section->vma)
7387         self_address += sec->output_offset + irel->r_offset + 3;
7388       else
7389         dest_address += bfd_get_section_limit (abfd, target_sec->output_section);
7390       /* Call targets should be four-byte aligned.  */
7391       dest_address = (dest_address + 3) & ~3;
7392     }
7393   else
7394     {
7395
7396       self_address = (sec->output_section->vma
7397                       + sec->output_offset + irel->r_offset + 3);
7398       dest_address = (target_sec->output_section->vma
7399                       + target_sec->output_offset + target_offset);
7400     }
7401
7402   *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
7403                                       self_address, dest_address);
7404
7405   if ((self_address >> CALL_SEGMENT_BITS) !=
7406       (dest_address >> CALL_SEGMENT_BITS))
7407     return FALSE;
7408
7409   return TRUE;
7410 }
7411
7412
7413 static Elf_Internal_Rela *
7414 find_associated_l32r_irel (bfd *abfd,
7415                            asection *sec,
7416                            bfd_byte *contents,
7417                            Elf_Internal_Rela *other_irel,
7418                            Elf_Internal_Rela *internal_relocs)
7419 {
7420   unsigned i;
7421
7422   for (i = 0; i < sec->reloc_count; i++)
7423     {
7424       Elf_Internal_Rela *irel = &internal_relocs[i];
7425
7426       if (irel == other_irel)
7427         continue;
7428       if (irel->r_offset != other_irel->r_offset)
7429         continue;
7430       if (is_l32r_relocation (abfd, sec, contents, irel))
7431         return irel;
7432     }
7433
7434   return NULL;
7435 }
7436
7437
7438 static xtensa_opcode *
7439 build_reloc_opcodes (bfd *abfd,
7440                      asection *sec,
7441                      bfd_byte *contents,
7442                      Elf_Internal_Rela *internal_relocs)
7443 {
7444   unsigned i;
7445   xtensa_opcode *reloc_opcodes =
7446     (xtensa_opcode *) bfd_malloc (sizeof (xtensa_opcode) * sec->reloc_count);
7447   for (i = 0; i < sec->reloc_count; i++)
7448     {
7449       Elf_Internal_Rela *irel = &internal_relocs[i];
7450       reloc_opcodes[i] = get_relocation_opcode (abfd, sec, contents, irel);
7451     }
7452   return reloc_opcodes;
7453 }
7454
7455 struct reloc_range_struct
7456 {
7457   bfd_vma addr;
7458   bfd_boolean add; /* TRUE if start of a range, FALSE otherwise.  */
7459   /* Original irel index in the array of relocations for a section.  */
7460   unsigned irel_index;
7461 };
7462 typedef struct reloc_range_struct reloc_range;
7463
7464 typedef struct reloc_range_list_entry_struct reloc_range_list_entry;
7465 struct reloc_range_list_entry_struct
7466 {
7467   reloc_range_list_entry *next;
7468   reloc_range_list_entry *prev;
7469   Elf_Internal_Rela *irel;
7470   xtensa_opcode opcode;
7471   int opnum;
7472 };
7473
7474 struct reloc_range_list_struct
7475 {
7476   /* The rest of the structure is only meaningful when ok is TRUE.  */
7477   bfd_boolean ok;
7478
7479   unsigned n_range; /* Number of range markers.  */
7480   reloc_range *range; /* Sorted range markers.  */
7481
7482   unsigned first; /* Index of a first range element in the list.  */
7483   unsigned last; /* One past index of a last range element in the list.  */
7484
7485   unsigned n_list; /* Number of list elements.  */
7486   reloc_range_list_entry *reloc; /*  */
7487   reloc_range_list_entry list_root;
7488 };
7489
7490 static int
7491 reloc_range_compare (const void *a, const void *b)
7492 {
7493   const reloc_range *ra = a;
7494   const reloc_range *rb = b;
7495
7496   if (ra->addr != rb->addr)
7497     return ra->addr < rb->addr ? -1 : 1;
7498   if (ra->add != rb->add)
7499     return ra->add ? -1 : 1;
7500   return 0;
7501 }
7502
7503 static void
7504 build_reloc_ranges (bfd *abfd, asection *sec,
7505                     bfd_byte *contents,
7506                     Elf_Internal_Rela *internal_relocs,
7507                     xtensa_opcode *reloc_opcodes,
7508                     reloc_range_list *list)
7509 {
7510   unsigned i;
7511   size_t n = 0;
7512   size_t max_n = 0;
7513   reloc_range *ranges = NULL;
7514   reloc_range_list_entry *reloc =
7515     bfd_malloc (sec->reloc_count * sizeof (*reloc));
7516
7517   memset (list, 0, sizeof (*list));
7518   list->ok = TRUE;
7519
7520   for (i = 0; i < sec->reloc_count; i++)
7521     {
7522       Elf_Internal_Rela *irel = &internal_relocs[i];
7523       int r_type = ELF32_R_TYPE (irel->r_info);
7524       reloc_howto_type *howto = &elf_howto_table[r_type];
7525       r_reloc r_rel;
7526
7527       if (r_type == R_XTENSA_ASM_SIMPLIFY
7528           || r_type == R_XTENSA_32_PCREL
7529           || !howto->pc_relative)
7530         continue;
7531
7532       r_reloc_init (&r_rel, abfd, irel, contents,
7533                     bfd_get_section_limit (abfd, sec));
7534
7535       if (r_reloc_get_section (&r_rel) != sec)
7536         continue;
7537
7538       if (n + 2 > max_n)
7539         {
7540           max_n = (max_n + 2) * 2;
7541           ranges = bfd_realloc (ranges, max_n * sizeof (*ranges));
7542         }
7543
7544       ranges[n].addr = irel->r_offset;
7545       ranges[n + 1].addr = r_rel.target_offset;
7546
7547       ranges[n].add = ranges[n].addr < ranges[n + 1].addr;
7548       ranges[n + 1].add = !ranges[n].add;
7549
7550       ranges[n].irel_index = i;
7551       ranges[n + 1].irel_index = i;
7552
7553       n += 2;
7554
7555       reloc[i].irel = irel;
7556
7557       /* Every relocation won't possibly be checked in the optimized version of
7558          check_section_ebb_pcrels_fit, so this needs to be done here.  */
7559       if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7560         {
7561           /* None of the current alternate relocs are PC-relative,
7562              and only PC-relative relocs matter here.  */
7563         }
7564       else
7565         {
7566           xtensa_opcode opcode;
7567           int opnum;
7568
7569           if (reloc_opcodes)
7570             opcode = reloc_opcodes[i];
7571           else
7572             opcode = get_relocation_opcode (abfd, sec, contents, irel);
7573
7574           if (opcode == XTENSA_UNDEFINED)
7575             {
7576               list->ok = FALSE;
7577               break;
7578             }
7579
7580           opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
7581           if (opnum == XTENSA_UNDEFINED)
7582             {
7583               list->ok = FALSE;
7584               break;
7585             }
7586
7587           /* Record relocation opcode and opnum as we've calculated them
7588              anyway and they won't change.  */
7589           reloc[i].opcode = opcode;
7590           reloc[i].opnum = opnum;
7591         }
7592     }
7593
7594   if (list->ok)
7595     {
7596       ranges = bfd_realloc (ranges, n * sizeof (*ranges));
7597       qsort (ranges, n, sizeof (*ranges), reloc_range_compare);
7598
7599       list->n_range = n;
7600       list->range = ranges;
7601       list->reloc = reloc;
7602       list->list_root.prev = &list->list_root;
7603       list->list_root.next = &list->list_root;
7604     }
7605   else
7606     {
7607       free (ranges);
7608       free (reloc);
7609     }
7610 }
7611
7612 static void reloc_range_list_append (reloc_range_list *list,
7613                                      unsigned irel_index)
7614 {
7615   reloc_range_list_entry *entry = list->reloc + irel_index;
7616
7617   entry->prev = list->list_root.prev;
7618   entry->next = &list->list_root;
7619   entry->prev->next = entry;
7620   entry->next->prev = entry;
7621   ++list->n_list;
7622 }
7623
7624 static void reloc_range_list_remove (reloc_range_list *list,
7625                                      unsigned irel_index)
7626 {
7627   reloc_range_list_entry *entry = list->reloc + irel_index;
7628
7629   entry->next->prev = entry->prev;
7630   entry->prev->next = entry->next;
7631   --list->n_list;
7632 }
7633
7634 /* Update relocation list object so that it lists all relocations that cross
7635    [first; last] range.  Range bounds should not decrease with successive
7636    invocations.  */
7637 static void reloc_range_list_update_range (reloc_range_list *list,
7638                                            bfd_vma first, bfd_vma last)
7639 {
7640   /* This should not happen: EBBs are iterated from lower addresses to higher.
7641      But even if that happens there's no need to break: just flush current list
7642      and start from scratch.  */
7643   if ((list->last > 0 && list->range[list->last - 1].addr > last) ||
7644       (list->first > 0 && list->range[list->first - 1].addr >= first))
7645     {
7646       list->first = 0;
7647       list->last = 0;
7648       list->n_list = 0;
7649       list->list_root.next = &list->list_root;
7650       list->list_root.prev = &list->list_root;
7651       fprintf (stderr, "%s: move backwards requested\n", __func__);
7652     }
7653
7654   for (; list->last < list->n_range &&
7655        list->range[list->last].addr <= last; ++list->last)
7656     if (list->range[list->last].add)
7657       reloc_range_list_append (list, list->range[list->last].irel_index);
7658
7659   for (; list->first < list->n_range &&
7660        list->range[list->first].addr < first; ++list->first)
7661     if (!list->range[list->first].add)
7662       reloc_range_list_remove (list, list->range[list->first].irel_index);
7663 }
7664
7665 static void free_reloc_range_list (reloc_range_list *list)
7666 {
7667   free (list->range);
7668   free (list->reloc);
7669 }
7670
7671 /* The compute_text_actions function will build a list of potential
7672    transformation actions for code in the extended basic block of each
7673    longcall that is optimized to a direct call.  From this list we
7674    generate a set of actions to actually perform that optimizes for
7675    space and, if not using size_opt, maintains branch target
7676    alignments.
7677
7678    These actions to be performed are placed on a per-section list.
7679    The actual changes are performed by relax_section() in the second
7680    pass.  */
7681
7682 bfd_boolean
7683 compute_text_actions (bfd *abfd,
7684                       asection *sec,
7685                       struct bfd_link_info *link_info)
7686 {
7687   xtensa_opcode *reloc_opcodes = NULL;
7688   xtensa_relax_info *relax_info;
7689   bfd_byte *contents;
7690   Elf_Internal_Rela *internal_relocs;
7691   bfd_boolean ok = TRUE;
7692   unsigned i;
7693   property_table_entry *prop_table = 0;
7694   int ptblsize = 0;
7695   bfd_size_type sec_size;
7696   reloc_range_list relevant_relocs;
7697
7698   relax_info = get_xtensa_relax_info (sec);
7699   BFD_ASSERT (relax_info);
7700   BFD_ASSERT (relax_info->src_next == relax_info->src_count);
7701
7702   /* Do nothing if the section contains no optimized longcalls.  */
7703   if (!relax_info->is_relaxable_asm_section)
7704     return ok;
7705
7706   internal_relocs = retrieve_internal_relocs (abfd, sec,
7707                                               link_info->keep_memory);
7708
7709   if (internal_relocs)
7710     qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7711            internal_reloc_compare);
7712
7713   sec_size = bfd_get_section_limit (abfd, sec);
7714   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7715   if (contents == NULL && sec_size != 0)
7716     {
7717       ok = FALSE;
7718       goto error_return;
7719     }
7720
7721   ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7722                                         XTENSA_PROP_SEC_NAME, FALSE);
7723   if (ptblsize < 0)
7724     {
7725       ok = FALSE;
7726       goto error_return;
7727     }
7728
7729   /* Precompute the opcode for each relocation.  */
7730   reloc_opcodes = build_reloc_opcodes (abfd, sec, contents, internal_relocs);
7731
7732   build_reloc_ranges (abfd, sec, contents, internal_relocs, reloc_opcodes,
7733                       &relevant_relocs);
7734
7735   for (i = 0; i < sec->reloc_count; i++)
7736     {
7737       Elf_Internal_Rela *irel = &internal_relocs[i];
7738       bfd_vma r_offset;
7739       property_table_entry *the_entry;
7740       int ptbl_idx;
7741       ebb_t *ebb;
7742       ebb_constraint ebb_table;
7743       bfd_size_type simplify_size;
7744
7745       if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
7746         continue;
7747       r_offset = irel->r_offset;
7748
7749       simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
7750       if (simplify_size == 0)
7751         {
7752           (*_bfd_error_handler)
7753             (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
7754              sec->owner, sec, r_offset);
7755           continue;
7756         }
7757
7758       /* If the instruction table is not around, then don't do this
7759          relaxation.  */
7760       the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7761                                                   sec->vma + irel->r_offset);
7762       if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
7763         {
7764           text_action_add (&relax_info->action_list,
7765                            ta_convert_longcall, sec, r_offset,
7766                            0);
7767           continue;
7768         }
7769
7770       /* If the next longcall happens to be at the same address as an
7771          unreachable section of size 0, then skip forward.  */
7772       ptbl_idx = the_entry - prop_table;
7773       while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
7774              && the_entry->size == 0
7775              && ptbl_idx + 1 < ptblsize
7776              && (prop_table[ptbl_idx + 1].address
7777                  == prop_table[ptbl_idx].address))
7778         {
7779           ptbl_idx++;
7780           the_entry++;
7781         }
7782
7783       if (the_entry->flags & XTENSA_PROP_NO_TRANSFORM)
7784           /* NO_REORDER is OK */
7785         continue;
7786
7787       init_ebb_constraint (&ebb_table);
7788       ebb = &ebb_table.ebb;
7789       init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
7790                 internal_relocs, sec->reloc_count);
7791       ebb->start_offset = r_offset + simplify_size;
7792       ebb->end_offset = r_offset + simplify_size;
7793       ebb->start_ptbl_idx = ptbl_idx;
7794       ebb->end_ptbl_idx = ptbl_idx;
7795       ebb->start_reloc_idx = i;
7796       ebb->end_reloc_idx = i;
7797
7798       if (!extend_ebb_bounds (ebb)
7799           || !compute_ebb_proposed_actions (&ebb_table)
7800           || !compute_ebb_actions (&ebb_table)
7801           || !check_section_ebb_pcrels_fit (abfd, sec, contents,
7802                                             internal_relocs,
7803                                             &relevant_relocs,
7804                                             &ebb_table, reloc_opcodes)
7805           || !check_section_ebb_reduces (&ebb_table))
7806         {
7807           /* If anything goes wrong or we get unlucky and something does
7808              not fit, with our plan because of expansion between
7809              critical branches, just convert to a NOP.  */
7810
7811           text_action_add (&relax_info->action_list,
7812                            ta_convert_longcall, sec, r_offset, 0);
7813           i = ebb_table.ebb.end_reloc_idx;
7814           free_ebb_constraint (&ebb_table);
7815           continue;
7816         }
7817
7818       text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
7819
7820       /* Update the index so we do not go looking at the relocations
7821          we have already processed.  */
7822       i = ebb_table.ebb.end_reloc_idx;
7823       free_ebb_constraint (&ebb_table);
7824     }
7825
7826   free_reloc_range_list (&relevant_relocs);
7827
7828 #if DEBUG
7829   if (action_list_count (&relax_info->action_list))
7830     print_action_list (stderr, &relax_info->action_list);
7831 #endif
7832
7833 error_return:
7834   release_contents (sec, contents);
7835   release_internal_relocs (sec, internal_relocs);
7836   if (prop_table)
7837     free (prop_table);
7838   if (reloc_opcodes)
7839     free (reloc_opcodes);
7840
7841   return ok;
7842 }
7843
7844
7845 /* Do not widen an instruction if it is preceeded by a
7846    loop opcode.  It might cause misalignment.  */
7847
7848 static bfd_boolean
7849 prev_instr_is_a_loop (bfd_byte *contents,
7850                       bfd_size_type content_length,
7851                       bfd_size_type offset)
7852 {
7853   xtensa_opcode prev_opcode;
7854
7855   if (offset < 3)
7856     return FALSE;
7857   prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
7858   return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
7859 }
7860
7861
7862 /* Find all of the possible actions for an extended basic block.  */
7863
7864 bfd_boolean
7865 compute_ebb_proposed_actions (ebb_constraint *ebb_table)
7866 {
7867   const ebb_t *ebb = &ebb_table->ebb;
7868   unsigned rel_idx = ebb->start_reloc_idx;
7869   property_table_entry *entry, *start_entry, *end_entry;
7870   bfd_vma offset = 0;
7871   xtensa_isa isa = xtensa_default_isa;
7872   xtensa_format fmt;
7873   static xtensa_insnbuf insnbuf = NULL;
7874   static xtensa_insnbuf slotbuf = NULL;
7875
7876   if (insnbuf == NULL)
7877     {
7878       insnbuf = xtensa_insnbuf_alloc (isa);
7879       slotbuf = xtensa_insnbuf_alloc (isa);
7880     }
7881
7882   start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
7883   end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
7884
7885   for (entry = start_entry; entry <= end_entry; entry++)
7886     {
7887       bfd_vma start_offset, end_offset;
7888       bfd_size_type insn_len;
7889
7890       start_offset = entry->address - ebb->sec->vma;
7891       end_offset = entry->address + entry->size - ebb->sec->vma;
7892
7893       if (entry == start_entry)
7894         start_offset = ebb->start_offset;
7895       if (entry == end_entry)
7896         end_offset = ebb->end_offset;
7897       offset = start_offset;
7898
7899       if (offset == entry->address - ebb->sec->vma
7900           && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
7901         {
7902           enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
7903           BFD_ASSERT (offset != end_offset);
7904           if (offset == end_offset)
7905             return FALSE;
7906
7907           insn_len = insn_decode_len (ebb->contents, ebb->content_length,
7908                                       offset);
7909           if (insn_len == 0)
7910             goto decode_error;
7911
7912           if (check_branch_target_aligned_address (offset, insn_len))
7913             align_type = EBB_REQUIRE_TGT_ALIGN;
7914
7915           ebb_propose_action (ebb_table, align_type, 0,
7916                               ta_none, offset, 0, TRUE);
7917         }
7918
7919       while (offset != end_offset)
7920         {
7921           Elf_Internal_Rela *irel;
7922           xtensa_opcode opcode;
7923
7924           while (rel_idx < ebb->end_reloc_idx
7925                  && (ebb->relocs[rel_idx].r_offset < offset
7926                      || (ebb->relocs[rel_idx].r_offset == offset
7927                          && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
7928                              != R_XTENSA_ASM_SIMPLIFY))))
7929             rel_idx++;
7930
7931           /* Check for longcall.  */
7932           irel = &ebb->relocs[rel_idx];
7933           if (irel->r_offset == offset
7934               && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
7935             {
7936               bfd_size_type simplify_size;
7937
7938               simplify_size = get_asm_simplify_size (ebb->contents,
7939                                                      ebb->content_length,
7940                                                      irel->r_offset);
7941               if (simplify_size == 0)
7942                 goto decode_error;
7943
7944               ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7945                                   ta_convert_longcall, offset, 0, TRUE);
7946
7947               offset += simplify_size;
7948               continue;
7949             }
7950
7951           if (offset + MIN_INSN_LENGTH > ebb->content_length)
7952             goto decode_error;
7953           xtensa_insnbuf_from_chars (isa, insnbuf, &ebb->contents[offset],
7954                                      ebb->content_length - offset);
7955           fmt = xtensa_format_decode (isa, insnbuf);
7956           if (fmt == XTENSA_UNDEFINED)
7957             goto decode_error;
7958           insn_len = xtensa_format_length (isa, fmt);
7959           if (insn_len == (bfd_size_type) XTENSA_UNDEFINED)
7960             goto decode_error;
7961
7962           if (xtensa_format_num_slots (isa, fmt) != 1)
7963             {
7964               offset += insn_len;
7965               continue;
7966             }
7967
7968           xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7969           opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7970           if (opcode == XTENSA_UNDEFINED)
7971             goto decode_error;
7972
7973           if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
7974               && (entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7975               && can_narrow_instruction (slotbuf, fmt, opcode) != 0)
7976             {
7977               /* Add an instruction narrow action.  */
7978               ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7979                                   ta_narrow_insn, offset, 0, FALSE);
7980             }
7981           else if ((entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7982                    && can_widen_instruction (slotbuf, fmt, opcode) != 0
7983                    && ! prev_instr_is_a_loop (ebb->contents,
7984                                               ebb->content_length, offset))
7985             {
7986               /* Add an instruction widen action.  */
7987               ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7988                                   ta_widen_insn, offset, 0, FALSE);
7989             }
7990           else if (xtensa_opcode_is_loop (xtensa_default_isa, opcode) == 1)
7991             {
7992               /* Check for branch targets.  */
7993               ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
7994                                   ta_none, offset, 0, TRUE);
7995             }
7996
7997           offset += insn_len;
7998         }
7999     }
8000
8001   if (ebb->ends_unreachable)
8002     {
8003       ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
8004                           ta_fill, ebb->end_offset, 0, TRUE);
8005     }
8006
8007   return TRUE;
8008
8009  decode_error:
8010   (*_bfd_error_handler)
8011     (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
8012      ebb->sec->owner, ebb->sec, offset);
8013   return FALSE;
8014 }
8015
8016
8017 /* After all of the information has collected about the
8018    transformations possible in an EBB, compute the appropriate actions
8019    here in compute_ebb_actions.  We still must check later to make
8020    sure that the actions do not break any relocations.  The algorithm
8021    used here is pretty greedy.  Basically, it removes as many no-ops
8022    as possible so that the end of the EBB has the same alignment
8023    characteristics as the original.  First, it uses narrowing, then
8024    fill space at the end of the EBB, and finally widenings.  If that
8025    does not work, it tries again with one fewer no-op removed.  The
8026    optimization will only be performed if all of the branch targets
8027    that were aligned before transformation are also aligned after the
8028    transformation.
8029
8030    When the size_opt flag is set, ignore the branch target alignments,
8031    narrow all wide instructions, and remove all no-ops unless the end
8032    of the EBB prevents it.  */
8033
8034 bfd_boolean
8035 compute_ebb_actions (ebb_constraint *ebb_table)
8036 {
8037   unsigned i = 0;
8038   unsigned j;
8039   int removed_bytes = 0;
8040   ebb_t *ebb = &ebb_table->ebb;
8041   unsigned seg_idx_start = 0;
8042   unsigned seg_idx_end = 0;
8043
8044   /* We perform this like the assembler relaxation algorithm: Start by
8045      assuming all instructions are narrow and all no-ops removed; then
8046      walk through....  */
8047
8048   /* For each segment of this that has a solid constraint, check to
8049      see if there are any combinations that will keep the constraint.
8050      If so, use it.  */
8051   for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
8052     {
8053       bfd_boolean requires_text_end_align = FALSE;
8054       unsigned longcall_count = 0;
8055       unsigned longcall_convert_count = 0;
8056       unsigned narrowable_count = 0;
8057       unsigned narrowable_convert_count = 0;
8058       unsigned widenable_count = 0;
8059       unsigned widenable_convert_count = 0;
8060
8061       proposed_action *action = NULL;
8062       int align = (1 << ebb_table->ebb.sec->alignment_power);
8063
8064       seg_idx_start = seg_idx_end;
8065
8066       for (i = seg_idx_start; i < ebb_table->action_count; i++)
8067         {
8068           action = &ebb_table->actions[i];
8069           if (action->action == ta_convert_longcall)
8070             longcall_count++;
8071           if (action->action == ta_narrow_insn)
8072             narrowable_count++;
8073           if (action->action == ta_widen_insn)
8074             widenable_count++;
8075           if (action->action == ta_fill)
8076             break;
8077           if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
8078             break;
8079           if (action->align_type == EBB_REQUIRE_TGT_ALIGN
8080               && !elf32xtensa_size_opt)
8081             break;
8082         }
8083       seg_idx_end = i;
8084
8085       if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
8086         requires_text_end_align = TRUE;
8087
8088       if (elf32xtensa_size_opt && !requires_text_end_align
8089           && action->align_type != EBB_REQUIRE_LOOP_ALIGN
8090           && action->align_type != EBB_REQUIRE_TGT_ALIGN)
8091         {
8092           longcall_convert_count = longcall_count;
8093           narrowable_convert_count = narrowable_count;
8094           widenable_convert_count = 0;
8095         }
8096       else
8097         {
8098           /* There is a constraint.  Convert the max number of longcalls.  */
8099           narrowable_convert_count = 0;
8100           longcall_convert_count = 0;
8101           widenable_convert_count = 0;
8102
8103           for (j = 0; j < longcall_count; j++)
8104             {
8105               int removed = (longcall_count - j) * 3 & (align - 1);
8106               unsigned desire_narrow = (align - removed) & (align - 1);
8107               unsigned desire_widen = removed;
8108               if (desire_narrow <= narrowable_count)
8109                 {
8110                   narrowable_convert_count = desire_narrow;
8111                   narrowable_convert_count +=
8112                     (align * ((narrowable_count - narrowable_convert_count)
8113                               / align));
8114                   longcall_convert_count = (longcall_count - j);
8115                   widenable_convert_count = 0;
8116                   break;
8117                 }
8118               if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
8119                 {
8120                   narrowable_convert_count = 0;
8121                   longcall_convert_count = longcall_count - j;
8122                   widenable_convert_count = desire_widen;
8123                   break;
8124                 }
8125             }
8126         }
8127
8128       /* Now the number of conversions are saved.  Do them.  */
8129       for (i = seg_idx_start; i < seg_idx_end; i++)
8130         {
8131           action = &ebb_table->actions[i];
8132           switch (action->action)
8133             {
8134             case ta_convert_longcall:
8135               if (longcall_convert_count != 0)
8136                 {
8137                   action->action = ta_remove_longcall;
8138                   action->do_action = TRUE;
8139                   action->removed_bytes += 3;
8140                   longcall_convert_count--;
8141                 }
8142               break;
8143             case ta_narrow_insn:
8144               if (narrowable_convert_count != 0)
8145                 {
8146                   action->do_action = TRUE;
8147                   action->removed_bytes += 1;
8148                   narrowable_convert_count--;
8149                 }
8150               break;
8151             case ta_widen_insn:
8152               if (widenable_convert_count != 0)
8153                 {
8154                   action->do_action = TRUE;
8155                   action->removed_bytes -= 1;
8156                   widenable_convert_count--;
8157                 }
8158               break;
8159             default:
8160               break;
8161             }
8162         }
8163     }
8164
8165   /* Now we move on to some local opts.  Try to remove each of the
8166      remaining longcalls.  */
8167
8168   if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
8169     {
8170       removed_bytes = 0;
8171       for (i = 0; i < ebb_table->action_count; i++)
8172         {
8173           int old_removed_bytes = removed_bytes;
8174           proposed_action *action = &ebb_table->actions[i];
8175
8176           if (action->do_action && action->action == ta_convert_longcall)
8177             {
8178               bfd_boolean bad_alignment = FALSE;
8179               removed_bytes += 3;
8180               for (j = i + 1; j < ebb_table->action_count; j++)
8181                 {
8182                   proposed_action *new_action = &ebb_table->actions[j];
8183                   bfd_vma offset = new_action->offset;
8184                   if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
8185                     {
8186                       if (!check_branch_target_aligned
8187                           (ebb_table->ebb.contents,
8188                            ebb_table->ebb.content_length,
8189                            offset, offset - removed_bytes))
8190                         {
8191                           bad_alignment = TRUE;
8192                           break;
8193                         }
8194                     }
8195                   if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
8196                     {
8197                       if (!check_loop_aligned (ebb_table->ebb.contents,
8198                                                ebb_table->ebb.content_length,
8199                                                offset,
8200                                                offset - removed_bytes))
8201                         {
8202                           bad_alignment = TRUE;
8203                           break;
8204                         }
8205                     }
8206                   if (new_action->action == ta_narrow_insn
8207                       && !new_action->do_action
8208                       && ebb_table->ebb.sec->alignment_power == 2)
8209                     {
8210                       /* Narrow an instruction and we are done.  */
8211                       new_action->do_action = TRUE;
8212                       new_action->removed_bytes += 1;
8213                       bad_alignment = FALSE;
8214                       break;
8215                     }
8216                   if (new_action->action == ta_widen_insn
8217                       && new_action->do_action
8218                       && ebb_table->ebb.sec->alignment_power == 2)
8219                     {
8220                       /* Narrow an instruction and we are done.  */
8221                       new_action->do_action = FALSE;
8222                       new_action->removed_bytes += 1;
8223                       bad_alignment = FALSE;
8224                       break;
8225                     }
8226                   if (new_action->do_action)
8227                     removed_bytes += new_action->removed_bytes;
8228                 }
8229               if (!bad_alignment)
8230                 {
8231                   action->removed_bytes += 3;
8232                   action->action = ta_remove_longcall;
8233                   action->do_action = TRUE;
8234                 }
8235             }
8236           removed_bytes = old_removed_bytes;
8237           if (action->do_action)
8238             removed_bytes += action->removed_bytes;
8239         }
8240     }
8241
8242   removed_bytes = 0;
8243   for (i = 0; i < ebb_table->action_count; ++i)
8244     {
8245       proposed_action *action = &ebb_table->actions[i];
8246       if (action->do_action)
8247         removed_bytes += action->removed_bytes;
8248     }
8249
8250   if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
8251       && ebb->ends_unreachable)
8252     {
8253       proposed_action *action;
8254       int br;
8255       int extra_space;
8256
8257       BFD_ASSERT (ebb_table->action_count != 0);
8258       action = &ebb_table->actions[ebb_table->action_count - 1];
8259       BFD_ASSERT (action->action == ta_fill);
8260       BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
8261
8262       extra_space = compute_fill_extra_space (ebb->ends_unreachable);
8263       br = action->removed_bytes + removed_bytes + extra_space;
8264       br = br & ((1 << ebb->sec->alignment_power ) - 1);
8265
8266       action->removed_bytes = extra_space - br;
8267     }
8268   return TRUE;
8269 }
8270
8271
8272 /* The xlate_map is a sorted array of address mappings designed to
8273    answer the offset_with_removed_text() query with a binary search instead
8274    of a linear search through the section's action_list.  */
8275
8276 typedef struct xlate_map_entry xlate_map_entry_t;
8277 typedef struct xlate_map xlate_map_t;
8278
8279 struct xlate_map_entry
8280 {
8281   unsigned orig_address;
8282   unsigned new_address;
8283   unsigned size;
8284 };
8285
8286 struct xlate_map
8287 {
8288   unsigned entry_count;
8289   xlate_map_entry_t *entry;
8290 };
8291
8292
8293 static int
8294 xlate_compare (const void *a_v, const void *b_v)
8295 {
8296   const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
8297   const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
8298   if (a->orig_address < b->orig_address)
8299     return -1;
8300   if (a->orig_address > (b->orig_address + b->size - 1))
8301     return 1;
8302   return 0;
8303 }
8304
8305
8306 static bfd_vma
8307 xlate_offset_with_removed_text (const xlate_map_t *map,
8308                                 text_action_list *action_list,
8309                                 bfd_vma offset)
8310 {
8311   void *r;
8312   xlate_map_entry_t *e;
8313
8314   if (map == NULL)
8315     return offset_with_removed_text (action_list, offset);
8316
8317   if (map->entry_count == 0)
8318     return offset;
8319
8320   r = bsearch (&offset, map->entry, map->entry_count,
8321                sizeof (xlate_map_entry_t), &xlate_compare);
8322   e = (xlate_map_entry_t *) r;
8323
8324   BFD_ASSERT (e != NULL);
8325   if (e == NULL)
8326     return offset;
8327   return e->new_address - e->orig_address + offset;
8328 }
8329
8330 typedef struct xlate_map_context_struct xlate_map_context;
8331 struct xlate_map_context_struct
8332 {
8333   xlate_map_t *map;
8334   xlate_map_entry_t *current_entry;
8335   int removed;
8336 };
8337
8338 static int
8339 xlate_map_fn (splay_tree_node node, void *p)
8340 {
8341   text_action *r = (text_action *)node->value;
8342   xlate_map_context *ctx = p;
8343   unsigned orig_size = 0;
8344
8345   switch (r->action)
8346     {
8347     case ta_none:
8348     case ta_remove_insn:
8349     case ta_convert_longcall:
8350     case ta_remove_literal:
8351     case ta_add_literal:
8352       break;
8353     case ta_remove_longcall:
8354       orig_size = 6;
8355       break;
8356     case ta_narrow_insn:
8357       orig_size = 3;
8358       break;
8359     case ta_widen_insn:
8360       orig_size = 2;
8361       break;
8362     case ta_fill:
8363       break;
8364     }
8365   ctx->current_entry->size =
8366     r->offset + orig_size - ctx->current_entry->orig_address;
8367   if (ctx->current_entry->size != 0)
8368     {
8369       ctx->current_entry++;
8370       ctx->map->entry_count++;
8371     }
8372   ctx->current_entry->orig_address = r->offset + orig_size;
8373   ctx->removed += r->removed_bytes;
8374   ctx->current_entry->new_address = r->offset + orig_size - ctx->removed;
8375   ctx->current_entry->size = 0;
8376   return 0;
8377 }
8378
8379 /* Build a binary searchable offset translation map from a section's
8380    action list.  */
8381
8382 static xlate_map_t *
8383 build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
8384 {
8385   text_action_list *action_list = &relax_info->action_list;
8386   unsigned num_actions = 0;
8387   xlate_map_context ctx;
8388
8389   ctx.map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
8390
8391   if (ctx.map == NULL)
8392     return NULL;
8393
8394   num_actions = action_list_count (action_list);
8395   ctx.map->entry = (xlate_map_entry_t *)
8396     bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
8397   if (ctx.map->entry == NULL)
8398     {
8399       free (ctx.map);
8400       return NULL;
8401     }
8402   ctx.map->entry_count = 0;
8403
8404   ctx.removed = 0;
8405   ctx.current_entry = &ctx.map->entry[0];
8406
8407   ctx.current_entry->orig_address = 0;
8408   ctx.current_entry->new_address = 0;
8409   ctx.current_entry->size = 0;
8410
8411   splay_tree_foreach (action_list->tree, xlate_map_fn, &ctx);
8412
8413   ctx.current_entry->size = (bfd_get_section_limit (sec->owner, sec)
8414                              - ctx.current_entry->orig_address);
8415   if (ctx.current_entry->size != 0)
8416     ctx.map->entry_count++;
8417
8418   return ctx.map;
8419 }
8420
8421
8422 /* Free an offset translation map.  */
8423
8424 static void
8425 free_xlate_map (xlate_map_t *map)
8426 {
8427   if (map && map->entry)
8428     free (map->entry);
8429   if (map)
8430     free (map);
8431 }
8432
8433
8434 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8435    relocations in a section will fit if a proposed set of actions
8436    are performed.  */
8437
8438 static bfd_boolean
8439 check_section_ebb_pcrels_fit (bfd *abfd,
8440                               asection *sec,
8441                               bfd_byte *contents,
8442                               Elf_Internal_Rela *internal_relocs,
8443                               reloc_range_list *relevant_relocs,
8444                               const ebb_constraint *constraint,
8445                               const xtensa_opcode *reloc_opcodes)
8446 {
8447   unsigned i, j;
8448   unsigned n = sec->reloc_count;
8449   Elf_Internal_Rela *irel;
8450   xlate_map_t *xmap = NULL;
8451   bfd_boolean ok = TRUE;
8452   xtensa_relax_info *relax_info;
8453   reloc_range_list_entry *entry = NULL;
8454
8455   relax_info = get_xtensa_relax_info (sec);
8456
8457   if (relax_info && sec->reloc_count > 100)
8458     {
8459       xmap = build_xlate_map (sec, relax_info);
8460       /* NULL indicates out of memory, but the slow version
8461          can still be used.  */
8462     }
8463
8464   if (relevant_relocs && constraint->action_count)
8465     {
8466       if (!relevant_relocs->ok)
8467         {
8468           ok = FALSE;
8469           n = 0;
8470         }
8471       else
8472         {
8473           bfd_vma min_offset, max_offset;
8474           min_offset = max_offset = constraint->actions[0].offset;
8475
8476           for (i = 1; i < constraint->action_count; ++i)
8477             {
8478               proposed_action *action = &constraint->actions[i];
8479               bfd_vma offset = action->offset;
8480
8481               if (offset < min_offset)
8482                 min_offset = offset;
8483               if (offset > max_offset)
8484                 max_offset = offset;
8485             }
8486           reloc_range_list_update_range (relevant_relocs, min_offset,
8487                                          max_offset);
8488           n = relevant_relocs->n_list;
8489           entry = &relevant_relocs->list_root;
8490         }
8491     }
8492   else
8493     {
8494       relevant_relocs = NULL;
8495     }
8496
8497   for (i = 0; i < n; i++)
8498     {
8499       r_reloc r_rel;
8500       bfd_vma orig_self_offset, orig_target_offset;
8501       bfd_vma self_offset, target_offset;
8502       int r_type;
8503       reloc_howto_type *howto;
8504       int self_removed_bytes, target_removed_bytes;
8505
8506       if (relevant_relocs)
8507         {
8508           entry = entry->next;
8509           irel = entry->irel;
8510         }
8511       else
8512         {
8513           irel = internal_relocs + i;
8514         }
8515       r_type = ELF32_R_TYPE (irel->r_info);
8516
8517       howto = &elf_howto_table[r_type];
8518       /* We maintain the required invariant: PC-relative relocations
8519          that fit before linking must fit after linking.  Thus we only
8520          need to deal with relocations to the same section that are
8521          PC-relative.  */
8522       if (r_type == R_XTENSA_ASM_SIMPLIFY
8523           || r_type == R_XTENSA_32_PCREL
8524           || !howto->pc_relative)
8525         continue;
8526
8527       r_reloc_init (&r_rel, abfd, irel, contents,
8528                     bfd_get_section_limit (abfd, sec));
8529
8530       if (r_reloc_get_section (&r_rel) != sec)
8531         continue;
8532
8533       orig_self_offset = irel->r_offset;
8534       orig_target_offset = r_rel.target_offset;
8535
8536       self_offset = orig_self_offset;
8537       target_offset = orig_target_offset;
8538
8539       if (relax_info)
8540         {
8541           self_offset =
8542             xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8543                                             orig_self_offset);
8544           target_offset =
8545             xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8546                                             orig_target_offset);
8547         }
8548
8549       self_removed_bytes = 0;
8550       target_removed_bytes = 0;
8551
8552       for (j = 0; j < constraint->action_count; ++j)
8553         {
8554           proposed_action *action = &constraint->actions[j];
8555           bfd_vma offset = action->offset;
8556           int removed_bytes = action->removed_bytes;
8557           if (offset < orig_self_offset
8558               || (offset == orig_self_offset && action->action == ta_fill
8559                   && action->removed_bytes < 0))
8560             self_removed_bytes += removed_bytes;
8561           if (offset < orig_target_offset
8562               || (offset == orig_target_offset && action->action == ta_fill
8563                   && action->removed_bytes < 0))
8564             target_removed_bytes += removed_bytes;
8565         }
8566       self_offset -= self_removed_bytes;
8567       target_offset -= target_removed_bytes;
8568
8569       /* Try to encode it.  Get the operand and check.  */
8570       if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
8571         {
8572           /* None of the current alternate relocs are PC-relative,
8573              and only PC-relative relocs matter here.  */
8574         }
8575       else
8576         {
8577           xtensa_opcode opcode;
8578           int opnum;
8579
8580           if (relevant_relocs)
8581             {
8582               opcode = entry->opcode;
8583               opnum = entry->opnum;
8584             }
8585           else
8586             {
8587               if (reloc_opcodes)
8588                 opcode = reloc_opcodes[relevant_relocs ?
8589                   (unsigned)(entry - relevant_relocs->reloc) : i];
8590               else
8591                 opcode = get_relocation_opcode (abfd, sec, contents, irel);
8592               if (opcode == XTENSA_UNDEFINED)
8593                 {
8594                   ok = FALSE;
8595                   break;
8596                 }
8597
8598               opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
8599               if (opnum == XTENSA_UNDEFINED)
8600                 {
8601                   ok = FALSE;
8602                   break;
8603                 }
8604             }
8605
8606           if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
8607             {
8608               ok = FALSE;
8609               break;
8610             }
8611         }
8612     }
8613
8614   if (xmap)
8615     free_xlate_map (xmap);
8616
8617   return ok;
8618 }
8619
8620
8621 static bfd_boolean
8622 check_section_ebb_reduces (const ebb_constraint *constraint)
8623 {
8624   int removed = 0;
8625   unsigned i;
8626
8627   for (i = 0; i < constraint->action_count; i++)
8628     {
8629       const proposed_action *action = &constraint->actions[i];
8630       if (action->do_action)
8631         removed += action->removed_bytes;
8632     }
8633   if (removed < 0)
8634     return FALSE;
8635
8636   return TRUE;
8637 }
8638
8639
8640 void
8641 text_action_add_proposed (text_action_list *l,
8642                           const ebb_constraint *ebb_table,
8643                           asection *sec)
8644 {
8645   unsigned i;
8646
8647   for (i = 0; i < ebb_table->action_count; i++)
8648     {
8649       proposed_action *action = &ebb_table->actions[i];
8650
8651       if (!action->do_action)
8652         continue;
8653       switch (action->action)
8654         {
8655         case ta_remove_insn:
8656         case ta_remove_longcall:
8657         case ta_convert_longcall:
8658         case ta_narrow_insn:
8659         case ta_widen_insn:
8660         case ta_fill:
8661         case ta_remove_literal:
8662           text_action_add (l, action->action, sec, action->offset,
8663                            action->removed_bytes);
8664           break;
8665         case ta_none:
8666           break;
8667         default:
8668           BFD_ASSERT (0);
8669           break;
8670         }
8671     }
8672 }
8673
8674
8675 int
8676 compute_fill_extra_space (property_table_entry *entry)
8677 {
8678   int fill_extra_space;
8679
8680   if (!entry)
8681     return 0;
8682
8683   if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
8684     return 0;
8685
8686   fill_extra_space = entry->size;
8687   if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
8688     {
8689       /* Fill bytes for alignment:
8690          (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8691       int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
8692       int nsm = (1 << pow) - 1;
8693       bfd_vma addr = entry->address + entry->size;
8694       bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
8695       fill_extra_space += align_fill;
8696     }
8697   return fill_extra_space;
8698 }
8699
8700 \f
8701 /* First relaxation pass.  */
8702
8703 /* If the section contains relaxable literals, check each literal to
8704    see if it has the same value as another literal that has already
8705    been seen, either in the current section or a previous one.  If so,
8706    add an entry to the per-section list of removed literals.  The
8707    actual changes are deferred until the next pass.  */
8708
8709 static bfd_boolean
8710 compute_removed_literals (bfd *abfd,
8711                           asection *sec,
8712                           struct bfd_link_info *link_info,
8713                           value_map_hash_table *values)
8714 {
8715   xtensa_relax_info *relax_info;
8716   bfd_byte *contents;
8717   Elf_Internal_Rela *internal_relocs;
8718   source_reloc *src_relocs, *rel;
8719   bfd_boolean ok = TRUE;
8720   property_table_entry *prop_table = NULL;
8721   int ptblsize;
8722   int i, prev_i;
8723   bfd_boolean last_loc_is_prev = FALSE;
8724   bfd_vma last_target_offset = 0;
8725   section_cache_t target_sec_cache;
8726   bfd_size_type sec_size;
8727
8728   init_section_cache (&target_sec_cache);
8729
8730   /* Do nothing if it is not a relaxable literal section.  */
8731   relax_info = get_xtensa_relax_info (sec);
8732   BFD_ASSERT (relax_info);
8733   if (!relax_info->is_relaxable_literal_section)
8734     return ok;
8735
8736   internal_relocs = retrieve_internal_relocs (abfd, sec,
8737                                               link_info->keep_memory);
8738
8739   sec_size = bfd_get_section_limit (abfd, sec);
8740   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8741   if (contents == NULL && sec_size != 0)
8742     {
8743       ok = FALSE;
8744       goto error_return;
8745     }
8746
8747   /* Sort the source_relocs by target offset.  */
8748   src_relocs = relax_info->src_relocs;
8749   qsort (src_relocs, relax_info->src_count,
8750          sizeof (source_reloc), source_reloc_compare);
8751   qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
8752          internal_reloc_compare);
8753
8754   ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
8755                                         XTENSA_PROP_SEC_NAME, FALSE);
8756   if (ptblsize < 0)
8757     {
8758       ok = FALSE;
8759       goto error_return;
8760     }
8761
8762   prev_i = -1;
8763   for (i = 0; i < relax_info->src_count; i++)
8764     {
8765       Elf_Internal_Rela *irel = NULL;
8766
8767       rel = &src_relocs[i];
8768       if (get_l32r_opcode () != rel->opcode)
8769         continue;
8770       irel = get_irel_at_offset (sec, internal_relocs,
8771                                  rel->r_rel.target_offset);
8772
8773       /* If the relocation on this is not a simple R_XTENSA_32 or
8774          R_XTENSA_PLT then do not consider it.  This may happen when
8775          the difference of two symbols is used in a literal.  */
8776       if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
8777                    && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
8778         continue;
8779
8780       /* If the target_offset for this relocation is the same as the
8781          previous relocation, then we've already considered whether the
8782          literal can be coalesced.  Skip to the next one....  */
8783       if (i != 0 && prev_i != -1
8784           && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
8785         continue;
8786       prev_i = i;
8787
8788       if (last_loc_is_prev &&
8789           last_target_offset + 4 != rel->r_rel.target_offset)
8790         last_loc_is_prev = FALSE;
8791
8792       /* Check if the relocation was from an L32R that is being removed
8793          because a CALLX was converted to a direct CALL, and check if
8794          there are no other relocations to the literal.  */
8795       if (is_removable_literal (rel, i, src_relocs, relax_info->src_count,
8796                                 sec, prop_table, ptblsize))
8797         {
8798           if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
8799                                     irel, rel, prop_table, ptblsize))
8800             {
8801               ok = FALSE;
8802               goto error_return;
8803             }
8804           last_target_offset = rel->r_rel.target_offset;
8805           continue;
8806         }
8807
8808       if (!identify_literal_placement (abfd, sec, contents, link_info,
8809                                        values,
8810                                        &last_loc_is_prev, irel,
8811                                        relax_info->src_count - i, rel,
8812                                        prop_table, ptblsize,
8813                                        &target_sec_cache, rel->is_abs_literal))
8814         {
8815           ok = FALSE;
8816           goto error_return;
8817         }
8818       last_target_offset = rel->r_rel.target_offset;
8819     }
8820
8821 #if DEBUG
8822   print_removed_literals (stderr, &relax_info->removed_list);
8823   print_action_list (stderr, &relax_info->action_list);
8824 #endif /* DEBUG */
8825
8826 error_return:
8827   if (prop_table)
8828     free (prop_table);
8829   free_section_cache (&target_sec_cache);
8830
8831   release_contents (sec, contents);
8832   release_internal_relocs (sec, internal_relocs);
8833   return ok;
8834 }
8835
8836
8837 static Elf_Internal_Rela *
8838 get_irel_at_offset (asection *sec,
8839                     Elf_Internal_Rela *internal_relocs,
8840                     bfd_vma offset)
8841 {
8842   unsigned i;
8843   Elf_Internal_Rela *irel;
8844   unsigned r_type;
8845   Elf_Internal_Rela key;
8846
8847   if (!internal_relocs)
8848     return NULL;
8849
8850   key.r_offset = offset;
8851   irel = bsearch (&key, internal_relocs, sec->reloc_count,
8852                   sizeof (Elf_Internal_Rela), internal_reloc_matches);
8853   if (!irel)
8854     return NULL;
8855
8856   /* bsearch does not guarantee which will be returned if there are
8857      multiple matches.  We need the first that is not an alignment.  */
8858   i = irel - internal_relocs;
8859   while (i > 0)
8860     {
8861       if (internal_relocs[i-1].r_offset != offset)
8862         break;
8863       i--;
8864     }
8865   for ( ; i < sec->reloc_count; i++)
8866     {
8867       irel = &internal_relocs[i];
8868       r_type = ELF32_R_TYPE (irel->r_info);
8869       if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
8870         return irel;
8871     }
8872
8873   return NULL;
8874 }
8875
8876
8877 bfd_boolean
8878 is_removable_literal (const source_reloc *rel,
8879                       int i,
8880                       const source_reloc *src_relocs,
8881                       int src_count,
8882                       asection *sec,
8883                       property_table_entry *prop_table,
8884                       int ptblsize)
8885 {
8886   const source_reloc *curr_rel;
8887   property_table_entry *entry;
8888
8889   if (!rel->is_null)
8890     return FALSE;
8891
8892   entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8893                                           sec->vma + rel->r_rel.target_offset);
8894   if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8895     return FALSE;
8896
8897   for (++i; i < src_count; ++i)
8898     {
8899       curr_rel = &src_relocs[i];
8900       /* If all others have the same target offset....  */
8901       if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
8902         return TRUE;
8903
8904       if (!curr_rel->is_null
8905           && !xtensa_is_property_section (curr_rel->source_sec)
8906           && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
8907         return FALSE;
8908     }
8909   return TRUE;
8910 }
8911
8912
8913 bfd_boolean
8914 remove_dead_literal (bfd *abfd,
8915                      asection *sec,
8916                      struct bfd_link_info *link_info,
8917                      Elf_Internal_Rela *internal_relocs,
8918                      Elf_Internal_Rela *irel,
8919                      source_reloc *rel,
8920                      property_table_entry *prop_table,
8921                      int ptblsize)
8922 {
8923   property_table_entry *entry;
8924   xtensa_relax_info *relax_info;
8925
8926   relax_info = get_xtensa_relax_info (sec);
8927   if (!relax_info)
8928     return FALSE;
8929
8930   entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8931                                           sec->vma + rel->r_rel.target_offset);
8932
8933   /* Mark the unused literal so that it will be removed.  */
8934   add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
8935
8936   text_action_add (&relax_info->action_list,
8937                    ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8938
8939   /* If the section is 4-byte aligned, do not add fill.  */
8940   if (sec->alignment_power > 2)
8941     {
8942       int fill_extra_space;
8943       bfd_vma entry_sec_offset;
8944       text_action *fa;
8945       property_table_entry *the_add_entry;
8946       int removed_diff;
8947
8948       if (entry)
8949         entry_sec_offset = entry->address - sec->vma + entry->size;
8950       else
8951         entry_sec_offset = rel->r_rel.target_offset + 4;
8952
8953       /* If the literal range is at the end of the section,
8954          do not add fill.  */
8955       the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8956                                                       entry_sec_offset);
8957       fill_extra_space = compute_fill_extra_space (the_add_entry);
8958
8959       fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8960       removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8961                                                   -4, fill_extra_space);
8962       if (fa)
8963         adjust_fill_action (fa, removed_diff);
8964       else
8965         text_action_add (&relax_info->action_list,
8966                          ta_fill, sec, entry_sec_offset, removed_diff);
8967     }
8968
8969   /* Zero out the relocation on this literal location.  */
8970   if (irel)
8971     {
8972       if (elf_hash_table (link_info)->dynamic_sections_created)
8973         shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8974
8975       irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8976       pin_internal_relocs (sec, internal_relocs);
8977     }
8978
8979   /* Do not modify "last_loc_is_prev".  */
8980   return TRUE;
8981 }
8982
8983
8984 bfd_boolean
8985 identify_literal_placement (bfd *abfd,
8986                             asection *sec,
8987                             bfd_byte *contents,
8988                             struct bfd_link_info *link_info,
8989                             value_map_hash_table *values,
8990                             bfd_boolean *last_loc_is_prev_p,
8991                             Elf_Internal_Rela *irel,
8992                             int remaining_src_rels,
8993                             source_reloc *rel,
8994                             property_table_entry *prop_table,
8995                             int ptblsize,
8996                             section_cache_t *target_sec_cache,
8997                             bfd_boolean is_abs_literal)
8998 {
8999   literal_value val;
9000   value_map *val_map;
9001   xtensa_relax_info *relax_info;
9002   bfd_boolean literal_placed = FALSE;
9003   r_reloc r_rel;
9004   unsigned long value;
9005   bfd_boolean final_static_link;
9006   bfd_size_type sec_size;
9007
9008   relax_info = get_xtensa_relax_info (sec);
9009   if (!relax_info)
9010     return FALSE;
9011
9012   sec_size = bfd_get_section_limit (abfd, sec);
9013
9014   final_static_link =
9015     (!bfd_link_relocatable (link_info)
9016      && !elf_hash_table (link_info)->dynamic_sections_created);
9017
9018   /* The placement algorithm first checks to see if the literal is
9019      already in the value map.  If so and the value map is reachable
9020      from all uses, then the literal is moved to that location.  If
9021      not, then we identify the last location where a fresh literal was
9022      placed.  If the literal can be safely moved there, then we do so.
9023      If not, then we assume that the literal is not to move and leave
9024      the literal where it is, marking it as the last literal
9025      location.  */
9026
9027   /* Find the literal value.  */
9028   value = 0;
9029   r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
9030   if (!irel)
9031     {
9032       BFD_ASSERT (rel->r_rel.target_offset < sec_size);
9033       value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
9034     }
9035   init_literal_value (&val, &r_rel, value, is_abs_literal);
9036
9037   /* Check if we've seen another literal with the same value that
9038      is in the same output section.  */
9039   val_map = value_map_get_cached_value (values, &val, final_static_link);
9040
9041   if (val_map
9042       && (r_reloc_get_section (&val_map->loc)->output_section
9043           == sec->output_section)
9044       && relocations_reach (rel, remaining_src_rels, &val_map->loc)
9045       && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
9046     {
9047       /* No change to last_loc_is_prev.  */
9048       literal_placed = TRUE;
9049     }
9050
9051   /* For relocatable links, do not try to move literals.  To do it
9052      correctly might increase the number of relocations in an input
9053      section making the default relocatable linking fail.  */
9054   if (!bfd_link_relocatable (link_info) && !literal_placed
9055       && values->has_last_loc && !(*last_loc_is_prev_p))
9056     {
9057       asection *target_sec = r_reloc_get_section (&values->last_loc);
9058       if (target_sec && target_sec->output_section == sec->output_section)
9059         {
9060           /* Increment the virtual offset.  */
9061           r_reloc try_loc = values->last_loc;
9062           try_loc.virtual_offset += 4;
9063
9064           /* There is a last loc that was in the same output section.  */
9065           if (relocations_reach (rel, remaining_src_rels, &try_loc)
9066               && move_shared_literal (sec, link_info, rel,
9067                                       prop_table, ptblsize,
9068                                       &try_loc, &val, target_sec_cache))
9069             {
9070               values->last_loc.virtual_offset += 4;
9071               literal_placed = TRUE;
9072               if (!val_map)
9073                 val_map = add_value_map (values, &val, &try_loc,
9074                                          final_static_link);
9075               else
9076                 val_map->loc = try_loc;
9077             }
9078         }
9079     }
9080
9081   if (!literal_placed)
9082     {
9083       /* Nothing worked, leave the literal alone but update the last loc.  */
9084       values->has_last_loc = TRUE;
9085       values->last_loc = rel->r_rel;
9086       if (!val_map)
9087         val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
9088       else
9089         val_map->loc = rel->r_rel;
9090       *last_loc_is_prev_p = TRUE;
9091     }
9092
9093   return TRUE;
9094 }
9095
9096
9097 /* Check if the original relocations (presumably on L32R instructions)
9098    identified by reloc[0..N] can be changed to reference the literal
9099    identified by r_rel.  If r_rel is out of range for any of the
9100    original relocations, then we don't want to coalesce the original
9101    literal with the one at r_rel.  We only check reloc[0..N], where the
9102    offsets are all the same as for reloc[0] (i.e., they're all
9103    referencing the same literal) and where N is also bounded by the
9104    number of remaining entries in the "reloc" array.  The "reloc" array
9105    is sorted by target offset so we know all the entries for the same
9106    literal will be contiguous.  */
9107
9108 static bfd_boolean
9109 relocations_reach (source_reloc *reloc,
9110                    int remaining_relocs,
9111                    const r_reloc *r_rel)
9112 {
9113   bfd_vma from_offset, source_address, dest_address;
9114   asection *sec;
9115   int i;
9116
9117   if (!r_reloc_is_defined (r_rel))
9118     return FALSE;
9119
9120   sec = r_reloc_get_section (r_rel);
9121   from_offset = reloc[0].r_rel.target_offset;
9122
9123   for (i = 0; i < remaining_relocs; i++)
9124     {
9125       if (reloc[i].r_rel.target_offset != from_offset)
9126         break;
9127
9128       /* Ignore relocations that have been removed.  */
9129       if (reloc[i].is_null)
9130         continue;
9131
9132       /* The original and new output section for these must be the same
9133          in order to coalesce.  */
9134       if (r_reloc_get_section (&reloc[i].r_rel)->output_section
9135           != sec->output_section)
9136         return FALSE;
9137
9138       /* Absolute literals in the same output section can always be
9139          combined.  */
9140       if (reloc[i].is_abs_literal)
9141         continue;
9142
9143       /* A literal with no PC-relative relocations can be moved anywhere.  */
9144       if (reloc[i].opnd != -1)
9145         {
9146           /* Otherwise, check to see that it fits.  */
9147           source_address = (reloc[i].source_sec->output_section->vma
9148                             + reloc[i].source_sec->output_offset
9149                             + reloc[i].r_rel.rela.r_offset);
9150           dest_address = (sec->output_section->vma
9151                           + sec->output_offset
9152                           + r_rel->target_offset);
9153
9154           if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
9155                                  source_address, dest_address))
9156             return FALSE;
9157         }
9158     }
9159
9160   return TRUE;
9161 }
9162
9163
9164 /* Move a literal to another literal location because it is
9165    the same as the other literal value.  */
9166
9167 static bfd_boolean
9168 coalesce_shared_literal (asection *sec,
9169                          source_reloc *rel,
9170                          property_table_entry *prop_table,
9171                          int ptblsize,
9172                          value_map *val_map)
9173 {
9174   property_table_entry *entry;
9175   text_action *fa;
9176   property_table_entry *the_add_entry;
9177   int removed_diff;
9178   xtensa_relax_info *relax_info;
9179
9180   relax_info = get_xtensa_relax_info (sec);
9181   if (!relax_info)
9182     return FALSE;
9183
9184   entry = elf_xtensa_find_property_entry
9185     (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
9186   if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
9187     return TRUE;
9188
9189   /* Mark that the literal will be coalesced.  */
9190   add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
9191
9192   text_action_add (&relax_info->action_list,
9193                    ta_remove_literal, sec, rel->r_rel.target_offset, 4);
9194
9195   /* If the section is 4-byte aligned, do not add fill.  */
9196   if (sec->alignment_power > 2)
9197     {
9198       int fill_extra_space;
9199       bfd_vma entry_sec_offset;
9200
9201       if (entry)
9202         entry_sec_offset = entry->address - sec->vma + entry->size;
9203       else
9204         entry_sec_offset = rel->r_rel.target_offset + 4;
9205
9206       /* If the literal range is at the end of the section,
9207          do not add fill.  */
9208       fill_extra_space = 0;
9209       the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
9210                                                       entry_sec_offset);
9211       if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9212         fill_extra_space = the_add_entry->size;
9213
9214       fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
9215       removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
9216                                                   -4, fill_extra_space);
9217       if (fa)
9218         adjust_fill_action (fa, removed_diff);
9219       else
9220         text_action_add (&relax_info->action_list,
9221                          ta_fill, sec, entry_sec_offset, removed_diff);
9222     }
9223
9224   return TRUE;
9225 }
9226
9227
9228 /* Move a literal to another location.  This may actually increase the
9229    total amount of space used because of alignments so we need to do
9230    this carefully.  Also, it may make a branch go out of range.  */
9231
9232 static bfd_boolean
9233 move_shared_literal (asection *sec,
9234                      struct bfd_link_info *link_info,
9235                      source_reloc *rel,
9236                      property_table_entry *prop_table,
9237                      int ptblsize,
9238                      const r_reloc *target_loc,
9239                      const literal_value *lit_value,
9240                      section_cache_t *target_sec_cache)
9241 {
9242   property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
9243   text_action *fa, *target_fa;
9244   int removed_diff;
9245   xtensa_relax_info *relax_info, *target_relax_info;
9246   asection *target_sec;
9247   ebb_t *ebb;
9248   ebb_constraint ebb_table;
9249   bfd_boolean relocs_fit;
9250
9251   /* If this routine always returns FALSE, the literals that cannot be
9252      coalesced will not be moved.  */
9253   if (elf32xtensa_no_literal_movement)
9254     return FALSE;
9255
9256   relax_info = get_xtensa_relax_info (sec);
9257   if (!relax_info)
9258     return FALSE;
9259
9260   target_sec = r_reloc_get_section (target_loc);
9261   target_relax_info = get_xtensa_relax_info (target_sec);
9262
9263   /* Literals to undefined sections may not be moved because they
9264      must report an error.  */
9265   if (bfd_is_und_section (target_sec))
9266     return FALSE;
9267
9268   src_entry = elf_xtensa_find_property_entry
9269     (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
9270
9271   if (!section_cache_section (target_sec_cache, target_sec, link_info))
9272     return FALSE;
9273
9274   target_entry = elf_xtensa_find_property_entry
9275     (target_sec_cache->ptbl, target_sec_cache->pte_count,
9276      target_sec->vma + target_loc->target_offset);
9277
9278   if (!target_entry)
9279     return FALSE;
9280
9281   /* Make sure that we have not broken any branches.  */
9282   relocs_fit = FALSE;
9283
9284   init_ebb_constraint (&ebb_table);
9285   ebb = &ebb_table.ebb;
9286   init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
9287             target_sec_cache->content_length,
9288             target_sec_cache->ptbl, target_sec_cache->pte_count,
9289             target_sec_cache->relocs, target_sec_cache->reloc_count);
9290
9291   /* Propose to add 4 bytes + worst-case alignment size increase to
9292      destination.  */
9293   ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
9294                       ta_fill, target_loc->target_offset,
9295                       -4 - (1 << target_sec->alignment_power), TRUE);
9296
9297   /* Check all of the PC-relative relocations to make sure they still fit.  */
9298   relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
9299                                              target_sec_cache->contents,
9300                                              target_sec_cache->relocs, NULL,
9301                                              &ebb_table, NULL);
9302
9303   if (!relocs_fit)
9304     return FALSE;
9305
9306   text_action_add_literal (&target_relax_info->action_list,
9307                            ta_add_literal, target_loc, lit_value, -4);
9308
9309   if (target_sec->alignment_power > 2 && target_entry != src_entry)
9310     {
9311       /* May need to add or remove some fill to maintain alignment.  */
9312       int fill_extra_space;
9313       bfd_vma entry_sec_offset;
9314
9315       entry_sec_offset =
9316         target_entry->address - target_sec->vma + target_entry->size;
9317
9318       /* If the literal range is at the end of the section,
9319          do not add fill.  */
9320       fill_extra_space = 0;
9321       the_add_entry =
9322         elf_xtensa_find_property_entry (target_sec_cache->ptbl,
9323                                         target_sec_cache->pte_count,
9324                                         entry_sec_offset);
9325       if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9326         fill_extra_space = the_add_entry->size;
9327
9328       target_fa = find_fill_action (&target_relax_info->action_list,
9329                                     target_sec, entry_sec_offset);
9330       removed_diff = compute_removed_action_diff (target_fa, target_sec,
9331                                                   entry_sec_offset, 4,
9332                                                   fill_extra_space);
9333       if (target_fa)
9334         adjust_fill_action (target_fa, removed_diff);
9335       else
9336         text_action_add (&target_relax_info->action_list,
9337                          ta_fill, target_sec, entry_sec_offset, removed_diff);
9338     }
9339
9340   /* Mark that the literal will be moved to the new location.  */
9341   add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
9342
9343   /* Remove the literal.  */
9344   text_action_add (&relax_info->action_list,
9345                    ta_remove_literal, sec, rel->r_rel.target_offset, 4);
9346
9347   /* If the section is 4-byte aligned, do not add fill.  */
9348   if (sec->alignment_power > 2 && target_entry != src_entry)
9349     {
9350       int fill_extra_space;
9351       bfd_vma entry_sec_offset;
9352
9353       if (src_entry)
9354         entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
9355       else
9356         entry_sec_offset = rel->r_rel.target_offset+4;
9357
9358       /* If the literal range is at the end of the section,
9359          do not add fill.  */
9360       fill_extra_space = 0;
9361       the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
9362                                                       entry_sec_offset);
9363       if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9364         fill_extra_space = the_add_entry->size;
9365
9366       fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
9367       removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
9368                                                   -4, fill_extra_space);
9369       if (fa)
9370         adjust_fill_action (fa, removed_diff);
9371       else
9372         text_action_add (&relax_info->action_list,
9373                          ta_fill, sec, entry_sec_offset, removed_diff);
9374     }
9375
9376   return TRUE;
9377 }
9378
9379 \f
9380 /* Second relaxation pass.  */
9381
9382 static int
9383 action_remove_bytes_fn (splay_tree_node node, void *p)
9384 {
9385   bfd_size_type *final_size = p;
9386   text_action *action = (text_action *)node->value;
9387
9388   *final_size -= action->removed_bytes;
9389   return 0;
9390 }
9391
9392 /* Modify all of the relocations to point to the right spot, and if this
9393    is a relaxable section, delete the unwanted literals and fix the
9394    section size.  */
9395
9396 bfd_boolean
9397 relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
9398 {
9399   Elf_Internal_Rela *internal_relocs;
9400   xtensa_relax_info *relax_info;
9401   bfd_byte *contents;
9402   bfd_boolean ok = TRUE;
9403   unsigned i;
9404   bfd_boolean rv = FALSE;
9405   bfd_boolean virtual_action;
9406   bfd_size_type sec_size;
9407
9408   sec_size = bfd_get_section_limit (abfd, sec);
9409   relax_info = get_xtensa_relax_info (sec);
9410   BFD_ASSERT (relax_info);
9411
9412   /* First translate any of the fixes that have been added already.  */
9413   translate_section_fixes (sec);
9414
9415   /* Handle property sections (e.g., literal tables) specially.  */
9416   if (xtensa_is_property_section (sec))
9417     {
9418       BFD_ASSERT (!relax_info->is_relaxable_literal_section);
9419       return relax_property_section (abfd, sec, link_info);
9420     }
9421
9422   internal_relocs = retrieve_internal_relocs (abfd, sec,
9423                                               link_info->keep_memory);
9424   if (!internal_relocs && !action_list_count (&relax_info->action_list))
9425     return TRUE;
9426
9427   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9428   if (contents == NULL && sec_size != 0)
9429     {
9430       ok = FALSE;
9431       goto error_return;
9432     }
9433
9434   if (internal_relocs)
9435     {
9436       for (i = 0; i < sec->reloc_count; i++)
9437         {
9438           Elf_Internal_Rela *irel;
9439           xtensa_relax_info *target_relax_info;
9440           bfd_vma source_offset, old_source_offset;
9441           r_reloc r_rel;
9442           unsigned r_type;
9443           asection *target_sec;
9444
9445           /* Locally change the source address.
9446              Translate the target to the new target address.
9447              If it points to this section and has been removed,
9448              NULLify it.
9449              Write it back.  */
9450
9451           irel = &internal_relocs[i];
9452           source_offset = irel->r_offset;
9453           old_source_offset = source_offset;
9454
9455           r_type = ELF32_R_TYPE (irel->r_info);
9456           r_reloc_init (&r_rel, abfd, irel, contents,
9457                         bfd_get_section_limit (abfd, sec));
9458
9459           /* If this section could have changed then we may need to
9460              change the relocation's offset.  */
9461
9462           if (relax_info->is_relaxable_literal_section
9463               || relax_info->is_relaxable_asm_section)
9464             {
9465               pin_internal_relocs (sec, internal_relocs);
9466
9467               if (r_type != R_XTENSA_NONE
9468                   && find_removed_literal (&relax_info->removed_list,
9469                                            irel->r_offset))
9470                 {
9471                   /* Remove this relocation.  */
9472                   if (elf_hash_table (link_info)->dynamic_sections_created)
9473                     shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
9474                   irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
9475                   irel->r_offset = offset_with_removed_text_map
9476                     (&relax_info->action_list, irel->r_offset);
9477                   continue;
9478                 }
9479
9480               if (r_type == R_XTENSA_ASM_SIMPLIFY)
9481                 {
9482                   text_action *action =
9483                     find_insn_action (&relax_info->action_list,
9484                                       irel->r_offset);
9485                   if (action && (action->action == ta_convert_longcall
9486                                  || action->action == ta_remove_longcall))
9487                     {
9488                       bfd_reloc_status_type retval;
9489                       char *error_message = NULL;
9490
9491                       retval = contract_asm_expansion (contents, sec_size,
9492                                                        irel, &error_message);
9493                       if (retval != bfd_reloc_ok)
9494                         {
9495                           (*link_info->callbacks->reloc_dangerous)
9496                             (link_info, error_message, abfd, sec,
9497                              irel->r_offset);
9498                           goto error_return;
9499                         }
9500                       /* Update the action so that the code that moves
9501                          the contents will do the right thing.  */
9502                       /* ta_remove_longcall and ta_remove_insn actions are
9503                          grouped together in the tree as well as
9504                          ta_convert_longcall and ta_none, so that changes below
9505                          can be done w/o removing and reinserting action into
9506                          the tree.  */
9507
9508                       if (action->action == ta_remove_longcall)
9509                         action->action = ta_remove_insn;
9510                       else
9511                         action->action = ta_none;
9512                       /* Refresh the info in the r_rel.  */
9513                       r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
9514                       r_type = ELF32_R_TYPE (irel->r_info);
9515                     }
9516                 }
9517
9518               source_offset = offset_with_removed_text_map
9519                 (&relax_info->action_list, irel->r_offset);
9520               irel->r_offset = source_offset;
9521             }
9522
9523           /* If the target section could have changed then
9524              we may need to change the relocation's target offset.  */
9525
9526           target_sec = r_reloc_get_section (&r_rel);
9527
9528           /* For a reference to a discarded section from a DWARF section,
9529              i.e., where action_discarded is PRETEND, the symbol will
9530              eventually be modified to refer to the kept section (at least if
9531              the kept and discarded sections are the same size).  Anticipate
9532              that here and adjust things accordingly.  */
9533           if (! elf_xtensa_ignore_discarded_relocs (sec)
9534               && elf_xtensa_action_discarded (sec) == PRETEND
9535               && sec->sec_info_type != SEC_INFO_TYPE_STABS
9536               && target_sec != NULL
9537               && discarded_section (target_sec))
9538             {
9539               /* It would be natural to call _bfd_elf_check_kept_section
9540                  here, but it's not exported from elflink.c.  It's also a
9541                  fairly expensive check.  Adjusting the relocations to the
9542                  discarded section is fairly harmless; it will only adjust
9543                  some addends and difference values.  If it turns out that
9544                  _bfd_elf_check_kept_section fails later, it won't matter,
9545                  so just compare the section names to find the right group
9546                  member.  */
9547               asection *kept = target_sec->kept_section;
9548               if (kept != NULL)
9549                 {
9550                   if ((kept->flags & SEC_GROUP) != 0)
9551                     {
9552                       asection *first = elf_next_in_group (kept);
9553                       asection *s = first;
9554
9555                       kept = NULL;
9556                       while (s != NULL)
9557                         {
9558                           if (strcmp (s->name, target_sec->name) == 0)
9559                             {
9560                               kept = s;
9561                               break;
9562                             }
9563                           s = elf_next_in_group (s);
9564                           if (s == first)
9565                             break;
9566                         }
9567                     }
9568                 }
9569               if (kept != NULL
9570                   && ((target_sec->rawsize != 0
9571                        ? target_sec->rawsize : target_sec->size)
9572                       == (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9573                 target_sec = kept;
9574             }
9575
9576           target_relax_info = get_xtensa_relax_info (target_sec);
9577           if (target_relax_info
9578               && (target_relax_info->is_relaxable_literal_section
9579                   || target_relax_info->is_relaxable_asm_section))
9580             {
9581               r_reloc new_reloc;
9582               target_sec = translate_reloc (&r_rel, &new_reloc, target_sec);
9583
9584               if (r_type == R_XTENSA_DIFF8
9585                   || r_type == R_XTENSA_DIFF16
9586                   || r_type == R_XTENSA_DIFF32)
9587                 {
9588                   bfd_signed_vma diff_value = 0;
9589                   bfd_vma new_end_offset, diff_mask = 0;
9590
9591                   if (bfd_get_section_limit (abfd, sec) < old_source_offset)
9592                     {
9593                       (*link_info->callbacks->reloc_dangerous)
9594                         (link_info, _("invalid relocation address"),
9595                          abfd, sec, old_source_offset);
9596                       goto error_return;
9597                     }
9598
9599                   switch (r_type)
9600                     {
9601                     case R_XTENSA_DIFF8:
9602                       diff_value =
9603                         bfd_get_signed_8 (abfd, &contents[old_source_offset]);
9604                       break;
9605                     case R_XTENSA_DIFF16:
9606                       diff_value =
9607                         bfd_get_signed_16 (abfd, &contents[old_source_offset]);
9608                       break;
9609                     case R_XTENSA_DIFF32:
9610                       diff_value =
9611                         bfd_get_signed_32 (abfd, &contents[old_source_offset]);
9612                       break;
9613                     }
9614
9615                   new_end_offset = offset_with_removed_text_map
9616                     (&target_relax_info->action_list,
9617                      r_rel.target_offset + diff_value);
9618                   diff_value = new_end_offset - new_reloc.target_offset;
9619
9620                   switch (r_type)
9621                     {
9622                     case R_XTENSA_DIFF8:
9623                       diff_mask = 0x7f;
9624                       bfd_put_signed_8 (abfd, diff_value,
9625                                  &contents[old_source_offset]);
9626                       break;
9627                     case R_XTENSA_DIFF16:
9628                       diff_mask = 0x7fff;
9629                       bfd_put_signed_16 (abfd, diff_value,
9630                                   &contents[old_source_offset]);
9631                       break;
9632                     case R_XTENSA_DIFF32:
9633                       diff_mask = 0x7fffffff;
9634                       bfd_put_signed_32 (abfd, diff_value,
9635                                   &contents[old_source_offset]);
9636                       break;
9637                     }
9638
9639                   /* Check for overflow. Sign bits must be all zeroes or all ones */
9640                   if ((diff_value & ~diff_mask) != 0 &&
9641                       (diff_value & ~diff_mask) != (-1 & ~diff_mask))
9642                     {
9643                       (*link_info->callbacks->reloc_dangerous)
9644                         (link_info, _("overflow after relaxation"),
9645                          abfd, sec, old_source_offset);
9646                       goto error_return;
9647                     }
9648
9649                   pin_contents (sec, contents);
9650                 }
9651
9652               /* If the relocation still references a section in the same
9653                  input file, modify the relocation directly instead of
9654                  adding a "fix" record.  */
9655               if (target_sec->owner == abfd)
9656                 {
9657                   unsigned r_symndx = ELF32_R_SYM (new_reloc.rela.r_info);
9658                   irel->r_info = ELF32_R_INFO (r_symndx, r_type);
9659                   irel->r_addend = new_reloc.rela.r_addend;
9660                   pin_internal_relocs (sec, internal_relocs);
9661                 }
9662               else
9663                 {
9664                   bfd_vma addend_displacement;
9665                   reloc_bfd_fix *fix;
9666
9667                   addend_displacement =
9668                     new_reloc.target_offset + new_reloc.virtual_offset;
9669                   fix = reloc_bfd_fix_init (sec, source_offset, r_type,
9670                                             target_sec,
9671                                             addend_displacement, TRUE);
9672                   add_fix (sec, fix);
9673                 }
9674             }
9675         }
9676     }
9677
9678   if ((relax_info->is_relaxable_literal_section
9679        || relax_info->is_relaxable_asm_section)
9680       && action_list_count (&relax_info->action_list))
9681     {
9682       /* Walk through the planned actions and build up a table
9683          of move, copy and fill records.  Use the move, copy and
9684          fill records to perform the actions once.  */
9685
9686       bfd_size_type final_size, copy_size, orig_insn_size;
9687       bfd_byte *scratch = NULL;
9688       bfd_byte *dup_contents = NULL;
9689       bfd_size_type orig_size = sec->size;
9690       bfd_vma orig_dot = 0;
9691       bfd_vma orig_dot_copied = 0; /* Byte copied already from
9692                                             orig dot in physical memory.  */
9693       bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot.  */
9694       bfd_vma dup_dot = 0;
9695
9696       text_action *action;
9697
9698       final_size = sec->size;
9699
9700       splay_tree_foreach (relax_info->action_list.tree,
9701                           action_remove_bytes_fn, &final_size);
9702       scratch = (bfd_byte *) bfd_zmalloc (final_size);
9703       dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
9704
9705       /* The dot is the current fill location.  */
9706 #if DEBUG
9707       print_action_list (stderr, &relax_info->action_list);
9708 #endif
9709
9710       for (action = action_first (&relax_info->action_list); action;
9711            action = action_next (&relax_info->action_list, action))
9712         {
9713           virtual_action = FALSE;
9714           if (action->offset > orig_dot)
9715             {
9716               orig_dot += orig_dot_copied;
9717               orig_dot_copied = 0;
9718               orig_dot_vo = 0;
9719               /* Out of the virtual world.  */
9720             }
9721
9722           if (action->offset > orig_dot)
9723             {
9724               copy_size = action->offset - orig_dot;
9725               memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9726               orig_dot += copy_size;
9727               dup_dot += copy_size;
9728               BFD_ASSERT (action->offset == orig_dot);
9729             }
9730           else if (action->offset < orig_dot)
9731             {
9732               if (action->action == ta_fill
9733                   && action->offset - action->removed_bytes == orig_dot)
9734                 {
9735                   /* This is OK because the fill only effects the dup_dot.  */
9736                 }
9737               else if (action->action == ta_add_literal)
9738                 {
9739                   /* TBD.  Might need to handle this.  */
9740                 }
9741             }
9742           if (action->offset == orig_dot)
9743             {
9744               if (action->virtual_offset > orig_dot_vo)
9745                 {
9746                   if (orig_dot_vo == 0)
9747                     {
9748                       /* Need to copy virtual_offset bytes.  Probably four.  */
9749                       copy_size = action->virtual_offset - orig_dot_vo;
9750                       memmove (&dup_contents[dup_dot],
9751                                &contents[orig_dot], copy_size);
9752                       orig_dot_copied = copy_size;
9753                       dup_dot += copy_size;
9754                     }
9755                   virtual_action = TRUE;
9756                 }
9757               else
9758                 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
9759             }
9760           switch (action->action)
9761             {
9762             case ta_remove_literal:
9763             case ta_remove_insn:
9764               BFD_ASSERT (action->removed_bytes >= 0);
9765               orig_dot += action->removed_bytes;
9766               break;
9767
9768             case ta_narrow_insn:
9769               orig_insn_size = 3;
9770               copy_size = 2;
9771               memmove (scratch, &contents[orig_dot], orig_insn_size);
9772               BFD_ASSERT (action->removed_bytes == 1);
9773               rv = narrow_instruction (scratch, final_size, 0);
9774               BFD_ASSERT (rv);
9775               memmove (&dup_contents[dup_dot], scratch, copy_size);
9776               orig_dot += orig_insn_size;
9777               dup_dot += copy_size;
9778               break;
9779
9780             case ta_fill:
9781               if (action->removed_bytes >= 0)
9782                 orig_dot += action->removed_bytes;
9783               else
9784                 {
9785                   /* Already zeroed in dup_contents.  Just bump the
9786                      counters.  */
9787                   dup_dot += (-action->removed_bytes);
9788                 }
9789               break;
9790
9791             case ta_none:
9792               BFD_ASSERT (action->removed_bytes == 0);
9793               break;
9794
9795             case ta_convert_longcall:
9796             case ta_remove_longcall:
9797               /* These will be removed or converted before we get here.  */
9798               BFD_ASSERT (0);
9799               break;
9800
9801             case ta_widen_insn:
9802               orig_insn_size = 2;
9803               copy_size = 3;
9804               memmove (scratch, &contents[orig_dot], orig_insn_size);
9805               BFD_ASSERT (action->removed_bytes == -1);
9806               rv = widen_instruction (scratch, final_size, 0);
9807               BFD_ASSERT (rv);
9808               memmove (&dup_contents[dup_dot], scratch, copy_size);
9809               orig_dot += orig_insn_size;
9810               dup_dot += copy_size;
9811               break;
9812
9813             case ta_add_literal:
9814               orig_insn_size = 0;
9815               copy_size = 4;
9816               BFD_ASSERT (action->removed_bytes == -4);
9817               /* TBD -- place the literal value here and insert
9818                  into the table.  */
9819               memset (&dup_contents[dup_dot], 0, 4);
9820               pin_internal_relocs (sec, internal_relocs);
9821               pin_contents (sec, contents);
9822
9823               if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
9824                                  relax_info, &internal_relocs, &action->value))
9825                 goto error_return;
9826
9827               if (virtual_action)
9828                 orig_dot_vo += copy_size;
9829
9830               orig_dot += orig_insn_size;
9831               dup_dot += copy_size;
9832               break;
9833
9834             default:
9835               /* Not implemented yet.  */
9836               BFD_ASSERT (0);
9837               break;
9838             }
9839
9840           BFD_ASSERT (dup_dot <= final_size);
9841           BFD_ASSERT (orig_dot <= orig_size);
9842         }
9843
9844       orig_dot += orig_dot_copied;
9845       orig_dot_copied = 0;
9846
9847       if (orig_dot != orig_size)
9848         {
9849           copy_size = orig_size - orig_dot;
9850           BFD_ASSERT (orig_size > orig_dot);
9851           BFD_ASSERT (dup_dot + copy_size == final_size);
9852           memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9853           orig_dot += copy_size;
9854           dup_dot += copy_size;
9855         }
9856       BFD_ASSERT (orig_size == orig_dot);
9857       BFD_ASSERT (final_size == dup_dot);
9858
9859       /* Move the dup_contents back.  */
9860       if (final_size > orig_size)
9861         {
9862           /* Contents need to be reallocated.  Swap the dup_contents into
9863              contents.  */
9864           sec->contents = dup_contents;
9865           free (contents);
9866           contents = dup_contents;
9867           pin_contents (sec, contents);
9868         }
9869       else
9870         {
9871           BFD_ASSERT (final_size <= orig_size);
9872           memset (contents, 0, orig_size);
9873           memcpy (contents, dup_contents, final_size);
9874           free (dup_contents);
9875         }
9876       free (scratch);
9877       pin_contents (sec, contents);
9878
9879       if (sec->rawsize == 0)
9880         sec->rawsize = sec->size;
9881       sec->size = final_size;
9882     }
9883
9884  error_return:
9885   release_internal_relocs (sec, internal_relocs);
9886   release_contents (sec, contents);
9887   return ok;
9888 }
9889
9890
9891 static bfd_boolean
9892 translate_section_fixes (asection *sec)
9893 {
9894   xtensa_relax_info *relax_info;
9895   reloc_bfd_fix *r;
9896
9897   relax_info = get_xtensa_relax_info (sec);
9898   if (!relax_info)
9899     return TRUE;
9900
9901   for (r = relax_info->fix_list; r != NULL; r = r->next)
9902     if (!translate_reloc_bfd_fix (r))
9903       return FALSE;
9904
9905   return TRUE;
9906 }
9907
9908
9909 /* Translate a fix given the mapping in the relax info for the target
9910    section.  If it has already been translated, no work is required.  */
9911
9912 static bfd_boolean
9913 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
9914 {
9915   reloc_bfd_fix new_fix;
9916   asection *sec;
9917   xtensa_relax_info *relax_info;
9918   removed_literal *removed;
9919   bfd_vma new_offset, target_offset;
9920
9921   if (fix->translated)
9922     return TRUE;
9923
9924   sec = fix->target_sec;
9925   target_offset = fix->target_offset;
9926
9927   relax_info = get_xtensa_relax_info (sec);
9928   if (!relax_info)
9929     {
9930       fix->translated = TRUE;
9931       return TRUE;
9932     }
9933
9934   new_fix = *fix;
9935
9936   /* The fix does not need to be translated if the section cannot change.  */
9937   if (!relax_info->is_relaxable_literal_section
9938       && !relax_info->is_relaxable_asm_section)
9939     {
9940       fix->translated = TRUE;
9941       return TRUE;
9942     }
9943
9944   /* If the literal has been moved and this relocation was on an
9945      opcode, then the relocation should move to the new literal
9946      location.  Otherwise, the relocation should move within the
9947      section.  */
9948
9949   removed = FALSE;
9950   if (is_operand_relocation (fix->src_type))
9951     {
9952       /* Check if the original relocation is against a literal being
9953          removed.  */
9954       removed = find_removed_literal (&relax_info->removed_list,
9955                                       target_offset);
9956     }
9957
9958   if (removed)
9959     {
9960       asection *new_sec;
9961
9962       /* The fact that there is still a relocation to this literal indicates
9963          that the literal is being coalesced, not simply removed.  */
9964       BFD_ASSERT (removed->to.abfd != NULL);
9965
9966       /* This was moved to some other address (possibly another section).  */
9967       new_sec = r_reloc_get_section (&removed->to);
9968       if (new_sec != sec)
9969         {
9970           sec = new_sec;
9971           relax_info = get_xtensa_relax_info (sec);
9972           if (!relax_info ||
9973               (!relax_info->is_relaxable_literal_section
9974                && !relax_info->is_relaxable_asm_section))
9975             {
9976               target_offset = removed->to.target_offset;
9977               new_fix.target_sec = new_sec;
9978               new_fix.target_offset = target_offset;
9979               new_fix.translated = TRUE;
9980               *fix = new_fix;
9981               return TRUE;
9982             }
9983         }
9984       target_offset = removed->to.target_offset;
9985       new_fix.target_sec = new_sec;
9986     }
9987
9988   /* The target address may have been moved within its section.  */
9989   new_offset = offset_with_removed_text (&relax_info->action_list,
9990                                          target_offset);
9991
9992   new_fix.target_offset = new_offset;
9993   new_fix.target_offset = new_offset;
9994   new_fix.translated = TRUE;
9995   *fix = new_fix;
9996   return TRUE;
9997 }
9998
9999
10000 /* Fix up a relocation to take account of removed literals.  */
10001
10002 static asection *
10003 translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec)
10004 {
10005   xtensa_relax_info *relax_info;
10006   removed_literal *removed;
10007   bfd_vma target_offset, base_offset;
10008
10009   *new_rel = *orig_rel;
10010
10011   if (!r_reloc_is_defined (orig_rel))
10012     return sec ;
10013
10014   relax_info = get_xtensa_relax_info (sec);
10015   BFD_ASSERT (relax_info && (relax_info->is_relaxable_literal_section
10016                              || relax_info->is_relaxable_asm_section));
10017
10018   target_offset = orig_rel->target_offset;
10019
10020   removed = FALSE;
10021   if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
10022     {
10023       /* Check if the original relocation is against a literal being
10024          removed.  */
10025       removed = find_removed_literal (&relax_info->removed_list,
10026                                       target_offset);
10027     }
10028   if (removed && removed->to.abfd)
10029     {
10030       asection *new_sec;
10031
10032       /* The fact that there is still a relocation to this literal indicates
10033          that the literal is being coalesced, not simply removed.  */
10034       BFD_ASSERT (removed->to.abfd != NULL);
10035
10036       /* This was moved to some other address
10037          (possibly in another section).  */
10038       *new_rel = removed->to;
10039       new_sec = r_reloc_get_section (new_rel);
10040       if (new_sec != sec)
10041         {
10042           sec = new_sec;
10043           relax_info = get_xtensa_relax_info (sec);
10044           if (!relax_info
10045               || (!relax_info->is_relaxable_literal_section
10046                   && !relax_info->is_relaxable_asm_section))
10047             return sec;
10048         }
10049       target_offset = new_rel->target_offset;
10050     }
10051
10052   /* Find the base offset of the reloc symbol, excluding any addend from the
10053      reloc or from the section contents (for a partial_inplace reloc).  Then
10054      find the adjusted values of the offsets due to relaxation.  The base
10055      offset is needed to determine the change to the reloc's addend; the reloc
10056      addend should not be adjusted due to relaxations located before the base
10057      offset.  */
10058
10059   base_offset = r_reloc_get_target_offset (new_rel) - new_rel->rela.r_addend;
10060   if (base_offset <= target_offset)
10061     {
10062       int base_removed = removed_by_actions_map (&relax_info->action_list,
10063                                                  base_offset, FALSE);
10064       int addend_removed = removed_by_actions_map (&relax_info->action_list,
10065                                                    target_offset, FALSE) -
10066         base_removed;
10067
10068       new_rel->target_offset = target_offset - base_removed - addend_removed;
10069       new_rel->rela.r_addend -= addend_removed;
10070     }
10071   else
10072     {
10073       /* Handle a negative addend.  The base offset comes first.  */
10074       int tgt_removed = removed_by_actions_map (&relax_info->action_list,
10075                                                 target_offset, FALSE);
10076       int addend_removed = removed_by_actions_map (&relax_info->action_list,
10077                                                    base_offset, FALSE) -
10078         tgt_removed;
10079
10080       new_rel->target_offset = target_offset - tgt_removed;
10081       new_rel->rela.r_addend += addend_removed;
10082     }
10083
10084   return sec;
10085 }
10086
10087
10088 /* For dynamic links, there may be a dynamic relocation for each
10089    literal.  The number of dynamic relocations must be computed in
10090    size_dynamic_sections, which occurs before relaxation.  When a
10091    literal is removed, this function checks if there is a corresponding
10092    dynamic relocation and shrinks the size of the appropriate dynamic
10093    relocation section accordingly.  At this point, the contents of the
10094    dynamic relocation sections have not yet been filled in, so there's
10095    nothing else that needs to be done.  */
10096
10097 static void
10098 shrink_dynamic_reloc_sections (struct bfd_link_info *info,
10099                                bfd *abfd,
10100                                asection *input_section,
10101                                Elf_Internal_Rela *rel)
10102 {
10103   struct elf_xtensa_link_hash_table *htab;
10104   Elf_Internal_Shdr *symtab_hdr;
10105   struct elf_link_hash_entry **sym_hashes;
10106   unsigned long r_symndx;
10107   int r_type;
10108   struct elf_link_hash_entry *h;
10109   bfd_boolean dynamic_symbol;
10110
10111   htab = elf_xtensa_hash_table (info);
10112   if (htab == NULL)
10113     return;
10114
10115   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10116   sym_hashes = elf_sym_hashes (abfd);
10117
10118   r_type = ELF32_R_TYPE (rel->r_info);
10119   r_symndx = ELF32_R_SYM (rel->r_info);
10120
10121   if (r_symndx < symtab_hdr->sh_info)
10122     h = NULL;
10123   else
10124     h = sym_hashes[r_symndx - symtab_hdr->sh_info];
10125
10126   dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
10127
10128   if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
10129       && (input_section->flags & SEC_ALLOC) != 0
10130       && (dynamic_symbol || bfd_link_pic (info)))
10131     {
10132       asection *srel;
10133       bfd_boolean is_plt = FALSE;
10134
10135       if (dynamic_symbol && r_type == R_XTENSA_PLT)
10136         {
10137           srel = htab->srelplt;
10138           is_plt = TRUE;
10139         }
10140       else
10141         srel = htab->srelgot;
10142
10143       /* Reduce size of the .rela.* section by one reloc.  */
10144       BFD_ASSERT (srel != NULL);
10145       BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
10146       srel->size -= sizeof (Elf32_External_Rela);
10147
10148       if (is_plt)
10149         {
10150           asection *splt, *sgotplt, *srelgot;
10151           int reloc_index, chunk;
10152
10153           /* Find the PLT reloc index of the entry being removed.  This
10154              is computed from the size of ".rela.plt".  It is needed to
10155              figure out which PLT chunk to resize.  Usually "last index
10156              = size - 1" since the index starts at zero, but in this
10157              context, the size has just been decremented so there's no
10158              need to subtract one.  */
10159           reloc_index = srel->size / sizeof (Elf32_External_Rela);
10160
10161           chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
10162           splt = elf_xtensa_get_plt_section (info, chunk);
10163           sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
10164           BFD_ASSERT (splt != NULL && sgotplt != NULL);
10165
10166           /* Check if an entire PLT chunk has just been eliminated.  */
10167           if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
10168             {
10169               /* The two magic GOT entries for that chunk can go away.  */
10170               srelgot = htab->srelgot;
10171               BFD_ASSERT (srelgot != NULL);
10172               srelgot->reloc_count -= 2;
10173               srelgot->size -= 2 * sizeof (Elf32_External_Rela);
10174               sgotplt->size -= 8;
10175
10176               /* There should be only one entry left (and it will be
10177                  removed below).  */
10178               BFD_ASSERT (sgotplt->size == 4);
10179               BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
10180             }
10181
10182           BFD_ASSERT (sgotplt->size >= 4);
10183           BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
10184
10185           sgotplt->size -= 4;
10186           splt->size -= PLT_ENTRY_SIZE;
10187         }
10188     }
10189 }
10190
10191
10192 /* Take an r_rel and move it to another section.  This usually
10193    requires extending the interal_relocation array and pinning it.  If
10194    the original r_rel is from the same BFD, we can complete this here.
10195    Otherwise, we add a fix record to let the final link fix the
10196    appropriate address.  Contents and internal relocations for the
10197    section must be pinned after calling this routine.  */
10198
10199 static bfd_boolean
10200 move_literal (bfd *abfd,
10201               struct bfd_link_info *link_info,
10202               asection *sec,
10203               bfd_vma offset,
10204               bfd_byte *contents,
10205               xtensa_relax_info *relax_info,
10206               Elf_Internal_Rela **internal_relocs_p,
10207               const literal_value *lit)
10208 {
10209   Elf_Internal_Rela *new_relocs = NULL;
10210   size_t new_relocs_count = 0;
10211   Elf_Internal_Rela this_rela;
10212   const r_reloc *r_rel;
10213
10214   r_rel = &lit->r_rel;
10215   BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
10216
10217   if (r_reloc_is_const (r_rel))
10218     bfd_put_32 (abfd, lit->value, contents + offset);
10219   else
10220     {
10221       int r_type;
10222       unsigned i;
10223       reloc_bfd_fix *fix;
10224       unsigned insert_at;
10225
10226       r_type = ELF32_R_TYPE (r_rel->rela.r_info);
10227
10228       /* This is the difficult case.  We have to create a fix up.  */
10229       this_rela.r_offset = offset;
10230       this_rela.r_info = ELF32_R_INFO (0, r_type);
10231       this_rela.r_addend =
10232         r_rel->target_offset - r_reloc_get_target_offset (r_rel);
10233       bfd_put_32 (abfd, lit->value, contents + offset);
10234
10235       /* Currently, we cannot move relocations during a relocatable link.  */
10236       BFD_ASSERT (!bfd_link_relocatable (link_info));
10237       fix = reloc_bfd_fix_init (sec, offset, r_type,
10238                                 r_reloc_get_section (r_rel),
10239                                 r_rel->target_offset + r_rel->virtual_offset,
10240                                 FALSE);
10241       /* We also need to mark that relocations are needed here.  */
10242       sec->flags |= SEC_RELOC;
10243
10244       translate_reloc_bfd_fix (fix);
10245       /* This fix has not yet been translated.  */
10246       add_fix (sec, fix);
10247
10248       /* Add the relocation.  If we have already allocated our own
10249          space for the relocations and we have room for more, then use
10250          it.  Otherwise, allocate new space and move the literals.  */
10251       insert_at = sec->reloc_count;
10252       for (i = 0; i < sec->reloc_count; ++i)
10253         {
10254           if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
10255             {
10256               insert_at = i;
10257               break;
10258             }
10259         }
10260
10261       if (*internal_relocs_p != relax_info->allocated_relocs
10262           || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
10263         {
10264           BFD_ASSERT (relax_info->allocated_relocs == NULL
10265                       || sec->reloc_count == relax_info->relocs_count);
10266
10267           if (relax_info->allocated_relocs_count == 0)
10268             new_relocs_count = (sec->reloc_count + 2) * 2;
10269           else
10270             new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
10271
10272           new_relocs = (Elf_Internal_Rela *)
10273             bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
10274           if (!new_relocs)
10275             return FALSE;
10276
10277           /* We could handle this more quickly by finding the split point.  */
10278           if (insert_at != 0)
10279             memcpy (new_relocs, *internal_relocs_p,
10280                     insert_at * sizeof (Elf_Internal_Rela));
10281
10282           new_relocs[insert_at] = this_rela;
10283
10284           if (insert_at != sec->reloc_count)
10285             memcpy (new_relocs + insert_at + 1,
10286                     (*internal_relocs_p) + insert_at,
10287                     (sec->reloc_count - insert_at)
10288                     * sizeof (Elf_Internal_Rela));
10289
10290           if (*internal_relocs_p != relax_info->allocated_relocs)
10291             {
10292               /* The first time we re-allocate, we can only free the
10293                  old relocs if they were allocated with bfd_malloc.
10294                  This is not true when keep_memory is in effect.  */
10295               if (!link_info->keep_memory)
10296                 free (*internal_relocs_p);
10297             }
10298           else
10299             free (*internal_relocs_p);
10300           relax_info->allocated_relocs = new_relocs;
10301           relax_info->allocated_relocs_count = new_relocs_count;
10302           elf_section_data (sec)->relocs = new_relocs;
10303           sec->reloc_count++;
10304           relax_info->relocs_count = sec->reloc_count;
10305           *internal_relocs_p = new_relocs;
10306         }
10307       else
10308         {
10309           if (insert_at != sec->reloc_count)
10310             {
10311               unsigned idx;
10312               for (idx = sec->reloc_count; idx > insert_at; idx--)
10313                 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
10314             }
10315           (*internal_relocs_p)[insert_at] = this_rela;
10316           sec->reloc_count++;
10317           if (relax_info->allocated_relocs)
10318             relax_info->relocs_count = sec->reloc_count;
10319         }
10320     }
10321   return TRUE;
10322 }
10323
10324
10325 /* This is similar to relax_section except that when a target is moved,
10326    we shift addresses up.  We also need to modify the size.  This
10327    algorithm does NOT allow for relocations into the middle of the
10328    property sections.  */
10329
10330 static bfd_boolean
10331 relax_property_section (bfd *abfd,
10332                         asection *sec,
10333                         struct bfd_link_info *link_info)
10334 {
10335   Elf_Internal_Rela *internal_relocs;
10336   bfd_byte *contents;
10337   unsigned i;
10338   bfd_boolean ok = TRUE;
10339   bfd_boolean is_full_prop_section;
10340   size_t last_zfill_target_offset = 0;
10341   asection *last_zfill_target_sec = NULL;
10342   bfd_size_type sec_size;
10343   bfd_size_type entry_size;
10344
10345   sec_size = bfd_get_section_limit (abfd, sec);
10346   internal_relocs = retrieve_internal_relocs (abfd, sec,
10347                                               link_info->keep_memory);
10348   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
10349   if (contents == NULL && sec_size != 0)
10350     {
10351       ok = FALSE;
10352       goto error_return;
10353     }
10354
10355   is_full_prop_section = xtensa_is_proptable_section (sec);
10356   if (is_full_prop_section)
10357     entry_size = 12;
10358   else
10359     entry_size = 8;
10360
10361   if (internal_relocs)
10362     {
10363       for (i = 0; i < sec->reloc_count; i++)
10364         {
10365           Elf_Internal_Rela *irel;
10366           xtensa_relax_info *target_relax_info;
10367           unsigned r_type;
10368           asection *target_sec;
10369           literal_value val;
10370           bfd_byte *size_p, *flags_p;
10371
10372           /* Locally change the source address.
10373              Translate the target to the new target address.
10374              If it points to this section and has been removed, MOVE IT.
10375              Also, don't forget to modify the associated SIZE at
10376              (offset + 4).  */
10377
10378           irel = &internal_relocs[i];
10379           r_type = ELF32_R_TYPE (irel->r_info);
10380           if (r_type == R_XTENSA_NONE)
10381             continue;
10382
10383           /* Find the literal value.  */
10384           r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
10385           size_p = &contents[irel->r_offset + 4];
10386           flags_p = NULL;
10387           if (is_full_prop_section)
10388             flags_p = &contents[irel->r_offset + 8];
10389           BFD_ASSERT (irel->r_offset + entry_size <= sec_size);
10390
10391           target_sec = r_reloc_get_section (&val.r_rel);
10392           target_relax_info = get_xtensa_relax_info (target_sec);
10393
10394           if (target_relax_info
10395               && (target_relax_info->is_relaxable_literal_section
10396                   || target_relax_info->is_relaxable_asm_section ))
10397             {
10398               /* Translate the relocation's destination.  */
10399               bfd_vma old_offset = val.r_rel.target_offset;
10400               bfd_vma new_offset;
10401               long old_size, new_size;
10402               int removed_by_old_offset =
10403                 removed_by_actions_map (&target_relax_info->action_list,
10404                                         old_offset, FALSE);
10405               new_offset = old_offset - removed_by_old_offset;
10406
10407               /* Assert that we are not out of bounds.  */
10408               old_size = bfd_get_32 (abfd, size_p);
10409               new_size = old_size;
10410
10411               if (old_size == 0)
10412                 {
10413                   /* Only the first zero-sized unreachable entry is
10414                      allowed to expand.  In this case the new offset
10415                      should be the offset before the fill and the new
10416                      size is the expansion size.  For other zero-sized
10417                      entries the resulting size should be zero with an
10418                      offset before or after the fill address depending
10419                      on whether the expanding unreachable entry
10420                      preceeds it.  */
10421                   if (last_zfill_target_sec == 0
10422                       || last_zfill_target_sec != target_sec
10423                       || last_zfill_target_offset != old_offset)
10424                     {
10425                       bfd_vma new_end_offset = new_offset;
10426
10427                       /* Recompute the new_offset, but this time don't
10428                          include any fill inserted by relaxation.  */
10429                       removed_by_old_offset =
10430                         removed_by_actions_map (&target_relax_info->action_list,
10431                                                 old_offset, TRUE);
10432                       new_offset = old_offset - removed_by_old_offset;
10433
10434                       /* If it is not unreachable and we have not yet
10435                          seen an unreachable at this address, place it
10436                          before the fill address.  */
10437                       if (flags_p && (bfd_get_32 (abfd, flags_p)
10438                                       & XTENSA_PROP_UNREACHABLE) != 0)
10439                         {
10440                           new_size = new_end_offset - new_offset;
10441
10442                           last_zfill_target_sec = target_sec;
10443                           last_zfill_target_offset = old_offset;
10444                         }
10445                     }
10446                 }
10447               else
10448                 {
10449                   int removed_by_old_offset_size =
10450                     removed_by_actions_map (&target_relax_info->action_list,
10451                                             old_offset + old_size, TRUE);
10452                   new_size -= removed_by_old_offset_size - removed_by_old_offset;
10453                 }
10454
10455               if (new_size != old_size)
10456                 {
10457                   bfd_put_32 (abfd, new_size, size_p);
10458                   pin_contents (sec, contents);
10459                 }
10460
10461               if (new_offset != old_offset)
10462                 {
10463                   bfd_vma diff = new_offset - old_offset;
10464                   irel->r_addend += diff;
10465                   pin_internal_relocs (sec, internal_relocs);
10466                 }
10467             }
10468         }
10469     }
10470
10471   /* Combine adjacent property table entries.  This is also done in
10472      finish_dynamic_sections() but at that point it's too late to
10473      reclaim the space in the output section, so we do this twice.  */
10474
10475   if (internal_relocs && (!bfd_link_relocatable (link_info)
10476                           || xtensa_is_littable_section (sec)))
10477     {
10478       Elf_Internal_Rela *last_irel = NULL;
10479       Elf_Internal_Rela *irel, *next_rel, *rel_end;
10480       int removed_bytes = 0;
10481       bfd_vma offset;
10482       flagword predef_flags;
10483
10484       predef_flags = xtensa_get_property_predef_flags (sec);
10485
10486       /* Walk over memory and relocations at the same time.
10487          This REQUIRES that the internal_relocs be sorted by offset.  */
10488       qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
10489              internal_reloc_compare);
10490
10491       pin_internal_relocs (sec, internal_relocs);
10492       pin_contents (sec, contents);
10493
10494       next_rel = internal_relocs;
10495       rel_end = internal_relocs + sec->reloc_count;
10496
10497       BFD_ASSERT (sec->size % entry_size == 0);
10498
10499       for (offset = 0; offset < sec->size; offset += entry_size)
10500         {
10501           Elf_Internal_Rela *offset_rel, *extra_rel;
10502           bfd_vma bytes_to_remove, size, actual_offset;
10503           bfd_boolean remove_this_rel;
10504           flagword flags;
10505
10506           /* Find the first relocation for the entry at the current offset.
10507              Adjust the offsets of any extra relocations for the previous
10508              entry.  */
10509           offset_rel = NULL;
10510           if (next_rel)
10511             {
10512               for (irel = next_rel; irel < rel_end; irel++)
10513                 {
10514                   if ((irel->r_offset == offset
10515                        && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
10516                       || irel->r_offset > offset)
10517                     {
10518                       offset_rel = irel;
10519                       break;
10520                     }
10521                   irel->r_offset -= removed_bytes;
10522                 }
10523             }
10524
10525           /* Find the next relocation (if there are any left).  */
10526           extra_rel = NULL;
10527           if (offset_rel)
10528             {
10529               for (irel = offset_rel + 1; irel < rel_end; irel++)
10530                 {
10531                   if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
10532                     {
10533                       extra_rel = irel;
10534                       break;
10535                     }
10536                 }
10537             }
10538
10539           /* Check if there are relocations on the current entry.  There
10540              should usually be a relocation on the offset field.  If there
10541              are relocations on the size or flags, then we can't optimize
10542              this entry.  Also, find the next relocation to examine on the
10543              next iteration.  */
10544           if (offset_rel)
10545             {
10546               if (offset_rel->r_offset >= offset + entry_size)
10547                 {
10548                   next_rel = offset_rel;
10549                   /* There are no relocations on the current entry, but we
10550                      might still be able to remove it if the size is zero.  */
10551                   offset_rel = NULL;
10552                 }
10553               else if (offset_rel->r_offset > offset
10554                        || (extra_rel
10555                            && extra_rel->r_offset < offset + entry_size))
10556                 {
10557                   /* There is a relocation on the size or flags, so we can't
10558                      do anything with this entry.  Continue with the next.  */
10559                   next_rel = offset_rel;
10560                   continue;
10561                 }
10562               else
10563                 {
10564                   BFD_ASSERT (offset_rel->r_offset == offset);
10565                   offset_rel->r_offset -= removed_bytes;
10566                   next_rel = offset_rel + 1;
10567                 }
10568             }
10569           else
10570             next_rel = NULL;
10571
10572           remove_this_rel = FALSE;
10573           bytes_to_remove = 0;
10574           actual_offset = offset - removed_bytes;
10575           size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
10576
10577           if (is_full_prop_section)
10578             flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
10579           else
10580             flags = predef_flags;
10581
10582           if (size == 0
10583               && (flags & XTENSA_PROP_ALIGN) == 0
10584               && (flags & XTENSA_PROP_UNREACHABLE) == 0)
10585             {
10586               /* Always remove entries with zero size and no alignment.  */
10587               bytes_to_remove = entry_size;
10588               if (offset_rel)
10589                 remove_this_rel = TRUE;
10590             }
10591           else if (offset_rel
10592                    && ELF32_R_TYPE (offset_rel->r_info) == R_XTENSA_32)
10593             {
10594               if (last_irel)
10595                 {
10596                   flagword old_flags;
10597                   bfd_vma old_size =
10598                     bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
10599                   bfd_vma old_address =
10600                     (last_irel->r_addend
10601                      + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
10602                   bfd_vma new_address =
10603                     (offset_rel->r_addend
10604                      + bfd_get_32 (abfd, &contents[actual_offset]));
10605                   if (is_full_prop_section)
10606                     old_flags = bfd_get_32
10607                       (abfd, &contents[last_irel->r_offset + 8]);
10608                   else
10609                     old_flags = predef_flags;
10610
10611                   if ((ELF32_R_SYM (offset_rel->r_info)
10612                        == ELF32_R_SYM (last_irel->r_info))
10613                       && old_address + old_size == new_address
10614                       && old_flags == flags
10615                       && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
10616                       && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
10617                     {
10618                       /* Fix the old size.  */
10619                       bfd_put_32 (abfd, old_size + size,
10620                                   &contents[last_irel->r_offset + 4]);
10621                       bytes_to_remove = entry_size;
10622                       remove_this_rel = TRUE;
10623                     }
10624                   else
10625                     last_irel = offset_rel;
10626                 }
10627               else
10628                 last_irel = offset_rel;
10629             }
10630
10631           if (remove_this_rel)
10632             {
10633               offset_rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
10634               offset_rel->r_offset = 0;
10635             }
10636
10637           if (bytes_to_remove != 0)
10638             {
10639               removed_bytes += bytes_to_remove;
10640               if (offset + bytes_to_remove < sec->size)
10641                 memmove (&contents[actual_offset],
10642                          &contents[actual_offset + bytes_to_remove],
10643                          sec->size - offset - bytes_to_remove);
10644             }
10645         }
10646
10647       if (removed_bytes)
10648         {
10649           /* Fix up any extra relocations on the last entry.  */
10650           for (irel = next_rel; irel < rel_end; irel++)
10651             irel->r_offset -= removed_bytes;
10652
10653           /* Clear the removed bytes.  */
10654           memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
10655
10656           if (sec->rawsize == 0)
10657             sec->rawsize = sec->size;
10658           sec->size -= removed_bytes;
10659
10660           if (xtensa_is_littable_section (sec))
10661             {
10662               asection *sgotloc = elf_xtensa_hash_table (link_info)->sgotloc;
10663               if (sgotloc)
10664                 sgotloc->size -= removed_bytes;
10665             }
10666         }
10667     }
10668
10669  error_return:
10670   release_internal_relocs (sec, internal_relocs);
10671   release_contents (sec, contents);
10672   return ok;
10673 }
10674
10675 \f
10676 /* Third relaxation pass.  */
10677
10678 /* Change symbol values to account for removed literals.  */
10679
10680 bfd_boolean
10681 relax_section_symbols (bfd *abfd, asection *sec)
10682 {
10683   xtensa_relax_info *relax_info;
10684   unsigned int sec_shndx;
10685   Elf_Internal_Shdr *symtab_hdr;
10686   Elf_Internal_Sym *isymbuf;
10687   unsigned i, num_syms, num_locals;
10688
10689   relax_info = get_xtensa_relax_info (sec);
10690   BFD_ASSERT (relax_info);
10691
10692   if (!relax_info->is_relaxable_literal_section
10693       && !relax_info->is_relaxable_asm_section)
10694     return TRUE;
10695
10696   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
10697
10698   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10699   isymbuf = retrieve_local_syms (abfd);
10700
10701   num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
10702   num_locals = symtab_hdr->sh_info;
10703
10704   /* Adjust the local symbols defined in this section.  */
10705   for (i = 0; i < num_locals; i++)
10706     {
10707       Elf_Internal_Sym *isym = &isymbuf[i];
10708
10709       if (isym->st_shndx == sec_shndx)
10710         {
10711           bfd_vma orig_addr = isym->st_value;
10712           int removed = removed_by_actions_map (&relax_info->action_list,
10713                                                 orig_addr, FALSE);
10714
10715           isym->st_value -= removed;
10716           if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
10717             isym->st_size -=
10718               removed_by_actions_map (&relax_info->action_list,
10719                                       orig_addr + isym->st_size, FALSE) -
10720               removed;
10721         }
10722     }
10723
10724   /* Now adjust the global symbols defined in this section.  */
10725   for (i = 0; i < (num_syms - num_locals); i++)
10726     {
10727       struct elf_link_hash_entry *sym_hash;
10728
10729       sym_hash = elf_sym_hashes (abfd)[i];
10730
10731       if (sym_hash->root.type == bfd_link_hash_warning)
10732         sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
10733
10734       if ((sym_hash->root.type == bfd_link_hash_defined
10735            || sym_hash->root.type == bfd_link_hash_defweak)
10736           && sym_hash->root.u.def.section == sec)
10737         {
10738           bfd_vma orig_addr = sym_hash->root.u.def.value;
10739           int removed = removed_by_actions_map (&relax_info->action_list,
10740                                                 orig_addr, FALSE);
10741
10742           sym_hash->root.u.def.value -= removed;
10743
10744           if (sym_hash->type == STT_FUNC)
10745             sym_hash->size -=
10746               removed_by_actions_map (&relax_info->action_list,
10747                                       orig_addr + sym_hash->size, FALSE) -
10748               removed;
10749         }
10750     }
10751
10752   return TRUE;
10753 }
10754
10755 \f
10756 /* "Fix" handling functions, called while performing relocations.  */
10757
10758 static bfd_boolean
10759 do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
10760                              bfd *input_bfd,
10761                              asection *input_section,
10762                              bfd_byte *contents)
10763 {
10764   r_reloc r_rel;
10765   asection *sec, *old_sec;
10766   bfd_vma old_offset;
10767   int r_type = ELF32_R_TYPE (rel->r_info);
10768   reloc_bfd_fix *fix;
10769
10770   if (r_type == R_XTENSA_NONE)
10771     return TRUE;
10772
10773   fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10774   if (!fix)
10775     return TRUE;
10776
10777   r_reloc_init (&r_rel, input_bfd, rel, contents,
10778                 bfd_get_section_limit (input_bfd, input_section));
10779   old_sec = r_reloc_get_section (&r_rel);
10780   old_offset = r_rel.target_offset;
10781
10782   if (!old_sec || !r_reloc_is_defined (&r_rel))
10783     {
10784       if (r_type != R_XTENSA_ASM_EXPAND)
10785         {
10786           (*_bfd_error_handler)
10787             (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
10788              input_bfd, input_section, rel->r_offset,
10789              elf_howto_table[r_type].name);
10790           return FALSE;
10791         }
10792       /* Leave it be.  Resolution will happen in a later stage.  */
10793     }
10794   else
10795     {
10796       sec = fix->target_sec;
10797       rel->r_addend += ((sec->output_offset + fix->target_offset)
10798                         - (old_sec->output_offset + old_offset));
10799     }
10800   return TRUE;
10801 }
10802
10803
10804 static void
10805 do_fix_for_final_link (Elf_Internal_Rela *rel,
10806                        bfd *input_bfd,
10807                        asection *input_section,
10808                        bfd_byte *contents,
10809                        bfd_vma *relocationp)
10810 {
10811   asection *sec;
10812   int r_type = ELF32_R_TYPE (rel->r_info);
10813   reloc_bfd_fix *fix;
10814   bfd_vma fixup_diff;
10815
10816   if (r_type == R_XTENSA_NONE)
10817     return;
10818
10819   fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10820   if (!fix)
10821     return;
10822
10823   sec = fix->target_sec;
10824
10825   fixup_diff = rel->r_addend;
10826   if (elf_howto_table[fix->src_type].partial_inplace)
10827     {
10828       bfd_vma inplace_val;
10829       BFD_ASSERT (fix->src_offset
10830                   < bfd_get_section_limit (input_bfd, input_section));
10831       inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
10832       fixup_diff += inplace_val;
10833     }
10834
10835   *relocationp = (sec->output_section->vma
10836                   + sec->output_offset
10837                   + fix->target_offset - fixup_diff);
10838 }
10839
10840 \f
10841 /* Miscellaneous utility functions....  */
10842
10843 static asection *
10844 elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
10845 {
10846   struct elf_xtensa_link_hash_table *htab;
10847   bfd *dynobj;
10848   char plt_name[10];
10849
10850   if (chunk == 0)
10851     {
10852       htab = elf_xtensa_hash_table (info);
10853       if (htab == NULL)
10854         return NULL;
10855
10856       return htab->splt;
10857     }
10858
10859   dynobj = elf_hash_table (info)->dynobj;
10860   sprintf (plt_name, ".plt.%u", chunk);
10861   return bfd_get_linker_section (dynobj, plt_name);
10862 }
10863
10864
10865 static asection *
10866 elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
10867 {
10868   struct elf_xtensa_link_hash_table *htab;
10869   bfd *dynobj;
10870   char got_name[14];
10871
10872   if (chunk == 0)
10873     {
10874       htab = elf_xtensa_hash_table (info);
10875       if (htab == NULL)
10876         return NULL;
10877       return htab->sgotplt;
10878     }
10879
10880   dynobj = elf_hash_table (info)->dynobj;
10881   sprintf (got_name, ".got.plt.%u", chunk);
10882   return bfd_get_linker_section (dynobj, got_name);
10883 }
10884
10885
10886 /* Get the input section for a given symbol index.
10887    If the symbol is:
10888    . a section symbol, return the section;
10889    . a common symbol, return the common section;
10890    . an undefined symbol, return the undefined section;
10891    . an indirect symbol, follow the links;
10892    . an absolute value, return the absolute section.  */
10893
10894 static asection *
10895 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
10896 {
10897   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10898   asection *target_sec = NULL;
10899   if (r_symndx < symtab_hdr->sh_info)
10900     {
10901       Elf_Internal_Sym *isymbuf;
10902       unsigned int section_index;
10903
10904       isymbuf = retrieve_local_syms (abfd);
10905       section_index = isymbuf[r_symndx].st_shndx;
10906
10907       if (section_index == SHN_UNDEF)
10908         target_sec = bfd_und_section_ptr;
10909       else if (section_index == SHN_ABS)
10910         target_sec = bfd_abs_section_ptr;
10911       else if (section_index == SHN_COMMON)
10912         target_sec = bfd_com_section_ptr;
10913       else
10914         target_sec = bfd_section_from_elf_index (abfd, section_index);
10915     }
10916   else
10917     {
10918       unsigned long indx = r_symndx - symtab_hdr->sh_info;
10919       struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
10920
10921       while (h->root.type == bfd_link_hash_indirect
10922              || h->root.type == bfd_link_hash_warning)
10923         h = (struct elf_link_hash_entry *) h->root.u.i.link;
10924
10925       switch (h->root.type)
10926         {
10927         case bfd_link_hash_defined:
10928         case  bfd_link_hash_defweak:
10929           target_sec = h->root.u.def.section;
10930           break;
10931         case bfd_link_hash_common:
10932           target_sec = bfd_com_section_ptr;
10933           break;
10934         case bfd_link_hash_undefined:
10935         case bfd_link_hash_undefweak:
10936           target_sec = bfd_und_section_ptr;
10937           break;
10938         default: /* New indirect warning.  */
10939           target_sec = bfd_und_section_ptr;
10940           break;
10941         }
10942     }
10943   return target_sec;
10944 }
10945
10946
10947 static struct elf_link_hash_entry *
10948 get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
10949 {
10950   unsigned long indx;
10951   struct elf_link_hash_entry *h;
10952   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10953
10954   if (r_symndx < symtab_hdr->sh_info)
10955     return NULL;
10956
10957   indx = r_symndx - symtab_hdr->sh_info;
10958   h = elf_sym_hashes (abfd)[indx];
10959   while (h->root.type == bfd_link_hash_indirect
10960          || h->root.type == bfd_link_hash_warning)
10961     h = (struct elf_link_hash_entry *) h->root.u.i.link;
10962   return h;
10963 }
10964
10965
10966 /* Get the section-relative offset for a symbol number.  */
10967
10968 static bfd_vma
10969 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
10970 {
10971   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10972   bfd_vma offset = 0;
10973
10974   if (r_symndx < symtab_hdr->sh_info)
10975     {
10976       Elf_Internal_Sym *isymbuf;
10977       isymbuf = retrieve_local_syms (abfd);
10978       offset = isymbuf[r_symndx].st_value;
10979     }
10980   else
10981     {
10982       unsigned long indx = r_symndx - symtab_hdr->sh_info;
10983       struct elf_link_hash_entry *h =
10984         elf_sym_hashes (abfd)[indx];
10985
10986       while (h->root.type == bfd_link_hash_indirect
10987              || h->root.type == bfd_link_hash_warning)
10988         h = (struct elf_link_hash_entry *) h->root.u.i.link;
10989       if (h->root.type == bfd_link_hash_defined
10990           || h->root.type == bfd_link_hash_defweak)
10991         offset = h->root.u.def.value;
10992     }
10993   return offset;
10994 }
10995
10996
10997 static bfd_boolean
10998 is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
10999 {
11000   unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
11001   struct elf_link_hash_entry *h;
11002
11003   h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
11004   if (h && h->root.type == bfd_link_hash_defweak)
11005     return TRUE;
11006   return FALSE;
11007 }
11008
11009
11010 static bfd_boolean
11011 pcrel_reloc_fits (xtensa_opcode opc,
11012                   int opnd,
11013                   bfd_vma self_address,
11014                   bfd_vma dest_address)
11015 {
11016   xtensa_isa isa = xtensa_default_isa;
11017   uint32 valp = dest_address;
11018   if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
11019       || xtensa_operand_encode (isa, opc, opnd, &valp))
11020     return FALSE;
11021   return TRUE;
11022 }
11023
11024
11025 static bfd_boolean
11026 xtensa_is_property_section (asection *sec)
11027 {
11028   if (xtensa_is_insntable_section (sec)
11029       || xtensa_is_littable_section (sec)
11030       || xtensa_is_proptable_section (sec))
11031     return TRUE;
11032
11033   return FALSE;
11034 }
11035
11036
11037 static bfd_boolean
11038 xtensa_is_insntable_section (asection *sec)
11039 {
11040   if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
11041       || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
11042     return TRUE;
11043
11044   return FALSE;
11045 }
11046
11047
11048 static bfd_boolean
11049 xtensa_is_littable_section (asection *sec)
11050 {
11051   if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
11052       || CONST_STRNEQ (sec->name, ".gnu.linkonce.p."))
11053     return TRUE;
11054
11055   return FALSE;
11056 }
11057
11058
11059 static bfd_boolean
11060 xtensa_is_proptable_section (asection *sec)
11061 {
11062   if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
11063       || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."))
11064     return TRUE;
11065
11066   return FALSE;
11067 }
11068
11069
11070 static int
11071 internal_reloc_compare (const void *ap, const void *bp)
11072 {
11073   const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
11074   const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
11075
11076   if (a->r_offset != b->r_offset)
11077     return (a->r_offset - b->r_offset);
11078
11079   /* We don't need to sort on these criteria for correctness,
11080      but enforcing a more strict ordering prevents unstable qsort
11081      from behaving differently with different implementations.
11082      Without the code below we get correct but different results
11083      on Solaris 2.7 and 2.8.  We would like to always produce the
11084      same results no matter the host.  */
11085
11086   if (a->r_info != b->r_info)
11087     return (a->r_info - b->r_info);
11088
11089   return (a->r_addend - b->r_addend);
11090 }
11091
11092
11093 static int
11094 internal_reloc_matches (const void *ap, const void *bp)
11095 {
11096   const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
11097   const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
11098
11099   /* Check if one entry overlaps with the other; this shouldn't happen
11100      except when searching for a match.  */
11101   return (a->r_offset - b->r_offset);
11102 }
11103
11104
11105 /* Predicate function used to look up a section in a particular group.  */
11106
11107 static bfd_boolean
11108 match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
11109 {
11110   const char *gname = inf;
11111   const char *group_name = elf_group_name (sec);
11112
11113   return (group_name == gname
11114           || (group_name != NULL
11115               && gname != NULL
11116               && strcmp (group_name, gname) == 0));
11117 }
11118
11119
11120 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
11121
11122 static char *
11123 xtensa_property_section_name (asection *sec, const char *base_name)
11124 {
11125   const char *suffix, *group_name;
11126   char *prop_sec_name;
11127
11128   group_name = elf_group_name (sec);
11129   if (group_name)
11130     {
11131       suffix = strrchr (sec->name, '.');
11132       if (suffix == sec->name)
11133         suffix = 0;
11134       prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1
11135                                            + (suffix ? strlen (suffix) : 0));
11136       strcpy (prop_sec_name, base_name);
11137       if (suffix)
11138         strcat (prop_sec_name, suffix);
11139     }
11140   else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
11141     {
11142       char *linkonce_kind = 0;
11143
11144       if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
11145         linkonce_kind = "x.";
11146       else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
11147         linkonce_kind = "p.";
11148       else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
11149         linkonce_kind = "prop.";
11150       else
11151         abort ();
11152
11153       prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
11154                                            + strlen (linkonce_kind) + 1);
11155       memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
11156       strcpy (prop_sec_name + linkonce_len, linkonce_kind);
11157
11158       suffix = sec->name + linkonce_len;
11159       /* For backward compatibility, replace "t." instead of inserting
11160          the new linkonce_kind (but not for "prop" sections).  */
11161       if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
11162         suffix += 2;
11163       strcat (prop_sec_name + linkonce_len, suffix);
11164     }
11165   else
11166     prop_sec_name = strdup (base_name);
11167
11168   return prop_sec_name;
11169 }
11170
11171
11172 static asection *
11173 xtensa_get_property_section (asection *sec, const char *base_name)
11174 {
11175   char *prop_sec_name;
11176   asection *prop_sec;
11177
11178   prop_sec_name = xtensa_property_section_name (sec, base_name);
11179   prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
11180                                          match_section_group,
11181                                          (void *) elf_group_name (sec));
11182   free (prop_sec_name);
11183   return prop_sec;
11184 }
11185
11186
11187 asection *
11188 xtensa_make_property_section (asection *sec, const char *base_name)
11189 {
11190   char *prop_sec_name;
11191   asection *prop_sec;
11192
11193   /* Check if the section already exists.  */
11194   prop_sec_name = xtensa_property_section_name (sec, base_name);
11195   prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
11196                                          match_section_group,
11197                                          (void *) elf_group_name (sec));
11198   /* If not, create it.  */
11199   if (! prop_sec)
11200     {
11201       flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
11202       flags |= (bfd_get_section_flags (sec->owner, sec)
11203                 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
11204
11205       prop_sec = bfd_make_section_anyway_with_flags
11206         (sec->owner, strdup (prop_sec_name), flags);
11207       if (! prop_sec)
11208         return 0;
11209
11210       elf_group_name (prop_sec) = elf_group_name (sec);
11211     }
11212
11213   free (prop_sec_name);
11214   return prop_sec;
11215 }
11216
11217
11218 flagword
11219 xtensa_get_property_predef_flags (asection *sec)
11220 {
11221   if (xtensa_is_insntable_section (sec))
11222     return (XTENSA_PROP_INSN
11223             | XTENSA_PROP_NO_TRANSFORM
11224             | XTENSA_PROP_INSN_NO_REORDER);
11225
11226   if (xtensa_is_littable_section (sec))
11227     return (XTENSA_PROP_LITERAL
11228             | XTENSA_PROP_NO_TRANSFORM
11229             | XTENSA_PROP_INSN_NO_REORDER);
11230
11231   return 0;
11232 }
11233
11234 \f
11235 /* Other functions called directly by the linker.  */
11236
11237 bfd_boolean
11238 xtensa_callback_required_dependence (bfd *abfd,
11239                                      asection *sec,
11240                                      struct bfd_link_info *link_info,
11241                                      deps_callback_t callback,
11242                                      void *closure)
11243 {
11244   Elf_Internal_Rela *internal_relocs;
11245   bfd_byte *contents;
11246   unsigned i;
11247   bfd_boolean ok = TRUE;
11248   bfd_size_type sec_size;
11249
11250   sec_size = bfd_get_section_limit (abfd, sec);
11251
11252   /* ".plt*" sections have no explicit relocations but they contain L32R
11253      instructions that reference the corresponding ".got.plt*" sections.  */
11254   if ((sec->flags & SEC_LINKER_CREATED) != 0
11255       && CONST_STRNEQ (sec->name, ".plt"))
11256     {
11257       asection *sgotplt;
11258
11259       /* Find the corresponding ".got.plt*" section.  */
11260       if (sec->name[4] == '\0')
11261         sgotplt = bfd_get_linker_section (sec->owner, ".got.plt");
11262       else
11263         {
11264           char got_name[14];
11265           int chunk = 0;
11266
11267           BFD_ASSERT (sec->name[4] == '.');
11268           chunk = strtol (&sec->name[5], NULL, 10);
11269
11270           sprintf (got_name, ".got.plt.%u", chunk);
11271           sgotplt = bfd_get_linker_section (sec->owner, got_name);
11272         }
11273       BFD_ASSERT (sgotplt);
11274
11275       /* Assume worst-case offsets: L32R at the very end of the ".plt"
11276          section referencing a literal at the very beginning of
11277          ".got.plt".  This is very close to the real dependence, anyway.  */
11278       (*callback) (sec, sec_size, sgotplt, 0, closure);
11279     }
11280
11281   /* Only ELF files are supported for Xtensa.  Check here to avoid a segfault
11282      when building uclibc, which runs "ld -b binary /dev/null".  */
11283   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
11284     return ok;
11285
11286   internal_relocs = retrieve_internal_relocs (abfd, sec,
11287                                               link_info->keep_memory);
11288   if (internal_relocs == NULL
11289       || sec->reloc_count == 0)
11290     return ok;
11291
11292   /* Cache the contents for the duration of this scan.  */
11293   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
11294   if (contents == NULL && sec_size != 0)
11295     {
11296       ok = FALSE;
11297       goto error_return;
11298     }
11299
11300   if (!xtensa_default_isa)
11301     xtensa_default_isa = xtensa_isa_init (0, 0);
11302
11303   for (i = 0; i < sec->reloc_count; i++)
11304     {
11305       Elf_Internal_Rela *irel = &internal_relocs[i];
11306       if (is_l32r_relocation (abfd, sec, contents, irel))
11307         {
11308           r_reloc l32r_rel;
11309           asection *target_sec;
11310           bfd_vma target_offset;
11311
11312           r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
11313           target_sec = NULL;
11314           target_offset = 0;
11315           /* L32Rs must be local to the input file.  */
11316           if (r_reloc_is_defined (&l32r_rel))
11317             {
11318               target_sec = r_reloc_get_section (&l32r_rel);
11319               target_offset = l32r_rel.target_offset;
11320             }
11321           (*callback) (sec, irel->r_offset, target_sec, target_offset,
11322                        closure);
11323         }
11324     }
11325
11326  error_return:
11327   release_internal_relocs (sec, internal_relocs);
11328   release_contents (sec, contents);
11329   return ok;
11330 }
11331
11332 /* The default literal sections should always be marked as "code" (i.e.,
11333    SHF_EXECINSTR).  This is particularly important for the Linux kernel
11334    module loader so that the literals are not placed after the text.  */
11335 static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
11336 {
11337   { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11338   { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11339   { STRING_COMMA_LEN (".literal"),      0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11340   { STRING_COMMA_LEN (".xtensa.info"),  0, SHT_NOTE,     0 },
11341   { NULL,                       0,      0, 0,            0 }
11342 };
11343 \f
11344 #define ELF_TARGET_ID                   XTENSA_ELF_DATA
11345 #ifndef ELF_ARCH
11346 #define TARGET_LITTLE_SYM               xtensa_elf32_le_vec
11347 #define TARGET_LITTLE_NAME              "elf32-xtensa-le"
11348 #define TARGET_BIG_SYM                  xtensa_elf32_be_vec
11349 #define TARGET_BIG_NAME                 "elf32-xtensa-be"
11350 #define ELF_ARCH                        bfd_arch_xtensa
11351
11352 #define ELF_MACHINE_CODE                EM_XTENSA
11353 #define ELF_MACHINE_ALT1                EM_XTENSA_OLD
11354
11355 #if XCHAL_HAVE_MMU
11356 #define ELF_MAXPAGESIZE                 (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
11357 #else /* !XCHAL_HAVE_MMU */
11358 #define ELF_MAXPAGESIZE                 1
11359 #endif /* !XCHAL_HAVE_MMU */
11360 #endif /* ELF_ARCH */
11361
11362 #define elf_backend_can_gc_sections     1
11363 #define elf_backend_can_refcount        1
11364 #define elf_backend_plt_readonly        1
11365 #define elf_backend_got_header_size     4
11366 #define elf_backend_want_dynbss         0
11367 #define elf_backend_want_got_plt        1
11368
11369 #define elf_info_to_howto                    elf_xtensa_info_to_howto_rela
11370
11371 #define bfd_elf32_mkobject                   elf_xtensa_mkobject
11372
11373 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11374 #define bfd_elf32_new_section_hook           elf_xtensa_new_section_hook
11375 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11376 #define bfd_elf32_bfd_relax_section          elf_xtensa_relax_section
11377 #define bfd_elf32_bfd_reloc_type_lookup      elf_xtensa_reloc_type_lookup
11378 #define bfd_elf32_bfd_reloc_name_lookup \
11379   elf_xtensa_reloc_name_lookup
11380 #define bfd_elf32_bfd_set_private_flags      elf_xtensa_set_private_flags
11381 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11382
11383 #define elf_backend_adjust_dynamic_symbol    elf_xtensa_adjust_dynamic_symbol
11384 #define elf_backend_check_relocs             elf_xtensa_check_relocs
11385 #define elf_backend_create_dynamic_sections  elf_xtensa_create_dynamic_sections
11386 #define elf_backend_discard_info             elf_xtensa_discard_info
11387 #define elf_backend_ignore_discarded_relocs  elf_xtensa_ignore_discarded_relocs
11388 #define elf_backend_final_write_processing   elf_xtensa_final_write_processing
11389 #define elf_backend_finish_dynamic_sections  elf_xtensa_finish_dynamic_sections
11390 #define elf_backend_finish_dynamic_symbol    elf_xtensa_finish_dynamic_symbol
11391 #define elf_backend_gc_mark_hook             elf_xtensa_gc_mark_hook
11392 #define elf_backend_gc_sweep_hook            elf_xtensa_gc_sweep_hook
11393 #define elf_backend_grok_prstatus            elf_xtensa_grok_prstatus
11394 #define elf_backend_grok_psinfo              elf_xtensa_grok_psinfo
11395 #define elf_backend_hide_symbol              elf_xtensa_hide_symbol
11396 #define elf_backend_object_p                 elf_xtensa_object_p
11397 #define elf_backend_reloc_type_class         elf_xtensa_reloc_type_class
11398 #define elf_backend_relocate_section         elf_xtensa_relocate_section
11399 #define elf_backend_size_dynamic_sections    elf_xtensa_size_dynamic_sections
11400 #define elf_backend_always_size_sections     elf_xtensa_always_size_sections
11401 #define elf_backend_omit_section_dynsym \
11402   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
11403 #define elf_backend_special_sections         elf_xtensa_special_sections
11404 #define elf_backend_action_discarded         elf_xtensa_action_discarded
11405 #define elf_backend_copy_indirect_symbol     elf_xtensa_copy_indirect_symbol
11406
11407 #include "elf32-target.h"