bfd/elf32-xtensa.c

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