1 /* NDS32-specific support for 32-bit ELF.
2 Copyright (C) 2012-2014 Free Software Foundation, Inc.
3 Contributed by Andes Technology Corporation.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfd_stdint.h"
26 #include "bfdlink.h"
27 #include "libbfd.h"
28 #include "elf-bfd.h"
29 #include "libiberty.h"
30 #include "bfd_stdint.h"
31 #include "elf/nds32.h"
32 #include "opcode/nds32.h"
33 #include "elf32-nds32.h"
34 #include "opcode/cgen.h"
35 #include "../opcodes/nds32-opc.h"
36
37 /* Relocation HOWTO functions. */
38 static bfd_reloc_status_type nds32_elf_ignore_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type nds32_elf_9_pcrel_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type nds32_elf_hi20_reloc
43 (bfd *, arelent *, asymbol *, void *,
44 asection *, bfd *, char **);
45 static bfd_reloc_status_type nds32_elf_lo12_reloc
46 (bfd *, arelent *, asymbol *, void *,
47 asection *, bfd *, char **);
48 static bfd_reloc_status_type nds32_elf_generic_reloc
49 (bfd *, arelent *, asymbol *, void *,
50 asection *, bfd *, char **);
51 static bfd_reloc_status_type nds32_elf_sda15_reloc
52 (bfd *, arelent *, asymbol *, void *,
53 asection *, bfd *, char **);
54
55 /* Helper functions for HOWTO. */
56 static bfd_reloc_status_type nds32_elf_do_9_pcrel_reloc
57 (bfd *, reloc_howto_type *, asection *, bfd_byte *, bfd_vma,
58 asection *, bfd_vma, bfd_vma);
59 static void nds32_elf_relocate_hi20
60 (bfd *, int, Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_byte *, bfd_vma);
61 static reloc_howto_type *bfd_elf32_bfd_reloc_type_table_lookup
62 (enum elf_nds32_reloc_type);
63 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
64 (bfd *, bfd_reloc_code_real_type);
65
66 /* Target hooks. */
67 static void nds32_info_to_howto_rel
68 (bfd *, arelent *, Elf_Internal_Rela *dst);
69 static void nds32_info_to_howto
70 (bfd *, arelent *, Elf_Internal_Rela *dst);
71 static bfd_boolean nds32_elf_add_symbol_hook
72 (bfd *, struct bfd_link_info *, Elf_Internal_Sym *, const char **,
73 flagword *, asection **, bfd_vma *);
74 static bfd_boolean nds32_elf_relocate_section
75 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
76 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
77 static bfd_boolean nds32_elf_object_p (bfd *);
78 static void nds32_elf_final_write_processing (bfd *, bfd_boolean);
79 static bfd_boolean nds32_elf_set_private_flags (bfd *, flagword);
80 static bfd_boolean nds32_elf_merge_private_bfd_data (bfd *, bfd *);
81 static bfd_boolean nds32_elf_print_private_bfd_data (bfd *, void *);
82 static bfd_boolean nds32_elf_gc_sweep_hook
83 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
84 static bfd_boolean nds32_elf_check_relocs
85 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
86 static asection *nds32_elf_gc_mark_hook
87 (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
88 struct elf_link_hash_entry *, Elf_Internal_Sym *);
89 static bfd_boolean nds32_elf_adjust_dynamic_symbol
90 (struct bfd_link_info *, struct elf_link_hash_entry *);
91 static bfd_boolean nds32_elf_size_dynamic_sections
92 (bfd *, struct bfd_link_info *);
93 static bfd_boolean nds32_elf_create_dynamic_sections
94 (bfd *, struct bfd_link_info *);
95 static bfd_boolean nds32_elf_finish_dynamic_sections
96 (bfd *, struct bfd_link_info *info);
97 static bfd_boolean nds32_elf_finish_dynamic_symbol
98 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
99 Elf_Internal_Sym *);
100 static bfd_boolean nds32_elf_mkobject (bfd *);
101
102 /* Nds32 helper functions. */
103 static bfd_reloc_status_type nds32_elf_final_sda_base
104 (bfd *, struct bfd_link_info *, bfd_vma *, bfd_boolean);
105 static bfd_boolean allocate_dynrelocs (struct elf_link_hash_entry *, void *);
106 static bfd_boolean readonly_dynrelocs (struct elf_link_hash_entry *, void *);
107 static Elf_Internal_Rela *find_relocs_at_address
108 (Elf_Internal_Rela *, Elf_Internal_Rela *,
109 Elf_Internal_Rela *, enum elf_nds32_reloc_type);
110 static bfd_vma calculate_memory_address
111 (bfd *, Elf_Internal_Rela *, Elf_Internal_Sym *, Elf_Internal_Shdr *);
112 static int nds32_get_section_contents (bfd *, asection *, bfd_byte **);
113 static bfd_boolean nds32_elf_ex9_build_hash_table
114 (bfd *, asection *, struct bfd_link_info *);
115 static bfd_boolean nds32_elf_ex9_itb_base (struct bfd_link_info *);
116 static void nds32_elf_ex9_import_table (struct bfd_link_info *);
117 static void nds32_elf_ex9_finish (struct bfd_link_info *);
118 static void nds32_elf_ex9_reloc_jmp (struct bfd_link_info *);
119 static void nds32_elf_get_insn_with_reg
120 (Elf_Internal_Rela *, uint32_t, uint32_t *);
121 static int nds32_get_local_syms (bfd *, asection *ATTRIBUTE_UNUSED,
122 Elf_Internal_Sym **);
123 static bfd_boolean nds32_elf_ex9_replace_instruction
124 (struct bfd_link_info *, bfd *, asection *);
125 static bfd_boolean nds32_elf_ifc_calc (struct bfd_link_info *, bfd *,
126 asection *);
127 static bfd_boolean nds32_elf_ifc_finish (struct bfd_link_info *);
128 static bfd_boolean nds32_elf_ifc_replace (struct bfd_link_info *);
129 static bfd_boolean nds32_elf_ifc_reloc (void);
130 static bfd_boolean nds32_relax_fp_as_gp
131 (struct bfd_link_info *link_info, bfd *abfd, asection *sec,
132 Elf_Internal_Rela *internal_relocs, Elf_Internal_Rela *irelend,
133 Elf_Internal_Sym *isymbuf);
134 static bfd_boolean nds32_fag_remove_unused_fpbase
135 (bfd *abfd, asection *sec, Elf_Internal_Rela *internal_relocs,
136 Elf_Internal_Rela *irelend);
137 static bfd_byte *
138 nds32_elf_get_relocated_section_contents (bfd *abfd,
139 struct bfd_link_info *link_info,
140 struct bfd_link_order *link_order,
141 bfd_byte *data,
142 bfd_boolean relocatable,
143 asymbol **symbols);
144
145 enum
146 {
147 MACH_V1 = bfd_mach_n1h,
148 MACH_V2 = bfd_mach_n1h_v2,
149 MACH_V3 = bfd_mach_n1h_v3,
150 MACH_V3M = bfd_mach_n1h_v3m
151 };
152
153 #define MIN(a, b) ((a) > (b) ? (b) : (a))
154 #define MAX(a, b) ((a) > (b) ? (a) : (b))
155
156 /* The name of the dynamic interpreter. This is put in the .interp
157 section. */
158 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
159
160 /* The nop opcode we use. */
161 #define NDS32_NOP32 0x40000009
162 #define NDS32_NOP16 0x9200
163
164 /* The size in bytes of an entry in the procedure linkage table. */
165 #define PLT_ENTRY_SIZE 24
166 #define PLT_HEADER_SIZE 24
167
168 /* The first entry in a procedure linkage table are reserved,
169 and the initial contents are unimportant (we zero them out).
170 Subsequent entries look like this. */
171 #define PLT0_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(.got+4) */
172 #define PLT0_ENTRY_WORD1 0x58f78000 /* ori r15, r25, LO12(.got+4) */
173 #define PLT0_ENTRY_WORD2 0x05178000 /* lwi r17, [r15+0] */
174 #define PLT0_ENTRY_WORD3 0x04f78001 /* lwi r15, [r15+4] */
175 #define PLT0_ENTRY_WORD4 0x4a003c00 /* jr r15 */
176
177 /* $ta is change to $r15 (from $r25). */
178 #define PLT0_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[1]@GOT) */
179 #define PLT0_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[1]@GOT) */
180 #define PLT0_PIC_ENTRY_WORD2 0x40f7f400 /* add r15, gp, r15 */
181 #define PLT0_PIC_ENTRY_WORD3 0x05178000 /* lwi r17, [r15+0] */
182 #define PLT0_PIC_ENTRY_WORD4 0x04f78001 /* lwi r15, [r15+4] */
183 #define PLT0_PIC_ENTRY_WORD5 0x4a003c00 /* jr r15 */
184
185 #define PLT_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(&got[n+3]) */
186 #define PLT_ENTRY_WORD1 0x04f78000 /* lwi r15, r15, LO12(&got[n+3]) */
187 #define PLT_ENTRY_WORD2 0x4a003c00 /* jr r15 */
188 #define PLT_ENTRY_WORD3 0x45000000 /* movi r16, sizeof(RELA) * n */
189 #define PLT_ENTRY_WORD4 0x48000000 /* j .plt0. */
190
191 #define PLT_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[n+3]@GOT) */
192 #define PLT_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[n+3]@GOT) */
193 #define PLT_PIC_ENTRY_WORD2 0x38febc02 /* lw r15, [gp+r15] */
194 #define PLT_PIC_ENTRY_WORD3 0x4a003c00 /* jr r15 */
195 #define PLT_PIC_ENTRY_WORD4 0x45000000 /* movi r16, sizeof(RELA) * n */
196 #define PLT_PIC_ENTRY_WORD5 0x48000000 /* j .plt0 */
197
198 /* These are macros used to get the relocation accurate value. */
199 #define ACCURATE_8BIT_S1 (0x100)
200 #define ACCURATE_U9BIT_S1 (0x400)
201 #define ACCURATE_12BIT_S1 (0x2000)
202 #define ACCURATE_14BIT_S1 (0x4000)
203 #define ACCURATE_19BIT (0x40000)
204
205 /* These are macros used to get the relocation conservative value. */
206 #define CONSERVATIVE_8BIT_S1 (0x100 - 4)
207 #define CONSERVATIVE_14BIT_S1 (0x4000 - 4)
208 #define CONSERVATIVE_16BIT_S1 (0x10000 - 4)
209 #define CONSERVATIVE_24BIT_S1 (0x1000000 - 4)
210 /* These must be more conservative because the address may be in
211 different segment. */
212 #define CONSERVATIVE_15BIT (0x4000 - 0x1000)
213 #define CONSERVATIVE_15BIT_S1 (0x8000 - 0x1000)
214 #define CONSERVATIVE_15BIT_S2 (0x10000 - 0x1000)
215 #define CONSERVATIVE_19BIT (0x40000 - 0x1000)
216 #define CONSERVATIVE_20BIT (0x80000 - 0x1000)
217
218 /* Size of small data/bss sections, used to calculate SDA_BASE. */
219 static long got_size = 0;
220 static int is_SDA_BASE_set = 0;
221 static int is_ITB_BASE_set = 0;
222
223 /* Convert ELF-VER in eflags to string for debugging purpose. */
224 static const char *const nds32_elfver_strtab[] =
225 {
226 "ELF-1.2",
227 "ELF-1.3",
228 "ELF-1.4",
229 };
230
231 /* The nds32 linker needs to keep track of the number of relocs that it
232 decides to copy in check_relocs for each symbol. This is so that
233 it can discard PC relative relocs if it doesn't need them when
234 linking with -Bsymbolic. We store the information in a field
235 extending the regular ELF linker hash table. */
236
237 /* This structure keeps track of the number of PC relative relocs we
238 have copied for a given symbol. */
239
240 struct elf_nds32_pcrel_relocs_copied
241 {
242 /* Next section. */
243 struct elf_nds32_pcrel_relocs_copied *next;
244 /* A section in dynobj. */
245 asection *section;
246 /* Number of relocs copied in this section. */
247 bfd_size_type count;
248 };
249
250 /* The sh linker needs to keep track of the number of relocs that it
251 decides to copy as dynamic relocs in check_relocs for each symbol.
252 This is so that it can later discard them if they are found to be
253 unnecessary. We store the information in a field extending the
254 regular ELF linker hash table. */
255
256 struct elf_nds32_dyn_relocs
257 {
258 struct elf_nds32_dyn_relocs *next;
259
260 /* The input section of the reloc. */
261 asection *sec;
262
263 /* Total number of relocs copied for the input section. */
264 bfd_size_type count;
265
266 /* Number of pc-relative relocs copied for the input section. */
267 bfd_size_type pc_count;
268 };
269
270 /* Nds32 ELF linker hash entry. */
271
272 struct elf_nds32_link_hash_entry
273 {
274 struct elf_link_hash_entry root;
275
276 /* Track dynamic relocs copied for this symbol. */
277 struct elf_nds32_dyn_relocs *dyn_relocs;
278
279 /* For checking relocation type. */
280 #define GOT_UNKNOWN 0
281 #define GOT_NORMAL 1
282 #define GOT_TLS_IE 2
283 unsigned int tls_type;
284 };
285
286 /* Get the nds32 ELF linker hash table from a link_info structure. */
287
288 #define FP_BASE_NAME "_FP_BASE_"
289 static int check_start_export_sym = 0;
290 static size_t ex9_relax_size = 0; /* Save ex9 predicted reducing size. */
291
292 /* The offset for executable tls relaxation. */
293 #define TP_OFFSET 0x0
294
295 struct elf_nds32_obj_tdata
296 {
297 struct elf_obj_tdata root;
298
299 /* tls_type for each local got entry. */
300 char *local_got_tls_type;
301 };
302
303 #define elf_nds32_tdata(bfd) \
304 ((struct elf_nds32_obj_tdata *) (bfd)->tdata.any)
305
306 #define elf32_nds32_local_got_tls_type(bfd) \
307 (elf_nds32_tdata (bfd)->local_got_tls_type)
308
309 #define elf32_nds32_hash_entry(ent) ((struct elf_nds32_link_hash_entry *)(ent))
310
311 static bfd_boolean
nds32_elf_mkobject(bfd * abfd)312 nds32_elf_mkobject (bfd *abfd)
313 {
314 return bfd_elf_allocate_object (abfd, sizeof (struct elf_nds32_obj_tdata),
315 NDS32_ELF_DATA);
316 }
317
318 /* Relocations used for relocation. */
319 static reloc_howto_type nds32_elf_howto_table[] =
320 {
321 /* This reloc does nothing. */
322 HOWTO (R_NDS32_NONE, /* type */
323 0, /* rightshift */
324 2, /* size (0 = byte, 1 = short, 2 = long) */
325 32, /* bitsize */
326 FALSE, /* pc_relative */
327 0, /* bitpos */
328 complain_overflow_bitfield, /* complain_on_overflow */
329 bfd_elf_generic_reloc, /* special_function */
330 "R_NDS32_NONE", /* name */
331 FALSE, /* partial_inplace */
332 0, /* src_mask */
333 0, /* dst_mask */
334 FALSE), /* pcrel_offset */
335
336 /* A 16 bit absolute relocation. */
337 HOWTO (R_NDS32_16, /* type */
338 0, /* rightshift */
339 1, /* size (0 = byte, 1 = short, 2 = long) */
340 16, /* bitsize */
341 FALSE, /* pc_relative */
342 0, /* bitpos */
343 complain_overflow_bitfield, /* complain_on_overflow */
344 nds32_elf_generic_reloc, /* special_function */
345 "R_NDS32_16", /* name */
346 FALSE, /* partial_inplace */
347 0xffff, /* src_mask */
348 0xffff, /* dst_mask */
349 FALSE), /* pcrel_offset */
350
351 /* A 32 bit absolute relocation. */
352 HOWTO (R_NDS32_32, /* type */
353 0, /* rightshift */
354 2, /* size (0 = byte, 1 = short, 2 = long) */
355 32, /* bitsize */
356 FALSE, /* pc_relative */
357 0, /* bitpos */
358 complain_overflow_bitfield, /* complain_on_overflow */
359 nds32_elf_generic_reloc, /* special_function */
360 "R_NDS32_32", /* name */
361 FALSE, /* partial_inplace */
362 0xffffffff, /* src_mask */
363 0xffffffff, /* dst_mask */
364 FALSE), /* pcrel_offset */
365
366 /* A 20 bit address. */
367 HOWTO (R_NDS32_20, /* type */
368 0, /* rightshift */
369 2, /* size (0 = byte, 1 = short, 2 = long) */
370 20, /* bitsize */
371 FALSE, /* pc_relative */
372 0, /* bitpos */
373 complain_overflow_unsigned, /* complain_on_overflow */
374 nds32_elf_generic_reloc, /* special_function */
375 "R_NDS32_20", /* name */
376 FALSE, /* partial_inplace */
377 0xfffff, /* src_mask */
378 0xfffff, /* dst_mask */
379 FALSE), /* pcrel_offset */
380
381 /* An PC Relative 9-bit relocation, shifted by 2.
382 This reloc is complicated because relocations are relative to pc & -4.
383 i.e. branches in the right insn slot use the address of the left insn
384 slot for pc. */
385 /* ??? It's not clear whether this should have partial_inplace set or not.
386 Branch relaxing in the assembler can store the addend in the insn,
387 and if bfd_install_relocation gets called the addend may get added
388 again. */
389 HOWTO (R_NDS32_9_PCREL, /* type */
390 1, /* rightshift */
391 1, /* size (0 = byte, 1 = short, 2 = long) */
392 8, /* bitsize */
393 TRUE, /* pc_relative */
394 0, /* bitpos */
395 complain_overflow_signed, /* complain_on_overflow */
396 nds32_elf_9_pcrel_reloc, /* special_function */
397 "R_NDS32_9_PCREL", /* name */
398 FALSE, /* partial_inplace */
399 0xff, /* src_mask */
400 0xff, /* dst_mask */
401 TRUE), /* pcrel_offset */
402
403 /* A relative 15 bit relocation, right shifted by 1. */
404 HOWTO (R_NDS32_15_PCREL, /* type */
405 1, /* rightshift */
406 2, /* size (0 = byte, 1 = short, 2 = long) */
407 14, /* bitsize */
408 TRUE, /* pc_relative */
409 0, /* bitpos */
410 complain_overflow_signed, /* complain_on_overflow */
411 bfd_elf_generic_reloc, /* special_function */
412 "R_NDS32_15_PCREL", /* name */
413 FALSE, /* partial_inplace */
414 0x3fff, /* src_mask */
415 0x3fff, /* dst_mask */
416 TRUE), /* pcrel_offset */
417
418 /* A relative 17 bit relocation, right shifted by 1. */
419 HOWTO (R_NDS32_17_PCREL, /* type */
420 1, /* rightshift */
421 2, /* size (0 = byte, 1 = short, 2 = long) */
422 16, /* bitsize */
423 TRUE, /* pc_relative */
424 0, /* bitpos */
425 complain_overflow_signed, /* complain_on_overflow */
426 bfd_elf_generic_reloc, /* special_function */
427 "R_NDS32_17_PCREL", /* name */
428 FALSE, /* partial_inplace */
429 0xffff, /* src_mask */
430 0xffff, /* dst_mask */
431 TRUE), /* pcrel_offset */
432
433 /* A relative 25 bit relocation, right shifted by 1. */
434 /* ??? It's not clear whether this should have partial_inplace set or not.
435 Branch relaxing in the assembler can store the addend in the insn,
436 and if bfd_install_relocation gets called the addend may get added
437 again. */
438 HOWTO (R_NDS32_25_PCREL, /* type */
439 1, /* rightshift */
440 2, /* size (0 = byte, 1 = short, 2 = long) */
441 24, /* bitsize */
442 TRUE, /* pc_relative */
443 0, /* bitpos */
444 complain_overflow_signed, /* complain_on_overflow */
445 bfd_elf_generic_reloc, /* special_function */
446 "R_NDS32_25_PCREL", /* name */
447 FALSE, /* partial_inplace */
448 0xffffff, /* src_mask */
449 0xffffff, /* dst_mask */
450 TRUE), /* pcrel_offset */
451
452 /* High 20 bits of address when lower 12 is or'd in. */
453 HOWTO (R_NDS32_HI20, /* type */
454 12, /* rightshift */
455 2, /* size (0 = byte, 1 = short, 2 = long) */
456 20, /* bitsize */
457 FALSE, /* pc_relative */
458 0, /* bitpos */
459 complain_overflow_dont,/* complain_on_overflow */
460 nds32_elf_hi20_reloc, /* special_function */
461 "R_NDS32_HI20", /* name */
462 FALSE, /* partial_inplace */
463 0x000fffff, /* src_mask */
464 0x000fffff, /* dst_mask */
465 FALSE), /* pcrel_offset */
466
467 /* Lower 12 bits of address. */
468 HOWTO (R_NDS32_LO12S3, /* type */
469 3, /* rightshift */
470 2, /* size (0 = byte, 1 = short, 2 = long) */
471 9, /* bitsize */
472 FALSE, /* pc_relative */
473 0, /* bitpos */
474 complain_overflow_dont,/* complain_on_overflow */
475 nds32_elf_lo12_reloc, /* special_function */
476 "R_NDS32_LO12S3", /* name */
477 FALSE, /* partial_inplace */
478 0x000001ff, /* src_mask */
479 0x000001ff, /* dst_mask */
480 FALSE), /* pcrel_offset */
481
482 /* Lower 12 bits of address. */
483 HOWTO (R_NDS32_LO12S2, /* type */
484 2, /* rightshift */
485 2, /* size (0 = byte, 1 = short, 2 = long) */
486 10, /* bitsize */
487 FALSE, /* pc_relative */
488 0, /* bitpos */
489 complain_overflow_dont,/* complain_on_overflow */
490 nds32_elf_lo12_reloc, /* special_function */
491 "R_NDS32_LO12S2", /* name */
492 FALSE, /* partial_inplace */
493 0x000003ff, /* src_mask */
494 0x000003ff, /* dst_mask */
495 FALSE), /* pcrel_offset */
496
497 /* Lower 12 bits of address. */
498 HOWTO (R_NDS32_LO12S1, /* type */
499 1, /* rightshift */
500 2, /* size (0 = byte, 1 = short, 2 = long) */
501 11, /* bitsize */
502 FALSE, /* pc_relative */
503 0, /* bitpos */
504 complain_overflow_dont,/* complain_on_overflow */
505 nds32_elf_lo12_reloc, /* special_function */
506 "R_NDS32_LO12S1", /* name */
507 FALSE, /* partial_inplace */
508 0x000007ff, /* src_mask */
509 0x000007ff, /* dst_mask */
510 FALSE), /* pcrel_offset */
511
512 /* Lower 12 bits of address. */
513 HOWTO (R_NDS32_LO12S0, /* type */
514 0, /* rightshift */
515 2, /* size (0 = byte, 1 = short, 2 = long) */
516 12, /* bitsize */
517 FALSE, /* pc_relative */
518 0, /* bitpos */
519 complain_overflow_dont,/* complain_on_overflow */
520 nds32_elf_lo12_reloc, /* special_function */
521 "R_NDS32_LO12S0", /* name */
522 FALSE, /* partial_inplace */
523 0x00000fff, /* src_mask */
524 0x00000fff, /* dst_mask */
525 FALSE), /* pcrel_offset */
526
527 /* Small data area 15 bits offset. */
528 HOWTO (R_NDS32_SDA15S3, /* type */
529 3, /* rightshift */
530 2, /* size (0 = byte, 1 = short, 2 = long) */
531 15, /* bitsize */
532 FALSE, /* pc_relative */
533 0, /* bitpos */
534 complain_overflow_signed, /* complain_on_overflow */
535 nds32_elf_sda15_reloc, /* special_function */
536 "R_NDS32_SDA15S3", /* name */
537 FALSE, /* partial_inplace */
538 0x00007fff, /* src_mask */
539 0x00007fff, /* dst_mask */
540 FALSE), /* pcrel_offset */
541
542 /* Small data area 15 bits offset. */
543 HOWTO (R_NDS32_SDA15S2, /* type */
544 2, /* rightshift */
545 2, /* size (0 = byte, 1 = short, 2 = long) */
546 15, /* bitsize */
547 FALSE, /* pc_relative */
548 0, /* bitpos */
549 complain_overflow_signed, /* complain_on_overflow */
550 nds32_elf_sda15_reloc, /* special_function */
551 "R_NDS32_SDA15S2", /* name */
552 FALSE, /* partial_inplace */
553 0x00007fff, /* src_mask */
554 0x00007fff, /* dst_mask */
555 FALSE), /* pcrel_offset */
556
557 /* Small data area 15 bits offset. */
558 HOWTO (R_NDS32_SDA15S1, /* type */
559 1, /* rightshift */
560 2, /* size (0 = byte, 1 = short, 2 = long) */
561 15, /* bitsize */
562 FALSE, /* pc_relative */
563 0, /* bitpos */
564 complain_overflow_signed, /* complain_on_overflow */
565 nds32_elf_sda15_reloc, /* special_function */
566 "R_NDS32_SDA15S1", /* name */
567 FALSE, /* partial_inplace */
568 0x00007fff, /* src_mask */
569 0x00007fff, /* dst_mask */
570 FALSE), /* pcrel_offset */
571
572 /* Small data area 15 bits offset. */
573 HOWTO (R_NDS32_SDA15S0, /* type */
574 0, /* rightshift */
575 2, /* size (0 = byte, 1 = short, 2 = long) */
576 15, /* bitsize */
577 FALSE, /* pc_relative */
578 0, /* bitpos */
579 complain_overflow_signed, /* complain_on_overflow */
580 nds32_elf_sda15_reloc, /* special_function */
581 "R_NDS32_SDA15S0", /* name */
582 FALSE, /* partial_inplace */
583 0x00007fff, /* src_mask */
584 0x00007fff, /* dst_mask */
585 FALSE), /* pcrel_offset */
586
587 /* GNU extension to record C++ vtable hierarchy */
588 HOWTO (R_NDS32_GNU_VTINHERIT, /* type */
589 0, /* rightshift */
590 2, /* size (0 = byte, 1 = short, 2 = long) */
591 0, /* bitsize */
592 FALSE, /* pc_relative */
593 0, /* bitpos */
594 complain_overflow_dont,/* complain_on_overflow */
595 NULL, /* special_function */
596 "R_NDS32_GNU_VTINHERIT", /* name */
597 FALSE, /* partial_inplace */
598 0, /* src_mask */
599 0, /* dst_mask */
600 FALSE), /* pcrel_offset */
601
602 /* GNU extension to record C++ vtable member usage */
603 HOWTO (R_NDS32_GNU_VTENTRY, /* type */
604 0, /* rightshift */
605 2, /* size (0 = byte, 1 = short, 2 = long) */
606 0, /* bitsize */
607 FALSE, /* pc_relative */
608 0, /* bitpos */
609 complain_overflow_dont,/* complain_on_overflow */
610 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
611 "R_NDS32_GNU_VTENTRY", /* name */
612 FALSE, /* partial_inplace */
613 0, /* src_mask */
614 0, /* dst_mask */
615 FALSE), /* pcrel_offset */
616
617 /* A 16 bit absolute relocation. */
618 HOWTO (R_NDS32_16_RELA, /* type */
619 0, /* rightshift */
620 1, /* size (0 = byte, 1 = short, 2 = long) */
621 16, /* bitsize */
622 FALSE, /* pc_relative */
623 0, /* bitpos */
624 complain_overflow_bitfield, /* complain_on_overflow */
625 bfd_elf_generic_reloc, /* special_function */
626 "R_NDS32_16_RELA", /* name */
627 FALSE, /* partial_inplace */
628 0xffff, /* src_mask */
629 0xffff, /* dst_mask */
630 FALSE), /* pcrel_offset */
631
632 /* A 32 bit absolute relocation. */
633 HOWTO (R_NDS32_32_RELA, /* type */
634 0, /* rightshift */
635 2, /* size (0 = byte, 1 = short, 2 = long) */
636 32, /* bitsize */
637 FALSE, /* pc_relative */
638 0, /* bitpos */
639 complain_overflow_bitfield, /* complain_on_overflow */
640 bfd_elf_generic_reloc, /* special_function */
641 "R_NDS32_32_RELA", /* name */
642 FALSE, /* partial_inplace */
643 0xffffffff, /* src_mask */
644 0xffffffff, /* dst_mask */
645 FALSE), /* pcrel_offset */
646
647 /* A 20 bit address. */
648 HOWTO (R_NDS32_20_RELA, /* type */
649 0, /* rightshift */
650 2, /* size (0 = byte, 1 = short, 2 = long) */
651 20, /* bitsize */
652 FALSE, /* pc_relative */
653 0, /* bitpos */
654 complain_overflow_signed, /* complain_on_overflow */
655 bfd_elf_generic_reloc, /* special_function */
656 "R_NDS32_20_RELA", /* name */
657 FALSE, /* partial_inplace */
658 0xfffff, /* src_mask */
659 0xfffff, /* dst_mask */
660 FALSE), /* pcrel_offset */
661
662 HOWTO (R_NDS32_9_PCREL_RELA, /* type */
663 1, /* rightshift */
664 1, /* size (0 = byte, 1 = short, 2 = long) */
665 8, /* bitsize */
666 TRUE, /* pc_relative */
667 0, /* bitpos */
668 complain_overflow_signed, /* complain_on_overflow */
669 bfd_elf_generic_reloc, /* special_function */
670 "R_NDS32_9_PCREL_RELA",/* name */
671 FALSE, /* partial_inplace */
672 0xff, /* src_mask */
673 0xff, /* dst_mask */
674 TRUE), /* pcrel_offset */
675
676 /* A relative 15 bit relocation, right shifted by 1. */
677 HOWTO (R_NDS32_15_PCREL_RELA, /* type */
678 1, /* rightshift */
679 2, /* size (0 = byte, 1 = short, 2 = long) */
680 14, /* bitsize */
681 TRUE, /* pc_relative */
682 0, /* bitpos */
683 complain_overflow_signed, /* complain_on_overflow */
684 bfd_elf_generic_reloc, /* special_function */
685 "R_NDS32_15_PCREL_RELA", /* name */
686 FALSE, /* partial_inplace */
687 0x3fff, /* src_mask */
688 0x3fff, /* dst_mask */
689 TRUE), /* pcrel_offset */
690
691 /* A relative 17 bit relocation, right shifted by 1. */
692 HOWTO (R_NDS32_17_PCREL_RELA, /* type */
693 1, /* rightshift */
694 2, /* size (0 = byte, 1 = short, 2 = long) */
695 16, /* bitsize */
696 TRUE, /* pc_relative */
697 0, /* bitpos */
698 complain_overflow_signed, /* complain_on_overflow */
699 bfd_elf_generic_reloc, /* special_function */
700 "R_NDS32_17_PCREL_RELA", /* name */
701 FALSE, /* partial_inplace */
702 0xffff, /* src_mask */
703 0xffff, /* dst_mask */
704 TRUE), /* pcrel_offset */
705
706 /* A relative 25 bit relocation, right shifted by 2. */
707 HOWTO (R_NDS32_25_PCREL_RELA, /* type */
708 1, /* rightshift */
709 2, /* size (0 = byte, 1 = short, 2 = long) */
710 24, /* bitsize */
711 TRUE, /* pc_relative */
712 0, /* bitpos */
713 complain_overflow_signed, /* complain_on_overflow */
714 bfd_elf_generic_reloc, /* special_function */
715 "R_NDS32_25_PCREL_RELA", /* name */
716 FALSE, /* partial_inplace */
717 0xffffff, /* src_mask */
718 0xffffff, /* dst_mask */
719 TRUE), /* pcrel_offset */
720
721 /* High 20 bits of address when lower 16 is or'd in. */
722 HOWTO (R_NDS32_HI20_RELA, /* type */
723 12, /* rightshift */
724 2, /* size (0 = byte, 1 = short, 2 = long) */
725 20, /* bitsize */
726 FALSE, /* pc_relative */
727 0, /* bitpos */
728 complain_overflow_dont,/* complain_on_overflow */
729 bfd_elf_generic_reloc, /* special_function */
730 "R_NDS32_HI20_RELA", /* name */
731 FALSE, /* partial_inplace */
732 0x000fffff, /* src_mask */
733 0x000fffff, /* dst_mask */
734 FALSE), /* pcrel_offset */
735
736 /* Lower 12 bits of address. */
737 HOWTO (R_NDS32_LO12S3_RELA, /* type */
738 3, /* rightshift */
739 2, /* size (0 = byte, 1 = short, 2 = long) */
740 9, /* bitsize */
741 FALSE, /* pc_relative */
742 0, /* bitpos */
743 complain_overflow_dont,/* complain_on_overflow */
744 bfd_elf_generic_reloc, /* special_function */
745 "R_NDS32_LO12S3_RELA", /* name */
746 FALSE, /* partial_inplace */
747 0x000001ff, /* src_mask */
748 0x000001ff, /* dst_mask */
749 FALSE), /* pcrel_offset */
750
751 /* Lower 12 bits of address. */
752 HOWTO (R_NDS32_LO12S2_RELA, /* type */
753 2, /* rightshift */
754 2, /* size (0 = byte, 1 = short, 2 = long) */
755 10, /* bitsize */
756 FALSE, /* pc_relative */
757 0, /* bitpos */
758 complain_overflow_dont,/* complain_on_overflow */
759 bfd_elf_generic_reloc, /* special_function */
760 "R_NDS32_LO12S2_RELA", /* name */
761 FALSE, /* partial_inplace */
762 0x000003ff, /* src_mask */
763 0x000003ff, /* dst_mask */
764 FALSE), /* pcrel_offset */
765
766 /* Lower 12 bits of address. */
767 HOWTO (R_NDS32_LO12S1_RELA, /* type */
768 1, /* rightshift */
769 2, /* size (0 = byte, 1 = short, 2 = long) */
770 11, /* bitsize */
771 FALSE, /* pc_relative */
772 0, /* bitpos */
773 complain_overflow_dont,/* complain_on_overflow */
774 bfd_elf_generic_reloc, /* special_function */
775 "R_NDS32_LO12S1_RELA", /* name */
776 FALSE, /* partial_inplace */
777 0x000007ff, /* src_mask */
778 0x000007ff, /* dst_mask */
779 FALSE), /* pcrel_offset */
780
781 /* Lower 12 bits of address. */
782 HOWTO (R_NDS32_LO12S0_RELA, /* type */
783 0, /* rightshift */
784 2, /* size (0 = byte, 1 = short, 2 = long) */
785 12, /* bitsize */
786 FALSE, /* pc_relative */
787 0, /* bitpos */
788 complain_overflow_dont,/* complain_on_overflow */
789 bfd_elf_generic_reloc, /* special_function */
790 "R_NDS32_LO12S0_RELA", /* name */
791 FALSE, /* partial_inplace */
792 0x00000fff, /* src_mask */
793 0x00000fff, /* dst_mask */
794 FALSE), /* pcrel_offset */
795
796 /* Small data area 15 bits offset. */
797 HOWTO (R_NDS32_SDA15S3_RELA, /* type */
798 3, /* rightshift */
799 2, /* size (0 = byte, 1 = short, 2 = long) */
800 15, /* bitsize */
801 FALSE, /* pc_relative */
802 0, /* bitpos */
803 complain_overflow_signed, /* complain_on_overflow */
804 bfd_elf_generic_reloc, /* special_function */
805 "R_NDS32_SDA15S3_RELA",/* name */
806 FALSE, /* partial_inplace */
807 0x00007fff, /* src_mask */
808 0x00007fff, /* dst_mask */
809 FALSE), /* pcrel_offset */
810
811 /* Small data area 15 bits offset. */
812 HOWTO (R_NDS32_SDA15S2_RELA, /* type */
813 2, /* rightshift */
814 2, /* size (0 = byte, 1 = short, 2 = long) */
815 15, /* bitsize */
816 FALSE, /* pc_relative */
817 0, /* bitpos */
818 complain_overflow_signed, /* complain_on_overflow */
819 bfd_elf_generic_reloc, /* special_function */
820 "R_NDS32_SDA15S2_RELA",/* name */
821 FALSE, /* partial_inplace */
822 0x00007fff, /* src_mask */
823 0x00007fff, /* dst_mask */
824 FALSE), /* pcrel_offset */
825
826 HOWTO (R_NDS32_SDA15S1_RELA, /* type */
827 1, /* rightshift */
828 2, /* size (0 = byte, 1 = short, 2 = long) */
829 15, /* bitsize */
830 FALSE, /* pc_relative */
831 0, /* bitpos */
832 complain_overflow_signed, /* complain_on_overflow */
833 bfd_elf_generic_reloc, /* special_function */
834 "R_NDS32_SDA15S1_RELA",/* name */
835 FALSE, /* partial_inplace */
836 0x00007fff, /* src_mask */
837 0x00007fff, /* dst_mask */
838 FALSE), /* pcrel_offset */
839
840 HOWTO (R_NDS32_SDA15S0_RELA, /* type */
841 0, /* rightshift */
842 2, /* size (0 = byte, 1 = short, 2 = long) */
843 15, /* bitsize */
844 FALSE, /* pc_relative */
845 0, /* bitpos */
846 complain_overflow_signed, /* complain_on_overflow */
847 bfd_elf_generic_reloc, /* special_function */
848 "R_NDS32_SDA15S0_RELA",/* name */
849 FALSE, /* partial_inplace */
850 0x00007fff, /* src_mask */
851 0x00007fff, /* dst_mask */
852 FALSE), /* pcrel_offset */
853
854 /* GNU extension to record C++ vtable hierarchy */
855 HOWTO (R_NDS32_RELA_GNU_VTINHERIT, /* type */
856 0, /* rightshift */
857 2, /* size (0 = byte, 1 = short, 2 = long) */
858 0, /* bitsize */
859 FALSE, /* pc_relative */
860 0, /* bitpos */
861 complain_overflow_dont,/* complain_on_overflow */
862 NULL, /* special_function */
863 "R_NDS32_RELA_GNU_VTINHERIT", /* name */
864 FALSE, /* partial_inplace */
865 0, /* src_mask */
866 0, /* dst_mask */
867 FALSE), /* pcrel_offset */
868
869 /* GNU extension to record C++ vtable member usage */
870 HOWTO (R_NDS32_RELA_GNU_VTENTRY, /* type */
871 0, /* rightshift */
872 2, /* size (0 = byte, 1 = short, 2 = long) */
873 0, /* bitsize */
874 FALSE, /* pc_relative */
875 0, /* bitpos */
876 complain_overflow_dont,/* complain_on_overflow */
877 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
878 "R_NDS32_RELA_GNU_VTENTRY", /* name */
879 FALSE, /* partial_inplace */
880 0, /* src_mask */
881 0, /* dst_mask */
882 FALSE), /* pcrel_offset */
883
884 /* Like R_NDS32_20, but referring to the GOT table entry for
885 the symbol. */
886 HOWTO (R_NDS32_GOT20, /* type */
887 0, /* rightshift */
888 2, /* size (0 = byte, 1 = short, 2 = long) */
889 20, /* bitsize */
890 FALSE, /* pc_relative */
891 0, /* bitpos */
892 complain_overflow_signed, /* complain_on_overflow */
893 bfd_elf_generic_reloc, /* special_function */
894 "R_NDS32_GOT20", /* name */
895 FALSE, /* partial_inplace */
896 0xfffff, /* src_mask */
897 0xfffff, /* dst_mask */
898 FALSE), /* pcrel_offset */
899
900 /* Like R_NDS32_PCREL, but referring to the procedure linkage table
901 entry for the symbol. */
902 HOWTO (R_NDS32_25_PLTREL, /* type */
903 1, /* rightshift */
904 2, /* size (0 = byte, 1 = short, 2 = long) */
905 24, /* bitsize */
906 TRUE, /* pc_relative */
907 0, /* bitpos */
908 complain_overflow_signed, /* complain_on_overflow */
909 bfd_elf_generic_reloc, /* special_function */
910 "R_NDS32_25_PLTREL", /* name */
911 FALSE, /* partial_inplace */
912 0xffffff, /* src_mask */
913 0xffffff, /* dst_mask */
914 TRUE), /* pcrel_offset */
915
916 /* This is used only by the dynamic linker. The symbol should exist
917 both in the object being run and in some shared library. The
918 dynamic linker copies the data addressed by the symbol from the
919 shared library into the object, because the object being
920 run has to have the data at some particular address. */
921 HOWTO (R_NDS32_COPY, /* type */
922 0, /* rightshift */
923 2, /* size (0 = byte, 1 = short, 2 = long) */
924 32, /* bitsize */
925 FALSE, /* pc_relative */
926 0, /* bitpos */
927 complain_overflow_bitfield, /* complain_on_overflow */
928 bfd_elf_generic_reloc, /* special_function */
929 "R_NDS32_COPY", /* name */
930 FALSE, /* partial_inplace */
931 0xffffffff, /* src_mask */
932 0xffffffff, /* dst_mask */
933 FALSE), /* pcrel_offset */
934
935 /* Like R_NDS32_20, but used when setting global offset table
936 entries. */
937 HOWTO (R_NDS32_GLOB_DAT, /* type */
938 0, /* rightshift */
939 2, /* size (0 = byte, 1 = short, 2 = long) */
940 32, /* bitsize */
941 FALSE, /* pc_relative */
942 0, /* bitpos */
943 complain_overflow_bitfield, /* complain_on_overflow */
944 bfd_elf_generic_reloc, /* special_function */
945 "R_NDS32_GLOB_DAT", /* name */
946 FALSE, /* partial_inplace */
947 0xffffffff, /* src_mask */
948 0xffffffff, /* dst_mask */
949 FALSE), /* pcrel_offset */
950
951 /* Marks a procedure linkage table entry for a symbol. */
952 HOWTO (R_NDS32_JMP_SLOT, /* type */
953 0, /* rightshift */
954 2, /* size (0 = byte, 1 = short, 2 = long) */
955 32, /* bitsize */
956 FALSE, /* pc_relative */
957 0, /* bitpos */
958 complain_overflow_bitfield, /* complain_on_overflow */
959 bfd_elf_generic_reloc, /* special_function */
960 "R_NDS32_JMP_SLOT", /* name */
961 FALSE, /* partial_inplace */
962 0xffffffff, /* src_mask */
963 0xffffffff, /* dst_mask */
964 FALSE), /* pcrel_offset */
965
966 /* Used only by the dynamic linker. When the object is run, this
967 longword is set to the load address of the object, plus the
968 addend. */
969 HOWTO (R_NDS32_RELATIVE, /* type */
970 0, /* rightshift */
971 2, /* size (0 = byte, 1 = short, 2 = long) */
972 32, /* bitsize */
973 FALSE, /* pc_relative */
974 0, /* bitpos */
975 complain_overflow_bitfield, /* complain_on_overflow */
976 bfd_elf_generic_reloc, /* special_function */
977 "R_NDS32_RELATIVE", /* name */
978 FALSE, /* partial_inplace */
979 0xffffffff, /* src_mask */
980 0xffffffff, /* dst_mask */
981 FALSE), /* pcrel_offset */
982
983 HOWTO (R_NDS32_GOTOFF, /* type */
984 0, /* rightshift */
985 2, /* size (0 = byte, 1 = short, 2 = long) */
986 20, /* bitsize */
987 FALSE, /* pc_relative */
988 0, /* bitpos */
989 complain_overflow_signed, /* complain_on_overflow */
990 bfd_elf_generic_reloc, /* special_function */
991 "R_NDS32_GOTOFF", /* name */
992 FALSE, /* partial_inplace */
993 0xfffff, /* src_mask */
994 0xfffff, /* dst_mask */
995 FALSE), /* pcrel_offset */
996
997 /* An PC Relative 20-bit relocation used when setting PIC offset
998 table register. */
999 HOWTO (R_NDS32_GOTPC20, /* type */
1000 0, /* rightshift */
1001 2, /* size (0 = byte, 1 = short, 2 = long) */
1002 20, /* bitsize */
1003 TRUE, /* pc_relative */
1004 0, /* bitpos */
1005 complain_overflow_signed, /* complain_on_overflow */
1006 bfd_elf_generic_reloc, /* special_function */
1007 "R_NDS32_GOTPC20", /* name */
1008 FALSE, /* partial_inplace */
1009 0xfffff, /* src_mask */
1010 0xfffff, /* dst_mask */
1011 TRUE), /* pcrel_offset */
1012
1013 /* Like R_NDS32_HI20, but referring to the GOT table entry for
1014 the symbol. */
1015 HOWTO (R_NDS32_GOT_HI20, /* type */
1016 12, /* rightshift */
1017 2, /* size (0 = byte, 1 = short, 2 = long) */
1018 20, /* bitsize */
1019 FALSE, /* pc_relative */
1020 0, /* bitpos */
1021 complain_overflow_dont,/* complain_on_overflow */
1022 bfd_elf_generic_reloc, /* special_function */
1023 "R_NDS32_GOT_HI20", /* name */
1024 FALSE, /* partial_inplace */
1025 0x000fffff, /* src_mask */
1026 0x000fffff, /* dst_mask */
1027 FALSE), /* pcrel_offset */
1028 HOWTO (R_NDS32_GOT_LO12, /* type */
1029 0, /* rightshift */
1030 2, /* size (0 = byte, 1 = short, 2 = long) */
1031 12, /* bitsize */
1032 FALSE, /* pc_relative */
1033 0, /* bitpos */
1034 complain_overflow_dont,/* complain_on_overflow */
1035 bfd_elf_generic_reloc, /* special_function */
1036 "R_NDS32_GOT_LO12", /* name */
1037 FALSE, /* partial_inplace */
1038 0x00000fff, /* src_mask */
1039 0x00000fff, /* dst_mask */
1040 FALSE), /* pcrel_offset */
1041
1042 /* An PC Relative relocation used when setting PIC offset table register.
1043 Like R_NDS32_HI20, but referring to the GOT table entry for
1044 the symbol. */
1045 HOWTO (R_NDS32_GOTPC_HI20, /* type */
1046 12, /* rightshift */
1047 2, /* size (0 = byte, 1 = short, 2 = long) */
1048 20, /* bitsize */
1049 FALSE, /* pc_relative */
1050 0, /* bitpos */
1051 complain_overflow_dont,/* complain_on_overflow */
1052 bfd_elf_generic_reloc, /* special_function */
1053 "R_NDS32_GOTPC_HI20", /* name */
1054 FALSE, /* partial_inplace */
1055 0x000fffff, /* src_mask */
1056 0x000fffff, /* dst_mask */
1057 TRUE), /* pcrel_offset */
1058 HOWTO (R_NDS32_GOTPC_LO12, /* type */
1059 0, /* rightshift */
1060 2, /* size (0 = byte, 1 = short, 2 = long) */
1061 12, /* bitsize */
1062 FALSE, /* pc_relative */
1063 0, /* bitpos */
1064 complain_overflow_dont, /* complain_on_overflow */
1065 bfd_elf_generic_reloc, /* special_function */
1066 "R_NDS32_GOTPC_LO12", /* name */
1067 FALSE, /* partial_inplace */
1068 0x00000fff, /* src_mask */
1069 0x00000fff, /* dst_mask */
1070 TRUE), /* pcrel_offset */
1071
1072 HOWTO (R_NDS32_GOTOFF_HI20, /* type */
1073 12, /* rightshift */
1074 2, /* size (0 = byte, 1 = short, 2 = long) */
1075 20, /* bitsize */
1076 FALSE, /* pc_relative */
1077 0, /* bitpos */
1078 complain_overflow_dont,/* complain_on_overflow */
1079 bfd_elf_generic_reloc, /* special_function */
1080 "R_NDS32_GOTOFF_HI20", /* name */
1081 FALSE, /* partial_inplace */
1082 0x000fffff, /* src_mask */
1083 0x000fffff, /* dst_mask */
1084 FALSE), /* pcrel_offset */
1085 HOWTO (R_NDS32_GOTOFF_LO12, /* type */
1086 0, /* rightshift */
1087 2, /* size (0 = byte, 1 = short, 2 = long) */
1088 12, /* bitsize */
1089 FALSE, /* pc_relative */
1090 0, /* bitpos */
1091 complain_overflow_dont,/* complain_on_overflow */
1092 bfd_elf_generic_reloc, /* special_function */
1093 "R_NDS32_GOTOFF_LO12", /* name */
1094 FALSE, /* partial_inplace */
1095 0x00000fff, /* src_mask */
1096 0x00000fff, /* dst_mask */
1097 FALSE), /* pcrel_offset */
1098
1099 /* Alignment hint for relaxable instruction. This is used with
1100 R_NDS32_LABEL as a pair. Relax this instruction from 4 bytes to 2
1101 in order to make next label aligned on word boundary. */
1102 HOWTO (R_NDS32_INSN16, /* type */
1103 0, /* rightshift */
1104 2, /* size (0 = byte, 1 = short, 2 = long) */
1105 32, /* bitsize */
1106 FALSE, /* pc_relative */
1107 0, /* bitpos */
1108 complain_overflow_dont,/* complain_on_overflow */
1109 nds32_elf_ignore_reloc,/* special_function */
1110 "R_NDS32_INSN16", /* name */
1111 FALSE, /* partial_inplace */
1112 0x00000fff, /* src_mask */
1113 0x00000fff, /* dst_mask */
1114 FALSE), /* pcrel_offset */
1115
1116 /* Alignment hint for label. */
1117 HOWTO (R_NDS32_LABEL, /* type */
1118 0, /* rightshift */
1119 2, /* size (0 = byte, 1 = short, 2 = long) */
1120 32, /* bitsize */
1121 FALSE, /* pc_relative */
1122 0, /* bitpos */
1123 complain_overflow_dont,/* complain_on_overflow */
1124 nds32_elf_ignore_reloc,/* special_function */
1125 "R_NDS32_LABEL", /* name */
1126 FALSE, /* partial_inplace */
1127 0xffffffff, /* src_mask */
1128 0xffffffff, /* dst_mask */
1129 FALSE), /* pcrel_offset */
1130
1131 /* Relax hint for unconditional call sequence */
1132 HOWTO (R_NDS32_LONGCALL1, /* type */
1133 0, /* rightshift */
1134 2, /* size (0 = byte, 1 = short, 2 = long) */
1135 32, /* bitsize */
1136 FALSE, /* pc_relative */
1137 0, /* bitpos */
1138 complain_overflow_dont,/* complain_on_overflow */
1139 nds32_elf_ignore_reloc,/* special_function */
1140 "R_NDS32_LONGCALL1", /* name */
1141 FALSE, /* partial_inplace */
1142 0xffffffff, /* src_mask */
1143 0xffffffff, /* dst_mask */
1144 FALSE), /* pcrel_offset */
1145
1146 /* Relax hint for conditional call sequence. */
1147 HOWTO (R_NDS32_LONGCALL2, /* type */
1148 0, /* rightshift */
1149 2, /* size (0 = byte, 1 = short, 2 = long) */
1150 32, /* bitsize */
1151 FALSE, /* pc_relative */
1152 0, /* bitpos */
1153 complain_overflow_dont,/* complain_on_overflow */
1154 nds32_elf_ignore_reloc,/* special_function */
1155 "R_NDS32_LONGCALL2", /* name */
1156 FALSE, /* partial_inplace */
1157 0xffffffff, /* src_mask */
1158 0xffffffff, /* dst_mask */
1159 FALSE), /* pcrel_offset */
1160
1161 /* Relax hint for conditional call sequence. */
1162 HOWTO (R_NDS32_LONGCALL3, /* type */
1163 0, /* rightshift */
1164 2, /* size (0 = byte, 1 = short, 2 = long) */
1165 32, /* bitsize */
1166 FALSE, /* pc_relative */
1167 0, /* bitpos */
1168 complain_overflow_dont,/* complain_on_overflow */
1169 nds32_elf_ignore_reloc,/* special_function */
1170 "R_NDS32_LONGCALL3", /* name */
1171 FALSE, /* partial_inplace */
1172 0xffffffff, /* src_mask */
1173 0xffffffff, /* dst_mask */
1174 FALSE), /* pcrel_offset */
1175
1176 /* Relax hint for unconditional branch sequence. */
1177 HOWTO (R_NDS32_LONGJUMP1, /* type */
1178 0, /* rightshift */
1179 2, /* size (0 = byte, 1 = short, 2 = long) */
1180 32, /* bitsize */
1181 FALSE, /* pc_relative */
1182 0, /* bitpos */
1183 complain_overflow_dont,/* complain_on_overflow */
1184 nds32_elf_ignore_reloc,/* special_function */
1185 "R_NDS32_LONGJUMP1", /* name */
1186 FALSE, /* partial_inplace */
1187 0xffffffff, /* src_mask */
1188 0xffffffff, /* dst_mask */
1189 FALSE), /* pcrel_offset */
1190
1191 /* Relax hint for conditional branch sequence. */
1192 HOWTO (R_NDS32_LONGJUMP2, /* type */
1193 0, /* rightshift */
1194 2, /* size (0 = byte, 1 = short, 2 = long) */
1195 32, /* bitsize */
1196 FALSE, /* pc_relative */
1197 0, /* bitpos */
1198 complain_overflow_dont,/* complain_on_overflow */
1199 nds32_elf_ignore_reloc,/* special_function */
1200 "R_NDS32_LONGJUMP2", /* name */
1201 FALSE, /* partial_inplace */
1202 0xffffffff, /* src_mask */
1203 0xffffffff, /* dst_mask */
1204 FALSE), /* pcrel_offset */
1205
1206 /* Relax hint for conditional branch sequence. */
1207 HOWTO (R_NDS32_LONGJUMP3, /* type */
1208 0, /* rightshift */
1209 2, /* size (0 = byte, 1 = short, 2 = long) */
1210 32, /* bitsize */
1211 FALSE, /* pc_relative */
1212 0, /* bitpos */
1213 complain_overflow_dont,/* complain_on_overflow */
1214 nds32_elf_ignore_reloc,/* special_function */
1215 "R_NDS32_LONGJUMP3", /* name */
1216 FALSE, /* partial_inplace */
1217 0xffffffff, /* src_mask */
1218 0xffffffff, /* dst_mask */
1219 FALSE), /* pcrel_offset */
1220
1221 /* Relax hint for load/store sequence. */
1222 HOWTO (R_NDS32_LOADSTORE, /* type */
1223 0, /* rightshift */
1224 2, /* size (0 = byte, 1 = short, 2 = long) */
1225 32, /* bitsize */
1226 FALSE, /* pc_relative */
1227 0, /* bitpos */
1228 complain_overflow_dont,/* complain_on_overflow */
1229 nds32_elf_ignore_reloc,/* special_function */
1230 "R_NDS32_LOADSTORE", /* name */
1231 FALSE, /* partial_inplace */
1232 0xffffffff, /* src_mask */
1233 0xffffffff, /* dst_mask */
1234 FALSE), /* pcrel_offset */
1235
1236 /* Relax hint for load/store sequence. */
1237 HOWTO (R_NDS32_9_FIXED_RELA, /* type */
1238 0, /* rightshift */
1239 1, /* size (0 = byte, 1 = short, 2 = long) */
1240 16, /* bitsize */
1241 FALSE, /* pc_relative */
1242 0, /* bitpos */
1243 complain_overflow_dont,/* complain_on_overflow */
1244 nds32_elf_ignore_reloc,/* special_function */
1245 "R_NDS32_9_FIXED_RELA",/* name */
1246 FALSE, /* partial_inplace */
1247 0x000000ff, /* src_mask */
1248 0x000000ff, /* dst_mask */
1249 FALSE), /* pcrel_offset */
1250
1251 /* Relax hint for load/store sequence. */
1252 HOWTO (R_NDS32_15_FIXED_RELA, /* type */
1253 0, /* rightshift */
1254 2, /* size (0 = byte, 1 = short, 2 = long) */
1255 32, /* bitsize */
1256 FALSE, /* pc_relative */
1257 0, /* bitpos */
1258 complain_overflow_dont,/* complain_on_overflow */
1259 nds32_elf_ignore_reloc,/* special_function */
1260 "R_NDS32_15_FIXED_RELA", /* name */
1261 FALSE, /* partial_inplace */
1262 0x00003fff, /* src_mask */
1263 0x00003fff, /* dst_mask */
1264 FALSE), /* pcrel_offset */
1265
1266 /* Relax hint for load/store sequence. */
1267 HOWTO (R_NDS32_17_FIXED_RELA, /* type */
1268 0, /* rightshift */
1269 2, /* size (0 = byte, 1 = short, 2 = long) */
1270 32, /* bitsize */
1271 FALSE, /* pc_relative */
1272 0, /* bitpos */
1273 complain_overflow_dont,/* complain_on_overflow */
1274 nds32_elf_ignore_reloc,/* special_function */
1275 "R_NDS32_17_FIXED_RELA", /* name */
1276 FALSE, /* partial_inplace */
1277 0x0000ffff, /* src_mask */
1278 0x0000ffff, /* dst_mask */
1279 FALSE), /* pcrel_offset */
1280
1281 /* Relax hint for load/store sequence. */
1282 HOWTO (R_NDS32_25_FIXED_RELA, /* type */
1283 0, /* rightshift */
1284 2, /* size (0 = byte, 1 = short, 2 = long) */
1285 32, /* bitsize */
1286 FALSE, /* pc_relative */
1287 0, /* bitpos */
1288 complain_overflow_dont,/* complain_on_overflow */
1289 nds32_elf_ignore_reloc,/* special_function */
1290 "R_NDS32_25_FIXED_RELA", /* name */
1291 FALSE, /* partial_inplace */
1292 0x00ffffff, /* src_mask */
1293 0x00ffffff, /* dst_mask */
1294 FALSE), /* pcrel_offset */
1295
1296 /* High 20 bits of PLT symbol offset relative to PC. */
1297 HOWTO (R_NDS32_PLTREL_HI20, /* type */
1298 12, /* rightshift */
1299 2, /* size (0 = byte, 1 = short, 2 = long) */
1300 20, /* bitsize */
1301 FALSE, /* pc_relative */
1302 0, /* bitpos */
1303 complain_overflow_dont,/* complain_on_overflow */
1304 bfd_elf_generic_reloc, /* special_function */
1305 "R_NDS32_PLTREL_HI20", /* name */
1306 FALSE, /* partial_inplace */
1307 0x000fffff, /* src_mask */
1308 0x000fffff, /* dst_mask */
1309 FALSE), /* pcrel_offset */
1310
1311 /* Low 12 bits of PLT symbol offset relative to PC. */
1312 HOWTO (R_NDS32_PLTREL_LO12, /* type */
1313 0, /* rightshift */
1314 2, /* size (0 = byte, 1 = short, 2 = long) */
1315 12, /* bitsize */
1316 FALSE, /* pc_relative */
1317 0, /* bitpos */
1318 complain_overflow_dont,/* complain_on_overflow */
1319 bfd_elf_generic_reloc, /* special_function */
1320 "R_NDS32_PLTREL_LO12", /* name */
1321 FALSE, /* partial_inplace */
1322 0x00000fff, /* src_mask */
1323 0x00000fff, /* dst_mask */
1324 FALSE), /* pcrel_offset */
1325
1326 /* High 20 bits of PLT symbol offset relative to GOT (GP). */
1327 HOWTO (R_NDS32_PLT_GOTREL_HI20, /* type */
1328 12, /* rightshift */
1329 2, /* size (0 = byte, 1 = short, 2 = long) */
1330 20, /* bitsize */
1331 FALSE, /* pc_relative */
1332 0, /* bitpos */
1333 complain_overflow_dont,/* complain_on_overflow */
1334 bfd_elf_generic_reloc, /* special_function */
1335 "R_NDS32_PLT_GOTREL_HI20", /* name */
1336 FALSE, /* partial_inplace */
1337 0x000fffff, /* src_mask */
1338 0x000fffff, /* dst_mask */
1339 FALSE), /* pcrel_offset */
1340
1341 /* Low 12 bits of PLT symbol offset relative to GOT (GP). */
1342 HOWTO (R_NDS32_PLT_GOTREL_LO12, /* type */
1343 0, /* rightshift */
1344 2, /* size (0 = byte, 1 = short, 2 = long) */
1345 12, /* bitsize */
1346 FALSE, /* pc_relative */
1347 0, /* bitpos */
1348 complain_overflow_dont,/* complain_on_overflow */
1349 bfd_elf_generic_reloc, /* special_function */
1350 "R_NDS32_PLT_GOTREL_LO12", /* name */
1351 FALSE, /* partial_inplace */
1352 0x00000fff, /* src_mask */
1353 0x00000fff, /* dst_mask */
1354 FALSE), /* pcrel_offset */
1355
1356 /* Small data area 12 bits offset. */
1357 HOWTO (R_NDS32_SDA12S2_DP_RELA, /* type */
1358 2, /* rightshift */
1359 2, /* size (0 = byte, 1 = short, 2 = long) */
1360 12, /* bitsize */
1361 FALSE, /* pc_relative */
1362 0, /* bitpos */
1363 complain_overflow_signed, /* complain_on_overflow */
1364 bfd_elf_generic_reloc, /* special_function */
1365 "R_NDS32_SDA12S2_DP_RELA", /* name */
1366 FALSE, /* partial_inplace */
1367 0x00000fff, /* src_mask */
1368 0x00000fff, /* dst_mask */
1369 FALSE), /* pcrel_offset */
1370
1371 /* Small data area 12 bits offset. */
1372 HOWTO (R_NDS32_SDA12S2_SP_RELA, /* type */
1373 2, /* rightshift */
1374 2, /* size (0 = byte, 1 = short, 2 = long) */
1375 12, /* bitsize */
1376 FALSE, /* pc_relative */
1377 0, /* bitpos */
1378 complain_overflow_signed, /* complain_on_overflow */
1379 bfd_elf_generic_reloc, /* special_function */
1380 "R_NDS32_SDA12S2_SP_RELA", /* name */
1381 FALSE, /* partial_inplace */
1382 0x00000fff, /* src_mask */
1383 0x00000fff, /* dst_mask */
1384 FALSE), /* pcrel_offset */
1385 /* Lower 12 bits of address. */
1386
1387 HOWTO (R_NDS32_LO12S2_DP_RELA, /* type */
1388 2, /* rightshift */
1389 2, /* size (0 = byte, 1 = short, 2 = long) */
1390 10, /* bitsize */
1391 FALSE, /* pc_relative */
1392 0, /* bitpos */
1393 complain_overflow_dont,/* complain_on_overflow */
1394 bfd_elf_generic_reloc, /* special_function */
1395 "R_NDS32_LO12S2_DP_RELA", /* name */
1396 FALSE, /* partial_inplace */
1397 0x000003ff, /* src_mask */
1398 0x000003ff, /* dst_mask */
1399 FALSE), /* pcrel_offset */
1400
1401 /* Lower 12 bits of address. */
1402 HOWTO (R_NDS32_LO12S2_SP_RELA,/* type */
1403 2, /* rightshift */
1404 2, /* size (0 = byte, 1 = short, 2 = long) */
1405 10, /* bitsize */
1406 FALSE, /* pc_relative */
1407 0, /* bitpos */
1408 complain_overflow_dont,/* complain_on_overflow */
1409 bfd_elf_generic_reloc, /* special_function */
1410 "R_NDS32_LO12S2_SP_RELA", /* name */
1411 FALSE, /* partial_inplace */
1412 0x000003ff, /* src_mask */
1413 0x000003ff, /* dst_mask */
1414 FALSE), /* pcrel_offset */
1415 /* Lower 12 bits of address. Special identity for or case. */
1416 HOWTO (R_NDS32_LO12S0_ORI_RELA, /* type */
1417 0, /* rightshift */
1418 2, /* size (0 = byte, 1 = short, 2 = long) */
1419 12, /* bitsize */
1420 FALSE, /* pc_relative */
1421 0, /* bitpos */
1422 complain_overflow_dont,/* complain_on_overflow */
1423 bfd_elf_generic_reloc, /* special_function */
1424 "R_NDS32_LO12S0_ORI_RELA", /* name */
1425 FALSE, /* partial_inplace */
1426 0x00000fff, /* src_mask */
1427 0x00000fff, /* dst_mask */
1428 FALSE), /* pcrel_offset */
1429 /* Small data area 19 bits offset. */
1430 HOWTO (R_NDS32_SDA16S3_RELA, /* type */
1431 3, /* rightshift */
1432 2, /* size (0 = byte, 1 = short, 2 = long) */
1433 16, /* bitsize */
1434 FALSE, /* pc_relative */
1435 0, /* bitpos */
1436 complain_overflow_signed, /* complain_on_overflow */
1437 bfd_elf_generic_reloc, /* special_function */
1438 "R_NDS32_SDA16S3_RELA",/* name */
1439 FALSE, /* partial_inplace */
1440 0x0000ffff, /* src_mask */
1441 0x0000ffff, /* dst_mask */
1442 FALSE), /* pcrel_offset */
1443
1444 /* Small data area 15 bits offset. */
1445 HOWTO (R_NDS32_SDA17S2_RELA, /* type */
1446 2, /* rightshift */
1447 2, /* size (0 = byte, 1 = short, 2 = long) */
1448 17, /* bitsize */
1449 FALSE, /* pc_relative */
1450 0, /* bitpos */
1451 complain_overflow_signed, /* complain_on_overflow */
1452 bfd_elf_generic_reloc, /* special_function */
1453 "R_NDS32_SDA17S2_RELA",/* name */
1454 FALSE, /* partial_inplace */
1455 0x0001ffff, /* src_mask */
1456 0x0001ffff, /* dst_mask */
1457 FALSE), /* pcrel_offset */
1458
1459 HOWTO (R_NDS32_SDA18S1_RELA, /* type */
1460 1, /* rightshift */
1461 2, /* size (0 = byte, 1 = short, 2 = long) */
1462 18, /* bitsize */
1463 FALSE, /* pc_relative */
1464 0, /* bitpos */
1465 complain_overflow_signed, /* complain_on_overflow */
1466 bfd_elf_generic_reloc, /* special_function */
1467 "R_NDS32_SDA18S1_RELA",/* name */
1468 FALSE, /* partial_inplace */
1469 0x0003ffff, /* src_mask */
1470 0x0003ffff, /* dst_mask */
1471 FALSE), /* pcrel_offset */
1472
1473 HOWTO (R_NDS32_SDA19S0_RELA, /* type */
1474 0, /* rightshift */
1475 2, /* size (0 = byte, 1 = short, 2 = long) */
1476 19, /* bitsize */
1477 FALSE, /* pc_relative */
1478 0, /* bitpos */
1479 complain_overflow_signed, /* complain_on_overflow */
1480 bfd_elf_generic_reloc, /* special_function */
1481 "R_NDS32_SDA19S0_RELA",/* name */
1482 FALSE, /* partial_inplace */
1483 0x0007ffff, /* src_mask */
1484 0x0007ffff, /* dst_mask */
1485 FALSE), /* pcrel_offset */
1486 HOWTO (R_NDS32_DWARF2_OP1_RELA, /* type */
1487 0, /* rightshift */
1488 0, /* size (0 = byte, 1 = short, 2 = long) */
1489 8, /* bitsize */
1490 FALSE, /* pc_relative */
1491 0, /* bitpos */
1492 complain_overflow_dont,/* complain_on_overflow */
1493 nds32_elf_ignore_reloc,/* special_function */
1494 "R_NDS32_DWARF2_OP1_RELA", /* name */
1495 FALSE, /* partial_inplace */
1496 0xff, /* src_mask */
1497 0xff, /* dst_mask */
1498 FALSE), /* pcrel_offset */
1499 HOWTO (R_NDS32_DWARF2_OP2_RELA, /* type */
1500 0, /* rightshift */
1501 1, /* size (0 = byte, 1 = short, 2 = long) */
1502 16, /* bitsize */
1503 FALSE, /* pc_relative */
1504 0, /* bitpos */
1505 complain_overflow_dont,/* complain_on_overflow */
1506 nds32_elf_ignore_reloc,/* special_function */
1507 "R_NDS32_DWARF2_OP2_RELA", /* name */
1508 FALSE, /* partial_inplace */
1509 0xffff, /* src_mask */
1510 0xffff, /* dst_mask */
1511 FALSE), /* pcrel_offset */
1512 HOWTO (R_NDS32_DWARF2_LEB_RELA, /* type */
1513 0, /* rightshift */
1514 2, /* size (0 = byte, 1 = short, 2 = long) */
1515 32, /* bitsize */
1516 FALSE, /* pc_relative */
1517 0, /* bitpos */
1518 complain_overflow_dont,/* complain_on_overflow */
1519 nds32_elf_ignore_reloc,/* special_function */
1520 "R_NDS32_DWARF2_LEB_RELA", /* name */
1521 FALSE, /* partial_inplace */
1522 0xffffffff, /* src_mask */
1523 0xffffffff, /* dst_mask */
1524 FALSE), /* pcrel_offset */
1525 HOWTO (R_NDS32_UPDATE_TA_RELA,/* type */
1526 0, /* rightshift */
1527 1, /* size (0 = byte, 1 = short, 2 = long) */
1528 16, /* bitsize */
1529 FALSE, /* pc_relative */
1530 0, /* bitpos */
1531 complain_overflow_dont,/* complain_on_overflow */
1532 nds32_elf_ignore_reloc,/* special_function */
1533 "R_NDS32_UPDATE_TA_RELA", /* name */
1534 FALSE, /* partial_inplace */
1535 0xffff, /* src_mask */
1536 0xffff, /* dst_mask */
1537 FALSE), /* pcrel_offset */
1538 /* Like R_NDS32_PCREL, but referring to the procedure linkage table
1539 entry for the symbol. */
1540 HOWTO (R_NDS32_9_PLTREL, /* type */
1541 1, /* rightshift */
1542 1, /* size (0 = byte, 1 = short, 2 = long) */
1543 8, /* bitsize */
1544 TRUE, /* pc_relative */
1545 0, /* bitpos */
1546 complain_overflow_signed, /* complain_on_overflow */
1547 bfd_elf_generic_reloc, /* special_function */
1548 "R_NDS32_9_PLTREL", /* name */
1549 FALSE, /* partial_inplace */
1550 0xff, /* src_mask */
1551 0xff, /* dst_mask */
1552 TRUE), /* pcrel_offset */
1553 /* Low 20 bits of PLT symbol offset relative to GOT (GP). */
1554 HOWTO (R_NDS32_PLT_GOTREL_LO20, /* type */
1555 0, /* rightshift */
1556 2, /* size (0 = byte, 1 = short, 2 = long) */
1557 20, /* bitsize */
1558 FALSE, /* pc_relative */
1559 0, /* bitpos */
1560 complain_overflow_dont,/* complain_on_overflow */
1561 bfd_elf_generic_reloc, /* special_function */
1562 "R_NDS32_PLT_GOTREL_LO20", /* name */
1563 FALSE, /* partial_inplace */
1564 0x000fffff, /* src_mask */
1565 0x000fffff, /* dst_mask */
1566 FALSE), /* pcrel_offset */
1567 /* low 15 bits of PLT symbol offset relative to GOT (GP) */
1568 HOWTO (R_NDS32_PLT_GOTREL_LO15, /* type */
1569 0, /* rightshift */
1570 2, /* size (0 = byte, 1 = short, 2 = long) */
1571 15, /* bitsize */
1572 FALSE, /* pc_relative */
1573 0, /* bitpos */
1574 complain_overflow_dont,/* complain_on_overflow */
1575 bfd_elf_generic_reloc, /* special_function */
1576 "R_NDS32_PLT_GOTREL_LO15", /* name */
1577 FALSE, /* partial_inplace */
1578 0x00007fff, /* src_mask */
1579 0x00007fff, /* dst_mask */
1580 FALSE), /* pcrel_offset */
1581 /* Low 19 bits of PLT symbol offset relative to GOT (GP). */
1582 HOWTO (R_NDS32_PLT_GOTREL_LO19, /* type */
1583 0, /* rightshift */
1584 2, /* size (0 = byte, 1 = short, 2 = long) */
1585 19, /* bitsize */
1586 FALSE, /* pc_relative */
1587 0, /* bitpos */
1588 complain_overflow_dont,/* complain_on_overflow */
1589 bfd_elf_generic_reloc, /* special_function */
1590 "R_NDS32_PLT_GOTREL_LO19", /* name */
1591 FALSE, /* partial_inplace */
1592 0x0007ffff, /* src_mask */
1593 0x0007ffff, /* dst_mask */
1594 FALSE), /* pcrel_offset */
1595 HOWTO (R_NDS32_GOT_LO15, /* type */
1596 0, /* rightshift */
1597 2, /* size (0 = byte, 1 = short, 2 = long) */
1598 15, /* bitsize */
1599 FALSE, /* pc_relative */
1600 0, /* bitpos */
1601 complain_overflow_dont,/* complain_on_overflow */
1602 bfd_elf_generic_reloc, /* special_function */
1603 "R_NDS32_GOT_LO15", /* name */
1604 FALSE, /* partial_inplace */
1605 0x00007fff, /* src_mask */
1606 0x00007fff, /* dst_mask */
1607 FALSE), /* pcrel_offset */
1608 HOWTO (R_NDS32_GOT_LO19, /* type */
1609 0, /* rightshift */
1610 2, /* size (0 = byte, 1 = short, 2 = long) */
1611 19, /* bitsize */
1612 FALSE, /* pc_relative */
1613 0, /* bitpos */
1614 complain_overflow_dont,/* complain_on_overflow */
1615 bfd_elf_generic_reloc, /* special_function */
1616 "R_NDS32_GOT_LO19", /* name */
1617 FALSE, /* partial_inplace */
1618 0x0007ffff, /* src_mask */
1619 0x0007ffff, /* dst_mask */
1620 FALSE), /* pcrel_offset */
1621 HOWTO (R_NDS32_GOTOFF_LO15, /* type */
1622 0, /* rightshift */
1623 2, /* size (0 = byte, 1 = short, 2 = long) */
1624 15, /* bitsize */
1625 FALSE, /* pc_relative */
1626 0, /* bitpos */
1627 complain_overflow_dont,/* complain_on_overflow */
1628 bfd_elf_generic_reloc, /* special_function */
1629 "R_NDS32_GOTOFF_LO15", /* name */
1630 FALSE, /* partial_inplace */
1631 0x00007fff, /* src_mask */
1632 0x00007fff, /* dst_mask */
1633 FALSE), /* pcrel_offset */
1634 HOWTO (R_NDS32_GOTOFF_LO19, /* type */
1635 0, /* rightshift */
1636 2, /* size (0 = byte, 1 = short, 2 = long) */
1637 19, /* bitsize */
1638 FALSE, /* pc_relative */
1639 0, /* bitpos */
1640 complain_overflow_dont,/* complain_on_overflow */
1641 bfd_elf_generic_reloc, /* special_function */
1642 "R_NDS32_GOTOFF_LO19", /* name */
1643 FALSE, /* partial_inplace */
1644 0x0007ffff, /* src_mask */
1645 0x0007ffff, /* dst_mask */
1646 FALSE), /* pcrel_offset */
1647 /* GOT 15 bits offset. */
1648 HOWTO (R_NDS32_GOT15S2_RELA, /* type */
1649 2, /* rightshift */
1650 2, /* size (0 = byte, 1 = short, 2 = long) */
1651 15, /* bitsize */
1652 FALSE, /* pc_relative */
1653 0, /* bitpos */
1654 complain_overflow_signed, /* complain_on_overflow */
1655 bfd_elf_generic_reloc, /* special_function */
1656 "R_NDS32_GOT15S2_RELA",/* name */
1657 FALSE, /* partial_inplace */
1658 0x00007fff, /* src_mask */
1659 0x00007fff, /* dst_mask */
1660 FALSE), /* pcrel_offset */
1661 /* GOT 17 bits offset. */
1662 HOWTO (R_NDS32_GOT17S2_RELA, /* type */
1663 2, /* rightshift */
1664 2, /* size (0 = byte, 1 = short, 2 = long) */
1665 17, /* bitsize */
1666 FALSE, /* pc_relative */
1667 0, /* bitpos */
1668 complain_overflow_signed, /* complain_on_overflow */
1669 bfd_elf_generic_reloc, /* special_function */
1670 "R_NDS32_GOT17S2_RELA",/* name */
1671 FALSE, /* partial_inplace */
1672 0x0001ffff, /* src_mask */
1673 0x0001ffff, /* dst_mask */
1674 FALSE), /* pcrel_offset */
1675 /* A 5 bit address. */
1676 HOWTO (R_NDS32_5_RELA, /* type */
1677 0, /* rightshift */
1678 1, /* size (0 = byte, 1 = short, 2 = long) */
1679 5, /* bitsize */
1680 FALSE, /* pc_relative */
1681 0, /* bitpos */
1682 complain_overflow_signed, /* complain_on_overflow */
1683 bfd_elf_generic_reloc, /* special_function */
1684 "R_NDS32_5_RELA", /* name */
1685 FALSE, /* partial_inplace */
1686 0x1f, /* src_mask */
1687 0x1f, /* dst_mask */
1688 FALSE), /* pcrel_offset */
1689 HOWTO (R_NDS32_10_UPCREL_RELA,/* type */
1690 1, /* rightshift */
1691 1, /* size (0 = byte, 1 = short, 2 = long) */
1692 9, /* bitsize */
1693 TRUE, /* pc_relative */
1694 0, /* bitpos */
1695 complain_overflow_unsigned, /* complain_on_overflow */
1696 bfd_elf_generic_reloc, /* special_function */
1697 "R_NDS32_10_UPCREL_RELA", /* name */
1698 FALSE, /* partial_inplace */
1699 0x1ff, /* src_mask */
1700 0x1ff, /* dst_mask */
1701 TRUE), /* pcrel_offset */
1702 HOWTO (R_NDS32_SDA_FP7U2_RELA,/* type */
1703 2, /* rightshift */
1704 1, /* size (0 = byte, 1 = short, 2 = long) */
1705 7, /* bitsize */
1706 FALSE, /* pc_relative */
1707 0, /* bitpos */
1708 complain_overflow_unsigned, /* complain_on_overflow */
1709 bfd_elf_generic_reloc, /* special_function */
1710 "R_NDS32_SDA_FP7U2_RELA", /* name */
1711 FALSE, /* partial_inplace */
1712 0x0000007f, /* src_mask */
1713 0x0000007f, /* dst_mask */
1714 FALSE), /* pcrel_offset */
1715 HOWTO (R_NDS32_WORD_9_PCREL_RELA, /* type */
1716 1, /* rightshift */
1717 2, /* size (0 = byte, 1 = short, 2 = long) */
1718 8, /* bitsize */
1719 TRUE, /* pc_relative */
1720 0, /* bitpos */
1721 complain_overflow_signed, /* complain_on_overflow */
1722 bfd_elf_generic_reloc, /* special_function */
1723 "R_NDS32_WORD_9_PCREL_RELA", /* name */
1724 FALSE, /* partial_inplace */
1725 0xff, /* src_mask */
1726 0xff, /* dst_mask */
1727 TRUE), /* pcrel_offset */
1728 HOWTO (R_NDS32_25_ABS_RELA, /* type */
1729 1, /* rightshift */
1730 2, /* size (0 = byte, 1 = short, 2 = long) */
1731 24, /* bitsize */
1732 FALSE, /* pc_relative */
1733 0, /* bitpos */
1734 complain_overflow_dont,/* complain_on_overflow */
1735 bfd_elf_generic_reloc, /* special_function */
1736 "R_NDS32_25_ABS_RELA", /* name */
1737 FALSE, /* partial_inplace */
1738 0xffffff, /* src_mask */
1739 0xffffff, /* dst_mask */
1740 FALSE), /* pcrel_offset */
1741
1742 /* A relative 17 bit relocation for ifc, right shifted by 1. */
1743 HOWTO (R_NDS32_17IFC_PCREL_RELA, /* type */
1744 1, /* rightshift */
1745 2, /* size (0 = byte, 1 = short, 2 = long) */
1746 16, /* bitsize */
1747 TRUE, /* pc_relative */
1748 0, /* bitpos */
1749 complain_overflow_signed, /* complain_on_overflow */
1750 bfd_elf_generic_reloc, /* special_function */
1751 "R_NDS32_17IFC_PCREL_RELA", /* name */
1752 FALSE, /* partial_inplace */
1753 0xffff, /* src_mask */
1754 0xffff, /* dst_mask */
1755 TRUE), /* pcrel_offset */
1756
1757 /* A relative unsigned 10 bit relocation for ifc, right shifted by 1. */
1758 HOWTO (R_NDS32_10IFCU_PCREL_RELA, /* type */
1759 1, /* rightshift */
1760 1, /* size (0 = byte, 1 = short, 2 = long) */
1761 9, /* bitsize */
1762 TRUE, /* pc_relative */
1763 0, /* bitpos */
1764 complain_overflow_unsigned, /* complain_on_overflow */
1765 bfd_elf_generic_reloc, /* special_function */
1766 "R_NDS32_10IFCU_PCREL_RELA", /* name */
1767 FALSE, /* partial_inplace */
1768 0x1ff, /* src_mask */
1769 0x1ff, /* dst_mask */
1770 TRUE), /* pcrel_offset */
1771
1772 /* Like R_NDS32_HI20, but referring to the TLS entry for the symbol. */
1773 HOWTO (R_NDS32_TLS_LE_HI20, /* type */
1774 12, /* rightshift */
1775 2, /* size (0 = byte, 1 = short, 2 = long) */
1776 20, /* bitsize */
1777 FALSE, /* pc_relative */
1778 0, /* bitpos */
1779 complain_overflow_dont, /* complain_on_overflow */
1780 bfd_elf_generic_reloc, /* special_function */
1781 "R_NDS32_TLS_LE_HI20", /* name */
1782 FALSE, /* partial_inplace */
1783 0x000fffff, /* src_mask */
1784 0x000fffff, /* dst_mask */
1785 FALSE), /* pcrel_offset */
1786 HOWTO (R_NDS32_TLS_LE_LO12, /* type */
1787 0, /* rightshift */
1788 2, /* size (0 = byte, 1 = short, 2 = long) */
1789 12, /* bitsize */
1790 FALSE, /* pc_relative */
1791 0, /* bitpos */
1792 complain_overflow_dont, /* complain_on_overflow */
1793 bfd_elf_generic_reloc, /* special_function */
1794 "R_NDS32_TLS_LE_LO12", /* name */
1795 FALSE, /* partial_inplace */
1796 0x00000fff, /* src_mask */
1797 0x00000fff, /* dst_mask */
1798 FALSE), /* pcrel_offset */
1799
1800 /* Like R_NDS32_HI20, but referring to the TLS entry for the symbol. */
1801 HOWTO (R_NDS32_TLS_IE_HI20, /* type */
1802 12, /* rightshift */
1803 2, /* size (0 = byte, 1 = short, 2 = long) */
1804 20, /* bitsize */
1805 FALSE, /* pc_relative */
1806 0, /* bitpos */
1807 complain_overflow_dont, /* complain_on_overflow */
1808 bfd_elf_generic_reloc, /* special_function */
1809 "R_NDS32_TLS_IE_HI20", /* name */
1810 FALSE, /* partial_inplace */
1811 0x000fffff, /* src_mask */
1812 0x000fffff, /* dst_mask */
1813 FALSE), /* pcrel_offset */
1814 HOWTO (R_NDS32_TLS_IE_LO12S2, /* type */
1815 2, /* rightshift */
1816 2, /* size (0 = byte, 1 = short, 2 = long) */
1817 10, /* bitsize */
1818 FALSE, /* pc_relative */
1819 0, /* bitpos */
1820 complain_overflow_dont, /* complain_on_overflow */
1821 bfd_elf_generic_reloc, /* special_function */
1822 "R_NDS32_TLS_IE_LO12S2", /* name */
1823 FALSE, /* partial_inplace */
1824 0x000003ff, /* src_mask */
1825 0x000003ff, /* dst_mask */
1826 FALSE), /* pcrel_offset */
1827 /* Mark a TLS IE entry in GOT. */
1828 HOWTO (R_NDS32_TLS_TPOFF, /* type */
1829 0, /* rightshift */
1830 2, /* size (0 = byte, 1 = short, 2 = long) */
1831 32, /* bitsize */
1832 FALSE, /* pc_relative */
1833 0, /* bitpos */
1834 complain_overflow_bitfield, /* complain_on_overflow */
1835 bfd_elf_generic_reloc, /* special_function */
1836 "R_NDS32_TLS_TPOFF", /* name */
1837 FALSE, /* partial_inplace */
1838 0xffffffff, /* src_mask */
1839 0xffffffff, /* dst_mask */
1840 FALSE), /* pcrel_offset */
1841 /* A 20 bit address. */
1842 HOWTO (R_NDS32_TLS_LE_20, /* type */
1843 0, /* rightshift */
1844 2, /* size (0 = byte, 1 = short, 2 = long) */
1845 20, /* bitsize */
1846 FALSE, /* pc_relative */
1847 0, /* bitpos */
1848 complain_overflow_signed, /* complain_on_overflow */
1849 bfd_elf_generic_reloc, /* special_function */
1850 "R_NDS32_TLS_LE_20", /* name */
1851 FALSE, /* partial_inplace */
1852 0xfffff, /* src_mask */
1853 0xfffff, /* dst_mask */
1854 FALSE), /* pcrel_offset */
1855 HOWTO (R_NDS32_TLS_LE_15S0, /* type */
1856 0, /* rightshift */
1857 2, /* size (0 = byte, 1 = short, 2 = long) */
1858 15, /* bitsize */
1859 FALSE, /* pc_relative */
1860 0, /* bitpos */
1861 complain_overflow_signed, /* complain_on_overflow */
1862 bfd_elf_generic_reloc, /* special_function */
1863 "R_NDS32_TLS_LE_15S0", /* name */
1864 FALSE, /* partial_inplace */
1865 0x7fff, /* src_mask */
1866 0x7fff, /* dst_mask */
1867 FALSE), /* pcrel_offset */
1868 HOWTO (R_NDS32_TLS_LE_15S1, /* type */
1869 1, /* rightshift */
1870 2, /* size (0 = byte, 1 = short, 2 = long) */
1871 15, /* bitsize */
1872 FALSE, /* pc_relative */
1873 0, /* bitpos */
1874 complain_overflow_signed, /* complain_on_overflow */
1875 bfd_elf_generic_reloc, /* special_function */
1876 "R_NDS32_TLS_LE_15S1", /* name */
1877 FALSE, /* partial_inplace */
1878 0x7fff, /* src_mask */
1879 0x7fff, /* dst_mask */
1880 FALSE), /* pcrel_offset */
1881 HOWTO (R_NDS32_TLS_LE_15S2, /* type */
1882 2, /* rightshift */
1883 2, /* size (0 = byte, 1 = short, 2 = long) */
1884 15, /* bitsize */
1885 FALSE, /* pc_relative */
1886 0, /* bitpos */
1887 complain_overflow_signed, /* complain_on_overflow */
1888 bfd_elf_generic_reloc, /* special_function */
1889 "R_NDS32_TLS_LE_15S2", /* name */
1890 FALSE, /* partial_inplace */
1891 0x7fff, /* src_mask */
1892 0x7fff, /* dst_mask */
1893 FALSE), /* pcrel_offset */
1894
1895 /* Relax hint for unconditional call sequence */
1896 HOWTO (R_NDS32_LONGCALL4, /* type */
1897 0, /* rightshift */
1898 2, /* size (0 = byte, 1 = short, 2 = long) */
1899 32, /* bitsize */
1900 FALSE, /* pc_relative */
1901 0, /* bitpos */
1902 complain_overflow_dont, /* complain_on_overflow */
1903 nds32_elf_ignore_reloc, /* special_function */
1904 "R_NDS32_LONGCALL4", /* name */
1905 FALSE, /* partial_inplace */
1906 0xffffffff, /* src_mask */
1907 0xffffffff, /* dst_mask */
1908 FALSE), /* pcrel_offset */
1909
1910 /* Relax hint for conditional call sequence. */
1911 HOWTO (R_NDS32_LONGCALL5, /* type */
1912 0, /* rightshift */
1913 2, /* size (0 = byte, 1 = short, 2 = long) */
1914 32, /* bitsize */
1915 FALSE, /* pc_relative */
1916 0, /* bitpos */
1917 complain_overflow_dont, /* complain_on_overflow */
1918 nds32_elf_ignore_reloc, /* special_function */
1919 "R_NDS32_LONGCALL5", /* name */
1920 FALSE, /* partial_inplace */
1921 0xffffffff, /* src_mask */
1922 0xffffffff, /* dst_mask */
1923 FALSE), /* pcrel_offset */
1924
1925 /* Relax hint for conditional call sequence. */
1926 HOWTO (R_NDS32_LONGCALL6, /* type */
1927 0, /* rightshift */
1928 2, /* size (0 = byte, 1 = short, 2 = long) */
1929 32, /* bitsize */
1930 FALSE, /* pc_relative */
1931 0, /* bitpos */
1932 complain_overflow_dont, /* complain_on_overflow */
1933 nds32_elf_ignore_reloc, /* special_function */
1934 "R_NDS32_LONGCALL6", /* name */
1935 FALSE, /* partial_inplace */
1936 0xffffffff, /* src_mask */
1937 0xffffffff, /* dst_mask */
1938 FALSE), /* pcrel_offset */
1939
1940 /* Relax hint for unconditional branch sequence. */
1941 HOWTO (R_NDS32_LONGJUMP4, /* type */
1942 0, /* rightshift */
1943 2, /* size (0 = byte, 1 = short, 2 = long) */
1944 32, /* bitsize */
1945 FALSE, /* pc_relative */
1946 0, /* bitpos */
1947 complain_overflow_dont, /* complain_on_overflow */
1948 nds32_elf_ignore_reloc, /* special_function */
1949 "R_NDS32_LONGJUMP4", /* name */
1950 FALSE, /* partial_inplace */
1951 0xffffffff, /* src_mask */
1952 0xffffffff, /* dst_mask */
1953 FALSE), /* pcrel_offset */
1954
1955 /* Relax hint for conditional branch sequence. */
1956 HOWTO (R_NDS32_LONGJUMP5, /* type */
1957 0, /* rightshift */
1958 2, /* size (0 = byte, 1 = short, 2 = long) */
1959 32, /* bitsize */
1960 FALSE, /* pc_relative */
1961 0, /* bitpos */
1962 complain_overflow_dont, /* complain_on_overflow */
1963 nds32_elf_ignore_reloc, /* special_function */
1964 "R_NDS32_LONGJUMP5", /* name */
1965 FALSE, /* partial_inplace */
1966 0xffffffff, /* src_mask */
1967 0xffffffff, /* dst_mask */
1968 FALSE), /* pcrel_offset */
1969
1970 /* Relax hint for conditional branch sequence. */
1971 HOWTO (R_NDS32_LONGJUMP6, /* type */
1972 0, /* rightshift */
1973 2, /* size (0 = byte, 1 = short, 2 = long) */
1974 32, /* bitsize */
1975 FALSE, /* pc_relative */
1976 0, /* bitpos */
1977 complain_overflow_dont, /* complain_on_overflow */
1978 nds32_elf_ignore_reloc, /* special_function */
1979 "R_NDS32_LONGJUMP6", /* name */
1980 FALSE, /* partial_inplace */
1981 0xffffffff, /* src_mask */
1982 0xffffffff, /* dst_mask */
1983 FALSE), /* pcrel_offset */
1984
1985 /* Relax hint for conditional branch sequence. */
1986 HOWTO (R_NDS32_LONGJUMP7, /* type */
1987 0, /* rightshift */
1988 2, /* size (0 = byte, 1 = short, 2 = long) */
1989 32, /* bitsize */
1990 FALSE, /* pc_relative */
1991 0, /* bitpos */
1992 complain_overflow_dont, /* complain_on_overflow */
1993 nds32_elf_ignore_reloc, /* special_function */
1994 "R_NDS32_LONGJUMP7", /* name */
1995 FALSE, /* partial_inplace */
1996 0xffffffff, /* src_mask */
1997 0xffffffff, /* dst_mask */
1998 FALSE), /* pcrel_offset */
1999 };
2000
2001 /* Relocations used for relaxation. */
2002 static reloc_howto_type nds32_elf_relax_howto_table[] =
2003 {
2004 HOWTO (R_NDS32_RELAX_ENTRY, /* type */
2005 0, /* rightshift */
2006 2, /* size (0 = byte, 1 = short, 2 = long) */
2007 32, /* bitsize */
2008 FALSE, /* pc_relative */
2009 0, /* bitpos */
2010 complain_overflow_dont,/* complain_on_overflow */
2011 nds32_elf_ignore_reloc,/* special_function */
2012 "R_NDS32_RELAX_ENTRY", /* name */
2013 FALSE, /* partial_inplace */
2014 0xffffffff, /* src_mask */
2015 0xffffffff, /* dst_mask */
2016 FALSE), /* pcrel_offset */
2017 HOWTO (R_NDS32_GOT_SUFF, /* type */
2018 0, /* rightshift */
2019 2, /* size (0 = byte, 1 = short, 2 = long) */
2020 32, /* bitsize */
2021 FALSE, /* pc_relative */
2022 0, /* bitpos */
2023 complain_overflow_dont,/* complain_on_overflow */
2024 nds32_elf_ignore_reloc,/* special_function */
2025 "R_NDS32_GOT_SUFF", /* name */
2026 FALSE, /* partial_inplace */
2027 0xffffffff, /* src_mask */
2028 0xffffffff, /* dst_mask */
2029 FALSE), /* pcrel_offset */
2030 HOWTO (R_NDS32_GOTOFF_SUFF, /* type */
2031 0, /* rightshift */
2032 2, /* size (0 = byte, 1 = short, 2 = long) */
2033 32, /* bitsize */
2034 FALSE, /* pc_relative */
2035 0, /* bitpos */
2036 complain_overflow_bitfield, /* complain_on_overflow */
2037 nds32_elf_ignore_reloc,/* special_function */
2038 "R_NDS32_GOTOFF_SUFF", /* name */
2039 FALSE, /* partial_inplace */
2040 0xffffffff, /* src_mask */
2041 0xffffffff, /* dst_mask */
2042 FALSE), /* pcrel_offset */
2043 HOWTO (R_NDS32_PLT_GOT_SUFF, /* type */
2044 0, /* rightshift */
2045 2, /* size (0 = byte, 1 = short, 2 = long) */
2046 32, /* bitsize */
2047 FALSE, /* pc_relative */
2048 0, /* bitpos */
2049 complain_overflow_dont,/* complain_on_overflow */
2050 nds32_elf_ignore_reloc,/* special_function */
2051 "R_NDS32_PLT_GOT_SUFF",/* name */
2052 FALSE, /* partial_inplace */
2053 0xffffffff, /* src_mask */
2054 0xffffffff, /* dst_mask */
2055 FALSE), /* pcrel_offset */
2056 HOWTO (R_NDS32_MULCALL_SUFF, /* type */
2057 0, /* rightshift */
2058 2, /* size (0 = byte, 1 = short, 2 = long) */
2059 32, /* bitsize */
2060 FALSE, /* pc_relative */
2061 0, /* bitpos */
2062 complain_overflow_dont,/* complain_on_overflow */
2063 nds32_elf_ignore_reloc,/* special_function */
2064 "R_NDS32_MULCALL_SUFF",/* name */
2065 FALSE, /* partial_inplace */
2066 0xffffffff, /* src_mask */
2067 0xffffffff, /* dst_mask */
2068 FALSE), /* pcrel_offset */
2069 HOWTO (R_NDS32_PTR, /* type */
2070 0, /* rightshift */
2071 2, /* size (0 = byte, 1 = short, 2 = long) */
2072 32, /* bitsize */
2073 FALSE, /* pc_relative */
2074 0, /* bitpos */
2075 complain_overflow_dont,/* complain_on_overflow */
2076 nds32_elf_ignore_reloc,/* special_function */
2077 "R_NDS32_PTR", /* name */
2078 FALSE, /* partial_inplace */
2079 0xffffffff, /* src_mask */
2080 0xffffffff, /* dst_mask */
2081 FALSE), /* pcrel_offset */
2082 HOWTO (R_NDS32_PTR_COUNT, /* type */
2083 0, /* rightshift */
2084 2, /* size (0 = byte, 1 = short, 2 = long) */
2085 32, /* bitsize */
2086 FALSE, /* pc_relative */
2087 0, /* bitpos */
2088 complain_overflow_dont,/* complain_on_overflow */
2089 nds32_elf_ignore_reloc,/* special_function */
2090 "R_NDS32_PTR_COUNT", /* name */
2091 FALSE, /* partial_inplace */
2092 0xffffffff, /* src_mask */
2093 0xffffffff, /* dst_mask */
2094 FALSE), /* pcrel_offset */
2095 HOWTO (R_NDS32_PTR_RESOLVED, /* type */
2096 0, /* rightshift */
2097 2, /* size (0 = byte, 1 = short, 2 = long) */
2098 32, /* bitsize */
2099 FALSE, /* pc_relative */
2100 0, /* bitpos */
2101 complain_overflow_dont,/* complain_on_overflow */
2102 nds32_elf_ignore_reloc,/* special_function */
2103 "R_NDS32_PTR_RESOLVED",/* name */
2104 FALSE, /* partial_inplace */
2105 0xffffffff, /* src_mask */
2106 0xffffffff, /* dst_mask */
2107 FALSE), /* pcrel_offset */
2108 HOWTO (R_NDS32_PLTBLOCK, /* type */
2109 0, /* rightshift */
2110 2, /* size (0 = byte, 1 = short, 2 = long) */
2111 32, /* bitsize */
2112 FALSE, /* pc_relative */
2113 0, /* bitpos */
2114 complain_overflow_dont,/* complain_on_overflow */
2115 nds32_elf_ignore_reloc,/* special_function */
2116 "R_NDS32_PLTBLOCK", /* name */
2117 FALSE, /* partial_inplace */
2118 0xffffffff, /* src_mask */
2119 0xffffffff, /* dst_mask */
2120 FALSE), /* pcrel_offset */
2121 HOWTO (R_NDS32_RELAX_REGION_BEGIN, /* type */
2122 0, /* rightshift */
2123 2, /* size (0 = byte, 1 = short, 2 = long) */
2124 32, /* bitsize */
2125 FALSE, /* pc_relative */
2126 0, /* bitpos */
2127 complain_overflow_dont,/* complain_on_overflow */
2128 nds32_elf_ignore_reloc,/* special_function */
2129 "R_NDS32_RELAX_REGION_BEGIN", /* name */
2130 FALSE, /* partial_inplace */
2131 0xffffffff, /* src_mask */
2132 0xffffffff, /* dst_mask */
2133 FALSE), /* pcrel_offset */
2134 HOWTO (R_NDS32_RELAX_REGION_END, /* type */
2135 0, /* rightshift */
2136 2, /* size (0 = byte, 1 = short, 2 = long) */
2137 32, /* bitsize */
2138 FALSE, /* pc_relative */
2139 0, /* bitpos */
2140 complain_overflow_dont,/* complain_on_overflow */
2141 nds32_elf_ignore_reloc,/* special_function */
2142 "R_NDS32_RELAX_REGION_END", /* name */
2143 FALSE, /* partial_inplace */
2144 0xffffffff, /* src_mask */
2145 0xffffffff, /* dst_mask */
2146 FALSE), /* pcrel_offset */
2147 HOWTO (R_NDS32_MINUEND, /* type */
2148 0, /* rightshift */
2149 2, /* size (0 = byte, 1 = short, 2 = long) */
2150 32, /* bitsize */
2151 FALSE, /* pc_relative */
2152 0, /* bitpos */
2153 complain_overflow_dont,/* complain_on_overflow */
2154 nds32_elf_ignore_reloc,/* special_function */
2155 "R_NDS32_MINUEND", /* name */
2156 FALSE, /* partial_inplace */
2157 0xffffffff, /* src_mask */
2158 0xffffffff, /* dst_mask */
2159 FALSE), /* pcrel_offset */
2160 HOWTO (R_NDS32_SUBTRAHEND, /* type */
2161 0, /* rightshift */
2162 2, /* size (0 = byte, 1 = short, 2 = long) */
2163 32, /* bitsize */
2164 FALSE, /* pc_relative */
2165 0, /* bitpos */
2166 complain_overflow_dont,/* complain_on_overflow */
2167 nds32_elf_ignore_reloc,/* special_function */
2168 "R_NDS32_SUBTRAHEND", /* name */
2169 FALSE, /* partial_inplace */
2170 0xffffffff, /* src_mask */
2171 0xffffffff, /* dst_mask */
2172 FALSE), /* pcrel_offset */
2173 HOWTO (R_NDS32_DIFF8, /* type */
2174 0, /* rightshift */
2175 0, /* size (0 = byte, 1 = short, 2 = long) */
2176 8, /* bitsize */
2177 FALSE, /* pc_relative */
2178 0, /* bitpos */
2179 complain_overflow_dont,/* complain_on_overflow */
2180 nds32_elf_ignore_reloc,/* special_function */
2181 "R_NDS32_DIFF8", /* name */
2182 FALSE, /* partial_inplace */
2183 0x000000ff, /* src_mask */
2184 0x000000ff, /* dst_mask */
2185 FALSE), /* pcrel_offset */
2186 HOWTO (R_NDS32_DIFF16, /* type */
2187 0, /* rightshift */
2188 1, /* size (0 = byte, 1 = short, 2 = long) */
2189 16, /* bitsize */
2190 FALSE, /* pc_relative */
2191 0, /* bitpos */
2192 complain_overflow_dont,/* complain_on_overflow */
2193 nds32_elf_ignore_reloc,/* special_function */
2194 "R_NDS32_DIFF16", /* name */
2195 FALSE, /* partial_inplace */
2196 0x0000ffff, /* src_mask */
2197 0x0000ffff, /* dst_mask */
2198 FALSE), /* pcrel_offset */
2199 HOWTO (R_NDS32_DIFF32, /* type */
2200 0, /* rightshift */
2201 2, /* size (0 = byte, 1 = short, 2 = long) */
2202 32, /* bitsize */
2203 FALSE, /* pc_relative */
2204 0, /* bitpos */
2205 complain_overflow_dont,/* complain_on_overflow */
2206 nds32_elf_ignore_reloc,/* special_function */
2207 "R_NDS32_DIFF32", /* name */
2208 FALSE, /* partial_inplace */
2209 0xffffffff, /* src_mask */
2210 0xffffffff, /* dst_mask */
2211 FALSE), /* pcrel_offset */
2212 HOWTO (R_NDS32_DIFF_ULEB128, /* type */
2213 0, /* rightshift */
2214 0, /* size (0 = byte, 1 = short, 2 = long) */
2215 0, /* bitsize */
2216 FALSE, /* pc_relative */
2217 0, /* bitpos */
2218 complain_overflow_dont,/* complain_on_overflow */
2219 nds32_elf_ignore_reloc,/* special_function */
2220 "R_NDS32_DIFF_ULEB128",/* name */
2221 FALSE, /* partial_inplace */
2222 0xffffffff, /* src_mask */
2223 0xffffffff, /* dst_mask */
2224 FALSE), /* pcrel_offset */
2225 HOWTO (R_NDS32_DATA, /* type */
2226 0, /* rightshift */
2227 2, /* size (0 = byte, 1 = short, 2 = long) */
2228 32, /* bitsize */
2229 FALSE, /* pc_relative */
2230 0, /* bitpos */
2231 complain_overflow_dont,/* complain_on_overflow */
2232 nds32_elf_ignore_reloc,/* special_function */
2233 "R_NDS32_DATA", /* name */
2234 FALSE, /* partial_inplace */
2235 0xffffffff, /* src_mask */
2236 0xffffffff, /* dst_mask */
2237 FALSE), /* pcrel_offset */
2238 HOWTO (R_NDS32_TRAN, /* type */
2239 0, /* rightshift */
2240 2, /* size (0 = byte, 1 = short, 2 = long) */
2241 32, /* bitsize */
2242 FALSE, /* pc_relative */
2243 0, /* bitpos */
2244 complain_overflow_dont,/* complain_on_overflow */
2245 nds32_elf_ignore_reloc,/* special_function */
2246 "R_NDS32_TRAN", /* name */
2247 FALSE, /* partial_inplace */
2248 0xffffffff, /* src_mask */
2249 0xffffffff, /* dst_mask */
2250 FALSE), /* pcrel_offset */
2251 HOWTO (R_NDS32_TLS_LE_ADD, /* type */
2252 0, /* rightshift */
2253 2, /* size (0 = byte, 1 = short, 2 = long) */
2254 32, /* bitsize */
2255 FALSE, /* pc_relative */
2256 0, /* bitpos */
2257 complain_overflow_dont, /* complain_on_overflow */
2258 nds32_elf_ignore_reloc, /* special_function */
2259 "R_NDS32_TLS_LE_ADD", /* name */
2260 FALSE, /* partial_inplace */
2261 0xffffffff, /* src_mask */
2262 0xffffffff, /* dst_mask */
2263 FALSE), /* pcrel_offset */
2264 HOWTO (R_NDS32_TLS_LE_LS, /* type */
2265 0, /* rightshift */
2266 2, /* size (0 = byte, 1 = short, 2 = long) */
2267 32, /* bitsize */
2268 FALSE, /* pc_relative */
2269 0, /* bitpos */
2270 complain_overflow_dont, /* complain_on_overflow */
2271 nds32_elf_ignore_reloc, /* special_function */
2272 "R_NDS32_TLS_LE_LS", /* name */
2273 FALSE, /* partial_inplace */
2274 0xffffffff, /* src_mask */
2275 0xffffffff, /* dst_mask */
2276 FALSE), /* pcrel_offset */
2277 HOWTO (R_NDS32_EMPTY, /* type */
2278 0, /* rightshift */
2279 2, /* size (0 = byte, 1 = short, 2 = long) */
2280 32, /* bitsize */
2281 FALSE, /* pc_relative */
2282 0, /* bitpos */
2283 complain_overflow_dont, /* complain_on_overflow */
2284 nds32_elf_ignore_reloc, /* special_function */
2285 "R_NDS32_EMPTY", /* name */
2286 FALSE, /* partial_inplace */
2287 0xffffffff, /* src_mask */
2288 0xffffffff, /* dst_mask */
2289 FALSE), /* pcrel_offset */
2290 };
2291
2292
2293 /* nds32_insertion_sort sorts an array with nmemb elements of size size.
2294 This prototype is the same as qsort (). */
2295
2296 void
nds32_insertion_sort(void * base,size_t nmemb,size_t size,int (* compar)(const void * lhs,const void * rhs))2297 nds32_insertion_sort (void *base, size_t nmemb, size_t size,
2298 int (*compar) (const void *lhs, const void *rhs))
2299 {
2300 char *ptr = (char *) base;
2301 int i, j;
2302 char *tmp = alloca (size);
2303
2304 /* If i is less than j, i is inserted before j.
2305
2306 |---- j ----- i --------------|
2307 \ / \ /
2308 sorted unsorted
2309 */
2310
2311 for (i = 1; i < (int) nmemb; i++)
2312 {
2313 for (j = (i - 1); j >= 0; j--)
2314 if (compar (ptr + i * size, ptr + j * size) >= 0)
2315 break;
2316
2317 j++;
2318
2319 if (i == j)
2320 continue; /* i is in order. */
2321
2322 memcpy (tmp, ptr + i * size, size);
2323 memmove (ptr + (j + 1) * size, ptr + j * size, (i - j) * size);
2324 memcpy (ptr + j * size, tmp, size);
2325 }
2326 }
2327
2328 /* Sort relocation by r_offset.
2329
2330 We didn't use qsort () in stdlib, because quick-sort is not a stable sorting
2331 algorithm. Relocations at the same r_offset must keep their order.
2332 For example, RELAX_ENTRY must be the very first relocation entry.
2333
2334 Currently, this function implements insertion-sort.
2335
2336 FIXME: If we already sort them in assembler, why bother sort them
2337 here again? */
2338
2339 static int
compar_reloc(const void * lhs,const void * rhs)2340 compar_reloc (const void *lhs, const void *rhs)
2341 {
2342 const Elf_Internal_Rela *l = (const Elf_Internal_Rela *) lhs;
2343 const Elf_Internal_Rela *r = (const Elf_Internal_Rela *) rhs;
2344
2345 if (l->r_offset > r->r_offset)
2346 return 1;
2347 else if (l->r_offset == r->r_offset)
2348 return 0;
2349 else
2350 return -1;
2351 }
2352
2353 /* Functions listed below are only used for old relocs.
2354 * nds32_elf_9_pcrel_reloc
2355 * nds32_elf_do_9_pcrel_reloc
2356 * nds32_elf_hi20_reloc
2357 * nds32_elf_relocate_hi20
2358 * nds32_elf_lo12_reloc
2359 * nds32_elf_sda15_reloc
2360 * nds32_elf_generic_reloc
2361 */
2362
2363 /* Handle the R_NDS32_9_PCREL & R_NDS32_9_PCREL_RELA reloc. */
2364
2365 static bfd_reloc_status_type
nds32_elf_9_pcrel_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)2366 nds32_elf_9_pcrel_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2367 void *data, asection *input_section, bfd *output_bfd,
2368 char **error_message ATTRIBUTE_UNUSED)
2369 {
2370 /* This part is from bfd_elf_generic_reloc. */
2371 if (output_bfd != (bfd *) NULL
2372 && (symbol->flags & BSF_SECTION_SYM) == 0
2373 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2374 {
2375 reloc_entry->address += input_section->output_offset;
2376 return bfd_reloc_ok;
2377 }
2378
2379 if (output_bfd != NULL)
2380 {
2381 /* FIXME: See bfd_perform_relocation. Is this right? */
2382 return bfd_reloc_continue;
2383 }
2384
2385 return nds32_elf_do_9_pcrel_reloc (abfd, reloc_entry->howto,
2386 input_section,
2387 data, reloc_entry->address,
2388 symbol->section,
2389 (symbol->value
2390 + symbol->section->output_section->vma
2391 + symbol->section->output_offset),
2392 reloc_entry->addend);
2393 }
2394
2395 /* Utility to actually perform an R_NDS32_9_PCREL reloc. */
2396 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
2397
2398 static bfd_reloc_status_type
nds32_elf_do_9_pcrel_reloc(bfd * abfd,reloc_howto_type * howto,asection * input_section,bfd_byte * data,bfd_vma offset,asection * symbol_section ATTRIBUTE_UNUSED,bfd_vma symbol_value,bfd_vma addend)2399 nds32_elf_do_9_pcrel_reloc (bfd *abfd, reloc_howto_type *howto,
2400 asection *input_section, bfd_byte *data,
2401 bfd_vma offset,
2402 asection *symbol_section ATTRIBUTE_UNUSED,
2403 bfd_vma symbol_value, bfd_vma addend)
2404 {
2405 bfd_signed_vma relocation;
2406 unsigned short x;
2407 bfd_reloc_status_type status;
2408
2409 /* Sanity check the address (offset in section). */
2410 if (offset > bfd_get_section_limit (abfd, input_section))
2411 return bfd_reloc_outofrange;
2412
2413 relocation = symbol_value + addend;
2414 /* Make it pc relative. */
2415 relocation -= (input_section->output_section->vma
2416 + input_section->output_offset);
2417 /* These jumps mask off the lower two bits of the current address
2418 before doing pcrel calculations. */
2419 relocation -= (offset & -(bfd_vma) 2);
2420
2421 if (relocation < -ACCURATE_8BIT_S1 || relocation >= ACCURATE_8BIT_S1)
2422 status = bfd_reloc_overflow;
2423 else
2424 status = bfd_reloc_ok;
2425
2426 x = bfd_getb16 (data + offset);
2427
2428 relocation >>= howto->rightshift;
2429 relocation <<= howto->bitpos;
2430 x = (x & ~howto->dst_mask)
2431 | (((x & howto->src_mask) + relocation) & howto->dst_mask);
2432
2433 bfd_putb16 ((bfd_vma) x, data + offset);
2434
2435 return status;
2436 }
2437
2438 /* Handle the R_NDS32_HI20_[SU]LO relocs.
2439 HI20_SLO is for the add3 and load/store with displacement instructions.
2440 HI20 is for the or3 instruction.
2441 For R_NDS32_HI20_SLO, the lower 16 bits are sign extended when added to
2442 the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
2443 we must add one to the high 16 bytes (which will get subtracted off when
2444 the low 16 bits are added).
2445 These relocs have to be done in combination with an R_NDS32_LO12 reloc
2446 because there is a carry from the LO12 to the HI20. Here we just save
2447 the information we need; we do the actual relocation when we see the LO12.
2448 This code is copied from the elf32-mips.c. We also support an arbitrary
2449 number of HI20 relocs to be associated with a single LO12 reloc. The
2450 assembler sorts the relocs to ensure each HI20 immediately precedes its
2451 LO12. However if there are multiple copies, the assembler may not find
2452 the real LO12 so it picks the first one it finds. */
2453
2454 struct nds32_hi20
2455 {
2456 struct nds32_hi20 *next;
2457 bfd_byte *addr;
2458 bfd_vma addend;
2459 };
2460
2461 static struct nds32_hi20 *nds32_hi20_list;
2462
2463 static bfd_reloc_status_type
nds32_elf_hi20_reloc(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)2464 nds32_elf_hi20_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2465 asymbol *symbol, void *data, asection *input_section,
2466 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2467 {
2468 bfd_reloc_status_type ret;
2469 bfd_vma relocation;
2470 struct nds32_hi20 *n;
2471
2472 /* This part is from bfd_elf_generic_reloc.
2473 If we're relocating, and this an external symbol, we don't want
2474 to change anything. */
2475 if (output_bfd != (bfd *) NULL
2476 && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0)
2477 {
2478 reloc_entry->address += input_section->output_offset;
2479 return bfd_reloc_ok;
2480 }
2481
2482 /* Sanity check the address (offset in section). */
2483 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2484 return bfd_reloc_outofrange;
2485
2486 ret = bfd_reloc_ok;
2487 if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2488 ret = bfd_reloc_undefined;
2489
2490 if (bfd_is_com_section (symbol->section))
2491 relocation = 0;
2492 else
2493 relocation = symbol->value;
2494
2495 relocation += symbol->section->output_section->vma;
2496 relocation += symbol->section->output_offset;
2497 relocation += reloc_entry->addend;
2498
2499 /* Save the information, and let LO12 do the actual relocation. */
2500 n = (struct nds32_hi20 *) bfd_malloc ((bfd_size_type) sizeof *n);
2501 if (n == NULL)
2502 return bfd_reloc_outofrange;
2503
2504 n->addr = (bfd_byte *) data + reloc_entry->address;
2505 n->addend = relocation;
2506 n->next = nds32_hi20_list;
2507 nds32_hi20_list = n;
2508
2509 if (output_bfd != (bfd *) NULL)
2510 reloc_entry->address += input_section->output_offset;
2511
2512 return ret;
2513 }
2514
2515 /* Handle an NDS32 ELF HI20 reloc. */
2516
2517 static void
nds32_elf_relocate_hi20(bfd * input_bfd ATTRIBUTE_UNUSED,int type ATTRIBUTE_UNUSED,Elf_Internal_Rela * relhi,Elf_Internal_Rela * rello,bfd_byte * contents,bfd_vma addend)2518 nds32_elf_relocate_hi20 (bfd *input_bfd ATTRIBUTE_UNUSED,
2519 int type ATTRIBUTE_UNUSED, Elf_Internal_Rela *relhi,
2520 Elf_Internal_Rela *rello, bfd_byte *contents,
2521 bfd_vma addend)
2522 {
2523 unsigned long insn;
2524 bfd_vma addlo;
2525
2526 insn = bfd_getb32 (contents + relhi->r_offset);
2527
2528 addlo = bfd_getb32 (contents + rello->r_offset);
2529 addlo &= 0xfff;
2530
2531 addend += ((insn & 0xfffff) << 20) + addlo;
2532
2533 insn = (insn & 0xfff00000) | ((addend >> 12) & 0xfffff);
2534 bfd_putb32 (insn, contents + relhi->r_offset);
2535 }
2536
2537 /* Do an R_NDS32_LO12 relocation. This is a straightforward 12 bit
2538 inplace relocation; this function exists in order to do the
2539 R_NDS32_HI20_[SU]LO relocation described above. */
2540
2541 static bfd_reloc_status_type
nds32_elf_lo12_reloc(bfd * input_bfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message)2542 nds32_elf_lo12_reloc (bfd *input_bfd, arelent *reloc_entry, asymbol *symbol,
2543 void *data, asection *input_section, bfd *output_bfd,
2544 char **error_message)
2545 {
2546 /* This part is from bfd_elf_generic_reloc.
2547 If we're relocating, and this an external symbol, we don't want
2548 to change anything. */
2549 if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2550 && reloc_entry->addend == 0)
2551 {
2552 reloc_entry->address += input_section->output_offset;
2553 return bfd_reloc_ok;
2554 }
2555
2556 if (nds32_hi20_list != NULL)
2557 {
2558 struct nds32_hi20 *l;
2559
2560 l = nds32_hi20_list;
2561 while (l != NULL)
2562 {
2563 unsigned long insn;
2564 unsigned long val;
2565 unsigned long vallo;
2566 struct nds32_hi20 *next;
2567
2568 /* Do the HI20 relocation. Note that we actually don't need
2569 to know anything about the LO12 itself, except where to
2570 find the low 12 bits of the addend needed by the LO12. */
2571 insn = bfd_getb32 (l->addr);
2572 vallo = bfd_getb32 ((bfd_byte *) data + reloc_entry->address);
2573 vallo &= 0xfff;
2574 switch (reloc_entry->howto->type)
2575 {
2576 case R_NDS32_LO12S3:
2577 vallo <<= 3;
2578 break;
2579
2580 case R_NDS32_LO12S2:
2581 vallo <<= 2;
2582 break;
2583
2584 case R_NDS32_LO12S1:
2585 vallo <<= 1;
2586 break;
2587
2588 case R_NDS32_LO12S0:
2589 vallo <<= 0;
2590 break;
2591 }
2592
2593 val = ((insn & 0xfffff) << 12) + vallo;
2594 val += l->addend;
2595
2596 insn = (insn & ~(bfd_vma) 0xfffff) | ((val >> 12) & 0xfffff);
2597 bfd_putb32 ((bfd_vma) insn, l->addr);
2598
2599 next = l->next;
2600 free (l);
2601 l = next;
2602 }
2603
2604 nds32_hi20_list = NULL;
2605 }
2606
2607 /* Now do the LO12 reloc in the usual way.
2608 ??? It would be nice to call bfd_elf_generic_reloc here,
2609 but we have partial_inplace set. bfd_elf_generic_reloc will
2610 pass the handling back to bfd_install_relocation which will install
2611 a section relative addend which is wrong. */
2612 return nds32_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
2613 input_section, output_bfd, error_message);
2614 }
2615
2616 /* Do generic partial_inplace relocation.
2617 This is a local replacement for bfd_elf_generic_reloc. */
2618
2619 static bfd_reloc_status_type
nds32_elf_generic_reloc(bfd * input_bfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)2620 nds32_elf_generic_reloc (bfd *input_bfd, arelent *reloc_entry,
2621 asymbol *symbol, void *data, asection *input_section,
2622 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2623 {
2624 bfd_reloc_status_type ret;
2625 bfd_vma relocation;
2626 bfd_byte *inplace_address;
2627
2628 /* This part is from bfd_elf_generic_reloc.
2629 If we're relocating, and this an external symbol, we don't want
2630 to change anything. */
2631 if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2632 && reloc_entry->addend == 0)
2633 {
2634 reloc_entry->address += input_section->output_offset;
2635 return bfd_reloc_ok;
2636 }
2637
2638 /* Now do the reloc in the usual way.
2639 ??? It would be nice to call bfd_elf_generic_reloc here,
2640 but we have partial_inplace set. bfd_elf_generic_reloc will
2641 pass the handling back to bfd_install_relocation which will install
2642 a section relative addend which is wrong. */
2643
2644 /* Sanity check the address (offset in section). */
2645 if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
2646 return bfd_reloc_outofrange;
2647
2648 ret = bfd_reloc_ok;
2649 if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2650 ret = bfd_reloc_undefined;
2651
2652 if (bfd_is_com_section (symbol->section) || output_bfd != (bfd *) NULL)
2653 relocation = 0;
2654 else
2655 relocation = symbol->value;
2656
2657 /* Only do this for a final link. */
2658 if (output_bfd == (bfd *) NULL)
2659 {
2660 relocation += symbol->section->output_section->vma;
2661 relocation += symbol->section->output_offset;
2662 }
2663
2664 relocation += reloc_entry->addend;
2665 switch (reloc_entry->howto->type)
2666 {
2667 case R_NDS32_LO12S3:
2668 relocation >>= 3;
2669 break;
2670
2671 case R_NDS32_LO12S2:
2672 relocation >>= 2;
2673 break;
2674
2675 case R_NDS32_LO12S1:
2676 relocation >>= 1;
2677 break;
2678
2679 case R_NDS32_LO12S0:
2680 default:
2681 relocation >>= 0;
2682 break;
2683 }
2684
2685 inplace_address = (bfd_byte *) data + reloc_entry->address;
2686
2687 #define DOIT(x) \
2688 x = ((x & ~reloc_entry->howto->dst_mask) | \
2689 (((x & reloc_entry->howto->src_mask) + relocation) & \
2690 reloc_entry->howto->dst_mask))
2691
2692 switch (reloc_entry->howto->size)
2693 {
2694 case 1:
2695 {
2696 short x = bfd_getb16 (inplace_address);
2697
2698 DOIT (x);
2699 bfd_putb16 ((bfd_vma) x, inplace_address);
2700 }
2701 break;
2702 case 2:
2703 {
2704 unsigned long x = bfd_getb32 (inplace_address);
2705
2706 DOIT (x);
2707 bfd_putb32 ((bfd_vma) x, inplace_address);
2708 }
2709 break;
2710 default:
2711 BFD_ASSERT (0);
2712 }
2713
2714 if (output_bfd != (bfd *) NULL)
2715 reloc_entry->address += input_section->output_offset;
2716
2717 return ret;
2718 }
2719
2720 /* Handle the R_NDS32_SDA15 reloc.
2721 This reloc is used to compute the address of objects in the small data area
2722 and to perform loads and stores from that area.
2723 The lower 15 bits are sign extended and added to the register specified
2724 in the instruction, which is assumed to point to _SDA_BASE_.
2725
2726 Since the lower 15 bits offset is left-shifted 0, 1 or 2 bits depending on
2727 the access size, this must be taken care of. */
2728
2729 static bfd_reloc_status_type
nds32_elf_sda15_reloc(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry,asymbol * symbol,void * data ATTRIBUTE_UNUSED,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)2730 nds32_elf_sda15_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2731 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2732 asection *input_section, bfd *output_bfd,
2733 char **error_message ATTRIBUTE_UNUSED)
2734 {
2735 /* This part is from bfd_elf_generic_reloc. */
2736 if (output_bfd != (bfd *) NULL
2737 && (symbol->flags & BSF_SECTION_SYM) == 0
2738 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2739 {
2740 reloc_entry->address += input_section->output_offset;
2741 return bfd_reloc_ok;
2742 }
2743
2744 if (output_bfd != NULL)
2745 {
2746 /* FIXME: See bfd_perform_relocation. Is this right? */
2747 return bfd_reloc_continue;
2748 }
2749
2750 /* FIXME: not sure what to do here yet. But then again, the linker
2751 may never call us. */
2752 abort ();
2753 }
2754
2755 /* nds32_elf_ignore_reloc is the special function for
2756 relocation types which don't need to be relocated
2757 like relaxation relocation types.
2758 This function simply return bfd_reloc_ok when it is
2759 invoked. */
2760
2761 static bfd_reloc_status_type
nds32_elf_ignore_reloc(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry,asymbol * symbol ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)2762 nds32_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2763 asymbol *symbol ATTRIBUTE_UNUSED,
2764 void *data ATTRIBUTE_UNUSED, asection *input_section,
2765 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2766 {
2767 if (output_bfd != NULL)
2768 reloc_entry->address += input_section->output_offset;
2769
2770 return bfd_reloc_ok;
2771 }
2772
2773
2774 /* Map BFD reloc types to NDS32 ELF reloc types. */
2775
2776 struct nds32_reloc_map_entry
2777 {
2778 bfd_reloc_code_real_type bfd_reloc_val;
2779 unsigned char elf_reloc_val;
2780 };
2781
2782 static const struct nds32_reloc_map_entry nds32_reloc_map[] =
2783 {
2784 {BFD_RELOC_NONE, R_NDS32_NONE},
2785 {BFD_RELOC_16, R_NDS32_16_RELA},
2786 {BFD_RELOC_32, R_NDS32_32_RELA},
2787 {BFD_RELOC_NDS32_20, R_NDS32_20_RELA},
2788 {BFD_RELOC_NDS32_5, R_NDS32_5_RELA},
2789 {BFD_RELOC_NDS32_9_PCREL, R_NDS32_9_PCREL_RELA},
2790 {BFD_RELOC_NDS32_WORD_9_PCREL, R_NDS32_WORD_9_PCREL_RELA},
2791 {BFD_RELOC_NDS32_15_PCREL, R_NDS32_15_PCREL_RELA},
2792 {BFD_RELOC_NDS32_17_PCREL, R_NDS32_17_PCREL_RELA},
2793 {BFD_RELOC_NDS32_25_PCREL, R_NDS32_25_PCREL_RELA},
2794 {BFD_RELOC_NDS32_10_UPCREL, R_NDS32_10_UPCREL_RELA},
2795 {BFD_RELOC_NDS32_HI20, R_NDS32_HI20_RELA},
2796 {BFD_RELOC_NDS32_LO12S3, R_NDS32_LO12S3_RELA},
2797 {BFD_RELOC_NDS32_LO12S2, R_NDS32_LO12S2_RELA},
2798 {BFD_RELOC_NDS32_LO12S1, R_NDS32_LO12S1_RELA},
2799 {BFD_RELOC_NDS32_LO12S0, R_NDS32_LO12S0_RELA},
2800 {BFD_RELOC_NDS32_LO12S0_ORI, R_NDS32_LO12S0_ORI_RELA},
2801 {BFD_RELOC_NDS32_SDA15S3, R_NDS32_SDA15S3_RELA},
2802 {BFD_RELOC_NDS32_SDA15S2, R_NDS32_SDA15S2_RELA},
2803 {BFD_RELOC_NDS32_SDA15S1, R_NDS32_SDA15S1_RELA},
2804 {BFD_RELOC_NDS32_SDA15S0, R_NDS32_SDA15S0_RELA},
2805 {BFD_RELOC_VTABLE_INHERIT, R_NDS32_RELA_GNU_VTINHERIT},
2806 {BFD_RELOC_VTABLE_ENTRY, R_NDS32_RELA_GNU_VTENTRY},
2807
2808 {BFD_RELOC_NDS32_GOT20, R_NDS32_GOT20},
2809 {BFD_RELOC_NDS32_9_PLTREL, R_NDS32_9_PLTREL},
2810 {BFD_RELOC_NDS32_25_PLTREL, R_NDS32_25_PLTREL},
2811 {BFD_RELOC_NDS32_COPY, R_NDS32_COPY},
2812 {BFD_RELOC_NDS32_GLOB_DAT, R_NDS32_GLOB_DAT},
2813 {BFD_RELOC_NDS32_JMP_SLOT, R_NDS32_JMP_SLOT},
2814 {BFD_RELOC_NDS32_RELATIVE, R_NDS32_RELATIVE},
2815 {BFD_RELOC_NDS32_GOTOFF, R_NDS32_GOTOFF},
2816 {BFD_RELOC_NDS32_GOTPC20, R_NDS32_GOTPC20},
2817 {BFD_RELOC_NDS32_GOT_HI20, R_NDS32_GOT_HI20},
2818 {BFD_RELOC_NDS32_GOT_LO12, R_NDS32_GOT_LO12},
2819 {BFD_RELOC_NDS32_GOT_LO15, R_NDS32_GOT_LO15},
2820 {BFD_RELOC_NDS32_GOT_LO19, R_NDS32_GOT_LO19},
2821 {BFD_RELOC_NDS32_GOTPC_HI20, R_NDS32_GOTPC_HI20},
2822 {BFD_RELOC_NDS32_GOTPC_LO12, R_NDS32_GOTPC_LO12},
2823 {BFD_RELOC_NDS32_GOTOFF_HI20, R_NDS32_GOTOFF_HI20},
2824 {BFD_RELOC_NDS32_GOTOFF_LO12, R_NDS32_GOTOFF_LO12},
2825 {BFD_RELOC_NDS32_GOTOFF_LO15, R_NDS32_GOTOFF_LO15},
2826 {BFD_RELOC_NDS32_GOTOFF_LO19, R_NDS32_GOTOFF_LO19},
2827 {BFD_RELOC_NDS32_INSN16, R_NDS32_INSN16},
2828 {BFD_RELOC_NDS32_LABEL, R_NDS32_LABEL},
2829 {BFD_RELOC_NDS32_LONGCALL1, R_NDS32_LONGCALL1},
2830 {BFD_RELOC_NDS32_LONGCALL2, R_NDS32_LONGCALL2},
2831 {BFD_RELOC_NDS32_LONGCALL3, R_NDS32_LONGCALL3},
2832 {BFD_RELOC_NDS32_LONGCALL4, R_NDS32_LONGCALL4},
2833 {BFD_RELOC_NDS32_LONGCALL5, R_NDS32_LONGCALL5},
2834 {BFD_RELOC_NDS32_LONGCALL6, R_NDS32_LONGCALL6},
2835 {BFD_RELOC_NDS32_LONGJUMP1, R_NDS32_LONGJUMP1},
2836 {BFD_RELOC_NDS32_LONGJUMP2, R_NDS32_LONGJUMP2},
2837 {BFD_RELOC_NDS32_LONGJUMP3, R_NDS32_LONGJUMP3},
2838 {BFD_RELOC_NDS32_LONGJUMP4, R_NDS32_LONGJUMP4},
2839 {BFD_RELOC_NDS32_LONGJUMP5, R_NDS32_LONGJUMP5},
2840 {BFD_RELOC_NDS32_LONGJUMP6, R_NDS32_LONGJUMP6},
2841 {BFD_RELOC_NDS32_LONGJUMP7, R_NDS32_LONGJUMP7},
2842 {BFD_RELOC_NDS32_LOADSTORE, R_NDS32_LOADSTORE},
2843 {BFD_RELOC_NDS32_9_FIXED, R_NDS32_9_FIXED_RELA},
2844 {BFD_RELOC_NDS32_15_FIXED, R_NDS32_15_FIXED_RELA},
2845 {BFD_RELOC_NDS32_17_FIXED, R_NDS32_17_FIXED_RELA},
2846 {BFD_RELOC_NDS32_25_FIXED, R_NDS32_25_FIXED_RELA},
2847 {BFD_RELOC_NDS32_PLTREL_HI20, R_NDS32_PLTREL_HI20},
2848 {BFD_RELOC_NDS32_PLTREL_LO12, R_NDS32_PLTREL_LO12},
2849 {BFD_RELOC_NDS32_PLT_GOTREL_HI20, R_NDS32_PLT_GOTREL_HI20},
2850 {BFD_RELOC_NDS32_PLT_GOTREL_LO12, R_NDS32_PLT_GOTREL_LO12},
2851 {BFD_RELOC_NDS32_PLT_GOTREL_LO15, R_NDS32_PLT_GOTREL_LO15},
2852 {BFD_RELOC_NDS32_PLT_GOTREL_LO19, R_NDS32_PLT_GOTREL_LO19},
2853 {BFD_RELOC_NDS32_PLT_GOTREL_LO20, R_NDS32_PLT_GOTREL_LO20},
2854 {BFD_RELOC_NDS32_SDA12S2_DP, R_NDS32_SDA12S2_DP_RELA},
2855 {BFD_RELOC_NDS32_SDA12S2_SP, R_NDS32_SDA12S2_SP_RELA},
2856 {BFD_RELOC_NDS32_LO12S2_DP, R_NDS32_LO12S2_DP_RELA},
2857 {BFD_RELOC_NDS32_LO12S2_SP, R_NDS32_LO12S2_SP_RELA},
2858 {BFD_RELOC_NDS32_SDA16S3, R_NDS32_SDA16S3_RELA},
2859 {BFD_RELOC_NDS32_SDA17S2, R_NDS32_SDA17S2_RELA},
2860 {BFD_RELOC_NDS32_SDA18S1, R_NDS32_SDA18S1_RELA},
2861 {BFD_RELOC_NDS32_SDA19S0, R_NDS32_SDA19S0_RELA},
2862 {BFD_RELOC_NDS32_SDA_FP7U2_RELA, R_NDS32_SDA_FP7U2_RELA},
2863 {BFD_RELOC_NDS32_DWARF2_OP1, R_NDS32_DWARF2_OP1_RELA},
2864 {BFD_RELOC_NDS32_DWARF2_OP2, R_NDS32_DWARF2_OP2_RELA},
2865 {BFD_RELOC_NDS32_DWARF2_LEB, R_NDS32_DWARF2_LEB_RELA},
2866 {BFD_RELOC_NDS32_UPDATE_TA, R_NDS32_UPDATE_TA_RELA},
2867 {BFD_RELOC_NDS32_GOT_SUFF, R_NDS32_GOT_SUFF},
2868 {BFD_RELOC_NDS32_GOTOFF_SUFF, R_NDS32_GOTOFF_SUFF},
2869 {BFD_RELOC_NDS32_GOT15S2, R_NDS32_GOT15S2_RELA},
2870 {BFD_RELOC_NDS32_GOT17S2, R_NDS32_GOT17S2_RELA},
2871 {BFD_RELOC_NDS32_PTR, R_NDS32_PTR},
2872 {BFD_RELOC_NDS32_PTR_COUNT, R_NDS32_PTR_COUNT},
2873 {BFD_RELOC_NDS32_PLT_GOT_SUFF, R_NDS32_PLT_GOT_SUFF},
2874 {BFD_RELOC_NDS32_PTR_RESOLVED, R_NDS32_PTR_RESOLVED},
2875 {BFD_RELOC_NDS32_RELAX_ENTRY, R_NDS32_RELAX_ENTRY},
2876 {BFD_RELOC_NDS32_MULCALL_SUFF, R_NDS32_MULCALL_SUFF},
2877 {BFD_RELOC_NDS32_PLTBLOCK, R_NDS32_PLTBLOCK},
2878 {BFD_RELOC_NDS32_RELAX_REGION_BEGIN, R_NDS32_RELAX_REGION_BEGIN},
2879 {BFD_RELOC_NDS32_RELAX_REGION_END, R_NDS32_RELAX_REGION_END},
2880 {BFD_RELOC_NDS32_MINUEND, R_NDS32_MINUEND},
2881 {BFD_RELOC_NDS32_SUBTRAHEND, R_NDS32_SUBTRAHEND},
2882 {BFD_RELOC_NDS32_EMPTY, R_NDS32_EMPTY},
2883
2884 {BFD_RELOC_NDS32_DIFF8, R_NDS32_DIFF8},
2885 {BFD_RELOC_NDS32_DIFF16, R_NDS32_DIFF16},
2886 {BFD_RELOC_NDS32_DIFF32, R_NDS32_DIFF32},
2887 {BFD_RELOC_NDS32_DIFF_ULEB128, R_NDS32_DIFF_ULEB128},
2888 {BFD_RELOC_NDS32_25_ABS, R_NDS32_25_ABS_RELA},
2889 {BFD_RELOC_NDS32_DATA, R_NDS32_DATA},
2890 {BFD_RELOC_NDS32_TRAN, R_NDS32_TRAN},
2891 {BFD_RELOC_NDS32_17IFC_PCREL, R_NDS32_17IFC_PCREL_RELA},
2892 {BFD_RELOC_NDS32_10IFCU_PCREL, R_NDS32_10IFCU_PCREL_RELA},
2893 {BFD_RELOC_NDS32_TLS_LE_HI20, R_NDS32_TLS_LE_HI20},
2894 {BFD_RELOC_NDS32_TLS_LE_LO12, R_NDS32_TLS_LE_LO12},
2895 {BFD_RELOC_NDS32_TLS_LE_ADD, R_NDS32_TLS_LE_ADD},
2896 {BFD_RELOC_NDS32_TLS_LE_LS, R_NDS32_TLS_LE_LS},
2897 {BFD_RELOC_NDS32_TLS_IE_HI20, R_NDS32_TLS_IE_HI20},
2898 {BFD_RELOC_NDS32_TLS_IE_LO12S2, R_NDS32_TLS_IE_LO12S2},
2899 {BFD_RELOC_NDS32_TLS_TPOFF, R_NDS32_TLS_TPOFF},
2900 {BFD_RELOC_NDS32_TLS_LE_20, R_NDS32_TLS_LE_20},
2901 {BFD_RELOC_NDS32_TLS_LE_15S0, R_NDS32_TLS_LE_15S0},
2902 {BFD_RELOC_NDS32_TLS_LE_15S1, R_NDS32_TLS_LE_15S1},
2903 {BFD_RELOC_NDS32_TLS_LE_15S2, R_NDS32_TLS_LE_15S2},
2904 };
2905
2906 /* Patch tag. */
2907
2908 static reloc_howto_type *
bfd_elf32_bfd_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)2909 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2910 const char *r_name)
2911 {
2912 unsigned int i;
2913
2914 for (i = 0; i < ARRAY_SIZE (nds32_elf_howto_table); i++)
2915 if (nds32_elf_howto_table[i].name != NULL
2916 && strcasecmp (nds32_elf_howto_table[i].name, r_name) == 0)
2917 return &nds32_elf_howto_table[i];
2918
2919 for (i = 0; i < ARRAY_SIZE (nds32_elf_relax_howto_table); i++)
2920 if (nds32_elf_relax_howto_table[i].name != NULL
2921 && strcasecmp (nds32_elf_relax_howto_table[i].name, r_name) == 0)
2922 return &nds32_elf_relax_howto_table[i];
2923
2924 return NULL;
2925 }
2926
2927 static reloc_howto_type *
bfd_elf32_bfd_reloc_type_table_lookup(enum elf_nds32_reloc_type code)2928 bfd_elf32_bfd_reloc_type_table_lookup (enum elf_nds32_reloc_type code)
2929 {
2930 if (code < R_NDS32_RELAX_ENTRY)
2931 {
2932 BFD_ASSERT (code < ARRAY_SIZE (nds32_elf_howto_table));
2933 return &nds32_elf_howto_table[code];
2934 }
2935 else
2936 {
2937 BFD_ASSERT ((size_t) (code - R_NDS32_RELAX_ENTRY)
2938 < ARRAY_SIZE (nds32_elf_relax_howto_table));
2939 return &nds32_elf_relax_howto_table[code - R_NDS32_RELAX_ENTRY];
2940 }
2941 }
2942
2943 static reloc_howto_type *
bfd_elf32_bfd_reloc_type_lookup(bfd * abfd ATTRIBUTE_UNUSED,bfd_reloc_code_real_type code)2944 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2945 bfd_reloc_code_real_type code)
2946 {
2947 unsigned int i;
2948
2949 for (i = 0; i < ARRAY_SIZE (nds32_reloc_map); i++)
2950 {
2951 if (nds32_reloc_map[i].bfd_reloc_val == code)
2952 return bfd_elf32_bfd_reloc_type_table_lookup
2953 (nds32_reloc_map[i].elf_reloc_val);
2954 }
2955
2956 return NULL;
2957 }
2958
2959 /* Set the howto pointer for an NDS32 ELF reloc. */
2960
2961 static void
nds32_info_to_howto_rel(bfd * abfd ATTRIBUTE_UNUSED,arelent * cache_ptr,Elf_Internal_Rela * dst)2962 nds32_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2963 Elf_Internal_Rela *dst)
2964 {
2965 enum elf_nds32_reloc_type r_type;
2966
2967 r_type = ELF32_R_TYPE (dst->r_info);
2968 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) <= R_NDS32_GNU_VTENTRY);
2969 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
2970 }
2971
2972 static void
nds32_info_to_howto(bfd * abfd ATTRIBUTE_UNUSED,arelent * cache_ptr,Elf_Internal_Rela * dst)2973 nds32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2974 Elf_Internal_Rela *dst)
2975 {
2976 BFD_ASSERT ((ELF32_R_TYPE (dst->r_info) == R_NDS32_NONE)
2977 || ((ELF32_R_TYPE (dst->r_info) > R_NDS32_GNU_VTENTRY)
2978 && (ELF32_R_TYPE (dst->r_info) < R_NDS32_max)));
2979 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (dst->r_info));
2980 }
2981
2982 /* Support for core dump NOTE sections.
2983 Reference to include/linux/elfcore.h in Linux. */
2984
2985 static bfd_boolean
nds32_elf_grok_prstatus(bfd * abfd,Elf_Internal_Note * note)2986 nds32_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2987 {
2988 int offset;
2989 size_t size;
2990
2991 switch (note->descsz)
2992 {
2993 case 0x114:
2994 /* Linux/NDS32 32-bit, ABI1 */
2995
2996 /* pr_cursig */
2997 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2998
2999 /* pr_pid */
3000 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3001
3002 /* pr_reg */
3003 offset = 72;
3004 size = 200;
3005 break;
3006
3007 case 0xfc:
3008 /* Linux/NDS32 32-bit */
3009
3010 /* pr_cursig */
3011 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3012
3013 /* pr_pid */
3014 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3015
3016 /* pr_reg */
3017 offset = 72;
3018 size = 176;
3019 break;
3020
3021 default:
3022 return FALSE;
3023 }
3024
3025 /* Make a ".reg" section. */
3026 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3027 size, note->descpos + offset);
3028 }
3029
3030 static bfd_boolean
nds32_elf_grok_psinfo(bfd * abfd,Elf_Internal_Note * note)3031 nds32_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3032 {
3033 switch (note->descsz)
3034 {
3035 case 124:
3036 /* Linux/NDS32 */
3037
3038 /* __kernel_uid_t, __kernel_gid_t are short on NDS32 platform. */
3039 elf_tdata (abfd)->core->program =
3040 _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3041 elf_tdata (abfd)->core->command =
3042 _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3043
3044 default:
3045 return FALSE;
3046 }
3047
3048 /* Note that for some reason, a spurious space is tacked
3049 onto the end of the args in some (at least one anyway)
3050 implementations, so strip it off if it exists. */
3051 {
3052 char *command = elf_tdata (abfd)->core->command;
3053 int n = strlen (command);
3054
3055 if (0 < n && command[n - 1] == ' ')
3056 command[n - 1] = '\0';
3057 }
3058
3059 return TRUE;
3060 }
3061
3062 /* Hook called by the linker routine which adds symbols from an object
3063 file. We must handle the special NDS32 section numbers here.
3064 We also keep watching for whether we need to create the sdata special
3065 linker sections. */
3066
3067 static bfd_boolean
nds32_elf_add_symbol_hook(bfd * abfd,struct bfd_link_info * info ATTRIBUTE_UNUSED,Elf_Internal_Sym * sym,const char ** namep ATTRIBUTE_UNUSED,flagword * flagsp ATTRIBUTE_UNUSED,asection ** secp,bfd_vma * valp)3068 nds32_elf_add_symbol_hook (bfd *abfd,
3069 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3070 Elf_Internal_Sym *sym,
3071 const char **namep ATTRIBUTE_UNUSED,
3072 flagword *flagsp ATTRIBUTE_UNUSED,
3073 asection **secp, bfd_vma *valp)
3074 {
3075 switch (sym->st_shndx)
3076 {
3077 case SHN_COMMON:
3078 /* Common symbols less than the GP size are automatically
3079 treated as SHN_MIPS_SCOMMON symbols. */
3080 if (sym->st_size > elf_gp_size (abfd)
3081 || ELF_ST_TYPE (sym->st_info) == STT_TLS)
3082 break;
3083
3084 /* st_value is the alignemnt constraint.
3085 That might be its actual size if it is an array or structure. */
3086 switch (sym->st_value)
3087 {
3088 case 1:
3089 *secp = bfd_make_section_old_way (abfd, ".scommon_b");
3090 break;
3091 case 2:
3092 *secp = bfd_make_section_old_way (abfd, ".scommon_h");
3093 break;
3094 case 4:
3095 *secp = bfd_make_section_old_way (abfd, ".scommon_w");
3096 break;
3097 case 8:
3098 *secp = bfd_make_section_old_way (abfd, ".scommon_d");
3099 break;
3100 default:
3101 return TRUE;
3102 }
3103
3104 (*secp)->flags |= SEC_IS_COMMON;
3105 *valp = sym->st_size;
3106 break;
3107 }
3108
3109 return TRUE;
3110 }
3111
3112
3113 /* This function can figure out the best location for a base register to access
3114 data relative to this base register
3115 INPUT:
3116 sda_d0: size of first DOUBLE WORD data section
3117 sda_w0: size of first WORD data section
3118 sda_h0: size of first HALF WORD data section
3119 sda_b : size of BYTE data section
3120 sda_hi: size of second HALF WORD data section
3121 sda_w1: size of second WORD data section
3122 sda_d1: size of second DOUBLE WORD data section
3123 OUTPUT:
3124 offset (always positive) from the beginning of sda_d0 if OK
3125 a negative error value if fail
3126 NOTE:
3127 these 7 sections have to be located back to back if exist
3128 a pass in 0 value for non-existing section */
3129
3130 /* Due to the interpretation of simm15 field of load/store depending on
3131 data accessing size, the organization of base register relative data shall
3132 like the following figure
3133 -------------------------------------------
3134 | DOUBLE WORD sized data (range +/- 128K)
3135 -------------------------------------------
3136 | WORD sized data (range +/- 64K)
3137 -------------------------------------------
3138 | HALF WORD sized data (range +/- 32K)
3139 -------------------------------------------
3140 | BYTE sized data (range +/- 16K)
3141 -------------------------------------------
3142 | HALF WORD sized data (range +/- 32K)
3143 -------------------------------------------
3144 | WORD sized data (range +/- 64K)
3145 -------------------------------------------
3146 | DOUBLE WORD sized data (range +/- 128K)
3147 -------------------------------------------
3148 Its base register shall be set to access these data freely. */
3149
3150 /* We have to figure out the SDA_BASE value, so that we can adjust the
3151 symbol value correctly. We look up the symbol _SDA_BASE_ in the output
3152 BFD. If we can't find it, we're stuck. We cache it in the ELF
3153 target data. We don't need to adjust the symbol value for an
3154 external symbol if we are producing relocatable output. */
3155
3156 static asection *sda_rela_sec = NULL;
3157
3158 #define SDA_SECTION_NUM 10
3159
3160 static bfd_reloc_status_type
nds32_elf_final_sda_base(bfd * output_bfd,struct bfd_link_info * info,bfd_vma * psb,bfd_boolean add_symbol)3161 nds32_elf_final_sda_base (bfd *output_bfd, struct bfd_link_info *info,
3162 bfd_vma *psb, bfd_boolean add_symbol)
3163 {
3164 int relax_fp_as_gp;
3165 struct elf_nds32_link_hash_table *table;
3166 struct bfd_link_hash_entry *h, *h2;
3167 long unsigned int total = 0;
3168
3169 h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
3170 if (!h || (h->type != bfd_link_hash_defined && h->type != bfd_link_hash_defweak))
3171 {
3172 asection *first = NULL, *final = NULL, *temp;
3173 bfd_vma sda_base;
3174 /* The first section must be 4-byte aligned to promise _SDA_BASE_ being
3175 4 byte-aligned. Therefore, it has to set the first section ".data"
3176 4 byte-aligned. */
3177 static const char sec_name[SDA_SECTION_NUM][10] =
3178 {
3179 ".data", ".got", ".sdata_d", ".sdata_w", ".sdata_h", ".sdata_b",
3180 ".sbss_b", ".sbss_h", ".sbss_w", ".sbss_d"
3181 };
3182 size_t i = 0;
3183
3184 if (output_bfd->sections == NULL)
3185 {
3186 *psb = elf_gp (output_bfd);
3187 return bfd_reloc_ok;
3188 }
3189
3190 /* Get the first and final section. */
3191 while (i < sizeof (sec_name) / sizeof (sec_name [0]))
3192 {
3193 temp = bfd_get_section_by_name (output_bfd, sec_name[i]);
3194 if (temp && !first && (temp->size != 0 || temp->rawsize != 0))
3195 first = temp;
3196 if (temp && (temp->size != 0 || temp->rawsize != 0))
3197 final = temp;
3198
3199 /* Summarize the sections in order to check if joining .bss. */
3200 if (temp && temp->size != 0)
3201 total += temp->size;
3202 else if (temp && temp->rawsize != 0)
3203 total += temp->rawsize;
3204
3205 i++;
3206 }
3207
3208 /* Check .bss size. */
3209 temp = bfd_get_section_by_name (output_bfd, ".bss");
3210 if (temp)
3211 {
3212 if (temp->size != 0)
3213 total += temp->size;
3214 else if (temp->rawsize != 0)
3215 total += temp->rawsize;
3216
3217 if (total < 0x80000)
3218 {
3219 if (!first && (temp->size != 0 || temp->rawsize != 0))
3220 first = temp;
3221 if ((temp->size != 0 || temp->rawsize != 0))
3222 final = temp;
3223 }
3224 }
3225
3226 if (first && final)
3227 {
3228 /* The middle of data region. */
3229 sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3230
3231 /* Find the section sda_base located. */
3232 i = 0;
3233 while (i < sizeof (sec_name) / sizeof (sec_name [0]))
3234 {
3235 final = bfd_get_section_by_name (output_bfd, sec_name[i]);
3236 if (final && (final->size != 0 || final->rawsize != 0)
3237 && sda_base >= final->vma)
3238 {
3239 first = final;
3240 i++;
3241 }
3242 else
3243 break;
3244 }
3245 }
3246 else
3247 {
3248 /* There is not any data section in output bfd, and set _SDA_BASE_ in
3249 first output section. */
3250 first = output_bfd->sections;
3251 while (first && first->size == 0 && first->rawsize == 0)
3252 first = first->next;
3253 if (!first)
3254 {
3255 *psb = elf_gp (output_bfd);
3256 return bfd_reloc_ok;
3257 }
3258 sda_base = first->vma + first->rawsize;
3259 }
3260
3261 sda_base -= first->vma;
3262 sda_base = sda_base & (~7);
3263
3264 if (!_bfd_generic_link_add_one_symbol
3265 (info, output_bfd, "_SDA_BASE_", BSF_GLOBAL | BSF_WEAK, first,
3266 (bfd_vma) sda_base, (const char *) NULL, FALSE,
3267 get_elf_backend_data (output_bfd)->collect, &h))
3268 return FALSE;
3269
3270 sda_rela_sec = first;
3271
3272 table = nds32_elf_hash_table (info);
3273 relax_fp_as_gp = table->relax_fp_as_gp;
3274 if (relax_fp_as_gp)
3275 {
3276 h2 = bfd_link_hash_lookup (info->hash, FP_BASE_NAME,
3277 FALSE, FALSE, FALSE);
3278 /* Define a weak FP_BASE_NAME here to prevent the undefined symbol.
3279 And set FP equal to SDA_BASE to do relaxation for
3280 la $fp, _FP_BASE_. */
3281 if (!_bfd_generic_link_add_one_symbol
3282 (info, output_bfd, FP_BASE_NAME, BSF_GLOBAL | BSF_WEAK,
3283 first, (bfd_vma) sda_base, (const char *) NULL,
3284 FALSE, get_elf_backend_data (output_bfd)->collect, &h2))
3285 return FALSE;
3286 }
3287 }
3288
3289 if (add_symbol == TRUE)
3290 {
3291 if (h)
3292 {
3293 /* Now set gp. */
3294 elf_gp (output_bfd) = (h->u.def.value
3295 + h->u.def.section->output_section->vma
3296 + h->u.def.section->output_offset);
3297 }
3298 else
3299 {
3300 (*_bfd_error_handler) (_("error: Can't find symbol: _SDA_BASE_."));
3301 return bfd_reloc_dangerous;
3302 }
3303 }
3304
3305 *psb = h->u.def.value + h->u.def.section->output_section->vma
3306 + h->u.def.section->output_offset;
3307 return bfd_reloc_ok;
3308 }
3309
3310
3311 /* Return size of a PLT entry. */
3312 #define elf_nds32_sizeof_plt(info) PLT_ENTRY_SIZE
3313
3314
3315 /* Create an entry in an nds32 ELF linker hash table. */
3316
3317 static struct bfd_hash_entry *
nds32_elf_link_hash_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)3318 nds32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
3319 struct bfd_hash_table *table,
3320 const char *string)
3321 {
3322 struct elf_nds32_link_hash_entry *ret;
3323
3324 ret = (struct elf_nds32_link_hash_entry *) entry;
3325
3326 /* Allocate the structure if it has not already been allocated by a
3327 subclass. */
3328 if (ret == NULL)
3329 ret = (struct elf_nds32_link_hash_entry *)
3330 bfd_hash_allocate (table, sizeof (struct elf_nds32_link_hash_entry));
3331
3332 if (ret == NULL)
3333 return (struct bfd_hash_entry *) ret;
3334
3335 /* Call the allocation method of the superclass. */
3336 ret = (struct elf_nds32_link_hash_entry *)
3337 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
3338
3339 if (ret != NULL)
3340 {
3341 struct elf_nds32_link_hash_entry *eh;
3342
3343 eh = (struct elf_nds32_link_hash_entry *) ret;
3344 eh->dyn_relocs = NULL;
3345 eh->tls_type = GOT_UNKNOWN;
3346 }
3347
3348 return (struct bfd_hash_entry *) ret;
3349 }
3350
3351 /* Create an nds32 ELF linker hash table. */
3352
3353 static struct bfd_link_hash_table *
nds32_elf_link_hash_table_create(bfd * abfd)3354 nds32_elf_link_hash_table_create (bfd *abfd)
3355 {
3356 struct elf_nds32_link_hash_table *ret;
3357
3358 bfd_size_type amt = sizeof (struct elf_nds32_link_hash_table);
3359
3360 ret = (struct elf_nds32_link_hash_table *) bfd_zmalloc (amt);
3361 if (ret == NULL)
3362 return NULL;
3363
3364 /* patch tag. */
3365 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3366 nds32_elf_link_hash_newfunc,
3367 sizeof (struct elf_nds32_link_hash_entry),
3368 NDS32_ELF_DATA))
3369 {
3370 free (ret);
3371 return NULL;
3372 }
3373
3374 ret->sgot = NULL;
3375 ret->sgotplt = NULL;
3376 ret->srelgot = NULL;
3377 ret->splt = NULL;
3378 ret->srelplt = NULL;
3379 ret->sdynbss = NULL;
3380 ret->srelbss = NULL;
3381 ret->sym_ld_script = NULL;
3382 ret->ex9_export_file = NULL;
3383 ret->ex9_import_file = NULL;
3384
3385 return &ret->root.root;
3386 }
3387
3388 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3389 shortcuts to them in our hash table. */
3390
3391 static bfd_boolean
create_got_section(bfd * dynobj,struct bfd_link_info * info)3392 create_got_section (bfd *dynobj, struct bfd_link_info *info)
3393 {
3394 struct elf_nds32_link_hash_table *htab;
3395
3396 if (!_bfd_elf_create_got_section (dynobj, info))
3397 return FALSE;
3398
3399 htab = nds32_elf_hash_table (info);
3400 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
3401 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3402 if (!htab->sgot || !htab->sgotplt)
3403 abort ();
3404
3405 /* _bfd_elf_create_got_section will create it for us. */
3406 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3407 if (htab->srelgot == NULL
3408 || !bfd_set_section_flags (dynobj, htab->srelgot,
3409 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
3410 | SEC_IN_MEMORY | SEC_LINKER_CREATED
3411 | SEC_READONLY))
3412 || !bfd_set_section_alignment (dynobj, htab->srelgot, 2))
3413 return FALSE;
3414
3415 return TRUE;
3416 }
3417
3418 /* Create dynamic sections when linking against a dynamic object. */
3419
3420 static bfd_boolean
nds32_elf_create_dynamic_sections(bfd * abfd,struct bfd_link_info * info)3421 nds32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3422 {
3423 struct elf_nds32_link_hash_table *htab;
3424 flagword flags, pltflags;
3425 register asection *s;
3426 const struct elf_backend_data *bed;
3427 int ptralign = 2; /* 32-bit */
3428
3429 bed = get_elf_backend_data (abfd);
3430
3431 htab = nds32_elf_hash_table (info);
3432
3433 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3434 .rel[a].bss sections. */
3435
3436 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3437 | SEC_LINKER_CREATED);
3438
3439 pltflags = flags;
3440 pltflags |= SEC_CODE;
3441 if (bed->plt_not_loaded)
3442 pltflags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
3443 if (bed->plt_readonly)
3444 pltflags |= SEC_READONLY;
3445
3446 s = bfd_make_section (abfd, ".plt");
3447 htab->splt = s;
3448 if (s == NULL
3449 || !bfd_set_section_flags (abfd, s, pltflags)
3450 || !bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3451 return FALSE;
3452
3453 if (bed->want_plt_sym)
3454 {
3455 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3456 .plt section. */
3457 struct bfd_link_hash_entry *bh = NULL;
3458 struct elf_link_hash_entry *h;
3459
3460 if (!(_bfd_generic_link_add_one_symbol
3461 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3462 (bfd_vma) 0, (const char *) NULL, FALSE,
3463 get_elf_backend_data (abfd)->collect, &bh)))
3464 return FALSE;
3465
3466 h = (struct elf_link_hash_entry *) bh;
3467 h->def_regular = 1;
3468 h->type = STT_OBJECT;
3469
3470 if (info->shared && !bfd_elf_link_record_dynamic_symbol (info, h))
3471 return FALSE;
3472 }
3473
3474 s = bfd_make_section (abfd,
3475 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3476 htab->srelplt = s;
3477 if (s == NULL
3478 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3479 || !bfd_set_section_alignment (abfd, s, ptralign))
3480 return FALSE;
3481
3482 if (htab->sgot == NULL && !create_got_section (abfd, info))
3483 return FALSE;
3484
3485 {
3486 const char *secname;
3487 char *relname;
3488 flagword secflags;
3489 asection *sec;
3490
3491 for (sec = abfd->sections; sec; sec = sec->next)
3492 {
3493 secflags = bfd_get_section_flags (abfd, sec);
3494 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3495 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3496 continue;
3497 secname = bfd_get_section_name (abfd, sec);
3498 relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3499 strcpy (relname, ".rela");
3500 strcat (relname, secname);
3501 if (bfd_get_section_by_name (abfd, secname))
3502 continue;
3503 s = bfd_make_section (abfd, relname);
3504 if (s == NULL
3505 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3506 || !bfd_set_section_alignment (abfd, s, ptralign))
3507 return FALSE;
3508 }
3509 }
3510
3511 if (bed->want_dynbss)
3512 {
3513 /* The .dynbss section is a place to put symbols which are defined
3514 by dynamic objects, are referenced by regular objects, and are
3515 not functions. We must allocate space for them in the process
3516 image and use a R_*_COPY reloc to tell the dynamic linker to
3517 initialize them at run time. The linker script puts the .dynbss
3518 section into the .bss section of the final image. */
3519 s = bfd_make_section (abfd, ".dynbss");
3520 htab->sdynbss = s;
3521 if (s == NULL
3522 || !bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
3523 return FALSE;
3524 /* The .rel[a].bss section holds copy relocs. This section is not
3525 normally needed. We need to create it here, though, so that the
3526 linker will map it to an output section. We can't just create it
3527 only if we need it, because we will not know whether we need it
3528 until we have seen all the input files, and the first time the
3529 main linker code calls BFD after examining all the input files
3530 (size_dynamic_sections) the input sections have already been
3531 mapped to the output sections. If the section turns out not to
3532 be needed, we can discard it later. We will never need this
3533 section when generating a shared object, since they do not use
3534 copy relocs. */
3535 if (!info->shared)
3536 {
3537 s = bfd_make_section (abfd, (bed->default_use_rela_p
3538 ? ".rela.bss" : ".rel.bss"));
3539 htab->srelbss = s;
3540 if (s == NULL
3541 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3542 || !bfd_set_section_alignment (abfd, s, ptralign))
3543 return FALSE;
3544 }
3545 }
3546
3547 return TRUE;
3548 }
3549
3550 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3551 static void
nds32_elf_copy_indirect_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * dir,struct elf_link_hash_entry * ind)3552 nds32_elf_copy_indirect_symbol (struct bfd_link_info *info,
3553 struct elf_link_hash_entry *dir,
3554 struct elf_link_hash_entry *ind)
3555 {
3556 struct elf_nds32_link_hash_entry *edir, *eind;
3557
3558 edir = (struct elf_nds32_link_hash_entry *) dir;
3559 eind = (struct elf_nds32_link_hash_entry *) ind;
3560
3561 if (eind->dyn_relocs != NULL)
3562 {
3563 if (edir->dyn_relocs != NULL)
3564 {
3565 struct elf_nds32_dyn_relocs **pp;
3566 struct elf_nds32_dyn_relocs *p;
3567
3568 if (ind->root.type == bfd_link_hash_indirect)
3569 abort ();
3570
3571 /* Add reloc counts against the weak sym to the strong sym
3572 list. Merge any entries against the same section. */
3573 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
3574 {
3575 struct elf_nds32_dyn_relocs *q;
3576
3577 for (q = edir->dyn_relocs; q != NULL; q = q->next)
3578 if (q->sec == p->sec)
3579 {
3580 q->pc_count += p->pc_count;
3581 q->count += p->count;
3582 *pp = p->next;
3583 break;
3584 }
3585 if (q == NULL)
3586 pp = &p->next;
3587 }
3588 *pp = edir->dyn_relocs;
3589 }
3590
3591 edir->dyn_relocs = eind->dyn_relocs;
3592 eind->dyn_relocs = NULL;
3593 }
3594
3595 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3596 }
3597
3598
3599 /* Adjust a symbol defined by a dynamic object and referenced by a
3600 regular object. The current definition is in some section of the
3601 dynamic object, but we're not including those sections. We have to
3602 change the definition to something the rest of the link can
3603 understand. */
3604
3605 static bfd_boolean
nds32_elf_adjust_dynamic_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * h)3606 nds32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3607 struct elf_link_hash_entry *h)
3608 {
3609 struct elf_nds32_link_hash_table *htab;
3610 struct elf_nds32_link_hash_entry *eh;
3611 struct elf_nds32_dyn_relocs *p;
3612 bfd *dynobj;
3613 asection *s;
3614 unsigned int power_of_two;
3615
3616 dynobj = elf_hash_table (info)->dynobj;
3617
3618 /* Make sure we know what is going on here. */
3619 BFD_ASSERT (dynobj != NULL
3620 && (h->needs_plt
3621 || h->u.weakdef != NULL
3622 || (h->def_dynamic && h->ref_regular && !h->def_regular)));
3623
3624
3625 /* If this is a function, put it in the procedure linkage table. We
3626 will fill in the contents of the procedure linkage table later,
3627 when we know the address of the .got section. */
3628 if (h->type == STT_FUNC || h->needs_plt)
3629 {
3630 if (!info->shared
3631 && !h->def_dynamic
3632 && !h->ref_dynamic
3633 && h->root.type != bfd_link_hash_undefweak
3634 && h->root.type != bfd_link_hash_undefined)
3635 {
3636 /* This case can occur if we saw a PLT reloc in an input
3637 file, but the symbol was never referred to by a dynamic
3638 object. In such a case, we don't actually need to build
3639 a procedure linkage table, and we can just do a PCREL
3640 reloc instead. */
3641 h->plt.offset = (bfd_vma) - 1;
3642 h->needs_plt = 0;
3643 }
3644
3645 return TRUE;
3646 }
3647 else
3648 h->plt.offset = (bfd_vma) - 1;
3649
3650 /* If this is a weak symbol, and there is a real definition, the
3651 processor independent code will have arranged for us to see the
3652 real definition first, and we can just use the same value. */
3653 if (h->u.weakdef != NULL)
3654 {
3655 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3656 || h->u.weakdef->root.type == bfd_link_hash_defweak);
3657 h->root.u.def.section = h->u.weakdef->root.u.def.section;
3658 h->root.u.def.value = h->u.weakdef->root.u.def.value;
3659 return TRUE;
3660 }
3661
3662 /* This is a reference to a symbol defined by a dynamic object which
3663 is not a function. */
3664
3665 /* If we are creating a shared library, we must presume that the
3666 only references to the symbol are via the global offset table.
3667 For such cases we need not do anything here; the relocations will
3668 be handled correctly by relocate_section. */
3669 if (info->shared)
3670 return TRUE;
3671
3672 /* If there are no references to this symbol that do not use the
3673 GOT, we don't need to generate a copy reloc. */
3674 if (!h->non_got_ref)
3675 return TRUE;
3676
3677 /* If -z nocopyreloc was given, we won't generate them either. */
3678 if (info->nocopyreloc)
3679 {
3680 h->non_got_ref = 0;
3681 return TRUE;
3682 }
3683
3684 eh = (struct elf_nds32_link_hash_entry *) h;
3685 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3686 {
3687 s = p->sec->output_section;
3688 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
3689 break;
3690 }
3691
3692 /* If we didn't find any dynamic relocs in sections which needs the
3693 copy reloc, then we'll be keeping the dynamic relocs and avoiding
3694 the copy reloc. */
3695 if (p == NULL)
3696 {
3697 h->non_got_ref = 0;
3698 return TRUE;
3699 }
3700
3701 /* We must allocate the symbol in our .dynbss section, which will
3702 become part of the .bss section of the executable. There will be
3703 an entry for this symbol in the .dynsym section. The dynamic
3704 object will contain position independent code, so all references
3705 from the dynamic object to this symbol will go through the global
3706 offset table. The dynamic linker will use the .dynsym entry to
3707 determine the address it must put in the global offset table, so
3708 both the dynamic object and the regular object will refer to the
3709 same memory location for the variable. */
3710
3711 htab = nds32_elf_hash_table (info);
3712 s = htab->sdynbss;
3713 BFD_ASSERT (s != NULL);
3714
3715 /* We must generate a R_NDS32_COPY reloc to tell the dynamic linker
3716 to copy the initial value out of the dynamic object and into the
3717 runtime process image. We need to remember the offset into the
3718 .rela.bss section we are going to use. */
3719 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3720 {
3721 asection *srel;
3722
3723 srel = htab->srelbss;
3724 BFD_ASSERT (srel != NULL);
3725 srel->size += sizeof (Elf32_External_Rela);
3726 h->needs_copy = 1;
3727 }
3728
3729 /* We need to figure out the alignment required for this symbol. I
3730 have no idea how ELF linkers handle this. */
3731 power_of_two = bfd_log2 (h->size);
3732 if (power_of_two > 3)
3733 power_of_two = 3;
3734
3735 /* Apply the required alignment. */
3736 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
3737 if (power_of_two > bfd_get_section_alignment (dynobj, s))
3738 {
3739 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
3740 return FALSE;
3741 }
3742
3743 /* Define the symbol as being at this point in the section. */
3744 h->root.u.def.section = s;
3745 h->root.u.def.value = s->size;
3746
3747 /* Increment the section size to make room for the symbol. */
3748 s->size += h->size;
3749
3750 return TRUE;
3751 }
3752
3753 /* Allocate space in .plt, .got and associated reloc sections for
3754 dynamic relocs. */
3755
3756 static bfd_boolean
allocate_dynrelocs(struct elf_link_hash_entry * h,void * inf)3757 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3758 {
3759 struct bfd_link_info *info;
3760 struct elf_nds32_link_hash_table *htab;
3761 struct elf_nds32_link_hash_entry *eh;
3762 struct elf_nds32_dyn_relocs *p;
3763
3764 if (h->root.type == bfd_link_hash_indirect)
3765 return TRUE;
3766
3767 if (h->root.type == bfd_link_hash_warning)
3768 /* When warning symbols are created, they **replace** the "real"
3769 entry in the hash table, thus we never get to see the real
3770 symbol in a hash traversal. So look at it now. */
3771 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3772
3773 info = (struct bfd_link_info *) inf;
3774 htab = nds32_elf_hash_table (info);
3775
3776 eh = (struct elf_nds32_link_hash_entry *) h;
3777
3778 if (htab->root.dynamic_sections_created && h->plt.refcount > 0)
3779 {
3780 /* Make sure this symbol is output as a dynamic symbol.
3781 Undefined weak syms won't yet be marked as dynamic. */
3782 if (h->dynindx == -1 && !h->forced_local)
3783 {
3784 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3785 return FALSE;
3786 }
3787
3788 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
3789 {
3790 asection *s = htab->splt;
3791
3792 /* If this is the first .plt entry, make room for the special
3793 first entry. */
3794 if (s->size == 0)
3795 s->size += PLT_ENTRY_SIZE;
3796
3797 h->plt.offset = s->size;
3798
3799 /* If this symbol is not defined in a regular file, and we are
3800 not generating a shared library, then set the symbol to this
3801 location in the .plt. This is required to make function
3802 pointers compare as equal between the normal executable and
3803 the shared library. */
3804 if (!info->shared && !h->def_regular)
3805 {
3806 h->root.u.def.section = s;
3807 h->root.u.def.value = h->plt.offset;
3808 }
3809
3810 /* Make room for this entry. */
3811 s->size += PLT_ENTRY_SIZE;
3812
3813 /* We also need to make an entry in the .got.plt section, which
3814 will be placed in the .got section by the linker script. */
3815 htab->sgotplt->size += 4;
3816
3817 /* We also need to make an entry in the .rel.plt section. */
3818 htab->srelplt->size += sizeof (Elf32_External_Rela);
3819 }
3820 else
3821 {
3822 h->plt.offset = (bfd_vma) - 1;
3823 h->needs_plt = 0;
3824 }
3825 }
3826 else
3827 {
3828 h->plt.offset = (bfd_vma) - 1;
3829 h->needs_plt = 0;
3830 }
3831
3832 if (h->got.refcount > 0)
3833 {
3834 asection *s;
3835 bfd_boolean dyn;
3836 int tls_type = elf32_nds32_hash_entry (h)->tls_type;
3837
3838 /* Make sure this symbol is output as a dynamic symbol.
3839 Undefined weak syms won't yet be marked as dynamic. */
3840 if (h->dynindx == -1 && !h->forced_local)
3841 {
3842 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3843 return FALSE;
3844 }
3845
3846 s = htab->sgot;
3847 h->got.offset = s->size;
3848
3849 if (tls_type == GOT_UNKNOWN)
3850 abort ();
3851 else if (tls_type == GOT_NORMAL
3852 || tls_type == GOT_TLS_IE)
3853 /* Need a GOT slot. */
3854 s->size += 4;
3855
3856 dyn = htab->root.dynamic_sections_created;
3857 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
3858 htab->srelgot->size += sizeof (Elf32_External_Rela);
3859 }
3860 else
3861 h->got.offset = (bfd_vma) - 1;
3862
3863 if (eh->dyn_relocs == NULL)
3864 return TRUE;
3865
3866 /* In the shared -Bsymbolic case, discard space allocated for
3867 dynamic pc-relative relocs against symbols which turn out to be
3868 defined in regular objects. For the normal shared case, discard
3869 space for pc-relative relocs that have become local due to symbol
3870 visibility changes. */
3871
3872 if (info->shared)
3873 {
3874 if (h->def_regular && (h->forced_local || info->symbolic))
3875 {
3876 struct elf_nds32_dyn_relocs **pp;
3877
3878 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
3879 {
3880 p->count -= p->pc_count;
3881 p->pc_count = 0;
3882 if (p->count == 0)
3883 *pp = p->next;
3884 else
3885 pp = &p->next;
3886 }
3887 }
3888 }
3889 else
3890 {
3891 /* For the non-shared case, discard space for relocs against
3892 symbols which turn out to need copy relocs or are not dynamic. */
3893
3894 if (!h->non_got_ref
3895 && ((h->def_dynamic
3896 && !h->def_regular)
3897 || (htab->root.dynamic_sections_created
3898 && (h->root.type == bfd_link_hash_undefweak
3899 || h->root.type == bfd_link_hash_undefined))))
3900 {
3901 /* Make sure this symbol is output as a dynamic symbol.
3902 Undefined weak syms won't yet be marked as dynamic. */
3903 if (h->dynindx == -1 && !h->forced_local)
3904 {
3905 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3906 return FALSE;
3907 }
3908
3909 /* If that succeeded, we know we'll be keeping all the
3910 relocs. */
3911 if (h->dynindx != -1)
3912 goto keep;
3913 }
3914
3915 eh->dyn_relocs = NULL;
3916
3917 keep:;
3918 }
3919
3920 /* Finally, allocate space. */
3921 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3922 {
3923 asection *sreloc = elf_section_data (p->sec)->sreloc;
3924 sreloc->size += p->count * sizeof (Elf32_External_Rela);
3925 }
3926
3927 return TRUE;
3928 }
3929
3930 /* Find any dynamic relocs that apply to read-only sections. */
3931
3932 static bfd_boolean
readonly_dynrelocs(struct elf_link_hash_entry * h,void * inf)3933 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3934 {
3935 struct elf_nds32_link_hash_entry *eh;
3936 struct elf_nds32_dyn_relocs *p;
3937
3938 if (h->root.type == bfd_link_hash_warning)
3939 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3940
3941 eh = (struct elf_nds32_link_hash_entry *) h;
3942 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3943 {
3944 asection *s = p->sec->output_section;
3945
3946 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3947 {
3948 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3949
3950 info->flags |= DF_TEXTREL;
3951
3952 /* Not an error, just cut short the traversal. */
3953 return FALSE;
3954 }
3955 }
3956 return TRUE;
3957 }
3958
3959 /* Set the sizes of the dynamic sections. */
3960
3961 static bfd_boolean
nds32_elf_size_dynamic_sections(bfd * output_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info)3962 nds32_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3963 struct bfd_link_info *info)
3964 {
3965 struct elf_nds32_link_hash_table *htab;
3966 bfd *dynobj;
3967 asection *s;
3968 bfd_boolean relocs;
3969 bfd *ibfd;
3970
3971 htab = nds32_elf_hash_table (info);
3972 dynobj = htab->root.dynobj;
3973 BFD_ASSERT (dynobj != NULL);
3974
3975 if (htab->root.dynamic_sections_created)
3976 {
3977 /* Set the contents of the .interp section to the interpreter. */
3978 if (!info->shared)
3979 {
3980 s = bfd_get_section_by_name (dynobj, ".interp");
3981 BFD_ASSERT (s != NULL);
3982 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3983 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3984 }
3985 }
3986
3987 /* Set up .got offsets for local syms, and space for local dynamic
3988 relocs. */
3989 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3990 {
3991 bfd_signed_vma *local_got;
3992 bfd_signed_vma *end_local_got;
3993 bfd_size_type locsymcount;
3994 Elf_Internal_Shdr *symtab_hdr;
3995 asection *srel;
3996
3997 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
3998 continue;
3999
4000 for (s = ibfd->sections; s != NULL; s = s->next)
4001 {
4002 struct elf_nds32_dyn_relocs *p;
4003
4004 for (p = ((struct elf_nds32_dyn_relocs *)
4005 elf_section_data (s)->local_dynrel);
4006 p != NULL; p = p->next)
4007 {
4008 if (!bfd_is_abs_section (p->sec)
4009 && bfd_is_abs_section (p->sec->output_section))
4010 {
4011 /* Input section has been discarded, either because
4012 it is a copy of a linkonce section or due to
4013 linker script /DISCARD/, so we'll be discarding
4014 the relocs too. */
4015 }
4016 else if (p->count != 0)
4017 {
4018 srel = elf_section_data (p->sec)->sreloc;
4019 srel->size += p->count * sizeof (Elf32_External_Rela);
4020 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
4021 info->flags |= DF_TEXTREL;
4022 }
4023 }
4024 }
4025
4026 local_got = elf_local_got_refcounts (ibfd);
4027 if (!local_got)
4028 continue;
4029
4030 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4031 locsymcount = symtab_hdr->sh_info;
4032 end_local_got = local_got + locsymcount;
4033 s = htab->sgot;
4034 srel = htab->srelgot;
4035 for (; local_got < end_local_got; ++local_got)
4036 {
4037 if (*local_got > 0)
4038 {
4039 *local_got = s->size;
4040 s->size += 4;
4041 if (info->shared)
4042 srel->size += sizeof (Elf32_External_Rela);
4043 }
4044 else
4045 *local_got = (bfd_vma) - 1;
4046 }
4047 }
4048
4049 /* Allocate global sym .plt and .got entries, and space for global
4050 sym dynamic relocs. */
4051 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (void *) info);
4052
4053 /* We now have determined the sizes of the various dynamic sections.
4054 Allocate memory for them. */
4055 relocs = FALSE;
4056 for (s = dynobj->sections; s != NULL; s = s->next)
4057 {
4058 if ((s->flags & SEC_LINKER_CREATED) == 0)
4059 continue;
4060
4061 if (s == htab->splt)
4062 {
4063 /* Strip this section if we don't need it; see the
4064 comment below. */
4065 }
4066 else if (s == htab->sgot)
4067 {
4068 got_size += s->size;
4069 }
4070 else if (s == htab->sgotplt)
4071 {
4072 got_size += s->size;
4073 }
4074 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
4075 {
4076 if (s->size != 0 && s != htab->srelplt)
4077 relocs = TRUE;
4078
4079 /* We use the reloc_count field as a counter if we need
4080 to copy relocs into the output file. */
4081 s->reloc_count = 0;
4082 }
4083 else
4084 {
4085 /* It's not one of our sections, so don't allocate space. */
4086 continue;
4087 }
4088
4089 if (s->size == 0)
4090 {
4091 /* If we don't need this section, strip it from the
4092 output file. This is mostly to handle .rela.bss and
4093 .rela.plt. We must create both sections in
4094 create_dynamic_sections, because they must be created
4095 before the linker maps input sections to output
4096 sections. The linker does that before
4097 adjust_dynamic_symbol is called, and it is that
4098 function which decides whether anything needs to go
4099 into these sections. */
4100 s->flags |= SEC_EXCLUDE;
4101 continue;
4102 }
4103
4104 /* Allocate memory for the section contents. We use bfd_zalloc
4105 here in case unused entries are not reclaimed before the
4106 section's contents are written out. This should not happen,
4107 but this way if it does, we get a R_NDS32_NONE reloc instead
4108 of garbage. */
4109 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4110 if (s->contents == NULL)
4111 return FALSE;
4112 }
4113
4114
4115 if (htab->root.dynamic_sections_created)
4116 {
4117 /* Add some entries to the .dynamic section. We fill in the
4118 values later, in nds32_elf_finish_dynamic_sections, but we
4119 must add the entries now so that we get the correct size for
4120 the .dynamic section. The DT_DEBUG entry is filled in by the
4121 dynamic linker and used by the debugger. */
4122 #define add_dynamic_entry(TAG, VAL) \
4123 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4124
4125 if (!info->shared)
4126 {
4127 if (!add_dynamic_entry (DT_DEBUG, 0))
4128 return FALSE;
4129 }
4130
4131 if (htab->splt->size != 0)
4132 {
4133 if (!add_dynamic_entry (DT_PLTGOT, 0)
4134 || !add_dynamic_entry (DT_PLTRELSZ, 0)
4135 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4136 || !add_dynamic_entry (DT_JMPREL, 0))
4137 return FALSE;
4138 }
4139
4140 if (relocs)
4141 {
4142 if (!add_dynamic_entry (DT_RELA, 0)
4143 || !add_dynamic_entry (DT_RELASZ, 0)
4144 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
4145 return FALSE;
4146
4147 /* If any dynamic relocs apply to a read-only section,
4148 then we need a DT_TEXTREL entry. */
4149 if ((info->flags & DF_TEXTREL) == 0)
4150 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
4151 (void *) info);
4152
4153 if ((info->flags & DF_TEXTREL) != 0)
4154 {
4155 if (!add_dynamic_entry (DT_TEXTREL, 0))
4156 return FALSE;
4157 }
4158 }
4159 }
4160 #undef add_dynamic_entry
4161
4162 return TRUE;
4163 }
4164
4165 static bfd_reloc_status_type
nds32_relocate_contents(reloc_howto_type * howto,bfd * input_bfd,bfd_vma relocation,bfd_byte * location)4166 nds32_relocate_contents (reloc_howto_type *howto, bfd *input_bfd,
4167 bfd_vma relocation, bfd_byte *location)
4168 {
4169 int size;
4170 bfd_vma x = 0;
4171 bfd_reloc_status_type flag;
4172 unsigned int rightshift = howto->rightshift;
4173 unsigned int bitpos = howto->bitpos;
4174
4175 /* If the size is negative, negate RELOCATION. This isn't very
4176 general. */
4177 if (howto->size < 0)
4178 relocation = -relocation;
4179
4180 /* Get the value we are going to relocate. */
4181 size = bfd_get_reloc_size (howto);
4182 switch (size)
4183 {
4184 default:
4185 case 0:
4186 case 1:
4187 case 8:
4188 abort ();
4189 break;
4190 case 2:
4191 x = bfd_getb16 (location);
4192 break;
4193 case 4:
4194 x = bfd_getb32 (location);
4195 break;
4196 }
4197
4198 /* Check for overflow. FIXME: We may drop bits during the addition
4199 which we don't check for. We must either check at every single
4200 operation, which would be tedious, or we must do the computations
4201 in a type larger than bfd_vma, which would be inefficient. */
4202 flag = bfd_reloc_ok;
4203 if (howto->complain_on_overflow != complain_overflow_dont)
4204 {
4205 bfd_vma addrmask, fieldmask, signmask, ss;
4206 bfd_vma a, b, sum;
4207
4208 /* Get the values to be added together. For signed and unsigned
4209 relocations, we assume that all values should be truncated to
4210 the size of an address. For bitfields, all the bits matter.
4211 See also bfd_check_overflow. */
4212 fieldmask = N_ONES (howto->bitsize);
4213 signmask = ~fieldmask;
4214 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4215 a = (relocation & addrmask) >> rightshift;
4216 b = (x & howto->src_mask & addrmask) >> bitpos;
4217
4218 switch (howto->complain_on_overflow)
4219 {
4220 case complain_overflow_signed:
4221 /* If any sign bits are set, all sign bits must be set.
4222 That is, A must be a valid negative address after
4223 shifting. */
4224 signmask = ~(fieldmask >> 1);
4225 /* Fall through. */
4226
4227 case complain_overflow_bitfield:
4228 /* Much like the signed check, but for a field one bit
4229 wider. We allow a bitfield to represent numbers in the
4230 range -2**n to 2**n-1, where n is the number of bits in the
4231 field. Note that when bfd_vma is 32 bits, a 32-bit reloc
4232 can't overflow, which is exactly what we want. */
4233 ss = a & signmask;
4234 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4235 flag = bfd_reloc_overflow;
4236
4237 /* We only need this next bit of code if the sign bit of B
4238 is below the sign bit of A. This would only happen if
4239 SRC_MASK had fewer bits than BITSIZE. Note that if
4240 SRC_MASK has more bits than BITSIZE, we can get into
4241 trouble; we would need to verify that B is in range, as
4242 we do for A above. */
4243 ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4244 ss >>= bitpos;
4245
4246 /* Set all the bits above the sign bit. */
4247 b = (b ^ ss) - ss;
4248
4249 /* Now we can do the addition. */
4250 sum = a + b;
4251
4252 /* See if the result has the correct sign. Bits above the
4253 sign bit are junk now; ignore them. If the sum is
4254 positive, make sure we did not have all negative inputs;
4255 if the sum is negative, make sure we did not have all
4256 positive inputs. The test below looks only at the sign
4257 bits, and it really just
4258 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4259
4260 We mask with addrmask here to explicitly allow an address
4261 wrap-around. The Linux kernel relies on it, and it is
4262 the only way to write assembler code which can run when
4263 loaded at a location 0x80000000 away from the location at
4264 which it is linked. */
4265 if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4266 flag = bfd_reloc_overflow;
4267
4268 break;
4269
4270 case complain_overflow_unsigned:
4271 /* Checking for an unsigned overflow is relatively easy:
4272 trim the addresses and add, and trim the result as well.
4273 Overflow is normally indicated when the result does not
4274 fit in the field. However, we also need to consider the
4275 case when, e.g., fieldmask is 0x7fffffff or smaller, an
4276 input is 0x80000000, and bfd_vma is only 32 bits; then we
4277 will get sum == 0, but there is an overflow, since the
4278 inputs did not fit in the field. Instead of doing a
4279 separate test, we can check for this by or-ing in the
4280 operands when testing for the sum overflowing its final
4281 field. */
4282 sum = (a + b) & addrmask;
4283 if ((a | b | sum) & signmask)
4284 flag = bfd_reloc_overflow;
4285 break;
4286
4287 default:
4288 abort ();
4289 }
4290 }
4291
4292 /* Put RELOCATION in the right bits. */
4293 relocation >>= (bfd_vma) rightshift;
4294 relocation <<= (bfd_vma) bitpos;
4295
4296 /* Add RELOCATION to the right bits of X. */
4297 /* FIXME : 090616
4298 Because the relaxation may generate duplicate relocation at one address,
4299 an addition to immediate in the instruction may cause the relocation added
4300 several times.
4301 This bug should be fixed in assembler, but a check is also needed here. */
4302 if (howto->partial_inplace)
4303 x = ((x & ~howto->dst_mask)
4304 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4305 else
4306 x = ((x & ~howto->dst_mask) | ((relocation) & howto->dst_mask));
4307
4308
4309 /* Put the relocated value back in the object file. */
4310 switch (size)
4311 {
4312 default:
4313 case 0:
4314 case 1:
4315 case 8:
4316 abort ();
4317 break;
4318 case 2:
4319 bfd_putb16 (x, location);
4320 break;
4321 case 4:
4322 bfd_putb32 (x, location);
4323 break;
4324 }
4325
4326 return flag;
4327 }
4328
4329 static bfd_reloc_status_type
nds32_elf_final_link_relocate(reloc_howto_type * howto,bfd * input_bfd,asection * input_section,bfd_byte * contents,bfd_vma address,bfd_vma value,bfd_vma addend)4330 nds32_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
4331 asection *input_section, bfd_byte *contents,
4332 bfd_vma address, bfd_vma value, bfd_vma addend)
4333 {
4334 bfd_vma relocation;
4335
4336 /* Sanity check the address. */
4337 if (address > bfd_get_section_limit (input_bfd, input_section))
4338 return bfd_reloc_outofrange;
4339
4340 /* This function assumes that we are dealing with a basic relocation
4341 against a symbol. We want to compute the value of the symbol to
4342 relocate to. This is just VALUE, the value of the symbol, plus
4343 ADDEND, any addend associated with the reloc. */
4344 relocation = value + addend;
4345
4346 /* If the relocation is PC relative, we want to set RELOCATION to
4347 the distance between the symbol (currently in RELOCATION) and the
4348 location we are relocating. Some targets (e.g., i386-aout)
4349 arrange for the contents of the section to be the negative of the
4350 offset of the location within the section; for such targets
4351 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF)
4352 simply leave the contents of the section as zero; for such
4353 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not
4354 need to subtract out the offset of the location within the
4355 section (which is just ADDRESS). */
4356 if (howto->pc_relative)
4357 {
4358 relocation -= (input_section->output_section->vma
4359 + input_section->output_offset);
4360 if (howto->pcrel_offset)
4361 relocation -= address;
4362 }
4363
4364 return nds32_relocate_contents (howto, input_bfd, relocation,
4365 contents + address);
4366 }
4367
4368 static bfd_boolean
nds32_elf_output_symbol_hook(struct bfd_link_info * info,const char * name,Elf_Internal_Sym * elfsym ATTRIBUTE_UNUSED,asection * input_sec,struct elf_link_hash_entry * h ATTRIBUTE_UNUSED)4369 nds32_elf_output_symbol_hook (struct bfd_link_info *info,
4370 const char *name,
4371 Elf_Internal_Sym *elfsym ATTRIBUTE_UNUSED,
4372 asection *input_sec,
4373 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4374 {
4375 const char *source;
4376 FILE *sym_ld_script = NULL;
4377 struct elf_nds32_link_hash_table *table;
4378
4379 table = nds32_elf_hash_table (info);
4380 sym_ld_script = table->sym_ld_script;
4381 if (!sym_ld_script)
4382 return TRUE;
4383
4384 if (!h || !name || *name == '\0')
4385 return TRUE;
4386
4387 if (input_sec->flags & SEC_EXCLUDE)
4388 return TRUE;
4389
4390 if (!check_start_export_sym)
4391 {
4392 fprintf (sym_ld_script, "SECTIONS\n{\n");
4393 check_start_export_sym = 1;
4394 }
4395
4396 if (h->root.type == bfd_link_hash_defined
4397 || h->root.type == bfd_link_hash_defweak)
4398 {
4399 if (!h->root.u.def.section->output_section)
4400 return TRUE;
4401
4402 if (bfd_is_const_section (input_sec))
4403 source = input_sec->name;
4404 else
4405 source = input_sec->owner->filename;
4406
4407 fprintf (sym_ld_script, "\t%s = 0x%08lx;\t /* %s */\n",
4408 h->root.root.string,
4409 (long) (h->root.u.def.value
4410 + h->root.u.def.section->output_section->vma
4411 + h->root.u.def.section->output_offset), source);
4412 }
4413
4414 return TRUE;
4415 }
4416
4417 /* Relocate an NDS32/D ELF section.
4418 There is some attempt to make this function usable for many architectures,
4419 both for RELA and REL type relocs, if only to serve as a learning tool.
4420
4421 The RELOCATE_SECTION function is called by the new ELF backend linker
4422 to handle the relocations for a section.
4423
4424 The relocs are always passed as Rela structures; if the section
4425 actually uses Rel structures, the r_addend field will always be
4426 zero.
4427
4428 This function is responsible for adjust the section contents as
4429 necessary, and (if using Rela relocs and generating a
4430 relocatable output file) adjusting the reloc addend as
4431 necessary.
4432
4433 This function does not have to worry about setting the reloc
4434 address or the reloc symbol index.
4435
4436 LOCAL_SYMS is a pointer to the swapped in local symbols.
4437
4438 LOCAL_SECTIONS is an array giving the section in the input file
4439 corresponding to the st_shndx field of each local symbol.
4440
4441 The global hash table entry for the global symbols can be found
4442 via elf_sym_hashes (input_bfd).
4443
4444 When generating relocatable output, this function must handle
4445 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
4446 going to be the section symbol corresponding to the output
4447 section, which means that the addend must be adjusted
4448 accordingly. */
4449
4450 static bfd_vma
dtpoff_base(struct bfd_link_info * info)4451 dtpoff_base (struct bfd_link_info *info)
4452 {
4453 /* If tls_sec is NULL, we should have signalled an error already. */
4454 if (elf_hash_table (info)->tls_sec == NULL)
4455 return 0;
4456 return elf_hash_table (info)->tls_sec->vma;
4457 }
4458
4459 static bfd_boolean
nds32_elf_relocate_section(bfd * output_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info,bfd * input_bfd,asection * input_section,bfd_byte * contents,Elf_Internal_Rela * relocs,Elf_Internal_Sym * local_syms,asection ** local_sections)4460 nds32_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
4461 struct bfd_link_info * info,
4462 bfd * input_bfd,
4463 asection * input_section,
4464 bfd_byte * contents,
4465 Elf_Internal_Rela * relocs,
4466 Elf_Internal_Sym * local_syms,
4467 asection ** local_sections)
4468 {
4469 Elf_Internal_Shdr *symtab_hdr;
4470 struct elf_link_hash_entry **sym_hashes;
4471 Elf_Internal_Rela *rel, *relend;
4472 bfd_boolean ret = TRUE; /* Assume success. */
4473 int align = 0;
4474 bfd_reloc_status_type r;
4475 const char *errmsg = NULL;
4476 bfd_vma gp;
4477 struct elf_nds32_link_hash_table *htab;
4478 bfd *dynobj;
4479 bfd_vma *local_got_offsets;
4480 asection *sgot, *splt, *sreloc;
4481 bfd_vma high_address;
4482 struct elf_nds32_link_hash_table *table;
4483 int eliminate_gc_relocs;
4484 bfd_vma fpbase_addr;
4485
4486 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4487 sym_hashes = elf_sym_hashes (input_bfd);
4488 htab = nds32_elf_hash_table (info);
4489 high_address = bfd_get_section_limit (input_bfd, input_section);
4490
4491 dynobj = htab->root.dynobj;
4492 local_got_offsets = elf_local_got_offsets (input_bfd);
4493
4494 sgot = htab->sgot;
4495 splt = htab->splt;
4496 sreloc = NULL;
4497
4498 rel = relocs;
4499 relend = relocs + input_section->reloc_count;
4500
4501 table = nds32_elf_hash_table (info);
4502 eliminate_gc_relocs = table->eliminate_gc_relocs;
4503 /* By this time, we can adjust the value of _SDA_BASE_. */
4504 if ((!info->relocatable))
4505 {
4506 is_SDA_BASE_set = 1;
4507 r = nds32_elf_final_sda_base (output_bfd, info, &gp, TRUE);
4508 if (r != bfd_reloc_ok)
4509 return FALSE;
4510 }
4511
4512 if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
4513 if (!nds32_elf_ifc_reloc ())
4514 (*_bfd_error_handler) (_("error: IFC relocation error."));
4515
4516 /* Relocation for .ex9.itable. */
4517 if (table->target_optimize & NDS32_RELAX_EX9_ON
4518 || (table->ex9_import_file && table->update_ex9_table))
4519 nds32_elf_ex9_reloc_jmp (info);
4520
4521 /* Use gp as fp to prevent truncated fit. Because in relaxation time
4522 the fp value is set as gp, and it has be reverted for instruction
4523 setting fp. */
4524 fpbase_addr = elf_gp (output_bfd);
4525
4526 for (rel = relocs; rel < relend; rel++)
4527 {
4528 enum elf_nds32_reloc_type r_type;
4529 reloc_howto_type *howto = NULL;
4530 unsigned long r_symndx;
4531 struct elf_link_hash_entry *h = NULL;
4532 Elf_Internal_Sym *sym = NULL;
4533 asection *sec;
4534 bfd_vma relocation;
4535
4536 /* We can't modify r_addend here as elf_link_input_bfd has an assert to
4537 ensure it's zero (we use REL relocs, not RELA). Therefore this
4538 should be assigning zero to `addend', but for clarity we use
4539 `r_addend'. */
4540
4541 bfd_vma addend = rel->r_addend;
4542 bfd_vma offset = rel->r_offset;
4543
4544 r_type = ELF32_R_TYPE (rel->r_info);
4545 if (r_type >= R_NDS32_max)
4546 {
4547 (*_bfd_error_handler) (_("%B: error: unknown relocation type %d."),
4548 input_bfd, r_type);
4549 bfd_set_error (bfd_error_bad_value);
4550 ret = FALSE;
4551 continue;
4552 }
4553
4554 if (r_type == R_NDS32_GNU_VTENTRY
4555 || r_type == R_NDS32_GNU_VTINHERIT
4556 || r_type == R_NDS32_NONE
4557 || r_type == R_NDS32_RELA_GNU_VTENTRY
4558 || r_type == R_NDS32_RELA_GNU_VTINHERIT
4559 || (r_type >= R_NDS32_INSN16 && r_type <= R_NDS32_25_FIXED_RELA)
4560 || r_type == R_NDS32_DATA
4561 || r_type == R_NDS32_TRAN
4562 || (r_type >= R_NDS32_LONGCALL4 && r_type <= R_NDS32_LONGJUMP6))
4563 continue;
4564
4565 /* If we enter the fp-as-gp region. Resolve the address of best fp-base. */
4566 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_BEGIN
4567 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
4568 {
4569 int dist;
4570
4571 /* Distance to relocation of best fp-base is encoded in R_SYM. */
4572 dist = rel->r_addend >> 16;
4573 fpbase_addr = calculate_memory_address (input_bfd, rel + dist,
4574 local_syms, symtab_hdr);
4575 }
4576 else if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_END
4577 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
4578 {
4579 fpbase_addr = elf_gp (output_bfd);
4580 }
4581
4582 if (((r_type >= R_NDS32_DWARF2_OP1_RELA
4583 && r_type <= R_NDS32_DWARF2_LEB_RELA)
4584 || r_type >= R_NDS32_RELAX_ENTRY) && !info->relocatable)
4585 continue;
4586
4587 howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
4588 r_symndx = ELF32_R_SYM (rel->r_info);
4589
4590 /* This is a final link. */
4591 sym = NULL;
4592 sec = NULL;
4593 h = NULL;
4594
4595 if (r_symndx < symtab_hdr->sh_info)
4596 {
4597 /* Local symbol. */
4598 sym = local_syms + r_symndx;
4599 sec = local_sections[r_symndx];
4600
4601 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4602 addend = rel->r_addend;
4603 }
4604 else
4605 {
4606 /* External symbol. */
4607 bfd_boolean warned, ignored, unresolved_reloc;
4608 int symndx = r_symndx - symtab_hdr->sh_info;
4609
4610 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4611 r_symndx, symtab_hdr, sym_hashes, h, sec,
4612 relocation, unresolved_reloc, warned,
4613 ignored);
4614
4615 /* la $fp, _FP_BASE_ is per-function (region).
4616 Handle it specially. */
4617 switch ((int) r_type)
4618 {
4619 case R_NDS32_SDA19S0_RELA:
4620 case R_NDS32_SDA15S0_RELA:
4621 case R_NDS32_20_RELA:
4622 if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
4623 FP_BASE_NAME) == 0)
4624 {
4625 relocation = fpbase_addr;
4626 break;
4627 }
4628 }
4629
4630 }
4631
4632 if (info->relocatable)
4633 {
4634 /* This is a relocatable link. We don't have to change
4635 anything, unless the reloc is against a section symbol,
4636 in which case we have to adjust according to where the
4637 section symbol winds up in the output section. */
4638 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4639 rel->r_addend += sec->output_offset + sym->st_value;
4640
4641 continue;
4642 }
4643
4644 /* Sanity check the address. */
4645 if (offset > high_address)
4646 {
4647 r = bfd_reloc_outofrange;
4648 goto check_reloc;
4649 }
4650
4651 if ((r_type >= R_NDS32_DWARF2_OP1_RELA
4652 && r_type <= R_NDS32_DWARF2_LEB_RELA)
4653 || r_type >= R_NDS32_RELAX_ENTRY)
4654 continue;
4655
4656 switch ((int) r_type)
4657 {
4658 case R_NDS32_GOTOFF:
4659 /* Relocation is relative to the start of the global offset
4660 table (for ld24 rx, #uimm24), e.g. access at label+addend
4661
4662 ld24 rx. #label@GOTOFF + addend
4663 sub rx, r12. */
4664 case R_NDS32_GOTOFF_HI20:
4665 case R_NDS32_GOTOFF_LO12:
4666 case R_NDS32_GOTOFF_LO15:
4667 case R_NDS32_GOTOFF_LO19:
4668 BFD_ASSERT (sgot != NULL);
4669
4670 relocation -= elf_gp (output_bfd);
4671 break;
4672
4673 case R_NDS32_9_PLTREL:
4674 case R_NDS32_25_PLTREL:
4675 /* Relocation is to the entry for this symbol in the
4676 procedure linkage table. */
4677
4678 /* The native assembler will generate a 25_PLTREL reloc
4679 for a local symbol if you assemble a call from one
4680 section to another when using -K pic. */
4681 if (h == NULL)
4682 break;
4683
4684 if (h->forced_local)
4685 break;
4686
4687 /* We didn't make a PLT entry for this symbol. This
4688 happens when statically linking PIC code, or when
4689 using -Bsymbolic. */
4690 if (h->plt.offset == (bfd_vma) - 1)
4691 break;
4692
4693 relocation = (splt->output_section->vma
4694 + splt->output_offset + h->plt.offset);
4695 break;
4696
4697 case R_NDS32_PLT_GOTREL_HI20:
4698 case R_NDS32_PLT_GOTREL_LO12:
4699 case R_NDS32_PLT_GOTREL_LO15:
4700 case R_NDS32_PLT_GOTREL_LO19:
4701 case R_NDS32_PLT_GOTREL_LO20:
4702 if (h == NULL || h->forced_local || h->plt.offset == (bfd_vma) - 1)
4703 {
4704 /* We didn't make a PLT entry for this symbol. This
4705 happens when statically linking PIC code, or when
4706 using -Bsymbolic. */
4707 relocation -= elf_gp (output_bfd);
4708 break;
4709 }
4710
4711 relocation = (splt->output_section->vma
4712 + splt->output_offset + h->plt.offset);
4713
4714 relocation -= elf_gp (output_bfd);
4715 break;
4716
4717 case R_NDS32_PLTREL_HI20:
4718 case R_NDS32_PLTREL_LO12:
4719
4720 /* Relocation is to the entry for this symbol in the
4721 procedure linkage table. */
4722
4723 /* The native assembler will generate a 25_PLTREL reloc
4724 for a local symbol if you assemble a call from one
4725 section to another when using -K pic. */
4726 if (h == NULL)
4727 break;
4728
4729 if (h->forced_local)
4730 break;
4731
4732 if (h->plt.offset == (bfd_vma) - 1)
4733 /* We didn't make a PLT entry for this symbol. This
4734 happens when statically linking PIC code, or when
4735 using -Bsymbolic. */
4736 break;
4737
4738 if (splt == NULL)
4739 break;
4740
4741 relocation = (splt->output_section->vma
4742 + splt->output_offset
4743 + h->plt.offset + 4)
4744 - (input_section->output_section->vma
4745 + input_section->output_offset
4746 + rel->r_offset);
4747
4748 break;
4749
4750 case R_NDS32_GOTPC20:
4751 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
4752 ld24 rx,#_GLOBAL_OFFSET_TABLE_ */
4753 relocation = elf_gp (output_bfd);
4754 break;
4755
4756 case R_NDS32_GOTPC_HI20:
4757 case R_NDS32_GOTPC_LO12:
4758 {
4759 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
4760 bl .+4
4761 seth rx,#high(_GLOBAL_OFFSET_TABLE_)
4762 or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
4763 or
4764 bl .+4
4765 seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
4766 add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
4767 */
4768 relocation = elf_gp (output_bfd);
4769 relocation -= (input_section->output_section->vma
4770 + input_section->output_offset + rel->r_offset);
4771 break;
4772 }
4773
4774 case R_NDS32_GOT20:
4775 /* Fall through. */
4776 case R_NDS32_GOT_HI20:
4777 case R_NDS32_GOT_LO12:
4778 case R_NDS32_GOT_LO15:
4779 case R_NDS32_GOT_LO19:
4780 /* Relocation is to the entry for this symbol in the global
4781 offset table. */
4782 BFD_ASSERT (sgot != NULL);
4783
4784 if (h != NULL)
4785 {
4786 bfd_boolean dyn;
4787 bfd_vma off;
4788
4789 off = h->got.offset;
4790 BFD_ASSERT (off != (bfd_vma) - 1);
4791 dyn = htab->root.dynamic_sections_created;
4792 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
4793 || (info->shared
4794 && (info->symbolic
4795 || h->dynindx == -1
4796 || h->forced_local) && h->def_regular))
4797 {
4798 /* This is actually a static link, or it is a
4799 -Bsymbolic link and the symbol is defined
4800 locally, or the symbol was forced to be local
4801 because of a version file. We must initialize
4802 this entry in the global offset table. Since the
4803 offset must always be a multiple of 4, we use the
4804 least significant bit to record whether we have
4805 initialized it already.
4806
4807 When doing a dynamic link, we create a .rela.got
4808 relocation entry to initialize the value. This
4809 is done in the finish_dynamic_symbol routine. */
4810 if ((off & 1) != 0)
4811 off &= ~1;
4812 else
4813 {
4814 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4815 h->got.offset |= 1;
4816 }
4817 }
4818 relocation = sgot->output_section->vma + sgot->output_offset + off
4819 - elf_gp (output_bfd);
4820 }
4821 else
4822 {
4823 bfd_vma off;
4824 bfd_byte *loc;
4825
4826 BFD_ASSERT (local_got_offsets != NULL
4827 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
4828
4829 off = local_got_offsets[r_symndx];
4830
4831 /* The offset must always be a multiple of 4. We use
4832 the least significant bit to record whether we have
4833 already processed this entry. */
4834 if ((off & 1) != 0)
4835 off &= ~1;
4836 else
4837 {
4838 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4839
4840 if (info->shared)
4841 {
4842 asection *srelgot;
4843 Elf_Internal_Rela outrel;
4844
4845 /* We need to generate a R_NDS32_RELATIVE reloc
4846 for the dynamic linker. */
4847 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4848 BFD_ASSERT (srelgot != NULL);
4849
4850 outrel.r_offset = (elf_gp (output_bfd)
4851 + sgot->output_offset + off);
4852 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
4853 outrel.r_addend = relocation;
4854 loc = srelgot->contents;
4855 loc +=
4856 srelgot->reloc_count * sizeof (Elf32_External_Rela);
4857 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4858 ++srelgot->reloc_count;
4859 }
4860 local_got_offsets[r_symndx] |= 1;
4861 }
4862 relocation = sgot->output_section->vma + sgot->output_offset + off
4863 - elf_gp (output_bfd);
4864 }
4865
4866 break;
4867
4868 case R_NDS32_16_RELA:
4869 case R_NDS32_20_RELA:
4870 case R_NDS32_5_RELA:
4871 case R_NDS32_32_RELA:
4872 case R_NDS32_9_PCREL_RELA:
4873 case R_NDS32_WORD_9_PCREL_RELA:
4874 case R_NDS32_10_UPCREL_RELA:
4875 case R_NDS32_15_PCREL_RELA:
4876 case R_NDS32_17_PCREL_RELA:
4877 case R_NDS32_25_PCREL_RELA:
4878 case R_NDS32_HI20_RELA:
4879 case R_NDS32_LO12S3_RELA:
4880 case R_NDS32_LO12S2_RELA:
4881 case R_NDS32_LO12S2_DP_RELA:
4882 case R_NDS32_LO12S2_SP_RELA:
4883 case R_NDS32_LO12S1_RELA:
4884 case R_NDS32_LO12S0_RELA:
4885 case R_NDS32_LO12S0_ORI_RELA:
4886 if (info->shared && r_symndx != 0
4887 && (input_section->flags & SEC_ALLOC) != 0
4888 && (eliminate_gc_relocs == 0
4889 || (sec && (sec->flags & SEC_EXCLUDE) == 0))
4890 && ((r_type != R_NDS32_9_PCREL_RELA
4891 && r_type != R_NDS32_WORD_9_PCREL_RELA
4892 && r_type != R_NDS32_10_UPCREL_RELA
4893 && r_type != R_NDS32_15_PCREL_RELA
4894 && r_type != R_NDS32_17_PCREL_RELA
4895 && r_type != R_NDS32_25_PCREL_RELA
4896 && !(r_type == R_NDS32_32_RELA
4897 && strcmp (input_section->name, ".eh_frame") == 0))
4898 || (h != NULL && h->dynindx != -1
4899 && (!info->symbolic || !h->def_regular))))
4900 {
4901 Elf_Internal_Rela outrel;
4902 bfd_boolean skip, relocate;
4903 bfd_byte *loc;
4904
4905 /* When generating a shared object, these relocations
4906 are copied into the output file to be resolved at run
4907 time. */
4908
4909 if (sreloc == NULL)
4910 {
4911 const char *name;
4912
4913 name = bfd_elf_string_from_elf_section
4914 (input_bfd, elf_elfheader (input_bfd)->e_shstrndx,
4915 elf_section_data (input_section)->rela.hdr->sh_name);
4916 if (name == NULL)
4917 return FALSE;
4918
4919 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
4920 && strcmp (bfd_get_section_name (input_bfd,
4921 input_section),
4922 name + 5) == 0);
4923
4924 sreloc = bfd_get_section_by_name (dynobj, name);
4925 BFD_ASSERT (sreloc != NULL);
4926 }
4927
4928 skip = FALSE;
4929 relocate = FALSE;
4930
4931 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
4932 info,
4933 input_section,
4934 rel->r_offset);
4935 if (outrel.r_offset == (bfd_vma) - 1)
4936 skip = TRUE;
4937 else if (outrel.r_offset == (bfd_vma) - 2)
4938 skip = TRUE, relocate = TRUE;
4939 outrel.r_offset += (input_section->output_section->vma
4940 + input_section->output_offset);
4941
4942 if (skip)
4943 memset (&outrel, 0, sizeof outrel);
4944 else if (r_type == R_NDS32_17_PCREL_RELA
4945 || r_type == R_NDS32_15_PCREL_RELA
4946 || r_type == R_NDS32_25_PCREL_RELA)
4947 {
4948 BFD_ASSERT (h != NULL && h->dynindx != -1);
4949 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4950 outrel.r_addend = rel->r_addend;
4951 }
4952 else
4953 {
4954 /* h->dynindx may be -1 if this symbol was marked to
4955 become local. */
4956 if (h == NULL
4957 || ((info->symbolic || h->dynindx == -1)
4958 && h->def_regular))
4959 {
4960 relocate = TRUE;
4961 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
4962 outrel.r_addend = relocation + rel->r_addend;
4963 }
4964 else
4965 {
4966 BFD_ASSERT (h->dynindx != -1);
4967 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4968 outrel.r_addend = rel->r_addend;
4969 }
4970 }
4971
4972 loc = sreloc->contents;
4973 loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
4974 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4975 ++sreloc->reloc_count;
4976
4977 /* If this reloc is against an external symbol, we do
4978 not want to fiddle with the addend. Otherwise, we
4979 need to include the symbol value so that it becomes
4980 an addend for the dynamic reloc. */
4981 if (!relocate)
4982 continue;
4983 }
4984 break;
4985
4986 case R_NDS32_25_ABS_RELA:
4987 if (info->shared)
4988 {
4989 (*_bfd_error_handler)
4990 (_("%s: warning: cannot deal R_NDS32_25_ABS_RELA in shared "
4991 "mode."), bfd_get_filename (input_bfd));
4992 return FALSE;
4993 }
4994 break;
4995
4996 case R_NDS32_9_PCREL:
4997 r = nds32_elf_do_9_pcrel_reloc (input_bfd, howto, input_section,
4998 contents, offset,
4999 sec, relocation, addend);
5000 goto check_reloc;
5001
5002 case R_NDS32_HI20:
5003 {
5004 Elf_Internal_Rela *lorel;
5005
5006 /* We allow an arbitrary number of HI20 relocs before the
5007 LO12 reloc. This permits gcc to emit the HI and LO relocs
5008 itself. */
5009 for (lorel = rel + 1;
5010 (lorel < relend
5011 && ELF32_R_TYPE (lorel->r_info) == R_NDS32_HI20); lorel++)
5012 continue;
5013 if (lorel < relend
5014 && (ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S3
5015 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S2
5016 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S1
5017 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S0))
5018 {
5019 nds32_elf_relocate_hi20 (input_bfd, r_type, rel, lorel,
5020 contents, relocation + addend);
5021 r = bfd_reloc_ok;
5022 }
5023 else
5024 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5025 contents, offset, relocation,
5026 addend);
5027 }
5028
5029 goto check_reloc;
5030
5031 case R_NDS32_GOT17S2_RELA:
5032 case R_NDS32_GOT15S2_RELA:
5033 {
5034 bfd_vma off;
5035
5036 BFD_ASSERT (sgot != NULL);
5037
5038 if (h != NULL)
5039 {
5040 bfd_boolean dyn;
5041
5042 off = h->got.offset;
5043 BFD_ASSERT (off != (bfd_vma) - 1);
5044
5045 dyn = htab->root.dynamic_sections_created;
5046 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL
5047 (dyn, info->shared, h) || (info->shared
5048 && (info->symbolic
5049 || h->dynindx == -1
5050 || h->forced_local)
5051 && h->def_regular))
5052 {
5053 /* This is actually a static link, or it is a
5054 -Bsymbolic link and the symbol is defined
5055 locally, or the symbol was forced to be local
5056 because of a version file. We must initialize
5057 this entry in the global offset table. Since the
5058 offset must always be a multiple of 4, we use the
5059 least significant bit to record whether we have
5060 initialized it already.
5061
5062 When doing a dynamic link, we create a .rela.got
5063 relocation entry to initialize the value. This
5064 is done in the finish_dynamic_symbol routine. */
5065 if ((off & 1) != 0)
5066 off &= ~1;
5067 else
5068 {
5069 bfd_put_32 (output_bfd, relocation,
5070 sgot->contents + off);
5071 h->got.offset |= 1;
5072 }
5073 }
5074 }
5075 else
5076 {
5077 bfd_byte *loc;
5078
5079 BFD_ASSERT (local_got_offsets != NULL
5080 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5081
5082 off = local_got_offsets[r_symndx];
5083
5084 /* The offset must always be a multiple of 4. We use
5085 the least significant bit to record whether we have
5086 already processed this entry. */
5087 if ((off & 1) != 0)
5088 off &= ~1;
5089 else
5090 {
5091 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5092
5093 if (info->shared)
5094 {
5095 asection *srelgot;
5096 Elf_Internal_Rela outrel;
5097
5098 /* We need to generate a R_NDS32_RELATIVE reloc
5099 for the dynamic linker. */
5100 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5101 BFD_ASSERT (srelgot != NULL);
5102
5103 outrel.r_offset = (elf_gp (output_bfd)
5104 + sgot->output_offset + off);
5105 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5106 outrel.r_addend = relocation;
5107 loc = srelgot->contents;
5108 loc +=
5109 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5110 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5111 ++srelgot->reloc_count;
5112 }
5113 local_got_offsets[r_symndx] |= 1;
5114 }
5115 }
5116 relocation = sgot->output_section->vma + sgot->output_offset + off
5117 - elf_gp (output_bfd);
5118 }
5119 if (relocation & align)
5120 {
5121 /* Incorrect alignment. */
5122 (*_bfd_error_handler)
5123 (_("%B: warning: unaligned access to GOT entry."), input_bfd);
5124 ret = FALSE;
5125 r = bfd_reloc_dangerous;
5126 goto check_reloc;
5127 }
5128 break;
5129
5130 case R_NDS32_SDA16S3_RELA:
5131 case R_NDS32_SDA15S3_RELA:
5132 case R_NDS32_SDA15S3:
5133 align = 0x7;
5134 goto handle_sda;
5135
5136 case R_NDS32_SDA17S2_RELA:
5137 case R_NDS32_SDA15S2_RELA:
5138 case R_NDS32_SDA12S2_SP_RELA:
5139 case R_NDS32_SDA12S2_DP_RELA:
5140 case R_NDS32_SDA15S2:
5141 case R_NDS32_SDA_FP7U2_RELA:
5142 align = 0x3;
5143 goto handle_sda;
5144
5145 case R_NDS32_SDA18S1_RELA:
5146 case R_NDS32_SDA15S1_RELA:
5147 case R_NDS32_SDA15S1:
5148 align = 0x1;
5149 goto handle_sda;
5150
5151 case R_NDS32_SDA19S0_RELA:
5152 case R_NDS32_SDA15S0_RELA:
5153 case R_NDS32_SDA15S0:
5154 {
5155 align = 0x0;
5156 handle_sda:
5157 BFD_ASSERT (sec != NULL);
5158
5159 /* If the symbol is in the abs section, the out_bfd will be null.
5160 This happens when the relocation has a symbol@GOTOFF. */
5161 r = nds32_elf_final_sda_base (output_bfd, info, &gp, FALSE);
5162 if (r != bfd_reloc_ok)
5163 {
5164 (*_bfd_error_handler)
5165 (_("%B: warning: relocate SDA_BASE failed."), input_bfd);
5166 ret = FALSE;
5167 goto check_reloc;
5168 }
5169
5170 /* At this point `relocation' contains the object's
5171 address. */
5172 if (r_type == R_NDS32_SDA_FP7U2_RELA)
5173 {
5174 relocation -= fpbase_addr;
5175 }
5176 else
5177 relocation -= gp;
5178 /* Now it contains the offset from _SDA_BASE_. */
5179
5180 /* Make sure alignment is correct. */
5181
5182 if (relocation & align)
5183 {
5184 /* Incorrect alignment. */
5185 (*_bfd_error_handler)
5186 (_("%B(%A): warning: unaligned small data access of type %d."),
5187 input_bfd, input_section, r_type);
5188 ret = FALSE;
5189 goto check_reloc;
5190 }
5191 }
5192
5193 break;
5194 case R_NDS32_17IFC_PCREL_RELA:
5195 case R_NDS32_10IFCU_PCREL_RELA:
5196 /* do nothing */
5197 break;
5198
5199 case R_NDS32_TLS_LE_HI20:
5200 case R_NDS32_TLS_LE_LO12:
5201 case R_NDS32_TLS_LE_20:
5202 case R_NDS32_TLS_LE_15S0:
5203 case R_NDS32_TLS_LE_15S1:
5204 case R_NDS32_TLS_LE_15S2:
5205 if (elf_hash_table (info)->tls_sec != NULL)
5206 relocation -= (elf_hash_table (info)->tls_sec->vma + TP_OFFSET);
5207 break;
5208 case R_NDS32_TLS_IE_HI20:
5209 case R_NDS32_TLS_IE_LO12S2:
5210 {
5211 /* Relocation is to the entry for this symbol in the global
5212 offset table. */
5213 unsigned int tls_type;
5214 asection *srelgot;
5215 Elf_Internal_Rela outrel;
5216 bfd_vma off;
5217 bfd_byte *loc;
5218 int indx = 0;
5219
5220 BFD_ASSERT (sgot != NULL);
5221 if (h != NULL)
5222 {
5223 bfd_boolean dyn;
5224
5225 off = h->got.offset;
5226 BFD_ASSERT (off != (bfd_vma) - 1);
5227 dyn = htab->root.dynamic_sections_created;
5228 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
5229 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
5230 && (!info->shared
5231 || !SYMBOL_REFERENCES_LOCAL (info, h)))
5232 indx = h->dynindx;
5233 }
5234 else
5235 {
5236 /* Never happen currently. */
5237 BFD_ASSERT (local_got_offsets != NULL
5238 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5239
5240 off = local_got_offsets[r_symndx];
5241
5242 tls_type = elf32_nds32_local_got_tls_type (input_bfd)[r_symndx];
5243 }
5244 relocation = sgot->output_section->vma + sgot->output_offset + off;
5245
5246 if (r_type == R_NDS32_TLS_IE_LO12S2)
5247 break;
5248
5249 /* The offset must always be a multiple of 4. We use
5250 the least significant bit to record whether we have
5251 already processed this entry. */
5252 if ((off & 1) != 0)
5253 off &= ~1;
5254 else
5255 {
5256 bfd_boolean need_relocs = FALSE;
5257 srelgot = htab->srelgot;
5258 if ((info->shared || indx != 0)
5259 && (h == NULL
5260 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5261 || h->root.type != bfd_link_hash_undefweak))
5262 {
5263 need_relocs = TRUE;
5264 BFD_ASSERT (srelgot != NULL);
5265 }
5266 if (tls_type & GOT_TLS_IE)
5267 {
5268 if (need_relocs)
5269 {
5270 if (h->dynindx == 0)
5271 outrel.r_addend = relocation - dtpoff_base (info);
5272 else
5273 outrel.r_addend = 0;
5274 outrel.r_offset = (sgot->output_section->vma
5275 + sgot->output_offset
5276 + off);
5277 outrel.r_info =
5278 ELF32_R_INFO (h->dynindx, R_NDS32_TLS_TPOFF);
5279
5280 loc = srelgot->contents;
5281 loc +=
5282 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5283 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5284 ++srelgot->reloc_count;
5285 }
5286 else
5287 bfd_put_32 (output_bfd, h->root.u.def.value - TP_OFFSET,
5288 sgot->contents + off);
5289 }
5290 }
5291 }
5292 break;
5293
5294 /* DON'T fall through. */
5295
5296 default:
5297 /* OLD_NDS32_RELOC. */
5298
5299 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5300 contents, offset, relocation, addend);
5301 goto check_reloc;
5302 }
5303
5304 switch ((int) r_type)
5305 {
5306 case R_NDS32_20_RELA:
5307 case R_NDS32_5_RELA:
5308 case R_NDS32_9_PCREL_RELA:
5309 case R_NDS32_WORD_9_PCREL_RELA:
5310 case R_NDS32_10_UPCREL_RELA:
5311 case R_NDS32_15_PCREL_RELA:
5312 case R_NDS32_17_PCREL_RELA:
5313 case R_NDS32_25_PCREL_RELA:
5314 case R_NDS32_25_ABS_RELA:
5315 case R_NDS32_HI20_RELA:
5316 case R_NDS32_LO12S3_RELA:
5317 case R_NDS32_LO12S2_RELA:
5318 case R_NDS32_LO12S2_DP_RELA:
5319 case R_NDS32_LO12S2_SP_RELA:
5320 case R_NDS32_LO12S1_RELA:
5321 case R_NDS32_LO12S0_RELA:
5322 case R_NDS32_LO12S0_ORI_RELA:
5323 case R_NDS32_SDA16S3_RELA:
5324 case R_NDS32_SDA17S2_RELA:
5325 case R_NDS32_SDA18S1_RELA:
5326 case R_NDS32_SDA19S0_RELA:
5327 case R_NDS32_SDA15S3_RELA:
5328 case R_NDS32_SDA15S2_RELA:
5329 case R_NDS32_SDA12S2_DP_RELA:
5330 case R_NDS32_SDA12S2_SP_RELA:
5331 case R_NDS32_SDA15S1_RELA:
5332 case R_NDS32_SDA15S0_RELA:
5333 case R_NDS32_SDA_FP7U2_RELA:
5334 case R_NDS32_9_PLTREL:
5335 case R_NDS32_25_PLTREL:
5336 case R_NDS32_GOT20:
5337 case R_NDS32_GOT_HI20:
5338 case R_NDS32_GOT_LO12:
5339 case R_NDS32_GOT_LO15:
5340 case R_NDS32_GOT_LO19:
5341 case R_NDS32_GOT15S2_RELA:
5342 case R_NDS32_GOT17S2_RELA:
5343 case R_NDS32_GOTPC20:
5344 case R_NDS32_GOTPC_HI20:
5345 case R_NDS32_GOTPC_LO12:
5346 case R_NDS32_GOTOFF:
5347 case R_NDS32_GOTOFF_HI20:
5348 case R_NDS32_GOTOFF_LO12:
5349 case R_NDS32_GOTOFF_LO15:
5350 case R_NDS32_GOTOFF_LO19:
5351 case R_NDS32_PLTREL_HI20:
5352 case R_NDS32_PLTREL_LO12:
5353 case R_NDS32_PLT_GOTREL_HI20:
5354 case R_NDS32_PLT_GOTREL_LO12:
5355 case R_NDS32_PLT_GOTREL_LO15:
5356 case R_NDS32_PLT_GOTREL_LO19:
5357 case R_NDS32_PLT_GOTREL_LO20:
5358 case R_NDS32_17IFC_PCREL_RELA:
5359 case R_NDS32_10IFCU_PCREL_RELA:
5360 case R_NDS32_TLS_LE_HI20:
5361 case R_NDS32_TLS_LE_LO12:
5362 case R_NDS32_TLS_IE_HI20:
5363 case R_NDS32_TLS_IE_LO12S2:
5364 case R_NDS32_TLS_LE_20:
5365 case R_NDS32_TLS_LE_15S0:
5366 case R_NDS32_TLS_LE_15S1:
5367 case R_NDS32_TLS_LE_15S2:
5368 /* Instruction related relocs must handle endian properly. */
5369 /* NOTE: PIC IS NOT HANDLE YET; DO IT LATER. */
5370 r = nds32_elf_final_link_relocate (howto, input_bfd,
5371 input_section, contents,
5372 rel->r_offset, relocation,
5373 rel->r_addend);
5374 break;
5375
5376 default:
5377 /* All other relocs can use default handler. */
5378 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5379 contents, rel->r_offset,
5380 relocation, rel->r_addend);
5381 break;
5382 }
5383
5384 check_reloc:
5385
5386 if (r != bfd_reloc_ok)
5387 {
5388 /* FIXME: This should be generic enough to go in a utility. */
5389 const char *name;
5390
5391 if (h != NULL)
5392 name = h->root.root.string;
5393 else
5394 {
5395 name = bfd_elf_string_from_elf_section
5396 (input_bfd, symtab_hdr->sh_link, sym->st_name);
5397 if (name == NULL || *name == '\0')
5398 name = bfd_section_name (input_bfd, sec);
5399 }
5400
5401 if (errmsg != NULL)
5402 goto common_error;
5403
5404 switch (r)
5405 {
5406 case bfd_reloc_overflow:
5407 if (!((*info->callbacks->reloc_overflow)
5408 (info, (h ? &h->root : NULL), name, howto->name,
5409 (bfd_vma) 0, input_bfd, input_section, offset)))
5410 return FALSE;
5411 break;
5412
5413 case bfd_reloc_undefined:
5414 if (!((*info->callbacks->undefined_symbol)
5415 (info, name, input_bfd, input_section, offset, TRUE)))
5416 return FALSE;
5417 break;
5418
5419 case bfd_reloc_outofrange:
5420 errmsg = _("internal error: out of range error");
5421 goto common_error;
5422
5423 case bfd_reloc_notsupported:
5424 errmsg = _("internal error: unsupported relocation error");
5425 goto common_error;
5426
5427 case bfd_reloc_dangerous:
5428 errmsg = _("internal error: dangerous error");
5429 goto common_error;
5430
5431 default:
5432 errmsg = _("internal error: unknown error");
5433 /* Fall through. */
5434
5435 common_error:
5436 if (!((*info->callbacks->warning)
5437 (info, errmsg, name, input_bfd, input_section, offset)))
5438 return FALSE;
5439 break;
5440 }
5441 }
5442 }
5443
5444 return ret;
5445 }
5446
5447 /* Finish up dynamic symbol handling. We set the contents of various
5448 dynamic sections here. */
5449
5450 static bfd_boolean
nds32_elf_finish_dynamic_symbol(bfd * output_bfd,struct bfd_link_info * info,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym)5451 nds32_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
5452 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
5453 {
5454 struct elf_nds32_link_hash_table *htab;
5455 bfd_byte *loc;
5456
5457 htab = nds32_elf_hash_table (info);
5458
5459 if (h->plt.offset != (bfd_vma) - 1)
5460 {
5461 asection *splt;
5462 asection *sgot;
5463 asection *srela;
5464
5465 bfd_vma plt_index;
5466 bfd_vma got_offset;
5467 bfd_vma local_plt_offset;
5468 Elf_Internal_Rela rela;
5469
5470 /* This symbol has an entry in the procedure linkage table. Set
5471 it up. */
5472
5473 BFD_ASSERT (h->dynindx != -1);
5474
5475 splt = htab->splt;
5476 sgot = htab->sgotplt;
5477 srela = htab->srelplt;
5478 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
5479
5480 /* Get the index in the procedure linkage table which
5481 corresponds to this symbol. This is the index of this symbol
5482 in all the symbols for which we are making plt entries. The
5483 first entry in the procedure linkage table is reserved. */
5484 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
5485
5486 /* Get the offset into the .got table of the entry that
5487 corresponds to this function. Each .got entry is 4 bytes.
5488 The first three are reserved. */
5489 got_offset = (plt_index + 3) * 4;
5490
5491 /* Fill in the entry in the procedure linkage table. */
5492 if (!info->shared)
5493 {
5494 unsigned long insn;
5495
5496 insn = PLT_ENTRY_WORD0 + (((sgot->output_section->vma
5497 + sgot->output_offset + got_offset) >> 12)
5498 & 0xfffff);
5499 bfd_putb32 (insn, splt->contents + h->plt.offset);
5500
5501 insn = PLT_ENTRY_WORD1 + (((sgot->output_section->vma
5502 + sgot->output_offset + got_offset) & 0x0fff)
5503 >> 2);
5504 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
5505
5506 insn = PLT_ENTRY_WORD2;
5507 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
5508
5509 insn = PLT_ENTRY_WORD3 + (plt_index & 0x7ffff);
5510 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
5511
5512 insn = PLT_ENTRY_WORD4
5513 + (((unsigned int) ((-(h->plt.offset + 16)) >> 1)) & 0xffffff);
5514 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
5515 local_plt_offset = 12;
5516 }
5517 else
5518 {
5519 /* sda_base must be set at this time. */
5520 unsigned long insn;
5521 long offset;
5522
5523 /* FIXME, sda_base is 65536, it will damage opcode. */
5524 /* insn = PLT_PIC_ENTRY_WORD0 + (((got_offset - sda_base) >> 2) & 0x7fff); */
5525 offset = sgot->output_section->vma + sgot->output_offset + got_offset
5526 - elf_gp (output_bfd);
5527 insn = PLT_PIC_ENTRY_WORD0 + ((offset >> 12) & 0xfffff);
5528 bfd_putb32 (insn, splt->contents + h->plt.offset);
5529
5530 insn = PLT_PIC_ENTRY_WORD1 + (offset & 0xfff);
5531 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
5532
5533 insn = PLT_PIC_ENTRY_WORD2;
5534 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
5535
5536 insn = PLT_PIC_ENTRY_WORD3;
5537 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
5538
5539 insn = PLT_PIC_ENTRY_WORD4 + (plt_index & 0x7fffff);
5540 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
5541
5542 insn = PLT_PIC_ENTRY_WORD5
5543 + (((unsigned int) ((-(h->plt.offset + 20)) >> 1)) & 0xffffff);
5544 bfd_putb32 (insn, splt->contents + h->plt.offset + 20);
5545
5546 local_plt_offset = 16;
5547 }
5548
5549 /* Fill in the entry in the global offset table,
5550 so it will fall through to the next instruction for the first time. */
5551 bfd_put_32 (output_bfd,
5552 (splt->output_section->vma + splt->output_offset
5553 + h->plt.offset + local_plt_offset),
5554 sgot->contents + got_offset);
5555
5556 /* Fill in the entry in the .rela.plt section. */
5557 rela.r_offset = (sgot->output_section->vma
5558 + sgot->output_offset + got_offset);
5559 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_JMP_SLOT);
5560 rela.r_addend = 0;
5561 loc = srela->contents;
5562 loc += plt_index * sizeof (Elf32_External_Rela);
5563 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5564
5565 if (!h->def_regular)
5566 {
5567 /* Mark the symbol as undefined, rather than as defined in
5568 the .plt section. Leave the value alone. */
5569 sym->st_shndx = SHN_UNDEF;
5570 if (!h->ref_regular_nonweak)
5571 sym->st_value = 0;
5572 }
5573 }
5574
5575 if (h->got.offset != (bfd_vma) - 1)
5576 {
5577 asection *sgot;
5578 asection *srela;
5579 Elf_Internal_Rela rela;
5580
5581 /* This symbol has an entry in the global offset table.
5582 Set it up. */
5583
5584 sgot = htab->sgot;
5585 srela = htab->srelgot;
5586 BFD_ASSERT (sgot != NULL && srela != NULL);
5587
5588 rela.r_offset = (sgot->output_section->vma
5589 + sgot->output_offset + (h->got.offset & ~1));
5590
5591 /* If this is a -Bsymbolic link, and the symbol is defined
5592 locally, we just want to emit a RELATIVE reloc. Likewise if
5593 the symbol was forced to be local because of a version file.
5594 The entry in the global offset table will already have been
5595 initialized in the relocate_section function. */
5596 if (info->shared
5597 && (info->symbolic
5598 || h->dynindx == -1 || h->forced_local) && h->def_regular)
5599 {
5600 rela.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5601 rela.r_addend = (h->root.u.def.value
5602 + h->root.u.def.section->output_section->vma
5603 + h->root.u.def.section->output_offset);
5604 }
5605 else
5606 {
5607 BFD_ASSERT ((h->got.offset & 1) == 0);
5608 bfd_put_32 (output_bfd, (bfd_vma) 0,
5609 sgot->contents + h->got.offset);
5610 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_GLOB_DAT);
5611 rela.r_addend = 0;
5612 }
5613
5614 loc = srela->contents;
5615 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
5616 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5617 ++srela->reloc_count;
5618 }
5619
5620 if (h->needs_copy)
5621 {
5622 asection *s;
5623 Elf_Internal_Rela rela;
5624
5625 /* This symbols needs a copy reloc. Set it up. */
5626
5627 BFD_ASSERT (h->dynindx != -1
5628 && (h->root.type == bfd_link_hash_defined
5629 || h->root.type == bfd_link_hash_defweak));
5630
5631 s = bfd_get_section_by_name (h->root.u.def.section->owner, ".rela.bss");
5632 BFD_ASSERT (s != NULL);
5633
5634 rela.r_offset = (h->root.u.def.value
5635 + h->root.u.def.section->output_section->vma
5636 + h->root.u.def.section->output_offset);
5637 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_COPY);
5638 rela.r_addend = 0;
5639 loc = s->contents;
5640 loc += s->reloc_count * sizeof (Elf32_External_Rela);
5641 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5642 ++s->reloc_count;
5643 }
5644
5645 /* Mark some specially defined symbols as absolute. */
5646 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5647 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
5648 sym->st_shndx = SHN_ABS;
5649
5650 return TRUE;
5651 }
5652
5653
5654 /* Finish up the dynamic sections. */
5655
5656 static bfd_boolean
nds32_elf_finish_dynamic_sections(bfd * output_bfd,struct bfd_link_info * info)5657 nds32_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
5658 {
5659 struct elf_nds32_link_hash_table *htab;
5660 bfd *dynobj;
5661 asection *sdyn;
5662 asection *sgot;
5663
5664 htab = nds32_elf_hash_table (info);
5665 dynobj = htab->root.dynobj;
5666
5667 sgot = htab->sgotplt;
5668 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5669
5670 if (htab->root.dynamic_sections_created)
5671 {
5672 asection *splt;
5673 Elf32_External_Dyn *dyncon, *dynconend;
5674
5675 BFD_ASSERT (sgot != NULL && sdyn != NULL);
5676
5677 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5678 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5679
5680 for (; dyncon < dynconend; dyncon++)
5681 {
5682 Elf_Internal_Dyn dyn;
5683 asection *s;
5684
5685 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5686
5687 switch (dyn.d_tag)
5688 {
5689 default:
5690 break;
5691
5692 case DT_PLTGOT:
5693 /* name = ".got"; */
5694 s = htab->sgot->output_section;
5695 goto get_vma;
5696 case DT_JMPREL:
5697 s = htab->srelplt->output_section;
5698 get_vma:
5699 BFD_ASSERT (s != NULL);
5700 dyn.d_un.d_ptr = s->vma;
5701 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5702 break;
5703
5704 case DT_PLTRELSZ:
5705 s = htab->srelplt->output_section;
5706 BFD_ASSERT (s != NULL);
5707 dyn.d_un.d_val = s->size;
5708 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5709 break;
5710
5711 case DT_RELASZ:
5712 /* My reading of the SVR4 ABI indicates that the
5713 procedure linkage table relocs (DT_JMPREL) should be
5714 included in the overall relocs (DT_RELA). This is
5715 what Solaris does. However, UnixWare can not handle
5716 that case. Therefore, we override the DT_RELASZ entry
5717 here to make it not include the JMPREL relocs. Since
5718 the linker script arranges for .rela.plt to follow all
5719 other relocation sections, we don't have to worry
5720 about changing the DT_RELA entry. */
5721 if (htab->srelplt != NULL)
5722 {
5723 s = htab->srelplt->output_section;
5724 dyn.d_un.d_val -= s->size;
5725 }
5726 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5727 break;
5728 }
5729 }
5730
5731 /* Fill in the first entry in the procedure linkage table. */
5732 splt = htab->splt;
5733 if (splt && splt->size > 0)
5734 {
5735 if (info->shared)
5736 {
5737 unsigned long insn;
5738 long offset;
5739
5740 /* FIXME, sda_base is 65536, it will damage opcode. */
5741 /* insn = PLT_PIC_ENTRY_WORD0 + (((got_offset - sda_base) >> 2) & 0x7fff); */
5742 offset = sgot->output_section->vma + sgot->output_offset + 4
5743 - elf_gp (output_bfd);
5744 insn = PLT0_PIC_ENTRY_WORD0 | ((offset >> 12) & 0xfffff);
5745 bfd_putb32 (insn, splt->contents);
5746
5747 /* insn = PLT0_PIC_ENTRY_WORD0 | (((8 - sda_base) >> 2) & 0x7fff) ; */
5748 /* here has a typo? */
5749 insn = PLT0_PIC_ENTRY_WORD1 | (offset & 0xfff);
5750 bfd_putb32 (insn, splt->contents + 4);
5751
5752 insn = PLT0_PIC_ENTRY_WORD2;
5753 bfd_putb32 (insn, splt->contents + 8);
5754
5755 insn = PLT0_PIC_ENTRY_WORD3;
5756 bfd_putb32 (insn, splt->contents + 12);
5757
5758 insn = PLT0_PIC_ENTRY_WORD4;
5759 bfd_putb32 (insn, splt->contents + 16);
5760
5761 insn = PLT0_PIC_ENTRY_WORD5;
5762 bfd_putb32 (insn, splt->contents + 20);
5763 }
5764 else
5765 {
5766 unsigned long insn;
5767 unsigned long addr;
5768
5769 /* addr = .got + 4 */
5770 addr = sgot->output_section->vma + sgot->output_offset + 4;
5771 insn = PLT0_ENTRY_WORD0 | ((addr >> 12) & 0xfffff);
5772 bfd_putb32 (insn, splt->contents);
5773
5774 insn = PLT0_ENTRY_WORD1 | (addr & 0x0fff);
5775 bfd_putb32 (insn, splt->contents + 4);
5776
5777 insn = PLT0_ENTRY_WORD2;
5778 bfd_putb32 (insn, splt->contents + 8);
5779
5780 insn = PLT0_ENTRY_WORD3;
5781 bfd_putb32 (insn, splt->contents + 12);
5782
5783 insn = PLT0_ENTRY_WORD4;
5784 bfd_putb32 (insn, splt->contents + 16);
5785 }
5786
5787 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
5788 PLT_ENTRY_SIZE;
5789 }
5790 }
5791
5792 /* Fill in the first three entries in the global offset table. */
5793 if (sgot && sgot->size > 0)
5794 {
5795 if (sdyn == NULL)
5796 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5797 else
5798 bfd_put_32 (output_bfd,
5799 sdyn->output_section->vma + sdyn->output_offset,
5800 sgot->contents);
5801 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5802 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5803
5804 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
5805 }
5806
5807 return TRUE;
5808 }
5809
5810
5811 /* Set the right machine number. */
5812
5813 static bfd_boolean
nds32_elf_object_p(bfd * abfd)5814 nds32_elf_object_p (bfd *abfd)
5815 {
5816 static unsigned int cur_arch = 0;
5817
5818 if (E_N1_ARCH != (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH))
5819 {
5820 /* E_N1_ARCH is a wild card, so it is set only when no others exist. */
5821 cur_arch = (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH);
5822 }
5823
5824 switch (cur_arch)
5825 {
5826 default:
5827 case E_N1_ARCH:
5828 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1);
5829 break;
5830 case E_N1H_ARCH:
5831 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h);
5832 break;
5833 case E_NDS_ARCH_STAR_V2_0:
5834 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v2);
5835 break;
5836 case E_NDS_ARCH_STAR_V3_0:
5837 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3);
5838 break;
5839 case E_NDS_ARCH_STAR_V3_M:
5840 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3m);
5841 break;
5842 }
5843
5844 return TRUE;
5845 }
5846
5847 /* Store the machine number in the flags field. */
5848
5849 static void
nds32_elf_final_write_processing(bfd * abfd,bfd_boolean linker ATTRIBUTE_UNUSED)5850 nds32_elf_final_write_processing (bfd *abfd,
5851 bfd_boolean linker ATTRIBUTE_UNUSED)
5852 {
5853 unsigned long val;
5854 static unsigned int cur_mach = 0;
5855
5856 if (bfd_mach_n1 != bfd_get_mach (abfd))
5857 {
5858 cur_mach = bfd_get_mach (abfd);
5859 }
5860
5861 switch (cur_mach)
5862 {
5863 case bfd_mach_n1:
5864 /* Only happen when object is empty, since the case is abandon. */
5865 val = E_N1_ARCH;
5866 val |= E_NDS_ABI_AABI;
5867 val |= E_NDS32_ELF_VER_1_4;
5868 break;
5869 case bfd_mach_n1h:
5870 val = E_N1H_ARCH;
5871 break;
5872 case bfd_mach_n1h_v2:
5873 val = E_NDS_ARCH_STAR_V2_0;
5874 break;
5875 case bfd_mach_n1h_v3:
5876 val = E_NDS_ARCH_STAR_V3_0;
5877 break;
5878 case bfd_mach_n1h_v3m:
5879 val = E_NDS_ARCH_STAR_V3_M;
5880 break;
5881 default:
5882 val = 0;
5883 break;
5884 }
5885
5886 elf_elfheader (abfd)->e_flags &= ~EF_NDS_ARCH;
5887 elf_elfheader (abfd)->e_flags |= val;
5888 }
5889
5890 /* Function to keep NDS32 specific file flags. */
5891
5892 static bfd_boolean
nds32_elf_set_private_flags(bfd * abfd,flagword flags)5893 nds32_elf_set_private_flags (bfd *abfd, flagword flags)
5894 {
5895 BFD_ASSERT (!elf_flags_init (abfd)
5896 || elf_elfheader (abfd)->e_flags == flags);
5897
5898 elf_elfheader (abfd)->e_flags = flags;
5899 elf_flags_init (abfd) = TRUE;
5900 return TRUE;
5901 }
5902
5903 static unsigned int
convert_e_flags(unsigned int e_flags,unsigned int arch)5904 convert_e_flags (unsigned int e_flags, unsigned int arch)
5905 {
5906 if ((e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9)
5907 {
5908 /* From 0.9 to 1.0. */
5909 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V1_0;
5910
5911 /* Invert E_NDS32_HAS_NO_MAC_INST. */
5912 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
5913 if (arch == E_NDS_ARCH_STAR_V1_0)
5914 {
5915 /* Done. */
5916 return e_flags;
5917 }
5918 }
5919
5920 /* From 1.0 to 2.0. */
5921 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V2_0;
5922
5923 /* Clear E_NDS32_HAS_MFUSR_PC_INST. */
5924 e_flags &= ~E_NDS32_HAS_MFUSR_PC_INST;
5925
5926 /* Invert E_NDS32_HAS_NO_MAC_INST. */
5927 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
5928 return e_flags;
5929 }
5930
5931 static bfd_boolean
nds32_check_vec_size(bfd * ibfd)5932 nds32_check_vec_size (bfd *ibfd)
5933 {
5934 static unsigned int nds32_vec_size = 0;
5935
5936 asection *sec_t = NULL;
5937 bfd_byte *contents = NULL;
5938
5939 sec_t = bfd_get_section_by_name (ibfd, ".nds32_e_flags");
5940
5941 if (sec_t && sec_t->size >= 4)
5942 {
5943 /* Get vec_size in file. */
5944 unsigned int flag_t;
5945
5946 nds32_get_section_contents (ibfd, sec_t, &contents);
5947 flag_t = bfd_get_32 (ibfd, contents);
5948
5949 /* The value could only be 4 or 16. */
5950
5951 if (!nds32_vec_size)
5952 /* Set if not set yet. */
5953 nds32_vec_size = (flag_t & 0x3);
5954 else if (nds32_vec_size != (flag_t & 0x3))
5955 {
5956 (*_bfd_error_handler) (_("%B: ISR vector size mismatch"
5957 " with previous modules, previous %u-byte, current %u-byte"),
5958 ibfd,
5959 nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
5960 (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
5961 return FALSE;
5962 }
5963 else
5964 /* Only keep the first vec_size section. */
5965 sec_t->flags |= SEC_EXCLUDE;
5966 }
5967
5968 return TRUE;
5969 }
5970
5971 /* Merge backend specific data from an object file to the output
5972 object file when linking. */
5973
5974 static bfd_boolean
nds32_elf_merge_private_bfd_data(bfd * ibfd,bfd * obfd)5975 nds32_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5976 {
5977 flagword out_flags;
5978 flagword in_flags;
5979 flagword out_16regs;
5980 flagword in_no_mac;
5981 flagword out_no_mac;
5982 flagword in_16regs;
5983 flagword out_version;
5984 flagword in_version;
5985 flagword out_fpu_config;
5986 flagword in_fpu_config;
5987
5988 /* TODO: Revise to use object-attributes instead. */
5989 if (!nds32_check_vec_size (ibfd))
5990 return FALSE;
5991
5992 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5993 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5994 return TRUE;
5995
5996 if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
5997 {
5998 (*_bfd_error_handler)
5999 (_("%B: warning: Endian mismatch with previous modules."), ibfd);
6000
6001 bfd_set_error (bfd_error_bad_value);
6002 return FALSE;
6003 }
6004
6005 in_version = elf_elfheader (ibfd)->e_flags & EF_NDS32_ELF_VERSION;
6006 if (in_version == E_NDS32_ELF_VER_1_2)
6007 {
6008 (*_bfd_error_handler)
6009 (_("%B: warning: Older version of object file encountered, "
6010 "Please recompile with current tool chain."), ibfd);
6011 }
6012
6013 /* We may need to merge V1 and V2 arch object files to V2. */
6014 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6015 != (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6016 {
6017 /* Need to convert version. */
6018 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6019 == E_NDS_ARCH_STAR_RESERVED)
6020 {
6021 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6022 }
6023 else if ((elf_elfheader (obfd)->e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9
6024 || (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6025 > (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6026 {
6027 elf_elfheader (obfd)->e_flags =
6028 convert_e_flags (elf_elfheader (obfd)->e_flags,
6029 (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH));
6030 }
6031 else
6032 {
6033 elf_elfheader (ibfd)->e_flags =
6034 convert_e_flags (elf_elfheader (ibfd)->e_flags,
6035 (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH));
6036 }
6037 }
6038
6039 /* Extract some flags. */
6040 in_flags = elf_elfheader (ibfd)->e_flags
6041 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6042 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6043
6044 /* The following flags need special treatment. */
6045 in_16regs = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6046 in_no_mac = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6047 in_fpu_config = elf_elfheader (ibfd)->e_flags & E_NDS32_FPU_REG_CONF;
6048
6049 /* Extract some flags. */
6050 out_flags = elf_elfheader (obfd)->e_flags
6051 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6052 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6053
6054 /* The following flags need special treatment. */
6055 out_16regs = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6056 out_no_mac = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6057 out_fpu_config = elf_elfheader (obfd)->e_flags & E_NDS32_FPU_REG_CONF;
6058 out_version = elf_elfheader (obfd)->e_flags & EF_NDS32_ELF_VERSION;
6059 if (!elf_flags_init (obfd))
6060 {
6061 /* If the input is the default architecture then do not
6062 bother setting the flags for the output architecture,
6063 instead allow future merges to do this. If no future
6064 merges ever set these flags then they will retain their
6065 unitialised values, which surprise surprise, correspond
6066 to the default values. */
6067 if (bfd_get_arch_info (ibfd)->the_default)
6068 return TRUE;
6069
6070 elf_flags_init (obfd) = TRUE;
6071 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6072
6073 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
6074 && bfd_get_arch_info (obfd)->the_default)
6075 {
6076 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
6077 bfd_get_mach (ibfd));
6078 }
6079
6080 return TRUE;
6081 }
6082
6083 /* Check flag compatibility. */
6084 if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
6085 {
6086 (*_bfd_error_handler)
6087 (_("%B: error: ABI mismatch with previous modules."), ibfd);
6088
6089 bfd_set_error (bfd_error_bad_value);
6090 return FALSE;
6091 }
6092
6093 if ((in_flags & EF_NDS_ARCH) != (out_flags & EF_NDS_ARCH))
6094 {
6095 if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
6096 {
6097 (*_bfd_error_handler)
6098 (_("%B: error: Instruction set mismatch with previous modules."), ibfd);
6099
6100 bfd_set_error (bfd_error_bad_value);
6101 return FALSE;
6102 }
6103 }
6104
6105 /* When linking with V1.2 and V1.3 objects together the output is V1.2.
6106 and perf ext1 and DIV are mergerd to perf ext1. */
6107 if (in_version == E_NDS32_ELF_VER_1_2 || out_version == E_NDS32_ELF_VER_1_2)
6108 {
6109 elf_elfheader (obfd)->e_flags =
6110 (in_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6111 | (out_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6112 | (((in_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6113 ? E_NDS32_HAS_EXT_INST : 0)
6114 | (((out_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6115 ? E_NDS32_HAS_EXT_INST : 0)
6116 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6117 | ((in_version > out_version) ? out_version : in_version);
6118 }
6119 else
6120 {
6121 if (in_version != out_version)
6122 (*_bfd_error_handler) (_("%B: warning: Incompatible elf-versions %s and %s."),
6123 ibfd, nds32_elfver_strtab[out_version],
6124 nds32_elfver_strtab[in_version]);
6125
6126 elf_elfheader (obfd)->e_flags = in_flags | out_flags
6127 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6128 | (in_fpu_config > out_fpu_config ? in_fpu_config : out_fpu_config)
6129 | (in_version > out_version ? out_version : in_version);
6130 }
6131
6132 return TRUE;
6133 }
6134
6135 /* Display the flags field. */
6136
6137 static bfd_boolean
nds32_elf_print_private_bfd_data(bfd * abfd,void * ptr)6138 nds32_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6139 {
6140 FILE *file = (FILE *) ptr;
6141
6142 BFD_ASSERT (abfd != NULL && ptr != NULL);
6143
6144 _bfd_elf_print_private_bfd_data (abfd, ptr);
6145
6146 fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
6147
6148 switch (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH)
6149 {
6150 default:
6151 case E_N1_ARCH:
6152 fprintf (file, _(": n1 instructions"));
6153 break;
6154 case E_N1H_ARCH:
6155 fprintf (file, _(": n1h instructions"));
6156 break;
6157 }
6158
6159 fputc ('\n', file);
6160
6161 return TRUE;
6162 }
6163
6164 static unsigned int
nds32_elf_action_discarded(asection * sec)6165 nds32_elf_action_discarded (asection *sec)
6166 {
6167
6168 if (strncmp
6169 (".gcc_except_table", sec->name, sizeof (".gcc_except_table") - 1) == 0)
6170 return 0;
6171
6172 return _bfd_elf_default_action_discarded (sec);
6173 }
6174
6175 static asection *
nds32_elf_gc_mark_hook(asection * sec,struct bfd_link_info * info,Elf_Internal_Rela * rel,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym)6176 nds32_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info,
6177 Elf_Internal_Rela *rel, struct elf_link_hash_entry *h,
6178 Elf_Internal_Sym *sym)
6179 {
6180 if (h != NULL)
6181 switch (ELF32_R_TYPE (rel->r_info))
6182 {
6183 case R_NDS32_GNU_VTINHERIT:
6184 case R_NDS32_GNU_VTENTRY:
6185 case R_NDS32_RELA_GNU_VTINHERIT:
6186 case R_NDS32_RELA_GNU_VTENTRY:
6187 return NULL;
6188 }
6189
6190 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6191 }
6192
6193 static bfd_boolean
nds32_elf_gc_sweep_hook(bfd * abfd,struct bfd_link_info * info,asection * sec,const Elf_Internal_Rela * relocs)6194 nds32_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info, asection *sec,
6195 const Elf_Internal_Rela *relocs)
6196 {
6197 /* Update the got entry reference counts for the section being removed. */
6198 Elf_Internal_Shdr *symtab_hdr;
6199 struct elf_link_hash_entry **sym_hashes;
6200 bfd_signed_vma *local_got_refcounts;
6201 const Elf_Internal_Rela *rel, *relend;
6202
6203 elf_section_data (sec)->local_dynrel = NULL;
6204
6205 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6206 sym_hashes = elf_sym_hashes (abfd);
6207 local_got_refcounts = elf_local_got_refcounts (abfd);
6208
6209 relend = relocs + sec->reloc_count;
6210 for (rel = relocs; rel < relend; rel++)
6211 {
6212 unsigned long r_symndx;
6213 struct elf_link_hash_entry *h = NULL;
6214
6215 r_symndx = ELF32_R_SYM (rel->r_info);
6216 if (r_symndx >= symtab_hdr->sh_info)
6217 {
6218 /* External symbol. */
6219 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6220 while (h->root.type == bfd_link_hash_indirect
6221 || h->root.type == bfd_link_hash_warning)
6222 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6223 }
6224
6225 switch (ELF32_R_TYPE (rel->r_info))
6226 {
6227 case R_NDS32_GOT_HI20:
6228 case R_NDS32_GOT_LO12:
6229 case R_NDS32_GOT_LO15:
6230 case R_NDS32_GOT_LO19:
6231 case R_NDS32_GOT17S2_RELA:
6232 case R_NDS32_GOT15S2_RELA:
6233 case R_NDS32_GOTOFF:
6234 case R_NDS32_GOTOFF_HI20:
6235 case R_NDS32_GOTOFF_LO12:
6236 case R_NDS32_GOTOFF_LO15:
6237 case R_NDS32_GOTOFF_LO19:
6238 case R_NDS32_GOT20:
6239 case R_NDS32_GOTPC_HI20:
6240 case R_NDS32_GOTPC_LO12:
6241 case R_NDS32_GOTPC20:
6242 if (h != NULL)
6243 {
6244 if (h->got.refcount > 0)
6245 h->got.refcount--;
6246 }
6247 else
6248 {
6249 if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
6250 local_got_refcounts[r_symndx]--;
6251 }
6252 break;
6253
6254 case R_NDS32_16_RELA:
6255 case R_NDS32_20_RELA:
6256 case R_NDS32_5_RELA:
6257 case R_NDS32_32_RELA:
6258 case R_NDS32_HI20_RELA:
6259 case R_NDS32_LO12S3_RELA:
6260 case R_NDS32_LO12S2_RELA:
6261 case R_NDS32_LO12S2_DP_RELA:
6262 case R_NDS32_LO12S2_SP_RELA:
6263 case R_NDS32_LO12S1_RELA:
6264 case R_NDS32_LO12S0_RELA:
6265 case R_NDS32_LO12S0_ORI_RELA:
6266 case R_NDS32_SDA16S3_RELA:
6267 case R_NDS32_SDA17S2_RELA:
6268 case R_NDS32_SDA18S1_RELA:
6269 case R_NDS32_SDA19S0_RELA:
6270 case R_NDS32_SDA15S3_RELA:
6271 case R_NDS32_SDA15S2_RELA:
6272 case R_NDS32_SDA12S2_DP_RELA:
6273 case R_NDS32_SDA12S2_SP_RELA:
6274 case R_NDS32_SDA15S1_RELA:
6275 case R_NDS32_SDA15S0_RELA:
6276 case R_NDS32_SDA_FP7U2_RELA:
6277 case R_NDS32_15_PCREL_RELA:
6278 case R_NDS32_17_PCREL_RELA:
6279 case R_NDS32_25_PCREL_RELA:
6280 if (h != NULL)
6281 {
6282 struct elf_nds32_link_hash_entry *eh;
6283 struct elf_nds32_dyn_relocs **pp;
6284 struct elf_nds32_dyn_relocs *p;
6285
6286 if (!info->shared && h->plt.refcount > 0)
6287 h->plt.refcount -= 1;
6288
6289 eh = (struct elf_nds32_link_hash_entry *) h;
6290
6291 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6292 if (p->sec == sec)
6293 {
6294 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
6295 || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA
6296 || ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA)
6297 p->pc_count -= 1;
6298 p->count -= 1;
6299 if (p->count == 0)
6300 *pp = p->next;
6301 break;
6302 }
6303 }
6304 break;
6305
6306 case R_NDS32_9_PLTREL:
6307 case R_NDS32_25_PLTREL:
6308 if (h != NULL)
6309 {
6310 if (h->plt.refcount > 0)
6311 h->plt.refcount--;
6312 }
6313 break;
6314
6315 default:
6316 break;
6317 }
6318 }
6319
6320 return TRUE;
6321 }
6322
6323 /* Look through the relocs for a section during the first phase.
6324 Since we don't do .gots or .plts, we just need to consider the
6325 virtual table relocs for gc. */
6326
6327 static bfd_boolean
nds32_elf_check_relocs(bfd * abfd,struct bfd_link_info * info,asection * sec,const Elf_Internal_Rela * relocs)6328 nds32_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
6329 asection *sec, const Elf_Internal_Rela *relocs)
6330 {
6331 Elf_Internal_Shdr *symtab_hdr;
6332 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6333 const Elf_Internal_Rela *rel;
6334 const Elf_Internal_Rela *rel_end;
6335 struct elf_nds32_link_hash_table *htab;
6336 bfd *dynobj;
6337 asection *sreloc = NULL;
6338
6339 if (info->relocatable)
6340 return TRUE;
6341
6342 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6343 sym_hashes = elf_sym_hashes (abfd);
6344 sym_hashes_end =
6345 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
6346 if (!elf_bad_symtab (abfd))
6347 sym_hashes_end -= symtab_hdr->sh_info;
6348
6349 htab = nds32_elf_hash_table (info);
6350 dynobj = htab->root.dynobj;
6351
6352 rel_end = relocs + sec->reloc_count;
6353 for (rel = relocs; rel < rel_end; rel++)
6354 {
6355 enum elf_nds32_reloc_type r_type;
6356 struct elf_link_hash_entry *h;
6357 unsigned long r_symndx;
6358 int tls_type, old_tls_type;
6359
6360 r_symndx = ELF32_R_SYM (rel->r_info);
6361 r_type = ELF32_R_TYPE (rel->r_info);
6362 if (r_symndx < symtab_hdr->sh_info)
6363 h = NULL;
6364 else
6365 {
6366 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6367 while (h->root.type == bfd_link_hash_indirect
6368 || h->root.type == bfd_link_hash_warning)
6369 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6370 }
6371
6372 /* Some relocs require a global offset table. We create
6373 got section here, since these relocation need got section
6374 and it is not created yet. */
6375 if (htab->sgot == NULL)
6376 {
6377 switch (r_type)
6378 {
6379 case R_NDS32_GOT_HI20:
6380 case R_NDS32_GOT_LO12:
6381 case R_NDS32_GOT_LO15:
6382 case R_NDS32_GOT_LO19:
6383 case R_NDS32_GOT17S2_RELA:
6384 case R_NDS32_GOT15S2_RELA:
6385 case R_NDS32_GOTOFF:
6386 case R_NDS32_GOTOFF_HI20:
6387 case R_NDS32_GOTOFF_LO12:
6388 case R_NDS32_GOTOFF_LO15:
6389 case R_NDS32_GOTOFF_LO19:
6390 case R_NDS32_GOTPC20:
6391 case R_NDS32_GOTPC_HI20:
6392 case R_NDS32_GOTPC_LO12:
6393 case R_NDS32_GOT20:
6394 case R_NDS32_TLS_IE_HI20:
6395 case R_NDS32_TLS_IE_LO12S2:
6396 if (dynobj == NULL)
6397 htab->root.dynobj = dynobj = abfd;
6398 if (!create_got_section (dynobj, info))
6399 return FALSE;
6400 break;
6401
6402 default:
6403 break;
6404 }
6405 }
6406
6407 switch ((int) r_type)
6408 {
6409 case R_NDS32_GOT_HI20:
6410 case R_NDS32_GOT_LO12:
6411 case R_NDS32_GOT_LO15:
6412 case R_NDS32_GOT_LO19:
6413 case R_NDS32_GOT20:
6414 case R_NDS32_TLS_IE_HI20:
6415 case R_NDS32_TLS_IE_LO12S2:
6416 switch (r_type)
6417 {
6418 case R_NDS32_TLS_IE_HI20:
6419 case R_NDS32_TLS_IE_LO12S2:
6420 tls_type = GOT_TLS_IE;
6421 break;
6422 default:
6423 tls_type = GOT_NORMAL;
6424 break;
6425 }
6426 if (h != NULL)
6427 {
6428 old_tls_type = elf32_nds32_hash_entry (h)->tls_type;
6429 h->got.refcount += 1;
6430 }
6431 else
6432 {
6433 bfd_signed_vma *local_got_refcounts;
6434
6435 /* This is a global offset table entry for a local
6436 symbol. */
6437 local_got_refcounts = elf_local_got_refcounts (abfd);
6438 if (local_got_refcounts == NULL)
6439 {
6440 bfd_size_type size;
6441
6442 size = symtab_hdr->sh_info;
6443 size *= sizeof (bfd_signed_vma);
6444 local_got_refcounts = (bfd_signed_vma *) bfd_zalloc (abfd, size);
6445 if (local_got_refcounts == NULL)
6446 return FALSE;
6447 elf_local_got_refcounts (abfd) = local_got_refcounts;
6448 }
6449 local_got_refcounts[r_symndx] += 1;
6450 old_tls_type = elf32_nds32_local_got_tls_type (abfd)[r_symndx];
6451 }
6452
6453 /* We will already have issued an error message if there
6454 is a TLS/non-TLS mismatch, based on the symbol
6455 type. So just combine any TLS types needed. */
6456 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
6457 && tls_type != GOT_NORMAL)
6458 tls_type |= old_tls_type;
6459
6460 if (old_tls_type != tls_type)
6461 {
6462 if (h != NULL)
6463 elf32_nds32_hash_entry (h)->tls_type = tls_type;
6464 else
6465 elf32_nds32_local_got_tls_type (abfd)[r_symndx] = tls_type;
6466 }
6467 break;
6468 case R_NDS32_9_PLTREL:
6469 case R_NDS32_25_PLTREL:
6470 case R_NDS32_PLTREL_HI20:
6471 case R_NDS32_PLTREL_LO12:
6472 case R_NDS32_PLT_GOTREL_HI20:
6473 case R_NDS32_PLT_GOTREL_LO12:
6474 case R_NDS32_PLT_GOTREL_LO15:
6475 case R_NDS32_PLT_GOTREL_LO19:
6476 case R_NDS32_PLT_GOTREL_LO20:
6477
6478 /* This symbol requires a procedure linkage table entry. We
6479 actually build the entry in adjust_dynamic_symbol,
6480 because this might be a case of linking PIC code without
6481 linking in any dynamic objects, in which case we don't
6482 need to generate a procedure linkage table after all. */
6483
6484 /* If this is a local symbol, we resolve it directly without
6485 creating a procedure linkage table entry. */
6486 if (h == NULL)
6487 continue;
6488
6489 if (h->forced_local)
6490 break;
6491
6492 elf32_nds32_hash_entry (h)->tls_type = GOT_NORMAL;
6493 h->needs_plt = 1;
6494 h->plt.refcount += 1;
6495 break;
6496
6497 case R_NDS32_16_RELA:
6498 case R_NDS32_20_RELA:
6499 case R_NDS32_5_RELA:
6500 case R_NDS32_32_RELA:
6501 case R_NDS32_HI20_RELA:
6502 case R_NDS32_LO12S3_RELA:
6503 case R_NDS32_LO12S2_RELA:
6504 case R_NDS32_LO12S2_DP_RELA:
6505 case R_NDS32_LO12S2_SP_RELA:
6506 case R_NDS32_LO12S1_RELA:
6507 case R_NDS32_LO12S0_RELA:
6508 case R_NDS32_LO12S0_ORI_RELA:
6509 case R_NDS32_SDA16S3_RELA:
6510 case R_NDS32_SDA17S2_RELA:
6511 case R_NDS32_SDA18S1_RELA:
6512 case R_NDS32_SDA19S0_RELA:
6513 case R_NDS32_SDA15S3_RELA:
6514 case R_NDS32_SDA15S2_RELA:
6515 case R_NDS32_SDA12S2_DP_RELA:
6516 case R_NDS32_SDA12S2_SP_RELA:
6517 case R_NDS32_SDA15S1_RELA:
6518 case R_NDS32_SDA15S0_RELA:
6519 case R_NDS32_SDA_FP7U2_RELA:
6520 case R_NDS32_15_PCREL_RELA:
6521 case R_NDS32_17_PCREL_RELA:
6522 case R_NDS32_25_PCREL_RELA:
6523
6524 if (h != NULL && !info->shared)
6525 {
6526 h->non_got_ref = 1;
6527 h->plt.refcount += 1;
6528 }
6529
6530 /* If we are creating a shared library, and this is a reloc against
6531 a global symbol, or a non PC relative reloc against a local
6532 symbol, then we need to copy the reloc into the shared library.
6533 However, if we are linking with -Bsymbolic, we do not need to
6534 copy a reloc against a global symbol which is defined in an
6535 object we are including in the link (i.e., DEF_REGULAR is set).
6536 At this point we have not seen all the input files, so it is
6537 possible that DEF_REGULAR is not set now but will be set later
6538 (it is never cleared). We account for that possibility below by
6539 storing information in the dyn_relocs field of the hash table
6540 entry. A similar situation occurs when creating shared libraries
6541 and symbol visibility changes render the symbol local.
6542
6543 If on the other hand, we are creating an executable, we may need
6544 to keep relocations for symbols satisfied by a dynamic library
6545 if we manage to avoid copy relocs for the symbol. */
6546 if ((info->shared
6547 && (sec->flags & SEC_ALLOC) != 0
6548 && ((r_type != R_NDS32_25_PCREL_RELA
6549 && r_type != R_NDS32_15_PCREL_RELA
6550 && r_type != R_NDS32_17_PCREL_RELA
6551 && !(r_type == R_NDS32_32_RELA
6552 && strcmp (sec->name, ".eh_frame") == 0))
6553 || (h != NULL
6554 && (!info->symbolic
6555 || h->root.type == bfd_link_hash_defweak
6556 || !h->def_regular))))
6557 || (!info->shared
6558 && (sec->flags & SEC_ALLOC) != 0
6559 && h != NULL
6560 && (h->root.type == bfd_link_hash_defweak
6561 || !h->def_regular)))
6562 {
6563 struct elf_nds32_dyn_relocs *p;
6564 struct elf_nds32_dyn_relocs **head;
6565
6566 if (dynobj == NULL)
6567 htab->root.dynobj = dynobj = abfd;
6568
6569 /* When creating a shared object, we must copy these
6570 relocs into the output file. We create a reloc
6571 section in dynobj and make room for the reloc. */
6572 if (sreloc == NULL)
6573 {
6574 const char *name;
6575
6576 name = bfd_elf_string_from_elf_section
6577 (abfd, elf_elfheader (abfd)->e_shstrndx,
6578 elf_section_data (sec)->rela.hdr->sh_name);
6579 if (name == NULL)
6580 return FALSE;
6581
6582 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6583 && strcmp (bfd_get_section_name (abfd, sec),
6584 name + 5) == 0);
6585
6586 sreloc = bfd_get_section_by_name (dynobj, name);
6587 if (sreloc == NULL)
6588 {
6589 flagword flags;
6590
6591 sreloc = bfd_make_section (dynobj, name);
6592 flags = (SEC_HAS_CONTENTS | SEC_READONLY
6593 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6594 if ((sec->flags & SEC_ALLOC) != 0)
6595 flags |= SEC_ALLOC | SEC_LOAD;
6596 if (sreloc == NULL
6597 || !bfd_set_section_flags (dynobj, sreloc, flags)
6598 || !bfd_set_section_alignment (dynobj, sreloc, 2))
6599 return FALSE;
6600
6601 elf_section_type (sreloc) = SHT_RELA;
6602 }
6603 elf_section_data (sec)->sreloc = sreloc;
6604 }
6605
6606 /* If this is a global symbol, we count the number of
6607 relocations we need for this symbol. */
6608 if (h != NULL)
6609 head = &((struct elf_nds32_link_hash_entry *) h)->dyn_relocs;
6610 else
6611 {
6612 asection *s;
6613
6614 Elf_Internal_Sym *isym;
6615 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
6616 if (isym == NULL)
6617 return FALSE;
6618
6619 /* Track dynamic relocs needed for local syms too. */
6620 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6621 if (s == NULL)
6622 return FALSE;
6623
6624 head = ((struct elf_nds32_dyn_relocs **)
6625 &elf_section_data (s)->local_dynrel);
6626 }
6627
6628 p = *head;
6629 if (p == NULL || p->sec != sec)
6630 {
6631 bfd_size_type amt = sizeof (*p);
6632 p = (struct elf_nds32_dyn_relocs *) bfd_alloc (dynobj, amt);
6633 if (p == NULL)
6634 return FALSE;
6635 p->next = *head;
6636 *head = p;
6637 p->sec = sec;
6638 p->count = 0;
6639 p->pc_count = 0;
6640 }
6641
6642 p->count += 1;
6643 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA
6644 || ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
6645 || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA)
6646 p->pc_count += 1;
6647 }
6648 break;
6649
6650 /* This relocation describes the C++ object vtable hierarchy.
6651 Reconstruct it for later use during GC. */
6652 case R_NDS32_RELA_GNU_VTINHERIT:
6653 case R_NDS32_GNU_VTINHERIT:
6654 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6655 return FALSE;
6656 break;
6657
6658 /* This relocation describes which C++ vtable entries are actually
6659 used. Record for later use during GC. */
6660 case R_NDS32_GNU_VTENTRY:
6661 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6662 return FALSE;
6663 break;
6664 case R_NDS32_RELA_GNU_VTENTRY:
6665 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6666 return FALSE;
6667 break;
6668 }
6669 }
6670
6671 return TRUE;
6672 }
6673
6674 /* Write VAL in uleb128 format to P, returning a pointer to the
6675 following byte.
6676 This code is copied from elf-attr.c. */
6677
6678 static bfd_byte *
write_uleb128(bfd_byte * p,unsigned int val)6679 write_uleb128 (bfd_byte *p, unsigned int val)
6680 {
6681 bfd_byte c;
6682 do
6683 {
6684 c = val & 0x7f;
6685 val >>= 7;
6686 if (val)
6687 c |= 0x80;
6688 *(p++) = c;
6689 }
6690 while (val);
6691 return p;
6692 }
6693
6694 static bfd_signed_vma
calculate_offset(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr,int * pic_ext_target)6695 calculate_offset (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
6696 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr,
6697 int *pic_ext_target)
6698 {
6699 bfd_signed_vma foff;
6700 bfd_vma symval, addend;
6701 asection *sym_sec;
6702
6703 /* Get the value of the symbol referred to by the reloc. */
6704 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6705 {
6706 Elf_Internal_Sym *isym;
6707
6708 /* A local symbol. */
6709 isym = isymbuf + ELF32_R_SYM (irel->r_info);
6710
6711 if (isym->st_shndx == SHN_UNDEF)
6712 sym_sec = bfd_und_section_ptr;
6713 else if (isym->st_shndx == SHN_ABS)
6714 sym_sec = bfd_abs_section_ptr;
6715 else if (isym->st_shndx == SHN_COMMON)
6716 sym_sec = bfd_com_section_ptr;
6717 else
6718 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6719 symval = isym->st_value + sym_sec->output_section->vma
6720 + sym_sec->output_offset;
6721 }
6722 else
6723 {
6724 unsigned long indx;
6725 struct elf_link_hash_entry *h;
6726 bfd *owner;
6727
6728 /* An external symbol. */
6729 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6730 h = elf_sym_hashes (abfd)[indx];
6731 BFD_ASSERT (h != NULL);
6732
6733 if (h->root.type != bfd_link_hash_defined
6734 && h->root.type != bfd_link_hash_defweak)
6735 /* This appears to be a reference to an undefined
6736 symbol. Just ignore it--it will be caught by the
6737 regular reloc processing. */
6738 return 0;
6739 owner = h->root.u.def.section->owner;
6740 if (owner && (elf_elfheader (owner)->e_flags & E_NDS32_HAS_PIC))
6741 *pic_ext_target = 1;
6742
6743 if (h->root.u.def.section->flags & SEC_MERGE)
6744 {
6745 sym_sec = h->root.u.def.section;
6746 symval = _bfd_merged_section_offset (abfd, &sym_sec,
6747 elf_section_data (sym_sec)->sec_info,
6748 h->root.u.def.value);
6749 symval = symval + sym_sec->output_section->vma
6750 + sym_sec->output_offset;
6751 }
6752 else
6753 symval = (h->root.u.def.value
6754 + h->root.u.def.section->output_section->vma
6755 + h->root.u.def.section->output_offset);
6756 }
6757
6758 addend = irel->r_addend;
6759
6760 foff = (symval + addend
6761 - (irel->r_offset + sec->output_section->vma + sec->output_offset));
6762 return foff;
6763 }
6764
6765 static bfd_vma
calculate_plt_memory_address(bfd * abfd,struct bfd_link_info * link_info,Elf_Internal_Sym * isymbuf,Elf_Internal_Rela * irel,Elf_Internal_Shdr * symtab_hdr)6766 calculate_plt_memory_address (bfd *abfd, struct bfd_link_info *link_info,
6767 Elf_Internal_Sym *isymbuf,
6768 Elf_Internal_Rela *irel,
6769 Elf_Internal_Shdr *symtab_hdr)
6770 {
6771 bfd_vma symval;
6772
6773 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6774 {
6775 Elf_Internal_Sym *isym;
6776 asection *sym_sec;
6777 /* A local symbol. */
6778 isym = isymbuf + ELF32_R_SYM (irel->r_info);
6779
6780 if (isym->st_shndx == SHN_UNDEF)
6781 sym_sec = bfd_und_section_ptr;
6782 else if (isym->st_shndx == SHN_ABS)
6783 sym_sec = bfd_abs_section_ptr;
6784 else if (isym->st_shndx == SHN_COMMON)
6785 sym_sec = bfd_com_section_ptr;
6786 else
6787 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6788 symval = isym->st_value + sym_sec->output_section->vma
6789 + sym_sec->output_offset;
6790 }
6791 else
6792 {
6793 unsigned long indx;
6794 struct elf_link_hash_entry *h;
6795 struct elf_nds32_link_hash_table *htab;
6796 asection *splt;
6797
6798 /* An external symbol. */
6799 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6800 h = elf_sym_hashes (abfd)[indx];
6801 BFD_ASSERT (h != NULL);
6802 htab = nds32_elf_hash_table (link_info);
6803 splt = htab->splt;
6804
6805 while (h->root.type == bfd_link_hash_indirect
6806 || h->root.type == bfd_link_hash_warning)
6807 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6808
6809 if (h->plt.offset == (bfd_vma) - 1)
6810 {
6811 if (h->root.type != bfd_link_hash_defined
6812 && h->root.type != bfd_link_hash_defweak)
6813 /* This appears to be a reference to an undefined
6814 * symbol. Just ignore it--it will be caught by the
6815 * regular reloc processing. */
6816 return 0;
6817 symval = (h->root.u.def.value
6818 + h->root.u.def.section->output_section->vma
6819 + h->root.u.def.section->output_offset);
6820 }
6821 else
6822 symval = splt->output_section->vma + h->plt.offset;
6823 }
6824
6825 return symval;
6826 }
6827
6828 static bfd_signed_vma
calculate_plt_offset(bfd * abfd,asection * sec,struct bfd_link_info * link_info,Elf_Internal_Sym * isymbuf,Elf_Internal_Rela * irel,Elf_Internal_Shdr * symtab_hdr)6829 calculate_plt_offset (bfd *abfd, asection *sec, struct bfd_link_info *link_info,
6830 Elf_Internal_Sym *isymbuf, Elf_Internal_Rela *irel,
6831 Elf_Internal_Shdr *symtab_hdr)
6832 {
6833 bfd_vma foff;
6834 if ((foff = calculate_plt_memory_address (abfd, link_info, isymbuf, irel,
6835 symtab_hdr)) == 0)
6836 return 0;
6837 else
6838 return foff - (irel->r_offset
6839 + sec->output_section->vma + sec->output_offset);
6840 }
6841
6842 /* Convert a 32-bit instruction to 16-bit one.
6843 INSN is the input 32-bit instruction, INSN16 is the output 16-bit
6844 instruction. If INSN_TYPE is not NULL, it the CGEN instruction
6845 type of INSN16. Return 1 if successful. */
6846
6847 static int
nds32_convert_32_to_16_alu1(bfd * abfd,uint32_t insn,uint16_t * pinsn16,int * pinsn_type)6848 nds32_convert_32_to_16_alu1 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
6849 int *pinsn_type)
6850 {
6851 uint16_t insn16 = 0;
6852 int insn_type;
6853 unsigned long mach = bfd_get_mach (abfd);
6854
6855 if (N32_SH5 (insn) != 0)
6856 return 0;
6857
6858 switch (N32_SUB5 (insn))
6859 {
6860 case N32_ALU1_ADD_SLLI:
6861 case N32_ALU1_ADD_SRLI:
6862 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
6863 {
6864 insn16 = N16_TYPE333 (ADD333, N32_RT5 (insn), N32_RA5 (insn),
6865 N32_RB5 (insn));
6866 insn_type = NDS32_INSN_ADD333;
6867 }
6868 else if (N32_IS_RT4 (insn))
6869 {
6870 if (N32_RT5 (insn) == N32_RA5 (insn))
6871 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RB5 (insn));
6872 else if (N32_RT5 (insn) == N32_RB5 (insn))
6873 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RA5 (insn));
6874 insn_type = NDS32_INSN_ADD45;
6875 }
6876 break;
6877
6878 case N32_ALU1_SUB_SLLI:
6879 case N32_ALU1_SUB_SRLI:
6880 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
6881 {
6882 insn16 = N16_TYPE333 (SUB333, N32_RT5 (insn), N32_RA5 (insn),
6883 N32_RB5 (insn));
6884 insn_type = NDS32_INSN_SUB333;
6885 }
6886 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6887 {
6888 insn16 = N16_TYPE45 (SUB45, N32_RT54 (insn), N32_RB5 (insn));
6889 insn_type = NDS32_INSN_SUB45;
6890 }
6891 break;
6892
6893 case N32_ALU1_AND_SLLI:
6894 case N32_ALU1_AND_SRLI:
6895 /* and $rt, $rt, $rb -> and33 for v3, v3m. */
6896 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6897 && N32_IS_RB3 (insn))
6898 {
6899 if (N32_RT5 (insn) == N32_RA5 (insn))
6900 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RB5 (insn));
6901 else if (N32_RT5 (insn) == N32_RB5 (insn))
6902 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RA5 (insn));
6903 if (insn16)
6904 insn_type = NDS32_INSN_AND33;
6905 }
6906 break;
6907
6908 case N32_ALU1_XOR_SLLI:
6909 case N32_ALU1_XOR_SRLI:
6910 /* xor $rt, $rt, $rb -> xor33 for v3, v3m. */
6911 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6912 && N32_IS_RB3 (insn))
6913 {
6914 if (N32_RT5 (insn) == N32_RA5 (insn))
6915 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RB5 (insn));
6916 else if (N32_RT5 (insn) == N32_RB5 (insn))
6917 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RA5 (insn));
6918 if (insn16)
6919 insn_type = NDS32_INSN_XOR33;
6920 }
6921 break;
6922
6923 case N32_ALU1_OR_SLLI:
6924 case N32_ALU1_OR_SRLI:
6925 /* or $rt, $rt, $rb -> or33 for v3, v3m. */
6926 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6927 && N32_IS_RB3 (insn))
6928 {
6929 if (N32_RT5 (insn) == N32_RA5 (insn))
6930 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RB5 (insn));
6931 else if (N32_RT5 (insn) == N32_RB5 (insn))
6932 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RA5 (insn));
6933 if (insn16)
6934 insn_type = NDS32_INSN_OR33;
6935 }
6936 break;
6937 case N32_ALU1_NOR:
6938 /* nor $rt, $ra, $ra -> not33 for v3, v3m. */
6939 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RB3 (insn)
6940 && N32_RA5 (insn) == N32_RB5 (insn))
6941 {
6942 insn16 = N16_MISC33 (NOT33, N32_RT5 (insn), N32_RA5 (insn));
6943 insn_type = NDS32_INSN_NOT33;
6944 }
6945 break;
6946 case N32_ALU1_SRAI:
6947 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6948 {
6949 insn16 = N16_TYPE45 (SRAI45, N32_RT54 (insn), N32_UB5 (insn));
6950 insn_type = NDS32_INSN_SRAI45;
6951 }
6952 break;
6953
6954 case N32_ALU1_SRLI:
6955 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6956 {
6957 insn16 = N16_TYPE45 (SRLI45, N32_RT54 (insn), N32_UB5 (insn));
6958 insn_type = NDS32_INSN_SRLI45;
6959 }
6960 break;
6961
6962 case N32_ALU1_SLLI:
6963 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_UB5 (insn) < 8)
6964 {
6965 insn16 = N16_TYPE333 (SLLI333, N32_RT5 (insn), N32_RA5 (insn),
6966 N32_UB5 (insn));
6967 insn_type = NDS32_INSN_SLLI333;
6968 }
6969 break;
6970
6971 case N32_ALU1_ZEH:
6972 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6973 {
6974 insn16 = N16_BFMI333 (ZEH33, N32_RT5 (insn), N32_RA5 (insn));
6975 insn_type = NDS32_INSN_ZEH33;
6976 }
6977 break;
6978
6979 case N32_ALU1_SEB:
6980 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6981 {
6982 insn16 = N16_BFMI333 (SEB33, N32_RT5 (insn), N32_RA5 (insn));
6983 insn_type = NDS32_INSN_SEB33;
6984 }
6985 break;
6986
6987 case N32_ALU1_SEH:
6988 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6989 {
6990 insn16 = N16_BFMI333 (SEH33, N32_RT5 (insn), N32_RA5 (insn));
6991 insn_type = NDS32_INSN_SEH33;
6992 }
6993 break;
6994
6995 case N32_ALU1_SLT:
6996 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
6997 {
6998 /* Implicit r15. */
6999 insn16 = N16_TYPE45 (SLT45, N32_RA54 (insn), N32_RB5 (insn));
7000 insn_type = NDS32_INSN_SLT45;
7001 }
7002 break;
7003
7004 case N32_ALU1_SLTS:
7005 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7006 {
7007 /* Implicit r15. */
7008 insn16 = N16_TYPE45 (SLTS45, N32_RA54 (insn), N32_RB5 (insn));
7009 insn_type = NDS32_INSN_SLTS45;
7010 }
7011 break;
7012 }
7013
7014 if ((insn16 & 0x8000) == 0)
7015 return 0;
7016
7017 if (pinsn16)
7018 *pinsn16 = insn16;
7019 if (pinsn_type)
7020 *pinsn_type = insn_type;
7021 return 1;
7022 }
7023
7024 static int
nds32_convert_32_to_16_alu2(bfd * abfd,uint32_t insn,uint16_t * pinsn16,int * pinsn_type)7025 nds32_convert_32_to_16_alu2 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7026 int *pinsn_type)
7027 {
7028 uint16_t insn16 = 0;
7029 int insn_type;
7030 unsigned long mach = bfd_get_mach (abfd);
7031
7032 /* TODO: bset, bclr, btgl, btst. */
7033 if (__GF (insn, 6, 4) != 0)
7034 return 0;
7035
7036 switch (N32_IMMU (insn, 6))
7037 {
7038 case N32_ALU2_MUL:
7039 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7040 && N32_IS_RB3 (insn))
7041 {
7042 if (N32_RT5 (insn) == N32_RA5 (insn))
7043 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RB5 (insn));
7044 else if (N32_RT5 (insn) == N32_RB5 (insn))
7045 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RA5 (insn));
7046 if (insn16)
7047 insn_type = NDS32_INSN_MUL33;
7048 }
7049 }
7050
7051 if ((insn16 & 0x8000) == 0)
7052 return 0;
7053
7054 if (pinsn16)
7055 *pinsn16 = insn16;
7056 if (pinsn_type)
7057 *pinsn_type = insn_type;
7058 return 1;
7059 }
7060
7061 int
nds32_convert_32_to_16(bfd * abfd,uint32_t insn,uint16_t * pinsn16,int * pinsn_type)7062 nds32_convert_32_to_16 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7063 int *pinsn_type)
7064 {
7065 int op6;
7066 uint16_t insn16 = 0;
7067 int insn_type;
7068 unsigned long mach = bfd_get_mach (abfd);
7069
7070 /* Decode 32-bit instruction. */
7071 if (insn & 0x80000000)
7072 {
7073 /* Not 32-bit insn. */
7074 return 0;
7075 }
7076
7077 op6 = N32_OP6 (insn);
7078
7079 /* Convert it to 16-bit instruction. */
7080 switch (op6)
7081 {
7082 case N32_OP6_MOVI:
7083 if (IS_WITHIN_S (N32_IMM20S (insn), 5))
7084 {
7085 insn16 = N16_TYPE55 (MOVI55, N32_RT5 (insn), N32_IMM20S (insn));
7086 insn_type = NDS32_INSN_MOVI55;
7087 }
7088 else if (mach >= MACH_V3 && N32_IMM20S (insn) >= 16
7089 && N32_IMM20S (insn) < 48 && N32_IS_RT4 (insn))
7090 {
7091 insn16 = N16_TYPE45 (MOVPI45, N32_RT54 (insn),
7092 N32_IMM20S (insn) - 16);
7093 insn_type = NDS32_INSN_MOVPI45;
7094 }
7095 break;
7096
7097 case N32_OP6_ADDI:
7098 if (N32_IMM15S (insn) == 0)
7099 {
7100 /* Do not convert `addi $sp, $sp, 0' to `mov55 $sp, $sp',
7101 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7102 if (mach <= MACH_V2
7103 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7104 {
7105 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7106 insn_type = NDS32_INSN_MOV55;
7107 }
7108 }
7109 else if (N32_IMM15S (insn) > 0)
7110 {
7111 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) < 8)
7112 {
7113 insn16 = N16_TYPE333 (ADDI333, N32_RT5 (insn), N32_RA5 (insn),
7114 N32_IMM15S (insn));
7115 insn_type = NDS32_INSN_ADDI333;
7116 }
7117 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7118 && N32_IMM15S (insn) < 32)
7119 {
7120 insn16 = N16_TYPE45 (ADDI45, N32_RT54 (insn), N32_IMM15S (insn));
7121 insn_type = NDS32_INSN_ADDI45;
7122 }
7123 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7124 && N32_RT5 (insn) == N32_RA5 (insn)
7125 && N32_IMM15S (insn) < 512)
7126 {
7127 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7128 insn_type = NDS32_INSN_ADDI10_SP;
7129 }
7130 else if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7131 && N32_RA5 (insn) == REG_SP && N32_IMM15S (insn) < 256
7132 && (N32_IMM15S (insn) % 4 == 0))
7133 {
7134 insn16 = N16_TYPE36 (ADDRI36_SP, N32_RT5 (insn),
7135 N32_IMM15S (insn) >> 2);
7136 insn_type = NDS32_INSN_ADDRI36_SP;
7137 }
7138 }
7139 else
7140 {
7141 /* Less than 0. */
7142 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) > -8)
7143 {
7144 insn16 = N16_TYPE333 (SUBI333, N32_RT5 (insn), N32_RA5 (insn),
7145 0 - N32_IMM15S (insn));
7146 insn_type = NDS32_INSN_SUBI333;
7147 }
7148 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7149 && N32_IMM15S (insn) > -32)
7150 {
7151 insn16 = N16_TYPE45 (SUBI45, N32_RT54 (insn),
7152 0 - N32_IMM15S (insn));
7153 insn_type = NDS32_INSN_SUBI45;
7154 }
7155 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7156 && N32_RT5 (insn) == N32_RA5 (insn)
7157 && N32_IMM15S (insn) >= -512)
7158 {
7159 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7160 insn_type = NDS32_INSN_ADDI10_SP;
7161 }
7162 }
7163 break;
7164
7165 case N32_OP6_ORI:
7166 if (N32_IMM15S (insn) == 0)
7167 {
7168 /* Do not convert `ori $sp, $sp, 0' to `mov55 $sp, $sp',
7169 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7170 if (mach <= MACH_V2
7171 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7172 {
7173 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7174 insn_type = NDS32_INSN_MOV55;
7175 }
7176 }
7177 break;
7178
7179 case N32_OP6_SUBRI:
7180 if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7181 && N32_IS_RA3 (insn) && N32_IMM15S (insn) == 0)
7182 {
7183 insn16 = N16_MISC33 (NEG33, N32_RT5 (insn), N32_RA5 (insn));
7184 insn_type = NDS32_INSN_NEG33;
7185 }
7186 break;
7187
7188 case N32_OP6_ANDI:
7189 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7190 {
7191 if (N32_IMM15U (insn) == 1)
7192 {
7193 insn16 = N16_BFMI333 (XLSB33, N32_RT5 (insn), N32_RA5 (insn));
7194 insn_type = NDS32_INSN_XLSB33;
7195 }
7196 else if (N32_IMM15U (insn) == 0x7ff)
7197 {
7198 insn16 = N16_BFMI333 (X11B33, N32_RT5 (insn), N32_RA5 (insn));
7199 insn_type = NDS32_INSN_X11B33;
7200 }
7201 else if (N32_IMM15U (insn) == 0xff)
7202 {
7203 insn16 = N16_BFMI333 (ZEB33, N32_RT5 (insn), N32_RA5 (insn));
7204 insn_type = NDS32_INSN_ZEB33;
7205 }
7206 else if (mach >= MACH_V3 && N32_RT5 (insn) == N32_RA5 (insn)
7207 && N32_IMM15U (insn) < 256)
7208 {
7209 int imm15u = N32_IMM15U (insn);
7210
7211 if (__builtin_popcount (imm15u) == 1)
7212 {
7213 /* BMSKI33 */
7214 int imm3u = __builtin_ctz (imm15u);
7215
7216 insn16 = N16_BFMI333 (BMSKI33, N32_RT5 (insn), imm3u);
7217 insn_type = NDS32_INSN_BMSKI33;
7218 }
7219 else if (imm15u != 0 && __builtin_popcount (imm15u + 1) == 1)
7220 {
7221 /* FEXTI33 */
7222 int imm3u = __builtin_ctz (imm15u + 1) - 1;
7223
7224 insn16 = N16_BFMI333 (FEXTI33, N32_RT5 (insn), imm3u);
7225 insn_type = NDS32_INSN_FEXTI33;
7226 }
7227 }
7228 }
7229 break;
7230
7231 case N32_OP6_SLTI:
7232 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7233 && IS_WITHIN_U (N32_IMM15S (insn), 5))
7234 {
7235 insn16 = N16_TYPE45 (SLTI45, N32_RA54 (insn), N32_IMM15S (insn));
7236 insn_type = NDS32_INSN_SLTI45;
7237 }
7238 break;
7239
7240 case N32_OP6_SLTSI:
7241 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7242 && IS_WITHIN_U (N32_IMM15S (insn), 5))
7243 {
7244 insn16 = N16_TYPE45 (SLTSI45, N32_RA54 (insn), N32_IMM15S (insn));
7245 insn_type = NDS32_INSN_SLTSI45;
7246 }
7247 break;
7248
7249 case N32_OP6_LWI:
7250 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7251 {
7252 insn16 = N16_TYPE45 (LWI450, N32_RT54 (insn), N32_RA5 (insn));
7253 insn_type = NDS32_INSN_LWI450;
7254 }
7255 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7256 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7257 {
7258 insn16 = N16_TYPE333 (LWI333, N32_RT5 (insn), N32_RA5 (insn),
7259 N32_IMM15S (insn));
7260 insn_type = NDS32_INSN_LWI333;
7261 }
7262 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7263 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7264 {
7265 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7266 insn_type = NDS32_INSN_LWI37;
7267 }
7268 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7269 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7270 {
7271 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 0, N32_IMM15S (insn));
7272 insn_type = NDS32_INSN_LWI37_SP;
7273 }
7274 else if (mach >= MACH_V2 && N32_IS_RT4 (insn) && N32_RA5 (insn) == REG_R8
7275 && -32 <= N32_IMM15S (insn) && N32_IMM15S (insn) < 0)
7276 {
7277 insn16 = N16_TYPE45 (LWI45_FE, N32_RT54 (insn),
7278 N32_IMM15S (insn) + 32);
7279 insn_type = NDS32_INSN_LWI45_FE;
7280 }
7281 break;
7282
7283 case N32_OP6_SWI:
7284 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7285 {
7286 insn16 = N16_TYPE45 (SWI450, N32_RT54 (insn), N32_RA5 (insn));
7287 insn_type = NDS32_INSN_SWI450;
7288 }
7289 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7290 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7291 {
7292 insn16 = N16_TYPE333 (SWI333, N32_RT5 (insn), N32_RA5 (insn),
7293 N32_IMM15S (insn));
7294 insn_type = NDS32_INSN_SWI333;
7295 }
7296 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7297 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7298 {
7299 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7300 insn_type = NDS32_INSN_SWI37;
7301 }
7302 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7303 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7304 {
7305 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 1, N32_IMM15S (insn));
7306 insn_type = NDS32_INSN_SWI37_SP;
7307 }
7308 break;
7309
7310 case N32_OP6_LWI_BI:
7311 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7312 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7313 {
7314 insn16 = N16_TYPE333 (LWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7315 N32_IMM15S (insn));
7316 insn_type = NDS32_INSN_LWI333_BI;
7317 }
7318 break;
7319
7320 case N32_OP6_SWI_BI:
7321 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7322 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7323 {
7324 insn16 = N16_TYPE333 (SWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7325 N32_IMM15S (insn));
7326 insn_type = NDS32_INSN_SWI333_BI;
7327 }
7328 break;
7329
7330 case N32_OP6_LHI:
7331 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7332 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7333 {
7334 insn16 = N16_TYPE333 (LHI333, N32_RT5 (insn), N32_RA5 (insn),
7335 N32_IMM15S (insn));
7336 insn_type = NDS32_INSN_LHI333;
7337 }
7338 break;
7339
7340 case N32_OP6_SHI:
7341 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7342 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7343 {
7344 insn16 = N16_TYPE333 (SHI333, N32_RT5 (insn), N32_RA5 (insn),
7345 N32_IMM15S (insn));
7346 insn_type = NDS32_INSN_SHI333;
7347 }
7348 break;
7349
7350 case N32_OP6_LBI:
7351 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7352 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7353 {
7354 insn16 = N16_TYPE333 (LBI333, N32_RT5 (insn), N32_RA5 (insn),
7355 N32_IMM15S (insn));
7356 insn_type = NDS32_INSN_LBI333;
7357 }
7358 break;
7359
7360 case N32_OP6_SBI:
7361 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7362 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7363 {
7364 insn16 = N16_TYPE333 (SBI333, N32_RT5 (insn), N32_RA5 (insn),
7365 N32_IMM15S (insn));
7366 insn_type = NDS32_INSN_SBI333;
7367 }
7368 break;
7369
7370 case N32_OP6_ALU1:
7371 return nds32_convert_32_to_16_alu1 (abfd, insn, pinsn16, pinsn_type);
7372
7373 case N32_OP6_ALU2:
7374 return nds32_convert_32_to_16_alu2 (abfd, insn, pinsn16, pinsn_type);
7375
7376 case N32_OP6_BR1:
7377 if (!IS_WITHIN_S (N32_IMM14S (insn), 8))
7378 goto done;
7379
7380 if ((insn & __BIT (14)) == 0)
7381 {
7382 /* N32_BR1_BEQ */
7383 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
7384 && N32_RT5 (insn) != REG_R5)
7385 insn16 = N16_TYPE38 (BEQS38, N32_RT5 (insn), N32_IMM14S (insn));
7386 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
7387 && N32_RA5 (insn) != REG_R5)
7388 insn16 = N16_TYPE38 (BEQS38, N32_RA5 (insn), N32_IMM14S (insn));
7389 insn_type = NDS32_INSN_BEQS38;
7390 break;
7391 }
7392 else
7393 {
7394 /* N32_BR1_BNE */
7395 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
7396 && N32_RT5 (insn) != REG_R5)
7397 insn16 = N16_TYPE38 (BNES38, N32_RT5 (insn), N32_IMM14S (insn));
7398 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
7399 && N32_RA5 (insn) != REG_R5)
7400 insn16 = N16_TYPE38 (BNES38, N32_RA5 (insn), N32_IMM14S (insn));
7401 insn_type = NDS32_INSN_BNES38;
7402 break;
7403 }
7404 break;
7405
7406 case N32_OP6_BR2:
7407 switch (N32_BR2_SUB (insn))
7408 {
7409 case N32_BR2_BEQZ:
7410 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
7411 {
7412 insn16 = N16_TYPE38 (BEQZ38, N32_RT5 (insn), N32_IMM16S (insn));
7413 insn_type = NDS32_INSN_BEQZ38;
7414 }
7415 else if (N32_RT5 (insn) == REG_R15
7416 && IS_WITHIN_S (N32_IMM16S (insn), 8))
7417 {
7418 insn16 = N16_TYPE8 (BEQZS8, N32_IMM16S (insn));
7419 insn_type = NDS32_INSN_BEQZS8;
7420 }
7421 break;
7422
7423 case N32_BR2_BNEZ:
7424 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
7425 {
7426 insn16 = N16_TYPE38 (BNEZ38, N32_RT5 (insn), N32_IMM16S (insn));
7427 insn_type = NDS32_INSN_BNEZ38;
7428 }
7429 else if (N32_RT5 (insn) == REG_R15
7430 && IS_WITHIN_S (N32_IMM16S (insn), 8))
7431 {
7432 insn16 = N16_TYPE8 (BNEZS8, N32_IMM16S (insn));
7433 insn_type = NDS32_INSN_BNEZS8;
7434 }
7435 break;
7436
7437 case N32_BR2_IFCALL:
7438 if (IS_WITHIN_U (N32_IMM16S (insn), 9))
7439 {
7440 insn16 = N16_TYPE9 (IFCALL9, N32_IMM16S (insn));
7441 insn_type = NDS32_INSN_IFCALL9;
7442 }
7443 break;
7444 }
7445 break;
7446
7447 case N32_OP6_JI:
7448 if ((insn & __BIT (24)) == 0)
7449 {
7450 /* N32_JI_J */
7451 if (IS_WITHIN_S (N32_IMM24S (insn), 8))
7452 {
7453 insn16 = N16_TYPE8 (J8, N32_IMM24S (insn));
7454 insn_type = NDS32_INSN_J8;
7455 }
7456 }
7457 break;
7458
7459 case N32_OP6_JREG:
7460 if (__GF (insn, 8, 2) != 0)
7461 goto done;
7462
7463 switch (N32_IMMU (insn, 5))
7464 {
7465 case N32_JREG_JR:
7466 if (N32_JREG_HINT (insn) == 0)
7467 {
7468 /* jr */
7469 insn16 = N16_TYPE5 (JR5, N32_RB5 (insn));
7470 insn_type = NDS32_INSN_JR5;
7471 }
7472 else if (N32_JREG_HINT (insn) == 1)
7473 {
7474 /* ret */
7475 insn16 = N16_TYPE5 (RET5, N32_RB5 (insn));
7476 insn_type = NDS32_INSN_RET5;
7477 }
7478 else if (N32_JREG_HINT (insn) == 3)
7479 {
7480 /* ifret = mov55 $sp, $sp */
7481 insn16 = N16_TYPE55 (MOV55, REG_SP, REG_SP);
7482 insn_type = NDS32_INSN_IFRET;
7483 }
7484 break;
7485
7486 case N32_JREG_JRAL:
7487 /* It's convertible when return rt5 is $lp and address
7488 translation is kept. */
7489 if (N32_RT5 (insn) == REG_LP && N32_JREG_HINT (insn) == 0)
7490 {
7491 insn16 = N16_TYPE5 (JRAL5, N32_RB5 (insn));
7492 insn_type = NDS32_INSN_JRAL5;
7493 }
7494 break;
7495 }
7496 break;
7497
7498 case N32_OP6_MISC:
7499 if (N32_SUB5 (insn) == N32_MISC_BREAK && N32_SWID (insn) < 32)
7500 {
7501 /* For v3, swid above 31 are used for ex9.it. */
7502 insn16 = N16_TYPE5 (BREAK16, N32_SWID (insn));
7503 insn_type = NDS32_INSN_BREAK16;
7504 }
7505 break;
7506
7507 default:
7508 /* This instruction has no 16-bit variant. */
7509 goto done;
7510 }
7511
7512 done:
7513 /* Bit-15 of insn16 should be set for a valid instruction. */
7514 if ((insn16 & 0x8000) == 0)
7515 return 0;
7516
7517 if (pinsn16)
7518 *pinsn16 = insn16;
7519 if (pinsn_type)
7520 *pinsn_type = insn_type;
7521 return 1;
7522 }
7523
7524 static int
special_convert_32_to_16(unsigned long insn,uint16_t * pinsn16,Elf_Internal_Rela * reloc)7525 special_convert_32_to_16 (unsigned long insn, uint16_t *pinsn16,
7526 Elf_Internal_Rela *reloc)
7527 {
7528 uint16_t insn16 = 0;
7529
7530 if ((reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG) == 0
7531 || (ELF32_R_TYPE (reloc->r_info) != R_NDS32_INSN16))
7532 return 0;
7533
7534 if (!N32_IS_RT3 (insn))
7535 return 0;
7536
7537 switch (N32_OP6 (insn))
7538 {
7539 case N32_OP6_LWI:
7540 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
7541 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7542 break;
7543 case N32_OP6_SWI:
7544 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
7545 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7546 break;
7547 case N32_OP6_HWGP:
7548 if (!IS_WITHIN_U (N32_IMM17S (insn), 7))
7549 break;
7550
7551 if (__GF (insn, 17, 3) == 6)
7552 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM17S (insn));
7553 else if (__GF (insn, 17, 3) == 7)
7554 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM17S (insn));
7555 break;
7556 }
7557
7558 if ((insn16 & 0x8000) == 0)
7559 return 0;
7560
7561 *pinsn16 = insn16;
7562 return 1;
7563 }
7564
7565 /* Convert a 16-bit instruction to 32-bit one.
7566 INSN16 it the input and PINSN it the point to output.
7567 Return non-zero on successful. Otherwise 0 is returned. */
7568
7569 int
nds32_convert_16_to_32(bfd * abfd,uint16_t insn16,uint32_t * pinsn)7570 nds32_convert_16_to_32 (bfd *abfd, uint16_t insn16, uint32_t *pinsn)
7571 {
7572 uint32_t insn = 0xffffffff;
7573 unsigned long mach = bfd_get_mach (abfd);
7574
7575 /* NOTE: push25, pop25 and movd44 do not have 32-bit variants. */
7576
7577 switch (__GF (insn16, 9, 6))
7578 {
7579 case 0x4: /* add45 */
7580 insn = N32_ALU1 (ADD, N16_RT4 (insn16), N16_RT4 (insn16),
7581 N16_RA5 (insn16));
7582 goto done;
7583 case 0x5: /* sub45 */
7584 insn = N32_ALU1 (SUB, N16_RT4 (insn16), N16_RT4 (insn16),
7585 N16_RA5 (insn16));
7586 goto done;
7587 case 0x6: /* addi45 */
7588 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
7589 N16_IMM5U (insn16));
7590 goto done;
7591 case 0x7: /* subi45 */
7592 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
7593 -N16_IMM5U (insn16));
7594 goto done;
7595 case 0x8: /* srai45 */
7596 insn = N32_ALU1 (SRAI, N16_RT4 (insn16), N16_RT4 (insn16),
7597 N16_IMM5U (insn16));
7598 goto done;
7599 case 0x9: /* srli45 */
7600 insn = N32_ALU1 (SRLI, N16_RT4 (insn16), N16_RT4 (insn16),
7601 N16_IMM5U (insn16));
7602 goto done;
7603 case 0xa: /* slli333 */
7604 insn = N32_ALU1 (SLLI, N16_RT3 (insn16), N16_RA3 (insn16),
7605 N16_IMM3U (insn16));
7606 goto done;
7607 case 0xc: /* add333 */
7608 insn = N32_ALU1 (ADD, N16_RT3 (insn16), N16_RA3 (insn16),
7609 N16_RB3 (insn16));
7610 goto done;
7611 case 0xd: /* sub333 */
7612 insn = N32_ALU1 (SUB, N16_RT3 (insn16), N16_RA3 (insn16),
7613 N16_RB3 (insn16));
7614 goto done;
7615 case 0xe: /* addi333 */
7616 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
7617 N16_IMM3U (insn16));
7618 goto done;
7619 case 0xf: /* subi333 */
7620 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
7621 -N16_IMM3U (insn16));
7622 goto done;
7623 case 0x10: /* lwi333 */
7624 insn = N32_TYPE2 (LWI, N16_RT3 (insn16), N16_RA3 (insn16),
7625 N16_IMM3U (insn16));
7626 goto done;
7627 case 0x12: /* lhi333 */
7628 insn = N32_TYPE2 (LHI, N16_RT3 (insn16), N16_RA3 (insn16),
7629 N16_IMM3U (insn16));
7630 goto done;
7631 case 0x13: /* lbi333 */
7632 insn = N32_TYPE2 (LBI, N16_RT3 (insn16), N16_RA3 (insn16),
7633 N16_IMM3U (insn16));
7634 goto done;
7635 case 0x11: /* lwi333.bi */
7636 insn = N32_TYPE2 (LWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
7637 N16_IMM3U (insn16));
7638 goto done;
7639 case 0x14: /* swi333 */
7640 insn = N32_TYPE2 (SWI, N16_RT3 (insn16), N16_RA3 (insn16),
7641 N16_IMM3U (insn16));
7642 goto done;
7643 case 0x16: /* shi333 */
7644 insn = N32_TYPE2 (SHI, N16_RT3 (insn16), N16_RA3 (insn16),
7645 N16_IMM3U (insn16));
7646 goto done;
7647 case 0x17: /* sbi333 */
7648 insn = N32_TYPE2 (SBI, N16_RT3 (insn16), N16_RA3 (insn16),
7649 N16_IMM3U (insn16));
7650 goto done;
7651 case 0x15: /* swi333.bi */
7652 insn = N32_TYPE2 (SWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
7653 N16_IMM3U (insn16));
7654 goto done;
7655 case 0x18: /* addri36.sp */
7656 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), REG_SP,
7657 N16_IMM6U (insn16) << 2);
7658 goto done;
7659 case 0x19: /* lwi45.fe */
7660 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), REG_R8,
7661 (N16_IMM5U (insn16) - 32));
7662 goto done;
7663 case 0x1a: /* lwi450 */
7664 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
7665 goto done;
7666 case 0x1b: /* swi450 */
7667 insn = N32_TYPE2 (SWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
7668 goto done;
7669
7670 /* These are r15 implied instructions. */
7671 case 0x30: /* slts45 */
7672 insn = N32_ALU1 (SLTS, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
7673 goto done;
7674 case 0x31: /* slt45 */
7675 insn = N32_ALU1 (SLT, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
7676 goto done;
7677 case 0x32: /* sltsi45 */
7678 insn = N32_TYPE2 (SLTSI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
7679 goto done;
7680 case 0x33: /* slti45 */
7681 insn = N32_TYPE2 (SLTI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
7682 goto done;
7683 case 0x34: /* beqzs8, bnezs8 */
7684 if (insn16 & __BIT (8))
7685 insn = N32_BR2 (BNEZ, REG_TA, N16_IMM8S (insn16));
7686 else
7687 insn = N32_BR2 (BEQZ, REG_TA, N16_IMM8S (insn16));
7688 goto done;
7689
7690 case 0x35: /* break16, ex9.it */
7691 /* Only consider range of v3 break16. */
7692 insn = N32_TYPE0 (MISC, (N16_IMM5U (insn16) << 5) | N32_MISC_BREAK);
7693 goto done;
7694
7695 case 0x3c: /* ifcall9 */
7696 insn = N32_BR2 (IFCALL, 0, N16_IMM9U (insn16));
7697 goto done;
7698 case 0x3d: /* movpi45 */
7699 insn = N32_TYPE1 (MOVI, N16_RT4 (insn16), N16_IMM5U (insn16) + 16);
7700 goto done;
7701
7702 case 0x3f: /* MISC33 */
7703 switch (insn16 & 0x7)
7704 {
7705 case 2: /* neg33 */
7706 insn = N32_TYPE2 (SUBRI, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7707 break;
7708 case 3: /* not33 */
7709 insn = N32_ALU1 (NOR, N16_RT3 (insn16), N16_RA3 (insn16),
7710 N16_RA3 (insn16));
7711 break;
7712 case 4: /* mul33 */
7713 insn = N32_ALU2 (MUL, N16_RT3 (insn16), N16_RT3 (insn16),
7714 N16_RA3 (insn16));
7715 break;
7716 case 5: /* xor33 */
7717 insn = N32_ALU1 (XOR, N16_RT3 (insn16), N16_RT3 (insn16),
7718 N16_RA3 (insn16));
7719 break;
7720 case 6: /* and33 */
7721 insn = N32_ALU1 (AND, N16_RT3 (insn16), N16_RT3 (insn16),
7722 N16_RA3 (insn16));
7723 break;
7724 case 7: /* or33 */
7725 insn = N32_ALU1 (OR, N16_RT3 (insn16), N16_RT3 (insn16),
7726 N16_RA3 (insn16));
7727 break;
7728 }
7729 goto done;
7730
7731 case 0xb:
7732 switch (insn16 & 0x7)
7733 {
7734 case 0: /* zeb33 */
7735 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0xff);
7736 break;
7737 case 1: /* zeh33 */
7738 insn = N32_ALU1 (ZEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7739 break;
7740 case 2: /* seb33 */
7741 insn = N32_ALU1 (SEB, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7742 break;
7743 case 3: /* seh33 */
7744 insn = N32_ALU1 (SEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7745 break;
7746 case 4: /* xlsb33 */
7747 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 1);
7748 break;
7749 case 5: /* x11b33 */
7750 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0x7ff);
7751 break;
7752 case 6: /* bmski33 */
7753 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
7754 1 << __GF (insn16, 3, 3));
7755 break;
7756 case 7: /* fexti33 */
7757 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
7758 (1 << (__GF (insn16, 3, 3) + 1)) - 1);
7759 break;
7760 }
7761 goto done;
7762 }
7763
7764 switch (__GF (insn16, 10, 5))
7765 {
7766 case 0x0: /* mov55 or ifret16 */
7767 if (mach >= MACH_V3 && N16_RT5 (insn16) == REG_SP
7768 && N16_RT5 (insn16) == N16_RA5 (insn16))
7769 insn = N32_JREG (JR, 0, 0, 0, 3);
7770 else
7771 insn = N32_TYPE2 (ADDI, N16_RT5 (insn16), N16_RA5 (insn16), 0);
7772 goto done;
7773 case 0x1: /* movi55 */
7774 insn = N32_TYPE1 (MOVI, N16_RT5 (insn16), N16_IMM5S (insn16));
7775 goto done;
7776 case 0x1b: /* addi10s (V2) */
7777 insn = N32_TYPE2 (ADDI, REG_SP, REG_SP, N16_IMM10S (insn16));
7778 goto done;
7779 }
7780
7781 switch (__GF (insn16, 11, 4))
7782 {
7783 case 0x7: /* lwi37.fp/swi37.fp */
7784 if (insn16 & __BIT (7)) /* swi37.fp */
7785 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
7786 else /* lwi37.fp */
7787 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
7788 goto done;
7789 case 0x8: /* beqz38 */
7790 insn = N32_BR2 (BEQZ, N16_RT38 (insn16), N16_IMM8S (insn16));
7791 goto done;
7792 case 0x9: /* bnez38 */
7793 insn = N32_BR2 (BNEZ, N16_RT38 (insn16), N16_IMM8S (insn16));
7794 goto done;
7795 case 0xa: /* beqs38/j8, implied r5 */
7796 if (N16_RT38 (insn16) == 5)
7797 insn = N32_JI (J, N16_IMM8S (insn16));
7798 else
7799 insn = N32_BR1 (BEQ, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
7800 goto done;
7801 case 0xb: /* bnes38 and others */
7802 if (N16_RT38 (insn16) == 5)
7803 {
7804 switch (__GF (insn16, 5, 3))
7805 {
7806 case 0: /* jr5 */
7807 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 0);
7808 break;
7809 case 4: /* ret5 */
7810 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 1);
7811 break;
7812 case 1: /* jral5 */
7813 insn = N32_JREG (JRAL, REG_LP, N16_RA5 (insn16), 0, 0);
7814 break;
7815 case 2: /* ex9.it imm5 */
7816 /* ex9.it had no 32-bit variantl. */
7817 break;
7818 case 5: /* add5.pc */
7819 /* add5.pc had no 32-bit variantl. */
7820 break;
7821 }
7822 }
7823 else /* bnes38 */
7824 insn = N32_BR1 (BNE, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
7825 goto done;
7826 case 0xe: /* lwi37/swi37 */
7827 if (insn16 & (1 << 7)) /* swi37.sp */
7828 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
7829 else /* lwi37.sp */
7830 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
7831 goto done;
7832 }
7833
7834 done:
7835 if (insn & 0x80000000)
7836 return 0;
7837
7838 if (pinsn)
7839 *pinsn = insn;
7840 return 1;
7841 }
7842
7843 static bfd_boolean
is_sda_access_insn(unsigned long insn)7844 is_sda_access_insn (unsigned long insn)
7845 {
7846 switch (N32_OP6 (insn))
7847 {
7848 case N32_OP6_LWI:
7849 case N32_OP6_LHI:
7850 case N32_OP6_LHSI:
7851 case N32_OP6_LBI:
7852 case N32_OP6_LBSI:
7853 case N32_OP6_SWI:
7854 case N32_OP6_SHI:
7855 case N32_OP6_SBI:
7856 case N32_OP6_LWC:
7857 case N32_OP6_LDC:
7858 case N32_OP6_SWC:
7859 case N32_OP6_SDC:
7860 return TRUE;
7861 default:
7862 ;
7863 }
7864 return FALSE;
7865 }
7866
7867 static unsigned long
turn_insn_to_sda_access(uint32_t insn,bfd_signed_vma type,uint32_t * pinsn)7868 turn_insn_to_sda_access (uint32_t insn, bfd_signed_vma type, uint32_t *pinsn)
7869 {
7870 uint32_t oinsn = 0;
7871
7872 switch (type)
7873 {
7874 case R_NDS32_GOT_LO12:
7875 case R_NDS32_GOTOFF_LO12:
7876 case R_NDS32_PLTREL_LO12:
7877 case R_NDS32_PLT_GOTREL_LO12:
7878 case R_NDS32_LO12S0_RELA:
7879 switch (N32_OP6 (insn))
7880 {
7881 case N32_OP6_LBI:
7882 /* lbi.gp */
7883 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
7884 break;
7885 case N32_OP6_LBSI:
7886 /* lbsi.gp */
7887 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), __BIT (19));
7888 break;
7889 case N32_OP6_SBI:
7890 /* sbi.gp */
7891 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
7892 break;
7893 case N32_OP6_ORI:
7894 /* addi.gp */
7895 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
7896 break;
7897 }
7898 break;
7899
7900 case R_NDS32_LO12S1_RELA:
7901 switch (N32_OP6 (insn))
7902 {
7903 case N32_OP6_LHI:
7904 /* lhi.gp */
7905 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
7906 break;
7907 case N32_OP6_LHSI:
7908 /* lhsi.gp */
7909 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (18));
7910 break;
7911 case N32_OP6_SHI:
7912 /* shi.gp */
7913 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (19));
7914 break;
7915 }
7916 break;
7917
7918 case R_NDS32_LO12S2_RELA:
7919 switch (N32_OP6 (insn))
7920 {
7921 case N32_OP6_LWI:
7922 /* lwi.gp */
7923 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
7924 break;
7925 case N32_OP6_SWI:
7926 /* swi.gp */
7927 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
7928 break;
7929 }
7930 break;
7931
7932 case R_NDS32_LO12S2_DP_RELA:
7933 case R_NDS32_LO12S2_SP_RELA:
7934 oinsn = (insn & 0x7ff07000) | (REG_GP << 15);
7935 break;
7936 }
7937
7938 if (oinsn)
7939 *pinsn = oinsn;
7940
7941 return oinsn != 0;
7942 }
7943
7944 /* Linker hasn't found the correct merge section for non-section symbol
7945 in relax time, this work is left to the function elf_link_input_bfd().
7946 So for non-section symbol, _bfd_merged_section_offset is also needed
7947 to find the correct symbol address. */
7948
7949 static bfd_vma
nds32_elf_rela_local_sym(bfd * abfd,Elf_Internal_Sym * sym,asection ** psec,Elf_Internal_Rela * rel)7950 nds32_elf_rela_local_sym (bfd *abfd, Elf_Internal_Sym *sym,
7951 asection **psec, Elf_Internal_Rela *rel)
7952 {
7953 asection *sec = *psec;
7954 bfd_vma relocation;
7955
7956 relocation = (sec->output_section->vma
7957 + sec->output_offset + sym->st_value);
7958 if ((sec->flags & SEC_MERGE) && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
7959 {
7960 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
7961 rel->r_addend =
7962 _bfd_merged_section_offset (abfd, psec,
7963 elf_section_data (sec)->sec_info,
7964 sym->st_value + rel->r_addend);
7965 else
7966 rel->r_addend =
7967 _bfd_merged_section_offset (abfd, psec,
7968 elf_section_data (sec)->sec_info,
7969 sym->st_value) + rel->r_addend;
7970
7971 if (sec != *psec)
7972 {
7973 /* If we have changed the section, and our original section is
7974 marked with SEC_EXCLUDE, it means that the original
7975 SEC_MERGE section has been completely subsumed in some
7976 other SEC_MERGE section. In this case, we need to leave
7977 some info around for --emit-relocs. */
7978 if ((sec->flags & SEC_EXCLUDE) != 0)
7979 sec->kept_section = *psec;
7980 sec = *psec;
7981 }
7982 rel->r_addend -= relocation;
7983 rel->r_addend += sec->output_section->vma + sec->output_offset;
7984 }
7985 return relocation;
7986 }
7987
7988 static bfd_vma
calculate_memory_address(bfd * abfd,Elf_Internal_Rela * irel,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)7989 calculate_memory_address (bfd *abfd, Elf_Internal_Rela *irel,
7990 Elf_Internal_Sym *isymbuf,
7991 Elf_Internal_Shdr *symtab_hdr)
7992 {
7993 bfd_signed_vma foff;
7994 bfd_vma symval, addend;
7995 Elf_Internal_Rela irel_fn;
7996 Elf_Internal_Sym *isym;
7997 asection *sym_sec;
7998
7999 /* Get the value of the symbol referred to by the reloc. */
8000 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
8001 {
8002 /* A local symbol. */
8003 isym = isymbuf + ELF32_R_SYM (irel->r_info);
8004
8005 if (isym->st_shndx == SHN_UNDEF)
8006 sym_sec = bfd_und_section_ptr;
8007 else if (isym->st_shndx == SHN_ABS)
8008 sym_sec = bfd_abs_section_ptr;
8009 else if (isym->st_shndx == SHN_COMMON)
8010 sym_sec = bfd_com_section_ptr;
8011 else
8012 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
8013 memcpy (&irel_fn, irel, sizeof (Elf_Internal_Rela));
8014 symval = nds32_elf_rela_local_sym (abfd, isym, &sym_sec, &irel_fn);
8015 addend = irel_fn.r_addend;
8016 }
8017 else
8018 {
8019 unsigned long indx;
8020 struct elf_link_hash_entry *h;
8021
8022 /* An external symbol. */
8023 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8024 h = elf_sym_hashes (abfd)[indx];
8025 BFD_ASSERT (h != NULL);
8026
8027 while (h->root.type == bfd_link_hash_indirect
8028 || h->root.type == bfd_link_hash_warning)
8029 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8030
8031 if (h->root.type != bfd_link_hash_defined
8032 && h->root.type != bfd_link_hash_defweak)
8033 /* This appears to be a reference to an undefined
8034 symbol. Just ignore it--it will be caught by the
8035 regular reloc processing. */
8036 return 0;
8037
8038 if (h->root.u.def.section->flags & SEC_MERGE)
8039 {
8040 sym_sec = h->root.u.def.section;
8041 symval = _bfd_merged_section_offset (abfd, &sym_sec, elf_section_data
8042 (sym_sec)->sec_info, h->root.u.def.value);
8043 symval = symval + sym_sec->output_section->vma
8044 + sym_sec->output_offset;
8045 }
8046 else
8047 symval = (h->root.u.def.value
8048 + h->root.u.def.section->output_section->vma
8049 + h->root.u.def.section->output_offset);
8050 addend = irel->r_addend;
8051 }
8052
8053 foff = symval + addend;
8054
8055 return foff;
8056 }
8057
8058 static bfd_vma
calculate_got_memory_address(bfd * abfd,struct bfd_link_info * link_info,Elf_Internal_Rela * irel,Elf_Internal_Shdr * symtab_hdr)8059 calculate_got_memory_address (bfd *abfd, struct bfd_link_info *link_info,
8060 Elf_Internal_Rela *irel,
8061 Elf_Internal_Shdr *symtab_hdr)
8062 {
8063 int symndx;
8064 bfd_vma *local_got_offsets;
8065 /* Get the value of the symbol referred to by the reloc. */
8066 struct elf_link_hash_entry *h;
8067 struct elf_nds32_link_hash_table *htab = nds32_elf_hash_table (link_info);
8068
8069 /* An external symbol. */
8070 symndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8071 h = elf_sym_hashes (abfd)[symndx];
8072 while (h->root.type == bfd_link_hash_indirect
8073 || h->root.type == bfd_link_hash_warning)
8074 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8075
8076 if (symndx >= 0)
8077 {
8078 BFD_ASSERT (h != NULL);
8079 return htab->sgot->output_section->vma + htab->sgot->output_offset
8080 + h->got.offset;
8081 }
8082 else
8083 {
8084 local_got_offsets = elf_local_got_offsets (abfd);
8085 BFD_ASSERT (local_got_offsets != NULL);
8086 return htab->sgot->output_section->vma + htab->sgot->output_offset
8087 + local_got_offsets[ELF32_R_SYM (irel->r_info)];
8088 }
8089
8090 /* The _GLOBAL_OFFSET_TABLE_ may be undefweak(or should be?). */
8091 /* The check of h->root.type is passed. */
8092 }
8093
8094 static int
is_16bit_NOP(bfd * abfd ATTRIBUTE_UNUSED,asection * sec,Elf_Internal_Rela * rel)8095 is_16bit_NOP (bfd *abfd ATTRIBUTE_UNUSED,
8096 asection *sec, Elf_Internal_Rela *rel)
8097 {
8098 bfd_byte *contents;
8099 unsigned short insn16;
8100
8101 if (!(rel->r_addend & R_NDS32_INSN16_CONVERT_FLAG))
8102 return FALSE;
8103 contents = elf_section_data (sec)->this_hdr.contents;
8104 insn16 = bfd_getb16 (contents + rel->r_offset);
8105 if (insn16 == NDS32_NOP16)
8106 return TRUE;
8107 return FALSE;
8108 }
8109
8110 /* It checks whether the instruction could be converted to
8111 16-bit form and returns the converted one.
8112
8113 `internal_relocs' is supposed to be sorted. */
8114
8115 static int
is_convert_32_to_16(bfd * abfd,asection * sec,Elf_Internal_Rela * reloc,Elf_Internal_Rela * internal_relocs,Elf_Internal_Rela * irelend,uint16_t * insn16)8116 is_convert_32_to_16 (bfd *abfd, asection *sec,
8117 Elf_Internal_Rela *reloc,
8118 Elf_Internal_Rela *internal_relocs,
8119 Elf_Internal_Rela *irelend,
8120 uint16_t *insn16)
8121 {
8122 #define NORMAL_32_TO_16 (1 << 0)
8123 #define SPECIAL_32_TO_16 (1 << 1)
8124 bfd_byte *contents = NULL;
8125 bfd_signed_vma off;
8126 bfd_vma mem_addr;
8127 uint32_t insn = 0;
8128 Elf_Internal_Rela *pc_rel;
8129 int pic_ext_target = 0;
8130 Elf_Internal_Shdr *symtab_hdr;
8131 Elf_Internal_Sym *isymbuf = NULL;
8132 int convert_type;
8133 bfd_vma offset;
8134
8135 if (reloc->r_offset + 4 > sec->size)
8136 return FALSE;
8137
8138 offset = reloc->r_offset;
8139
8140 if (!nds32_get_section_contents (abfd, sec, &contents))
8141 return FALSE;
8142 insn = bfd_getb32 (contents + offset);
8143
8144 if (nds32_convert_32_to_16 (abfd, insn, insn16, NULL))
8145 convert_type = NORMAL_32_TO_16;
8146 else if (special_convert_32_to_16 (insn, insn16, reloc))
8147 convert_type = SPECIAL_32_TO_16;
8148 else
8149 return FALSE;
8150
8151 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8152 if (!nds32_get_local_syms (abfd, sec, &isymbuf))
8153 return FALSE;
8154
8155 /* Find the first relocation of the same relocation-type,
8156 so we iteratie them forward. */
8157 pc_rel = reloc;
8158 while ((pc_rel - 1) >= internal_relocs && pc_rel[-1].r_offset == offset)
8159 pc_rel--;
8160
8161 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8162 {
8163 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8164 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8165 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA
8166 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8167 {
8168 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr,
8169 &pic_ext_target);
8170 if (off >= ACCURATE_8BIT_S1 || off < -ACCURATE_8BIT_S1
8171 || off == 0)
8172 return FALSE;
8173 break;
8174 }
8175 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8176 {
8177 /* movi => movi55 */
8178 mem_addr = calculate_memory_address (abfd, pc_rel, isymbuf,
8179 symtab_hdr);
8180 /* mem_addr is unsigned, but the value should
8181 be between [-16, 15]. */
8182 if ((mem_addr + 0x10) >> 5)
8183 return FALSE;
8184 break;
8185 }
8186 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_20)
8187 || (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_LO12))
8188 {
8189 /* It never happen movi to movi55 for R_NDS32_TLS_LE_20,
8190 because it can be relaxed to addi for TLS_LE_ADD. */
8191 return FALSE;
8192 }
8193 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8194 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8195 && (reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG)
8196 && convert_type == SPECIAL_32_TO_16)
8197 {
8198 /* fp-as-gp
8199 We've selected a best fp-base for this access, so we can
8200 always resolve it anyway. Do nothing. */
8201 break;
8202 }
8203 else if ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_NONE
8204 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_RELA_GNU_VTINHERIT))
8205 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_RELA_GNU_VTENTRY)
8206 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_INSN16))
8207 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_LOADSTORE)
8208 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_DWARF2_OP1_RELA)))
8209 {
8210 /* Prevent unresolved addi instruction translate
8211 to addi45 or addi333. */
8212 return FALSE;
8213 }
8214 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8215 {
8216 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr,
8217 &pic_ext_target);
8218 if (off >= ACCURATE_U9BIT_S1 || off <= 0)
8219 return FALSE;
8220 break;
8221 }
8222 }
8223
8224 return TRUE;
8225 }
8226
8227 static void
nds32_elf_write_16(bfd * abfd ATTRIBUTE_UNUSED,bfd_byte * contents,Elf_Internal_Rela * reloc,Elf_Internal_Rela * internal_relocs,Elf_Internal_Rela * irelend,unsigned short insn16)8228 nds32_elf_write_16 (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *contents,
8229 Elf_Internal_Rela *reloc,
8230 Elf_Internal_Rela *internal_relocs,
8231 Elf_Internal_Rela *irelend,
8232 unsigned short insn16)
8233 {
8234 Elf_Internal_Rela *pc_rel;
8235 bfd_vma offset;
8236
8237 offset = reloc->r_offset;
8238 bfd_putb16 (insn16, contents + offset);
8239 /* Find the first relocation of the same relocation-type,
8240 so we iteratie them forward. */
8241 pc_rel = reloc;
8242 while ((pc_rel - 1) > internal_relocs && pc_rel[-1].r_offset == offset)
8243 pc_rel--;
8244
8245 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8246 {
8247 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8248 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8249 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA)
8250 {
8251 pc_rel->r_info =
8252 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PCREL_RELA);
8253 }
8254 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8255 pc_rel->r_info =
8256 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PLTREL);
8257 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8258 pc_rel->r_info =
8259 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_5_RELA);
8260 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8261 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8262 pc_rel->r_info =
8263 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_SDA_FP7U2_RELA);
8264 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8265 pc_rel->r_info =
8266 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_10IFCU_PCREL_RELA);
8267 }
8268 }
8269
8270 /* Find a relocation of type specified by `reloc_type'
8271 of the same r_offset with reloc.
8272 If not found, return irelend.
8273
8274 Assuming relocations are sorted by r_offset,
8275 we find the relocation from `reloc' backward untill relocs,
8276 or find it from `reloc' forward untill irelend. */
8277
8278 static Elf_Internal_Rela *
find_relocs_at_address(Elf_Internal_Rela * reloc,Elf_Internal_Rela * relocs,Elf_Internal_Rela * irelend,enum elf_nds32_reloc_type reloc_type)8279 find_relocs_at_address (Elf_Internal_Rela *reloc,
8280 Elf_Internal_Rela *relocs,
8281 Elf_Internal_Rela *irelend,
8282 enum elf_nds32_reloc_type reloc_type)
8283 {
8284 Elf_Internal_Rela *rel_t;
8285
8286 /* Find backward. */
8287 for (rel_t = reloc;
8288 rel_t >= relocs && rel_t->r_offset == reloc->r_offset;
8289 rel_t--)
8290 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8291 return rel_t;
8292
8293 /* We didn't find it backward. Try find it forward. */
8294 for (rel_t = reloc;
8295 rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8296 rel_t++)
8297 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8298 return rel_t;
8299
8300 return irelend;
8301 }
8302
8303 /* Find a relocation of specified type and offset.
8304 `reloc' is just a refence point to find a relocation at specified offset.
8305 If not found, return irelend.
8306
8307 Assuming relocations are sorted by r_offset,
8308 we find the relocation from `reloc' backward untill relocs,
8309 or find it from `reloc' forward untill irelend. */
8310
8311 static Elf_Internal_Rela *
find_relocs_at_address_addr(Elf_Internal_Rela * reloc,Elf_Internal_Rela * relocs,Elf_Internal_Rela * irelend,unsigned char reloc_type,bfd_vma offset_p)8312 find_relocs_at_address_addr (Elf_Internal_Rela *reloc,
8313 Elf_Internal_Rela *relocs,
8314 Elf_Internal_Rela *irelend,
8315 unsigned char reloc_type,
8316 bfd_vma offset_p)
8317 {
8318 Elf_Internal_Rela *rel_t = NULL;
8319
8320 /* First, we try to find a relocation of offset `offset_p',
8321 and then we use find_relocs_at_address to find specific type. */
8322
8323 if (reloc->r_offset > offset_p)
8324 {
8325 /* Find backward. */
8326 for (rel_t = reloc;
8327 rel_t >= relocs && rel_t->r_offset > offset_p; rel_t--)
8328 /* Do nothing. */;
8329 }
8330 else if (reloc->r_offset < offset_p)
8331 {
8332 /* Find forward. */
8333 for (rel_t = reloc;
8334 rel_t < irelend && rel_t->r_offset < offset_p; rel_t++)
8335 /* Do nothing. */;
8336 }
8337 else
8338 rel_t = reloc;
8339
8340 /* Not found? */
8341 if (rel_t < relocs || rel_t == irelend || rel_t->r_offset != offset_p)
8342 return irelend;
8343
8344 return find_relocs_at_address (rel_t, relocs, irelend, reloc_type);
8345 }
8346
8347 static bfd_boolean
nds32_elf_check_dup_relocs(Elf_Internal_Rela * reloc,Elf_Internal_Rela * internal_relocs,Elf_Internal_Rela * irelend,unsigned char reloc_type)8348 nds32_elf_check_dup_relocs (Elf_Internal_Rela *reloc,
8349 Elf_Internal_Rela *internal_relocs,
8350 Elf_Internal_Rela *irelend,
8351 unsigned char reloc_type)
8352 {
8353 Elf_Internal_Rela *rel_t;
8354
8355 for (rel_t = reloc;
8356 rel_t >= internal_relocs && rel_t->r_offset == reloc->r_offset;
8357 rel_t--)
8358 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8359 {
8360 if (ELF32_R_SYM (rel_t->r_info) == ELF32_R_SYM (reloc->r_info)
8361 && rel_t->r_addend == reloc->r_addend)
8362 continue;
8363 return TRUE;
8364 }
8365
8366 for (rel_t = reloc; rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8367 rel_t++)
8368 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8369 {
8370 if (ELF32_R_SYM (rel_t->r_info) == ELF32_R_SYM (reloc->r_info)
8371 && rel_t->r_addend == reloc->r_addend)
8372 continue;
8373 return TRUE;
8374 }
8375
8376 return FALSE;
8377 }
8378
8379 typedef struct nds32_elf_blank nds32_elf_blank_t;
8380 struct nds32_elf_blank
8381 {
8382 /* Where the blank begins. */
8383 bfd_vma offset;
8384 /* The size of the blank. */
8385 bfd_vma size;
8386 /* The accumulative size before this blank. */
8387 bfd_vma total_size;
8388 nds32_elf_blank_t *next;
8389 nds32_elf_blank_t *prev;
8390 };
8391
8392 static nds32_elf_blank_t *blank_free_list = NULL;
8393
8394 static nds32_elf_blank_t *
create_nds32_elf_blank(bfd_vma offset_p,bfd_vma size_p)8395 create_nds32_elf_blank (bfd_vma offset_p, bfd_vma size_p)
8396 {
8397 nds32_elf_blank_t *blank_t;
8398
8399 if (blank_free_list)
8400 {
8401 blank_t = blank_free_list;
8402 blank_free_list = blank_free_list->next;
8403 }
8404 else
8405 blank_t = bfd_malloc (sizeof (nds32_elf_blank_t));
8406
8407 if (blank_t == NULL)
8408 return NULL;
8409
8410 blank_t->offset = offset_p;
8411 blank_t->size = size_p;
8412 blank_t->total_size = 0;
8413 blank_t->next = NULL;
8414 blank_t->prev = NULL;
8415
8416 return blank_t;
8417 }
8418
8419 static void
remove_nds32_elf_blank(nds32_elf_blank_t * blank_p)8420 remove_nds32_elf_blank (nds32_elf_blank_t *blank_p)
8421 {
8422 if (blank_free_list)
8423 {
8424 blank_free_list->prev = blank_p;
8425 blank_p->next = blank_free_list;
8426 }
8427 else
8428 blank_p->next = NULL;
8429
8430 blank_p->prev = NULL;
8431 blank_free_list = blank_p;
8432 }
8433
8434 static void
clean_nds32_elf_blank(void)8435 clean_nds32_elf_blank (void)
8436 {
8437 nds32_elf_blank_t *blank_t;
8438
8439 while (blank_free_list)
8440 {
8441 blank_t = blank_free_list;
8442 blank_free_list = blank_free_list->next;
8443 free (blank_t);
8444 }
8445 }
8446
8447 static nds32_elf_blank_t *
search_nds32_elf_blank(nds32_elf_blank_t * blank_p,bfd_vma addr)8448 search_nds32_elf_blank (nds32_elf_blank_t *blank_p, bfd_vma addr)
8449 {
8450 nds32_elf_blank_t *blank_t;
8451
8452 if (!blank_p)
8453 return NULL;
8454 blank_t = blank_p;
8455
8456 while (blank_t && addr < blank_t->offset)
8457 blank_t = blank_t->prev;
8458 while (blank_t && blank_t->next && addr >= blank_t->next->offset)
8459 blank_t = blank_t->next;
8460
8461 return blank_t;
8462 }
8463
8464 static bfd_vma
get_nds32_elf_blank_total(nds32_elf_blank_t ** blank_p,bfd_vma addr,int overwrite)8465 get_nds32_elf_blank_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
8466 int overwrite)
8467 {
8468 nds32_elf_blank_t *blank_t;
8469
8470 blank_t = search_nds32_elf_blank (*blank_p, addr);
8471 if (!blank_t)
8472 return 0;
8473
8474 if (overwrite)
8475 *blank_p = blank_t;
8476
8477 if (addr < blank_t->offset + blank_t->size)
8478 return blank_t->total_size + (addr - blank_t->offset);
8479 else
8480 return blank_t->total_size + blank_t->size;
8481 }
8482
8483 static bfd_boolean
insert_nds32_elf_blank(nds32_elf_blank_t ** blank_p,bfd_vma addr,bfd_vma len)8484 insert_nds32_elf_blank (nds32_elf_blank_t **blank_p, bfd_vma addr, bfd_vma len)
8485 {
8486 nds32_elf_blank_t *blank_t, *blank_t2;
8487
8488 if (!*blank_p)
8489 {
8490 *blank_p = create_nds32_elf_blank (addr, len);
8491 return *blank_p ? TRUE : FALSE;
8492 }
8493
8494 blank_t = search_nds32_elf_blank (*blank_p, addr);
8495
8496 if (blank_t == NULL)
8497 {
8498 blank_t = create_nds32_elf_blank (addr, len);
8499 if (!blank_t)
8500 return FALSE;
8501 while ((*blank_p)->prev != NULL)
8502 *blank_p = (*blank_p)->prev;
8503 blank_t->next = *blank_p;
8504 (*blank_p)->prev = blank_t;
8505 (*blank_p) = blank_t;
8506 return TRUE;
8507 }
8508
8509 if (addr < blank_t->offset + blank_t->size)
8510 {
8511 if (addr > blank_t->offset + blank_t->size)
8512 blank_t->size = addr - blank_t->offset;
8513 }
8514 else
8515 {
8516 blank_t2 = create_nds32_elf_blank (addr, len);
8517 if (!blank_t2)
8518 return FALSE;
8519 if (blank_t->next)
8520 {
8521 blank_t->next->prev = blank_t2;
8522 blank_t2->next = blank_t->next;
8523 }
8524 blank_t2->prev = blank_t;
8525 blank_t->next = blank_t2;
8526 *blank_p = blank_t2;
8527 }
8528
8529 return TRUE;
8530 }
8531
8532 static bfd_boolean
insert_nds32_elf_blank_recalc_total(nds32_elf_blank_t ** blank_p,bfd_vma addr,bfd_vma len)8533 insert_nds32_elf_blank_recalc_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
8534 bfd_vma len)
8535 {
8536 nds32_elf_blank_t *blank_t;
8537
8538 if (!insert_nds32_elf_blank (blank_p, addr, len))
8539 return FALSE;
8540
8541 blank_t = *blank_p;
8542
8543 if (!blank_t->prev)
8544 {
8545 blank_t->total_size = 0;
8546 blank_t = blank_t->next;
8547 }
8548
8549 while (blank_t)
8550 {
8551 blank_t->total_size = blank_t->prev->total_size + blank_t->prev->size;
8552 blank_t = blank_t->next;
8553 }
8554
8555 return TRUE;
8556 }
8557
8558 static void
calc_nds32_blank_total(nds32_elf_blank_t * blank_p)8559 calc_nds32_blank_total (nds32_elf_blank_t *blank_p)
8560 {
8561 nds32_elf_blank_t *blank_t;
8562 bfd_vma total_size = 0;
8563
8564 if (!blank_p)
8565 return;
8566
8567 blank_t = blank_p;
8568 while (blank_t->prev)
8569 blank_t = blank_t->prev;
8570 while (blank_t)
8571 {
8572 blank_t->total_size = total_size;
8573 total_size += blank_t->size;
8574 blank_t = blank_t->next;
8575 }
8576 }
8577
8578 static bfd_boolean
nds32_elf_relax_delete_blanks(bfd * abfd,asection * sec,nds32_elf_blank_t * blank_p)8579 nds32_elf_relax_delete_blanks (bfd *abfd, asection *sec,
8580 nds32_elf_blank_t *blank_p)
8581 {
8582 Elf_Internal_Shdr *symtab_hdr; /* Symbol table header of this bfd. */
8583 Elf_Internal_Sym *isym = NULL; /* Symbol table of this bfd. */
8584 Elf_Internal_Sym *isymend; /* Symbol entry iterator. */
8585 unsigned int sec_shndx; /* The section the be relaxed. */
8586 bfd_byte *contents; /* Contents data of iterating section. */
8587 Elf_Internal_Rela *internal_relocs;
8588 Elf_Internal_Rela *irel;
8589 Elf_Internal_Rela *irelend;
8590 struct elf_link_hash_entry **sym_hashes;
8591 struct elf_link_hash_entry **end_hashes;
8592 unsigned int symcount;
8593 asection *sect;
8594 nds32_elf_blank_t *blank_t;
8595 nds32_elf_blank_t *blank_t2;
8596 nds32_elf_blank_t *blank_head;
8597
8598 blank_head = blank_t = blank_p;
8599 while (blank_head->prev != NULL)
8600 blank_head = blank_head->prev;
8601 while (blank_t->next != NULL)
8602 blank_t = blank_t->next;
8603
8604 if (blank_t->offset + blank_t->size <= sec->size)
8605 {
8606 blank_t->next = create_nds32_elf_blank (sec->size + 4, 0);
8607 blank_t->next->prev = blank_t;
8608 }
8609 if (blank_head->offset > 0)
8610 {
8611 blank_head->prev = create_nds32_elf_blank (0, 0);
8612 blank_head->prev->next = blank_head;
8613 blank_head = blank_head->prev;
8614 }
8615
8616 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
8617
8618 /* The deletion must stop at the next ALIGN reloc for an alignment
8619 power larger than the number of bytes we are deleting. */
8620
8621 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8622 if (!nds32_get_local_syms (abfd, sec, &isym))
8623 return FALSE;
8624
8625 if (isym == NULL)
8626 {
8627 isym = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8628 symtab_hdr->sh_info, 0, NULL, NULL, NULL);
8629 symtab_hdr->contents = (bfd_byte *) isym;
8630 }
8631
8632 if (isym == NULL || symtab_hdr->sh_info == 0)
8633 return FALSE;
8634
8635 blank_t = blank_head;
8636 calc_nds32_blank_total (blank_head);
8637
8638 for (sect = abfd->sections; sect != NULL; sect = sect->next)
8639 {
8640 /* Adjust all the relocs. */
8641
8642 /* Relocations MUST be kept in memory, because relaxation adjust them. */
8643 internal_relocs = _bfd_elf_link_read_relocs (abfd, sect, NULL, NULL,
8644 TRUE /* keep_memory */);
8645 irelend = internal_relocs + sect->reloc_count;
8646
8647 blank_t = blank_head;
8648 blank_t2 = blank_head;
8649
8650 if (!(sect->flags & SEC_RELOC))
8651 continue;
8652
8653 nds32_get_section_contents (abfd, sect, &contents);
8654
8655 for (irel = internal_relocs; irel < irelend; irel++)
8656 {
8657 bfd_vma raddr;
8658
8659 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_DIFF8
8660 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_DIFF32
8661 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
8662 {
8663 unsigned long val = 0;
8664 unsigned long mask;
8665 long before, between;
8666 long offset;
8667
8668 switch (ELF32_R_TYPE (irel->r_info))
8669 {
8670 case R_NDS32_DIFF8:
8671 offset = bfd_get_8 (abfd, contents + irel->r_offset);
8672 break;
8673 case R_NDS32_DIFF16:
8674 offset = bfd_get_16 (abfd, contents + irel->r_offset);
8675 break;
8676 case R_NDS32_DIFF32:
8677 val = bfd_get_32 (abfd, contents + irel->r_offset);
8678 /* Get the signed bit and mask for the high part. The
8679 gcc will alarm when right shift 32-bit since the
8680 type size of long may be 32-bit. */
8681 mask = 0 - (val >> 31);
8682 if (mask)
8683 offset = (val | (mask - 0xffffffff));
8684 else
8685 offset = val;
8686 break;
8687 default:
8688 BFD_ASSERT (0);
8689 }
8690
8691 /* DIFF value
8692 0 |encoded in location|
8693 |------------|-------------------|---------
8694 sym+off(addend)
8695 -- before ---| *****************
8696 --------------------- between ---|
8697
8698 We only care how much data are relax between DIFF,
8699 marked as ***. */
8700
8701 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
8702 between = get_nds32_elf_blank_total (&blank_t,
8703 irel->r_addend + offset, 0);
8704 if (between == before)
8705 goto done_adjust_diff;
8706
8707 switch (ELF32_R_TYPE (irel->r_info))
8708 {
8709 case R_NDS32_DIFF8:
8710 bfd_put_8 (abfd, offset - (between - before),
8711 contents + irel->r_offset);
8712 break;
8713 case R_NDS32_DIFF16:
8714 bfd_put_16 (abfd, offset - (between - before),
8715 contents + irel->r_offset);
8716 break;
8717 case R_NDS32_DIFF32:
8718 bfd_put_32 (abfd, offset - (between - before),
8719 contents + irel->r_offset);
8720 break;
8721 }
8722 }
8723 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_DIFF_ULEB128
8724 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
8725 {
8726 bfd_vma val = 0;
8727 unsigned int len = 0;
8728 unsigned long before, between;
8729 bfd_byte *endp, *p;
8730
8731 val = read_unsigned_leb128 (abfd, contents + irel->r_offset,
8732 &len);
8733
8734 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
8735 between = get_nds32_elf_blank_total (&blank_t,
8736 irel->r_addend + val, 0);
8737 if (between == before)
8738 goto done_adjust_diff;
8739
8740 p = contents + irel->r_offset;
8741 endp = p + len -1;
8742 memset (p, 0x80, len);
8743 *(endp) = 0;
8744 p = write_uleb128 (p, val - (between - before)) - 1;
8745 if (p < endp)
8746 *p |= 0x80;
8747 }
8748 done_adjust_diff:
8749
8750 if (sec == sect)
8751 {
8752 raddr = irel->r_offset;
8753 irel->r_offset -= get_nds32_elf_blank_total (&blank_t2,
8754 irel->r_offset, 1);
8755
8756 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
8757 continue;
8758 if (blank_t2 && blank_t2->next
8759 && (blank_t2->offset > raddr
8760 || blank_t2->next->offset <= raddr))
8761 (*_bfd_error_handler)
8762 (_("%B: %s\n"), abfd,
8763 "Error: search_nds32_elf_blank reports wrong node");
8764
8765 /* Mark reloc in deleted portion as NONE.
8766 For some relocs like R_NDS32_LABEL that doesn't modify the
8767 content in the section. R_NDS32_LABEL doesn't belong to the
8768 instruction in the section, so we should preserve it. */
8769 if (raddr >= blank_t2->offset
8770 && raddr < blank_t2->offset + blank_t2->size
8771 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL
8772 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_BEGIN
8773 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
8774 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
8775 && ELF32_R_TYPE (irel->r_info) != R_NDS32_SUBTRAHEND
8776 && ELF32_R_TYPE (irel->r_info) != R_NDS32_MINUEND)
8777 {
8778 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
8779 R_NDS32_NONE);
8780 continue;
8781 }
8782 }
8783
8784 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE
8785 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
8786 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
8787 continue;
8788
8789 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info
8790 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx
8791 && ELF_ST_TYPE (isym[ELF32_R_SYM (irel->r_info)].st_info) == STT_SECTION)
8792 {
8793 if (irel->r_addend <= sec->size)
8794 irel->r_addend -=
8795 get_nds32_elf_blank_total (&blank_t, irel->r_addend, 1);
8796 }
8797 }
8798 }
8799
8800 /* Adjust the local symbols defined in this section. */
8801 blank_t = blank_head;
8802 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
8803 {
8804 if (isym->st_shndx == sec_shndx)
8805 {
8806 if (isym->st_value <= sec->size)
8807 {
8808 bfd_vma ahead;
8809 bfd_vma orig_addr = isym->st_value;
8810
8811 ahead = get_nds32_elf_blank_total (&blank_t, isym->st_value, 1);
8812 isym->st_value -= ahead;
8813
8814 /* Adjust function size. */
8815 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC
8816 && isym->st_size > 0)
8817 isym->st_size -=
8818 get_nds32_elf_blank_total
8819 (&blank_t, orig_addr + isym->st_size, 0) - ahead;
8820 }
8821 }
8822 }
8823
8824 /* Now adjust the global symbols defined in this section. */
8825 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
8826 - symtab_hdr->sh_info);
8827 sym_hashes = elf_sym_hashes (abfd);
8828 end_hashes = sym_hashes + symcount;
8829 blank_t = blank_head;
8830 for (; sym_hashes < end_hashes; sym_hashes++)
8831 {
8832 struct elf_link_hash_entry *sym_hash = *sym_hashes;
8833
8834 if ((sym_hash->root.type == bfd_link_hash_defined
8835 || sym_hash->root.type == bfd_link_hash_defweak)
8836 && sym_hash->root.u.def.section == sec)
8837 {
8838 if (sym_hash->root.u.def.value <= sec->size)
8839 {
8840 bfd_vma ahead;
8841 bfd_vma orig_addr = sym_hash->root.u.def.value;
8842
8843 ahead = get_nds32_elf_blank_total (&blank_t, sym_hash->root.u.def.value, 1);
8844 sym_hash->root.u.def.value -= ahead;
8845
8846 /* Adjust function size. */
8847 if (sym_hash->type == STT_FUNC)
8848 sym_hash->size -=
8849 get_nds32_elf_blank_total
8850 (&blank_t, orig_addr + sym_hash->size, 0) - ahead;
8851
8852 }
8853 }
8854 }
8855
8856 contents = elf_section_data (sec)->this_hdr.contents;
8857 blank_t = blank_head;
8858 while (blank_t->next)
8859 {
8860 /* Actually delete the bytes. */
8861
8862 /* If current blank is the last blank overlap with current section,
8863 go to finish process. */
8864 if (sec->size <= (blank_t->next->offset))
8865 break;
8866
8867 memmove (contents + blank_t->offset - blank_t->total_size,
8868 contents + blank_t->offset + blank_t->size,
8869 blank_t->next->offset - (blank_t->offset + blank_t->size));
8870
8871 blank_t = blank_t->next;
8872 }
8873
8874 if (sec->size > (blank_t->offset + blank_t->size))
8875 {
8876 /* There are remaining code between blank and section boundary.
8877 Move the remaining code to appropriate location. */
8878 memmove (contents + blank_t->offset - blank_t->total_size,
8879 contents + blank_t->offset + blank_t->size,
8880 sec->size - (blank_t->offset + blank_t->size));
8881 sec->size -= blank_t->total_size + blank_t->size;
8882 }
8883 else
8884 /* This blank is not entirely included in the section,
8885 reduce the section size by only part of the blank size. */
8886 sec->size -= blank_t->total_size + (sec->size - blank_t->offset);
8887
8888 while (blank_head)
8889 {
8890 blank_t = blank_head;
8891 blank_head = blank_head->next;
8892 remove_nds32_elf_blank (blank_t);
8893 }
8894
8895 return TRUE;
8896 }
8897
8898 /* Get the contents of a section. */
8899
8900 static int
nds32_get_section_contents(bfd * abfd,asection * sec,bfd_byte ** contents_p)8901 nds32_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents_p)
8902 {
8903 /* Get the section contents. */
8904 if (elf_section_data (sec)->this_hdr.contents != NULL)
8905 *contents_p = elf_section_data (sec)->this_hdr.contents;
8906 else
8907 {
8908 if (!bfd_malloc_and_get_section (abfd, sec, contents_p))
8909 return FALSE;
8910 elf_section_data (sec)->this_hdr.contents = *contents_p;
8911 }
8912
8913 return TRUE;
8914 }
8915
8916 /* Get the contents of the internal symbol of abfd. */
8917
8918 static int
nds32_get_local_syms(bfd * abfd,asection * sec ATTRIBUTE_UNUSED,Elf_Internal_Sym ** isymbuf_p)8919 nds32_get_local_syms (bfd *abfd, asection *sec ATTRIBUTE_UNUSED,
8920 Elf_Internal_Sym **isymbuf_p)
8921 {
8922 Elf_Internal_Shdr *symtab_hdr;
8923 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8924
8925 /* Read this BFD's local symbols if we haven't done so already. */
8926 if (*isymbuf_p == NULL && symtab_hdr->sh_info != 0)
8927 {
8928 *isymbuf_p = (Elf_Internal_Sym *) symtab_hdr->contents;
8929 if (*isymbuf_p == NULL)
8930 {
8931 *isymbuf_p = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8932 symtab_hdr->sh_info, 0,
8933 NULL, NULL, NULL);
8934 if (*isymbuf_p == NULL)
8935 return FALSE;
8936 }
8937 }
8938 symtab_hdr->contents = (bfd_byte *) (*isymbuf_p);
8939
8940 return TRUE;
8941 }
8942
8943 /* Range of small data. */
8944 static bfd_vma sdata_range[2][2];
8945 static bfd_vma const sdata_init_range[2] =
8946 { ACCURATE_12BIT_S1, ACCURATE_19BIT };
8947
8948 static int
nds32_elf_insn_size(bfd * abfd ATTRIBUTE_UNUSED,bfd_byte * contents,bfd_vma addr)8949 nds32_elf_insn_size (bfd *abfd ATTRIBUTE_UNUSED,
8950 bfd_byte *contents, bfd_vma addr)
8951 {
8952 unsigned long insn = bfd_getb32 (contents + addr);
8953
8954 if (insn & 0x80000000)
8955 return 2;
8956
8957 return 4;
8958 }
8959
8960 /* Set the gp relax range. We have to measure the safe range
8961 to do gp relaxation. */
8962
8963 static void
relax_range_measurement(bfd * abfd)8964 relax_range_measurement (bfd *abfd)
8965 {
8966 asection *sec_f, *sec_b;
8967 /* For upper bound. */
8968 bfd_vma maxpgsz = get_elf_backend_data (abfd)->maxpagesize;
8969 bfd_vma align;
8970 static int decide_relax_range = 0;
8971 int i;
8972 int range_number = sizeof (sdata_init_range) / sizeof (sdata_init_range[0]);
8973
8974 if (decide_relax_range)
8975 return;
8976 decide_relax_range = 1;
8977
8978 if (sda_rela_sec == NULL)
8979 {
8980 /* Since there is no data sections, we assume the range is page size. */
8981 for (i = 0; i < range_number; i++)
8982 {
8983 sdata_range[i][0] = sdata_init_range[i] - 0x1000;
8984 sdata_range[i][1] = sdata_init_range[i] - 0x1000;
8985 }
8986 return;
8987 }
8988
8989 /* Get the biggest alignment power after the gp located section. */
8990 sec_f = sda_rela_sec->output_section;
8991 sec_b = sec_f->next;
8992 align = 0;
8993 while (sec_b != NULL)
8994 {
8995 if ((unsigned)(1 << sec_b->alignment_power) > align)
8996 align = (1 << sec_b->alignment_power);
8997 sec_b = sec_b->next;
8998 }
8999
9000 /* I guess we can not determine the section before
9001 gp located section, so we assume the align is max page size. */
9002 for (i = 0; i < range_number; i++)
9003 {
9004 sdata_range[i][1] = sdata_init_range[i] - align;
9005 BFD_ASSERT (sdata_range[i][1] <= sdata_init_range[i]);
9006 sdata_range[i][0] = sdata_init_range[i] - maxpgsz;
9007 BFD_ASSERT (sdata_range[i][0] <= sdata_init_range[i]);
9008 }
9009 }
9010
9011 /* These are macros used to check flags encoded in r_addend.
9012 They are only used by nds32_elf_relax_section (). */
9013 #define GET_SEQ_LEN(addend) ((addend) & 0x000000ff)
9014 #define IS_1ST_CONVERT(addend) ((addend) & 0x80000000)
9015 #define IS_OPTIMIZE(addend) ((addend) & 0x40000000)
9016 #define IS_16BIT_ON(addend) ((addend) & 0x20000000)
9017
9018 /* Relax LONGCALL1 relocation for nds32_elf_relax_section. */
9019
9020 static bfd_boolean
nds32_elf_relax_longcall1(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)9021 nds32_elf_relax_longcall1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9022 Elf_Internal_Rela *internal_relocs, int *insn_len,
9023 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9024 Elf_Internal_Shdr *symtab_hdr)
9025 {
9026 /* There are 3 variations for LONGCALL1
9027 case 4-4-2; 16-bit on, optimize off or optimize for space
9028 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9029 ori ta, ta, lo12(symbol) ; LO12S0
9030 jral5 ta ;
9031
9032 case 4-4-4; 16-bit off, optimize don't care
9033 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9034 ori ta, ta, lo12(symbol) ; LO12S0
9035 jral ta ;
9036
9037 case 4-4-4; 16-bit on, optimize for speed
9038 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9039 ori ta, ta, lo12(symbol) ; LO12S0
9040 jral ta ;
9041 Check code for -mlong-calls output. */
9042
9043 /* Get the reloc for the address from which the register is
9044 being loaded. This reloc will tell us which function is
9045 actually being called. */
9046
9047 bfd_vma laddr;
9048 int seq_len; /* Original length of instruction sequence. */
9049 uint32_t insn;
9050 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9051 int pic_ext_target = 0;
9052 bfd_signed_vma foff;
9053 uint16_t insn16;
9054
9055 irelend = internal_relocs + sec->reloc_count;
9056 seq_len = GET_SEQ_LEN (irel->r_addend);
9057 laddr = irel->r_offset;
9058 *insn_len = seq_len;
9059
9060 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9061 R_NDS32_HI20_RELA, laddr);
9062 lo_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9063 R_NDS32_LO12S0_ORI_RELA,
9064 laddr + 4);
9065
9066 if (hi_irelfn == irelend || lo_irelfn == irelend)
9067 {
9068 (*_bfd_error_handler)
9069 ("%B: warning: R_NDS32_LONGCALL1 points to unrecognized"
9070 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9071 return FALSE;
9072 }
9073
9074 /* Get the value of the symbol referred to by the reloc. */
9075 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9076 &pic_ext_target);
9077
9078 /* This condition only happened when symbol is undefined. */
9079 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9080 || foff >= CONSERVATIVE_24BIT_S1)
9081 return FALSE;
9082
9083 /* Relax to: jal symbol; 25_PCREL */
9084 /* For simplicity of coding, we are going to modify the section
9085 contents, the section relocs, and the BFD symbol table. We
9086 must tell the rest of the code not to free up this
9087 information. It would be possible to instead create a table
9088 of changes which have to be made, as is done in coff-mips.c;
9089 that would be more work, but would require less memory when
9090 the linker is run. */
9091
9092 /* Replace the long call with a jal. */
9093 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9094 R_NDS32_25_PCREL_RELA);
9095 irel->r_addend = hi_irelfn->r_addend;
9096
9097 /* We don't resolve this here but resolve it in relocate_section. */
9098 insn = INSN_JAL;
9099 bfd_putb32 (insn, contents + irel->r_offset);
9100
9101 hi_irelfn->r_info =
9102 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9103 lo_irelfn->r_info =
9104 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9105 *insn_len = 4;
9106
9107 if (seq_len & 0x2)
9108 {
9109 insn16 = NDS32_NOP16;
9110 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9111 lo_irelfn->r_info =
9112 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9113 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9114 *insn_len += 2;
9115 }
9116 return TRUE;
9117 }
9118
9119 #define CONVERT_CONDITION_CALL(insn) (((insn) & 0xffff0000) ^ 0x90000)
9120 /* Relax LONGCALL2 relocation for nds32_elf_relax_section. */
9121
9122 static bfd_boolean
nds32_elf_relax_longcall2(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)9123 nds32_elf_relax_longcall2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9124 Elf_Internal_Rela *internal_relocs, int *insn_len,
9125 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9126 Elf_Internal_Shdr *symtab_hdr)
9127 {
9128 /* bltz rt, .L1 ; LONGCALL2
9129 jal symbol ; 25_PCREL
9130 .L1: */
9131
9132 /* Get the reloc for the address from which the register is
9133 being loaded. This reloc will tell us which function is
9134 actually being called. */
9135
9136 bfd_vma laddr;
9137 uint32_t insn;
9138 Elf_Internal_Rela *i1_irelfn, *cond_irelfn, *irelend;
9139 int pic_ext_target = 0;
9140 bfd_signed_vma foff;
9141
9142 irelend = internal_relocs + sec->reloc_count;
9143 laddr = irel->r_offset;
9144 i1_irelfn =
9145 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9146 R_NDS32_25_PCREL_RELA, laddr + 4);
9147
9148 if (i1_irelfn == irelend)
9149 {
9150 (*_bfd_error_handler)
9151 ("%B: warning: R_NDS32_LONGCALL2 points to unrecognized"
9152 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9153 return FALSE;
9154 }
9155
9156 insn = bfd_getb32 (contents + laddr);
9157
9158 /* Get the value of the symbol referred to by the reloc. */
9159 foff = calculate_offset (abfd, sec, i1_irelfn, isymbuf, symtab_hdr,
9160 &pic_ext_target);
9161
9162 if (foff == 0 || foff < -CONSERVATIVE_16BIT_S1
9163 || foff >= CONSERVATIVE_16BIT_S1)
9164 return FALSE;
9165
9166 /* Relax to bgezal rt, label ; 17_PCREL
9167 or bltzal rt, label ; 17_PCREL */
9168
9169 /* Convert to complimentary conditional call. */
9170 insn = CONVERT_CONDITION_CALL (insn);
9171
9172 /* For simplicity of coding, we are going to modify the section
9173 contents, the section relocs, and the BFD symbol table. We
9174 must tell the rest of the code not to free up this
9175 information. It would be possible to instead create a table
9176 of changes which have to be made, as is done in coff-mips.c;
9177 that would be more work, but would require less memory when
9178 the linker is run. */
9179
9180 /* Clean unnessary relocations. */
9181 i1_irelfn->r_info =
9182 ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info), R_NDS32_NONE);
9183 cond_irelfn =
9184 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9185 R_NDS32_17_PCREL_RELA, laddr);
9186 if (cond_irelfn != irelend)
9187 cond_irelfn->r_info =
9188 ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info), R_NDS32_NONE);
9189
9190 /* Replace the long call with a bgezal. */
9191 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info),
9192 R_NDS32_17_PCREL_RELA);
9193 irel->r_addend = i1_irelfn->r_addend;
9194
9195 bfd_putb32 (insn, contents + irel->r_offset);
9196
9197 *insn_len = 4;
9198 return TRUE;
9199 }
9200
9201 /* Relax LONGCALL3 relocation for nds32_elf_relax_section. */
9202
9203 static bfd_boolean
nds32_elf_relax_longcall3(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)9204 nds32_elf_relax_longcall3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9205 Elf_Internal_Rela *internal_relocs, int *insn_len,
9206 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9207 Elf_Internal_Shdr *symtab_hdr)
9208 {
9209 /* There are 3 variations for LONGCALL3
9210 case 4-4-4-2; 16-bit on, optimize off or optimize for space
9211 bltz rt, $1 ; LONGCALL3
9212 sethi ta, hi20(symbol) ; HI20
9213 ori ta, ta, lo12(symbol) ; LO12S0
9214 jral5 ta ;
9215 $1
9216
9217 case 4-4-4-4; 16-bit off, optimize don't care
9218 bltz rt, $1 ; LONGCALL3
9219 sethi ta, hi20(symbol) ; HI20
9220 ori ta, ta, lo12(symbol) ; LO12S0
9221 jral ta ;
9222 $1
9223
9224 case 4-4-4-4; 16-bit on, optimize for speed
9225 bltz rt, $1 ; LONGCALL3
9226 sethi ta, hi20(symbol) ; HI20
9227 ori ta, ta, lo12(symbol) ; LO12S0
9228 jral ta ;
9229 $1 */
9230
9231 /* Get the reloc for the address from which the register is
9232 being loaded. This reloc will tell us which function is
9233 actually being called. */
9234
9235 bfd_vma laddr;
9236 int seq_len; /* Original length of instruction sequence. */
9237 uint32_t insn;
9238 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9239 int pic_ext_target = 0;
9240 bfd_signed_vma foff;
9241 uint16_t insn16;
9242
9243 irelend = internal_relocs + sec->reloc_count;
9244 seq_len = GET_SEQ_LEN (irel->r_addend);
9245 laddr = irel->r_offset;
9246 *insn_len = seq_len;
9247
9248 hi_irelfn =
9249 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9250 R_NDS32_HI20_RELA, laddr + 4);
9251 lo_irelfn =
9252 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9253 R_NDS32_LO12S0_ORI_RELA, laddr + 8);
9254
9255 if (hi_irelfn == irelend || lo_irelfn == irelend)
9256 {
9257 (*_bfd_error_handler)
9258 ("%B: warning: R_NDS32_LONGCALL3 points to unrecognized"
9259 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9260 return FALSE;
9261 }
9262
9263 /* Get the value of the symbol referred to by the reloc. */
9264 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9265 &pic_ext_target);
9266
9267 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9268 || foff >= CONSERVATIVE_24BIT_S1)
9269 return FALSE;
9270
9271 insn = bfd_getb32 (contents + laddr);
9272 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
9273 {
9274 /* Relax to bgezal rt, label ; 17_PCREL
9275 or bltzal rt, label ; 17_PCREL */
9276
9277 /* Convert to complimentary conditional call. */
9278 insn = CONVERT_CONDITION_CALL (insn);
9279 bfd_putb32 (insn, contents + irel->r_offset);
9280
9281 *insn_len = 4;
9282 irel->r_info =
9283 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9284 hi_irelfn->r_info =
9285 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9286 lo_irelfn->r_info =
9287 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9288
9289 cond_irelfn =
9290 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9291 R_NDS32_17_PCREL_RELA, laddr);
9292 if (cond_irelfn != irelend)
9293 {
9294 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9295 R_NDS32_17_PCREL_RELA);
9296 cond_irelfn->r_addend = hi_irelfn->r_addend;
9297 }
9298
9299 if (seq_len & 0x2)
9300 {
9301 insn16 = NDS32_NOP16;
9302 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9303 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9304 R_NDS32_INSN16);
9305 hi_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9306 insn_len += 2;
9307 }
9308 }
9309 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
9310 {
9311 /* Relax to the following instruction sequence
9312 bltz rt, $1 ; LONGCALL2
9313 jal symbol ; 25_PCREL
9314 $1 */
9315 *insn_len = 8;
9316 insn = INSN_JAL;
9317 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9318
9319 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9320 R_NDS32_25_PCREL_RELA);
9321 irel->r_info =
9322 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL2);
9323
9324 lo_irelfn->r_info =
9325 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9326
9327 if (seq_len & 0x2)
9328 {
9329 insn16 = NDS32_NOP16;
9330 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9331 lo_irelfn->r_info =
9332 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9333 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9334 insn_len += 2;
9335 }
9336 }
9337 return TRUE;
9338 }
9339
9340 /* Relax LONGJUMP1 relocation for nds32_elf_relax_section. */
9341
9342 static bfd_boolean
nds32_elf_relax_longjump1(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)9343 nds32_elf_relax_longjump1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9344 Elf_Internal_Rela *internal_relocs, int *insn_len,
9345 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9346 Elf_Internal_Shdr *symtab_hdr)
9347 {
9348 /* There are 3 variations for LONGJUMP1
9349 case 4-4-2; 16-bit bit on, optimize off or optimize for space
9350 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9351 ori ta, ta, lo12(symbol) ; LO12S0
9352 jr5 ta ;
9353
9354 case 4-4-4; 16-bit off, optimize don't care
9355 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9356 ori ta, ta, lo12(symbol) ; LO12S0
9357 jr ta ;
9358
9359 case 4-4-4; 16-bit on, optimize for speed
9360 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9361 ori ta, ta, lo12(symbol) ; LO12S0
9362 jr ta ; */
9363
9364 /* Get the reloc for the address from which the register is
9365 being loaded. This reloc will tell us which function is
9366 actually being called. */
9367
9368 bfd_vma laddr;
9369 int seq_len; /* Original length of instruction sequence. */
9370 int insn16_on; /* 16-bit on/off. */
9371 uint32_t insn;
9372 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9373 int pic_ext_target = 0;
9374 bfd_signed_vma foff;
9375 uint16_t insn16;
9376 unsigned long reloc;
9377
9378 irelend = internal_relocs + sec->reloc_count;
9379 seq_len = GET_SEQ_LEN (irel->r_addend);
9380 laddr = irel->r_offset;
9381 *insn_len = seq_len;
9382 insn16_on = IS_16BIT_ON (irel->r_addend);
9383
9384 hi_irelfn =
9385 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9386 R_NDS32_HI20_RELA, laddr);
9387 lo_irelfn =
9388 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9389 R_NDS32_LO12S0_ORI_RELA, laddr + 4);
9390 if (hi_irelfn == irelend || lo_irelfn == irelend)
9391 {
9392 (*_bfd_error_handler)
9393 ("%B: warning: R_NDS32_LONGJUMP1 points to unrecognized"
9394 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9395 return FALSE;
9396 }
9397
9398 /* Get the value of the symbol referred to by the reloc. */
9399 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9400 &pic_ext_target);
9401
9402 if (pic_ext_target || foff == 0 || foff >= CONSERVATIVE_24BIT_S1
9403 || foff < -CONSERVATIVE_24BIT_S1)
9404 return FALSE;
9405
9406 if (insn16_on && foff >= -ACCURATE_8BIT_S1
9407 && foff < ACCURATE_8BIT_S1 && (seq_len & 0x2))
9408 {
9409 /* j8 label */
9410 /* 16-bit on, but not optimized for speed. */
9411 reloc = R_NDS32_9_PCREL_RELA;
9412 insn16 = INSN_J8;
9413 bfd_putb16 (insn16, contents + irel->r_offset);
9414 *insn_len = 2;
9415 irel->r_info =
9416 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
9417 }
9418 else
9419 {
9420 /* j label */
9421 reloc = R_NDS32_25_PCREL_RELA;
9422 insn = INSN_J;
9423 bfd_putb32 (insn, contents + irel->r_offset);
9424 *insn_len = 4;
9425 irel->r_info =
9426 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_INSN16);
9427 irel->r_addend = 0;
9428 }
9429
9430 hi_irelfn->r_info =
9431 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
9432 lo_irelfn->r_info =
9433 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9434
9435 if ((seq_len & 0x2) && ((*insn_len & 2) == 0))
9436 {
9437 insn16 = NDS32_NOP16;
9438 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9439 lo_irelfn->r_info =
9440 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9441 R_NDS32_INSN16);
9442 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9443 *insn_len += 2;
9444 }
9445 return TRUE;
9446 }
9447
9448 /* Revert condition branch. This function does not check if the input
9449 instruction is condition branch or not. */
9450
9451 static void
nds32_elf_convert_branch(uint16_t insn16,uint32_t insn,uint16_t * re_insn16,uint32_t * re_insn)9452 nds32_elf_convert_branch (uint16_t insn16, uint32_t insn,
9453 uint16_t *re_insn16, uint32_t *re_insn)
9454 {
9455 uint32_t comp_insn = 0;
9456 uint16_t comp_insn16 = 0;
9457
9458 if (insn)
9459 {
9460 if (N32_OP6 (insn) == N32_OP6_BR1)
9461 {
9462 /* beqs label. */
9463 comp_insn = (insn ^ 0x4000) & 0xffffc000;
9464 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5)
9465 {
9466 /* Insn can be contracted to 16-bit implied r5. */
9467 comp_insn16 =
9468 (comp_insn & 0x4000) ? INSN_BNES38 : INSN_BEQS38;
9469 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
9470 }
9471 }
9472 else if (N32_OP6 (insn) == N32_OP6_BR3)
9473 {
9474 /* bnec $ta, imm11, label. */
9475 comp_insn = (insn ^ 0x80000) & 0xffffff00;
9476 }
9477 else
9478 {
9479 comp_insn = (insn ^ 0x10000) & 0xffffc000;
9480 if (N32_BR2_SUB (insn) == N32_BR2_BEQZ
9481 || N32_BR2_SUB (insn) == N32_BR2_BNEZ)
9482 {
9483 if (N32_IS_RT3 (insn))
9484 {
9485 /* Insn can be contracted to 16-bit. */
9486 comp_insn16 =
9487 (comp_insn & 0x10000) ? INSN_BNEZ38 : INSN_BEQZ38;
9488 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
9489 }
9490 else if (N32_RT5 (insn) == REG_R15)
9491 {
9492 /* Insn can be contracted to 16-bit. */
9493 comp_insn16 =
9494 (comp_insn & 0x10000) ? INSN_BNES38 : INSN_BEQS38;
9495 }
9496 }
9497 }
9498 }
9499 else
9500 {
9501 switch ((insn16 & 0xf000) >> 12)
9502 {
9503 case 0xc:
9504 /* beqz38 or bnez38 */
9505 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
9506 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNEZ : INSN_BEQZ;
9507 comp_insn |= ((comp_insn16 & 0x0700) >> 8) << 20;
9508 break;
9509
9510 case 0xd:
9511 /* beqs38 or bnes38 */
9512 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
9513 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNE : INSN_BEQ;
9514 comp_insn |= (((comp_insn16 & 0x0700) >> 8) << 20)
9515 | (REG_R5 << 15);
9516 break;
9517
9518 case 0xe:
9519 /* beqzS8 or bnezS8 */
9520 comp_insn16 = (insn16 ^ 0x0100) & 0xff00;
9521 comp_insn = (comp_insn16 & 0x0100) ? INSN_BNEZ : INSN_BEQZ;
9522 comp_insn |= REG_R15 << 20;
9523 break;
9524
9525 default:
9526 break;
9527 }
9528 }
9529 if (comp_insn && re_insn)
9530 *re_insn = comp_insn;
9531 if (comp_insn16 && re_insn16)
9532 *re_insn16 = comp_insn16;
9533 }
9534
9535 /* Relax LONGJUMP2 relocation for nds32_elf_relax_section. */
9536
9537 static bfd_boolean
nds32_elf_relax_longjump2(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)9538 nds32_elf_relax_longjump2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9539 Elf_Internal_Rela *internal_relocs, int *insn_len,
9540 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9541 Elf_Internal_Shdr *symtab_hdr)
9542 {
9543 /* There are 3 variations for LONGJUMP2
9544 case 2-4; 1st insn convertible, 16-bit on,
9545 optimize off or optimize for space
9546 bnes38 rt, ra, $1 ; LONGJUMP2
9547 j label ; 25_PCREL
9548 $1:
9549
9550 case 4-4; 1st insn not convertible
9551 bne rt, ra, $1 ; LONGJUMP2
9552 j label ; 25_PCREL
9553 $1:
9554
9555 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
9556 bne rt, ra, $1 ; LONGJUMP2
9557 j label ; 25_PCREL
9558 $1: */
9559
9560 /* Get the reloc for the address from which the register is
9561 being loaded. This reloc will tell us which function is
9562 actually being called. */
9563
9564 bfd_vma laddr;
9565 int seq_len; /* Original length of instruction sequence. */
9566 Elf_Internal_Rela *i2_irelfn, *cond_irelfn, *irelend;
9567 int pic_ext_target = 0, first_size;
9568 unsigned int i;
9569 bfd_signed_vma foff;
9570 uint32_t insn, re_insn = 0;
9571 uint16_t insn16, re_insn16 = 0;
9572 unsigned long reloc, cond_reloc;
9573
9574 enum elf_nds32_reloc_type checked_types[] =
9575 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
9576
9577 irelend = internal_relocs + sec->reloc_count;
9578 seq_len = GET_SEQ_LEN (irel->r_addend);
9579 laddr = irel->r_offset;
9580 *insn_len = seq_len;
9581 first_size = (seq_len == 6) ? 2 : 4;
9582
9583 i2_irelfn =
9584 find_relocs_at_address_addr (irel, internal_relocs,
9585 irelend, R_NDS32_25_PCREL_RELA,
9586 laddr + first_size);
9587
9588 for (i = 0; i < sizeof (checked_types) / sizeof(checked_types[0]); i++)
9589 {
9590 cond_irelfn =
9591 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9592 checked_types[i], laddr);
9593 if (cond_irelfn != irelend)
9594 break;
9595 }
9596
9597 if (i2_irelfn == irelend || cond_irelfn == irelend)
9598 {
9599 (*_bfd_error_handler)
9600 ("%B: warning: R_NDS32_LONGJUMP2 points to unrecognized"
9601 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9602 return FALSE;
9603 }
9604
9605 /* Get the value of the symbol referred to by the reloc. */
9606 foff =
9607 calculate_offset (abfd, sec, i2_irelfn, isymbuf, symtab_hdr,
9608 &pic_ext_target);
9609 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_16BIT_S1
9610 || foff >= CONSERVATIVE_16BIT_S1)
9611 return FALSE;
9612
9613 /* Get the all corresponding instructions. */
9614 if (first_size == 4)
9615 {
9616 insn = bfd_getb32 (contents + laddr);
9617 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
9618 }
9619 else
9620 {
9621 insn16 = bfd_getb16 (contents + laddr);
9622 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
9623 }
9624
9625 if (re_insn16 && foff >= -(ACCURATE_8BIT_S1 - first_size)
9626 && foff < ACCURATE_8BIT_S1 - first_size)
9627 {
9628 if (first_size == 4)
9629 {
9630 /* Don't convert it to 16-bit now, keep this as relaxable for
9631 ``label reloc; INSN16''. */
9632
9633 /* Save comp_insn32 to buffer. */
9634 bfd_putb32 (re_insn, contents + irel->r_offset);
9635 *insn_len = 4;
9636 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
9637 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
9638 cond_reloc = R_NDS32_INSN16;
9639 }
9640 else
9641 {
9642 bfd_putb16 (re_insn16, contents + irel->r_offset);
9643 *insn_len = 2;
9644 reloc = R_NDS32_9_PCREL_RELA;
9645 cond_reloc = R_NDS32_NONE;
9646 }
9647 }
9648 else if (N32_OP6 (re_insn) == N32_OP6_BR1
9649 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
9650 && foff < ACCURATE_14BIT_S1 - first_size))
9651 {
9652 /* beqs label ; 15_PCREL */
9653 bfd_putb32 (re_insn, contents + irel->r_offset);
9654 *insn_len = 4;
9655 reloc = R_NDS32_15_PCREL_RELA;
9656 cond_reloc = R_NDS32_NONE;
9657 }
9658 else if (N32_OP6 (re_insn) == N32_OP6_BR2
9659 && foff >= -CONSERVATIVE_16BIT_S1
9660 && foff < CONSERVATIVE_16BIT_S1)
9661 {
9662 /* beqz label ; 17_PCREL */
9663 bfd_putb32 (re_insn, contents + irel->r_offset);
9664 *insn_len = 4;
9665 reloc = R_NDS32_17_PCREL_RELA;
9666 cond_reloc = R_NDS32_NONE;
9667 }
9668 else
9669 return FALSE;
9670
9671 /* Set all relocations. */
9672 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info), reloc);
9673 irel->r_addend = i2_irelfn->r_addend;
9674
9675 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
9676 cond_reloc);
9677 cond_irelfn->r_addend = 0;
9678
9679 if ((seq_len ^ *insn_len ) & 0x2)
9680 {
9681 insn16 = NDS32_NOP16;
9682 bfd_putb16 (insn16, contents + irel->r_offset + 4);
9683 i2_irelfn->r_offset = 4;
9684 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
9685 R_NDS32_INSN16);
9686 i2_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9687 *insn_len += 2;
9688 }
9689 else
9690 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
9691 R_NDS32_NONE);
9692 return TRUE;
9693 }
9694
9695 /* Relax LONGJUMP3 relocation for nds32_elf_relax_section. */
9696
9697 static bfd_boolean
nds32_elf_relax_longjump3(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)9698 nds32_elf_relax_longjump3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9699 Elf_Internal_Rela *internal_relocs, int *insn_len,
9700 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9701 Elf_Internal_Shdr *symtab_hdr)
9702 {
9703 /* There are 5 variations for LONGJUMP3
9704 case 1: 2-4-4-2; 1st insn convertible, 16-bit on,
9705 optimize off or optimize for space
9706 bnes38 rt, ra, $1 ; LONGJUMP3
9707 sethi ta, hi20(symbol) ; HI20
9708 ori ta, ta, lo12(symbol) ; LO12S0
9709 jr5 ta ;
9710 $1: ;
9711
9712 case 2: 2-4-4-2; 1st insn convertible, 16-bit on, optimize for speed
9713 bnes38 rt, ra, $1 ; LONGJUMP3
9714 sethi ta, hi20(symbol) ; HI20
9715 ori ta, ta, lo12(symbol) ; LO12S0
9716 jr5 ta ;
9717 $1: ; LABEL
9718
9719 case 3: 4-4-4-2; 1st insn not convertible, 16-bit on,
9720 optimize off or optimize for space
9721 bne rt, ra, $1 ; LONGJUMP3
9722 sethi ta, hi20(symbol) ; HI20
9723 ori ta, ta, lo12(symbol) ; LO12S0
9724 jr5 ta ;
9725 $1: ;
9726
9727 case 4: 4-4-4-4; 1st insn don't care, 16-bit off, optimize don't care
9728 16-bit off if no INSN16
9729 bne rt, ra, $1 ; LONGJUMP3
9730 sethi ta, hi20(symbol) ; HI20
9731 ori ta, ta, lo12(symbol) ; LO12S0
9732 jr ta ;
9733 $1: ;
9734
9735 case 5: 4-4-4-4; 1st insn not convertible, 16-bit on, optimize for speed
9736 16-bit off if no INSN16
9737 bne rt, ra, $1 ; LONGJUMP3
9738 sethi ta, hi20(symbol) ; HI20
9739 ori ta, ta, lo12(symbol) ; LO12S0
9740 jr ta ;
9741 $1: ; LABEL */
9742
9743 /* Get the reloc for the address from which the register is
9744 being loaded. This reloc will tell us which function is
9745 actually being called. */
9746 enum elf_nds32_reloc_type checked_types[] =
9747 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
9748
9749 int reloc_off = 0, cond_removed = 0, convertible;
9750 bfd_vma laddr;
9751 int seq_len; /* Original length of instruction sequence. */
9752 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9753 int pic_ext_target = 0, first_size;
9754 unsigned int i;
9755 bfd_signed_vma foff;
9756 uint32_t insn, re_insn = 0;
9757 uint16_t insn16, re_insn16 = 0;
9758 unsigned long reloc, cond_reloc;
9759
9760 irelend = internal_relocs + sec->reloc_count;
9761 seq_len = GET_SEQ_LEN (irel->r_addend);
9762 laddr = irel->r_offset;
9763 *insn_len = seq_len;
9764
9765 convertible = IS_1ST_CONVERT (irel->r_addend);
9766
9767 if (convertible)
9768 first_size = 2;
9769 else
9770 first_size = 4;
9771
9772 /* Get all needed relocations. */
9773 hi_irelfn =
9774 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9775 R_NDS32_HI20_RELA, laddr + first_size);
9776 lo_irelfn =
9777 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9778 R_NDS32_LO12S0_ORI_RELA,
9779 laddr + first_size + 4);
9780
9781 for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
9782 {
9783 cond_irelfn =
9784 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9785 checked_types[i], laddr);
9786 if (cond_irelfn != irelend)
9787 break;
9788 }
9789
9790 if (hi_irelfn == irelend || lo_irelfn == irelend || cond_irelfn == irelend)
9791 {
9792 (*_bfd_error_handler)
9793 ("%B: warning: R_NDS32_LONGJUMP3 points to unrecognized"
9794 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9795 return FALSE;
9796 }
9797
9798 /* Get the value of the symbol referred to by the reloc. */
9799 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9800 &pic_ext_target);
9801
9802 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9803 || foff >= CONSERVATIVE_24BIT_S1)
9804 return FALSE;
9805
9806 /* Get the all corresponding instructions. */
9807 if (first_size == 4)
9808 {
9809 insn = bfd_getb32 (contents + laddr);
9810 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
9811 }
9812 else
9813 {
9814 insn16 = bfd_getb16 (contents + laddr);
9815 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
9816 }
9817
9818 /* For simplicity of coding, we are going to modify the section
9819 contents, the section relocs, and the BFD symbol table. We
9820 must tell the rest of the code not to free up this
9821 information. It would be possible to instead create a table
9822 of changes which have to be made, as is done in coff-mips.c;
9823 that would be more work, but would require less memory when
9824 the linker is run. */
9825
9826 if (re_insn16 && foff >= -ACCURATE_8BIT_S1 - first_size
9827 && foff < ACCURATE_8BIT_S1 - first_size)
9828 {
9829 if (!(seq_len & 0x2))
9830 {
9831 /* Don't convert it to 16-bit now, keep this as relaxable
9832 for ``label reloc; INSN1a''6. */
9833 /* Save comp_insn32 to buffer. */
9834 bfd_putb32 (re_insn, contents + irel->r_offset);
9835 *insn_len = 4;
9836 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
9837 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
9838 cond_reloc = R_NDS32_INSN16;
9839 }
9840 else
9841 {
9842 /* Not optimize for speed; convert sequence to 16-bit. */
9843 /* Save comp_insn16 to buffer. */
9844 bfd_putb16 (re_insn16, contents + irel->r_offset);
9845 *insn_len = 2;
9846 reloc = R_NDS32_9_PCREL_RELA;
9847 cond_reloc = R_NDS32_NONE;
9848 }
9849 cond_removed = 1;
9850 }
9851 else if (N32_OP6 (re_insn) == N32_OP6_BR1
9852 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
9853 && foff < ACCURATE_14BIT_S1 - first_size))
9854 {
9855 /* beqs label ; 15_PCREL */
9856 bfd_putb32 (re_insn, contents + irel->r_offset);
9857 *insn_len = 4;
9858 reloc = R_NDS32_15_PCREL_RELA;
9859 cond_reloc = R_NDS32_NONE;
9860 cond_removed = 1;
9861 }
9862 else if (N32_OP6 (re_insn) == N32_OP6_BR2
9863 && foff >= -CONSERVATIVE_16BIT_S1
9864 && foff < CONSERVATIVE_16BIT_S1)
9865 {
9866 /* beqz label ; 17_PCREL */
9867 bfd_putb32 (re_insn, contents + irel->r_offset);
9868 *insn_len = 4;
9869 reloc = R_NDS32_17_PCREL_RELA;
9870 cond_reloc = R_NDS32_NONE;
9871 cond_removed = 1;
9872 }
9873 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
9874 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
9875 {
9876 /* Relax to one of the following 3 variations
9877
9878 case 2-4; 1st insn convertible, 16-bit on, optimize off or optimize
9879 for space
9880 bnes38 rt, $1 ; LONGJUMP2
9881 j label ; 25_PCREL
9882 $1
9883
9884 case 4-4; 1st insn not convertible, others don't care
9885 bne rt, ra, $1 ; LONGJUMP2
9886 j label ; 25_PCREL
9887 $1
9888
9889 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
9890 bne rt, ra, $1 ; LONGJUMP2
9891 j label ; 25_PCREL
9892 $1 */
9893
9894 /* Offset for first instruction. */
9895
9896 /* Use j label as second instruction. */
9897 *insn_len = 4 + first_size;
9898 insn = INSN_J;
9899 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9900 reloc = R_NDS32_LONGJUMP2;
9901 cond_reloc = R_NDS32_25_PLTREL;
9902 }
9903 else
9904 return FALSE;
9905
9906 if (cond_removed == 1)
9907 {
9908 /* Set all relocations. */
9909 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
9910 irel->r_addend = hi_irelfn->r_addend;
9911
9912 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
9913 cond_reloc);
9914 cond_irelfn->r_addend = 0;
9915 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9916 R_NDS32_NONE);
9917 }
9918 else
9919 {
9920 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
9921 irel->r_addend = irel->r_addend;
9922 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9923 cond_reloc);
9924 }
9925
9926 if ((seq_len ^ *insn_len ) & 0x2)
9927 {
9928 insn16 = NDS32_NOP16;
9929 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9930 lo_irelfn->r_offset = *insn_len;
9931 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9932 R_NDS32_INSN16);
9933 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9934 *insn_len += 2;
9935 }
9936 else
9937 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9938 R_NDS32_NONE);
9939 return TRUE;
9940 }
9941
9942 /* Relax LONGCALL4 relocation for nds32_elf_relax_section. */
9943
9944 static bfd_boolean
nds32_elf_relax_longcall4(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)9945 nds32_elf_relax_longcall4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9946 Elf_Internal_Rela *internal_relocs, int *insn_len,
9947 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9948 Elf_Internal_Shdr *symtab_hdr)
9949 {
9950 /* The pattern for LONGCALL4. Support for function cse.
9951 sethi ta, hi20(symbol) ; LONGCALL4/HI20
9952 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
9953 jral ta ; PTR_RES/EMPTY/INSN16 */
9954
9955 bfd_vma laddr;
9956 uint32_t insn;
9957 Elf_Internal_Rela *hi_irel, *ptr_irel, *insn_irel, *em_irel, *call_irel;
9958 Elf_Internal_Rela *irelend;
9959 int pic_ext_target = 0;
9960 bfd_signed_vma foff;
9961
9962 irelend = internal_relocs + sec->reloc_count;
9963 laddr = irel->r_offset;
9964
9965 /* Get the reloc for the address from which the register is
9966 being loaded. This reloc will tell us which function is
9967 actually being called. */
9968 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9969 R_NDS32_HI20_RELA, laddr);
9970
9971 if (hi_irel == irelend)
9972 {
9973 (*_bfd_error_handler)
9974 ("%B: warning: R_NDS32_LONGCALL4 points to unrecognized"
9975 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9976 return FALSE;
9977 }
9978
9979 /* Get the value of the symbol referred to by the reloc. */
9980 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr,
9981 &pic_ext_target);
9982
9983 /* This condition only happened when symbol is undefined. */
9984 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9985 || foff >= CONSERVATIVE_24BIT_S1)
9986 return FALSE;
9987
9988 /* Relax to: jal symbol; 25_PCREL */
9989 /* For simplicity of coding, we are going to modify the section
9990 contents, the section relocs, and the BFD symbol table. We
9991 must tell the rest of the code not to free up this
9992 information. It would be possible to instead create a table
9993 of changes which have to be made, as is done in coff-mips.c;
9994 that would be more work, but would require less memory when
9995 the linker is run. */
9996
9997 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9998 R_NDS32_PTR_RESOLVED, irel->r_addend);
9999 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10000 R_NDS32_EMPTY, irel->r_addend);
10001
10002 if (ptr_irel == irelend || em_irel == irelend)
10003 {
10004 (*_bfd_error_handler)
10005 ("%B: warning: R_NDS32_LONGCALL4 points to unrecognized"
10006 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10007 return FALSE;
10008 }
10009 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10010 insn = bfd_getb32 (contents + irel->r_addend);
10011 if (insn & 0x80000000)
10012 return FALSE;
10013
10014 /* Replace the long call with a jal. */
10015 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10016 R_NDS32_25_PCREL_RELA);
10017 ptr_irel->r_addend = 1;
10018
10019 /* We don't resolve this here but resolve it in relocate_section. */
10020 insn = INSN_JAL;
10021 bfd_putb32 (insn, contents + em_irel->r_offset);
10022
10023 irel->r_info =
10024 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10025
10026 /* If there is function cse, HI20 can not remove now. */
10027 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10028 R_NDS32_LONGCALL4, laddr);
10029 if (call_irel == irelend)
10030 {
10031 *insn_len = 0;
10032 hi_irel->r_info =
10033 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10034 }
10035
10036 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10037 R_NDS32_INSN16, irel->r_addend);
10038 if (insn_irel != irelend)
10039 insn_irel->r_info =
10040 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10041
10042 return TRUE;
10043 }
10044
10045 /* Relax LONGCALL5 relocation for nds32_elf_relax_section. */
10046
10047 static bfd_boolean
nds32_elf_relax_longcall5(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)10048 nds32_elf_relax_longcall5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10049 Elf_Internal_Rela *internal_relocs, int *insn_len,
10050 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10051 Elf_Internal_Shdr *symtab_hdr)
10052 {
10053 /* The pattern for LONGCALL5.
10054 bltz rt, .L1 ; LONGCALL5/17_PCREL
10055 jal symbol ; 25_PCREL
10056 .L1: */
10057
10058 bfd_vma laddr;
10059 uint32_t insn;
10060 Elf_Internal_Rela *cond_irel, *irelend;
10061 int pic_ext_target = 0;
10062 bfd_signed_vma foff;
10063
10064 irelend = internal_relocs + sec->reloc_count;
10065 laddr = irel->r_offset;
10066 insn = bfd_getb32 (contents + laddr);
10067
10068 /* Get the reloc for the address from which the register is
10069 being loaded. This reloc will tell us which function is
10070 actually being called. */
10071 cond_irel =
10072 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10073 R_NDS32_25_PCREL_RELA, irel->r_addend);
10074 if (cond_irel == irelend)
10075 {
10076 (*_bfd_error_handler)
10077 ("%B: warning: R_NDS32_LONGCALL5 points to unrecognized"
10078 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10079 return FALSE;
10080 }
10081
10082 /* Get the value of the symbol referred to by the reloc. */
10083 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10084 &pic_ext_target);
10085
10086 if (foff == 0 || foff < -CONSERVATIVE_16BIT_S1
10087 || foff >= CONSERVATIVE_16BIT_S1)
10088 return FALSE;
10089
10090 /* Relax to bgezal rt, label ; 17_PCREL
10091 or bltzal rt, label ; 17_PCREL */
10092
10093 /* Convert to complimentary conditional call. */
10094 insn = CONVERT_CONDITION_CALL (insn);
10095
10096 /* For simplicity of coding, we are going to modify the section
10097 contents, the section relocs, and the BFD symbol table. We
10098 must tell the rest of the code not to free up this
10099 information. It would be possible to instead create a table
10100 of changes which have to be made, as is done in coff-mips.c;
10101 that would be more work, but would require less memory when
10102 the linker is run. */
10103
10104 /* Modify relocation and contents. */
10105 cond_irel->r_info =
10106 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_17_PCREL_RELA);
10107
10108 /* Replace the long call with a bgezal. */
10109 bfd_putb32 (insn, contents + cond_irel->r_offset);
10110 *insn_len = 0;
10111
10112 /* Clean unnessary relocations. */
10113 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10114
10115 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10116 R_NDS32_17_PCREL_RELA, laddr);
10117 cond_irel->r_info =
10118 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10119
10120 return TRUE;
10121 }
10122
10123 /* Relax LONGCALL6 relocation for nds32_elf_relax_section. */
10124
10125 static bfd_boolean
nds32_elf_relax_longcall6(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)10126 nds32_elf_relax_longcall6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10127 Elf_Internal_Rela *internal_relocs, int *insn_len,
10128 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10129 Elf_Internal_Shdr *symtab_hdr)
10130 {
10131 /* The pattern for LONGCALL6.
10132 bltz rt, .L1 ; LONGCALL6/17_PCREL
10133 sethi ta, hi20(symbol) ; HI20/PTR
10134 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10135 jral ta ; PTR_RES/EMPTY/INSN16
10136 .L1 */
10137
10138 bfd_vma laddr;
10139 uint32_t insn;
10140 Elf_Internal_Rela *em_irel, *cond_irel, *irelend;
10141 int pic_ext_target = 0;
10142 bfd_signed_vma foff;
10143
10144 irelend = internal_relocs + sec->reloc_count;
10145 laddr = irel->r_offset;
10146
10147 /* Get the reloc for the address from which the register is
10148 being loaded. This reloc will tell us which function is
10149 actually being called. */
10150 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10151 R_NDS32_EMPTY, irel->r_addend);
10152
10153 if (em_irel == irelend)
10154 {
10155 (*_bfd_error_handler)
10156 ("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
10157 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10158 return FALSE;
10159 }
10160
10161 /* Get the value of the symbol referred to by the reloc. */
10162 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr,
10163 &pic_ext_target);
10164
10165 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10166 || foff >= CONSERVATIVE_24BIT_S1)
10167 return FALSE;
10168
10169 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10170 insn = bfd_getb32 (contents + irel->r_addend);
10171 if (insn & 0x80000000)
10172 return FALSE;
10173
10174 insn = bfd_getb32 (contents + laddr);
10175 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10176 {
10177 /* Relax to bgezal rt, label ; 17_PCREL
10178 or bltzal rt, label ; 17_PCREL */
10179
10180 /* Convert to complimentary conditional call. */
10181 *insn_len = 0;
10182 insn = CONVERT_CONDITION_CALL (insn);
10183 bfd_putb32 (insn, contents + em_irel->r_offset);
10184
10185 em_irel->r_info =
10186 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_17_PCREL_RELA);
10187
10188 /* Set resolved relocation. */
10189 cond_irel =
10190 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10191 R_NDS32_PTR_RESOLVED, irel->r_addend);
10192 if (cond_irel == irelend)
10193 {
10194 (*_bfd_error_handler)
10195 ("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
10196 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10197 return FALSE;
10198 }
10199 cond_irel->r_addend = 1;
10200
10201 /* Clear relocations. */
10202
10203 irel->r_info =
10204 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10205
10206 cond_irel =
10207 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10208 R_NDS32_17_PCREL_RELA, laddr);
10209 if (cond_irel != irelend)
10210 cond_irel->r_info =
10211 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10212
10213 cond_irel =
10214 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10215 R_NDS32_INSN16, irel->r_addend);
10216 if (cond_irel != irelend)
10217 cond_irel->r_info =
10218 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10219
10220 }
10221 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10222 {
10223 /* Relax to the following instruction sequence
10224 bltz rt, .L1 ; LONGCALL2/17_PCREL
10225 jal symbol ; 25_PCREL/PTR_RES
10226 .L1 */
10227 *insn_len = 4;
10228 /* Convert instruction. */
10229 insn = INSN_JAL;
10230 bfd_putb32 (insn, contents + em_irel->r_offset);
10231
10232 /* Convert relocations. */
10233 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10234 R_NDS32_25_PCREL_RELA);
10235 irel->r_info =
10236 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL5);
10237
10238 /* Set resolved relocation. */
10239 cond_irel =
10240 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10241 R_NDS32_PTR_RESOLVED, irel->r_addend);
10242 if (cond_irel == irelend)
10243 {
10244 (*_bfd_error_handler)
10245 ("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
10246 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10247 return FALSE;
10248 }
10249 cond_irel->r_addend = 1;
10250
10251 cond_irel =
10252 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10253 R_NDS32_INSN16, irel->r_addend);
10254 if (cond_irel != irelend)
10255 cond_irel->r_info =
10256 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10257 }
10258 return TRUE;
10259 }
10260
10261 /* Relax LONGJUMP4 relocation for nds32_elf_relax_section. */
10262
10263 static bfd_boolean
nds32_elf_relax_longjump4(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)10264 nds32_elf_relax_longjump4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10265 Elf_Internal_Rela *internal_relocs, int *insn_len,
10266 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10267 Elf_Internal_Shdr *symtab_hdr)
10268 {
10269 /* The pattern for LONGJUMP4.
10270 sethi ta, hi20(symbol) ; LONGJUMP4/HI20
10271 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10272 jr ta ; PTR_RES/INSN16/EMPTY */
10273
10274 bfd_vma laddr;
10275 int seq_len; /* Original length of instruction sequence. */
10276 uint32_t insn;
10277 Elf_Internal_Rela *hi_irel, *ptr_irel, *em_irel, *call_irel, *irelend;
10278 int pic_ext_target = 0;
10279 bfd_signed_vma foff;
10280
10281 irelend = internal_relocs + sec->reloc_count;
10282 seq_len = GET_SEQ_LEN (irel->r_addend);
10283 laddr = irel->r_offset;
10284 *insn_len = seq_len;
10285
10286 /* Get the reloc for the address from which the register is
10287 being loaded. This reloc will tell us which function is
10288 actually being called. */
10289
10290 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10291 R_NDS32_HI20_RELA, laddr);
10292
10293 if (hi_irel == irelend)
10294 {
10295 (*_bfd_error_handler)
10296 ("%B: warning: R_NDS32_LONGJUMP4 points to unrecognized"
10297 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10298 return FALSE;
10299 }
10300
10301 /* Get the value of the symbol referred to by the reloc. */
10302 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr,
10303 &pic_ext_target);
10304
10305 if (pic_ext_target || foff == 0 || foff >= CONSERVATIVE_24BIT_S1
10306 || foff < -CONSERVATIVE_24BIT_S1)
10307 return FALSE;
10308
10309 /* Convert it to "j label", it may be converted to j8 in the final
10310 pass of relaxation. Therefore, we do not consider this currently. */
10311 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10312 R_NDS32_PTR_RESOLVED, irel->r_addend);
10313 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10314 R_NDS32_EMPTY, irel->r_addend);
10315
10316 if (ptr_irel == irelend || em_irel == irelend)
10317 {
10318 (*_bfd_error_handler)
10319 ("%B: warning: R_NDS32_LONGJUMP4 points to unrecognized"
10320 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10321 return FALSE;
10322 }
10323
10324 em_irel->r_info =
10325 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_25_PCREL_RELA);
10326 ptr_irel->r_addend = 1;
10327
10328 /* Write instruction. */
10329 insn = INSN_J;
10330 bfd_putb32 (insn, contents + em_irel->r_offset);
10331
10332 /* Clear relocations. */
10333 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10334
10335 /* If there is function cse, HI20 can not remove now. */
10336 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10337 R_NDS32_LONGJUMP4, laddr);
10338 if (call_irel == irelend)
10339 {
10340 *insn_len = 0;
10341 hi_irel->r_info =
10342 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10343 }
10344
10345 return TRUE;
10346 }
10347
10348 /* Relax LONGJUMP5 relocation for nds32_elf_relax_section. */
10349
10350 static bfd_boolean
nds32_elf_relax_longjump5(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,int * seq_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)10351 nds32_elf_relax_longjump5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10352 Elf_Internal_Rela *internal_relocs, int *insn_len,
10353 int *seq_len, bfd_byte *contents,
10354 Elf_Internal_Sym *isymbuf,
10355 Elf_Internal_Shdr *symtab_hdr)
10356 {
10357 /* There are 2 variations for LONGJUMP5
10358 case 2-4; 1st insn convertible, 16-bit on.
10359 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
10360 j label ; 25_PCREL/INSN16
10361 $1:
10362
10363 case 4-4; 1st insn not convertible
10364 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
10365 j label ; 25_PCREL/INSN16
10366 .L1: */
10367
10368 bfd_vma laddr;
10369 Elf_Internal_Rela *cond_irel, *irelend;
10370 int pic_ext_target = 0;
10371 unsigned int i;
10372 bfd_signed_vma foff;
10373 uint32_t insn, re_insn = 0;
10374 uint16_t insn16, re_insn16 = 0;
10375 unsigned long reloc;
10376
10377 enum elf_nds32_reloc_type checked_types[] =
10378 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10379 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10380
10381 irelend = internal_relocs + sec->reloc_count;
10382 laddr = irel->r_offset;
10383
10384 /* Get the reloc for the address from which the register is
10385 being loaded. This reloc will tell us which function is
10386 actually being called. */
10387
10388 cond_irel =
10389 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10390 R_NDS32_25_PCREL_RELA, irel->r_addend);
10391 if (cond_irel == irelend)
10392 {
10393 (*_bfd_error_handler)
10394 ("%B: warning: R_NDS32_LONGJUMP5 points to unrecognized"
10395 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10396 return FALSE;
10397 }
10398
10399 /* Get the value of the symbol referred to by the reloc. */
10400 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10401 &pic_ext_target);
10402
10403 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_16BIT_S1
10404 || foff >= CONSERVATIVE_16BIT_S1)
10405 return FALSE;
10406
10407 /* Get the all corresponding instructions. */
10408 insn = bfd_getb32 (contents + laddr);
10409 /* Check instruction size. */
10410 if (insn & 0x80000000)
10411 {
10412 *seq_len = 0;
10413 insn16 = insn >> 16;
10414 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10415 }
10416 else
10417 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10418
10419 if (N32_OP6 (re_insn) == N32_OP6_BR1
10420 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
10421 {
10422 /* beqs label ; 15_PCREL. */
10423 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10424 reloc = R_NDS32_15_PCREL_RELA;
10425 }
10426 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10427 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10428 {
10429 /* beqz label ; 17_PCREL. */
10430 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10431 reloc = R_NDS32_17_PCREL_RELA;
10432 }
10433 else if ( N32_OP6 (re_insn) == N32_OP6_BR3
10434 && foff >= -CONSERVATIVE_8BIT_S1 && foff < CONSERVATIVE_8BIT_S1)
10435 {
10436 /* beqc label ; 9_PCREL. */
10437 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10438 reloc = R_NDS32_WORD_9_PCREL_RELA;
10439 }
10440 else
10441 return FALSE;
10442
10443 /* Set all relocations. */
10444 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), reloc);
10445
10446 /* Clean relocations. */
10447 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10448 for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
10449 {
10450 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10451 checked_types[i], laddr);
10452 if (cond_irel != irelend)
10453 {
10454 if (*seq_len == 0
10455 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
10456 {
10457 /* If the branch instruction is 2 byte, it cannot remove
10458 directly. Only convert it to nop16 and remove it after
10459 checking alignment issue. */
10460 insn16 = NDS32_NOP16;
10461 bfd_putb16 (insn16, contents + laddr);
10462 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10463 }
10464 else
10465 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10466 R_NDS32_NONE);
10467 }
10468 }
10469 *insn_len = 0;
10470
10471 return TRUE;
10472 }
10473
10474 /* Relax LONGJUMP6 relocation for nds32_elf_relax_section. */
10475
10476 static bfd_boolean
nds32_elf_relax_longjump6(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,int * seq_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)10477 nds32_elf_relax_longjump6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10478 Elf_Internal_Rela *internal_relocs, int *insn_len,
10479 int *seq_len, bfd_byte *contents,
10480 Elf_Internal_Sym *isymbuf,
10481 Elf_Internal_Shdr *symtab_hdr)
10482 {
10483 /* There are 5 variations for LONGJUMP6
10484 case : 2-4-4-4; 1st insn convertible, 16-bit on.
10485 bnes38 rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
10486 sethi ta, hi20(symbol) ; HI20/PTR
10487 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10488 jr ta ; PTR_RES/INSN16/EMPTY
10489 .L1:
10490
10491 case : 4-4-4-4; 1st insn not convertible, 16-bit on.
10492 bne rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
10493 sethi ta, hi20(symbol) ; HI20/PTR
10494 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10495 jr ta ; PTR_RES/INSN16/EMPTY
10496 .L1: */
10497
10498 enum elf_nds32_reloc_type checked_types[] =
10499 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10500 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10501
10502 int reloc_off = 0, cond_removed = 0;
10503 bfd_vma laddr;
10504 Elf_Internal_Rela *cond_irel, *em_irel, *irelend, *insn_irel;
10505 int pic_ext_target = 0;
10506 unsigned int i;
10507 bfd_signed_vma foff;
10508 uint32_t insn, re_insn = 0;
10509 uint16_t insn16, re_insn16 = 0;
10510 unsigned long reloc;
10511
10512 irelend = internal_relocs + sec->reloc_count;
10513 laddr = irel->r_offset;
10514
10515 /* Get the reloc for the address from which the register is
10516 being loaded. This reloc will tell us which function is
10517 actually being called. */
10518 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10519 R_NDS32_EMPTY, irel->r_addend);
10520
10521 if (em_irel == irelend)
10522 {
10523 (*_bfd_error_handler)
10524 ("%B: warning: R_NDS32_LONGJUMP6 points to unrecognized"
10525 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10526 return FALSE;
10527 }
10528
10529 /* Get the value of the symbol referred to by the reloc. */
10530 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr,
10531 &pic_ext_target);
10532
10533 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10534 || foff >= CONSERVATIVE_24BIT_S1)
10535 return FALSE;
10536
10537 insn = bfd_getb32 (contents + laddr);
10538 /* Check instruction size. */
10539 if (insn & 0x80000000)
10540 {
10541 *seq_len = 0;
10542 insn16 = insn >> 16;
10543 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10544 }
10545 else
10546 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10547
10548 /* For simplicity of coding, we are going to modify the section
10549 contents, the section relocs, and the BFD symbol table. We
10550 must tell the rest of the code not to free up this
10551 information. It would be possible to instead create a table
10552 of changes which have to be made, as is done in coff-mips.c;
10553 that would be more work, but would require less memory when
10554 the linker is run. */
10555
10556 if (N32_OP6 (re_insn) == N32_OP6_BR1
10557 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
10558 {
10559 /* beqs label ; 15_PCREL */
10560 bfd_putb32 (re_insn, contents + em_irel->r_offset);
10561 reloc = R_NDS32_15_PCREL_RELA;
10562 cond_removed = 1;
10563 }
10564 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10565 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10566 {
10567 /* beqz label ; 17_PCREL */
10568 bfd_putb32 (re_insn, contents + em_irel->r_offset);
10569 reloc = R_NDS32_17_PCREL_RELA;
10570 cond_removed = 1;
10571 }
10572 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
10573 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
10574 {
10575 /* Relax to one of the following 2 variations
10576
10577 case 2-4; 1st insn convertible, 16-bit on.
10578 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
10579 j label ; 25_PCREL/INSN16
10580 $1:
10581
10582 case 4-4; 1st insn not convertible
10583 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
10584 j label ; 25_PCREL/INSN16
10585 .L1: */
10586
10587 /* Use j label as second instruction. */
10588 insn = INSN_J;
10589 reloc = R_NDS32_25_PCREL_RELA;
10590 bfd_putb32 (insn, contents + em_irel->r_offset);
10591 }
10592 else
10593 return FALSE;
10594
10595 /* Set all relocations. */
10596 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), reloc);
10597
10598 cond_irel =
10599 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10600 R_NDS32_PTR_RESOLVED, em_irel->r_offset);
10601 cond_irel->r_addend = 1;
10602
10603 /* Use INSN16 of first branch instruction to distinguish if keeping
10604 INSN16 of final instruction or not. */
10605 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10606 R_NDS32_INSN16, irel->r_offset);
10607 if (insn_irel == irelend)
10608 {
10609 /* Clean the final INSN16. */
10610 insn_irel =
10611 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10612 R_NDS32_INSN16, em_irel->r_offset);
10613 insn_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10614 R_NDS32_NONE);
10615 }
10616
10617 if (cond_removed == 1)
10618 {
10619 *insn_len = 0;
10620
10621 /* Clear relocations. */
10622 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10623
10624 for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
10625 {
10626 cond_irel =
10627 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10628 checked_types[i], laddr);
10629 if (cond_irel != irelend)
10630 {
10631 if (*seq_len == 0
10632 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
10633 {
10634 /* If the branch instruction is 2 byte, it cannot remove
10635 directly. Only convert it to nop16 and remove it after
10636 checking alignment issue. */
10637 insn16 = NDS32_NOP16;
10638 bfd_putb16 (insn16, contents + laddr);
10639 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10640 }
10641 else
10642 cond_irel->r_info =
10643 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10644 }
10645 }
10646 }
10647 else
10648 {
10649 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
10650 R_NDS32_LONGJUMP5);
10651 }
10652
10653 return TRUE;
10654 }
10655
10656 /* Relax LONGJUMP7 relocation for nds32_elf_relax_section. */
10657
10658 static bfd_boolean
nds32_elf_relax_longjump7(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,int * seq_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)10659 nds32_elf_relax_longjump7 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10660 Elf_Internal_Rela *internal_relocs, int *insn_len,
10661 int *seq_len, bfd_byte *contents,
10662 Elf_Internal_Sym *isymbuf,
10663 Elf_Internal_Shdr *symtab_hdr)
10664 {
10665 /* There are 2 variations for LONGJUMP5
10666 case 2-4; 1st insn convertible, 16-bit on.
10667 movi55 ta, imm11 ; LONGJUMP7/INSN16
10668 beq rt, ta, label ; 15_PCREL
10669
10670 case 4-4; 1st insn not convertible
10671 movi55 ta, imm11 ; LONGJUMP7/INSN16
10672 beq rt, ta, label ; 15_PCREL */
10673
10674 bfd_vma laddr;
10675 Elf_Internal_Rela *cond_irel, *irelend, *insn_irel;
10676 int pic_ext_target = 0;
10677 bfd_signed_vma foff;
10678 uint32_t insn, re_insn = 0;
10679 uint16_t insn16;
10680 uint32_t imm11;
10681
10682 irelend = internal_relocs + sec->reloc_count;
10683 laddr = irel->r_offset;
10684
10685 /* Get the reloc for the address from which the register is
10686 being loaded. This reloc will tell us which function is
10687 actually being called. */
10688
10689 cond_irel =
10690 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10691 R_NDS32_15_PCREL_RELA, irel->r_addend);
10692 if (cond_irel == irelend)
10693 {
10694 (*_bfd_error_handler)
10695 ("%B: warning: R_NDS32_LONGJUMP7 points to unrecognized"
10696 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10697 return FALSE;
10698 }
10699
10700 /* Get the value of the symbol referred to by the reloc. */
10701 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10702 &pic_ext_target);
10703
10704 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_8BIT_S1
10705 || foff >= CONSERVATIVE_8BIT_S1)
10706 return FALSE;
10707
10708 /* Get the first instruction for its size. */
10709 insn = bfd_getb32 (contents + laddr);
10710 if (insn & 0x80000000)
10711 {
10712 *seq_len = 0;
10713 /* Get the immediate from movi55. */
10714 imm11 = N16_IMM5S (insn >> 16);
10715 }
10716 else
10717 {
10718 /* Get the immediate from movi. */
10719 imm11 = N32_IMM20S (insn);
10720 }
10721
10722 /* Get the branch instruction. */
10723 insn = bfd_getb32 (contents + irel->r_addend);
10724 /* Convert instruction to BR3. */
10725 if ((insn >> 14) & 0x1)
10726 re_insn = N32_BR3 (BNEC, N32_RT5 (insn), imm11, 0);
10727 else
10728 re_insn = N32_BR3 (BEQC, N32_RT5 (insn), imm11, 0);
10729
10730 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10731
10732 /* Set all relocations. */
10733 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10734 R_NDS32_WORD_9_PCREL_RELA);
10735
10736 /* Clean relocations. */
10737 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10738 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10739 R_NDS32_INSN16, irel->r_offset);
10740 if (insn_irel != irelend)
10741 {
10742 if (*seq_len == 0)
10743 {
10744 /* If the first insntruction is 16bit, convert it to nop16. */
10745 insn16 = NDS32_NOP16;
10746 bfd_putb16 (insn16, contents + laddr);
10747 insn_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10748 }
10749 else
10750 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10751 R_NDS32_NONE);
10752 }
10753 *insn_len = 0;
10754
10755 return TRUE;
10756 }
10757
10758 #define GET_LOADSTORE_RANGE(addend) (((addend) >> 8) & 0x3f)
10759
10760 /* Relax LOADSTORE relocation for nds32_elf_relax_section. */
10761
10762 static bfd_boolean
nds32_elf_relax_loadstore(struct bfd_link_info * link_info,bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr,int load_store_relax)10763 nds32_elf_relax_loadstore (struct bfd_link_info *link_info, bfd *abfd,
10764 asection *sec, Elf_Internal_Rela *irel,
10765 Elf_Internal_Rela *internal_relocs, int *insn_len,
10766 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10767 Elf_Internal_Shdr *symtab_hdr, int load_store_relax)
10768 {
10769 int eliminate_sethi = 0, range_type, i;
10770 bfd_vma local_sda, laddr;
10771 int seq_len; /* Original length of instruction sequence. */
10772 uint32_t insn;
10773 Elf_Internal_Rela *hi_irelfn = NULL, *irelend;
10774 bfd_vma access_addr = 0;
10775 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
10776 enum elf_nds32_reloc_type checked_types[] =
10777 { R_NDS32_HI20_RELA, R_NDS32_GOT_HI20,
10778 R_NDS32_GOTPC_HI20, R_NDS32_GOTOFF_HI20,
10779 R_NDS32_PLTREL_HI20, R_NDS32_PLT_GOTREL_HI20,
10780 R_NDS32_TLS_LE_HI20
10781 };
10782
10783 irelend = internal_relocs + sec->reloc_count;
10784 seq_len = GET_SEQ_LEN (irel->r_addend);
10785 laddr = irel->r_offset;
10786 *insn_len = seq_len;
10787
10788 /* Get the high part relocation. */
10789 for (i = 0; (unsigned) i < sizeof (checked_types); i++)
10790 {
10791 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10792 checked_types[i], laddr);
10793 if (hi_irelfn != irelend)
10794 break;
10795 }
10796
10797 if (hi_irelfn == irelend)
10798 {
10799 (*_bfd_error_handler)
10800 ("%B: warning: R_NDS32_LOADSTORE points to unrecognized"
10801 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10802 return FALSE;
10803 }
10804
10805 range_type = GET_LOADSTORE_RANGE (irel->r_addend);
10806 nds32_elf_final_sda_base (sec->output_section->owner,
10807 link_info, &local_sda, FALSE);
10808
10809 switch (ELF32_R_TYPE (hi_irelfn->r_info))
10810 {
10811 case R_NDS32_HI20_RELA:
10812 insn = bfd_getb32 (contents + laddr);
10813 access_addr =
10814 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10815
10816 if (range_type == NDS32_LOADSTORE_IMM)
10817 {
10818 struct elf_link_hash_entry *h = NULL;
10819 int indx;
10820
10821 if (ELF32_R_SYM (hi_irelfn->r_info) >= symtab_hdr->sh_info)
10822 {
10823 indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
10824 h = elf_sym_hashes (abfd)[indx];
10825 }
10826
10827 if ((access_addr < CONSERVATIVE_20BIT)
10828 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
10829 {
10830 eliminate_sethi = 1;
10831 break;
10832 }
10833
10834 /* This is avoid to relax symbol address which is fixed
10835 relocations. Ex: _stack. */
10836 if (h && bfd_is_abs_section (h->root.u.def.section))
10837 return FALSE;
10838 }
10839
10840 if (!load_store_relax)
10841 return FALSE;
10842
10843 /* Case for set gp register. */
10844 if (N32_RT5 (insn) == REG_GP)
10845 break;
10846
10847 if (range_type == NDS32_LOADSTORE_FLOAT_S
10848 || range_type == NDS32_LOADSTORE_FLOAT_S)
10849 {
10850 range_l = sdata_range[0][0];
10851 range_h = sdata_range[0][1];
10852 }
10853 else
10854 {
10855 range_l = sdata_range[1][0];
10856 range_h = sdata_range[1][1];
10857 }
10858 break;
10859
10860 case R_NDS32_GOT_HI20:
10861 access_addr =
10862 calculate_got_memory_address (abfd, link_info, hi_irelfn, symtab_hdr);
10863
10864 /* If this symbol is not in .got, the return value will be -1.
10865 Since the gp value is set to SDA_BASE but not GLOBAL_OFFSET_TABLE,
10866 a negative offset is allowed. */
10867 if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10868 && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10869 eliminate_sethi = 1;
10870 break;
10871
10872 case R_NDS32_PLT_GOTREL_HI20:
10873 access_addr = calculate_plt_memory_address (abfd, link_info, isymbuf,
10874 hi_irelfn, symtab_hdr);
10875
10876 if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10877 && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10878 eliminate_sethi = 1;
10879 break;
10880
10881 case R_NDS32_GOTOFF_HI20:
10882 access_addr =
10883 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10884
10885 if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10886 && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10887 eliminate_sethi = 1;
10888 break;
10889
10890 case R_NDS32_GOTPC_HI20:
10891 /* The access_addr must consider r_addend of hi_irel. */
10892 access_addr = sec->output_section->vma + sec->output_offset
10893 + irel->r_offset + hi_irelfn->r_addend;
10894
10895 if ((bfd_signed_vma) (local_sda - access_addr) < CONSERVATIVE_20BIT
10896 && (bfd_signed_vma) (local_sda - access_addr) >= -CONSERVATIVE_20BIT)
10897 eliminate_sethi = 1;
10898 break;
10899
10900 case R_NDS32_TLS_LE_HI20:
10901 access_addr =
10902 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10903 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
10904 access_addr -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
10905 if ((range_type == NDS32_LOADSTORE_IMM)
10906 && (bfd_signed_vma) (access_addr) < CONSERVATIVE_20BIT
10907 && (bfd_signed_vma) (access_addr) >= -CONSERVATIVE_20BIT)
10908 eliminate_sethi = 1;
10909 break;
10910
10911 default:
10912 return FALSE;
10913 }
10914
10915 /* Delete sethi instruction. */
10916 if (eliminate_sethi == 1
10917 || (local_sda <= access_addr && (access_addr - local_sda) < range_h)
10918 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
10919 {
10920 hi_irelfn->r_info =
10921 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
10922 irel->r_info =
10923 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10924 *insn_len = 0;
10925 }
10926 return TRUE;
10927 }
10928
10929 /* Relax LO12 relocation for nds32_elf_relax_section. */
10930
10931 static void
nds32_elf_relax_lo12(struct bfd_link_info * link_info,bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)10932 nds32_elf_relax_lo12 (struct bfd_link_info *link_info, bfd *abfd,
10933 asection *sec, Elf_Internal_Rela *irel,
10934 Elf_Internal_Rela *internal_relocs, bfd_byte *contents,
10935 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
10936 {
10937 uint32_t insn;
10938 bfd_vma local_sda, laddr;
10939 unsigned long reloc;
10940 bfd_vma access_addr;
10941 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
10942 Elf_Internal_Rela *irelfn = NULL, *irelend;
10943 struct elf_link_hash_entry *h = NULL;
10944 int indx;
10945
10946 /* For SDA base relative relaxation. */
10947 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
10948 &local_sda, FALSE);
10949
10950 irelend = internal_relocs + sec->reloc_count;
10951 laddr = irel->r_offset;
10952 insn = bfd_getb32 (contents + laddr);
10953
10954 if (!is_sda_access_insn (insn) && N32_OP6 (insn) != N32_OP6_ORI)
10955 return;
10956
10957 access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
10958
10959 if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
10960 {
10961 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
10962 h = elf_sym_hashes (abfd)[indx];
10963 }
10964
10965 if (N32_OP6 (insn) == N32_OP6_ORI && access_addr < CONSERVATIVE_20BIT
10966 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
10967 {
10968 reloc = R_NDS32_20_RELA;
10969 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10970 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
10971 bfd_putb32 (insn, contents + laddr);
10972 }
10973 /* This is avoid to relax symbol address which is fixed
10974 relocations. Ex: _stack. */
10975 else if (N32_OP6 (insn) == N32_OP6_ORI
10976 && h && bfd_is_abs_section (h->root.u.def.section))
10977 return;
10978 else
10979 {
10980 range_l = sdata_range[1][0];
10981 range_h = sdata_range[1][1];
10982 switch (ELF32_R_TYPE (irel->r_info))
10983 {
10984 case R_NDS32_LO12S0_RELA:
10985 reloc = R_NDS32_SDA19S0_RELA;
10986 break;
10987 case R_NDS32_LO12S1_RELA:
10988 reloc = R_NDS32_SDA18S1_RELA;
10989 break;
10990 case R_NDS32_LO12S2_RELA:
10991 reloc = R_NDS32_SDA17S2_RELA;
10992 break;
10993 case R_NDS32_LO12S2_DP_RELA:
10994 range_l = sdata_range[0][0];
10995 range_h = sdata_range[0][1];
10996 reloc = R_NDS32_SDA12S2_DP_RELA;
10997 break;
10998 case R_NDS32_LO12S2_SP_RELA:
10999 range_l = sdata_range[0][0];
11000 range_h = sdata_range[0][1];
11001 reloc = R_NDS32_SDA12S2_SP_RELA;
11002 break;
11003 default:
11004 return;
11005 }
11006
11007 /* There are range_h and range_l because linker has to promise
11008 all sections move cross one page together. */
11009 if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11010 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11011 {
11012 if (N32_OP6 (insn) == N32_OP6_ORI && N32_RT5 (insn) == REG_GP)
11013 {
11014 /* Maybe we should add R_NDS32_INSN16 reloc type here
11015 or manually do some optimization. sethi can't be
11016 eliminated when updating $gp so the relative ori
11017 needs to be preserved. */
11018 return;
11019 }
11020 if (!turn_insn_to_sda_access (insn, ELF32_R_TYPE (irel->r_info),
11021 &insn))
11022 return;
11023 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11024 bfd_putb32 (insn, contents + laddr);
11025
11026 irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11027 R_NDS32_INSN16);
11028 /* SDA17 must keep INSN16 for converting fp_as_gp. */
11029 if (irelfn != irelend && reloc != R_NDS32_SDA17S2_RELA)
11030 irelfn->r_info =
11031 ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_NDS32_NONE);
11032
11033 }
11034 }
11035 return;
11036 }
11037
11038 /* Relax low part of PIC instruction pattern. */
11039
11040 static void
nds32_elf_relax_piclo12(struct bfd_link_info * link_info,bfd * abfd,asection * sec,Elf_Internal_Rela * irel,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)11041 nds32_elf_relax_piclo12 (struct bfd_link_info *link_info, bfd *abfd,
11042 asection *sec, Elf_Internal_Rela *irel,
11043 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11044 Elf_Internal_Shdr *symtab_hdr)
11045 {
11046 uint32_t insn;
11047 bfd_vma local_sda, laddr;
11048 bfd_signed_vma foff;
11049 unsigned long reloc;
11050
11051 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11052 &local_sda, FALSE);
11053 laddr = irel->r_offset;
11054 insn = bfd_getb32 (contents + laddr);
11055
11056 if (N32_OP6 (insn) != N32_OP6_ORI)
11057 return;
11058
11059 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12)
11060 {
11061 foff = calculate_got_memory_address (abfd, link_info, irel,
11062 symtab_hdr) - local_sda;
11063 reloc = R_NDS32_GOT20;
11064 }
11065 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12)
11066 {
11067 foff = calculate_plt_memory_address (abfd, link_info, isymbuf, irel,
11068 symtab_hdr) - local_sda;
11069 reloc = R_NDS32_PLT_GOTREL_LO20;
11070 }
11071 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12)
11072 {
11073 foff = calculate_memory_address (abfd, irel, isymbuf,
11074 symtab_hdr) - local_sda;
11075 reloc = R_NDS32_GOTOFF;
11076 }
11077 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12)
11078 {
11079 foff = local_sda - sec->output_section->vma + sec->output_offset
11080 + irel->r_offset + irel->r_addend;
11081 reloc = R_NDS32_GOTPC20;
11082 }
11083 else
11084 return;
11085
11086 if ((foff < CONSERVATIVE_20BIT) && (foff >= -CONSERVATIVE_20BIT))
11087 {
11088 /* Turn into MOVI. */
11089 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11090 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11091 bfd_putb32 (insn, contents + laddr);
11092 }
11093 }
11094
11095 /* Relax low part of LE TLS instruction pattern. */
11096
11097 static void
nds32_elf_relax_letlslo12(struct bfd_link_info * link_info,bfd * abfd,Elf_Internal_Rela * irel,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr)11098 nds32_elf_relax_letlslo12 (struct bfd_link_info *link_info, bfd *abfd,
11099 Elf_Internal_Rela *irel,
11100 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11101 Elf_Internal_Shdr *symtab_hdr)
11102 {
11103 uint32_t insn;
11104 bfd_vma laddr;
11105 bfd_signed_vma foff;
11106 unsigned long reloc;
11107
11108 laddr = irel->r_offset;
11109 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11110 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11111 foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11112 insn = bfd_getb32 (contents + laddr);
11113
11114 if ( (bfd_signed_vma) (foff) < CONSERVATIVE_20BIT
11115 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_20BIT)
11116 {
11117 /* Pattern sethi-ori transform to movi. */
11118 reloc = R_NDS32_TLS_LE_20;
11119 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11120 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11121 bfd_putb32 (insn, contents + laddr);
11122 }
11123 }
11124
11125 /* Relax LE TLS calculate address instruction pattern. */
11126
11127 static void
nds32_elf_relax_letlsadd(struct bfd_link_info * link_info,bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr,bfd_boolean * again)11128 nds32_elf_relax_letlsadd (struct bfd_link_info *link_info, bfd *abfd,
11129 asection *sec, Elf_Internal_Rela *irel,
11130 Elf_Internal_Rela *internal_relocs,
11131 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11132 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11133 {
11134 /* Local TLS non-pic
11135 sethi ta, hi20(symbol@tpoff) ; TLS_LE_HI20
11136 ori ta, ta, lo12(symbol@tpoff) ; TLS_LE_LO12
11137 add ra, ta, tp ; TLS_LE_ADD */
11138
11139 uint32_t insn;
11140 bfd_vma laddr;
11141 bfd_signed_vma foff;
11142 Elf_Internal_Rela *i1_irelfn, *irelend;
11143
11144 irelend = internal_relocs + sec->reloc_count;
11145 laddr = irel->r_offset;
11146 insn = bfd_getb32 (contents + laddr);
11147 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11148 R_NDS32_PTR_RESOLVED);
11149 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11150 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11151 foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11152
11153 /* The range is +/-16k. */
11154 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT
11155 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT)
11156 {
11157 /* Transform add to addi. */
11158 insn = N32_TYPE2 (ADDI, N32_RT5 (insn), N32_RB5 (insn), 0);
11159 irel->r_info =
11160 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S0);
11161
11162 bfd_putb32 (insn, contents + laddr);
11163 if (i1_irelfn != irelend)
11164 {
11165 i1_irelfn->r_addend |= 1;
11166 *again = TRUE;
11167 }
11168 }
11169 }
11170
11171 /* Relax LE TLS load store instruction pattern. */
11172
11173 static void
nds32_elf_relax_letlsls(struct bfd_link_info * link_info,bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr,bfd_boolean * again)11174 nds32_elf_relax_letlsls (struct bfd_link_info *link_info, bfd *abfd,
11175 asection *sec, Elf_Internal_Rela *irel,
11176 Elf_Internal_Rela *internal_relocs,
11177 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11178 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11179 {
11180
11181 uint32_t insn;
11182 bfd_vma laddr;
11183 bfd_signed_vma foff;
11184 Elf_Internal_Rela *i1_irelfn, *irelend;
11185 int success = 0;
11186
11187 irelend = internal_relocs + sec->reloc_count;
11188 laddr = irel->r_offset;
11189 insn = bfd_getb32 (contents + laddr);
11190 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11191 R_NDS32_PTR_RESOLVED);
11192 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11193 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11194 foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11195
11196 switch ((N32_OP6 (insn) << 8) | (insn & 0xff))
11197 {
11198 case (N32_OP6_MEM << 8) | N32_MEM_LB:
11199 case (N32_OP6_MEM << 8) | N32_MEM_SB:
11200 case (N32_OP6_MEM << 8) | N32_MEM_LBS:
11201 /* The range is +/-16k. */
11202 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT
11203 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT)
11204 {
11205 insn =
11206 ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11207 irel->r_info =
11208 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S0);
11209 success = 1;
11210 break;
11211 }
11212 case (N32_OP6_MEM << 8) | N32_MEM_LH:
11213 case (N32_OP6_MEM << 8) | N32_MEM_SH:
11214 case (N32_OP6_MEM << 8) | N32_MEM_LHS:
11215 /* The range is +/-32k. */
11216 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT_S1
11217 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT_S1)
11218 {
11219 insn =
11220 ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11221 irel->r_info =
11222 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S1);
11223 success = 1;
11224 break;
11225 }
11226 case (N32_OP6_MEM << 8) | N32_MEM_LW:
11227 case (N32_OP6_MEM << 8) | N32_MEM_SW:
11228 /* The range is +/-64k. */
11229 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT_S2
11230 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT_S2)
11231 {
11232 insn =
11233 ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11234 irel->r_info =
11235 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S2);
11236 success = 1;
11237 break;
11238 }
11239 default:
11240 break;
11241 }
11242
11243 if (success)
11244 {
11245 bfd_putb32 (insn, contents + laddr);
11246 if (i1_irelfn != irelend)
11247 {
11248 i1_irelfn->r_addend |= 1;
11249 *again = TRUE;
11250 }
11251 }
11252 }
11253
11254 /* Relax PTR relocation for nds32_elf_relax_section. */
11255
11256 static bfd_boolean
nds32_elf_relax_ptr(bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,int * insn_len,int * seq_len,bfd_byte * contents)11257 nds32_elf_relax_ptr (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11258 Elf_Internal_Rela *internal_relocs, int *insn_len,
11259 int *seq_len, bfd_byte *contents)
11260 {
11261 Elf_Internal_Rela *ptr_irel, *irelend, *count_irel, *re_irel;
11262
11263 irelend = internal_relocs + sec->reloc_count;
11264
11265 re_irel =
11266 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11267 R_NDS32_PTR_RESOLVED, irel->r_addend);
11268
11269 if (re_irel == irelend)
11270 {
11271 (*_bfd_error_handler)
11272 ("%B: warning: R_NDS32_PTR points to unrecognized reloc at 0x%lx.",
11273 abfd, (long) irel->r_offset);
11274 return FALSE;
11275 }
11276
11277 if (re_irel->r_addend != 1)
11278 return FALSE;
11279
11280 /* Pointed target is relaxed and no longer needs this void *,
11281 change the type to NONE. */
11282 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11283
11284 /* Find PTR_COUNT to decide remove it or not. If PTR_COUNT does
11285 not exist, it means only count 1 and remove it directly. */
11286 /* TODO: I hope we can obsolate R_NDS32_COUNT in the future. */
11287 count_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11288 R_NDS32_PTR_COUNT);
11289 ptr_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11290 R_NDS32_PTR);
11291 if (count_irel != irelend)
11292 {
11293 if (--count_irel->r_addend > 0)
11294 return FALSE;
11295 }
11296
11297 if (ptr_irel != irelend)
11298 return FALSE;
11299
11300 /* If the PTR_COUNT is already 0, remove current instruction. */
11301 *seq_len = nds32_elf_insn_size (abfd, contents, irel->r_offset);
11302 *insn_len = 0;
11303 return TRUE;
11304 }
11305
11306 /* Relax PLT_GOT_SUFF relocation for nds32_elf_relax_section. */
11307
11308 static void
nds32_elf_relax_pltgot_suff(struct bfd_link_info * link_info,bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr,bfd_boolean * again)11309 nds32_elf_relax_pltgot_suff (struct bfd_link_info *link_info, bfd *abfd,
11310 asection *sec, Elf_Internal_Rela *irel,
11311 Elf_Internal_Rela *internal_relocs,
11312 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11313 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11314 {
11315 uint32_t insn;
11316 bfd_signed_vma foff;
11317 Elf_Internal_Rela *i1_irelfn, *irelend;
11318 bfd_vma local_sda, laddr;
11319
11320 irelend = internal_relocs + sec->reloc_count;
11321 laddr = irel->r_offset;
11322 insn = bfd_getb32 (contents + laddr);
11323
11324 /* FIXME: It's a little trouble to turn JRAL5 to JAL since
11325 we need additional space. It might be help if we could
11326 borrow some space from instructions to be eliminated
11327 such as sethi, ori, add. */
11328 if (insn & 0x80000000)
11329 return;
11330
11331 if (nds32_elf_check_dup_relocs
11332 (irel, internal_relocs, irelend, R_NDS32_PLT_GOT_SUFF))
11333 return;
11334
11335 i1_irelfn =
11336 find_relocs_at_address (irel, internal_relocs, irelend,
11337 R_NDS32_PTR_RESOLVED);
11338
11339 /* FIXIT 090606
11340 The boundary should be reduced since the .plt section hasn't
11341 been created and the address of specific entry is still unknown
11342 Maybe the range between the function call and the begin of the
11343 .text section can be used to decide if the .plt is in the range
11344 of function call. */
11345
11346 if (N32_OP6 (insn) == N32_OP6_ALU1
11347 && N32_SUB5 (insn) == N32_ALU1_ADD)
11348 {
11349 /* Get the value of the symbol referred to by the reloc. */
11350 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11351 &local_sda, FALSE);
11352 foff = (bfd_signed_vma) (calculate_plt_memory_address
11353 (abfd, link_info, isymbuf, irel,
11354 symtab_hdr) - local_sda);
11355 /* This condition only happened when symbol is undefined. */
11356 if (foff == 0)
11357 return;
11358
11359 if (foff < -CONSERVATIVE_19BIT || foff >= CONSERVATIVE_19BIT)
11360 return;
11361 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11362 R_NDS32_PLT_GOTREL_LO19);
11363 /* addi.gp */
11364 insn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
11365 }
11366 else if (N32_OP6 (insn) == N32_OP6_JREG
11367 && N32_SUB5 (insn) == N32_JREG_JRAL)
11368 {
11369 /* Get the value of the symbol referred to by the reloc. */
11370 foff =
11371 calculate_plt_offset (abfd, sec, link_info, isymbuf, irel, symtab_hdr);
11372 /* This condition only happened when symbol is undefined. */
11373 if (foff == 0)
11374 return;
11375 if (foff < -CONSERVATIVE_24BIT_S1 || foff >= CONSERVATIVE_24BIT_S1)
11376 return;
11377 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_25_PLTREL);
11378 insn = INSN_JAL;
11379 }
11380 else
11381 return;
11382
11383 bfd_putb32 (insn, contents + laddr);
11384 if (i1_irelfn != irelend)
11385 {
11386 i1_irelfn->r_addend |= 1;
11387 *again = TRUE;
11388 }
11389 }
11390
11391 /* Relax GOT_SUFF relocation for nds32_elf_relax_section. */
11392
11393 static void
nds32_elf_relax_got_suff(struct bfd_link_info * link_info,bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,bfd_byte * contents,Elf_Internal_Shdr * symtab_hdr,bfd_boolean * again)11394 nds32_elf_relax_got_suff (struct bfd_link_info *link_info, bfd *abfd,
11395 asection *sec, Elf_Internal_Rela *irel,
11396 Elf_Internal_Rela *internal_relocs,
11397 bfd_byte *contents, Elf_Internal_Shdr *symtab_hdr,
11398 bfd_boolean *again)
11399 {
11400 uint32_t insn;
11401 bfd_signed_vma foff;
11402 Elf_Internal_Rela *i1_irelfn, *irelend;
11403 bfd_vma local_sda, laddr;
11404
11405 irelend = internal_relocs + sec->reloc_count;
11406 laddr = irel->r_offset;
11407 insn = bfd_getb32 (contents + laddr);
11408 if (insn & 0x80000000)
11409 return;
11410
11411 if (nds32_elf_check_dup_relocs
11412 (irel, internal_relocs, irelend, R_NDS32_GOT_SUFF))
11413 return;
11414
11415 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11416 R_NDS32_PTR_RESOLVED);
11417
11418 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11419 &local_sda, FALSE);
11420 foff = calculate_got_memory_address (abfd, link_info, irel,
11421 symtab_hdr) - local_sda;
11422
11423 if (foff < CONSERVATIVE_19BIT && foff >= -CONSERVATIVE_19BIT)
11424 {
11425 /* Turn LW to LWI.GP. Change relocation type to R_NDS32_GOT_REL. */
11426 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
11427 irel->r_info =
11428 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_GOT17S2_RELA);
11429 bfd_putb32 (insn, contents + laddr);
11430 if (i1_irelfn != irelend)
11431 {
11432 i1_irelfn->r_addend |= 1;
11433 *again = TRUE;
11434 }
11435 }
11436 }
11437
11438 /* Relax PLT_GOT_SUFF relocation for nds32_elf_relax_section. */
11439
11440 static void
nds32_elf_relax_gotoff_suff(struct bfd_link_info * link_info,bfd * abfd,asection * sec,Elf_Internal_Rela * irel,Elf_Internal_Rela * internal_relocs,bfd_byte * contents,Elf_Internal_Sym * isymbuf,Elf_Internal_Shdr * symtab_hdr,bfd_boolean * again)11441 nds32_elf_relax_gotoff_suff (struct bfd_link_info *link_info, bfd *abfd,
11442 asection *sec, Elf_Internal_Rela *irel,
11443 Elf_Internal_Rela *internal_relocs,
11444 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11445 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11446 {
11447 int opc_insn_gotoff;
11448 uint32_t insn;
11449 bfd_signed_vma foff;
11450 Elf_Internal_Rela *i1_irelfn, *i2_irelfn, *irelend;
11451 bfd_vma local_sda, laddr;
11452
11453 irelend = internal_relocs + sec->reloc_count;
11454 laddr = irel->r_offset;
11455 insn = bfd_getb32 (contents + laddr);
11456
11457 if (insn & 0x80000000)
11458 return;
11459
11460 if (nds32_elf_check_dup_relocs
11461 (irel, internal_relocs, irelend, R_NDS32_GOTOFF_SUFF))
11462 return;
11463
11464 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11465 R_NDS32_PTR_RESOLVED);
11466 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11467 &local_sda, FALSE);
11468 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11469 foff = foff - local_sda;
11470
11471 if (foff >= CONSERVATIVE_19BIT || foff < -CONSERVATIVE_19BIT)
11472 return;
11473
11474 /* Concatenate opcode and sub-opcode for switch case.
11475 It may be MEM or ALU1. */
11476 opc_insn_gotoff = (N32_OP6 (insn) << 8) | (insn & 0xff);
11477 switch (opc_insn_gotoff)
11478 {
11479 case (N32_OP6_MEM << 8) | N32_MEM_LW:
11480 /* 4-byte aligned. */
11481 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
11482 irel->r_info =
11483 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA17S2_RELA);
11484 break;
11485 case (N32_OP6_MEM << 8) | N32_MEM_SW:
11486 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
11487 irel->r_info =
11488 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA17S2_RELA);
11489 break;
11490 case (N32_OP6_MEM << 8) | N32_MEM_LH:
11491 /* 2-byte aligned. */
11492 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
11493 irel->r_info =
11494 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11495 break;
11496 case (N32_OP6_MEM << 8) | N32_MEM_LHS:
11497 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (18));
11498 irel->r_info =
11499 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11500 break;
11501 case (N32_OP6_MEM << 8) | N32_MEM_SH:
11502 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (19));
11503 irel->r_info =
11504 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11505 break;
11506 case (N32_OP6_MEM << 8) | N32_MEM_LB:
11507 /* 1-byte aligned. */
11508 insn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
11509 irel->r_info =
11510 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11511 break;
11512 case (N32_OP6_MEM << 8) | N32_MEM_LBS:
11513 insn = N32_TYPE1 (LBGP, N32_RT5 (insn), __BIT (19));
11514 irel->r_info =
11515 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11516 break;
11517 case (N32_OP6_MEM << 8) | N32_MEM_SB:
11518 insn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
11519 irel->r_info =
11520 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11521 break;
11522 case (N32_OP6_ALU1 << 8) | N32_ALU1_ADD:
11523 insn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
11524 irel->r_info =
11525 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11526 break;
11527 default:
11528 return;
11529 }
11530
11531 bfd_putb32 (insn, contents + laddr);
11532 if (i1_irelfn != irelend)
11533 {
11534 i1_irelfn->r_addend |= 1;
11535 *again = TRUE;
11536 }
11537 if ((i2_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11538 R_NDS32_INSN16)) != irelend)
11539 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11540
11541 }
11542
11543 static bfd_boolean
nds32_relax_adjust_label(bfd * abfd,asection * sec,Elf_Internal_Rela * internal_relocs,bfd_byte * contents,nds32_elf_blank_t ** relax_blank_list,int optimize,int opt_size)11544 nds32_relax_adjust_label (bfd *abfd, asection *sec,
11545 Elf_Internal_Rela *internal_relocs,
11546 bfd_byte *contents,
11547 nds32_elf_blank_t **relax_blank_list,
11548 int optimize, int opt_size)
11549 {
11550 /* This code block is used to adjust 4-byte alignment by relax a pair
11551 of instruction a time.
11552
11553 It recognizes three types of relocations.
11554 1. R_NDS32_LABEL - a aligment.
11555 2. R_NDS32_INSN16 - relax a 32-bit instruction to 16-bit.
11556 3. is_16bit_NOP () - remove a 16-bit instruction. */
11557
11558 /* TODO: It seems currently implementation only support 4-byte aligment.
11559 We should handle any-aligment. */
11560
11561 Elf_Internal_Rela *insn_rel = NULL, *label_rel = NULL, *irel;
11562 Elf_Internal_Rela *tmp_rel, *tmp2_rel = NULL;
11563 Elf_Internal_Rela rel_temp;
11564 Elf_Internal_Rela *irelend;
11565 bfd_vma address;
11566 uint16_t insn16;
11567
11568 /* Checking for branch relaxation relies on the relocations to
11569 be sorted on 'r_offset'. This is not guaranteed so we must sort. */
11570 nds32_insertion_sort (internal_relocs, sec->reloc_count,
11571 sizeof (Elf_Internal_Rela), compar_reloc);
11572
11573 irelend = internal_relocs + sec->reloc_count;
11574
11575 /* Force R_NDS32_LABEL before R_NDS32_INSN16. */
11576 /* FIXME: Can we generate the right order in assembler?
11577 So we don't have to swapping them here. */
11578
11579 for (label_rel = internal_relocs, insn_rel = internal_relocs;
11580 label_rel < irelend; label_rel++)
11581 {
11582 if (ELF32_R_TYPE (label_rel->r_info) != R_NDS32_LABEL)
11583 continue;
11584
11585 /* Find the first reloc has the same offset with label_rel. */
11586 while (insn_rel < irelend && insn_rel->r_offset < label_rel->r_offset)
11587 insn_rel++;
11588
11589 for (;insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset;
11590 insn_rel++)
11591 /* Check if there were R_NDS32_INSN16 and R_NDS32_LABEL at the same
11592 address. */
11593 if (ELF32_R_TYPE (insn_rel->r_info) == R_NDS32_INSN16)
11594 break;
11595
11596 if (insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset
11597 && insn_rel < label_rel)
11598 {
11599 /* Swap the two reloc if the R_NDS32_INSN16 is
11600 before R_NDS32_LABEL. */
11601 memcpy (&rel_temp, insn_rel, sizeof (Elf_Internal_Rela));
11602 memcpy (insn_rel, label_rel, sizeof (Elf_Internal_Rela));
11603 memcpy (label_rel, &rel_temp, sizeof (Elf_Internal_Rela));
11604 }
11605 }
11606
11607 label_rel = NULL;
11608 insn_rel = NULL;
11609 /* If there were a sequence of R_NDS32_LABEL end up with .align 2
11610 or higher, remove other R_NDS32_LABEL with lower alignment.
11611 If an R_NDS32_INSN16 in between R_NDS32_LABELs must be converted,
11612 then the R_NDS32_LABEL sequence is broke. */
11613 for (tmp_rel = internal_relocs; tmp_rel < irelend; tmp_rel++)
11614 {
11615 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_LABEL)
11616 {
11617 if (label_rel == NULL)
11618 {
11619 if (tmp_rel->r_addend < 2)
11620 label_rel = tmp_rel;
11621 continue;
11622 }
11623 else if (tmp_rel->r_addend > 1)
11624 {
11625 /* Remove all LABEL relocation from label_rel to tmp_rel
11626 including relocations with same offset as tmp_rel. */
11627 for (tmp2_rel = label_rel; tmp2_rel < tmp_rel
11628 || tmp2_rel->r_offset == tmp_rel->r_offset; tmp2_rel++)
11629 {
11630 if (ELF32_R_TYPE (tmp2_rel->r_info) == R_NDS32_LABEL
11631 && tmp2_rel->r_addend < 2)
11632 tmp2_rel->r_info =
11633 ELF32_R_INFO (ELF32_R_SYM (tmp2_rel->r_info),
11634 R_NDS32_NONE);
11635 }
11636 label_rel = NULL;
11637 }
11638 }
11639 else if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16 && label_rel)
11640 {
11641 /* A new INSN16 which can be converted, so clear label_rel. */
11642 if (is_convert_32_to_16 (abfd, sec, tmp_rel, internal_relocs,
11643 irelend, &insn16)
11644 || is_16bit_NOP (abfd, sec, tmp_rel))
11645 label_rel = NULL;
11646 }
11647 }
11648
11649 label_rel = NULL;
11650 insn_rel = NULL;
11651 /* Optimized for speed and nothing has not been relaxed.
11652 It's time to align labels.
11653 We may convert a 16-bit instruction right before a label to
11654 32-bit, in order to align the label if necessary
11655 all reloc entries has been sorted by r_offset. */
11656 for (irel = internal_relocs; irel < irelend; irel++)
11657 {
11658 if (ELF32_R_TYPE (irel->r_info) != R_NDS32_INSN16
11659 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL)
11660 continue;
11661
11662 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_INSN16)
11663 {
11664 /* A new INSN16 found, resize the old one. */
11665 if (is_convert_32_to_16
11666 (abfd, sec, irel, internal_relocs, irelend, &insn16)
11667 || is_16bit_NOP (abfd, sec, irel))
11668 {
11669 if (insn_rel)
11670 {
11671 /* Previous INSN16 reloc exists, reduce its
11672 size to 16-bit. */
11673 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11674 irelend, &insn16))
11675 {
11676 nds32_elf_write_16 (abfd, contents, insn_rel,
11677 internal_relocs, irelend, insn16);
11678
11679 if (!insert_nds32_elf_blank_recalc_total
11680 (relax_blank_list, insn_rel->r_offset + 2, 2))
11681 return FALSE;
11682 }
11683 else if (is_16bit_NOP (abfd, sec, insn_rel))
11684 {
11685 if (!insert_nds32_elf_blank_recalc_total
11686 (relax_blank_list, insn_rel->r_offset, 2))
11687 return FALSE;
11688 }
11689 insn_rel->r_info =
11690 ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info), R_NDS32_NONE);
11691 }
11692 /* Save the new one for later use. */
11693 insn_rel = irel;
11694 }
11695 else
11696 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11697 R_NDS32_NONE);
11698 }
11699 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL)
11700 {
11701 /* Search for label. */
11702 int force_relax = 0;
11703
11704 /* Label on 16-bit instruction or optimization
11705 needless, just reset this reloc. */
11706 insn16 = bfd_getb16 (contents + irel->r_offset);
11707 if ((irel->r_addend & 0x1f) < 2 && (!optimize || (insn16 & 0x8000)))
11708 {
11709 irel->r_info =
11710 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11711 continue;
11712 }
11713
11714 address =
11715 irel->r_offset - get_nds32_elf_blank_total (relax_blank_list,
11716 irel->r_offset, 1);
11717
11718 if (!insn_rel)
11719 {
11720 /* Check if there is case which can not be aligned. */
11721 if (irel->r_addend == 2 && address & 0x2)
11722 return FALSE;
11723 continue;
11724 }
11725
11726 /* Try to align this label. */
11727
11728 if ((irel->r_addend & 0x1f) < 2)
11729 {
11730 /* Check if there is a INSN16 at the same address.
11731 Label_rel always seats before insn_rel after
11732 our sort. */
11733
11734 /* Search for INSN16 at LABEL location. If INSN16 is at
11735 same location and this LABEL alignment is lower than 2,
11736 the INSN16 can be converted to 2-byte. */
11737 for (tmp_rel = irel;
11738 tmp_rel < irelend && tmp_rel->r_offset == irel->r_offset;
11739 tmp_rel++)
11740 {
11741 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16
11742 && (is_convert_32_to_16
11743 (abfd, sec, tmp_rel, internal_relocs,
11744 irelend, &insn16)
11745 || is_16bit_NOP (abfd, sec, tmp_rel)))
11746 {
11747 force_relax = 1;
11748 break;
11749 }
11750 }
11751 }
11752
11753 if (force_relax || irel->r_addend == 1 || address & 0x2)
11754 {
11755 /* Label not aligned. */
11756 /* Previous reloc exists, reduce its size to 16-bit. */
11757 if (is_convert_32_to_16 (abfd, sec, insn_rel,
11758 internal_relocs, irelend, &insn16))
11759 {
11760 nds32_elf_write_16 (abfd, contents, insn_rel,
11761 internal_relocs, irelend, insn16);
11762
11763 if (!insert_nds32_elf_blank_recalc_total
11764 (relax_blank_list, insn_rel->r_offset + 2, 2))
11765 return FALSE;
11766 }
11767 else if (is_16bit_NOP (abfd, sec, insn_rel))
11768 {
11769 if (!insert_nds32_elf_blank_recalc_total
11770 (relax_blank_list, insn_rel->r_offset, 2))
11771 return FALSE;
11772 }
11773
11774 }
11775 /* INSN16 reloc is used. */
11776 insn_rel = NULL;
11777 }
11778 }
11779
11780 address =
11781 sec->size - get_nds32_elf_blank_total (relax_blank_list, sec->size, 0);
11782 if (insn_rel && (address & 0x2 || opt_size))
11783 {
11784 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11785 irelend, &insn16))
11786 {
11787 nds32_elf_write_16 (abfd, contents, insn_rel, internal_relocs,
11788 irelend, insn16);
11789 if (!insert_nds32_elf_blank_recalc_total
11790 (relax_blank_list, insn_rel->r_offset + 2, 2))
11791 return FALSE;
11792 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
11793 R_NDS32_NONE);
11794 }
11795 else if (is_16bit_NOP (abfd, sec, insn_rel))
11796 {
11797 if (!insert_nds32_elf_blank_recalc_total
11798 (relax_blank_list, insn_rel->r_offset, 2))
11799 return FALSE;
11800 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
11801 R_NDS32_NONE);
11802 }
11803 }
11804 insn_rel = NULL;
11805 return TRUE;
11806 }
11807
11808 /* Pick relaxation round. */
11809
11810 static int
nds32_elf_pick_relax(bfd_boolean init,asection * sec,bfd_boolean * again,struct elf_nds32_link_hash_table * table,struct bfd_link_info * link_info)11811 nds32_elf_pick_relax (bfd_boolean init, asection *sec, bfd_boolean *again,
11812 struct elf_nds32_link_hash_table *table,
11813 struct bfd_link_info *link_info)
11814 {
11815 static asection *final_sec;
11816 static bfd_boolean set = FALSE;
11817 static bfd_boolean first = TRUE;
11818 int round_table[] = {
11819 NDS32_RELAX_NORMAL_ROUND,
11820 NDS32_RELAX_JUMP_IFC_ROUND,
11821 NDS32_RELAX_EX9_BUILD_ROUND,
11822 NDS32_RELAX_EX9_REPLACE_ROUND,
11823 };
11824 static int pass = 0;
11825 static int relax_round;
11826
11827 if (first)
11828 {
11829 /* Run an empty run to get the final section. */
11830 relax_round = NDS32_RELAX_EMPTY_ROUND;
11831
11832 /* It has to enter relax again because we can
11833 not make sure what the final turn is. */
11834 *again = TRUE;
11835 first = FALSE;
11836 }
11837
11838 if (!set && *again)
11839 {
11840 /* It is reentered when again is FALSE. */
11841 final_sec = sec;
11842 return relax_round;
11843 }
11844
11845 /* The second round begins. */
11846 set = TRUE;
11847
11848 relax_round = round_table[pass];
11849
11850 if (!init && final_sec == sec)
11851 {
11852 switch (relax_round)
11853 {
11854 case NDS32_RELAX_NORMAL_ROUND:
11855 if (!*again)
11856 {
11857 /* Normal relaxation done. */
11858 if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
11859 {
11860 pass++;
11861 *again = TRUE;
11862 }
11863 else if (table->target_optimize & NDS32_RELAX_EX9_ON)
11864 {
11865 pass += 2; /* NDS32_RELAX_EX9_BUILD_ROUND */
11866 *again = TRUE;
11867 }
11868 else if (table->ex9_import_file)
11869 {
11870 /* Import ex9 table. */
11871 if (table->update_ex9_table)
11872 pass += 2; /* NDS32_RELAX_EX9_BUILD_ROUND */
11873 else
11874 pass += 3; /* NDS32_RELAX_EX9_REPLACE_ROUND */
11875 nds32_elf_ex9_import_table (link_info);
11876 *again = TRUE;
11877 }
11878 }
11879 break;
11880 case NDS32_RELAX_JUMP_IFC_ROUND:
11881 if (!nds32_elf_ifc_finish (link_info))
11882 (*_bfd_error_handler) (_("error: Jump IFC Fail."));
11883 if (table->target_optimize & NDS32_RELAX_EX9_ON)
11884 {
11885 pass++;
11886 *again = TRUE;
11887 }
11888 break;
11889 case NDS32_RELAX_EX9_BUILD_ROUND:
11890 nds32_elf_ex9_finish (link_info);
11891 pass++;
11892 *again = TRUE;
11893 break;
11894 case NDS32_RELAX_EX9_REPLACE_ROUND:
11895 if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
11896 {
11897 /* Do jump IFC optimization again. */
11898 if (!nds32_elf_ifc_finish (link_info))
11899 (*_bfd_error_handler) (_("error: Jump IFC Fail."));
11900 }
11901 break;
11902 default:
11903 break;
11904 }
11905 }
11906
11907 return relax_round;
11908 }
11909
11910 static bfd_boolean
nds32_elf_relax_section(bfd * abfd,asection * sec,struct bfd_link_info * link_info,bfd_boolean * again)11911 nds32_elf_relax_section (bfd *abfd, asection *sec,
11912 struct bfd_link_info *link_info, bfd_boolean *again)
11913 {
11914 nds32_elf_blank_t *relax_blank_list = NULL;
11915 Elf_Internal_Shdr *symtab_hdr;
11916 Elf_Internal_Rela *internal_relocs;
11917 Elf_Internal_Rela *irel;
11918 Elf_Internal_Rela *irelend;
11919 Elf_Internal_Sym *isymbuf = NULL;
11920 bfd_byte *contents = NULL;
11921 bfd_boolean result = TRUE;
11922 int optimize = 0;
11923 int opt_size = 0;
11924 uint32_t insn;
11925 uint16_t insn16;
11926
11927 /* Target dependnet option. */
11928 struct elf_nds32_link_hash_table *table;
11929 int load_store_relax;
11930 int relax_round;
11931
11932 relax_blank_list = NULL;
11933
11934 *again = FALSE;
11935
11936 /* Nothing to do for
11937 * relocatable link or
11938 * non-relocatable section or
11939 * non-code section or
11940 * empty content or
11941 * no reloc entry. */
11942 if (link_info->relocatable
11943 || (sec->flags & SEC_RELOC) == 0
11944 || (sec->flags & SEC_EXCLUDE) == 1
11945 || (sec->flags & SEC_CODE) == 0
11946 || sec->size == 0)
11947 return TRUE;
11948
11949 /* 09.12.11 Workaround. */
11950 /* We have to adjust align for R_NDS32_LABEL if needed.
11951 The adjust approach only can fix 2-byte align once. */
11952 if (sec->alignment_power > 2)
11953 return TRUE;
11954
11955 /* The optimization type to do. */
11956
11957 table = nds32_elf_hash_table (link_info);
11958 relax_round = nds32_elf_pick_relax (TRUE, sec, again, table, link_info);
11959 switch (relax_round)
11960 {
11961 case NDS32_RELAX_JUMP_IFC_ROUND:
11962 /* Here is the entrance of ifc jump relaxation. */
11963 if (!nds32_elf_ifc_calc (link_info, abfd, sec))
11964 return FALSE;
11965 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11966 return TRUE;
11967
11968 case NDS32_RELAX_EX9_BUILD_ROUND:
11969 /* Here is the entrance of ex9 relaxation. There are two pass of
11970 ex9 relaxation. The one is to traverse all instructions and build
11971 the hash table. The other one is to compare instructions and replace
11972 it by ex9.it. */
11973 if (!nds32_elf_ex9_build_hash_table (abfd, sec, link_info))
11974 return FALSE;
11975 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11976 return TRUE;
11977
11978 case NDS32_RELAX_EX9_REPLACE_ROUND:
11979 if (!nds32_elf_ex9_replace_instruction (link_info, abfd, sec))
11980 return FALSE;
11981 return TRUE;
11982
11983 case NDS32_RELAX_EMPTY_ROUND:
11984 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11985 return TRUE;
11986
11987 case NDS32_RELAX_NORMAL_ROUND:
11988 default:
11989 if (sec->reloc_count == 0)
11990 return TRUE;
11991 break;
11992 }
11993
11994 /* The begining of general relaxation. */
11995
11996 if (is_SDA_BASE_set == 0)
11997 {
11998 bfd_vma gp;
11999 is_SDA_BASE_set = 1;
12000 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
12001 &gp, FALSE);
12002 relax_range_measurement (abfd);
12003 }
12004
12005 if (is_ITB_BASE_set == 0)
12006 {
12007 /* Set the _ITB_BASE_. */
12008 if (!nds32_elf_ex9_itb_base (link_info))
12009 {
12010 (*_bfd_error_handler) (_("%B: error: Cannot set _ITB_BASE_"), abfd);
12011 bfd_set_error (bfd_error_bad_value);
12012 }
12013 }
12014
12015 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12016 /* Relocations MUST be kept in memory, because relaxation adjust them. */
12017 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12018 TRUE /* keep_memory */);
12019 if (internal_relocs == NULL)
12020 goto error_return;
12021
12022 irelend = internal_relocs + sec->reloc_count;
12023 irel = find_relocs_at_address (internal_relocs, internal_relocs,
12024 irelend, R_NDS32_RELAX_ENTRY);
12025
12026 if (irel == irelend)
12027 return TRUE;
12028
12029 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
12030 {
12031 if (irel->r_addend & R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG)
12032 return TRUE;
12033
12034 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FLAG)
12035 optimize = 1;
12036
12037 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FOR_SPACE_FLAG)
12038 opt_size = 1;
12039 }
12040
12041 load_store_relax = table->load_store_relax;
12042
12043 /* Get symbol table and section content. */
12044 if (!nds32_get_section_contents (abfd, sec, &contents)
12045 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12046 goto error_return;
12047
12048 /* Do relax loop only when finalize is not done.
12049 Take care of relaxable relocs except INSN16. */
12050 for (irel = internal_relocs; irel < irelend; irel++)
12051 {
12052 int seq_len; /* Original length of instruction sequence. */
12053 int insn_len = 0; /* Final length of instruction sequence. */
12054 bfd_boolean removed;
12055
12056 insn = 0;
12057 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
12058 && (irel->r_addend & 0x1f) >= 2)
12059 optimize = 1;
12060
12061 /* Relocation Types
12062 R_NDS32_LONGCALL1 53
12063 R_NDS32_LONGCALL2 54
12064 R_NDS32_LONGCALL3 55
12065 R_NDS32_LONGJUMP1 56
12066 R_NDS32_LONGJUMP2 57
12067 R_NDS32_LONGJUMP3 58
12068 R_NDS32_LOADSTORE 59 */
12069 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL1
12070 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LOADSTORE)
12071 seq_len = GET_SEQ_LEN (irel->r_addend);
12072
12073 /* Relocation Types
12074 R_NDS32_LONGCALL4 107
12075 R_NDS32_LONGCALL5 108
12076 R_NDS32_LONGCALL6 109
12077 R_NDS32_LONGJUMP4 110
12078 R_NDS32_LONGJUMP5 111
12079 R_NDS32_LONGJUMP6 112
12080 R_NDS32_LONGJUMP7 113 */
12081 else if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL4
12082 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LONGJUMP7)
12083 seq_len = 4;
12084
12085 /* Relocation Types
12086 R_NDS32_LO12S0_RELA 30
12087 R_NDS32_LO12S1_RELA 29
12088 R_NDS32_LO12S2_RELA 28
12089 R_NDS32_LO12S2_SP_RELA 71
12090 R_NDS32_LO12S2_DP_RELA 70
12091 R_NDS32_GOT_LO12 46
12092 R_NDS32_GOTOFF_LO12 50
12093 R_NDS32_PLTREL_LO12 65
12094 R_NDS32_PLT_GOTREL_LO12 67
12095 R_NDS32_17IFC_PCREL_RELA 96
12096 R_NDS32_GOT_SUFF 193
12097 R_NDS32_GOTOFF_SUFF 194
12098 R_NDS32_PLT_GOT_SUFF 195
12099 R_NDS32_MULCALL_SUFF 196
12100 R_NDS32_PTR 197 */
12101 else if ((ELF32_R_TYPE (irel->r_info) <= R_NDS32_LO12S0_RELA
12102 && ELF32_R_TYPE (irel->r_info) >= R_NDS32_LO12S2_RELA)
12103 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_SP_RELA
12104 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_DP_RELA
12105 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12
12106 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12
12107 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12
12108 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLTREL_LO12
12109 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12
12110 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_GOT_SUFF
12111 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_PTR)
12112 || ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12113 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LO12
12114 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_ADD
12115 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LS)
12116 seq_len = 0;
12117 else
12118 continue;
12119
12120 insn_len = seq_len;
12121 removed = FALSE;
12122
12123 switch (ELF32_R_TYPE (irel->r_info))
12124 {
12125 case R_NDS32_LONGCALL1:
12126 removed = nds32_elf_relax_longcall1 (abfd, sec, irel, internal_relocs,
12127 &insn_len, contents, isymbuf,
12128 symtab_hdr);
12129 break;
12130 case R_NDS32_LONGCALL2:
12131 removed = nds32_elf_relax_longcall2 (abfd, sec, irel, internal_relocs,
12132 &insn_len, contents, isymbuf,
12133 symtab_hdr);
12134 break;
12135 case R_NDS32_LONGCALL3:
12136 removed = nds32_elf_relax_longcall3 (abfd, sec, irel, internal_relocs,
12137 &insn_len, contents, isymbuf,
12138 symtab_hdr);
12139 break;
12140 case R_NDS32_LONGJUMP1:
12141 removed = nds32_elf_relax_longjump1 (abfd, sec, irel, internal_relocs,
12142 &insn_len, contents, isymbuf,
12143 symtab_hdr);
12144 break;
12145 case R_NDS32_LONGJUMP2:
12146 removed = nds32_elf_relax_longjump2 (abfd, sec, irel, internal_relocs,
12147 &insn_len, contents, isymbuf,
12148 symtab_hdr);
12149 break;
12150 case R_NDS32_LONGJUMP3:
12151 removed = nds32_elf_relax_longjump3 (abfd, sec, irel, internal_relocs,
12152 &insn_len, contents, isymbuf,
12153 symtab_hdr);
12154 break;
12155 case R_NDS32_LONGCALL4:
12156 removed = nds32_elf_relax_longcall4 (abfd, sec, irel, internal_relocs,
12157 &insn_len, contents, isymbuf,
12158 symtab_hdr);
12159 break;
12160 case R_NDS32_LONGCALL5:
12161 removed = nds32_elf_relax_longcall5 (abfd, sec, irel, internal_relocs,
12162 &insn_len, contents, isymbuf,
12163 symtab_hdr);
12164 break;
12165 case R_NDS32_LONGCALL6:
12166 removed = nds32_elf_relax_longcall6 (abfd, sec, irel, internal_relocs,
12167 &insn_len, contents, isymbuf,
12168 symtab_hdr);
12169 break;
12170 case R_NDS32_LONGJUMP4:
12171 removed = nds32_elf_relax_longjump4 (abfd, sec, irel, internal_relocs,
12172 &insn_len, contents, isymbuf,
12173 symtab_hdr);
12174 break;
12175 case R_NDS32_LONGJUMP5:
12176 removed = nds32_elf_relax_longjump5 (abfd, sec, irel, internal_relocs,
12177 &insn_len, &seq_len, contents,
12178 isymbuf, symtab_hdr);
12179 break;
12180 case R_NDS32_LONGJUMP6:
12181 removed = nds32_elf_relax_longjump6 (abfd, sec, irel, internal_relocs,
12182 &insn_len, &seq_len, contents,
12183 isymbuf, symtab_hdr);
12184 break;
12185 case R_NDS32_LONGJUMP7:
12186 removed = nds32_elf_relax_longjump7 (abfd, sec, irel, internal_relocs,
12187 &insn_len, &seq_len, contents,
12188 isymbuf, symtab_hdr);
12189 break;
12190 case R_NDS32_LOADSTORE:
12191 removed = nds32_elf_relax_loadstore (link_info, abfd, sec, irel,
12192 internal_relocs, &insn_len,
12193 contents, isymbuf, symtab_hdr,
12194 load_store_relax);
12195 break;
12196 case R_NDS32_LO12S0_RELA:
12197 case R_NDS32_LO12S1_RELA:
12198 case R_NDS32_LO12S2_DP_RELA:
12199 case R_NDS32_LO12S2_SP_RELA:
12200 case R_NDS32_LO12S2_RELA:
12201 /* Relax for low part. */
12202 nds32_elf_relax_lo12 (link_info, abfd, sec, irel, internal_relocs,
12203 contents, isymbuf, symtab_hdr);
12204
12205 /* It is impossible to delete blank, so just continue. */
12206 continue;
12207 case R_NDS32_GOT_LO12:
12208 case R_NDS32_GOTOFF_LO12:
12209 case R_NDS32_PLTREL_LO12:
12210 case R_NDS32_PLT_GOTREL_LO12:
12211 case R_NDS32_GOTPC_LO12:
12212 /* Relax for PIC gp-relative low part. */
12213 nds32_elf_relax_piclo12 (link_info, abfd, sec, irel, contents,
12214 isymbuf, symtab_hdr);
12215
12216 /* It is impossible to delete blank, so just continue. */
12217 continue;
12218 case R_NDS32_TLS_LE_LO12:
12219 /* Relax for LE TLS low part. */
12220 nds32_elf_relax_letlslo12 (link_info, abfd, irel, contents,
12221 isymbuf, symtab_hdr);
12222
12223 /* It is impossible to delete blank, so just continue. */
12224 continue;
12225 case R_NDS32_TLS_LE_ADD:
12226 nds32_elf_relax_letlsadd (link_info, abfd, sec, irel, internal_relocs,
12227 contents, isymbuf, symtab_hdr, again);
12228 /* It is impossible to delete blank, so just continue. */
12229 continue;
12230 case R_NDS32_TLS_LE_LS:
12231 nds32_elf_relax_letlsls (link_info, abfd, sec, irel, internal_relocs,
12232 contents, isymbuf, symtab_hdr, again);
12233 continue;
12234 case R_NDS32_PTR:
12235 removed = nds32_elf_relax_ptr (abfd, sec, irel, internal_relocs,
12236 &insn_len, &seq_len, contents);
12237 break;
12238 case R_NDS32_PLT_GOT_SUFF:
12239 nds32_elf_relax_pltgot_suff (link_info, abfd, sec, irel,
12240 internal_relocs, contents,
12241 isymbuf, symtab_hdr, again);
12242 /* It is impossible to delete blank, so just continue. */
12243 continue;
12244 case R_NDS32_GOT_SUFF:
12245 nds32_elf_relax_got_suff (link_info, abfd, sec, irel,
12246 internal_relocs, contents,
12247 symtab_hdr, again);
12248 /* It is impossible to delete blank, so just continue. */
12249 continue;
12250 case R_NDS32_GOTOFF_SUFF:
12251 nds32_elf_relax_gotoff_suff (link_info, abfd, sec, irel,
12252 internal_relocs, contents,
12253 isymbuf, symtab_hdr, again);
12254 /* It is impossible to delete blank, so just continue. */
12255 continue;
12256 default:
12257 continue;
12258
12259 }
12260 if (removed && seq_len - insn_len > 0)
12261 {
12262 if (!insert_nds32_elf_blank
12263 (&relax_blank_list, irel->r_offset + insn_len,
12264 seq_len - insn_len))
12265 goto error_return;
12266 *again = TRUE;
12267 }
12268 }
12269
12270 calc_nds32_blank_total (relax_blank_list);
12271
12272 if (table->relax_fp_as_gp)
12273 {
12274 if (!nds32_relax_fp_as_gp (link_info, abfd, sec, internal_relocs,
12275 irelend, isymbuf))
12276 goto error_return;
12277
12278 if (*again == FALSE)
12279 {
12280 if (!nds32_fag_remove_unused_fpbase (abfd, sec, internal_relocs,
12281 irelend))
12282 goto error_return;
12283 }
12284 }
12285
12286 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12287
12288 if (*again == FALSE)
12289 {
12290 if (!nds32_relax_adjust_label (abfd, sec, internal_relocs, contents,
12291 &relax_blank_list, optimize, opt_size))
12292 goto error_return;
12293 }
12294
12295 /* It doesn't matter optimize_for_space_no_align anymore.
12296 If object file is assembled with flag '-Os',
12297 the we don't adjust jump-destination on 4-byte boundary. */
12298
12299 if (relax_blank_list)
12300 {
12301 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12302 relax_blank_list = NULL;
12303 }
12304
12305 if (*again == FALSE)
12306 {
12307 /* Closing the section, so we don't relax it anymore. */
12308 bfd_vma sec_size_align;
12309 Elf_Internal_Rela *tmp_rel;
12310
12311 /* Pad to alignment boundary. Only handle current section alignment. */
12312 sec_size_align = (sec->size + (~((-1) << sec->alignment_power)))
12313 & ((-1) << sec->alignment_power);
12314 if ((sec_size_align - sec->size) & 0x2)
12315 {
12316 insn16 = NDS32_NOP16;
12317 bfd_putb16 (insn16, contents + sec->size);
12318 sec->size += 2;
12319 }
12320
12321 while (sec_size_align != sec->size)
12322 {
12323 insn = NDS32_NOP32;
12324 bfd_putb32 (insn, contents + sec->size);
12325 sec->size += 4;
12326 }
12327
12328 tmp_rel = find_relocs_at_address (internal_relocs, internal_relocs,
12329 irelend, R_NDS32_RELAX_ENTRY);
12330 if (tmp_rel != irelend)
12331 tmp_rel->r_addend |= R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG;
12332
12333 clean_nds32_elf_blank ();
12334 }
12335
12336 finish:
12337 if (internal_relocs != NULL
12338 && elf_section_data (sec)->relocs != internal_relocs)
12339 free (internal_relocs);
12340
12341 if (contents != NULL
12342 && elf_section_data (sec)->this_hdr.contents != contents)
12343 free (contents);
12344
12345 if (isymbuf != NULL && symtab_hdr->contents != (bfd_byte *) isymbuf)
12346 free (isymbuf);
12347
12348 return result;
12349
12350 error_return:
12351 result = FALSE;
12352 goto finish;
12353 }
12354
12355 static struct bfd_elf_special_section const nds32_elf_special_sections[] =
12356 {
12357 {".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE},
12358 {".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE},
12359 {NULL, 0, 0, 0, 0}
12360 };
12361
12362 static bfd_boolean
nds32_elf_output_arch_syms(bfd * output_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info,void * finfo ATTRIBUTE_UNUSED,bfd_boolean (* func)(void *,const char *,Elf_Internal_Sym *,asection *,struct elf_link_hash_entry *)ATTRIBUTE_UNUSED)12363 nds32_elf_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
12364 struct bfd_link_info *info,
12365 void *finfo ATTRIBUTE_UNUSED,
12366 bfd_boolean (*func) (void *, const char *,
12367 Elf_Internal_Sym *,
12368 asection *,
12369 struct elf_link_hash_entry *)
12370 ATTRIBUTE_UNUSED)
12371 {
12372 FILE *sym_ld_script = NULL;
12373 struct elf_nds32_link_hash_table *table;
12374
12375 table = nds32_elf_hash_table (info);
12376 sym_ld_script = table->sym_ld_script;
12377
12378 if (check_start_export_sym)
12379 fprintf (sym_ld_script, "}\n");
12380
12381 return TRUE;
12382 }
12383
12384 static enum elf_reloc_type_class
nds32_elf_reloc_type_class(const struct bfd_link_info * info ATTRIBUTE_UNUSED,const asection * rel_sec ATTRIBUTE_UNUSED,const Elf_Internal_Rela * rela)12385 nds32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
12386 const asection *rel_sec ATTRIBUTE_UNUSED,
12387 const Elf_Internal_Rela *rela)
12388 {
12389 switch ((int) ELF32_R_TYPE (rela->r_info))
12390 {
12391 case R_NDS32_RELATIVE:
12392 return reloc_class_relative;
12393 case R_NDS32_JMP_SLOT:
12394 return reloc_class_plt;
12395 case R_NDS32_COPY:
12396 return reloc_class_copy;
12397 default:
12398 return reloc_class_normal;
12399 }
12400 }
12401
12402 /* Put target dependent option into info hash table. */
12403 void
bfd_elf32_nds32_set_target_option(struct bfd_link_info * link_info,int relax_fp_as_gp,int eliminate_gc_relocs,FILE * sym_ld_script,int load_store_relax,int target_optimize,int relax_status,int relax_round,FILE * ex9_export_file,FILE * ex9_import_file,int update_ex9_table,int ex9_limit,bfd_boolean ex9_loop_aware,bfd_boolean ifc_loop_aware)12404 bfd_elf32_nds32_set_target_option (struct bfd_link_info *link_info,
12405 int relax_fp_as_gp,
12406 int eliminate_gc_relocs,
12407 FILE * sym_ld_script, int load_store_relax,
12408 int target_optimize, int relax_status,
12409 int relax_round, FILE * ex9_export_file,
12410 FILE * ex9_import_file,
12411 int update_ex9_table, int ex9_limit,
12412 bfd_boolean ex9_loop_aware,
12413 bfd_boolean ifc_loop_aware)
12414 {
12415 struct elf_nds32_link_hash_table *table;
12416
12417 table = nds32_elf_hash_table (link_info);
12418 if (table == NULL)
12419 return;
12420
12421 table->relax_fp_as_gp = relax_fp_as_gp;
12422 table->eliminate_gc_relocs = eliminate_gc_relocs;
12423 table->sym_ld_script = sym_ld_script;
12424 table ->load_store_relax = load_store_relax;
12425 table->target_optimize = target_optimize;
12426 table->relax_status = relax_status;
12427 table->relax_round = relax_round;
12428 table->ex9_export_file = ex9_export_file;
12429 table->ex9_import_file = ex9_import_file;
12430 table->update_ex9_table = update_ex9_table;
12431 table->ex9_limit = ex9_limit;
12432 table->ex9_loop_aware = ex9_loop_aware;
12433 table->ifc_loop_aware = ifc_loop_aware;
12434 }
12435
12436 /* These functions and data-structures are used for fp-as-gp
12437 optimization. */
12438
12439 #define FAG_THRESHOLD 3 /* At least 3 gp-access. */
12440 /* lwi37.fp covers 508 bytes, but there may be 32-byte padding between
12441 the read-only section and read-write section. */
12442 #define FAG_WINDOW (508 - 32)
12443
12444 /* An nds32_fag represent a gp-relative access.
12445 We find best fp-base by using a sliding window
12446 to find a base address which can cover most gp-access. */
12447 struct nds32_fag
12448 {
12449 struct nds32_fag *next; /* NULL-teminated linked list. */
12450 bfd_vma addr; /* The address of this fag. */
12451 Elf_Internal_Rela **relas; /* The relocations associated with this fag.
12452 It is used for applying FP7U2_FLAG. */
12453 int count; /* How many times this address is referred.
12454 There should be exactly `count' relocations
12455 in relas. */
12456 int relas_capcity; /* The buffer size of relas.
12457 We use an array instead of linked-list,
12458 and realloc is used to adjust buffer size. */
12459 };
12460
12461 static void
nds32_fag_init(struct nds32_fag * head)12462 nds32_fag_init (struct nds32_fag *head)
12463 {
12464 memset (head, 0, sizeof (struct nds32_fag));
12465 }
12466
12467 static void
nds32_fag_verify(struct nds32_fag * head)12468 nds32_fag_verify (struct nds32_fag *head)
12469 {
12470 struct nds32_fag *iter;
12471 struct nds32_fag *prev;
12472
12473 prev = NULL;
12474 iter = head->next;
12475 while (iter)
12476 {
12477 if (prev && prev->addr >= iter->addr)
12478 puts ("Bug in fp-as-gp insertion.");
12479 prev = iter;
12480 iter = iter->next;
12481 }
12482 }
12483
12484 /* Insert a fag in ascending order.
12485 If a fag of the same address already exists,
12486 they are chained by relas array. */
12487
12488 static void
nds32_fag_insert(struct nds32_fag * head,bfd_vma addr,Elf_Internal_Rela * rel)12489 nds32_fag_insert (struct nds32_fag *head, bfd_vma addr,
12490 Elf_Internal_Rela * rel)
12491 {
12492 struct nds32_fag *iter;
12493 struct nds32_fag *new_fag;
12494 const int INIT_RELAS_CAP = 4;
12495
12496 for (iter = head;
12497 iter->next && iter->next->addr <= addr;
12498 iter = iter->next)
12499 /* Find somewhere to insert. */ ;
12500
12501 /* `iter' will be equal to `head' if the list is empty. */
12502 if (iter != head && iter->addr == addr)
12503 {
12504 /* The address exists in the list.
12505 Insert `rel' into relocation list, relas. */
12506
12507 /* Check whether relas is big enough. */
12508 if (iter->count >= iter->relas_capcity)
12509 {
12510 iter->relas_capcity *= 2;
12511 iter->relas = bfd_realloc
12512 (iter->relas, iter->relas_capcity * sizeof (void *));
12513 }
12514 iter->relas[iter->count++] = rel;
12515 return;
12516 }
12517
12518 /* This is a new address. Create a fag node for it. */
12519 new_fag = bfd_malloc (sizeof (struct nds32_fag));
12520 memset (new_fag, 0, sizeof (*new_fag));
12521 new_fag->addr = addr;
12522 new_fag->count = 1;
12523 new_fag->next = iter->next;
12524 new_fag->relas_capcity = INIT_RELAS_CAP;
12525 new_fag->relas = (Elf_Internal_Rela **)
12526 bfd_malloc (new_fag->relas_capcity * sizeof (void *));
12527 new_fag->relas[0] = rel;
12528 iter->next = new_fag;
12529
12530 nds32_fag_verify (head);
12531 }
12532
12533 static void
nds32_fag_free_list(struct nds32_fag * head)12534 nds32_fag_free_list (struct nds32_fag *head)
12535 {
12536 struct nds32_fag *iter;
12537
12538 iter = head->next;
12539 while (iter)
12540 {
12541 struct nds32_fag *tmp = iter;
12542 iter = iter->next;
12543 free (tmp->relas);
12544 tmp->relas = NULL;
12545 free (tmp);
12546 }
12547 }
12548
12549 /* Find the best fp-base address.
12550 The relocation associated with that address is returned,
12551 so we can track the symbol instead of a fixed address.
12552
12553 When relaxation, the address of an datum may change,
12554 because a text section is shrinked, so the data section
12555 moves forward. If the aligments of text and data section
12556 are different, their distance may change too.
12557 Therefore, tracking a fixed address is not appriate. */
12558
12559 static int
nds32_fag_find_base(struct nds32_fag * head,struct nds32_fag ** bestpp)12560 nds32_fag_find_base (struct nds32_fag *head, struct nds32_fag **bestpp)
12561 {
12562 struct nds32_fag *base; /* First fag in the window. */
12563 struct nds32_fag *last; /* First fag outside the window. */
12564 int accu = 0; /* Usage accumulation. */
12565 struct nds32_fag *best; /* Best fag. */
12566 int baccu = 0; /* Best accumulation. */
12567
12568 /* Use first fag for initial, and find the last fag in the window.
12569
12570 In each iteration, we could simply subtract previous fag
12571 and accumulate following fags which are inside the window,
12572 untill we each the end. */
12573
12574 if (head->next == NULL)
12575 {
12576 *bestpp = NULL;
12577 return 0;
12578 }
12579
12580 /* Initialize base. */
12581 base = head->next;
12582 best = base;
12583 for (last = base;
12584 last && last->addr < base->addr + FAG_WINDOW;
12585 last = last->next)
12586 accu += last->count;
12587
12588 baccu = accu;
12589
12590 /* Record the best base in each iteration. */
12591 while (base->next)
12592 {
12593 accu -= base->count;
12594 base = base->next;
12595 /* Account fags in window. */
12596 for (/* Nothing. */;
12597 last && last->addr < base->addr + FAG_WINDOW;
12598 last = last->next)
12599 accu += last->count;
12600
12601 /* A better fp-base? */
12602 if (accu > baccu)
12603 {
12604 best = base;
12605 baccu = accu;
12606 }
12607 }
12608
12609 if (bestpp)
12610 *bestpp = best;
12611 return baccu;
12612 }
12613
12614 /* Apply R_NDS32_INSN16_FP7U2_FLAG on gp-relative accesses,
12615 so we can convert it fo fp-relative access later.
12616 `best_fag' is the best fp-base. Only those inside the window
12617 of best_fag is applied the flag. */
12618
12619 static bfd_boolean
nds32_fag_mark_relax(struct bfd_link_info * link_info,bfd * abfd,struct nds32_fag * best_fag,Elf_Internal_Rela * internal_relocs,Elf_Internal_Rela * irelend)12620 nds32_fag_mark_relax (struct bfd_link_info *link_info,
12621 bfd *abfd, struct nds32_fag *best_fag,
12622 Elf_Internal_Rela *internal_relocs,
12623 Elf_Internal_Rela *irelend)
12624 {
12625 struct nds32_fag *ifag;
12626 bfd_vma best_fpbase, gp;
12627 bfd *output_bfd;
12628
12629 output_bfd = abfd->sections->output_section->owner;
12630 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
12631 best_fpbase = best_fag->addr;
12632
12633 if (best_fpbase > gp + sdata_range[1][1]
12634 || best_fpbase < gp - sdata_range[1][0])
12635 return FALSE;
12636
12637 /* Mark these inside the window R_NDS32_INSN16_FP7U2_FLAG flag,
12638 so we know they can be converted to lwi37.fp. */
12639 for (ifag = best_fag;
12640 ifag && ifag->addr < best_fpbase + FAG_WINDOW; ifag = ifag->next)
12641 {
12642 int i;
12643
12644 for (i = 0; i < ifag->count; i++)
12645 {
12646 Elf_Internal_Rela *insn16_rel;
12647 Elf_Internal_Rela *fag_rel;
12648
12649 fag_rel = ifag->relas[i];
12650
12651 /* Only if this is within the WINDOWS, FP7U2_FLAG
12652 is applied. */
12653
12654 insn16_rel = find_relocs_at_address
12655 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12656
12657 if (insn16_rel != irelend)
12658 insn16_rel->r_addend = R_NDS32_INSN16_FP7U2_FLAG;
12659 }
12660 }
12661 return TRUE;
12662 }
12663
12664 /* Reset INSN16 to clean fp as gp. */
12665
12666 static void
nds32_fag_unmark_relax(struct nds32_fag * fag,Elf_Internal_Rela * internal_relocs,Elf_Internal_Rela * irelend)12667 nds32_fag_unmark_relax (struct nds32_fag *fag,
12668 Elf_Internal_Rela *internal_relocs,
12669 Elf_Internal_Rela *irelend)
12670 {
12671 struct nds32_fag *ifag;
12672 int i;
12673 Elf_Internal_Rela *insn16_rel;
12674 Elf_Internal_Rela *fag_rel;
12675
12676 for (ifag = fag; ifag; ifag = ifag->next)
12677 {
12678 for (i = 0; i < ifag->count; i++)
12679 {
12680 fag_rel = ifag->relas[i];
12681
12682 /* Restore the INSN16 relocation. */
12683 insn16_rel = find_relocs_at_address
12684 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12685
12686 if (insn16_rel != irelend)
12687 insn16_rel->r_addend &= ~R_NDS32_INSN16_FP7U2_FLAG;
12688 }
12689 }
12690 }
12691
12692 /* This is the main function of fp-as-gp optimization.
12693 It should be called by relax_section. */
12694
12695 static bfd_boolean
nds32_relax_fp_as_gp(struct bfd_link_info * link_info,bfd * abfd,asection * sec,Elf_Internal_Rela * internal_relocs,Elf_Internal_Rela * irelend,Elf_Internal_Sym * isymbuf)12696 nds32_relax_fp_as_gp (struct bfd_link_info *link_info,
12697 bfd *abfd, asection *sec,
12698 Elf_Internal_Rela *internal_relocs,
12699 Elf_Internal_Rela *irelend,
12700 Elf_Internal_Sym *isymbuf)
12701 {
12702 Elf_Internal_Rela *begin_rel = NULL;
12703 Elf_Internal_Rela *irel;
12704 struct nds32_fag fag_head;
12705 Elf_Internal_Shdr *symtab_hdr;
12706 bfd_byte *contents;
12707 bfd_boolean ifc_inside = FALSE;
12708
12709 /* FIXME: Can we bfd_elf_link_read_relocs for the relocs? */
12710
12711 /* Per-function fp-base selection.
12712 1. Create a list for all the gp-relative access.
12713 2. Base on those gp-relative address,
12714 find a fp-base which can cover most access.
12715 3. Use the fp-base for fp-as-gp relaxation.
12716
12717 NOTE: If fp-as-gp is not worth to do, (e.g., less than 3 times),
12718 we should
12719 1. delete the `la $fp, _FP_BASE_' instruction and
12720 2. not convert lwi.gp to lwi37.fp.
12721
12722 To delete the _FP_BASE_ instruction, we simply apply
12723 R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG flag in the r_addend to disable it.
12724
12725 To suppress the conversion, we simply NOT to apply
12726 R_NDS32_INSN16_FP7U2_FLAG flag. */
12727
12728 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12729
12730 if (!nds32_get_section_contents (abfd, sec, &contents)
12731 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12732 return FALSE;
12733
12734 /* Check whether it is worth for fp-as-gp optimization,
12735 i.e., at least 3 gp-load.
12736
12737 Set R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG if we should NOT
12738 apply this optimization. */
12739
12740 for (irel = internal_relocs; irel < irelend; irel++)
12741 {
12742 /* We recognize R_NDS32_RELAX_REGION_BEGIN/_END for the region.
12743 One we enter the begin of the region, we track all the LW/ST
12744 instructions, so when we leave the region, we try to find
12745 the best fp-base address for those LW/ST instructions. */
12746
12747 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12748 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12749 {
12750 /* Begin of the region. */
12751 if (begin_rel)
12752 (*_bfd_error_handler) (_("%B: Nested OMIT_FP in %A."), abfd, sec);
12753
12754 begin_rel = irel;
12755 nds32_fag_init (&fag_head);
12756 ifc_inside = FALSE;
12757 }
12758 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12759 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12760 {
12761 int accu;
12762 struct nds32_fag *best_fag, *tmp_fag;
12763 int dist;
12764
12765 /* End of the region.
12766 Check whether it is worth to do fp-as-gp. */
12767
12768 if (begin_rel == NULL)
12769 {
12770 (*_bfd_error_handler) (_("%B: Unmatched OMIT_FP in %A."), abfd, sec);
12771 continue;
12772 }
12773
12774 accu = nds32_fag_find_base (&fag_head, &best_fag);
12775
12776 /* Clean FP7U2_FLAG because they may set ever. */
12777 tmp_fag = fag_head.next;
12778 nds32_fag_unmark_relax (tmp_fag, internal_relocs, irelend);
12779
12780 /* Check if it is worth, and FP_BASE is near enough to SDA_BASE. */
12781 if (accu < FAG_THRESHOLD
12782 || !nds32_fag_mark_relax (link_info, abfd, best_fag,
12783 internal_relocs, irelend))
12784 {
12785 /* Not worth to do fp-as-gp. */
12786 begin_rel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12787 begin_rel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12788 irel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12789 irel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12790 nds32_fag_free_list (&fag_head);
12791 begin_rel = NULL;
12792 continue;
12793 }
12794
12795 /* R_SYM of R_NDS32_RELAX_REGION_BEGIN is not used by assembler,
12796 so we use it to record the distance to the reloction of best
12797 fp-base. */
12798 dist = best_fag->relas[0] - begin_rel;
12799 BFD_ASSERT (dist > 0 && dist < 0xffffff);
12800 /* Use high 16 bits of addend to record the _FP_BASE_ matched
12801 relocation. And get the base value when relocating. */
12802 begin_rel->r_addend &= (0x1 << 16) - 1;
12803 begin_rel->r_addend |= dist << 16;
12804
12805 nds32_fag_free_list (&fag_head);
12806 begin_rel = NULL;
12807 }
12808
12809 if (begin_rel == NULL || ifc_inside)
12810 /* Skip if we are not in the region of fp-as-gp. */
12811 continue;
12812
12813 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S2_RELA
12814 || ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA17S2_RELA)
12815 {
12816 bfd_vma addr;
12817 uint32_t insn;
12818
12819 /* A gp-relative access is found. Insert it to the fag-list. */
12820
12821 /* Rt is necessary an RT3, so it can be converted to lwi37.fp. */
12822 insn = bfd_getb32 (contents + irel->r_offset);
12823 if (!N32_IS_RT3 (insn))
12824 continue;
12825
12826 addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
12827 nds32_fag_insert (&fag_head, addr, irel);
12828 }
12829 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA_FP7U2_RELA)
12830 {
12831 begin_rel = NULL;
12832 }
12833 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12834 || ELF32_R_TYPE (irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
12835 {
12836 /* Suppress fp as gp when encounter ifc. */
12837 ifc_inside = TRUE;
12838 }
12839 }
12840
12841 return TRUE;
12842 }
12843
12844 /* Remove unused `la $fp, _FD_BASE_' instruction. */
12845
12846 static bfd_boolean
nds32_fag_remove_unused_fpbase(bfd * abfd,asection * sec,Elf_Internal_Rela * internal_relocs,Elf_Internal_Rela * irelend)12847 nds32_fag_remove_unused_fpbase (bfd *abfd, asection *sec,
12848 Elf_Internal_Rela *internal_relocs,
12849 Elf_Internal_Rela *irelend)
12850 {
12851 Elf_Internal_Rela *irel;
12852 Elf_Internal_Shdr *symtab_hdr;
12853 bfd_byte *contents = NULL;
12854 nds32_elf_blank_t *relax_blank_list = NULL;
12855 bfd_boolean result = TRUE;
12856 bfd_boolean unused_region = FALSE;
12857
12858 /*
12859 NOTE: Disable fp-as-gp if we encounter ifcall relocations.
12860 * R_NDS32_17IFC_PCREL_RELA
12861 * R_NDS32_10IFCU_PCREL_RELA
12862
12863 CASE??????????????
12864 */
12865
12866 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12867 nds32_get_section_contents (abfd, sec, &contents);
12868
12869 for (irel = internal_relocs; irel < irelend; irel++)
12870 {
12871 /* To remove unused fp-base, we simply find the REGION_NOT_OMIT_FP
12872 we marked to in previous pass.
12873 DO NOT scan relocations again, since we've alreadly decided it
12874 and set the flag. */
12875 const char *syname;
12876 int syndx;
12877 uint32_t insn;
12878
12879 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12880 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
12881 unused_region = TRUE;
12882 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12883 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
12884 unused_region = FALSE;
12885
12886 /* We're not in the region. */
12887 if (!unused_region)
12888 continue;
12889
12890 /* _FP_BASE_ must be a GLOBAL symbol. */
12891 syndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
12892 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
12893 continue;
12894
12895 /* The symbol name must be _FP_BASE_. */
12896 syname = elf_sym_hashes (abfd)[syndx]->root.root.string;
12897 if (strcmp (syname, FP_BASE_NAME) != 0)
12898 continue;
12899
12900 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA19S0_RELA)
12901 {
12902 /* addi.gp $fp, -256 */
12903 insn = bfd_getb32 (contents + irel->r_offset);
12904 if (insn != INSN_ADDIGP_TO_FP)
12905 continue;
12906 }
12907 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S0_RELA)
12908 {
12909 /* addi $fp, $gp, -256 */
12910 insn = bfd_getb32 (contents + irel->r_offset);
12911 if (insn != INSN_ADDI_GP_TO_FP)
12912 continue;
12913 }
12914 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_20_RELA)
12915 {
12916 /* movi $fp, FP_BASE */
12917 insn = bfd_getb32 (contents + irel->r_offset);
12918 if (insn != INSN_MOVI_TO_FP)
12919 continue;
12920 }
12921 else
12922 continue;
12923
12924 /* We got here because a FP_BASE instruction is found. */
12925 if (!insert_nds32_elf_blank_recalc_total
12926 (&relax_blank_list, irel->r_offset, 4))
12927 goto error_return;
12928 }
12929
12930 finish:
12931 if (relax_blank_list)
12932 {
12933 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12934 relax_blank_list = NULL;
12935 }
12936 return result;
12937
12938 error_return:
12939 result = FALSE;
12940 goto finish;
12941 }
12942
12943 /* This is a version of bfd_generic_get_relocated_section_contents.
12944 We need this variety because relaxation will modify the dwarf
12945 infomation. When there is undefined symbol reference error mesage,
12946 linker need to dump line number where the symbol be used. However
12947 the address is be relaxed, it can not get the original dwarf contents.
12948 The variety only modify function call for reading in the section. */
12949
12950 static bfd_byte *
nds32_elf_get_relocated_section_contents(bfd * abfd,struct bfd_link_info * link_info,struct bfd_link_order * link_order,bfd_byte * data,bfd_boolean relocatable,asymbol ** symbols)12951 nds32_elf_get_relocated_section_contents (bfd *abfd,
12952 struct bfd_link_info *link_info,
12953 struct bfd_link_order *link_order,
12954 bfd_byte *data,
12955 bfd_boolean relocatable,
12956 asymbol **symbols)
12957 {
12958 bfd *input_bfd = link_order->u.indirect.section->owner;
12959 asection *input_section = link_order->u.indirect.section;
12960 long reloc_size;
12961 arelent **reloc_vector;
12962 long reloc_count;
12963
12964 reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
12965 if (reloc_size < 0)
12966 return NULL;
12967
12968 /* Read in the section. */
12969 if (!nds32_get_section_contents (input_bfd, input_section, &data))
12970 return NULL;
12971
12972 if (reloc_size == 0)
12973 return data;
12974
12975 reloc_vector = (arelent **) bfd_malloc (reloc_size);
12976 if (reloc_vector == NULL)
12977 return NULL;
12978
12979 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
12980 reloc_vector, symbols);
12981 if (reloc_count < 0)
12982 goto error_return;
12983
12984 if (reloc_count > 0)
12985 {
12986 arelent **parent;
12987 for (parent = reloc_vector; *parent != NULL; parent++)
12988 {
12989 char *error_message = NULL;
12990 asymbol *symbol;
12991 bfd_reloc_status_type r;
12992
12993 symbol = *(*parent)->sym_ptr_ptr;
12994 if (symbol->section && discarded_section (symbol->section))
12995 {
12996 bfd_byte *p;
12997 static reloc_howto_type none_howto
12998 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
12999 "unused", FALSE, 0, 0, FALSE);
13000
13001 p = data + (*parent)->address * bfd_octets_per_byte (input_bfd);
13002 _bfd_clear_contents ((*parent)->howto, input_bfd, input_section,
13003 p);
13004 (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
13005 (*parent)->addend = 0;
13006 (*parent)->howto = &none_howto;
13007 r = bfd_reloc_ok;
13008 }
13009 else
13010 r = bfd_perform_relocation (input_bfd, *parent, data,
13011 input_section,
13012 relocatable ? abfd : NULL,
13013 &error_message);
13014
13015 if (relocatable)
13016 {
13017 asection *os = input_section->output_section;
13018
13019 /* A partial link, so keep the relocs. */
13020 os->orelocation[os->reloc_count] = *parent;
13021 os->reloc_count++;
13022 }
13023
13024 if (r != bfd_reloc_ok)
13025 {
13026 switch (r)
13027 {
13028 case bfd_reloc_undefined:
13029 if (!((*link_info->callbacks->undefined_symbol)
13030 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13031 input_bfd, input_section, (*parent)->address, TRUE)))
13032 goto error_return;
13033 break;
13034 case bfd_reloc_dangerous:
13035 BFD_ASSERT (error_message != NULL);
13036 if (!((*link_info->callbacks->reloc_dangerous)
13037 (link_info, error_message, input_bfd, input_section,
13038 (*parent)->address)))
13039 goto error_return;
13040 break;
13041 case bfd_reloc_overflow:
13042 if (!((*link_info->callbacks->reloc_overflow)
13043 (link_info, NULL,
13044 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13045 (*parent)->howto->name, (*parent)->addend,
13046 input_bfd, input_section, (*parent)->address)))
13047 goto error_return;
13048 break;
13049 case bfd_reloc_outofrange:
13050 /* PR ld/13730:
13051 This error can result when processing some partially
13052 complete binaries. Do not abort, but issue an error
13053 message instead. */
13054 link_info->callbacks->einfo
13055 (_("%X%P: %B(%A): relocation \"%R\" goes out of range\n"),
13056 abfd, input_section, * parent);
13057 goto error_return;
13058
13059 default:
13060 abort ();
13061 break;
13062 }
13063 }
13064 }
13065 }
13066
13067 free (reloc_vector);
13068 return data;
13069
13070 error_return:
13071 free (reloc_vector);
13072 return NULL;
13073 }
13074
13075 /* Link-time IFC relaxation.
13076 In this optimization, we chains jump instructions
13077 of the same destination with ifcall. */
13078
13079
13080 /* List to save jal and j relocation. */
13081 struct elf_nds32_ifc_symbol_entry
13082 {
13083 asection *sec;
13084 struct elf_link_hash_entry *h;
13085 struct elf_nds32_ifc_irel_list *irel_head;
13086 unsigned long insn;
13087 int times;
13088 int enable; /* Apply ifc. */
13089 int ex9_enable; /* Apply ifc after ex9. */
13090 struct elf_nds32_ifc_symbol_entry *next;
13091 };
13092
13093 struct elf_nds32_ifc_irel_list
13094 {
13095 Elf_Internal_Rela *irel;
13096 asection *sec;
13097 bfd_vma addr;
13098 /* If this is set, then it is the last instruction for
13099 ifc-chain, so it must be keep for the actual branching. */
13100 int keep;
13101 struct elf_nds32_ifc_irel_list *next;
13102 };
13103
13104 static struct elf_nds32_ifc_symbol_entry *ifc_symbol_head = NULL;
13105
13106 /* Insert symbol of jal and j for ifc. */
13107
13108 static void
nds32_elf_ifc_insert_symbol(asection * sec,struct elf_link_hash_entry * h,Elf_Internal_Rela * irel,unsigned long insn)13109 nds32_elf_ifc_insert_symbol (asection *sec,
13110 struct elf_link_hash_entry *h,
13111 Elf_Internal_Rela *irel,
13112 unsigned long insn)
13113 {
13114 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13115
13116 /* Check there is target of existing entry the same as the new one. */
13117 while (ptr != NULL)
13118 {
13119 if (((h == NULL && ptr->sec == sec
13120 && ELF32_R_SYM (ptr->irel_head->irel->r_info) == ELF32_R_SYM (irel->r_info)
13121 && ptr->irel_head->irel->r_addend == irel->r_addend)
13122 || h != NULL)
13123 && ptr->h == h
13124 && ptr->insn == insn)
13125 {
13126 /* The same target exist, so insert into list. */
13127 struct elf_nds32_ifc_irel_list *irel_list = ptr->irel_head;
13128
13129 while (irel_list->next != NULL)
13130 irel_list = irel_list->next;
13131 irel_list->next = bfd_malloc (sizeof (struct elf_nds32_ifc_irel_list));
13132 irel_list = irel_list->next;
13133 irel_list->irel = irel;
13134 irel_list->keep = 1;
13135
13136 if (h == NULL)
13137 irel_list->sec = NULL;
13138 else
13139 irel_list->sec = sec;
13140 irel_list->next = NULL;
13141 return;
13142 }
13143 if (ptr->next == NULL)
13144 break;
13145 ptr = ptr->next;
13146 }
13147
13148 /* There is no same target entry, so build a new one. */
13149 if (ifc_symbol_head == NULL)
13150 {
13151 ifc_symbol_head = bfd_malloc (sizeof (struct elf_nds32_ifc_symbol_entry));
13152 ptr = ifc_symbol_head;
13153 }
13154 else
13155 {
13156 ptr->next = bfd_malloc (sizeof (struct elf_nds32_ifc_symbol_entry));
13157 ptr = ptr->next;
13158 }
13159
13160 ptr->h = h;
13161 ptr->irel_head = bfd_malloc (sizeof (struct elf_nds32_ifc_irel_list));
13162 ptr->irel_head->irel = irel;
13163 ptr->insn = insn;
13164 ptr->irel_head->keep = 1;
13165
13166 if (h == NULL)
13167 {
13168 /* Local symbols. */
13169 ptr->sec = sec;
13170 ptr->irel_head->sec = NULL;
13171 }
13172 else
13173 {
13174 /* Global symbol. */
13175 ptr->sec = NULL;
13176 ptr->irel_head->sec = sec;
13177 }
13178
13179 ptr->irel_head->next = NULL;
13180 ptr->times = 0;
13181 ptr->enable = 0;
13182 ptr->ex9_enable = 0;
13183 ptr->next = NULL;
13184 }
13185
13186 /* Gather all jal and j instructions. */
13187
13188 static bfd_boolean
nds32_elf_ifc_calc(struct bfd_link_info * info,bfd * abfd,asection * sec)13189 nds32_elf_ifc_calc (struct bfd_link_info *info,
13190 bfd *abfd, asection *sec)
13191 {
13192 Elf_Internal_Rela *internal_relocs;
13193 Elf_Internal_Rela *irelend;
13194 Elf_Internal_Rela *irel;
13195 Elf_Internal_Shdr *symtab_hdr;
13196 bfd_byte *contents = NULL;
13197 uint32_t insn, insn_with_reg;
13198 unsigned long r_symndx;
13199 struct elf_link_hash_entry *h;
13200 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
13201 struct elf_nds32_link_hash_table *table;
13202 bfd_boolean ifc_loop_aware;
13203
13204 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
13205 TRUE /* keep_memory */);
13206 irelend = internal_relocs + sec->reloc_count;
13207 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13208
13209 /* Check if the object enable ifc. */
13210 irel = find_relocs_at_address (internal_relocs, internal_relocs, irelend,
13211 R_NDS32_RELAX_ENTRY);
13212
13213 if (irel == NULL
13214 || irel >= irelend
13215 || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
13216 || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
13217 && !(irel->r_addend & R_NDS32_RELAX_ENTRY_IFC_FLAG)))
13218 return TRUE;
13219
13220 if (!nds32_get_section_contents (abfd, sec, &contents))
13221 return FALSE;
13222
13223 table = nds32_elf_hash_table (info);
13224 ifc_loop_aware = table->ifc_loop_aware;
13225 while (irel != NULL && irel < irelend)
13226 {
13227 /* Traverse all relocation and gather all of them to build the list. */
13228
13229 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN)
13230 {
13231 if (ifc_loop_aware == 1
13232 && (irel->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG) != 0)
13233 {
13234 /* Check the region if loop or not. If it is true and
13235 ifc-loop-aware is true, ignore the region till region end. */
13236 while (irel != NULL
13237 && irel < irelend
13238 && (ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
13239 || (irel->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG) != 0))
13240 irel++;
13241 }
13242 }
13243
13244 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA)
13245 {
13246 insn = bfd_getb32 (contents + irel->r_offset);
13247 nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
13248 r_symndx = ELF32_R_SYM (irel->r_info);
13249 if (r_symndx < symtab_hdr->sh_info)
13250 {
13251 /* Local symbol. */
13252 nds32_elf_ifc_insert_symbol (sec, NULL, irel, insn_with_reg);
13253 }
13254 else
13255 {
13256 /* External symbol. */
13257 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13258 nds32_elf_ifc_insert_symbol (sec, h, irel, insn_with_reg);
13259 }
13260 }
13261 irel++;
13262 }
13263 return TRUE;
13264 }
13265
13266 /* Determine whether j and jal should be substituted. */
13267
13268 static void
nds32_elf_ifc_filter(struct bfd_link_info * info)13269 nds32_elf_ifc_filter (struct bfd_link_info *info)
13270 {
13271 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13272 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13273 struct elf_nds32_ifc_irel_list *irel_keeper = NULL;
13274 struct elf_nds32_link_hash_table *table;
13275 int target_optimize;
13276 bfd_vma address;
13277
13278 table = nds32_elf_hash_table (info);
13279 target_optimize = table->target_optimize;
13280 while (ptr)
13281 {
13282 irel_ptr = ptr->irel_head;
13283 if (ptr->h == NULL)
13284 {
13285 /* Local symbol. */
13286 irel_keeper = irel_ptr;
13287 while (irel_ptr && irel_ptr->next)
13288 {
13289 /* Check there is jump target can be used. */
13290 if ((irel_ptr->next->irel->r_offset
13291 - irel_keeper->irel->r_offset) > 1022)
13292 irel_keeper = irel_ptr->next;
13293 else
13294 {
13295 ptr->enable = 1;
13296 irel_ptr->keep = 0;
13297 }
13298 irel_ptr = irel_ptr->next;
13299 }
13300 }
13301 else
13302 {
13303 /* Global symbol. */
13304 /* We have to get the absolute address and decide
13305 whether to keep it or not. */
13306 while (irel_ptr)
13307 {
13308 address = (irel_ptr->irel->r_offset
13309 + irel_ptr->sec->output_section->vma
13310 + irel_ptr->sec->output_offset);
13311 irel_ptr->addr = address;
13312 irel_ptr = irel_ptr->next;
13313 }
13314
13315 irel_ptr = ptr->irel_head;
13316 while (irel_ptr)
13317 {
13318 /* Sort by address. */
13319 struct elf_nds32_ifc_irel_list *irel_dest = irel_ptr;
13320 struct elf_nds32_ifc_irel_list *irel_temp = irel_ptr;
13321 struct elf_nds32_ifc_irel_list *irel_ptr_prev = NULL;
13322 struct elf_nds32_ifc_irel_list *irel_dest_prev = NULL;
13323
13324 /* Get the smallest one. */
13325 while (irel_temp->next)
13326 {
13327 if (irel_temp->next->addr < irel_dest->addr)
13328 {
13329 irel_dest_prev = irel_temp;
13330 irel_dest = irel_temp->next;
13331 }
13332 irel_temp = irel_temp->next;
13333 }
13334
13335 if (irel_dest != irel_ptr)
13336 {
13337 if (irel_ptr_prev)
13338 irel_ptr_prev->next = irel_dest;
13339 if (irel_dest_prev)
13340 irel_dest_prev->next = irel_ptr;
13341 irel_temp = irel_ptr->next;
13342 irel_ptr->next = irel_dest->next;
13343 irel_dest->next = irel_temp;
13344 }
13345 irel_ptr_prev = irel_ptr;
13346 irel_ptr = irel_ptr->next;
13347 }
13348
13349 irel_ptr = ptr->irel_head;
13350 irel_keeper = irel_ptr;
13351 while (irel_ptr && irel_ptr->next)
13352 {
13353 if ((irel_ptr->next->addr - irel_keeper->addr) > 1022)
13354 irel_keeper = irel_ptr->next;
13355 else
13356 {
13357 ptr->enable = 1;
13358 irel_ptr->keep = 0;
13359 }
13360 irel_ptr = irel_ptr->next;
13361 }
13362 }
13363
13364 /* Ex9 enable. Reserve it for ex9. */
13365 if ((target_optimize & NDS32_RELAX_EX9_ON)
13366 && ptr->irel_head != irel_keeper)
13367 ptr->enable = 0;
13368 ptr = ptr->next;
13369 }
13370 }
13371
13372 /* Determine whether j and jal should be substituted after ex9 done. */
13373
13374 static void
nds32_elf_ifc_filter_after_ex9(void)13375 nds32_elf_ifc_filter_after_ex9 (void)
13376 {
13377 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13378 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13379
13380 while (ptr)
13381 {
13382 if (ptr->enable == 0)
13383 {
13384 /* Check whether ifc is applied or not. */
13385 irel_ptr = ptr->irel_head;
13386 ptr->ex9_enable = 1;
13387 while (irel_ptr)
13388 {
13389 if (ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_TRAN)
13390 {
13391 /* Ex9 already. */
13392 ptr->ex9_enable = 0;
13393 break;
13394 }
13395 irel_ptr = irel_ptr->next;
13396 }
13397 }
13398 ptr = ptr->next;
13399 }
13400 }
13401
13402 /* Wrapper to do ifc relaxation. */
13403
13404 bfd_boolean
nds32_elf_ifc_finish(struct bfd_link_info * info)13405 nds32_elf_ifc_finish (struct bfd_link_info *info)
13406 {
13407 int relax_status;
13408 struct elf_nds32_link_hash_table *table;
13409
13410 table = nds32_elf_hash_table (info);
13411 relax_status = table->relax_status;
13412
13413 if (!(relax_status & NDS32_RELAX_JUMP_IFC_DONE))
13414 nds32_elf_ifc_filter (info);
13415 else
13416 nds32_elf_ifc_filter_after_ex9 ();
13417
13418 if (!nds32_elf_ifc_replace (info))
13419 return FALSE;
13420
13421 if (table)
13422 table->relax_status |= NDS32_RELAX_JUMP_IFC_DONE;
13423 return TRUE;
13424 }
13425
13426 /* Traverse the result of ifc filter and replace it with ifcall9. */
13427
13428 static bfd_boolean
nds32_elf_ifc_replace(struct bfd_link_info * info)13429 nds32_elf_ifc_replace (struct bfd_link_info *info)
13430 {
13431 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13432 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13433 nds32_elf_blank_t *relax_blank_list = NULL;
13434 bfd_byte *contents = NULL;
13435 Elf_Internal_Rela *internal_relocs;
13436 Elf_Internal_Rela *irel;
13437 Elf_Internal_Rela *irelend;
13438 unsigned short insn16 = INSN_IFCALL9;
13439 struct elf_nds32_link_hash_table *table;
13440 int relax_status;
13441
13442 table = nds32_elf_hash_table (info);
13443 relax_status = table->relax_status;
13444
13445 while (ptr)
13446 {
13447 /* Traverse the ifc gather list, and replace the
13448 filter entries by ifcall9. */
13449 if ((!(relax_status & NDS32_RELAX_JUMP_IFC_DONE) && ptr->enable == 1)
13450 || ((relax_status & NDS32_RELAX_JUMP_IFC_DONE)
13451 && ptr->ex9_enable == 1))
13452 {
13453 irel_ptr = ptr->irel_head;
13454 if (ptr->h == NULL)
13455 {
13456 /* Local symbol. */
13457 internal_relocs = _bfd_elf_link_read_relocs
13458 (ptr->sec->owner, ptr->sec, NULL, NULL, TRUE /* keep_memory */);
13459 irelend = internal_relocs + ptr->sec->reloc_count;
13460
13461 if (!nds32_get_section_contents (ptr->sec->owner, ptr->sec,
13462 &contents))
13463 return FALSE;
13464
13465 while (irel_ptr)
13466 {
13467 if (irel_ptr->keep == 0 && irel_ptr->next)
13468 {
13469 /* The one can be replaced. We have to check whether
13470 there is any alignment point in the region. */
13471 irel = irel_ptr->irel;
13472 while (((irel_ptr->next->keep == 0
13473 && irel < irel_ptr->next->irel)
13474 || (irel_ptr->next->keep == 1 && irel < irelend))
13475 && !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13476 && (irel->r_addend & 0x1f) == 2))
13477 irel++;
13478 if (irel >= irelend
13479 || !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13480 && (irel->r_addend & 0x1f) == 2
13481 && ((irel->r_offset - get_nds32_elf_blank_total
13482 (&relax_blank_list, irel->r_offset, 1))
13483 & 0x02) == 0))
13484 {
13485 /* Replace by ifcall9. */
13486 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13487 if (!insert_nds32_elf_blank_recalc_total
13488 (&relax_blank_list, irel_ptr->irel->r_offset + 2, 2))
13489 return FALSE;
13490 irel_ptr->irel->r_info =
13491 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13492 R_NDS32_10IFCU_PCREL_RELA);
13493 }
13494 }
13495 irel_ptr = irel_ptr->next;
13496 }
13497
13498 /* Delete the redundant code. */
13499 if (relax_blank_list)
13500 {
13501 nds32_elf_relax_delete_blanks (ptr->sec->owner, ptr->sec,
13502 relax_blank_list);
13503 relax_blank_list = NULL;
13504 }
13505 }
13506 else
13507 {
13508 /* Global symbol. */
13509 while (irel_ptr)
13510 {
13511 if (irel_ptr->keep == 0 && irel_ptr->next)
13512 {
13513 /* The one can be replaced, and we have to check
13514 whether there is any alignment point in the region. */
13515 internal_relocs = _bfd_elf_link_read_relocs
13516 (irel_ptr->sec->owner, irel_ptr->sec, NULL, NULL,
13517 TRUE /* keep_memory */);
13518 irelend = internal_relocs + irel_ptr->sec->reloc_count;
13519 if (!nds32_get_section_contents
13520 (irel_ptr->sec->owner, irel_ptr->sec, &contents))
13521 return FALSE;
13522
13523 irel = irel_ptr->irel;
13524 while (((irel_ptr->sec == irel_ptr->next->sec
13525 && irel_ptr->next->keep == 0
13526 && irel < irel_ptr->next->irel)
13527 || ((irel_ptr->sec != irel_ptr->next->sec
13528 || irel_ptr->next->keep == 1)
13529 && irel < irelend))
13530 && !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13531 && (irel->r_addend & 0x1f) == 2))
13532 irel++;
13533 if (irel >= irelend
13534 || !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13535 && (irel->r_addend & 0x1f) == 2
13536 && ((irel->r_offset
13537 - get_nds32_elf_blank_total (&relax_blank_list,
13538 irel->r_offset, 1)) & 0x02) == 0))
13539 {
13540 /* Replace by ifcall9. */
13541 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13542 if (!insert_nds32_elf_blank_recalc_total
13543 (&relax_blank_list, irel_ptr->irel->r_offset + 2, 2))
13544 return FALSE;
13545
13546 /* Delete the redundant code, and clear the relocation. */
13547 nds32_elf_relax_delete_blanks (irel_ptr->sec->owner,
13548 irel_ptr->sec,
13549 relax_blank_list);
13550 irel_ptr->irel->r_info =
13551 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13552 R_NDS32_10IFCU_PCREL_RELA);
13553 relax_blank_list = NULL;
13554 }
13555 }
13556
13557 irel_ptr = irel_ptr->next;
13558 }
13559 }
13560 }
13561 ptr = ptr->next;
13562 }
13563
13564 return TRUE;
13565 }
13566
13567 /* Relocate ifcall. */
13568
13569 static bfd_boolean
nds32_elf_ifc_reloc(void)13570 nds32_elf_ifc_reloc (void)
13571 {
13572 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13573 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13574 struct elf_nds32_ifc_irel_list *irel_keeper = NULL;
13575 bfd_vma relocation, address;
13576 unsigned short insn16;
13577 bfd_byte *contents = NULL;
13578 static bfd_boolean done = FALSE;
13579
13580 if (done)
13581 return TRUE;
13582
13583 done = TRUE;
13584
13585 while (ptr)
13586 {
13587 /* Check the entry is enable ifcall. */
13588 if (ptr->enable == 1 || ptr->ex9_enable == 1)
13589 {
13590 /* Get the reserve jump. */
13591 irel_ptr = ptr->irel_head;
13592 while (irel_ptr)
13593 {
13594 if (irel_ptr->keep == 1)
13595 {
13596 irel_keeper = irel_ptr;
13597 break;
13598 }
13599 irel_ptr = irel_ptr->next;
13600 }
13601
13602 irel_ptr = ptr->irel_head;
13603 if (ptr->h == NULL)
13604 {
13605 /* Local symbol. */
13606 if (!nds32_get_section_contents (ptr->sec->owner, ptr->sec, &contents))
13607 return FALSE;
13608
13609 while (irel_ptr)
13610 {
13611 if (irel_ptr->keep == 0
13612 && ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13613 {
13614 relocation = irel_keeper->irel->r_offset;
13615 relocation = relocation - irel_ptr->irel->r_offset;
13616 while (irel_keeper && relocation > 1022)
13617 {
13618 irel_keeper = irel_keeper->next;
13619 if (irel_keeper && irel_keeper->keep == 1)
13620 {
13621 relocation = irel_keeper->irel->r_offset;
13622 relocation = relocation - irel_ptr->irel->r_offset;
13623 }
13624 }
13625 if (relocation > 1022)
13626 {
13627 /* Double check. */
13628 irel_keeper = ptr->irel_head;
13629 while (irel_keeper)
13630 {
13631 if (irel_keeper->keep == 1)
13632 {
13633 relocation = irel_keeper->irel->r_offset;
13634 relocation = relocation - irel_ptr->irel->r_offset;
13635 }
13636 if (relocation <= 1022)
13637 break;
13638 irel_keeper = irel_keeper->next;
13639 }
13640 if (!irel_keeper)
13641 return FALSE;
13642 }
13643 irel_ptr->irel->r_info =
13644 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13645 R_NDS32_NONE);
13646 insn16 = INSN_IFCALL9 | (relocation >> 1);
13647 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13648 }
13649 irel_ptr = irel_ptr->next;
13650 }
13651 }
13652 else
13653 {
13654 /* Global symbol. */
13655 while (irel_ptr)
13656 {
13657 if (irel_ptr->keep == 0
13658 && ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13659 {
13660 /* Get the distance between ifcall and jump. */
13661 relocation = (irel_keeper->irel->r_offset
13662 + irel_keeper->sec->output_section->vma
13663 + irel_keeper->sec->output_offset);
13664 address = (irel_ptr->irel->r_offset
13665 + irel_ptr->sec->output_section->vma
13666 + irel_ptr->sec->output_offset);
13667 relocation = relocation - address;
13668
13669 /* The distance is over ragne, find callee again. */
13670 while (irel_keeper && relocation > 1022)
13671 {
13672 irel_keeper = irel_keeper->next;
13673 if (irel_keeper && irel_keeper->keep ==1)
13674 {
13675 relocation = (irel_keeper->irel->r_offset
13676 + irel_keeper->sec->output_section->vma
13677 + irel_keeper->sec->output_offset);
13678 relocation = relocation - address;
13679 }
13680 }
13681
13682 if (relocation > 1022)
13683 {
13684 /* Double check. */
13685 irel_keeper = ptr->irel_head;
13686 while (irel_keeper)
13687 {
13688 if (irel_keeper->keep == 1)
13689 {
13690
13691 relocation = (irel_keeper->irel->r_offset
13692 + irel_keeper->sec->output_section->vma
13693 + irel_keeper->sec->output_offset);
13694 relocation = relocation - address;
13695 }
13696 if (relocation <= 1022)
13697 break;
13698 irel_keeper = irel_keeper->next;
13699 }
13700 if (!irel_keeper)
13701 return FALSE;
13702 }
13703 if (!nds32_get_section_contents
13704 (irel_ptr->sec->owner, irel_ptr->sec, &contents))
13705 return FALSE;
13706 insn16 = INSN_IFCALL9 | (relocation >> 1);
13707 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13708 irel_ptr->irel->r_info =
13709 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13710 R_NDS32_NONE);
13711 }
13712 irel_ptr =irel_ptr->next;
13713 }
13714 }
13715 }
13716 ptr = ptr->next;
13717 }
13718
13719 return TRUE;
13720 }
13721
13722 /* End of IFC relaxation. */
13723
13724 /* EX9 Instruction Table Relaxation. */
13725
13726 /* Global hash list. */
13727 struct elf_link_hash_entry_list
13728 {
13729 struct elf_link_hash_entry *h;
13730 struct elf_link_hash_entry_list *next;
13731 };
13732
13733 /* Save different destination but same insn. */
13734 struct elf_link_hash_entry_mul_list
13735 {
13736 /* Global symbol times. */
13737 int times;
13738 /* Save relocation for each global symbol but useful?? */
13739 Elf_Internal_Rela *irel;
13740 /* For sethi, two sethi may have the same high-part but different low-parts. */
13741 Elf_Internal_Rela rel_backup;
13742 struct elf_link_hash_entry_list *h_list;
13743 struct elf_link_hash_entry_mul_list *next;
13744 };
13745
13746 /* Instruction hash table. */
13747 struct elf_nds32_code_hash_entry
13748 {
13749 struct bfd_hash_entry root;
13750 int times;
13751 /* For insn that can use relocation or constant ex: sethi. */
13752 int const_insn;
13753 asection *sec;
13754 struct elf_link_hash_entry_mul_list *m_list;
13755 /* Using r_addend. */
13756 Elf_Internal_Rela *irel;
13757 /* Using r_info. */
13758 Elf_Internal_Rela rel_backup;
13759 };
13760
13761 /* Instruction count list. */
13762 struct elf_nds32_insn_times_entry
13763 {
13764 const char *string;
13765 int times;
13766 int order;
13767 asection *sec;
13768 struct elf_link_hash_entry_mul_list *m_list;
13769 Elf_Internal_Rela *irel;
13770 Elf_Internal_Rela rel_backup;
13771 struct elf_nds32_insn_times_entry *next;
13772 };
13773
13774 /* J and JAL symbol list. */
13775 struct elf_nds32_symbol_entry
13776 {
13777 char *string;
13778 unsigned long insn;
13779 struct elf_nds32_symbol_entry *next;
13780 };
13781
13782 /* Relocation list. */
13783 struct elf_nds32_irel_entry
13784 {
13785 Elf_Internal_Rela *irel;
13786 struct elf_nds32_irel_entry *next;
13787 };
13788
13789 /* ex9.it insn need to be fixed. */
13790 struct elf_nds32_ex9_refix
13791 {
13792 Elf_Internal_Rela *irel;
13793 asection *sec;
13794 struct elf_link_hash_entry *h;
13795 int order;
13796 struct elf_nds32_ex9_refix *next;
13797 };
13798
13799 static struct bfd_hash_table ex9_code_table;
13800 static struct elf_nds32_insn_times_entry *ex9_insn_head = NULL;
13801 static struct elf_nds32_ex9_refix *ex9_refix_head = NULL;
13802
13803 /* EX9 hash function. */
13804
13805 static struct bfd_hash_entry *
nds32_elf_code_hash_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)13806 nds32_elf_code_hash_newfunc (struct bfd_hash_entry *entry,
13807 struct bfd_hash_table *table,
13808 const char *string)
13809 {
13810 struct elf_nds32_code_hash_entry *ret;
13811
13812 /* Allocate the structure if it has not already been allocated by a
13813 subclass. */
13814 if (entry == NULL)
13815 {
13816 entry = (struct bfd_hash_entry *)
13817 bfd_hash_allocate (table, sizeof (*ret));
13818 if (entry == NULL)
13819 return entry;
13820 }
13821
13822 /* Call the allocation method of the superclass. */
13823 entry = bfd_hash_newfunc (entry, table, string);
13824 if (entry == NULL)
13825 return entry;
13826
13827 ret = (struct elf_nds32_code_hash_entry*) entry;
13828 ret->times = 0;
13829 ret->const_insn = 0;
13830 ret->m_list = NULL;
13831 ret->sec = NULL;
13832 ret->irel = NULL;
13833 return &ret->root;
13834 }
13835
13836 /* Insert ex9 entry
13837 this insert must be stable sorted by times. */
13838
13839 static void
nds32_elf_ex9_insert_entry(struct elf_nds32_insn_times_entry * ptr)13840 nds32_elf_ex9_insert_entry (struct elf_nds32_insn_times_entry *ptr)
13841 {
13842 struct elf_nds32_insn_times_entry *temp;
13843 struct elf_nds32_insn_times_entry *temp2;
13844
13845 if (ex9_insn_head == NULL)
13846 {
13847 ex9_insn_head = ptr;
13848 ptr->next = NULL;
13849 }
13850 else
13851 {
13852 temp = ex9_insn_head;
13853 temp2 = ex9_insn_head;
13854 while (temp->next &&
13855 (temp->next->times >= ptr->times
13856 || temp->times == -1))
13857 {
13858 if (temp->times == -1)
13859 temp2 = temp;
13860 temp = temp->next;
13861 }
13862 if (ptr->times > temp->times && temp->times != -1)
13863 {
13864 ptr->next = temp;
13865 if (temp2->times == -1)
13866 temp2->next = ptr;
13867 else
13868 ex9_insn_head = ptr;
13869 }
13870 else if (temp->next == NULL)
13871 {
13872 temp->next = ptr;
13873 ptr->next = NULL;
13874 }
13875 else
13876 {
13877 ptr->next = temp->next;
13878 temp->next = ptr;
13879 }
13880 }
13881 }
13882
13883 /* Examine each insn times in hash table.
13884 Handle multi-link hash entry.
13885
13886 TODO: This function doesn't assign so much info since it is fake. */
13887
13888 static int
nds32_elf_examine_insn_times(struct elf_nds32_code_hash_entry * h)13889 nds32_elf_examine_insn_times (struct elf_nds32_code_hash_entry *h)
13890 {
13891 struct elf_nds32_insn_times_entry *ptr;
13892 int times;
13893
13894 if (h->m_list == NULL)
13895 {
13896 /* Local symbol insn or insn without relocation. */
13897 if (h->times < 3)
13898 return TRUE;
13899
13900 ptr = (struct elf_nds32_insn_times_entry *)
13901 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13902 ptr->times = h->times;
13903 ptr->string = h->root.string;
13904 ptr->m_list = NULL;
13905 ptr->sec = h->sec;
13906 ptr->irel = h->irel;
13907 ptr->rel_backup = h->rel_backup;
13908 nds32_elf_ex9_insert_entry (ptr);
13909 }
13910 else
13911 {
13912 /* Global symbol insn. */
13913 /* Only sethi insn has multiple m_list. */
13914 struct elf_link_hash_entry_mul_list *m_list = h->m_list;
13915
13916 times = 0;
13917 while (m_list)
13918 {
13919 times += m_list->times;
13920 m_list = m_list->next;
13921 }
13922 if (times >= 3)
13923 {
13924 m_list = h->m_list;
13925 ptr = (struct elf_nds32_insn_times_entry *)
13926 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13927 ptr->times = times; /* Use the total times. */
13928 ptr->string = h->root.string;
13929 ptr->m_list = m_list;
13930 ptr->sec = h->sec;
13931 ptr->irel = m_list->irel;
13932 ptr->rel_backup = m_list->rel_backup;
13933 nds32_elf_ex9_insert_entry (ptr);
13934 }
13935 if (h->const_insn == 1)
13936 {
13937 /* sethi with constant value. */
13938 if (h->times < 3)
13939 return TRUE;
13940
13941 ptr = (struct elf_nds32_insn_times_entry *)
13942 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13943 ptr->times = h->times;
13944 ptr->string = h->root.string;
13945 ptr->m_list = NULL;
13946 ptr->sec = NULL;
13947 ptr->irel = NULL;
13948 ptr->rel_backup = h->rel_backup;
13949 nds32_elf_ex9_insert_entry (ptr);
13950 }
13951 }
13952 return TRUE;
13953 }
13954
13955 /* Count each insn times in hash table.
13956 Handle multi-link hash entry. */
13957
13958 static int
nds32_elf_count_insn_times(struct elf_nds32_code_hash_entry * h)13959 nds32_elf_count_insn_times (struct elf_nds32_code_hash_entry *h)
13960 {
13961 int reservation, times;
13962 unsigned long relocation, min_relocation;
13963 struct elf_nds32_insn_times_entry *ptr;
13964
13965 if (h->m_list == NULL)
13966 {
13967 /* Local symbol insn or insn without relocation. */
13968 if (h->times < 3)
13969 return TRUE;
13970 ptr = (struct elf_nds32_insn_times_entry *)
13971 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13972 ptr->times = h->times;
13973 ptr->string = h->root.string;
13974 ptr->m_list = NULL;
13975 ptr->sec = h->sec;
13976 ptr->irel = h->irel;
13977 ptr->rel_backup = h->rel_backup;
13978 nds32_elf_ex9_insert_entry (ptr);
13979 }
13980 else
13981 {
13982 /* Global symbol insn. */
13983 /* Only sethi insn has multiple m_list. */
13984 struct elf_link_hash_entry_mul_list *m_list = h->m_list;
13985
13986 if (ELF32_R_TYPE (m_list->rel_backup.r_info) == R_NDS32_HI20_RELA
13987 && m_list->next != NULL)
13988 {
13989 /* Sethi insn has different symbol or addend but has same hi20. */
13990 times = 0;
13991 reservation = 1;
13992 relocation = 0;
13993 min_relocation = 0xffffffff;
13994 while (m_list)
13995 {
13996 /* Get the minimum sethi address
13997 and calculate how many entry the sethi-list have to use. */
13998 if ((m_list->h_list->h->root.type == bfd_link_hash_defined
13999 || m_list->h_list->h->root.type == bfd_link_hash_defweak)
14000 && (m_list->h_list->h->root.u.def.section != NULL
14001 && m_list->h_list->h->root.u.def.section->output_section != NULL))
14002 {
14003 relocation = (m_list->h_list->h->root.u.def.value +
14004 m_list->h_list->h->root.u.def.section->output_section->vma +
14005 m_list->h_list->h->root.u.def.section->output_offset);
14006 relocation += m_list->irel->r_addend;
14007 }
14008 else
14009 relocation = 0;
14010 if (relocation < min_relocation)
14011 min_relocation = relocation;
14012 times += m_list->times;
14013 m_list = m_list->next;
14014 }
14015 if (min_relocation < ex9_relax_size)
14016 reservation = (min_relocation >> 12) + 1;
14017 else
14018 reservation = (min_relocation >> 12)
14019 - ((min_relocation - ex9_relax_size) >> 12) + 1;
14020 if (reservation < (times / 3))
14021 {
14022 /* Efficient enough to use ex9. */
14023 int i;
14024
14025 for (i = reservation ; i > 0; i--)
14026 {
14027 /* Allocate number of reservation ex9 entry. */
14028 ptr = (struct elf_nds32_insn_times_entry *)
14029 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14030 ptr->times = h->m_list->times / reservation;
14031 ptr->string = h->root.string;
14032 ptr->m_list = h->m_list;
14033 ptr->sec = h->sec;
14034 ptr->irel = h->m_list->irel;
14035 ptr->rel_backup = h->m_list->rel_backup;
14036 nds32_elf_ex9_insert_entry (ptr);
14037 }
14038 }
14039 }
14040 else
14041 {
14042 /* Normal global symbol that means no different address symbol
14043 using same ex9 entry. */
14044 if (m_list->times >= 3)
14045 {
14046 ptr = (struct elf_nds32_insn_times_entry *)
14047 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14048 ptr->times = m_list->times;
14049 ptr->string = h->root.string;
14050 ptr->m_list = h->m_list;
14051 ptr->sec = h->sec;
14052 ptr->irel = h->m_list->irel;
14053 ptr->rel_backup = h->m_list->rel_backup;
14054 nds32_elf_ex9_insert_entry (ptr);
14055 }
14056 }
14057
14058 if (h->const_insn == 1)
14059 {
14060 /* sethi with constant value. */
14061 if (h->times < 3)
14062 return TRUE;
14063
14064 ptr = (struct elf_nds32_insn_times_entry *)
14065 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14066 ptr->times = h->times;
14067 ptr->string = h->root.string;
14068 ptr->m_list = NULL;
14069 ptr->sec = NULL;
14070 ptr->irel = NULL;
14071 ptr->rel_backup = h->rel_backup;
14072 nds32_elf_ex9_insert_entry (ptr);
14073 }
14074 }
14075
14076 return TRUE;
14077 }
14078
14079 /* Hash table traverse function. */
14080
14081 static void
nds32_elf_code_hash_traverse(int (* func)(struct elf_nds32_code_hash_entry *))14082 nds32_elf_code_hash_traverse (int (*func) (struct elf_nds32_code_hash_entry*))
14083 {
14084 unsigned int i;
14085
14086 ex9_code_table.frozen = 1;
14087 for (i = 0; i < ex9_code_table.size; i++)
14088 {
14089 struct bfd_hash_entry *p;
14090
14091 for (p = ex9_code_table.table[i]; p != NULL; p = p->next)
14092 if (!func ((struct elf_nds32_code_hash_entry *) p))
14093 goto out;
14094 }
14095 out:
14096 ex9_code_table.frozen = 0;
14097 }
14098
14099
14100 /* Give order number to insn list. */
14101
14102 static void
nds32_elf_order_insn_times(struct bfd_link_info * info)14103 nds32_elf_order_insn_times (struct bfd_link_info *info)
14104 {
14105 struct elf_nds32_insn_times_entry *ex9_insn;
14106 struct elf_nds32_insn_times_entry *temp = NULL;
14107 struct elf_nds32_link_hash_table *table;
14108 int ex9_limit;
14109 int number = 0;
14110
14111 if (ex9_insn_head == NULL)
14112 return;
14113
14114 /* The max number of entries is 512. */
14115 ex9_insn = ex9_insn_head;
14116 table = nds32_elf_hash_table (info);
14117 ex9_limit = table->ex9_limit;
14118
14119 ex9_insn = ex9_insn_head;
14120
14121 while (ex9_insn != NULL && number < ex9_limit)
14122 {
14123 ex9_insn->order = number;
14124 number++;
14125 temp = ex9_insn;
14126 ex9_insn = ex9_insn->next;
14127 }
14128
14129 if (ex9_insn && temp)
14130 temp->next = NULL;
14131
14132 while (ex9_insn != NULL)
14133 {
14134 /* Free useless entry. */
14135 temp = ex9_insn;
14136 ex9_insn = ex9_insn->next;
14137 free (temp);
14138 }
14139 }
14140
14141 /* Build .ex9.itable section. */
14142
14143 static void
nds32_elf_ex9_build_itable(struct bfd_link_info * link_info)14144 nds32_elf_ex9_build_itable (struct bfd_link_info *link_info)
14145 {
14146 asection *table_sec;
14147 struct elf_nds32_insn_times_entry *ptr;
14148 bfd *it_abfd;
14149 int number = 0;
14150 bfd_byte *contents = NULL;
14151
14152 for (it_abfd = link_info->input_bfds; it_abfd != NULL;
14153 it_abfd = it_abfd->link.next)
14154 {
14155 /* Find the section .ex9.itable, and put all entries into it. */
14156 table_sec = bfd_get_section_by_name (it_abfd, ".ex9.itable");
14157 if (table_sec != NULL)
14158 {
14159 if (!nds32_get_section_contents (it_abfd, table_sec, &contents))
14160 return;
14161
14162 for (ptr = ex9_insn_head; ptr !=NULL ; ptr = ptr->next)
14163 number++;
14164
14165 table_sec->size = number * 4;
14166
14167 if (number == 0)
14168 return;
14169
14170 elf_elfheader (link_info->output_bfd)->e_flags |= E_NDS32_HAS_EX9_INST;
14171 number = 0;
14172 for (ptr = ex9_insn_head; ptr !=NULL ; ptr = ptr->next)
14173 {
14174 long val;
14175
14176 val = strtol (ptr->string, NULL, 16);
14177 bfd_putb32 ((bfd_vma) val, (char *) contents + (number * 4));
14178 number++;
14179 }
14180 break;
14181 }
14182 }
14183 }
14184
14185 /* Get insn with regs according to relocation type. */
14186
14187 static void
nds32_elf_get_insn_with_reg(Elf_Internal_Rela * irel,uint32_t insn,uint32_t * insn_with_reg)14188 nds32_elf_get_insn_with_reg (Elf_Internal_Rela *irel,
14189 uint32_t insn, uint32_t *insn_with_reg)
14190 {
14191 reloc_howto_type *howto = NULL;
14192
14193 if (irel == NULL
14194 || (ELF32_R_TYPE (irel->r_info) >= (int) ARRAY_SIZE (nds32_elf_howto_table)
14195 && (ELF32_R_TYPE (irel->r_info) - R_NDS32_RELAX_ENTRY)
14196 >= (int) ARRAY_SIZE (nds32_elf_relax_howto_table)))
14197 {
14198 *insn_with_reg = insn;
14199 return;
14200 }
14201
14202 howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
14203 *insn_with_reg = insn & (0xffffffff ^ howto->dst_mask);
14204 }
14205
14206 /* Mask number of address bits according to relocation. */
14207
14208 static unsigned long
nds32_elf_irel_mask(Elf_Internal_Rela * irel)14209 nds32_elf_irel_mask (Elf_Internal_Rela *irel)
14210 {
14211 reloc_howto_type *howto = NULL;
14212
14213 if (irel == NULL
14214 || (ELF32_R_TYPE (irel->r_info) >= (int) ARRAY_SIZE (nds32_elf_howto_table)
14215 && (ELF32_R_TYPE (irel->r_info) - R_NDS32_RELAX_ENTRY)
14216 >= (int) ARRAY_SIZE (nds32_elf_relax_howto_table)))
14217 return 0;
14218
14219 howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
14220 return howto->dst_mask;
14221 }
14222
14223 static void
nds32_elf_insert_irel_entry(struct elf_nds32_irel_entry ** irel_list,struct elf_nds32_irel_entry * irel_ptr)14224 nds32_elf_insert_irel_entry (struct elf_nds32_irel_entry **irel_list,
14225 struct elf_nds32_irel_entry *irel_ptr)
14226 {
14227 if (*irel_list == NULL)
14228 {
14229 *irel_list = irel_ptr;
14230 irel_ptr->next = NULL;
14231 }
14232 else
14233 {
14234 irel_ptr->next = *irel_list;
14235 *irel_list = irel_ptr;
14236 }
14237 }
14238
14239 static void
nds32_elf_ex9_insert_fix(asection * sec,Elf_Internal_Rela * irel,struct elf_link_hash_entry * h,int order)14240 nds32_elf_ex9_insert_fix (asection * sec, Elf_Internal_Rela * irel,
14241 struct elf_link_hash_entry *h, int order)
14242 {
14243 struct elf_nds32_ex9_refix *ptr;
14244
14245 ptr = bfd_malloc (sizeof (struct elf_nds32_ex9_refix));
14246 ptr->sec = sec;
14247 ptr->irel = irel;
14248 ptr->h = h;
14249 ptr->order = order;
14250 ptr->next = NULL;
14251
14252 if (ex9_refix_head == NULL)
14253 ex9_refix_head = ptr;
14254 else
14255 {
14256 struct elf_nds32_ex9_refix *temp = ex9_refix_head;
14257
14258 while (temp->next != NULL)
14259 temp = temp->next;
14260 temp->next = ptr;
14261 }
14262 }
14263
14264 enum
14265 {
14266 DATA_EXIST = 1,
14267 CLEAN_PRE = 1 << 1,
14268 PUSH_PRE = 1 << 2
14269 };
14270
14271 /* Check relocation type if supporting for ex9. */
14272
14273 static int
nds32_elf_ex9_relocation_check(struct bfd_link_info * info,Elf_Internal_Rela ** irel,Elf_Internal_Rela * irelend,nds32_elf_blank_t * relax_blank_list,asection * sec,bfd_vma * off,bfd_byte * contents)14274 nds32_elf_ex9_relocation_check (struct bfd_link_info *info,
14275 Elf_Internal_Rela **irel,
14276 Elf_Internal_Rela *irelend,
14277 nds32_elf_blank_t *relax_blank_list,
14278 asection *sec,bfd_vma *off,
14279 bfd_byte *contents)
14280 {
14281 /* Suppress ex9 if `.no_relax ex9' or inner loop. */
14282 bfd_boolean nested_ex9, nested_loop;
14283 bfd_boolean ex9_loop_aware;
14284 /* We use the highest 1 byte of result to record
14285 how many bytes location counter has to move. */
14286 int result = 0;
14287 Elf_Internal_Rela *irel_save = NULL;
14288 struct elf_nds32_link_hash_table *table;
14289
14290 table = nds32_elf_hash_table (info);
14291 ex9_loop_aware = table->ex9_loop_aware;
14292
14293 while ((*irel) != NULL && (*irel) < irelend && *off == (*irel)->r_offset)
14294 {
14295 switch (ELF32_R_TYPE ((*irel)->r_info))
14296 {
14297 case R_NDS32_RELAX_REGION_BEGIN:
14298 /* Ignore code block. */
14299 nested_ex9 = FALSE;
14300 nested_loop = FALSE;
14301 if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG)
14302 || (ex9_loop_aware
14303 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG)))
14304 {
14305 /* Check the region if loop or not. If it is true and
14306 ex9-loop-aware is true, ignore the region till region end. */
14307 /* To save the status for in .no_relax ex9 region and
14308 loop region to conform the block can do ex9 relaxation. */
14309 nested_ex9 = ((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG);
14310 nested_loop = (ex9_loop_aware
14311 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG));
14312 while ((*irel) && (*irel) < irelend && (nested_ex9 || nested_loop))
14313 {
14314 (*irel)++;
14315 if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_RELAX_REGION_BEGIN)
14316 {
14317 /* There may be nested region. */
14318 if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG) != 0)
14319 nested_ex9 = TRUE;
14320 else if (ex9_loop_aware
14321 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG))
14322 nested_loop = TRUE;
14323 }
14324 else if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_RELAX_REGION_END)
14325 {
14326 /* The end of region. */
14327 if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG) != 0)
14328 nested_ex9 = FALSE;
14329 else if (ex9_loop_aware
14330 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG))
14331 nested_loop = FALSE;
14332 }
14333 else if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_LABEL
14334 && ((*irel)->r_addend & 0x1f) == 2)
14335 {
14336 /* Alignment exist in the region. */
14337 result |= CLEAN_PRE;
14338 if (((*irel)->r_offset -
14339 get_nds32_elf_blank_total (&relax_blank_list,
14340 (*irel)->r_offset, 0)) & 0x02)
14341 result |= PUSH_PRE;
14342 }
14343 }
14344 if ((*irel) >= irelend)
14345 *off = sec->size;
14346 else
14347 *off = (*irel)->r_offset;
14348
14349 /* The final instruction in the region, regard this one as data to ignore it. */
14350 result |= DATA_EXIST;
14351 return result;
14352 }
14353 break;
14354
14355 case R_NDS32_LABEL:
14356 if (((*irel)->r_addend & 0x1f) == 2)
14357 {
14358 /* Check this point is align and decide to do ex9 or not. */
14359 result |= CLEAN_PRE;
14360 if (((*irel)->r_offset -
14361 get_nds32_elf_blank_total (&relax_blank_list,
14362 (*irel)->r_offset, 0)) & 0x02)
14363 result |= PUSH_PRE;
14364 }
14365 break;
14366 case R_NDS32_32_RELA:
14367 /* Data. */
14368 result |= (4 << 24);
14369 result |= DATA_EXIST;
14370 break;
14371 case R_NDS32_16_RELA:
14372 /* Data. */
14373 result |= (2 << 24);
14374 result |= DATA_EXIST;
14375 break;
14376 case R_NDS32_DATA:
14377 /* Data. */
14378 /* The least code alignment is 2. If the data is only one byte,
14379 we have to shift one more byte. */
14380 if ((*irel)->r_addend == 1)
14381 result |= ((*irel)->r_addend << 25) ;
14382 else
14383 result |= ((*irel)->r_addend << 24) ;
14384
14385 result |= DATA_EXIST;
14386 break;
14387
14388 case R_NDS32_25_PCREL_RELA:
14389 case R_NDS32_SDA16S3_RELA:
14390 case R_NDS32_SDA15S3_RELA:
14391 case R_NDS32_SDA15S3:
14392 case R_NDS32_SDA17S2_RELA:
14393 case R_NDS32_SDA15S2_RELA:
14394 case R_NDS32_SDA12S2_SP_RELA:
14395 case R_NDS32_SDA12S2_DP_RELA:
14396 case R_NDS32_SDA15S2:
14397 case R_NDS32_SDA18S1_RELA:
14398 case R_NDS32_SDA15S1_RELA:
14399 case R_NDS32_SDA15S1:
14400 case R_NDS32_SDA19S0_RELA:
14401 case R_NDS32_SDA15S0_RELA:
14402 case R_NDS32_SDA15S0:
14403 case R_NDS32_HI20_RELA:
14404 case R_NDS32_LO12S0_ORI_RELA:
14405 case R_NDS32_LO12S0_RELA:
14406 case R_NDS32_LO12S1_RELA:
14407 case R_NDS32_LO12S2_RELA:
14408 /* These relocation is supported ex9 relaxation currently. */
14409 /* We have to save the relocation for using later, since we have
14410 to check there is any alignment in the same address. */
14411 irel_save = *irel;
14412 break;
14413 default:
14414 /* Not support relocations. */
14415 if (ELF32_R_TYPE ((*irel)->r_info) < ARRAY_SIZE (nds32_elf_howto_table)
14416 && ELF32_R_TYPE ((*irel)->r_info) != R_NDS32_NONE
14417 && ELF32_R_TYPE ((*irel)->r_info) != R_NDS32_INSN16)
14418 {
14419 /* Note: To optimize aggressively, it maybe can ignore R_NDS32_INSN16 here.
14420 But we have to consider if there is any side-effect. */
14421 if (!(result & DATA_EXIST))
14422 {
14423 /* We have to confirm there is no data relocation in the
14424 same address. In general case, this won't happen. */
14425 /* We have to do ex9 conservative, for those relocation not
14426 considerd we ignore instruction. */
14427 result |= DATA_EXIST;
14428 if (*(contents + *off) & 0x80)
14429 result |= (2 << 24);
14430 else
14431 result |= (4 << 24);
14432 break;
14433 }
14434 }
14435 }
14436 if ((*irel) < irelend
14437 && ((*irel) + 1) < irelend
14438 && (*irel)->r_offset == ((*irel) + 1)->r_offset)
14439 /* There are relocations pointing to the same address, we have to
14440 check all of them. */
14441 (*irel)++;
14442 else
14443 {
14444 if (irel_save)
14445 *irel = irel_save;
14446 return result;
14447 }
14448 }
14449 return result;
14450 }
14451
14452 /* Replace with ex9 instruction. */
14453
14454 static bfd_boolean
nds32_elf_ex9_push_insn(uint16_t insn16,bfd_byte * contents,bfd_vma pre_off,nds32_elf_blank_t ** relax_blank_list,struct elf_nds32_irel_entry * pre_irel_ptr,struct elf_nds32_irel_entry ** irel_list)14455 nds32_elf_ex9_push_insn (uint16_t insn16, bfd_byte *contents, bfd_vma pre_off,
14456 nds32_elf_blank_t **relax_blank_list,
14457 struct elf_nds32_irel_entry *pre_irel_ptr,
14458 struct elf_nds32_irel_entry **irel_list)
14459 {
14460 if (insn16 != 0)
14461 {
14462 /* Implement the ex9 relaxation. */
14463 bfd_putb16 (insn16, contents + pre_off);
14464 if (!insert_nds32_elf_blank_recalc_total (relax_blank_list,
14465 pre_off + 2, 2))
14466 return FALSE;
14467 if (pre_irel_ptr != NULL)
14468 nds32_elf_insert_irel_entry (irel_list, pre_irel_ptr);
14469 }
14470 return TRUE;
14471 }
14472
14473 /* Replace input file instruction which is in ex9 itable. */
14474
14475 static bfd_boolean
nds32_elf_ex9_replace_instruction(struct bfd_link_info * info,bfd * abfd,asection * sec)14476 nds32_elf_ex9_replace_instruction (struct bfd_link_info *info, bfd *abfd, asection *sec)
14477 {
14478 struct elf_nds32_insn_times_entry *ex9_insn = ex9_insn_head;
14479 bfd_byte *contents = NULL;
14480 bfd_vma off;
14481 uint16_t insn16, insn_ex9;
14482 /* `pre_*' are used to track previous instruction that can use ex9.it. */
14483 bfd_vma pre_off = -1;
14484 uint16_t pre_insn16 = 0;
14485 struct elf_nds32_irel_entry *pre_irel_ptr = NULL;
14486 Elf_Internal_Rela *internal_relocs;
14487 Elf_Internal_Rela *irel;
14488 Elf_Internal_Rela *irelend;
14489 Elf_Internal_Shdr *symtab_hdr;
14490 Elf_Internal_Sym *isym = NULL;
14491 nds32_elf_blank_t *relax_blank_list = NULL;
14492 uint32_t insn = 0;
14493 uint32_t insn_with_reg = 0;
14494 uint32_t it_insn;
14495 uint32_t it_insn_with_reg;
14496 unsigned long r_symndx;
14497 asection *isec;
14498 struct elf_nds32_irel_entry *irel_list = NULL;
14499 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
14500 int data_flag, do_replace, save_irel;
14501 struct elf_link_hash_entry_list *h_list;
14502
14503
14504 /* Load section instructions, relocations, and symbol table. */
14505 if (!nds32_get_section_contents (abfd, sec, &contents)
14506 || !nds32_get_local_syms (abfd, sec, &isym))
14507 return FALSE;
14508 internal_relocs =
14509 _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, TRUE /* keep_memory */);
14510 irelend = internal_relocs + sec->reloc_count;
14511 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
14512
14513 off = 0;
14514
14515 /* Check if the object enable ex9. */
14516 irel = find_relocs_at_address (internal_relocs, internal_relocs,
14517 irelend, R_NDS32_RELAX_ENTRY);
14518
14519 /* Check this section trigger ex9 relaxation. */
14520 if (irel == NULL
14521 || irel >= irelend
14522 || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
14523 || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
14524 && !(irel->r_addend & R_NDS32_RELAX_ENTRY_EX9_FLAG)))
14525 return TRUE;
14526
14527 irel = internal_relocs;
14528
14529 /* Check alignment and fetch proper relocation. */
14530 while (off < sec->size)
14531 {
14532 struct elf_link_hash_entry *h = NULL;
14533 struct elf_nds32_irel_entry *irel_ptr = NULL;
14534
14535 /* Syn the instruction and the relocation. */
14536 while (irel != NULL && irel < irelend && irel->r_offset < off)
14537 irel++;
14538
14539 data_flag = nds32_elf_ex9_relocation_check (info, &irel, irelend,
14540 relax_blank_list, sec,
14541 &off, contents);
14542 if (data_flag & PUSH_PRE)
14543 if (!nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14544 &relax_blank_list, pre_irel_ptr,
14545 &irel_list))
14546 return FALSE;
14547
14548 if (data_flag & CLEAN_PRE)
14549 {
14550 pre_off = 0;
14551 pre_insn16 = 0;
14552 pre_irel_ptr = NULL;
14553 }
14554 if (data_flag & DATA_EXIST)
14555 {
14556 /* We save the move offset in the highest byte. */
14557 off += (data_flag >> 24);
14558 continue;
14559 }
14560
14561 if (*(contents + off) & 0x80)
14562 {
14563 /* 2-byte instruction. */
14564 off += 2;
14565 continue;
14566 }
14567
14568 /* Load the instruction and its opcode with register for comparing. */
14569 ex9_insn = ex9_insn_head;
14570 insn = bfd_getb32 (contents + off);
14571 insn_with_reg = 0;
14572 while (ex9_insn)
14573 {
14574 it_insn = strtol (ex9_insn->string, NULL, 16);
14575 it_insn_with_reg = 0;
14576 do_replace = 0;
14577 save_irel = 0;
14578
14579 if (irel != NULL && irel < irelend && irel->r_offset == off)
14580 {
14581 /* Insn with relocation. */
14582 nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
14583
14584 if (ex9_insn->irel != NULL)
14585 nds32_elf_get_insn_with_reg (ex9_insn->irel, it_insn,
14586 &it_insn_with_reg);
14587
14588 if (ex9_insn->irel != NULL
14589 && (ELF32_R_TYPE (irel->r_info) ==
14590 ELF32_R_TYPE (ex9_insn->irel->r_info))
14591 && (insn_with_reg == it_insn_with_reg))
14592 {
14593 /* Insn relocation and format is the same as table entry. */
14594
14595 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA
14596 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_ORI_RELA
14597 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_RELA
14598 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S1_RELA
14599 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_RELA
14600 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
14601 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
14602 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
14603 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
14604 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
14605 && ELF32_R_TYPE (irel->r_info) <=
14606 R_NDS32_SDA12S2_SP_RELA)
14607 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
14608 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
14609 {
14610 r_symndx = ELF32_R_SYM (irel->r_info);
14611 if (r_symndx < symtab_hdr->sh_info)
14612 {
14613 /* Local symbol. */
14614 int shndx = isym[r_symndx].st_shndx;
14615
14616 isec = elf_elfsections (abfd)[shndx]->bfd_section;
14617 if (ex9_insn->sec == isec
14618 && ex9_insn->irel->r_addend == irel->r_addend
14619 && ex9_insn->irel->r_info == irel->r_info)
14620 {
14621 do_replace = 1;
14622 save_irel = 1;
14623 }
14624 }
14625 else
14626 {
14627 /* External symbol. */
14628 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14629 if (ex9_insn->m_list)
14630 {
14631 h_list = ex9_insn->m_list->h_list;
14632 while (h_list)
14633 {
14634 if (h == h_list->h
14635 && (ex9_insn->m_list->irel->r_addend ==
14636 irel->r_addend))
14637 {
14638 do_replace = 1;
14639 save_irel = 1;
14640 break;
14641 }
14642 h_list = h_list->next;
14643 }
14644 }
14645 }
14646 }
14647 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_HI20_RELA)
14648 {
14649 r_symndx = ELF32_R_SYM (irel->r_info);
14650 if (r_symndx < symtab_hdr->sh_info)
14651 {
14652 /* Local symbols. Compare its base symbol and offset. */
14653 int shndx = isym[r_symndx].st_shndx;
14654
14655 isec = elf_elfsections (abfd)[shndx]->bfd_section;
14656 if (ex9_insn->sec == isec
14657 && ex9_insn->irel->r_addend == irel->r_addend
14658 && ex9_insn->irel->r_info == irel->r_info)
14659 {
14660 do_replace = 1;
14661 save_irel = 1;
14662 }
14663 }
14664 else
14665 {
14666 /* External symbol. */
14667 struct elf_link_hash_entry_mul_list *m_list;
14668
14669 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14670 m_list = ex9_insn->m_list;
14671
14672 while (m_list)
14673 {
14674 h_list = m_list->h_list;
14675
14676 while (h_list)
14677 {
14678 if (h == h_list->h
14679 && (m_list->irel->r_addend
14680 == irel->r_addend))
14681 {
14682 do_replace = 1;
14683 save_irel = 1;
14684 if (ex9_insn->next
14685 && ex9_insn->m_list
14686 && ex9_insn->m_list == ex9_insn->next->m_list)
14687 {
14688 /* sethi multiple entry must be fixed */
14689 nds32_elf_ex9_insert_fix (sec, irel,
14690 h, ex9_insn->order);
14691 }
14692 break;
14693 }
14694 h_list = h_list->next;
14695 }
14696 m_list = m_list->next;
14697 }
14698 }
14699 }
14700 }
14701
14702 /* Import table: Check the symbol hash table and the
14703 jump target. Only R_NDS32_25_PCREL_RELA now. */
14704 else if (ex9_insn->times == -1
14705 && ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA)
14706 {
14707 nds32_elf_get_insn_with_reg (irel, it_insn, &it_insn_with_reg);
14708 if (insn_with_reg == it_insn_with_reg)
14709 {
14710 char code[10];
14711 bfd_vma relocation;
14712
14713 r_symndx = ELF32_R_SYM (irel->r_info);
14714 if (r_symndx >= symtab_hdr->sh_info)
14715 {
14716 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14717 if ((h->root.type == bfd_link_hash_defined
14718 || h->root.type == bfd_link_hash_defweak)
14719 && h->root.u.def.section != NULL
14720 && h->root.u.def.section->output_section != NULL
14721 && h->root.u.def.section->gc_mark == 1
14722 && bfd_is_abs_section (h->root.u.def.section)
14723 && h->root.u.def.value > sec->size)
14724 {
14725 relocation = h->root.u.def.value +
14726 h->root.u.def.section->output_section->vma +
14727 h->root.u.def.section->output_offset;
14728 relocation += irel->r_addend;
14729 insn = insn_with_reg
14730 | ((relocation >> 1) & 0xffffff);
14731 snprintf (code, sizeof (code), "%08x", insn);
14732 if (strcmp (code, ex9_insn->string) == 0)
14733 {
14734 do_replace = 1;
14735 save_irel = 1;
14736 }
14737 }
14738 }
14739 }
14740 }
14741 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
14742 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
14743 || ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
14744 {
14745 /* These relocations do not have to relocate contens, so it can
14746 be regard as instruction without relocation. */
14747 if (insn == it_insn && ex9_insn->irel == NULL)
14748 do_replace = 1;
14749 }
14750 }
14751 else
14752 {
14753 /* Instruction without relocation, we only
14754 have to compare their byte code. */
14755 if (insn == it_insn && ex9_insn->irel == NULL)
14756 do_replace = 1;
14757 }
14758
14759 /* Insntruction match so replacing the code here. */
14760 if (do_replace == 1)
14761 {
14762 /* There are two formats of ex9 instruction. */
14763 if (ex9_insn->order < 32)
14764 insn_ex9 = INSN_EX9_IT_2;
14765 else
14766 insn_ex9 = INSN_EX9_IT_1;
14767 insn16 = insn_ex9 | ex9_insn->order;
14768
14769 /* Insert ex9 instruction. */
14770 nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14771 &relax_blank_list, pre_irel_ptr,
14772 &irel_list);
14773 pre_off = off;
14774 pre_insn16 = insn16;
14775
14776 if (save_irel)
14777 {
14778 /* For instuction with relocation do relax. */
14779 irel_ptr = (struct elf_nds32_irel_entry *)
14780 bfd_malloc (sizeof (struct elf_nds32_irel_entry));
14781 irel_ptr->irel = irel;
14782 irel_ptr->next = NULL;
14783 pre_irel_ptr = irel_ptr;
14784 }
14785 else
14786 pre_irel_ptr = NULL;
14787 break;
14788 }
14789 ex9_insn = ex9_insn->next;
14790 }
14791 off += 4;
14792 }
14793
14794 /* Insert ex9 instruction. */
14795 nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14796 &relax_blank_list, pre_irel_ptr,
14797 &irel_list);
14798
14799 /* Delete the redundant code. */
14800 if (relax_blank_list)
14801 {
14802 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
14803 relax_blank_list = NULL;
14804 }
14805
14806 /* Clear the relocation that is replaced by ex9. */
14807 while (irel_list)
14808 {
14809 struct elf_nds32_irel_entry *irel_ptr;
14810
14811 irel_ptr = irel_list;
14812 irel_list = irel_ptr->next;
14813 irel_ptr->irel->r_info =
14814 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info), R_NDS32_TRAN);
14815 free (irel_ptr);
14816 }
14817 return TRUE;
14818 }
14819
14820 /* Initialize ex9 hash table. */
14821
14822 int
nds32_elf_ex9_init(void)14823 nds32_elf_ex9_init (void)
14824 {
14825 if (!bfd_hash_table_init_n (&ex9_code_table, nds32_elf_code_hash_newfunc,
14826 sizeof (struct elf_nds32_code_hash_entry),
14827 1023))
14828 {
14829 (*_bfd_error_handler) (_("Linker: cannot init ex9 hash table error \n"));
14830 return FALSE;
14831 }
14832 return TRUE;
14833 }
14834
14835 /* Predict how many bytes will be relaxed with ex9 and ifc. */
14836
14837 static void
nds32_elf_ex9_total_relax(struct bfd_link_info * info)14838 nds32_elf_ex9_total_relax (struct bfd_link_info *info)
14839 {
14840 struct elf_nds32_insn_times_entry *ex9_insn;
14841 struct elf_nds32_insn_times_entry *temp;
14842 int target_optimize;
14843 struct elf_nds32_link_hash_table *table;
14844
14845 if (ex9_insn_head == NULL)
14846 return;
14847
14848 table = nds32_elf_hash_table (info);
14849 target_optimize = table->target_optimize;
14850 ex9_insn = ex9_insn_head;
14851 while (ex9_insn)
14852 {
14853 ex9_relax_size = ex9_insn->times * 2 + ex9_relax_size;
14854 temp = ex9_insn;
14855 ex9_insn = ex9_insn->next;
14856 free (temp);
14857 }
14858 ex9_insn_head = NULL;
14859
14860 if ((target_optimize & NDS32_RELAX_JUMP_IFC_ON))
14861 {
14862 /* Examine ifc reduce size. */
14863 struct elf_nds32_ifc_symbol_entry *ifc_ent = ifc_symbol_head;
14864 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
14865 int size = 0;
14866
14867 while (ifc_ent)
14868 {
14869 if (ifc_ent->enable == 0)
14870 {
14871 /* Not ifc yet. */
14872 irel_ptr = ifc_ent->irel_head;
14873 while (irel_ptr)
14874 {
14875 size += 2;
14876 irel_ptr = irel_ptr->next;
14877 }
14878 }
14879 size -= 2;
14880 ifc_ent = ifc_ent->next;
14881 }
14882 ex9_relax_size += size;
14883 }
14884 }
14885
14886 /* Finish ex9 table. */
14887
14888 void
nds32_elf_ex9_finish(struct bfd_link_info * link_info)14889 nds32_elf_ex9_finish (struct bfd_link_info *link_info)
14890 {
14891 nds32_elf_code_hash_traverse (nds32_elf_examine_insn_times);
14892 nds32_elf_order_insn_times (link_info);
14893 nds32_elf_ex9_total_relax (link_info);
14894 /* Traverse the hash table and count its times. */
14895 nds32_elf_code_hash_traverse (nds32_elf_count_insn_times);
14896 nds32_elf_order_insn_times (link_info);
14897 nds32_elf_ex9_build_itable (link_info);
14898 }
14899
14900 /* Relocate the entries in ex9 table. */
14901
14902 static bfd_vma
nds32_elf_ex9_reloc_insn(struct elf_nds32_insn_times_entry * ptr,struct bfd_link_info * link_info)14903 nds32_elf_ex9_reloc_insn (struct elf_nds32_insn_times_entry *ptr,
14904 struct bfd_link_info *link_info)
14905 {
14906 Elf_Internal_Sym *isym = NULL;
14907 bfd_vma relocation = -1;
14908 struct elf_link_hash_entry *h;
14909
14910 if (ptr->m_list != NULL)
14911 {
14912 /* Global symbol. */
14913 h = ptr->m_list->h_list->h;
14914 if ((h->root.type == bfd_link_hash_defined
14915 || h->root.type == bfd_link_hash_defweak)
14916 && h->root.u.def.section != NULL
14917 && h->root.u.def.section->output_section != NULL)
14918 {
14919
14920 relocation = h->root.u.def.value +
14921 h->root.u.def.section->output_section->vma +
14922 h->root.u.def.section->output_offset;
14923 relocation += ptr->m_list->irel->r_addend;
14924 }
14925 else
14926 relocation = 0;
14927 }
14928 else if (ptr->sec !=NULL)
14929 {
14930 /* Local symbol. */
14931 Elf_Internal_Sym sym;
14932 asection *sec = NULL;
14933 asection isec;
14934 asection *isec_ptr = &isec;
14935 Elf_Internal_Rela irel_backup = *(ptr->irel);
14936 asection *sec_backup = ptr->sec;
14937 bfd *abfd = ptr->sec->owner;
14938
14939 if (!nds32_get_local_syms (abfd, sec, &isym))
14940 return FALSE;
14941 isym = isym + ELF32_R_SYM (ptr->irel->r_info);
14942
14943 sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
14944 if (sec != NULL)
14945 *isec_ptr = *sec;
14946 sym = *isym;
14947
14948 /* The purpose is same as elf_link_input_bfd. */
14949 if (isec_ptr != NULL
14950 && isec_ptr->sec_info_type == SEC_INFO_TYPE_MERGE
14951 && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
14952 {
14953 sym.st_value =
14954 _bfd_merged_section_offset (ptr->sec->output_section->owner, &isec_ptr,
14955 elf_section_data (isec_ptr)->sec_info,
14956 isym->st_value);
14957 }
14958 relocation = _bfd_elf_rela_local_sym (link_info->output_bfd, &sym,
14959 &ptr->sec, ptr->irel);
14960 if (ptr->irel != NULL)
14961 relocation += ptr->irel->r_addend;
14962
14963 /* Restore origin value since there may be some insntructions that
14964 could not be replaced with ex9.it. */
14965 *(ptr->irel) = irel_backup;
14966 ptr->sec = sec_backup;
14967 }
14968
14969 return relocation;
14970 }
14971
14972 /* Import ex9 table and build list. */
14973
14974 void
nds32_elf_ex9_import_table(struct bfd_link_info * info)14975 nds32_elf_ex9_import_table (struct bfd_link_info *info)
14976 {
14977 int num = 0;
14978 bfd_byte *contents;
14979 unsigned long insn;
14980 FILE *ex9_import_file;
14981 int update_ex9_table;
14982 struct elf_nds32_link_hash_table *table;
14983
14984 table = nds32_elf_hash_table (info);
14985 ex9_import_file = table->ex9_import_file;
14986 rewind (table->ex9_import_file);
14987
14988 contents = bfd_malloc (sizeof (bfd_byte) * 4);
14989
14990 /* Read instructions from the input file and build the list. */
14991 while (!feof (ex9_import_file))
14992 {
14993 char *code;
14994 struct elf_nds32_insn_times_entry *ptr;
14995 size_t nread;
14996
14997 nread = fread (contents, sizeof (bfd_byte) * 4, 1, ex9_import_file);
14998 /* Ignore the final byte 0x0a. */
14999 if (nread < 1)
15000 break;
15001 insn = bfd_getb32 (contents);
15002 code = bfd_malloc (sizeof (char) * 9);
15003 snprintf (code, 9, "%08lx", insn);
15004 ptr = bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
15005 ptr->string = code;
15006 ptr->order = num;
15007 ptr->times = -1;
15008 ptr->sec = NULL;
15009 ptr->m_list = NULL;
15010 ptr->rel_backup.r_offset = 0;
15011 ptr->rel_backup.r_info = 0;
15012 ptr->rel_backup.r_addend = 0;
15013 ptr->irel = NULL;
15014 ptr->next = NULL;
15015 nds32_elf_ex9_insert_entry (ptr);
15016 num++;
15017 }
15018
15019 update_ex9_table = table->update_ex9_table;
15020 if (update_ex9_table == 1)
15021 {
15022 /* It has to consider of sethi need to use multiple page
15023 but it not be done yet. */
15024 nds32_elf_code_hash_traverse (nds32_elf_examine_insn_times);
15025 nds32_elf_order_insn_times (info);
15026 }
15027 }
15028
15029 /* Export ex9 table. */
15030
15031 static void
nds32_elf_ex9_export(struct bfd_link_info * info,bfd_byte * contents,int size)15032 nds32_elf_ex9_export (struct bfd_link_info *info,
15033 bfd_byte *contents, int size)
15034 {
15035 FILE *ex9_export_file;
15036 struct elf_nds32_link_hash_table *table;
15037
15038 table = nds32_elf_hash_table (info);
15039 ex9_export_file = table->ex9_export_file;
15040 fwrite (contents, sizeof (bfd_byte), size, ex9_export_file);
15041 fclose (ex9_export_file);
15042 }
15043
15044 /* Adjust relocations of J and JAL in ex9.itable.
15045 Export ex9 table. */
15046
15047 static void
nds32_elf_ex9_reloc_jmp(struct bfd_link_info * link_info)15048 nds32_elf_ex9_reloc_jmp (struct bfd_link_info *link_info)
15049 {
15050 asection *table_sec = NULL;
15051 struct elf_nds32_insn_times_entry *ex9_insn = ex9_insn_head;
15052 struct elf_nds32_insn_times_entry *temp_ptr, *temp_ptr2;
15053 bfd *it_abfd;
15054 uint32_t insn, insn_with_reg, source_insn;
15055 bfd_byte *contents = NULL, *source_contents = NULL;
15056 int size = 0;
15057 bfd_vma gp;
15058 int shift, update_ex9_table, offset = 0;
15059 reloc_howto_type *howto = NULL;
15060 Elf_Internal_Rela rel_backup;
15061 unsigned short insn_ex9;
15062 struct elf_nds32_link_hash_table *table;
15063 FILE *ex9_export_file;
15064 static bfd_boolean done = FALSE;
15065
15066 if (done)
15067 return;
15068
15069 done = TRUE;
15070
15071 table = nds32_elf_hash_table (link_info);
15072 if (table)
15073 table->relax_status |= NDS32_RELAX_EX9_DONE;
15074
15075
15076 update_ex9_table = table->update_ex9_table;
15077 /* Generated ex9.itable exactly. */
15078 if (update_ex9_table == 0)
15079 {
15080 for (it_abfd = link_info->input_bfds; it_abfd != NULL;
15081 it_abfd = it_abfd->link.next)
15082 {
15083 table_sec = bfd_get_section_by_name (it_abfd, ".ex9.itable");
15084 if (table_sec != NULL)
15085 break;
15086 }
15087
15088 if (table_sec != NULL)
15089 {
15090 bfd *output_bfd;
15091
15092 output_bfd = table_sec->output_section->owner;
15093 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15094 if (table_sec->size == 0)
15095 return;
15096
15097 if (!nds32_get_section_contents (it_abfd, table_sec, &contents))
15098 return;
15099 }
15100 }
15101 else
15102 {
15103 /* Set gp. */
15104 bfd *output_bfd;
15105
15106 output_bfd = link_info->input_bfds->sections->output_section->owner;
15107 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15108 contents = bfd_malloc (sizeof (bfd_byte) * 2048);
15109 }
15110
15111 /* Relocate instruction. */
15112 while (ex9_insn)
15113 {
15114 bfd_vma relocation, min_relocation = 0xffffffff;
15115
15116 insn = strtol (ex9_insn->string, NULL, 16);
15117 insn_with_reg = 0;
15118 if (ex9_insn->m_list != NULL || ex9_insn->sec != NULL)
15119 {
15120 if (ex9_insn->m_list)
15121 rel_backup = ex9_insn->m_list->rel_backup;
15122 else
15123 rel_backup = ex9_insn->rel_backup;
15124
15125 nds32_elf_get_insn_with_reg (&rel_backup, insn, &insn_with_reg);
15126 howto =
15127 bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE
15128 (rel_backup.r_info));
15129 shift = howto->rightshift;
15130 if (ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_25_PCREL_RELA
15131 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S0_ORI_RELA
15132 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S0_RELA
15133 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S1_RELA
15134 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S2_RELA)
15135 {
15136 relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15137 insn =
15138 insn_with_reg | ((relocation >> shift) &
15139 nds32_elf_irel_mask (&rel_backup));
15140 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15141 }
15142 else if ((ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA15S3
15143 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA15S0)
15144 || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA15S3_RELA
15145 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA15S0_RELA)
15146 || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA12S2_DP_RELA
15147 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA12S2_SP_RELA)
15148 || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA16S3_RELA
15149 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA19S0_RELA))
15150 {
15151 relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15152 insn =
15153 insn_with_reg | (((relocation - gp) >> shift) &
15154 nds32_elf_irel_mask (&rel_backup));
15155 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15156 }
15157 else if (ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_HI20_RELA)
15158 {
15159 /* Sethi may be multiple entry for one insn. */
15160 if (ex9_insn->next && ex9_insn->m_list
15161 && ex9_insn->m_list == ex9_insn->next->m_list)
15162 {
15163 struct elf_link_hash_entry_mul_list *m_list;
15164 struct elf_nds32_ex9_refix *fix_ptr;
15165 struct elf_link_hash_entry *h;
15166
15167 temp_ptr = ex9_insn;
15168 temp_ptr2 = ex9_insn;
15169 m_list = ex9_insn->m_list;
15170 while (m_list)
15171 {
15172 h = m_list->h_list->h;
15173 relocation = h->root.u.def.value +
15174 h->root.u.def.section->output_section->vma +
15175 h->root.u.def.section->output_offset;
15176 relocation += m_list->irel->r_addend;
15177
15178 if (relocation < min_relocation)
15179 min_relocation = relocation;
15180 m_list = m_list->next;
15181 }
15182 relocation = min_relocation;
15183
15184 /* Put insntruction into ex9 table. */
15185 insn = insn_with_reg
15186 | ((relocation >> shift) & nds32_elf_irel_mask (&rel_backup));
15187 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15188 relocation = relocation + 0x1000; /* hi20 */
15189
15190 while (ex9_insn->next && ex9_insn->m_list
15191 && ex9_insn->m_list == ex9_insn->next->m_list)
15192 {
15193 /* Multiple sethi. */
15194 ex9_insn = ex9_insn->next;
15195 size += 4;
15196 insn =
15197 insn_with_reg | ((relocation >> shift) &
15198 nds32_elf_irel_mask (&rel_backup));
15199 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15200 relocation = relocation + 0x1000; /* hi20 */
15201 }
15202
15203 fix_ptr = ex9_refix_head;
15204 while (fix_ptr)
15205 {
15206 /* Fix ex9 insn. */
15207 /* temp_ptr2 points to the head of multiple sethi. */
15208 temp_ptr = temp_ptr2;
15209 while (fix_ptr->order != temp_ptr->order && fix_ptr->next)
15210 {
15211 fix_ptr = fix_ptr->next;
15212 }
15213 if (fix_ptr->order != temp_ptr->order)
15214 break;
15215
15216 /* Set source insn. */
15217 relocation =
15218 fix_ptr->h->root.u.def.value +
15219 fix_ptr->h->root.u.def.section->output_section->vma +
15220 fix_ptr->h->root.u.def.section->output_offset;
15221 relocation += fix_ptr->irel->r_addend;
15222 /* sethi imm is imm20s. */
15223 source_insn = insn_with_reg | ((relocation >> shift) & 0xfffff);
15224
15225 while (temp_ptr)
15226 {
15227 /* Match entry and source code. */
15228 insn = bfd_getb32 (contents + (temp_ptr->order) * 4 + offset);
15229 if (insn == source_insn)
15230 {
15231 /* Fix the ex9 insn. */
15232 if (temp_ptr->order != fix_ptr->order)
15233 {
15234 if (!nds32_get_section_contents
15235 (fix_ptr->sec->owner, fix_ptr->sec,
15236 &source_contents))
15237 (*_bfd_error_handler)
15238 (_("Linker: error cannot fixed ex9 relocation \n"));
15239 if (temp_ptr->order < 32)
15240 insn_ex9 = INSN_EX9_IT_2;
15241 else
15242 insn_ex9 = INSN_EX9_IT_1;
15243 insn_ex9 = insn_ex9 | temp_ptr->order;
15244 bfd_putb16 (insn_ex9, source_contents + fix_ptr->irel->r_offset);
15245 }
15246 break;
15247 }
15248 else
15249 {
15250 if (!temp_ptr->next || temp_ptr->m_list != temp_ptr->next->m_list)
15251 (*_bfd_error_handler)
15252 (_("Linker: error cannot fixed ex9 relocation \n"));
15253 else
15254 temp_ptr = temp_ptr->next;
15255 }
15256 }
15257 fix_ptr = fix_ptr->next;
15258 }
15259 }
15260 else
15261 {
15262 relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15263 insn = insn_with_reg
15264 | ((relocation >> shift) & nds32_elf_irel_mask (&rel_backup));
15265 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15266 }
15267 }
15268 }
15269 else
15270 {
15271 /* Insn without relocation does not have to be fixed
15272 if need to update export table. */
15273 if (update_ex9_table == 1)
15274 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15275 }
15276 ex9_insn = ex9_insn->next;
15277 size += 4;
15278 }
15279
15280 ex9_export_file = table->ex9_export_file;
15281 if (ex9_export_file != NULL)
15282 nds32_elf_ex9_export (link_info, contents, table_sec->size);
15283 else if (update_ex9_table == 1)
15284 {
15285 table->ex9_export_file = table->ex9_import_file;
15286 rewind (table->ex9_export_file);
15287 nds32_elf_ex9_export (link_info, contents, size);
15288 }
15289 }
15290
15291 /* Generate ex9 hash table. */
15292
15293 static bfd_boolean
nds32_elf_ex9_build_hash_table(bfd * abfd,asection * sec,struct bfd_link_info * link_info)15294 nds32_elf_ex9_build_hash_table (bfd *abfd, asection *sec,
15295 struct bfd_link_info *link_info)
15296 {
15297 Elf_Internal_Rela *internal_relocs;
15298 Elf_Internal_Rela *irelend;
15299 Elf_Internal_Rela *irel;
15300 Elf_Internal_Rela *jrel;
15301 Elf_Internal_Rela rel_backup;
15302 Elf_Internal_Shdr *symtab_hdr;
15303 Elf_Internal_Sym *isym = NULL;
15304 asection *isec;
15305 struct elf_link_hash_entry **sym_hashes;
15306 bfd_byte *contents = NULL;
15307 bfd_vma off = 0;
15308 unsigned long r_symndx;
15309 uint32_t insn, insn_with_reg;
15310 struct elf_link_hash_entry *h;
15311 int data_flag, shift, align;
15312 bfd_vma relocation;
15313 /* Suppress ex9 if `.no_relax ex9' or inner loop. */
15314 reloc_howto_type *howto = NULL;
15315
15316 sym_hashes = elf_sym_hashes (abfd);
15317 /* Load section instructions, relocations, and symbol table. */
15318 if (!nds32_get_section_contents (abfd, sec, &contents))
15319 return FALSE;
15320
15321 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
15322 TRUE /* keep_memory */);
15323 irelend = internal_relocs + sec->reloc_count;
15324 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
15325 if (!nds32_get_local_syms (abfd, sec, &isym))
15326 return FALSE;
15327
15328 /* Check the object if enable ex9. */
15329 irel = find_relocs_at_address (internal_relocs, internal_relocs, irelend,
15330 R_NDS32_RELAX_ENTRY);
15331
15332 /* Check this section trigger ex9 relaxation. */
15333 if (irel == NULL
15334 || irel >= irelend
15335 || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
15336 || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
15337 && !(irel->r_addend & R_NDS32_RELAX_ENTRY_EX9_FLAG)))
15338 return TRUE;
15339
15340 irel = internal_relocs;
15341
15342 /* Push each insn into hash table. */
15343 while (off < sec->size)
15344 {
15345 char code[10];
15346 struct elf_nds32_code_hash_entry *entry;
15347
15348 while (irel != NULL && irel < irelend && irel->r_offset < off)
15349 irel++;
15350
15351 data_flag = nds32_elf_ex9_relocation_check (link_info, &irel, irelend,
15352 NULL, sec, &off, contents);
15353 if (data_flag & DATA_EXIST)
15354 {
15355 /* We save the move offset in the highest byte. */
15356 off += (data_flag >> 24);
15357 continue;
15358 }
15359
15360 if (*(contents + off) & 0x80)
15361 {
15362 off += 2;
15363 }
15364 else
15365 {
15366 h = NULL;
15367 isec = NULL;
15368 jrel = NULL;
15369 rel_backup.r_info = 0;
15370 rel_backup.r_offset = 0;
15371 rel_backup.r_addend = 0;
15372 /* Load the instruction and its opcode with register for comparing. */
15373 insn = bfd_getb32 (contents + off);
15374 insn_with_reg = 0;
15375 if (irel != NULL && irel < irelend && irel->r_offset == off)
15376 {
15377 nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
15378 howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
15379 shift = howto->rightshift;
15380 align = (1 << shift) - 1;
15381 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA
15382 || ELF32_R_TYPE (irel->r_info) == R_NDS32_HI20_RELA
15383 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_ORI_RELA
15384 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_RELA
15385 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S1_RELA
15386 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_RELA
15387 ||(ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
15388 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
15389 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
15390 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
15391 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
15392 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA12S2_SP_RELA)
15393 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
15394 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
15395 {
15396 r_symndx = ELF32_R_SYM (irel->r_info);
15397 jrel = irel;
15398 rel_backup = *irel;
15399 if (r_symndx < symtab_hdr->sh_info)
15400 {
15401 /* Local symbol. */
15402 int shndx = isym[r_symndx].st_shndx;
15403
15404 bfd_vma st_value = (isym + r_symndx)->st_value;
15405 isec = elf_elfsections (abfd)[shndx]->bfd_section;
15406 relocation = (isec->output_section->vma + isec->output_offset
15407 + st_value + irel->r_addend);
15408 }
15409 else
15410 {
15411 /* External symbol. */
15412 bfd_boolean warned ATTRIBUTE_UNUSED;
15413 bfd_boolean ignored ATTRIBUTE_UNUSED;
15414 bfd_boolean unresolved_reloc ATTRIBUTE_UNUSED;
15415 asection *sym_sec;
15416
15417 /* Maybe there is a better way to get h and relocation */
15418 RELOC_FOR_GLOBAL_SYMBOL (link_info, abfd, sec, irel,
15419 r_symndx, symtab_hdr, sym_hashes,
15420 h, sym_sec, relocation,
15421 unresolved_reloc, warned, ignored);
15422 relocation += irel->r_addend;
15423 if ((h->root.type != bfd_link_hash_defined
15424 && h->root.type != bfd_link_hash_defweak)
15425 || strcmp (h->root.root.string, "_FP_BASE_") == 0)
15426 {
15427 off += 4;
15428 continue;
15429 }
15430 }
15431
15432 /* Check for gp relative instruction alignment. */
15433 if ((ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
15434 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
15435 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
15436 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
15437 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
15438 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA12S2_SP_RELA)
15439 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
15440 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
15441 {
15442 bfd_vma gp;
15443 bfd *output_bfd = sec->output_section->owner;
15444 bfd_reloc_status_type r;
15445
15446 /* If the symbol is in the abs section, the out_bfd will be null.
15447 This happens when the relocation has a symbol@GOTOFF. */
15448 r = nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15449 if (r != bfd_reloc_ok)
15450 {
15451 off += 4;
15452 continue;
15453 }
15454
15455 relocation -= gp;
15456
15457 /* Make sure alignment is correct. */
15458 if (relocation & align)
15459 {
15460 /* Incorrect alignment. */
15461 (*_bfd_error_handler)
15462 (_("%s: warning: unaligned small data access. "
15463 "For entry: {%d, %d, %d}, addr = 0x%x, align = 0x%x."),
15464 bfd_get_filename (abfd), irel->r_offset,
15465 irel->r_info, irel->r_addend, relocation, align);
15466 off += 4;
15467 continue;
15468 }
15469 }
15470
15471 insn = insn_with_reg
15472 | ((relocation >> shift) & nds32_elf_irel_mask (irel));
15473 }
15474 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
15475 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
15476 || ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
15477 {
15478 /* These relocations do not have to relocate contens, so it can
15479 be regard as instruction without relocation. */
15480 }
15481 else
15482 {
15483 off += 4;
15484 continue;
15485 }
15486 }
15487
15488 snprintf (code, sizeof (code), "%08x", insn);
15489 /* Copy "code". */
15490 entry = (struct elf_nds32_code_hash_entry*)
15491 bfd_hash_lookup (&ex9_code_table, code, TRUE, TRUE);
15492 if (entry == NULL)
15493 {
15494 (*_bfd_error_handler)
15495 (_("%P%F: failed creating ex9.it %s hash table: %E\n"), code);
15496 return FALSE;
15497 }
15498 if (h)
15499 {
15500 if (h->root.type == bfd_link_hash_undefined)
15501 return TRUE;
15502 /* Global symbol. */
15503 /* In order to do sethi with different symbol but same value. */
15504 if (entry->m_list == NULL)
15505 {
15506 struct elf_link_hash_entry_mul_list *m_list_new;
15507 struct elf_link_hash_entry_list *h_list_new;
15508
15509 m_list_new = (struct elf_link_hash_entry_mul_list *)
15510 bfd_malloc (sizeof (struct elf_link_hash_entry_mul_list));
15511 h_list_new = (struct elf_link_hash_entry_list *)
15512 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15513 entry->m_list = m_list_new;
15514 m_list_new->h_list = h_list_new;
15515 m_list_new->rel_backup = rel_backup;
15516 m_list_new->times = 1;
15517 m_list_new->irel = jrel;
15518 m_list_new->next = NULL;
15519 h_list_new->h = h;
15520 h_list_new->next = NULL;
15521 }
15522 else
15523 {
15524 struct elf_link_hash_entry_mul_list *m_list = entry->m_list;
15525 struct elf_link_hash_entry_list *h_list;
15526
15527 while (m_list)
15528 {
15529 /* Build the different symbols that point to the same address. */
15530 h_list = m_list->h_list;
15531 if (h_list->h->root.u.def.value == h->root.u.def.value
15532 && h_list->h->root.u.def.section->output_section->vma
15533 == h->root.u.def.section->output_section->vma
15534 && h_list->h->root.u.def.section->output_offset
15535 == h->root.u.def.section->output_offset
15536 && m_list->rel_backup.r_addend == rel_backup.r_addend)
15537 {
15538 m_list->times++;
15539 m_list->irel = jrel;
15540 while (h_list->h != h && h_list->next)
15541 h_list = h_list->next;
15542 if (h_list->h != h)
15543 {
15544 struct elf_link_hash_entry_list *h_list_new;
15545
15546 h_list_new = (struct elf_link_hash_entry_list *)
15547 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15548 h_list->next = h_list_new;
15549 h_list_new->h = h;
15550 h_list_new->next = NULL;
15551 }
15552 break;
15553 }
15554 /* The sethi case may have different address but the
15555 hi20 is the same. */
15556 else if (ELF32_R_TYPE (jrel->r_info) == R_NDS32_HI20_RELA
15557 && m_list->next == NULL)
15558 {
15559 struct elf_link_hash_entry_mul_list *m_list_new;
15560 struct elf_link_hash_entry_list *h_list_new;
15561
15562 m_list_new = (struct elf_link_hash_entry_mul_list *)
15563 bfd_malloc (sizeof (struct elf_link_hash_entry_mul_list));
15564 h_list_new = (struct elf_link_hash_entry_list *)
15565 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15566 m_list->next = m_list_new;
15567 m_list_new->h_list = h_list_new;
15568 m_list_new->rel_backup = rel_backup;
15569 m_list_new->times = 1;
15570 m_list_new->irel = jrel;
15571 m_list_new->next = NULL;
15572 h_list_new->h = h;
15573 h_list_new->next = NULL;
15574 break;
15575 }
15576 m_list = m_list->next;
15577 }
15578 if (!m_list)
15579 {
15580 off += 4;
15581 continue;
15582 }
15583 }
15584 }
15585 else
15586 {
15587 /* Local symbol and insn without relocation*/
15588 entry->times++;
15589 entry->rel_backup = rel_backup;
15590 }
15591
15592 /* Use in sethi insn with constant and global symbol in same format. */
15593 if (!jrel)
15594 entry->const_insn = 1;
15595 else
15596 entry->irel = jrel;
15597 entry->sec = isec;
15598 off += 4;
15599 }
15600 }
15601 return TRUE;
15602 }
15603
15604 /* Set the _ITB_BASE, and point it to ex9 table. */
15605
15606 bfd_boolean
nds32_elf_ex9_itb_base(struct bfd_link_info * link_info)15607 nds32_elf_ex9_itb_base (struct bfd_link_info *link_info)
15608 {
15609 bfd *abfd;
15610 asection *sec;
15611 bfd *output_bfd = NULL;
15612 struct bfd_link_hash_entry *bh = NULL;
15613
15614 if (is_ITB_BASE_set == 1)
15615 return TRUE;
15616
15617 is_ITB_BASE_set = 1;
15618
15619 bh = bfd_link_hash_lookup (link_info->hash, "_ITB_BASE_", FALSE, FALSE, TRUE);
15620
15621 if (bh && (bh->type == bfd_link_hash_defined
15622 || bh->type == bfd_link_hash_defweak))
15623 return TRUE;
15624
15625 for (abfd = link_info->input_bfds; abfd != NULL;
15626 abfd = abfd->link.next)
15627 {
15628 sec = bfd_get_section_by_name (abfd, ".ex9.itable");
15629 if (sec != NULL)
15630 {
15631 output_bfd = sec->output_section->owner;
15632 break;
15633 }
15634 }
15635 if (output_bfd == NULL)
15636 {
15637 output_bfd = link_info->output_bfd;
15638 if (output_bfd->sections == NULL)
15639 return TRUE;
15640 else
15641 sec = bfd_abs_section_ptr;
15642 }
15643 bh = bfd_link_hash_lookup (link_info->hash, "_ITB_BASE_",
15644 FALSE, FALSE, TRUE);
15645 return (_bfd_generic_link_add_one_symbol
15646 (link_info, output_bfd, "_ITB_BASE_",
15647 BSF_GLOBAL | BSF_WEAK, sec, 0,
15648 (const char *) NULL, FALSE, get_elf_backend_data
15649 (output_bfd)->collect, &bh));
15650 } /* End EX9.IT */
15651
15652
15653 #define ELF_ARCH bfd_arch_nds32
15654 #define ELF_MACHINE_CODE EM_NDS32
15655 #define ELF_MAXPAGESIZE 0x1000
15656 #define ELF_TARGET_ID NDS32_ELF_DATA
15657
15658 #define TARGET_BIG_SYM nds32_elf32_be_vec
15659 #define TARGET_BIG_NAME "elf32-nds32be"
15660 #define TARGET_LITTLE_SYM nds32_elf32_le_vec
15661 #define TARGET_LITTLE_NAME "elf32-nds32le"
15662
15663 #define elf_info_to_howto nds32_info_to_howto
15664 #define elf_info_to_howto_rel nds32_info_to_howto_rel
15665
15666 #define bfd_elf32_bfd_link_hash_table_create nds32_elf_link_hash_table_create
15667 #define bfd_elf32_bfd_merge_private_bfd_data nds32_elf_merge_private_bfd_data
15668 #define bfd_elf32_bfd_print_private_bfd_data nds32_elf_print_private_bfd_data
15669 #define bfd_elf32_bfd_relax_section nds32_elf_relax_section
15670 #define bfd_elf32_bfd_set_private_flags nds32_elf_set_private_flags
15671
15672 #define bfd_elf32_mkobject nds32_elf_mkobject
15673 #define elf_backend_action_discarded nds32_elf_action_discarded
15674 #define elf_backend_add_symbol_hook nds32_elf_add_symbol_hook
15675 #define elf_backend_check_relocs nds32_elf_check_relocs
15676 #define elf_backend_adjust_dynamic_symbol nds32_elf_adjust_dynamic_symbol
15677 #define elf_backend_create_dynamic_sections nds32_elf_create_dynamic_sections
15678 #define elf_backend_finish_dynamic_sections nds32_elf_finish_dynamic_sections
15679 #define elf_backend_finish_dynamic_symbol nds32_elf_finish_dynamic_symbol
15680 #define elf_backend_size_dynamic_sections nds32_elf_size_dynamic_sections
15681 #define elf_backend_relocate_section nds32_elf_relocate_section
15682 #define elf_backend_gc_mark_hook nds32_elf_gc_mark_hook
15683 #define elf_backend_gc_sweep_hook nds32_elf_gc_sweep_hook
15684 #define elf_backend_grok_prstatus nds32_elf_grok_prstatus
15685 #define elf_backend_grok_psinfo nds32_elf_grok_psinfo
15686 #define elf_backend_reloc_type_class nds32_elf_reloc_type_class
15687 #define elf_backend_copy_indirect_symbol nds32_elf_copy_indirect_symbol
15688 #define elf_backend_link_output_symbol_hook nds32_elf_output_symbol_hook
15689 #define elf_backend_output_arch_syms nds32_elf_output_arch_syms
15690 #define elf_backend_object_p nds32_elf_object_p
15691 #define elf_backend_final_write_processing nds32_elf_final_write_processing
15692 #define elf_backend_special_sections nds32_elf_special_sections
15693 #define bfd_elf32_bfd_get_relocated_section_contents \
15694 nds32_elf_get_relocated_section_contents
15695
15696 #define elf_backend_can_gc_sections 1
15697 #define elf_backend_can_refcount 1
15698 #define elf_backend_want_got_plt 1
15699 #define elf_backend_plt_readonly 1
15700 #define elf_backend_want_plt_sym 0
15701 #define elf_backend_got_header_size 12
15702 #define elf_backend_may_use_rel_p 1
15703 #define elf_backend_default_use_rela_p 1
15704 #define elf_backend_may_use_rela_p 1
15705
15706 #include "elf32-target.h"
15707
15708 #undef ELF_MAXPAGESIZE
15709 #define ELF_MAXPAGESIZE 0x2000
15710
15711 #undef TARGET_BIG_SYM
15712 #define TARGET_BIG_SYM nds32_elf32_linux_be_vec
15713 #undef TARGET_BIG_NAME
15714 #define TARGET_BIG_NAME "elf32-nds32be-linux"
15715 #undef TARGET_LITTLE_SYM
15716 #define TARGET_LITTLE_SYM nds32_elf32_linux_le_vec
15717 #undef TARGET_LITTLE_NAME
15718 #define TARGET_LITTLE_NAME "elf32-nds32le-linux"
15719 #undef elf32_bed
15720 #define elf32_bed elf32_nds32_lin_bed
15721
15722 #include "elf32-target.h"
15723