bfd/elf32-xtensa.c

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