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