bfd/elf32-xtensa.c

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