bfd/elf32-xtensa.c

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