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