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