bfd/elf32-xtensa.c

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