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