bfd/elf32-xtensa.c

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