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