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