bfd/elf32-xtensa.c

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