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