bfd/elf32-xtensa.c

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