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