bfd/elf32-xtensa.c

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