bfd/elf32-xtensa.c

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