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