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