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 (!relocations_analyzed)
6642     {
6643       /* Do some overall initialization for relaxation.  */
6644       values = value_map_hash_table_init ();
6645       if (values == NULL)
6646         return FALSE;
6647       relaxing_section = TRUE;
6648       if (!analyze_relocations (link_info))
6649         return FALSE;
6650       relocations_analyzed = TRUE;
6651     }
6652   *again = FALSE;
6653
6654   /* Don't mess with linker-created sections.  */
6655   if ((sec->flags & SEC_LINKER_CREATED) != 0)
6656     return TRUE;
6657
6658   relax_info = get_xtensa_relax_info (sec);
6659   BFD_ASSERT (relax_info != NULL);
6660
6661   switch (relax_info->visited)
6662     {
6663     case 0:
6664       /* Note: It would be nice to fold this pass into
6665          analyze_relocations, but it is important for this step that the
6666          sections be examined in link order.  */
6667       if (!compute_removed_literals (abfd, sec, link_info, values))
6668         return FALSE;
6669       *again = TRUE;
6670       break;
6671
6672     case 1:
6673       if (values)
6674         value_map_hash_table_delete (values);
6675       values = NULL;
6676       if (!relax_section (abfd, sec, link_info))
6677         return FALSE;
6678       *again = TRUE;
6679       break;
6680
6681     case 2:
6682       if (!relax_section_symbols (abfd, sec))
6683         return FALSE;
6684       break;
6685     }
6686
6687   relax_info->visited++;
6688   return TRUE;
6689 }
6690
6691 \f
6692 /* Initialization for relaxation.  */
6693
6694 /* This function is called once at the start of relaxation.  It scans
6695    all the input sections and marks the ones that are relaxable (i.e.,
6696    literal sections with L32R relocations against them), and then
6697    collects source_reloc information for all the relocations against
6698    those relaxable sections.  During this process, it also detects
6699    longcalls, i.e., calls relaxed by the assembler into indirect
6700    calls, that can be optimized back into direct calls.  Within each
6701    extended basic block (ebb) containing an optimized longcall, it
6702    computes a set of "text actions" that can be performed to remove
6703    the L32R associated with the longcall while optionally preserving
6704    branch target alignments.  */
6705
6706 static bfd_boolean
6707 analyze_relocations (struct bfd_link_info *link_info)
6708 {
6709   bfd *abfd;
6710   asection *sec;
6711   bfd_boolean is_relaxable = FALSE;
6712
6713   /* Initialize the per-section relaxation info.  */
6714   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6715     for (sec = abfd->sections; sec != NULL; sec = sec->next)
6716       {
6717         init_xtensa_relax_info (sec);
6718       }
6719
6720   /* Mark relaxable sections (and count relocations against each one).  */
6721   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6722     for (sec = abfd->sections; sec != NULL; sec = sec->next)
6723       {
6724         if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
6725           return FALSE;
6726       }
6727
6728   /* Bail out if there are no relaxable sections.  */
6729   if (!is_relaxable)
6730     return TRUE;
6731
6732   /* Allocate space for source_relocs.  */
6733   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6734     for (sec = abfd->sections; sec != NULL; sec = sec->next)
6735       {
6736         xtensa_relax_info *relax_info;
6737
6738         relax_info = get_xtensa_relax_info (sec);
6739         if (relax_info->is_relaxable_literal_section
6740             || relax_info->is_relaxable_asm_section)
6741           {
6742             relax_info->src_relocs = (source_reloc *)
6743               bfd_malloc (relax_info->src_count * sizeof (source_reloc));
6744           }
6745         else
6746           relax_info->src_count = 0;
6747       }
6748
6749   /* Collect info on relocations against each relaxable section.  */
6750   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6751     for (sec = abfd->sections; sec != NULL; sec = sec->next)
6752       {
6753         if (!collect_source_relocs (abfd, sec, link_info))
6754           return FALSE;
6755       }
6756
6757   /* Compute the text actions.  */
6758   for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6759     for (sec = abfd->sections; sec != NULL; sec = sec->next)
6760       {
6761         if (!compute_text_actions (abfd, sec, link_info))
6762           return FALSE;
6763       }
6764
6765   return TRUE;
6766 }
6767
6768
6769 /* Find all the sections that might be relaxed.  The motivation for
6770    this pass is that collect_source_relocs() needs to record _all_ the
6771    relocations that target each relaxable section.  That is expensive
6772    and unnecessary unless the target section is actually going to be
6773    relaxed.  This pass identifies all such sections by checking if
6774    they have L32Rs pointing to them.  In the process, the total number
6775    of relocations targeting each section is also counted so that we
6776    know how much space to allocate for source_relocs against each
6777    relaxable literal section.  */
6778
6779 static bfd_boolean
6780 find_relaxable_sections (bfd *abfd,
6781                          asection *sec,
6782                          struct bfd_link_info *link_info,
6783                          bfd_boolean *is_relaxable_p)
6784 {
6785   Elf_Internal_Rela *internal_relocs;
6786   bfd_byte *contents;
6787   bfd_boolean ok = TRUE;
6788   unsigned i;
6789   xtensa_relax_info *source_relax_info;
6790   bfd_boolean is_l32r_reloc;
6791
6792   internal_relocs = retrieve_internal_relocs (abfd, sec,
6793                                               link_info->keep_memory);
6794   if (internal_relocs == NULL)
6795     return ok;
6796
6797   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6798   if (contents == NULL && sec->size != 0)
6799     {
6800       ok = FALSE;
6801       goto error_return;
6802     }
6803
6804   source_relax_info = get_xtensa_relax_info (sec);
6805   for (i = 0; i < sec->reloc_count; i++)
6806     {
6807       Elf_Internal_Rela *irel = &internal_relocs[i];
6808       r_reloc r_rel;
6809       asection *target_sec;
6810       xtensa_relax_info *target_relax_info;
6811
6812       /* If this section has not already been marked as "relaxable", and
6813          if it contains any ASM_EXPAND relocations (marking expanded
6814          longcalls) that can be optimized into direct calls, then mark
6815          the section as "relaxable".  */
6816       if (source_relax_info
6817           && !source_relax_info->is_relaxable_asm_section
6818           && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
6819         {
6820           bfd_boolean is_reachable = FALSE;
6821           if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
6822                                            link_info, &is_reachable)
6823               && is_reachable)
6824             {
6825               source_relax_info->is_relaxable_asm_section = TRUE;
6826               *is_relaxable_p = TRUE;
6827             }
6828         }
6829
6830       r_reloc_init (&r_rel, abfd, irel, contents,
6831                     bfd_get_section_limit (abfd, sec));
6832
6833       target_sec = r_reloc_get_section (&r_rel);
6834       target_relax_info = get_xtensa_relax_info (target_sec);
6835       if (!target_relax_info)
6836         continue;
6837
6838       /* Count PC-relative operand relocations against the target section.
6839          Note: The conditions tested here must match the conditions under
6840          which init_source_reloc is called in collect_source_relocs().  */
6841       is_l32r_reloc = FALSE;
6842       if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6843         {
6844           xtensa_opcode opcode =
6845             get_relocation_opcode (abfd, sec, contents, irel);
6846           if (opcode != XTENSA_UNDEFINED)
6847             {
6848               is_l32r_reloc = (opcode == get_l32r_opcode ());
6849               if (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
6850                   || is_l32r_reloc)
6851                 target_relax_info->src_count++;
6852             }
6853         }
6854
6855       if (is_l32r_reloc && r_reloc_is_defined (&r_rel))
6856         {
6857           /* Mark the target section as relaxable.  */
6858           target_relax_info->is_relaxable_literal_section = TRUE;
6859           *is_relaxable_p = TRUE;
6860         }
6861     }
6862
6863  error_return:
6864   release_contents (sec, contents);
6865   release_internal_relocs (sec, internal_relocs);
6866   return ok;
6867 }
6868
6869
6870 /* Record _all_ the relocations that point to relaxable sections, and
6871    get rid of ASM_EXPAND relocs by either converting them to
6872    ASM_SIMPLIFY or by removing them.  */
6873
6874 static bfd_boolean
6875 collect_source_relocs (bfd *abfd,
6876                        asection *sec,
6877                        struct bfd_link_info *link_info)
6878 {
6879   Elf_Internal_Rela *internal_relocs;
6880   bfd_byte *contents;
6881   bfd_boolean ok = TRUE;
6882   unsigned i;
6883   bfd_size_type sec_size;
6884
6885   internal_relocs = retrieve_internal_relocs (abfd, sec,
6886                                               link_info->keep_memory);
6887   if (internal_relocs == NULL)
6888     return ok;
6889
6890   sec_size = bfd_get_section_limit (abfd, sec);
6891   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6892   if (contents == NULL && sec_size != 0)
6893     {
6894       ok = FALSE;
6895       goto error_return;
6896     }
6897
6898   /* Record relocations against relaxable literal sections.  */
6899   for (i = 0; i < sec->reloc_count; i++)
6900     {
6901       Elf_Internal_Rela *irel = &internal_relocs[i];
6902       r_reloc r_rel;
6903       asection *target_sec;
6904       xtensa_relax_info *target_relax_info;
6905
6906       r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6907
6908       target_sec = r_reloc_get_section (&r_rel);
6909       target_relax_info = get_xtensa_relax_info (target_sec);
6910
6911       if (target_relax_info
6912           && (target_relax_info->is_relaxable_literal_section
6913               || target_relax_info->is_relaxable_asm_section))
6914         {
6915           xtensa_opcode opcode = XTENSA_UNDEFINED;
6916           int opnd = -1;
6917           bfd_boolean is_abs_literal = FALSE;
6918
6919           if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
6920             {
6921               /* None of the current alternate relocs are PC-relative,
6922                  and only PC-relative relocs matter here.  However, we
6923                  still need to record the opcode for literal
6924                  coalescing.  */
6925               opcode = get_relocation_opcode (abfd, sec, contents, irel);
6926               if (opcode == get_l32r_opcode ())
6927                 {
6928                   is_abs_literal = TRUE;
6929                   opnd = 1;
6930                 }
6931               else
6932                 opcode = XTENSA_UNDEFINED;
6933             }
6934           else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6935             {
6936               opcode = get_relocation_opcode (abfd, sec, contents, irel);
6937               opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
6938             }
6939
6940           if (opcode != XTENSA_UNDEFINED)
6941             {
6942               int src_next = target_relax_info->src_next++;
6943               source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
6944
6945               init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
6946                                  is_abs_literal);
6947             }
6948         }
6949     }
6950
6951   /* Now get rid of ASM_EXPAND relocations.  At this point, the
6952      src_relocs array for the target literal section may still be
6953      incomplete, but it must at least contain the entries for the L32R
6954      relocations associated with ASM_EXPANDs because they were just
6955      added in the preceding loop over the relocations.  */
6956
6957   for (i = 0; i < sec->reloc_count; i++)
6958     {
6959       Elf_Internal_Rela *irel = &internal_relocs[i];
6960       bfd_boolean is_reachable;
6961
6962       if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
6963                                         &is_reachable))
6964         continue;
6965
6966       if (is_reachable)
6967         {
6968           Elf_Internal_Rela *l32r_irel;
6969           r_reloc r_rel;
6970           asection *target_sec;
6971           xtensa_relax_info *target_relax_info;
6972
6973           /* Mark the source_reloc for the L32R so that it will be
6974              removed in compute_removed_literals(), along with the
6975              associated literal.  */
6976           l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
6977                                                  irel, internal_relocs);
6978           if (l32r_irel == NULL)
6979             continue;
6980
6981           r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
6982
6983           target_sec = r_reloc_get_section (&r_rel);
6984           target_relax_info = get_xtensa_relax_info (target_sec);
6985
6986           if (target_relax_info
6987               && (target_relax_info->is_relaxable_literal_section
6988                   || target_relax_info->is_relaxable_asm_section))
6989             {
6990               source_reloc *s_reloc;
6991
6992               /* Search the source_relocs for the entry corresponding to
6993                  the l32r_irel.  Note: The src_relocs array is not yet
6994                  sorted, but it wouldn't matter anyway because we're
6995                  searching by source offset instead of target offset.  */
6996               s_reloc = find_source_reloc (target_relax_info->src_relocs,
6997                                            target_relax_info->src_next,
6998                                            sec, l32r_irel);
6999               BFD_ASSERT (s_reloc);
7000               s_reloc->is_null = TRUE;
7001             }
7002
7003           /* Convert this reloc to ASM_SIMPLIFY.  */
7004           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
7005                                        R_XTENSA_ASM_SIMPLIFY);
7006           l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7007
7008           pin_internal_relocs (sec, internal_relocs);
7009         }
7010       else
7011         {
7012           /* It is resolvable but doesn't reach.  We resolve now
7013              by eliminating the relocation -- the call will remain
7014              expanded into L32R/CALLX.  */
7015           irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7016           pin_internal_relocs (sec, internal_relocs);
7017         }
7018     }
7019
7020  error_return:
7021   release_contents (sec, contents);
7022   release_internal_relocs (sec, internal_relocs);
7023   return ok;
7024 }
7025
7026
7027 /* Return TRUE if the asm expansion can be resolved.  Generally it can
7028    be resolved on a final link or when a partial link locates it in the
7029    same section as the target.  Set "is_reachable" flag if the target of
7030    the call is within the range of a direct call, given the current VMA
7031    for this section and the target section.  */
7032
7033 bfd_boolean
7034 is_resolvable_asm_expansion (bfd *abfd,
7035                              asection *sec,
7036                              bfd_byte *contents,
7037                              Elf_Internal_Rela *irel,
7038                              struct bfd_link_info *link_info,
7039                              bfd_boolean *is_reachable_p)
7040 {
7041   asection *target_sec;
7042   bfd_vma target_offset;
7043   r_reloc r_rel;
7044   xtensa_opcode opcode, direct_call_opcode;
7045   bfd_vma self_address;
7046   bfd_vma dest_address;
7047   bfd_boolean uses_l32r;
7048   bfd_size_type sec_size;
7049
7050   *is_reachable_p = FALSE;
7051
7052   if (contents == NULL)
7053     return FALSE;
7054
7055   if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
7056     return FALSE;
7057
7058   sec_size = bfd_get_section_limit (abfd, sec);
7059   opcode = get_expanded_call_opcode (contents + irel->r_offset,
7060                                      sec_size - irel->r_offset, &uses_l32r);
7061   /* Optimization of longcalls that use CONST16 is not yet implemented.  */
7062   if (!uses_l32r)
7063     return FALSE;
7064
7065   direct_call_opcode = swap_callx_for_call_opcode (opcode);
7066   if (direct_call_opcode == XTENSA_UNDEFINED)
7067     return FALSE;
7068
7069   /* Check and see that the target resolves.  */
7070   r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7071   if (!r_reloc_is_defined (&r_rel))
7072     return FALSE;
7073
7074   target_sec = r_reloc_get_section (&r_rel);
7075   target_offset = r_rel.target_offset;
7076
7077   /* If the target is in a shared library, then it doesn't reach.  This
7078      isn't supposed to come up because the compiler should never generate
7079      non-PIC calls on systems that use shared libraries, but the linker
7080      shouldn't crash regardless.  */
7081   if (!target_sec->output_section)
7082     return FALSE;
7083
7084   /* For relocatable sections, we can only simplify when the output
7085      section of the target is the same as the output section of the
7086      source.  */
7087   if (link_info->relocatable
7088       && (target_sec->output_section != sec->output_section
7089           || is_reloc_sym_weak (abfd, irel)))
7090     return FALSE;
7091
7092   self_address = (sec->output_section->vma
7093                   + sec->output_offset + irel->r_offset + 3);
7094   dest_address = (target_sec->output_section->vma
7095                   + target_sec->output_offset + target_offset);
7096
7097   *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
7098                                       self_address, dest_address);
7099
7100   if ((self_address >> CALL_SEGMENT_BITS) !=
7101       (dest_address >> CALL_SEGMENT_BITS))
7102     return FALSE;
7103
7104   return TRUE;
7105 }
7106
7107
7108 static Elf_Internal_Rela *
7109 find_associated_l32r_irel (bfd *abfd,
7110                            asection *sec,
7111                            bfd_byte *contents,
7112                            Elf_Internal_Rela *other_irel,
7113                            Elf_Internal_Rela *internal_relocs)
7114 {
7115   unsigned i;
7116
7117   for (i = 0; i < sec->reloc_count; i++)
7118     {
7119       Elf_Internal_Rela *irel = &internal_relocs[i];
7120
7121       if (irel == other_irel)
7122         continue;
7123       if (irel->r_offset != other_irel->r_offset)
7124         continue;
7125       if (is_l32r_relocation (abfd, sec, contents, irel))
7126         return irel;
7127     }
7128
7129   return NULL;
7130 }
7131
7132
7133 static xtensa_opcode *
7134 build_reloc_opcodes (bfd *abfd,
7135                      asection *sec,
7136                      bfd_byte *contents,
7137                      Elf_Internal_Rela *internal_relocs)
7138 {
7139   unsigned i;
7140   xtensa_opcode *reloc_opcodes =
7141     (xtensa_opcode *) bfd_malloc (sizeof (xtensa_opcode) * sec->reloc_count);
7142   for (i = 0; i < sec->reloc_count; i++)
7143     {
7144       Elf_Internal_Rela *irel = &internal_relocs[i];
7145       reloc_opcodes[i] = get_relocation_opcode (abfd, sec, contents, irel);
7146     }
7147   return reloc_opcodes;
7148 }
7149
7150
7151 /* The compute_text_actions function will build a list of potential
7152    transformation actions for code in the extended basic block of each
7153    longcall that is optimized to a direct call.  From this list we
7154    generate a set of actions to actually perform that optimizes for
7155    space and, if not using size_opt, maintains branch target
7156    alignments.
7157
7158    These actions to be performed are placed on a per-section list.
7159    The actual changes are performed by relax_section() in the second
7160    pass.  */
7161
7162 bfd_boolean
7163 compute_text_actions (bfd *abfd,
7164                       asection *sec,
7165                       struct bfd_link_info *link_info)
7166 {
7167   xtensa_opcode *reloc_opcodes = NULL;
7168   xtensa_relax_info *relax_info;
7169   bfd_byte *contents;
7170   Elf_Internal_Rela *internal_relocs;
7171   bfd_boolean ok = TRUE;
7172   unsigned i;
7173   property_table_entry *prop_table = 0;
7174   int ptblsize = 0;
7175   bfd_size_type sec_size;
7176
7177   relax_info = get_xtensa_relax_info (sec);
7178   BFD_ASSERT (relax_info);
7179   BFD_ASSERT (relax_info->src_next == relax_info->src_count);
7180
7181   /* Do nothing if the section contains no optimized longcalls.  */
7182   if (!relax_info->is_relaxable_asm_section)
7183     return ok;
7184
7185   internal_relocs = retrieve_internal_relocs (abfd, sec,
7186                                               link_info->keep_memory);
7187
7188   if (internal_relocs)
7189     qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7190            internal_reloc_compare);
7191
7192   sec_size = bfd_get_section_limit (abfd, sec);
7193   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7194   if (contents == NULL && sec_size != 0)
7195     {
7196       ok = FALSE;
7197       goto error_return;
7198     }
7199
7200   ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7201                                         XTENSA_PROP_SEC_NAME, FALSE);
7202   if (ptblsize < 0)
7203     {
7204       ok = FALSE;
7205       goto error_return;
7206     }
7207
7208   for (i = 0; i < sec->reloc_count; i++)
7209     {
7210       Elf_Internal_Rela *irel = &internal_relocs[i];
7211       bfd_vma r_offset;
7212       property_table_entry *the_entry;
7213       int ptbl_idx;
7214       ebb_t *ebb;
7215       ebb_constraint ebb_table;
7216       bfd_size_type simplify_size;
7217
7218       if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
7219         continue;
7220       r_offset = irel->r_offset;
7221
7222       simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
7223       if (simplify_size == 0)
7224         {
7225           (*_bfd_error_handler)
7226             (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
7227              sec->owner, sec, r_offset);
7228           continue;
7229         }
7230
7231       /* If the instruction table is not around, then don't do this
7232          relaxation.  */
7233       the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7234                                                   sec->vma + irel->r_offset);
7235       if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
7236         {
7237           text_action_add (&relax_info->action_list,
7238                            ta_convert_longcall, sec, r_offset,
7239                            0);
7240           continue;
7241         }
7242
7243       /* If the next longcall happens to be at the same address as an
7244          unreachable section of size 0, then skip forward.  */
7245       ptbl_idx = the_entry - prop_table;
7246       while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
7247              && the_entry->size == 0
7248              && ptbl_idx + 1 < ptblsize
7249              && (prop_table[ptbl_idx + 1].address
7250                  == prop_table[ptbl_idx].address))
7251         {
7252           ptbl_idx++;
7253           the_entry++;
7254         }
7255
7256       if (the_entry->flags & XTENSA_PROP_NO_TRANSFORM)
7257           /* NO_REORDER is OK */
7258         continue;
7259
7260       init_ebb_constraint (&ebb_table);
7261       ebb = &ebb_table.ebb;
7262       init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
7263                 internal_relocs, sec->reloc_count);
7264       ebb->start_offset = r_offset + simplify_size;
7265       ebb->end_offset = r_offset + simplify_size;
7266       ebb->start_ptbl_idx = ptbl_idx;
7267       ebb->end_ptbl_idx = ptbl_idx;
7268       ebb->start_reloc_idx = i;
7269       ebb->end_reloc_idx = i;
7270
7271       /* Precompute the opcode for each relocation.  */
7272       if (reloc_opcodes == NULL)
7273         reloc_opcodes = build_reloc_opcodes (abfd, sec, contents,
7274                                              internal_relocs);
7275
7276       if (!extend_ebb_bounds (ebb)
7277           || !compute_ebb_proposed_actions (&ebb_table)
7278           || !compute_ebb_actions (&ebb_table)
7279           || !check_section_ebb_pcrels_fit (abfd, sec, contents,
7280                                             internal_relocs, &ebb_table,
7281                                             reloc_opcodes)
7282           || !check_section_ebb_reduces (&ebb_table))
7283         {
7284           /* If anything goes wrong or we get unlucky and something does
7285              not fit, with our plan because of expansion between
7286              critical branches, just convert to a NOP.  */
7287
7288           text_action_add (&relax_info->action_list,
7289                            ta_convert_longcall, sec, r_offset, 0);
7290           i = ebb_table.ebb.end_reloc_idx;
7291           free_ebb_constraint (&ebb_table);
7292           continue;
7293         }
7294
7295       text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
7296
7297       /* Update the index so we do not go looking at the relocations
7298          we have already processed.  */
7299       i = ebb_table.ebb.end_reloc_idx;
7300       free_ebb_constraint (&ebb_table);
7301     }
7302
7303 #if DEBUG
7304   if (relax_info->action_list.head)
7305     print_action_list (stderr, &relax_info->action_list);
7306 #endif
7307
7308 error_return:
7309   release_contents (sec, contents);
7310   release_internal_relocs (sec, internal_relocs);
7311   if (prop_table)
7312     free (prop_table);
7313   if (reloc_opcodes)
7314     free (reloc_opcodes);
7315
7316   return ok;
7317 }
7318
7319
7320 /* Do not widen an instruction if it is preceeded by a
7321    loop opcode.  It might cause misalignment.  */
7322
7323 static bfd_boolean
7324 prev_instr_is_a_loop (bfd_byte *contents,
7325                       bfd_size_type content_length,
7326                       bfd_size_type offset)
7327 {
7328   xtensa_opcode prev_opcode;
7329
7330   if (offset < 3)
7331     return FALSE;
7332   prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
7333   return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
7334 }
7335
7336
7337 /* Find all of the possible actions for an extended basic block.  */
7338
7339 bfd_boolean
7340 compute_ebb_proposed_actions (ebb_constraint *ebb_table)
7341 {
7342   const ebb_t *ebb = &ebb_table->ebb;
7343   unsigned rel_idx = ebb->start_reloc_idx;
7344   property_table_entry *entry, *start_entry, *end_entry;
7345   bfd_vma offset = 0;
7346   xtensa_isa isa = xtensa_default_isa;
7347   xtensa_format fmt;
7348   static xtensa_insnbuf insnbuf = NULL;
7349   static xtensa_insnbuf slotbuf = NULL;
7350
7351   if (insnbuf == NULL)
7352     {
7353       insnbuf = xtensa_insnbuf_alloc (isa);
7354       slotbuf = xtensa_insnbuf_alloc (isa);
7355     }
7356
7357   start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
7358   end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
7359
7360   for (entry = start_entry; entry <= end_entry; entry++)
7361     {
7362       bfd_vma start_offset, end_offset;
7363       bfd_size_type insn_len;
7364
7365       start_offset = entry->address - ebb->sec->vma;
7366       end_offset = entry->address + entry->size - ebb->sec->vma;
7367
7368       if (entry == start_entry)
7369         start_offset = ebb->start_offset;
7370       if (entry == end_entry)
7371         end_offset = ebb->end_offset;
7372       offset = start_offset;
7373
7374       if (offset == entry->address - ebb->sec->vma
7375           && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
7376         {
7377           enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
7378           BFD_ASSERT (offset != end_offset);
7379           if (offset == end_offset)
7380             return FALSE;
7381
7382           insn_len = insn_decode_len (ebb->contents, ebb->content_length,
7383                                       offset);
7384           if (insn_len == 0)
7385             goto decode_error;
7386
7387           if (check_branch_target_aligned_address (offset, insn_len))
7388             align_type = EBB_REQUIRE_TGT_ALIGN;
7389
7390           ebb_propose_action (ebb_table, align_type, 0,
7391                               ta_none, offset, 0, TRUE);
7392         }
7393
7394       while (offset != end_offset)
7395         {
7396           Elf_Internal_Rela *irel;
7397           xtensa_opcode opcode;
7398
7399           while (rel_idx < ebb->end_reloc_idx
7400                  && (ebb->relocs[rel_idx].r_offset < offset
7401                      || (ebb->relocs[rel_idx].r_offset == offset
7402                          && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
7403                              != R_XTENSA_ASM_SIMPLIFY))))
7404             rel_idx++;
7405
7406           /* Check for longcall.  */
7407           irel = &ebb->relocs[rel_idx];
7408           if (irel->r_offset == offset
7409               && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
7410             {
7411               bfd_size_type simplify_size;
7412
7413               simplify_size = get_asm_simplify_size (ebb->contents,
7414                                                      ebb->content_length,
7415                                                      irel->r_offset);
7416               if (simplify_size == 0)
7417                 goto decode_error;
7418
7419               ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7420                                   ta_convert_longcall, offset, 0, TRUE);
7421
7422               offset += simplify_size;
7423               continue;
7424             }
7425
7426           if (offset + MIN_INSN_LENGTH > ebb->content_length)
7427             goto decode_error;
7428           xtensa_insnbuf_from_chars (isa, insnbuf, &ebb->contents[offset],
7429                                      ebb->content_length - offset);
7430           fmt = xtensa_format_decode (isa, insnbuf);
7431           if (fmt == XTENSA_UNDEFINED)
7432             goto decode_error;
7433           insn_len = xtensa_format_length (isa, fmt);
7434           if (insn_len == (bfd_size_type) XTENSA_UNDEFINED)
7435             goto decode_error;
7436
7437           if (xtensa_format_num_slots (isa, fmt) != 1)
7438             {
7439               offset += insn_len;
7440               continue;
7441             }
7442
7443           xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7444           opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7445           if (opcode == XTENSA_UNDEFINED)
7446             goto decode_error;
7447
7448           if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
7449               && (entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7450               && can_narrow_instruction (slotbuf, fmt, opcode) != 0)
7451             {
7452               /* Add an instruction narrow action.  */
7453               ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7454                                   ta_narrow_insn, offset, 0, FALSE);
7455             }
7456           else if ((entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7457                    && can_widen_instruction (slotbuf, fmt, opcode) != 0
7458                    && ! prev_instr_is_a_loop (ebb->contents,
7459                                               ebb->content_length, offset))
7460             {
7461               /* Add an instruction widen action.  */
7462               ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7463                                   ta_widen_insn, offset, 0, FALSE);
7464             }
7465           else if (xtensa_opcode_is_loop (xtensa_default_isa, opcode) == 1)
7466             {
7467               /* Check for branch targets.  */
7468               ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
7469                                   ta_none, offset, 0, TRUE);
7470             }
7471
7472           offset += insn_len;
7473         }
7474     }
7475
7476   if (ebb->ends_unreachable)
7477     {
7478       ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7479                           ta_fill, ebb->end_offset, 0, TRUE);
7480     }
7481
7482   return TRUE;
7483
7484  decode_error:
7485   (*_bfd_error_handler)
7486     (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
7487      ebb->sec->owner, ebb->sec, offset);
7488   return FALSE;
7489 }
7490
7491
7492 /* After all of the information has collected about the
7493    transformations possible in an EBB, compute the appropriate actions
7494    here in compute_ebb_actions.  We still must check later to make
7495    sure that the actions do not break any relocations.  The algorithm
7496    used here is pretty greedy.  Basically, it removes as many no-ops
7497    as possible so that the end of the EBB has the same alignment
7498    characteristics as the original.  First, it uses narrowing, then
7499    fill space at the end of the EBB, and finally widenings.  If that
7500    does not work, it tries again with one fewer no-op removed.  The
7501    optimization will only be performed if all of the branch targets
7502    that were aligned before transformation are also aligned after the
7503    transformation.
7504
7505    When the size_opt flag is set, ignore the branch target alignments,
7506    narrow all wide instructions, and remove all no-ops unless the end
7507    of the EBB prevents it.  */
7508
7509 bfd_boolean
7510 compute_ebb_actions (ebb_constraint *ebb_table)
7511 {
7512   unsigned i = 0;
7513   unsigned j;
7514   int removed_bytes = 0;
7515   ebb_t *ebb = &ebb_table->ebb;
7516   unsigned seg_idx_start = 0;
7517   unsigned seg_idx_end = 0;
7518
7519   /* We perform this like the assembler relaxation algorithm: Start by
7520      assuming all instructions are narrow and all no-ops removed; then
7521      walk through....  */
7522
7523   /* For each segment of this that has a solid constraint, check to
7524      see if there are any combinations that will keep the constraint.
7525      If so, use it.  */
7526   for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
7527     {
7528       bfd_boolean requires_text_end_align = FALSE;
7529       unsigned longcall_count = 0;
7530       unsigned longcall_convert_count = 0;
7531       unsigned narrowable_count = 0;
7532       unsigned narrowable_convert_count = 0;
7533       unsigned widenable_count = 0;
7534       unsigned widenable_convert_count = 0;
7535
7536       proposed_action *action = NULL;
7537       int align = (1 << ebb_table->ebb.sec->alignment_power);
7538
7539       seg_idx_start = seg_idx_end;
7540
7541       for (i = seg_idx_start; i < ebb_table->action_count; i++)
7542         {
7543           action = &ebb_table->actions[i];
7544           if (action->action == ta_convert_longcall)
7545             longcall_count++;
7546           if (action->action == ta_narrow_insn)
7547             narrowable_count++;
7548           if (action->action == ta_widen_insn)
7549             widenable_count++;
7550           if (action->action == ta_fill)
7551             break;
7552           if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
7553             break;
7554           if (action->align_type == EBB_REQUIRE_TGT_ALIGN
7555               && !elf32xtensa_size_opt)
7556             break;
7557         }
7558       seg_idx_end = i;
7559
7560       if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
7561         requires_text_end_align = TRUE;
7562
7563       if (elf32xtensa_size_opt && !requires_text_end_align
7564           && action->align_type != EBB_REQUIRE_LOOP_ALIGN
7565           && action->align_type != EBB_REQUIRE_TGT_ALIGN)
7566         {
7567           longcall_convert_count = longcall_count;
7568           narrowable_convert_count = narrowable_count;
7569           widenable_convert_count = 0;
7570         }
7571       else
7572         {
7573           /* There is a constraint.  Convert the max number of longcalls.  */
7574           narrowable_convert_count = 0;
7575           longcall_convert_count = 0;
7576           widenable_convert_count = 0;
7577
7578           for (j = 0; j < longcall_count; j++)
7579             {
7580               int removed = (longcall_count - j) * 3 & (align - 1);
7581               unsigned desire_narrow = (align - removed) & (align - 1);
7582               unsigned desire_widen = removed;
7583               if (desire_narrow <= narrowable_count)
7584                 {
7585                   narrowable_convert_count = desire_narrow;
7586                   narrowable_convert_count +=
7587                     (align * ((narrowable_count - narrowable_convert_count)
7588                               / align));
7589                   longcall_convert_count = (longcall_count - j);
7590                   widenable_convert_count = 0;
7591                   break;
7592                 }
7593               if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
7594                 {
7595                   narrowable_convert_count = 0;
7596                   longcall_convert_count = longcall_count - j;
7597                   widenable_convert_count = desire_widen;
7598                   break;
7599                 }
7600             }
7601         }
7602
7603       /* Now the number of conversions are saved.  Do them.  */
7604       for (i = seg_idx_start; i < seg_idx_end; i++)
7605         {
7606           action = &ebb_table->actions[i];
7607           switch (action->action)
7608             {
7609             case ta_convert_longcall:
7610               if (longcall_convert_count != 0)
7611                 {
7612                   action->action = ta_remove_longcall;
7613                   action->do_action = TRUE;
7614                   action->removed_bytes += 3;
7615                   longcall_convert_count--;
7616                 }
7617               break;
7618             case ta_narrow_insn:
7619               if (narrowable_convert_count != 0)
7620                 {
7621                   action->do_action = TRUE;
7622                   action->removed_bytes += 1;
7623                   narrowable_convert_count--;
7624                 }
7625               break;
7626             case ta_widen_insn:
7627               if (widenable_convert_count != 0)
7628                 {
7629                   action->do_action = TRUE;
7630                   action->removed_bytes -= 1;
7631                   widenable_convert_count--;
7632                 }
7633               break;
7634             default:
7635               break;
7636             }
7637         }
7638     }
7639
7640   /* Now we move on to some local opts.  Try to remove each of the
7641      remaining longcalls.  */
7642
7643   if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
7644     {
7645       removed_bytes = 0;
7646       for (i = 0; i < ebb_table->action_count; i++)
7647         {
7648           int old_removed_bytes = removed_bytes;
7649           proposed_action *action = &ebb_table->actions[i];
7650
7651           if (action->do_action && action->action == ta_convert_longcall)
7652             {
7653               bfd_boolean bad_alignment = FALSE;
7654               removed_bytes += 3;
7655               for (j = i + 1; j < ebb_table->action_count; j++)
7656                 {
7657                   proposed_action *new_action = &ebb_table->actions[j];
7658                   bfd_vma offset = new_action->offset;
7659                   if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
7660                     {
7661                       if (!check_branch_target_aligned
7662                           (ebb_table->ebb.contents,
7663                            ebb_table->ebb.content_length,
7664                            offset, offset - removed_bytes))
7665                         {
7666                           bad_alignment = TRUE;
7667                           break;
7668                         }
7669                     }
7670                   if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
7671                     {
7672                       if (!check_loop_aligned (ebb_table->ebb.contents,
7673                                                ebb_table->ebb.content_length,
7674                                                offset,
7675                                                offset - removed_bytes))
7676                         {
7677                           bad_alignment = TRUE;
7678                           break;
7679                         }
7680                     }
7681                   if (new_action->action == ta_narrow_insn
7682                       && !new_action->do_action
7683                       && ebb_table->ebb.sec->alignment_power == 2)
7684                     {
7685                       /* Narrow an instruction and we are done.  */
7686                       new_action->do_action = TRUE;
7687                       new_action->removed_bytes += 1;
7688                       bad_alignment = FALSE;
7689                       break;
7690                     }
7691                   if (new_action->action == ta_widen_insn
7692                       && new_action->do_action
7693                       && ebb_table->ebb.sec->alignment_power == 2)
7694                     {
7695                       /* Narrow an instruction and we are done.  */
7696                       new_action->do_action = FALSE;
7697                       new_action->removed_bytes += 1;
7698                       bad_alignment = FALSE;
7699                       break;
7700                     }
7701                   if (new_action->do_action)
7702                     removed_bytes += new_action->removed_bytes;
7703                 }
7704               if (!bad_alignment)
7705                 {
7706                   action->removed_bytes += 3;
7707                   action->action = ta_remove_longcall;
7708                   action->do_action = TRUE;
7709                 }
7710             }
7711           removed_bytes = old_removed_bytes;
7712           if (action->do_action)
7713             removed_bytes += action->removed_bytes;
7714         }
7715     }
7716
7717   removed_bytes = 0;
7718   for (i = 0; i < ebb_table->action_count; ++i)
7719     {
7720       proposed_action *action = &ebb_table->actions[i];
7721       if (action->do_action)
7722         removed_bytes += action->removed_bytes;
7723     }
7724
7725   if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
7726       && ebb->ends_unreachable)
7727     {
7728       proposed_action *action;
7729       int br;
7730       int extra_space;
7731
7732       BFD_ASSERT (ebb_table->action_count != 0);
7733       action = &ebb_table->actions[ebb_table->action_count - 1];
7734       BFD_ASSERT (action->action == ta_fill);
7735       BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
7736
7737       extra_space = compute_fill_extra_space (ebb->ends_unreachable);
7738       br = action->removed_bytes + removed_bytes + extra_space;
7739       br = br & ((1 << ebb->sec->alignment_power ) - 1);
7740
7741       action->removed_bytes = extra_space - br;
7742     }
7743   return TRUE;
7744 }
7745
7746
7747 /* The xlate_map is a sorted array of address mappings designed to
7748    answer the offset_with_removed_text() query with a binary search instead
7749    of a linear search through the section's action_list.  */
7750
7751 typedef struct xlate_map_entry xlate_map_entry_t;
7752 typedef struct xlate_map xlate_map_t;
7753
7754 struct xlate_map_entry
7755 {
7756   unsigned orig_address;
7757   unsigned new_address;
7758   unsigned size;
7759 };
7760
7761 struct xlate_map
7762 {
7763   unsigned entry_count;
7764   xlate_map_entry_t *entry;
7765 };
7766
7767
7768 static int
7769 xlate_compare (const void *a_v, const void *b_v)
7770 {
7771   const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
7772   const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
7773   if (a->orig_address < b->orig_address)
7774     return -1;
7775   if (a->orig_address > (b->orig_address + b->size - 1))
7776     return 1;
7777   return 0;
7778 }
7779
7780
7781 static bfd_vma
7782 xlate_offset_with_removed_text (const xlate_map_t *map,
7783                                 text_action_list *action_list,
7784                                 bfd_vma offset)
7785 {
7786   xlate_map_entry_t tmp;
7787   void *r;
7788   xlate_map_entry_t *e;
7789
7790   if (map == NULL)
7791     return offset_with_removed_text (action_list, offset);
7792
7793   if (map->entry_count == 0)
7794     return offset;
7795
7796   tmp.orig_address = offset;
7797   tmp.new_address = offset;
7798   tmp.size = 1;
7799
7800   r = bsearch (&offset, map->entry, map->entry_count,
7801                sizeof (xlate_map_entry_t), &xlate_compare);
7802   e = (xlate_map_entry_t *) r;
7803
7804   BFD_ASSERT (e != NULL);
7805   if (e == NULL)
7806     return offset;
7807   return e->new_address - e->orig_address + offset;
7808 }
7809
7810
7811 /* Build a binary searchable offset translation map from a section's
7812    action list.  */
7813
7814 static xlate_map_t *
7815 build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
7816 {
7817   xlate_map_t *map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
7818   text_action_list *action_list = &relax_info->action_list;
7819   unsigned num_actions = 0;
7820   text_action *r;
7821   int removed;
7822   xlate_map_entry_t *current_entry;
7823
7824   if (map == NULL)
7825     return NULL;
7826
7827   num_actions = action_list_count (action_list);
7828   map->entry = (xlate_map_entry_t *)
7829     bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
7830   if (map->entry == NULL)
7831     {
7832       free (map);
7833       return NULL;
7834     }
7835   map->entry_count = 0;
7836
7837   removed = 0;
7838   current_entry = &map->entry[0];
7839
7840   current_entry->orig_address = 0;
7841   current_entry->new_address = 0;
7842   current_entry->size = 0;
7843
7844   for (r = action_list->head; r != NULL; r = r->next)
7845     {
7846       unsigned orig_size = 0;
7847       switch (r->action)
7848         {
7849         case ta_none:
7850         case ta_remove_insn:
7851         case ta_convert_longcall:
7852         case ta_remove_literal:
7853         case ta_add_literal:
7854           break;
7855         case ta_remove_longcall:
7856           orig_size = 6;
7857           break;
7858         case ta_narrow_insn:
7859           orig_size = 3;
7860           break;
7861         case ta_widen_insn:
7862           orig_size = 2;
7863           break;
7864         case ta_fill:
7865           break;
7866         }
7867       current_entry->size =
7868         r->offset + orig_size - current_entry->orig_address;
7869       if (current_entry->size != 0)
7870         {
7871           current_entry++;
7872           map->entry_count++;
7873         }
7874       current_entry->orig_address = r->offset + orig_size;
7875       removed += r->removed_bytes;
7876       current_entry->new_address = r->offset + orig_size - removed;
7877       current_entry->size = 0;
7878     }
7879
7880   current_entry->size = (bfd_get_section_limit (sec->owner, sec)
7881                          - current_entry->orig_address);
7882   if (current_entry->size != 0)
7883     map->entry_count++;
7884
7885   return map;
7886 }
7887
7888
7889 /* Free an offset translation map.  */
7890
7891 static void
7892 free_xlate_map (xlate_map_t *map)
7893 {
7894   if (map && map->entry)
7895     free (map->entry);
7896   if (map)
7897     free (map);
7898 }
7899
7900
7901 /* Use check_section_ebb_pcrels_fit to make sure that all of the
7902    relocations in a section will fit if a proposed set of actions
7903    are performed.  */
7904
7905 static bfd_boolean
7906 check_section_ebb_pcrels_fit (bfd *abfd,
7907                               asection *sec,
7908                               bfd_byte *contents,
7909                               Elf_Internal_Rela *internal_relocs,
7910                               const ebb_constraint *constraint,
7911                               const xtensa_opcode *reloc_opcodes)
7912 {
7913   unsigned i, j;
7914   Elf_Internal_Rela *irel;
7915   xlate_map_t *xmap = NULL;
7916   bfd_boolean ok = TRUE;
7917   xtensa_relax_info *relax_info;
7918
7919   relax_info = get_xtensa_relax_info (sec);
7920
7921   if (relax_info && sec->reloc_count > 100)
7922     {
7923       xmap = build_xlate_map (sec, relax_info);
7924       /* NULL indicates out of memory, but the slow version
7925          can still be used.  */
7926     }
7927
7928   for (i = 0; i < sec->reloc_count; i++)
7929     {
7930       r_reloc r_rel;
7931       bfd_vma orig_self_offset, orig_target_offset;
7932       bfd_vma self_offset, target_offset;
7933       int r_type;
7934       reloc_howto_type *howto;
7935       int self_removed_bytes, target_removed_bytes;
7936
7937       irel = &internal_relocs[i];
7938       r_type = ELF32_R_TYPE (irel->r_info);
7939
7940       howto = &elf_howto_table[r_type];
7941       /* We maintain the required invariant: PC-relative relocations
7942          that fit before linking must fit after linking.  Thus we only
7943          need to deal with relocations to the same section that are
7944          PC-relative.  */
7945       if (r_type == R_XTENSA_ASM_SIMPLIFY
7946           || r_type == R_XTENSA_32_PCREL
7947           || !howto->pc_relative)
7948         continue;
7949
7950       r_reloc_init (&r_rel, abfd, irel, contents,
7951                     bfd_get_section_limit (abfd, sec));
7952
7953       if (r_reloc_get_section (&r_rel) != sec)
7954         continue;
7955
7956       orig_self_offset = irel->r_offset;
7957       orig_target_offset = r_rel.target_offset;
7958
7959       self_offset = orig_self_offset;
7960       target_offset = orig_target_offset;
7961
7962       if (relax_info)
7963         {
7964           self_offset =
7965             xlate_offset_with_removed_text (xmap, &relax_info->action_list,
7966                                             orig_self_offset);
7967           target_offset =
7968             xlate_offset_with_removed_text (xmap, &relax_info->action_list,
7969                                             orig_target_offset);
7970         }
7971
7972       self_removed_bytes = 0;
7973       target_removed_bytes = 0;
7974
7975       for (j = 0; j < constraint->action_count; ++j)
7976         {
7977           proposed_action *action = &constraint->actions[j];
7978           bfd_vma offset = action->offset;
7979           int removed_bytes = action->removed_bytes;
7980           if (offset < orig_self_offset
7981               || (offset == orig_self_offset && action->action == ta_fill
7982                   && action->removed_bytes < 0))
7983             self_removed_bytes += removed_bytes;
7984           if (offset < orig_target_offset
7985               || (offset == orig_target_offset && action->action == ta_fill
7986                   && action->removed_bytes < 0))
7987             target_removed_bytes += removed_bytes;
7988         }
7989       self_offset -= self_removed_bytes;
7990       target_offset -= target_removed_bytes;
7991
7992       /* Try to encode it.  Get the operand and check.  */
7993       if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7994         {
7995           /* None of the current alternate relocs are PC-relative,
7996              and only PC-relative relocs matter here.  */
7997         }
7998       else
7999         {
8000           xtensa_opcode opcode;
8001           int opnum;
8002
8003           if (reloc_opcodes)
8004             opcode = reloc_opcodes[i];
8005           else
8006             opcode = get_relocation_opcode (abfd, sec, contents, irel);
8007           if (opcode == XTENSA_UNDEFINED)
8008             {
8009               ok = FALSE;
8010               break;
8011             }
8012
8013           opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
8014           if (opnum == XTENSA_UNDEFINED)
8015             {
8016               ok = FALSE;
8017               break;
8018             }
8019
8020           if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
8021             {
8022               ok = FALSE;
8023               break;
8024             }
8025         }
8026     }
8027
8028   if (xmap)
8029     free_xlate_map (xmap);
8030
8031   return ok;
8032 }
8033
8034
8035 static bfd_boolean
8036 check_section_ebb_reduces (const ebb_constraint *constraint)
8037 {
8038   int removed = 0;
8039   unsigned i;
8040
8041   for (i = 0; i < constraint->action_count; i++)
8042     {
8043       const proposed_action *action = &constraint->actions[i];
8044       if (action->do_action)
8045         removed += action->removed_bytes;
8046     }
8047   if (removed < 0)
8048     return FALSE;
8049
8050   return TRUE;
8051 }
8052
8053
8054 void
8055 text_action_add_proposed (text_action_list *l,
8056                           const ebb_constraint *ebb_table,
8057                           asection *sec)
8058 {
8059   unsigned i;
8060
8061   for (i = 0; i < ebb_table->action_count; i++)
8062     {
8063       proposed_action *action = &ebb_table->actions[i];
8064
8065       if (!action->do_action)
8066         continue;
8067       switch (action->action)
8068         {
8069         case ta_remove_insn:
8070         case ta_remove_longcall:
8071         case ta_convert_longcall:
8072         case ta_narrow_insn:
8073         case ta_widen_insn:
8074         case ta_fill:
8075         case ta_remove_literal:
8076           text_action_add (l, action->action, sec, action->offset,
8077                            action->removed_bytes);
8078           break;
8079         case ta_none:
8080           break;
8081         default:
8082           BFD_ASSERT (0);
8083           break;
8084         }
8085     }
8086 }
8087
8088
8089 int
8090 compute_fill_extra_space (property_table_entry *entry)
8091 {
8092   int fill_extra_space;
8093
8094   if (!entry)
8095     return 0;
8096
8097   if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
8098     return 0;
8099
8100   fill_extra_space = entry->size;
8101   if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
8102     {
8103       /* Fill bytes for alignment:
8104          (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8105       int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
8106       int nsm = (1 << pow) - 1;
8107       bfd_vma addr = entry->address + entry->size;
8108       bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
8109       fill_extra_space += align_fill;
8110     }
8111   return fill_extra_space;
8112 }
8113
8114 \f
8115 /* First relaxation pass.  */
8116
8117 /* If the section contains relaxable literals, check each literal to
8118    see if it has the same value as another literal that has already
8119    been seen, either in the current section or a previous one.  If so,
8120    add an entry to the per-section list of removed literals.  The
8121    actual changes are deferred until the next pass.  */
8122
8123 static bfd_boolean
8124 compute_removed_literals (bfd *abfd,
8125                           asection *sec,
8126                           struct bfd_link_info *link_info,
8127                           value_map_hash_table *values)
8128 {
8129   xtensa_relax_info *relax_info;
8130   bfd_byte *contents;
8131   Elf_Internal_Rela *internal_relocs;
8132   source_reloc *src_relocs, *rel;
8133   bfd_boolean ok = TRUE;
8134   property_table_entry *prop_table = NULL;
8135   int ptblsize;
8136   int i, prev_i;
8137   bfd_boolean last_loc_is_prev = FALSE;
8138   bfd_vma last_target_offset = 0;
8139   section_cache_t target_sec_cache;
8140   bfd_size_type sec_size;
8141
8142   init_section_cache (&target_sec_cache);
8143
8144   /* Do nothing if it is not a relaxable literal section.  */
8145   relax_info = get_xtensa_relax_info (sec);
8146   BFD_ASSERT (relax_info);
8147   if (!relax_info->is_relaxable_literal_section)
8148     return ok;
8149
8150   internal_relocs = retrieve_internal_relocs (abfd, sec,
8151                                               link_info->keep_memory);
8152
8153   sec_size = bfd_get_section_limit (abfd, sec);
8154   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8155   if (contents == NULL && sec_size != 0)
8156     {
8157       ok = FALSE;
8158       goto error_return;
8159     }
8160
8161   /* Sort the source_relocs by target offset.  */
8162   src_relocs = relax_info->src_relocs;
8163   qsort (src_relocs, relax_info->src_count,
8164          sizeof (source_reloc), source_reloc_compare);
8165   qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
8166          internal_reloc_compare);
8167
8168   ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
8169                                         XTENSA_PROP_SEC_NAME, FALSE);
8170   if (ptblsize < 0)
8171     {
8172       ok = FALSE;
8173       goto error_return;
8174     }
8175
8176   prev_i = -1;
8177   for (i = 0; i < relax_info->src_count; i++)
8178     {
8179       Elf_Internal_Rela *irel = NULL;
8180
8181       rel = &src_relocs[i];
8182       if (get_l32r_opcode () != rel->opcode)
8183         continue;
8184       irel = get_irel_at_offset (sec, internal_relocs,
8185                                  rel->r_rel.target_offset);
8186
8187       /* If the relocation on this is not a simple R_XTENSA_32 or
8188          R_XTENSA_PLT then do not consider it.  This may happen when
8189          the difference of two symbols is used in a literal.  */
8190       if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
8191                    && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
8192         continue;
8193
8194       /* If the target_offset for this relocation is the same as the
8195          previous relocation, then we've already considered whether the
8196          literal can be coalesced.  Skip to the next one....  */
8197       if (i != 0 && prev_i != -1
8198           && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
8199         continue;
8200       prev_i = i;
8201
8202       if (last_loc_is_prev &&
8203           last_target_offset + 4 != rel->r_rel.target_offset)
8204         last_loc_is_prev = FALSE;
8205
8206       /* Check if the relocation was from an L32R that is being removed
8207          because a CALLX was converted to a direct CALL, and check if
8208          there are no other relocations to the literal.  */
8209       if (is_removable_literal (rel, i, src_relocs, relax_info->src_count,
8210                                 sec, prop_table, ptblsize))
8211         {
8212           if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
8213                                     irel, rel, prop_table, ptblsize))
8214             {
8215               ok = FALSE;
8216               goto error_return;
8217             }
8218           last_target_offset = rel->r_rel.target_offset;
8219           continue;
8220         }
8221
8222       if (!identify_literal_placement (abfd, sec, contents, link_info,
8223                                        values,
8224                                        &last_loc_is_prev, irel,
8225                                        relax_info->src_count - i, rel,
8226                                        prop_table, ptblsize,
8227                                        &target_sec_cache, rel->is_abs_literal))
8228         {
8229           ok = FALSE;
8230           goto error_return;
8231         }
8232       last_target_offset = rel->r_rel.target_offset;
8233     }
8234
8235 #if DEBUG
8236   print_removed_literals (stderr, &relax_info->removed_list);
8237   print_action_list (stderr, &relax_info->action_list);
8238 #endif /* DEBUG */
8239
8240 error_return:
8241   if (prop_table) free (prop_table);
8242   clear_section_cache (&target_sec_cache);
8243
8244   release_contents (sec, contents);
8245   release_internal_relocs (sec, internal_relocs);
8246   return ok;
8247 }
8248
8249
8250 static Elf_Internal_Rela *
8251 get_irel_at_offset (asection *sec,
8252                     Elf_Internal_Rela *internal_relocs,
8253                     bfd_vma offset)
8254 {
8255   unsigned i;
8256   Elf_Internal_Rela *irel;
8257   unsigned r_type;
8258   Elf_Internal_Rela key;
8259
8260   if (!internal_relocs)
8261     return NULL;
8262
8263   key.r_offset = offset;
8264   irel = bsearch (&key, internal_relocs, sec->reloc_count,
8265                   sizeof (Elf_Internal_Rela), internal_reloc_matches);
8266   if (!irel)
8267     return NULL;
8268
8269   /* bsearch does not guarantee which will be returned if there are
8270      multiple matches.  We need the first that is not an alignment.  */
8271   i = irel - internal_relocs;
8272   while (i > 0)
8273     {
8274       if (internal_relocs[i-1].r_offset != offset)
8275         break;
8276       i--;
8277     }
8278   for ( ; i < sec->reloc_count; i++)
8279     {
8280       irel = &internal_relocs[i];
8281       r_type = ELF32_R_TYPE (irel->r_info);
8282       if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
8283         return irel;
8284     }
8285
8286   return NULL;
8287 }
8288
8289
8290 bfd_boolean
8291 is_removable_literal (const source_reloc *rel,
8292                       int i,
8293                       const source_reloc *src_relocs,
8294                       int src_count,
8295                       asection *sec,
8296                       property_table_entry *prop_table,
8297                       int ptblsize)
8298 {
8299   const source_reloc *curr_rel;
8300   property_table_entry *entry;
8301
8302   if (!rel->is_null)
8303     return FALSE;
8304
8305   entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8306                                           sec->vma + rel->r_rel.target_offset);
8307   if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8308     return FALSE;
8309
8310   for (++i; i < src_count; ++i)
8311     {
8312       curr_rel = &src_relocs[i];
8313       /* If all others have the same target offset....  */
8314       if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
8315         return TRUE;
8316
8317       if (!curr_rel->is_null
8318           && !xtensa_is_property_section (curr_rel->source_sec)
8319           && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
8320         return FALSE;
8321     }
8322   return TRUE;
8323 }
8324
8325
8326 bfd_boolean
8327 remove_dead_literal (bfd *abfd,
8328                      asection *sec,
8329                      struct bfd_link_info *link_info,
8330                      Elf_Internal_Rela *internal_relocs,
8331                      Elf_Internal_Rela *irel,
8332                      source_reloc *rel,
8333                      property_table_entry *prop_table,
8334                      int ptblsize)
8335 {
8336   property_table_entry *entry;
8337   xtensa_relax_info *relax_info;
8338
8339   relax_info = get_xtensa_relax_info (sec);
8340   if (!relax_info)
8341     return FALSE;
8342
8343   entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8344                                           sec->vma + rel->r_rel.target_offset);
8345
8346   /* Mark the unused literal so that it will be removed.  */
8347   add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
8348
8349   text_action_add (&relax_info->action_list,
8350                    ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8351
8352   /* If the section is 4-byte aligned, do not add fill.  */
8353   if (sec->alignment_power > 2)
8354     {
8355       int fill_extra_space;
8356       bfd_vma entry_sec_offset;
8357       text_action *fa;
8358       property_table_entry *the_add_entry;
8359       int removed_diff;
8360
8361       if (entry)
8362         entry_sec_offset = entry->address - sec->vma + entry->size;
8363       else
8364         entry_sec_offset = rel->r_rel.target_offset + 4;
8365
8366       /* If the literal range is at the end of the section,
8367          do not add fill.  */
8368       the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8369                                                       entry_sec_offset);
8370       fill_extra_space = compute_fill_extra_space (the_add_entry);
8371
8372       fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8373       removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8374                                                   -4, fill_extra_space);
8375       if (fa)
8376         adjust_fill_action (fa, removed_diff);
8377       else
8378         text_action_add (&relax_info->action_list,
8379                          ta_fill, sec, entry_sec_offset, removed_diff);
8380     }
8381
8382   /* Zero out the relocation on this literal location.  */
8383   if (irel)
8384     {
8385       if (elf_hash_table (link_info)->dynamic_sections_created)
8386         shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8387
8388       irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8389       pin_internal_relocs (sec, internal_relocs);
8390     }
8391
8392   /* Do not modify "last_loc_is_prev".  */
8393   return TRUE;
8394 }
8395
8396
8397 bfd_boolean
8398 identify_literal_placement (bfd *abfd,
8399                             asection *sec,
8400                             bfd_byte *contents,
8401                             struct bfd_link_info *link_info,
8402                             value_map_hash_table *values,
8403                             bfd_boolean *last_loc_is_prev_p,
8404                             Elf_Internal_Rela *irel,
8405                             int remaining_src_rels,
8406                             source_reloc *rel,
8407                             property_table_entry *prop_table,
8408                             int ptblsize,
8409                             section_cache_t *target_sec_cache,
8410                             bfd_boolean is_abs_literal)
8411 {
8412   literal_value val;
8413   value_map *val_map;
8414   xtensa_relax_info *relax_info;
8415   bfd_boolean literal_placed = FALSE;
8416   r_reloc r_rel;
8417   unsigned long value;
8418   bfd_boolean final_static_link;
8419   bfd_size_type sec_size;
8420
8421   relax_info = get_xtensa_relax_info (sec);
8422   if (!relax_info)
8423     return FALSE;
8424
8425   sec_size = bfd_get_section_limit (abfd, sec);
8426
8427   final_static_link =
8428     (!link_info->relocatable
8429      && !elf_hash_table (link_info)->dynamic_sections_created);
8430
8431   /* The placement algorithm first checks to see if the literal is
8432      already in the value map.  If so and the value map is reachable
8433      from all uses, then the literal is moved to that location.  If
8434      not, then we identify the last location where a fresh literal was
8435      placed.  If the literal can be safely moved there, then we do so.
8436      If not, then we assume that the literal is not to move and leave
8437      the literal where it is, marking it as the last literal
8438      location.  */
8439
8440   /* Find the literal value.  */
8441   value = 0;
8442   r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8443   if (!irel)
8444     {
8445       BFD_ASSERT (rel->r_rel.target_offset < sec_size);
8446       value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
8447     }
8448   init_literal_value (&val, &r_rel, value, is_abs_literal);
8449
8450   /* Check if we've seen another literal with the same value that
8451      is in the same output section.  */
8452   val_map = value_map_get_cached_value (values, &val, final_static_link);
8453
8454   if (val_map
8455       && (r_reloc_get_section (&val_map->loc)->output_section
8456           == sec->output_section)
8457       && relocations_reach (rel, remaining_src_rels, &val_map->loc)
8458       && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
8459     {
8460       /* No change to last_loc_is_prev.  */
8461       literal_placed = TRUE;
8462     }
8463
8464   /* For relocatable links, do not try to move literals.  To do it
8465      correctly might increase the number of relocations in an input
8466      section making the default relocatable linking fail.  */
8467   if (!link_info->relocatable && !literal_placed
8468       && values->has_last_loc && !(*last_loc_is_prev_p))
8469     {
8470       asection *target_sec = r_reloc_get_section (&values->last_loc);
8471       if (target_sec && target_sec->output_section == sec->output_section)
8472         {
8473           /* Increment the virtual offset.  */
8474           r_reloc try_loc = values->last_loc;
8475           try_loc.virtual_offset += 4;
8476
8477           /* There is a last loc that was in the same output section.  */
8478           if (relocations_reach (rel, remaining_src_rels, &try_loc)
8479               && move_shared_literal (sec, link_info, rel,
8480                                       prop_table, ptblsize,
8481                                       &try_loc, &val, target_sec_cache))
8482             {
8483               values->last_loc.virtual_offset += 4;
8484               literal_placed = TRUE;
8485               if (!val_map)
8486                 val_map = add_value_map (values, &val, &try_loc,
8487                                          final_static_link);
8488               else
8489                 val_map->loc = try_loc;
8490             }
8491         }
8492     }
8493
8494   if (!literal_placed)
8495     {
8496       /* Nothing worked, leave the literal alone but update the last loc.  */
8497       values->has_last_loc = TRUE;
8498       values->last_loc = rel->r_rel;
8499       if (!val_map)
8500         val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
8501       else
8502         val_map->loc = rel->r_rel;
8503       *last_loc_is_prev_p = TRUE;
8504     }
8505
8506   return TRUE;
8507 }
8508
8509
8510 /* Check if the original relocations (presumably on L32R instructions)
8511    identified by reloc[0..N] can be changed to reference the literal
8512    identified by r_rel.  If r_rel is out of range for any of the
8513    original relocations, then we don't want to coalesce the original
8514    literal with the one at r_rel.  We only check reloc[0..N], where the
8515    offsets are all the same as for reloc[0] (i.e., they're all
8516    referencing the same literal) and where N is also bounded by the
8517    number of remaining entries in the "reloc" array.  The "reloc" array
8518    is sorted by target offset so we know all the entries for the same
8519    literal will be contiguous.  */
8520
8521 static bfd_boolean
8522 relocations_reach (source_reloc *reloc,
8523                    int remaining_relocs,
8524                    const r_reloc *r_rel)
8525 {
8526   bfd_vma from_offset, source_address, dest_address;
8527   asection *sec;
8528   int i;
8529
8530   if (!r_reloc_is_defined (r_rel))
8531     return FALSE;
8532
8533   sec = r_reloc_get_section (r_rel);
8534   from_offset = reloc[0].r_rel.target_offset;
8535
8536   for (i = 0; i < remaining_relocs; i++)
8537     {
8538       if (reloc[i].r_rel.target_offset != from_offset)
8539         break;
8540
8541       /* Ignore relocations that have been removed.  */
8542       if (reloc[i].is_null)
8543         continue;
8544
8545       /* The original and new output section for these must be the same
8546          in order to coalesce.  */
8547       if (r_reloc_get_section (&reloc[i].r_rel)->output_section
8548           != sec->output_section)
8549         return FALSE;
8550
8551       /* Absolute literals in the same output section can always be
8552          combined.  */
8553       if (reloc[i].is_abs_literal)
8554         continue;
8555
8556       /* A literal with no PC-relative relocations can be moved anywhere.  */
8557       if (reloc[i].opnd != -1)
8558         {
8559           /* Otherwise, check to see that it fits.  */
8560           source_address = (reloc[i].source_sec->output_section->vma
8561                             + reloc[i].source_sec->output_offset
8562                             + reloc[i].r_rel.rela.r_offset);
8563           dest_address = (sec->output_section->vma
8564                           + sec->output_offset
8565                           + r_rel->target_offset);
8566
8567           if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
8568                                  source_address, dest_address))
8569             return FALSE;
8570         }
8571     }
8572
8573   return TRUE;
8574 }
8575
8576
8577 /* Move a literal to another literal location because it is
8578    the same as the other literal value.  */
8579
8580 static bfd_boolean
8581 coalesce_shared_literal (asection *sec,
8582                          source_reloc *rel,
8583                          property_table_entry *prop_table,
8584                          int ptblsize,
8585                          value_map *val_map)
8586 {
8587   property_table_entry *entry;
8588   text_action *fa;
8589   property_table_entry *the_add_entry;
8590   int removed_diff;
8591   xtensa_relax_info *relax_info;
8592
8593   relax_info = get_xtensa_relax_info (sec);
8594   if (!relax_info)
8595     return FALSE;
8596
8597   entry = elf_xtensa_find_property_entry
8598     (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
8599   if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8600     return TRUE;
8601
8602   /* Mark that the literal will be coalesced.  */
8603   add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
8604
8605   text_action_add (&relax_info->action_list,
8606                    ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8607
8608   /* If the section is 4-byte aligned, do not add fill.  */
8609   if (sec->alignment_power > 2)
8610     {
8611       int fill_extra_space;
8612       bfd_vma entry_sec_offset;
8613
8614       if (entry)
8615         entry_sec_offset = entry->address - sec->vma + entry->size;
8616       else
8617         entry_sec_offset = rel->r_rel.target_offset + 4;
8618
8619       /* If the literal range is at the end of the section,
8620          do not add fill.  */
8621       fill_extra_space = 0;
8622       the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8623                                                       entry_sec_offset);
8624       if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8625         fill_extra_space = the_add_entry->size;
8626
8627       fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8628       removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8629                                                   -4, fill_extra_space);
8630       if (fa)
8631         adjust_fill_action (fa, removed_diff);
8632       else
8633         text_action_add (&relax_info->action_list,
8634                          ta_fill, sec, entry_sec_offset, removed_diff);
8635     }
8636
8637   return TRUE;
8638 }
8639
8640
8641 /* Move a literal to another location.  This may actually increase the
8642    total amount of space used because of alignments so we need to do
8643    this carefully.  Also, it may make a branch go out of range.  */
8644
8645 static bfd_boolean
8646 move_shared_literal (asection *sec,
8647                      struct bfd_link_info *link_info,
8648                      source_reloc *rel,
8649                      property_table_entry *prop_table,
8650                      int ptblsize,
8651                      const r_reloc *target_loc,
8652                      const literal_value *lit_value,
8653                      section_cache_t *target_sec_cache)
8654 {
8655   property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
8656   text_action *fa, *target_fa;
8657   int removed_diff;
8658   xtensa_relax_info *relax_info, *target_relax_info;
8659   asection *target_sec;
8660   ebb_t *ebb;
8661   ebb_constraint ebb_table;
8662   bfd_boolean relocs_fit;
8663
8664   /* If this routine always returns FALSE, the literals that cannot be
8665      coalesced will not be moved.  */
8666   if (elf32xtensa_no_literal_movement)
8667     return FALSE;
8668
8669   relax_info = get_xtensa_relax_info (sec);
8670   if (!relax_info)
8671     return FALSE;
8672
8673   target_sec = r_reloc_get_section (target_loc);
8674   target_relax_info = get_xtensa_relax_info (target_sec);
8675
8676   /* Literals to undefined sections may not be moved because they
8677      must report an error.  */
8678   if (bfd_is_und_section (target_sec))
8679     return FALSE;
8680
8681   src_entry = elf_xtensa_find_property_entry
8682     (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
8683
8684   if (!section_cache_section (target_sec_cache, target_sec, link_info))
8685     return FALSE;
8686
8687   target_entry = elf_xtensa_find_property_entry
8688     (target_sec_cache->ptbl, target_sec_cache->pte_count,
8689      target_sec->vma + target_loc->target_offset);
8690
8691   if (!target_entry)
8692     return FALSE;
8693
8694   /* Make sure that we have not broken any branches.  */
8695   relocs_fit = FALSE;
8696
8697   init_ebb_constraint (&ebb_table);
8698   ebb = &ebb_table.ebb;
8699   init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
8700             target_sec_cache->content_length,
8701             target_sec_cache->ptbl, target_sec_cache->pte_count,
8702             target_sec_cache->relocs, target_sec_cache->reloc_count);
8703
8704   /* Propose to add 4 bytes + worst-case alignment size increase to
8705      destination.  */
8706   ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
8707                       ta_fill, target_loc->target_offset,
8708                       -4 - (1 << target_sec->alignment_power), TRUE);
8709
8710   /* Check all of the PC-relative relocations to make sure they still fit.  */
8711   relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
8712                                              target_sec_cache->contents,
8713                                              target_sec_cache->relocs,
8714                                              &ebb_table, NULL);
8715
8716   if (!relocs_fit)
8717     return FALSE;
8718
8719   text_action_add_literal (&target_relax_info->action_list,
8720                            ta_add_literal, target_loc, lit_value, -4);
8721
8722   if (target_sec->alignment_power > 2 && target_entry != src_entry)
8723     {
8724       /* May need to add or remove some fill to maintain alignment.  */
8725       int fill_extra_space;
8726       bfd_vma entry_sec_offset;
8727
8728       entry_sec_offset =
8729         target_entry->address - target_sec->vma + target_entry->size;
8730
8731       /* If the literal range is at the end of the section,
8732          do not add fill.  */
8733       fill_extra_space = 0;
8734       the_add_entry =
8735         elf_xtensa_find_property_entry (target_sec_cache->ptbl,
8736                                         target_sec_cache->pte_count,
8737                                         entry_sec_offset);
8738       if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8739         fill_extra_space = the_add_entry->size;
8740
8741       target_fa = find_fill_action (&target_relax_info->action_list,
8742                                     target_sec, entry_sec_offset);
8743       removed_diff = compute_removed_action_diff (target_fa, target_sec,
8744                                                   entry_sec_offset, 4,
8745                                                   fill_extra_space);
8746       if (target_fa)
8747         adjust_fill_action (target_fa, removed_diff);
8748       else
8749         text_action_add (&target_relax_info->action_list,
8750                          ta_fill, target_sec, entry_sec_offset, removed_diff);
8751     }
8752
8753   /* Mark that the literal will be moved to the new location.  */
8754   add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
8755
8756   /* Remove the literal.  */
8757   text_action_add (&relax_info->action_list,
8758                    ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8759
8760   /* If the section is 4-byte aligned, do not add fill.  */
8761   if (sec->alignment_power > 2 && target_entry != src_entry)
8762     {
8763       int fill_extra_space;
8764       bfd_vma entry_sec_offset;
8765
8766       if (src_entry)
8767         entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
8768       else
8769         entry_sec_offset = rel->r_rel.target_offset+4;
8770
8771       /* If the literal range is at the end of the section,
8772          do not add fill.  */
8773       fill_extra_space = 0;
8774       the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8775                                                       entry_sec_offset);
8776       if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8777         fill_extra_space = the_add_entry->size;
8778
8779       fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8780       removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8781                                                   -4, fill_extra_space);
8782       if (fa)
8783         adjust_fill_action (fa, removed_diff);
8784       else
8785         text_action_add (&relax_info->action_list,
8786                          ta_fill, sec, entry_sec_offset, removed_diff);
8787     }
8788
8789   return TRUE;
8790 }
8791
8792 \f
8793 /* Second relaxation pass.  */
8794
8795 /* Modify all of the relocations to point to the right spot, and if this
8796    is a relaxable section, delete the unwanted literals and fix the
8797    section size.  */
8798
8799 bfd_boolean
8800 relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
8801 {
8802   Elf_Internal_Rela *internal_relocs;
8803   xtensa_relax_info *relax_info;
8804   bfd_byte *contents;
8805   bfd_boolean ok = TRUE;
8806   unsigned i;
8807   bfd_boolean rv = FALSE;
8808   bfd_boolean virtual_action;
8809   bfd_size_type sec_size;
8810
8811   sec_size = bfd_get_section_limit (abfd, sec);
8812   relax_info = get_xtensa_relax_info (sec);
8813   BFD_ASSERT (relax_info);
8814
8815   /* First translate any of the fixes that have been added already.  */
8816   translate_section_fixes (sec);
8817
8818   /* Handle property sections (e.g., literal tables) specially.  */
8819   if (xtensa_is_property_section (sec))
8820     {
8821       BFD_ASSERT (!relax_info->is_relaxable_literal_section);
8822       return relax_property_section (abfd, sec, link_info);
8823     }
8824
8825   internal_relocs = retrieve_internal_relocs (abfd, sec,
8826                                               link_info->keep_memory);
8827   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8828   if (contents == NULL && sec_size != 0)
8829     {
8830       ok = FALSE;
8831       goto error_return;
8832     }
8833
8834   if (internal_relocs)
8835     {
8836       for (i = 0; i < sec->reloc_count; i++)
8837         {
8838           Elf_Internal_Rela *irel;
8839           xtensa_relax_info *target_relax_info;
8840           bfd_vma source_offset, old_source_offset;
8841           r_reloc r_rel;
8842           unsigned r_type;
8843           asection *target_sec;
8844
8845           /* Locally change the source address.
8846              Translate the target to the new target address.
8847              If it points to this section and has been removed,
8848              NULLify it.
8849              Write it back.  */
8850
8851           irel = &internal_relocs[i];
8852           source_offset = irel->r_offset;
8853           old_source_offset = source_offset;
8854
8855           r_type = ELF32_R_TYPE (irel->r_info);
8856           r_reloc_init (&r_rel, abfd, irel, contents,
8857                         bfd_get_section_limit (abfd, sec));
8858
8859           /* If this section could have changed then we may need to
8860              change the relocation's offset.  */
8861
8862           if (relax_info->is_relaxable_literal_section
8863               || relax_info->is_relaxable_asm_section)
8864             {
8865               pin_internal_relocs (sec, internal_relocs);
8866
8867               if (r_type != R_XTENSA_NONE
8868                   && find_removed_literal (&relax_info->removed_list,
8869                                            irel->r_offset))
8870                 {
8871                   /* Remove this relocation.  */
8872                   if (elf_hash_table (link_info)->dynamic_sections_created)
8873                     shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8874                   irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8875                   irel->r_offset = offset_with_removed_text
8876                     (&relax_info->action_list, irel->r_offset);
8877                   continue;
8878                 }
8879
8880               if (r_type == R_XTENSA_ASM_SIMPLIFY)
8881                 {
8882                   text_action *action =
8883                     find_insn_action (&relax_info->action_list,
8884                                       irel->r_offset);
8885                   if (action && (action->action == ta_convert_longcall
8886                                  || action->action == ta_remove_longcall))
8887                     {
8888                       bfd_reloc_status_type retval;
8889                       char *error_message = NULL;
8890
8891                       retval = contract_asm_expansion (contents, sec_size,
8892                                                        irel, &error_message);
8893                       if (retval != bfd_reloc_ok)
8894                         {
8895                           (*link_info->callbacks->reloc_dangerous)
8896                             (link_info, error_message, abfd, sec,
8897                              irel->r_offset);
8898                           goto error_return;
8899                         }
8900                       /* Update the action so that the code that moves
8901                          the contents will do the right thing.  */
8902                       if (action->action == ta_remove_longcall)
8903                         action->action = ta_remove_insn;
8904                       else
8905                         action->action = ta_none;
8906                       /* Refresh the info in the r_rel.  */
8907                       r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8908                       r_type = ELF32_R_TYPE (irel->r_info);
8909                     }
8910                 }
8911
8912               source_offset = offset_with_removed_text
8913                 (&relax_info->action_list, irel->r_offset);
8914               irel->r_offset = source_offset;
8915             }
8916
8917           /* If the target section could have changed then
8918              we may need to change the relocation's target offset.  */
8919
8920           target_sec = r_reloc_get_section (&r_rel);
8921
8922           /* For a reference to a discarded section from a DWARF section,
8923              i.e., where action_discarded is PRETEND, the symbol will
8924              eventually be modified to refer to the kept section (at least if
8925              the kept and discarded sections are the same size).  Anticipate
8926              that here and adjust things accordingly.  */
8927           if (! elf_xtensa_ignore_discarded_relocs (sec)
8928               && elf_xtensa_action_discarded (sec) == PRETEND
8929               && sec->sec_info_type != ELF_INFO_TYPE_STABS
8930               && target_sec != NULL
8931               && elf_discarded_section (target_sec))
8932             {
8933               /* It would be natural to call _bfd_elf_check_kept_section
8934                  here, but it's not exported from elflink.c.  It's also a
8935                  fairly expensive check.  Adjusting the relocations to the
8936                  discarded section is fairly harmless; it will only adjust
8937                  some addends and difference values.  If it turns out that
8938                  _bfd_elf_check_kept_section fails later, it won't matter,
8939                  so just compare the section names to find the right group
8940                  member.  */
8941               asection *kept = target_sec->kept_section;
8942               if (kept != NULL)
8943                 {
8944                   if ((kept->flags & SEC_GROUP) != 0)
8945                     {
8946                       asection *first = elf_next_in_group (kept);
8947                       asection *s = first;
8948
8949                       kept = NULL;
8950                       while (s != NULL)
8951                         {
8952                           if (strcmp (s->name, target_sec->name) == 0)
8953                             {
8954                               kept = s;
8955                               break;
8956                             }
8957                           s = elf_next_in_group (s);
8958                           if (s == first)
8959                             break;
8960                         }
8961                     }
8962                 }
8963               if (kept != NULL
8964                   && ((target_sec->rawsize != 0
8965                        ? target_sec->rawsize : target_sec->size)
8966                       == (kept->rawsize != 0 ? kept->rawsize : kept->size)))
8967                 target_sec = kept;
8968             }
8969
8970           target_relax_info = get_xtensa_relax_info (target_sec);
8971           if (target_relax_info
8972               && (target_relax_info->is_relaxable_literal_section
8973                   || target_relax_info->is_relaxable_asm_section))
8974             {
8975               r_reloc new_reloc;
8976               target_sec = translate_reloc (&r_rel, &new_reloc, target_sec);
8977
8978               if (r_type == R_XTENSA_DIFF8
8979                   || r_type == R_XTENSA_DIFF16
8980                   || r_type == R_XTENSA_DIFF32)
8981                 {
8982                   bfd_vma diff_value = 0, new_end_offset, diff_mask = 0;
8983
8984                   if (bfd_get_section_limit (abfd, sec) < old_source_offset)
8985                     {
8986                       (*link_info->callbacks->reloc_dangerous)
8987                         (link_info, _("invalid relocation address"),
8988                          abfd, sec, old_source_offset);
8989                       goto error_return;
8990                     }
8991
8992                   switch (r_type)
8993                     {
8994                     case R_XTENSA_DIFF8:
8995                       diff_value =
8996                         bfd_get_8 (abfd, &contents[old_source_offset]);
8997                       break;
8998                     case R_XTENSA_DIFF16:
8999                       diff_value =
9000                         bfd_get_16 (abfd, &contents[old_source_offset]);
9001                       break;
9002                     case R_XTENSA_DIFF32:
9003                       diff_value =
9004                         bfd_get_32 (abfd, &contents[old_source_offset]);
9005                       break;
9006                     }
9007
9008                   new_end_offset = offset_with_removed_text
9009                     (&target_relax_info->action_list,
9010                      r_rel.target_offset + diff_value);
9011                   diff_value = new_end_offset - new_reloc.target_offset;
9012
9013                   switch (r_type)
9014                     {
9015                     case R_XTENSA_DIFF8:
9016                       diff_mask = 0xff;
9017                       bfd_put_8 (abfd, diff_value,
9018                                  &contents[old_source_offset]);
9019                       break;
9020                     case R_XTENSA_DIFF16:
9021                       diff_mask = 0xffff;
9022                       bfd_put_16 (abfd, diff_value,
9023                                   &contents[old_source_offset]);
9024                       break;
9025                     case R_XTENSA_DIFF32:
9026                       diff_mask = 0xffffffff;
9027                       bfd_put_32 (abfd, diff_value,
9028                                   &contents[old_source_offset]);
9029                       break;
9030                     }
9031
9032                   /* Check for overflow.  */
9033                   if ((diff_value & ~diff_mask) != 0)
9034                     {
9035                       (*link_info->callbacks->reloc_dangerous)
9036                         (link_info, _("overflow after relaxation"),
9037                          abfd, sec, old_source_offset);
9038                       goto error_return;
9039                     }
9040
9041                   pin_contents (sec, contents);
9042                 }
9043
9044               /* If the relocation still references a section in the same
9045                  input file, modify the relocation directly instead of
9046                  adding a "fix" record.  */
9047               if (target_sec->owner == abfd)
9048                 {
9049                   unsigned r_symndx = ELF32_R_SYM (new_reloc.rela.r_info);
9050                   irel->r_info = ELF32_R_INFO (r_symndx, r_type);
9051                   irel->r_addend = new_reloc.rela.r_addend;
9052                   pin_internal_relocs (sec, internal_relocs);
9053                 }
9054               else
9055                 {
9056                   bfd_vma addend_displacement;
9057                   reloc_bfd_fix *fix;
9058
9059                   addend_displacement =
9060                     new_reloc.target_offset + new_reloc.virtual_offset;
9061                   fix = reloc_bfd_fix_init (sec, source_offset, r_type,
9062                                             target_sec,
9063                                             addend_displacement, TRUE);
9064                   add_fix (sec, fix);
9065                 }
9066             }
9067         }
9068     }
9069
9070   if ((relax_info->is_relaxable_literal_section
9071        || relax_info->is_relaxable_asm_section)
9072       && relax_info->action_list.head)
9073     {
9074       /* Walk through the planned actions and build up a table
9075          of move, copy and fill records.  Use the move, copy and
9076          fill records to perform the actions once.  */
9077
9078       int removed = 0;
9079       bfd_size_type final_size, copy_size, orig_insn_size;
9080       bfd_byte *scratch = NULL;
9081       bfd_byte *dup_contents = NULL;
9082       bfd_size_type orig_size = sec->size;
9083       bfd_vma orig_dot = 0;
9084       bfd_vma orig_dot_copied = 0; /* Byte copied already from
9085                                             orig dot in physical memory.  */
9086       bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot.  */
9087       bfd_vma dup_dot = 0;
9088
9089       text_action *action = relax_info->action_list.head;
9090
9091       final_size = sec->size;
9092       for (action = relax_info->action_list.head; action;
9093            action = action->next)
9094         {
9095           final_size -= action->removed_bytes;
9096         }
9097
9098       scratch = (bfd_byte *) bfd_zmalloc (final_size);
9099       dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
9100
9101       /* The dot is the current fill location.  */
9102 #if DEBUG
9103       print_action_list (stderr, &relax_info->action_list);
9104 #endif
9105
9106       for (action = relax_info->action_list.head; action;
9107            action = action->next)
9108         {
9109           virtual_action = FALSE;
9110           if (action->offset > orig_dot)
9111             {
9112               orig_dot += orig_dot_copied;
9113               orig_dot_copied = 0;
9114               orig_dot_vo = 0;
9115               /* Out of the virtual world.  */
9116             }
9117
9118           if (action->offset > orig_dot)
9119             {
9120               copy_size = action->offset - orig_dot;
9121               memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9122               orig_dot += copy_size;
9123               dup_dot += copy_size;
9124               BFD_ASSERT (action->offset == orig_dot);
9125             }
9126           else if (action->offset < orig_dot)
9127             {
9128               if (action->action == ta_fill
9129                   && action->offset - action->removed_bytes == orig_dot)
9130                 {
9131                   /* This is OK because the fill only effects the dup_dot.  */
9132                 }
9133               else if (action->action == ta_add_literal)
9134                 {
9135                   /* TBD.  Might need to handle this.  */
9136                 }
9137             }
9138           if (action->offset == orig_dot)
9139             {
9140               if (action->virtual_offset > orig_dot_vo)
9141                 {
9142                   if (orig_dot_vo == 0)
9143                     {
9144                       /* Need to copy virtual_offset bytes.  Probably four.  */
9145                       copy_size = action->virtual_offset - orig_dot_vo;
9146                       memmove (&dup_contents[dup_dot],
9147                                &contents[orig_dot], copy_size);
9148                       orig_dot_copied = copy_size;
9149                       dup_dot += copy_size;
9150                     }
9151                   virtual_action = TRUE;
9152                 }
9153               else
9154                 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
9155             }
9156           switch (action->action)
9157             {
9158             case ta_remove_literal:
9159             case ta_remove_insn:
9160               BFD_ASSERT (action->removed_bytes >= 0);
9161               orig_dot += action->removed_bytes;
9162               break;
9163
9164             case ta_narrow_insn:
9165               orig_insn_size = 3;
9166               copy_size = 2;
9167               memmove (scratch, &contents[orig_dot], orig_insn_size);
9168               BFD_ASSERT (action->removed_bytes == 1);
9169               rv = narrow_instruction (scratch, final_size, 0);
9170               BFD_ASSERT (rv);
9171               memmove (&dup_contents[dup_dot], scratch, copy_size);
9172               orig_dot += orig_insn_size;
9173               dup_dot += copy_size;
9174               break;
9175
9176             case ta_fill:
9177               if (action->removed_bytes >= 0)
9178                 orig_dot += action->removed_bytes;
9179               else
9180                 {
9181                   /* Already zeroed in dup_contents.  Just bump the
9182                      counters.  */
9183                   dup_dot += (-action->removed_bytes);
9184                 }
9185               break;
9186
9187             case ta_none:
9188               BFD_ASSERT (action->removed_bytes == 0);
9189               break;
9190
9191             case ta_convert_longcall:
9192             case ta_remove_longcall:
9193               /* These will be removed or converted before we get here.  */
9194               BFD_ASSERT (0);
9195               break;
9196
9197             case ta_widen_insn:
9198               orig_insn_size = 2;
9199               copy_size = 3;
9200               memmove (scratch, &contents[orig_dot], orig_insn_size);
9201               BFD_ASSERT (action->removed_bytes == -1);
9202               rv = widen_instruction (scratch, final_size, 0);
9203               BFD_ASSERT (rv);
9204               memmove (&dup_contents[dup_dot], scratch, copy_size);
9205               orig_dot += orig_insn_size;
9206               dup_dot += copy_size;
9207               break;
9208
9209             case ta_add_literal:
9210               orig_insn_size = 0;
9211               copy_size = 4;
9212               BFD_ASSERT (action->removed_bytes == -4);
9213               /* TBD -- place the literal value here and insert
9214                  into the table.  */
9215               memset (&dup_contents[dup_dot], 0, 4);
9216               pin_internal_relocs (sec, internal_relocs);
9217               pin_contents (sec, contents);
9218
9219               if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
9220                                  relax_info, &internal_relocs, &action->value))
9221                 goto error_return;
9222
9223               if (virtual_action)
9224                 orig_dot_vo += copy_size;
9225
9226               orig_dot += orig_insn_size;
9227               dup_dot += copy_size;
9228               break;
9229
9230             default:
9231               /* Not implemented yet.  */
9232               BFD_ASSERT (0);
9233               break;
9234             }
9235
9236           removed += action->removed_bytes;
9237           BFD_ASSERT (dup_dot <= final_size);
9238           BFD_ASSERT (orig_dot <= orig_size);
9239         }
9240
9241       orig_dot += orig_dot_copied;
9242       orig_dot_copied = 0;
9243
9244       if (orig_dot != orig_size)
9245         {
9246           copy_size = orig_size - orig_dot;
9247           BFD_ASSERT (orig_size > orig_dot);
9248           BFD_ASSERT (dup_dot + copy_size == final_size);
9249           memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9250           orig_dot += copy_size;
9251           dup_dot += copy_size;
9252         }
9253       BFD_ASSERT (orig_size == orig_dot);
9254       BFD_ASSERT (final_size == dup_dot);
9255
9256       /* Move the dup_contents back.  */
9257       if (final_size > orig_size)
9258         {
9259           /* Contents need to be reallocated.  Swap the dup_contents into
9260              contents.  */
9261           sec->contents = dup_contents;
9262           free (contents);
9263           contents = dup_contents;
9264           pin_contents (sec, contents);
9265         }
9266       else
9267         {
9268           BFD_ASSERT (final_size <= orig_size);
9269           memset (contents, 0, orig_size);
9270           memcpy (contents, dup_contents, final_size);
9271           free (dup_contents);
9272         }
9273       free (scratch);
9274       pin_contents (sec, contents);
9275
9276       if (sec->rawsize == 0)
9277         sec->rawsize = sec->size;
9278       sec->size = final_size;
9279     }
9280
9281  error_return:
9282   release_internal_relocs (sec, internal_relocs);
9283   release_contents (sec, contents);
9284   return ok;
9285 }
9286
9287
9288 static bfd_boolean
9289 translate_section_fixes (asection *sec)
9290 {
9291   xtensa_relax_info *relax_info;
9292   reloc_bfd_fix *r;
9293
9294   relax_info = get_xtensa_relax_info (sec);
9295   if (!relax_info)
9296     return TRUE;
9297
9298   for (r = relax_info->fix_list; r != NULL; r = r->next)
9299     if (!translate_reloc_bfd_fix (r))
9300       return FALSE;
9301
9302   return TRUE;
9303 }
9304
9305
9306 /* Translate a fix given the mapping in the relax info for the target
9307    section.  If it has already been translated, no work is required.  */
9308
9309 static bfd_boolean
9310 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
9311 {
9312   reloc_bfd_fix new_fix;
9313   asection *sec;
9314   xtensa_relax_info *relax_info;
9315   removed_literal *removed;
9316   bfd_vma new_offset, target_offset;
9317
9318   if (fix->translated)
9319     return TRUE;
9320
9321   sec = fix->target_sec;
9322   target_offset = fix->target_offset;
9323
9324   relax_info = get_xtensa_relax_info (sec);
9325   if (!relax_info)
9326     {
9327       fix->translated = TRUE;
9328       return TRUE;
9329     }
9330
9331   new_fix = *fix;
9332
9333   /* The fix does not need to be translated if the section cannot change.  */
9334   if (!relax_info->is_relaxable_literal_section
9335       && !relax_info->is_relaxable_asm_section)
9336     {
9337       fix->translated = TRUE;
9338       return TRUE;
9339     }
9340
9341   /* If the literal has been moved and this relocation was on an
9342      opcode, then the relocation should move to the new literal
9343      location.  Otherwise, the relocation should move within the
9344      section.  */
9345
9346   removed = FALSE;
9347   if (is_operand_relocation (fix->src_type))
9348     {
9349       /* Check if the original relocation is against a literal being
9350          removed.  */
9351       removed = find_removed_literal (&relax_info->removed_list,
9352                                       target_offset);
9353     }
9354
9355   if (removed)
9356     {
9357       asection *new_sec;
9358
9359       /* The fact that there is still a relocation to this literal indicates
9360          that the literal is being coalesced, not simply removed.  */
9361       BFD_ASSERT (removed->to.abfd != NULL);
9362
9363       /* This was moved to some other address (possibly another section).  */
9364       new_sec = r_reloc_get_section (&removed->to);
9365       if (new_sec != sec)
9366         {
9367           sec = new_sec;
9368           relax_info = get_xtensa_relax_info (sec);
9369           if (!relax_info ||
9370               (!relax_info->is_relaxable_literal_section
9371                && !relax_info->is_relaxable_asm_section))
9372             {
9373               target_offset = removed->to.target_offset;
9374               new_fix.target_sec = new_sec;
9375               new_fix.target_offset = target_offset;
9376               new_fix.translated = TRUE;
9377               *fix = new_fix;
9378               return TRUE;
9379             }
9380         }
9381       target_offset = removed->to.target_offset;
9382       new_fix.target_sec = new_sec;
9383     }
9384
9385   /* The target address may have been moved within its section.  */
9386   new_offset = offset_with_removed_text (&relax_info->action_list,
9387                                          target_offset);
9388
9389   new_fix.target_offset = new_offset;
9390   new_fix.target_offset = new_offset;
9391   new_fix.translated = TRUE;
9392   *fix = new_fix;
9393   return TRUE;
9394 }
9395
9396
9397 /* Fix up a relocation to take account of removed literals.  */
9398
9399 static asection *
9400 translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec)
9401 {
9402   xtensa_relax_info *relax_info;
9403   removed_literal *removed;
9404   bfd_vma target_offset, base_offset;
9405   text_action *act;
9406
9407   *new_rel = *orig_rel;
9408
9409   if (!r_reloc_is_defined (orig_rel))
9410     return sec ;
9411
9412   relax_info = get_xtensa_relax_info (sec);
9413   BFD_ASSERT (relax_info && (relax_info->is_relaxable_literal_section
9414                              || relax_info->is_relaxable_asm_section));
9415
9416   target_offset = orig_rel->target_offset;
9417
9418   removed = FALSE;
9419   if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
9420     {
9421       /* Check if the original relocation is against a literal being
9422          removed.  */
9423       removed = find_removed_literal (&relax_info->removed_list,
9424                                       target_offset);
9425     }
9426   if (removed && removed->to.abfd)
9427     {
9428       asection *new_sec;
9429
9430       /* The fact that there is still a relocation to this literal indicates
9431          that the literal is being coalesced, not simply removed.  */
9432       BFD_ASSERT (removed->to.abfd != NULL);
9433
9434       /* This was moved to some other address
9435          (possibly in another section).  */
9436       *new_rel = removed->to;
9437       new_sec = r_reloc_get_section (new_rel);
9438       if (new_sec != sec)
9439         {
9440           sec = new_sec;
9441           relax_info = get_xtensa_relax_info (sec);
9442           if (!relax_info
9443               || (!relax_info->is_relaxable_literal_section
9444                   && !relax_info->is_relaxable_asm_section))
9445             return sec;
9446         }
9447       target_offset = new_rel->target_offset;
9448     }
9449
9450   /* Find the base offset of the reloc symbol, excluding any addend from the
9451      reloc or from the section contents (for a partial_inplace reloc).  Then
9452      find the adjusted values of the offsets due to relaxation.  The base
9453      offset is needed to determine the change to the reloc's addend; the reloc
9454      addend should not be adjusted due to relaxations located before the base
9455      offset.  */
9456
9457   base_offset = r_reloc_get_target_offset (new_rel) - new_rel->rela.r_addend;
9458   act = relax_info->action_list.head;
9459   if (base_offset <= target_offset)
9460     {
9461       int base_removed = removed_by_actions (&act, base_offset, FALSE);
9462       int addend_removed = removed_by_actions (&act, target_offset, FALSE);
9463       new_rel->target_offset = target_offset - base_removed - addend_removed;
9464       new_rel->rela.r_addend -= addend_removed;
9465     }
9466   else
9467     {
9468       /* Handle a negative addend.  The base offset comes first.  */
9469       int tgt_removed = removed_by_actions (&act, target_offset, FALSE);
9470       int addend_removed = removed_by_actions (&act, base_offset, FALSE);
9471       new_rel->target_offset = target_offset - tgt_removed;
9472       new_rel->rela.r_addend += addend_removed;
9473     }
9474
9475   return sec;
9476 }
9477
9478
9479 /* For dynamic links, there may be a dynamic relocation for each
9480    literal.  The number of dynamic relocations must be computed in
9481    size_dynamic_sections, which occurs before relaxation.  When a
9482    literal is removed, this function checks if there is a corresponding
9483    dynamic relocation and shrinks the size of the appropriate dynamic
9484    relocation section accordingly.  At this point, the contents of the
9485    dynamic relocation sections have not yet been filled in, so there's
9486    nothing else that needs to be done.  */
9487
9488 static void
9489 shrink_dynamic_reloc_sections (struct bfd_link_info *info,
9490                                bfd *abfd,
9491                                asection *input_section,
9492                                Elf_Internal_Rela *rel)
9493 {
9494   struct elf_xtensa_link_hash_table *htab;
9495   Elf_Internal_Shdr *symtab_hdr;
9496   struct elf_link_hash_entry **sym_hashes;
9497   unsigned long r_symndx;
9498   int r_type;
9499   struct elf_link_hash_entry *h;
9500   bfd_boolean dynamic_symbol;
9501
9502   htab = elf_xtensa_hash_table (info);
9503   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9504   sym_hashes = elf_sym_hashes (abfd);
9505
9506   r_type = ELF32_R_TYPE (rel->r_info);
9507   r_symndx = ELF32_R_SYM (rel->r_info);
9508
9509   if (r_symndx < symtab_hdr->sh_info)
9510     h = NULL;
9511   else
9512     h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9513
9514   dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
9515
9516   if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
9517       && (input_section->flags & SEC_ALLOC) != 0
9518       && (dynamic_symbol || info->shared))
9519     {
9520       asection *srel;
9521       bfd_boolean is_plt = FALSE;
9522
9523       if (dynamic_symbol && r_type == R_XTENSA_PLT)
9524         {
9525           srel = htab->srelplt;
9526           is_plt = TRUE;
9527         }
9528       else
9529         srel = htab->srelgot;
9530
9531       /* Reduce size of the .rela.* section by one reloc.  */
9532       BFD_ASSERT (srel != NULL);
9533       BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
9534       srel->size -= sizeof (Elf32_External_Rela);
9535
9536       if (is_plt)
9537         {
9538           asection *splt, *sgotplt, *srelgot;
9539           int reloc_index, chunk;
9540
9541           /* Find the PLT reloc index of the entry being removed.  This
9542              is computed from the size of ".rela.plt".  It is needed to
9543              figure out which PLT chunk to resize.  Usually "last index
9544              = size - 1" since the index starts at zero, but in this
9545              context, the size has just been decremented so there's no
9546              need to subtract one.  */
9547           reloc_index = srel->size / sizeof (Elf32_External_Rela);
9548
9549           chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
9550           splt = elf_xtensa_get_plt_section (info, chunk);
9551           sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
9552           BFD_ASSERT (splt != NULL && sgotplt != NULL);
9553
9554           /* Check if an entire PLT chunk has just been eliminated.  */
9555           if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
9556             {
9557               /* The two magic GOT entries for that chunk can go away.  */
9558               srelgot = htab->srelgot;
9559               BFD_ASSERT (srelgot != NULL);
9560               srelgot->reloc_count -= 2;
9561               srelgot->size -= 2 * sizeof (Elf32_External_Rela);
9562               sgotplt->size -= 8;
9563
9564               /* There should be only one entry left (and it will be
9565                  removed below).  */
9566               BFD_ASSERT (sgotplt->size == 4);
9567               BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
9568             }
9569
9570           BFD_ASSERT (sgotplt->size >= 4);
9571           BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
9572
9573           sgotplt->size -= 4;
9574           splt->size -= PLT_ENTRY_SIZE;
9575         }
9576     }
9577 }
9578
9579
9580 /* Take an r_rel and move it to another section.  This usually
9581    requires extending the interal_relocation array and pinning it.  If
9582    the original r_rel is from the same BFD, we can complete this here.
9583    Otherwise, we add a fix record to let the final link fix the
9584    appropriate address.  Contents and internal relocations for the
9585    section must be pinned after calling this routine.  */
9586
9587 static bfd_boolean
9588 move_literal (bfd *abfd,
9589               struct bfd_link_info *link_info,
9590               asection *sec,
9591               bfd_vma offset,
9592               bfd_byte *contents,
9593               xtensa_relax_info *relax_info,
9594               Elf_Internal_Rela **internal_relocs_p,
9595               const literal_value *lit)
9596 {
9597   Elf_Internal_Rela *new_relocs = NULL;
9598   size_t new_relocs_count = 0;
9599   Elf_Internal_Rela this_rela;
9600   const r_reloc *r_rel;
9601
9602   r_rel = &lit->r_rel;
9603   BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
9604
9605   if (r_reloc_is_const (r_rel))
9606     bfd_put_32 (abfd, lit->value, contents + offset);
9607   else
9608     {
9609       int r_type;
9610       unsigned i;
9611       asection *target_sec;
9612       reloc_bfd_fix *fix;
9613       unsigned insert_at;
9614
9615       r_type = ELF32_R_TYPE (r_rel->rela.r_info);
9616       target_sec = r_reloc_get_section (r_rel);
9617
9618       /* This is the difficult case.  We have to create a fix up.  */
9619       this_rela.r_offset = offset;
9620       this_rela.r_info = ELF32_R_INFO (0, r_type);
9621       this_rela.r_addend =
9622         r_rel->target_offset - r_reloc_get_target_offset (r_rel);
9623       bfd_put_32 (abfd, lit->value, contents + offset);
9624
9625       /* Currently, we cannot move relocations during a relocatable link.  */
9626       BFD_ASSERT (!link_info->relocatable);
9627       fix = reloc_bfd_fix_init (sec, offset, r_type,
9628                                 r_reloc_get_section (r_rel),
9629                                 r_rel->target_offset + r_rel->virtual_offset,
9630                                 FALSE);
9631       /* We also need to mark that relocations are needed here.  */
9632       sec->flags |= SEC_RELOC;
9633
9634       translate_reloc_bfd_fix (fix);
9635       /* This fix has not yet been translated.  */
9636       add_fix (sec, fix);
9637
9638       /* Add the relocation.  If we have already allocated our own
9639          space for the relocations and we have room for more, then use
9640          it.  Otherwise, allocate new space and move the literals.  */
9641       insert_at = sec->reloc_count;
9642       for (i = 0; i < sec->reloc_count; ++i)
9643         {
9644           if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
9645             {
9646               insert_at = i;
9647               break;
9648             }
9649         }
9650
9651       if (*internal_relocs_p != relax_info->allocated_relocs
9652           || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
9653         {
9654           BFD_ASSERT (relax_info->allocated_relocs == NULL
9655                       || sec->reloc_count == relax_info->relocs_count);
9656
9657           if (relax_info->allocated_relocs_count == 0)
9658             new_relocs_count = (sec->reloc_count + 2) * 2;
9659           else
9660             new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
9661
9662           new_relocs = (Elf_Internal_Rela *)
9663             bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
9664           if (!new_relocs)
9665             return FALSE;
9666
9667           /* We could handle this more quickly by finding the split point.  */
9668           if (insert_at != 0)
9669             memcpy (new_relocs, *internal_relocs_p,
9670                     insert_at * sizeof (Elf_Internal_Rela));
9671
9672           new_relocs[insert_at] = this_rela;
9673
9674           if (insert_at != sec->reloc_count)
9675             memcpy (new_relocs + insert_at + 1,
9676                     (*internal_relocs_p) + insert_at,
9677                     (sec->reloc_count - insert_at)
9678                     * sizeof (Elf_Internal_Rela));
9679
9680           if (*internal_relocs_p != relax_info->allocated_relocs)
9681             {
9682               /* The first time we re-allocate, we can only free the
9683                  old relocs if they were allocated with bfd_malloc.
9684                  This is not true when keep_memory is in effect.  */
9685               if (!link_info->keep_memory)
9686                 free (*internal_relocs_p);
9687             }
9688           else
9689             free (*internal_relocs_p);
9690           relax_info->allocated_relocs = new_relocs;
9691           relax_info->allocated_relocs_count = new_relocs_count;
9692           elf_section_data (sec)->relocs = new_relocs;
9693           sec->reloc_count++;
9694           relax_info->relocs_count = sec->reloc_count;
9695           *internal_relocs_p = new_relocs;
9696         }
9697       else
9698         {
9699           if (insert_at != sec->reloc_count)
9700             {
9701               unsigned idx;
9702               for (idx = sec->reloc_count; idx > insert_at; idx--)
9703                 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
9704             }
9705           (*internal_relocs_p)[insert_at] = this_rela;
9706           sec->reloc_count++;
9707           if (relax_info->allocated_relocs)
9708             relax_info->relocs_count = sec->reloc_count;
9709         }
9710     }
9711   return TRUE;
9712 }
9713
9714
9715 /* This is similar to relax_section except that when a target is moved,
9716    we shift addresses up.  We also need to modify the size.  This
9717    algorithm does NOT allow for relocations into the middle of the
9718    property sections.  */
9719
9720 static bfd_boolean
9721 relax_property_section (bfd *abfd,
9722                         asection *sec,
9723                         struct bfd_link_info *link_info)
9724 {
9725   Elf_Internal_Rela *internal_relocs;
9726   bfd_byte *contents;
9727   unsigned i;
9728   bfd_boolean ok = TRUE;
9729   bfd_boolean is_full_prop_section;
9730   size_t last_zfill_target_offset = 0;
9731   asection *last_zfill_target_sec = NULL;
9732   bfd_size_type sec_size;
9733   bfd_size_type entry_size;
9734
9735   sec_size = bfd_get_section_limit (abfd, sec);
9736   internal_relocs = retrieve_internal_relocs (abfd, sec,
9737                                               link_info->keep_memory);
9738   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9739   if (contents == NULL && sec_size != 0)
9740     {
9741       ok = FALSE;
9742       goto error_return;
9743     }
9744
9745   is_full_prop_section = xtensa_is_proptable_section (sec);
9746   if (is_full_prop_section)
9747     entry_size = 12;
9748   else
9749     entry_size = 8;
9750
9751   if (internal_relocs)
9752     {
9753       for (i = 0; i < sec->reloc_count; i++)
9754         {
9755           Elf_Internal_Rela *irel;
9756           xtensa_relax_info *target_relax_info;
9757           unsigned r_type;
9758           asection *target_sec;
9759           literal_value val;
9760           bfd_byte *size_p, *flags_p;
9761
9762           /* Locally change the source address.
9763              Translate the target to the new target address.
9764              If it points to this section and has been removed, MOVE IT.
9765              Also, don't forget to modify the associated SIZE at
9766              (offset + 4).  */
9767
9768           irel = &internal_relocs[i];
9769           r_type = ELF32_R_TYPE (irel->r_info);
9770           if (r_type == R_XTENSA_NONE)
9771             continue;
9772
9773           /* Find the literal value.  */
9774           r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
9775           size_p = &contents[irel->r_offset + 4];
9776           flags_p = NULL;
9777           if (is_full_prop_section)
9778             flags_p = &contents[irel->r_offset + 8];
9779           BFD_ASSERT (irel->r_offset + entry_size <= sec_size);
9780
9781           target_sec = r_reloc_get_section (&val.r_rel);
9782           target_relax_info = get_xtensa_relax_info (target_sec);
9783
9784           if (target_relax_info
9785               && (target_relax_info->is_relaxable_literal_section
9786                   || target_relax_info->is_relaxable_asm_section ))
9787             {
9788               /* Translate the relocation's destination.  */
9789               bfd_vma old_offset = val.r_rel.target_offset;
9790               bfd_vma new_offset;
9791               long old_size, new_size;
9792               text_action *act = target_relax_info->action_list.head;
9793               new_offset = old_offset -
9794                 removed_by_actions (&act, old_offset, FALSE);
9795
9796               /* Assert that we are not out of bounds.  */
9797               old_size = bfd_get_32 (abfd, size_p);
9798               new_size = old_size;
9799
9800               if (old_size == 0)
9801                 {
9802                   /* Only the first zero-sized unreachable entry is
9803                      allowed to expand.  In this case the new offset
9804                      should be the offset before the fill and the new
9805                      size is the expansion size.  For other zero-sized
9806                      entries the resulting size should be zero with an
9807                      offset before or after the fill address depending
9808                      on whether the expanding unreachable entry
9809                      preceeds it.  */
9810                   if (last_zfill_target_sec == 0
9811                       || last_zfill_target_sec != target_sec
9812                       || last_zfill_target_offset != old_offset)
9813                     {
9814                       bfd_vma new_end_offset = new_offset;
9815
9816                       /* Recompute the new_offset, but this time don't
9817                          include any fill inserted by relaxation.  */
9818                       act = target_relax_info->action_list.head;
9819                       new_offset = old_offset -
9820                         removed_by_actions (&act, old_offset, TRUE);
9821
9822                       /* If it is not unreachable and we have not yet
9823                          seen an unreachable at this address, place it
9824                          before the fill address.  */
9825                       if (flags_p && (bfd_get_32 (abfd, flags_p)
9826                                       & XTENSA_PROP_UNREACHABLE) != 0)
9827                         {
9828                           new_size = new_end_offset - new_offset;
9829
9830                           last_zfill_target_sec = target_sec;
9831                           last_zfill_target_offset = old_offset;
9832                         }
9833                     }
9834                 }
9835               else
9836                 new_size -=
9837                     removed_by_actions (&act, old_offset + old_size, TRUE);
9838
9839               if (new_size != old_size)
9840                 {
9841                   bfd_put_32 (abfd, new_size, size_p);
9842                   pin_contents (sec, contents);
9843                 }
9844
9845               if (new_offset != old_offset)
9846                 {
9847                   bfd_vma diff = new_offset - old_offset;
9848                   irel->r_addend += diff;
9849                   pin_internal_relocs (sec, internal_relocs);
9850                 }
9851             }
9852         }
9853     }
9854
9855   /* Combine adjacent property table entries.  This is also done in
9856      finish_dynamic_sections() but at that point it's too late to
9857      reclaim the space in the output section, so we do this twice.  */
9858
9859   if (internal_relocs && (!link_info->relocatable
9860                           || xtensa_is_littable_section (sec)))
9861     {
9862       Elf_Internal_Rela *last_irel = NULL;
9863       Elf_Internal_Rela *irel, *next_rel, *rel_end;
9864       int removed_bytes = 0;
9865       bfd_vma offset;
9866       flagword predef_flags;
9867
9868       predef_flags = xtensa_get_property_predef_flags (sec);
9869
9870       /* Walk over memory and relocations at the same time.
9871          This REQUIRES that the internal_relocs be sorted by offset.  */
9872       qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
9873              internal_reloc_compare);
9874
9875       pin_internal_relocs (sec, internal_relocs);
9876       pin_contents (sec, contents);
9877
9878       next_rel = internal_relocs;
9879       rel_end = internal_relocs + sec->reloc_count;
9880
9881       BFD_ASSERT (sec->size % entry_size == 0);
9882
9883       for (offset = 0; offset < sec->size; offset += entry_size)
9884         {
9885           Elf_Internal_Rela *offset_rel, *extra_rel;
9886           bfd_vma bytes_to_remove, size, actual_offset;
9887           bfd_boolean remove_this_rel;
9888           flagword flags;
9889
9890           /* Find the first relocation for the entry at the current offset.
9891              Adjust the offsets of any extra relocations for the previous
9892              entry.  */
9893           offset_rel = NULL;
9894           if (next_rel)
9895             {
9896               for (irel = next_rel; irel < rel_end; irel++)
9897                 {
9898                   if ((irel->r_offset == offset
9899                        && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
9900                       || irel->r_offset > offset)
9901                     {
9902                       offset_rel = irel;
9903                       break;
9904                     }
9905                   irel->r_offset -= removed_bytes;
9906                 }
9907             }
9908
9909           /* Find the next relocation (if there are any left).  */
9910           extra_rel = NULL;
9911           if (offset_rel)
9912             {
9913               for (irel = offset_rel + 1; irel < rel_end; irel++)
9914                 {
9915                   if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
9916                     {
9917                       extra_rel = irel;
9918                       break;
9919                     }
9920                 }
9921             }
9922
9923           /* Check if there are relocations on the current entry.  There
9924              should usually be a relocation on the offset field.  If there
9925              are relocations on the size or flags, then we can't optimize
9926              this entry.  Also, find the next relocation to examine on the
9927              next iteration.  */
9928           if (offset_rel)
9929             {
9930               if (offset_rel->r_offset >= offset + entry_size)
9931                 {
9932                   next_rel = offset_rel;
9933                   /* There are no relocations on the current entry, but we
9934                      might still be able to remove it if the size is zero.  */
9935                   offset_rel = NULL;
9936                 }
9937               else if (offset_rel->r_offset > offset
9938                        || (extra_rel
9939                            && extra_rel->r_offset < offset + entry_size))
9940                 {
9941                   /* There is a relocation on the size or flags, so we can't
9942                      do anything with this entry.  Continue with the next.  */
9943                   next_rel = offset_rel;
9944                   continue;
9945                 }
9946               else
9947                 {
9948                   BFD_ASSERT (offset_rel->r_offset == offset);
9949                   offset_rel->r_offset -= removed_bytes;
9950                   next_rel = offset_rel + 1;
9951                 }
9952             }
9953           else
9954             next_rel = NULL;
9955
9956           remove_this_rel = FALSE;
9957           bytes_to_remove = 0;
9958           actual_offset = offset - removed_bytes;
9959           size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
9960
9961           if (is_full_prop_section)
9962             flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
9963           else
9964             flags = predef_flags;
9965
9966           if (size == 0
9967               && (flags & XTENSA_PROP_ALIGN) == 0
9968               && (flags & XTENSA_PROP_UNREACHABLE) == 0)
9969             {
9970               /* Always remove entries with zero size and no alignment.  */
9971               bytes_to_remove = entry_size;
9972               if (offset_rel)
9973                 remove_this_rel = TRUE;
9974             }
9975           else if (offset_rel
9976                    && ELF32_R_TYPE (offset_rel->r_info) == R_XTENSA_32)
9977             {
9978               if (last_irel)
9979                 {
9980                   flagword old_flags;
9981                   bfd_vma old_size =
9982                     bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
9983                   bfd_vma old_address =
9984                     (last_irel->r_addend
9985                      + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
9986                   bfd_vma new_address =
9987                     (offset_rel->r_addend
9988                      + bfd_get_32 (abfd, &contents[actual_offset]));
9989                   if (is_full_prop_section)
9990                     old_flags = bfd_get_32
9991                       (abfd, &contents[last_irel->r_offset + 8]);
9992                   else
9993                     old_flags = predef_flags;
9994
9995                   if ((ELF32_R_SYM (offset_rel->r_info)
9996                        == ELF32_R_SYM (last_irel->r_info))
9997                       && old_address + old_size == new_address
9998                       && old_flags == flags
9999                       && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
10000                       && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
10001                     {
10002                       /* Fix the old size.  */
10003                       bfd_put_32 (abfd, old_size + size,
10004                                   &contents[last_irel->r_offset + 4]);
10005                       bytes_to_remove = entry_size;
10006                       remove_this_rel = TRUE;
10007                     }
10008                   else
10009                     last_irel = offset_rel;
10010                 }
10011               else
10012                 last_irel = offset_rel;
10013             }
10014
10015           if (remove_this_rel)
10016             {
10017               offset_rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
10018               offset_rel->r_offset = 0;
10019             }
10020
10021           if (bytes_to_remove != 0)
10022             {
10023               removed_bytes += bytes_to_remove;
10024               if (offset + bytes_to_remove < sec->size)
10025                 memmove (&contents[actual_offset],
10026                          &contents[actual_offset + bytes_to_remove],
10027                          sec->size - offset - bytes_to_remove);
10028             }
10029         }
10030
10031       if (removed_bytes)
10032         {
10033           /* Fix up any extra relocations on the last entry.  */
10034           for (irel = next_rel; irel < rel_end; irel++)
10035             irel->r_offset -= removed_bytes;
10036
10037           /* Clear the removed bytes.  */
10038           memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
10039
10040           if (sec->rawsize == 0)
10041             sec->rawsize = sec->size;
10042           sec->size -= removed_bytes;
10043
10044           if (xtensa_is_littable_section (sec))
10045             {
10046               asection *sgotloc = elf_xtensa_hash_table (link_info)->sgotloc;
10047               if (sgotloc)
10048                 sgotloc->size -= removed_bytes;
10049             }
10050         }
10051     }
10052
10053  error_return:
10054   release_internal_relocs (sec, internal_relocs);
10055   release_contents (sec, contents);
10056   return ok;
10057 }
10058
10059 \f
10060 /* Third relaxation pass.  */
10061
10062 /* Change symbol values to account for removed literals.  */
10063
10064 bfd_boolean
10065 relax_section_symbols (bfd *abfd, asection *sec)
10066 {
10067   xtensa_relax_info *relax_info;
10068   unsigned int sec_shndx;
10069   Elf_Internal_Shdr *symtab_hdr;
10070   Elf_Internal_Sym *isymbuf;
10071   unsigned i, num_syms, num_locals;
10072
10073   relax_info = get_xtensa_relax_info (sec);
10074   BFD_ASSERT (relax_info);
10075
10076   if (!relax_info->is_relaxable_literal_section
10077       && !relax_info->is_relaxable_asm_section)
10078     return TRUE;
10079
10080   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
10081
10082   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10083   isymbuf = retrieve_local_syms (abfd);
10084
10085   num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
10086   num_locals = symtab_hdr->sh_info;
10087
10088   /* Adjust the local symbols defined in this section.  */
10089   for (i = 0; i < num_locals; i++)
10090     {
10091       Elf_Internal_Sym *isym = &isymbuf[i];
10092
10093       if (isym->st_shndx == sec_shndx)
10094         {
10095           text_action *act = relax_info->action_list.head;
10096           bfd_vma orig_addr = isym->st_value;
10097
10098           isym->st_value -= removed_by_actions (&act, orig_addr, FALSE);
10099
10100           if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
10101             isym->st_size -=
10102               removed_by_actions (&act, orig_addr + isym->st_size, FALSE);
10103         }
10104     }
10105
10106   /* Now adjust the global symbols defined in this section.  */
10107   for (i = 0; i < (num_syms - num_locals); i++)
10108     {
10109       struct elf_link_hash_entry *sym_hash;
10110
10111       sym_hash = elf_sym_hashes (abfd)[i];
10112
10113       if (sym_hash->root.type == bfd_link_hash_warning)
10114         sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
10115
10116       if ((sym_hash->root.type == bfd_link_hash_defined
10117            || sym_hash->root.type == bfd_link_hash_defweak)
10118           && sym_hash->root.u.def.section == sec)
10119         {
10120           text_action *act = relax_info->action_list.head;
10121           bfd_vma orig_addr = sym_hash->root.u.def.value;
10122
10123           sym_hash->root.u.def.value -=
10124             removed_by_actions (&act, orig_addr, FALSE);
10125
10126           if (sym_hash->type == STT_FUNC)
10127             sym_hash->size -=
10128               removed_by_actions (&act, orig_addr + sym_hash->size, FALSE);
10129         }
10130     }
10131
10132   return TRUE;
10133 }
10134
10135 \f
10136 /* "Fix" handling functions, called while performing relocations.  */
10137
10138 static bfd_boolean
10139 do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
10140                              bfd *input_bfd,
10141                              asection *input_section,
10142                              bfd_byte *contents)
10143 {
10144   r_reloc r_rel;
10145   asection *sec, *old_sec;
10146   bfd_vma old_offset;
10147   int r_type = ELF32_R_TYPE (rel->r_info);
10148   reloc_bfd_fix *fix;
10149
10150   if (r_type == R_XTENSA_NONE)
10151     return TRUE;
10152
10153   fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10154   if (!fix)
10155     return TRUE;
10156
10157   r_reloc_init (&r_rel, input_bfd, rel, contents,
10158                 bfd_get_section_limit (input_bfd, input_section));
10159   old_sec = r_reloc_get_section (&r_rel);
10160   old_offset = r_rel.target_offset;
10161
10162   if (!old_sec || !r_reloc_is_defined (&r_rel))
10163     {
10164       if (r_type != R_XTENSA_ASM_EXPAND)
10165         {
10166           (*_bfd_error_handler)
10167             (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
10168              input_bfd, input_section, rel->r_offset,
10169              elf_howto_table[r_type].name);
10170           return FALSE;
10171         }
10172       /* Leave it be.  Resolution will happen in a later stage.  */
10173     }
10174   else
10175     {
10176       sec = fix->target_sec;
10177       rel->r_addend += ((sec->output_offset + fix->target_offset)
10178                         - (old_sec->output_offset + old_offset));
10179     }
10180   return TRUE;
10181 }
10182
10183
10184 static void
10185 do_fix_for_final_link (Elf_Internal_Rela *rel,
10186                        bfd *input_bfd,
10187                        asection *input_section,
10188                        bfd_byte *contents,
10189                        bfd_vma *relocationp)
10190 {
10191   asection *sec;
10192   int r_type = ELF32_R_TYPE (rel->r_info);
10193   reloc_bfd_fix *fix;
10194   bfd_vma fixup_diff;
10195
10196   if (r_type == R_XTENSA_NONE)
10197     return;
10198
10199   fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10200   if (!fix)
10201     return;
10202
10203   sec = fix->target_sec;
10204
10205   fixup_diff = rel->r_addend;
10206   if (elf_howto_table[fix->src_type].partial_inplace)
10207     {
10208       bfd_vma inplace_val;
10209       BFD_ASSERT (fix->src_offset
10210                   < bfd_get_section_limit (input_bfd, input_section));
10211       inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
10212       fixup_diff += inplace_val;
10213     }
10214
10215   *relocationp = (sec->output_section->vma
10216                   + sec->output_offset
10217                   + fix->target_offset - fixup_diff);
10218 }
10219
10220 \f
10221 /* Miscellaneous utility functions....  */
10222
10223 static asection *
10224 elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
10225 {
10226   struct elf_xtensa_link_hash_table *htab;
10227   bfd *dynobj;
10228   char plt_name[10];
10229
10230   if (chunk == 0)
10231     {
10232       htab = elf_xtensa_hash_table (info);
10233       return htab->splt;
10234     }
10235
10236   dynobj = elf_hash_table (info)->dynobj;
10237   sprintf (plt_name, ".plt.%u", chunk);
10238   return bfd_get_section_by_name (dynobj, plt_name);
10239 }
10240
10241
10242 static asection *
10243 elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
10244 {
10245   struct elf_xtensa_link_hash_table *htab;
10246   bfd *dynobj;
10247   char got_name[14];
10248
10249   if (chunk == 0)
10250     {
10251       htab = elf_xtensa_hash_table (info);
10252       return htab->sgotplt;
10253     }
10254
10255   dynobj = elf_hash_table (info)->dynobj;
10256   sprintf (got_name, ".got.plt.%u", chunk);
10257   return bfd_get_section_by_name (dynobj, got_name);
10258 }
10259
10260
10261 /* Get the input section for a given symbol index.
10262    If the symbol is:
10263    . a section symbol, return the section;
10264    . a common symbol, return the common section;
10265    . an undefined symbol, return the undefined section;
10266    . an indirect symbol, follow the links;
10267    . an absolute value, return the absolute section.  */
10268
10269 static asection *
10270 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
10271 {
10272   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10273   asection *target_sec = NULL;
10274   if (r_symndx < symtab_hdr->sh_info)
10275     {
10276       Elf_Internal_Sym *isymbuf;
10277       unsigned int section_index;
10278
10279       isymbuf = retrieve_local_syms (abfd);
10280       section_index = isymbuf[r_symndx].st_shndx;
10281
10282       if (section_index == SHN_UNDEF)
10283         target_sec = bfd_und_section_ptr;
10284       else if (section_index == SHN_ABS)
10285         target_sec = bfd_abs_section_ptr;
10286       else if (section_index == SHN_COMMON)
10287         target_sec = bfd_com_section_ptr;
10288       else
10289         target_sec = bfd_section_from_elf_index (abfd, section_index);
10290     }
10291   else
10292     {
10293       unsigned long indx = r_symndx - symtab_hdr->sh_info;
10294       struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
10295
10296       while (h->root.type == bfd_link_hash_indirect
10297              || h->root.type == bfd_link_hash_warning)
10298         h = (struct elf_link_hash_entry *) h->root.u.i.link;
10299
10300       switch (h->root.type)
10301         {
10302         case bfd_link_hash_defined:
10303         case  bfd_link_hash_defweak:
10304           target_sec = h->root.u.def.section;
10305           break;
10306         case bfd_link_hash_common:
10307           target_sec = bfd_com_section_ptr;
10308           break;
10309         case bfd_link_hash_undefined:
10310         case bfd_link_hash_undefweak:
10311           target_sec = bfd_und_section_ptr;
10312           break;
10313         default: /* New indirect warning.  */
10314           target_sec = bfd_und_section_ptr;
10315           break;
10316         }
10317     }
10318   return target_sec;
10319 }
10320
10321
10322 static struct elf_link_hash_entry *
10323 get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
10324 {
10325   unsigned long indx;
10326   struct elf_link_hash_entry *h;
10327   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10328
10329   if (r_symndx < symtab_hdr->sh_info)
10330     return NULL;
10331
10332   indx = r_symndx - symtab_hdr->sh_info;
10333   h = elf_sym_hashes (abfd)[indx];
10334   while (h->root.type == bfd_link_hash_indirect
10335          || h->root.type == bfd_link_hash_warning)
10336     h = (struct elf_link_hash_entry *) h->root.u.i.link;
10337   return h;
10338 }
10339
10340
10341 /* Get the section-relative offset for a symbol number.  */
10342
10343 static bfd_vma
10344 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
10345 {
10346   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10347   bfd_vma offset = 0;
10348
10349   if (r_symndx < symtab_hdr->sh_info)
10350     {
10351       Elf_Internal_Sym *isymbuf;
10352       isymbuf = retrieve_local_syms (abfd);
10353       offset = isymbuf[r_symndx].st_value;
10354     }
10355   else
10356     {
10357       unsigned long indx = r_symndx - symtab_hdr->sh_info;
10358       struct elf_link_hash_entry *h =
10359         elf_sym_hashes (abfd)[indx];
10360
10361       while (h->root.type == bfd_link_hash_indirect
10362              || h->root.type == bfd_link_hash_warning)
10363         h = (struct elf_link_hash_entry *) h->root.u.i.link;
10364       if (h->root.type == bfd_link_hash_defined
10365           || h->root.type == bfd_link_hash_defweak)
10366         offset = h->root.u.def.value;
10367     }
10368   return offset;
10369 }
10370
10371
10372 static bfd_boolean
10373 is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
10374 {
10375   unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
10376   struct elf_link_hash_entry *h;
10377
10378   h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
10379   if (h && h->root.type == bfd_link_hash_defweak)
10380     return TRUE;
10381   return FALSE;
10382 }
10383
10384
10385 static bfd_boolean
10386 pcrel_reloc_fits (xtensa_opcode opc,
10387                   int opnd,
10388                   bfd_vma self_address,
10389                   bfd_vma dest_address)
10390 {
10391   xtensa_isa isa = xtensa_default_isa;
10392   uint32 valp = dest_address;
10393   if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
10394       || xtensa_operand_encode (isa, opc, opnd, &valp))
10395     return FALSE;
10396   return TRUE;
10397 }
10398
10399
10400 static bfd_boolean
10401 xtensa_is_property_section (asection *sec)
10402 {
10403   if (xtensa_is_insntable_section (sec)
10404       || xtensa_is_littable_section (sec)
10405       || xtensa_is_proptable_section (sec))
10406     return TRUE;
10407
10408   return FALSE;
10409 }
10410
10411
10412 static bfd_boolean
10413 xtensa_is_insntable_section (asection *sec)
10414 {
10415   if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
10416       || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
10417     return TRUE;
10418
10419   return FALSE;
10420 }
10421
10422
10423 static bfd_boolean
10424 xtensa_is_littable_section (asection *sec)
10425 {
10426   if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
10427       || CONST_STRNEQ (sec->name, ".gnu.linkonce.p."))
10428     return TRUE;
10429
10430   return FALSE;
10431 }
10432
10433
10434 static bfd_boolean
10435 xtensa_is_proptable_section (asection *sec)
10436 {
10437   if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
10438       || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."))
10439     return TRUE;
10440
10441   return FALSE;
10442 }
10443
10444
10445 static int
10446 internal_reloc_compare (const void *ap, const void *bp)
10447 {
10448   const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10449   const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10450
10451   if (a->r_offset != b->r_offset)
10452     return (a->r_offset - b->r_offset);
10453
10454   /* We don't need to sort on these criteria for correctness,
10455      but enforcing a more strict ordering prevents unstable qsort
10456      from behaving differently with different implementations.
10457      Without the code below we get correct but different results
10458      on Solaris 2.7 and 2.8.  We would like to always produce the
10459      same results no matter the host.  */
10460
10461   if (a->r_info != b->r_info)
10462     return (a->r_info - b->r_info);
10463
10464   return (a->r_addend - b->r_addend);
10465 }
10466
10467
10468 static int
10469 internal_reloc_matches (const void *ap, const void *bp)
10470 {
10471   const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10472   const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10473
10474   /* Check if one entry overlaps with the other; this shouldn't happen
10475      except when searching for a match.  */
10476   return (a->r_offset - b->r_offset);
10477 }
10478
10479
10480 /* Predicate function used to look up a section in a particular group.  */
10481
10482 static bfd_boolean
10483 match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
10484 {
10485   const char *gname = inf;
10486   const char *group_name = elf_group_name (sec);
10487
10488   return (group_name == gname
10489           || (group_name != NULL
10490               && gname != NULL
10491               && strcmp (group_name, gname) == 0));
10492 }
10493
10494
10495 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
10496
10497 static char *
10498 xtensa_property_section_name (asection *sec, const char *base_name)
10499 {
10500   const char *suffix, *group_name;
10501   char *prop_sec_name;
10502
10503   group_name = elf_group_name (sec);
10504   if (group_name)
10505     {
10506       suffix = strrchr (sec->name, '.');
10507       if (suffix == sec->name)
10508         suffix = 0;
10509       prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1
10510                                            + (suffix ? strlen (suffix) : 0));
10511       strcpy (prop_sec_name, base_name);
10512       if (suffix)
10513         strcat (prop_sec_name, suffix);
10514     }
10515   else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
10516     {
10517       char *linkonce_kind = 0;
10518
10519       if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
10520         linkonce_kind = "x.";
10521       else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
10522         linkonce_kind = "p.";
10523       else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
10524         linkonce_kind = "prop.";
10525       else
10526         abort ();
10527
10528       prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
10529                                            + strlen (linkonce_kind) + 1);
10530       memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
10531       strcpy (prop_sec_name + linkonce_len, linkonce_kind);
10532
10533       suffix = sec->name + linkonce_len;
10534       /* For backward compatibility, replace "t." instead of inserting
10535          the new linkonce_kind (but not for "prop" sections).  */
10536       if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
10537         suffix += 2;
10538       strcat (prop_sec_name + linkonce_len, suffix);
10539     }
10540   else
10541     prop_sec_name = strdup (base_name);
10542
10543   return prop_sec_name;
10544 }
10545
10546
10547 static asection *
10548 xtensa_get_property_section (asection *sec, const char *base_name)
10549 {
10550   char *prop_sec_name;
10551   asection *prop_sec;
10552
10553   prop_sec_name = xtensa_property_section_name (sec, base_name);
10554   prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
10555                                          match_section_group,
10556                                          (void *) elf_group_name (sec));
10557   free (prop_sec_name);
10558   return prop_sec;
10559 }
10560
10561
10562 asection *
10563 xtensa_make_property_section (asection *sec, const char *base_name)
10564 {
10565   char *prop_sec_name;
10566   asection *prop_sec;
10567
10568   /* Check if the section already exists.  */
10569   prop_sec_name = xtensa_property_section_name (sec, base_name);
10570   prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
10571                                          match_section_group,
10572                                          (void *) elf_group_name (sec));
10573   /* If not, create it.  */
10574   if (! prop_sec)
10575     {
10576       flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
10577       flags |= (bfd_get_section_flags (sec->owner, sec)
10578                 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
10579
10580       prop_sec = bfd_make_section_anyway_with_flags
10581         (sec->owner, strdup (prop_sec_name), flags);
10582       if (! prop_sec)
10583         return 0;
10584
10585       elf_group_name (prop_sec) = elf_group_name (sec);
10586     }
10587
10588   free (prop_sec_name);
10589   return prop_sec;
10590 }
10591
10592
10593 flagword
10594 xtensa_get_property_predef_flags (asection *sec)
10595 {
10596   if (xtensa_is_insntable_section (sec))
10597     return (XTENSA_PROP_INSN
10598             | XTENSA_PROP_NO_TRANSFORM
10599             | XTENSA_PROP_INSN_NO_REORDER);
10600
10601   if (xtensa_is_littable_section (sec))
10602     return (XTENSA_PROP_LITERAL
10603             | XTENSA_PROP_NO_TRANSFORM
10604             | XTENSA_PROP_INSN_NO_REORDER);
10605
10606   return 0;
10607 }
10608
10609 \f
10610 /* Other functions called directly by the linker.  */
10611
10612 bfd_boolean
10613 xtensa_callback_required_dependence (bfd *abfd,
10614                                      asection *sec,
10615                                      struct bfd_link_info *link_info,
10616                                      deps_callback_t callback,
10617                                      void *closure)
10618 {
10619   Elf_Internal_Rela *internal_relocs;
10620   bfd_byte *contents;
10621   unsigned i;
10622   bfd_boolean ok = TRUE;
10623   bfd_size_type sec_size;
10624
10625   sec_size = bfd_get_section_limit (abfd, sec);
10626
10627   /* ".plt*" sections have no explicit relocations but they contain L32R
10628      instructions that reference the corresponding ".got.plt*" sections.  */
10629   if ((sec->flags & SEC_LINKER_CREATED) != 0
10630       && CONST_STRNEQ (sec->name, ".plt"))
10631     {
10632       asection *sgotplt;
10633
10634       /* Find the corresponding ".got.plt*" section.  */
10635       if (sec->name[4] == '\0')
10636         sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
10637       else
10638         {
10639           char got_name[14];
10640           int chunk = 0;
10641
10642           BFD_ASSERT (sec->name[4] == '.');
10643           chunk = strtol (&sec->name[5], NULL, 10);
10644
10645           sprintf (got_name, ".got.plt.%u", chunk);
10646           sgotplt = bfd_get_section_by_name (sec->owner, got_name);
10647         }
10648       BFD_ASSERT (sgotplt);
10649
10650       /* Assume worst-case offsets: L32R at the very end of the ".plt"
10651          section referencing a literal at the very beginning of
10652          ".got.plt".  This is very close to the real dependence, anyway.  */
10653       (*callback) (sec, sec_size, sgotplt, 0, closure);
10654     }
10655
10656   /* Only ELF files are supported for Xtensa.  Check here to avoid a segfault
10657      when building uclibc, which runs "ld -b binary /dev/null".  */
10658   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
10659     return ok;
10660
10661   internal_relocs = retrieve_internal_relocs (abfd, sec,
10662                                               link_info->keep_memory);
10663   if (internal_relocs == NULL
10664       || sec->reloc_count == 0)
10665     return ok;
10666
10667   /* Cache the contents for the duration of this scan.  */
10668   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
10669   if (contents == NULL && sec_size != 0)
10670     {
10671       ok = FALSE;
10672       goto error_return;
10673     }
10674
10675   if (!xtensa_default_isa)
10676     xtensa_default_isa = xtensa_isa_init (0, 0);
10677
10678   for (i = 0; i < sec->reloc_count; i++)
10679     {
10680       Elf_Internal_Rela *irel = &internal_relocs[i];
10681       if (is_l32r_relocation (abfd, sec, contents, irel))
10682         {
10683           r_reloc l32r_rel;
10684           asection *target_sec;
10685           bfd_vma target_offset;
10686
10687           r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
10688           target_sec = NULL;
10689           target_offset = 0;
10690           /* L32Rs must be local to the input file.  */
10691           if (r_reloc_is_defined (&l32r_rel))
10692             {
10693               target_sec = r_reloc_get_section (&l32r_rel);
10694               target_offset = l32r_rel.target_offset;
10695             }
10696           (*callback) (sec, irel->r_offset, target_sec, target_offset,
10697                        closure);
10698         }
10699     }
10700
10701  error_return:
10702   release_internal_relocs (sec, internal_relocs);
10703   release_contents (sec, contents);
10704   return ok;
10705 }
10706
10707 /* The default literal sections should always be marked as "code" (i.e.,
10708    SHF_EXECINSTR).  This is particularly important for the Linux kernel
10709    module loader so that the literals are not placed after the text.  */
10710 static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
10711 {
10712   { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10713   { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10714   { STRING_COMMA_LEN (".literal"),      0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10715   { STRING_COMMA_LEN (".xtensa.info"),  0, SHT_NOTE,     0 },
10716   { NULL,                       0,      0, 0,            0 }
10717 };
10718 \f
10719 #ifndef ELF_ARCH
10720 #define TARGET_LITTLE_SYM               bfd_elf32_xtensa_le_vec
10721 #define TARGET_LITTLE_NAME              "elf32-xtensa-le"
10722 #define TARGET_BIG_SYM                  bfd_elf32_xtensa_be_vec
10723 #define TARGET_BIG_NAME                 "elf32-xtensa-be"
10724 #define ELF_ARCH                        bfd_arch_xtensa
10725
10726 #define ELF_MACHINE_CODE                EM_XTENSA
10727 #define ELF_MACHINE_ALT1                EM_XTENSA_OLD
10728
10729 #if XCHAL_HAVE_MMU
10730 #define ELF_MAXPAGESIZE                 (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
10731 #else /* !XCHAL_HAVE_MMU */
10732 #define ELF_MAXPAGESIZE                 1
10733 #endif /* !XCHAL_HAVE_MMU */
10734 #endif /* ELF_ARCH */
10735
10736 #define elf_backend_can_gc_sections     1
10737 #define elf_backend_can_refcount        1
10738 #define elf_backend_plt_readonly        1
10739 #define elf_backend_got_header_size     4
10740 #define elf_backend_want_dynbss         0
10741 #define elf_backend_want_got_plt        1
10742
10743 #define elf_info_to_howto                    elf_xtensa_info_to_howto_rela
10744
10745 #define bfd_elf32_mkobject                   elf_xtensa_mkobject
10746
10747 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
10748 #define bfd_elf32_new_section_hook           elf_xtensa_new_section_hook
10749 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
10750 #define bfd_elf32_bfd_relax_section          elf_xtensa_relax_section
10751 #define bfd_elf32_bfd_reloc_type_lookup      elf_xtensa_reloc_type_lookup
10752 #define bfd_elf32_bfd_reloc_name_lookup \
10753   elf_xtensa_reloc_name_lookup
10754 #define bfd_elf32_bfd_set_private_flags      elf_xtensa_set_private_flags
10755 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
10756
10757 #define elf_backend_adjust_dynamic_symbol    elf_xtensa_adjust_dynamic_symbol
10758 #define elf_backend_check_relocs             elf_xtensa_check_relocs
10759 #define elf_backend_create_dynamic_sections  elf_xtensa_create_dynamic_sections
10760 #define elf_backend_discard_info             elf_xtensa_discard_info
10761 #define elf_backend_ignore_discarded_relocs  elf_xtensa_ignore_discarded_relocs
10762 #define elf_backend_final_write_processing   elf_xtensa_final_write_processing
10763 #define elf_backend_finish_dynamic_sections  elf_xtensa_finish_dynamic_sections
10764 #define elf_backend_finish_dynamic_symbol    elf_xtensa_finish_dynamic_symbol
10765 #define elf_backend_gc_mark_hook             elf_xtensa_gc_mark_hook
10766 #define elf_backend_gc_sweep_hook            elf_xtensa_gc_sweep_hook
10767 #define elf_backend_grok_prstatus            elf_xtensa_grok_prstatus
10768 #define elf_backend_grok_psinfo              elf_xtensa_grok_psinfo
10769 #define elf_backend_hide_symbol              elf_xtensa_hide_symbol
10770 #define elf_backend_object_p                 elf_xtensa_object_p
10771 #define elf_backend_reloc_type_class         elf_xtensa_reloc_type_class
10772 #define elf_backend_relocate_section         elf_xtensa_relocate_section
10773 #define elf_backend_size_dynamic_sections    elf_xtensa_size_dynamic_sections
10774 #define elf_backend_always_size_sections     elf_xtensa_always_size_sections
10775 #define elf_backend_omit_section_dynsym \
10776   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
10777 #define elf_backend_special_sections         elf_xtensa_special_sections
10778 #define elf_backend_action_discarded         elf_xtensa_action_discarded
10779 #define elf_backend_copy_indirect_symbol     elf_xtensa_copy_indirect_symbol
10780
10781 #include "elf32-target.h"