bfd/elf32-xtensa.c

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