Coverage Report

Created: 2024-05-21 06:29

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