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