bfd/elf32-xtensa.c

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