bfd/elf32-xtensa.c

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