bfd/elf32-xtensa.c

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