bfd/elf32-xtensa.c

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