bfd/elf32-xtensa.c

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