bfd/elf32-xtensa.c

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