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