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