bfd/elf32-xtensa.c

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