bfd/elf32-xtensa.c

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