bfd/elf32-xtensa.c

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