bfd/elf32-xtensa.c

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