bfd/elf32-xtensa.c

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