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