bfd/elf32-xtensa.c

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