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