bfd/elf32-xtensa.c

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