bfd/elf32-xtensa.c

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