projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add support fpr MAXQ processor
[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 5600 unsigned new_allocated, i;
823fc61f 5601 proposed_action *new_actions;
b08b5071
BW		 5602
5603 new_allocated = (c->action_count + 2) * 2;
823fc61f 5604 new_actions = (proposed_action *)
43cd72b9
BW		 5605 bfd_zmalloc (sizeof (proposed_action) * new_allocated);
5606
5607 for (i = 0; i < c->action_count; i++)
5608 new_actions[i] = c->actions[i];
7fa3d080 5609 if (c->actions)
43cd72b9
BW		 5610 free (c->actions);
5611 c->actions = new_actions;
5612 c->action_allocated = new_allocated;
5613 }
b08b5071
BW		 5614
5615 act = &c->actions[c->action_count];
5616 act->align_type = align_type;
5617 act->alignment_pow = alignment_pow;
5618 act->action = action;
5619 act->offset = offset;
5620 act->removed_bytes = removed_bytes;
5621 act->do_action = do_action;
5622
43cd72b9
BW		 5623 c->action_count++;
5624}
5625
5626\f
5627/* Access to internal relocations, section contents and symbols. */
5628
5629/* During relaxation, we need to modify relocations, section contents,
5630 and symbol definitions, and we need to keep the original values from
5631 being reloaded from the input files, i.e., we need to "pin" the
5632 modified values in memory. We also want to continue to observe the
5633 setting of the "keep-memory" flag. The following functions wrap the
5634 standard BFD functions to take care of this for us. */
5635
5636static Elf_Internal_Rela *
7fa3d080 5637retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
43cd72b9
BW		 5638{
5639 Elf_Internal_Rela *internal_relocs;
5640
5641 if ((sec->flags & SEC_LINKER_CREATED) != 0)
5642 return NULL;
5643
5644 internal_relocs = elf_section_data (sec)->relocs;
5645 if (internal_relocs == NULL)
5646 internal_relocs = (_bfd_elf_link_read_relocs
7fa3d080 5647 (abfd, sec, NULL, NULL, keep_memory));
43cd72b9
BW		 5648 return internal_relocs;
5649}
5650
5651
5652static void
7fa3d080 5653pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
43cd72b9
BW		 5654{
5655 elf_section_data (sec)->relocs = internal_relocs;
5656}
5657
5658
5659static void
7fa3d080 5660release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
43cd72b9
BW		 5661{
5662 if (internal_relocs
5663 && elf_section_data (sec)->relocs != internal_relocs)
5664 free (internal_relocs);
5665}
5666
5667
5668static bfd_byte *
7fa3d080 5669retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
43cd72b9
BW		 5670{
5671 bfd_byte *contents;
5672 bfd_size_type sec_size;
5673
5674 sec_size = bfd_get_section_limit (abfd, sec);
5675 contents = elf_section_data (sec)->this_hdr.contents;
5676
5677 if (contents == NULL && sec_size != 0)
5678 {
5679 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
5680 {
7fa3d080 5681 if (contents)
43cd72b9
BW		 5682 free (contents);
5683 return NULL;
5684 }
5685 if (keep_memory)
5686 elf_section_data (sec)->this_hdr.contents = contents;
5687 }
5688 return contents;
5689}
5690
5691
5692static void
7fa3d080 5693pin_contents (asection *sec, bfd_byte *contents)
43cd72b9
BW		 5694{
5695 elf_section_data (sec)->this_hdr.contents = contents;
5696}
5697
5698
5699static void
7fa3d080 5700release_contents (asection *sec, bfd_byte *contents)
43cd72b9
BW		 5701{
5702 if (contents && elf_section_data (sec)->this_hdr.contents != contents)
5703 free (contents);
5704}
5705
5706
5707static Elf_Internal_Sym *
7fa3d080 5708retrieve_local_syms (bfd *input_bfd)
43cd72b9
BW		 5709{
5710 Elf_Internal_Shdr *symtab_hdr;
5711 Elf_Internal_Sym *isymbuf;
5712 size_t locsymcount;
5713
5714 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5715 locsymcount = symtab_hdr->sh_info;
5716
5717 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5718 if (isymbuf == NULL && locsymcount != 0)
5719 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
5720 NULL, NULL, NULL);
5721
5722 /* Save the symbols for this input file so they won't be read again. */
5723 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
5724 symtab_hdr->contents = (unsigned char *) isymbuf;
5725
5726 return isymbuf;
5727}
5728
5729\f
5730/* Code for link-time relaxation. */
5731
5732/* Initialization for relaxation: */
7fa3d080 5733static bfd_boolean analyze_relocations (struct bfd_link_info *);
43cd72b9 5734static bfd_boolean find_relaxable_sections
7fa3d080 5735 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
43cd72b9 5736static bfd_boolean collect_source_relocs
7fa3d080 5737 (bfd *, asection *, struct bfd_link_info *);
43cd72b9 5738static bfd_boolean is_resolvable_asm_expansion
7fa3d080
BW		 5739 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
5740 bfd_boolean *);
43cd72b9 5741static Elf_Internal_Rela *find_associated_l32r_irel
7fa3d080 5742 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
43cd72b9 5743static bfd_boolean compute_text_actions
7fa3d080
BW		 5744 (bfd *, asection *, struct bfd_link_info *);
5745static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
5746static bfd_boolean compute_ebb_actions (ebb_constraint *);
43cd72b9 5747static bfd_boolean check_section_ebb_pcrels_fit
7fa3d080
BW		 5748 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, const ebb_constraint *);
5749static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
43cd72b9 5750static void text_action_add_proposed
7fa3d080
BW		 5751 (text_action_list *, const ebb_constraint *, asection *);
5752static int compute_fill_extra_space (property_table_entry *);
43cd72b9
BW		 5753
5754/* First pass: */
5755static bfd_boolean compute_removed_literals
7fa3d080 5756 (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
43cd72b9 5757static Elf_Internal_Rela *get_irel_at_offset
7fa3d080 5758 (asection *, Elf_Internal_Rela *, bfd_vma);
43cd72b9 5759static bfd_boolean is_removable_literal
7fa3d080 5760 (const source_reloc *, int, const source_reloc *, int);
43cd72b9 5761static bfd_boolean remove_dead_literal
7fa3d080
BW		 5762 (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
5763 Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
5764static bfd_boolean identify_literal_placement
5765 (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
5766 value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
5767 source_reloc *, property_table_entry *, int, section_cache_t *,
5768 bfd_boolean);
5769static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
43cd72b9 5770static bfd_boolean coalesce_shared_literal
7fa3d080 5771 (asection *, source_reloc *, property_table_entry *, int, value_map *);
43cd72b9 5772static bfd_boolean move_shared_literal
7fa3d080
BW		 5773 (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
5774 int, const r_reloc *, const literal_value *, section_cache_t *);
43cd72b9
BW		 5775
5776/* Second pass: */
7fa3d080
BW		 5777static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
5778static bfd_boolean translate_section_fixes (asection *);
5779static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
5780static void translate_reloc (const r_reloc *, r_reloc *);
43cd72b9 5781static void shrink_dynamic_reloc_sections
7fa3d080 5782 (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
43cd72b9 5783static bfd_boolean move_literal
7fa3d080
BW		 5784 (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
5785 xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
43cd72b9 5786static bfd_boolean relax_property_section
7fa3d080 5787 (bfd *, asection *, struct bfd_link_info *);
43cd72b9
BW		 5788
5789/* Third pass: */
7fa3d080 5790static bfd_boolean relax_section_symbols (bfd *, asection *);
43cd72b9
BW		 5791
5792
5793static bfd_boolean
7fa3d080
BW		 5794elf_xtensa_relax_section (bfd *abfd,
5795 asection *sec,
5796 struct bfd_link_info *link_info,
5797 bfd_boolean *again)
43cd72b9
BW		 5798{
5799 static value_map_hash_table *values = NULL;
5800 static bfd_boolean relocations_analyzed = FALSE;
5801 xtensa_relax_info *relax_info;
5802
5803 if (!relocations_analyzed)
5804 {
5805 /* Do some overall initialization for relaxation. */
5806 values = value_map_hash_table_init ();
5807 if (values == NULL)
5808 return FALSE;
5809 relaxing_section = TRUE;
5810 if (!analyze_relocations (link_info))
5811 return FALSE;
5812 relocations_analyzed = TRUE;
5813 }
5814 *again = FALSE;
5815
5816 /* Don't mess with linker-created sections. */
5817 if ((sec->flags & SEC_LINKER_CREATED) != 0)
5818 return TRUE;
5819
5820 relax_info = get_xtensa_relax_info (sec);
5821 BFD_ASSERT (relax_info != NULL);
5822
5823 switch (relax_info->visited)
5824 {
5825 case 0:
5826 /* Note: It would be nice to fold this pass into
5827 analyze_relocations, but it is important for this step that the
5828 sections be examined in link order. */
5829 if (!compute_removed_literals (abfd, sec, link_info, values))
5830 return FALSE;
5831 *again = TRUE;
5832 break;
5833
5834 case 1:
5835 if (values)
5836 value_map_hash_table_delete (values);
5837 values = NULL;
5838 if (!relax_section (abfd, sec, link_info))
5839 return FALSE;
5840 *again = TRUE;
5841 break;
5842
5843 case 2:
5844 if (!relax_section_symbols (abfd, sec))
5845 return FALSE;
5846 break;
5847 }
5848
5849 relax_info->visited++;
5850 return TRUE;
5851}
5852
5853\f
5854/* Initialization for relaxation. */
5855
5856/* This function is called once at the start of relaxation. It scans
5857 all the input sections and marks the ones that are relaxable (i.e.,
5858 literal sections with L32R relocations against them), and then
5859 collects source_reloc information for all the relocations against
5860 those relaxable sections. During this process, it also detects
5861 longcalls, i.e., calls relaxed by the assembler into indirect
5862 calls, that can be optimized back into direct calls. Within each
5863 extended basic block (ebb) containing an optimized longcall, it
5864 computes a set of "text actions" that can be performed to remove
5865 the L32R associated with the longcall while optionally preserving
5866 branch target alignments. */
5867
5868static bfd_boolean
7fa3d080 5869analyze_relocations (struct bfd_link_info *link_info)
43cd72b9
BW		 5870{
5871 bfd *abfd;
5872 asection *sec;
5873 bfd_boolean is_relaxable = FALSE;
5874
5875 /* Initialize the per-section relaxation info. */
5876 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5877 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5878 {
5879 init_xtensa_relax_info (sec);
5880 }
5881
5882 /* Mark relaxable sections (and count relocations against each one). */
5883 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5884 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5885 {
5886 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
5887 return FALSE;
5888 }
5889
5890 /* Bail out if there are no relaxable sections. */
5891 if (!is_relaxable)
5892 return TRUE;
5893
5894 /* Allocate space for source_relocs. */
5895 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5896 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5897 {
5898 xtensa_relax_info *relax_info;
5899
5900 relax_info = get_xtensa_relax_info (sec);
5901 if (relax_info->is_relaxable_literal_section
5902 || relax_info->is_relaxable_asm_section)
5903 {
5904 relax_info->src_relocs = (source_reloc *)
5905 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
5906 }
5907 }
5908
5909 /* Collect info on relocations against each relaxable section. */
5910 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5911 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5912 {
5913 if (!collect_source_relocs (abfd, sec, link_info))
5914 return FALSE;
5915 }
5916
5917 /* Compute the text actions. */
5918 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5919 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5920 {
5921 if (!compute_text_actions (abfd, sec, link_info))
5922 return FALSE;
5923 }
5924
5925 return TRUE;
5926}
5927
5928
5929/* Find all the sections that might be relaxed. The motivation for
5930 this pass is that collect_source_relocs() needs to record _all_ the
5931 relocations that target each relaxable section. That is expensive
5932 and unnecessary unless the target section is actually going to be
5933 relaxed. This pass identifies all such sections by checking if
5934 they have L32Rs pointing to them. In the process, the total number
5935 of relocations targeting each section is also counted so that we
5936 know how much space to allocate for source_relocs against each
5937 relaxable literal section. */
5938
5939static bfd_boolean
7fa3d080
BW		 5940find_relaxable_sections (bfd *abfd,
5941 asection *sec,
5942 struct bfd_link_info *link_info,
5943 bfd_boolean *is_relaxable_p)
43cd72b9
BW		 5944{
5945 Elf_Internal_Rela *internal_relocs;
5946 bfd_byte *contents;
5947 bfd_boolean ok = TRUE;
5948 unsigned i;
5949 xtensa_relax_info *source_relax_info;
5950
5951 internal_relocs = retrieve_internal_relocs (abfd, sec,
5952 link_info->keep_memory);
5953 if (internal_relocs == NULL)
5954 return ok;
5955
5956 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5957 if (contents == NULL && sec->size != 0)
5958 {
5959 ok = FALSE;
5960 goto error_return;
5961 }
5962
5963 source_relax_info = get_xtensa_relax_info (sec);
5964 for (i = 0; i < sec->reloc_count; i++)
5965 {
5966 Elf_Internal_Rela *irel = &internal_relocs[i];
5967 r_reloc r_rel;
5968 asection *target_sec;
5969 xtensa_relax_info *target_relax_info;
5970
5971 /* If this section has not already been marked as "relaxable", and
5972 if it contains any ASM_EXPAND relocations (marking expanded
5973 longcalls) that can be optimized into direct calls, then mark
5974 the section as "relaxable". */
5975 if (source_relax_info
5976 && !source_relax_info->is_relaxable_asm_section
5977 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
5978 {
5979 bfd_boolean is_reachable = FALSE;
5980 if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
5981 link_info, &is_reachable)
5982 && is_reachable)
5983 {
5984 source_relax_info->is_relaxable_asm_section = TRUE;
5985 *is_relaxable_p = TRUE;
5986 }
5987 }
5988
5989 r_reloc_init (&r_rel, abfd, irel, contents,
5990 bfd_get_section_limit (abfd, sec));
5991
5992 target_sec = r_reloc_get_section (&r_rel);
5993 target_relax_info = get_xtensa_relax_info (target_sec);
5994 if (!target_relax_info)
5995 continue;
5996
5997 /* Count PC-relative operand relocations against the target section.
5998 Note: The conditions tested here must match the conditions under
5999 which init_source_reloc is called in collect_source_relocs(). */
6000 if (is_operand_relocation (ELF32_R_TYPE (irel->r_info))
6001 && (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
6002 || is_l32r_relocation (abfd, sec, contents, irel)))
6003 target_relax_info->src_count++;
6004
6005 if (is_l32r_relocation (abfd, sec, contents, irel)
6006 && r_reloc_is_defined (&r_rel))
6007 {
6008 /* Mark the target section as relaxable. */
6009 target_relax_info->is_relaxable_literal_section = TRUE;
6010 *is_relaxable_p = TRUE;
6011 }
6012 }
6013
6014 error_return:
6015 release_contents (sec, contents);
6016 release_internal_relocs (sec, internal_relocs);
6017 return ok;
6018}
6019
6020
6021/* Record _all_ the relocations that point to relaxable sections, and
6022 get rid of ASM_EXPAND relocs by either converting them to
6023 ASM_SIMPLIFY or by removing them. */
6024
6025static bfd_boolean
7fa3d080
BW		 6026collect_source_relocs (bfd *abfd,
6027 asection *sec,
6028 struct bfd_link_info *link_info)
43cd72b9
BW		 6029{
6030 Elf_Internal_Rela *internal_relocs;
6031 bfd_byte *contents;
6032 bfd_boolean ok = TRUE;
6033 unsigned i;
6034 bfd_size_type sec_size;
6035
6036 internal_relocs = retrieve_internal_relocs (abfd, sec,
6037 link_info->keep_memory);
6038 if (internal_relocs == NULL)
6039 return ok;
6040
6041 sec_size = bfd_get_section_limit (abfd, sec);
6042 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6043 if (contents == NULL && sec_size != 0)
6044 {
6045 ok = FALSE;
6046 goto error_return;
6047 }
6048
6049 /* Record relocations against relaxable literal sections. */
6050 for (i = 0; i < sec->reloc_count; i++)
6051 {
6052 Elf_Internal_Rela *irel = &internal_relocs[i];
6053 r_reloc r_rel;
6054 asection *target_sec;
6055 xtensa_relax_info *target_relax_info;
6056
6057 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6058
6059 target_sec = r_reloc_get_section (&r_rel);
6060 target_relax_info = get_xtensa_relax_info (target_sec);
6061
6062 if (target_relax_info
6063 && (target_relax_info->is_relaxable_literal_section
6064 || target_relax_info->is_relaxable_asm_section))
6065 {
6066 xtensa_opcode opcode = XTENSA_UNDEFINED;
6067 int opnd = -1;
6068 bfd_boolean is_abs_literal = FALSE;
6069
6070 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
6071 {
6072 /* None of the current alternate relocs are PC-relative,
6073 and only PC-relative relocs matter here. However, we
6074 still need to record the opcode for literal
6075 coalescing. */
6076 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6077 if (opcode == get_l32r_opcode ())
6078 {
6079 is_abs_literal = TRUE;
6080 opnd = 1;
6081 }
6082 else
6083 opcode = XTENSA_UNDEFINED;
6084 }
6085 else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6086 {
6087 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6088 opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
6089 }
6090
6091 if (opcode != XTENSA_UNDEFINED)
6092 {
6093 int src_next = target_relax_info->src_next++;
6094 source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
6095
6096 init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
6097 is_abs_literal);
6098 }
6099 }
6100 }
6101
6102 /* Now get rid of ASM_EXPAND relocations. At this point, the
6103 src_relocs array for the target literal section may still be
6104 incomplete, but it must at least contain the entries for the L32R
6105 relocations associated with ASM_EXPANDs because they were just
6106 added in the preceding loop over the relocations. */
6107
6108 for (i = 0; i < sec->reloc_count; i++)
6109 {
6110 Elf_Internal_Rela *irel = &internal_relocs[i];
6111 bfd_boolean is_reachable;
6112
6113 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
6114 &is_reachable))
6115 continue;
6116
6117 if (is_reachable)
6118 {
6119 Elf_Internal_Rela *l32r_irel;
6120 r_reloc r_rel;
6121 asection *target_sec;
6122 xtensa_relax_info *target_relax_info;
6123
6124 /* Mark the source_reloc for the L32R so that it will be
6125 removed in compute_removed_literals(), along with the
6126 associated literal. */
6127 l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
6128 irel, internal_relocs);
6129 if (l32r_irel == NULL)
6130 continue;
6131
6132 r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
6133
6134 target_sec = r_reloc_get_section (&r_rel);
6135 target_relax_info = get_xtensa_relax_info (target_sec);
6136
6137 if (target_relax_info
6138 && (target_relax_info->is_relaxable_literal_section
6139 || target_relax_info->is_relaxable_asm_section))
6140 {
6141 source_reloc *s_reloc;
6142
6143 /* Search the source_relocs for the entry corresponding to
6144 the l32r_irel. Note: The src_relocs array is not yet
6145 sorted, but it wouldn't matter anyway because we're
6146 searching by source offset instead of target offset. */
6147 s_reloc = find_source_reloc (target_relax_info->src_relocs,
6148 target_relax_info->src_next,
6149 sec, l32r_irel);
6150 BFD_ASSERT (s_reloc);
6151 s_reloc->is_null = TRUE;
6152 }
6153
6154 /* Convert this reloc to ASM_SIMPLIFY. */
6155 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
6156 R_XTENSA_ASM_SIMPLIFY);
6157 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
6158
6159 pin_internal_relocs (sec, internal_relocs);
6160 }
6161 else
6162 {
6163 /* It is resolvable but doesn't reach. We resolve now
6164 by eliminating the relocation -- the call will remain
6165 expanded into L32R/CALLX. */
6166 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
6167 pin_internal_relocs (sec, internal_relocs);
6168 }
6169 }
6170
6171 error_return:
6172 release_contents (sec, contents);
6173 release_internal_relocs (sec, internal_relocs);
6174 return ok;
6175}
6176
6177
6178/* Return TRUE if the asm expansion can be resolved. Generally it can
6179 be resolved on a final link or when a partial link locates it in the
6180 same section as the target. Set "is_reachable" flag if the target of
6181 the call is within the range of a direct call, given the current VMA
6182 for this section and the target section. */
6183
6184bfd_boolean
7fa3d080
BW		 6185is_resolvable_asm_expansion (bfd *abfd,
6186 asection *sec,
6187 bfd_byte *contents,
6188 Elf_Internal_Rela *irel,
6189 struct bfd_link_info *link_info,
6190 bfd_boolean *is_reachable_p)
43cd72b9
BW		 6191{
6192 asection *target_sec;
6193 bfd_vma target_offset;
6194 r_reloc r_rel;
6195 xtensa_opcode opcode, direct_call_opcode;
6196 bfd_vma self_address;
6197 bfd_vma dest_address;
6198 bfd_boolean uses_l32r;
6199 bfd_size_type sec_size;
6200
6201 *is_reachable_p = FALSE;
6202
6203 if (contents == NULL)
6204 return FALSE;
6205
6206 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
6207 return FALSE;
6208
6209 sec_size = bfd_get_section_limit (abfd, sec);
6210 opcode = get_expanded_call_opcode (contents + irel->r_offset,
6211 sec_size - irel->r_offset, &uses_l32r);
6212 /* Optimization of longcalls that use CONST16 is not yet implemented. */
6213 if (!uses_l32r)
6214 return FALSE;
6215
6216 direct_call_opcode = swap_callx_for_call_opcode (opcode);
6217 if (direct_call_opcode == XTENSA_UNDEFINED)
6218 return FALSE;
6219
6220 /* Check and see that the target resolves. */
6221 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6222 if (!r_reloc_is_defined (&r_rel))
6223 return FALSE;
6224
6225 target_sec = r_reloc_get_section (&r_rel);
6226 target_offset = r_rel.target_offset;
6227
6228 /* If the target is in a shared library, then it doesn't reach. This
6229 isn't supposed to come up because the compiler should never generate
6230 non-PIC calls on systems that use shared libraries, but the linker
6231 shouldn't crash regardless. */
6232 if (!target_sec->output_section)
6233 return FALSE;
6234
6235 /* For relocatable sections, we can only simplify when the output
6236 section of the target is the same as the output section of the
6237 source. */
6238 if (link_info->relocatable
6239 && (target_sec->output_section != sec->output_section
6240 || is_reloc_sym_weak (abfd, irel)))
6241 return FALSE;
6242
6243 self_address = (sec->output_section->vma
6244 + sec->output_offset + irel->r_offset + 3);
6245 dest_address = (target_sec->output_section->vma
6246 + target_sec->output_offset + target_offset);
6247
6248 *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
6249 self_address, dest_address);
6250
6251 if ((self_address >> CALL_SEGMENT_BITS) !=
6252 (dest_address >> CALL_SEGMENT_BITS))
6253 return FALSE;
6254
6255 return TRUE;
6256}
6257
6258
6259static Elf_Internal_Rela *
7fa3d080
BW		 6260find_associated_l32r_irel (bfd *abfd,
6261 asection *sec,
6262 bfd_byte *contents,
6263 Elf_Internal_Rela *other_irel,
6264 Elf_Internal_Rela *internal_relocs)
43cd72b9
BW		 6265{
6266 unsigned i;
e0001a05 6267
43cd72b9
BW		 6268 for (i = 0; i < sec->reloc_count; i++)
6269 {
6270 Elf_Internal_Rela *irel = &internal_relocs[i];
e0001a05 6271
43cd72b9
BW		 6272 if (irel == other_irel)
6273 continue;
6274 if (irel->r_offset != other_irel->r_offset)
6275 continue;
6276 if (is_l32r_relocation (abfd, sec, contents, irel))
6277 return irel;
6278 }
6279
6280 return NULL;
e0001a05
NC		 6281}
6282
6283
43cd72b9
BW		 6284/* The compute_text_actions function will build a list of potential
6285 transformation actions for code in the extended basic block of each
6286 longcall that is optimized to a direct call. From this list we
6287 generate a set of actions to actually perform that optimizes for
6288 space and, if not using size_opt, maintains branch target
6289 alignments.
e0001a05 6290
43cd72b9
BW		 6291 These actions to be performed are placed on a per-section list.
6292 The actual changes are performed by relax_section() in the second
6293 pass. */
6294
6295bfd_boolean
7fa3d080
BW		 6296compute_text_actions (bfd *abfd,
6297 asection *sec,
6298 struct bfd_link_info *link_info)
e0001a05 6299{
43cd72b9 6300 xtensa_relax_info *relax_info;
e0001a05 6301 bfd_byte *contents;
43cd72b9 6302 Elf_Internal_Rela *internal_relocs;
e0001a05
NC		 6303 bfd_boolean ok = TRUE;
6304 unsigned i;
43cd72b9
BW		 6305 property_table_entry *prop_table = 0;
6306 int ptblsize = 0;
6307 bfd_size_type sec_size;
6308 static bfd_boolean no_insn_move = FALSE;
6309
6310 if (no_insn_move)
6311 return ok;
6312
6313 /* Do nothing if the section contains no optimized longcalls. */
6314 relax_info = get_xtensa_relax_info (sec);
6315 BFD_ASSERT (relax_info);
6316 if (!relax_info->is_relaxable_asm_section)
6317 return ok;
e0001a05
NC		 6318
6319 internal_relocs = retrieve_internal_relocs (abfd, sec,
6320 link_info->keep_memory);
e0001a05 6321
43cd72b9
BW		 6322 if (internal_relocs)
6323 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
6324 internal_reloc_compare);
6325
6326 sec_size = bfd_get_section_limit (abfd, sec);
e0001a05 6327 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
43cd72b9 6328 if (contents == NULL && sec_size != 0)
e0001a05
NC		 6329 {
6330 ok = FALSE;
6331 goto error_return;
6332 }
6333
43cd72b9
BW		 6334 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6335 XTENSA_PROP_SEC_NAME, FALSE);
6336 if (ptblsize < 0)
6337 {
6338 ok = FALSE;
6339 goto error_return;
6340 }
6341
6342 for (i = 0; i < sec->reloc_count; i++)
e0001a05
NC		 6343 {
6344 Elf_Internal_Rela *irel = &internal_relocs[i];
43cd72b9
BW		 6345 bfd_vma r_offset;
6346 property_table_entry *the_entry;
6347 int ptbl_idx;
6348 ebb_t *ebb;
6349 ebb_constraint ebb_table;
6350 bfd_size_type simplify_size;
6351
6352 if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
6353 continue;
6354 r_offset = irel->r_offset;
e0001a05 6355
43cd72b9
BW		 6356 simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
6357 if (simplify_size == 0)
6358 {
6359 (*_bfd_error_handler)
6360 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
6361 sec->owner, sec, r_offset);
6362 continue;
6363 }
e0001a05 6364
43cd72b9
BW		 6365 /* If the instruction table is not around, then don't do this
6366 relaxation. */
6367 the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
6368 sec->vma + irel->r_offset);
6369 if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
6370 {
6371 text_action_add (&relax_info->action_list,
6372 ta_convert_longcall, sec, r_offset,
6373 0);
6374 continue;
6375 }
6376
6377 /* If the next longcall happens to be at the same address as an
6378 unreachable section of size 0, then skip forward. */
6379 ptbl_idx = the_entry - prop_table;
6380 while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
6381 && the_entry->size == 0
6382 && ptbl_idx + 1 < ptblsize
6383 && (prop_table[ptbl_idx + 1].address
6384 == prop_table[ptbl_idx].address))
6385 {
6386 ptbl_idx++;
6387 the_entry++;
6388 }
e0001a05 6389
43cd72b9
BW		 6390 if (the_entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM)
6391 /* NO_REORDER is OK */
6392 continue;
e0001a05 6393
43cd72b9
BW		 6394 init_ebb_constraint (&ebb_table);
6395 ebb = &ebb_table.ebb;
6396 init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
6397 internal_relocs, sec->reloc_count);
6398 ebb->start_offset = r_offset + simplify_size;
6399 ebb->end_offset = r_offset + simplify_size;
6400 ebb->start_ptbl_idx = ptbl_idx;
6401 ebb->end_ptbl_idx = ptbl_idx;
6402 ebb->start_reloc_idx = i;
6403 ebb->end_reloc_idx = i;
6404
6405 if (!extend_ebb_bounds (ebb)
6406 || !compute_ebb_proposed_actions (&ebb_table)
6407 || !compute_ebb_actions (&ebb_table)
6408 || !check_section_ebb_pcrels_fit (abfd, sec, contents,
6409 internal_relocs, &ebb_table)
6410 || !check_section_ebb_reduces (&ebb_table))
e0001a05 6411 {
43cd72b9
BW		 6412 /* If anything goes wrong or we get unlucky and something does
6413 not fit, with our plan because of expansion between
6414 critical branches, just convert to a NOP. */
6415
6416 text_action_add (&relax_info->action_list,
6417 ta_convert_longcall, sec, r_offset, 0);
6418 i = ebb_table.ebb.end_reloc_idx;
6419 free_ebb_constraint (&ebb_table);
6420 continue;
e0001a05 6421 }
43cd72b9
BW		 6422
6423 text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
6424
6425 /* Update the index so we do not go looking at the relocations
6426 we have already processed. */
6427 i = ebb_table.ebb.end_reloc_idx;
6428 free_ebb_constraint (&ebb_table);
e0001a05
NC		 6429 }
6430
43cd72b9 6431#if DEBUG
7fa3d080 6432 if (relax_info->action_list.head)
43cd72b9
BW		 6433 print_action_list (stderr, &relax_info->action_list);
6434#endif
6435
6436error_return:
e0001a05
NC		 6437 release_contents (sec, contents);
6438 release_internal_relocs (sec, internal_relocs);
43cd72b9
BW		 6439 if (prop_table)
6440 free (prop_table);
6441
e0001a05
NC		 6442 return ok;
6443}
6444
6445
43cd72b9 6446/* Find all of the possible actions for an extended basic block. */
e0001a05 6447
43cd72b9 6448bfd_boolean
7fa3d080 6449compute_ebb_proposed_actions (ebb_constraint *ebb_table)
e0001a05 6450{
43cd72b9
BW		 6451 const ebb_t *ebb = &ebb_table->ebb;
6452 unsigned rel_idx = ebb->start_reloc_idx;
6453 property_table_entry *entry, *start_entry, *end_entry;
e0001a05 6454
43cd72b9
BW		 6455 start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6456 end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
e0001a05 6457
43cd72b9 6458 for (entry = start_entry; entry <= end_entry; entry++)
e0001a05 6459 {
43cd72b9
BW		 6460 bfd_vma offset, start_offset, end_offset;
6461 bfd_size_type insn_len;
e0001a05 6462
43cd72b9
BW		 6463 start_offset = entry->address - ebb->sec->vma;
6464 end_offset = entry->address + entry->size - ebb->sec->vma;
e0001a05 6465
43cd72b9
BW		 6466 if (entry == start_entry)
6467 start_offset = ebb->start_offset;
6468 if (entry == end_entry)
6469 end_offset = ebb->end_offset;
6470 offset = start_offset;
e0001a05 6471
43cd72b9
BW		 6472 if (offset == entry->address - ebb->sec->vma
6473 && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
6474 {
6475 enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
6476 BFD_ASSERT (offset != end_offset);
6477 if (offset == end_offset)
6478 return FALSE;
e0001a05 6479
43cd72b9
BW		 6480 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
6481 offset);
6482
6483 /* Propose no actions for a section with an undecodable offset. */
6484 if (insn_len == 0)
6485 {
6486 (*_bfd_error_handler)
6487 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6488 ebb->sec->owner, ebb->sec, offset);
6489 return FALSE;
6490 }
6491 if (check_branch_target_aligned_address (offset, insn_len))
6492 align_type = EBB_REQUIRE_TGT_ALIGN;
6493
6494 ebb_propose_action (ebb_table, align_type, 0,
6495 ta_none, offset, 0, TRUE);
6496 }
6497
6498 while (offset != end_offset)
e0001a05 6499 {
43cd72b9 6500 Elf_Internal_Rela *irel;
e0001a05 6501 xtensa_opcode opcode;
e0001a05 6502
43cd72b9
BW		 6503 while (rel_idx < ebb->end_reloc_idx
6504 && (ebb->relocs[rel_idx].r_offset < offset
6505 || (ebb->relocs[rel_idx].r_offset == offset
6506 && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
6507 != R_XTENSA_ASM_SIMPLIFY))))
6508 rel_idx++;
6509
6510 /* Check for longcall. */
6511 irel = &ebb->relocs[rel_idx];
6512 if (irel->r_offset == offset
6513 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
6514 {
6515 bfd_size_type simplify_size;
e0001a05 6516
43cd72b9
BW		 6517 simplify_size = get_asm_simplify_size (ebb->contents,
6518 ebb->content_length,
6519 irel->r_offset);
6520 if (simplify_size == 0)
6521 {
6522 (*_bfd_error_handler)
6523 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
6524 ebb->sec->owner, ebb->sec, offset);
6525 return FALSE;
6526 }
6527
6528 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6529 ta_convert_longcall, offset, 0, TRUE);
6530
6531 offset += simplify_size;
6532 continue;
6533 }
e0001a05 6534
43cd72b9
BW		 6535 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
6536 offset);
6537 /* If the instruction is undecodable, then report an error. */
6538 if (insn_len == 0)
6539 {
6540 (*_bfd_error_handler)
6541 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6542 ebb->sec->owner, ebb->sec, offset);
6543 return FALSE;
6544 }
6545
6546 if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
6547 && (entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) == 0
6548 && narrow_instruction (ebb->contents, ebb->content_length,
6549 offset, FALSE))
6550 {
6551 /* Add an instruction narrow action. */
6552 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6553 ta_narrow_insn, offset, 0, FALSE);
6554 offset += insn_len;
6555 continue;
6556 }
6557 if ((entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) == 0
6558 && widen_instruction (ebb->contents, ebb->content_length,
6559 offset, FALSE))
6560 {
6561 /* Add an instruction widen action. */
6562 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6563 ta_widen_insn, offset, 0, FALSE);
6564 offset += insn_len;
6565 continue;
6566 }
6567 opcode = insn_decode_opcode (ebb->contents, ebb->content_length,
6568 offset, 0);
6569 if (xtensa_opcode_is_loop (xtensa_default_isa, opcode))
6570 {
6571 /* Check for branch targets. */
6572 ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
6573 ta_none, offset, 0, TRUE);
6574 offset += insn_len;
6575 continue;
6576 }
6577
6578 offset += insn_len;
e0001a05
NC		 6579 }
6580 }
6581
43cd72b9
BW		 6582 if (ebb->ends_unreachable)
6583 {
6584 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6585 ta_fill, ebb->end_offset, 0, TRUE);
6586 }
e0001a05 6587
43cd72b9
BW		 6588 return TRUE;
6589}
6590
6591
6592/* After all of the information has collected about the
6593 transformations possible in an EBB, compute the appropriate actions
6594 here in compute_ebb_actions. We still must check later to make
6595 sure that the actions do not break any relocations. The algorithm
6596 used here is pretty greedy. Basically, it removes as many no-ops
6597 as possible so that the end of the EBB has the same alignment
6598 characteristics as the original. First, it uses narrowing, then
6599 fill space at the end of the EBB, and finally widenings. If that
6600 does not work, it tries again with one fewer no-op removed. The
6601 optimization will only be performed if all of the branch targets
6602 that were aligned before transformation are also aligned after the
6603 transformation.
6604
6605 When the size_opt flag is set, ignore the branch target alignments,
6606 narrow all wide instructions, and remove all no-ops unless the end
6607 of the EBB prevents it. */
6608
6609bfd_boolean
7fa3d080 6610compute_ebb_actions (ebb_constraint *ebb_table)
43cd72b9
BW		 6611{
6612 unsigned i = 0;
6613 unsigned j;
6614 int removed_bytes = 0;
6615 ebb_t *ebb = &ebb_table->ebb;
6616 unsigned seg_idx_start = 0;
6617 unsigned seg_idx_end = 0;
6618
6619 /* We perform this like the assembler relaxation algorithm: Start by
6620 assuming all instructions are narrow and all no-ops removed; then
6621 walk through.... */
6622
6623 /* For each segment of this that has a solid constraint, check to
6624 see if there are any combinations that will keep the constraint.
6625 If so, use it. */
6626 for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
e0001a05 6627 {
43cd72b9
BW		 6628 bfd_boolean requires_text_end_align = FALSE;
6629 unsigned longcall_count = 0;
6630 unsigned longcall_convert_count = 0;
6631 unsigned narrowable_count = 0;
6632 unsigned narrowable_convert_count = 0;
6633 unsigned widenable_count = 0;
6634 unsigned widenable_convert_count = 0;
e0001a05 6635
43cd72b9
BW		 6636 proposed_action *action = NULL;
6637 int align = (1 << ebb_table->ebb.sec->alignment_power);
e0001a05 6638
43cd72b9 6639 seg_idx_start = seg_idx_end;
e0001a05 6640
43cd72b9
BW		 6641 for (i = seg_idx_start; i < ebb_table->action_count; i++)
6642 {
6643 action = &ebb_table->actions[i];
6644 if (action->action == ta_convert_longcall)
6645 longcall_count++;
6646 if (action->action == ta_narrow_insn)
6647 narrowable_count++;
6648 if (action->action == ta_widen_insn)
6649 widenable_count++;
6650 if (action->action == ta_fill)
6651 break;
6652 if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
6653 break;
6654 if (action->align_type == EBB_REQUIRE_TGT_ALIGN
6655 && !elf32xtensa_size_opt)
6656 break;
6657 }
6658 seg_idx_end = i;
e0001a05 6659
43cd72b9
BW		 6660 if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
6661 requires_text_end_align = TRUE;
e0001a05 6662
43cd72b9
BW		 6663 if (elf32xtensa_size_opt && !requires_text_end_align
6664 && action->align_type != EBB_REQUIRE_LOOP_ALIGN
6665 && action->align_type != EBB_REQUIRE_TGT_ALIGN)
6666 {
6667 longcall_convert_count = longcall_count;
6668 narrowable_convert_count = narrowable_count;
6669 widenable_convert_count = 0;
6670 }
6671 else
6672 {
6673 /* There is a constraint. Convert the max number of longcalls. */
6674 narrowable_convert_count = 0;
6675 longcall_convert_count = 0;
6676 widenable_convert_count = 0;
e0001a05 6677
43cd72b9 6678 for (j = 0; j < longcall_count; j++)
e0001a05 6679 {
43cd72b9
BW		 6680 int removed = (longcall_count - j) * 3 & (align - 1);
6681 unsigned desire_narrow = (align - removed) & (align - 1);
6682 unsigned desire_widen = removed;
6683 if (desire_narrow <= narrowable_count)
6684 {
6685 narrowable_convert_count = desire_narrow;
6686 narrowable_convert_count +=
6687 (align * ((narrowable_count - narrowable_convert_count)
6688 / align));
6689 longcall_convert_count = (longcall_count - j);
6690 widenable_convert_count = 0;
6691 break;
6692 }
6693 if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
6694 {
6695 narrowable_convert_count = 0;
6696 longcall_convert_count = longcall_count - j;
6697 widenable_convert_count = desire_widen;
6698 break;
6699 }
6700 }
6701 }
e0001a05 6702
43cd72b9
BW		 6703 /* Now the number of conversions are saved. Do them. */
6704 for (i = seg_idx_start; i < seg_idx_end; i++)
6705 {
6706 action = &ebb_table->actions[i];
6707 switch (action->action)
6708 {
6709 case ta_convert_longcall:
6710 if (longcall_convert_count != 0)
6711 {
6712 action->action = ta_remove_longcall;
6713 action->do_action = TRUE;
6714 action->removed_bytes += 3;
6715 longcall_convert_count--;
6716 }
6717 break;
6718 case ta_narrow_insn:
6719 if (narrowable_convert_count != 0)
6720 {
6721 action->do_action = TRUE;
6722 action->removed_bytes += 1;
6723 narrowable_convert_count--;
6724 }
6725 break;
6726 case ta_widen_insn:
6727 if (widenable_convert_count != 0)
6728 {
6729 action->do_action = TRUE;
6730 action->removed_bytes -= 1;
6731 widenable_convert_count--;
6732 }
6733 break;
6734 default:
6735 break;
e0001a05 6736 }
43cd72b9
BW		 6737 }
6738 }
e0001a05 6739
43cd72b9
BW		 6740 /* Now we move on to some local opts. Try to remove each of the
6741 remaining longcalls. */
e0001a05 6742
43cd72b9
BW		 6743 if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
6744 {
6745 removed_bytes = 0;
6746 for (i = 0; i < ebb_table->action_count; i++)
e0001a05 6747 {
43cd72b9
BW		 6748 int old_removed_bytes = removed_bytes;
6749 proposed_action *action = &ebb_table->actions[i];
6750
6751 if (action->do_action && action->action == ta_convert_longcall)
6752 {
6753 bfd_boolean bad_alignment = FALSE;
6754 removed_bytes += 3;
6755 for (j = i + 1; j < ebb_table->action_count; j++)
6756 {
6757 proposed_action *new_action = &ebb_table->actions[j];
6758 bfd_vma offset = new_action->offset;
6759 if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
6760 {
6761 if (!check_branch_target_aligned
6762 (ebb_table->ebb.contents,
6763 ebb_table->ebb.content_length,
6764 offset, offset - removed_bytes))
6765 {
6766 bad_alignment = TRUE;
6767 break;
6768 }
6769 }
6770 if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
6771 {
6772 if (!check_loop_aligned (ebb_table->ebb.contents,
6773 ebb_table->ebb.content_length,
6774 offset,
6775 offset - removed_bytes))
6776 {
6777 bad_alignment = TRUE;
6778 break;
6779 }
6780 }
6781 if (new_action->action == ta_narrow_insn
6782 && !new_action->do_action
6783 && ebb_table->ebb.sec->alignment_power == 2)
6784 {
6785 /* Narrow an instruction and we are done. */
6786 new_action->do_action = TRUE;
6787 new_action->removed_bytes += 1;
6788 bad_alignment = FALSE;
6789 break;
6790 }
6791 if (new_action->action == ta_widen_insn
6792 && new_action->do_action
6793 && ebb_table->ebb.sec->alignment_power == 2)
6794 {
6795 /* Narrow an instruction and we are done. */
6796 new_action->do_action = FALSE;
6797 new_action->removed_bytes += 1;
6798 bad_alignment = FALSE;
6799 break;
6800 }
6801 }
6802 if (!bad_alignment)
6803 {
6804 action->removed_bytes += 3;
6805 action->action = ta_remove_longcall;
6806 action->do_action = TRUE;
6807 }
6808 }
6809 removed_bytes = old_removed_bytes;
6810 if (action->do_action)
6811 removed_bytes += action->removed_bytes;
e0001a05
NC		 6812 }
6813 }
6814
43cd72b9
BW		 6815 removed_bytes = 0;
6816 for (i = 0; i < ebb_table->action_count; ++i)
6817 {
6818 proposed_action *action = &ebb_table->actions[i];
6819 if (action->do_action)
6820 removed_bytes += action->removed_bytes;
6821 }
6822
6823 if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
6824 && ebb->ends_unreachable)
6825 {
6826 proposed_action *action;
6827 int br;
6828 int extra_space;
6829
6830 BFD_ASSERT (ebb_table->action_count != 0);
6831 action = &ebb_table->actions[ebb_table->action_count - 1];
6832 BFD_ASSERT (action->action == ta_fill);
6833 BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
6834
6835 extra_space = compute_fill_extra_space (ebb->ends_unreachable);
6836 br = action->removed_bytes + removed_bytes + extra_space;
6837 br = br & ((1 << ebb->sec->alignment_power ) - 1);
6838
6839 action->removed_bytes = extra_space - br;
6840 }
6841 return TRUE;
e0001a05
NC		 6842}
6843
6844
43cd72b9
BW		 6845/* Use check_section_ebb_pcrels_fit to make sure that all of the
6846 relocations in a section will fit if a proposed set of actions
6847 are performed. */
e0001a05 6848
43cd72b9 6849static bfd_boolean
7fa3d080
BW		 6850check_section_ebb_pcrels_fit (bfd *abfd,
6851 asection *sec,
6852 bfd_byte *contents,
6853 Elf_Internal_Rela *internal_relocs,
6854 const ebb_constraint *constraint)
e0001a05 6855{
43cd72b9
BW		 6856 unsigned i, j;
6857 Elf_Internal_Rela *irel;
6858 xtensa_relax_info *relax_info;
e0001a05 6859
43cd72b9 6860 relax_info = get_xtensa_relax_info (sec);
e0001a05 6861
43cd72b9
BW		 6862 for (i = 0; i < sec->reloc_count; i++)
6863 {
6864 r_reloc r_rel;
6865 bfd_vma orig_self_offset, orig_target_offset;
6866 bfd_vma self_offset, target_offset;
6867 int r_type;
6868 reloc_howto_type *howto;
6869 int self_removed_bytes, target_removed_bytes;
e0001a05 6870
43cd72b9
BW		 6871 irel = &internal_relocs[i];
6872 r_type = ELF32_R_TYPE (irel->r_info);
e0001a05 6873
43cd72b9
BW		 6874 howto = &elf_howto_table[r_type];
6875 /* We maintain the required invariant: PC-relative relocations
6876 that fit before linking must fit after linking. Thus we only
6877 need to deal with relocations to the same section that are
6878 PC-relative. */
6879 if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY
6880 || !howto->pc_relative)
6881 continue;
e0001a05 6882
43cd72b9
BW		 6883 r_reloc_init (&r_rel, abfd, irel, contents,
6884 bfd_get_section_limit (abfd, sec));
e0001a05 6885
43cd72b9
BW		 6886 if (r_reloc_get_section (&r_rel) != sec)
6887 continue;
e0001a05 6888
43cd72b9
BW		 6889 orig_self_offset = irel->r_offset;
6890 orig_target_offset = r_rel.target_offset;
e0001a05 6891
43cd72b9
BW		 6892 self_offset = orig_self_offset;
6893 target_offset = orig_target_offset;
6894
6895 if (relax_info)
6896 {
6897 self_offset = offset_with_removed_text (&relax_info->action_list,
6898 orig_self_offset);
6899 target_offset = offset_with_removed_text (&relax_info->action_list,
6900 orig_target_offset);
6901 }
6902
6903 self_removed_bytes = 0;
6904 target_removed_bytes = 0;
6905
6906 for (j = 0; j < constraint->action_count; ++j)
6907 {
6908 proposed_action *action = &constraint->actions[j];
6909 bfd_vma offset = action->offset;
6910 int removed_bytes = action->removed_bytes;
6911 if (offset < orig_self_offset
6912 || (offset == orig_self_offset && action->action == ta_fill
6913 && action->removed_bytes < 0))
6914 self_removed_bytes += removed_bytes;
6915 if (offset < orig_target_offset
6916 || (offset == orig_target_offset && action->action == ta_fill
6917 && action->removed_bytes < 0))
6918 target_removed_bytes += removed_bytes;
6919 }
6920 self_offset -= self_removed_bytes;
6921 target_offset -= target_removed_bytes;
6922
6923 /* Try to encode it. Get the operand and check. */
6924 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
6925 {
6926 /* None of the current alternate relocs are PC-relative,
6927 and only PC-relative relocs matter here. */
6928 }
6929 else
6930 {
6931 xtensa_opcode opcode;
6932 int opnum;
6933
6934 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6935 if (opcode == XTENSA_UNDEFINED)
6936 return FALSE;
6937
6938 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
6939 if (opnum == XTENSA_UNDEFINED)
6940 return FALSE;
6941
6942 if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
6943 return FALSE;
6944 }
6945 }
6946
6947 return TRUE;
6948}
6949
6950
6951static bfd_boolean
7fa3d080 6952check_section_ebb_reduces (const ebb_constraint *constraint)
43cd72b9
BW		 6953{
6954 int removed = 0;
6955 unsigned i;
6956
6957 for (i = 0; i < constraint->action_count; i++)
6958 {
6959 const proposed_action *action = &constraint->actions[i];
6960 if (action->do_action)
6961 removed += action->removed_bytes;
6962 }
6963 if (removed < 0)
e0001a05
NC		 6964 return FALSE;
6965
6966 return TRUE;
6967}
6968
6969
43cd72b9 6970void
7fa3d080
BW		 6971text_action_add_proposed (text_action_list *l,
6972 const ebb_constraint *ebb_table,
6973 asection *sec)
e0001a05
NC		 6974{
6975 unsigned i;
6976
43cd72b9 6977 for (i = 0; i < ebb_table->action_count; i++)
e0001a05 6978 {
43cd72b9 6979 proposed_action *action = &ebb_table->actions[i];
e0001a05 6980
43cd72b9 6981 if (!action->do_action)
e0001a05 6982 continue;
43cd72b9
BW		 6983 switch (action->action)
6984 {
6985 case ta_remove_insn:
6986 case ta_remove_longcall:
6987 case ta_convert_longcall:
6988 case ta_narrow_insn:
6989 case ta_widen_insn:
6990 case ta_fill:
6991 case ta_remove_literal:
6992 text_action_add (l, action->action, sec, action->offset,
6993 action->removed_bytes);
6994 break;
6995 case ta_none:
6996 break;
6997 default:
6998 BFD_ASSERT (0);
6999 break;
7000 }
e0001a05 7001 }
43cd72b9 7002}
e0001a05 7003
43cd72b9
BW		 7004
7005int
7fa3d080 7006compute_fill_extra_space (property_table_entry *entry)
43cd72b9
BW		 7007{
7008 int fill_extra_space;
7009
7010 if (!entry)
7011 return 0;
7012
7013 if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
7014 return 0;
7015
7016 fill_extra_space = entry->size;
7017 if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
7018 {
7019 /* Fill bytes for alignment:
7020 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
7021 int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
7022 int nsm = (1 << pow) - 1;
7023 bfd_vma addr = entry->address + entry->size;
7024 bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
7025 fill_extra_space += align_fill;
7026 }
7027 return fill_extra_space;
e0001a05
NC		 7028}
7029
43cd72b9 7030\f
e0001a05
NC		 7031/* First relaxation pass. */
7032
43cd72b9
BW		 7033/* If the section contains relaxable literals, check each literal to
7034 see if it has the same value as another literal that has already
7035 been seen, either in the current section or a previous one. If so,
7036 add an entry to the per-section list of removed literals. The
e0001a05
NC		 7037 actual changes are deferred until the next pass. */
7038
7039static bfd_boolean
7fa3d080
BW		 7040compute_removed_literals (bfd *abfd,
7041 asection *sec,
7042 struct bfd_link_info *link_info,
7043 value_map_hash_table *values)
e0001a05
NC		 7044{
7045 xtensa_relax_info *relax_info;
7046 bfd_byte *contents;
7047 Elf_Internal_Rela *internal_relocs;
43cd72b9 7048 source_reloc *src_relocs, *rel;
e0001a05 7049 bfd_boolean ok = TRUE;
43cd72b9
BW		 7050 property_table_entry *prop_table = NULL;
7051 int ptblsize;
7052 int i, prev_i;
7053 bfd_boolean last_loc_is_prev = FALSE;
7054 bfd_vma last_target_offset = 0;
7055 section_cache_t target_sec_cache;
7056 bfd_size_type sec_size;
7057
7058 init_section_cache (&target_sec_cache);
e0001a05
NC		 7059
7060 /* Do nothing if it is not a relaxable literal section. */
7061 relax_info = get_xtensa_relax_info (sec);
7062 BFD_ASSERT (relax_info);
e0001a05
NC		 7063 if (!relax_info->is_relaxable_literal_section)
7064 return ok;
7065
7066 internal_relocs = retrieve_internal_relocs (abfd, sec,
7067 link_info->keep_memory);
7068
43cd72b9 7069 sec_size = bfd_get_section_limit (abfd, sec);
e0001a05 7070 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
43cd72b9 7071 if (contents == NULL && sec_size != 0)
e0001a05
NC		 7072 {
7073 ok = FALSE;
7074 goto error_return;
7075 }
7076
7077 /* Sort the source_relocs by target offset. */
7078 src_relocs = relax_info->src_relocs;
7079 qsort (src_relocs, relax_info->src_count,
7080 sizeof (source_reloc), source_reloc_compare);
43cd72b9
BW		 7081 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7082 internal_reloc_compare);
e0001a05 7083
43cd72b9
BW		 7084 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7085 XTENSA_PROP_SEC_NAME, FALSE);
7086 if (ptblsize < 0)
7087 {
7088 ok = FALSE;
7089 goto error_return;
7090 }
7091
7092 prev_i = -1;
e0001a05
NC		 7093 for (i = 0; i < relax_info->src_count; i++)
7094 {
e0001a05 7095 Elf_Internal_Rela *irel = NULL;
e0001a05
NC		 7096
7097 rel = &src_relocs[i];
43cd72b9
BW		 7098 if (get_l32r_opcode () != rel->opcode)
7099 continue;
e0001a05
NC		 7100 irel = get_irel_at_offset (sec, internal_relocs,
7101 rel->r_rel.target_offset);
7102
43cd72b9
BW		 7103 /* If the relocation on this is not a simple R_XTENSA_32 or
7104 R_XTENSA_PLT then do not consider it. This may happen when
7105 the difference of two symbols is used in a literal. */
7106 if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
7107 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
7108 continue;
7109
e0001a05
NC		 7110 /* If the target_offset for this relocation is the same as the
7111 previous relocation, then we've already considered whether the
7112 literal can be coalesced. Skip to the next one.... */
43cd72b9
BW		 7113 if (i != 0 && prev_i != -1
7114 && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
e0001a05 7115 continue;
43cd72b9
BW		 7116 prev_i = i;
7117
7118 if (last_loc_is_prev &&
7119 last_target_offset + 4 != rel->r_rel.target_offset)
7120 last_loc_is_prev = FALSE;
e0001a05
NC		 7121
7122 /* Check if the relocation was from an L32R that is being removed
7123 because a CALLX was converted to a direct CALL, and check if
7124 there are no other relocations to the literal. */
43cd72b9 7125 if (is_removable_literal (rel, i, src_relocs, relax_info->src_count))
e0001a05 7126 {
43cd72b9
BW		 7127 if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
7128 irel, rel, prop_table, ptblsize))
e0001a05 7129 {
43cd72b9
BW		 7130 ok = FALSE;
7131 goto error_return;
e0001a05 7132 }
43cd72b9 7133 last_target_offset = rel->r_rel.target_offset;
e0001a05
NC		 7134 continue;
7135 }
7136
43cd72b9
BW		 7137 if (!identify_literal_placement (abfd, sec, contents, link_info,
7138 values,
7139 &last_loc_is_prev, irel,
7140 relax_info->src_count - i, rel,
7141 prop_table, ptblsize,
7142 &target_sec_cache, rel->is_abs_literal))
e0001a05 7143 {
43cd72b9
BW		 7144 ok = FALSE;
7145 goto error_return;
7146 }
7147 last_target_offset = rel->r_rel.target_offset;
7148 }
e0001a05 7149
43cd72b9
BW		 7150#if DEBUG
7151 print_removed_literals (stderr, &relax_info->removed_list);
7152 print_action_list (stderr, &relax_info->action_list);
7153#endif /* DEBUG */
7154
7155error_return:
7156 if (prop_table) free (prop_table);
7157 clear_section_cache (&target_sec_cache);
7158
7159 release_contents (sec, contents);
7160 release_internal_relocs (sec, internal_relocs);
7161 return ok;
7162}
7163
7164
7165static Elf_Internal_Rela *
7fa3d080
BW		 7166get_irel_at_offset (asection *sec,
7167 Elf_Internal_Rela *internal_relocs,
7168 bfd_vma offset)
43cd72b9
BW		 7169{
7170 unsigned i;
7171 Elf_Internal_Rela *irel;
7172 unsigned r_type;
7173 Elf_Internal_Rela key;
7174
7175 if (!internal_relocs)
7176 return NULL;
7177
7178 key.r_offset = offset;
7179 irel = bsearch (&key, internal_relocs, sec->reloc_count,
7180 sizeof (Elf_Internal_Rela), internal_reloc_matches);
7181 if (!irel)
7182 return NULL;
7183
7184 /* bsearch does not guarantee which will be returned if there are
7185 multiple matches. We need the first that is not an alignment. */
7186 i = irel - internal_relocs;
7187 while (i > 0)
7188 {
7189 if (internal_relocs[i-1].r_offset != offset)
7190 break;
7191 i--;
7192 }
7193 for ( ; i < sec->reloc_count; i++)
7194 {
7195 irel = &internal_relocs[i];
7196 r_type = ELF32_R_TYPE (irel->r_info);
7197 if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
7198 return irel;
7199 }
7200
7201 return NULL;
7202}
7203
7204
7205bfd_boolean
7fa3d080
BW		 7206is_removable_literal (const source_reloc *rel,
7207 int i,
7208 const source_reloc *src_relocs,
7209 int src_count)
43cd72b9
BW		 7210{
7211 const source_reloc *curr_rel;
7212 if (!rel->is_null)
7213 return FALSE;
7214
7215 for (++i; i < src_count; ++i)
7216 {
7217 curr_rel = &src_relocs[i];
7218 /* If all others have the same target offset.... */
7219 if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
7220 return TRUE;
7221
7222 if (!curr_rel->is_null
7223 && !xtensa_is_property_section (curr_rel->source_sec)
7224 && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
7225 return FALSE;
7226 }
7227 return TRUE;
7228}
7229
7230
7231bfd_boolean
7fa3d080
BW		 7232remove_dead_literal (bfd *abfd,
7233 asection *sec,
7234 struct bfd_link_info *link_info,
7235 Elf_Internal_Rela *internal_relocs,
7236 Elf_Internal_Rela *irel,
7237 source_reloc *rel,
7238 property_table_entry *prop_table,
7239 int ptblsize)
43cd72b9
BW		 7240{
7241 property_table_entry *entry;
7242 xtensa_relax_info *relax_info;
7243
7244 relax_info = get_xtensa_relax_info (sec);
7245 if (!relax_info)
7246 return FALSE;
7247
7248 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7249 sec->vma + rel->r_rel.target_offset);
7250
7251 /* Mark the unused literal so that it will be removed. */
7252 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
7253
7254 text_action_add (&relax_info->action_list,
7255 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
7256
7257 /* If the section is 4-byte aligned, do not add fill. */
7258 if (sec->alignment_power > 2)
7259 {
7260 int fill_extra_space;
7261 bfd_vma entry_sec_offset;
7262 text_action *fa;
7263 property_table_entry *the_add_entry;
7264 int removed_diff;
7265
7266 if (entry)
7267 entry_sec_offset = entry->address - sec->vma + entry->size;
7268 else
7269 entry_sec_offset = rel->r_rel.target_offset + 4;
7270
7271 /* If the literal range is at the end of the section,
7272 do not add fill. */
7273 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7274 entry_sec_offset);
7275 fill_extra_space = compute_fill_extra_space (the_add_entry);
7276
7277 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
7278 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
7279 -4, fill_extra_space);
7280 if (fa)
7281 adjust_fill_action (fa, removed_diff);
7282 else
7283 text_action_add (&relax_info->action_list,
7284 ta_fill, sec, entry_sec_offset, removed_diff);
7285 }
7286
7287 /* Zero out the relocation on this literal location. */
7288 if (irel)
7289 {
7290 if (elf_hash_table (link_info)->dynamic_sections_created)
7291 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
7292
7293 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7294 pin_internal_relocs (sec, internal_relocs);
7295 }
7296
7297 /* Do not modify "last_loc_is_prev". */
7298 return TRUE;
7299}
7300
7301
7302bfd_boolean
7fa3d080
BW		 7303identify_literal_placement (bfd *abfd,
7304 asection *sec,
7305 bfd_byte *contents,
7306 struct bfd_link_info *link_info,
7307 value_map_hash_table *values,
7308 bfd_boolean *last_loc_is_prev_p,
7309 Elf_Internal_Rela *irel,
7310 int remaining_src_rels,
7311 source_reloc *rel,
7312 property_table_entry *prop_table,
7313 int ptblsize,
7314 section_cache_t *target_sec_cache,
7315 bfd_boolean is_abs_literal)
43cd72b9
BW		 7316{
7317 literal_value val;
7318 value_map *val_map;
7319 xtensa_relax_info *relax_info;
7320 bfd_boolean literal_placed = FALSE;
7321 r_reloc r_rel;
7322 unsigned long value;
7323 bfd_boolean final_static_link;
7324 bfd_size_type sec_size;
7325
7326 relax_info = get_xtensa_relax_info (sec);
7327 if (!relax_info)
7328 return FALSE;
7329
7330 sec_size = bfd_get_section_limit (abfd, sec);
7331
7332 final_static_link =
7333 (!link_info->relocatable
7334 && !elf_hash_table (link_info)->dynamic_sections_created);
7335
7336 /* The placement algorithm first checks to see if the literal is
7337 already in the value map. If so and the value map is reachable
7338 from all uses, then the literal is moved to that location. If
7339 not, then we identify the last location where a fresh literal was
7340 placed. If the literal can be safely moved there, then we do so.
7341 If not, then we assume that the literal is not to move and leave
7342 the literal where it is, marking it as the last literal
7343 location. */
7344
7345 /* Find the literal value. */
7346 value = 0;
7347 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7348 if (!irel)
7349 {
7350 BFD_ASSERT (rel->r_rel.target_offset < sec_size);
7351 value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
7352 }
7353 init_literal_value (&val, &r_rel, value, is_abs_literal);
7354
7355 /* Check if we've seen another literal with the same value that
7356 is in the same output section. */
7357 val_map = value_map_get_cached_value (values, &val, final_static_link);
7358
7359 if (val_map
7360 && (r_reloc_get_section (&val_map->loc)->output_section
7361 == sec->output_section)
7362 && relocations_reach (rel, remaining_src_rels, &val_map->loc)
7363 && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
7364 {
7365 /* No change to last_loc_is_prev. */
7366 literal_placed = TRUE;
7367 }
7368
7369 /* For relocatable links, do not try to move literals. To do it
7370 correctly might increase the number of relocations in an input
7371 section making the default relocatable linking fail. */
7372 if (!link_info->relocatable && !literal_placed
7373 && values->has_last_loc && !(*last_loc_is_prev_p))
7374 {
7375 asection *target_sec = r_reloc_get_section (&values->last_loc);
7376 if (target_sec && target_sec->output_section == sec->output_section)
7377 {
7378 /* Increment the virtual offset. */
7379 r_reloc try_loc = values->last_loc;
7380 try_loc.virtual_offset += 4;
7381
7382 /* There is a last loc that was in the same output section. */
7383 if (relocations_reach (rel, remaining_src_rels, &try_loc)
7384 && move_shared_literal (sec, link_info, rel,
7385 prop_table, ptblsize,
7386 &try_loc, &val, target_sec_cache))
e0001a05 7387 {
43cd72b9
BW		 7388 values->last_loc.virtual_offset += 4;
7389 literal_placed = TRUE;
7390 if (!val_map)
7391 val_map = add_value_map (values, &val, &try_loc,
7392 final_static_link);
7393 else
7394 val_map->loc = try_loc;
e0001a05
NC		 7395 }
7396 }
43cd72b9
BW		 7397 }
7398
7399 if (!literal_placed)
7400 {
7401 /* Nothing worked, leave the literal alone but update the last loc. */
7402 values->has_last_loc = TRUE;
7403 values->last_loc = rel->r_rel;
7404 if (!val_map)
7405 val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
e0001a05 7406 else
43cd72b9
BW		 7407 val_map->loc = rel->r_rel;
7408 *last_loc_is_prev_p = TRUE;
e0001a05
NC		 7409 }
7410
43cd72b9 7411 return TRUE;
e0001a05
NC		 7412}
7413
7414
7415/* Check if the original relocations (presumably on L32R instructions)
7416 identified by reloc[0..N] can be changed to reference the literal
7417 identified by r_rel. If r_rel is out of range for any of the
7418 original relocations, then we don't want to coalesce the original
7419 literal with the one at r_rel. We only check reloc[0..N], where the
7420 offsets are all the same as for reloc[0] (i.e., they're all
7421 referencing the same literal) and where N is also bounded by the
7422 number of remaining entries in the "reloc" array. The "reloc" array
7423 is sorted by target offset so we know all the entries for the same
7424 literal will be contiguous. */
7425
7426static bfd_boolean
7fa3d080
BW		 7427relocations_reach (source_reloc *reloc,
7428 int remaining_relocs,
7429 const r_reloc *r_rel)
e0001a05
NC		 7430{
7431 bfd_vma from_offset, source_address, dest_address;
7432 asection *sec;
7433 int i;
7434
7435 if (!r_reloc_is_defined (r_rel))
7436 return FALSE;
7437
7438 sec = r_reloc_get_section (r_rel);
7439 from_offset = reloc[0].r_rel.target_offset;
7440
7441 for (i = 0; i < remaining_relocs; i++)
7442 {
7443 if (reloc[i].r_rel.target_offset != from_offset)
7444 break;
7445
7446 /* Ignore relocations that have been removed. */
7447 if (reloc[i].is_null)
7448 continue;
7449
7450 /* The original and new output section for these must be the same
7451 in order to coalesce. */
7452 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
7453 != sec->output_section)
7454 return FALSE;
7455
43cd72b9
BW		 7456 /* A literal with no PC-relative relocations can be moved anywhere. */
7457 if (reloc[i].opnd != -1)
e0001a05
NC		 7458 {
7459 /* Otherwise, check to see that it fits. */
7460 source_address = (reloc[i].source_sec->output_section->vma
7461 + reloc[i].source_sec->output_offset
7462 + reloc[i].r_rel.rela.r_offset);
7463 dest_address = (sec->output_section->vma
7464 + sec->output_offset
7465 + r_rel->target_offset);
7466
43cd72b9
BW		 7467 if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
7468 source_address, dest_address))
e0001a05
NC		 7469 return FALSE;
7470 }
7471 }
7472
7473 return TRUE;
7474}
7475
7476
43cd72b9
BW		 7477/* Move a literal to another literal location because it is
7478 the same as the other literal value. */
e0001a05 7479
43cd72b9 7480static bfd_boolean
7fa3d080
BW		 7481coalesce_shared_literal (asection *sec,
7482 source_reloc *rel,
7483 property_table_entry *prop_table,
7484 int ptblsize,
7485 value_map *val_map)
e0001a05 7486{
43cd72b9
BW		 7487 property_table_entry *entry;
7488 text_action *fa;
7489 property_table_entry *the_add_entry;
7490 int removed_diff;
7491 xtensa_relax_info *relax_info;
7492
7493 relax_info = get_xtensa_relax_info (sec);
7494 if (!relax_info)
7495 return FALSE;
7496
7497 entry = elf_xtensa_find_property_entry
7498 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
7499 if (entry && (entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM))
7500 return TRUE;
7501
7502 /* Mark that the literal will be coalesced. */
7503 add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
7504
7505 text_action_add (&relax_info->action_list,
7506 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
7507
7508 /* If the section is 4-byte aligned, do not add fill. */
7509 if (sec->alignment_power > 2)
e0001a05 7510 {
43cd72b9
BW		 7511 int fill_extra_space;
7512 bfd_vma entry_sec_offset;
7513
7514 if (entry)
7515 entry_sec_offset = entry->address - sec->vma + entry->size;
7516 else
7517 entry_sec_offset = rel->r_rel.target_offset + 4;
7518
7519 /* If the literal range is at the end of the section,
7520 do not add fill. */
7521 fill_extra_space = 0;
7522 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7523 entry_sec_offset);
7524 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
7525 fill_extra_space = the_add_entry->size;
7526
7527 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
7528 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
7529 -4, fill_extra_space);
7530 if (fa)
7531 adjust_fill_action (fa, removed_diff);
7532 else
7533 text_action_add (&relax_info->action_list,
7534 ta_fill, sec, entry_sec_offset, removed_diff);
e0001a05 7535 }
43cd72b9
BW		 7536
7537 return TRUE;
7538}
7539
7540
7541/* Move a literal to another location. This may actually increase the
7542 total amount of space used because of alignments so we need to do
7543 this carefully. Also, it may make a branch go out of range. */
7544
7545static bfd_boolean
7fa3d080
BW		 7546move_shared_literal (asection *sec,
7547 struct bfd_link_info *link_info,
7548 source_reloc *rel,
7549 property_table_entry *prop_table,
7550 int ptblsize,
7551 const r_reloc *target_loc,
7552 const literal_value *lit_value,
7553 section_cache_t *target_sec_cache)
43cd72b9
BW		 7554{
7555 property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
7556 text_action *fa, *target_fa;
7557 int removed_diff;
7558 xtensa_relax_info *relax_info, *target_relax_info;
7559 asection *target_sec;
7560 ebb_t *ebb;
7561 ebb_constraint ebb_table;
7562 bfd_boolean relocs_fit;
7563
7564 /* If this routine always returns FALSE, the literals that cannot be
7565 coalesced will not be moved. */
7566 if (elf32xtensa_no_literal_movement)
7567 return FALSE;
7568
7569 relax_info = get_xtensa_relax_info (sec);
7570 if (!relax_info)
7571 return FALSE;
7572
7573 target_sec = r_reloc_get_section (target_loc);
7574 target_relax_info = get_xtensa_relax_info (target_sec);
7575
7576 /* Literals to undefined sections may not be moved because they
7577 must report an error. */
7578 if (bfd_is_und_section (target_sec))
7579 return FALSE;
7580
7581 src_entry = elf_xtensa_find_property_entry
7582 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
7583
7584 if (!section_cache_section (target_sec_cache, target_sec, link_info))
7585 return FALSE;
7586
7587 target_entry = elf_xtensa_find_property_entry
7588 (target_sec_cache->ptbl, target_sec_cache->pte_count,
7589 target_sec->vma + target_loc->target_offset);
7590
7591 if (!target_entry)
7592 return FALSE;
7593
7594 /* Make sure that we have not broken any branches. */
7595 relocs_fit = FALSE;
7596
7597 init_ebb_constraint (&ebb_table);
7598 ebb = &ebb_table.ebb;
7599 init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
7600 target_sec_cache->content_length,
7601 target_sec_cache->ptbl, target_sec_cache->pte_count,
7602 target_sec_cache->relocs, target_sec_cache->reloc_count);
7603
7604 /* Propose to add 4 bytes + worst-case alignment size increase to
7605 destination. */
7606 ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
7607 ta_fill, target_loc->target_offset,
7608 -4 - (1 << target_sec->alignment_power), TRUE);
7609
7610 /* Check all of the PC-relative relocations to make sure they still fit. */
7611 relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
7612 target_sec_cache->contents,
7613 target_sec_cache->relocs,
7614 &ebb_table);
7615
7616 if (!relocs_fit)
7617 return FALSE;
7618
7619 text_action_add_literal (&target_relax_info->action_list,
7620 ta_add_literal, target_loc, lit_value, -4);
7621
7622 if (target_sec->alignment_power > 2 && target_entry != src_entry)
7623 {
7624 /* May need to add or remove some fill to maintain alignment. */
7625 int fill_extra_space;
7626 bfd_vma entry_sec_offset;
7627
7628 entry_sec_offset =
7629 target_entry->address - target_sec->vma + target_entry->size;
7630
7631 /* If the literal range is at the end of the section,
7632 do not add fill. */
7633 fill_extra_space = 0;
7634 the_add_entry =
7635 elf_xtensa_find_property_entry (target_sec_cache->ptbl,
7636 target_sec_cache->pte_count,
7637 entry_sec_offset);
7638 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
7639 fill_extra_space = the_add_entry->size;
7640
7641 target_fa = find_fill_action (&target_relax_info->action_list,
7642 target_sec, entry_sec_offset);
7643 removed_diff = compute_removed_action_diff (target_fa, target_sec,
7644 entry_sec_offset, 4,
7645 fill_extra_space);
7646 if (target_fa)
7647 adjust_fill_action (target_fa, removed_diff);
7648 else
7649 text_action_add (&target_relax_info->action_list,
7650 ta_fill, target_sec, entry_sec_offset, removed_diff);
7651 }
7652
7653 /* Mark that the literal will be moved to the new location. */
7654 add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
7655
7656 /* Remove the literal. */
7657 text_action_add (&relax_info->action_list,
7658 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
7659
7660 /* If the section is 4-byte aligned, do not add fill. */
7661 if (sec->alignment_power > 2 && target_entry != src_entry)
7662 {
7663 int fill_extra_space;
7664 bfd_vma entry_sec_offset;
7665
7666 if (src_entry)
7667 entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
7668 else
7669 entry_sec_offset = rel->r_rel.target_offset+4;
7670
7671 /* If the literal range is at the end of the section,
7672 do not add fill. */
7673 fill_extra_space = 0;
7674 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7675 entry_sec_offset);
7676 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
7677 fill_extra_space = the_add_entry->size;
7678
7679 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
7680 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
7681 -4, fill_extra_space);
7682 if (fa)
7683 adjust_fill_action (fa, removed_diff);
7684 else
7685 text_action_add (&relax_info->action_list,
7686 ta_fill, sec, entry_sec_offset, removed_diff);
7687 }
7688
7689 return TRUE;
e0001a05
NC		 7690}
7691
7692\f
7693/* Second relaxation pass. */
7694
7695/* Modify all of the relocations to point to the right spot, and if this
7696 is a relaxable section, delete the unwanted literals and fix the
43cd72b9 7697 section size. */
e0001a05 7698
43cd72b9 7699bfd_boolean
7fa3d080 7700relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
e0001a05
NC		 7701{
7702 Elf_Internal_Rela *internal_relocs;
7703 xtensa_relax_info *relax_info;
7704 bfd_byte *contents;
7705 bfd_boolean ok = TRUE;
7706 unsigned i;
43cd72b9
BW		 7707 bfd_boolean rv = FALSE;
7708 bfd_boolean virtual_action;
7709 bfd_size_type sec_size;
e0001a05 7710
43cd72b9 7711 sec_size = bfd_get_section_limit (abfd, sec);
e0001a05
NC		 7712 relax_info = get_xtensa_relax_info (sec);
7713 BFD_ASSERT (relax_info);
7714
43cd72b9
BW		 7715 /* First translate any of the fixes that have been added already. */
7716 translate_section_fixes (sec);
7717
e0001a05
NC		 7718 /* Handle property sections (e.g., literal tables) specially. */
7719 if (xtensa_is_property_section (sec))
7720 {
7721 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
7722 return relax_property_section (abfd, sec, link_info);
7723 }
7724
43cd72b9
BW		 7725 internal_relocs = retrieve_internal_relocs (abfd, sec,
7726 link_info->keep_memory);
7727 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7728 if (contents == NULL && sec_size != 0)
7729 {
7730 ok = FALSE;
7731 goto error_return;
7732 }
7733
7734 if (internal_relocs)
7735 {
7736 for (i = 0; i < sec->reloc_count; i++)
7737 {
7738 Elf_Internal_Rela *irel;
7739 xtensa_relax_info *target_relax_info;
7740 bfd_vma source_offset, old_source_offset;
7741 r_reloc r_rel;
7742 unsigned r_type;
7743 asection *target_sec;
7744
7745 /* Locally change the source address.
7746 Translate the target to the new target address.
7747 If it points to this section and has been removed,
7748 NULLify it.
7749 Write it back. */
7750
7751 irel = &internal_relocs[i];
7752 source_offset = irel->r_offset;
7753 old_source_offset = source_offset;
7754
7755 r_type = ELF32_R_TYPE (irel->r_info);
7756 r_reloc_init (&r_rel, abfd, irel, contents,
7757 bfd_get_section_limit (abfd, sec));
7758
7759 /* If this section could have changed then we may need to
7760 change the relocation's offset. */
7761
7762 if (relax_info->is_relaxable_literal_section
7763 || relax_info->is_relaxable_asm_section)
7764 {
7765 if (r_type != R_XTENSA_NONE
7766 && find_removed_literal (&relax_info->removed_list,
7767 irel->r_offset))
7768 {
7769 /* Remove this relocation. */
7770 if (elf_hash_table (link_info)->dynamic_sections_created)
7771 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
7772 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7773 irel->r_offset = offset_with_removed_text
7774 (&relax_info->action_list, irel->r_offset);
7775 pin_internal_relocs (sec, internal_relocs);
7776 continue;
7777 }
7778
7779 if (r_type == R_XTENSA_ASM_SIMPLIFY)
7780 {
7781 text_action *action =
7782 find_insn_action (&relax_info->action_list,
7783 irel->r_offset);
7784 if (action && (action->action == ta_convert_longcall
7785 || action->action == ta_remove_longcall))
7786 {
7787 bfd_reloc_status_type retval;
7788 char *error_message = NULL;
7789
7790 retval = contract_asm_expansion (contents, sec_size,
7791 irel, &error_message);
7792 if (retval != bfd_reloc_ok)
7793 {
7794 (*link_info->callbacks->reloc_dangerous)
7795 (link_info, error_message, abfd, sec,
7796 irel->r_offset);
7797 goto error_return;
7798 }
7799 /* Update the action so that the code that moves
7800 the contents will do the right thing. */
7801 if (action->action == ta_remove_longcall)
7802 action->action = ta_remove_insn;
7803 else
7804 action->action = ta_none;
7805 /* Refresh the info in the r_rel. */
7806 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7807 r_type = ELF32_R_TYPE (irel->r_info);
7808 }
7809 }
7810
7811 source_offset = offset_with_removed_text
7812 (&relax_info->action_list, irel->r_offset);
7813 irel->r_offset = source_offset;
7814 }
7815
7816 /* If the target section could have changed then
7817 we may need to change the relocation's target offset. */
7818
7819 target_sec = r_reloc_get_section (&r_rel);
7820 target_relax_info = get_xtensa_relax_info (target_sec);
7821
7822 if (target_relax_info
7823 && (target_relax_info->is_relaxable_literal_section
7824 || target_relax_info->is_relaxable_asm_section))
7825 {
7826 r_reloc new_reloc;
7827 reloc_bfd_fix *fix;
7828 bfd_vma addend_displacement;
7829
7830 translate_reloc (&r_rel, &new_reloc);
7831
7832 if (r_type == R_XTENSA_DIFF8
7833 || r_type == R_XTENSA_DIFF16
7834 || r_type == R_XTENSA_DIFF32)
7835 {
7836 bfd_vma diff_value = 0, new_end_offset, diff_mask = 0;
7837
7838 if (bfd_get_section_limit (abfd, sec) < old_source_offset)
7839 {
7840 (*link_info->callbacks->reloc_dangerous)
7841 (link_info, _("invalid relocation address"),
7842 abfd, sec, old_source_offset);
7843 goto error_return;
7844 }
7845
7846 switch (r_type)
7847 {
7848 case R_XTENSA_DIFF8:
7849 diff_value =
7850 bfd_get_8 (abfd, &contents[old_source_offset]);
7851 break;
7852 case R_XTENSA_DIFF16:
7853 diff_value =
7854 bfd_get_16 (abfd, &contents[old_source_offset]);
7855 break;
7856 case R_XTENSA_DIFF32:
7857 diff_value =
7858 bfd_get_32 (abfd, &contents[old_source_offset]);
7859 break;
7860 }
7861
7862 new_end_offset = offset_with_removed_text
7863 (&target_relax_info->action_list,
7864 r_rel.target_offset + diff_value);
7865 diff_value = new_end_offset - new_reloc.target_offset;
7866
7867 switch (r_type)
7868 {
7869 case R_XTENSA_DIFF8:
7870 diff_mask = 0xff;
7871 bfd_put_8 (abfd, diff_value,
7872 &contents[old_source_offset]);
7873 break;
7874 case R_XTENSA_DIFF16:
7875 diff_mask = 0xffff;
7876 bfd_put_16 (abfd, diff_value,
7877 &contents[old_source_offset]);
7878 break;
7879 case R_XTENSA_DIFF32:
7880 diff_mask = 0xffffffff;
7881 bfd_put_32 (abfd, diff_value,
7882 &contents[old_source_offset]);
7883 break;
7884 }
7885
7886 /* Check for overflow. */
7887 if ((diff_value & ~diff_mask) != 0)
7888 {
7889 (*link_info->callbacks->reloc_dangerous)
7890 (link_info, _("overflow after relaxation"),
7891 abfd, sec, old_source_offset);
7892 goto error_return;
7893 }
7894
7895 pin_contents (sec, contents);
7896 }
7897
7898 /* FIXME: If the relocation still references a section in
7899 the same input file, the relocation should be modified
7900 directly instead of adding a "fix" record. */
7901
7902 addend_displacement =
7903 new_reloc.target_offset + new_reloc.virtual_offset;
7904
7905 fix = reloc_bfd_fix_init (sec, source_offset, r_type, 0,
7906 r_reloc_get_section (&new_reloc),
7907 addend_displacement, TRUE);
7908 add_fix (sec, fix);
7909 }
7910
7911 pin_internal_relocs (sec, internal_relocs);
7912 }
7913 }
7914
7915 if ((relax_info->is_relaxable_literal_section
7916 || relax_info->is_relaxable_asm_section)
7917 && relax_info->action_list.head)
7918 {
7919 /* Walk through the planned actions and build up a table
7920 of move, copy and fill records. Use the move, copy and
7921 fill records to perform the actions once. */
7922
7923 bfd_size_type size = sec->size;
7924 int removed = 0;
7925 bfd_size_type final_size, copy_size, orig_insn_size;
7926 bfd_byte *scratch = NULL;
7927 bfd_byte *dup_contents = NULL;
7928 bfd_size_type orig_size = size;
7929 bfd_vma orig_dot = 0;
7930 bfd_vma orig_dot_copied = 0; /* Byte copied already from
7931 orig dot in physical memory. */
7932 bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
7933 bfd_vma dup_dot = 0;
7934
7935 text_action *action = relax_info->action_list.head;
7936
7937 final_size = sec->size;
7938 for (action = relax_info->action_list.head; action;
7939 action = action->next)
7940 {
7941 final_size -= action->removed_bytes;
7942 }
7943
7944 scratch = (bfd_byte *) bfd_zmalloc (final_size);
7945 dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
7946
7947 /* The dot is the current fill location. */
7948#if DEBUG
7949 print_action_list (stderr, &relax_info->action_list);
7950#endif
7951
7952 for (action = relax_info->action_list.head; action;
7953 action = action->next)
7954 {
7955 virtual_action = FALSE;
7956 if (action->offset > orig_dot)
7957 {
7958 orig_dot += orig_dot_copied;
7959 orig_dot_copied = 0;
7960 orig_dot_vo = 0;
7961 /* Out of the virtual world. */
7962 }
7963
7964 if (action->offset > orig_dot)
7965 {
7966 copy_size = action->offset - orig_dot;
7967 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
7968 orig_dot += copy_size;
7969 dup_dot += copy_size;
7970 BFD_ASSERT (action->offset == orig_dot);
7971 }
7972 else if (action->offset < orig_dot)
7973 {
7974 if (action->action == ta_fill
7975 && action->offset - action->removed_bytes == orig_dot)
7976 {
7977 /* This is OK because the fill only effects the dup_dot. */
7978 }
7979 else if (action->action == ta_add_literal)
7980 {
7981 /* TBD. Might need to handle this. */
7982 }
7983 }
7984 if (action->offset == orig_dot)
7985 {
7986 if (action->virtual_offset > orig_dot_vo)
7987 {
7988 if (orig_dot_vo == 0)
7989 {
7990 /* Need to copy virtual_offset bytes. Probably four. */
7991 copy_size = action->virtual_offset - orig_dot_vo;
7992 memmove (&dup_contents[dup_dot],
7993 &contents[orig_dot], copy_size);
7994 orig_dot_copied = copy_size;
7995 dup_dot += copy_size;
7996 }
7997 virtual_action = TRUE;
7998 }
7999 else
8000 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
8001 }
8002 switch (action->action)
8003 {
8004 case ta_remove_literal:
8005 case ta_remove_insn:
8006 BFD_ASSERT (action->removed_bytes >= 0);
8007 orig_dot += action->removed_bytes;
8008 break;
8009
8010 case ta_narrow_insn:
8011 orig_insn_size = 3;
8012 copy_size = 2;
8013 memmove (scratch, &contents[orig_dot], orig_insn_size);
8014 BFD_ASSERT (action->removed_bytes == 1);
8015 rv = narrow_instruction (scratch, final_size, 0, TRUE);
8016 BFD_ASSERT (rv);
8017 memmove (&dup_contents[dup_dot], scratch, copy_size);
8018 orig_dot += orig_insn_size;
8019 dup_dot += copy_size;
8020 break;
8021
8022 case ta_fill:
8023 if (action->removed_bytes >= 0)
8024 orig_dot += action->removed_bytes;
8025 else
8026 {
8027 /* Already zeroed in dup_contents. Just bump the
8028 counters. */
8029 dup_dot += (-action->removed_bytes);
8030 }
8031 break;
8032
8033 case ta_none:
8034 BFD_ASSERT (action->removed_bytes == 0);
8035 break;
8036
8037 case ta_convert_longcall:
8038 case ta_remove_longcall:
8039 /* These will be removed or converted before we get here. */
8040 BFD_ASSERT (0);
8041 break;
8042
8043 case ta_widen_insn:
8044 orig_insn_size = 2;
8045 copy_size = 3;
8046 memmove (scratch, &contents[orig_dot], orig_insn_size);
8047 BFD_ASSERT (action->removed_bytes == -1);
8048 rv = widen_instruction (scratch, final_size, 0, TRUE);
8049 BFD_ASSERT (rv);
8050 memmove (&dup_contents[dup_dot], scratch, copy_size);
8051 orig_dot += orig_insn_size;
8052 dup_dot += copy_size;
8053 break;
8054
8055 case ta_add_literal:
8056 orig_insn_size = 0;
8057 copy_size = 4;
8058 BFD_ASSERT (action->removed_bytes == -4);
8059 /* TBD -- place the literal value here and insert
8060 into the table. */
8061 memset (&dup_contents[dup_dot], 0, 4);
8062 pin_internal_relocs (sec, internal_relocs);
8063 pin_contents (sec, contents);
8064
8065 if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
8066 relax_info, &internal_relocs, &action->value))
8067 goto error_return;
8068
8069 if (virtual_action)
8070 orig_dot_vo += copy_size;
8071
8072 orig_dot += orig_insn_size;
8073 dup_dot += copy_size;
8074 break;
8075
8076 default:
8077 /* Not implemented yet. */
8078 BFD_ASSERT (0);
8079 break;
8080 }
8081
8082 size -= action->removed_bytes;
8083 removed += action->removed_bytes;
8084 BFD_ASSERT (dup_dot <= final_size);
8085 BFD_ASSERT (orig_dot <= orig_size);
8086 }
8087
8088 orig_dot += orig_dot_copied;
8089 orig_dot_copied = 0;
8090
8091 if (orig_dot != orig_size)
8092 {
8093 copy_size = orig_size - orig_dot;
8094 BFD_ASSERT (orig_size > orig_dot);
8095 BFD_ASSERT (dup_dot + copy_size == final_size);
8096 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
8097 orig_dot += copy_size;
8098 dup_dot += copy_size;
8099 }
8100 BFD_ASSERT (orig_size == orig_dot);
8101 BFD_ASSERT (final_size == dup_dot);
8102
8103 /* Move the dup_contents back. */
8104 if (final_size > orig_size)
8105 {
8106 /* Contents need to be reallocated. Swap the dup_contents into
8107 contents. */
8108 sec->contents = dup_contents;
8109 free (contents);
8110 contents = dup_contents;
8111 pin_contents (sec, contents);
8112 }
8113 else
8114 {
8115 BFD_ASSERT (final_size <= orig_size);
8116 memset (contents, 0, orig_size);
8117 memcpy (contents, dup_contents, final_size);
8118 free (dup_contents);
8119 }
8120 free (scratch);
8121 pin_contents (sec, contents);
8122
8123 sec->size = final_size;
8124 }
8125
8126 error_return:
8127 release_internal_relocs (sec, internal_relocs);
8128 release_contents (sec, contents);
8129 return ok;
8130}
8131
8132
8133static bfd_boolean
7fa3d080 8134translate_section_fixes (asection *sec)
43cd72b9
BW		 8135{
8136 xtensa_relax_info *relax_info;
8137 reloc_bfd_fix *r;
8138
8139 relax_info = get_xtensa_relax_info (sec);
8140 if (!relax_info)
8141 return TRUE;
8142
8143 for (r = relax_info->fix_list; r != NULL; r = r->next)
8144 if (!translate_reloc_bfd_fix (r))
8145 return FALSE;
e0001a05 8146
43cd72b9
BW		 8147 return TRUE;
8148}
e0001a05 8149
e0001a05 8150
43cd72b9
BW		 8151/* Translate a fix given the mapping in the relax info for the target
8152 section. If it has already been translated, no work is required. */
e0001a05 8153
43cd72b9 8154static bfd_boolean
7fa3d080 8155translate_reloc_bfd_fix (reloc_bfd_fix *fix)
43cd72b9
BW		 8156{
8157 reloc_bfd_fix new_fix;
8158 asection *sec;
8159 xtensa_relax_info *relax_info;
8160 removed_literal *removed;
8161 bfd_vma new_offset, target_offset;
e0001a05 8162
43cd72b9
BW		 8163 if (fix->translated)
8164 return TRUE;
e0001a05 8165
43cd72b9
BW		 8166 sec = fix->target_sec;
8167 target_offset = fix->target_offset;
e0001a05 8168
43cd72b9
BW		 8169 relax_info = get_xtensa_relax_info (sec);
8170 if (!relax_info)
8171 {
8172 fix->translated = TRUE;
8173 return TRUE;
8174 }
e0001a05 8175
43cd72b9 8176 new_fix = *fix;
e0001a05 8177
43cd72b9
BW		 8178 /* The fix does not need to be translated if the section cannot change. */
8179 if (!relax_info->is_relaxable_literal_section
8180 && !relax_info->is_relaxable_asm_section)
8181 {
8182 fix->translated = TRUE;
8183 return TRUE;
8184 }
e0001a05 8185
43cd72b9
BW		 8186 /* If the literal has been moved and this relocation was on an
8187 opcode, then the relocation should move to the new literal
8188 location. Otherwise, the relocation should move within the
8189 section. */
8190
8191 removed = FALSE;
8192 if (is_operand_relocation (fix->src_type))
8193 {
8194 /* Check if the original relocation is against a literal being
8195 removed. */
8196 removed = find_removed_literal (&relax_info->removed_list,
8197 target_offset);
e0001a05
NC		 8198 }
8199
43cd72b9 8200 if (removed)
e0001a05 8201 {
43cd72b9 8202 asection *new_sec;
e0001a05 8203
43cd72b9
BW		 8204 /* The fact that there is still a relocation to this literal indicates
8205 that the literal is being coalesced, not simply removed. */
8206 BFD_ASSERT (removed->to.abfd != NULL);
e0001a05 8207
43cd72b9
BW		 8208 /* This was moved to some other address (possibly another section). */
8209 new_sec = r_reloc_get_section (&removed->to);
8210 if (new_sec != sec)
e0001a05 8211 {
43cd72b9
BW		 8212 sec = new_sec;
8213 relax_info = get_xtensa_relax_info (sec);
8214 if (!relax_info ||
8215 (!relax_info->is_relaxable_literal_section
8216 && !relax_info->is_relaxable_asm_section))
e0001a05 8217 {
43cd72b9
BW		 8218 target_offset = removed->to.target_offset;
8219 new_fix.target_sec = new_sec;
8220 new_fix.target_offset = target_offset;
8221 new_fix.translated = TRUE;
8222 *fix = new_fix;
8223 return TRUE;
e0001a05 8224 }
e0001a05 8225 }
43cd72b9
BW		 8226 target_offset = removed->to.target_offset;
8227 new_fix.target_sec = new_sec;
e0001a05 8228 }
43cd72b9
BW		 8229
8230 /* The target address may have been moved within its section. */
8231 new_offset = offset_with_removed_text (&relax_info->action_list,
8232 target_offset);
8233
8234 new_fix.target_offset = new_offset;
8235 new_fix.target_offset = new_offset;
8236 new_fix.translated = TRUE;
8237 *fix = new_fix;
8238 return TRUE;
e0001a05
NC		 8239}
8240
8241
8242/* Fix up a relocation to take account of removed literals. */
8243
8244static void
7fa3d080 8245translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel)
e0001a05
NC		 8246{
8247 asection *sec;
8248 xtensa_relax_info *relax_info;
8249 removed_literal *removed;
43cd72b9 8250 bfd_vma new_offset, target_offset, removed_bytes;
e0001a05
NC		 8251
8252 *new_rel = *orig_rel;
8253
8254 if (!r_reloc_is_defined (orig_rel))
8255 return;
8256 sec = r_reloc_get_section (orig_rel);
8257
8258 relax_info = get_xtensa_relax_info (sec);
8259 BFD_ASSERT (relax_info);
8260
43cd72b9
BW		 8261 if (!relax_info->is_relaxable_literal_section
8262 && !relax_info->is_relaxable_asm_section)
e0001a05
NC		 8263 return;
8264
43cd72b9
BW		 8265 target_offset = orig_rel->target_offset;
8266
8267 removed = FALSE;
8268 if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
8269 {
8270 /* Check if the original relocation is against a literal being
8271 removed. */
8272 removed = find_removed_literal (&relax_info->removed_list,
8273 target_offset);
8274 }
8275 if (removed && removed->to.abfd)
e0001a05
NC		 8276 {
8277 asection *new_sec;
8278
8279 /* The fact that there is still a relocation to this literal indicates
8280 that the literal is being coalesced, not simply removed. */
8281 BFD_ASSERT (removed->to.abfd != NULL);
8282
43cd72b9
BW		 8283 /* This was moved to some other address
8284 (possibly in another section). */
e0001a05
NC		 8285 *new_rel = removed->to;
8286 new_sec = r_reloc_get_section (new_rel);
43cd72b9 8287 if (new_sec != sec)
e0001a05
NC		 8288 {
8289 sec = new_sec;
8290 relax_info = get_xtensa_relax_info (sec);
43cd72b9
BW		 8291 if (!relax_info
8292 || (!relax_info->is_relaxable_literal_section
8293 && !relax_info->is_relaxable_asm_section))
e0001a05
NC		 8294 return;
8295 }
43cd72b9 8296 target_offset = new_rel->target_offset;
e0001a05
NC		 8297 }
8298
8299 /* ...and the target address may have been moved within its section. */
43cd72b9
BW		 8300 new_offset = offset_with_removed_text (&relax_info->action_list,
8301 target_offset);
e0001a05
NC		 8302
8303 /* Modify the offset and addend. */
43cd72b9 8304 removed_bytes = target_offset - new_offset;
e0001a05 8305 new_rel->target_offset = new_offset;
43cd72b9 8306 new_rel->rela.r_addend -= removed_bytes;
e0001a05
NC		 8307}
8308
8309
8310/* For dynamic links, there may be a dynamic relocation for each
8311 literal. The number of dynamic relocations must be computed in
8312 size_dynamic_sections, which occurs before relaxation. When a
8313 literal is removed, this function checks if there is a corresponding
8314 dynamic relocation and shrinks the size of the appropriate dynamic
8315 relocation section accordingly. At this point, the contents of the
8316 dynamic relocation sections have not yet been filled in, so there's
8317 nothing else that needs to be done. */
8318
8319static void
7fa3d080
BW		 8320shrink_dynamic_reloc_sections (struct bfd_link_info *info,
8321 bfd *abfd,
8322 asection *input_section,
8323 Elf_Internal_Rela *rel)
e0001a05
NC		 8324{
8325 Elf_Internal_Shdr *symtab_hdr;
8326 struct elf_link_hash_entry **sym_hashes;
8327 unsigned long r_symndx;
8328 int r_type;
8329 struct elf_link_hash_entry *h;
8330 bfd_boolean dynamic_symbol;
8331
8332 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8333 sym_hashes = elf_sym_hashes (abfd);
8334
8335 r_type = ELF32_R_TYPE (rel->r_info);
8336 r_symndx = ELF32_R_SYM (rel->r_info);
8337
8338 if (r_symndx < symtab_hdr->sh_info)
8339 h = NULL;
8340 else
8341 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8342
571b5725 8343 dynamic_symbol = xtensa_elf_dynamic_symbol_p (h, info);
e0001a05
NC		 8344
8345 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
8346 && (input_section->flags & SEC_ALLOC) != 0
8347 && (dynamic_symbol || info->shared))
8348 {
8349 bfd *dynobj;
8350 const char *srel_name;
8351 asection *srel;
8352 bfd_boolean is_plt = FALSE;
8353
8354 dynobj = elf_hash_table (info)->dynobj;
8355 BFD_ASSERT (dynobj != NULL);
8356
8357 if (dynamic_symbol && r_type == R_XTENSA_PLT)
8358 {
8359 srel_name = ".rela.plt";
8360 is_plt = TRUE;
8361 }
8362 else
8363 srel_name = ".rela.got";
8364
8365 /* Reduce size of the .rela.* section by one reloc. */
8366 srel = bfd_get_section_by_name (dynobj, srel_name);
8367 BFD_ASSERT (srel != NULL);
eea6121a
AM		 8368 BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
8369 srel->size -= sizeof (Elf32_External_Rela);
e0001a05
NC		 8370
8371 if (is_plt)
8372 {
8373 asection *splt, *sgotplt, *srelgot;
8374 int reloc_index, chunk;
8375
8376 /* Find the PLT reloc index of the entry being removed. This
8377 is computed from the size of ".rela.plt". It is needed to
8378 figure out which PLT chunk to resize. Usually "last index
8379 = size - 1" since the index starts at zero, but in this
8380 context, the size has just been decremented so there's no
8381 need to subtract one. */
eea6121a 8382 reloc_index = srel->size / sizeof (Elf32_External_Rela);
e0001a05
NC		 8383
8384 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
8385 splt = elf_xtensa_get_plt_section (dynobj, chunk);
8386 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
8387 BFD_ASSERT (splt != NULL && sgotplt != NULL);
8388
8389 /* Check if an entire PLT chunk has just been eliminated. */
8390 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
8391 {
8392 /* The two magic GOT entries for that chunk can go away. */
8393 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
8394 BFD_ASSERT (srelgot != NULL);
8395 srelgot->reloc_count -= 2;
eea6121a
AM		 8396 srelgot->size -= 2 * sizeof (Elf32_External_Rela);
8397 sgotplt->size -= 8;
e0001a05
NC		 8398
8399 /* There should be only one entry left (and it will be
8400 removed below). */
eea6121a
AM		 8401 BFD_ASSERT (sgotplt->size == 4);
8402 BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
e0001a05
NC		 8403 }
8404
eea6121a
AM		 8405 BFD_ASSERT (sgotplt->size >= 4);
8406 BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
e0001a05 8407
eea6121a
AM		 8408 sgotplt->size -= 4;
8409 splt->size -= PLT_ENTRY_SIZE;
e0001a05
NC		 8410 }
8411 }
8412}
8413
8414
43cd72b9
BW		 8415/* Take an r_rel and move it to another section. This usually
8416 requires extending the interal_relocation array and pinning it. If
8417 the original r_rel is from the same BFD, we can complete this here.
8418 Otherwise, we add a fix record to let the final link fix the
8419 appropriate address. Contents and internal relocations for the
8420 section must be pinned after calling this routine. */
8421
8422static bfd_boolean
7fa3d080
BW		 8423move_literal (bfd *abfd,
8424 struct bfd_link_info *link_info,
8425 asection *sec,
8426 bfd_vma offset,
8427 bfd_byte *contents,
8428 xtensa_relax_info *relax_info,
8429 Elf_Internal_Rela **internal_relocs_p,
8430 const literal_value *lit)
43cd72b9
BW		 8431{
8432 Elf_Internal_Rela *new_relocs = NULL;
8433 size_t new_relocs_count = 0;
8434 Elf_Internal_Rela this_rela;
8435 const r_reloc *r_rel;
8436
8437 r_rel = &lit->r_rel;
8438 BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
8439
8440 if (r_reloc_is_const (r_rel))
8441 bfd_put_32 (abfd, lit->value, contents + offset);
8442 else
8443 {
8444 int r_type;
8445 unsigned i;
8446 asection *target_sec;
8447 reloc_bfd_fix *fix;
8448 unsigned insert_at;
8449
8450 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
8451 target_sec = r_reloc_get_section (r_rel);
8452
8453 /* This is the difficult case. We have to create a fix up. */
8454 this_rela.r_offset = offset;
8455 this_rela.r_info = ELF32_R_INFO (0, r_type);
8456 this_rela.r_addend =
8457 r_rel->target_offset - r_reloc_get_target_offset (r_rel);
8458 bfd_put_32 (abfd, lit->value, contents + offset);
8459
8460 /* Currently, we cannot move relocations during a relocatable link. */
8461 BFD_ASSERT (!link_info->relocatable);
8462 fix = reloc_bfd_fix_init (sec, offset, r_type, r_rel->abfd,
8463 r_reloc_get_section (r_rel),
8464 r_rel->target_offset + r_rel->virtual_offset,
8465 FALSE);
8466 /* We also need to mark that relocations are needed here. */
8467 sec->flags |= SEC_RELOC;
8468
8469 translate_reloc_bfd_fix (fix);
8470 /* This fix has not yet been translated. */
8471 add_fix (sec, fix);
8472
8473 /* Add the relocation. If we have already allocated our own
8474 space for the relocations and we have room for more, then use
8475 it. Otherwise, allocate new space and move the literals. */
8476 insert_at = sec->reloc_count;
8477 for (i = 0; i < sec->reloc_count; ++i)
8478 {
8479 if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
8480 {
8481 insert_at = i;
8482 break;
8483 }
8484 }
8485
8486 if (*internal_relocs_p != relax_info->allocated_relocs
8487 || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
8488 {
8489 BFD_ASSERT (relax_info->allocated_relocs == NULL
8490 || sec->reloc_count == relax_info->relocs_count);
8491
8492 if (relax_info->allocated_relocs_count == 0)
8493 new_relocs_count = (sec->reloc_count + 2) * 2;
8494 else
8495 new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
8496
8497 new_relocs = (Elf_Internal_Rela *)
8498 bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
8499 if (!new_relocs)
8500 return FALSE;
8501
8502 /* We could handle this more quickly by finding the split point. */
8503 if (insert_at != 0)
8504 memcpy (new_relocs, *internal_relocs_p,
8505 insert_at * sizeof (Elf_Internal_Rela));
8506
8507 new_relocs[insert_at] = this_rela;
8508
8509 if (insert_at != sec->reloc_count)
8510 memcpy (new_relocs + insert_at + 1,
8511 (*internal_relocs_p) + insert_at,
8512 (sec->reloc_count - insert_at)
8513 * sizeof (Elf_Internal_Rela));
8514
8515 if (*internal_relocs_p != relax_info->allocated_relocs)
8516 {
8517 /* The first time we re-allocate, we can only free the
8518 old relocs if they were allocated with bfd_malloc.
8519 This is not true when keep_memory is in effect. */
8520 if (!link_info->keep_memory)
8521 free (*internal_relocs_p);
8522 }
8523 else
8524 free (*internal_relocs_p);
8525 relax_info->allocated_relocs = new_relocs;
8526 relax_info->allocated_relocs_count = new_relocs_count;
8527 elf_section_data (sec)->relocs = new_relocs;
8528 sec->reloc_count++;
8529 relax_info->relocs_count = sec->reloc_count;
8530 *internal_relocs_p = new_relocs;
8531 }
8532 else
8533 {
8534 if (insert_at != sec->reloc_count)
8535 {
8536 unsigned idx;
8537 for (idx = sec->reloc_count; idx > insert_at; idx--)
8538 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
8539 }
8540 (*internal_relocs_p)[insert_at] = this_rela;
8541 sec->reloc_count++;
8542 if (relax_info->allocated_relocs)
8543 relax_info->relocs_count = sec->reloc_count;
8544 }
8545 }
8546 return TRUE;
8547}
8548
8549
e0001a05
NC		 8550/* This is similar to relax_section except that when a target is moved,
8551 we shift addresses up. We also need to modify the size. This
8552 algorithm does NOT allow for relocations into the middle of the
8553 property sections. */
8554
43cd72b9 8555static bfd_boolean
7fa3d080
BW		 8556relax_property_section (bfd *abfd,
8557 asection *sec,
8558 struct bfd_link_info *link_info)
e0001a05
NC		 8559{
8560 Elf_Internal_Rela *internal_relocs;
8561 bfd_byte *contents;
8562 unsigned i, nexti;
8563 bfd_boolean ok = TRUE;
43cd72b9
BW		 8564 bfd_boolean is_full_prop_section;
8565 size_t last_zfill_target_offset = 0;
8566 asection *last_zfill_target_sec = NULL;
8567 bfd_size_type sec_size;
e0001a05 8568
43cd72b9 8569 sec_size = bfd_get_section_limit (abfd, sec);
e0001a05
NC		 8570 internal_relocs = retrieve_internal_relocs (abfd, sec,
8571 link_info->keep_memory);
8572 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
43cd72b9 8573 if (contents == NULL && sec_size != 0)
e0001a05
NC		 8574 {
8575 ok = FALSE;
8576 goto error_return;
8577 }
8578
43cd72b9
BW		 8579 is_full_prop_section =
8580 ((strcmp (sec->name, XTENSA_PROP_SEC_NAME) == 0)
8581 || (strncmp (sec->name, ".gnu.linkonce.prop.",
8582 sizeof ".gnu.linkonce.prop." - 1) == 0));
8583
8584 if (internal_relocs)
e0001a05 8585 {
43cd72b9 8586 for (i = 0; i < sec->reloc_count; i++)
e0001a05
NC		 8587 {
8588 Elf_Internal_Rela *irel;
8589 xtensa_relax_info *target_relax_info;
e0001a05
NC		 8590 unsigned r_type;
8591 asection *target_sec;
43cd72b9
BW		 8592 literal_value val;
8593 bfd_byte *size_p, *flags_p;
e0001a05
NC		 8594
8595 /* Locally change the source address.
8596 Translate the target to the new target address.
8597 If it points to this section and has been removed, MOVE IT.
8598 Also, don't forget to modify the associated SIZE at
8599 (offset + 4). */
8600
8601 irel = &internal_relocs[i];
8602 r_type = ELF32_R_TYPE (irel->r_info);
8603 if (r_type == R_XTENSA_NONE)
8604 continue;
8605
43cd72b9
BW		 8606 /* Find the literal value. */
8607 r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
8608 size_p = &contents[irel->r_offset + 4];
8609 flags_p = NULL;
8610 if (is_full_prop_section)
8611 {
8612 flags_p = &contents[irel->r_offset + 8];
8613 BFD_ASSERT (irel->r_offset + 12 <= sec_size);
8614 }
8615 else
8616 BFD_ASSERT (irel->r_offset + 8 <= sec_size);
e0001a05 8617
43cd72b9 8618 target_sec = r_reloc_get_section (&val.r_rel);
e0001a05
NC		 8619 target_relax_info = get_xtensa_relax_info (target_sec);
8620
8621 if (target_relax_info
43cd72b9
BW		 8622 && (target_relax_info->is_relaxable_literal_section
8623 || target_relax_info->is_relaxable_asm_section ))
e0001a05
NC		 8624 {
8625 /* Translate the relocation's destination. */
43cd72b9 8626 bfd_vma new_offset, new_end_offset;
e0001a05
NC		 8627 long old_size, new_size;
8628
43cd72b9
BW		 8629 new_offset = offset_with_removed_text
8630 (&target_relax_info->action_list, val.r_rel.target_offset);
e0001a05
NC		 8631
8632 /* Assert that we are not out of bounds. */
43cd72b9
BW		 8633 old_size = bfd_get_32 (abfd, size_p);
8634
8635 if (old_size == 0)
8636 {
8637 /* Only the first zero-sized unreachable entry is
8638 allowed to expand. In this case the new offset
8639 should be the offset before the fill and the new
8640 size is the expansion size. For other zero-sized
8641 entries the resulting size should be zero with an
8642 offset before or after the fill address depending
8643 on whether the expanding unreachable entry
8644 preceeds it. */
8645 if (last_zfill_target_sec
8646 && last_zfill_target_sec == target_sec
8647 && last_zfill_target_offset == val.r_rel.target_offset)
8648 new_end_offset = new_offset;
8649 else
8650 {
8651 new_end_offset = new_offset;
8652 new_offset = offset_with_removed_text_before_fill
8653 (&target_relax_info->action_list,
8654 val.r_rel.target_offset);
8655
8656 /* If it is not unreachable and we have not yet
8657 seen an unreachable at this address, place it
8658 before the fill address. */
8659 if (!flags_p
8660 || (bfd_get_32 (abfd, flags_p)
8661 & XTENSA_PROP_UNREACHABLE) == 0)
8662 new_end_offset = new_offset;
8663 else
8664 {
8665 last_zfill_target_sec = target_sec;
8666 last_zfill_target_offset = val.r_rel.target_offset;
8667 }
8668 }
8669 }
8670 else
8671 {
8672 new_end_offset = offset_with_removed_text_before_fill
8673 (&target_relax_info->action_list,
8674 val.r_rel.target_offset + old_size);
8675 }
e0001a05 8676
e0001a05 8677 new_size = new_end_offset - new_offset;
43cd72b9 8678
e0001a05
NC		 8679 if (new_size != old_size)
8680 {
8681 bfd_put_32 (abfd, new_size, size_p);
8682 pin_contents (sec, contents);
8683 }
43cd72b9
BW		 8684
8685 if (new_offset != val.r_rel.target_offset)
e0001a05 8686 {
43cd72b9 8687 bfd_vma diff = new_offset - val.r_rel.target_offset;
e0001a05
NC		 8688 irel->r_addend += diff;
8689 pin_internal_relocs (sec, internal_relocs);
8690 }
8691 }
8692 }
8693 }
8694
8695 /* Combine adjacent property table entries. This is also done in
8696 finish_dynamic_sections() but at that point it's too late to
8697 reclaim the space in the output section, so we do this twice. */
8698
43cd72b9
BW		 8699 if (internal_relocs && (!link_info->relocatable
8700 || strcmp (sec->name, XTENSA_LIT_SEC_NAME) == 0))
e0001a05
NC		 8701 {
8702 Elf_Internal_Rela *last_irel = NULL;
8703 int removed_bytes = 0;
8704 bfd_vma offset, last_irel_offset;
8705 bfd_vma section_size;
43cd72b9
BW		 8706 bfd_size_type entry_size;
8707 flagword predef_flags;
8708
8709 if (is_full_prop_section)
8710 entry_size = 12;
8711 else
8712 entry_size = 8;
8713
8714 predef_flags = xtensa_get_property_predef_flags (sec);
e0001a05
NC		 8715
8716 /* Walk over memory and irels at the same time.
8717 This REQUIRES that the internal_relocs be sorted by offset. */
8718 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
8719 internal_reloc_compare);
8720 nexti = 0; /* Index into internal_relocs. */
8721
8722 pin_internal_relocs (sec, internal_relocs);
8723 pin_contents (sec, contents);
8724
8725 last_irel_offset = (bfd_vma) -1;
eea6121a 8726 section_size = sec->size;
43cd72b9 8727 BFD_ASSERT (section_size % entry_size == 0);
e0001a05 8728
43cd72b9 8729 for (offset = 0; offset < section_size; offset += entry_size)
e0001a05
NC		 8730 {
8731 Elf_Internal_Rela *irel, *next_irel;
8732 bfd_vma bytes_to_remove, size, actual_offset;
8733 bfd_boolean remove_this_irel;
43cd72b9 8734 flagword flags;
e0001a05
NC		 8735
8736 irel = NULL;
8737 next_irel = NULL;
8738
8739 /* Find the next two relocations (if there are that many left),
8740 skipping over any R_XTENSA_NONE relocs. On entry, "nexti" is
8741 the starting reloc index. After these two loops, "i"
8742 is the index of the first non-NONE reloc past that starting
8743 index, and "nexti" is the index for the next non-NONE reloc
8744 after "i". */
8745
8746 for (i = nexti; i < sec->reloc_count; i++)
8747 {
8748 if (ELF32_R_TYPE (internal_relocs[i].r_info) != R_XTENSA_NONE)
8749 {
8750 irel = &internal_relocs[i];
8751 break;
8752 }
8753 internal_relocs[i].r_offset -= removed_bytes;
8754 }
8755
8756 for (nexti = i + 1; nexti < sec->reloc_count; nexti++)
8757 {
8758 if (ELF32_R_TYPE (internal_relocs[nexti].r_info)
8759 != R_XTENSA_NONE)
8760 {
8761 next_irel = &internal_relocs[nexti];
8762 break;
8763 }
8764 internal_relocs[nexti].r_offset -= removed_bytes;
8765 }
8766
8767 remove_this_irel = FALSE;
8768 bytes_to_remove = 0;
8769 actual_offset = offset - removed_bytes;
8770 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
8771
43cd72b9
BW		 8772 if (is_full_prop_section)
8773 flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
8774 else
8775 flags = predef_flags;
8776
e0001a05
NC		 8777 /* Check that the irels are sorted by offset,
8778 with only one per address. */
8779 BFD_ASSERT (!irel || (int) irel->r_offset > (int) last_irel_offset);
8780 BFD_ASSERT (!next_irel || next_irel->r_offset > irel->r_offset);
8781
43cd72b9
BW		 8782 /* Make sure there aren't relocs on the size or flag fields. */
8783 if ((irel && irel->r_offset == offset + 4)
8784 || (is_full_prop_section
8785 && irel && irel->r_offset == offset + 8))
e0001a05
NC		 8786 {
8787 irel->r_offset -= removed_bytes;
8788 last_irel_offset = irel->r_offset;
8789 }
43cd72b9
BW		 8790 else if (next_irel && (next_irel->r_offset == offset + 4
8791 || (is_full_prop_section
8792 && next_irel->r_offset == offset + 8)))
e0001a05
NC		 8793 {
8794 nexti += 1;
8795 irel->r_offset -= removed_bytes;
8796 next_irel->r_offset -= removed_bytes;
8797 last_irel_offset = next_irel->r_offset;
8798 }
43cd72b9
BW		 8799 else if (size == 0 && (flags & XTENSA_PROP_ALIGN) == 0
8800 && (flags & XTENSA_PROP_UNREACHABLE) == 0)
e0001a05 8801 {
43cd72b9
BW		 8802 /* Always remove entries with zero size and no alignment. */
8803 bytes_to_remove = entry_size;
e0001a05
NC		 8804 if (irel && irel->r_offset == offset)
8805 {
8806 remove_this_irel = TRUE;
8807
8808 irel->r_offset -= removed_bytes;
8809 last_irel_offset = irel->r_offset;
8810 }
8811 }
8812 else if (irel && irel->r_offset == offset)
8813 {
8814 if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32)
8815 {
8816 if (last_irel)
8817 {
43cd72b9
BW		 8818 flagword old_flags;
8819 bfd_vma old_size =
e0001a05 8820 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
43cd72b9
BW		 8821 bfd_vma old_address =
8822 (last_irel->r_addend
e0001a05 8823 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
43cd72b9
BW		 8824 bfd_vma new_address =
8825 (irel->r_addend
e0001a05 8826 + bfd_get_32 (abfd, &contents[actual_offset]));
43cd72b9
BW		 8827 if (is_full_prop_section)
8828 old_flags = bfd_get_32
8829 (abfd, &contents[last_irel->r_offset + 8]);
8830 else
8831 old_flags = predef_flags;
8832
8833 if ((ELF32_R_SYM (irel->r_info)
8834 == ELF32_R_SYM (last_irel->r_info))
8835 && old_address + old_size == new_address
8836 && old_flags == flags
8837 && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
8838 && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
e0001a05 8839 {
43cd72b9 8840 /* Fix the old size. */
e0001a05
NC		 8841 bfd_put_32 (abfd, old_size + size,
8842 &contents[last_irel->r_offset + 4]);
43cd72b9 8843 bytes_to_remove = entry_size;
e0001a05
NC		 8844 remove_this_irel = TRUE;
8845 }
8846 else
8847 last_irel = irel;
8848 }
8849 else
8850 last_irel = irel;
8851 }
8852
8853 irel->r_offset -= removed_bytes;
8854 last_irel_offset = irel->r_offset;
8855 }
8856
8857 if (remove_this_irel)
8858 {
8859 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8860 irel->r_offset -= bytes_to_remove;
8861 }
8862
8863 if (bytes_to_remove != 0)
8864 {
8865 removed_bytes += bytes_to_remove;
43cd72b9 8866 if (offset + bytes_to_remove < section_size)
e0001a05 8867 memmove (&contents[actual_offset],
43cd72b9
BW		 8868 &contents[actual_offset + bytes_to_remove],
8869 section_size - offset - bytes_to_remove);
e0001a05
NC		 8870 }
8871 }
8872
43cd72b9 8873 if (removed_bytes)
e0001a05
NC		 8874 {
8875 /* Clear the removed bytes. */
8876 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
8877
eea6121a 8878 sec->size = section_size - removed_bytes;
e901de89
BW		 8879
8880 if (xtensa_is_littable_section (sec))
8881 {
8882 bfd *dynobj = elf_hash_table (link_info)->dynobj;
8883 if (dynobj)
8884 {
8885 asection *sgotloc =
8886 bfd_get_section_by_name (dynobj, ".got.loc");
8887 if (sgotloc)
eea6121a 8888 sgotloc->size -= removed_bytes;
e901de89
BW		 8889 }
8890 }
e0001a05
NC		 8891 }
8892 }
e901de89 8893
e0001a05
NC		 8894 error_return:
8895 release_internal_relocs (sec, internal_relocs);
8896 release_contents (sec, contents);
8897 return ok;
8898}
8899
8900\f
8901/* Third relaxation pass. */
8902
8903/* Change symbol values to account for removed literals. */
8904
43cd72b9 8905bfd_boolean
7fa3d080 8906relax_section_symbols (bfd *abfd, asection *sec)
e0001a05
NC		 8907{
8908 xtensa_relax_info *relax_info;
8909 unsigned int sec_shndx;
8910 Elf_Internal_Shdr *symtab_hdr;
8911 Elf_Internal_Sym *isymbuf;
8912 unsigned i, num_syms, num_locals;
8913
8914 relax_info = get_xtensa_relax_info (sec);
8915 BFD_ASSERT (relax_info);
8916
43cd72b9
BW		 8917 if (!relax_info->is_relaxable_literal_section
8918 && !relax_info->is_relaxable_asm_section)
e0001a05
NC		 8919 return TRUE;
8920
8921 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
8922
8923 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8924 isymbuf = retrieve_local_syms (abfd);
8925
8926 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
8927 num_locals = symtab_hdr->sh_info;
8928
8929 /* Adjust the local symbols defined in this section. */
8930 for (i = 0; i < num_locals; i++)
8931 {
8932 Elf_Internal_Sym *isym = &isymbuf[i];
8933
8934 if (isym->st_shndx == sec_shndx)
8935 {
43cd72b9
BW		 8936 bfd_vma new_address = offset_with_removed_text
8937 (&relax_info->action_list, isym->st_value);
8938 bfd_vma new_size = isym->st_size;
8939
8940 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
8941 {
8942 bfd_vma new_end = offset_with_removed_text
8943 (&relax_info->action_list, isym->st_value + isym->st_size);
8944 new_size = new_end - new_address;
8945 }
8946
8947 isym->st_value = new_address;
8948 isym->st_size = new_size;
e0001a05
NC		 8949 }
8950 }
8951
8952 /* Now adjust the global symbols defined in this section. */
8953 for (i = 0; i < (num_syms - num_locals); i++)
8954 {
8955 struct elf_link_hash_entry *sym_hash;
8956
8957 sym_hash = elf_sym_hashes (abfd)[i];
8958
8959 if (sym_hash->root.type == bfd_link_hash_warning)
8960 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
8961
8962 if ((sym_hash->root.type == bfd_link_hash_defined
8963 || sym_hash->root.type == bfd_link_hash_defweak)
8964 && sym_hash->root.u.def.section == sec)
8965 {
43cd72b9
BW		 8966 bfd_vma new_address = offset_with_removed_text
8967 (&relax_info->action_list, sym_hash->root.u.def.value);
8968 bfd_vma new_size = sym_hash->size;
8969
8970 if (sym_hash->type == STT_FUNC)
8971 {
8972 bfd_vma new_end = offset_with_removed_text
8973 (&relax_info->action_list,
8974 sym_hash->root.u.def.value + sym_hash->size);
8975 new_size = new_end - new_address;
8976 }
8977
8978 sym_hash->root.u.def.value = new_address;
8979 sym_hash->size = new_size;
e0001a05
NC		 8980 }
8981 }
8982
8983 return TRUE;
8984}
8985
8986\f
8987/* "Fix" handling functions, called while performing relocations. */
8988
43cd72b9 8989static bfd_boolean
7fa3d080
BW		 8990do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
8991 bfd *input_bfd,
8992 asection *input_section,
8993 bfd_byte *contents)
e0001a05
NC		 8994{
8995 r_reloc r_rel;
8996 asection *sec, *old_sec;
8997 bfd_vma old_offset;
8998 int r_type = ELF32_R_TYPE (rel->r_info);
e0001a05
NC		 8999 reloc_bfd_fix *fix;
9000
9001 if (r_type == R_XTENSA_NONE)
43cd72b9 9002 return TRUE;
e0001a05 9003
43cd72b9
BW		 9004 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
9005 if (!fix)
9006 return TRUE;
e0001a05 9007
43cd72b9
BW		 9008 r_reloc_init (&r_rel, input_bfd, rel, contents,
9009 bfd_get_section_limit (input_bfd, input_section));
e0001a05 9010 old_sec = r_reloc_get_section (&r_rel);
43cd72b9
BW		 9011 old_offset = r_rel.target_offset;
9012
9013 if (!old_sec || !r_reloc_is_defined (&r_rel))
e0001a05 9014 {
43cd72b9
BW		 9015 if (r_type != R_XTENSA_ASM_EXPAND)
9016 {
9017 (*_bfd_error_handler)
9018 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
9019 input_bfd, input_section, rel->r_offset,
9020 elf_howto_table[r_type].name);
9021 return FALSE;
9022 }
e0001a05
NC		 9023 /* Leave it be. Resolution will happen in a later stage. */
9024 }
9025 else
9026 {
9027 sec = fix->target_sec;
9028 rel->r_addend += ((sec->output_offset + fix->target_offset)
9029 - (old_sec->output_offset + old_offset));
9030 }
43cd72b9 9031 return TRUE;
e0001a05
NC		 9032}
9033
9034
9035static void
7fa3d080
BW		 9036do_fix_for_final_link (Elf_Internal_Rela *rel,
9037 bfd *input_bfd,
9038 asection *input_section,
9039 bfd_byte *contents,
9040 bfd_vma *relocationp)
e0001a05
NC		 9041{
9042 asection *sec;
9043 int r_type = ELF32_R_TYPE (rel->r_info);
e0001a05 9044 reloc_bfd_fix *fix;
43cd72b9 9045 bfd_vma fixup_diff;
e0001a05
NC		 9046
9047 if (r_type == R_XTENSA_NONE)
9048 return;
9049
43cd72b9
BW		 9050 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
9051 if (!fix)
e0001a05
NC		 9052 return;
9053
9054 sec = fix->target_sec;
43cd72b9
BW		 9055
9056 fixup_diff = rel->r_addend;
9057 if (elf_howto_table[fix->src_type].partial_inplace)
9058 {
9059 bfd_vma inplace_val;
9060 BFD_ASSERT (fix->src_offset
9061 < bfd_get_section_limit (input_bfd, input_section));
9062 inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
9063 fixup_diff += inplace_val;
9064 }
9065
e0001a05
NC		 9066 *relocationp = (sec->output_section->vma
9067 + sec->output_offset
43cd72b9 9068 + fix->target_offset - fixup_diff);
e0001a05
NC		 9069}
9070
9071\f
9072/* Miscellaneous utility functions.... */
9073
9074static asection *
7fa3d080 9075elf_xtensa_get_plt_section (bfd *dynobj, int chunk)
e0001a05
NC		 9076{
9077 char plt_name[10];
9078
9079 if (chunk == 0)
9080 return bfd_get_section_by_name (dynobj, ".plt");
9081
9082 sprintf (plt_name, ".plt.%u", chunk);
9083 return bfd_get_section_by_name (dynobj, plt_name);
9084}
9085
9086
9087static asection *
7fa3d080 9088elf_xtensa_get_gotplt_section (bfd *dynobj, int chunk)
e0001a05
NC		 9089{
9090 char got_name[14];
9091
9092 if (chunk == 0)
9093 return bfd_get_section_by_name (dynobj, ".got.plt");
9094
9095 sprintf (got_name, ".got.plt.%u", chunk);
9096 return bfd_get_section_by_name (dynobj, got_name);
9097}
9098
9099
9100/* Get the input section for a given symbol index.
9101 If the symbol is:
9102 . a section symbol, return the section;
9103 . a common symbol, return the common section;
9104 . an undefined symbol, return the undefined section;
9105 . an indirect symbol, follow the links;
9106 . an absolute value, return the absolute section. */
9107
9108static asection *
7fa3d080 9109get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
e0001a05
NC		 9110{
9111 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9112 asection *target_sec = NULL;
43cd72b9 9113 if (r_symndx < symtab_hdr->sh_info)
e0001a05
NC		 9114 {
9115 Elf_Internal_Sym *isymbuf;
9116 unsigned int section_index;
9117
9118 isymbuf = retrieve_local_syms (abfd);
9119 section_index = isymbuf[r_symndx].st_shndx;
9120
9121 if (section_index == SHN_UNDEF)
9122 target_sec = bfd_und_section_ptr;
9123 else if (section_index > 0 && section_index < SHN_LORESERVE)
9124 target_sec = bfd_section_from_elf_index (abfd, section_index);
9125 else if (section_index == SHN_ABS)
9126 target_sec = bfd_abs_section_ptr;
9127 else if (section_index == SHN_COMMON)
9128 target_sec = bfd_com_section_ptr;
43cd72b9 9129 else
e0001a05
NC		 9130 /* Who knows? */
9131 target_sec = NULL;
9132 }
9133 else
9134 {
9135 unsigned long indx = r_symndx - symtab_hdr->sh_info;
9136 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
9137
9138 while (h->root.type == bfd_link_hash_indirect
9139 || h->root.type == bfd_link_hash_warning)
9140 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9141
9142 switch (h->root.type)
9143 {
9144 case bfd_link_hash_defined:
9145 case bfd_link_hash_defweak:
9146 target_sec = h->root.u.def.section;
9147 break;
9148 case bfd_link_hash_common:
9149 target_sec = bfd_com_section_ptr;
9150 break;
9151 case bfd_link_hash_undefined:
9152 case bfd_link_hash_undefweak:
9153 target_sec = bfd_und_section_ptr;
9154 break;
9155 default: /* New indirect warning. */
9156 target_sec = bfd_und_section_ptr;
9157 break;
9158 }
9159 }
9160 return target_sec;
9161}
9162
9163
9164static struct elf_link_hash_entry *
7fa3d080 9165get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
e0001a05
NC		 9166{
9167 unsigned long indx;
9168 struct elf_link_hash_entry *h;
9169 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9170
9171 if (r_symndx < symtab_hdr->sh_info)
9172 return NULL;
43cd72b9 9173
e0001a05
NC		 9174 indx = r_symndx - symtab_hdr->sh_info;
9175 h = elf_sym_hashes (abfd)[indx];
9176 while (h->root.type == bfd_link_hash_indirect
9177 || h->root.type == bfd_link_hash_warning)
9178 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9179 return h;
9180}
9181
9182
9183/* Get the section-relative offset for a symbol number. */
9184
9185static bfd_vma
7fa3d080 9186get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
e0001a05
NC		 9187{
9188 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9189 bfd_vma offset = 0;
9190
43cd72b9 9191 if (r_symndx < symtab_hdr->sh_info)
e0001a05
NC		 9192 {
9193 Elf_Internal_Sym *isymbuf;
9194 isymbuf = retrieve_local_syms (abfd);
9195 offset = isymbuf[r_symndx].st_value;
9196 }
9197 else
9198 {
9199 unsigned long indx = r_symndx - symtab_hdr->sh_info;
9200 struct elf_link_hash_entry *h =
9201 elf_sym_hashes (abfd)[indx];
9202
9203 while (h->root.type == bfd_link_hash_indirect
9204 || h->root.type == bfd_link_hash_warning)
9205 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9206 if (h->root.type == bfd_link_hash_defined
9207 || h->root.type == bfd_link_hash_defweak)
9208 offset = h->root.u.def.value;
9209 }
9210 return offset;
9211}
9212
9213
9214static bfd_boolean
7fa3d080 9215is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
43cd72b9
BW		 9216{
9217 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
9218 struct elf_link_hash_entry *h;
9219
9220 h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
9221 if (h && h->root.type == bfd_link_hash_defweak)
9222 return TRUE;
9223 return FALSE;
9224}
9225
9226
9227static bfd_boolean
7fa3d080
BW		 9228pcrel_reloc_fits (xtensa_opcode opc,
9229 int opnd,
9230 bfd_vma self_address,
9231 bfd_vma dest_address)
e0001a05 9232{
43cd72b9
BW		 9233 xtensa_isa isa = xtensa_default_isa;
9234 uint32 valp = dest_address;
9235 if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
9236 || xtensa_operand_encode (isa, opc, opnd, &valp))
9237 return FALSE;
9238 return TRUE;
e0001a05
NC		 9239}
9240
9241
b614a702
BW		 9242static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
9243static int insn_sec_len = sizeof (XTENSA_INSN_SEC_NAME) - 1;
9244static int lit_sec_len = sizeof (XTENSA_LIT_SEC_NAME) - 1;
43cd72b9 9245static int prop_sec_len = sizeof (XTENSA_PROP_SEC_NAME) - 1;
b614a702
BW		 9246
9247
e0001a05 9248static bfd_boolean
7fa3d080 9249xtensa_is_property_section (asection *sec)
e0001a05 9250{
b614a702 9251 if (strncmp (XTENSA_INSN_SEC_NAME, sec->name, insn_sec_len) == 0
43cd72b9
BW		 9252 || strncmp (XTENSA_LIT_SEC_NAME, sec->name, lit_sec_len) == 0
9253 || strncmp (XTENSA_PROP_SEC_NAME, sec->name, prop_sec_len) == 0)
b614a702 9254 return TRUE;
e901de89 9255
b614a702 9256 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0
43cd72b9
BW		 9257 && (strncmp (&sec->name[linkonce_len], "x.", 2) == 0
9258 || strncmp (&sec->name[linkonce_len], "p.", 2) == 0
9259 || strncmp (&sec->name[linkonce_len], "prop.", 5) == 0))
e901de89
BW		 9260 return TRUE;
9261
e901de89
BW		 9262 return FALSE;
9263}
9264
9265
9266static bfd_boolean
7fa3d080 9267xtensa_is_littable_section (asection *sec)
e901de89 9268{
b614a702
BW		 9269 if (strncmp (XTENSA_LIT_SEC_NAME, sec->name, lit_sec_len) == 0)
9270 return TRUE;
e901de89 9271
b614a702
BW		 9272 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0
9273 && sec->name[linkonce_len] == 'p'
9274 && sec->name[linkonce_len + 1] == '.')
e901de89 9275 return TRUE;
e0001a05 9276
e901de89 9277 return FALSE;
e0001a05
NC		 9278}
9279
9280
43cd72b9 9281static int
7fa3d080 9282internal_reloc_compare (const void *ap, const void *bp)
e0001a05 9283{
43cd72b9
BW		 9284 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
9285 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
9286
9287 if (a->r_offset != b->r_offset)
9288 return (a->r_offset - b->r_offset);
9289
9290 /* We don't need to sort on these criteria for correctness,
9291 but enforcing a more strict ordering prevents unstable qsort
9292 from behaving differently with different implementations.
9293 Without the code below we get correct but different results
9294 on Solaris 2.7 and 2.8. We would like to always produce the
9295 same results no matter the host. */
9296
9297 if (a->r_info != b->r_info)
9298 return (a->r_info - b->r_info);
9299
9300 return (a->r_addend - b->r_addend);
e0001a05
NC		 9301}
9302
9303
9304static int
7fa3d080 9305internal_reloc_matches (const void *ap, const void *bp)
e0001a05
NC		 9306{
9307 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
9308 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
9309
43cd72b9
BW		 9310 /* Check if one entry overlaps with the other; this shouldn't happen
9311 except when searching for a match. */
e0001a05
NC		 9312 return (a->r_offset - b->r_offset);
9313}
9314
9315
e0001a05 9316char *
7fa3d080 9317xtensa_get_property_section_name (asection *sec, const char *base_name)
e0001a05 9318{
b614a702 9319 if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
e0001a05 9320 {
b614a702
BW		 9321 char *prop_sec_name;
9322 const char *suffix;
43cd72b9 9323 char *linkonce_kind = 0;
b614a702
BW		 9324
9325 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
43cd72b9 9326 linkonce_kind = "x";
b614a702 9327 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
43cd72b9
BW		 9328 linkonce_kind = "p";
9329 else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
9330 linkonce_kind = "prop.";
e0001a05 9331 else
b614a702
BW		 9332 abort ();
9333
43cd72b9
BW		 9334 prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
9335 + strlen (linkonce_kind) + 1);
b614a702 9336 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
43cd72b9 9337 strcpy (prop_sec_name + linkonce_len, linkonce_kind);
b614a702
BW		 9338
9339 suffix = sec->name + linkonce_len;
096c35a7 9340 /* For backward compatibility, replace "t." instead of inserting
43cd72b9
BW		 9341 the new linkonce_kind (but not for "prop" sections). */
9342 if (strncmp (suffix, "t.", 2) == 0 && linkonce_kind[1] == '.')
9343 suffix += 2;
9344 strcat (prop_sec_name + linkonce_len, suffix);
b614a702
BW		 9345
9346 return prop_sec_name;
e0001a05
NC		 9347 }
9348
b614a702 9349 return strdup (base_name);
e0001a05
NC		 9350}
9351
43cd72b9
BW		 9352
9353flagword
7fa3d080 9354xtensa_get_property_predef_flags (asection *sec)
43cd72b9
BW		 9355{
9356 if (strcmp (sec->name, XTENSA_INSN_SEC_NAME) == 0
9357 || strncmp (sec->name, ".gnu.linkonce.x.",
9358 sizeof ".gnu.linkonce.x." - 1) == 0)
9359 return (XTENSA_PROP_INSN
9360 | XTENSA_PROP_INSN_NO_TRANSFORM
9361 | XTENSA_PROP_INSN_NO_REORDER);
9362
9363 if (xtensa_is_littable_section (sec))
9364 return (XTENSA_PROP_LITERAL
9365 | XTENSA_PROP_INSN_NO_TRANSFORM
9366 | XTENSA_PROP_INSN_NO_REORDER);
9367
9368 return 0;
9369}
9370
e0001a05
NC		 9371\f
9372/* Other functions called directly by the linker. */
9373
9374bfd_boolean
7fa3d080
BW		 9375xtensa_callback_required_dependence (bfd *abfd,
9376 asection *sec,
9377 struct bfd_link_info *link_info,
9378 deps_callback_t callback,
9379 void *closure)
e0001a05
NC		 9380{
9381 Elf_Internal_Rela *internal_relocs;
9382 bfd_byte *contents;
9383 unsigned i;
9384 bfd_boolean ok = TRUE;
43cd72b9
BW		 9385 bfd_size_type sec_size;
9386
9387 sec_size = bfd_get_section_limit (abfd, sec);
e0001a05
NC		 9388
9389 /* ".plt*" sections have no explicit relocations but they contain L32R
9390 instructions that reference the corresponding ".got.plt*" sections. */
9391 if ((sec->flags & SEC_LINKER_CREATED) != 0
9392 && strncmp (sec->name, ".plt", 4) == 0)
9393 {
9394 asection *sgotplt;
9395
9396 /* Find the corresponding ".got.plt*" section. */
9397 if (sec->name[4] == '\0')
9398 sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
9399 else
9400 {
9401 char got_name[14];
9402 int chunk = 0;
9403
9404 BFD_ASSERT (sec->name[4] == '.');
9405 chunk = strtol (&sec->name[5], NULL, 10);
9406
9407 sprintf (got_name, ".got.plt.%u", chunk);
9408 sgotplt = bfd_get_section_by_name (sec->owner, got_name);
9409 }
9410 BFD_ASSERT (sgotplt);
9411
9412 /* Assume worst-case offsets: L32R at the very end of the ".plt"
9413 section referencing a literal at the very beginning of
9414 ".got.plt". This is very close to the real dependence, anyway. */
43cd72b9 9415 (*callback) (sec, sec_size, sgotplt, 0, closure);
e0001a05
NC		 9416 }
9417
9418 internal_relocs = retrieve_internal_relocs (abfd, sec,
9419 link_info->keep_memory);
9420 if (internal_relocs == NULL
43cd72b9 9421 || sec->reloc_count == 0)
e0001a05
NC		 9422 return ok;
9423
9424 /* Cache the contents for the duration of this scan. */
9425 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
43cd72b9 9426 if (contents == NULL && sec_size != 0)
e0001a05
NC		 9427 {
9428 ok = FALSE;
9429 goto error_return;
9430 }
9431
43cd72b9
BW		 9432 if (!xtensa_default_isa)
9433 xtensa_default_isa = xtensa_isa_init (0, 0);
e0001a05 9434
43cd72b9 9435 for (i = 0; i < sec->reloc_count; i++)
e0001a05
NC		 9436 {
9437 Elf_Internal_Rela *irel = &internal_relocs[i];
43cd72b9 9438 if (is_l32r_relocation (abfd, sec, contents, irel))
e0001a05
NC		 9439 {
9440 r_reloc l32r_rel;
9441 asection *target_sec;
9442 bfd_vma target_offset;
43cd72b9
BW		 9443
9444 r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
e0001a05
NC		 9445 target_sec = NULL;
9446 target_offset = 0;
9447 /* L32Rs must be local to the input file. */
9448 if (r_reloc_is_defined (&l32r_rel))
9449 {
9450 target_sec = r_reloc_get_section (&l32r_rel);
43cd72b9 9451 target_offset = l32r_rel.target_offset;
e0001a05
NC		 9452 }
9453 (*callback) (sec, irel->r_offset, target_sec, target_offset,
9454 closure);
9455 }
9456 }
9457
9458 error_return:
9459 release_internal_relocs (sec, internal_relocs);
9460 release_contents (sec, contents);
9461 return ok;
9462}
9463
2f89ff8d
L		 9464/* The default literal sections should always be marked as "code" (i.e.,
9465 SHF_EXECINSTR). This is particularly important for the Linux kernel
9466 module loader so that the literals are not placed after the text. */
9467static struct bfd_elf_special_section const elf_xtensa_special_sections[]=
9468{
7dcb9820
AM		 9469 { ".literal", 8, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
9470 { ".init.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
9471 { ".fini.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
9472 { NULL, 0, 0, 0, 0 }
2f89ff8d
L		 9473};
9474
e0001a05
NC		 9475\f
9476#ifndef ELF_ARCH
9477#define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
9478#define TARGET_LITTLE_NAME "elf32-xtensa-le"
9479#define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
9480#define TARGET_BIG_NAME "elf32-xtensa-be"
9481#define ELF_ARCH bfd_arch_xtensa
9482
9483/* The new EM_XTENSA value will be recognized beginning in the Xtensa T1040
9484 release. However, we still have to generate files with the EM_XTENSA_OLD
9485 value so that pre-T1040 tools can read the files. As soon as we stop
9486 caring about pre-T1040 tools, the following two values should be
9487 swapped. At the same time, any other code that uses EM_XTENSA_OLD
43cd72b9 9488 should be changed to use EM_XTENSA. */
e0001a05
NC		 9489#define ELF_MACHINE_CODE EM_XTENSA_OLD
9490#define ELF_MACHINE_ALT1 EM_XTENSA
9491
9492#if XCHAL_HAVE_MMU
9493#define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
9494#else /* !XCHAL_HAVE_MMU */
9495#define ELF_MAXPAGESIZE 1
9496#endif /* !XCHAL_HAVE_MMU */
9497#endif /* ELF_ARCH */
9498
9499#define elf_backend_can_gc_sections 1
9500#define elf_backend_can_refcount 1
9501#define elf_backend_plt_readonly 1
9502#define elf_backend_got_header_size 4
9503#define elf_backend_want_dynbss 0
9504#define elf_backend_want_got_plt 1
9505
9506#define elf_info_to_howto elf_xtensa_info_to_howto_rela
9507
e0001a05
NC		 9508#define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
9509#define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
9510#define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
9511#define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
9512#define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
9513#define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
9514
9515#define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
9516#define elf_backend_check_relocs elf_xtensa_check_relocs
e0001a05
NC		 9517#define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
9518#define elf_backend_discard_info elf_xtensa_discard_info
9519#define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
9520#define elf_backend_final_write_processing elf_xtensa_final_write_processing
9521#define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
9522#define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
9523#define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
9524#define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
9525#define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
9526#define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
9527#define elf_backend_hide_symbol elf_xtensa_hide_symbol
9528#define elf_backend_modify_segment_map elf_xtensa_modify_segment_map
9529#define elf_backend_object_p elf_xtensa_object_p
9530#define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
9531#define elf_backend_relocate_section elf_xtensa_relocate_section
9532#define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
2f89ff8d 9533#define elf_backend_special_sections elf_xtensa_special_sections
e0001a05
NC		 9534
9535#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.580526 seconds and 4 git commands to generate.