GNU Binutils v2.34
[binutils.git] / bfd / elf32-xtensa.c
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
42 static bfd_boolean add_extra_plt_sections (struct bfd_link_info *, int);
43 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
44 static bfd_reloc_status_type bfd_elf_xtensa_reloc
45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_boolean do_fix_for_relocatable_link
47   (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *);
48 static 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
53 static bfd_boolean is_indirect_call_opcode (xtensa_opcode);
54 static bfd_boolean is_direct_call_opcode (xtensa_opcode);
55 static bfd_boolean is_windowed_call_opcode (xtensa_opcode);
56 static xtensa_opcode get_const16_opcode (void);
57 static xtensa_opcode get_l32r_opcode (void);
58 static bfd_vma l32r_offset (bfd_vma, bfd_vma);
59 static int get_relocation_opnd (xtensa_opcode, int);
60 static int get_relocation_slot (int);
61 static xtensa_opcode get_relocation_opcode
62   (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
63 static bfd_boolean is_l32r_relocation
64   (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
65 static bfd_boolean is_alt_relocation (int);
66 static bfd_boolean is_operand_relocation (int);
67 static bfd_size_type insn_decode_len
68   (bfd_byte *, bfd_size_type, bfd_size_type);
69 static int insn_num_slots
70   (bfd_byte *, bfd_size_type, bfd_size_type);
71 static xtensa_opcode insn_decode_opcode
72   (bfd_byte *, bfd_size_type, bfd_size_type, int);
73 static bfd_boolean check_branch_target_aligned
74   (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
75 static bfd_boolean check_loop_aligned
76   (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
77 static bfd_boolean check_branch_target_aligned_address (bfd_vma, int);
78 static 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
83 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
84   (bfd_byte *, bfd_vma, bfd_vma, char **);
85 static bfd_reloc_status_type contract_asm_expansion
86   (bfd_byte *, bfd_vma, Elf_Internal_Rela *, char **);
87 static xtensa_opcode swap_callx_for_call_opcode (xtensa_opcode);
88 static xtensa_opcode get_expanded_call_opcode (bfd_byte *, int, bfd_boolean *);
89
90 /* Access to internal relocations, section contents and symbols.  */
91
92 static Elf_Internal_Rela *retrieve_internal_relocs
93   (bfd *, asection *, bfd_boolean);
94 static void pin_internal_relocs (asection *, Elf_Internal_Rela *);
95 static void release_internal_relocs (asection *, Elf_Internal_Rela *);
96 static bfd_byte *retrieve_contents (bfd *, asection *, bfd_boolean);
97 static void pin_contents (asection *, bfd_byte *);
98 static void release_contents (asection *, bfd_byte *);
99 static Elf_Internal_Sym *retrieve_local_syms (bfd *);
100
101 /* Miscellaneous utility functions.  */
102
103 static asection *elf_xtensa_get_plt_section (struct bfd_link_info *, int);
104 static asection *elf_xtensa_get_gotplt_section (struct bfd_link_info *, int);
105 static asection *get_elf_r_symndx_section (bfd *, unsigned long);
106 static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
107   (bfd *, unsigned long);
108 static bfd_vma get_elf_r_symndx_offset (bfd *, unsigned long);
109 static bfd_boolean is_reloc_sym_weak (bfd *, Elf_Internal_Rela *);
110 static bfd_boolean pcrel_reloc_fits (xtensa_opcode, int, bfd_vma, bfd_vma);
111 static bfd_boolean xtensa_is_property_section (asection *);
112 static bfd_boolean xtensa_is_insntable_section (asection *);
113 static bfd_boolean xtensa_is_littable_section (asection *);
114 static bfd_boolean xtensa_is_proptable_section (asection *);
115 static int internal_reloc_compare (const void *, const void *);
116 static int internal_reloc_matches (const void *, const void *);
117 static asection *xtensa_get_property_section (asection *, const char *);
118 static flagword xtensa_get_property_predef_flags (asection *);
119
120 /* Other functions called directly by the linker.  */
121
122 typedef void (*deps_callback_t)
123   (asection *, bfd_vma, asection *, bfd_vma, void *);
124 extern 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
133 int 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
140 typedef 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
148 xtensa_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
155 static 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
160 int elf32xtensa_no_literal_movement = 1;
161
162 /* Place property records for a section into individual property section
163    with xt.prop. prefix.  */
164
165 bfd_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 \f
172 static 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
337 static reloc_howto_type *
338 elf_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
470 static reloc_howto_type *
471 elf_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
488 static bfd_boolean
489 elf_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 \f
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
538 static 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
557 static 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
579 struct 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
595 struct 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
619 static bfd_boolean
620 elf_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
628 struct 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
655 static struct bfd_hash_entry *
656 elf_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
684 static struct bfd_link_hash_table *
685 elf_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
719 static void
720 elf_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
744 static inline bfd_boolean
745 elf_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 \f
758 static int
759 property_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
791 static int
792 property_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
810 int
811 xtensa_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
956 static property_table_entry *
957 elf_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
977 static bfd_boolean
978 elf_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 \f
989 /* Look through the relocs for a section during the first phase, and
990    calculate needed space in the dynamic reloc sections.  */
991
992 static bfd_boolean
993 elf_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
1226 static void
1227 elf_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
1251 static void
1252 elf_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
1267 static asection *
1268 elf_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
1301 static bfd_boolean
1302 elf_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
1347 static bfd_boolean
1348 add_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
1393 static bfd_boolean
1394 elf_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
1417 static bfd_boolean
1418 elf_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
1457 static void
1458 elf_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
1502 static bfd_boolean
1503 elf_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
1744 static bfd_boolean
1745 elf_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 \f
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
1782 static bfd_vma
1783 dtpoff_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
1794 static bfd_vma
1795 tpoff (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
1815 static bfd_reloc_status_type
1816 elf_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
2058 static char *
2059 vsprint_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
2098 static bfd_reloc_status_type
2099 bfd_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
2209 static bfd_vma
2210 elf_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
2256 static bfd_boolean get_indirect_call_dest_reg (xtensa_opcode, unsigned *);
2257
2258 static bfd_boolean
2259 replace_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
2441 static bfd_boolean
2442 elf_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
3019 static bfd_boolean
3020 elf_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
3055 static int
3056 elf_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
3162 static bfd_boolean
3163 elf_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 \f
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
3356 static bfd_boolean
3357 elf_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
3410 static bfd_boolean
3411 elf_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
3423 static bfd_boolean
3424 elf_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
3447 static bfd_boolean
3448 elf_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
3471 static bfd_boolean
3472 elf_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
3492 static enum elf_reloc_type_class
3493 elf_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 \f
3509 static bfd_boolean
3510 elf_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)