bfd/elf32-xtensa.c

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