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