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