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