OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [elf32-xtensa.c] - Blame information for rev 24

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.