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