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