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