bfd/elf32-xtensa.c

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