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