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