bfd/elf32-xtensa.c

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