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