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