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