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