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           break;
3435
3436         case DT_PLTGOT:
3437           dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3438           break;
3439
3440         case DT_JMPREL:
3441           dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3442           break;
3443
3444         case DT_PLTRELSZ:
3445           dyn.d_un.d_val = htab->srelplt->output_section->size;
3446           break;
3447
3448         case DT_RELASZ:
3449           /* Adjust RELASZ to not include JMPREL.  This matches what
3450              glibc expects and what is done for several other ELF
3451              targets (e.g., i386, alpha), but the "correct" behavior
3452              seems to be unresolved.  Since the linker script arranges
3453              for .rela.plt to follow all other relocation sections, we
3454              don't have to worry about changing the DT_RELA entry.  */
3455           if (htab->srelplt)
3456             dyn.d_un.d_val -= htab->srelplt->output_section->size;
3457           break;
3458         }
3459
3460       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3461     }
3462
3463   return TRUE;
3464 }
3465
3466 \f
3467 /* Functions for dealing with the e_flags field.  */
3468
3469 /* Merge backend specific data from an object file to the output
3470    object file when linking.  */
3471
3472 static bfd_boolean
3473 elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3474 {
3475   unsigned out_mach, in_mach;
3476   flagword out_flag, in_flag;
3477
3478   /* Check if we have the same endianness.  */
3479   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
3480     return FALSE;
3481
3482   /* Don't even pretend to support mixed-format linking.  */
3483   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3484       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3485     return FALSE;
3486
3487   out_flag = elf_elfheader (obfd)->e_flags;
3488   in_flag = elf_elfheader (ibfd)->e_flags;
3489
3490   out_mach = out_flag & EF_XTENSA_MACH;
3491   in_mach = in_flag & EF_XTENSA_MACH;
3492   if (out_mach != in_mach)
3493     {
3494       (*_bfd_error_handler)
3495         (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
3496          ibfd, out_mach, in_mach);
3497       bfd_set_error (bfd_error_wrong_format);
3498       return FALSE;
3499     }
3500
3501   if (! elf_flags_init (obfd))
3502     {
3503       elf_flags_init (obfd) = TRUE;
3504       elf_elfheader (obfd)->e_flags = in_flag;
3505
3506       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3507           && bfd_get_arch_info (obfd)->the_default)
3508         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3509                                   bfd_get_mach (ibfd));
3510
3511       return TRUE;
3512     }
3513
3514   if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
3515     elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
3516
3517   if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
3518     elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
3519
3520   return TRUE;
3521 }
3522
3523
3524 static bfd_boolean
3525 elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
3526 {
3527   BFD_ASSERT (!elf_flags_init (abfd)
3528               || elf_elfheader (abfd)->e_flags == flags);
3529
3530   elf_elfheader (abfd)->e_flags |= flags;
3531   elf_flags_init (abfd) = TRUE;
3532
3533   return TRUE;
3534 }
3535
3536
3537 static bfd_boolean
3538 elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
3539 {
3540   FILE *f = (FILE *) farg;
3541   flagword e_flags = elf_elfheader (abfd)->e_flags;
3542
3543   fprintf (f, "\nXtensa header:\n");
3544   if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
3545     fprintf (f, "\nMachine     = Base\n");
3546   else
3547     fprintf (f, "\nMachine Id  = 0x%x\n", e_flags & EF_XTENSA_MACH);
3548
3549   fprintf (f, "Insn tables = %s\n",
3550            (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
3551
3552   fprintf (f, "Literal tables = %s\n",
3553            (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
3554
3555   return _bfd_elf_print_private_bfd_data (abfd, farg);
3556 }
3557
3558
3559 /* Set the right machine number for an Xtensa ELF file.  */
3560
3561 static bfd_boolean
3562 elf_xtensa_object_p (bfd *abfd)
3563 {
3564   int mach;
3565   unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
3566
3567   switch (arch)
3568     {
3569     case E_XTENSA_MACH:
3570       mach = bfd_mach_xtensa;
3571       break;
3572     default:
3573       return FALSE;
3574     }
3575
3576   (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
3577   return TRUE;
3578 }
3579
3580
3581 /* The final processing done just before writing out an Xtensa ELF object
3582    file.  This gets the Xtensa architecture right based on the machine
3583    number.  */
3584
3585 static void
3586 elf_xtensa_final_write_processing (bfd *abfd,
3587                                    bfd_boolean linker ATTRIBUTE_UNUSED)
3588 {
3589   int mach;
3590   unsigned long val;
3591
3592   switch (mach = bfd_get_mach (abfd))
3593     {
3594     case bfd_mach_xtensa:
3595       val = E_XTENSA_MACH;
3596       break;
3597     default:
3598       return;
3599     }
3600
3601   elf_elfheader (abfd)->e_flags &=  (~ EF_XTENSA_MACH);
3602   elf_elfheader (abfd)->e_flags |= val;
3603 }
3604
3605
3606 static enum elf_reloc_type_class
3607 elf_xtensa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3608                              const asection *rel_sec ATTRIBUTE_UNUSED,
3609                              const Elf_Internal_Rela *rela)
3610 {
3611   switch ((int) ELF32_R_TYPE (rela->r_info))
3612     {
3613     case R_XTENSA_RELATIVE:
3614       return reloc_class_relative;
3615     case R_XTENSA_JMP_SLOT:
3616       return reloc_class_plt;
3617     default:
3618       return reloc_class_normal;
3619     }
3620 }
3621
3622 \f
3623 static bfd_boolean
3624 elf_xtensa_discard_info_for_section (bfd *abfd,
3625                                      struct elf_reloc_cookie *cookie,
3626                                      struct bfd_link_info *info,
3627                                      asection *sec)
3628 {
3629   bfd_byte *contents;
3630   bfd_vma offset, actual_offset;
3631   bfd_size_type removed_bytes = 0;
3632   bfd_size_type entry_size;
3633
3634   if (sec->output_section
3635       && bfd_is_abs_section (sec->output_section))
3636     return FALSE;
3637
3638   if (xtensa_is_proptable_section (sec))
3639     entry_size = 12;
3640   else
3641     entry_size = 8;
3642
3643   if (sec->size == 0 || sec->size % entry_size != 0)
3644     return FALSE;
3645
3646   contents = retrieve_contents (abfd, sec, info->keep_memory);
3647   if (!contents)
3648     return FALSE;
3649
3650   cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
3651   if (!cookie->rels)
3652     {
3653       release_contents (sec, contents);
3654       return FALSE;
3655     }
3656
3657   /* Sort the relocations.  They should already be in order when
3658      relaxation is enabled, but it might not be.  */
3659   qsort (cookie->rels, sec->reloc_count, sizeof (Elf_Internal_Rela),
3660          internal_reloc_compare);
3661
3662   cookie->rel = cookie->rels;
3663   cookie->relend = cookie->rels + sec->reloc_count;
3664
3665   for (offset = 0; offset < sec->size; offset += entry_size)
3666     {
3667       actual_offset = offset - removed_bytes;
3668
3669       /* The ...symbol_deleted_p function will skip over relocs but it
3670          won't adjust their offsets, so do that here.  */
3671       while (cookie->rel < cookie->relend
3672              && cookie->rel->r_offset < offset)
3673         {
3674           cookie->rel->r_offset -= removed_bytes;
3675           cookie->rel++;
3676         }
3677
3678       while (cookie->rel < cookie->relend
3679              && cookie->rel->r_offset == offset)
3680         {
3681           if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
3682             {
3683               /* Remove the table entry.  (If the reloc type is NONE, then
3684                  the entry has already been merged with another and deleted
3685                  during relaxation.)  */
3686               if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
3687                 {
3688                   /* Shift the contents up.  */
3689                   if (offset + entry_size < sec->size)
3690                     memmove (&contents[actual_offset],
3691                              &contents[actual_offset + entry_size],
3692                              sec->size - offset - entry_size);
3693                   removed_bytes += entry_size;
3694                 }
3695
3696               /* Remove this relocation.  */
3697               cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
3698             }
3699
3700           /* Adjust the relocation offset for previous removals.  This
3701              should not be done before calling ...symbol_deleted_p
3702              because it might mess up the offset comparisons there.
3703              Make sure the offset doesn't underflow in the case where
3704              the first entry is removed.  */
3705           if (cookie->rel->r_offset >= removed_bytes)
3706             cookie->rel->r_offset -= removed_bytes;
3707           else
3708             cookie->rel->r_offset = 0;
3709
3710           cookie->rel++;
3711         }
3712     }
3713
3714   if (removed_bytes != 0)
3715     {
3716       /* Adjust any remaining relocs (shouldn't be any).  */
3717       for (; cookie->rel < cookie->relend; cookie->rel++)
3718         {
3719           if (cookie->rel->r_offset >= removed_bytes)
3720             cookie->rel->r_offset -= removed_bytes;
3721           else
3722             cookie->rel->r_offset = 0;
3723         }
3724
3725       /* Clear the removed bytes.  */
3726       memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
3727
3728       pin_contents (sec, contents);
3729       pin_internal_relocs (sec, cookie->rels);
3730
3731       /* Shrink size.  */
3732       if (sec->rawsize == 0)
3733         sec->rawsize = sec->size;
3734       sec->size -= removed_bytes;
3735
3736       if (xtensa_is_littable_section (sec))
3737         {
3738           asection *sgotloc = elf_xtensa_hash_table (info)->sgotloc;
3739           if (sgotloc)
3740             sgotloc->size -= removed_bytes;
3741         }
3742     }
3743   else
3744     {
3745       release_contents (sec, contents);
3746       release_internal_relocs (sec, cookie->rels);
3747     }
3748
3749   return (removed_bytes != 0);
3750 }
3751
3752
3753 static bfd_boolean
3754 elf_xtensa_discard_info (bfd *abfd,
3755                          struct elf_reloc_cookie *cookie,
3756                          struct bfd_link_info *info)
3757 {
3758   asection *sec;
3759   bfd_boolean changed = FALSE;
3760
3761   for (sec = abfd->sections; sec != NULL; sec = sec->next)
3762     {
3763       if (xtensa_is_property_section (sec))
3764         {
3765           if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
3766             changed = TRUE;
3767         }
3768     }
3769
3770   return changed;
3771 }
3772
3773
3774 static bfd_boolean
3775 elf_xtensa_ignore_discarded_relocs (asection *sec)
3776 {
3777   return xtensa_is_property_section (sec);
3778 }
3779
3780
3781 static unsigned int
3782 elf_xtensa_action_discarded (asection *sec)
3783 {
3784   if (strcmp (".xt_except_table", sec->name) == 0)
3785     return 0;
3786
3787   if (strcmp (".xt_except_desc", sec->name) == 0)
3788     return 0;
3789
3790   return _bfd_elf_default_action_discarded (sec);
3791 }
3792
3793 \f
3794 /* Support for core dump NOTE sections.  */
3795
3796 static bfd_boolean
3797 elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3798 {
3799   int offset;
3800   unsigned int size;
3801
3802   /* The size for Xtensa is variable, so don't try to recognize the format
3803      based on the size.  Just assume this is GNU/Linux.  */
3804
3805   /* pr_cursig */
3806   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3807
3808   /* pr_pid */
3809   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
3810
3811   /* pr_reg */
3812   offset = 72;
3813   size = note->descsz - offset - 4;
3814
3815   /* Make a ".reg/999" section.  */
3816   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3817                                           size, note->descpos + offset);
3818 }
3819
3820
3821 static bfd_boolean
3822 elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3823 {
3824   switch (note->descsz)
3825     {
3826       default:
3827         return FALSE;
3828
3829       case 128:         /* GNU/Linux elf_prpsinfo */
3830         elf_tdata (abfd)->core->program
3831          = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
3832         elf_tdata (abfd)->core->command
3833          = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3834     }
3835
3836   /* Note that for some reason, a spurious space is tacked
3837      onto the end of the args in some (at least one anyway)
3838      implementations, so strip it off if it exists.  */
3839
3840   {
3841     char *command = elf_tdata (abfd)->core->command;
3842     int n = strlen (command);
3843
3844     if (0 < n && command[n - 1] == ' ')
3845       command[n - 1] = '\0';
3846   }
3847
3848   return TRUE;
3849 }
3850
3851 \f
3852 /* Generic Xtensa configurability stuff.  */
3853
3854 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3855 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3856 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3857 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3858 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3859 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3860 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3861 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3862
3863 static void
3864 init_call_opcodes (void)
3865 {
3866   if (callx0_op == XTENSA_UNDEFINED)
3867     {
3868       callx0_op  = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3869       callx4_op  = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3870       callx8_op  = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3871       callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3872       call0_op   = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3873       call4_op   = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3874       call8_op   = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3875       call12_op  = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3876     }
3877 }
3878
3879
3880 static bfd_boolean
3881 is_indirect_call_opcode (xtensa_opcode opcode)
3882 {
3883   init_call_opcodes ();
3884   return (opcode == callx0_op
3885           || opcode == callx4_op
3886           || opcode == callx8_op
3887           || opcode == callx12_op);
3888 }
3889
3890
3891 static bfd_boolean
3892 is_direct_call_opcode (xtensa_opcode opcode)
3893 {
3894   init_call_opcodes ();
3895   return (opcode == call0_op
3896           || opcode == call4_op
3897           || opcode == call8_op
3898           || opcode == call12_op);
3899 }
3900
3901
3902 static bfd_boolean
3903 is_windowed_call_opcode (xtensa_opcode opcode)
3904 {
3905   init_call_opcodes ();
3906   return (opcode == call4_op
3907           || opcode == call8_op
3908           || opcode == call12_op
3909           || opcode == callx4_op
3910           || opcode == callx8_op
3911           || opcode == callx12_op);
3912 }
3913
3914
3915 static bfd_boolean
3916 get_indirect_call_dest_reg (xtensa_opcode opcode, unsigned *pdst)
3917 {
3918   unsigned dst = (unsigned) -1;
3919
3920   init_call_opcodes ();
3921   if (opcode == callx0_op)
3922     dst = 0;
3923   else if (opcode == callx4_op)
3924     dst = 4;
3925   else if (opcode == callx8_op)
3926     dst = 8;
3927   else if (opcode == callx12_op)
3928     dst = 12;
3929
3930   if (dst == (unsigned) -1)
3931     return FALSE;
3932
3933   *pdst = dst;
3934   return TRUE;
3935 }
3936
3937
3938 static xtensa_opcode
3939 get_const16_opcode (void)
3940 {
3941   static bfd_boolean done_lookup = FALSE;
3942   static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3943   if (!done_lookup)
3944     {
3945       const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3946       done_lookup = TRUE;
3947     }
3948   return const16_opcode;
3949 }
3950
3951
3952 static xtensa_opcode
3953 get_l32r_opcode (void)
3954 {
3955   static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
3956   static bfd_boolean done_lookup = FALSE;
3957
3958   if (!done_lookup)
3959     {
3960       l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
3961       done_lookup = TRUE;
3962     }
3963   return l32r_opcode;
3964 }
3965
3966
3967 static bfd_vma
3968 l32r_offset (bfd_vma addr, bfd_vma pc)
3969 {
3970   bfd_vma offset;
3971
3972   offset = addr - ((pc+3) & -4);
3973   BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3974   offset = (signed int) offset >> 2;
3975   BFD_ASSERT ((signed int) offset >> 16 == -1);
3976   return offset;
3977 }
3978
3979
3980 static int
3981 get_relocation_opnd (xtensa_opcode opcode, int r_type)
3982 {
3983   xtensa_isa isa = xtensa_default_isa;
3984   int last_immed, last_opnd, opi;
3985
3986   if (opcode == XTENSA_UNDEFINED)
3987     return XTENSA_UNDEFINED;
3988
3989   /* Find the last visible PC-relative immediate operand for the opcode.
3990      If there are no PC-relative immediates, then choose the last visible
3991      immediate; otherwise, fail and return XTENSA_UNDEFINED.  */
3992   last_immed = XTENSA_UNDEFINED;
3993   last_opnd = xtensa_opcode_num_operands (isa, opcode);
3994   for (opi = last_opnd - 1; opi >= 0; opi--)
3995     {
3996       if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
3997         continue;
3998       if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
3999         {
4000           last_immed = opi;
4001           break;
4002         }
4003       if (last_immed == XTENSA_UNDEFINED
4004           && xtensa_operand_is_register (isa, opcode, opi) == 0)
4005         last_immed = opi;
4006     }
4007   if (last_immed < 0)
4008     return XTENSA_UNDEFINED;
4009
4010   /* If the operand number was specified in an old-style relocation,
4011      check for consistency with the operand computed above.  */
4012   if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
4013     {
4014       int reloc_opnd = r_type - R_XTENSA_OP0;
4015       if (reloc_opnd != last_immed)
4016         return XTENSA_UNDEFINED;
4017     }
4018
4019   return last_immed;
4020 }
4021
4022
4023 int
4024 get_relocation_slot (int r_type)
4025 {
4026   switch (r_type)
4027     {
4028     case R_XTENSA_OP0:
4029     case R_XTENSA_OP1:
4030     case R_XTENSA_OP2:
4031       return 0;
4032
4033     default:
4034       if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4035         return r_type - R_XTENSA_SLOT0_OP;
4036       if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4037         return r_type - R_XTENSA_SLOT0_ALT;
4038       break;
4039     }
4040
4041   return XTENSA_UNDEFINED;
4042 }
4043
4044
4045 /* Get the opcode for a relocation.  */
4046
4047 static xtensa_opcode
4048 get_relocation_opcode (bfd *abfd,
4049                        asection *sec,
4050                        bfd_byte *contents,
4051                        Elf_Internal_Rela *irel)
4052 {
4053   static xtensa_insnbuf ibuff = NULL;
4054   static xtensa_insnbuf sbuff = NULL;
4055   xtensa_isa isa = xtensa_default_isa;
4056   xtensa_format fmt;
4057   int slot;
4058
4059   if (contents == NULL)
4060     return XTENSA_UNDEFINED;
4061
4062   if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
4063     return XTENSA_UNDEFINED;
4064
4065   if (ibuff == NULL)
4066     {
4067       ibuff = xtensa_insnbuf_alloc (isa);
4068       sbuff = xtensa_insnbuf_alloc (isa);
4069     }
4070
4071   /* Decode the instruction.  */
4072   xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
4073                              sec->size - irel->r_offset);
4074   fmt = xtensa_format_decode (isa, ibuff);
4075   slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
4076   if (slot == XTENSA_UNDEFINED)
4077     return XTENSA_UNDEFINED;
4078   xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
4079   return xtensa_opcode_decode (isa, fmt, slot, sbuff);
4080 }
4081
4082
4083 bfd_boolean
4084 is_l32r_relocation (bfd *abfd,
4085                     asection *sec,
4086                     bfd_byte *contents,
4087                     Elf_Internal_Rela *irel)
4088 {
4089   xtensa_opcode opcode;
4090   if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
4091     return FALSE;
4092   opcode = get_relocation_opcode (abfd, sec, contents, irel);
4093   return (opcode == get_l32r_opcode ());
4094 }
4095
4096
4097 static bfd_size_type
4098 get_asm_simplify_size (bfd_byte *contents,
4099                        bfd_size_type content_len,
4100                        bfd_size_type offset)
4101 {
4102   bfd_size_type insnlen, size = 0;
4103
4104   /* Decode the size of the next two instructions.  */
4105   insnlen = insn_decode_len (contents, content_len, offset);
4106   if (insnlen == 0)
4107     return 0;
4108
4109   size += insnlen;
4110
4111   insnlen = insn_decode_len (contents, content_len, offset + size);
4112   if (insnlen == 0)
4113     return 0;
4114
4115   size += insnlen;
4116   return size;
4117 }
4118
4119
4120 bfd_boolean
4121 is_alt_relocation (int r_type)
4122 {
4123   return (r_type >= R_XTENSA_SLOT0_ALT
4124           && r_type <= R_XTENSA_SLOT14_ALT);
4125 }
4126
4127
4128 bfd_boolean
4129 is_operand_relocation (int r_type)
4130 {
4131   switch (r_type)
4132     {
4133     case R_XTENSA_OP0:
4134     case R_XTENSA_OP1:
4135     case R_XTENSA_OP2:
4136       return TRUE;
4137
4138     default:
4139       if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4140         return TRUE;
4141       if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4142         return TRUE;
4143       break;
4144     }
4145
4146   return FALSE;
4147 }
4148
4149
4150 #define MIN_INSN_LENGTH 2
4151
4152 /* Return 0 if it fails to decode.  */
4153
4154 bfd_size_type
4155 insn_decode_len (bfd_byte *contents,
4156                  bfd_size_type content_len,
4157                  bfd_size_type offset)
4158 {
4159   int insn_len;
4160   xtensa_isa isa = xtensa_default_isa;
4161   xtensa_format fmt;
4162   static xtensa_insnbuf ibuff = NULL;
4163
4164   if (offset + MIN_INSN_LENGTH > content_len)
4165     return 0;
4166
4167   if (ibuff == NULL)
4168     ibuff = xtensa_insnbuf_alloc (isa);
4169   xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
4170                              content_len - offset);
4171   fmt = xtensa_format_decode (isa, ibuff);
4172   if (fmt == XTENSA_UNDEFINED)
4173     return 0;
4174   insn_len = xtensa_format_length (isa, fmt);
4175   if (insn_len ==  XTENSA_UNDEFINED)
4176     return 0;
4177   return insn_len;
4178 }
4179
4180
4181 /* Decode the opcode for a single slot instruction.
4182    Return 0 if it fails to decode or the instruction is multi-slot.  */
4183
4184 xtensa_opcode
4185 insn_decode_opcode (bfd_byte *contents,
4186                     bfd_size_type content_len,
4187                     bfd_size_type offset,
4188                     int slot)
4189 {
4190   xtensa_isa isa = xtensa_default_isa;
4191   xtensa_format fmt;
4192   static xtensa_insnbuf insnbuf = NULL;
4193   static xtensa_insnbuf slotbuf = NULL;
4194
4195   if (offset + MIN_INSN_LENGTH > content_len)
4196     return XTENSA_UNDEFINED;
4197
4198   if (insnbuf == NULL)
4199     {
4200       insnbuf = xtensa_insnbuf_alloc (isa);
4201       slotbuf = xtensa_insnbuf_alloc (isa);
4202     }
4203
4204   xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4205                              content_len - offset);
4206   fmt = xtensa_format_decode (isa, insnbuf);
4207   if (fmt == XTENSA_UNDEFINED)
4208     return XTENSA_UNDEFINED;
4209
4210   if (slot >= xtensa_format_num_slots (isa, fmt))
4211     return XTENSA_UNDEFINED;
4212
4213   xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
4214   return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
4215 }
4216
4217
4218 /* The offset is the offset in the contents.
4219    The address is the address of that offset.  */
4220
4221 static bfd_boolean
4222 check_branch_target_aligned (bfd_byte *contents,
4223                              bfd_size_type content_length,
4224                              bfd_vma offset,
4225                              bfd_vma address)
4226 {
4227   bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
4228   if (insn_len == 0)
4229     return FALSE;
4230   return check_branch_target_aligned_address (address, insn_len);
4231 }
4232
4233
4234 static bfd_boolean
4235 check_loop_aligned (bfd_byte *contents,
4236                     bfd_size_type content_length,
4237                     bfd_vma offset,
4238                     bfd_vma address)
4239 {
4240   bfd_size_type loop_len, insn_len;
4241   xtensa_opcode opcode;
4242
4243   opcode = insn_decode_opcode (contents, content_length, offset, 0);
4244   if (opcode == XTENSA_UNDEFINED
4245       || xtensa_opcode_is_loop (xtensa_default_isa, opcode) != 1)
4246     {
4247       BFD_ASSERT (FALSE);
4248       return FALSE;
4249     }
4250
4251   loop_len = insn_decode_len (contents, content_length, offset);
4252   insn_len = insn_decode_len (contents, content_length, offset + loop_len);
4253   if (loop_len == 0 || insn_len == 0)
4254     {
4255       BFD_ASSERT (FALSE);
4256       return FALSE;
4257     }
4258
4259   return check_branch_target_aligned_address (address + loop_len, insn_len);
4260 }
4261
4262
4263 static bfd_boolean
4264 check_branch_target_aligned_address (bfd_vma addr, int len)
4265 {
4266   if (len == 8)
4267     return (addr % 8 == 0);
4268   return ((addr >> 2) == ((addr + len - 1) >> 2));
4269 }
4270
4271 \f
4272 /* Instruction widening and narrowing.  */
4273
4274 /* When FLIX is available we need to access certain instructions only
4275    when they are 16-bit or 24-bit instructions.  This table caches
4276    information about such instructions by walking through all the
4277    opcodes and finding the smallest single-slot format into which each
4278    can be encoded.  */
4279
4280 static xtensa_format *op_single_fmt_table = NULL;
4281
4282
4283 static void
4284 init_op_single_format_table (void)
4285 {
4286   xtensa_isa isa = xtensa_default_isa;
4287   xtensa_insnbuf ibuf;
4288   xtensa_opcode opcode;
4289   xtensa_format fmt;
4290   int num_opcodes;
4291
4292   if (op_single_fmt_table)
4293     return;
4294
4295   ibuf = xtensa_insnbuf_alloc (isa);
4296   num_opcodes = xtensa_isa_num_opcodes (isa);
4297
4298   op_single_fmt_table = (xtensa_format *)
4299     bfd_malloc (sizeof (xtensa_format) * num_opcodes);
4300   for (opcode = 0; opcode < num_opcodes; opcode++)
4301     {
4302       op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
4303       for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
4304         {
4305           if (xtensa_format_num_slots (isa, fmt) == 1
4306               && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
4307             {
4308               xtensa_opcode old_fmt = op_single_fmt_table[opcode];
4309               int fmt_length = xtensa_format_length (isa, fmt);
4310               if (old_fmt == XTENSA_UNDEFINED
4311                   || fmt_length < xtensa_format_length (isa, old_fmt))
4312                 op_single_fmt_table[opcode] = fmt;
4313             }
4314         }
4315     }
4316   xtensa_insnbuf_free (isa, ibuf);
4317 }
4318
4319
4320 static xtensa_format
4321 get_single_format (xtensa_opcode opcode)
4322 {
4323   init_op_single_format_table ();
4324   return op_single_fmt_table[opcode];
4325 }
4326
4327
4328 /* For the set of narrowable instructions we do NOT include the
4329    narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4330    involved during linker relaxation that may require these to
4331    re-expand in some conditions.  Also, the narrowing "or" -> mov.n
4332    requires special case code to ensure it only works when op1 == op2.  */
4333
4334 struct string_pair
4335 {
4336   const char *wide;
4337   const char *narrow;
4338 };
4339
4340 struct string_pair narrowable[] =
4341 {
4342   { "add", "add.n" },
4343   { "addi", "addi.n" },
4344   { "addmi", "addi.n" },
4345   { "l32i", "l32i.n" },
4346   { "movi", "movi.n" },
4347   { "ret", "ret.n" },
4348   { "retw", "retw.n" },
4349   { "s32i", "s32i.n" },
4350   { "or", "mov.n" } /* special case only when op1 == op2 */
4351 };
4352
4353 struct string_pair widenable[] =
4354 {
4355   { "add", "add.n" },
4356   { "addi", "addi.n" },
4357   { "addmi", "addi.n" },
4358   { "beqz", "beqz.n" },
4359   { "bnez", "bnez.n" },
4360   { "l32i", "l32i.n" },
4361   { "movi", "movi.n" },
4362   { "ret", "ret.n" },
4363   { "retw", "retw.n" },
4364   { "s32i", "s32i.n" },
4365   { "or", "mov.n" } /* special case only when op1 == op2 */
4366 };
4367
4368
4369 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4370    3-byte instruction to a 2-byte "density" instruction.  If it is valid,
4371    return the instruction buffer holding the narrow instruction.  Otherwise,
4372    return 0.  The set of valid narrowing are specified by a string table
4373    but require some special case operand checks in some cases.  */
4374
4375 static xtensa_insnbuf
4376 can_narrow_instruction (xtensa_insnbuf slotbuf,
4377                         xtensa_format fmt,
4378                         xtensa_opcode opcode)
4379 {
4380   xtensa_isa isa = xtensa_default_isa;
4381   xtensa_format o_fmt;
4382   unsigned opi;
4383
4384   static xtensa_insnbuf o_insnbuf = NULL;
4385   static xtensa_insnbuf o_slotbuf = NULL;
4386
4387   if (o_insnbuf == NULL)
4388     {
4389       o_insnbuf = xtensa_insnbuf_alloc (isa);
4390       o_slotbuf = xtensa_insnbuf_alloc (isa);
4391     }
4392
4393   for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); opi++)
4394     {
4395       bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
4396
4397       if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
4398         {
4399           uint32 value, newval;
4400           int i, operand_count, o_operand_count;
4401           xtensa_opcode o_opcode;
4402
4403           /* Address does not matter in this case.  We might need to
4404              fix it to handle branches/jumps.  */
4405           bfd_vma self_address = 0;
4406
4407           o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
4408           if (o_opcode == XTENSA_UNDEFINED)
4409             return 0;
4410           o_fmt = get_single_format (o_opcode);
4411           if (o_fmt == XTENSA_UNDEFINED)
4412             return 0;
4413
4414           if (xtensa_format_length (isa, fmt) != 3
4415               || xtensa_format_length (isa, o_fmt) != 2)
4416             return 0;
4417
4418           xtensa_format_encode (isa, o_fmt, o_insnbuf);
4419           operand_count = xtensa_opcode_num_operands (isa, opcode);
4420           o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4421
4422           if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4423             return 0;
4424
4425           if (!is_or)
4426             {
4427               if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4428                 return 0;
4429             }
4430           else
4431             {
4432               uint32 rawval0, rawval1, rawval2;
4433
4434               if (o_operand_count + 1 != operand_count
4435                   || xtensa_operand_get_field (isa, opcode, 0,
4436                                                fmt, 0, slotbuf, &rawval0) != 0
4437                   || xtensa_operand_get_field (isa, opcode, 1,
4438                                                fmt, 0, slotbuf, &rawval1) != 0
4439                   || xtensa_operand_get_field (isa, opcode, 2,
4440                                                fmt, 0, slotbuf, &rawval2) != 0
4441                   || rawval1 != rawval2
4442                   || rawval0 == rawval1 /* it is a nop */)
4443                 return 0;
4444             }
4445
4446           for (i = 0; i < o_operand_count; ++i)
4447             {
4448               if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
4449                                             slotbuf, &value)
4450                   || xtensa_operand_decode (isa, opcode, i, &value))
4451                 return 0;
4452
4453               /* PC-relative branches need adjustment, but
4454                  the PC-rel operand will always have a relocation.  */
4455               newval = value;
4456               if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4457                                            self_address)
4458                   || xtensa_operand_encode (isa, o_opcode, i, &newval)
4459                   || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4460                                                o_slotbuf, newval))
4461                 return 0;
4462             }
4463
4464           if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4465             return 0;
4466
4467           return o_insnbuf;
4468         }
4469     }
4470   return 0;
4471 }
4472
4473
4474 /* Attempt to narrow an instruction.  If the narrowing is valid, perform
4475    the action in-place directly into the contents and return TRUE.  Otherwise,
4476    the return value is FALSE and the contents are not modified.  */
4477
4478 static bfd_boolean
4479 narrow_instruction (bfd_byte *contents,
4480                     bfd_size_type content_length,
4481                     bfd_size_type offset)
4482 {
4483   xtensa_opcode opcode;
4484   bfd_size_type insn_len;
4485   xtensa_isa isa = xtensa_default_isa;
4486   xtensa_format fmt;
4487   xtensa_insnbuf o_insnbuf;
4488
4489   static xtensa_insnbuf insnbuf = NULL;
4490   static xtensa_insnbuf slotbuf = NULL;
4491
4492   if (insnbuf == NULL)
4493     {
4494       insnbuf = xtensa_insnbuf_alloc (isa);
4495       slotbuf = xtensa_insnbuf_alloc (isa);
4496     }
4497
4498   BFD_ASSERT (offset < content_length);
4499
4500   if (content_length < 2)
4501     return FALSE;
4502
4503   /* We will hand-code a few of these for a little while.
4504      These have all been specified in the assembler aleady.  */
4505   xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4506                              content_length - offset);
4507   fmt = xtensa_format_decode (isa, insnbuf);
4508   if (xtensa_format_num_slots (isa, fmt) != 1)
4509     return FALSE;
4510
4511   if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4512     return FALSE;
4513
4514   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4515   if (opcode == XTENSA_UNDEFINED)
4516     return FALSE;
4517   insn_len = xtensa_format_length (isa, fmt);
4518   if (insn_len > content_length)
4519     return FALSE;
4520
4521   o_insnbuf = can_narrow_instruction (slotbuf, fmt, opcode);
4522   if (o_insnbuf)
4523     {
4524       xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4525                                content_length - offset);
4526       return TRUE;
4527     }
4528
4529   return FALSE;
4530 }
4531
4532
4533 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4534    "density" instruction to a standard 3-byte instruction.  If it is valid,
4535    return the instruction buffer holding the wide instruction.  Otherwise,
4536    return 0.  The set of valid widenings are specified by a string table
4537    but require some special case operand checks in some cases.  */
4538
4539 static xtensa_insnbuf
4540 can_widen_instruction (xtensa_insnbuf slotbuf,
4541                        xtensa_format fmt,
4542                        xtensa_opcode opcode)
4543 {
4544   xtensa_isa isa = xtensa_default_isa;
4545   xtensa_format o_fmt;
4546   unsigned opi;
4547
4548   static xtensa_insnbuf o_insnbuf = NULL;
4549   static xtensa_insnbuf o_slotbuf = NULL;
4550
4551   if (o_insnbuf == NULL)
4552     {
4553       o_insnbuf = xtensa_insnbuf_alloc (isa);
4554       o_slotbuf = xtensa_insnbuf_alloc (isa);
4555     }
4556
4557   for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); opi++)
4558     {
4559       bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
4560       bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
4561                                || strcmp ("bnez", widenable[opi].wide) == 0);
4562
4563       if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
4564         {
4565           uint32 value, newval;
4566           int i, operand_count, o_operand_count, check_operand_count;
4567           xtensa_opcode o_opcode;
4568
4569           /* Address does not matter in this case.  We might need to fix it
4570              to handle branches/jumps.  */
4571           bfd_vma self_address = 0;
4572
4573           o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
4574           if (o_opcode == XTENSA_UNDEFINED)
4575             return 0;
4576           o_fmt = get_single_format (o_opcode);
4577           if (o_fmt == XTENSA_UNDEFINED)
4578             return 0;
4579
4580           if (xtensa_format_length (isa, fmt) != 2
4581               || xtensa_format_length (isa, o_fmt) != 3)
4582             return 0;
4583
4584           xtensa_format_encode (isa, o_fmt, o_insnbuf);
4585           operand_count = xtensa_opcode_num_operands (isa, opcode);
4586           o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4587           check_operand_count = o_operand_count;
4588
4589           if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4590             return 0;
4591
4592           if (!is_or)
4593             {
4594               if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4595                 return 0;
4596             }
4597           else
4598             {
4599               uint32 rawval0, rawval1;
4600
4601               if (o_operand_count != operand_count + 1
4602                   || xtensa_operand_get_field (isa, opcode, 0,
4603                                                fmt, 0, slotbuf, &rawval0) != 0
4604                   || xtensa_operand_get_field (isa, opcode, 1,
4605                                                fmt, 0, slotbuf, &rawval1) != 0
4606                   || rawval0 == rawval1 /* it is a nop */)
4607                 return 0;
4608             }
4609           if (is_branch)
4610             check_operand_count--;
4611
4612           for (i = 0; i < check_operand_count; i++)
4613             {
4614               int new_i = i;
4615               if (is_or && i == o_operand_count - 1)
4616                 new_i = i - 1;
4617               if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
4618                                             slotbuf, &value)
4619                   || xtensa_operand_decode (isa, opcode, new_i, &value))
4620                 return 0;
4621
4622               /* PC-relative branches need adjustment, but
4623                  the PC-rel operand will always have a relocation.  */
4624               newval = value;
4625               if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4626                                            self_address)
4627                   || xtensa_operand_encode (isa, o_opcode, i, &newval)
4628                   || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4629                                                o_slotbuf, newval))
4630                 return 0;
4631             }
4632
4633           if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4634             return 0;
4635
4636           return o_insnbuf;
4637         }
4638     }
4639   return 0;
4640 }
4641
4642
4643 /* Attempt to widen an instruction.  If the widening is valid, perform
4644    the action in-place directly into the contents and return TRUE.  Otherwise,
4645    the return value is FALSE and the contents are not modified.  */
4646
4647 static bfd_boolean
4648 widen_instruction (bfd_byte *contents,
4649                    bfd_size_type content_length,
4650                    bfd_size_type offset)
4651 {
4652   xtensa_opcode opcode;
4653   bfd_size_type insn_len;
4654   xtensa_isa isa = xtensa_default_isa;
4655   xtensa_format fmt;
4656   xtensa_insnbuf o_insnbuf;
4657
4658   static xtensa_insnbuf insnbuf = NULL;
4659   static xtensa_insnbuf slotbuf = NULL;
4660
4661   if (insnbuf == NULL)
4662     {
4663       insnbuf = xtensa_insnbuf_alloc (isa);
4664       slotbuf = xtensa_insnbuf_alloc (isa);
4665     }
4666
4667   BFD_ASSERT (offset < content_length);
4668
4669   if (content_length < 2)
4670     return FALSE;
4671
4672   /* We will hand-code a few of these for a little while.
4673      These have all been specified in the assembler aleady.  */
4674   xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4675                              content_length - offset);
4676   fmt = xtensa_format_decode (isa, insnbuf);
4677   if (xtensa_format_num_slots (isa, fmt) != 1)
4678     return FALSE;
4679
4680   if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4681     return FALSE;
4682
4683   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4684   if (opcode == XTENSA_UNDEFINED)
4685     return FALSE;
4686   insn_len = xtensa_format_length (isa, fmt);
4687   if (insn_len > content_length)
4688     return FALSE;
4689
4690   o_insnbuf = can_widen_instruction (slotbuf, fmt, opcode);
4691   if (o_insnbuf)
4692     {
4693       xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4694                                content_length - offset);
4695       return TRUE;
4696     }
4697   return FALSE;
4698 }
4699
4700 \f
4701 /* Code for transforming CALLs at link-time.  */
4702
4703 static bfd_reloc_status_type
4704 elf_xtensa_do_asm_simplify (bfd_byte *contents,
4705                             bfd_vma address,
4706                             bfd_vma content_length,
4707                             char **error_message)
4708 {
4709   static xtensa_insnbuf insnbuf = NULL;
4710   static xtensa_insnbuf slotbuf = NULL;
4711   xtensa_format core_format = XTENSA_UNDEFINED;
4712   xtensa_opcode opcode;
4713   xtensa_opcode direct_call_opcode;
4714   xtensa_isa isa = xtensa_default_isa;
4715   bfd_byte *chbuf = contents + address;
4716   int opn;
4717
4718   if (insnbuf == NULL)
4719     {
4720       insnbuf = xtensa_insnbuf_alloc (isa);
4721       slotbuf = xtensa_insnbuf_alloc (isa);
4722     }
4723
4724   if (content_length < address)
4725     {
4726       *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4727       return bfd_reloc_other;
4728     }
4729
4730   opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
4731   direct_call_opcode = swap_callx_for_call_opcode (opcode);
4732   if (direct_call_opcode == XTENSA_UNDEFINED)
4733     {
4734       *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4735       return bfd_reloc_other;
4736     }
4737
4738   /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset.  */
4739   core_format = xtensa_format_lookup (isa, "x24");
4740   opcode = xtensa_opcode_lookup (isa, "or");
4741   xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
4742   for (opn = 0; opn < 3; opn++)
4743     {
4744       uint32 regno = 1;
4745       xtensa_operand_encode (isa, opcode, opn, &regno);
4746       xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
4747                                 slotbuf, regno);
4748     }
4749   xtensa_format_encode (isa, core_format, insnbuf);
4750   xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4751   xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
4752
4753   /* Assemble a CALL ("callN 0") into the 3 byte offset.  */
4754   xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
4755   xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
4756
4757   xtensa_format_encode (isa, core_format, insnbuf);
4758   xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4759   xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
4760                            content_length - address - 3);
4761
4762   return bfd_reloc_ok;
4763 }
4764
4765
4766 static bfd_reloc_status_type
4767 contract_asm_expansion (bfd_byte *contents,
4768                         bfd_vma content_length,
4769                         Elf_Internal_Rela *irel,
4770                         char **error_message)
4771 {
4772   bfd_reloc_status_type retval =
4773     elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
4774                                 error_message);
4775
4776   if (retval != bfd_reloc_ok)
4777     return bfd_reloc_dangerous;
4778
4779   /* Update the irel->r_offset field so that the right immediate and
4780      the right instruction are modified during the relocation.  */
4781   irel->r_offset += 3;
4782   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
4783   return bfd_reloc_ok;
4784 }
4785
4786
4787 static xtensa_opcode
4788 swap_callx_for_call_opcode (xtensa_opcode opcode)
4789 {
4790   init_call_opcodes ();
4791
4792   if (opcode == callx0_op) return call0_op;
4793   if (opcode == callx4_op) return call4_op;
4794   if (opcode == callx8_op) return call8_op;
4795   if (opcode == callx12_op) return call12_op;
4796
4797   /* Return XTENSA_UNDEFINED if the opcode is not an indirect call.  */
4798   return XTENSA_UNDEFINED;
4799 }
4800
4801
4802 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4803    CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4804    If not, return XTENSA_UNDEFINED.  */
4805
4806 #define L32R_TARGET_REG_OPERAND 0
4807 #define CONST16_TARGET_REG_OPERAND 0
4808 #define CALLN_SOURCE_OPERAND 0
4809
4810 static xtensa_opcode
4811 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
4812 {
4813   static xtensa_insnbuf insnbuf = NULL;
4814   static xtensa_insnbuf slotbuf = NULL;
4815   xtensa_format fmt;
4816   xtensa_opcode opcode;
4817   xtensa_isa isa = xtensa_default_isa;
4818   uint32 regno, const16_regno, call_regno;
4819   int offset = 0;
4820
4821   if (insnbuf == NULL)
4822     {
4823       insnbuf = xtensa_insnbuf_alloc (isa);
4824       slotbuf = xtensa_insnbuf_alloc (isa);
4825     }
4826
4827   xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
4828   fmt = xtensa_format_decode (isa, insnbuf);
4829   if (fmt == XTENSA_UNDEFINED
4830       || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4831     return XTENSA_UNDEFINED;
4832
4833   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4834   if (opcode == XTENSA_UNDEFINED)
4835     return XTENSA_UNDEFINED;
4836
4837   if (opcode == get_l32r_opcode ())
4838     {
4839       if (p_uses_l32r)
4840         *p_uses_l32r = TRUE;
4841       if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
4842                                     fmt, 0, slotbuf, &regno)
4843           || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
4844                                     &regno))
4845         return XTENSA_UNDEFINED;
4846     }
4847   else if (opcode == get_const16_opcode ())
4848     {
4849       if (p_uses_l32r)
4850         *p_uses_l32r = FALSE;
4851       if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4852                                     fmt, 0, slotbuf, &regno)
4853           || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4854                                     &regno))
4855         return XTENSA_UNDEFINED;
4856
4857       /* Check that the next instruction is also CONST16.  */
4858       offset += xtensa_format_length (isa, fmt);
4859       xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4860       fmt = xtensa_format_decode (isa, insnbuf);
4861       if (fmt == XTENSA_UNDEFINED
4862           || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4863         return XTENSA_UNDEFINED;
4864       opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4865       if (opcode != get_const16_opcode ())
4866         return XTENSA_UNDEFINED;
4867
4868       if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4869                                     fmt, 0, slotbuf, &const16_regno)
4870           || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4871                                     &const16_regno)
4872           || const16_regno != regno)
4873         return XTENSA_UNDEFINED;
4874     }
4875   else
4876     return XTENSA_UNDEFINED;
4877
4878   /* Next instruction should be an CALLXn with operand 0 == regno.  */
4879   offset += xtensa_format_length (isa, fmt);
4880   xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4881   fmt = xtensa_format_decode (isa, insnbuf);
4882   if (fmt == XTENSA_UNDEFINED
4883       || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4884     return XTENSA_UNDEFINED;
4885   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4886   if (opcode == XTENSA_UNDEFINED
4887       || !is_indirect_call_opcode (opcode))
4888     return XTENSA_UNDEFINED;
4889
4890   if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4891                                 fmt, 0, slotbuf, &call_regno)
4892       || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4893                                 &call_regno))
4894     return XTENSA_UNDEFINED;
4895
4896   if (call_regno != regno)
4897     return XTENSA_UNDEFINED;
4898
4899   return opcode;
4900 }
4901
4902 \f
4903 /* Data structures used during relaxation.  */
4904
4905 /* r_reloc: relocation values.  */
4906
4907 /* Through the relaxation process, we need to keep track of the values
4908    that will result from evaluating relocations.  The standard ELF
4909    relocation structure is not sufficient for this purpose because we're
4910    operating on multiple input files at once, so we need to know which
4911    input file a relocation refers to.  The r_reloc structure thus
4912    records both the input file (bfd) and ELF relocation.
4913
4914    For efficiency, an r_reloc also contains a "target_offset" field to
4915    cache the target-section-relative offset value that is represented by
4916    the relocation.
4917
4918    The r_reloc also contains a virtual offset that allows multiple
4919    inserted literals to be placed at the same "address" with
4920    different offsets.  */
4921
4922 typedef struct r_reloc_struct r_reloc;
4923
4924 struct r_reloc_struct
4925 {
4926   bfd *abfd;
4927   Elf_Internal_Rela rela;
4928   bfd_vma target_offset;
4929   bfd_vma virtual_offset;
4930 };
4931
4932
4933 /* The r_reloc structure is included by value in literal_value, but not
4934    every literal_value has an associated relocation -- some are simple
4935    constants.  In such cases, we set all the fields in the r_reloc
4936    struct to zero.  The r_reloc_is_const function should be used to
4937    detect this case.  */
4938
4939 static bfd_boolean
4940 r_reloc_is_const (const r_reloc *r_rel)
4941 {
4942   return (r_rel->abfd == NULL);
4943 }
4944
4945
4946 static bfd_vma
4947 r_reloc_get_target_offset (const r_reloc *r_rel)
4948 {
4949   bfd_vma target_offset;
4950   unsigned long r_symndx;
4951
4952   BFD_ASSERT (!r_reloc_is_const (r_rel));
4953   r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4954   target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4955   return (target_offset + r_rel->rela.r_addend);
4956 }
4957
4958
4959 static struct elf_link_hash_entry *
4960 r_reloc_get_hash_entry (const r_reloc *r_rel)
4961 {
4962   unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4963   return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4964 }
4965
4966
4967 static asection *
4968 r_reloc_get_section (const r_reloc *r_rel)
4969 {
4970   unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4971   return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4972 }
4973
4974
4975 static bfd_boolean
4976 r_reloc_is_defined (const r_reloc *r_rel)
4977 {
4978   asection *sec;
4979   if (r_rel == NULL)
4980     return FALSE;
4981
4982   sec = r_reloc_get_section (r_rel);
4983   if (sec == bfd_abs_section_ptr
4984       || sec == bfd_com_section_ptr
4985       || sec == bfd_und_section_ptr)
4986     return FALSE;
4987   return TRUE;
4988 }
4989
4990
4991 static void
4992 r_reloc_init (r_reloc *r_rel,
4993               bfd *abfd,
4994               Elf_Internal_Rela *irel,
4995               bfd_byte *contents,
4996               bfd_size_type content_length)
4997 {
4998   int r_type;
4999   reloc_howto_type *howto;
5000
5001   if (irel)
5002     {
5003       r_rel->rela = *irel;
5004       r_rel->abfd = abfd;
5005       r_rel->target_offset = r_reloc_get_target_offset (r_rel);
5006       r_rel->virtual_offset = 0;
5007       r_type = ELF32_R_TYPE (r_rel->rela.r_info);
5008       howto = &elf_howto_table[r_type];
5009       if (howto->partial_inplace)
5010         {
5011           bfd_vma inplace_val;
5012           BFD_ASSERT (r_rel->rela.r_offset < content_length);
5013
5014           inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
5015           r_rel->target_offset += inplace_val;
5016         }
5017     }
5018   else
5019     memset (r_rel, 0, sizeof (r_reloc));
5020 }
5021
5022
5023 #if DEBUG
5024
5025 static void
5026 print_r_reloc (FILE *fp, const r_reloc *r_rel)
5027 {
5028   if (r_reloc_is_defined (r_rel))
5029     {
5030       asection *sec = r_reloc_get_section (r_rel);
5031       fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
5032     }
5033   else if (r_reloc_get_hash_entry (r_rel))
5034     fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
5035   else
5036     fprintf (fp, " ?? + ");
5037
5038   fprintf_vma (fp, r_rel->target_offset);
5039   if (r_rel->virtual_offset)
5040     {
5041       fprintf (fp, " + ");
5042       fprintf_vma (fp, r_rel->virtual_offset);
5043     }
5044
5045   fprintf (fp, ")");
5046 }
5047
5048 #endif /* DEBUG */
5049
5050 \f
5051 /* source_reloc: relocations that reference literals.  */
5052
5053 /* To determine whether literals can be coalesced, we need to first
5054    record all the relocations that reference the literals.  The
5055    source_reloc structure below is used for this purpose.  The
5056    source_reloc entries are kept in a per-literal-section array, sorted
5057    by offset within the literal section (i.e., target offset).
5058
5059    The source_sec and r_rel.rela.r_offset fields identify the source of
5060    the relocation.  The r_rel field records the relocation value, i.e.,
5061    the offset of the literal being referenced.  The opnd field is needed
5062    to determine the range of the immediate field to which the relocation
5063    applies, so we can determine whether another literal with the same
5064    value is within range.  The is_null field is true when the relocation
5065    is being removed (e.g., when an L32R is being removed due to a CALLX
5066    that is converted to a direct CALL).  */
5067
5068 typedef struct source_reloc_struct source_reloc;
5069
5070 struct source_reloc_struct
5071 {
5072   asection *source_sec;
5073   r_reloc r_rel;
5074   xtensa_opcode opcode;
5075   int opnd;
5076   bfd_boolean is_null;
5077   bfd_boolean is_abs_literal;
5078 };
5079
5080
5081 static void
5082 init_source_reloc (source_reloc *reloc,
5083                    asection *source_sec,
5084                    const r_reloc *r_rel,
5085                    xtensa_opcode opcode,
5086                    int opnd,
5087                    bfd_boolean is_abs_literal)
5088 {
5089   reloc->source_sec = source_sec;
5090   reloc->r_rel = *r_rel;
5091   reloc->opcode = opcode;
5092   reloc->opnd = opnd;
5093   reloc->is_null = FALSE;
5094   reloc->is_abs_literal = is_abs_literal;
5095 }
5096
5097
5098 /* Find the source_reloc for a particular source offset and relocation
5099    type.  Note that the array is sorted by _target_ offset, so this is
5100    just a linear search.  */
5101
5102 static source_reloc *
5103 find_source_reloc (source_reloc *src_relocs,
5104                    int src_count,
5105                    asection *sec,
5106                    Elf_Internal_Rela *irel)
5107 {
5108   int i;
5109
5110   for (i = 0; i < src_count; i++)
5111     {
5112       if (src_relocs[i].source_sec == sec
5113           && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
5114           && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
5115               == ELF32_R_TYPE (irel->r_info)))
5116         return &src_relocs[i];
5117     }
5118
5119   return NULL;
5120 }
5121
5122
5123 static int
5124 source_reloc_compare (const void *ap, const void *bp)
5125 {
5126   const source_reloc *a = (const source_reloc *) ap;
5127   const source_reloc *b = (const source_reloc *) bp;
5128
5129   if (a->r_rel.target_offset != b->r_rel.target_offset)
5130     return (a->r_rel.target_offset - b->r_rel.target_offset);
5131
5132   /* We don't need to sort on these criteria for correctness,
5133      but enforcing a more strict ordering prevents unstable qsort
5134      from behaving differently with different implementations.
5135      Without the code below we get correct but different results
5136      on Solaris 2.7 and 2.8.  We would like to always produce the
5137      same results no matter the host. */
5138
5139   if ((!a->is_null) - (!b->is_null))
5140     return ((!a->is_null) - (!b->is_null));
5141   return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
5142 }
5143
5144 \f
5145 /* Literal values and value hash tables.  */
5146
5147 /* Literals with the same value can be coalesced.  The literal_value
5148    structure records the value of a literal: the "r_rel" field holds the
5149    information from the relocation on the literal (if there is one) and
5150    the "value" field holds the contents of the literal word itself.
5151
5152    The value_map structure records a literal value along with the
5153    location of a literal holding that value.  The value_map hash table
5154    is indexed by the literal value, so that we can quickly check if a
5155    particular literal value has been seen before and is thus a candidate
5156    for coalescing.  */
5157
5158 typedef struct literal_value_struct literal_value;
5159 typedef struct value_map_struct value_map;
5160 typedef struct value_map_hash_table_struct value_map_hash_table;
5161
5162 struct literal_value_struct
5163 {
5164   r_reloc r_rel;
5165   unsigned long value;
5166   bfd_boolean is_abs_literal;
5167 };
5168
5169 struct value_map_struct
5170 {
5171   literal_value val;                    /* The literal value.  */
5172   r_reloc loc;                          /* Location of the literal.  */
5173   value_map *next;
5174 };
5175
5176 struct value_map_hash_table_struct
5177 {
5178   unsigned bucket_count;
5179   value_map **buckets;
5180   unsigned count;
5181   bfd_boolean has_last_loc;
5182   r_reloc last_loc;
5183 };
5184
5185
5186 static void
5187 init_literal_value (literal_value *lit,
5188                     const r_reloc *r_rel,
5189                     unsigned long value,
5190                     bfd_boolean is_abs_literal)
5191 {
5192   lit->r_rel = *r_rel;
5193   lit->value = value;
5194   lit->is_abs_literal = is_abs_literal;
5195 }
5196
5197
5198 static bfd_boolean
5199 literal_value_equal (const literal_value *src1,
5200                      const literal_value *src2,
5201                      bfd_boolean final_static_link)
5202 {
5203   struct elf_link_hash_entry *h1, *h2;
5204
5205   if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
5206     return FALSE;
5207
5208   if (r_reloc_is_const (&src1->r_rel))
5209     return (src1->value == src2->value);
5210
5211   if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
5212       != ELF32_R_TYPE (src2->r_rel.rela.r_info))
5213     return FALSE;
5214
5215   if (src1->r_rel.target_offset != src2->r_rel.target_offset)
5216     return FALSE;
5217
5218   if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
5219     return FALSE;
5220
5221   if (src1->value != src2->value)
5222     return FALSE;
5223
5224   /* Now check for the same section (if defined) or the same elf_hash
5225      (if undefined or weak).  */
5226   h1 = r_reloc_get_hash_entry (&src1->r_rel);
5227   h2 = r_reloc_get_hash_entry (&src2->r_rel);
5228   if (r_reloc_is_defined (&src1->r_rel)
5229       && (final_static_link
5230           || ((!h1 || h1->root.type != bfd_link_hash_defweak)
5231               && (!h2 || h2->root.type != bfd_link_hash_defweak))))
5232     {
5233       if (r_reloc_get_section (&src1->r_rel)
5234           != r_reloc_get_section (&src2->r_rel))
5235         return FALSE;
5236     }
5237   else
5238     {
5239       /* Require that the hash entries (i.e., symbols) be identical.  */
5240       if (h1 != h2 || h1 == 0)
5241         return FALSE;
5242     }
5243
5244   if (src1->is_abs_literal != src2->is_abs_literal)
5245     return FALSE;
5246
5247   return TRUE;
5248 }
5249
5250
5251 /* Must be power of 2.  */
5252 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5253
5254 static value_map_hash_table *
5255 value_map_hash_table_init (void)
5256 {
5257   value_map_hash_table *values;
5258
5259   values = (value_map_hash_table *)
5260     bfd_zmalloc (sizeof (value_map_hash_table));
5261   values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
5262   values->count = 0;
5263   values->buckets = (value_map **)
5264     bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
5265   if (values->buckets == NULL)
5266     {
5267       free (values);
5268       return NULL;
5269     }
5270   values->has_last_loc = FALSE;
5271
5272   return values;
5273 }
5274
5275
5276 static void
5277 value_map_hash_table_delete (value_map_hash_table *table)
5278 {
5279   free (table->buckets);
5280   free (table);
5281 }
5282
5283
5284 static unsigned
5285 hash_bfd_vma (bfd_vma val)
5286 {
5287   return (val >> 2) + (val >> 10);
5288 }
5289
5290
5291 static unsigned
5292 literal_value_hash (const literal_value *src)
5293 {
5294   unsigned hash_val;
5295
5296   hash_val = hash_bfd_vma (src->value);
5297   if (!r_reloc_is_const (&src->r_rel))
5298     {
5299       void *sec_or_hash;
5300
5301       hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
5302       hash_val += hash_bfd_vma (src->r_rel.target_offset);
5303       hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
5304
5305       /* Now check for the same section and the same elf_hash.  */
5306       if (r_reloc_is_defined (&src->r_rel))
5307         sec_or_hash = r_reloc_get_section (&src->r_rel);
5308       else
5309         sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
5310       hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
5311     }
5312   return hash_val;
5313 }
5314
5315
5316 /* Check if the specified literal_value has been seen before.  */
5317
5318 static value_map *
5319 value_map_get_cached_value (value_map_hash_table *map,
5320                             const literal_value *val,
5321                             bfd_boolean final_static_link)
5322 {
5323   value_map *map_e;
5324   value_map *bucket;
5325   unsigned idx;
5326
5327   idx = literal_value_hash (val);
5328   idx = idx & (map->bucket_count - 1);
5329   bucket = map->buckets[idx];
5330   for (map_e = bucket; map_e; map_e = map_e->next)
5331     {
5332       if (literal_value_equal (&map_e->val, val, final_static_link))
5333         return map_e;
5334     }
5335   return NULL;
5336 }
5337
5338
5339 /* Record a new literal value.  It is illegal to call this if VALUE
5340    already has an entry here.  */
5341
5342 static value_map *
5343 add_value_map (value_map_hash_table *map,
5344                const literal_value *val,
5345                const r_reloc *loc,
5346                bfd_boolean final_static_link)
5347 {
5348   value_map **bucket_p;
5349   unsigned idx;
5350
5351   value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
5352   if (val_e == NULL)
5353     {
5354       bfd_set_error (bfd_error_no_memory);
5355       return NULL;
5356     }
5357
5358   BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
5359   val_e->val = *val;
5360   val_e->loc = *loc;
5361
5362   idx = literal_value_hash (val);
5363   idx = idx & (map->bucket_count - 1);
5364   bucket_p = &map->buckets[idx];
5365
5366   val_e->next = *bucket_p;
5367   *bucket_p = val_e;
5368   map->count++;
5369   /* FIXME: Consider resizing the hash table if we get too many entries.  */
5370
5371   return val_e;
5372 }
5373
5374 \f
5375 /* Lists of text actions (ta_) for narrowing, widening, longcall
5376    conversion, space fill, code & literal removal, etc.  */
5377
5378 /* The following text actions are generated:
5379
5380    "ta_remove_insn"         remove an instruction or instructions
5381    "ta_remove_longcall"     convert longcall to call
5382    "ta_convert_longcall"    convert longcall to nop/call
5383    "ta_narrow_insn"         narrow a wide instruction
5384    "ta_widen"               widen a narrow instruction
5385    "ta_fill"                add fill or remove fill
5386       removed < 0 is a fill; branches to the fill address will be
5387         changed to address + fill size (e.g., address - removed)
5388       removed >= 0 branches to the fill address will stay unchanged
5389    "ta_remove_literal"      remove a literal; this action is
5390                             indicated when a literal is removed
5391                             or replaced.
5392    "ta_add_literal"         insert a new literal; this action is
5393                             indicated when a literal has been moved.
5394                             It may use a virtual_offset because
5395                             multiple literals can be placed at the
5396                             same location.
5397
5398    For each of these text actions, we also record the number of bytes
5399    removed by performing the text action.  In the case of a "ta_widen"
5400    or a "ta_fill" that adds space, the removed_bytes will be negative.  */
5401
5402 typedef struct text_action_struct text_action;
5403 typedef struct text_action_list_struct text_action_list;
5404 typedef enum text_action_enum_t text_action_t;
5405
5406 enum text_action_enum_t
5407 {
5408   ta_none,
5409   ta_remove_insn,        /* removed = -size */
5410   ta_remove_longcall,    /* removed = -size */
5411   ta_convert_longcall,   /* removed = 0 */
5412   ta_narrow_insn,        /* removed = -1 */
5413   ta_widen_insn,         /* removed = +1 */
5414   ta_fill,               /* removed = +size */
5415   ta_remove_literal,
5416   ta_add_literal
5417 };
5418
5419
5420 /* Structure for a text action record.  */
5421 struct text_action_struct
5422 {
5423   text_action_t action;
5424   asection *sec;        /* Optional */
5425   bfd_vma offset;
5426   bfd_vma virtual_offset;  /* Zero except for adding literals.  */
5427   int removed_bytes;
5428   literal_value value;  /* Only valid when adding literals.  */
5429 };
5430
5431 struct removal_by_action_entry_struct
5432 {
5433   bfd_vma offset;
5434   int removed;
5435   int eq_removed;
5436   int eq_removed_before_fill;
5437 };
5438 typedef struct removal_by_action_entry_struct removal_by_action_entry;
5439
5440 struct removal_by_action_map_struct
5441 {
5442   unsigned n_entries;
5443   removal_by_action_entry *entry;
5444 };
5445 typedef struct removal_by_action_map_struct removal_by_action_map;
5446
5447
5448 /* List of all of the actions taken on a text section.  */
5449 struct text_action_list_struct
5450 {
5451   unsigned count;
5452   splay_tree tree;
5453   removal_by_action_map map;
5454 };
5455
5456
5457 static text_action *
5458 find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
5459 {
5460   text_action a;
5461
5462   /* It is not necessary to fill at the end of a section.  */
5463   if (sec->size == offset)
5464     return NULL;
5465
5466   a.offset = offset;
5467   a.action = ta_fill;
5468
5469   splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a);
5470   if (node)
5471     return (text_action *)node->value;
5472   return NULL;
5473 }
5474
5475
5476 static int
5477 compute_removed_action_diff (const text_action *ta,
5478                              asection *sec,
5479                              bfd_vma offset,
5480                              int removed,
5481                              int removable_space)
5482 {
5483   int new_removed;
5484   int current_removed = 0;
5485
5486   if (ta)
5487     current_removed = ta->removed_bytes;
5488
5489   BFD_ASSERT (ta == NULL || ta->offset == offset);
5490   BFD_ASSERT (ta == NULL || ta->action == ta_fill);
5491
5492   /* It is not necessary to fill at the end of a section.  Clean this up.  */
5493   if (sec->size == offset)
5494     new_removed = removable_space - 0;
5495   else
5496     {
5497       int space;
5498       int added = -removed - current_removed;
5499       /* Ignore multiples of the section alignment.  */
5500       added = ((1 << sec->alignment_power) - 1) & added;
5501       new_removed = (-added);
5502
5503       /* Modify for removable.  */
5504       space = removable_space - new_removed;
5505       new_removed = (removable_space
5506                      - (((1 << sec->alignment_power) - 1) & space));
5507     }
5508   return (new_removed - current_removed);
5509 }
5510
5511
5512 static void
5513 adjust_fill_action (text_action *ta, int fill_diff)
5514 {
5515   ta->removed_bytes += fill_diff;
5516 }
5517
5518
5519 static int
5520 text_action_compare (splay_tree_key a, splay_tree_key b)
5521 {
5522   text_action *pa = (text_action *)a;
5523   text_action *pb = (text_action *)b;
5524   static const int action_priority[] =
5525     {
5526       [ta_fill] = 0,
5527       [ta_none] = 1,
5528       [ta_convert_longcall] = 2,
5529       [ta_narrow_insn] = 3,
5530       [ta_remove_insn] = 4,
5531       [ta_remove_longcall] = 5,
5532       [ta_remove_literal] = 6,
5533       [ta_widen_insn] = 7,
5534       [ta_add_literal] = 8,
5535     };
5536
5537   if (pa->offset == pb->offset)
5538     {
5539       if (pa->action == pb->action)
5540           return 0;
5541       return action_priority[pa->action] - action_priority[pb->action];
5542     }
5543   else
5544     return pa->offset < pb->offset ? -1 : 1;
5545 }
5546
5547 static text_action *
5548 action_first (text_action_list *action_list)
5549 {
5550   splay_tree_node node = splay_tree_min (action_list->tree);
5551   return node ? (text_action *)node->value : NULL;
5552 }
5553
5554 static text_action *
5555 action_next (text_action_list *action_list, text_action *action)
5556 {
5557   splay_tree_node node = splay_tree_successor (action_list->tree,
5558                                                (splay_tree_key)action);
5559   return node ? (text_action *)node->value : NULL;
5560 }
5561
5562 /* Add a modification action to the text.  For the case of adding or
5563    removing space, modify any current fill and assume that
5564    "unreachable_space" bytes can be freely contracted.  Note that a
5565    negative removed value is a fill.  */
5566
5567 static void
5568 text_action_add (text_action_list *l,
5569                  text_action_t action,
5570                  asection *sec,
5571                  bfd_vma offset,
5572                  int removed)
5573 {
5574   text_action *ta;
5575   text_action a;
5576
5577   /* It is not necessary to fill at the end of a section.  */
5578   if (action == ta_fill && sec->size == offset)
5579     return;
5580
5581   /* It is not necessary to fill 0 bytes.  */
5582   if (action == ta_fill && removed == 0)
5583     return;
5584
5585   a.action = action;
5586   a.offset = offset;
5587
5588   if (action == ta_fill)
5589     {
5590       splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a);
5591
5592       if (node)
5593         {
5594           ta = (text_action *)node->value;
5595           ta->removed_bytes += removed;
5596           return;
5597         }
5598     }
5599   else
5600     BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)&a) == NULL);
5601
5602   ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5603   ta->action = action;
5604   ta->sec = sec;
5605   ta->offset = offset;
5606   ta->removed_bytes = removed;
5607   splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta);
5608   ++l->count;
5609 }
5610
5611
5612 static void
5613 text_action_add_literal (text_action_list *l,
5614                          text_action_t action,
5615                          const r_reloc *loc,
5616                          const literal_value *value,
5617                          int removed)
5618 {
5619   text_action *ta;
5620   asection *sec = r_reloc_get_section (loc);
5621   bfd_vma offset = loc->target_offset;
5622   bfd_vma virtual_offset = loc->virtual_offset;
5623
5624   BFD_ASSERT (action == ta_add_literal);
5625
5626   /* Create a new record and fill it up.  */
5627   ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5628   ta->action = action;
5629   ta->sec = sec;
5630   ta->offset = offset;
5631   ta->virtual_offset = virtual_offset;
5632   ta->value = *value;
5633   ta->removed_bytes = removed;
5634
5635   BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)ta) == NULL);
5636   splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta);
5637   ++l->count;
5638 }
5639
5640
5641 /* Find the total offset adjustment for the relaxations specified by
5642    text_actions, beginning from a particular starting action.  This is
5643    typically used from offset_with_removed_text to search an entire list of
5644    actions, but it may also be called directly when adjusting adjacent offsets
5645    so that each search may begin where the previous one left off.  */
5646
5647 static int
5648 removed_by_actions (text_action_list *action_list,
5649                     text_action **p_start_action,
5650                     bfd_vma offset,
5651                     bfd_boolean before_fill)
5652 {
5653   text_action *r;
5654   int removed = 0;
5655
5656   r = *p_start_action;
5657   if (r)
5658     {
5659       splay_tree_node node = splay_tree_lookup (action_list->tree,
5660                                                 (splay_tree_key)r);
5661       BFD_ASSERT (node != NULL && r == (text_action *)node->value);
5662     }
5663
5664   while (r)
5665     {
5666       if (r->offset > offset)
5667         break;
5668
5669       if (r->offset == offset
5670           && (before_fill || r->action != ta_fill || r->removed_bytes >= 0))
5671         break;
5672
5673       removed += r->removed_bytes;
5674
5675       r = action_next (action_list, r);
5676     }
5677
5678   *p_start_action = r;
5679   return removed;
5680 }
5681
5682
5683 static bfd_vma
5684 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
5685 {
5686   text_action *r = action_first (action_list);
5687
5688   return offset - removed_by_actions (action_list, &r, offset, FALSE);
5689 }
5690
5691
5692 static unsigned
5693 action_list_count (text_action_list *action_list)
5694 {
5695   return action_list->count;
5696 }
5697
5698 typedef struct map_action_fn_context_struct map_action_fn_context;
5699 struct map_action_fn_context_struct
5700 {
5701   int removed;
5702   removal_by_action_map map;
5703   bfd_boolean eq_complete;
5704 };
5705
5706 static int
5707 map_action_fn (splay_tree_node node, void *p)
5708 {
5709   map_action_fn_context *ctx = p;
5710   text_action *r = (text_action *)node->value;
5711   removal_by_action_entry *ientry = ctx->map.entry + ctx->map.n_entries;
5712
5713   if (ctx->map.n_entries && (ientry - 1)->offset == r->offset)
5714     {
5715       --ientry;
5716     }
5717   else
5718     {
5719       ++ctx->map.n_entries;
5720       ctx->eq_complete = FALSE;
5721       ientry->offset = r->offset;
5722       ientry->eq_removed_before_fill = ctx->removed;
5723     }
5724
5725   if (!ctx->eq_complete)
5726     {
5727       if (r->action != ta_fill || r->removed_bytes >= 0)
5728         {
5729           ientry->eq_removed = ctx->removed;
5730           ctx->eq_complete = TRUE;
5731         }
5732       else
5733         ientry->eq_removed = ctx->removed + r->removed_bytes;
5734     }
5735
5736   ctx->removed += r->removed_bytes;
5737   ientry->removed = ctx->removed;
5738   return 0;
5739 }
5740
5741 static void
5742 map_removal_by_action (text_action_list *action_list)
5743 {
5744   map_action_fn_context ctx;
5745
5746   ctx.removed = 0;
5747   ctx.map.n_entries = 0;
5748   ctx.map.entry = bfd_malloc (action_list_count (action_list) *
5749                               sizeof (removal_by_action_entry));
5750   ctx.eq_complete = FALSE;
5751
5752   splay_tree_foreach (action_list->tree, map_action_fn, &ctx);
5753   action_list->map = ctx.map;
5754 }
5755
5756 static int
5757 removed_by_actions_map (text_action_list *action_list, bfd_vma offset,
5758                         bfd_boolean before_fill)
5759 {
5760   unsigned a, b;
5761
5762   if (!action_list->map.entry)
5763     map_removal_by_action (action_list);
5764
5765   if (!action_list->map.n_entries)
5766     return 0;
5767
5768   a = 0;
5769   b = action_list->map.n_entries;
5770
5771   while (b - a > 1)
5772     {
5773       unsigned c = (a + b) / 2;
5774
5775       if (action_list->map.entry[c].offset <= offset)
5776         a = c;
5777       else
5778         b = c;
5779     }
5780
5781   if (action_list->map.entry[a].offset < offset)
5782     {
5783       return action_list->map.entry[a].removed;
5784     }
5785   else if (action_list->map.entry[a].offset == offset)
5786     {
5787       return before_fill ?
5788         action_list->map.entry[a].eq_removed_before_fill :
5789         action_list->map.entry[a].eq_removed;
5790     }
5791   else
5792     {
5793       return 0;
5794     }
5795 }
5796
5797 static bfd_vma
5798 offset_with_removed_text_map (text_action_list *action_list, bfd_vma offset)
5799 {
5800   int removed = removed_by_actions_map (action_list, offset, FALSE);
5801   return offset - removed;
5802 }
5803
5804
5805 /* The find_insn_action routine will only find non-fill actions.  */
5806
5807 static text_action *
5808 find_insn_action (text_action_list *action_list, bfd_vma offset)
5809 {
5810   static const text_action_t action[] =
5811     {
5812       ta_convert_longcall,
5813       ta_remove_longcall,
5814       ta_widen_insn,
5815       ta_narrow_insn,
5816       ta_remove_insn,
5817     };
5818   text_action a;
5819   unsigned i;
5820
5821   a.offset = offset;
5822   for (i = 0; i < sizeof (action) / sizeof (*action); ++i)
5823     {
5824       splay_tree_node node;
5825
5826       a.action = action[i];
5827       node = splay_tree_lookup (action_list->tree, (splay_tree_key)&a);
5828       if (node)
5829         return (text_action *)node->value;
5830     }
5831   return NULL;
5832 }
5833
5834
5835 #if DEBUG
5836
5837 static void
5838 print_action (FILE *fp, text_action *r)
5839 {
5840   const char *t = "unknown";
5841   switch (r->action)
5842     {
5843     case ta_remove_insn:
5844       t = "remove_insn"; break;
5845     case ta_remove_longcall:
5846       t = "remove_longcall"; break;
5847     case ta_convert_longcall:
5848       t = "convert_longcall"; break;
5849     case ta_narrow_insn:
5850       t = "narrow_insn"; break;
5851     case ta_widen_insn:
5852       t = "widen_insn"; break;
5853     case ta_fill:
5854       t = "fill"; break;
5855     case ta_none:
5856       t = "none"; break;
5857     case ta_remove_literal:
5858       t = "remove_literal"; break;
5859     case ta_add_literal:
5860       t = "add_literal"; break;
5861     }
5862
5863   fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
5864            r->sec->owner->filename,
5865            r->sec->name, (unsigned long) r->offset, t, r->removed_bytes);
5866 }
5867
5868 static int
5869 print_action_list_fn (splay_tree_node node, void *p)
5870 {
5871   text_action *r = (text_action *)node->value;
5872
5873   print_action (p, r);
5874   return 0;
5875 }
5876
5877 static void
5878 print_action_list (FILE *fp, text_action_list *action_list)
5879 {
5880   fprintf (fp, "Text Action\n");
5881   splay_tree_foreach (action_list->tree, print_action_list_fn, fp);
5882 }
5883
5884 #endif /* DEBUG */
5885
5886 \f
5887 /* Lists of literals being coalesced or removed.  */
5888
5889 /* In the usual case, the literal identified by "from" is being
5890    coalesced with another literal identified by "to".  If the literal is
5891    unused and is being removed altogether, "to.abfd" will be NULL.
5892    The removed_literal entries are kept on a per-section list, sorted
5893    by the "from" offset field.  */
5894
5895 typedef struct removed_literal_struct removed_literal;
5896 typedef struct removed_literal_map_entry_struct removed_literal_map_entry;
5897 typedef struct removed_literal_list_struct removed_literal_list;
5898
5899 struct removed_literal_struct
5900 {
5901   r_reloc from;
5902   r_reloc to;
5903   removed_literal *next;
5904 };
5905
5906 struct removed_literal_map_entry_struct
5907 {
5908   bfd_vma addr;
5909   removed_literal *literal;
5910 };
5911
5912 struct removed_literal_list_struct
5913 {
5914   removed_literal *head;
5915   removed_literal *tail;
5916
5917   unsigned n_map;
5918   removed_literal_map_entry *map;
5919 };
5920
5921
5922 /* Record that the literal at "from" is being removed.  If "to" is not
5923    NULL, the "from" literal is being coalesced with the "to" literal.  */
5924
5925 static void
5926 add_removed_literal (removed_literal_list *removed_list,
5927                      const r_reloc *from,
5928                      const r_reloc *to)
5929 {
5930   removed_literal *r, *new_r, *next_r;
5931
5932   new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
5933
5934   new_r->from = *from;
5935   if (to)
5936     new_r->to = *to;
5937   else
5938     new_r->to.abfd = NULL;
5939   new_r->next = NULL;
5940
5941   r = removed_list->head;
5942   if (r == NULL)
5943     {
5944       removed_list->head = new_r;
5945       removed_list->tail = new_r;
5946     }
5947   /* Special check for common case of append.  */
5948   else if (removed_list->tail->from.target_offset < from->target_offset)
5949     {
5950       removed_list->tail->next = new_r;
5951       removed_list->tail = new_r;
5952     }
5953   else
5954     {
5955       while (r->from.target_offset < from->target_offset && r->next)
5956         {
5957           r = r->next;
5958         }
5959       next_r = r->next;
5960       r->next = new_r;
5961       new_r->next = next_r;
5962       if (next_r == NULL)
5963         removed_list->tail = new_r;
5964     }
5965 }
5966
5967 static void
5968 map_removed_literal (removed_literal_list *removed_list)
5969 {
5970   unsigned n_map = 0;
5971   unsigned i;
5972   removed_literal_map_entry *map = NULL;
5973   removed_literal *r = removed_list->head;
5974
5975   for (i = 0; r; ++i, r = r->next)
5976     {
5977       if (i == n_map)
5978         {
5979           n_map = (n_map * 2) + 2;
5980           map = bfd_realloc (map, n_map * sizeof (*map));
5981         }
5982       map[i].addr = r->from.target_offset;
5983       map[i].literal = r;
5984     }
5985   removed_list->map = map;
5986   removed_list->n_map = i;
5987 }
5988
5989 static int
5990 removed_literal_compare (const void *a, const void *b)
5991 {
5992   const removed_literal_map_entry *pa = a;
5993   const removed_literal_map_entry *pb = b;
5994
5995   if (pa->addr == pb->addr)
5996     return 0;
5997   else
5998     return pa->addr < pb->addr ? -1 : 1;
5999 }
6000
6001 /* Check if the list of removed literals contains an entry for the
6002    given address.  Return the entry if found.  */
6003
6004 static removed_literal *
6005 find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
6006 {
6007   removed_literal_map_entry *p;
6008   removed_literal *r = NULL;
6009
6010   if (removed_list->map == NULL)
6011     map_removed_literal (removed_list);
6012
6013   p = bsearch (&addr, removed_list->map, removed_list->n_map,
6014                sizeof (*removed_list->map), removed_literal_compare);
6015   if (p)
6016     {
6017       while (p != removed_list->map && (p - 1)->addr == addr)
6018         --p;
6019       r = p->literal;
6020     }
6021   return r;
6022 }
6023
6024
6025 #if DEBUG
6026
6027 static void
6028 print_removed_literals (FILE *fp, removed_literal_list *removed_list)
6029 {
6030   removed_literal *r;
6031   r = removed_list->head;
6032   if (r)
6033     fprintf (fp, "Removed Literals\n");
6034   for (; r != NULL; r = r->next)
6035     {
6036       print_r_reloc (fp, &r->from);
6037       fprintf (fp, " => ");
6038       if (r->to.abfd == NULL)
6039         fprintf (fp, "REMOVED");
6040       else
6041         print_r_reloc (fp, &r->to);
6042       fprintf (fp, "\n");
6043     }
6044 }
6045
6046 #endif /* DEBUG */
6047
6048 \f
6049 /* Per-section data for relaxation.  */
6050
6051 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
6052
6053 struct xtensa_relax_info_struct
6054 {
6055   bfd_boolean is_relaxable_literal_section;
6056   bfd_boolean is_relaxable_asm_section;
6057   int visited;                          /* Number of times visited.  */
6058
6059   source_reloc *src_relocs;             /* Array[src_count].  */
6060   int src_count;
6061   int src_next;                         /* Next src_relocs entry to assign.  */
6062
6063   removed_literal_list removed_list;
6064   text_action_list action_list;
6065
6066   reloc_bfd_fix *fix_list;
6067   reloc_bfd_fix *fix_array;
6068   unsigned fix_array_count;
6069
6070   /* Support for expanding the reloc array that is stored
6071      in the section structure.  If the relocations have been
6072      reallocated, the newly allocated relocations will be referenced
6073      here along with the actual size allocated.  The relocation
6074      count will always be found in the section structure.  */
6075   Elf_Internal_Rela *allocated_relocs;
6076   unsigned relocs_count;
6077   unsigned allocated_relocs_count;
6078 };
6079
6080 struct elf_xtensa_section_data
6081 {
6082   struct bfd_elf_section_data elf;
6083   xtensa_relax_info relax_info;
6084 };
6085
6086
6087 static bfd_boolean
6088 elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
6089 {
6090   if (!sec->used_by_bfd)
6091     {
6092       struct elf_xtensa_section_data *sdata;
6093       bfd_size_type amt = sizeof (*sdata);
6094
6095       sdata = bfd_zalloc (abfd, amt);
6096       if (sdata == NULL)
6097         return FALSE;
6098       sec->used_by_bfd = sdata;
6099     }
6100
6101   return _bfd_elf_new_section_hook (abfd, sec);
6102 }
6103
6104
6105 static xtensa_relax_info *
6106 get_xtensa_relax_info (asection *sec)
6107 {
6108   struct elf_xtensa_section_data *section_data;
6109
6110   /* No info available if no section or if it is an output section.  */
6111   if (!sec || sec == sec->output_section)
6112     return NULL;
6113
6114   section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
6115   return &section_data->relax_info;
6116 }
6117
6118
6119 static void
6120 init_xtensa_relax_info (asection *sec)
6121 {
6122   xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6123
6124   relax_info->is_relaxable_literal_section = FALSE;
6125   relax_info->is_relaxable_asm_section = FALSE;
6126   relax_info->visited = 0;
6127
6128   relax_info->src_relocs = NULL;
6129   relax_info->src_count = 0;
6130   relax_info->src_next = 0;
6131
6132   relax_info->removed_list.head = NULL;
6133   relax_info->removed_list.tail = NULL;
6134
6135   relax_info->action_list.tree = splay_tree_new (text_action_compare,
6136                                                  NULL, NULL);
6137   relax_info->action_list.map.n_entries = 0;
6138   relax_info->action_list.map.entry = NULL;
6139
6140   relax_info->fix_list = NULL;
6141   relax_info->fix_array = NULL;
6142   relax_info->fix_array_count = 0;
6143
6144   relax_info->allocated_relocs = NULL;
6145   relax_info->relocs_count = 0;
6146   relax_info->allocated_relocs_count = 0;
6147 }
6148
6149 \f
6150 /* Coalescing literals may require a relocation to refer to a section in
6151    a different input file, but the standard relocation information
6152    cannot express that.  Instead, the reloc_bfd_fix structures are used
6153    to "fix" the relocations that refer to sections in other input files.
6154    These structures are kept on per-section lists.  The "src_type" field
6155    records the relocation type in case there are multiple relocations on
6156    the same location.  FIXME: This is ugly; an alternative might be to
6157    add new symbols with the "owner" field to some other input file.  */
6158
6159 struct reloc_bfd_fix_struct
6160 {
6161   asection *src_sec;
6162   bfd_vma src_offset;
6163   unsigned src_type;                    /* Relocation type.  */
6164
6165   asection *target_sec;
6166   bfd_vma target_offset;
6167   bfd_boolean translated;
6168
6169   reloc_bfd_fix *next;
6170 };
6171
6172
6173 static reloc_bfd_fix *
6174 reloc_bfd_fix_init (asection *src_sec,
6175                     bfd_vma src_offset,
6176                     unsigned src_type,
6177                     asection *target_sec,
6178                     bfd_vma target_offset,
6179                     bfd_boolean translated)
6180 {
6181   reloc_bfd_fix *fix;
6182
6183   fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
6184   fix->src_sec = src_sec;
6185   fix->src_offset = src_offset;
6186   fix->src_type = src_type;
6187   fix->target_sec = target_sec;
6188   fix->target_offset = target_offset;
6189   fix->translated = translated;
6190
6191   return fix;
6192 }
6193
6194
6195 static void
6196 add_fix (asection *src_sec, reloc_bfd_fix *fix)
6197 {
6198   xtensa_relax_info *relax_info;
6199
6200   relax_info = get_xtensa_relax_info (src_sec);
6201   fix->next = relax_info->fix_list;
6202   relax_info->fix_list = fix;
6203 }
6204
6205
6206 static int
6207 fix_compare (const void *ap, const void *bp)
6208 {
6209   const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
6210   const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
6211
6212   if (a->src_offset != b->src_offset)
6213     return (a->src_offset - b->src_offset);
6214   return (a->src_type - b->src_type);
6215 }
6216
6217
6218 static void
6219 cache_fix_array (asection *sec)
6220 {
6221   unsigned i, count = 0;
6222   reloc_bfd_fix *r;
6223   xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6224
6225   if (relax_info == NULL)
6226     return;
6227   if (relax_info->fix_list == NULL)
6228     return;
6229
6230   for (r = relax_info->fix_list; r != NULL; r = r->next)
6231     count++;
6232
6233   relax_info->fix_array =
6234     (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
6235   relax_info->fix_array_count = count;
6236
6237   r = relax_info->fix_list;
6238   for (i = 0; i < count; i++, r = r->next)
6239     {
6240       relax_info->fix_array[count - 1 - i] = *r;
6241       relax_info->fix_array[count - 1 - i].next = NULL;
6242     }
6243
6244   qsort (relax_info->fix_array, relax_info->fix_array_count,
6245          sizeof (reloc_bfd_fix), fix_compare);
6246 }
6247
6248
6249 static reloc_bfd_fix *
6250 get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
6251 {
6252   xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6253   reloc_bfd_fix *rv;
6254   reloc_bfd_fix key;
6255
6256   if (relax_info == NULL)
6257     return NULL;
6258   if (relax_info->fix_list == NULL)
6259     return NULL;
6260
6261   if (relax_info->fix_array == NULL)
6262     cache_fix_array (sec);
6263
6264   key.src_offset = offset;
6265   key.src_type = type;
6266   rv = bsearch (&key, relax_info->fix_array,  relax_info->fix_array_count,
6267                 sizeof (reloc_bfd_fix), fix_compare);
6268   return rv;
6269 }
6270
6271 \f
6272 /* Section caching.  */
6273
6274 typedef struct section_cache_struct section_cache_t;
6275
6276 struct section_cache_struct
6277 {
6278   asection *sec;
6279
6280   bfd_byte *contents;           /* Cache of the section contents.  */
6281   bfd_size_type content_length;
6282
6283   property_table_entry *ptbl;   /* Cache of the section property table.  */
6284   unsigned pte_count;
6285
6286   Elf_Internal_Rela *relocs;    /* Cache of the section relocations.  */
6287   unsigned reloc_count;
6288 };
6289
6290
6291 static void
6292 init_section_cache (section_cache_t *sec_cache)
6293 {
6294   memset (sec_cache, 0, sizeof (*sec_cache));
6295 }
6296
6297
6298 static void
6299 free_section_cache (section_cache_t *sec_cache)
6300 {
6301   if (sec_cache->sec)
6302     {
6303       release_contents (sec_cache->sec, sec_cache->contents);
6304       release_internal_relocs (sec_cache->sec, sec_cache->relocs);
6305       if (sec_cache->ptbl)
6306         free (sec_cache->ptbl);
6307     }
6308 }
6309
6310
6311 static bfd_boolean
6312 section_cache_section (section_cache_t *sec_cache,
6313                        asection *sec,
6314                        struct bfd_link_info *link_info)
6315 {
6316   bfd *abfd;
6317   property_table_entry *prop_table = NULL;
6318   int ptblsize = 0;
6319   bfd_byte *contents = NULL;
6320   Elf_Internal_Rela *internal_relocs = NULL;
6321   bfd_size_type sec_size;
6322
6323   if (sec == NULL)
6324     return FALSE;
6325   if (sec == sec_cache->sec)
6326     return TRUE;
6327
6328   abfd = sec->owner;
6329   sec_size = bfd_get_section_limit (abfd, sec);
6330
6331   /* Get the contents.  */
6332   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6333   if (contents == NULL && sec_size != 0)
6334     goto err;
6335
6336   /* Get the relocations.  */
6337   internal_relocs = retrieve_internal_relocs (abfd, sec,
6338                                               link_info->keep_memory);
6339
6340   /* Get the entry table.  */
6341   ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6342                                         XTENSA_PROP_SEC_NAME, FALSE);
6343   if (ptblsize < 0)
6344     goto err;
6345
6346   /* Fill in the new section cache.  */
6347   free_section_cache (sec_cache);
6348   init_section_cache (sec_cache);
6349
6350   sec_cache->sec = sec;
6351   sec_cache->contents = contents;
6352   sec_cache->content_length = sec_size;
6353   sec_cache->relocs = internal_relocs;
6354   sec_cache->reloc_count = sec->reloc_count;
6355   sec_cache->pte_count = ptblsize;
6356   sec_cache->ptbl = prop_table;
6357
6358   return TRUE;
6359
6360  err:
6361   release_contents (sec, contents);
6362   release_internal_relocs (sec, internal_relocs);
6363   if (prop_table)
6364     free (prop_table);
6365   return FALSE;
6366 }
6367
6368 \f
6369 /* Extended basic blocks.  */
6370
6371 /* An ebb_struct represents an Extended Basic Block.  Within this
6372    range, we guarantee that all instructions are decodable, the
6373    property table entries are contiguous, and no property table
6374    specifies a segment that cannot have instructions moved.  This
6375    structure contains caches of the contents, property table and
6376    relocations for the specified section for easy use.  The range is
6377    specified by ranges of indices for the byte offset, property table
6378    offsets and relocation offsets.  These must be consistent.  */
6379
6380 typedef struct ebb_struct ebb_t;
6381
6382 struct ebb_struct
6383 {
6384   asection *sec;
6385
6386   bfd_byte *contents;           /* Cache of the section contents.  */
6387   bfd_size_type content_length;
6388
6389   property_table_entry *ptbl;   /* Cache of the section property table.  */
6390   unsigned pte_count;
6391
6392   Elf_Internal_Rela *relocs;    /* Cache of the section relocations.  */
6393   unsigned reloc_count;
6394
6395   bfd_vma start_offset;         /* Offset in section.  */
6396   unsigned start_ptbl_idx;      /* Offset in the property table.  */
6397   unsigned start_reloc_idx;     /* Offset in the relocations.  */
6398
6399   bfd_vma end_offset;
6400   unsigned end_ptbl_idx;
6401   unsigned end_reloc_idx;
6402
6403   bfd_boolean ends_section;     /* Is this the last ebb in a section?  */
6404
6405   /* The unreachable property table at the end of this set of blocks;
6406      NULL if the end is not an unreachable block.  */
6407   property_table_entry *ends_unreachable;
6408 };
6409
6410
6411 enum ebb_target_enum
6412 {
6413   EBB_NO_ALIGN = 0,
6414   EBB_DESIRE_TGT_ALIGN,
6415   EBB_REQUIRE_TGT_ALIGN,
6416   EBB_REQUIRE_LOOP_ALIGN,
6417   EBB_REQUIRE_ALIGN
6418 };
6419
6420
6421 /* proposed_action_struct is similar to the text_action_struct except
6422    that is represents a potential transformation, not one that will
6423    occur.  We build a list of these for an extended basic block
6424    and use them to compute the actual actions desired.  We must be
6425    careful that the entire set of actual actions we perform do not
6426    break any relocations that would fit if the actions were not
6427    performed.  */
6428
6429 typedef struct proposed_action_struct proposed_action;
6430
6431 struct proposed_action_struct
6432 {
6433   enum ebb_target_enum align_type; /* for the target alignment */
6434   bfd_vma alignment_pow;
6435   text_action_t action;
6436   bfd_vma offset;
6437   int removed_bytes;
6438   bfd_boolean do_action; /* If false, then we will not perform the action.  */
6439 };
6440
6441
6442 /* The ebb_constraint_struct keeps a set of proposed actions for an
6443    extended basic block.   */
6444
6445 typedef struct ebb_constraint_struct ebb_constraint;
6446
6447 struct ebb_constraint_struct
6448 {
6449   ebb_t ebb;
6450   bfd_boolean start_movable;
6451
6452   /* Bytes of extra space at the beginning if movable.  */
6453   int start_extra_space;
6454
6455   enum ebb_target_enum start_align;
6456
6457   bfd_boolean end_movable;
6458
6459   /* Bytes of extra space at the end if movable.  */
6460   int end_extra_space;
6461
6462   unsigned action_count;
6463   unsigned action_allocated;
6464
6465   /* Array of proposed actions.  */
6466   proposed_action *actions;
6467
6468   /* Action alignments -- one for each proposed action.  */
6469   enum ebb_target_enum *action_aligns;
6470 };
6471
6472
6473 static void
6474 init_ebb_constraint (ebb_constraint *c)
6475 {
6476   memset (c, 0, sizeof (ebb_constraint));
6477 }
6478
6479
6480 static void
6481 free_ebb_constraint (ebb_constraint *c)
6482 {
6483   if (c->actions)
6484     free (c->actions);
6485 }
6486
6487
6488 static void
6489 init_ebb (ebb_t *ebb,
6490           asection *sec,
6491           bfd_byte *contents,
6492           bfd_size_type content_length,
6493           property_table_entry *prop_table,
6494           unsigned ptblsize,
6495           Elf_Internal_Rela *internal_relocs,
6496           unsigned reloc_count)
6497 {
6498   memset (ebb, 0, sizeof (ebb_t));
6499   ebb->sec = sec;
6500   ebb->contents = contents;
6501   ebb->content_length = content_length;
6502   ebb->ptbl = prop_table;
6503   ebb->pte_count = ptblsize;
6504   ebb->relocs = internal_relocs;
6505   ebb->reloc_count = reloc_count;
6506   ebb->start_offset = 0;
6507   ebb->end_offset = ebb->content_length - 1;
6508   ebb->start_ptbl_idx = 0;
6509   ebb->end_ptbl_idx = ptblsize;
6510   ebb->start_reloc_idx = 0;
6511   ebb->end_reloc_idx = reloc_count;
6512 }
6513
6514
6515 /* Extend the ebb to all decodable contiguous sections.  The algorithm
6516    for building a basic block around an instruction is to push it
6517    forward until we hit the end of a section, an unreachable block or
6518    a block that cannot be transformed.  Then we push it backwards
6519    searching for similar conditions.  */
6520
6521 static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
6522 static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
6523 static bfd_size_type insn_block_decodable_len
6524   (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
6525
6526 static bfd_boolean
6527 extend_ebb_bounds (ebb_t *ebb)
6528 {
6529   if (!extend_ebb_bounds_forward (ebb))
6530     return FALSE;
6531   if (!extend_ebb_bounds_backward (ebb))
6532     return FALSE;
6533   return TRUE;
6534 }
6535
6536
6537 static bfd_boolean
6538 extend_ebb_bounds_forward (ebb_t *ebb)
6539 {
6540   property_table_entry *the_entry, *new_entry;
6541
6542   the_entry = &ebb->ptbl[ebb->end_ptbl_idx];
6543
6544   /* Stop when (1) we cannot decode an instruction, (2) we are at
6545      the end of the property tables, (3) we hit a non-contiguous property
6546      table entry, (4) we hit a NO_TRANSFORM region.  */
6547
6548   while (1)
6549     {
6550       bfd_vma entry_end;
6551       bfd_size_type insn_block_len;
6552
6553       entry_end = the_entry->address - ebb->sec->vma + the_entry->size;
6554       insn_block_len =
6555         insn_block_decodable_len (ebb->contents, ebb->content_length,
6556                                   ebb->end_offset,
6557                                   entry_end - ebb->end_offset);
6558       if (insn_block_len != (entry_end - ebb->end_offset))
6559         {
6560           (*_bfd_error_handler)
6561             (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6562              ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6563           return FALSE;
6564         }
6565       ebb->end_offset += insn_block_len;
6566
6567       if (ebb->end_offset == ebb->sec->size)
6568         ebb->ends_section = TRUE;
6569
6570       /* Update the reloc counter.  */
6571       while (ebb->end_reloc_idx + 1 < ebb->reloc_count
6572              && (ebb->relocs[ebb->end_reloc_idx + 1].r_offset
6573                  < ebb->end_offset))
6574         {
6575           ebb->end_reloc_idx++;
6576         }
6577
6578       if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6579         return TRUE;
6580
6581       new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6582       if (((new_entry->flags & XTENSA_PROP_INSN) == 0)
6583           || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6584           || ((the_entry->flags & XTENSA_PROP_ALIGN) != 0))
6585         break;
6586
6587       if (the_entry->address + the_entry->size != new_entry->address)
6588         break;
6589
6590       the_entry = new_entry;
6591       ebb->end_ptbl_idx++;
6592     }
6593
6594   /* Quick check for an unreachable or end of file just at the end.  */
6595   if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6596     {
6597       if (ebb->end_offset == ebb->content_length)
6598         ebb->ends_section = TRUE;
6599     }
6600   else
6601     {
6602       new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6603       if ((new_entry->flags & XTENSA_PROP_UNREACHABLE) != 0
6604           && the_entry->address + the_entry->size == new_entry->address)
6605         ebb->ends_unreachable = new_entry;
6606     }
6607
6608   /* Any other ending requires exact alignment.  */
6609   return TRUE;
6610 }
6611
6612
6613 static bfd_boolean
6614 extend_ebb_bounds_backward (ebb_t *ebb)
6615 {
6616   property_table_entry *the_entry, *new_entry;
6617
6618   the_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6619
6620   /* Stop when (1) we cannot decode the instructions in the current entry.
6621      (2) we are at the beginning of the property tables, (3) we hit a
6622      non-contiguous property table entry, (4) we hit a NO_TRANSFORM region.  */
6623
6624   while (1)
6625     {
6626       bfd_vma block_begin;
6627       bfd_size_type insn_block_len;
6628
6629       block_begin = the_entry->address - ebb->sec->vma;
6630       insn_block_len =
6631         insn_block_decodable_len (ebb->contents, ebb->content_length,
6632                                   block_begin,
6633                                   ebb->start_offset - block_begin);
6634       if (insn_block_len != ebb->start_offset - block_begin)
6635         {
6636           (*_bfd_error_handler)
6637             (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6638              ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6639           return FALSE;
6640         }
6641       ebb->start_offset -= insn_block_len;
6642
6643       /* Update the reloc counter.  */
6644       while (ebb->start_reloc_idx > 0
6645              && (ebb->relocs[ebb->start_reloc_idx - 1].r_offset
6646                  >= ebb->start_offset))
6647         {
6648           ebb->start_reloc_idx--;
6649         }
6650
6651       if (ebb->start_ptbl_idx == 0)
6652         return TRUE;
6653
6654       new_entry = &ebb->ptbl[ebb->start_ptbl_idx - 1];
6655       if ((new_entry->flags & XTENSA_PROP_INSN) == 0
6656           || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6657           || ((new_entry->flags & XTENSA_PROP_ALIGN) != 0))
6658         return TRUE;
6659       if (new_entry->address + new_entry->size != the_entry->address)
6660         return TRUE;
6661
6662       the_entry = new_entry;
6663       ebb->start_ptbl_idx--;
6664     }
6665   return TRUE;
6666 }
6667
6668
6669 static bfd_size_type
6670 insn_block_decodable_len (bfd_byte *contents,
6671                           bfd_size_type content_len,
6672                           bfd_vma block_offset,
6673                           bfd_size_type block_len)
6674 {
6675   bfd_vma offset = block_offset;
6676
6677   while (offset < block_offset + block_len)
6678     {
6679       bfd_size_type insn_len = 0;
6680
6681       insn_len = insn_decode_len (contents, content_len, offset);
6682       if (insn_len == 0)
6683         return (offset - block_offset);
6684       offset += insn_len;
6685     }
6686   return (offset - block_offset);
6687 }
6688
6689
6690 static void
6691 ebb_propose_action (ebb_constraint *c,
6692                     enum ebb_target_enum align_type,
6693                     bfd_vma alignment_pow,
6694                     text_action_t action,
6695                     bfd_vma offset,
6696                     int removed_bytes,
6697                     bfd_boolean do_action)
6698 {
6699   proposed_action *act;
6700
6701   if (c->action_allocated <= c->action_count)
6702     {
6703       unsigned new_allocated, i;
6704       proposed_action *new_actions;
6705
6706       new_allocated = (c->action_count + 2) * 2;
6707       new_actions = (proposed_action *)
6708         bfd_zmalloc (sizeof (proposed_action) * new_allocated);
6709
6710       for (i = 0; i < c->action_count; i++)
6711         new_actions[i] = c->actions[i];
6712       if (c->actions)
6713         free (c->actions);
6714       c->actions = new_actions;
6715       c->action_allocated = new_allocated;
6716     }
6717
6718   act = &c->actions[c->action_count];
6719   act->align_type = align_type;
6720   act->alignment_pow = alignment_pow;
6721   act->action = action;
6722   act->offset = offset;
6723   act->removed_bytes = removed_bytes;
6724   act->do_action = do_action;
6725
6726   c->action_count++;
6727 }
6728
6729 \f
6730 /* Access to internal relocations, section contents and symbols.  */
6731
6732 /* During relaxation, we need to modify relocations, section contents,
6733    and symbol definitions, and we need to keep the original values from
6734    being reloaded from the input files, i.e., we need to "pin" the
6735    modified values in memory.  We also want to continue to observe the
6736    setting of the "keep-memory" flag.  The following functions wrap the
6737    standard BFD functions to take care of this for us.  */
6738
6739 static Elf_Internal_Rela *
6740 retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6741 {
6742   Elf_Internal_Rela *internal_relocs;
6743
6744   if ((sec->flags & SEC_LINKER_CREATED) != 0)
6745     return NULL;
6746
6747   internal_relocs = elf_section_data (sec)->relocs;
6748   if (internal_relocs == NULL)
6749     internal_relocs = (_bfd_elf_link_read_relocs
6750                        (abfd, sec, NULL, NULL, keep_memory));
6751   return internal_relocs;
6752 }
6753
6754
6755 static void
6756 pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6757 {
6758   elf_section_data (sec)->relocs = internal_relocs;
6759 }
6760
6761
6762 static void
6763 release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6764 {
6765   if (internal_relocs
6766       && elf_section_data (sec)->relocs != internal_relocs)
6767     free (internal_relocs);
6768 }
6769
6770
6771 static bfd_byte *
6772 retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6773 {
6774   bfd_byte *contents;
6775   bfd_size_type sec_size;
6776
6777   sec_size = bfd_get_section_limit (abfd, sec);
6778   contents = elf_section_data (sec)->this_hdr.contents;
6779
6780   if (contents == NULL && sec_size != 0)
6781     {
6782       if (!bfd_malloc_and_get_section (abfd, sec, &contents))
6783         {
6784           if (contents)
6785             free (contents);
6786           return NULL;
6787         }
6788       if (keep_memory)
6789         elf_section_data (sec)->this_hdr.contents = contents;
6790     }
6791   return contents;
6792 }
6793
6794
6795 static void
6796 pin_contents (asection *sec, bfd_byte *contents)
6797 {
6798   elf_section_data (sec)->this_hdr.contents = contents;
6799 }
6800
6801
6802 static void
6803 release_contents (asection *sec, bfd_byte *contents)
6804 {
6805   if (contents && elf_section_data (sec)->this_hdr.contents != contents)
6806     free (contents);
6807 }
6808
6809
6810 static Elf_Internal_Sym *
6811 retrieve_local_syms (bfd *input_bfd)
6812 {
6813   Elf_Internal_Shdr *symtab_hdr;
6814   Elf_Internal_Sym *isymbuf;
6815   size_t locsymcount;
6816
6817   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6818   locsymcount = symtab_hdr->sh_info;
6819
6820   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6821   if (isymbuf == NULL && locsymcount != 0)
6822     isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
6823                                     NULL, NULL, NULL);
6824
6825   /* Save the symbols for this input file so they won't be read again.  */
6826   if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
6827     symtab_hdr->contents = (unsigned char *) isymbuf;
6828
6829   return isymbuf;
6830 }
6831
6832 \f
6833 /* Code for link-time relaxation.  */
6834
6835 /* Initialization for relaxation: */
6836 static bfd_boolean analyze_relocations (struct bfd_link_info *);
6837 static bfd_boolean find_relaxable_sections
6838   (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
6839 static bfd_boolean collect_source_relocs
6840   (bfd *, asection *, struct bfd_link_info *);
6841 static bfd_boolean is_resolvable_asm_expansion
6842   (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
6843    bfd_boolean *);
6844 static Elf_Internal_Rela *find_associated_l32r_irel
6845   (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
6846 static bfd_boolean compute_text_actions
6847   (bfd *, asection *, struct bfd_link_info *);
6848 static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
6849 static bfd_boolean compute_ebb_actions (ebb_constraint *);
6850 typedef struct reloc_range_list_struct reloc_range_list;
6851 static bfd_boolean check_section_ebb_pcrels_fit
6852   (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *,
6853    reloc_range_list *, const ebb_constraint *,
6854    const xtensa_opcode *);
6855 static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
6856 static void text_action_add_proposed
6857   (text_action_list *, const ebb_constraint *, asection *);
6858 static int compute_fill_extra_space (property_table_entry *);
6859
6860 /* First pass: */
6861 static bfd_boolean compute_removed_literals
6862   (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
6863 static Elf_Internal_Rela *get_irel_at_offset
6864   (asection *, Elf_Internal_Rela *, bfd_vma);
6865 static bfd_boolean is_removable_literal
6866   (const source_reloc *, int, const source_reloc *, int, asection *,
6867    property_table_entry *, int);
6868 static bfd_boolean remove_dead_literal
6869   (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
6870    Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
6871 static bfd_boolean identify_literal_placement
6872   (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
6873    value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
6874    source_reloc *, property_table_entry *, int, section_cache_t *,
6875    bfd_boolean);
6876 static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
6877 static bfd_boolean coalesce_shared_literal
6878   (asection *, source_reloc *, property_table_entry *, int, value_map *);
6879 static bfd_boolean move_shared_literal
6880   (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
6881    int, const r_reloc *, const literal_value *, section_cache_t *);
6882
6883 /* Second pass: */
6884 static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
6885 static bfd_boolean translate_section_fixes (asection *);
6886 static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
6887 static asection *translate_reloc (const r_reloc *, r_reloc *, asection *);
6888 static void shrink_dynamic_reloc_sections
6889   (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
6890 static bfd_boolean move_literal
6891   (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
6892    xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
6893 static bfd_boolean relax_property_section
6894   (bfd *, asection *, struct bfd_link_info *);
6895
6896 /* Third pass: */
6897 static bfd_boolean relax_section_symbols (bfd *, asection *);
6898
6899
6900 static bfd_boolean
6901 elf_xtensa_relax_section (bfd *abfd,
6902                           asection *sec,
6903                           struct bfd_link_info *link_info,
6904                           bfd_boolean *again)
6905 {
6906   static value_map_hash_table *values = NULL;
6907   static bfd_boolean relocations_analyzed = FALSE;
6908   xtensa_relax_info *relax_info;
6909
6910   if (!relocations_analyzed)
6911     {
6912       /* Do some overall initialization for relaxation.  */
6913       values = value_map_hash_table_init ();
6914       if (values == NULL)
6915         return FALSE;
6916       relaxing_section = TRUE;
6917       if (!analyze_relocations (link_info))
6918         return FALSE;
6919       relocations_analyzed = TRUE;
6920     }
6921   *again = FALSE;
6922
6923   /* Don't mess with linker-created sections.  */
6924   if ((sec->flags & SEC_LINKER_CREATED) != 0)
6925     return TRUE;
6926
6927   relax_info = get_xtensa_relax_info (sec);
6928   BFD_ASSERT (relax_info != NULL);
6929
6930   switch (relax_info->visited)
6931     {
6932     case 0:
6933       /* Note: It would be nice to fold this pass into
6934          analyze_relocations, but it is important for this step that the
6935          sections be examined in link order.  */
6936       if (!compute_removed_literals (abfd, sec, link_info, values))
6937         return FALSE;
6938       *again = TRUE;
6939       break;
6940
6941     case 1:
6942       if (values)
6943         value_map_hash_table_delete (values);
6944       values = NULL;
6945       if (!relax_section (abfd, sec, link_info))
6946         return FALSE;
6947       *again = TRUE;
6948       break;
6949
6950     case 2:
6951       if (!relax_section_symbols (abfd, sec))
6952         return FALSE;
6953       break;
6954     }
6955
6956   relax_info->visited++;
6957   return TRUE;
6958 }
6959
6960 \f
6961 /* Initialization for relaxation.  */
6962
6963 /* This function is called once at the start of relaxation.  It scans
6964    all the input sections and marks the ones that are relaxable (i.e.,
6965    literal sections with L32R relocations against them), and then
6966    collects source_reloc information for all the relocations against
6967    those relaxable sections.  During this process, it also detects
6968    longcalls, i.e., calls relaxed by the assembler into indirect
6969    calls, that can be optimized back into direct calls.  Within each
6970    extended basic block (ebb) containing an optimized longcall, it
6971    computes a set of "text actions" that can be performed to remove
6972    the L32R associated with the longcall while optionally preserving
6973    branch target alignments.  */
6974
6975 static bfd_boolean
6976 analyze_relocations (struct bfd_link_info *link_info)
6977 {
6978   bfd *abfd;
6979   asection *sec;
6980   bfd_boolean is_relaxable = FALSE;
6981
6982   /* Initialize the per-section relaxation info.  */
6983   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
6984     for (sec = abfd->sections; sec != NULL; sec = sec->next)
6985       {
6986         init_xtensa_relax_info (sec);
6987       }
6988
6989   /* Mark relaxable sections (and count relocations against each one).  */
6990   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
6991     for (sec = abfd->sections; sec != NULL; sec = sec->next)
6992       {
6993         if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
6994           return FALSE;
6995       }
6996
6997   /* Bail out if there are no relaxable sections.  */
6998   if (!is_relaxable)
6999     return TRUE;
7000
7001   /* Allocate space for source_relocs.  */
7002   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
7003     for (sec = abfd->sections; sec != NULL; sec = sec->next)
7004       {
7005         xtensa_relax_info *relax_info;
7006
7007         relax_info = get_xtensa_relax_info (sec);
7008         if (relax_info->is_relaxable_literal_section
7009             || relax_info->is_relaxable_asm_section)
7010           {
7011             relax_info->src_relocs = (source_reloc *)
7012               bfd_malloc (relax_info->src_count * sizeof (source_reloc));
7013           }
7014         else
7015           relax_info->src_count = 0;
7016       }
7017
7018   /* Collect info on relocations against each relaxable section.  */
7019   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
7020     for (sec = abfd->sections; sec != NULL; sec = sec->next)
7021       {
7022         if (!collect_source_relocs (abfd, sec, link_info))
7023           return FALSE;
7024       }
7025
7026   /* Compute the text actions.  */
7027   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
7028     for (sec = abfd->sections; sec != NULL; sec = sec->next)
7029       {
7030         if (!compute_text_actions (abfd, sec, link_info))
7031           return FALSE;
7032       }
7033
7034   return TRUE;
7035 }
7036
7037
7038 /* Find all the sections that might be relaxed.  The motivation for
7039    this pass is that collect_source_relocs() needs to record _all_ the
7040    relocations that target each relaxable section.  That is expensive
7041    and unnecessary unless the target section is actually going to be
7042    relaxed.  This pass identifies all such sections by checking if
7043    they have L32Rs pointing to them.  In the process, the total number
7044    of relocations targeting each section is also counted so that we
7045    know how much space to allocate for source_relocs against each
7046    relaxable literal section.  */
7047
7048 static bfd_boolean
7049 find_relaxable_sections (bfd *abfd,
7050                          asection *sec,
7051                          struct bfd_link_info *link_info,
7052                          bfd_boolean *is_relaxable_p)
7053 {
7054   Elf_Internal_Rela *internal_relocs;
7055   bfd_byte *contents;
7056   bfd_boolean ok = TRUE;
7057   unsigned i;
7058   xtensa_relax_info *source_relax_info;
7059   bfd_boolean is_l32r_reloc;
7060
7061   internal_relocs = retrieve_internal_relocs (abfd, sec,
7062                                               link_info->keep_memory);
7063   if (internal_relocs == NULL)
7064     return ok;
7065
7066   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7067   if (contents == NULL && sec->size != 0)
7068     {
7069       ok = FALSE;
7070       goto error_return;
7071     }
7072
7073   source_relax_info = get_xtensa_relax_info (sec);
7074   for (i = 0; i < sec->reloc_count; i++)
7075     {
7076       Elf_Internal_Rela *irel = &internal_relocs[i];
7077       r_reloc r_rel;
7078       asection *target_sec;
7079       xtensa_relax_info *target_relax_info;
7080
7081       /* If this section has not already been marked as "relaxable", and
7082          if it contains any ASM_EXPAND relocations (marking expanded
7083          longcalls) that can be optimized into direct calls, then mark
7084          the section as "relaxable".  */
7085       if (source_relax_info
7086           && !source_relax_info->is_relaxable_asm_section
7087           && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
7088         {
7089           bfd_boolean is_reachable = FALSE;
7090           if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
7091                                            link_info, &is_reachable)
7092               && is_reachable)
7093             {
7094               source_relax_info->is_relaxable_asm_section = TRUE;
7095               *is_relaxable_p = TRUE;
7096             }
7097         }
7098
7099       r_reloc_init (&r_rel, abfd, irel, contents,
7100                     bfd_get_section_limit (abfd, sec));
7101
7102       target_sec = r_reloc_get_section (&r_rel);
7103       target_relax_info = get_xtensa_relax_info (target_sec);
7104       if (!target_relax_info)
7105         continue;
7106
7107       /* Count PC-relative operand relocations against the target section.
7108          Note: The conditions tested here must match the conditions under
7109          which init_source_reloc is called in collect_source_relocs().  */
7110       is_l32r_reloc = FALSE;
7111       if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
7112         {
7113           xtensa_opcode opcode =
7114             get_relocation_opcode (abfd, sec, contents, irel);
7115           if (opcode != XTENSA_UNDEFINED)
7116             {
7117               is_l32r_reloc = (opcode == get_l32r_opcode ());
7118               if (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
7119                   || is_l32r_reloc)
7120                 target_relax_info->src_count++;
7121             }
7122         }
7123
7124       if (is_l32r_reloc && r_reloc_is_defined (&r_rel))
7125         {
7126           /* Mark the target section as relaxable.  */
7127           target_relax_info->is_relaxable_literal_section = TRUE;
7128           *is_relaxable_p = TRUE;
7129         }
7130     }
7131
7132  error_return:
7133   release_contents (sec, contents);
7134   release_internal_relocs (sec, internal_relocs);
7135   return ok;
7136 }
7137
7138
7139 /* Record _all_ the relocations that point to relaxable sections, and
7140    get rid of ASM_EXPAND relocs by either converting them to
7141    ASM_SIMPLIFY or by removing them.  */
7142
7143 static bfd_boolean
7144 collect_source_relocs (bfd *abfd,
7145                        asection *sec,
7146                        struct bfd_link_info *link_info)
7147 {
7148   Elf_Internal_Rela *internal_relocs;
7149   bfd_byte *contents;
7150   bfd_boolean ok = TRUE;
7151   unsigned i;
7152   bfd_size_type sec_size;
7153
7154   internal_relocs = retrieve_internal_relocs (abfd, sec,
7155                                               link_info->keep_memory);
7156   if (internal_relocs == NULL)
7157     return ok;
7158
7159   sec_size = bfd_get_section_limit (abfd, sec);
7160   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7161   if (contents == NULL && sec_size != 0)
7162     {
7163       ok = FALSE;
7164       goto error_return;
7165     }
7166
7167   /* Record relocations against relaxable literal sections.  */
7168   for (i = 0; i < sec->reloc_count; i++)
7169     {
7170       Elf_Internal_Rela *irel = &internal_relocs[i];
7171       r_reloc r_rel;
7172       asection *target_sec;
7173       xtensa_relax_info *target_relax_info;
7174
7175       r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7176
7177       target_sec = r_reloc_get_section (&r_rel);
7178       target_relax_info = get_xtensa_relax_info (target_sec);
7179
7180       if (target_relax_info
7181           && (target_relax_info->is_relaxable_literal_section
7182               || target_relax_info->is_relaxable_asm_section))
7183         {
7184           xtensa_opcode opcode = XTENSA_UNDEFINED;
7185           int opnd = -1;
7186           bfd_boolean is_abs_literal = FALSE;
7187
7188           if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7189             {
7190               /* None of the current alternate relocs are PC-relative,
7191                  and only PC-relative relocs matter here.  However, we
7192                  still need to record the opcode for literal
7193                  coalescing.  */
7194               opcode = get_relocation_opcode (abfd, sec, contents, irel);
7195               if (opcode == get_l32r_opcode ())
7196                 {
7197                   is_abs_literal = TRUE;
7198                   opnd = 1;
7199                 }
7200               else
7201                 opcode = XTENSA_UNDEFINED;
7202             }
7203           else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
7204             {
7205               opcode = get_relocation_opcode (abfd, sec, contents, irel);
7206               opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
7207             }
7208
7209           if (opcode != XTENSA_UNDEFINED)
7210             {
7211               int src_next = target_relax_info->src_next++;
7212               source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
7213
7214               init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
7215                                  is_abs_literal);
7216             }
7217         }
7218     }
7219
7220   /* Now get rid of ASM_EXPAND relocations.  At this point, the
7221      src_relocs array for the target literal section may still be
7222      incomplete, but it must at least contain the entries for the L32R
7223      relocations associated with ASM_EXPANDs because they were just
7224      added in the preceding loop over the relocations.  */
7225
7226   for (i = 0; i < sec->reloc_count; i++)
7227     {
7228       Elf_Internal_Rela *irel = &internal_relocs[i];
7229       bfd_boolean is_reachable;
7230
7231       if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
7232                                         &is_reachable))
7233         continue;
7234
7235       if (is_reachable)
7236         {
7237           Elf_Internal_Rela *l32r_irel;
7238           r_reloc r_rel;
7239           asection *target_sec;
7240           xtensa_relax_info *target_relax_info;
7241
7242           /* Mark the source_reloc for the L32R so that it will be
7243              removed in compute_removed_literals(), along with the
7244              associated literal.  */
7245           l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
7246                                                  irel, internal_relocs);
7247           if (l32r_irel == NULL)
7248             continue;
7249
7250           r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
7251
7252           target_sec = r_reloc_get_section (&r_rel);
7253           target_relax_info = get_xtensa_relax_info (target_sec);
7254
7255           if (target_relax_info
7256               && (target_relax_info->is_relaxable_literal_section
7257                   || target_relax_info->is_relaxable_asm_section))
7258             {
7259               source_reloc *s_reloc;
7260
7261               /* Search the source_relocs for the entry corresponding to
7262                  the l32r_irel.  Note: The src_relocs array is not yet
7263                  sorted, but it wouldn't matter anyway because we're
7264                  searching by source offset instead of target offset.  */
7265               s_reloc = find_source_reloc (target_relax_info->src_relocs,
7266                                            target_relax_info->src_next,
7267                                            sec, l32r_irel);
7268               BFD_ASSERT (s_reloc);
7269               s_reloc->is_null = TRUE;
7270             }
7271
7272           /* Convert this reloc to ASM_SIMPLIFY.  */
7273           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
7274                                        R_XTENSA_ASM_SIMPLIFY);
7275           l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7276
7277           pin_internal_relocs (sec, internal_relocs);
7278         }
7279       else
7280         {
7281           /* It is resolvable but doesn't reach.  We resolve now
7282              by eliminating the relocation -- the call will remain
7283              expanded into L32R/CALLX.  */
7284           irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7285           pin_internal_relocs (sec, internal_relocs);
7286         }
7287     }
7288
7289  error_return:
7290   release_contents (sec, contents);
7291   release_internal_relocs (sec, internal_relocs);
7292   return ok;
7293 }
7294
7295
7296 /* Return TRUE if the asm expansion can be resolved.  Generally it can
7297    be resolved on a final link or when a partial link locates it in the
7298    same section as the target.  Set "is_reachable" flag if the target of
7299    the call is within the range of a direct call, given the current VMA
7300    for this section and the target section.  */
7301
7302 bfd_boolean
7303 is_resolvable_asm_expansion (bfd *abfd,
7304                              asection *sec,
7305                              bfd_byte *contents,
7306                              Elf_Internal_Rela *irel,
7307                              struct bfd_link_info *link_info,
7308                              bfd_boolean *is_reachable_p)
7309 {
7310   asection *target_sec;
7311   bfd_vma target_offset;
7312   r_reloc r_rel;
7313   xtensa_opcode opcode, direct_call_opcode;
7314   bfd_vma self_address;
7315   bfd_vma dest_address;
7316   bfd_boolean uses_l32r;
7317   bfd_size_type sec_size;
7318
7319   *is_reachable_p = FALSE;
7320
7321   if (contents == NULL)
7322     return FALSE;
7323
7324   if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
7325     return FALSE;
7326
7327   sec_size = bfd_get_section_limit (abfd, sec);
7328   opcode = get_expanded_call_opcode (contents + irel->r_offset,
7329                                      sec_size - irel->r_offset, &uses_l32r);
7330   /* Optimization of longcalls that use CONST16 is not yet implemented.  */
7331   if (!uses_l32r)
7332     return FALSE;
7333
7334   direct_call_opcode = swap_callx_for_call_opcode (opcode);
7335   if (direct_call_opcode == XTENSA_UNDEFINED)
7336     return FALSE;
7337
7338   /* Check and see that the target resolves.  */
7339   r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7340   if (!r_reloc_is_defined (&r_rel))
7341     return FALSE;
7342
7343   target_sec = r_reloc_get_section (&r_rel);
7344   target_offset = r_rel.target_offset;
7345
7346   /* If the target is in a shared library, then it doesn't reach.  This
7347      isn't supposed to come up because the compiler should never generate
7348      non-PIC calls on systems that use shared libraries, but the linker
7349      shouldn't crash regardless.  */
7350   if (!target_sec->output_section)
7351     return FALSE;
7352
7353   /* For relocatable sections, we can only simplify when the output
7354      section of the target is the same as the output section of the
7355      source.  */
7356   if (bfd_link_relocatable (link_info)
7357       && (target_sec->output_section != sec->output_section
7358           || is_reloc_sym_weak (abfd, irel)))
7359     return FALSE;
7360
7361   if (target_sec->output_section != sec->output_section)
7362     {
7363       /* If the two sections are sufficiently far away that relaxation
7364          might take the call out of range, we can't simplify.  For
7365          example, a positive displacement call into another memory
7366          could get moved to a lower address due to literal removal,
7367          but the destination won't move, and so the displacment might
7368          get larger.
7369
7370          If the displacement is negative, assume the destination could
7371          move as far back as the start of the output section.  The
7372          self_address will be at least as far into the output section
7373          as it is prior to relaxation.
7374
7375          If the displacement is postive, assume the destination will be in
7376          it's pre-relaxed location (because relaxation only makes sections
7377          smaller).  The self_address could go all the way to the beginning
7378          of the output section.  */
7379
7380       dest_address = target_sec->output_section->vma;
7381       self_address = sec->output_section->vma;
7382
7383       if (sec->output_section->vma > target_sec->output_section->vma)
7384         self_address += sec->output_offset + irel->r_offset + 3;
7385       else
7386         dest_address += bfd_get_section_limit (abfd, target_sec->output_section);
7387       /* Call targets should be four-byte aligned.  */
7388       dest_address = (dest_address + 3) & ~3;
7389     }
7390   else
7391     {
7392
7393       self_address = (sec->output_section->vma
7394                       + sec->output_offset + irel->r_offset + 3);
7395       dest_address = (target_sec->output_section->vma
7396                       + target_sec->output_offset + target_offset);
7397     }
7398
7399   *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
7400                                       self_address, dest_address);
7401
7402   if ((self_address >> CALL_SEGMENT_BITS) !=
7403       (dest_address >> CALL_SEGMENT_BITS))
7404     return FALSE;
7405
7406   return TRUE;
7407 }
7408
7409
7410 static Elf_Internal_Rela *
7411 find_associated_l32r_irel (bfd *abfd,
7412                            asection *sec,
7413                            bfd_byte *contents,
7414                            Elf_Internal_Rela *other_irel,
7415                            Elf_Internal_Rela *internal_relocs)
7416 {
7417   unsigned i;
7418
7419   for (i = 0; i < sec->reloc_count; i++)
7420     {
7421       Elf_Internal_Rela *irel = &internal_relocs[i];
7422
7423       if (irel == other_irel)
7424         continue;
7425       if (irel->r_offset != other_irel->r_offset)
7426         continue;
7427       if (is_l32r_relocation (abfd, sec, contents, irel))
7428         return irel;
7429     }
7430
7431   return NULL;
7432 }
7433
7434
7435 static xtensa_opcode *
7436 build_reloc_opcodes (bfd *abfd,
7437                      asection *sec,
7438                      bfd_byte *contents,
7439                      Elf_Internal_Rela *internal_relocs)
7440 {
7441   unsigned i;
7442   xtensa_opcode *reloc_opcodes =
7443     (xtensa_opcode *) bfd_malloc (sizeof (xtensa_opcode) * sec->reloc_count);
7444   for (i = 0; i < sec->reloc_count; i++)
7445     {
7446       Elf_Internal_Rela *irel = &internal_relocs[i];
7447       reloc_opcodes[i] = get_relocation_opcode (abfd, sec, contents, irel);
7448     }
7449   return reloc_opcodes;
7450 }
7451
7452 struct reloc_range_struct
7453 {
7454   bfd_vma addr;
7455   bfd_boolean add; /* TRUE if start of a range, FALSE otherwise.  */
7456   /* Original irel index in the array of relocations for a section.  */
7457   unsigned irel_index;
7458 };
7459 typedef struct reloc_range_struct reloc_range;
7460
7461 typedef struct reloc_range_list_entry_struct reloc_range_list_entry;
7462 struct reloc_range_list_entry_struct
7463 {
7464   reloc_range_list_entry *next;
7465   reloc_range_list_entry *prev;
7466   Elf_Internal_Rela *irel;
7467   xtensa_opcode opcode;
7468   int opnum;
7469 };
7470
7471 struct reloc_range_list_struct
7472 {
7473   /* The rest of the structure is only meaningful when ok is TRUE.  */
7474   bfd_boolean ok;
7475
7476   unsigned n_range; /* Number of range markers.  */
7477   reloc_range *range; /* Sorted range markers.  */
7478
7479   unsigned first; /* Index of a first range element in the list.  */
7480   unsigned last; /* One past index of a last range element in the list.  */
7481
7482   unsigned n_list; /* Number of list elements.  */
7483   reloc_range_list_entry *reloc; /*  */
7484   reloc_range_list_entry list_root;
7485 };
7486
7487 static int
7488 reloc_range_compare (const void *a, const void *b)
7489 {
7490   const reloc_range *ra = a;
7491   const reloc_range *rb = b;
7492
7493   if (ra->addr != rb->addr)
7494     return ra->addr < rb->addr ? -1 : 1;
7495   if (ra->add != rb->add)
7496     return ra->add ? -1 : 1;
7497   return 0;
7498 }
7499
7500 static void
7501 build_reloc_ranges (bfd *abfd, asection *sec,
7502                     bfd_byte *contents,
7503                     Elf_Internal_Rela *internal_relocs,
7504                     xtensa_opcode *reloc_opcodes,
7505                     reloc_range_list *list)
7506 {
7507   unsigned i;
7508   size_t n = 0;
7509   size_t max_n = 0;
7510   reloc_range *ranges = NULL;
7511   reloc_range_list_entry *reloc =
7512     bfd_malloc (sec->reloc_count * sizeof (*reloc));
7513
7514   memset (list, 0, sizeof (*list));
7515   list->ok = TRUE;
7516
7517   for (i = 0; i < sec->reloc_count; i++)
7518     {
7519       Elf_Internal_Rela *irel = &internal_relocs[i];
7520       int r_type = ELF32_R_TYPE (irel->r_info);
7521       reloc_howto_type *howto = &elf_howto_table[r_type];
7522       r_reloc r_rel;
7523
7524       if (r_type == R_XTENSA_ASM_SIMPLIFY
7525           || r_type == R_XTENSA_32_PCREL
7526           || !howto->pc_relative)
7527         continue;
7528
7529       r_reloc_init (&r_rel, abfd, irel, contents,
7530                     bfd_get_section_limit (abfd, sec));
7531
7532       if (r_reloc_get_section (&r_rel) != sec)
7533         continue;
7534
7535       if (n + 2 > max_n)
7536         {
7537           max_n = (max_n + 2) * 2;
7538           ranges = bfd_realloc (ranges, max_n * sizeof (*ranges));
7539         }
7540
7541       ranges[n].addr = irel->r_offset;
7542       ranges[n + 1].addr = r_rel.target_offset;
7543
7544       ranges[n].add = ranges[n].addr < ranges[n + 1].addr;
7545       ranges[n + 1].add = !ranges[n].add;
7546
7547       ranges[n].irel_index = i;
7548       ranges[n + 1].irel_index = i;
7549
7550       n += 2;
7551
7552       reloc[i].irel = irel;
7553
7554       /* Every relocation won't possibly be checked in the optimized version of
7555          check_section_ebb_pcrels_fit, so this needs to be done here.  */
7556       if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7557         {
7558           /* None of the current alternate relocs are PC-relative,
7559              and only PC-relative relocs matter here.  */
7560         }
7561       else
7562         {
7563           xtensa_opcode opcode;
7564           int opnum;
7565
7566           if (reloc_opcodes)
7567             opcode = reloc_opcodes[i];
7568           else
7569             opcode = get_relocation_opcode (abfd, sec, contents, irel);
7570
7571           if (opcode == XTENSA_UNDEFINED)
7572             {
7573               list->ok = FALSE;
7574               break;
7575             }
7576
7577           opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
7578           if (opnum == XTENSA_UNDEFINED)
7579             {
7580               list->ok = FALSE;
7581               break;
7582             }
7583
7584           /* Record relocation opcode and opnum as we've calculated them
7585              anyway and they won't change.  */
7586           reloc[i].opcode = opcode;
7587           reloc[i].opnum = opnum;
7588         }
7589     }
7590
7591   if (list->ok)
7592     {
7593       ranges = bfd_realloc (ranges, n * sizeof (*ranges));
7594       qsort (ranges, n, sizeof (*ranges), reloc_range_compare);
7595
7596       list->n_range = n;
7597       list->range = ranges;
7598       list->reloc = reloc;
7599       list->list_root.prev = &list->list_root;
7600       list->list_root.next = &list->list_root;
7601     }
7602   else
7603     {
7604       free (ranges);
7605       free (reloc);
7606     }
7607 }
7608
7609 static void reloc_range_list_append (reloc_range_list *list,
7610                                      unsigned irel_index)
7611 {
7612   reloc_range_list_entry *entry = list->reloc + irel_index;
7613
7614   entry->prev = list->list_root.prev;
7615   entry->next = &list->list_root;
7616   entry->prev->next = entry;
7617   entry->next->prev = entry;
7618   ++list->n_list;
7619 }
7620
7621 static void reloc_range_list_remove (reloc_range_list *list,
7622                                      unsigned irel_index)
7623 {
7624   reloc_range_list_entry *entry = list->reloc + irel_index;
7625
7626   entry->next->prev = entry->prev;
7627   entry->prev->next = entry->next;
7628   --list->n_list;
7629 }
7630
7631 /* Update relocation list object so that it lists all relocations that cross
7632    [first; last] range.  Range bounds should not decrease with successive
7633    invocations.  */
7634 static void reloc_range_list_update_range (reloc_range_list *list,
7635                                            bfd_vma first, bfd_vma last)
7636 {
7637   /* This should not happen: EBBs are iterated from lower addresses to higher.
7638      But even if that happens there's no need to break: just flush current list
7639      and start from scratch.  */
7640   if ((list->last > 0 && list->range[list->last - 1].addr > last) ||
7641       (list->first > 0 && list->range[list->first - 1].addr >= first))
7642     {
7643       list->first = 0;
7644       list->last = 0;
7645       list->n_list = 0;
7646       list->list_root.next = &list->list_root;
7647       list->list_root.prev = &list->list_root;
7648       fprintf (stderr, "%s: move backwards requested\n", __func__);
7649     }
7650
7651   for (; list->last < list->n_range &&
7652        list->range[list->last].addr <= last; ++list->last)
7653     if (list->range[list->last].add)
7654       reloc_range_list_append (list, list->range[list->last].irel_index);
7655
7656   for (; list->first < list->n_range &&
7657        list->range[list->first].addr < first; ++list->first)
7658     if (!list->range[list->first].add)
7659       reloc_range_list_remove (list, list->range[list->first].irel_index);
7660 }
7661
7662 static void free_reloc_range_list (reloc_range_list *list)
7663 {
7664   free (list->range);
7665   free (list->reloc);
7666 }
7667
7668 /* The compute_text_actions function will build a list of potential
7669    transformation actions for code in the extended basic block of each
7670    longcall that is optimized to a direct call.  From this list we
7671    generate a set of actions to actually perform that optimizes for
7672    space and, if not using size_opt, maintains branch target
7673    alignments.
7674
7675    These actions to be performed are placed on a per-section list.
7676    The actual changes are performed by relax_section() in the second
7677    pass.  */
7678
7679 bfd_boolean
7680 compute_text_actions (bfd *abfd,
7681                       asection *sec,
7682                       struct bfd_link_info *link_info)
7683 {
7684   xtensa_opcode *reloc_opcodes = NULL;
7685   xtensa_relax_info *relax_info;
7686   bfd_byte *contents;
7687   Elf_Internal_Rela *internal_relocs;
7688   bfd_boolean ok = TRUE;
7689   unsigned i;
7690   property_table_entry *prop_table = 0;
7691   int ptblsize = 0;
7692   bfd_size_type sec_size;
7693   reloc_range_list relevant_relocs;
7694
7695   relax_info = get_xtensa_relax_info (sec);
7696   BFD_ASSERT (relax_info);
7697   BFD_ASSERT (relax_info->src_next == relax_info->src_count);
7698
7699   /* Do nothing if the section contains no optimized longcalls.  */
7700   if (!relax_info->is_relaxable_asm_section)
7701     return ok;
7702
7703   internal_relocs = retrieve_internal_relocs (abfd, sec,
7704                                               link_info->keep_memory);
7705
7706   if (internal_relocs)
7707     qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7708            internal_reloc_compare);
7709
7710   sec_size = bfd_get_section_limit (abfd, sec);
7711   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7712   if (contents == NULL && sec_size != 0)
7713     {
7714       ok = FALSE;
7715       goto error_return;
7716     }
7717
7718   ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7719                                         XTENSA_PROP_SEC_NAME, FALSE);
7720   if (ptblsize < 0)
7721     {
7722       ok = FALSE;
7723       goto error_return;
7724     }
7725
7726   /* Precompute the opcode for each relocation.  */
7727   reloc_opcodes = build_reloc_opcodes (abfd, sec, contents, internal_relocs);
7728
7729   build_reloc_ranges (abfd, sec, contents, internal_relocs, reloc_opcodes,
7730                       &relevant_relocs);
7731
7732   for (i = 0; i < sec->reloc_count; i++)
7733     {
7734       Elf_Internal_Rela *irel = &internal_relocs[i];
7735       bfd_vma r_offset;
7736       property_table_entry *the_entry;
7737       int ptbl_idx;
7738       ebb_t *ebb;
7739       ebb_constraint ebb_table;
7740       bfd_size_type simplify_size;
7741
7742       if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
7743         continue;
7744       r_offset = irel->r_offset;
7745
7746       simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
7747       if (simplify_size == 0)
7748         {
7749           (*_bfd_error_handler)
7750             (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
7751              sec->owner, sec, r_offset);
7752           continue;
7753         }
7754
7755       /* If the instruction table is not around, then don't do this
7756          relaxation.  */
7757       the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7758                                                   sec->vma + irel->r_offset);
7759       if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
7760         {
7761           text_action_add (&relax_info->action_list,
7762                            ta_convert_longcall, sec, r_offset,
7763                            0);
7764           continue;
7765         }
7766
7767       /* If the next longcall happens to be at the same address as an
7768          unreachable section of size 0, then skip forward.  */
7769       ptbl_idx = the_entry - prop_table;
7770       while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
7771              && the_entry->size == 0
7772              && ptbl_idx + 1 < ptblsize
7773              && (prop_table[ptbl_idx + 1].address
7774                  == prop_table[ptbl_idx].address))
7775         {
7776           ptbl_idx++;
7777           the_entry++;
7778         }
7779
7780       if (the_entry->flags & XTENSA_PROP_NO_TRANSFORM)
7781           /* NO_REORDER is OK */
7782         continue;
7783
7784       init_ebb_constraint (&ebb_table);
7785       ebb = &ebb_table.ebb;
7786       init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
7787                 internal_relocs, sec->reloc_count);
7788       ebb->start_offset = r_offset + simplify_size;
7789       ebb->end_offset = r_offset + simplify_size;
7790       ebb->start_ptbl_idx = ptbl_idx;
7791       ebb->end_ptbl_idx = ptbl_idx;
7792       ebb->start_reloc_idx = i;
7793       ebb->end_reloc_idx = i;
7794
7795       if (!extend_ebb_bounds (ebb)
7796           || !compute_ebb_proposed_actions (&ebb_table)
7797           || !compute_ebb_actions (&ebb_table)
7798           || !check_section_ebb_pcrels_fit (abfd, sec, contents,
7799                                             internal_relocs,
7800                                             &relevant_relocs,
7801                                             &ebb_table, reloc_opcodes)
7802           || !check_section_ebb_reduces (&ebb_table))
7803         {
7804           /* If anything goes wrong or we get unlucky and something does
7805              not fit, with our plan because of expansion between
7806              critical branches, just convert to a NOP.  */
7807
7808           text_action_add (&relax_info->action_list,
7809                            ta_convert_longcall, sec, r_offset, 0);
7810           i = ebb_table.ebb.end_reloc_idx;
7811           free_ebb_constraint (&ebb_table);
7812           continue;
7813         }
7814
7815       text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
7816
7817       /* Update the index so we do not go looking at the relocations
7818          we have already processed.  */
7819       i = ebb_table.ebb.end_reloc_idx;
7820       free_ebb_constraint (&ebb_table);
7821     }
7822
7823   free_reloc_range_list (&relevant_relocs);
7824
7825 #if DEBUG
7826   if (action_list_count (&relax_info->action_list))
7827     print_action_list (stderr, &relax_info->action_list);
7828 #endif
7829
7830 error_return:
7831   release_contents (sec, contents);
7832   release_internal_relocs (sec, internal_relocs);
7833   if (prop_table)
7834     free (prop_table);
7835   if (reloc_opcodes)
7836     free (reloc_opcodes);
7837
7838   return ok;
7839 }
7840
7841
7842 /* Do not widen an instruction if it is preceeded by a
7843    loop opcode.  It might cause misalignment.  */
7844
7845 static bfd_boolean
7846 prev_instr_is_a_loop (bfd_byte *contents,
7847                       bfd_size_type content_length,
7848                       bfd_size_type offset)
7849 {
7850   xtensa_opcode prev_opcode;
7851
7852   if (offset < 3)
7853     return FALSE;
7854   prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
7855   return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
7856 }
7857
7858
7859 /* Find all of the possible actions for an extended basic block.  */
7860
7861 bfd_boolean
7862 compute_ebb_proposed_actions (ebb_constraint *ebb_table)
7863 {
7864   const ebb_t *ebb = &ebb_table->ebb;
7865   unsigned rel_idx = ebb->start_reloc_idx;
7866   property_table_entry *entry, *start_entry, *end_entry;
7867   bfd_vma offset = 0;
7868   xtensa_isa isa = xtensa_default_isa;
7869   xtensa_format fmt;
7870   static xtensa_insnbuf insnbuf = NULL;
7871   static xtensa_insnbuf slotbuf = NULL;
7872
7873   if (insnbuf == NULL)
7874     {
7875       insnbuf = xtensa_insnbuf_alloc (isa);
7876       slotbuf = xtensa_insnbuf_alloc (isa);
7877     }
7878
7879   start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
7880   end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
7881
7882   for (entry = start_entry; entry <= end_entry; entry++)
7883     {
7884       bfd_vma start_offset, end_offset;
7885       bfd_size_type insn_len;
7886
7887       start_offset = entry->address - ebb->sec->vma;
7888       end_offset = entry->address + entry->size - ebb->sec->vma;
7889
7890       if (entry == start_entry)
7891         start_offset = ebb->start_offset;
7892       if (entry == end_entry)
7893         end_offset = ebb->end_offset;
7894       offset = start_offset;
7895
7896       if (offset == entry->address - ebb->sec->vma
7897           && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
7898         {
7899           enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
7900           BFD_ASSERT (offset != end_offset);
7901           if (offset == end_offset)
7902             return FALSE;
7903
7904           insn_len = insn_decode_len (ebb->contents, ebb->content_length,
7905                                       offset);
7906           if (insn_len == 0)
7907             goto decode_error;
7908
7909           if (check_branch_target_aligned_address (offset, insn_len))
7910             align_type = EBB_REQUIRE_TGT_ALIGN;
7911
7912           ebb_propose_action (ebb_table, align_type, 0,
7913                               ta_none, offset, 0, TRUE);
7914         }
7915
7916       while (offset != end_offset)
7917         {
7918           Elf_Internal_Rela *irel;
7919           xtensa_opcode opcode;
7920
7921           while (rel_idx < ebb->end_reloc_idx
7922                  && (ebb->relocs[rel_idx].r_offset < offset
7923                      || (ebb->relocs[rel_idx].r_offset == offset
7924                          && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
7925                              != R_XTENSA_ASM_SIMPLIFY))))
7926             rel_idx++;
7927
7928           /* Check for longcall.  */
7929           irel = &ebb->relocs[rel_idx];
7930           if (irel->r_offset == offset
7931               && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
7932             {
7933               bfd_size_type simplify_size;
7934
7935               simplify_size = get_asm_simplify_size (ebb->contents,
7936                                                      ebb->content_length,
7937                                                      irel->r_offset);
7938               if (simplify_size == 0)
7939                 goto decode_error;
7940
7941               ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7942                                   ta_convert_longcall, offset, 0, TRUE);
7943
7944               offset += simplify_size;
7945               continue;
7946             }
7947
7948           if (offset + MIN_INSN_LENGTH > ebb->content_length)
7949             goto decode_error;
7950           xtensa_insnbuf_from_chars (isa, insnbuf, &ebb->contents[offset],
7951                                      ebb->content_length - offset);
7952           fmt = xtensa_format_decode (isa, insnbuf);
7953           if (fmt == XTENSA_UNDEFINED)
7954             goto decode_error;
7955           insn_len = xtensa_format_length (isa, fmt);
7956           if (insn_len == (bfd_size_type) XTENSA_UNDEFINED)
7957             goto decode_error;
7958
7959           if (xtensa_format_num_slots (isa, fmt) != 1)
7960             {
7961               offset += insn_len;
7962               continue;
7963             }
7964
7965           xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7966           opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7967           if (opcode == XTENSA_UNDEFINED)
7968             goto decode_error;
7969
7970           if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
7971               && (entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7972               && can_narrow_instruction (slotbuf, fmt, opcode) != 0)
7973             {
7974               /* Add an instruction narrow action.  */
7975               ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7976                                   ta_narrow_insn, offset, 0, FALSE);
7977             }
7978           else if ((entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7979                    && can_widen_instruction (slotbuf, fmt, opcode) != 0
7980                    && ! prev_instr_is_a_loop (ebb->contents,
7981                                               ebb->content_length, offset))
7982             {
7983               /* Add an instruction widen action.  */
7984               ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7985                                   ta_widen_insn, offset, 0, FALSE);
7986             }
7987           else if (xtensa_opcode_is_loop (xtensa_default_isa, opcode) == 1)
7988             {
7989               /* Check for branch targets.  */
7990               ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
7991                                   ta_none, offset, 0, TRUE);
7992             }
7993
7994           offset += insn_len;
7995         }
7996     }
7997
7998   if (ebb->ends_unreachable)
7999     {
8000       ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
8001                           ta_fill, ebb->end_offset, 0, TRUE);
8002     }
8003
8004   return TRUE;
8005
8006  decode_error:
8007   (*_bfd_error_handler)
8008     (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
8009      ebb->sec->owner, ebb->sec, offset);
8010   return FALSE;
8011 }
8012
8013
8014 /* After all of the information has collected about the
8015    transformations possible in an EBB, compute the appropriate actions
8016    here in compute_ebb_actions.  We still must check later to make
8017    sure that the actions do not break any relocations.  The algorithm
8018    used here is pretty greedy.  Basically, it removes as many no-ops
8019    as possible so that the end of the EBB has the same alignment
8020    characteristics as the original.  First, it uses narrowing, then
8021    fill space at the end of the EBB, and finally widenings.  If that
8022    does not work, it tries again with one fewer no-op removed.  The
8023    optimization will only be performed if all of the branch targets
8024    that were aligned before transformation are also aligned after the
8025    transformation.
8026
8027    When the size_opt flag is set, ignore the branch target alignments,
8028    narrow all wide instructions, and remove all no-ops unless the end
8029    of the EBB prevents it.  */
8030
8031 bfd_boolean
8032 compute_ebb_actions (ebb_constraint *ebb_table)
8033 {
8034   unsigned i = 0;
8035   unsigned j;
8036   int removed_bytes = 0;
8037   ebb_t *ebb = &ebb_table->ebb;
8038   unsigned seg_idx_start = 0;
8039   unsigned seg_idx_end = 0;
8040
8041   /* We perform this like the assembler relaxation algorithm: Start by
8042      assuming all instructions are narrow and all no-ops removed; then
8043      walk through....  */
8044
8045   /* For each segment of this that has a solid constraint, check to
8046      see if there are any combinations that will keep the constraint.
8047      If so, use it.  */
8048   for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
8049     {
8050       bfd_boolean requires_text_end_align = FALSE;
8051       unsigned longcall_count = 0;
8052       unsigned longcall_convert_count = 0;
8053       unsigned narrowable_count = 0;
8054       unsigned narrowable_convert_count = 0;
8055       unsigned widenable_count = 0;
8056       unsigned widenable_convert_count = 0;
8057
8058       proposed_action *action = NULL;
8059       int align = (1 << ebb_table->ebb.sec->alignment_power);
8060
8061       seg_idx_start = seg_idx_end;
8062
8063       for (i = seg_idx_start; i < ebb_table->action_count; i++)
8064         {
8065           action = &ebb_table->actions[i];
8066           if (action->action == ta_convert_longcall)
8067             longcall_count++;
8068           if (action->action == ta_narrow_insn)
8069             narrowable_count++;
8070           if (action->action == ta_widen_insn)
8071             widenable_count++;
8072           if (action->action == ta_fill)
8073             break;
8074           if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
8075             break;
8076           if (action->align_type == EBB_REQUIRE_TGT_ALIGN
8077               && !elf32xtensa_size_opt)
8078             break;
8079         }
8080       seg_idx_end = i;
8081
8082       if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
8083         requires_text_end_align = TRUE;
8084
8085       if (elf32xtensa_size_opt && !requires_text_end_align
8086           && action->align_type != EBB_REQUIRE_LOOP_ALIGN
8087           && action->align_type != EBB_REQUIRE_TGT_ALIGN)
8088         {
8089           longcall_convert_count = longcall_count;
8090           narrowable_convert_count = narrowable_count;
8091           widenable_convert_count = 0;
8092         }
8093       else
8094         {
8095           /* There is a constraint.  Convert the max number of longcalls.  */
8096           narrowable_convert_count = 0;
8097           longcall_convert_count = 0;
8098           widenable_convert_count = 0;
8099
8100           for (j = 0; j < longcall_count; j++)
8101             {
8102               int removed = (longcall_count - j) * 3 & (align - 1);
8103               unsigned desire_narrow = (align - removed) & (align - 1);
8104               unsigned desire_widen = removed;
8105               if (desire_narrow <= narrowable_count)
8106                 {
8107                   narrowable_convert_count = desire_narrow;
8108                   narrowable_convert_count +=
8109                     (align * ((narrowable_count - narrowable_convert_count)
8110                               / align));
8111                   longcall_convert_count = (longcall_count - j);
8112                   widenable_convert_count = 0;
8113                   break;
8114                 }
8115               if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
8116                 {
8117                   narrowable_convert_count = 0;
8118                   longcall_convert_count = longcall_count - j;
8119                   widenable_convert_count = desire_widen;
8120                   break;
8121                 }
8122             }
8123         }
8124
8125       /* Now the number of conversions are saved.  Do them.  */
8126       for (i = seg_idx_start; i < seg_idx_end; i++)
8127         {
8128           action = &ebb_table->actions[i];
8129           switch (action->action)
8130             {
8131             case ta_convert_longcall:
8132               if (longcall_convert_count != 0)
8133                 {
8134                   action->action = ta_remove_longcall;
8135                   action->do_action = TRUE;
8136                   action->removed_bytes += 3;
8137                   longcall_convert_count--;
8138                 }
8139               break;
8140             case ta_narrow_insn:
8141               if (narrowable_convert_count != 0)
8142                 {
8143                   action->do_action = TRUE;
8144                   action->removed_bytes += 1;
8145                   narrowable_convert_count--;
8146                 }
8147               break;
8148             case ta_widen_insn:
8149               if (widenable_convert_count != 0)
8150                 {
8151                   action->do_action = TRUE;
8152                   action->removed_bytes -= 1;
8153                   widenable_convert_count--;
8154                 }
8155               break;
8156             default:
8157               break;
8158             }
8159         }
8160     }
8161
8162   /* Now we move on to some local opts.  Try to remove each of the
8163      remaining longcalls.  */
8164
8165   if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
8166     {
8167       removed_bytes = 0;
8168       for (i = 0; i < ebb_table->action_count; i++)
8169         {
8170           int old_removed_bytes = removed_bytes;
8171           proposed_action *action = &ebb_table->actions[i];
8172
8173           if (action->do_action && action->action == ta_convert_longcall)
8174             {
8175               bfd_boolean bad_alignment = FALSE;
8176               removed_bytes += 3;
8177               for (j = i + 1; j < ebb_table->action_count; j++)
8178                 {
8179                   proposed_action *new_action = &ebb_table->actions[j];
8180                   bfd_vma offset = new_action->offset;
8181                   if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
8182                     {
8183                       if (!check_branch_target_aligned
8184                           (ebb_table->ebb.contents,
8185                            ebb_table->ebb.content_length,
8186                            offset, offset - removed_bytes))
8187                         {
8188                           bad_alignment = TRUE;
8189                           break;
8190                         }
8191                     }
8192                   if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
8193                     {
8194                       if (!check_loop_aligned (ebb_table->ebb.contents,
8195                                                ebb_table->ebb.content_length,
8196                                                offset,
8197                                                offset - removed_bytes))
8198                         {
8199                           bad_alignment = TRUE;
8200                           break;
8201                         }
8202                     }
8203                   if (new_action->action == ta_narrow_insn
8204                       && !new_action->do_action
8205                       && ebb_table->ebb.sec->alignment_power == 2)
8206                     {
8207                       /* Narrow an instruction and we are done.  */
8208                       new_action->do_action = TRUE;
8209                       new_action->removed_bytes += 1;
8210                       bad_alignment = FALSE;
8211                       break;
8212                     }
8213                   if (new_action->action == ta_widen_insn
8214                       && new_action->do_action
8215                       && ebb_table->ebb.sec->alignment_power == 2)
8216                     {
8217                       /* Narrow an instruction and we are done.  */
8218                       new_action->do_action = FALSE;
8219                       new_action->removed_bytes += 1;
8220                       bad_alignment = FALSE;
8221                       break;
8222                     }
8223                   if (new_action->do_action)
8224                     removed_bytes += new_action->removed_bytes;
8225                 }
8226               if (!bad_alignment)
8227                 {
8228                   action->removed_bytes += 3;
8229                   action->action = ta_remove_longcall;
8230                   action->do_action = TRUE;
8231                 }
8232             }
8233           removed_bytes = old_removed_bytes;
8234           if (action->do_action)
8235             removed_bytes += action->removed_bytes;
8236         }
8237     }
8238
8239   removed_bytes = 0;
8240   for (i = 0; i < ebb_table->action_count; ++i)
8241     {
8242       proposed_action *action = &ebb_table->actions[i];
8243       if (action->do_action)
8244         removed_bytes += action->removed_bytes;
8245     }
8246
8247   if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
8248       && ebb->ends_unreachable)
8249     {
8250       proposed_action *action;
8251       int br;
8252       int extra_space;
8253
8254       BFD_ASSERT (ebb_table->action_count != 0);
8255       action = &ebb_table->actions[ebb_table->action_count - 1];
8256       BFD_ASSERT (action->action == ta_fill);
8257       BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
8258
8259       extra_space = compute_fill_extra_space (ebb->ends_unreachable);
8260       br = action->removed_bytes + removed_bytes + extra_space;
8261       br = br & ((1 << ebb->sec->alignment_power ) - 1);
8262
8263       action->removed_bytes = extra_space - br;
8264     }
8265   return TRUE;
8266 }
8267
8268
8269 /* The xlate_map is a sorted array of address mappings designed to
8270    answer the offset_with_removed_text() query with a binary search instead
8271    of a linear search through the section's action_list.  */
8272
8273 typedef struct xlate_map_entry xlate_map_entry_t;
8274 typedef struct xlate_map xlate_map_t;
8275
8276 struct xlate_map_entry
8277 {
8278   unsigned orig_address;
8279   unsigned new_address;
8280   unsigned size;
8281 };
8282
8283 struct xlate_map
8284 {
8285   unsigned entry_count;
8286   xlate_map_entry_t *entry;
8287 };
8288
8289
8290 static int
8291 xlate_compare (const void *a_v, const void *b_v)
8292 {
8293   const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
8294   const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
8295   if (a->orig_address < b->orig_address)
8296     return -1;
8297   if (a->orig_address > (b->orig_address + b->size - 1))
8298     return 1;
8299   return 0;
8300 }
8301
8302
8303 static bfd_vma
8304 xlate_offset_with_removed_text (const xlate_map_t *map,
8305                                 text_action_list *action_list,
8306                                 bfd_vma offset)
8307 {
8308   void *r;
8309   xlate_map_entry_t *e;
8310
8311   if (map == NULL)
8312     return offset_with_removed_text (action_list, offset);
8313
8314   if (map->entry_count == 0)
8315     return offset;
8316
8317   r = bsearch (&offset, map->entry, map->entry_count,
8318                sizeof (xlate_map_entry_t), &xlate_compare);
8319   e = (xlate_map_entry_t *) r;
8320
8321   BFD_ASSERT (e != NULL);
8322   if (e == NULL)
8323     return offset;
8324   return e->new_address - e->orig_address + offset;
8325 }
8326
8327 typedef struct xlate_map_context_struct xlate_map_context;
8328 struct xlate_map_context_struct
8329 {
8330   xlate_map_t *map;
8331   xlate_map_entry_t *current_entry;
8332   int removed;
8333 };
8334
8335 static int
8336 xlate_map_fn (splay_tree_node node, void *p)
8337 {
8338   text_action *r = (text_action *)node->value;
8339   xlate_map_context *ctx = p;
8340   unsigned orig_size = 0;
8341
8342   switch (r->action)
8343     {
8344     case ta_none:
8345     case ta_remove_insn:
8346     case ta_convert_longcall:
8347     case ta_remove_literal:
8348     case ta_add_literal:
8349       break;
8350     case ta_remove_longcall:
8351       orig_size = 6;
8352       break;
8353     case ta_narrow_insn:
8354       orig_size = 3;
8355       break;
8356     case ta_widen_insn:
8357       orig_size = 2;
8358       break;
8359     case ta_fill:
8360       break;
8361     }
8362   ctx->current_entry->size =
8363     r->offset + orig_size - ctx->current_entry->orig_address;
8364   if (ctx->current_entry->size != 0)
8365     {
8366       ctx->current_entry++;
8367       ctx->map->entry_count++;
8368     }
8369   ctx->current_entry->orig_address = r->offset + orig_size;
8370   ctx->removed += r->removed_bytes;
8371   ctx->current_entry->new_address = r->offset + orig_size - ctx->removed;
8372   ctx->current_entry->size = 0;
8373   return 0;
8374 }
8375
8376 /* Build a binary searchable offset translation map from a section's
8377    action list.  */
8378
8379 static xlate_map_t *
8380 build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
8381 {
8382   text_action_list *action_list = &relax_info->action_list;
8383   unsigned num_actions = 0;
8384   xlate_map_context ctx;
8385
8386   ctx.map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
8387
8388   if (ctx.map == NULL)
8389     return NULL;
8390
8391   num_actions = action_list_count (action_list);
8392   ctx.map->entry = (xlate_map_entry_t *)
8393     bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
8394   if (ctx.map->entry == NULL)
8395     {
8396       free (ctx.map);
8397       return NULL;
8398     }
8399   ctx.map->entry_count = 0;
8400
8401   ctx.removed = 0;
8402   ctx.current_entry = &ctx.map->entry[0];
8403
8404   ctx.current_entry->orig_address = 0;
8405   ctx.current_entry->new_address = 0;
8406   ctx.current_entry->size = 0;
8407
8408   splay_tree_foreach (action_list->tree, xlate_map_fn, &ctx);
8409
8410   ctx.current_entry->size = (bfd_get_section_limit (sec->owner, sec)
8411                              - ctx.current_entry->orig_address);
8412   if (ctx.current_entry->size != 0)
8413     ctx.map->entry_count++;
8414
8415   return ctx.map;
8416 }
8417
8418
8419 /* Free an offset translation map.  */
8420
8421 static void
8422 free_xlate_map (xlate_map_t *map)
8423 {
8424   if (map && map->entry)
8425     free (map->entry);
8426   if (map)
8427     free (map);
8428 }
8429
8430
8431 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8432    relocations in a section will fit if a proposed set of actions
8433    are performed.  */
8434
8435 static bfd_boolean
8436 check_section_ebb_pcrels_fit (bfd *abfd,
8437                               asection *sec,
8438                               bfd_byte *contents,
8439                               Elf_Internal_Rela *internal_relocs,
8440                               reloc_range_list *relevant_relocs,
8441                               const ebb_constraint *constraint,
8442                               const xtensa_opcode *reloc_opcodes)
8443 {
8444   unsigned i, j;
8445   unsigned n = sec->reloc_count;
8446   Elf_Internal_Rela *irel;
8447   xlate_map_t *xmap = NULL;
8448   bfd_boolean ok = TRUE;
8449   xtensa_relax_info *relax_info;
8450   reloc_range_list_entry *entry = NULL;
8451
8452   relax_info = get_xtensa_relax_info (sec);
8453
8454   if (relax_info && sec->reloc_count > 100)
8455     {
8456       xmap = build_xlate_map (sec, relax_info);
8457       /* NULL indicates out of memory, but the slow version
8458          can still be used.  */
8459     }
8460
8461   if (relevant_relocs && constraint->action_count)
8462     {
8463       if (!relevant_relocs->ok)
8464         {
8465           ok = FALSE;
8466           n = 0;
8467         }
8468       else
8469         {
8470           bfd_vma min_offset, max_offset;
8471           min_offset = max_offset = constraint->actions[0].offset;
8472
8473           for (i = 1; i < constraint->action_count; ++i)
8474             {
8475               proposed_action *action = &constraint->actions[i];
8476               bfd_vma offset = action->offset;
8477
8478               if (offset < min_offset)
8479                 min_offset = offset;
8480               if (offset > max_offset)
8481                 max_offset = offset;
8482             }
8483           reloc_range_list_update_range (relevant_relocs, min_offset,
8484                                          max_offset);
8485           n = relevant_relocs->n_list;
8486           entry = &relevant_relocs->list_root;
8487         }
8488     }
8489   else
8490     {
8491       relevant_relocs = NULL;
8492     }
8493
8494   for (i = 0; i < n; i++)
8495     {
8496       r_reloc r_rel;
8497       bfd_vma orig_self_offset, orig_target_offset;
8498       bfd_vma self_offset, target_offset;
8499       int r_type;
8500       reloc_howto_type *howto;
8501       int self_removed_bytes, target_removed_bytes;
8502
8503       if (relevant_relocs)
8504         {
8505           entry = entry->next;
8506           irel = entry->irel;
8507         }
8508       else
8509         {
8510           irel = internal_relocs + i;
8511         }
8512       r_type = ELF32_R_TYPE (irel->r_info);
8513
8514       howto = &elf_howto_table[r_type];
8515       /* We maintain the required invariant: PC-relative relocations
8516          that fit before linking must fit after linking.  Thus we only
8517          need to deal with relocations to the same section that are
8518          PC-relative.  */
8519       if (r_type == R_XTENSA_ASM_SIMPLIFY
8520           || r_type == R_XTENSA_32_PCREL
8521           || !howto->pc_relative)
8522         continue;
8523
8524       r_reloc_init (&r_rel, abfd, irel, contents,
8525                     bfd_get_section_limit (abfd, sec));
8526
8527       if (r_reloc_get_section (&r_rel) != sec)
8528         continue;
8529
8530       orig_self_offset = irel->r_offset;
8531       orig_target_offset = r_rel.target_offset;
8532
8533       self_offset = orig_self_offset;
8534       target_offset = orig_target_offset;
8535
8536       if (relax_info)
8537         {
8538           self_offset =
8539             xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8540                                             orig_self_offset);
8541           target_offset =
8542             xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8543                                             orig_target_offset);
8544         }
8545
8546       self_removed_bytes = 0;
8547       target_removed_bytes = 0;
8548
8549       for (j = 0; j < constraint->action_count; ++j)
8550         {
8551           proposed_action *action = &constraint->actions[j];
8552           bfd_vma offset = action->offset;
8553           int removed_bytes = action->removed_bytes;
8554           if (offset < orig_self_offset
8555               || (offset == orig_self_offset && action->action == ta_fill
8556                   && action->removed_bytes < 0))
8557             self_removed_bytes += removed_bytes;
8558           if (offset < orig_target_offset
8559               || (offset == orig_target_offset && action->action == ta_fill
8560                   && action->removed_bytes < 0))
8561             target_removed_bytes += removed_bytes;
8562         }
8563       self_offset -= self_removed_bytes;
8564       target_offset -= target_removed_bytes;
8565
8566       /* Try to encode it.  Get the operand and check.  */
8567       if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
8568         {
8569           /* None of the current alternate relocs are PC-relative,
8570              and only PC-relative relocs matter here.  */
8571         }
8572       else
8573         {
8574           xtensa_opcode opcode;
8575           int opnum;
8576
8577           if (relevant_relocs)
8578             {
8579               opcode = entry->opcode;
8580               opnum = entry->opnum;
8581             }
8582           else
8583             {
8584               if (reloc_opcodes)
8585                 opcode = reloc_opcodes[relevant_relocs ?
8586                   (unsigned)(entry - relevant_relocs->reloc) : i];
8587               else
8588                 opcode = get_relocation_opcode (abfd, sec, contents, irel);
8589               if (opcode == XTENSA_UNDEFINED)
8590                 {
8591                   ok = FALSE;
8592                   break;
8593                 }
8594
8595               opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
8596               if (opnum == XTENSA_UNDEFINED)
8597                 {
8598                   ok = FALSE;
8599                   break;
8600                 }
8601             }
8602
8603           if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
8604             {
8605               ok = FALSE;
8606               break;
8607             }
8608         }
8609     }
8610
8611   if (xmap)
8612     free_xlate_map (xmap);
8613
8614   return ok;
8615 }
8616
8617
8618 static bfd_boolean
8619 check_section_ebb_reduces (const ebb_constraint *constraint)
8620 {
8621   int removed = 0;
8622   unsigned i;
8623
8624   for (i = 0; i < constraint->action_count; i++)
8625     {
8626       const proposed_action *action = &constraint->actions[i];
8627       if (action->do_action)
8628         removed += action->removed_bytes;
8629     }
8630   if (removed < 0)
8631     return FALSE;
8632
8633   return TRUE;
8634 }
8635
8636
8637 void
8638 text_action_add_proposed (text_action_list *l,
8639                           const ebb_constraint *ebb_table,
8640                           asection *sec)
8641 {
8642   unsigned i;
8643
8644   for (i = 0; i < ebb_table->action_count; i++)
8645     {
8646       proposed_action *action = &ebb_table->actions[i];
8647
8648       if (!action->do_action)
8649         continue;
8650       switch (action->action)
8651         {
8652         case ta_remove_insn:
8653         case ta_remove_longcall:
8654         case ta_convert_longcall:
8655         case ta_narrow_insn:
8656         case ta_widen_insn:
8657         case ta_fill:
8658         case ta_remove_literal:
8659           text_action_add (l, action->action, sec, action->offset,
8660                            action->removed_bytes);
8661           break;
8662         case ta_none:
8663           break;
8664         default:
8665           BFD_ASSERT (0);
8666           break;
8667         }
8668     }
8669 }
8670
8671
8672 int
8673 compute_fill_extra_space (property_table_entry *entry)
8674 {
8675   int fill_extra_space;
8676
8677   if (!entry)
8678     return 0;
8679
8680   if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
8681     return 0;
8682
8683   fill_extra_space = entry->size;
8684   if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
8685     {
8686       /* Fill bytes for alignment:
8687          (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8688       int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
8689       int nsm = (1 << pow) - 1;
8690       bfd_vma addr = entry->address + entry->size;
8691       bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
8692       fill_extra_space += align_fill;
8693     }
8694   return fill_extra_space;
8695 }
8696
8697 \f
8698 /* First relaxation pass.  */
8699
8700 /* If the section contains relaxable literals, check each literal to
8701    see if it has the same value as another literal that has already
8702    been seen, either in the current section or a previous one.  If so,
8703    add an entry to the per-section list of removed literals.  The
8704    actual changes are deferred until the next pass.  */
8705
8706 static bfd_boolean
8707 compute_removed_literals (bfd *abfd,
8708                           asection *sec,
8709                           struct bfd_link_info *link_info,
8710                           value_map_hash_table *values)
8711 {
8712   xtensa_relax_info *relax_info;
8713   bfd_byte *contents;
8714   Elf_Internal_Rela *internal_relocs;
8715   source_reloc *src_relocs, *rel;
8716   bfd_boolean ok = TRUE;
8717   property_table_entry *prop_table = NULL;
8718   int ptblsize;
8719   int i, prev_i;
8720   bfd_boolean last_loc_is_prev = FALSE;
8721   bfd_vma last_target_offset = 0;
8722   section_cache_t target_sec_cache;
8723   bfd_size_type sec_size;
8724
8725   init_section_cache (&target_sec_cache);
8726
8727   /* Do nothing if it is not a relaxable literal section.  */
8728   relax_info = get_xtensa_relax_info (sec);
8729   BFD_ASSERT (relax_info);
8730   if (!relax_info->is_relaxable_literal_section)
8731     return ok;
8732
8733   internal_relocs = retrieve_internal_relocs (abfd, sec,
8734                                               link_info->keep_memory);
8735
8736   sec_size = bfd_get_section_limit (abfd, sec);
8737   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8738   if (contents == NULL && sec_size != 0)
8739     {
8740       ok = FALSE;
8741       goto error_return;
8742     }
8743
8744   /* Sort the source_relocs by target offset.  */
8745   src_relocs = relax_info->src_relocs;
8746   qsort (src_relocs, relax_info->src_count,
8747          sizeof (source_reloc), source_reloc_compare);
8748   qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
8749          internal_reloc_compare);
8750
8751   ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
8752                                         XTENSA_PROP_SEC_NAME, FALSE);
8753   if (ptblsize < 0)
8754     {
8755       ok = FALSE;
8756       goto error_return;
8757     }
8758
8759   prev_i = -1;
8760   for (i = 0; i < relax_info->src_count; i++)
8761     {
8762       Elf_Internal_Rela *irel = NULL;
8763
8764       rel = &src_relocs[i];
8765       if (get_l32r_opcode () != rel->opcode)
8766         continue;
8767       irel = get_irel_at_offset (sec, internal_relocs,
8768                                  rel->r_rel.target_offset);
8769
8770       /* If the relocation on this is not a simple R_XTENSA_32 or
8771          R_XTENSA_PLT then do not consider it.  This may happen when
8772          the difference of two symbols is used in a literal.  */
8773       if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
8774                    && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
8775         continue;
8776
8777       /* If the target_offset for this relocation is the same as the
8778          previous relocation, then we've already considered whether the
8779          literal can be coalesced.  Skip to the next one....  */
8780       if (i != 0 && prev_i != -1
8781           && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
8782         continue;
8783       prev_i = i;
8784
8785       if (last_loc_is_prev &&
8786           last_target_offset + 4 != rel->r_rel.target_offset)
8787         last_loc_is_prev = FALSE;
8788
8789       /* Check if the relocation was from an L32R that is being removed
8790          because a CALLX was converted to a direct CALL, and check if
8791          there are no other relocations to the literal.  */
8792       if (is_removable_literal (rel, i, src_relocs, relax_info->src_count,
8793                                 sec, prop_table, ptblsize))
8794         {
8795           if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
8796                                     irel, rel, prop_table, ptblsize))
8797             {
8798               ok = FALSE;
8799               goto error_return;
8800             }
8801           last_target_offset = rel->r_rel.target_offset;
8802           continue;
8803         }
8804
8805       if (!identify_literal_placement (abfd, sec, contents, link_info,
8806                                        values,
8807                                        &last_loc_is_prev, irel,
8808                                        relax_info->src_count - i, rel,
8809                                        prop_table, ptblsize,
8810                                        &target_sec_cache, rel->is_abs_literal))
8811         {
8812           ok = FALSE;
8813           goto error_return;
8814         }
8815       last_target_offset = rel->r_rel.target_offset;
8816     }
8817
8818 #if DEBUG
8819   print_removed_literals (stderr, &relax_info->removed_list);
8820   print_action_list (stderr, &relax_info->action_list);
8821 #endif /* DEBUG */
8822
8823 error_return:
8824   if (prop_table)
8825     free (prop_table);
8826   free_section_cache (&target_sec_cache);
8827
8828   release_contents (sec, contents);
8829   release_internal_relocs (sec, internal_relocs);
8830   return ok;
8831 }
8832
8833
8834 static Elf_Internal_Rela *
8835 get_irel_at_offset (asection *sec,
8836                     Elf_Internal_Rela *internal_relocs,
8837                     bfd_vma offset)
8838 {
8839   unsigned i;
8840   Elf_Internal_Rela *irel;
8841   unsigned r_type;
8842   Elf_Internal_Rela key;
8843
8844   if (!internal_relocs)
8845     return NULL;
8846
8847   key.r_offset = offset;
8848   irel = bsearch (&key, internal_relocs, sec->reloc_count,
8849                   sizeof (Elf_Internal_Rela), internal_reloc_matches);
8850   if (!irel)
8851     return NULL;
8852
8853   /* bsearch does not guarantee which will be returned if there are
8854      multiple matches.  We need the first that is not an alignment.  */
8855   i = irel - internal_relocs;
8856   while (i > 0)
8857     {
8858       if (internal_relocs[i-1].r_offset != offset)
8859         break;
8860       i--;
8861     }
8862   for ( ; i < sec->reloc_count; i++)
8863     {
8864       irel = &internal_relocs[i];
8865       r_type = ELF32_R_TYPE (irel->r_info);
8866       if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
8867         return irel;
8868     }
8869
8870   return NULL;
8871 }
8872
8873
8874 bfd_boolean
8875 is_removable_literal (const source_reloc *rel,
8876                       int i,
8877                       const source_reloc *src_relocs,
8878                       int src_count,
8879                       asection *sec,
8880                       property_table_entry *prop_table,
8881                       int ptblsize)
8882 {
8883   const source_reloc *curr_rel;
8884   property_table_entry *entry;
8885
8886   if (!rel->is_null)
8887     return FALSE;
8888
8889   entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8890                                           sec->vma + rel->r_rel.target_offset);
8891   if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8892     return FALSE;
8893
8894   for (++i; i < src_count; ++i)
8895     {
8896       curr_rel = &src_relocs[i];
8897       /* If all others have the same target offset....  */
8898       if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
8899         return TRUE;
8900
8901       if (!curr_rel->is_null
8902           && !xtensa_is_property_section (curr_rel->source_sec)
8903           && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
8904         return FALSE;
8905     }
8906   return TRUE;
8907 }
8908
8909
8910 bfd_boolean
8911 remove_dead_literal (bfd *abfd,
8912                      asection *sec,
8913                      struct bfd_link_info *link_info,
8914                      Elf_Internal_Rela *internal_relocs,
8915                      Elf_Internal_Rela *irel,
8916                      source_reloc *rel,
8917                      property_table_entry *prop_table,
8918                      int ptblsize)
8919 {
8920   property_table_entry *entry;
8921   xtensa_relax_info *relax_info;
8922
8923   relax_info = get_xtensa_relax_info (sec);
8924   if (!relax_info)
8925     return FALSE;
8926
8927   entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8928                                           sec->vma + rel->r_rel.target_offset);
8929
8930   /* Mark the unused literal so that it will be removed.  */
8931   add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
8932
8933   text_action_add (&relax_info->action_list,
8934                    ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8935
8936   /* If the section is 4-byte aligned, do not add fill.  */
8937   if (sec->alignment_power > 2)
8938     {
8939       int fill_extra_space;
8940       bfd_vma entry_sec_offset;
8941       text_action *fa;
8942       property_table_entry *the_add_entry;
8943       int removed_diff;
8944
8945       if (entry)
8946         entry_sec_offset = entry->address - sec->vma + entry->size;
8947       else
8948         entry_sec_offset = rel->r_rel.target_offset + 4;
8949
8950       /* If the literal range is at the end of the section,
8951          do not add fill.  */
8952       the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8953                                                       entry_sec_offset);
8954       fill_extra_space = compute_fill_extra_space (the_add_entry);
8955
8956       fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8957       removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8958                                                   -4, fill_extra_space);
8959       if (fa)
8960         adjust_fill_action (fa, removed_diff);
8961       else
8962         text_action_add (&relax_info->action_list,
8963                          ta_fill, sec, entry_sec_offset, removed_diff);
8964     }
8965
8966   /* Zero out the relocation on this literal location.  */
8967   if (irel)
8968     {
8969       if (elf_hash_table (link_info)->dynamic_sections_created)
8970         shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8971
8972       irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8973       pin_internal_relocs (sec, internal_relocs);
8974     }
8975
8976   /* Do not modify "last_loc_is_prev".  */
8977   return TRUE;
8978 }
8979
8980
8981 bfd_boolean
8982 identify_literal_placement (bfd *abfd,
8983                             asection *sec,
8984                             bfd_byte *contents,
8985                             struct bfd_link_info *link_info,
8986                             value_map_hash_table *values,
8987                             bfd_boolean *last_loc_is_prev_p,
8988                             Elf_Internal_Rela *irel,
8989                             int remaining_src_rels,
8990                             source_reloc *rel,
8991                             property_table_entry *prop_table,
8992                             int ptblsize,
8993                             section_cache_t *target_sec_cache,
8994                             bfd_boolean is_abs_literal)
8995 {
8996   literal_value val;
8997   value_map *val_map;
8998   xtensa_relax_info *relax_info;
8999   bfd_boolean literal_placed = FALSE;
9000   r_reloc r_rel;
9001   unsigned long value;
9002   bfd_boolean final_static_link;
9003   bfd_size_type sec_size;
9004
9005   relax_info = get_xtensa_relax_info (sec);
9006   if (!relax_info)
9007     return FALSE;
9008
9009   sec_size = bfd_get_section_limit (abfd, sec);
9010
9011   final_static_link =
9012     (!bfd_link_relocatable (link_info)
9013      && !elf_hash_table (link_info)->dynamic_sections_created);
9014
9015   /* The placement algorithm first checks to see if the literal is
9016      already in the value map.  If so and the value map is reachable
9017      from all uses, then the literal is moved to that location.  If
9018      not, then we identify the last location where a fresh literal was
9019      placed.  If the literal can be safely moved there, then we do so.
9020      If not, then we assume that the literal is not to move and leave
9021      the literal where it is, marking it as the last literal
9022      location.  */
9023
9024   /* Find the literal value.  */
9025   value = 0;
9026   r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
9027   if (!irel)
9028     {
9029       BFD_ASSERT (rel->r_rel.target_offset < sec_size);
9030       value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
9031     }
9032   init_literal_value (&val, &r_rel, value, is_abs_literal);
9033
9034   /* Check if we've seen another literal with the same value that
9035      is in the same output section.  */
9036   val_map = value_map_get_cached_value (values, &val, final_static_link);
9037
9038   if (val_map
9039       && (r_reloc_get_section (&val_map->loc)->output_section
9040           == sec->output_section)
9041       && relocations_reach (rel, remaining_src_rels, &val_map->loc)
9042       && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
9043     {
9044       /* No change to last_loc_is_prev.  */
9045       literal_placed = TRUE;
9046     }
9047
9048   /* For relocatable links, do not try to move literals.  To do it
9049      correctly might increase the number of relocations in an input
9050      section making the default relocatable linking fail.  */
9051   if (!bfd_link_relocatable (link_info) && !literal_placed
9052       && values->has_last_loc && !(*last_loc_is_prev_p))
9053     {
9054       asection *target_sec = r_reloc_get_section (&values->last_loc);
9055       if (target_sec && target_sec->output_section == sec->output_section)
9056         {
9057           /* Increment the virtual offset.  */
9058           r_reloc try_loc = values->last_loc;
9059           try_loc.virtual_offset += 4;
9060
9061           /* There is a last loc that was in the same output section.  */
9062           if (relocations_reach (rel, remaining_src_rels, &try_loc)
9063               && move_shared_literal (sec, link_info, rel,
9064                                       prop_table, ptblsize,
9065                                       &try_loc, &val, target_sec_cache))
9066             {
9067               values->last_loc.virtual_offset += 4;
9068               literal_placed = TRUE;
9069               if (!val_map)
9070                 val_map = add_value_map (values, &val, &try_loc,
9071                                          final_static_link);
9072               else
9073                 val_map->loc = try_loc;
9074             }
9075         }
9076     }
9077
9078   if (!literal_placed)
9079     {
9080       /* Nothing worked, leave the literal alone but update the last loc.  */
9081       values->has_last_loc = TRUE;
9082       values->last_loc = rel->r_rel;
9083       if (!val_map)
9084         val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
9085       else
9086         val_map->loc = rel->r_rel;
9087       *last_loc_is_prev_p = TRUE;
9088     }
9089
9090   return TRUE;
9091 }
9092
9093
9094 /* Check if the original relocations (presumably on L32R instructions)
9095    identified by reloc[0..N] can be changed to reference the literal
9096    identified by r_rel.  If r_rel is out of range for any of the
9097    original relocations, then we don't want to coalesce the original
9098    literal with the one at r_rel.  We only check reloc[0..N], where the
9099    offsets are all the same as for reloc[0] (i.e., they're all
9100    referencing the same literal) and where N is also bounded by the
9101    number of remaining entries in the "reloc" array.  The "reloc" array
9102    is sorted by target offset so we know all the entries for the same
9103    literal will be contiguous.  */
9104
9105 static bfd_boolean
9106 relocations_reach (source_reloc *reloc,
9107                    int remaining_relocs,
9108                    const r_reloc *r_rel)
9109 {
9110   bfd_vma from_offset, source_address, dest_address;
9111   asection *sec;
9112   int i;
9113
9114   if (!r_reloc_is_defined (r_rel))
9115     return FALSE;
9116
9117   sec = r_reloc_get_section (r_rel);
9118   from_offset = reloc[0].r_rel.target_offset;
9119
9120   for (i = 0; i < remaining_relocs; i++)
9121     {
9122       if (reloc[i].r_rel.target_offset != from_offset)
9123         break;
9124
9125       /* Ignore relocations that have been removed.  */
9126       if (reloc[i].is_null)
9127         continue;
9128
9129       /* The original and new output section for these must be the same
9130          in order to coalesce.  */
9131       if (r_reloc_get_section (&reloc[i].r_rel)->output_section
9132           != sec->output_section)
9133         return FALSE;
9134
9135       /* Absolute literals in the same output section can always be
9136          combined.  */
9137       if (reloc[i].is_abs_literal)
9138         continue;
9139
9140       /* A literal with no PC-relative relocations can be moved anywhere.  */
9141       if (reloc[i].opnd != -1)
9142         {
9143           /* Otherwise, check to see that it fits.  */
9144           source_address = (reloc[i].source_sec->output_section->vma
9145                             + reloc[i].source_sec->output_offset
9146                             + reloc[i].r_rel.rela.r_offset);
9147           dest_address = (sec->output_section->vma
9148                           + sec->output_offset
9149                           + r_rel->target_offset);
9150
9151           if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
9152                                  source_address, dest_address))
9153             return FALSE;
9154         }
9155     }
9156
9157   return TRUE;
9158 }
9159
9160
9161 /* Move a literal to another literal location because it is
9162    the same as the other literal value.  */
9163
9164 static bfd_boolean
9165 coalesce_shared_literal (asection *sec,
9166                          source_reloc *rel,
9167                          property_table_entry *prop_table,
9168                          int ptblsize,
9169                          value_map *val_map)
9170 {
9171   property_table_entry *entry;
9172   text_action *fa;
9173   property_table_entry *the_add_entry;
9174   int removed_diff;
9175   xtensa_relax_info *relax_info;
9176
9177   relax_info = get_xtensa_relax_info (sec);
9178   if (!relax_info)
9179     return FALSE;
9180
9181   entry = elf_xtensa_find_property_entry
9182     (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
9183   if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
9184     return TRUE;
9185
9186   /* Mark that the literal will be coalesced.  */
9187   add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
9188
9189   text_action_add (&relax_info->action_list,
9190                    ta_remove_literal, sec, rel->r_rel.target_offset, 4);
9191
9192   /* If the section is 4-byte aligned, do not add fill.  */
9193   if (sec->alignment_power > 2)
9194     {
9195       int fill_extra_space;
9196       bfd_vma entry_sec_offset;
9197
9198       if (entry)
9199         entry_sec_offset = entry->address - sec->vma + entry->size;
9200       else
9201         entry_sec_offset = rel->r_rel.target_offset + 4;
9202
9203       /* If the literal range is at the end of the section,
9204          do not add fill.  */
9205       fill_extra_space = 0;
9206       the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
9207                                                       entry_sec_offset);
9208       if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9209         fill_extra_space = the_add_entry->size;
9210
9211       fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
9212       removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
9213                                                   -4, fill_extra_space);
9214       if (fa)
9215         adjust_fill_action (fa, removed_diff);
9216       else
9217         text_action_add (&relax_info->action_list,
9218                          ta_fill, sec, entry_sec_offset, removed_diff);
9219     }
9220
9221   return TRUE;
9222 }
9223
9224
9225 /* Move a literal to another location.  This may actually increase the
9226    total amount of space used because of alignments so we need to do
9227    this carefully.  Also, it may make a branch go out of range.  */
9228
9229 static bfd_boolean
9230 move_shared_literal (asection *sec,
9231                      struct bfd_link_info *link_info,
9232                      source_reloc *rel,
9233                      property_table_entry *prop_table,
9234                      int ptblsize,
9235                      const r_reloc *target_loc,
9236                      const literal_value *lit_value,
9237                      section_cache_t *target_sec_cache)
9238 {
9239   property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
9240   text_action *fa, *target_fa;
9241   int removed_diff;
9242   xtensa_relax_info *relax_info, *target_relax_info;
9243   asection *target_sec;
9244   ebb_t *ebb;
9245   ebb_constraint ebb_table;
9246   bfd_boolean relocs_fit;
9247
9248   /* If this routine always returns FALSE, the literals that cannot be
9249      coalesced will not be moved.  */
9250   if (elf32xtensa_no_literal_movement)
9251     return FALSE;
9252
9253   relax_info = get_xtensa_relax_info (sec);
9254   if (!relax_info)
9255     return FALSE;
9256
9257   target_sec = r_reloc_get_section (target_loc);
9258   target_relax_info = get_xtensa_relax_info (target_sec);
9259
9260   /* Literals to undefined sections may not be moved because they
9261      must report an error.  */
9262   if (bfd_is_und_section (target_sec))
9263     return FALSE;
9264
9265   src_entry = elf_xtensa_find_property_entry
9266     (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
9267
9268   if (!section_cache_section (target_sec_cache, target_sec, link_info))
9269     return FALSE;
9270
9271   target_entry = elf_xtensa_find_property_entry
9272     (target_sec_cache->ptbl, target_sec_cache->pte_count,
9273      target_sec->vma + target_loc->target_offset);
9274
9275   if (!target_entry)
9276     return FALSE;
9277
9278   /* Make sure that we have not broken any branches.  */
9279   relocs_fit = FALSE;
9280
9281   init_ebb_constraint (&ebb_table);
9282   ebb = &ebb_table.ebb;
9283   init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
9284             target_sec_cache->content_length,
9285             target_sec_cache->ptbl, target_sec_cache->pte_count,
9286             target_sec_cache->relocs, target_sec_cache->reloc_count);
9287
9288   /* Propose to add 4 bytes + worst-case alignment size increase to
9289      destination.  */
9290   ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
9291                       ta_fill, target_loc->target_offset,
9292                       -4 - (1 << target_sec->alignment_power), TRUE);
9293
9294   /* Check all of the PC-relative relocations to make sure they still fit.  */
9295   relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
9296                                              target_sec_cache->contents,
9297                                              target_sec_cache->relocs, NULL,
9298                                              &ebb_table, NULL);
9299
9300   if (!relocs_fit)
9301     return FALSE;
9302
9303   text_action_add_literal (&target_relax_info->action_list,
9304                            ta_add_literal, target_loc, lit_value, -4);
9305
9306   if (target_sec->alignment_power > 2 && target_entry != src_entry)
9307     {
9308       /* May need to add or remove some fill to maintain alignment.  */
9309       int fill_extra_space;
9310       bfd_vma entry_sec_offset;
9311
9312       entry_sec_offset =
9313         target_entry->address - target_sec->vma + target_entry->size;
9314
9315       /* If the literal range is at the end of the section,
9316          do not add fill.  */
9317       fill_extra_space = 0;
9318       the_add_entry =
9319         elf_xtensa_find_property_entry (target_sec_cache->ptbl,
9320                                         target_sec_cache->pte_count,
9321                                         entry_sec_offset);
9322       if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9323         fill_extra_space = the_add_entry->size;
9324
9325       target_fa = find_fill_action (&target_relax_info->action_list,
9326                                     target_sec, entry_sec_offset);
9327       removed_diff = compute_removed_action_diff (target_fa, target_sec,
9328                                                   entry_sec_offset, 4,
9329                                                   fill_extra_space);
9330       if (target_fa)
9331         adjust_fill_action (target_fa, removed_diff);
9332       else
9333         text_action_add (&target_relax_info->action_list,
9334                          ta_fill, target_sec, entry_sec_offset, removed_diff);
9335     }
9336
9337   /* Mark that the literal will be moved to the new location.  */
9338   add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
9339
9340   /* Remove the literal.  */
9341   text_action_add (&relax_info->action_list,
9342                    ta_remove_literal, sec, rel->r_rel.target_offset, 4);
9343
9344   /* If the section is 4-byte aligned, do not add fill.  */
9345   if (sec->alignment_power > 2 && target_entry != src_entry)
9346     {
9347       int fill_extra_space;
9348       bfd_vma entry_sec_offset;
9349
9350       if (src_entry)
9351         entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
9352       else
9353         entry_sec_offset = rel->r_rel.target_offset+4;
9354
9355       /* If the literal range is at the end of the section,
9356          do not add fill.  */
9357       fill_extra_space = 0;
9358       the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
9359                                                       entry_sec_offset);
9360       if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9361         fill_extra_space = the_add_entry->size;
9362
9363       fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
9364       removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
9365                                                   -4, fill_extra_space);
9366       if (fa)
9367         adjust_fill_action (fa, removed_diff);
9368       else
9369         text_action_add (&relax_info->action_list,
9370                          ta_fill, sec, entry_sec_offset, removed_diff);
9371     }
9372
9373   return TRUE;
9374 }
9375
9376 \f
9377 /* Second relaxation pass.  */
9378
9379 static int
9380 action_remove_bytes_fn (splay_tree_node node, void *p)
9381 {
9382   bfd_size_type *final_size = p;
9383   text_action *action = (text_action *)node->value;
9384
9385   *final_size -= action->removed_bytes;
9386   return 0;
9387 }
9388
9389 /* Modify all of the relocations to point to the right spot, and if this
9390    is a relaxable section, delete the unwanted literals and fix the
9391    section size.  */
9392
9393 bfd_boolean
9394 relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
9395 {
9396   Elf_Internal_Rela *internal_relocs;
9397   xtensa_relax_info *relax_info;
9398   bfd_byte *contents;
9399   bfd_boolean ok = TRUE;
9400   unsigned i;
9401   bfd_boolean rv = FALSE;
9402   bfd_boolean virtual_action;
9403   bfd_size_type sec_size;
9404
9405   sec_size = bfd_get_section_limit (abfd, sec);
9406   relax_info = get_xtensa_relax_info (sec);
9407   BFD_ASSERT (relax_info);
9408
9409   /* First translate any of the fixes that have been added already.  */
9410   translate_section_fixes (sec);
9411
9412   /* Handle property sections (e.g., literal tables) specially.  */
9413   if (xtensa_is_property_section (sec))
9414     {
9415       BFD_ASSERT (!relax_info->is_relaxable_literal_section);
9416       return relax_property_section (abfd, sec, link_info);
9417     }
9418
9419   internal_relocs = retrieve_internal_relocs (abfd, sec,
9420                                               link_info->keep_memory);
9421   if (!internal_relocs && !action_list_count (&relax_info->action_list))
9422     return TRUE;
9423
9424   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9425   if (contents == NULL && sec_size != 0)
9426     {
9427       ok = FALSE;
9428       goto error_return;
9429     }
9430
9431   if (internal_relocs)
9432     {
9433       for (i = 0; i < sec->reloc_count; i++)
9434         {
9435           Elf_Internal_Rela *irel;
9436           xtensa_relax_info *target_relax_info;
9437           bfd_vma source_offset, old_source_offset;
9438           r_reloc r_rel;
9439           unsigned r_type;
9440           asection *target_sec;
9441
9442           /* Locally change the source address.
9443              Translate the target to the new target address.
9444              If it points to this section and has been removed,
9445              NULLify it.
9446              Write it back.  */
9447
9448           irel = &internal_relocs[i];
9449           source_offset = irel->r_offset;
9450           old_source_offset = source_offset;
9451
9452           r_type = ELF32_R_TYPE (irel->r_info);
9453           r_reloc_init (&r_rel, abfd, irel, contents,
9454                         bfd_get_section_limit (abfd, sec));
9455
9456           /* If this section could have changed then we may need to
9457              change the relocation's offset.  */
9458
9459           if (relax_info->is_relaxable_literal_section
9460               || relax_info->is_relaxable_asm_section)
9461             {
9462               pin_internal_relocs (sec, internal_relocs);
9463
9464               if (r_type != R_XTENSA_NONE
9465                   && find_removed_literal (&relax_info->removed_list,
9466                                            irel->r_offset))
9467                 {
9468                   /* Remove this relocation.  */
9469                   if (elf_hash_table (link_info)->dynamic_sections_created)
9470                     shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
9471                   irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
9472                   irel->r_offset = offset_with_removed_text_map
9473                     (&relax_info->action_list, irel->r_offset);
9474                   continue;
9475                 }
9476
9477               if (r_type == R_XTENSA_ASM_SIMPLIFY)
9478                 {
9479                   text_action *action =
9480                     find_insn_action (&relax_info->action_list,
9481                                       irel->r_offset);
9482                   if (action && (action->action == ta_convert_longcall
9483                                  || action->action == ta_remove_longcall))
9484                     {
9485                       bfd_reloc_status_type retval;
9486                       char *error_message = NULL;
9487
9488                       retval = contract_asm_expansion (contents, sec_size,
9489                                                        irel, &error_message);
9490                       if (retval != bfd_reloc_ok)
9491                         {
9492                           (*link_info->callbacks->reloc_dangerous)
9493                             (link_info, error_message, abfd, sec,
9494                              irel->r_offset);
9495                           goto error_return;
9496                         }
9497                       /* Update the action so that the code that moves
9498                          the contents will do the right thing.  */
9499                       /* ta_remove_longcall and ta_remove_insn actions are
9500                          grouped together in the tree as well as
9501                          ta_convert_longcall and ta_none, so that changes below
9502                          can be done w/o removing and reinserting action into
9503                          the tree.  */
9504
9505                       if (action->action == ta_remove_longcall)
9506                         action->action = ta_remove_insn;
9507                       else
9508                         action->action = ta_none;
9509                       /* Refresh the info in the r_rel.  */
9510                       r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
9511                       r_type = ELF32_R_TYPE (irel->r_info);
9512                     }
9513                 }
9514
9515               source_offset = offset_with_removed_text_map
9516                 (&relax_info->action_list, irel->r_offset);
9517               irel->r_offset = source_offset;
9518             }
9519
9520           /* If the target section could have changed then
9521              we may need to change the relocation's target offset.  */
9522
9523           target_sec = r_reloc_get_section (&r_rel);
9524
9525           /* For a reference to a discarded section from a DWARF section,
9526              i.e., where action_discarded is PRETEND, the symbol will
9527              eventually be modified to refer to the kept section (at least if
9528              the kept and discarded sections are the same size).  Anticipate
9529              that here and adjust things accordingly.  */
9530           if (! elf_xtensa_ignore_discarded_relocs (sec)
9531               && elf_xtensa_action_discarded (sec) == PRETEND
9532               && sec->sec_info_type != SEC_INFO_TYPE_STABS
9533               && target_sec != NULL
9534               && discarded_section (target_sec))
9535             {
9536               /* It would be natural to call _bfd_elf_check_kept_section
9537                  here, but it's not exported from elflink.c.  It's also a
9538                  fairly expensive check.  Adjusting the relocations to the
9539                  discarded section is fairly harmless; it will only adjust
9540                  some addends and difference values.  If it turns out that
9541                  _bfd_elf_check_kept_section fails later, it won't matter,
9542                  so just compare the section names to find the right group
9543                  member.  */
9544               asection *kept = target_sec->kept_section;
9545               if (kept != NULL)
9546                 {
9547                   if ((kept->flags & SEC_GROUP) != 0)
9548                     {
9549                       asection *first = elf_next_in_group (kept);
9550                       asection *s = first;
9551
9552                       kept = NULL;
9553                       while (s != NULL)
9554                         {
9555                           if (strcmp (s->name, target_sec->name) == 0)
9556                             {
9557                               kept = s;
9558                               break;
9559                             }
9560                           s = elf_next_in_group (s);
9561                           if (s == first)
9562                             break;
9563                         }
9564                     }
9565                 }
9566               if (kept != NULL
9567                   && ((target_sec->rawsize != 0
9568                        ? target_sec->rawsize : target_sec->size)
9569                       == (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9570                 target_sec = kept;
9571             }
9572
9573           target_relax_info = get_xtensa_relax_info (target_sec);
9574           if (target_relax_info
9575               && (target_relax_info->is_relaxable_literal_section
9576                   || target_relax_info->is_relaxable_asm_section))
9577             {
9578               r_reloc new_reloc;
9579               target_sec = translate_reloc (&r_rel, &new_reloc, target_sec);
9580
9581               if (r_type == R_XTENSA_DIFF8
9582                   || r_type == R_XTENSA_DIFF16
9583                   || r_type == R_XTENSA_DIFF32)
9584                 {
9585                   bfd_signed_vma diff_value = 0;
9586                   bfd_vma new_end_offset, diff_mask = 0;
9587
9588                   if (bfd_get_section_limit (abfd, sec) < old_source_offset)
9589                     {
9590                       (*link_info->callbacks->reloc_dangerous)
9591                         (link_info, _("invalid relocation address"),
9592                          abfd, sec, old_source_offset);
9593                       goto error_return;
9594                     }
9595
9596                   switch (r_type)
9597                     {
9598                     case R_XTENSA_DIFF8:
9599                       diff_value =
9600                         bfd_get_signed_8 (abfd, &contents[old_source_offset]);
9601                       break;
9602                     case R_XTENSA_DIFF16:
9603                       diff_value =
9604                         bfd_get_signed_16 (abfd, &contents[old_source_offset]);
9605                       break;
9606                     case R_XTENSA_DIFF32:
9607                       diff_value =
9608                         bfd_get_signed_32 (abfd, &contents[old_source_offset]);
9609                       break;
9610                     }
9611
9612                   new_end_offset = offset_with_removed_text_map
9613                     (&target_relax_info->action_list,
9614                      r_rel.target_offset + diff_value);
9615                   diff_value = new_end_offset - new_reloc.target_offset;
9616
9617                   switch (r_type)
9618                     {
9619                     case R_XTENSA_DIFF8:
9620                       diff_mask = 0x7f;
9621                       bfd_put_signed_8 (abfd, diff_value,
9622                                  &contents[old_source_offset]);
9623                       break;
9624                     case R_XTENSA_DIFF16:
9625                       diff_mask = 0x7fff;
9626                       bfd_put_signed_16 (abfd, diff_value,
9627                                   &contents[old_source_offset]);
9628                       break;
9629                     case R_XTENSA_DIFF32:
9630                       diff_mask = 0x7fffffff;
9631                       bfd_put_signed_32 (abfd, diff_value,
9632                                   &contents[old_source_offset]);
9633                       break;
9634                     }
9635
9636                   /* Check for overflow. Sign bits must be all zeroes or all ones */
9637                   if ((diff_value & ~diff_mask) != 0 &&
9638                       (diff_value & ~diff_mask) != (-1 & ~diff_mask))
9639                     {
9640                       (*link_info->callbacks->reloc_dangerous)
9641                         (link_info, _("overflow after relaxation"),
9642                          abfd, sec, old_source_offset);
9643                       goto error_return;
9644                     }
9645
9646                   pin_contents (sec, contents);
9647                 }
9648
9649               /* If the relocation still references a section in the same
9650                  input file, modify the relocation directly instead of
9651                  adding a "fix" record.  */
9652               if (target_sec->owner == abfd)
9653                 {
9654                   unsigned r_symndx = ELF32_R_SYM (new_reloc.rela.r_info);
9655                   irel->r_info = ELF32_R_INFO (r_symndx, r_type);
9656                   irel->r_addend = new_reloc.rela.r_addend;
9657                   pin_internal_relocs (sec, internal_relocs);
9658                 }
9659               else
9660                 {
9661                   bfd_vma addend_displacement;
9662                   reloc_bfd_fix *fix;
9663
9664                   addend_displacement =
9665                     new_reloc.target_offset + new_reloc.virtual_offset;
9666                   fix = reloc_bfd_fix_init (sec, source_offset, r_type,
9667                                             target_sec,
9668                                             addend_displacement, TRUE);
9669                   add_fix (sec, fix);
9670                 }
9671             }
9672         }
9673     }
9674
9675   if ((relax_info->is_relaxable_literal_section
9676        || relax_info->is_relaxable_asm_section)
9677       && action_list_count (&relax_info->action_list))
9678     {
9679       /* Walk through the planned actions and build up a table
9680          of move, copy and fill records.  Use the move, copy and
9681          fill records to perform the actions once.  */
9682
9683       bfd_size_type final_size, copy_size, orig_insn_size;
9684       bfd_byte *scratch = NULL;
9685       bfd_byte *dup_contents = NULL;
9686       bfd_size_type orig_size = sec->size;
9687       bfd_vma orig_dot = 0;
9688       bfd_vma orig_dot_copied = 0; /* Byte copied already from
9689                                             orig dot in physical memory.  */
9690       bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot.  */
9691       bfd_vma dup_dot = 0;
9692
9693       text_action *action;
9694
9695       final_size = sec->size;
9696
9697       splay_tree_foreach (relax_info->action_list.tree,
9698                           action_remove_bytes_fn, &final_size);
9699       scratch = (bfd_byte *) bfd_zmalloc (final_size);
9700       dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
9701
9702       /* The dot is the current fill location.  */
9703 #if DEBUG
9704       print_action_list (stderr, &relax_info->action_list);
9705 #endif
9706
9707       for (action = action_first (&relax_info->action_list); action;
9708            action = action_next (&relax_info->action_list, action))
9709         {
9710           virtual_action = FALSE;
9711           if (action->offset > orig_dot)
9712             {
9713               orig_dot += orig_dot_copied;
9714               orig_dot_copied = 0;
9715               orig_dot_vo = 0;
9716               /* Out of the virtual world.  */
9717             }
9718
9719           if (action->offset > orig_dot)
9720             {
9721               copy_size = action->offset - orig_dot;
9722               memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9723               orig_dot += copy_size;
9724               dup_dot += copy_size;
9725               BFD_ASSERT (action->offset == orig_dot);
9726             }
9727           else if (action->offset < orig_dot)
9728             {
9729               if (action->action == ta_fill
9730                   && action->offset - action->removed_bytes == orig_dot)
9731                 {
9732                   /* This is OK because the fill only effects the dup_dot.  */
9733                 }
9734               else if (action->action == ta_add_literal)
9735                 {
9736                   /* TBD.  Might need to handle this.  */
9737                 }
9738             }
9739           if (action->offset == orig_dot)
9740             {
9741               if (action->virtual_offset > orig_dot_vo)
9742                 {
9743                   if (orig_dot_vo == 0)
9744                     {
9745                       /* Need to copy virtual_offset bytes.  Probably four.  */
9746                       copy_size = action->virtual_offset - orig_dot_vo;
9747                       memmove (&dup_contents[dup_dot],
9748                                &contents[orig_dot], copy_size);
9749                       orig_dot_copied = copy_size;
9750                       dup_dot += copy_size;
9751                     }
9752                   virtual_action = TRUE;
9753                 }
9754               else
9755                 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
9756             }
9757           switch (action->action)
9758             {
9759             case ta_remove_literal:
9760             case ta_remove_insn:
9761               BFD_ASSERT (action->removed_bytes >= 0);
9762               orig_dot += action->removed_bytes;
9763               break;
9764
9765             case ta_narrow_insn:
9766               orig_insn_size = 3;
9767               copy_size = 2;
9768               memmove (scratch, &contents[orig_dot], orig_insn_size);
9769               BFD_ASSERT (action->removed_bytes == 1);
9770               rv = narrow_instruction (scratch, final_size, 0);
9771               BFD_ASSERT (rv);
9772               memmove (&dup_contents[dup_dot], scratch, copy_size);
9773               orig_dot += orig_insn_size;
9774               dup_dot += copy_size;
9775               break;
9776
9777             case ta_fill:
9778               if (action->removed_bytes >= 0)
9779                 orig_dot += action->removed_bytes;
9780               else
9781                 {
9782                   /* Already zeroed in dup_contents.  Just bump the
9783                      counters.  */
9784                   dup_dot += (-action->removed_bytes);
9785                 }
9786               break;
9787
9788             case ta_none:
9789               BFD_ASSERT (action->removed_bytes == 0);
9790               break;
9791
9792             case ta_convert_longcall:
9793             case ta_remove_longcall:
9794               /* These will be removed or converted before we get here.  */
9795               BFD_ASSERT (0);
9796               break;
9797
9798             case ta_widen_insn:
9799               orig_insn_size = 2;
9800               copy_size = 3;
9801               memmove (scratch, &contents[orig_dot], orig_insn_size);
9802               BFD_ASSERT (action->removed_bytes == -1);
9803               rv = widen_instruction (scratch, final_size, 0);
9804               BFD_ASSERT (rv);
9805               memmove (&dup_contents[dup_dot], scratch, copy_size);
9806               orig_dot += orig_insn_size;
9807               dup_dot += copy_size;
9808               break;
9809
9810             case ta_add_literal:
9811               orig_insn_size = 0;
9812               copy_size = 4;
9813               BFD_ASSERT (action->removed_bytes == -4);
9814               /* TBD -- place the literal value here and insert
9815                  into the table.  */
9816               memset (&dup_contents[dup_dot], 0, 4);
9817               pin_internal_relocs (sec, internal_relocs);
9818               pin_contents (sec, contents);
9819
9820               if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
9821                                  relax_info, &internal_relocs, &action->value))
9822                 goto error_return;
9823
9824               if (virtual_action)
9825                 orig_dot_vo += copy_size;
9826
9827               orig_dot += orig_insn_size;
9828               dup_dot += copy_size;
9829               break;
9830
9831             default:
9832               /* Not implemented yet.  */
9833               BFD_ASSERT (0);
9834               break;
9835             }
9836
9837           BFD_ASSERT (dup_dot <= final_size);
9838           BFD_ASSERT (orig_dot <= orig_size);
9839         }
9840
9841       orig_dot += orig_dot_copied;
9842       orig_dot_copied = 0;
9843
9844       if (orig_dot != orig_size)
9845         {
9846           copy_size = orig_size - orig_dot;
9847           BFD_ASSERT (orig_size > orig_dot);
9848           BFD_ASSERT (dup_dot + copy_size == final_size);
9849           memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9850           orig_dot += copy_size;
9851           dup_dot += copy_size;
9852         }
9853       BFD_ASSERT (orig_size == orig_dot);
9854       BFD_ASSERT (final_size == dup_dot);
9855
9856       /* Move the dup_contents back.  */
9857       if (final_size > orig_size)
9858         {
9859           /* Contents need to be reallocated.  Swap the dup_contents into
9860              contents.  */
9861           sec->contents = dup_contents;
9862           free (contents);
9863           contents = dup_contents;
9864           pin_contents (sec, contents);
9865         }
9866       else
9867         {
9868           BFD_ASSERT (final_size <= orig_size);
9869           memset (contents, 0, orig_size);
9870           memcpy (contents, dup_contents, final_size);
9871           free (dup_contents);
9872         }
9873       free (scratch);
9874       pin_contents (sec, contents);
9875
9876       if (sec->rawsize == 0)
9877         sec->rawsize = sec->size;
9878       sec->size = final_size;
9879     }
9880
9881  error_return:
9882   release_internal_relocs (sec, internal_relocs);
9883   release_contents (sec, contents);
9884   return ok;
9885 }
9886
9887
9888 static bfd_boolean
9889 translate_section_fixes (asection *sec)
9890 {
9891   xtensa_relax_info *relax_info;
9892   reloc_bfd_fix *r;
9893
9894   relax_info = get_xtensa_relax_info (sec);
9895   if (!relax_info)
9896     return TRUE;
9897
9898   for (r = relax_info->fix_list; r != NULL; r = r->next)
9899     if (!translate_reloc_bfd_fix (r))
9900       return FALSE;
9901
9902   return TRUE;
9903 }
9904
9905
9906 /* Translate a fix given the mapping in the relax info for the target
9907    section.  If it has already been translated, no work is required.  */
9908
9909 static bfd_boolean
9910 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
9911 {
9912   reloc_bfd_fix new_fix;
9913   asection *sec;
9914   xtensa_relax_info *relax_info;
9915   removed_literal *removed;
9916   bfd_vma new_offset, target_offset;
9917
9918   if (fix->translated)
9919     return TRUE;
9920
9921   sec = fix->target_sec;
9922   target_offset = fix->target_offset;
9923
9924   relax_info = get_xtensa_relax_info (sec);
9925   if (!relax_info)
9926     {
9927       fix->translated = TRUE;
9928       return TRUE;
9929     }
9930
9931   new_fix = *fix;
9932
9933   /* The fix does not need to be translated if the section cannot change.  */
9934   if (!relax_info->is_relaxable_literal_section
9935       && !relax_info->is_relaxable_asm_section)
9936     {
9937       fix->translated = TRUE;
9938       return TRUE;
9939     }
9940
9941   /* If the literal has been moved and this relocation was on an
9942      opcode, then the relocation should move to the new literal
9943      location.  Otherwise, the relocation should move within the
9944      section.  */
9945
9946   removed = FALSE;
9947   if (is_operand_relocation (fix->src_type))
9948     {
9949       /* Check if the original relocation is against a literal being
9950          removed.  */
9951       removed = find_removed_literal (&relax_info->removed_list,
9952                                       target_offset);
9953     }
9954
9955   if (removed)
9956     {
9957       asection *new_sec;
9958
9959       /* The fact that there is still a relocation to this literal indicates
9960          that the literal is being coalesced, not simply removed.  */
9961       BFD_ASSERT (removed->to.abfd != NULL);
9962
9963       /* This was moved to some other address (possibly another section).  */
9964       new_sec = r_reloc_get_section (&removed->to);
9965       if (new_sec != sec)
9966         {
9967           sec = new_sec;
9968           relax_info = get_xtensa_relax_info (sec);
9969           if (!relax_info ||
9970               (!relax_info->is_relaxable_literal_section
9971                && !relax_info->is_relaxable_asm_section))
9972             {
9973               target_offset = removed->to.target_offset;
9974               new_fix.target_sec = new_sec;
9975               new_fix.target_offset = target_offset;
9976               new_fix.translated = TRUE;
9977               *fix = new_fix;
9978               return TRUE;
9979             }
9980         }
9981       target_offset = removed->to.target_offset;
9982       new_fix.target_sec = new_sec;
9983     }
9984
9985   /* The target address may have been moved within its section.  */
9986   new_offset = offset_with_removed_text (&relax_info->action_list,
9987                                          target_offset);
9988
9989   new_fix.target_offset = new_offset;
9990   new_fix.target_offset = new_offset;
9991   new_fix.translated = TRUE;
9992   *fix = new_fix;
9993   return TRUE;
9994 }
9995
9996
9997 /* Fix up a relocation to take account of removed literals.  */
9998
9999 static asection *
10000 translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec)
10001 {
10002   xtensa_relax_info *relax_info;
10003   removed_literal *removed;
10004   bfd_vma target_offset, base_offset;
10005
10006   *new_rel = *orig_rel;
10007
10008   if (!r_reloc_is_defined (orig_rel))
10009     return sec ;
10010
10011   relax_info = get_xtensa_relax_info (sec);
10012   BFD_ASSERT (relax_info && (relax_info->is_relaxable_literal_section
10013                              || relax_info->is_relaxable_asm_section));
10014
10015   target_offset = orig_rel->target_offset;
10016
10017   removed = FALSE;
10018   if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
10019     {
10020       /* Check if the original relocation is against a literal being
10021          removed.  */
10022       removed = find_removed_literal (&relax_info->removed_list,
10023                                       target_offset);
10024     }
10025   if (removed && removed->to.abfd)
10026     {
10027       asection *new_sec;
10028
10029       /* The fact that there is still a relocation to this literal indicates
10030          that the literal is being coalesced, not simply removed.  */
10031       BFD_ASSERT (removed->to.abfd != NULL);
10032
10033       /* This was moved to some other address
10034          (possibly in another section).  */
10035       *new_rel = removed->to;
10036       new_sec = r_reloc_get_section (new_rel);
10037       if (new_sec != sec)
10038         {
10039           sec = new_sec;
10040           relax_info = get_xtensa_relax_info (sec);
10041           if (!relax_info
10042               || (!relax_info->is_relaxable_literal_section
10043                   && !relax_info->is_relaxable_asm_section))
10044             return sec;
10045         }
10046       target_offset = new_rel->target_offset;
10047     }
10048
10049   /* Find the base offset of the reloc symbol, excluding any addend from the
10050      reloc or from the section contents (for a partial_inplace reloc).  Then
10051      find the adjusted values of the offsets due to relaxation.  The base
10052      offset is needed to determine the change to the reloc's addend; the reloc
10053      addend should not be adjusted due to relaxations located before the base
10054      offset.  */
10055
10056   base_offset = r_reloc_get_target_offset (new_rel) - new_rel->rela.r_addend;
10057   if (base_offset <= target_offset)
10058     {
10059       int base_removed = removed_by_actions_map (&relax_info->action_list,
10060                                                  base_offset, FALSE);
10061       int addend_removed = removed_by_actions_map (&relax_info->action_list,
10062                                                    target_offset, FALSE) -
10063         base_removed;
10064
10065       new_rel->target_offset = target_offset - base_removed - addend_removed;
10066       new_rel->rela.r_addend -= addend_removed;
10067     }
10068   else
10069     {
10070       /* Handle a negative addend.  The base offset comes first.  */
10071       int tgt_removed = removed_by_actions_map (&relax_info->action_list,
10072                                                 target_offset, FALSE);
10073       int addend_removed = removed_by_actions_map (&relax_info->action_list,
10074                                                    base_offset, FALSE) -
10075         tgt_removed;
10076
10077       new_rel->target_offset = target_offset - tgt_removed;
10078       new_rel->rela.r_addend += addend_removed;
10079     }
10080
10081   return sec;
10082 }
10083
10084
10085 /* For dynamic links, there may be a dynamic relocation for each
10086    literal.  The number of dynamic relocations must be computed in
10087    size_dynamic_sections, which occurs before relaxation.  When a
10088    literal is removed, this function checks if there is a corresponding
10089    dynamic relocation and shrinks the size of the appropriate dynamic
10090    relocation section accordingly.  At this point, the contents of the
10091    dynamic relocation sections have not yet been filled in, so there's
10092    nothing else that needs to be done.  */
10093
10094 static void
10095 shrink_dynamic_reloc_sections (struct bfd_link_info *info,
10096                                bfd *abfd,
10097                                asection *input_section,
10098                                Elf_Internal_Rela *rel)
10099 {
10100   struct elf_xtensa_link_hash_table *htab;
10101   Elf_Internal_Shdr *symtab_hdr;
10102   struct elf_link_hash_entry **sym_hashes;
10103   unsigned long r_symndx;
10104   int r_type;
10105   struct elf_link_hash_entry *h;
10106   bfd_boolean dynamic_symbol;
10107
10108   htab = elf_xtensa_hash_table (info);
10109   if (htab == NULL)
10110     return;
10111
10112   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10113   sym_hashes = elf_sym_hashes (abfd);
10114
10115   r_type = ELF32_R_TYPE (rel->r_info);
10116   r_symndx = ELF32_R_SYM (rel->r_info);
10117
10118   if (r_symndx < symtab_hdr->sh_info)
10119     h = NULL;
10120   else
10121     h = sym_hashes[r_symndx - symtab_hdr->sh_info];
10122
10123   dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
10124
10125   if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
10126       && (input_section->flags & SEC_ALLOC) != 0
10127       && (dynamic_symbol || bfd_link_pic (info)))
10128     {
10129       asection *srel;
10130       bfd_boolean is_plt = FALSE;
10131
10132       if (dynamic_symbol && r_type == R_XTENSA_PLT)
10133         {
10134           srel = htab->srelplt;
10135           is_plt = TRUE;
10136         }
10137       else
10138         srel = htab->srelgot;
10139
10140       /* Reduce size of the .rela.* section by one reloc.  */
10141       BFD_ASSERT (srel != NULL);
10142       BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
10143       srel->size -= sizeof (Elf32_External_Rela);
10144
10145       if (is_plt)
10146         {
10147           asection *splt, *sgotplt, *srelgot;
10148           int reloc_index, chunk;
10149
10150           /* Find the PLT reloc index of the entry being removed.  This
10151              is computed from the size of ".rela.plt".  It is needed to
10152              figure out which PLT chunk to resize.  Usually "last index
10153              = size - 1" since the index starts at zero, but in this
10154              context, the size has just been decremented so there's no
10155              need to subtract one.  */
10156           reloc_index = srel->size / sizeof (Elf32_External_Rela);
10157
10158           chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
10159           splt = elf_xtensa_get_plt_section (info, chunk);
10160           sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
10161           BFD_ASSERT (splt != NULL && sgotplt != NULL);
10162
10163           /* Check if an entire PLT chunk has just been eliminated.  */
10164           if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
10165             {
10166               /* The two magic GOT entries for that chunk can go away.  */
10167               srelgot = htab->srelgot;
10168               BFD_ASSERT (srelgot != NULL);
10169               srelgot->reloc_count -= 2;
10170               srelgot->size -= 2 * sizeof (Elf32_External_Rela);
10171               sgotplt->size -= 8;
10172
10173               /* There should be only one entry left (and it will be
10174                  removed below).  */
10175               BFD_ASSERT (sgotplt->size == 4);
10176               BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
10177             }
10178
10179           BFD_ASSERT (sgotplt->size >= 4);
10180           BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
10181
10182           sgotplt->size -= 4;
10183           splt->size -= PLT_ENTRY_SIZE;
10184         }
10185     }
10186 }
10187
10188
10189 /* Take an r_rel and move it to another section.  This usually
10190    requires extending the interal_relocation array and pinning it.  If
10191    the original r_rel is from the same BFD, we can complete this here.
10192    Otherwise, we add a fix record to let the final link fix the
10193    appropriate address.  Contents and internal relocations for the
10194    section must be pinned after calling this routine.  */
10195
10196 static bfd_boolean
10197 move_literal (bfd *abfd,
10198               struct bfd_link_info *link_info,
10199               asection *sec,
10200               bfd_vma offset,
10201               bfd_byte *contents,
10202               xtensa_relax_info *relax_info,
10203               Elf_Internal_Rela **internal_relocs_p,
10204               const literal_value *lit)
10205 {
10206   Elf_Internal_Rela *new_relocs = NULL;
10207   size_t new_relocs_count = 0;
10208   Elf_Internal_Rela this_rela;
10209   const r_reloc *r_rel;
10210
10211   r_rel = &lit->r_rel;
10212   BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
10213
10214   if (r_reloc_is_const (r_rel))
10215     bfd_put_32 (abfd, lit->value, contents + offset);
10216   else
10217     {
10218       int r_type;
10219       unsigned i;
10220       reloc_bfd_fix *fix;
10221       unsigned insert_at;
10222
10223       r_type = ELF32_R_TYPE (r_rel->rela.r_info);
10224
10225       /* This is the difficult case.  We have to create a fix up.  */
10226       this_rela.r_offset = offset;
10227       this_rela.r_info = ELF32_R_INFO (0, r_type);
10228       this_rela.r_addend =
10229         r_rel->target_offset - r_reloc_get_target_offset (r_rel);
10230       bfd_put_32 (abfd, lit->value, contents + offset);
10231
10232       /* Currently, we cannot move relocations during a relocatable link.  */
10233       BFD_ASSERT (!bfd_link_relocatable (link_info));
10234       fix = reloc_bfd_fix_init (sec, offset, r_type,
10235                                 r_reloc_get_section (r_rel),
10236                                 r_rel->target_offset + r_rel->virtual_offset,
10237                                 FALSE);
10238       /* We also need to mark that relocations are needed here.  */
10239       sec->flags |= SEC_RELOC;
10240
10241       translate_reloc_bfd_fix (fix);
10242       /* This fix has not yet been translated.  */
10243       add_fix (sec, fix);
10244
10245       /* Add the relocation.  If we have already allocated our own
10246          space for the relocations and we have room for more, then use
10247          it.  Otherwise, allocate new space and move the literals.  */
10248       insert_at = sec->reloc_count;
10249       for (i = 0; i < sec->reloc_count; ++i)
10250         {
10251           if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
10252             {
10253               insert_at = i;
10254               break;
10255             }
10256         }
10257
10258       if (*internal_relocs_p != relax_info->allocated_relocs
10259           || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
10260         {
10261           BFD_ASSERT (relax_info->allocated_relocs == NULL
10262                       || sec->reloc_count == relax_info->relocs_count);
10263
10264           if (relax_info->allocated_relocs_count == 0)
10265             new_relocs_count = (sec->reloc_count + 2) * 2;
10266           else
10267             new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
10268
10269           new_relocs = (Elf_Internal_Rela *)
10270             bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
10271           if (!new_relocs)
10272             return FALSE;
10273
10274           /* We could handle this more quickly by finding the split point.  */
10275           if (insert_at != 0)
10276             memcpy (new_relocs, *internal_relocs_p,
10277                     insert_at * sizeof (Elf_Internal_Rela));
10278
10279           new_relocs[insert_at] = this_rela;
10280
10281           if (insert_at != sec->reloc_count)
10282             memcpy (new_relocs + insert_at + 1,
10283                     (*internal_relocs_p) + insert_at,
10284                     (sec->reloc_count - insert_at)
10285                     * sizeof (Elf_Internal_Rela));
10286
10287           if (*internal_relocs_p != relax_info->allocated_relocs)
10288             {
10289               /* The first time we re-allocate, we can only free the
10290                  old relocs if they were allocated with bfd_malloc.
10291                  This is not true when keep_memory is in effect.  */
10292               if (!link_info->keep_memory)
10293                 free (*internal_relocs_p);
10294             }
10295           else
10296             free (*internal_relocs_p);
10297           relax_info->allocated_relocs = new_relocs;
10298           relax_info->allocated_relocs_count = new_relocs_count;
10299           elf_section_data (sec)->relocs = new_relocs;
10300           sec->reloc_count++;
10301           relax_info->relocs_count = sec->reloc_count;
10302           *internal_relocs_p = new_relocs;
10303         }
10304       else
10305         {
10306           if (insert_at != sec->reloc_count)
10307             {
10308               unsigned idx;
10309               for (idx = sec->reloc_count; idx > insert_at; idx--)
10310                 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
10311             }
10312           (*internal_relocs_p)[insert_at] = this_rela;
10313           sec->reloc_count++;
10314           if (relax_info->allocated_relocs)
10315             relax_info->relocs_count = sec->reloc_count;
10316         }
10317     }
10318   return TRUE;
10319 }
10320
10321
10322 /* This is similar to relax_section except that when a target is moved,
10323    we shift addresses up.  We also need to modify the size.  This
10324    algorithm does NOT allow for relocations into the middle of the
10325    property sections.  */
10326
10327 static bfd_boolean
10328 relax_property_section (bfd *abfd,
10329                         asection *sec,
10330                         struct bfd_link_info *link_info)
10331 {
10332   Elf_Internal_Rela *internal_relocs;
10333   bfd_byte *contents;
10334   unsigned i;
10335   bfd_boolean ok = TRUE;
10336   bfd_boolean is_full_prop_section;
10337   size_t last_zfill_target_offset = 0;
10338   asection *last_zfill_target_sec = NULL;
10339   bfd_size_type sec_size;
10340   bfd_size_type entry_size;
10341
10342   sec_size = bfd_get_section_limit (abfd, sec);
10343   internal_relocs = retrieve_internal_relocs (abfd, sec,
10344                                               link_info->keep_memory);
10345   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
10346   if (contents == NULL && sec_size != 0)
10347     {
10348       ok = FALSE;
10349       goto error_return;
10350     }
10351
10352   is_full_prop_section = xtensa_is_proptable_section (sec);
10353   if (is_full_prop_section)
10354     entry_size = 12;
10355   else
10356     entry_size = 8;
10357
10358   if (internal_relocs)
10359     {
10360       for (i = 0; i < sec->reloc_count; i++)
10361         {
10362           Elf_Internal_Rela *irel;
10363           xtensa_relax_info *target_relax_info;
10364           unsigned r_type;
10365           asection *target_sec;
10366           literal_value val;
10367           bfd_byte *size_p, *flags_p;
10368
10369           /* Locally change the source address.
10370              Translate the target to the new target address.
10371              If it points to this section and has been removed, MOVE IT.
10372              Also, don't forget to modify the associated SIZE at
10373              (offset + 4).  */
10374
10375           irel = &internal_relocs[i];
10376           r_type = ELF32_R_TYPE (irel->r_info);
10377           if (r_type == R_XTENSA_NONE)
10378             continue;
10379
10380           /* Find the literal value.  */
10381           r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
10382           size_p = &contents[irel->r_offset + 4];
10383           flags_p = NULL;
10384           if (is_full_prop_section)
10385             flags_p = &contents[irel->r_offset + 8];
10386           BFD_ASSERT (irel->r_offset + entry_size <= sec_size);
10387
10388           target_sec = r_reloc_get_section (&val.r_rel);
10389           target_relax_info = get_xtensa_relax_info (target_sec);
10390
10391           if (target_relax_info
10392               && (target_relax_info->is_relaxable_literal_section
10393                   || target_relax_info->is_relaxable_asm_section ))
10394             {
10395               /* Translate the relocation's destination.  */
10396               bfd_vma old_offset = val.r_rel.target_offset;
10397               bfd_vma new_offset;
10398               long old_size, new_size;
10399               int removed_by_old_offset =
10400                 removed_by_actions_map (&target_relax_info->action_list,
10401                                         old_offset, FALSE);
10402               new_offset = old_offset - removed_by_old_offset;
10403
10404               /* Assert that we are not out of bounds.  */
10405               old_size = bfd_get_32 (abfd, size_p);
10406               new_size = old_size;
10407
10408               if (old_size == 0)
10409                 {
10410                   /* Only the first zero-sized unreachable entry is
10411                      allowed to expand.  In this case the new offset
10412                      should be the offset before the fill and the new
10413                      size is the expansion size.  For other zero-sized
10414                      entries the resulting size should be zero with an
10415                      offset before or after the fill address depending
10416                      on whether the expanding unreachable entry
10417                      preceeds it.  */
10418                   if (last_zfill_target_sec == 0
10419                       || last_zfill_target_sec != target_sec
10420                       || last_zfill_target_offset != old_offset)
10421                     {
10422                       bfd_vma new_end_offset = new_offset;
10423
10424                       /* Recompute the new_offset, but this time don't
10425                          include any fill inserted by relaxation.  */
10426                       removed_by_old_offset =
10427                         removed_by_actions_map (&target_relax_info->action_list,
10428                                                 old_offset, TRUE);
10429                       new_offset = old_offset - removed_by_old_offset;
10430
10431                       /* If it is not unreachable and we have not yet
10432                          seen an unreachable at this address, place it
10433                          before the fill address.  */
10434                       if (flags_p && (bfd_get_32 (abfd, flags_p)
10435                                       & XTENSA_PROP_UNREACHABLE) != 0)
10436                         {
10437                           new_size = new_end_offset - new_offset;
10438
10439                           last_zfill_target_sec = target_sec;
10440                           last_zfill_target_offset = old_offset;
10441                         }
10442                     }
10443                 }
10444               else
10445                 {
10446                   int removed_by_old_offset_size =
10447                     removed_by_actions_map (&target_relax_info->action_list,
10448                                             old_offset + old_size, TRUE);
10449                   new_size -= removed_by_old_offset_size - removed_by_old_offset;
10450                 }
10451
10452               if (new_size != old_size)
10453                 {
10454                   bfd_put_32 (abfd, new_size, size_p);
10455                   pin_contents (sec, contents);
10456                 }
10457
10458               if (new_offset != old_offset)
10459                 {
10460                   bfd_vma diff = new_offset - old_offset;
10461                   irel->r_addend += diff;
10462                   pin_internal_relocs (sec, internal_relocs);
10463                 }
10464             }
10465         }
10466     }
10467
10468   /* Combine adjacent property table entries.  This is also done in
10469      finish_dynamic_sections() but at that point it's too late to
10470      reclaim the space in the output section, so we do this twice.  */
10471
10472   if (internal_relocs && (!bfd_link_relocatable (link_info)
10473                           || xtensa_is_littable_section (sec)))
10474     {
10475       Elf_Internal_Rela *last_irel = NULL;
10476       Elf_Internal_Rela *irel, *next_rel, *rel_end;
10477       int removed_bytes = 0;
10478       bfd_vma offset;
10479       flagword predef_flags;
10480
10481       predef_flags = xtensa_get_property_predef_flags (sec);
10482
10483       /* Walk over memory and relocations at the same time.
10484          This REQUIRES that the internal_relocs be sorted by offset.  */
10485       qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
10486              internal_reloc_compare);
10487
10488       pin_internal_relocs (sec, internal_relocs);
10489       pin_contents (sec, contents);
10490
10491       next_rel = internal_relocs;
10492       rel_end = internal_relocs + sec->reloc_count;
10493
10494       BFD_ASSERT (sec->size % entry_size == 0);
10495
10496       for (offset = 0; offset < sec->size; offset += entry_size)
10497         {
10498           Elf_Internal_Rela *offset_rel, *extra_rel;
10499           bfd_vma bytes_to_remove, size, actual_offset;
10500           bfd_boolean remove_this_rel;
10501           flagword flags;
10502
10503           /* Find the first relocation for the entry at the current offset.
10504              Adjust the offsets of any extra relocations for the previous
10505              entry.  */
10506           offset_rel = NULL;
10507           if (next_rel)
10508             {
10509               for (irel = next_rel; irel < rel_end; irel++)
10510                 {
10511                   if ((irel->r_offset == offset
10512                        && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
10513                       || irel->r_offset > offset)
10514                     {
10515                       offset_rel = irel;
10516                       break;
10517                     }
10518                   irel->r_offset -= removed_bytes;
10519                 }
10520             }
10521
10522           /* Find the next relocation (if there are any left).  */
10523           extra_rel = NULL;
10524           if (offset_rel)
10525             {
10526               for (irel = offset_rel + 1; irel < rel_end; irel++)
10527                 {
10528                   if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
10529                     {
10530                       extra_rel = irel;
10531                       break;
10532                     }
10533                 }
10534             }
10535
10536           /* Check if there are relocations on the current entry.  There
10537              should usually be a relocation on the offset field.  If there
10538              are relocations on the size or flags, then we can't optimize
10539              this entry.  Also, find the next relocation to examine on the
10540              next iteration.  */
10541           if (offset_rel)
10542             {
10543               if (offset_rel->r_offset >= offset + entry_size)
10544                 {
10545                   next_rel = offset_rel;
10546                   /* There are no relocations on the current entry, but we
10547                      might still be able to remove it if the size is zero.  */
10548                   offset_rel = NULL;
10549                 }
10550               else if (offset_rel->r_offset > offset
10551                        || (extra_rel
10552                            && extra_rel->r_offset < offset + entry_size))
10553                 {
10554                   /* There is a relocation on the size or flags, so we can't
10555                      do anything with this entry.  Continue with the next.  */
10556                   next_rel = offset_rel;
10557                   continue;
10558                 }
10559               else
10560                 {
10561                   BFD_ASSERT (offset_rel->r_offset == offset);
10562                   offset_rel->r_offset -= removed_bytes;
10563                   next_rel = offset_rel + 1;
10564                 }
10565             }
10566           else
10567             next_rel = NULL;
10568
10569           remove_this_rel = FALSE;
10570           bytes_to_remove = 0;
10571           actual_offset = offset - removed_bytes;
10572           size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
10573
10574           if (is_full_prop_section)
10575             flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
10576           else
10577             flags = predef_flags;
10578
10579           if (size == 0
10580               && (flags & XTENSA_PROP_ALIGN) == 0
10581               && (flags & XTENSA_PROP_UNREACHABLE) == 0)
10582             {
10583               /* Always remove entries with zero size and no alignment.  */
10584               bytes_to_remove = entry_size;
10585               if (offset_rel)
10586                 remove_this_rel = TRUE;
10587             }
10588           else if (offset_rel
10589                    && ELF32_R_TYPE (offset_rel->r_info) == R_XTENSA_32)
10590             {
10591               if (last_irel)
10592                 {
10593                   flagword old_flags;
10594                   bfd_vma old_size =
10595                     bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
10596                   bfd_vma old_address =
10597                     (last_irel->r_addend
10598                      + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
10599                   bfd_vma new_address =
10600                     (offset_rel->r_addend
10601                      + bfd_get_32 (abfd, &contents[actual_offset]));
10602                   if (is_full_prop_section)
10603                     old_flags = bfd_get_32
10604                       (abfd, &contents[last_irel->r_offset + 8]);
10605                   else
10606                     old_flags = predef_flags;
10607
10608                   if ((ELF32_R_SYM (offset_rel->r_info)
10609                        == ELF32_R_SYM (last_irel->r_info))
10610                       && old_address + old_size == new_address
10611                       && old_flags == flags
10612                       && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
10613                       && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
10614                     {
10615                       /* Fix the old size.  */
10616                       bfd_put_32 (abfd, old_size + size,
10617                                   &contents[last_irel->r_offset + 4]);
10618                       bytes_to_remove = entry_size;
10619                       remove_this_rel = TRUE;
10620                     }
10621                   else
10622                     last_irel = offset_rel;
10623                 }
10624               else
10625                 last_irel = offset_rel;
10626             }
10627
10628           if (remove_this_rel)
10629             {
10630               offset_rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
10631               offset_rel->r_offset = 0;
10632             }
10633
10634           if (bytes_to_remove != 0)
10635             {
10636               removed_bytes += bytes_to_remove;
10637               if (offset + bytes_to_remove < sec->size)
10638                 memmove (&contents[actual_offset],
10639                          &contents[actual_offset + bytes_to_remove],
10640                          sec->size - offset - bytes_to_remove);
10641             }
10642         }
10643
10644       if (removed_bytes)
10645         {
10646           /* Fix up any extra relocations on the last entry.  */
10647           for (irel = next_rel; irel < rel_end; irel++)
10648             irel->r_offset -= removed_bytes;
10649
10650           /* Clear the removed bytes.  */
10651           memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
10652
10653           if (sec->rawsize == 0)
10654             sec->rawsize = sec->size;
10655           sec->size -= removed_bytes;
10656
10657           if (xtensa_is_littable_section (sec))
10658             {
10659               asection *sgotloc = elf_xtensa_hash_table (link_info)->sgotloc;
10660               if (sgotloc)
10661                 sgotloc->size -= removed_bytes;
10662             }
10663         }
10664     }
10665
10666  error_return:
10667   release_internal_relocs (sec, internal_relocs);
10668   release_contents (sec, contents);
10669   return ok;
10670 }
10671
10672 \f
10673 /* Third relaxation pass.  */
10674
10675 /* Change symbol values to account for removed literals.  */
10676
10677 bfd_boolean
10678 relax_section_symbols (bfd *abfd, asection *sec)
10679 {
10680   xtensa_relax_info *relax_info;
10681   unsigned int sec_shndx;
10682   Elf_Internal_Shdr *symtab_hdr;
10683   Elf_Internal_Sym *isymbuf;
10684   unsigned i, num_syms, num_locals;
10685
10686   relax_info = get_xtensa_relax_info (sec);
10687   BFD_ASSERT (relax_info);
10688
10689   if (!relax_info->is_relaxable_literal_section
10690       && !relax_info->is_relaxable_asm_section)
10691     return TRUE;
10692
10693   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
10694
10695   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10696   isymbuf = retrieve_local_syms (abfd);
10697
10698   num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
10699   num_locals = symtab_hdr->sh_info;
10700
10701   /* Adjust the local symbols defined in this section.  */
10702   for (i = 0; i < num_locals; i++)
10703     {
10704       Elf_Internal_Sym *isym = &isymbuf[i];
10705
10706       if (isym->st_shndx == sec_shndx)
10707         {
10708           bfd_vma orig_addr = isym->st_value;
10709           int removed = removed_by_actions_map (&relax_info->action_list,
10710                                                 orig_addr, FALSE);
10711
10712           isym->st_value -= removed;
10713           if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
10714             isym->st_size -=
10715               removed_by_actions_map (&relax_info->action_list,
10716                                       orig_addr + isym->st_size, FALSE) -
10717               removed;
10718         }
10719     }
10720
10721   /* Now adjust the global symbols defined in this section.  */
10722   for (i = 0; i < (num_syms - num_locals); i++)
10723     {
10724       struct elf_link_hash_entry *sym_hash;
10725
10726       sym_hash = elf_sym_hashes (abfd)[i];
10727
10728       if (sym_hash->root.type == bfd_link_hash_warning)
10729         sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
10730
10731       if ((sym_hash->root.type == bfd_link_hash_defined
10732            || sym_hash->root.type == bfd_link_hash_defweak)
10733           && sym_hash->root.u.def.section == sec)
10734         {
10735           bfd_vma orig_addr = sym_hash->root.u.def.value;
10736           int removed = removed_by_actions_map (&relax_info->action_list,
10737                                                 orig_addr, FALSE);
10738
10739           sym_hash->root.u.def.value -= removed;
10740
10741           if (sym_hash->type == STT_FUNC)
10742             sym_hash->size -=
10743               removed_by_actions_map (&relax_info->action_list,
10744                                       orig_addr + sym_hash->size, FALSE) -
10745               removed;
10746         }
10747     }
10748
10749   return TRUE;
10750 }
10751
10752 \f
10753 /* "Fix" handling functions, called while performing relocations.  */
10754
10755 static bfd_boolean
10756 do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
10757                              bfd *input_bfd,
10758                              asection *input_section,
10759                              bfd_byte *contents)
10760 {
10761   r_reloc r_rel;
10762   asection *sec, *old_sec;
10763   bfd_vma old_offset;
10764   int r_type = ELF32_R_TYPE (rel->r_info);
10765   reloc_bfd_fix *fix;
10766
10767   if (r_type == R_XTENSA_NONE)
10768     return TRUE;
10769
10770   fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10771   if (!fix)
10772     return TRUE;
10773
10774   r_reloc_init (&r_rel, input_bfd, rel, contents,
10775                 bfd_get_section_limit (input_bfd, input_section));
10776   old_sec = r_reloc_get_section (&r_rel);
10777   old_offset = r_rel.target_offset;
10778
10779   if (!old_sec || !r_reloc_is_defined (&r_rel))
10780     {
10781       if (r_type != R_XTENSA_ASM_EXPAND)
10782         {
10783           (*_bfd_error_handler)
10784             (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
10785              input_bfd, input_section, rel->r_offset,
10786              elf_howto_table[r_type].name);
10787           return FALSE;
10788         }
10789       /* Leave it be.  Resolution will happen in a later stage.  */
10790     }
10791   else
10792     {
10793       sec = fix->target_sec;
10794       rel->r_addend += ((sec->output_offset + fix->target_offset)
10795                         - (old_sec->output_offset + old_offset));
10796     }
10797   return TRUE;
10798 }
10799
10800
10801 static void
10802 do_fix_for_final_link (Elf_Internal_Rela *rel,
10803                        bfd *input_bfd,
10804                        asection *input_section,
10805                        bfd_byte *contents,
10806                        bfd_vma *relocationp)
10807 {
10808   asection *sec;
10809   int r_type = ELF32_R_TYPE (rel->r_info);
10810   reloc_bfd_fix *fix;
10811   bfd_vma fixup_diff;
10812
10813   if (r_type == R_XTENSA_NONE)
10814     return;
10815
10816   fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10817   if (!fix)
10818     return;
10819
10820   sec = fix->target_sec;
10821
10822   fixup_diff = rel->r_addend;
10823   if (elf_howto_table[fix->src_type].partial_inplace)
10824     {
10825       bfd_vma inplace_val;
10826       BFD_ASSERT (fix->src_offset
10827                   < bfd_get_section_limit (input_bfd, input_section));
10828       inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
10829       fixup_diff += inplace_val;
10830     }
10831
10832   *relocationp = (sec->output_section->vma
10833                   + sec->output_offset
10834                   + fix->target_offset - fixup_diff);
10835 }
10836
10837 \f
10838 /* Miscellaneous utility functions....  */
10839
10840 static asection *
10841 elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
10842 {
10843   struct elf_xtensa_link_hash_table *htab;
10844   bfd *dynobj;
10845   char plt_name[10];
10846
10847   if (chunk == 0)
10848     {
10849       htab = elf_xtensa_hash_table (info);
10850       if (htab == NULL)
10851         return NULL;
10852
10853       return htab->splt;
10854     }
10855
10856   dynobj = elf_hash_table (info)->dynobj;
10857   sprintf (plt_name, ".plt.%u", chunk);
10858   return bfd_get_linker_section (dynobj, plt_name);
10859 }
10860
10861
10862 static asection *
10863 elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
10864 {
10865   struct elf_xtensa_link_hash_table *htab;
10866   bfd *dynobj;
10867   char got_name[14];
10868
10869   if (chunk == 0)
10870     {
10871       htab = elf_xtensa_hash_table (info);
10872       if (htab == NULL)
10873         return NULL;
10874       return htab->sgotplt;
10875     }
10876
10877   dynobj = elf_hash_table (info)->dynobj;
10878   sprintf (got_name, ".got.plt.%u", chunk);
10879   return bfd_get_linker_section (dynobj, got_name);
10880 }
10881
10882
10883 /* Get the input section for a given symbol index.
10884    If the symbol is:
10885    . a section symbol, return the section;
10886    . a common symbol, return the common section;
10887    . an undefined symbol, return the undefined section;
10888    . an indirect symbol, follow the links;
10889    . an absolute value, return the absolute section.  */
10890
10891 static asection *
10892 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
10893 {
10894   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10895   asection *target_sec = NULL;
10896   if (r_symndx < symtab_hdr->sh_info)
10897     {
10898       Elf_Internal_Sym *isymbuf;
10899       unsigned int section_index;
10900
10901       isymbuf = retrieve_local_syms (abfd);
10902       section_index = isymbuf[r_symndx].st_shndx;
10903
10904       if (section_index == SHN_UNDEF)
10905         target_sec = bfd_und_section_ptr;
10906       else if (section_index == SHN_ABS)
10907         target_sec = bfd_abs_section_ptr;
10908       else if (section_index == SHN_COMMON)
10909         target_sec = bfd_com_section_ptr;
10910       else
10911         target_sec = bfd_section_from_elf_index (abfd, section_index);
10912     }
10913   else
10914     {
10915       unsigned long indx = r_symndx - symtab_hdr->sh_info;
10916       struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
10917
10918       while (h->root.type == bfd_link_hash_indirect
10919              || h->root.type == bfd_link_hash_warning)
10920         h = (struct elf_link_hash_entry *) h->root.u.i.link;
10921
10922       switch (h->root.type)
10923         {
10924         case bfd_link_hash_defined:
10925         case  bfd_link_hash_defweak:
10926           target_sec = h->root.u.def.section;
10927           break;
10928         case bfd_link_hash_common:
10929           target_sec = bfd_com_section_ptr;
10930           break;
10931         case bfd_link_hash_undefined:
10932         case bfd_link_hash_undefweak:
10933           target_sec = bfd_und_section_ptr;
10934           break;
10935         default: /* New indirect warning.  */
10936           target_sec = bfd_und_section_ptr;
10937           break;
10938         }
10939     }
10940   return target_sec;
10941 }
10942
10943
10944 static struct elf_link_hash_entry *
10945 get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
10946 {
10947   unsigned long indx;
10948   struct elf_link_hash_entry *h;
10949   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10950
10951   if (r_symndx < symtab_hdr->sh_info)
10952     return NULL;
10953
10954   indx = r_symndx - symtab_hdr->sh_info;
10955   h = elf_sym_hashes (abfd)[indx];
10956   while (h->root.type == bfd_link_hash_indirect
10957          || h->root.type == bfd_link_hash_warning)
10958     h = (struct elf_link_hash_entry *) h->root.u.i.link;
10959   return h;
10960 }
10961
10962
10963 /* Get the section-relative offset for a symbol number.  */
10964
10965 static bfd_vma
10966 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
10967 {
10968   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10969   bfd_vma offset = 0;
10970
10971   if (r_symndx < symtab_hdr->sh_info)
10972     {
10973       Elf_Internal_Sym *isymbuf;
10974       isymbuf = retrieve_local_syms (abfd);
10975       offset = isymbuf[r_symndx].st_value;
10976     }
10977   else
10978     {
10979       unsigned long indx = r_symndx - symtab_hdr->sh_info;
10980       struct elf_link_hash_entry *h =
10981         elf_sym_hashes (abfd)[indx];
10982
10983       while (h->root.type == bfd_link_hash_indirect
10984              || h->root.type == bfd_link_hash_warning)
10985         h = (struct elf_link_hash_entry *) h->root.u.i.link;
10986       if (h->root.type == bfd_link_hash_defined
10987           || h->root.type == bfd_link_hash_defweak)
10988         offset = h->root.u.def.value;
10989     }
10990   return offset;
10991 }
10992
10993
10994 static bfd_boolean
10995 is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
10996 {
10997   unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
10998   struct elf_link_hash_entry *h;
10999
11000   h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
11001   if (h && h->root.type == bfd_link_hash_defweak)
11002     return TRUE;
11003   return FALSE;
11004 }
11005
11006
11007 static bfd_boolean
11008 pcrel_reloc_fits (xtensa_opcode opc,
11009                   int opnd,
11010                   bfd_vma self_address,
11011                   bfd_vma dest_address)
11012 {
11013   xtensa_isa isa = xtensa_default_isa;
11014   uint32 valp = dest_address;
11015   if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
11016       || xtensa_operand_encode (isa, opc, opnd, &valp))
11017     return FALSE;
11018   return TRUE;
11019 }
11020
11021
11022 static bfd_boolean
11023 xtensa_is_property_section (asection *sec)
11024 {
11025   if (xtensa_is_insntable_section (sec)
11026       || xtensa_is_littable_section (sec)
11027       || xtensa_is_proptable_section (sec))
11028     return TRUE;
11029
11030   return FALSE;
11031 }
11032
11033
11034 static bfd_boolean
11035 xtensa_is_insntable_section (asection *sec)
11036 {
11037   if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
11038       || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
11039     return TRUE;
11040
11041   return FALSE;
11042 }
11043
11044
11045 static bfd_boolean
11046 xtensa_is_littable_section (asection *sec)
11047 {
11048   if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
11049       || CONST_STRNEQ (sec->name, ".gnu.linkonce.p."))
11050     return TRUE;
11051
11052   return FALSE;
11053 }
11054
11055
11056 static bfd_boolean
11057 xtensa_is_proptable_section (asection *sec)
11058 {
11059   if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
11060       || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."))
11061     return TRUE;
11062
11063   return FALSE;
11064 }
11065
11066
11067 static int
11068 internal_reloc_compare (const void *ap, const void *bp)
11069 {
11070   const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
11071   const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
11072
11073   if (a->r_offset != b->r_offset)
11074     return (a->r_offset - b->r_offset);
11075
11076   /* We don't need to sort on these criteria for correctness,
11077      but enforcing a more strict ordering prevents unstable qsort
11078      from behaving differently with different implementations.
11079      Without the code below we get correct but different results
11080      on Solaris 2.7 and 2.8.  We would like to always produce the
11081      same results no matter the host.  */
11082
11083   if (a->r_info != b->r_info)
11084     return (a->r_info - b->r_info);
11085
11086   return (a->r_addend - b->r_addend);
11087 }
11088
11089
11090 static int
11091 internal_reloc_matches (const void *ap, const void *bp)
11092 {
11093   const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
11094   const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
11095
11096   /* Check if one entry overlaps with the other; this shouldn't happen
11097      except when searching for a match.  */
11098   return (a->r_offset - b->r_offset);
11099 }
11100
11101
11102 /* Predicate function used to look up a section in a particular group.  */
11103
11104 static bfd_boolean
11105 match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
11106 {
11107   const char *gname = inf;
11108   const char *group_name = elf_group_name (sec);
11109
11110   return (group_name == gname
11111           || (group_name != NULL
11112               && gname != NULL
11113               && strcmp (group_name, gname) == 0));
11114 }
11115
11116
11117 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
11118
11119 static char *
11120 xtensa_property_section_name (asection *sec, const char *base_name)
11121 {
11122   const char *suffix, *group_name;
11123   char *prop_sec_name;
11124
11125   group_name = elf_group_name (sec);
11126   if (group_name)
11127     {
11128       suffix = strrchr (sec->name, '.');
11129       if (suffix == sec->name)
11130         suffix = 0;
11131       prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1
11132                                            + (suffix ? strlen (suffix) : 0));
11133       strcpy (prop_sec_name, base_name);
11134       if (suffix)
11135         strcat (prop_sec_name, suffix);
11136     }
11137   else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
11138     {
11139       char *linkonce_kind = 0;
11140
11141       if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
11142         linkonce_kind = "x.";
11143       else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
11144         linkonce_kind = "p.";
11145       else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
11146         linkonce_kind = "prop.";
11147       else
11148         abort ();
11149
11150       prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
11151                                            + strlen (linkonce_kind) + 1);
11152       memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
11153       strcpy (prop_sec_name + linkonce_len, linkonce_kind);
11154
11155       suffix = sec->name + linkonce_len;
11156       /* For backward compatibility, replace "t." instead of inserting
11157          the new linkonce_kind (but not for "prop" sections).  */
11158       if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
11159         suffix += 2;
11160       strcat (prop_sec_name + linkonce_len, suffix);
11161     }
11162   else
11163     prop_sec_name = strdup (base_name);
11164
11165   return prop_sec_name;
11166 }
11167
11168
11169 static asection *
11170 xtensa_get_property_section (asection *sec, const char *base_name)
11171 {
11172   char *prop_sec_name;
11173   asection *prop_sec;
11174
11175   prop_sec_name = xtensa_property_section_name (sec, base_name);
11176   prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
11177                                          match_section_group,
11178                                          (void *) elf_group_name (sec));
11179   free (prop_sec_name);
11180   return prop_sec;
11181 }
11182
11183
11184 asection *
11185 xtensa_make_property_section (asection *sec, const char *base_name)
11186 {
11187   char *prop_sec_name;
11188   asection *prop_sec;
11189
11190   /* Check if the section already exists.  */
11191   prop_sec_name = xtensa_property_section_name (sec, base_name);
11192   prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
11193                                          match_section_group,
11194                                          (void *) elf_group_name (sec));
11195   /* If not, create it.  */
11196   if (! prop_sec)
11197     {
11198       flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
11199       flags |= (bfd_get_section_flags (sec->owner, sec)
11200                 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
11201
11202       prop_sec = bfd_make_section_anyway_with_flags
11203         (sec->owner, strdup (prop_sec_name), flags);
11204       if (! prop_sec)
11205         return 0;
11206
11207       elf_group_name (prop_sec) = elf_group_name (sec);
11208     }
11209
11210   free (prop_sec_name);
11211   return prop_sec;
11212 }
11213
11214
11215 flagword
11216 xtensa_get_property_predef_flags (asection *sec)
11217 {
11218   if (xtensa_is_insntable_section (sec))
11219     return (XTENSA_PROP_INSN
11220             | XTENSA_PROP_NO_TRANSFORM
11221             | XTENSA_PROP_INSN_NO_REORDER);
11222
11223   if (xtensa_is_littable_section (sec))
11224     return (XTENSA_PROP_LITERAL
11225             | XTENSA_PROP_NO_TRANSFORM
11226             | XTENSA_PROP_INSN_NO_REORDER);
11227
11228   return 0;
11229 }
11230
11231 \f
11232 /* Other functions called directly by the linker.  */
11233
11234 bfd_boolean
11235 xtensa_callback_required_dependence (bfd *abfd,
11236                                      asection *sec,
11237                                      struct bfd_link_info *link_info,
11238                                      deps_callback_t callback,
11239                                      void *closure)
11240 {
11241   Elf_Internal_Rela *internal_relocs;
11242   bfd_byte *contents;
11243   unsigned i;
11244   bfd_boolean ok = TRUE;
11245   bfd_size_type sec_size;
11246
11247   sec_size = bfd_get_section_limit (abfd, sec);
11248
11249   /* ".plt*" sections have no explicit relocations but they contain L32R
11250      instructions that reference the corresponding ".got.plt*" sections.  */
11251   if ((sec->flags & SEC_LINKER_CREATED) != 0
11252       && CONST_STRNEQ (sec->name, ".plt"))
11253     {
11254       asection *sgotplt;
11255
11256       /* Find the corresponding ".got.plt*" section.  */
11257       if (sec->name[4] == '\0')
11258         sgotplt = bfd_get_linker_section (sec->owner, ".got.plt");
11259       else
11260         {
11261           char got_name[14];
11262           int chunk = 0;
11263
11264           BFD_ASSERT (sec->name[4] == '.');
11265           chunk = strtol (&sec->name[5], NULL, 10);
11266
11267           sprintf (got_name, ".got.plt.%u", chunk);
11268           sgotplt = bfd_get_linker_section (sec->owner, got_name);
11269         }
11270       BFD_ASSERT (sgotplt);
11271
11272       /* Assume worst-case offsets: L32R at the very end of the ".plt"
11273          section referencing a literal at the very beginning of
11274          ".got.plt".  This is very close to the real dependence, anyway.  */
11275       (*callback) (sec, sec_size, sgotplt, 0, closure);
11276     }
11277
11278   /* Only ELF files are supported for Xtensa.  Check here to avoid a segfault
11279      when building uclibc, which runs "ld -b binary /dev/null".  */
11280   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
11281     return ok;
11282
11283   internal_relocs = retrieve_internal_relocs (abfd, sec,
11284                                               link_info->keep_memory);
11285   if (internal_relocs == NULL
11286       || sec->reloc_count == 0)
11287     return ok;
11288
11289   /* Cache the contents for the duration of this scan.  */
11290   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
11291   if (contents == NULL && sec_size != 0)
11292     {
11293       ok = FALSE;
11294       goto error_return;
11295     }
11296
11297   if (!xtensa_default_isa)
11298     xtensa_default_isa = xtensa_isa_init (0, 0);
11299
11300   for (i = 0; i < sec->reloc_count; i++)
11301     {
11302       Elf_Internal_Rela *irel = &internal_relocs[i];
11303       if (is_l32r_relocation (abfd, sec, contents, irel))
11304         {
11305           r_reloc l32r_rel;
11306           asection *target_sec;
11307           bfd_vma target_offset;
11308
11309           r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
11310           target_sec = NULL;
11311           target_offset = 0;
11312           /* L32Rs must be local to the input file.  */
11313           if (r_reloc_is_defined (&l32r_rel))
11314             {
11315               target_sec = r_reloc_get_section (&l32r_rel);
11316               target_offset = l32r_rel.target_offset;
11317             }
11318           (*callback) (sec, irel->r_offset, target_sec, target_offset,
11319                        closure);
11320         }
11321     }
11322
11323  error_return:
11324   release_internal_relocs (sec, internal_relocs);
11325   release_contents (sec, contents);
11326   return ok;
11327 }
11328
11329 /* The default literal sections should always be marked as "code" (i.e.,
11330    SHF_EXECINSTR).  This is particularly important for the Linux kernel
11331    module loader so that the literals are not placed after the text.  */
11332 static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
11333 {
11334   { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11335   { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11336   { STRING_COMMA_LEN (".literal"),      0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11337   { STRING_COMMA_LEN (".xtensa.info"),  0, SHT_NOTE,     0 },
11338   { NULL,                       0,      0, 0,            0 }
11339 };
11340 \f
11341 #define ELF_TARGET_ID                   XTENSA_ELF_DATA
11342 #ifndef ELF_ARCH
11343 #define TARGET_LITTLE_SYM               xtensa_elf32_le_vec
11344 #define TARGET_LITTLE_NAME              "elf32-xtensa-le"
11345 #define TARGET_BIG_SYM                  xtensa_elf32_be_vec
11346 #define TARGET_BIG_NAME                 "elf32-xtensa-be"
11347 #define ELF_ARCH                        bfd_arch_xtensa
11348
11349 #define ELF_MACHINE_CODE                EM_XTENSA
11350 #define ELF_MACHINE_ALT1                EM_XTENSA_OLD
11351
11352 #if XCHAL_HAVE_MMU
11353 #define ELF_MAXPAGESIZE                 (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
11354 #else /* !XCHAL_HAVE_MMU */
11355 #define ELF_MAXPAGESIZE                 1
11356 #endif /* !XCHAL_HAVE_MMU */
11357 #endif /* ELF_ARCH */
11358
11359 #define elf_backend_can_gc_sections     1
11360 #define elf_backend_can_refcount        1
11361 #define elf_backend_plt_readonly        1
11362 #define elf_backend_got_header_size     4
11363 #define elf_backend_want_dynbss         0
11364 #define elf_backend_want_got_plt        1
11365
11366 #define elf_info_to_howto                    elf_xtensa_info_to_howto_rela
11367
11368 #define bfd_elf32_mkobject                   elf_xtensa_mkobject
11369
11370 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11371 #define bfd_elf32_new_section_hook           elf_xtensa_new_section_hook
11372 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11373 #define bfd_elf32_bfd_relax_section          elf_xtensa_relax_section
11374 #define bfd_elf32_bfd_reloc_type_lookup      elf_xtensa_reloc_type_lookup
11375 #define bfd_elf32_bfd_reloc_name_lookup \
11376   elf_xtensa_reloc_name_lookup
11377 #define bfd_elf32_bfd_set_private_flags      elf_xtensa_set_private_flags
11378 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11379
11380 #define elf_backend_adjust_dynamic_symbol    elf_xtensa_adjust_dynamic_symbol
11381 #define elf_backend_check_relocs             elf_xtensa_check_relocs
11382 #define elf_backend_create_dynamic_sections  elf_xtensa_create_dynamic_sections
11383 #define elf_backend_discard_info             elf_xtensa_discard_info
11384 #define elf_backend_ignore_discarded_relocs  elf_xtensa_ignore_discarded_relocs
11385 #define elf_backend_final_write_processing   elf_xtensa_final_write_processing
11386 #define elf_backend_finish_dynamic_sections  elf_xtensa_finish_dynamic_sections
11387 #define elf_backend_finish_dynamic_symbol    elf_xtensa_finish_dynamic_symbol
11388 #define elf_backend_gc_mark_hook             elf_xtensa_gc_mark_hook
11389 #define elf_backend_gc_sweep_hook            elf_xtensa_gc_sweep_hook
11390 #define elf_backend_grok_prstatus            elf_xtensa_grok_prstatus
11391 #define elf_backend_grok_psinfo              elf_xtensa_grok_psinfo
11392 #define elf_backend_hide_symbol              elf_xtensa_hide_symbol
11393 #define elf_backend_object_p                 elf_xtensa_object_p
11394 #define elf_backend_reloc_type_class         elf_xtensa_reloc_type_class
11395 #define elf_backend_relocate_section         elf_xtensa_relocate_section
11396 #define elf_backend_size_dynamic_sections    elf_xtensa_size_dynamic_sections
11397 #define elf_backend_always_size_sections     elf_xtensa_always_size_sections
11398 #define elf_backend_omit_section_dynsym \
11399   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
11400 #define elf_backend_special_sections         elf_xtensa_special_sections
11401 #define elf_backend_action_discarded         elf_xtensa_action_discarded
11402 #define elf_backend_copy_indirect_symbol     elf_xtensa_copy_indirect_symbol
11403
11404 #include "elf32-target.h"