projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ChangeLog rotatation and copyright year update
[deliverable/binutils-gdb.git] / bfd / elf32-nds32.c
1 /* NDS32-specific support for 32-bit ELF.
2 Copyright (C) 2012-2015 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
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 \f
2293 /* nds32_insertion_sort sorts an array with nmemb elements of size size.
2294 This prototype is the same as qsort (). */
2295
2296 void
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
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
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
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
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
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
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
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
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
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 \f
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 *
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 *
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 *
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
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 if (r_type > R_NDS32_GNU_VTENTRY)
2969 {
2970 _bfd_error_handler (_("%A: invalid NDS32 reloc number: %d"), abfd, r_type);
2971 r_type = 0;
2972 }
2973 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
2974 }
2975
2976 static void
2977 nds32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2978 Elf_Internal_Rela *dst)
2979 {
2980 BFD_ASSERT ((ELF32_R_TYPE (dst->r_info) == R_NDS32_NONE)
2981 || ((ELF32_R_TYPE (dst->r_info) > R_NDS32_GNU_VTENTRY)
2982 && (ELF32_R_TYPE (dst->r_info) < R_NDS32_max)));
2983 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (dst->r_info));
2984 }
2985
2986 /* Support for core dump NOTE sections.
2987 Reference to include/linux/elfcore.h in Linux. */
2988
2989 static bfd_boolean
2990 nds32_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2991 {
2992 int offset;
2993 size_t size;
2994
2995 switch (note->descsz)
2996 {
2997 case 0x114:
2998 /* Linux/NDS32 32-bit, ABI1 */
2999
3000 /* pr_cursig */
3001 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3002
3003 /* pr_pid */
3004 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3005
3006 /* pr_reg */
3007 offset = 72;
3008 size = 200;
3009 break;
3010
3011 case 0xfc:
3012 /* Linux/NDS32 32-bit */
3013
3014 /* pr_cursig */
3015 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3016
3017 /* pr_pid */
3018 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3019
3020 /* pr_reg */
3021 offset = 72;
3022 size = 176;
3023 break;
3024
3025 default:
3026 return FALSE;
3027 }
3028
3029 /* Make a ".reg" section. */
3030 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3031 size, note->descpos + offset);
3032 }
3033
3034 static bfd_boolean
3035 nds32_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3036 {
3037 switch (note->descsz)
3038 {
3039 case 124:
3040 /* Linux/NDS32 */
3041
3042 /* __kernel_uid_t, __kernel_gid_t are short on NDS32 platform. */
3043 elf_tdata (abfd)->core->program =
3044 _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3045 elf_tdata (abfd)->core->command =
3046 _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3047
3048 default:
3049 return FALSE;
3050 }
3051
3052 /* Note that for some reason, a spurious space is tacked
3053 onto the end of the args in some (at least one anyway)
3054 implementations, so strip it off if it exists. */
3055 {
3056 char *command = elf_tdata (abfd)->core->command;
3057 int n = strlen (command);
3058
3059 if (0 < n && command[n - 1] == ' ')
3060 command[n - 1] = '\0';
3061 }
3062
3063 return TRUE;
3064 }
3065
3066 /* Hook called by the linker routine which adds symbols from an object
3067 file. We must handle the special NDS32 section numbers here.
3068 We also keep watching for whether we need to create the sdata special
3069 linker sections. */
3070
3071 static bfd_boolean
3072 nds32_elf_add_symbol_hook (bfd *abfd,
3073 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3074 Elf_Internal_Sym *sym,
3075 const char **namep ATTRIBUTE_UNUSED,
3076 flagword *flagsp ATTRIBUTE_UNUSED,
3077 asection **secp, bfd_vma *valp)
3078 {
3079 switch (sym->st_shndx)
3080 {
3081 case SHN_COMMON:
3082 /* Common symbols less than the GP size are automatically
3083 treated as SHN_MIPS_SCOMMON symbols. */
3084 if (sym->st_size > elf_gp_size (abfd)
3085 || ELF_ST_TYPE (sym->st_info) == STT_TLS)
3086 break;
3087
3088 /* st_value is the alignemnt constraint.
3089 That might be its actual size if it is an array or structure. */
3090 switch (sym->st_value)
3091 {
3092 case 1:
3093 *secp = bfd_make_section_old_way (abfd, ".scommon_b");
3094 break;
3095 case 2:
3096 *secp = bfd_make_section_old_way (abfd, ".scommon_h");
3097 break;
3098 case 4:
3099 *secp = bfd_make_section_old_way (abfd, ".scommon_w");
3100 break;
3101 case 8:
3102 *secp = bfd_make_section_old_way (abfd, ".scommon_d");
3103 break;
3104 default:
3105 return TRUE;
3106 }
3107
3108 (*secp)->flags |= SEC_IS_COMMON;
3109 *valp = sym->st_size;
3110 break;
3111 }
3112
3113 return TRUE;
3114 }
3115
3116
3117 /* This function can figure out the best location for a base register to access
3118 data relative to this base register
3119 INPUT:
3120 sda_d0: size of first DOUBLE WORD data section
3121 sda_w0: size of first WORD data section
3122 sda_h0: size of first HALF WORD data section
3123 sda_b : size of BYTE data section
3124 sda_hi: size of second HALF WORD data section
3125 sda_w1: size of second WORD data section
3126 sda_d1: size of second DOUBLE WORD data section
3127 OUTPUT:
3128 offset (always positive) from the beginning of sda_d0 if OK
3129 a negative error value if fail
3130 NOTE:
3131 these 7 sections have to be located back to back if exist
3132 a pass in 0 value for non-existing section */
3133
3134 /* Due to the interpretation of simm15 field of load/store depending on
3135 data accessing size, the organization of base register relative data shall
3136 like the following figure
3137 -------------------------------------------
3138 | DOUBLE WORD sized data (range +/- 128K)
3139 -------------------------------------------
3140 | WORD sized data (range +/- 64K)
3141 -------------------------------------------
3142 | HALF WORD sized data (range +/- 32K)
3143 -------------------------------------------
3144 | BYTE sized data (range +/- 16K)
3145 -------------------------------------------
3146 | HALF WORD sized data (range +/- 32K)
3147 -------------------------------------------
3148 | WORD sized data (range +/- 64K)
3149 -------------------------------------------
3150 | DOUBLE WORD sized data (range +/- 128K)
3151 -------------------------------------------
3152 Its base register shall be set to access these data freely. */
3153
3154 /* We have to figure out the SDA_BASE value, so that we can adjust the
3155 symbol value correctly. We look up the symbol _SDA_BASE_ in the output
3156 BFD. If we can't find it, we're stuck. We cache it in the ELF
3157 target data. We don't need to adjust the symbol value for an
3158 external symbol if we are producing relocatable output. */
3159
3160 static asection *sda_rela_sec = NULL;
3161
3162 #define SDA_SECTION_NUM 10
3163
3164 static bfd_reloc_status_type
3165 nds32_elf_final_sda_base (bfd *output_bfd, struct bfd_link_info *info,
3166 bfd_vma *psb, bfd_boolean add_symbol)
3167 {
3168 int relax_fp_as_gp;
3169 struct elf_nds32_link_hash_table *table;
3170 struct bfd_link_hash_entry *h, *h2;
3171 long unsigned int total = 0;
3172
3173 h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
3174 if (!h || (h->type != bfd_link_hash_defined && h->type != bfd_link_hash_defweak))
3175 {
3176 asection *first = NULL, *final = NULL, *temp;
3177 bfd_vma sda_base;
3178 /* The first section must be 4-byte aligned to promise _SDA_BASE_ being
3179 4 byte-aligned. Therefore, it has to set the first section ".data"
3180 4 byte-aligned. */
3181 static const char sec_name[SDA_SECTION_NUM][10] =
3182 {
3183 ".data", ".got", ".sdata_d", ".sdata_w", ".sdata_h", ".sdata_b",
3184 ".sbss_b", ".sbss_h", ".sbss_w", ".sbss_d"
3185 };
3186 size_t i = 0;
3187
3188 if (output_bfd->sections == NULL)
3189 {
3190 *psb = elf_gp (output_bfd);
3191 return bfd_reloc_ok;
3192 }
3193
3194 /* Get the first and final section. */
3195 while (i < sizeof (sec_name) / sizeof (sec_name [0]))
3196 {
3197 temp = bfd_get_section_by_name (output_bfd, sec_name[i]);
3198 if (temp && !first && (temp->size != 0 || temp->rawsize != 0))
3199 first = temp;
3200 if (temp && (temp->size != 0 || temp->rawsize != 0))
3201 final = temp;
3202
3203 /* Summarize the sections in order to check if joining .bss. */
3204 if (temp && temp->size != 0)
3205 total += temp->size;
3206 else if (temp && temp->rawsize != 0)
3207 total += temp->rawsize;
3208
3209 i++;
3210 }
3211
3212 /* Check .bss size. */
3213 temp = bfd_get_section_by_name (output_bfd, ".bss");
3214 if (temp)
3215 {
3216 if (temp->size != 0)
3217 total += temp->size;
3218 else if (temp->rawsize != 0)
3219 total += temp->rawsize;
3220
3221 if (total < 0x80000)
3222 {
3223 if (!first && (temp->size != 0 || temp->rawsize != 0))
3224 first = temp;
3225 if ((temp->size != 0 || temp->rawsize != 0))
3226 final = temp;
3227 }
3228 }
3229
3230 if (first && final)
3231 {
3232 /* The middle of data region. */
3233 sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3234
3235 /* Find the section sda_base located. */
3236 i = 0;
3237 while (i < sizeof (sec_name) / sizeof (sec_name [0]))
3238 {
3239 final = bfd_get_section_by_name (output_bfd, sec_name[i]);
3240 if (final && (final->size != 0 || final->rawsize != 0)
3241 && sda_base >= final->vma)
3242 {
3243 first = final;
3244 i++;
3245 }
3246 else
3247 break;
3248 }
3249 }
3250 else
3251 {
3252 /* There is not any data section in output bfd, and set _SDA_BASE_ in
3253 first output section. */
3254 first = output_bfd->sections;
3255 while (first && first->size == 0 && first->rawsize == 0)
3256 first = first->next;
3257 if (!first)
3258 {
3259 *psb = elf_gp (output_bfd);
3260 return bfd_reloc_ok;
3261 }
3262 sda_base = first->vma + first->rawsize;
3263 }
3264
3265 sda_base -= first->vma;
3266 sda_base = sda_base & (~7);
3267
3268 if (!_bfd_generic_link_add_one_symbol
3269 (info, output_bfd, "_SDA_BASE_", BSF_GLOBAL | BSF_WEAK, first,
3270 (bfd_vma) sda_base, (const char *) NULL, FALSE,
3271 get_elf_backend_data (output_bfd)->collect, &h))
3272 return FALSE;
3273
3274 sda_rela_sec = first;
3275
3276 table = nds32_elf_hash_table (info);
3277 relax_fp_as_gp = table->relax_fp_as_gp;
3278 if (relax_fp_as_gp)
3279 {
3280 h2 = bfd_link_hash_lookup (info->hash, FP_BASE_NAME,
3281 FALSE, FALSE, FALSE);
3282 /* Define a weak FP_BASE_NAME here to prevent the undefined symbol.
3283 And set FP equal to SDA_BASE to do relaxation for
3284 la $fp, _FP_BASE_. */
3285 if (!_bfd_generic_link_add_one_symbol
3286 (info, output_bfd, FP_BASE_NAME, BSF_GLOBAL | BSF_WEAK,
3287 first, (bfd_vma) sda_base, (const char *) NULL,
3288 FALSE, get_elf_backend_data (output_bfd)->collect, &h2))
3289 return FALSE;
3290 }
3291 }
3292
3293 if (add_symbol == TRUE)
3294 {
3295 if (h)
3296 {
3297 /* Now set gp. */
3298 elf_gp (output_bfd) = (h->u.def.value
3299 + h->u.def.section->output_section->vma
3300 + h->u.def.section->output_offset);
3301 }
3302 else
3303 {
3304 (*_bfd_error_handler) (_("error: Can't find symbol: _SDA_BASE_."));
3305 return bfd_reloc_dangerous;
3306 }
3307 }
3308
3309 *psb = h->u.def.value + h->u.def.section->output_section->vma
3310 + h->u.def.section->output_offset;
3311 return bfd_reloc_ok;
3312 }
3313 \f
3314
3315 /* Return size of a PLT entry. */
3316 #define elf_nds32_sizeof_plt(info) PLT_ENTRY_SIZE
3317
3318
3319 /* Create an entry in an nds32 ELF linker hash table. */
3320
3321 static struct bfd_hash_entry *
3322 nds32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
3323 struct bfd_hash_table *table,
3324 const char *string)
3325 {
3326 struct elf_nds32_link_hash_entry *ret;
3327
3328 ret = (struct elf_nds32_link_hash_entry *) entry;
3329
3330 /* Allocate the structure if it has not already been allocated by a
3331 subclass. */
3332 if (ret == NULL)
3333 ret = (struct elf_nds32_link_hash_entry *)
3334 bfd_hash_allocate (table, sizeof (struct elf_nds32_link_hash_entry));
3335
3336 if (ret == NULL)
3337 return (struct bfd_hash_entry *) ret;
3338
3339 /* Call the allocation method of the superclass. */
3340 ret = (struct elf_nds32_link_hash_entry *)
3341 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
3342
3343 if (ret != NULL)
3344 {
3345 struct elf_nds32_link_hash_entry *eh;
3346
3347 eh = (struct elf_nds32_link_hash_entry *) ret;
3348 eh->dyn_relocs = NULL;
3349 eh->tls_type = GOT_UNKNOWN;
3350 }
3351
3352 return (struct bfd_hash_entry *) ret;
3353 }
3354
3355 /* Create an nds32 ELF linker hash table. */
3356
3357 static struct bfd_link_hash_table *
3358 nds32_elf_link_hash_table_create (bfd *abfd)
3359 {
3360 struct elf_nds32_link_hash_table *ret;
3361
3362 bfd_size_type amt = sizeof (struct elf_nds32_link_hash_table);
3363
3364 ret = (struct elf_nds32_link_hash_table *) bfd_zmalloc (amt);
3365 if (ret == NULL)
3366 return NULL;
3367
3368 /* patch tag. */
3369 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3370 nds32_elf_link_hash_newfunc,
3371 sizeof (struct elf_nds32_link_hash_entry),
3372 NDS32_ELF_DATA))
3373 {
3374 free (ret);
3375 return NULL;
3376 }
3377
3378 ret->sgot = NULL;
3379 ret->sgotplt = NULL;
3380 ret->srelgot = NULL;
3381 ret->splt = NULL;
3382 ret->srelplt = NULL;
3383 ret->sdynbss = NULL;
3384 ret->srelbss = NULL;
3385 ret->sym_ld_script = NULL;
3386 ret->ex9_export_file = NULL;
3387 ret->ex9_import_file = NULL;
3388
3389 return &ret->root.root;
3390 }
3391
3392 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3393 shortcuts to them in our hash table. */
3394
3395 static bfd_boolean
3396 create_got_section (bfd *dynobj, struct bfd_link_info *info)
3397 {
3398 struct elf_nds32_link_hash_table *htab;
3399
3400 if (!_bfd_elf_create_got_section (dynobj, info))
3401 return FALSE;
3402
3403 htab = nds32_elf_hash_table (info);
3404 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
3405 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3406 if (!htab->sgot || !htab->sgotplt)
3407 abort ();
3408
3409 /* _bfd_elf_create_got_section will create it for us. */
3410 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3411 if (htab->srelgot == NULL
3412 || !bfd_set_section_flags (dynobj, htab->srelgot,
3413 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
3414 | SEC_IN_MEMORY | SEC_LINKER_CREATED
3415 | SEC_READONLY))
3416 || !bfd_set_section_alignment (dynobj, htab->srelgot, 2))
3417 return FALSE;
3418
3419 return TRUE;
3420 }
3421
3422 /* Create dynamic sections when linking against a dynamic object. */
3423
3424 static bfd_boolean
3425 nds32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3426 {
3427 struct elf_nds32_link_hash_table *htab;
3428 flagword flags, pltflags;
3429 register asection *s;
3430 const struct elf_backend_data *bed;
3431 int ptralign = 2; /* 32-bit */
3432
3433 bed = get_elf_backend_data (abfd);
3434
3435 htab = nds32_elf_hash_table (info);
3436
3437 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3438 .rel[a].bss sections. */
3439
3440 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3441 | SEC_LINKER_CREATED);
3442
3443 pltflags = flags;
3444 pltflags |= SEC_CODE;
3445 if (bed->plt_not_loaded)
3446 pltflags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
3447 if (bed->plt_readonly)
3448 pltflags |= SEC_READONLY;
3449
3450 s = bfd_make_section (abfd, ".plt");
3451 htab->splt = s;
3452 if (s == NULL
3453 || !bfd_set_section_flags (abfd, s, pltflags)
3454 || !bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3455 return FALSE;
3456
3457 if (bed->want_plt_sym)
3458 {
3459 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3460 .plt section. */
3461 struct bfd_link_hash_entry *bh = NULL;
3462 struct elf_link_hash_entry *h;
3463
3464 if (!(_bfd_generic_link_add_one_symbol
3465 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3466 (bfd_vma) 0, (const char *) NULL, FALSE,
3467 get_elf_backend_data (abfd)->collect, &bh)))
3468 return FALSE;
3469
3470 h = (struct elf_link_hash_entry *) bh;
3471 h->def_regular = 1;
3472 h->type = STT_OBJECT;
3473
3474 if (info->shared && !bfd_elf_link_record_dynamic_symbol (info, h))
3475 return FALSE;
3476 }
3477
3478 s = bfd_make_section (abfd,
3479 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3480 htab->srelplt = s;
3481 if (s == NULL
3482 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3483 || !bfd_set_section_alignment (abfd, s, ptralign))
3484 return FALSE;
3485
3486 if (htab->sgot == NULL && !create_got_section (abfd, info))
3487 return FALSE;
3488
3489 {
3490 const char *secname;
3491 char *relname;
3492 flagword secflags;
3493 asection *sec;
3494
3495 for (sec = abfd->sections; sec; sec = sec->next)
3496 {
3497 secflags = bfd_get_section_flags (abfd, sec);
3498 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3499 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3500 continue;
3501 secname = bfd_get_section_name (abfd, sec);
3502 relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3503 strcpy (relname, ".rela");
3504 strcat (relname, secname);
3505 if (bfd_get_section_by_name (abfd, secname))
3506 continue;
3507 s = bfd_make_section (abfd, relname);
3508 if (s == NULL
3509 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3510 || !bfd_set_section_alignment (abfd, s, ptralign))
3511 return FALSE;
3512 }
3513 }
3514
3515 if (bed->want_dynbss)
3516 {
3517 /* The .dynbss section is a place to put symbols which are defined
3518 by dynamic objects, are referenced by regular objects, and are
3519 not functions. We must allocate space for them in the process
3520 image and use a R_*_COPY reloc to tell the dynamic linker to
3521 initialize them at run time. The linker script puts the .dynbss
3522 section into the .bss section of the final image. */
3523 s = bfd_make_section (abfd, ".dynbss");
3524 htab->sdynbss = s;
3525 if (s == NULL
3526 || !bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
3527 return FALSE;
3528 /* The .rel[a].bss section holds copy relocs. This section is not
3529 normally needed. We need to create it here, though, so that the
3530 linker will map it to an output section. We can't just create it
3531 only if we need it, because we will not know whether we need it
3532 until we have seen all the input files, and the first time the
3533 main linker code calls BFD after examining all the input files
3534 (size_dynamic_sections) the input sections have already been
3535 mapped to the output sections. If the section turns out not to
3536 be needed, we can discard it later. We will never need this
3537 section when generating a shared object, since they do not use
3538 copy relocs. */
3539 if (!info->shared)
3540 {
3541 s = bfd_make_section (abfd, (bed->default_use_rela_p
3542 ? ".rela.bss" : ".rel.bss"));
3543 htab->srelbss = s;
3544 if (s == NULL
3545 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3546 || !bfd_set_section_alignment (abfd, s, ptralign))
3547 return FALSE;
3548 }
3549 }
3550
3551 return TRUE;
3552 }
3553
3554 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3555 static void
3556 nds32_elf_copy_indirect_symbol (struct bfd_link_info *info,
3557 struct elf_link_hash_entry *dir,
3558 struct elf_link_hash_entry *ind)
3559 {
3560 struct elf_nds32_link_hash_entry *edir, *eind;
3561
3562 edir = (struct elf_nds32_link_hash_entry *) dir;
3563 eind = (struct elf_nds32_link_hash_entry *) ind;
3564
3565 if (eind->dyn_relocs != NULL)
3566 {
3567 if (edir->dyn_relocs != NULL)
3568 {
3569 struct elf_nds32_dyn_relocs **pp;
3570 struct elf_nds32_dyn_relocs *p;
3571
3572 if (ind->root.type == bfd_link_hash_indirect)
3573 abort ();
3574
3575 /* Add reloc counts against the weak sym to the strong sym
3576 list. Merge any entries against the same section. */
3577 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
3578 {
3579 struct elf_nds32_dyn_relocs *q;
3580
3581 for (q = edir->dyn_relocs; q != NULL; q = q->next)
3582 if (q->sec == p->sec)
3583 {
3584 q->pc_count += p->pc_count;
3585 q->count += p->count;
3586 *pp = p->next;
3587 break;
3588 }
3589 if (q == NULL)
3590 pp = &p->next;
3591 }
3592 *pp = edir->dyn_relocs;
3593 }
3594
3595 edir->dyn_relocs = eind->dyn_relocs;
3596 eind->dyn_relocs = NULL;
3597 }
3598
3599 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3600 }
3601 \f
3602
3603 /* Adjust a symbol defined by a dynamic object and referenced by a
3604 regular object. The current definition is in some section of the
3605 dynamic object, but we're not including those sections. We have to
3606 change the definition to something the rest of the link can
3607 understand. */
3608
3609 static bfd_boolean
3610 nds32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3611 struct elf_link_hash_entry *h)
3612 {
3613 struct elf_nds32_link_hash_table *htab;
3614 struct elf_nds32_link_hash_entry *eh;
3615 struct elf_nds32_dyn_relocs *p;
3616 bfd *dynobj;
3617 asection *s;
3618 unsigned int power_of_two;
3619
3620 dynobj = elf_hash_table (info)->dynobj;
3621
3622 /* Make sure we know what is going on here. */
3623 BFD_ASSERT (dynobj != NULL
3624 && (h->needs_plt
3625 || h->u.weakdef != NULL
3626 || (h->def_dynamic && h->ref_regular && !h->def_regular)));
3627
3628
3629 /* If this is a function, put it in the procedure linkage table. We
3630 will fill in the contents of the procedure linkage table later,
3631 when we know the address of the .got section. */
3632 if (h->type == STT_FUNC || h->needs_plt)
3633 {
3634 if (!info->shared
3635 && !h->def_dynamic
3636 && !h->ref_dynamic
3637 && h->root.type != bfd_link_hash_undefweak
3638 && h->root.type != bfd_link_hash_undefined)
3639 {
3640 /* This case can occur if we saw a PLT reloc in an input
3641 file, but the symbol was never referred to by a dynamic
3642 object. In such a case, we don't actually need to build
3643 a procedure linkage table, and we can just do a PCREL
3644 reloc instead. */
3645 h->plt.offset = (bfd_vma) - 1;
3646 h->needs_plt = 0;
3647 }
3648
3649 return TRUE;
3650 }
3651 else
3652 h->plt.offset = (bfd_vma) - 1;
3653
3654 /* If this is a weak symbol, and there is a real definition, the
3655 processor independent code will have arranged for us to see the
3656 real definition first, and we can just use the same value. */
3657 if (h->u.weakdef != NULL)
3658 {
3659 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3660 || h->u.weakdef->root.type == bfd_link_hash_defweak);
3661 h->root.u.def.section = h->u.weakdef->root.u.def.section;
3662 h->root.u.def.value = h->u.weakdef->root.u.def.value;
3663 return TRUE;
3664 }
3665
3666 /* This is a reference to a symbol defined by a dynamic object which
3667 is not a function. */
3668
3669 /* If we are creating a shared library, we must presume that the
3670 only references to the symbol are via the global offset table.
3671 For such cases we need not do anything here; the relocations will
3672 be handled correctly by relocate_section. */
3673 if (info->shared)
3674 return TRUE;
3675
3676 /* If there are no references to this symbol that do not use the
3677 GOT, we don't need to generate a copy reloc. */
3678 if (!h->non_got_ref)
3679 return TRUE;
3680
3681 /* If -z nocopyreloc was given, we won't generate them either. */
3682 if (info->nocopyreloc)
3683 {
3684 h->non_got_ref = 0;
3685 return TRUE;
3686 }
3687
3688 eh = (struct elf_nds32_link_hash_entry *) h;
3689 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3690 {
3691 s = p->sec->output_section;
3692 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
3693 break;
3694 }
3695
3696 /* If we didn't find any dynamic relocs in sections which needs the
3697 copy reloc, then we'll be keeping the dynamic relocs and avoiding
3698 the copy reloc. */
3699 if (p == NULL)
3700 {
3701 h->non_got_ref = 0;
3702 return TRUE;
3703 }
3704
3705 /* We must allocate the symbol in our .dynbss section, which will
3706 become part of the .bss section of the executable. There will be
3707 an entry for this symbol in the .dynsym section. The dynamic
3708 object will contain position independent code, so all references
3709 from the dynamic object to this symbol will go through the global
3710 offset table. The dynamic linker will use the .dynsym entry to
3711 determine the address it must put in the global offset table, so
3712 both the dynamic object and the regular object will refer to the
3713 same memory location for the variable. */
3714
3715 htab = nds32_elf_hash_table (info);
3716 s = htab->sdynbss;
3717 BFD_ASSERT (s != NULL);
3718
3719 /* We must generate a R_NDS32_COPY reloc to tell the dynamic linker
3720 to copy the initial value out of the dynamic object and into the
3721 runtime process image. We need to remember the offset into the
3722 .rela.bss section we are going to use. */
3723 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3724 {
3725 asection *srel;
3726
3727 srel = htab->srelbss;
3728 BFD_ASSERT (srel != NULL);
3729 srel->size += sizeof (Elf32_External_Rela);
3730 h->needs_copy = 1;
3731 }
3732
3733 /* We need to figure out the alignment required for this symbol. I
3734 have no idea how ELF linkers handle this. */
3735 power_of_two = bfd_log2 (h->size);
3736 if (power_of_two > 3)
3737 power_of_two = 3;
3738
3739 /* Apply the required alignment. */
3740 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
3741 if (power_of_two > bfd_get_section_alignment (dynobj, s))
3742 {
3743 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
3744 return FALSE;
3745 }
3746
3747 /* Define the symbol as being at this point in the section. */
3748 h->root.u.def.section = s;
3749 h->root.u.def.value = s->size;
3750
3751 /* Increment the section size to make room for the symbol. */
3752 s->size += h->size;
3753
3754 return TRUE;
3755 }
3756
3757 /* Allocate space in .plt, .got and associated reloc sections for
3758 dynamic relocs. */
3759
3760 static bfd_boolean
3761 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3762 {
3763 struct bfd_link_info *info;
3764 struct elf_nds32_link_hash_table *htab;
3765 struct elf_nds32_link_hash_entry *eh;
3766 struct elf_nds32_dyn_relocs *p;
3767
3768 if (h->root.type == bfd_link_hash_indirect)
3769 return TRUE;
3770
3771 if (h->root.type == bfd_link_hash_warning)
3772 /* When warning symbols are created, they **replace** the "real"
3773 entry in the hash table, thus we never get to see the real
3774 symbol in a hash traversal. So look at it now. */
3775 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3776
3777 info = (struct bfd_link_info *) inf;
3778 htab = nds32_elf_hash_table (info);
3779
3780 eh = (struct elf_nds32_link_hash_entry *) h;
3781
3782 if (htab->root.dynamic_sections_created && h->plt.refcount > 0)
3783 {
3784 /* Make sure this symbol is output as a dynamic symbol.
3785 Undefined weak syms won't yet be marked as dynamic. */
3786 if (h->dynindx == -1 && !h->forced_local)
3787 {
3788 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3789 return FALSE;
3790 }
3791
3792 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
3793 {
3794 asection *s = htab->splt;
3795
3796 /* If this is the first .plt entry, make room for the special
3797 first entry. */
3798 if (s->size == 0)
3799 s->size += PLT_ENTRY_SIZE;
3800
3801 h->plt.offset = s->size;
3802
3803 /* If this symbol is not defined in a regular file, and we are
3804 not generating a shared library, then set the symbol to this
3805 location in the .plt. This is required to make function
3806 pointers compare as equal between the normal executable and
3807 the shared library. */
3808 if (!info->shared && !h->def_regular)
3809 {
3810 h->root.u.def.section = s;
3811 h->root.u.def.value = h->plt.offset;
3812 }
3813
3814 /* Make room for this entry. */
3815 s->size += PLT_ENTRY_SIZE;
3816
3817 /* We also need to make an entry in the .got.plt section, which
3818 will be placed in the .got section by the linker script. */
3819 htab->sgotplt->size += 4;
3820
3821 /* We also need to make an entry in the .rel.plt section. */
3822 htab->srelplt->size += sizeof (Elf32_External_Rela);
3823 }
3824 else
3825 {
3826 h->plt.offset = (bfd_vma) - 1;
3827 h->needs_plt = 0;
3828 }
3829 }
3830 else
3831 {
3832 h->plt.offset = (bfd_vma) - 1;
3833 h->needs_plt = 0;
3834 }
3835
3836 if (h->got.refcount > 0)
3837 {
3838 asection *s;
3839 bfd_boolean dyn;
3840 int tls_type = elf32_nds32_hash_entry (h)->tls_type;
3841
3842 /* Make sure this symbol is output as a dynamic symbol.
3843 Undefined weak syms won't yet be marked as dynamic. */
3844 if (h->dynindx == -1 && !h->forced_local)
3845 {
3846 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3847 return FALSE;
3848 }
3849
3850 s = htab->sgot;
3851 h->got.offset = s->size;
3852
3853 if (tls_type == GOT_UNKNOWN)
3854 abort ();
3855 else if (tls_type == GOT_NORMAL
3856 || tls_type == GOT_TLS_IE)
3857 /* Need a GOT slot. */
3858 s->size += 4;
3859
3860 dyn = htab->root.dynamic_sections_created;
3861 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
3862 htab->srelgot->size += sizeof (Elf32_External_Rela);
3863 }
3864 else
3865 h->got.offset = (bfd_vma) - 1;
3866
3867 if (eh->dyn_relocs == NULL)
3868 return TRUE;
3869
3870 /* In the shared -Bsymbolic case, discard space allocated for
3871 dynamic pc-relative relocs against symbols which turn out to be
3872 defined in regular objects. For the normal shared case, discard
3873 space for pc-relative relocs that have become local due to symbol
3874 visibility changes. */
3875
3876 if (info->shared)
3877 {
3878 if (h->def_regular && (h->forced_local || info->symbolic))
3879 {
3880 struct elf_nds32_dyn_relocs **pp;
3881
3882 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
3883 {
3884 p->count -= p->pc_count;
3885 p->pc_count = 0;
3886 if (p->count == 0)
3887 *pp = p->next;
3888 else
3889 pp = &p->next;
3890 }
3891 }
3892 }
3893 else
3894 {
3895 /* For the non-shared case, discard space for relocs against
3896 symbols which turn out to need copy relocs or are not dynamic. */
3897
3898 if (!h->non_got_ref
3899 && ((h->def_dynamic
3900 && !h->def_regular)
3901 || (htab->root.dynamic_sections_created
3902 && (h->root.type == bfd_link_hash_undefweak
3903 || h->root.type == bfd_link_hash_undefined))))
3904 {
3905 /* Make sure this symbol is output as a dynamic symbol.
3906 Undefined weak syms won't yet be marked as dynamic. */
3907 if (h->dynindx == -1 && !h->forced_local)
3908 {
3909 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3910 return FALSE;
3911 }
3912
3913 /* If that succeeded, we know we'll be keeping all the
3914 relocs. */
3915 if (h->dynindx != -1)
3916 goto keep;
3917 }
3918
3919 eh->dyn_relocs = NULL;
3920
3921 keep:;
3922 }
3923
3924 /* Finally, allocate space. */
3925 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3926 {
3927 asection *sreloc = elf_section_data (p->sec)->sreloc;
3928 sreloc->size += p->count * sizeof (Elf32_External_Rela);
3929 }
3930
3931 return TRUE;
3932 }
3933
3934 /* Find any dynamic relocs that apply to read-only sections. */
3935
3936 static bfd_boolean
3937 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3938 {
3939 struct elf_nds32_link_hash_entry *eh;
3940 struct elf_nds32_dyn_relocs *p;
3941
3942 if (h->root.type == bfd_link_hash_warning)
3943 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3944
3945 eh = (struct elf_nds32_link_hash_entry *) h;
3946 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3947 {
3948 asection *s = p->sec->output_section;
3949
3950 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3951 {
3952 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3953
3954 info->flags |= DF_TEXTREL;
3955
3956 /* Not an error, just cut short the traversal. */
3957 return FALSE;
3958 }
3959 }
3960 return TRUE;
3961 }
3962
3963 /* Set the sizes of the dynamic sections. */
3964
3965 static bfd_boolean
3966 nds32_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3967 struct bfd_link_info *info)
3968 {
3969 struct elf_nds32_link_hash_table *htab;
3970 bfd *dynobj;
3971 asection *s;
3972 bfd_boolean relocs;
3973 bfd *ibfd;
3974
3975 htab = nds32_elf_hash_table (info);
3976 dynobj = htab->root.dynobj;
3977 BFD_ASSERT (dynobj != NULL);
3978
3979 if (htab->root.dynamic_sections_created)
3980 {
3981 /* Set the contents of the .interp section to the interpreter. */
3982 if (!info->shared)
3983 {
3984 s = bfd_get_section_by_name (dynobj, ".interp");
3985 BFD_ASSERT (s != NULL);
3986 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3987 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3988 }
3989 }
3990
3991 /* Set up .got offsets for local syms, and space for local dynamic
3992 relocs. */
3993 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3994 {
3995 bfd_signed_vma *local_got;
3996 bfd_signed_vma *end_local_got;
3997 bfd_size_type locsymcount;
3998 Elf_Internal_Shdr *symtab_hdr;
3999 asection *srel;
4000
4001 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
4002 continue;
4003
4004 for (s = ibfd->sections; s != NULL; s = s->next)
4005 {
4006 struct elf_nds32_dyn_relocs *p;
4007
4008 for (p = ((struct elf_nds32_dyn_relocs *)
4009 elf_section_data (s)->local_dynrel);
4010 p != NULL; p = p->next)
4011 {
4012 if (!bfd_is_abs_section (p->sec)
4013 && bfd_is_abs_section (p->sec->output_section))
4014 {
4015 /* Input section has been discarded, either because
4016 it is a copy of a linkonce section or due to
4017 linker script /DISCARD/, so we'll be discarding
4018 the relocs too. */
4019 }
4020 else if (p->count != 0)
4021 {
4022 srel = elf_section_data (p->sec)->sreloc;
4023 srel->size += p->count * sizeof (Elf32_External_Rela);
4024 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
4025 info->flags |= DF_TEXTREL;
4026 }
4027 }
4028 }
4029
4030 local_got = elf_local_got_refcounts (ibfd);
4031 if (!local_got)
4032 continue;
4033
4034 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4035 locsymcount = symtab_hdr->sh_info;
4036 end_local_got = local_got + locsymcount;
4037 s = htab->sgot;
4038 srel = htab->srelgot;
4039 for (; local_got < end_local_got; ++local_got)
4040 {
4041 if (*local_got > 0)
4042 {
4043 *local_got = s->size;
4044 s->size += 4;
4045 if (info->shared)
4046 srel->size += sizeof (Elf32_External_Rela);
4047 }
4048 else
4049 *local_got = (bfd_vma) - 1;
4050 }
4051 }
4052
4053 /* Allocate global sym .plt and .got entries, and space for global
4054 sym dynamic relocs. */
4055 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (void *) info);
4056
4057 /* We now have determined the sizes of the various dynamic sections.
4058 Allocate memory for them. */
4059 relocs = FALSE;
4060 for (s = dynobj->sections; s != NULL; s = s->next)
4061 {
4062 if ((s->flags & SEC_LINKER_CREATED) == 0)
4063 continue;
4064
4065 if (s == htab->splt)
4066 {
4067 /* Strip this section if we don't need it; see the
4068 comment below. */
4069 }
4070 else if (s == htab->sgot)
4071 {
4072 got_size += s->size;
4073 }
4074 else if (s == htab->sgotplt)
4075 {
4076 got_size += s->size;
4077 }
4078 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
4079 {
4080 if (s->size != 0 && s != htab->srelplt)
4081 relocs = TRUE;
4082
4083 /* We use the reloc_count field as a counter if we need
4084 to copy relocs into the output file. */
4085 s->reloc_count = 0;
4086 }
4087 else
4088 {
4089 /* It's not one of our sections, so don't allocate space. */
4090 continue;
4091 }
4092
4093 if (s->size == 0)
4094 {
4095 /* If we don't need this section, strip it from the
4096 output file. This is mostly to handle .rela.bss and
4097 .rela.plt. We must create both sections in
4098 create_dynamic_sections, because they must be created
4099 before the linker maps input sections to output
4100 sections. The linker does that before
4101 adjust_dynamic_symbol is called, and it is that
4102 function which decides whether anything needs to go
4103 into these sections. */
4104 s->flags |= SEC_EXCLUDE;
4105 continue;
4106 }
4107
4108 /* Allocate memory for the section contents. We use bfd_zalloc
4109 here in case unused entries are not reclaimed before the
4110 section's contents are written out. This should not happen,
4111 but this way if it does, we get a R_NDS32_NONE reloc instead
4112 of garbage. */
4113 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4114 if (s->contents == NULL)
4115 return FALSE;
4116 }
4117
4118
4119 if (htab->root.dynamic_sections_created)
4120 {
4121 /* Add some entries to the .dynamic section. We fill in the
4122 values later, in nds32_elf_finish_dynamic_sections, but we
4123 must add the entries now so that we get the correct size for
4124 the .dynamic section. The DT_DEBUG entry is filled in by the
4125 dynamic linker and used by the debugger. */
4126 #define add_dynamic_entry(TAG, VAL) \
4127 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4128
4129 if (!info->shared)
4130 {
4131 if (!add_dynamic_entry (DT_DEBUG, 0))
4132 return FALSE;
4133 }
4134
4135 if (htab->splt->size != 0)
4136 {
4137 if (!add_dynamic_entry (DT_PLTGOT, 0)
4138 || !add_dynamic_entry (DT_PLTRELSZ, 0)
4139 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4140 || !add_dynamic_entry (DT_JMPREL, 0))
4141 return FALSE;
4142 }
4143
4144 if (relocs)
4145 {
4146 if (!add_dynamic_entry (DT_RELA, 0)
4147 || !add_dynamic_entry (DT_RELASZ, 0)
4148 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
4149 return FALSE;
4150
4151 /* If any dynamic relocs apply to a read-only section,
4152 then we need a DT_TEXTREL entry. */
4153 if ((info->flags & DF_TEXTREL) == 0)
4154 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
4155 (void *) info);
4156
4157 if ((info->flags & DF_TEXTREL) != 0)
4158 {
4159 if (!add_dynamic_entry (DT_TEXTREL, 0))
4160 return FALSE;
4161 }
4162 }
4163 }
4164 #undef add_dynamic_entry
4165
4166 return TRUE;
4167 }
4168
4169 static bfd_reloc_status_type
4170 nds32_relocate_contents (reloc_howto_type *howto, bfd *input_bfd,
4171 bfd_vma relocation, bfd_byte *location)
4172 {
4173 int size;
4174 bfd_vma x = 0;
4175 bfd_reloc_status_type flag;
4176 unsigned int rightshift = howto->rightshift;
4177 unsigned int bitpos = howto->bitpos;
4178
4179 /* If the size is negative, negate RELOCATION. This isn't very
4180 general. */
4181 if (howto->size < 0)
4182 relocation = -relocation;
4183
4184 /* Get the value we are going to relocate. */
4185 size = bfd_get_reloc_size (howto);
4186 switch (size)
4187 {
4188 default:
4189 case 0:
4190 case 1:
4191 case 8:
4192 abort ();
4193 break;
4194 case 2:
4195 x = bfd_getb16 (location);
4196 break;
4197 case 4:
4198 x = bfd_getb32 (location);
4199 break;
4200 }
4201
4202 /* Check for overflow. FIXME: We may drop bits during the addition
4203 which we don't check for. We must either check at every single
4204 operation, which would be tedious, or we must do the computations
4205 in a type larger than bfd_vma, which would be inefficient. */
4206 flag = bfd_reloc_ok;
4207 if (howto->complain_on_overflow != complain_overflow_dont)
4208 {
4209 bfd_vma addrmask, fieldmask, signmask, ss;
4210 bfd_vma a, b, sum;
4211
4212 /* Get the values to be added together. For signed and unsigned
4213 relocations, we assume that all values should be truncated to
4214 the size of an address. For bitfields, all the bits matter.
4215 See also bfd_check_overflow. */
4216 fieldmask = N_ONES (howto->bitsize);
4217 signmask = ~fieldmask;
4218 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4219 a = (relocation & addrmask) >> rightshift;
4220 b = (x & howto->src_mask & addrmask) >> bitpos;
4221
4222 switch (howto->complain_on_overflow)
4223 {
4224 case complain_overflow_signed:
4225 /* If any sign bits are set, all sign bits must be set.
4226 That is, A must be a valid negative address after
4227 shifting. */
4228 signmask = ~(fieldmask >> 1);
4229 /* Fall through. */
4230
4231 case complain_overflow_bitfield:
4232 /* Much like the signed check, but for a field one bit
4233 wider. We allow a bitfield to represent numbers in the
4234 range -2**n to 2**n-1, where n is the number of bits in the
4235 field. Note that when bfd_vma is 32 bits, a 32-bit reloc
4236 can't overflow, which is exactly what we want. */
4237 ss = a & signmask;
4238 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4239 flag = bfd_reloc_overflow;
4240
4241 /* We only need this next bit of code if the sign bit of B
4242 is below the sign bit of A. This would only happen if
4243 SRC_MASK had fewer bits than BITSIZE. Note that if
4244 SRC_MASK has more bits than BITSIZE, we can get into
4245 trouble; we would need to verify that B is in range, as
4246 we do for A above. */
4247 ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4248 ss >>= bitpos;
4249
4250 /* Set all the bits above the sign bit. */
4251 b = (b ^ ss) - ss;
4252
4253 /* Now we can do the addition. */
4254 sum = a + b;
4255
4256 /* See if the result has the correct sign. Bits above the
4257 sign bit are junk now; ignore them. If the sum is
4258 positive, make sure we did not have all negative inputs;
4259 if the sum is negative, make sure we did not have all
4260 positive inputs. The test below looks only at the sign
4261 bits, and it really just
4262 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4263
4264 We mask with addrmask here to explicitly allow an address
4265 wrap-around. The Linux kernel relies on it, and it is
4266 the only way to write assembler code which can run when
4267 loaded at a location 0x80000000 away from the location at
4268 which it is linked. */
4269 if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4270 flag = bfd_reloc_overflow;
4271
4272 break;
4273
4274 case complain_overflow_unsigned:
4275 /* Checking for an unsigned overflow is relatively easy:
4276 trim the addresses and add, and trim the result as well.
4277 Overflow is normally indicated when the result does not
4278 fit in the field. However, we also need to consider the
4279 case when, e.g., fieldmask is 0x7fffffff or smaller, an
4280 input is 0x80000000, and bfd_vma is only 32 bits; then we
4281 will get sum == 0, but there is an overflow, since the
4282 inputs did not fit in the field. Instead of doing a
4283 separate test, we can check for this by or-ing in the
4284 operands when testing for the sum overflowing its final
4285 field. */
4286 sum = (a + b) & addrmask;
4287 if ((a | b | sum) & signmask)
4288 flag = bfd_reloc_overflow;
4289 break;
4290
4291 default:
4292 abort ();
4293 }
4294 }
4295
4296 /* Put RELOCATION in the right bits. */
4297 relocation >>= (bfd_vma) rightshift;
4298 relocation <<= (bfd_vma) bitpos;
4299
4300 /* Add RELOCATION to the right bits of X. */
4301 /* FIXME : 090616
4302 Because the relaxation may generate duplicate relocation at one address,
4303 an addition to immediate in the instruction may cause the relocation added
4304 several times.
4305 This bug should be fixed in assembler, but a check is also needed here. */
4306 if (howto->partial_inplace)
4307 x = ((x & ~howto->dst_mask)
4308 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4309 else
4310 x = ((x & ~howto->dst_mask) | ((relocation) & howto->dst_mask));
4311
4312
4313 /* Put the relocated value back in the object file. */
4314 switch (size)
4315 {
4316 default:
4317 case 0:
4318 case 1:
4319 case 8:
4320 abort ();
4321 break;
4322 case 2:
4323 bfd_putb16 (x, location);
4324 break;
4325 case 4:
4326 bfd_putb32 (x, location);
4327 break;
4328 }
4329
4330 return flag;
4331 }
4332
4333 static bfd_reloc_status_type
4334 nds32_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
4335 asection *input_section, bfd_byte *contents,
4336 bfd_vma address, bfd_vma value, bfd_vma addend)
4337 {
4338 bfd_vma relocation;
4339
4340 /* Sanity check the address. */
4341 if (address > bfd_get_section_limit (input_bfd, input_section))
4342 return bfd_reloc_outofrange;
4343
4344 /* This function assumes that we are dealing with a basic relocation
4345 against a symbol. We want to compute the value of the symbol to
4346 relocate to. This is just VALUE, the value of the symbol, plus
4347 ADDEND, any addend associated with the reloc. */
4348 relocation = value + addend;
4349
4350 /* If the relocation is PC relative, we want to set RELOCATION to
4351 the distance between the symbol (currently in RELOCATION) and the
4352 location we are relocating. Some targets (e.g., i386-aout)
4353 arrange for the contents of the section to be the negative of the
4354 offset of the location within the section; for such targets
4355 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF)
4356 simply leave the contents of the section as zero; for such
4357 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not
4358 need to subtract out the offset of the location within the
4359 section (which is just ADDRESS). */
4360 if (howto->pc_relative)
4361 {
4362 relocation -= (input_section->output_section->vma
4363 + input_section->output_offset);
4364 if (howto->pcrel_offset)
4365 relocation -= address;
4366 }
4367
4368 return nds32_relocate_contents (howto, input_bfd, relocation,
4369 contents + address);
4370 }
4371
4372 static bfd_boolean
4373 nds32_elf_output_symbol_hook (struct bfd_link_info *info,
4374 const char *name,
4375 Elf_Internal_Sym *elfsym ATTRIBUTE_UNUSED,
4376 asection *input_sec,
4377 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4378 {
4379 const char *source;
4380 FILE *sym_ld_script = NULL;
4381 struct elf_nds32_link_hash_table *table;
4382
4383 table = nds32_elf_hash_table (info);
4384 sym_ld_script = table->sym_ld_script;
4385 if (!sym_ld_script)
4386 return TRUE;
4387
4388 if (!h || !name || *name == '\0')
4389 return TRUE;
4390
4391 if (input_sec->flags & SEC_EXCLUDE)
4392 return TRUE;
4393
4394 if (!check_start_export_sym)
4395 {
4396 fprintf (sym_ld_script, "SECTIONS\n{\n");
4397 check_start_export_sym = 1;
4398 }
4399
4400 if (h->root.type == bfd_link_hash_defined
4401 || h->root.type == bfd_link_hash_defweak)
4402 {
4403 if (!h->root.u.def.section->output_section)
4404 return TRUE;
4405
4406 if (bfd_is_const_section (input_sec))
4407 source = input_sec->name;
4408 else
4409 source = input_sec->owner->filename;
4410
4411 fprintf (sym_ld_script, "\t%s = 0x%08lx;\t /* %s */\n",
4412 h->root.root.string,
4413 (long) (h->root.u.def.value
4414 + h->root.u.def.section->output_section->vma
4415 + h->root.u.def.section->output_offset), source);
4416 }
4417
4418 return TRUE;
4419 }
4420
4421 /* Relocate an NDS32/D ELF section.
4422 There is some attempt to make this function usable for many architectures,
4423 both for RELA and REL type relocs, if only to serve as a learning tool.
4424
4425 The RELOCATE_SECTION function is called by the new ELF backend linker
4426 to handle the relocations for a section.
4427
4428 The relocs are always passed as Rela structures; if the section
4429 actually uses Rel structures, the r_addend field will always be
4430 zero.
4431
4432 This function is responsible for adjust the section contents as
4433 necessary, and (if using Rela relocs and generating a
4434 relocatable output file) adjusting the reloc addend as
4435 necessary.
4436
4437 This function does not have to worry about setting the reloc
4438 address or the reloc symbol index.
4439
4440 LOCAL_SYMS is a pointer to the swapped in local symbols.
4441
4442 LOCAL_SECTIONS is an array giving the section in the input file
4443 corresponding to the st_shndx field of each local symbol.
4444
4445 The global hash table entry for the global symbols can be found
4446 via elf_sym_hashes (input_bfd).
4447
4448 When generating relocatable output, this function must handle
4449 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
4450 going to be the section symbol corresponding to the output
4451 section, which means that the addend must be adjusted
4452 accordingly. */
4453
4454 static bfd_vma
4455 dtpoff_base (struct bfd_link_info *info)
4456 {
4457 /* If tls_sec is NULL, we should have signalled an error already. */
4458 if (elf_hash_table (info)->tls_sec == NULL)
4459 return 0;
4460 return elf_hash_table (info)->tls_sec->vma;
4461 }
4462
4463 static bfd_boolean
4464 nds32_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
4465 struct bfd_link_info * info,
4466 bfd * input_bfd,
4467 asection * input_section,
4468 bfd_byte * contents,
4469 Elf_Internal_Rela * relocs,
4470 Elf_Internal_Sym * local_syms,
4471 asection ** local_sections)
4472 {
4473 Elf_Internal_Shdr *symtab_hdr;
4474 struct elf_link_hash_entry **sym_hashes;
4475 Elf_Internal_Rela *rel, *relend;
4476 bfd_boolean ret = TRUE; /* Assume success. */
4477 int align = 0;
4478 bfd_reloc_status_type r;
4479 const char *errmsg = NULL;
4480 bfd_vma gp;
4481 struct elf_nds32_link_hash_table *htab;
4482 bfd *dynobj;
4483 bfd_vma *local_got_offsets;
4484 asection *sgot, *splt, *sreloc;
4485 bfd_vma high_address;
4486 struct elf_nds32_link_hash_table *table;
4487 int eliminate_gc_relocs;
4488 bfd_vma fpbase_addr;
4489
4490 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4491 sym_hashes = elf_sym_hashes (input_bfd);
4492 htab = nds32_elf_hash_table (info);
4493 high_address = bfd_get_section_limit (input_bfd, input_section);
4494
4495 dynobj = htab->root.dynobj;
4496 local_got_offsets = elf_local_got_offsets (input_bfd);
4497
4498 sgot = htab->sgot;
4499 splt = htab->splt;
4500 sreloc = NULL;
4501
4502 rel = relocs;
4503 relend = relocs + input_section->reloc_count;
4504
4505 table = nds32_elf_hash_table (info);
4506 eliminate_gc_relocs = table->eliminate_gc_relocs;
4507 /* By this time, we can adjust the value of _SDA_BASE_. */
4508 if ((!info->relocatable))
4509 {
4510 is_SDA_BASE_set = 1;
4511 r = nds32_elf_final_sda_base (output_bfd, info, &gp, TRUE);
4512 if (r != bfd_reloc_ok)
4513 return FALSE;
4514 }
4515
4516 if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
4517 if (!nds32_elf_ifc_reloc ())
4518 (*_bfd_error_handler) (_("error: IFC relocation error."));
4519
4520 /* Relocation for .ex9.itable. */
4521 if (table->target_optimize & NDS32_RELAX_EX9_ON
4522 || (table->ex9_import_file && table->update_ex9_table))
4523 nds32_elf_ex9_reloc_jmp (info);
4524
4525 /* Use gp as fp to prevent truncated fit. Because in relaxation time
4526 the fp value is set as gp, and it has be reverted for instruction
4527 setting fp. */
4528 fpbase_addr = elf_gp (output_bfd);
4529
4530 for (rel = relocs; rel < relend; rel++)
4531 {
4532 enum elf_nds32_reloc_type r_type;
4533 reloc_howto_type *howto = NULL;
4534 unsigned long r_symndx;
4535 struct elf_link_hash_entry *h = NULL;
4536 Elf_Internal_Sym *sym = NULL;
4537 asection *sec;
4538 bfd_vma relocation;
4539
4540 /* We can't modify r_addend here as elf_link_input_bfd has an assert to
4541 ensure it's zero (we use REL relocs, not RELA). Therefore this
4542 should be assigning zero to `addend', but for clarity we use
4543 `r_addend'. */
4544
4545 bfd_vma addend = rel->r_addend;
4546 bfd_vma offset = rel->r_offset;
4547
4548 r_type = ELF32_R_TYPE (rel->r_info);
4549 if (r_type >= R_NDS32_max)
4550 {
4551 (*_bfd_error_handler) (_("%B: error: unknown relocation type %d."),
4552 input_bfd, r_type);
4553 bfd_set_error (bfd_error_bad_value);
4554 ret = FALSE;
4555 continue;
4556 }
4557
4558 if (r_type == R_NDS32_GNU_VTENTRY
4559 || r_type == R_NDS32_GNU_VTINHERIT
4560 || r_type == R_NDS32_NONE
4561 || r_type == R_NDS32_RELA_GNU_VTENTRY
4562 || r_type == R_NDS32_RELA_GNU_VTINHERIT
4563 || (r_type >= R_NDS32_INSN16 && r_type <= R_NDS32_25_FIXED_RELA)
4564 || r_type == R_NDS32_DATA
4565 || r_type == R_NDS32_TRAN
4566 || (r_type >= R_NDS32_LONGCALL4 && r_type <= R_NDS32_LONGJUMP6))
4567 continue;
4568
4569 /* If we enter the fp-as-gp region. Resolve the address of best fp-base. */
4570 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_BEGIN
4571 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
4572 {
4573 int dist;
4574
4575 /* Distance to relocation of best fp-base is encoded in R_SYM. */
4576 dist = rel->r_addend >> 16;
4577 fpbase_addr = calculate_memory_address (input_bfd, rel + dist,
4578 local_syms, symtab_hdr);
4579 }
4580 else if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_END
4581 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
4582 {
4583 fpbase_addr = elf_gp (output_bfd);
4584 }
4585
4586 if (((r_type >= R_NDS32_DWARF2_OP1_RELA
4587 && r_type <= R_NDS32_DWARF2_LEB_RELA)
4588 || r_type >= R_NDS32_RELAX_ENTRY) && !info->relocatable)
4589 continue;
4590
4591 howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
4592 r_symndx = ELF32_R_SYM (rel->r_info);
4593
4594 /* This is a final link. */
4595 sym = NULL;
4596 sec = NULL;
4597 h = NULL;
4598
4599 if (r_symndx < symtab_hdr->sh_info)
4600 {
4601 /* Local symbol. */
4602 sym = local_syms + r_symndx;
4603 sec = local_sections[r_symndx];
4604
4605 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4606 addend = rel->r_addend;
4607 }
4608 else
4609 {
4610 /* External symbol. */
4611 bfd_boolean warned, ignored, unresolved_reloc;
4612 int symndx = r_symndx - symtab_hdr->sh_info;
4613
4614 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4615 r_symndx, symtab_hdr, sym_hashes, h, sec,
4616 relocation, unresolved_reloc, warned,
4617 ignored);
4618
4619 /* la $fp, _FP_BASE_ is per-function (region).
4620 Handle it specially. */
4621 switch ((int) r_type)
4622 {
4623 case R_NDS32_SDA19S0_RELA:
4624 case R_NDS32_SDA15S0_RELA:
4625 case R_NDS32_20_RELA:
4626 if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
4627 FP_BASE_NAME) == 0)
4628 {
4629 relocation = fpbase_addr;
4630 break;
4631 }
4632 }
4633
4634 }
4635
4636 if (info->relocatable)
4637 {
4638 /* This is a relocatable link. We don't have to change
4639 anything, unless the reloc is against a section symbol,
4640 in which case we have to adjust according to where the
4641 section symbol winds up in the output section. */
4642 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4643 rel->r_addend += sec->output_offset + sym->st_value;
4644
4645 continue;
4646 }
4647
4648 /* Sanity check the address. */
4649 if (offset > high_address)
4650 {
4651 r = bfd_reloc_outofrange;
4652 goto check_reloc;
4653 }
4654
4655 if ((r_type >= R_NDS32_DWARF2_OP1_RELA
4656 && r_type <= R_NDS32_DWARF2_LEB_RELA)
4657 || r_type >= R_NDS32_RELAX_ENTRY)
4658 continue;
4659
4660 switch ((int) r_type)
4661 {
4662 case R_NDS32_GOTOFF:
4663 /* Relocation is relative to the start of the global offset
4664 table (for ld24 rx, #uimm24), e.g. access at label+addend
4665
4666 ld24 rx. #label@GOTOFF + addend
4667 sub rx, r12. */
4668 case R_NDS32_GOTOFF_HI20:
4669 case R_NDS32_GOTOFF_LO12:
4670 case R_NDS32_GOTOFF_LO15:
4671 case R_NDS32_GOTOFF_LO19:
4672 BFD_ASSERT (sgot != NULL);
4673
4674 relocation -= elf_gp (output_bfd);
4675 break;
4676
4677 case R_NDS32_9_PLTREL:
4678 case R_NDS32_25_PLTREL:
4679 /* Relocation is to the entry for this symbol in the
4680 procedure linkage table. */
4681
4682 /* The native assembler will generate a 25_PLTREL reloc
4683 for a local symbol if you assemble a call from one
4684 section to another when using -K pic. */
4685 if (h == NULL)
4686 break;
4687
4688 if (h->forced_local)
4689 break;
4690
4691 /* We didn't make a PLT entry for this symbol. This
4692 happens when statically linking PIC code, or when
4693 using -Bsymbolic. */
4694 if (h->plt.offset == (bfd_vma) - 1)
4695 break;
4696
4697 relocation = (splt->output_section->vma
4698 + splt->output_offset + h->plt.offset);
4699 break;
4700
4701 case R_NDS32_PLT_GOTREL_HI20:
4702 case R_NDS32_PLT_GOTREL_LO12:
4703 case R_NDS32_PLT_GOTREL_LO15:
4704 case R_NDS32_PLT_GOTREL_LO19:
4705 case R_NDS32_PLT_GOTREL_LO20:
4706 if (h == NULL || h->forced_local || h->plt.offset == (bfd_vma) - 1)
4707 {
4708 /* We didn't make a PLT entry for this symbol. This
4709 happens when statically linking PIC code, or when
4710 using -Bsymbolic. */
4711 relocation -= elf_gp (output_bfd);
4712 break;
4713 }
4714
4715 relocation = (splt->output_section->vma
4716 + splt->output_offset + h->plt.offset);
4717
4718 relocation -= elf_gp (output_bfd);
4719 break;
4720
4721 case R_NDS32_PLTREL_HI20:
4722 case R_NDS32_PLTREL_LO12:
4723
4724 /* Relocation is to the entry for this symbol in the
4725 procedure linkage table. */
4726
4727 /* The native assembler will generate a 25_PLTREL reloc
4728 for a local symbol if you assemble a call from one
4729 section to another when using -K pic. */
4730 if (h == NULL)
4731 break;
4732
4733 if (h->forced_local)
4734 break;
4735
4736 if (h->plt.offset == (bfd_vma) - 1)
4737 /* We didn't make a PLT entry for this symbol. This
4738 happens when statically linking PIC code, or when
4739 using -Bsymbolic. */
4740 break;
4741
4742 if (splt == NULL)
4743 break;
4744
4745 relocation = (splt->output_section->vma
4746 + splt->output_offset
4747 + h->plt.offset + 4)
4748 - (input_section->output_section->vma
4749 + input_section->output_offset
4750 + rel->r_offset);
4751
4752 break;
4753
4754 case R_NDS32_GOTPC20:
4755 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
4756 ld24 rx,#_GLOBAL_OFFSET_TABLE_ */
4757 relocation = elf_gp (output_bfd);
4758 break;
4759
4760 case R_NDS32_GOTPC_HI20:
4761 case R_NDS32_GOTPC_LO12:
4762 {
4763 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
4764 bl .+4
4765 seth rx,#high(_GLOBAL_OFFSET_TABLE_)
4766 or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
4767 or
4768 bl .+4
4769 seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
4770 add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
4771 */
4772 relocation = elf_gp (output_bfd);
4773 relocation -= (input_section->output_section->vma
4774 + input_section->output_offset + rel->r_offset);
4775 break;
4776 }
4777
4778 case R_NDS32_GOT20:
4779 /* Fall through. */
4780 case R_NDS32_GOT_HI20:
4781 case R_NDS32_GOT_LO12:
4782 case R_NDS32_GOT_LO15:
4783 case R_NDS32_GOT_LO19:
4784 /* Relocation is to the entry for this symbol in the global
4785 offset table. */
4786 BFD_ASSERT (sgot != NULL);
4787
4788 if (h != NULL)
4789 {
4790 bfd_boolean dyn;
4791 bfd_vma off;
4792
4793 off = h->got.offset;
4794 BFD_ASSERT (off != (bfd_vma) - 1);
4795 dyn = htab->root.dynamic_sections_created;
4796 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
4797 || (info->shared
4798 && (info->symbolic
4799 || h->dynindx == -1
4800 || h->forced_local) && h->def_regular))
4801 {
4802 /* This is actually a static link, or it is a
4803 -Bsymbolic link and the symbol is defined
4804 locally, or the symbol was forced to be local
4805 because of a version file. We must initialize
4806 this entry in the global offset table. Since the
4807 offset must always be a multiple of 4, we use the
4808 least significant bit to record whether we have
4809 initialized it already.
4810
4811 When doing a dynamic link, we create a .rela.got
4812 relocation entry to initialize the value. This
4813 is done in the finish_dynamic_symbol routine. */
4814 if ((off & 1) != 0)
4815 off &= ~1;
4816 else
4817 {
4818 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4819 h->got.offset |= 1;
4820 }
4821 }
4822 relocation = sgot->output_section->vma + sgot->output_offset + off
4823 - elf_gp (output_bfd);
4824 }
4825 else
4826 {
4827 bfd_vma off;
4828 bfd_byte *loc;
4829
4830 BFD_ASSERT (local_got_offsets != NULL
4831 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
4832
4833 off = local_got_offsets[r_symndx];
4834
4835 /* The offset must always be a multiple of 4. We use
4836 the least significant bit to record whether we have
4837 already processed this entry. */
4838 if ((off & 1) != 0)
4839 off &= ~1;
4840 else
4841 {
4842 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4843
4844 if (info->shared)
4845 {
4846 asection *srelgot;
4847 Elf_Internal_Rela outrel;
4848
4849 /* We need to generate a R_NDS32_RELATIVE reloc
4850 for the dynamic linker. */
4851 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4852 BFD_ASSERT (srelgot != NULL);
4853
4854 outrel.r_offset = (elf_gp (output_bfd)
4855 + sgot->output_offset + off);
4856 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
4857 outrel.r_addend = relocation;
4858 loc = srelgot->contents;
4859 loc +=
4860 srelgot->reloc_count * sizeof (Elf32_External_Rela);
4861 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4862 ++srelgot->reloc_count;
4863 }
4864 local_got_offsets[r_symndx] |= 1;
4865 }
4866 relocation = sgot->output_section->vma + sgot->output_offset + off
4867 - elf_gp (output_bfd);
4868 }
4869
4870 break;
4871
4872 case R_NDS32_16_RELA:
4873 case R_NDS32_20_RELA:
4874 case R_NDS32_5_RELA:
4875 case R_NDS32_32_RELA:
4876 case R_NDS32_9_PCREL_RELA:
4877 case R_NDS32_WORD_9_PCREL_RELA:
4878 case R_NDS32_10_UPCREL_RELA:
4879 case R_NDS32_15_PCREL_RELA:
4880 case R_NDS32_17_PCREL_RELA:
4881 case R_NDS32_25_PCREL_RELA:
4882 case R_NDS32_HI20_RELA:
4883 case R_NDS32_LO12S3_RELA:
4884 case R_NDS32_LO12S2_RELA:
4885 case R_NDS32_LO12S2_DP_RELA:
4886 case R_NDS32_LO12S2_SP_RELA:
4887 case R_NDS32_LO12S1_RELA:
4888 case R_NDS32_LO12S0_RELA:
4889 case R_NDS32_LO12S0_ORI_RELA:
4890 if (info->shared && r_symndx != 0
4891 && (input_section->flags & SEC_ALLOC) != 0
4892 && (eliminate_gc_relocs == 0
4893 || (sec && (sec->flags & SEC_EXCLUDE) == 0))
4894 && ((r_type != R_NDS32_9_PCREL_RELA
4895 && r_type != R_NDS32_WORD_9_PCREL_RELA
4896 && r_type != R_NDS32_10_UPCREL_RELA
4897 && r_type != R_NDS32_15_PCREL_RELA
4898 && r_type != R_NDS32_17_PCREL_RELA
4899 && r_type != R_NDS32_25_PCREL_RELA
4900 && !(r_type == R_NDS32_32_RELA
4901 && strcmp (input_section->name, ".eh_frame") == 0))
4902 || (h != NULL && h->dynindx != -1
4903 && (!info->symbolic || !h->def_regular))))
4904 {
4905 Elf_Internal_Rela outrel;
4906 bfd_boolean skip, relocate;
4907 bfd_byte *loc;
4908
4909 /* When generating a shared object, these relocations
4910 are copied into the output file to be resolved at run
4911 time. */
4912
4913 if (sreloc == NULL)
4914 {
4915 const char *name;
4916
4917 name = bfd_elf_string_from_elf_section
4918 (input_bfd, elf_elfheader (input_bfd)->e_shstrndx,
4919 elf_section_data (input_section)->rela.hdr->sh_name);
4920 if (name == NULL)
4921 return FALSE;
4922
4923 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
4924 && strcmp (bfd_get_section_name (input_bfd,
4925 input_section),
4926 name + 5) == 0);
4927
4928 sreloc = bfd_get_section_by_name (dynobj, name);
4929 BFD_ASSERT (sreloc != NULL);
4930 }
4931
4932 skip = FALSE;
4933 relocate = FALSE;
4934
4935 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
4936 info,
4937 input_section,
4938 rel->r_offset);
4939 if (outrel.r_offset == (bfd_vma) - 1)
4940 skip = TRUE;
4941 else if (outrel.r_offset == (bfd_vma) - 2)
4942 skip = TRUE, relocate = TRUE;
4943 outrel.r_offset += (input_section->output_section->vma
4944 + input_section->output_offset);
4945
4946 if (skip)
4947 memset (&outrel, 0, sizeof outrel);
4948 else if (r_type == R_NDS32_17_PCREL_RELA
4949 || r_type == R_NDS32_15_PCREL_RELA
4950 || r_type == R_NDS32_25_PCREL_RELA)
4951 {
4952 BFD_ASSERT (h != NULL && h->dynindx != -1);
4953 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4954 outrel.r_addend = rel->r_addend;
4955 }
4956 else
4957 {
4958 /* h->dynindx may be -1 if this symbol was marked to
4959 become local. */
4960 if (h == NULL
4961 || ((info->symbolic || h->dynindx == -1)
4962 && h->def_regular))
4963 {
4964 relocate = TRUE;
4965 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
4966 outrel.r_addend = relocation + rel->r_addend;
4967 }
4968 else
4969 {
4970 BFD_ASSERT (h->dynindx != -1);
4971 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4972 outrel.r_addend = rel->r_addend;
4973 }
4974 }
4975
4976 loc = sreloc->contents;
4977 loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
4978 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4979 ++sreloc->reloc_count;
4980
4981 /* If this reloc is against an external symbol, we do
4982 not want to fiddle with the addend. Otherwise, we
4983 need to include the symbol value so that it becomes
4984 an addend for the dynamic reloc. */
4985 if (!relocate)
4986 continue;
4987 }
4988 break;
4989
4990 case R_NDS32_25_ABS_RELA:
4991 if (info->shared)
4992 {
4993 (*_bfd_error_handler)
4994 (_("%s: warning: cannot deal R_NDS32_25_ABS_RELA in shared "
4995 "mode."), bfd_get_filename (input_bfd));
4996 return FALSE;
4997 }
4998 break;
4999
5000 case R_NDS32_9_PCREL:
5001 r = nds32_elf_do_9_pcrel_reloc (input_bfd, howto, input_section,
5002 contents, offset,
5003 sec, relocation, addend);
5004 goto check_reloc;
5005
5006 case R_NDS32_HI20:
5007 {
5008 Elf_Internal_Rela *lorel;
5009
5010 /* We allow an arbitrary number of HI20 relocs before the
5011 LO12 reloc. This permits gcc to emit the HI and LO relocs
5012 itself. */
5013 for (lorel = rel + 1;
5014 (lorel < relend
5015 && ELF32_R_TYPE (lorel->r_info) == R_NDS32_HI20); lorel++)
5016 continue;
5017 if (lorel < relend
5018 && (ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S3
5019 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S2
5020 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S1
5021 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S0))
5022 {
5023 nds32_elf_relocate_hi20 (input_bfd, r_type, rel, lorel,
5024 contents, relocation + addend);
5025 r = bfd_reloc_ok;
5026 }
5027 else
5028 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5029 contents, offset, relocation,
5030 addend);
5031 }
5032
5033 goto check_reloc;
5034
5035 case R_NDS32_GOT17S2_RELA:
5036 case R_NDS32_GOT15S2_RELA:
5037 {
5038 bfd_vma off;
5039
5040 BFD_ASSERT (sgot != NULL);
5041
5042 if (h != NULL)
5043 {
5044 bfd_boolean dyn;
5045
5046 off = h->got.offset;
5047 BFD_ASSERT (off != (bfd_vma) - 1);
5048
5049 dyn = htab->root.dynamic_sections_created;
5050 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL
5051 (dyn, info->shared, h) || (info->shared
5052 && (info->symbolic
5053 || h->dynindx == -1
5054 || h->forced_local)
5055 && h->def_regular))
5056 {
5057 /* This is actually a static link, or it is a
5058 -Bsymbolic link and the symbol is defined
5059 locally, or the symbol was forced to be local
5060 because of a version file. We must initialize
5061 this entry in the global offset table. Since the
5062 offset must always be a multiple of 4, we use the
5063 least significant bit to record whether we have
5064 initialized it already.
5065
5066 When doing a dynamic link, we create a .rela.got
5067 relocation entry to initialize the value. This
5068 is done in the finish_dynamic_symbol routine. */
5069 if ((off & 1) != 0)
5070 off &= ~1;
5071 else
5072 {
5073 bfd_put_32 (output_bfd, relocation,
5074 sgot->contents + off);
5075 h->got.offset |= 1;
5076 }
5077 }
5078 }
5079 else
5080 {
5081 bfd_byte *loc;
5082
5083 BFD_ASSERT (local_got_offsets != NULL
5084 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5085
5086 off = local_got_offsets[r_symndx];
5087
5088 /* The offset must always be a multiple of 4. We use
5089 the least significant bit to record whether we have
5090 already processed this entry. */
5091 if ((off & 1) != 0)
5092 off &= ~1;
5093 else
5094 {
5095 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5096
5097 if (info->shared)
5098 {
5099 asection *srelgot;
5100 Elf_Internal_Rela outrel;
5101
5102 /* We need to generate a R_NDS32_RELATIVE reloc
5103 for the dynamic linker. */
5104 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5105 BFD_ASSERT (srelgot != NULL);
5106
5107 outrel.r_offset = (elf_gp (output_bfd)
5108 + sgot->output_offset + off);
5109 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5110 outrel.r_addend = relocation;
5111 loc = srelgot->contents;
5112 loc +=
5113 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5114 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5115 ++srelgot->reloc_count;
5116 }
5117 local_got_offsets[r_symndx] |= 1;
5118 }
5119 }
5120 relocation = sgot->output_section->vma + sgot->output_offset + off
5121 - elf_gp (output_bfd);
5122 }
5123 if (relocation & align)
5124 {
5125 /* Incorrect alignment. */
5126 (*_bfd_error_handler)
5127 (_("%B: warning: unaligned access to GOT entry."), input_bfd);
5128 ret = FALSE;
5129 r = bfd_reloc_dangerous;
5130 goto check_reloc;
5131 }
5132 break;
5133
5134 case R_NDS32_SDA16S3_RELA:
5135 case R_NDS32_SDA15S3_RELA:
5136 case R_NDS32_SDA15S3:
5137 align = 0x7;
5138 goto handle_sda;
5139
5140 case R_NDS32_SDA17S2_RELA:
5141 case R_NDS32_SDA15S2_RELA:
5142 case R_NDS32_SDA12S2_SP_RELA:
5143 case R_NDS32_SDA12S2_DP_RELA:
5144 case R_NDS32_SDA15S2:
5145 case R_NDS32_SDA_FP7U2_RELA:
5146 align = 0x3;
5147 goto handle_sda;
5148
5149 case R_NDS32_SDA18S1_RELA:
5150 case R_NDS32_SDA15S1_RELA:
5151 case R_NDS32_SDA15S1:
5152 align = 0x1;
5153 goto handle_sda;
5154
5155 case R_NDS32_SDA19S0_RELA:
5156 case R_NDS32_SDA15S0_RELA:
5157 case R_NDS32_SDA15S0:
5158 {
5159 align = 0x0;
5160 handle_sda:
5161 BFD_ASSERT (sec != NULL);
5162
5163 /* If the symbol is in the abs section, the out_bfd will be null.
5164 This happens when the relocation has a symbol@GOTOFF. */
5165 r = nds32_elf_final_sda_base (output_bfd, info, &gp, FALSE);
5166 if (r != bfd_reloc_ok)
5167 {
5168 (*_bfd_error_handler)
5169 (_("%B: warning: relocate SDA_BASE failed."), input_bfd);
5170 ret = FALSE;
5171 goto check_reloc;
5172 }
5173
5174 /* At this point `relocation' contains the object's
5175 address. */
5176 if (r_type == R_NDS32_SDA_FP7U2_RELA)
5177 {
5178 relocation -= fpbase_addr;
5179 }
5180 else
5181 relocation -= gp;
5182 /* Now it contains the offset from _SDA_BASE_. */
5183
5184 /* Make sure alignment is correct. */
5185
5186 if (relocation & align)
5187 {
5188 /* Incorrect alignment. */
5189 (*_bfd_error_handler)
5190 (_("%B(%A): warning: unaligned small data access of type %d."),
5191 input_bfd, input_section, r_type);
5192 ret = FALSE;
5193 goto check_reloc;
5194 }
5195 }
5196
5197 break;
5198 case R_NDS32_17IFC_PCREL_RELA:
5199 case R_NDS32_10IFCU_PCREL_RELA:
5200 /* do nothing */
5201 break;
5202
5203 case R_NDS32_TLS_LE_HI20:
5204 case R_NDS32_TLS_LE_LO12:
5205 case R_NDS32_TLS_LE_20:
5206 case R_NDS32_TLS_LE_15S0:
5207 case R_NDS32_TLS_LE_15S1:
5208 case R_NDS32_TLS_LE_15S2:
5209 if (elf_hash_table (info)->tls_sec != NULL)
5210 relocation -= (elf_hash_table (info)->tls_sec->vma + TP_OFFSET);
5211 break;
5212 case R_NDS32_TLS_IE_HI20:
5213 case R_NDS32_TLS_IE_LO12S2:
5214 {
5215 /* Relocation is to the entry for this symbol in the global
5216 offset table. */
5217 unsigned int tls_type;
5218 asection *srelgot;
5219 Elf_Internal_Rela outrel;
5220 bfd_vma off;
5221 bfd_byte *loc;
5222 int indx = 0;
5223
5224 BFD_ASSERT (sgot != NULL);
5225 if (h != NULL)
5226 {
5227 bfd_boolean dyn;
5228
5229 off = h->got.offset;
5230 BFD_ASSERT (off != (bfd_vma) - 1);
5231 dyn = htab->root.dynamic_sections_created;
5232 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
5233 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
5234 && (!info->shared
5235 || !SYMBOL_REFERENCES_LOCAL (info, h)))
5236 indx = h->dynindx;
5237 }
5238 else
5239 {
5240 /* Never happen currently. */
5241 BFD_ASSERT (local_got_offsets != NULL
5242 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5243
5244 off = local_got_offsets[r_symndx];
5245
5246 tls_type = elf32_nds32_local_got_tls_type (input_bfd)[r_symndx];
5247 }
5248 relocation = sgot->output_section->vma + sgot->output_offset + off;
5249
5250 if (r_type == R_NDS32_TLS_IE_LO12S2)
5251 break;
5252
5253 /* The offset must always be a multiple of 4. We use
5254 the least significant bit to record whether we have
5255 already processed this entry. */
5256 if ((off & 1) != 0)
5257 off &= ~1;
5258 else
5259 {
5260 bfd_boolean need_relocs = FALSE;
5261 srelgot = htab->srelgot;
5262 if ((info->shared || indx != 0)
5263 && (h == NULL
5264 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5265 || h->root.type != bfd_link_hash_undefweak))
5266 {
5267 need_relocs = TRUE;
5268 BFD_ASSERT (srelgot != NULL);
5269 }
5270 if (tls_type & GOT_TLS_IE)
5271 {
5272 if (need_relocs)
5273 {
5274 if (h->dynindx == 0)
5275 outrel.r_addend = relocation - dtpoff_base (info);
5276 else
5277 outrel.r_addend = 0;
5278 outrel.r_offset = (sgot->output_section->vma
5279 + sgot->output_offset
5280 + off);
5281 outrel.r_info =
5282 ELF32_R_INFO (h->dynindx, R_NDS32_TLS_TPOFF);
5283
5284 loc = srelgot->contents;
5285 loc +=
5286 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5287 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5288 ++srelgot->reloc_count;
5289 }
5290 else
5291 bfd_put_32 (output_bfd, h->root.u.def.value - TP_OFFSET,
5292 sgot->contents + off);
5293 }
5294 }
5295 }
5296 break;
5297
5298 /* DON'T fall through. */
5299
5300 default:
5301 /* OLD_NDS32_RELOC. */
5302
5303 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5304 contents, offset, relocation, addend);
5305 goto check_reloc;
5306 }
5307
5308 switch ((int) r_type)
5309 {
5310 case R_NDS32_20_RELA:
5311 case R_NDS32_5_RELA:
5312 case R_NDS32_9_PCREL_RELA:
5313 case R_NDS32_WORD_9_PCREL_RELA:
5314 case R_NDS32_10_UPCREL_RELA:
5315 case R_NDS32_15_PCREL_RELA:
5316 case R_NDS32_17_PCREL_RELA:
5317 case R_NDS32_25_PCREL_RELA:
5318 case R_NDS32_25_ABS_RELA:
5319 case R_NDS32_HI20_RELA:
5320 case R_NDS32_LO12S3_RELA:
5321 case R_NDS32_LO12S2_RELA:
5322 case R_NDS32_LO12S2_DP_RELA:
5323 case R_NDS32_LO12S2_SP_RELA:
5324 case R_NDS32_LO12S1_RELA:
5325 case R_NDS32_LO12S0_RELA:
5326 case R_NDS32_LO12S0_ORI_RELA:
5327 case R_NDS32_SDA16S3_RELA:
5328 case R_NDS32_SDA17S2_RELA:
5329 case R_NDS32_SDA18S1_RELA:
5330 case R_NDS32_SDA19S0_RELA:
5331 case R_NDS32_SDA15S3_RELA:
5332 case R_NDS32_SDA15S2_RELA:
5333 case R_NDS32_SDA12S2_DP_RELA:
5334 case R_NDS32_SDA12S2_SP_RELA:
5335 case R_NDS32_SDA15S1_RELA:
5336 case R_NDS32_SDA15S0_RELA:
5337 case R_NDS32_SDA_FP7U2_RELA:
5338 case R_NDS32_9_PLTREL:
5339 case R_NDS32_25_PLTREL:
5340 case R_NDS32_GOT20:
5341 case R_NDS32_GOT_HI20:
5342 case R_NDS32_GOT_LO12:
5343 case R_NDS32_GOT_LO15:
5344 case R_NDS32_GOT_LO19:
5345 case R_NDS32_GOT15S2_RELA:
5346 case R_NDS32_GOT17S2_RELA:
5347 case R_NDS32_GOTPC20:
5348 case R_NDS32_GOTPC_HI20:
5349 case R_NDS32_GOTPC_LO12:
5350 case R_NDS32_GOTOFF:
5351 case R_NDS32_GOTOFF_HI20:
5352 case R_NDS32_GOTOFF_LO12:
5353 case R_NDS32_GOTOFF_LO15:
5354 case R_NDS32_GOTOFF_LO19:
5355 case R_NDS32_PLTREL_HI20:
5356 case R_NDS32_PLTREL_LO12:
5357 case R_NDS32_PLT_GOTREL_HI20:
5358 case R_NDS32_PLT_GOTREL_LO12:
5359 case R_NDS32_PLT_GOTREL_LO15:
5360 case R_NDS32_PLT_GOTREL_LO19:
5361 case R_NDS32_PLT_GOTREL_LO20:
5362 case R_NDS32_17IFC_PCREL_RELA:
5363 case R_NDS32_10IFCU_PCREL_RELA:
5364 case R_NDS32_TLS_LE_HI20:
5365 case R_NDS32_TLS_LE_LO12:
5366 case R_NDS32_TLS_IE_HI20:
5367 case R_NDS32_TLS_IE_LO12S2:
5368 case R_NDS32_TLS_LE_20:
5369 case R_NDS32_TLS_LE_15S0:
5370 case R_NDS32_TLS_LE_15S1:
5371 case R_NDS32_TLS_LE_15S2:
5372 /* Instruction related relocs must handle endian properly. */
5373 /* NOTE: PIC IS NOT HANDLE YET; DO IT LATER. */
5374 r = nds32_elf_final_link_relocate (howto, input_bfd,
5375 input_section, contents,
5376 rel->r_offset, relocation,
5377 rel->r_addend);
5378 break;
5379
5380 default:
5381 /* All other relocs can use default handler. */
5382 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5383 contents, rel->r_offset,
5384 relocation, rel->r_addend);
5385 break;
5386 }
5387
5388 check_reloc:
5389
5390 if (r != bfd_reloc_ok)
5391 {
5392 /* FIXME: This should be generic enough to go in a utility. */
5393 const char *name;
5394
5395 if (h != NULL)
5396 name = h->root.root.string;
5397 else
5398 {
5399 name = bfd_elf_string_from_elf_section
5400 (input_bfd, symtab_hdr->sh_link, sym->st_name);
5401 if (name == NULL || *name == '\0')
5402 name = bfd_section_name (input_bfd, sec);
5403 }
5404
5405 if (errmsg != NULL)
5406 goto common_error;
5407
5408 switch (r)
5409 {
5410 case bfd_reloc_overflow:
5411 if (!((*info->callbacks->reloc_overflow)
5412 (info, (h ? &h->root : NULL), name, howto->name,
5413 (bfd_vma) 0, input_bfd, input_section, offset)))
5414 return FALSE;
5415 break;
5416
5417 case bfd_reloc_undefined:
5418 if (!((*info->callbacks->undefined_symbol)
5419 (info, name, input_bfd, input_section, offset, TRUE)))
5420 return FALSE;
5421 break;
5422
5423 case bfd_reloc_outofrange:
5424 errmsg = _("internal error: out of range error");
5425 goto common_error;
5426
5427 case bfd_reloc_notsupported:
5428 errmsg = _("internal error: unsupported relocation error");
5429 goto common_error;
5430
5431 case bfd_reloc_dangerous:
5432 errmsg = _("internal error: dangerous error");
5433 goto common_error;
5434
5435 default:
5436 errmsg = _("internal error: unknown error");
5437 /* Fall through. */
5438
5439 common_error:
5440 if (!((*info->callbacks->warning)
5441 (info, errmsg, name, input_bfd, input_section, offset)))
5442 return FALSE;
5443 break;
5444 }
5445 }
5446 }
5447
5448 return ret;
5449 }
5450
5451 /* Finish up dynamic symbol handling. We set the contents of various
5452 dynamic sections here. */
5453
5454 static bfd_boolean
5455 nds32_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
5456 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
5457 {
5458 struct elf_nds32_link_hash_table *htab;
5459 bfd_byte *loc;
5460
5461 htab = nds32_elf_hash_table (info);
5462
5463 if (h->plt.offset != (bfd_vma) - 1)
5464 {
5465 asection *splt;
5466 asection *sgot;
5467 asection *srela;
5468
5469 bfd_vma plt_index;
5470 bfd_vma got_offset;
5471 bfd_vma local_plt_offset;
5472 Elf_Internal_Rela rela;
5473
5474 /* This symbol has an entry in the procedure linkage table. Set
5475 it up. */
5476
5477 BFD_ASSERT (h->dynindx != -1);
5478
5479 splt = htab->splt;
5480 sgot = htab->sgotplt;
5481 srela = htab->srelplt;
5482 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
5483
5484 /* Get the index in the procedure linkage table which
5485 corresponds to this symbol. This is the index of this symbol
5486 in all the symbols for which we are making plt entries. The
5487 first entry in the procedure linkage table is reserved. */
5488 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
5489
5490 /* Get the offset into the .got table of the entry that
5491 corresponds to this function. Each .got entry is 4 bytes.
5492 The first three are reserved. */
5493 got_offset = (plt_index + 3) * 4;
5494
5495 /* Fill in the entry in the procedure linkage table. */
5496 if (!info->shared)
5497 {
5498 unsigned long insn;
5499
5500 insn = PLT_ENTRY_WORD0 + (((sgot->output_section->vma
5501 + sgot->output_offset + got_offset) >> 12)
5502 & 0xfffff);
5503 bfd_putb32 (insn, splt->contents + h->plt.offset);
5504
5505 insn = PLT_ENTRY_WORD1 + (((sgot->output_section->vma
5506 + sgot->output_offset + got_offset) & 0x0fff)
5507 >> 2);
5508 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
5509
5510 insn = PLT_ENTRY_WORD2;
5511 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
5512
5513 insn = PLT_ENTRY_WORD3 + (plt_index & 0x7ffff);
5514 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
5515
5516 insn = PLT_ENTRY_WORD4
5517 + (((unsigned int) ((-(h->plt.offset + 16)) >> 1)) & 0xffffff);
5518 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
5519 local_plt_offset = 12;
5520 }
5521 else
5522 {
5523 /* sda_base must be set at this time. */
5524 unsigned long insn;
5525 long offset;
5526
5527 /* FIXME, sda_base is 65536, it will damage opcode. */
5528 /* insn = PLT_PIC_ENTRY_WORD0 + (((got_offset - sda_base) >> 2) & 0x7fff); */
5529 offset = sgot->output_section->vma + sgot->output_offset + got_offset
5530 - elf_gp (output_bfd);
5531 insn = PLT_PIC_ENTRY_WORD0 + ((offset >> 12) & 0xfffff);
5532 bfd_putb32 (insn, splt->contents + h->plt.offset);
5533
5534 insn = PLT_PIC_ENTRY_WORD1 + (offset & 0xfff);
5535 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
5536
5537 insn = PLT_PIC_ENTRY_WORD2;
5538 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
5539
5540 insn = PLT_PIC_ENTRY_WORD3;
5541 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
5542
5543 insn = PLT_PIC_ENTRY_WORD4 + (plt_index & 0x7fffff);
5544 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
5545
5546 insn = PLT_PIC_ENTRY_WORD5
5547 + (((unsigned int) ((-(h->plt.offset + 20)) >> 1)) & 0xffffff);
5548 bfd_putb32 (insn, splt->contents + h->plt.offset + 20);
5549
5550 local_plt_offset = 16;
5551 }
5552
5553 /* Fill in the entry in the global offset table,
5554 so it will fall through to the next instruction for the first time. */
5555 bfd_put_32 (output_bfd,
5556 (splt->output_section->vma + splt->output_offset
5557 + h->plt.offset + local_plt_offset),
5558 sgot->contents + got_offset);
5559
5560 /* Fill in the entry in the .rela.plt section. */
5561 rela.r_offset = (sgot->output_section->vma
5562 + sgot->output_offset + got_offset);
5563 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_JMP_SLOT);
5564 rela.r_addend = 0;
5565 loc = srela->contents;
5566 loc += plt_index * sizeof (Elf32_External_Rela);
5567 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5568
5569 if (!h->def_regular)
5570 {
5571 /* Mark the symbol as undefined, rather than as defined in
5572 the .plt section. Leave the value alone. */
5573 sym->st_shndx = SHN_UNDEF;
5574 if (!h->ref_regular_nonweak)
5575 sym->st_value = 0;
5576 }
5577 }
5578
5579 if (h->got.offset != (bfd_vma) - 1)
5580 {
5581 asection *sgot;
5582 asection *srela;
5583 Elf_Internal_Rela rela;
5584
5585 /* This symbol has an entry in the global offset table.
5586 Set it up. */
5587
5588 sgot = htab->sgot;
5589 srela = htab->srelgot;
5590 BFD_ASSERT (sgot != NULL && srela != NULL);
5591
5592 rela.r_offset = (sgot->output_section->vma
5593 + sgot->output_offset + (h->got.offset & ~1));
5594
5595 /* If this is a -Bsymbolic link, and the symbol is defined
5596 locally, we just want to emit a RELATIVE reloc. Likewise if
5597 the symbol was forced to be local because of a version file.
5598 The entry in the global offset table will already have been
5599 initialized in the relocate_section function. */
5600 if (info->shared
5601 && (info->symbolic
5602 || h->dynindx == -1 || h->forced_local) && h->def_regular)
5603 {
5604 rela.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5605 rela.r_addend = (h->root.u.def.value
5606 + h->root.u.def.section->output_section->vma
5607 + h->root.u.def.section->output_offset);
5608 }
5609 else
5610 {
5611 BFD_ASSERT ((h->got.offset & 1) == 0);
5612 bfd_put_32 (output_bfd, (bfd_vma) 0,
5613 sgot->contents + h->got.offset);
5614 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_GLOB_DAT);
5615 rela.r_addend = 0;
5616 }
5617
5618 loc = srela->contents;
5619 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
5620 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5621 ++srela->reloc_count;
5622 }
5623
5624 if (h->needs_copy)
5625 {
5626 asection *s;
5627 Elf_Internal_Rela rela;
5628
5629 /* This symbols needs a copy reloc. Set it up. */
5630
5631 BFD_ASSERT (h->dynindx != -1
5632 && (h->root.type == bfd_link_hash_defined
5633 || h->root.type == bfd_link_hash_defweak));
5634
5635 s = bfd_get_section_by_name (h->root.u.def.section->owner, ".rela.bss");
5636 BFD_ASSERT (s != NULL);
5637
5638 rela.r_offset = (h->root.u.def.value
5639 + h->root.u.def.section->output_section->vma
5640 + h->root.u.def.section->output_offset);
5641 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_COPY);
5642 rela.r_addend = 0;
5643 loc = s->contents;
5644 loc += s->reloc_count * sizeof (Elf32_External_Rela);
5645 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5646 ++s->reloc_count;
5647 }
5648
5649 /* Mark some specially defined symbols as absolute. */
5650 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5651 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
5652 sym->st_shndx = SHN_ABS;
5653
5654 return TRUE;
5655 }
5656
5657
5658 /* Finish up the dynamic sections. */
5659
5660 static bfd_boolean
5661 nds32_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
5662 {
5663 struct elf_nds32_link_hash_table *htab;
5664 bfd *dynobj;
5665 asection *sdyn;
5666 asection *sgot;
5667
5668 htab = nds32_elf_hash_table (info);
5669 dynobj = htab->root.dynobj;
5670
5671 sgot = htab->sgotplt;
5672 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5673
5674 if (htab->root.dynamic_sections_created)
5675 {
5676 asection *splt;
5677 Elf32_External_Dyn *dyncon, *dynconend;
5678
5679 BFD_ASSERT (sgot != NULL && sdyn != NULL);
5680
5681 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5682 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5683
5684 for (; dyncon < dynconend; dyncon++)
5685 {
5686 Elf_Internal_Dyn dyn;
5687 asection *s;
5688
5689 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5690
5691 switch (dyn.d_tag)
5692 {
5693 default:
5694 break;
5695
5696 case DT_PLTGOT:
5697 /* name = ".got"; */
5698 s = htab->sgot->output_section;
5699 goto get_vma;
5700 case DT_JMPREL:
5701 s = htab->srelplt->output_section;
5702 get_vma:
5703 BFD_ASSERT (s != NULL);
5704 dyn.d_un.d_ptr = s->vma;
5705 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5706 break;
5707
5708 case DT_PLTRELSZ:
5709 s = htab->srelplt->output_section;
5710 BFD_ASSERT (s != NULL);
5711 dyn.d_un.d_val = s->size;
5712 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5713 break;
5714
5715 case DT_RELASZ:
5716 /* My reading of the SVR4 ABI indicates that the
5717 procedure linkage table relocs (DT_JMPREL) should be
5718 included in the overall relocs (DT_RELA). This is
5719 what Solaris does. However, UnixWare can not handle
5720 that case. Therefore, we override the DT_RELASZ entry
5721 here to make it not include the JMPREL relocs. Since
5722 the linker script arranges for .rela.plt to follow all
5723 other relocation sections, we don't have to worry
5724 about changing the DT_RELA entry. */
5725 if (htab->srelplt != NULL)
5726 {
5727 s = htab->srelplt->output_section;
5728 dyn.d_un.d_val -= s->size;
5729 }
5730 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5731 break;
5732 }
5733 }
5734
5735 /* Fill in the first entry in the procedure linkage table. */
5736 splt = htab->splt;
5737 if (splt && splt->size > 0)
5738 {
5739 if (info->shared)
5740 {
5741 unsigned long insn;
5742 long offset;
5743
5744 /* FIXME, sda_base is 65536, it will damage opcode. */
5745 /* insn = PLT_PIC_ENTRY_WORD0 + (((got_offset - sda_base) >> 2) & 0x7fff); */
5746 offset = sgot->output_section->vma + sgot->output_offset + 4
5747 - elf_gp (output_bfd);
5748 insn = PLT0_PIC_ENTRY_WORD0 | ((offset >> 12) & 0xfffff);
5749 bfd_putb32 (insn, splt->contents);
5750
5751 /* insn = PLT0_PIC_ENTRY_WORD0 | (((8 - sda_base) >> 2) & 0x7fff) ; */
5752 /* here has a typo? */
5753 insn = PLT0_PIC_ENTRY_WORD1 | (offset & 0xfff);
5754 bfd_putb32 (insn, splt->contents + 4);
5755
5756 insn = PLT0_PIC_ENTRY_WORD2;
5757 bfd_putb32 (insn, splt->contents + 8);
5758
5759 insn = PLT0_PIC_ENTRY_WORD3;
5760 bfd_putb32 (insn, splt->contents + 12);
5761
5762 insn = PLT0_PIC_ENTRY_WORD4;
5763 bfd_putb32 (insn, splt->contents + 16);
5764
5765 insn = PLT0_PIC_ENTRY_WORD5;
5766 bfd_putb32 (insn, splt->contents + 20);
5767 }
5768 else
5769 {
5770 unsigned long insn;
5771 unsigned long addr;
5772
5773 /* addr = .got + 4 */
5774 addr = sgot->output_section->vma + sgot->output_offset + 4;
5775 insn = PLT0_ENTRY_WORD0 | ((addr >> 12) & 0xfffff);
5776 bfd_putb32 (insn, splt->contents);
5777
5778 insn = PLT0_ENTRY_WORD1 | (addr & 0x0fff);
5779 bfd_putb32 (insn, splt->contents + 4);
5780
5781 insn = PLT0_ENTRY_WORD2;
5782 bfd_putb32 (insn, splt->contents + 8);
5783
5784 insn = PLT0_ENTRY_WORD3;
5785 bfd_putb32 (insn, splt->contents + 12);
5786
5787 insn = PLT0_ENTRY_WORD4;
5788 bfd_putb32 (insn, splt->contents + 16);
5789 }
5790
5791 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
5792 PLT_ENTRY_SIZE;
5793 }
5794 }
5795
5796 /* Fill in the first three entries in the global offset table. */
5797 if (sgot && sgot->size > 0)
5798 {
5799 if (sdyn == NULL)
5800 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5801 else
5802 bfd_put_32 (output_bfd,
5803 sdyn->output_section->vma + sdyn->output_offset,
5804 sgot->contents);
5805 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5806 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5807
5808 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
5809 }
5810
5811 return TRUE;
5812 }
5813 \f
5814
5815 /* Set the right machine number. */
5816
5817 static bfd_boolean
5818 nds32_elf_object_p (bfd *abfd)
5819 {
5820 static unsigned int cur_arch = 0;
5821
5822 if (E_N1_ARCH != (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH))
5823 {
5824 /* E_N1_ARCH is a wild card, so it is set only when no others exist. */
5825 cur_arch = (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH);
5826 }
5827
5828 switch (cur_arch)
5829 {
5830 default:
5831 case E_N1_ARCH:
5832 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1);
5833 break;
5834 case E_N1H_ARCH:
5835 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h);
5836 break;
5837 case E_NDS_ARCH_STAR_V2_0:
5838 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v2);
5839 break;
5840 case E_NDS_ARCH_STAR_V3_0:
5841 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3);
5842 break;
5843 case E_NDS_ARCH_STAR_V3_M:
5844 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3m);
5845 break;
5846 }
5847
5848 return TRUE;
5849 }
5850
5851 /* Store the machine number in the flags field. */
5852
5853 static void
5854 nds32_elf_final_write_processing (bfd *abfd,
5855 bfd_boolean linker ATTRIBUTE_UNUSED)
5856 {
5857 unsigned long val;
5858 static unsigned int cur_mach = 0;
5859
5860 if (bfd_mach_n1 != bfd_get_mach (abfd))
5861 {
5862 cur_mach = bfd_get_mach (abfd);
5863 }
5864
5865 switch (cur_mach)
5866 {
5867 case bfd_mach_n1:
5868 /* Only happen when object is empty, since the case is abandon. */
5869 val = E_N1_ARCH;
5870 val |= E_NDS_ABI_AABI;
5871 val |= E_NDS32_ELF_VER_1_4;
5872 break;
5873 case bfd_mach_n1h:
5874 val = E_N1H_ARCH;
5875 break;
5876 case bfd_mach_n1h_v2:
5877 val = E_NDS_ARCH_STAR_V2_0;
5878 break;
5879 case bfd_mach_n1h_v3:
5880 val = E_NDS_ARCH_STAR_V3_0;
5881 break;
5882 case bfd_mach_n1h_v3m:
5883 val = E_NDS_ARCH_STAR_V3_M;
5884 break;
5885 default:
5886 val = 0;
5887 break;
5888 }
5889
5890 elf_elfheader (abfd)->e_flags &= ~EF_NDS_ARCH;
5891 elf_elfheader (abfd)->e_flags |= val;
5892 }
5893
5894 /* Function to keep NDS32 specific file flags. */
5895
5896 static bfd_boolean
5897 nds32_elf_set_private_flags (bfd *abfd, flagword flags)
5898 {
5899 BFD_ASSERT (!elf_flags_init (abfd)
5900 || elf_elfheader (abfd)->e_flags == flags);
5901
5902 elf_elfheader (abfd)->e_flags = flags;
5903 elf_flags_init (abfd) = TRUE;
5904 return TRUE;
5905 }
5906
5907 static unsigned int
5908 convert_e_flags (unsigned int e_flags, unsigned int arch)
5909 {
5910 if ((e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9)
5911 {
5912 /* From 0.9 to 1.0. */
5913 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V1_0;
5914
5915 /* Invert E_NDS32_HAS_NO_MAC_INST. */
5916 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
5917 if (arch == E_NDS_ARCH_STAR_V1_0)
5918 {
5919 /* Done. */
5920 return e_flags;
5921 }
5922 }
5923
5924 /* From 1.0 to 2.0. */
5925 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V2_0;
5926
5927 /* Clear E_NDS32_HAS_MFUSR_PC_INST. */
5928 e_flags &= ~E_NDS32_HAS_MFUSR_PC_INST;
5929
5930 /* Invert E_NDS32_HAS_NO_MAC_INST. */
5931 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
5932 return e_flags;
5933 }
5934
5935 static bfd_boolean
5936 nds32_check_vec_size (bfd *ibfd)
5937 {
5938 static unsigned int nds32_vec_size = 0;
5939
5940 asection *sec_t = NULL;
5941 bfd_byte *contents = NULL;
5942
5943 sec_t = bfd_get_section_by_name (ibfd, ".nds32_e_flags");
5944
5945 if (sec_t && sec_t->size >= 4)
5946 {
5947 /* Get vec_size in file. */
5948 unsigned int flag_t;
5949
5950 nds32_get_section_contents (ibfd, sec_t, &contents);
5951 flag_t = bfd_get_32 (ibfd, contents);
5952
5953 /* The value could only be 4 or 16. */
5954
5955 if (!nds32_vec_size)
5956 /* Set if not set yet. */
5957 nds32_vec_size = (flag_t & 0x3);
5958 else if (nds32_vec_size != (flag_t & 0x3))
5959 {
5960 (*_bfd_error_handler) (_("%B: ISR vector size mismatch"
5961 " with previous modules, previous %u-byte, current %u-byte"),
5962 ibfd,
5963 nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
5964 (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
5965 return FALSE;
5966 }
5967 else
5968 /* Only keep the first vec_size section. */
5969 sec_t->flags |= SEC_EXCLUDE;
5970 }
5971
5972 return TRUE;
5973 }
5974
5975 /* Merge backend specific data from an object file to the output
5976 object file when linking. */
5977
5978 static bfd_boolean
5979 nds32_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5980 {
5981 flagword out_flags;
5982 flagword in_flags;
5983 flagword out_16regs;
5984 flagword in_no_mac;
5985 flagword out_no_mac;
5986 flagword in_16regs;
5987 flagword out_version;
5988 flagword in_version;
5989 flagword out_fpu_config;
5990 flagword in_fpu_config;
5991
5992 /* TODO: Revise to use object-attributes instead. */
5993 if (!nds32_check_vec_size (ibfd))
5994 return FALSE;
5995
5996 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5997 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5998 return TRUE;
5999
6000 if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
6001 {
6002 (*_bfd_error_handler)
6003 (_("%B: warning: Endian mismatch with previous modules."), ibfd);
6004
6005 bfd_set_error (bfd_error_bad_value);
6006 return FALSE;
6007 }
6008
6009 in_version = elf_elfheader (ibfd)->e_flags & EF_NDS32_ELF_VERSION;
6010 if (in_version == E_NDS32_ELF_VER_1_2)
6011 {
6012 (*_bfd_error_handler)
6013 (_("%B: warning: Older version of object file encountered, "
6014 "Please recompile with current tool chain."), ibfd);
6015 }
6016
6017 /* We may need to merge V1 and V2 arch object files to V2. */
6018 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6019 != (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6020 {
6021 /* Need to convert version. */
6022 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6023 == E_NDS_ARCH_STAR_RESERVED)
6024 {
6025 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6026 }
6027 else if ((elf_elfheader (obfd)->e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9
6028 || (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6029 > (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6030 {
6031 elf_elfheader (obfd)->e_flags =
6032 convert_e_flags (elf_elfheader (obfd)->e_flags,
6033 (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH));
6034 }
6035 else
6036 {
6037 elf_elfheader (ibfd)->e_flags =
6038 convert_e_flags (elf_elfheader (ibfd)->e_flags,
6039 (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH));
6040 }
6041 }
6042
6043 /* Extract some flags. */
6044 in_flags = elf_elfheader (ibfd)->e_flags
6045 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6046 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6047
6048 /* The following flags need special treatment. */
6049 in_16regs = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6050 in_no_mac = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6051 in_fpu_config = elf_elfheader (ibfd)->e_flags & E_NDS32_FPU_REG_CONF;
6052
6053 /* Extract some flags. */
6054 out_flags = elf_elfheader (obfd)->e_flags
6055 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6056 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6057
6058 /* The following flags need special treatment. */
6059 out_16regs = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6060 out_no_mac = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6061 out_fpu_config = elf_elfheader (obfd)->e_flags & E_NDS32_FPU_REG_CONF;
6062 out_version = elf_elfheader (obfd)->e_flags & EF_NDS32_ELF_VERSION;
6063 if (!elf_flags_init (obfd))
6064 {
6065 /* If the input is the default architecture then do not
6066 bother setting the flags for the output architecture,
6067 instead allow future merges to do this. If no future
6068 merges ever set these flags then they will retain their
6069 unitialised values, which surprise surprise, correspond
6070 to the default values. */
6071 if (bfd_get_arch_info (ibfd)->the_default)
6072 return TRUE;
6073
6074 elf_flags_init (obfd) = TRUE;
6075 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6076
6077 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
6078 && bfd_get_arch_info (obfd)->the_default)
6079 {
6080 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
6081 bfd_get_mach (ibfd));
6082 }
6083
6084 return TRUE;
6085 }
6086
6087 /* Check flag compatibility. */
6088 if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
6089 {
6090 (*_bfd_error_handler)
6091 (_("%B: error: ABI mismatch with previous modules."), ibfd);
6092
6093 bfd_set_error (bfd_error_bad_value);
6094 return FALSE;
6095 }
6096
6097 if ((in_flags & EF_NDS_ARCH) != (out_flags & EF_NDS_ARCH))
6098 {
6099 if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
6100 {
6101 (*_bfd_error_handler)
6102 (_("%B: error: Instruction set mismatch with previous modules."), ibfd);
6103
6104 bfd_set_error (bfd_error_bad_value);
6105 return FALSE;
6106 }
6107 }
6108
6109 /* When linking with V1.2 and V1.3 objects together the output is V1.2.
6110 and perf ext1 and DIV are mergerd to perf ext1. */
6111 if (in_version == E_NDS32_ELF_VER_1_2 || out_version == E_NDS32_ELF_VER_1_2)
6112 {
6113 elf_elfheader (obfd)->e_flags =
6114 (in_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6115 | (out_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6116 | (((in_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6117 ? E_NDS32_HAS_EXT_INST : 0)
6118 | (((out_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6119 ? E_NDS32_HAS_EXT_INST : 0)
6120 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6121 | ((in_version > out_version) ? out_version : in_version);
6122 }
6123 else
6124 {
6125 if (in_version != out_version)
6126 (*_bfd_error_handler) (_("%B: warning: Incompatible elf-versions %s and %s."),
6127 ibfd, nds32_elfver_strtab[out_version],
6128 nds32_elfver_strtab[in_version]);
6129
6130 elf_elfheader (obfd)->e_flags = in_flags | out_flags
6131 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6132 | (in_fpu_config > out_fpu_config ? in_fpu_config : out_fpu_config)
6133 | (in_version > out_version ? out_version : in_version);
6134 }
6135
6136 return TRUE;
6137 }
6138
6139 /* Display the flags field. */
6140
6141 static bfd_boolean
6142 nds32_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6143 {
6144 FILE *file = (FILE *) ptr;
6145
6146 BFD_ASSERT (abfd != NULL && ptr != NULL);
6147
6148 _bfd_elf_print_private_bfd_data (abfd, ptr);
6149
6150 fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
6151
6152 switch (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH)
6153 {
6154 default:
6155 case E_N1_ARCH:
6156 fprintf (file, _(": n1 instructions"));
6157 break;
6158 case E_N1H_ARCH:
6159 fprintf (file, _(": n1h instructions"));
6160 break;
6161 }
6162
6163 fputc ('\n', file);
6164
6165 return TRUE;
6166 }
6167
6168 static unsigned int
6169 nds32_elf_action_discarded (asection *sec)
6170 {
6171
6172 if (strncmp
6173 (".gcc_except_table", sec->name, sizeof (".gcc_except_table") - 1) == 0)
6174 return 0;
6175
6176 return _bfd_elf_default_action_discarded (sec);
6177 }
6178
6179 static asection *
6180 nds32_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info,
6181 Elf_Internal_Rela *rel, struct elf_link_hash_entry *h,
6182 Elf_Internal_Sym *sym)
6183 {
6184 if (h != NULL)
6185 switch (ELF32_R_TYPE (rel->r_info))
6186 {
6187 case R_NDS32_GNU_VTINHERIT:
6188 case R_NDS32_GNU_VTENTRY:
6189 case R_NDS32_RELA_GNU_VTINHERIT:
6190 case R_NDS32_RELA_GNU_VTENTRY:
6191 return NULL;
6192 }
6193
6194 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6195 }
6196
6197 static bfd_boolean
6198 nds32_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info, asection *sec,
6199 const Elf_Internal_Rela *relocs)
6200 {
6201 /* Update the got entry reference counts for the section being removed. */
6202 Elf_Internal_Shdr *symtab_hdr;
6203 struct elf_link_hash_entry **sym_hashes;
6204 bfd_signed_vma *local_got_refcounts;
6205 const Elf_Internal_Rela *rel, *relend;
6206
6207 elf_section_data (sec)->local_dynrel = NULL;
6208
6209 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6210 sym_hashes = elf_sym_hashes (abfd);
6211 local_got_refcounts = elf_local_got_refcounts (abfd);
6212
6213 relend = relocs + sec->reloc_count;
6214 for (rel = relocs; rel < relend; rel++)
6215 {
6216 unsigned long r_symndx;
6217 struct elf_link_hash_entry *h = NULL;
6218
6219 r_symndx = ELF32_R_SYM (rel->r_info);
6220 if (r_symndx >= symtab_hdr->sh_info)
6221 {
6222 /* External symbol. */
6223 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6224 while (h->root.type == bfd_link_hash_indirect
6225 || h->root.type == bfd_link_hash_warning)
6226 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6227 }
6228
6229 switch (ELF32_R_TYPE (rel->r_info))
6230 {
6231 case R_NDS32_GOT_HI20:
6232 case R_NDS32_GOT_LO12:
6233 case R_NDS32_GOT_LO15:
6234 case R_NDS32_GOT_LO19:
6235 case R_NDS32_GOT17S2_RELA:
6236 case R_NDS32_GOT15S2_RELA:
6237 case R_NDS32_GOTOFF:
6238 case R_NDS32_GOTOFF_HI20:
6239 case R_NDS32_GOTOFF_LO12:
6240 case R_NDS32_GOTOFF_LO15:
6241 case R_NDS32_GOTOFF_LO19:
6242 case R_NDS32_GOT20:
6243 case R_NDS32_GOTPC_HI20:
6244 case R_NDS32_GOTPC_LO12:
6245 case R_NDS32_GOTPC20:
6246 if (h != NULL)
6247 {
6248 if (h->got.refcount > 0)
6249 h->got.refcount--;
6250 }
6251 else
6252 {
6253 if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
6254 local_got_refcounts[r_symndx]--;
6255 }
6256 break;
6257
6258 case R_NDS32_16_RELA:
6259 case R_NDS32_20_RELA:
6260 case R_NDS32_5_RELA:
6261 case R_NDS32_32_RELA:
6262 case R_NDS32_HI20_RELA:
6263 case R_NDS32_LO12S3_RELA:
6264 case R_NDS32_LO12S2_RELA:
6265 case R_NDS32_LO12S2_DP_RELA:
6266 case R_NDS32_LO12S2_SP_RELA:
6267 case R_NDS32_LO12S1_RELA:
6268 case R_NDS32_LO12S0_RELA:
6269 case R_NDS32_LO12S0_ORI_RELA:
6270 case R_NDS32_SDA16S3_RELA:
6271 case R_NDS32_SDA17S2_RELA:
6272 case R_NDS32_SDA18S1_RELA:
6273 case R_NDS32_SDA19S0_RELA:
6274 case R_NDS32_SDA15S3_RELA:
6275 case R_NDS32_SDA15S2_RELA:
6276 case R_NDS32_SDA12S2_DP_RELA:
6277 case R_NDS32_SDA12S2_SP_RELA:
6278 case R_NDS32_SDA15S1_RELA:
6279 case R_NDS32_SDA15S0_RELA:
6280 case R_NDS32_SDA_FP7U2_RELA:
6281 case R_NDS32_15_PCREL_RELA:
6282 case R_NDS32_17_PCREL_RELA:
6283 case R_NDS32_25_PCREL_RELA:
6284 if (h != NULL)
6285 {
6286 struct elf_nds32_link_hash_entry *eh;
6287 struct elf_nds32_dyn_relocs **pp;
6288 struct elf_nds32_dyn_relocs *p;
6289
6290 if (!info->shared && h->plt.refcount > 0)
6291 h->plt.refcount -= 1;
6292
6293 eh = (struct elf_nds32_link_hash_entry *) h;
6294
6295 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6296 if (p->sec == sec)
6297 {
6298 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
6299 || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA
6300 || ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA)
6301 p->pc_count -= 1;
6302 p->count -= 1;
6303 if (p->count == 0)
6304 *pp = p->next;
6305 break;
6306 }
6307 }
6308 break;
6309
6310 case R_NDS32_9_PLTREL:
6311 case R_NDS32_25_PLTREL:
6312 if (h != NULL)
6313 {
6314 if (h->plt.refcount > 0)
6315 h->plt.refcount--;
6316 }
6317 break;
6318
6319 default:
6320 break;
6321 }
6322 }
6323
6324 return TRUE;
6325 }
6326
6327 /* Look through the relocs for a section during the first phase.
6328 Since we don't do .gots or .plts, we just need to consider the
6329 virtual table relocs for gc. */
6330
6331 static bfd_boolean
6332 nds32_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
6333 asection *sec, const Elf_Internal_Rela *relocs)
6334 {
6335 Elf_Internal_Shdr *symtab_hdr;
6336 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6337 const Elf_Internal_Rela *rel;
6338 const Elf_Internal_Rela *rel_end;
6339 struct elf_nds32_link_hash_table *htab;
6340 bfd *dynobj;
6341 asection *sreloc = NULL;
6342
6343 if (info->relocatable)
6344 return TRUE;
6345
6346 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6347 sym_hashes = elf_sym_hashes (abfd);
6348 sym_hashes_end =
6349 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
6350 if (!elf_bad_symtab (abfd))
6351 sym_hashes_end -= symtab_hdr->sh_info;
6352
6353 htab = nds32_elf_hash_table (info);
6354 dynobj = htab->root.dynobj;
6355
6356 rel_end = relocs + sec->reloc_count;
6357 for (rel = relocs; rel < rel_end; rel++)
6358 {
6359 enum elf_nds32_reloc_type r_type;
6360 struct elf_link_hash_entry *h;
6361 unsigned long r_symndx;
6362 int tls_type, old_tls_type;
6363
6364 r_symndx = ELF32_R_SYM (rel->r_info);
6365 r_type = ELF32_R_TYPE (rel->r_info);
6366 if (r_symndx < symtab_hdr->sh_info)
6367 h = NULL;
6368 else
6369 {
6370 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6371 while (h->root.type == bfd_link_hash_indirect
6372 || h->root.type == bfd_link_hash_warning)
6373 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6374 }
6375
6376 /* Some relocs require a global offset table. We create
6377 got section here, since these relocation need got section
6378 and it is not created yet. */
6379 if (htab->sgot == NULL)
6380 {
6381 switch (r_type)
6382 {
6383 case R_NDS32_GOT_HI20:
6384 case R_NDS32_GOT_LO12:
6385 case R_NDS32_GOT_LO15:
6386 case R_NDS32_GOT_LO19:
6387 case R_NDS32_GOT17S2_RELA:
6388 case R_NDS32_GOT15S2_RELA:
6389 case R_NDS32_GOTOFF:
6390 case R_NDS32_GOTOFF_HI20:
6391 case R_NDS32_GOTOFF_LO12:
6392 case R_NDS32_GOTOFF_LO15:
6393 case R_NDS32_GOTOFF_LO19:
6394 case R_NDS32_GOTPC20:
6395 case R_NDS32_GOTPC_HI20:
6396 case R_NDS32_GOTPC_LO12:
6397 case R_NDS32_GOT20:
6398 case R_NDS32_TLS_IE_HI20:
6399 case R_NDS32_TLS_IE_LO12S2:
6400 if (dynobj == NULL)
6401 htab->root.dynobj = dynobj = abfd;
6402 if (!create_got_section (dynobj, info))
6403 return FALSE;
6404 break;
6405
6406 default:
6407 break;
6408 }
6409 }
6410
6411 switch ((int) r_type)
6412 {
6413 case R_NDS32_GOT_HI20:
6414 case R_NDS32_GOT_LO12:
6415 case R_NDS32_GOT_LO15:
6416 case R_NDS32_GOT_LO19:
6417 case R_NDS32_GOT20:
6418 case R_NDS32_TLS_IE_HI20:
6419 case R_NDS32_TLS_IE_LO12S2:
6420 switch (r_type)
6421 {
6422 case R_NDS32_TLS_IE_HI20:
6423 case R_NDS32_TLS_IE_LO12S2:
6424 tls_type = GOT_TLS_IE;
6425 break;
6426 default:
6427 tls_type = GOT_NORMAL;
6428 break;
6429 }
6430 if (h != NULL)
6431 {
6432 old_tls_type = elf32_nds32_hash_entry (h)->tls_type;
6433 h->got.refcount += 1;
6434 }
6435 else
6436 {
6437 bfd_signed_vma *local_got_refcounts;
6438
6439 /* This is a global offset table entry for a local
6440 symbol. */
6441 local_got_refcounts = elf_local_got_refcounts (abfd);
6442 if (local_got_refcounts == NULL)
6443 {
6444 bfd_size_type size;
6445
6446 size = symtab_hdr->sh_info;
6447 size *= sizeof (bfd_signed_vma);
6448 local_got_refcounts = (bfd_signed_vma *) bfd_zalloc (abfd, size);
6449 if (local_got_refcounts == NULL)
6450 return FALSE;
6451 elf_local_got_refcounts (abfd) = local_got_refcounts;
6452 }
6453 local_got_refcounts[r_symndx] += 1;
6454 old_tls_type = elf32_nds32_local_got_tls_type (abfd)[r_symndx];
6455 }
6456
6457 /* We will already have issued an error message if there
6458 is a TLS/non-TLS mismatch, based on the symbol
6459 type. So just combine any TLS types needed. */
6460 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
6461 && tls_type != GOT_NORMAL)
6462 tls_type |= old_tls_type;
6463
6464 if (old_tls_type != tls_type)
6465 {
6466 if (h != NULL)
6467 elf32_nds32_hash_entry (h)->tls_type = tls_type;
6468 else
6469 elf32_nds32_local_got_tls_type (abfd)[r_symndx] = tls_type;
6470 }
6471 break;
6472 case R_NDS32_9_PLTREL:
6473 case R_NDS32_25_PLTREL:
6474 case R_NDS32_PLTREL_HI20:
6475 case R_NDS32_PLTREL_LO12:
6476 case R_NDS32_PLT_GOTREL_HI20:
6477 case R_NDS32_PLT_GOTREL_LO12:
6478 case R_NDS32_PLT_GOTREL_LO15:
6479 case R_NDS32_PLT_GOTREL_LO19:
6480 case R_NDS32_PLT_GOTREL_LO20:
6481
6482 /* This symbol requires a procedure linkage table entry. We
6483 actually build the entry in adjust_dynamic_symbol,
6484 because this might be a case of linking PIC code without
6485 linking in any dynamic objects, in which case we don't
6486 need to generate a procedure linkage table after all. */
6487
6488 /* If this is a local symbol, we resolve it directly without
6489 creating a procedure linkage table entry. */
6490 if (h == NULL)
6491 continue;
6492
6493 if (h->forced_local)
6494 break;
6495
6496 elf32_nds32_hash_entry (h)->tls_type = GOT_NORMAL;
6497 h->needs_plt = 1;
6498 h->plt.refcount += 1;
6499 break;
6500
6501 case R_NDS32_16_RELA:
6502 case R_NDS32_20_RELA:
6503 case R_NDS32_5_RELA:
6504 case R_NDS32_32_RELA:
6505 case R_NDS32_HI20_RELA:
6506 case R_NDS32_LO12S3_RELA:
6507 case R_NDS32_LO12S2_RELA:
6508 case R_NDS32_LO12S2_DP_RELA:
6509 case R_NDS32_LO12S2_SP_RELA:
6510 case R_NDS32_LO12S1_RELA:
6511 case R_NDS32_LO12S0_RELA:
6512 case R_NDS32_LO12S0_ORI_RELA:
6513 case R_NDS32_SDA16S3_RELA:
6514 case R_NDS32_SDA17S2_RELA:
6515 case R_NDS32_SDA18S1_RELA:
6516 case R_NDS32_SDA19S0_RELA:
6517 case R_NDS32_SDA15S3_RELA:
6518 case R_NDS32_SDA15S2_RELA:
6519 case R_NDS32_SDA12S2_DP_RELA:
6520 case R_NDS32_SDA12S2_SP_RELA:
6521 case R_NDS32_SDA15S1_RELA:
6522 case R_NDS32_SDA15S0_RELA:
6523 case R_NDS32_SDA_FP7U2_RELA:
6524 case R_NDS32_15_PCREL_RELA:
6525 case R_NDS32_17_PCREL_RELA:
6526 case R_NDS32_25_PCREL_RELA:
6527
6528 if (h != NULL && !info->shared)
6529 {
6530 h->non_got_ref = 1;
6531 h->plt.refcount += 1;
6532 }
6533
6534 /* If we are creating a shared library, and this is a reloc against
6535 a global symbol, or a non PC relative reloc against a local
6536 symbol, then we need to copy the reloc into the shared library.
6537 However, if we are linking with -Bsymbolic, we do not need to
6538 copy a reloc against a global symbol which is defined in an
6539 object we are including in the link (i.e., DEF_REGULAR is set).
6540 At this point we have not seen all the input files, so it is
6541 possible that DEF_REGULAR is not set now but will be set later
6542 (it is never cleared). We account for that possibility below by
6543 storing information in the dyn_relocs field of the hash table
6544 entry. A similar situation occurs when creating shared libraries
6545 and symbol visibility changes render the symbol local.
6546
6547 If on the other hand, we are creating an executable, we may need
6548 to keep relocations for symbols satisfied by a dynamic library
6549 if we manage to avoid copy relocs for the symbol. */
6550 if ((info->shared
6551 && (sec->flags & SEC_ALLOC) != 0
6552 && ((r_type != R_NDS32_25_PCREL_RELA
6553 && r_type != R_NDS32_15_PCREL_RELA
6554 && r_type != R_NDS32_17_PCREL_RELA
6555 && !(r_type == R_NDS32_32_RELA
6556 && strcmp (sec->name, ".eh_frame") == 0))
6557 || (h != NULL
6558 && (!info->symbolic
6559 || h->root.type == bfd_link_hash_defweak
6560 || !h->def_regular))))
6561 || (!info->shared
6562 && (sec->flags & SEC_ALLOC) != 0
6563 && h != NULL
6564 && (h->root.type == bfd_link_hash_defweak
6565 || !h->def_regular)))
6566 {
6567 struct elf_nds32_dyn_relocs *p;
6568 struct elf_nds32_dyn_relocs **head;
6569
6570 if (dynobj == NULL)
6571 htab->root.dynobj = dynobj = abfd;
6572
6573 /* When creating a shared object, we must copy these
6574 relocs into the output file. We create a reloc
6575 section in dynobj and make room for the reloc. */
6576 if (sreloc == NULL)
6577 {
6578 const char *name;
6579
6580 name = bfd_elf_string_from_elf_section
6581 (abfd, elf_elfheader (abfd)->e_shstrndx,
6582 elf_section_data (sec)->rela.hdr->sh_name);
6583 if (name == NULL)
6584 return FALSE;
6585
6586 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6587 && strcmp (bfd_get_section_name (abfd, sec),
6588 name + 5) == 0);
6589
6590 sreloc = bfd_get_section_by_name (dynobj, name);
6591 if (sreloc == NULL)
6592 {
6593 flagword flags;
6594
6595 sreloc = bfd_make_section (dynobj, name);
6596 flags = (SEC_HAS_CONTENTS | SEC_READONLY
6597 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6598 if ((sec->flags & SEC_ALLOC) != 0)
6599 flags |= SEC_ALLOC | SEC_LOAD;
6600 if (sreloc == NULL
6601 || !bfd_set_section_flags (dynobj, sreloc, flags)
6602 || !bfd_set_section_alignment (dynobj, sreloc, 2))
6603 return FALSE;
6604
6605 elf_section_type (sreloc) = SHT_RELA;
6606 }
6607 elf_section_data (sec)->sreloc = sreloc;
6608 }
6609
6610 /* If this is a global symbol, we count the number of
6611 relocations we need for this symbol. */
6612 if (h != NULL)
6613 head = &((struct elf_nds32_link_hash_entry *) h)->dyn_relocs;
6614 else
6615 {
6616 asection *s;
6617
6618 Elf_Internal_Sym *isym;
6619 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
6620 if (isym == NULL)
6621 return FALSE;
6622
6623 /* Track dynamic relocs needed for local syms too. */
6624 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6625 if (s == NULL)
6626 return FALSE;
6627
6628 head = ((struct elf_nds32_dyn_relocs **)
6629 &elf_section_data (s)->local_dynrel);
6630 }
6631
6632 p = *head;
6633 if (p == NULL || p->sec != sec)
6634 {
6635 bfd_size_type amt = sizeof (*p);
6636 p = (struct elf_nds32_dyn_relocs *) bfd_alloc (dynobj, amt);
6637 if (p == NULL)
6638 return FALSE;
6639 p->next = *head;
6640 *head = p;
6641 p->sec = sec;
6642 p->count = 0;
6643 p->pc_count = 0;
6644 }
6645
6646 p->count += 1;
6647 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA
6648 || ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
6649 || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA)
6650 p->pc_count += 1;
6651 }
6652 break;
6653
6654 /* This relocation describes the C++ object vtable hierarchy.
6655 Reconstruct it for later use during GC. */
6656 case R_NDS32_RELA_GNU_VTINHERIT:
6657 case R_NDS32_GNU_VTINHERIT:
6658 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6659 return FALSE;
6660 break;
6661
6662 /* This relocation describes which C++ vtable entries are actually
6663 used. Record for later use during GC. */
6664 case R_NDS32_GNU_VTENTRY:
6665 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6666 return FALSE;
6667 break;
6668 case R_NDS32_RELA_GNU_VTENTRY:
6669 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6670 return FALSE;
6671 break;
6672 }
6673 }
6674
6675 return TRUE;
6676 }
6677
6678 /* Write VAL in uleb128 format to P, returning a pointer to the
6679 following byte.
6680 This code is copied from elf-attr.c. */
6681
6682 static bfd_byte *
6683 write_uleb128 (bfd_byte *p, unsigned int val)
6684 {
6685 bfd_byte c;
6686 do
6687 {
6688 c = val & 0x7f;
6689 val >>= 7;
6690 if (val)
6691 c |= 0x80;
6692 *(p++) = c;
6693 }
6694 while (val);
6695 return p;
6696 }
6697
6698 static bfd_signed_vma
6699 calculate_offset (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
6700 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr,
6701 int *pic_ext_target)
6702 {
6703 bfd_signed_vma foff;
6704 bfd_vma symval, addend;
6705 asection *sym_sec;
6706
6707 /* Get the value of the symbol referred to by the reloc. */
6708 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6709 {
6710 Elf_Internal_Sym *isym;
6711
6712 /* A local symbol. */
6713 isym = isymbuf + ELF32_R_SYM (irel->r_info);
6714
6715 if (isym->st_shndx == SHN_UNDEF)
6716 sym_sec = bfd_und_section_ptr;
6717 else if (isym->st_shndx == SHN_ABS)
6718 sym_sec = bfd_abs_section_ptr;
6719 else if (isym->st_shndx == SHN_COMMON)
6720 sym_sec = bfd_com_section_ptr;
6721 else
6722 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6723 symval = isym->st_value + sym_sec->output_section->vma
6724 + sym_sec->output_offset;
6725 }
6726 else
6727 {
6728 unsigned long indx;
6729 struct elf_link_hash_entry *h;
6730 bfd *owner;
6731
6732 /* An external symbol. */
6733 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6734 h = elf_sym_hashes (abfd)[indx];
6735 BFD_ASSERT (h != NULL);
6736
6737 if (h->root.type != bfd_link_hash_defined
6738 && h->root.type != bfd_link_hash_defweak)
6739 /* This appears to be a reference to an undefined
6740 symbol. Just ignore it--it will be caught by the
6741 regular reloc processing. */
6742 return 0;
6743 owner = h->root.u.def.section->owner;
6744 if (owner && (elf_elfheader (owner)->e_flags & E_NDS32_HAS_PIC))
6745 *pic_ext_target = 1;
6746
6747 if (h->root.u.def.section->flags & SEC_MERGE)
6748 {
6749 sym_sec = h->root.u.def.section;
6750 symval = _bfd_merged_section_offset (abfd, &sym_sec,
6751 elf_section_data (sym_sec)->sec_info,
6752 h->root.u.def.value);
6753 symval = symval + sym_sec->output_section->vma
6754 + sym_sec->output_offset;
6755 }
6756 else
6757 symval = (h->root.u.def.value
6758 + h->root.u.def.section->output_section->vma
6759 + h->root.u.def.section->output_offset);
6760 }
6761
6762 addend = irel->r_addend;
6763
6764 foff = (symval + addend
6765 - (irel->r_offset + sec->output_section->vma + sec->output_offset));
6766 return foff;
6767 }
6768
6769 static bfd_vma
6770 calculate_plt_memory_address (bfd *abfd, struct bfd_link_info *link_info,
6771 Elf_Internal_Sym *isymbuf,
6772 Elf_Internal_Rela *irel,
6773 Elf_Internal_Shdr *symtab_hdr)
6774 {
6775 bfd_vma symval;
6776
6777 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6778 {
6779 Elf_Internal_Sym *isym;
6780 asection *sym_sec;
6781 /* A local symbol. */
6782 isym = isymbuf + ELF32_R_SYM (irel->r_info);
6783
6784 if (isym->st_shndx == SHN_UNDEF)
6785 sym_sec = bfd_und_section_ptr;
6786 else if (isym->st_shndx == SHN_ABS)
6787 sym_sec = bfd_abs_section_ptr;
6788 else if (isym->st_shndx == SHN_COMMON)
6789 sym_sec = bfd_com_section_ptr;
6790 else
6791 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6792 symval = isym->st_value + sym_sec->output_section->vma
6793 + sym_sec->output_offset;
6794 }
6795 else
6796 {
6797 unsigned long indx;
6798 struct elf_link_hash_entry *h;
6799 struct elf_nds32_link_hash_table *htab;
6800 asection *splt;
6801
6802 /* An external symbol. */
6803 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6804 h = elf_sym_hashes (abfd)[indx];
6805 BFD_ASSERT (h != NULL);
6806 htab = nds32_elf_hash_table (link_info);
6807 splt = htab->splt;
6808
6809 while (h->root.type == bfd_link_hash_indirect
6810 || h->root.type == bfd_link_hash_warning)
6811 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6812
6813 if (h->plt.offset == (bfd_vma) - 1)
6814 {
6815 if (h->root.type != bfd_link_hash_defined
6816 && h->root.type != bfd_link_hash_defweak)
6817 /* This appears to be a reference to an undefined
6818 * symbol. Just ignore it--it will be caught by the
6819 * regular reloc processing. */
6820 return 0;
6821 symval = (h->root.u.def.value
6822 + h->root.u.def.section->output_section->vma
6823 + h->root.u.def.section->output_offset);
6824 }
6825 else
6826 symval = splt->output_section->vma + h->plt.offset;
6827 }
6828
6829 return symval;
6830 }
6831
6832 static bfd_signed_vma
6833 calculate_plt_offset (bfd *abfd, asection *sec, struct bfd_link_info *link_info,
6834 Elf_Internal_Sym *isymbuf, Elf_Internal_Rela *irel,
6835 Elf_Internal_Shdr *symtab_hdr)
6836 {
6837 bfd_vma foff;
6838 if ((foff = calculate_plt_memory_address (abfd, link_info, isymbuf, irel,
6839 symtab_hdr)) == 0)
6840 return 0;
6841 else
6842 return foff - (irel->r_offset
6843 + sec->output_section->vma + sec->output_offset);
6844 }
6845 \f
6846 /* Convert a 32-bit instruction to 16-bit one.
6847 INSN is the input 32-bit instruction, INSN16 is the output 16-bit
6848 instruction. If INSN_TYPE is not NULL, it the CGEN instruction
6849 type of INSN16. Return 1 if successful. */
6850
6851 static int
6852 nds32_convert_32_to_16_alu1 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
6853 int *pinsn_type)
6854 {
6855 uint16_t insn16 = 0;
6856 int insn_type;
6857 unsigned long mach = bfd_get_mach (abfd);
6858
6859 if (N32_SH5 (insn) != 0)
6860 return 0;
6861
6862 switch (N32_SUB5 (insn))
6863 {
6864 case N32_ALU1_ADD_SLLI:
6865 case N32_ALU1_ADD_SRLI:
6866 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
6867 {
6868 insn16 = N16_TYPE333 (ADD333, N32_RT5 (insn), N32_RA5 (insn),
6869 N32_RB5 (insn));
6870 insn_type = NDS32_INSN_ADD333;
6871 }
6872 else if (N32_IS_RT4 (insn))
6873 {
6874 if (N32_RT5 (insn) == N32_RA5 (insn))
6875 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RB5 (insn));
6876 else if (N32_RT5 (insn) == N32_RB5 (insn))
6877 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RA5 (insn));
6878 insn_type = NDS32_INSN_ADD45;
6879 }
6880 break;
6881
6882 case N32_ALU1_SUB_SLLI:
6883 case N32_ALU1_SUB_SRLI:
6884 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
6885 {
6886 insn16 = N16_TYPE333 (SUB333, N32_RT5 (insn), N32_RA5 (insn),
6887 N32_RB5 (insn));
6888 insn_type = NDS32_INSN_SUB333;
6889 }
6890 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6891 {
6892 insn16 = N16_TYPE45 (SUB45, N32_RT54 (insn), N32_RB5 (insn));
6893 insn_type = NDS32_INSN_SUB45;
6894 }
6895 break;
6896
6897 case N32_ALU1_AND_SLLI:
6898 case N32_ALU1_AND_SRLI:
6899 /* and $rt, $rt, $rb -> and33 for v3, v3m. */
6900 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6901 && N32_IS_RB3 (insn))
6902 {
6903 if (N32_RT5 (insn) == N32_RA5 (insn))
6904 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RB5 (insn));
6905 else if (N32_RT5 (insn) == N32_RB5 (insn))
6906 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RA5 (insn));
6907 if (insn16)
6908 insn_type = NDS32_INSN_AND33;
6909 }
6910 break;
6911
6912 case N32_ALU1_XOR_SLLI:
6913 case N32_ALU1_XOR_SRLI:
6914 /* xor $rt, $rt, $rb -> xor33 for v3, v3m. */
6915 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6916 && N32_IS_RB3 (insn))
6917 {
6918 if (N32_RT5 (insn) == N32_RA5 (insn))
6919 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RB5 (insn));
6920 else if (N32_RT5 (insn) == N32_RB5 (insn))
6921 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RA5 (insn));
6922 if (insn16)
6923 insn_type = NDS32_INSN_XOR33;
6924 }
6925 break;
6926
6927 case N32_ALU1_OR_SLLI:
6928 case N32_ALU1_OR_SRLI:
6929 /* or $rt, $rt, $rb -> or33 for v3, v3m. */
6930 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6931 && N32_IS_RB3 (insn))
6932 {
6933 if (N32_RT5 (insn) == N32_RA5 (insn))
6934 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RB5 (insn));
6935 else if (N32_RT5 (insn) == N32_RB5 (insn))
6936 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RA5 (insn));
6937 if (insn16)
6938 insn_type = NDS32_INSN_OR33;
6939 }
6940 break;
6941 case N32_ALU1_NOR:
6942 /* nor $rt, $ra, $ra -> not33 for v3, v3m. */
6943 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RB3 (insn)
6944 && N32_RA5 (insn) == N32_RB5 (insn))
6945 {
6946 insn16 = N16_MISC33 (NOT33, N32_RT5 (insn), N32_RA5 (insn));
6947 insn_type = NDS32_INSN_NOT33;
6948 }
6949 break;
6950 case N32_ALU1_SRAI:
6951 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6952 {
6953 insn16 = N16_TYPE45 (SRAI45, N32_RT54 (insn), N32_UB5 (insn));
6954 insn_type = NDS32_INSN_SRAI45;
6955 }
6956 break;
6957
6958 case N32_ALU1_SRLI:
6959 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6960 {
6961 insn16 = N16_TYPE45 (SRLI45, N32_RT54 (insn), N32_UB5 (insn));
6962 insn_type = NDS32_INSN_SRLI45;
6963 }
6964 break;
6965
6966 case N32_ALU1_SLLI:
6967 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_UB5 (insn) < 8)
6968 {
6969 insn16 = N16_TYPE333 (SLLI333, N32_RT5 (insn), N32_RA5 (insn),
6970 N32_UB5 (insn));
6971 insn_type = NDS32_INSN_SLLI333;
6972 }
6973 break;
6974
6975 case N32_ALU1_ZEH:
6976 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6977 {
6978 insn16 = N16_BFMI333 (ZEH33, N32_RT5 (insn), N32_RA5 (insn));
6979 insn_type = NDS32_INSN_ZEH33;
6980 }
6981 break;
6982
6983 case N32_ALU1_SEB:
6984 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6985 {
6986 insn16 = N16_BFMI333 (SEB33, N32_RT5 (insn), N32_RA5 (insn));
6987 insn_type = NDS32_INSN_SEB33;
6988 }
6989 break;
6990
6991 case N32_ALU1_SEH:
6992 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6993 {
6994 insn16 = N16_BFMI333 (SEH33, N32_RT5 (insn), N32_RA5 (insn));
6995 insn_type = NDS32_INSN_SEH33;
6996 }
6997 break;
6998
6999 case N32_ALU1_SLT:
7000 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7001 {
7002 /* Implicit r15. */
7003 insn16 = N16_TYPE45 (SLT45, N32_RA54 (insn), N32_RB5 (insn));
7004 insn_type = NDS32_INSN_SLT45;
7005 }
7006 break;
7007
7008 case N32_ALU1_SLTS:
7009 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7010 {
7011 /* Implicit r15. */
7012 insn16 = N16_TYPE45 (SLTS45, N32_RA54 (insn), N32_RB5 (insn));
7013 insn_type = NDS32_INSN_SLTS45;
7014 }
7015 break;
7016 }
7017
7018 if ((insn16 & 0x8000) == 0)
7019 return 0;
7020
7021 if (pinsn16)
7022 *pinsn16 = insn16;
7023 if (pinsn_type)
7024 *pinsn_type = insn_type;
7025 return 1;
7026 }
7027
7028 static int
7029 nds32_convert_32_to_16_alu2 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7030 int *pinsn_type)
7031 {
7032 uint16_t insn16 = 0;
7033 int insn_type;
7034 unsigned long mach = bfd_get_mach (abfd);
7035
7036 /* TODO: bset, bclr, btgl, btst. */
7037 if (__GF (insn, 6, 4) != 0)
7038 return 0;
7039
7040 switch (N32_IMMU (insn, 6))
7041 {
7042 case N32_ALU2_MUL:
7043 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7044 && N32_IS_RB3 (insn))
7045 {
7046 if (N32_RT5 (insn) == N32_RA5 (insn))
7047 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RB5 (insn));
7048 else if (N32_RT5 (insn) == N32_RB5 (insn))
7049 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RA5 (insn));
7050 if (insn16)
7051 insn_type = NDS32_INSN_MUL33;
7052 }
7053 }
7054
7055 if ((insn16 & 0x8000) == 0)
7056 return 0;
7057
7058 if (pinsn16)
7059 *pinsn16 = insn16;
7060 if (pinsn_type)
7061 *pinsn_type = insn_type;
7062 return 1;
7063 }
7064
7065 int
7066 nds32_convert_32_to_16 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7067 int *pinsn_type)
7068 {
7069 int op6;
7070 uint16_t insn16 = 0;
7071 int insn_type;
7072 unsigned long mach = bfd_get_mach (abfd);
7073
7074 /* Decode 32-bit instruction. */
7075 if (insn & 0x80000000)
7076 {
7077 /* Not 32-bit insn. */
7078 return 0;
7079 }
7080
7081 op6 = N32_OP6 (insn);
7082
7083 /* Convert it to 16-bit instruction. */
7084 switch (op6)
7085 {
7086 case N32_OP6_MOVI:
7087 if (IS_WITHIN_S (N32_IMM20S (insn), 5))
7088 {
7089 insn16 = N16_TYPE55 (MOVI55, N32_RT5 (insn), N32_IMM20S (insn));
7090 insn_type = NDS32_INSN_MOVI55;
7091 }
7092 else if (mach >= MACH_V3 && N32_IMM20S (insn) >= 16
7093 && N32_IMM20S (insn) < 48 && N32_IS_RT4 (insn))
7094 {
7095 insn16 = N16_TYPE45 (MOVPI45, N32_RT54 (insn),
7096 N32_IMM20S (insn) - 16);
7097 insn_type = NDS32_INSN_MOVPI45;
7098 }
7099 break;
7100
7101 case N32_OP6_ADDI:
7102 if (N32_IMM15S (insn) == 0)
7103 {
7104 /* Do not convert `addi $sp, $sp, 0' to `mov55 $sp, $sp',
7105 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7106 if (mach <= MACH_V2
7107 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7108 {
7109 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7110 insn_type = NDS32_INSN_MOV55;
7111 }
7112 }
7113 else if (N32_IMM15S (insn) > 0)
7114 {
7115 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) < 8)
7116 {
7117 insn16 = N16_TYPE333 (ADDI333, N32_RT5 (insn), N32_RA5 (insn),
7118 N32_IMM15S (insn));
7119 insn_type = NDS32_INSN_ADDI333;
7120 }
7121 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7122 && N32_IMM15S (insn) < 32)
7123 {
7124 insn16 = N16_TYPE45 (ADDI45, N32_RT54 (insn), N32_IMM15S (insn));
7125 insn_type = NDS32_INSN_ADDI45;
7126 }
7127 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7128 && N32_RT5 (insn) == N32_RA5 (insn)
7129 && N32_IMM15S (insn) < 512)
7130 {
7131 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7132 insn_type = NDS32_INSN_ADDI10_SP;
7133 }
7134 else if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7135 && N32_RA5 (insn) == REG_SP && N32_IMM15S (insn) < 256
7136 && (N32_IMM15S (insn) % 4 == 0))
7137 {
7138 insn16 = N16_TYPE36 (ADDRI36_SP, N32_RT5 (insn),
7139 N32_IMM15S (insn) >> 2);
7140 insn_type = NDS32_INSN_ADDRI36_SP;
7141 }
7142 }
7143 else
7144 {
7145 /* Less than 0. */
7146 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) > -8)
7147 {
7148 insn16 = N16_TYPE333 (SUBI333, N32_RT5 (insn), N32_RA5 (insn),
7149 0 - N32_IMM15S (insn));
7150 insn_type = NDS32_INSN_SUBI333;
7151 }
7152 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7153 && N32_IMM15S (insn) > -32)
7154 {
7155 insn16 = N16_TYPE45 (SUBI45, N32_RT54 (insn),
7156 0 - N32_IMM15S (insn));
7157 insn_type = NDS32_INSN_SUBI45;
7158 }
7159 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7160 && N32_RT5 (insn) == N32_RA5 (insn)
7161 && N32_IMM15S (insn) >= -512)
7162 {
7163 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7164 insn_type = NDS32_INSN_ADDI10_SP;
7165 }
7166 }
7167 break;
7168
7169 case N32_OP6_ORI:
7170 if (N32_IMM15S (insn) == 0)
7171 {
7172 /* Do not convert `ori $sp, $sp, 0' to `mov55 $sp, $sp',
7173 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7174 if (mach <= MACH_V2
7175 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7176 {
7177 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7178 insn_type = NDS32_INSN_MOV55;
7179 }
7180 }
7181 break;
7182
7183 case N32_OP6_SUBRI:
7184 if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7185 && N32_IS_RA3 (insn) && N32_IMM15S (insn) == 0)
7186 {
7187 insn16 = N16_MISC33 (NEG33, N32_RT5 (insn), N32_RA5 (insn));
7188 insn_type = NDS32_INSN_NEG33;
7189 }
7190 break;
7191
7192 case N32_OP6_ANDI:
7193 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7194 {
7195 if (N32_IMM15U (insn) == 1)
7196 {
7197 insn16 = N16_BFMI333 (XLSB33, N32_RT5 (insn), N32_RA5 (insn));
7198 insn_type = NDS32_INSN_XLSB33;
7199 }
7200 else if (N32_IMM15U (insn) == 0x7ff)
7201 {
7202 insn16 = N16_BFMI333 (X11B33, N32_RT5 (insn), N32_RA5 (insn));
7203 insn_type = NDS32_INSN_X11B33;
7204 }
7205 else if (N32_IMM15U (insn) == 0xff)
7206 {
7207 insn16 = N16_BFMI333 (ZEB33, N32_RT5 (insn), N32_RA5 (insn));
7208 insn_type = NDS32_INSN_ZEB33;
7209 }
7210 else if (mach >= MACH_V3 && N32_RT5 (insn) == N32_RA5 (insn)
7211 && N32_IMM15U (insn) < 256)
7212 {
7213 int imm15u = N32_IMM15U (insn);
7214
7215 if (__builtin_popcount (imm15u) == 1)
7216 {
7217 /* BMSKI33 */
7218 int imm3u = __builtin_ctz (imm15u);
7219
7220 insn16 = N16_BFMI333 (BMSKI33, N32_RT5 (insn), imm3u);
7221 insn_type = NDS32_INSN_BMSKI33;
7222 }
7223 else if (imm15u != 0 && __builtin_popcount (imm15u + 1) == 1)
7224 {
7225 /* FEXTI33 */
7226 int imm3u = __builtin_ctz (imm15u + 1) - 1;
7227
7228 insn16 = N16_BFMI333 (FEXTI33, N32_RT5 (insn), imm3u);
7229 insn_type = NDS32_INSN_FEXTI33;
7230 }
7231 }
7232 }
7233 break;
7234
7235 case N32_OP6_SLTI:
7236 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7237 && IS_WITHIN_U (N32_IMM15S (insn), 5))
7238 {
7239 insn16 = N16_TYPE45 (SLTI45, N32_RA54 (insn), N32_IMM15S (insn));
7240 insn_type = NDS32_INSN_SLTI45;
7241 }
7242 break;
7243
7244 case N32_OP6_SLTSI:
7245 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7246 && IS_WITHIN_U (N32_IMM15S (insn), 5))
7247 {
7248 insn16 = N16_TYPE45 (SLTSI45, N32_RA54 (insn), N32_IMM15S (insn));
7249 insn_type = NDS32_INSN_SLTSI45;
7250 }
7251 break;
7252
7253 case N32_OP6_LWI:
7254 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7255 {
7256 insn16 = N16_TYPE45 (LWI450, N32_RT54 (insn), N32_RA5 (insn));
7257 insn_type = NDS32_INSN_LWI450;
7258 }
7259 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7260 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7261 {
7262 insn16 = N16_TYPE333 (LWI333, N32_RT5 (insn), N32_RA5 (insn),
7263 N32_IMM15S (insn));
7264 insn_type = NDS32_INSN_LWI333;
7265 }
7266 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7267 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7268 {
7269 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7270 insn_type = NDS32_INSN_LWI37;
7271 }
7272 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7273 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7274 {
7275 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 0, N32_IMM15S (insn));
7276 insn_type = NDS32_INSN_LWI37_SP;
7277 }
7278 else if (mach >= MACH_V2 && N32_IS_RT4 (insn) && N32_RA5 (insn) == REG_R8
7279 && -32 <= N32_IMM15S (insn) && N32_IMM15S (insn) < 0)
7280 {
7281 insn16 = N16_TYPE45 (LWI45_FE, N32_RT54 (insn),
7282 N32_IMM15S (insn) + 32);
7283 insn_type = NDS32_INSN_LWI45_FE;
7284 }
7285 break;
7286
7287 case N32_OP6_SWI:
7288 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7289 {
7290 insn16 = N16_TYPE45 (SWI450, N32_RT54 (insn), N32_RA5 (insn));
7291 insn_type = NDS32_INSN_SWI450;
7292 }
7293 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7294 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7295 {
7296 insn16 = N16_TYPE333 (SWI333, N32_RT5 (insn), N32_RA5 (insn),
7297 N32_IMM15S (insn));
7298 insn_type = NDS32_INSN_SWI333;
7299 }
7300 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7301 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7302 {
7303 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7304 insn_type = NDS32_INSN_SWI37;
7305 }
7306 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7307 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7308 {
7309 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 1, N32_IMM15S (insn));
7310 insn_type = NDS32_INSN_SWI37_SP;
7311 }
7312 break;
7313
7314 case N32_OP6_LWI_BI:
7315 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7316 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7317 {
7318 insn16 = N16_TYPE333 (LWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7319 N32_IMM15S (insn));
7320 insn_type = NDS32_INSN_LWI333_BI;
7321 }
7322 break;
7323
7324 case N32_OP6_SWI_BI:
7325 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7326 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7327 {
7328 insn16 = N16_TYPE333 (SWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7329 N32_IMM15S (insn));
7330 insn_type = NDS32_INSN_SWI333_BI;
7331 }
7332 break;
7333
7334 case N32_OP6_LHI:
7335 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7336 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7337 {
7338 insn16 = N16_TYPE333 (LHI333, N32_RT5 (insn), N32_RA5 (insn),
7339 N32_IMM15S (insn));
7340 insn_type = NDS32_INSN_LHI333;
7341 }
7342 break;
7343
7344 case N32_OP6_SHI:
7345 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7346 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7347 {
7348 insn16 = N16_TYPE333 (SHI333, N32_RT5 (insn), N32_RA5 (insn),
7349 N32_IMM15S (insn));
7350 insn_type = NDS32_INSN_SHI333;
7351 }
7352 break;
7353
7354 case N32_OP6_LBI:
7355 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7356 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7357 {
7358 insn16 = N16_TYPE333 (LBI333, N32_RT5 (insn), N32_RA5 (insn),
7359 N32_IMM15S (insn));
7360 insn_type = NDS32_INSN_LBI333;
7361 }
7362 break;
7363
7364 case N32_OP6_SBI:
7365 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7366 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7367 {
7368 insn16 = N16_TYPE333 (SBI333, N32_RT5 (insn), N32_RA5 (insn),
7369 N32_IMM15S (insn));
7370 insn_type = NDS32_INSN_SBI333;
7371 }
7372 break;
7373
7374 case N32_OP6_ALU1:
7375 return nds32_convert_32_to_16_alu1 (abfd, insn, pinsn16, pinsn_type);
7376
7377 case N32_OP6_ALU2:
7378 return nds32_convert_32_to_16_alu2 (abfd, insn, pinsn16, pinsn_type);
7379
7380 case N32_OP6_BR1:
7381 if (!IS_WITHIN_S (N32_IMM14S (insn), 8))
7382 goto done;
7383
7384 if ((insn & __BIT (14)) == 0)
7385 {
7386 /* N32_BR1_BEQ */
7387 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
7388 && N32_RT5 (insn) != REG_R5)
7389 insn16 = N16_TYPE38 (BEQS38, N32_RT5 (insn), N32_IMM14S (insn));
7390 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
7391 && N32_RA5 (insn) != REG_R5)
7392 insn16 = N16_TYPE38 (BEQS38, N32_RA5 (insn), N32_IMM14S (insn));
7393 insn_type = NDS32_INSN_BEQS38;
7394 break;
7395 }
7396 else
7397 {
7398 /* N32_BR1_BNE */
7399 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
7400 && N32_RT5 (insn) != REG_R5)
7401 insn16 = N16_TYPE38 (BNES38, N32_RT5 (insn), N32_IMM14S (insn));
7402 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
7403 && N32_RA5 (insn) != REG_R5)
7404 insn16 = N16_TYPE38 (BNES38, N32_RA5 (insn), N32_IMM14S (insn));
7405 insn_type = NDS32_INSN_BNES38;
7406 break;
7407 }
7408 break;
7409
7410 case N32_OP6_BR2:
7411 switch (N32_BR2_SUB (insn))
7412 {
7413 case N32_BR2_BEQZ:
7414 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
7415 {
7416 insn16 = N16_TYPE38 (BEQZ38, N32_RT5 (insn), N32_IMM16S (insn));
7417 insn_type = NDS32_INSN_BEQZ38;
7418 }
7419 else if (N32_RT5 (insn) == REG_R15
7420 && IS_WITHIN_S (N32_IMM16S (insn), 8))
7421 {
7422 insn16 = N16_TYPE8 (BEQZS8, N32_IMM16S (insn));
7423 insn_type = NDS32_INSN_BEQZS8;
7424 }
7425 break;
7426
7427 case N32_BR2_BNEZ:
7428 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
7429 {
7430 insn16 = N16_TYPE38 (BNEZ38, N32_RT5 (insn), N32_IMM16S (insn));
7431 insn_type = NDS32_INSN_BNEZ38;
7432 }
7433 else if (N32_RT5 (insn) == REG_R15
7434 && IS_WITHIN_S (N32_IMM16S (insn), 8))
7435 {
7436 insn16 = N16_TYPE8 (BNEZS8, N32_IMM16S (insn));
7437 insn_type = NDS32_INSN_BNEZS8;
7438 }
7439 break;
7440
7441 case N32_BR2_IFCALL:
7442 if (IS_WITHIN_U (N32_IMM16S (insn), 9))
7443 {
7444 insn16 = N16_TYPE9 (IFCALL9, N32_IMM16S (insn));
7445 insn_type = NDS32_INSN_IFCALL9;
7446 }
7447 break;
7448 }
7449 break;
7450
7451 case N32_OP6_JI:
7452 if ((insn & __BIT (24)) == 0)
7453 {
7454 /* N32_JI_J */
7455 if (IS_WITHIN_S (N32_IMM24S (insn), 8))
7456 {
7457 insn16 = N16_TYPE8 (J8, N32_IMM24S (insn));
7458 insn_type = NDS32_INSN_J8;
7459 }
7460 }
7461 break;
7462
7463 case N32_OP6_JREG:
7464 if (__GF (insn, 8, 2) != 0)
7465 goto done;
7466
7467 switch (N32_IMMU (insn, 5))
7468 {
7469 case N32_JREG_JR:
7470 if (N32_JREG_HINT (insn) == 0)
7471 {
7472 /* jr */
7473 insn16 = N16_TYPE5 (JR5, N32_RB5 (insn));
7474 insn_type = NDS32_INSN_JR5;
7475 }
7476 else if (N32_JREG_HINT (insn) == 1)
7477 {
7478 /* ret */
7479 insn16 = N16_TYPE5 (RET5, N32_RB5 (insn));
7480 insn_type = NDS32_INSN_RET5;
7481 }
7482 else if (N32_JREG_HINT (insn) == 3)
7483 {
7484 /* ifret = mov55 $sp, $sp */
7485 insn16 = N16_TYPE55 (MOV55, REG_SP, REG_SP);
7486 insn_type = NDS32_INSN_IFRET;
7487 }
7488 break;
7489
7490 case N32_JREG_JRAL:
7491 /* It's convertible when return rt5 is $lp and address
7492 translation is kept. */
7493 if (N32_RT5 (insn) == REG_LP && N32_JREG_HINT (insn) == 0)
7494 {
7495 insn16 = N16_TYPE5 (JRAL5, N32_RB5 (insn));
7496 insn_type = NDS32_INSN_JRAL5;
7497 }
7498 break;
7499 }
7500 break;
7501
7502 case N32_OP6_MISC:
7503 if (N32_SUB5 (insn) == N32_MISC_BREAK && N32_SWID (insn) < 32)
7504 {
7505 /* For v3, swid above 31 are used for ex9.it. */
7506 insn16 = N16_TYPE5 (BREAK16, N32_SWID (insn));
7507 insn_type = NDS32_INSN_BREAK16;
7508 }
7509 break;
7510
7511 default:
7512 /* This instruction has no 16-bit variant. */
7513 goto done;
7514 }
7515
7516 done:
7517 /* Bit-15 of insn16 should be set for a valid instruction. */
7518 if ((insn16 & 0x8000) == 0)
7519 return 0;
7520
7521 if (pinsn16)
7522 *pinsn16 = insn16;
7523 if (pinsn_type)
7524 *pinsn_type = insn_type;
7525 return 1;
7526 }
7527
7528 static int
7529 special_convert_32_to_16 (unsigned long insn, uint16_t *pinsn16,
7530 Elf_Internal_Rela *reloc)
7531 {
7532 uint16_t insn16 = 0;
7533
7534 if ((reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG) == 0
7535 || (ELF32_R_TYPE (reloc->r_info) != R_NDS32_INSN16))
7536 return 0;
7537
7538 if (!N32_IS_RT3 (insn))
7539 return 0;
7540
7541 switch (N32_OP6 (insn))
7542 {
7543 case N32_OP6_LWI:
7544 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
7545 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7546 break;
7547 case N32_OP6_SWI:
7548 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
7549 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7550 break;
7551 case N32_OP6_HWGP:
7552 if (!IS_WITHIN_U (N32_IMM17S (insn), 7))
7553 break;
7554
7555 if (__GF (insn, 17, 3) == 6)
7556 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM17S (insn));
7557 else if (__GF (insn, 17, 3) == 7)
7558 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM17S (insn));
7559 break;
7560 }
7561
7562 if ((insn16 & 0x8000) == 0)
7563 return 0;
7564
7565 *pinsn16 = insn16;
7566 return 1;
7567 }
7568
7569 /* Convert a 16-bit instruction to 32-bit one.
7570 INSN16 it the input and PINSN it the point to output.
7571 Return non-zero on successful. Otherwise 0 is returned. */
7572
7573 int
7574 nds32_convert_16_to_32 (bfd *abfd, uint16_t insn16, uint32_t *pinsn)
7575 {
7576 uint32_t insn = 0xffffffff;
7577 unsigned long mach = bfd_get_mach (abfd);
7578
7579 /* NOTE: push25, pop25 and movd44 do not have 32-bit variants. */
7580
7581 switch (__GF (insn16, 9, 6))
7582 {
7583 case 0x4: /* add45 */
7584 insn = N32_ALU1 (ADD, N16_RT4 (insn16), N16_RT4 (insn16),
7585 N16_RA5 (insn16));
7586 goto done;
7587 case 0x5: /* sub45 */
7588 insn = N32_ALU1 (SUB, N16_RT4 (insn16), N16_RT4 (insn16),
7589 N16_RA5 (insn16));
7590 goto done;
7591 case 0x6: /* addi45 */
7592 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
7593 N16_IMM5U (insn16));
7594 goto done;
7595 case 0x7: /* subi45 */
7596 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
7597 -N16_IMM5U (insn16));
7598 goto done;
7599 case 0x8: /* srai45 */
7600 insn = N32_ALU1 (SRAI, N16_RT4 (insn16), N16_RT4 (insn16),
7601 N16_IMM5U (insn16));
7602 goto done;
7603 case 0x9: /* srli45 */
7604 insn = N32_ALU1 (SRLI, N16_RT4 (insn16), N16_RT4 (insn16),
7605 N16_IMM5U (insn16));
7606 goto done;
7607 case 0xa: /* slli333 */
7608 insn = N32_ALU1 (SLLI, N16_RT3 (insn16), N16_RA3 (insn16),
7609 N16_IMM3U (insn16));
7610 goto done;
7611 case 0xc: /* add333 */
7612 insn = N32_ALU1 (ADD, N16_RT3 (insn16), N16_RA3 (insn16),
7613 N16_RB3 (insn16));
7614 goto done;
7615 case 0xd: /* sub333 */
7616 insn = N32_ALU1 (SUB, N16_RT3 (insn16), N16_RA3 (insn16),
7617 N16_RB3 (insn16));
7618 goto done;
7619 case 0xe: /* addi333 */
7620 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
7621 N16_IMM3U (insn16));
7622 goto done;
7623 case 0xf: /* subi333 */
7624 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
7625 -N16_IMM3U (insn16));
7626 goto done;
7627 case 0x10: /* lwi333 */
7628 insn = N32_TYPE2 (LWI, N16_RT3 (insn16), N16_RA3 (insn16),
7629 N16_IMM3U (insn16));
7630 goto done;
7631 case 0x12: /* lhi333 */
7632 insn = N32_TYPE2 (LHI, N16_RT3 (insn16), N16_RA3 (insn16),
7633 N16_IMM3U (insn16));
7634 goto done;
7635 case 0x13: /* lbi333 */
7636 insn = N32_TYPE2 (LBI, N16_RT3 (insn16), N16_RA3 (insn16),
7637 N16_IMM3U (insn16));
7638 goto done;
7639 case 0x11: /* lwi333.bi */
7640 insn = N32_TYPE2 (LWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
7641 N16_IMM3U (insn16));
7642 goto done;
7643 case 0x14: /* swi333 */
7644 insn = N32_TYPE2 (SWI, N16_RT3 (insn16), N16_RA3 (insn16),
7645 N16_IMM3U (insn16));
7646 goto done;
7647 case 0x16: /* shi333 */
7648 insn = N32_TYPE2 (SHI, N16_RT3 (insn16), N16_RA3 (insn16),
7649 N16_IMM3U (insn16));
7650 goto done;
7651 case 0x17: /* sbi333 */
7652 insn = N32_TYPE2 (SBI, N16_RT3 (insn16), N16_RA3 (insn16),
7653 N16_IMM3U (insn16));
7654 goto done;
7655 case 0x15: /* swi333.bi */
7656 insn = N32_TYPE2 (SWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
7657 N16_IMM3U (insn16));
7658 goto done;
7659 case 0x18: /* addri36.sp */
7660 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), REG_SP,
7661 N16_IMM6U (insn16) << 2);
7662 goto done;
7663 case 0x19: /* lwi45.fe */
7664 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), REG_R8,
7665 (N16_IMM5U (insn16) - 32));
7666 goto done;
7667 case 0x1a: /* lwi450 */
7668 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
7669 goto done;
7670 case 0x1b: /* swi450 */
7671 insn = N32_TYPE2 (SWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
7672 goto done;
7673
7674 /* These are r15 implied instructions. */
7675 case 0x30: /* slts45 */
7676 insn = N32_ALU1 (SLTS, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
7677 goto done;
7678 case 0x31: /* slt45 */
7679 insn = N32_ALU1 (SLT, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
7680 goto done;
7681 case 0x32: /* sltsi45 */
7682 insn = N32_TYPE2 (SLTSI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
7683 goto done;
7684 case 0x33: /* slti45 */
7685 insn = N32_TYPE2 (SLTI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
7686 goto done;
7687 case 0x34: /* beqzs8, bnezs8 */
7688 if (insn16 & __BIT (8))
7689 insn = N32_BR2 (BNEZ, REG_TA, N16_IMM8S (insn16));
7690 else
7691 insn = N32_BR2 (BEQZ, REG_TA, N16_IMM8S (insn16));
7692 goto done;
7693
7694 case 0x35: /* break16, ex9.it */
7695 /* Only consider range of v3 break16. */
7696 insn = N32_TYPE0 (MISC, (N16_IMM5U (insn16) << 5) | N32_MISC_BREAK);
7697 goto done;
7698
7699 case 0x3c: /* ifcall9 */
7700 insn = N32_BR2 (IFCALL, 0, N16_IMM9U (insn16));
7701 goto done;
7702 case 0x3d: /* movpi45 */
7703 insn = N32_TYPE1 (MOVI, N16_RT4 (insn16), N16_IMM5U (insn16) + 16);
7704 goto done;
7705
7706 case 0x3f: /* MISC33 */
7707 switch (insn16 & 0x7)
7708 {
7709 case 2: /* neg33 */
7710 insn = N32_TYPE2 (SUBRI, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7711 break;
7712 case 3: /* not33 */
7713 insn = N32_ALU1 (NOR, N16_RT3 (insn16), N16_RA3 (insn16),
7714 N16_RA3 (insn16));
7715 break;
7716 case 4: /* mul33 */
7717 insn = N32_ALU2 (MUL, N16_RT3 (insn16), N16_RT3 (insn16),
7718 N16_RA3 (insn16));
7719 break;
7720 case 5: /* xor33 */
7721 insn = N32_ALU1 (XOR, N16_RT3 (insn16), N16_RT3 (insn16),
7722 N16_RA3 (insn16));
7723 break;
7724 case 6: /* and33 */
7725 insn = N32_ALU1 (AND, N16_RT3 (insn16), N16_RT3 (insn16),
7726 N16_RA3 (insn16));
7727 break;
7728 case 7: /* or33 */
7729 insn = N32_ALU1 (OR, N16_RT3 (insn16), N16_RT3 (insn16),
7730 N16_RA3 (insn16));
7731 break;
7732 }
7733 goto done;
7734
7735 case 0xb:
7736 switch (insn16 & 0x7)
7737 {
7738 case 0: /* zeb33 */
7739 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0xff);
7740 break;
7741 case 1: /* zeh33 */
7742 insn = N32_ALU1 (ZEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7743 break;
7744 case 2: /* seb33 */
7745 insn = N32_ALU1 (SEB, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7746 break;
7747 case 3: /* seh33 */
7748 insn = N32_ALU1 (SEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7749 break;
7750 case 4: /* xlsb33 */
7751 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 1);
7752 break;
7753 case 5: /* x11b33 */
7754 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0x7ff);
7755 break;
7756 case 6: /* bmski33 */
7757 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
7758 1 << __GF (insn16, 3, 3));
7759 break;
7760 case 7: /* fexti33 */
7761 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
7762 (1 << (__GF (insn16, 3, 3) + 1)) - 1);
7763 break;
7764 }
7765 goto done;
7766 }
7767
7768 switch (__GF (insn16, 10, 5))
7769 {
7770 case 0x0: /* mov55 or ifret16 */
7771 if (mach >= MACH_V3 && N16_RT5 (insn16) == REG_SP
7772 && N16_RT5 (insn16) == N16_RA5 (insn16))
7773 insn = N32_JREG (JR, 0, 0, 0, 3);
7774 else
7775 insn = N32_TYPE2 (ADDI, N16_RT5 (insn16), N16_RA5 (insn16), 0);
7776 goto done;
7777 case 0x1: /* movi55 */
7778 insn = N32_TYPE1 (MOVI, N16_RT5 (insn16), N16_IMM5S (insn16));
7779 goto done;
7780 case 0x1b: /* addi10s (V2) */
7781 insn = N32_TYPE2 (ADDI, REG_SP, REG_SP, N16_IMM10S (insn16));
7782 goto done;
7783 }
7784
7785 switch (__GF (insn16, 11, 4))
7786 {
7787 case 0x7: /* lwi37.fp/swi37.fp */
7788 if (insn16 & __BIT (7)) /* swi37.fp */
7789 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
7790 else /* lwi37.fp */
7791 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
7792 goto done;
7793 case 0x8: /* beqz38 */
7794 insn = N32_BR2 (BEQZ, N16_RT38 (insn16), N16_IMM8S (insn16));
7795 goto done;
7796 case 0x9: /* bnez38 */
7797 insn = N32_BR2 (BNEZ, N16_RT38 (insn16), N16_IMM8S (insn16));
7798 goto done;
7799 case 0xa: /* beqs38/j8, implied r5 */
7800 if (N16_RT38 (insn16) == 5)
7801 insn = N32_JI (J, N16_IMM8S (insn16));
7802 else
7803 insn = N32_BR1 (BEQ, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
7804 goto done;
7805 case 0xb: /* bnes38 and others */
7806 if (N16_RT38 (insn16) == 5)
7807 {
7808 switch (__GF (insn16, 5, 3))
7809 {
7810 case 0: /* jr5 */
7811 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 0);
7812 break;
7813 case 4: /* ret5 */
7814 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 1);
7815 break;
7816 case 1: /* jral5 */
7817 insn = N32_JREG (JRAL, REG_LP, N16_RA5 (insn16), 0, 0);
7818 break;
7819 case 2: /* ex9.it imm5 */
7820 /* ex9.it had no 32-bit variantl. */
7821 break;
7822 case 5: /* add5.pc */
7823 /* add5.pc had no 32-bit variantl. */
7824 break;
7825 }
7826 }
7827 else /* bnes38 */
7828 insn = N32_BR1 (BNE, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
7829 goto done;
7830 case 0xe: /* lwi37/swi37 */
7831 if (insn16 & (1 << 7)) /* swi37.sp */
7832 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
7833 else /* lwi37.sp */
7834 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
7835 goto done;
7836 }
7837
7838 done:
7839 if (insn & 0x80000000)
7840 return 0;
7841
7842 if (pinsn)
7843 *pinsn = insn;
7844 return 1;
7845 }
7846 \f
7847 static bfd_boolean
7848 is_sda_access_insn (unsigned long insn)
7849 {
7850 switch (N32_OP6 (insn))
7851 {
7852 case N32_OP6_LWI:
7853 case N32_OP6_LHI:
7854 case N32_OP6_LHSI:
7855 case N32_OP6_LBI:
7856 case N32_OP6_LBSI:
7857 case N32_OP6_SWI:
7858 case N32_OP6_SHI:
7859 case N32_OP6_SBI:
7860 case N32_OP6_LWC:
7861 case N32_OP6_LDC:
7862 case N32_OP6_SWC:
7863 case N32_OP6_SDC:
7864 return TRUE;
7865 default:
7866 ;
7867 }
7868 return FALSE;
7869 }
7870
7871 static unsigned long
7872 turn_insn_to_sda_access (uint32_t insn, bfd_signed_vma type, uint32_t *pinsn)
7873 {
7874 uint32_t oinsn = 0;
7875
7876 switch (type)
7877 {
7878 case R_NDS32_GOT_LO12:
7879 case R_NDS32_GOTOFF_LO12:
7880 case R_NDS32_PLTREL_LO12:
7881 case R_NDS32_PLT_GOTREL_LO12:
7882 case R_NDS32_LO12S0_RELA:
7883 switch (N32_OP6 (insn))
7884 {
7885 case N32_OP6_LBI:
7886 /* lbi.gp */
7887 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
7888 break;
7889 case N32_OP6_LBSI:
7890 /* lbsi.gp */
7891 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), __BIT (19));
7892 break;
7893 case N32_OP6_SBI:
7894 /* sbi.gp */
7895 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
7896 break;
7897 case N32_OP6_ORI:
7898 /* addi.gp */
7899 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
7900 break;
7901 }
7902 break;
7903
7904 case R_NDS32_LO12S1_RELA:
7905 switch (N32_OP6 (insn))
7906 {
7907 case N32_OP6_LHI:
7908 /* lhi.gp */
7909 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
7910 break;
7911 case N32_OP6_LHSI:
7912 /* lhsi.gp */
7913 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (18));
7914 break;
7915 case N32_OP6_SHI:
7916 /* shi.gp */
7917 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (19));
7918 break;
7919 }
7920 break;
7921
7922 case R_NDS32_LO12S2_RELA:
7923 switch (N32_OP6 (insn))
7924 {
7925 case N32_OP6_LWI:
7926 /* lwi.gp */
7927 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
7928 break;
7929 case N32_OP6_SWI:
7930 /* swi.gp */
7931 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
7932 break;
7933 }
7934 break;
7935
7936 case R_NDS32_LO12S2_DP_RELA:
7937 case R_NDS32_LO12S2_SP_RELA:
7938 oinsn = (insn & 0x7ff07000) | (REG_GP << 15);
7939 break;
7940 }
7941
7942 if (oinsn)
7943 *pinsn = oinsn;
7944
7945 return oinsn != 0;
7946 }
7947
7948 /* Linker hasn't found the correct merge section for non-section symbol
7949 in relax time, this work is left to the function elf_link_input_bfd().
7950 So for non-section symbol, _bfd_merged_section_offset is also needed
7951 to find the correct symbol address. */
7952
7953 static bfd_vma
7954 nds32_elf_rela_local_sym (bfd *abfd, Elf_Internal_Sym *sym,
7955 asection **psec, Elf_Internal_Rela *rel)
7956 {
7957 asection *sec = *psec;
7958 bfd_vma relocation;
7959
7960 relocation = (sec->output_section->vma
7961 + sec->output_offset + sym->st_value);
7962 if ((sec->flags & SEC_MERGE) && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
7963 {
7964 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
7965 rel->r_addend =
7966 _bfd_merged_section_offset (abfd, psec,
7967 elf_section_data (sec)->sec_info,
7968 sym->st_value + rel->r_addend);
7969 else
7970 rel->r_addend =
7971 _bfd_merged_section_offset (abfd, psec,
7972 elf_section_data (sec)->sec_info,
7973 sym->st_value) + rel->r_addend;
7974
7975 if (sec != *psec)
7976 {
7977 /* If we have changed the section, and our original section is
7978 marked with SEC_EXCLUDE, it means that the original
7979 SEC_MERGE section has been completely subsumed in some
7980 other SEC_MERGE section. In this case, we need to leave
7981 some info around for --emit-relocs. */
7982 if ((sec->flags & SEC_EXCLUDE) != 0)
7983 sec->kept_section = *psec;
7984 sec = *psec;
7985 }
7986 rel->r_addend -= relocation;
7987 rel->r_addend += sec->output_section->vma + sec->output_offset;
7988 }
7989 return relocation;
7990 }
7991
7992 static bfd_vma
7993 calculate_memory_address (bfd *abfd, Elf_Internal_Rela *irel,
7994 Elf_Internal_Sym *isymbuf,
7995 Elf_Internal_Shdr *symtab_hdr)
7996 {
7997 bfd_signed_vma foff;
7998 bfd_vma symval, addend;
7999 Elf_Internal_Rela irel_fn;
8000 Elf_Internal_Sym *isym;
8001 asection *sym_sec;
8002
8003 /* Get the value of the symbol referred to by the reloc. */
8004 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
8005 {
8006 /* A local symbol. */
8007 isym = isymbuf + ELF32_R_SYM (irel->r_info);
8008
8009 if (isym->st_shndx == SHN_UNDEF)
8010 sym_sec = bfd_und_section_ptr;
8011 else if (isym->st_shndx == SHN_ABS)
8012 sym_sec = bfd_abs_section_ptr;
8013 else if (isym->st_shndx == SHN_COMMON)
8014 sym_sec = bfd_com_section_ptr;
8015 else
8016 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
8017 memcpy (&irel_fn, irel, sizeof (Elf_Internal_Rela));
8018 symval = nds32_elf_rela_local_sym (abfd, isym, &sym_sec, &irel_fn);
8019 addend = irel_fn.r_addend;
8020 }
8021 else
8022 {
8023 unsigned long indx;
8024 struct elf_link_hash_entry *h;
8025
8026 /* An external symbol. */
8027 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8028 h = elf_sym_hashes (abfd)[indx];
8029 BFD_ASSERT (h != NULL);
8030
8031 while (h->root.type == bfd_link_hash_indirect
8032 || h->root.type == bfd_link_hash_warning)
8033 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8034
8035 if (h->root.type != bfd_link_hash_defined
8036 && h->root.type != bfd_link_hash_defweak)
8037 /* This appears to be a reference to an undefined
8038 symbol. Just ignore it--it will be caught by the
8039 regular reloc processing. */
8040 return 0;
8041
8042 if (h->root.u.def.section->flags & SEC_MERGE)
8043 {
8044 sym_sec = h->root.u.def.section;
8045 symval = _bfd_merged_section_offset (abfd, &sym_sec, elf_section_data
8046 (sym_sec)->sec_info, h->root.u.def.value);
8047 symval = symval + sym_sec->output_section->vma
8048 + sym_sec->output_offset;
8049 }
8050 else
8051 symval = (h->root.u.def.value
8052 + h->root.u.def.section->output_section->vma
8053 + h->root.u.def.section->output_offset);
8054 addend = irel->r_addend;
8055 }
8056
8057 foff = symval + addend;
8058
8059 return foff;
8060 }
8061
8062 static bfd_vma
8063 calculate_got_memory_address (bfd *abfd, struct bfd_link_info *link_info,
8064 Elf_Internal_Rela *irel,
8065 Elf_Internal_Shdr *symtab_hdr)
8066 {
8067 int symndx;
8068 bfd_vma *local_got_offsets;
8069 /* Get the value of the symbol referred to by the reloc. */
8070 struct elf_link_hash_entry *h;
8071 struct elf_nds32_link_hash_table *htab = nds32_elf_hash_table (link_info);
8072
8073 /* An external symbol. */
8074 symndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8075 h = elf_sym_hashes (abfd)[symndx];
8076 while (h->root.type == bfd_link_hash_indirect
8077 || h->root.type == bfd_link_hash_warning)
8078 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8079
8080 if (symndx >= 0)
8081 {
8082 BFD_ASSERT (h != NULL);
8083 return htab->sgot->output_section->vma + htab->sgot->output_offset
8084 + h->got.offset;
8085 }
8086 else
8087 {
8088 local_got_offsets = elf_local_got_offsets (abfd);
8089 BFD_ASSERT (local_got_offsets != NULL);
8090 return htab->sgot->output_section->vma + htab->sgot->output_offset
8091 + local_got_offsets[ELF32_R_SYM (irel->r_info)];
8092 }
8093
8094 /* The _GLOBAL_OFFSET_TABLE_ may be undefweak(or should be?). */
8095 /* The check of h->root.type is passed. */
8096 }
8097
8098 static int
8099 is_16bit_NOP (bfd *abfd ATTRIBUTE_UNUSED,
8100 asection *sec, Elf_Internal_Rela *rel)
8101 {
8102 bfd_byte *contents;
8103 unsigned short insn16;
8104
8105 if (!(rel->r_addend & R_NDS32_INSN16_CONVERT_FLAG))
8106 return FALSE;
8107 contents = elf_section_data (sec)->this_hdr.contents;
8108 insn16 = bfd_getb16 (contents + rel->r_offset);
8109 if (insn16 == NDS32_NOP16)
8110 return TRUE;
8111 return FALSE;
8112 }
8113
8114 /* It checks whether the instruction could be converted to
8115 16-bit form and returns the converted one.
8116
8117 `internal_relocs' is supposed to be sorted. */
8118
8119 static int
8120 is_convert_32_to_16 (bfd *abfd, asection *sec,
8121 Elf_Internal_Rela *reloc,
8122 Elf_Internal_Rela *internal_relocs,
8123 Elf_Internal_Rela *irelend,
8124 uint16_t *insn16)
8125 {
8126 #define NORMAL_32_TO_16 (1 << 0)
8127 #define SPECIAL_32_TO_16 (1 << 1)
8128 bfd_byte *contents = NULL;
8129 bfd_signed_vma off;
8130 bfd_vma mem_addr;
8131 uint32_t insn = 0;
8132 Elf_Internal_Rela *pc_rel;
8133 int pic_ext_target = 0;
8134 Elf_Internal_Shdr *symtab_hdr;
8135 Elf_Internal_Sym *isymbuf = NULL;
8136 int convert_type;
8137 bfd_vma offset;
8138
8139 if (reloc->r_offset + 4 > sec->size)
8140 return FALSE;
8141
8142 offset = reloc->r_offset;
8143
8144 if (!nds32_get_section_contents (abfd, sec, &contents))
8145 return FALSE;
8146 insn = bfd_getb32 (contents + offset);
8147
8148 if (nds32_convert_32_to_16 (abfd, insn, insn16, NULL))
8149 convert_type = NORMAL_32_TO_16;
8150 else if (special_convert_32_to_16 (insn, insn16, reloc))
8151 convert_type = SPECIAL_32_TO_16;
8152 else
8153 return FALSE;
8154
8155 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8156 if (!nds32_get_local_syms (abfd, sec, &isymbuf))
8157 return FALSE;
8158
8159 /* Find the first relocation of the same relocation-type,
8160 so we iteratie them forward. */
8161 pc_rel = reloc;
8162 while ((pc_rel - 1) >= internal_relocs && pc_rel[-1].r_offset == offset)
8163 pc_rel--;
8164
8165 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8166 {
8167 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8168 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8169 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA
8170 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8171 {
8172 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr,
8173 &pic_ext_target);
8174 if (off >= ACCURATE_8BIT_S1 || off < -ACCURATE_8BIT_S1
8175 || off == 0)
8176 return FALSE;
8177 break;
8178 }
8179 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8180 {
8181 /* movi => movi55 */
8182 mem_addr = calculate_memory_address (abfd, pc_rel, isymbuf,
8183 symtab_hdr);
8184 /* mem_addr is unsigned, but the value should
8185 be between [-16, 15]. */
8186 if ((mem_addr + 0x10) >> 5)
8187 return FALSE;
8188 break;
8189 }
8190 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_20)
8191 || (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_LO12))
8192 {
8193 /* It never happen movi to movi55 for R_NDS32_TLS_LE_20,
8194 because it can be relaxed to addi for TLS_LE_ADD. */
8195 return FALSE;
8196 }
8197 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8198 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8199 && (reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG)
8200 && convert_type == SPECIAL_32_TO_16)
8201 {
8202 /* fp-as-gp
8203 We've selected a best fp-base for this access, so we can
8204 always resolve it anyway. Do nothing. */
8205 break;
8206 }
8207 else if ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_NONE
8208 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_RELA_GNU_VTINHERIT))
8209 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_RELA_GNU_VTENTRY)
8210 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_INSN16))
8211 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_LOADSTORE)
8212 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_DWARF2_OP1_RELA)))
8213 {
8214 /* Prevent unresolved addi instruction translate
8215 to addi45 or addi333. */
8216 return FALSE;
8217 }
8218 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8219 {
8220 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr,
8221 &pic_ext_target);
8222 if (off >= ACCURATE_U9BIT_S1 || off <= 0)
8223 return FALSE;
8224 break;
8225 }
8226 }
8227
8228 return TRUE;
8229 }
8230
8231 static void
8232 nds32_elf_write_16 (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *contents,
8233 Elf_Internal_Rela *reloc,
8234 Elf_Internal_Rela *internal_relocs,
8235 Elf_Internal_Rela *irelend,
8236 unsigned short insn16)
8237 {
8238 Elf_Internal_Rela *pc_rel;
8239 bfd_vma offset;
8240
8241 offset = reloc->r_offset;
8242 bfd_putb16 (insn16, contents + offset);
8243 /* Find the first relocation of the same relocation-type,
8244 so we iteratie them forward. */
8245 pc_rel = reloc;
8246 while ((pc_rel - 1) > internal_relocs && pc_rel[-1].r_offset == offset)
8247 pc_rel--;
8248
8249 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8250 {
8251 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8252 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8253 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA)
8254 {
8255 pc_rel->r_info =
8256 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PCREL_RELA);
8257 }
8258 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8259 pc_rel->r_info =
8260 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PLTREL);
8261 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8262 pc_rel->r_info =
8263 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_5_RELA);
8264 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8265 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8266 pc_rel->r_info =
8267 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_SDA_FP7U2_RELA);
8268 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8269 pc_rel->r_info =
8270 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_10IFCU_PCREL_RELA);
8271 }
8272 }
8273
8274 /* Find a relocation of type specified by `reloc_type'
8275 of the same r_offset with reloc.
8276 If not found, return irelend.
8277
8278 Assuming relocations are sorted by r_offset,
8279 we find the relocation from `reloc' backward untill relocs,
8280 or find it from `reloc' forward untill irelend. */
8281
8282 static Elf_Internal_Rela *
8283 find_relocs_at_address (Elf_Internal_Rela *reloc,
8284 Elf_Internal_Rela *relocs,
8285 Elf_Internal_Rela *irelend,
8286 enum elf_nds32_reloc_type reloc_type)
8287 {
8288 Elf_Internal_Rela *rel_t;
8289
8290 /* Find backward. */
8291 for (rel_t = reloc;
8292 rel_t >= relocs && rel_t->r_offset == reloc->r_offset;
8293 rel_t--)
8294 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8295 return rel_t;
8296
8297 /* We didn't find it backward. Try find it forward. */
8298 for (rel_t = reloc;
8299 rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8300 rel_t++)
8301 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8302 return rel_t;
8303
8304 return irelend;
8305 }
8306
8307 /* Find a relocation of specified type and offset.
8308 `reloc' is just a refence point to find a relocation at specified offset.
8309 If not found, return irelend.
8310
8311 Assuming relocations are sorted by r_offset,
8312 we find the relocation from `reloc' backward untill relocs,
8313 or find it from `reloc' forward untill irelend. */
8314
8315 static Elf_Internal_Rela *
8316 find_relocs_at_address_addr (Elf_Internal_Rela *reloc,
8317 Elf_Internal_Rela *relocs,
8318 Elf_Internal_Rela *irelend,
8319 unsigned char reloc_type,
8320 bfd_vma offset_p)
8321 {
8322 Elf_Internal_Rela *rel_t = NULL;
8323
8324 /* First, we try to find a relocation of offset `offset_p',
8325 and then we use find_relocs_at_address to find specific type. */
8326
8327 if (reloc->r_offset > offset_p)
8328 {
8329 /* Find backward. */
8330 for (rel_t = reloc;
8331 rel_t >= relocs && rel_t->r_offset > offset_p; rel_t--)
8332 /* Do nothing. */;
8333 }
8334 else if (reloc->r_offset < offset_p)
8335 {
8336 /* Find forward. */
8337 for (rel_t = reloc;
8338 rel_t < irelend && rel_t->r_offset < offset_p; rel_t++)
8339 /* Do nothing. */;
8340 }
8341 else
8342 rel_t = reloc;
8343
8344 /* Not found? */
8345 if (rel_t < relocs || rel_t == irelend || rel_t->r_offset != offset_p)
8346 return irelend;
8347
8348 return find_relocs_at_address (rel_t, relocs, irelend, reloc_type);
8349 }
8350
8351 static bfd_boolean
8352 nds32_elf_check_dup_relocs (Elf_Internal_Rela *reloc,
8353 Elf_Internal_Rela *internal_relocs,
8354 Elf_Internal_Rela *irelend,
8355 unsigned char reloc_type)
8356 {
8357 Elf_Internal_Rela *rel_t;
8358
8359 for (rel_t = reloc;
8360 rel_t >= internal_relocs && rel_t->r_offset == reloc->r_offset;
8361 rel_t--)
8362 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8363 {
8364 if (ELF32_R_SYM (rel_t->r_info) == ELF32_R_SYM (reloc->r_info)
8365 && rel_t->r_addend == reloc->r_addend)
8366 continue;
8367 return TRUE;
8368 }
8369
8370 for (rel_t = reloc; rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8371 rel_t++)
8372 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8373 {
8374 if (ELF32_R_SYM (rel_t->r_info) == ELF32_R_SYM (reloc->r_info)
8375 && rel_t->r_addend == reloc->r_addend)
8376 continue;
8377 return TRUE;
8378 }
8379
8380 return FALSE;
8381 }
8382
8383 typedef struct nds32_elf_blank nds32_elf_blank_t;
8384 struct nds32_elf_blank
8385 {
8386 /* Where the blank begins. */
8387 bfd_vma offset;
8388 /* The size of the blank. */
8389 bfd_vma size;
8390 /* The accumulative size before this blank. */
8391 bfd_vma total_size;
8392 nds32_elf_blank_t *next;
8393 nds32_elf_blank_t *prev;
8394 };
8395
8396 static nds32_elf_blank_t *blank_free_list = NULL;
8397
8398 static nds32_elf_blank_t *
8399 create_nds32_elf_blank (bfd_vma offset_p, bfd_vma size_p)
8400 {
8401 nds32_elf_blank_t *blank_t;
8402
8403 if (blank_free_list)
8404 {
8405 blank_t = blank_free_list;
8406 blank_free_list = blank_free_list->next;
8407 }
8408 else
8409 blank_t = bfd_malloc (sizeof (nds32_elf_blank_t));
8410
8411 if (blank_t == NULL)
8412 return NULL;
8413
8414 blank_t->offset = offset_p;
8415 blank_t->size = size_p;
8416 blank_t->total_size = 0;
8417 blank_t->next = NULL;
8418 blank_t->prev = NULL;
8419
8420 return blank_t;
8421 }
8422
8423 static void
8424 remove_nds32_elf_blank (nds32_elf_blank_t *blank_p)
8425 {
8426 if (blank_free_list)
8427 {
8428 blank_free_list->prev = blank_p;
8429 blank_p->next = blank_free_list;
8430 }
8431 else
8432 blank_p->next = NULL;
8433
8434 blank_p->prev = NULL;
8435 blank_free_list = blank_p;
8436 }
8437
8438 static void
8439 clean_nds32_elf_blank (void)
8440 {
8441 nds32_elf_blank_t *blank_t;
8442
8443 while (blank_free_list)
8444 {
8445 blank_t = blank_free_list;
8446 blank_free_list = blank_free_list->next;
8447 free (blank_t);
8448 }
8449 }
8450
8451 static nds32_elf_blank_t *
8452 search_nds32_elf_blank (nds32_elf_blank_t *blank_p, bfd_vma addr)
8453 {
8454 nds32_elf_blank_t *blank_t;
8455
8456 if (!blank_p)
8457 return NULL;
8458 blank_t = blank_p;
8459
8460 while (blank_t && addr < blank_t->offset)
8461 blank_t = blank_t->prev;
8462 while (blank_t && blank_t->next && addr >= blank_t->next->offset)
8463 blank_t = blank_t->next;
8464
8465 return blank_t;
8466 }
8467
8468 static bfd_vma
8469 get_nds32_elf_blank_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
8470 int overwrite)
8471 {
8472 nds32_elf_blank_t *blank_t;
8473
8474 blank_t = search_nds32_elf_blank (*blank_p, addr);
8475 if (!blank_t)
8476 return 0;
8477
8478 if (overwrite)
8479 *blank_p = blank_t;
8480
8481 if (addr < blank_t->offset + blank_t->size)
8482 return blank_t->total_size + (addr - blank_t->offset);
8483 else
8484 return blank_t->total_size + blank_t->size;
8485 }
8486
8487 static bfd_boolean
8488 insert_nds32_elf_blank (nds32_elf_blank_t **blank_p, bfd_vma addr, bfd_vma len)
8489 {
8490 nds32_elf_blank_t *blank_t, *blank_t2;
8491
8492 if (!*blank_p)
8493 {
8494 *blank_p = create_nds32_elf_blank (addr, len);
8495 return *blank_p ? TRUE : FALSE;
8496 }
8497
8498 blank_t = search_nds32_elf_blank (*blank_p, addr);
8499
8500 if (blank_t == NULL)
8501 {
8502 blank_t = create_nds32_elf_blank (addr, len);
8503 if (!blank_t)
8504 return FALSE;
8505 while ((*blank_p)->prev != NULL)
8506 *blank_p = (*blank_p)->prev;
8507 blank_t->next = *blank_p;
8508 (*blank_p)->prev = blank_t;
8509 (*blank_p) = blank_t;
8510 return TRUE;
8511 }
8512
8513 if (addr < blank_t->offset + blank_t->size)
8514 {
8515 if (addr > blank_t->offset + blank_t->size)
8516 blank_t->size = addr - blank_t->offset;
8517 }
8518 else
8519 {
8520 blank_t2 = create_nds32_elf_blank (addr, len);
8521 if (!blank_t2)
8522 return FALSE;
8523 if (blank_t->next)
8524 {
8525 blank_t->next->prev = blank_t2;
8526 blank_t2->next = blank_t->next;
8527 }
8528 blank_t2->prev = blank_t;
8529 blank_t->next = blank_t2;
8530 *blank_p = blank_t2;
8531 }
8532
8533 return TRUE;
8534 }
8535
8536 static bfd_boolean
8537 insert_nds32_elf_blank_recalc_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
8538 bfd_vma len)
8539 {
8540 nds32_elf_blank_t *blank_t;
8541
8542 if (!insert_nds32_elf_blank (blank_p, addr, len))
8543 return FALSE;
8544
8545 blank_t = *blank_p;
8546
8547 if (!blank_t->prev)
8548 {
8549 blank_t->total_size = 0;
8550 blank_t = blank_t->next;
8551 }
8552
8553 while (blank_t)
8554 {
8555 blank_t->total_size = blank_t->prev->total_size + blank_t->prev->size;
8556 blank_t = blank_t->next;
8557 }
8558
8559 return TRUE;
8560 }
8561
8562 static void
8563 calc_nds32_blank_total (nds32_elf_blank_t *blank_p)
8564 {
8565 nds32_elf_blank_t *blank_t;
8566 bfd_vma total_size = 0;
8567
8568 if (!blank_p)
8569 return;
8570
8571 blank_t = blank_p;
8572 while (blank_t->prev)
8573 blank_t = blank_t->prev;
8574 while (blank_t)
8575 {
8576 blank_t->total_size = total_size;
8577 total_size += blank_t->size;
8578 blank_t = blank_t->next;
8579 }
8580 }
8581
8582 static bfd_boolean
8583 nds32_elf_relax_delete_blanks (bfd *abfd, asection *sec,
8584 nds32_elf_blank_t *blank_p)
8585 {
8586 Elf_Internal_Shdr *symtab_hdr; /* Symbol table header of this bfd. */
8587 Elf_Internal_Sym *isym = NULL; /* Symbol table of this bfd. */
8588 Elf_Internal_Sym *isymend; /* Symbol entry iterator. */
8589 unsigned int sec_shndx; /* The section the be relaxed. */
8590 bfd_byte *contents; /* Contents data of iterating section. */
8591 Elf_Internal_Rela *internal_relocs;
8592 Elf_Internal_Rela *irel;
8593 Elf_Internal_Rela *irelend;
8594 struct elf_link_hash_entry **sym_hashes;
8595 struct elf_link_hash_entry **end_hashes;
8596 unsigned int symcount;
8597 asection *sect;
8598 nds32_elf_blank_t *blank_t;
8599 nds32_elf_blank_t *blank_t2;
8600 nds32_elf_blank_t *blank_head;
8601
8602 blank_head = blank_t = blank_p;
8603 while (blank_head->prev != NULL)
8604 blank_head = blank_head->prev;
8605 while (blank_t->next != NULL)
8606 blank_t = blank_t->next;
8607
8608 if (blank_t->offset + blank_t->size <= sec->size)
8609 {
8610 blank_t->next = create_nds32_elf_blank (sec->size + 4, 0);
8611 blank_t->next->prev = blank_t;
8612 }
8613 if (blank_head->offset > 0)
8614 {
8615 blank_head->prev = create_nds32_elf_blank (0, 0);
8616 blank_head->prev->next = blank_head;
8617 blank_head = blank_head->prev;
8618 }
8619
8620 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
8621
8622 /* The deletion must stop at the next ALIGN reloc for an alignment
8623 power larger than the number of bytes we are deleting. */
8624
8625 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8626 if (!nds32_get_local_syms (abfd, sec, &isym))
8627 return FALSE;
8628
8629 if (isym == NULL)
8630 {
8631 isym = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8632 symtab_hdr->sh_info, 0, NULL, NULL, NULL);
8633 symtab_hdr->contents = (bfd_byte *) isym;
8634 }
8635
8636 if (isym == NULL || symtab_hdr->sh_info == 0)
8637 return FALSE;
8638
8639 blank_t = blank_head;
8640 calc_nds32_blank_total (blank_head);
8641
8642 for (sect = abfd->sections; sect != NULL; sect = sect->next)
8643 {
8644 /* Adjust all the relocs. */
8645
8646 /* Relocations MUST be kept in memory, because relaxation adjust them. */
8647 internal_relocs = _bfd_elf_link_read_relocs (abfd, sect, NULL, NULL,
8648 TRUE /* keep_memory */);
8649 irelend = internal_relocs + sect->reloc_count;
8650
8651 blank_t = blank_head;
8652 blank_t2 = blank_head;
8653
8654 if (!(sect->flags & SEC_RELOC))
8655 continue;
8656
8657 nds32_get_section_contents (abfd, sect, &contents);
8658
8659 for (irel = internal_relocs; irel < irelend; irel++)
8660 {
8661 bfd_vma raddr;
8662
8663 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_DIFF8
8664 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_DIFF32
8665 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
8666 {
8667 unsigned long val = 0;
8668 unsigned long mask;
8669 long before, between;
8670 long offset;
8671
8672 switch (ELF32_R_TYPE (irel->r_info))
8673 {
8674 case R_NDS32_DIFF8:
8675 offset = bfd_get_8 (abfd, contents + irel->r_offset);
8676 break;
8677 case R_NDS32_DIFF16:
8678 offset = bfd_get_16 (abfd, contents + irel->r_offset);
8679 break;
8680 case R_NDS32_DIFF32:
8681 val = bfd_get_32 (abfd, contents + irel->r_offset);
8682 /* Get the signed bit and mask for the high part. The
8683 gcc will alarm when right shift 32-bit since the
8684 type size of long may be 32-bit. */
8685 mask = 0 - (val >> 31);
8686 if (mask)
8687 offset = (val | (mask - 0xffffffff));
8688 else
8689 offset = val;
8690 break;
8691 default:
8692 BFD_ASSERT (0);
8693 }
8694
8695 /* DIFF value
8696 0 |encoded in location|
8697 |------------|-------------------|---------
8698 sym+off(addend)
8699 -- before ---| *****************
8700 --------------------- between ---|
8701
8702 We only care how much data are relax between DIFF,
8703 marked as ***. */
8704
8705 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
8706 between = get_nds32_elf_blank_total (&blank_t,
8707 irel->r_addend + offset, 0);
8708 if (between == before)
8709 goto done_adjust_diff;
8710
8711 switch (ELF32_R_TYPE (irel->r_info))
8712 {
8713 case R_NDS32_DIFF8:
8714 bfd_put_8 (abfd, offset - (between - before),
8715 contents + irel->r_offset);
8716 break;
8717 case R_NDS32_DIFF16:
8718 bfd_put_16 (abfd, offset - (between - before),
8719 contents + irel->r_offset);
8720 break;
8721 case R_NDS32_DIFF32:
8722 bfd_put_32 (abfd, offset - (between - before),
8723 contents + irel->r_offset);
8724 break;
8725 }
8726 }
8727 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_DIFF_ULEB128
8728 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
8729 {
8730 bfd_vma val = 0;
8731 unsigned int len = 0;
8732 unsigned long before, between;
8733 bfd_byte *endp, *p;
8734
8735 val = read_unsigned_leb128 (abfd, contents + irel->r_offset,
8736 &len);
8737
8738 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
8739 between = get_nds32_elf_blank_total (&blank_t,
8740 irel->r_addend + val, 0);
8741 if (between == before)
8742 goto done_adjust_diff;
8743
8744 p = contents + irel->r_offset;
8745 endp = p + len -1;
8746 memset (p, 0x80, len);
8747 *(endp) = 0;
8748 p = write_uleb128 (p, val - (between - before)) - 1;
8749 if (p < endp)
8750 *p |= 0x80;
8751 }
8752 done_adjust_diff:
8753
8754 if (sec == sect)
8755 {
8756 raddr = irel->r_offset;
8757 irel->r_offset -= get_nds32_elf_blank_total (&blank_t2,
8758 irel->r_offset, 1);
8759
8760 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
8761 continue;
8762 if (blank_t2 && blank_t2->next
8763 && (blank_t2->offset > raddr
8764 || blank_t2->next->offset <= raddr))
8765 (*_bfd_error_handler)
8766 (_("%B: %s\n"), abfd,
8767 "Error: search_nds32_elf_blank reports wrong node");
8768
8769 /* Mark reloc in deleted portion as NONE.
8770 For some relocs like R_NDS32_LABEL that doesn't modify the
8771 content in the section. R_NDS32_LABEL doesn't belong to the
8772 instruction in the section, so we should preserve it. */
8773 if (raddr >= blank_t2->offset
8774 && raddr < blank_t2->offset + blank_t2->size
8775 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL
8776 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_BEGIN
8777 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
8778 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
8779 && ELF32_R_TYPE (irel->r_info) != R_NDS32_SUBTRAHEND
8780 && ELF32_R_TYPE (irel->r_info) != R_NDS32_MINUEND)
8781 {
8782 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
8783 R_NDS32_NONE);
8784 continue;
8785 }
8786 }
8787
8788 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE
8789 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
8790 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
8791 continue;
8792
8793 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info
8794 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx
8795 && ELF_ST_TYPE (isym[ELF32_R_SYM (irel->r_info)].st_info) == STT_SECTION)
8796 {
8797 if (irel->r_addend <= sec->size)
8798 irel->r_addend -=
8799 get_nds32_elf_blank_total (&blank_t, irel->r_addend, 1);
8800 }
8801 }
8802 }
8803
8804 /* Adjust the local symbols defined in this section. */
8805 blank_t = blank_head;
8806 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
8807 {
8808 if (isym->st_shndx == sec_shndx)
8809 {
8810 if (isym->st_value <= sec->size)
8811 {
8812 bfd_vma ahead;
8813 bfd_vma orig_addr = isym->st_value;
8814
8815 ahead = get_nds32_elf_blank_total (&blank_t, isym->st_value, 1);
8816 isym->st_value -= ahead;
8817
8818 /* Adjust function size. */
8819 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC
8820 && isym->st_size > 0)
8821 isym->st_size -=
8822 get_nds32_elf_blank_total
8823 (&blank_t, orig_addr + isym->st_size, 0) - ahead;
8824 }
8825 }
8826 }
8827
8828 /* Now adjust the global symbols defined in this section. */
8829 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
8830 - symtab_hdr->sh_info);
8831 sym_hashes = elf_sym_hashes (abfd);
8832 end_hashes = sym_hashes + symcount;
8833 blank_t = blank_head;
8834 for (; sym_hashes < end_hashes; sym_hashes++)
8835 {
8836 struct elf_link_hash_entry *sym_hash = *sym_hashes;
8837
8838 if ((sym_hash->root.type == bfd_link_hash_defined
8839 || sym_hash->root.type == bfd_link_hash_defweak)
8840 && sym_hash->root.u.def.section == sec)
8841 {
8842 if (sym_hash->root.u.def.value <= sec->size)
8843 {
8844 bfd_vma ahead;
8845 bfd_vma orig_addr = sym_hash->root.u.def.value;
8846
8847 ahead = get_nds32_elf_blank_total (&blank_t, sym_hash->root.u.def.value, 1);
8848 sym_hash->root.u.def.value -= ahead;
8849
8850 /* Adjust function size. */
8851 if (sym_hash->type == STT_FUNC)
8852 sym_hash->size -=
8853 get_nds32_elf_blank_total
8854 (&blank_t, orig_addr + sym_hash->size, 0) - ahead;
8855
8856 }
8857 }
8858 }
8859
8860 contents = elf_section_data (sec)->this_hdr.contents;
8861 blank_t = blank_head;
8862 while (blank_t->next)
8863 {
8864 /* Actually delete the bytes. */
8865
8866 /* If current blank is the last blank overlap with current section,
8867 go to finish process. */
8868 if (sec->size <= (blank_t->next->offset))
8869 break;
8870
8871 memmove (contents + blank_t->offset - blank_t->total_size,
8872 contents + blank_t->offset + blank_t->size,
8873 blank_t->next->offset - (blank_t->offset + blank_t->size));
8874
8875 blank_t = blank_t->next;
8876 }
8877
8878 if (sec->size > (blank_t->offset + blank_t->size))
8879 {
8880 /* There are remaining code between blank and section boundary.
8881 Move the remaining code to appropriate location. */
8882 memmove (contents + blank_t->offset - blank_t->total_size,
8883 contents + blank_t->offset + blank_t->size,
8884 sec->size - (blank_t->offset + blank_t->size));
8885 sec->size -= blank_t->total_size + blank_t->size;
8886 }
8887 else
8888 /* This blank is not entirely included in the section,
8889 reduce the section size by only part of the blank size. */
8890 sec->size -= blank_t->total_size + (sec->size - blank_t->offset);
8891
8892 while (blank_head)
8893 {
8894 blank_t = blank_head;
8895 blank_head = blank_head->next;
8896 remove_nds32_elf_blank (blank_t);
8897 }
8898
8899 return TRUE;
8900 }
8901
8902 /* Get the contents of a section. */
8903
8904 static int
8905 nds32_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents_p)
8906 {
8907 /* Get the section contents. */
8908 if (elf_section_data (sec)->this_hdr.contents != NULL)
8909 *contents_p = elf_section_data (sec)->this_hdr.contents;
8910 else
8911 {
8912 if (!bfd_malloc_and_get_section (abfd, sec, contents_p))
8913 return FALSE;
8914 elf_section_data (sec)->this_hdr.contents = *contents_p;
8915 }
8916
8917 return TRUE;
8918 }
8919
8920 /* Get the contents of the internal symbol of abfd. */
8921
8922 static int
8923 nds32_get_local_syms (bfd *abfd, asection *sec ATTRIBUTE_UNUSED,
8924 Elf_Internal_Sym **isymbuf_p)
8925 {
8926 Elf_Internal_Shdr *symtab_hdr;
8927 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8928
8929 /* Read this BFD's local symbols if we haven't done so already. */
8930 if (*isymbuf_p == NULL && symtab_hdr->sh_info != 0)
8931 {
8932 *isymbuf_p = (Elf_Internal_Sym *) symtab_hdr->contents;
8933 if (*isymbuf_p == NULL)
8934 {
8935 *isymbuf_p = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8936 symtab_hdr->sh_info, 0,
8937 NULL, NULL, NULL);
8938 if (*isymbuf_p == NULL)
8939 return FALSE;
8940 }
8941 }
8942 symtab_hdr->contents = (bfd_byte *) (*isymbuf_p);
8943
8944 return TRUE;
8945 }
8946
8947 /* Range of small data. */
8948 static bfd_vma sdata_range[2][2];
8949 static bfd_vma const sdata_init_range[2] =
8950 { ACCURATE_12BIT_S1, ACCURATE_19BIT };
8951
8952 static int
8953 nds32_elf_insn_size (bfd *abfd ATTRIBUTE_UNUSED,
8954 bfd_byte *contents, bfd_vma addr)
8955 {
8956 unsigned long insn = bfd_getb32 (contents + addr);
8957
8958 if (insn & 0x80000000)
8959 return 2;
8960
8961 return 4;
8962 }
8963
8964 /* Set the gp relax range. We have to measure the safe range
8965 to do gp relaxation. */
8966
8967 static void
8968 relax_range_measurement (bfd *abfd)
8969 {
8970 asection *sec_f, *sec_b;
8971 /* For upper bound. */
8972 bfd_vma maxpgsz = get_elf_backend_data (abfd)->maxpagesize;
8973 bfd_vma align;
8974 static int decide_relax_range = 0;
8975 int i;
8976 int range_number = sizeof (sdata_init_range) / sizeof (sdata_init_range[0]);
8977
8978 if (decide_relax_range)
8979 return;
8980 decide_relax_range = 1;
8981
8982 if (sda_rela_sec == NULL)
8983 {
8984 /* Since there is no data sections, we assume the range is page size. */
8985 for (i = 0; i < range_number; i++)
8986 {
8987 sdata_range[i][0] = sdata_init_range[i] - 0x1000;
8988 sdata_range[i][1] = sdata_init_range[i] - 0x1000;
8989 }
8990 return;
8991 }
8992
8993 /* Get the biggest alignment power after the gp located section. */
8994 sec_f = sda_rela_sec->output_section;
8995 sec_b = sec_f->next;
8996 align = 0;
8997 while (sec_b != NULL)
8998 {
8999 if ((unsigned)(1 << sec_b->alignment_power) > align)
9000 align = (1 << sec_b->alignment_power);
9001 sec_b = sec_b->next;
9002 }
9003
9004 /* I guess we can not determine the section before
9005 gp located section, so we assume the align is max page size. */
9006 for (i = 0; i < range_number; i++)
9007 {
9008 sdata_range[i][1] = sdata_init_range[i] - align;
9009 BFD_ASSERT (sdata_range[i][1] <= sdata_init_range[i]);
9010 sdata_range[i][0] = sdata_init_range[i] - maxpgsz;
9011 BFD_ASSERT (sdata_range[i][0] <= sdata_init_range[i]);
9012 }
9013 }
9014
9015 /* These are macros used to check flags encoded in r_addend.
9016 They are only used by nds32_elf_relax_section (). */
9017 #define GET_SEQ_LEN(addend) ((addend) & 0x000000ff)
9018 #define IS_1ST_CONVERT(addend) ((addend) & 0x80000000)
9019 #define IS_OPTIMIZE(addend) ((addend) & 0x40000000)
9020 #define IS_16BIT_ON(addend) ((addend) & 0x20000000)
9021
9022 /* Relax LONGCALL1 relocation for nds32_elf_relax_section. */
9023
9024 static bfd_boolean
9025 nds32_elf_relax_longcall1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9026 Elf_Internal_Rela *internal_relocs, int *insn_len,
9027 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9028 Elf_Internal_Shdr *symtab_hdr)
9029 {
9030 /* There are 3 variations for LONGCALL1
9031 case 4-4-2; 16-bit on, optimize off or optimize for space
9032 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9033 ori ta, ta, lo12(symbol) ; LO12S0
9034 jral5 ta ;
9035
9036 case 4-4-4; 16-bit off, optimize don't care
9037 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9038 ori ta, ta, lo12(symbol) ; LO12S0
9039 jral ta ;
9040
9041 case 4-4-4; 16-bit on, optimize for speed
9042 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9043 ori ta, ta, lo12(symbol) ; LO12S0
9044 jral ta ;
9045 Check code for -mlong-calls output. */
9046
9047 /* Get the reloc for the address from which the register is
9048 being loaded. This reloc will tell us which function is
9049 actually being called. */
9050
9051 bfd_vma laddr;
9052 int seq_len; /* Original length of instruction sequence. */
9053 uint32_t insn;
9054 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9055 int pic_ext_target = 0;
9056 bfd_signed_vma foff;
9057 uint16_t insn16;
9058
9059 irelend = internal_relocs + sec->reloc_count;
9060 seq_len = GET_SEQ_LEN (irel->r_addend);
9061 laddr = irel->r_offset;
9062 *insn_len = seq_len;
9063
9064 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9065 R_NDS32_HI20_RELA, laddr);
9066 lo_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9067 R_NDS32_LO12S0_ORI_RELA,
9068 laddr + 4);
9069
9070 if (hi_irelfn == irelend || lo_irelfn == irelend)
9071 {
9072 (*_bfd_error_handler)
9073 ("%B: warning: R_NDS32_LONGCALL1 points to unrecognized"
9074 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9075 return FALSE;
9076 }
9077
9078 /* Get the value of the symbol referred to by the reloc. */
9079 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9080 &pic_ext_target);
9081
9082 /* This condition only happened when symbol is undefined. */
9083 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9084 || foff >= CONSERVATIVE_24BIT_S1)
9085 return FALSE;
9086
9087 /* Relax to: jal symbol; 25_PCREL */
9088 /* For simplicity of coding, we are going to modify the section
9089 contents, the section relocs, and the BFD symbol table. We
9090 must tell the rest of the code not to free up this
9091 information. It would be possible to instead create a table
9092 of changes which have to be made, as is done in coff-mips.c;
9093 that would be more work, but would require less memory when
9094 the linker is run. */
9095
9096 /* Replace the long call with a jal. */
9097 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9098 R_NDS32_25_PCREL_RELA);
9099 irel->r_addend = hi_irelfn->r_addend;
9100
9101 /* We don't resolve this here but resolve it in relocate_section. */
9102 insn = INSN_JAL;
9103 bfd_putb32 (insn, contents + irel->r_offset);
9104
9105 hi_irelfn->r_info =
9106 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9107 lo_irelfn->r_info =
9108 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9109 *insn_len = 4;
9110
9111 if (seq_len & 0x2)
9112 {
9113 insn16 = NDS32_NOP16;
9114 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9115 lo_irelfn->r_info =
9116 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9117 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9118 *insn_len += 2;
9119 }
9120 return TRUE;
9121 }
9122
9123 #define CONVERT_CONDITION_CALL(insn) (((insn) & 0xffff0000) ^ 0x90000)
9124 /* Relax LONGCALL2 relocation for nds32_elf_relax_section. */
9125
9126 static bfd_boolean
9127 nds32_elf_relax_longcall2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9128 Elf_Internal_Rela *internal_relocs, int *insn_len,
9129 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9130 Elf_Internal_Shdr *symtab_hdr)
9131 {
9132 /* bltz rt, .L1 ; LONGCALL2
9133 jal symbol ; 25_PCREL
9134 .L1: */
9135
9136 /* Get the reloc for the address from which the register is
9137 being loaded. This reloc will tell us which function is
9138 actually being called. */
9139
9140 bfd_vma laddr;
9141 uint32_t insn;
9142 Elf_Internal_Rela *i1_irelfn, *cond_irelfn, *irelend;
9143 int pic_ext_target = 0;
9144 bfd_signed_vma foff;
9145
9146 irelend = internal_relocs + sec->reloc_count;
9147 laddr = irel->r_offset;
9148 i1_irelfn =
9149 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9150 R_NDS32_25_PCREL_RELA, laddr + 4);
9151
9152 if (i1_irelfn == irelend)
9153 {
9154 (*_bfd_error_handler)
9155 ("%B: warning: R_NDS32_LONGCALL2 points to unrecognized"
9156 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9157 return FALSE;
9158 }
9159
9160 insn = bfd_getb32 (contents + laddr);
9161
9162 /* Get the value of the symbol referred to by the reloc. */
9163 foff = calculate_offset (abfd, sec, i1_irelfn, isymbuf, symtab_hdr,
9164 &pic_ext_target);
9165
9166 if (foff == 0 || foff < -CONSERVATIVE_16BIT_S1
9167 || foff >= CONSERVATIVE_16BIT_S1)
9168 return FALSE;
9169
9170 /* Relax to bgezal rt, label ; 17_PCREL
9171 or bltzal rt, label ; 17_PCREL */
9172
9173 /* Convert to complimentary conditional call. */
9174 insn = CONVERT_CONDITION_CALL (insn);
9175
9176 /* For simplicity of coding, we are going to modify the section
9177 contents, the section relocs, and the BFD symbol table. We
9178 must tell the rest of the code not to free up this
9179 information. It would be possible to instead create a table
9180 of changes which have to be made, as is done in coff-mips.c;
9181 that would be more work, but would require less memory when
9182 the linker is run. */
9183
9184 /* Clean unnessary relocations. */
9185 i1_irelfn->r_info =
9186 ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info), R_NDS32_NONE);
9187 cond_irelfn =
9188 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9189 R_NDS32_17_PCREL_RELA, laddr);
9190 if (cond_irelfn != irelend)
9191 cond_irelfn->r_info =
9192 ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info), R_NDS32_NONE);
9193
9194 /* Replace the long call with a bgezal. */
9195 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info),
9196 R_NDS32_17_PCREL_RELA);
9197 irel->r_addend = i1_irelfn->r_addend;
9198
9199 bfd_putb32 (insn, contents + irel->r_offset);
9200
9201 *insn_len = 4;
9202 return TRUE;
9203 }
9204
9205 /* Relax LONGCALL3 relocation for nds32_elf_relax_section. */
9206
9207 static bfd_boolean
9208 nds32_elf_relax_longcall3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9209 Elf_Internal_Rela *internal_relocs, int *insn_len,
9210 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9211 Elf_Internal_Shdr *symtab_hdr)
9212 {
9213 /* There are 3 variations for LONGCALL3
9214 case 4-4-4-2; 16-bit on, optimize off or optimize for space
9215 bltz rt, $1 ; LONGCALL3
9216 sethi ta, hi20(symbol) ; HI20
9217 ori ta, ta, lo12(symbol) ; LO12S0
9218 jral5 ta ;
9219 $1
9220
9221 case 4-4-4-4; 16-bit off, optimize don't care
9222 bltz rt, $1 ; LONGCALL3
9223 sethi ta, hi20(symbol) ; HI20
9224 ori ta, ta, lo12(symbol) ; LO12S0
9225 jral ta ;
9226 $1
9227
9228 case 4-4-4-4; 16-bit on, optimize for speed
9229 bltz rt, $1 ; LONGCALL3
9230 sethi ta, hi20(symbol) ; HI20
9231 ori ta, ta, lo12(symbol) ; LO12S0
9232 jral ta ;
9233 $1 */
9234
9235 /* Get the reloc for the address from which the register is
9236 being loaded. This reloc will tell us which function is
9237 actually being called. */
9238
9239 bfd_vma laddr;
9240 int seq_len; /* Original length of instruction sequence. */
9241 uint32_t insn;
9242 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9243 int pic_ext_target = 0;
9244 bfd_signed_vma foff;
9245 uint16_t insn16;
9246
9247 irelend = internal_relocs + sec->reloc_count;
9248 seq_len = GET_SEQ_LEN (irel->r_addend);
9249 laddr = irel->r_offset;
9250 *insn_len = seq_len;
9251
9252 hi_irelfn =
9253 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9254 R_NDS32_HI20_RELA, laddr + 4);
9255 lo_irelfn =
9256 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9257 R_NDS32_LO12S0_ORI_RELA, laddr + 8);
9258
9259 if (hi_irelfn == irelend || lo_irelfn == irelend)
9260 {
9261 (*_bfd_error_handler)
9262 ("%B: warning: R_NDS32_LONGCALL3 points to unrecognized"
9263 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9264 return FALSE;
9265 }
9266
9267 /* Get the value of the symbol referred to by the reloc. */
9268 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9269 &pic_ext_target);
9270
9271 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9272 || foff >= CONSERVATIVE_24BIT_S1)
9273 return FALSE;
9274
9275 insn = bfd_getb32 (contents + laddr);
9276 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
9277 {
9278 /* Relax to bgezal rt, label ; 17_PCREL
9279 or bltzal rt, label ; 17_PCREL */
9280
9281 /* Convert to complimentary conditional call. */
9282 insn = CONVERT_CONDITION_CALL (insn);
9283 bfd_putb32 (insn, contents + irel->r_offset);
9284
9285 *insn_len = 4;
9286 irel->r_info =
9287 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9288 hi_irelfn->r_info =
9289 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9290 lo_irelfn->r_info =
9291 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9292
9293 cond_irelfn =
9294 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9295 R_NDS32_17_PCREL_RELA, laddr);
9296 if (cond_irelfn != irelend)
9297 {
9298 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9299 R_NDS32_17_PCREL_RELA);
9300 cond_irelfn->r_addend = hi_irelfn->r_addend;
9301 }
9302
9303 if (seq_len & 0x2)
9304 {
9305 insn16 = NDS32_NOP16;
9306 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9307 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9308 R_NDS32_INSN16);
9309 hi_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9310 insn_len += 2;
9311 }
9312 }
9313 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
9314 {
9315 /* Relax to the following instruction sequence
9316 bltz rt, $1 ; LONGCALL2
9317 jal symbol ; 25_PCREL
9318 $1 */
9319 *insn_len = 8;
9320 insn = INSN_JAL;
9321 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9322
9323 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9324 R_NDS32_25_PCREL_RELA);
9325 irel->r_info =
9326 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL2);
9327
9328 lo_irelfn->r_info =
9329 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9330
9331 if (seq_len & 0x2)
9332 {
9333 insn16 = NDS32_NOP16;
9334 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9335 lo_irelfn->r_info =
9336 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9337 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9338 insn_len += 2;
9339 }
9340 }
9341 return TRUE;
9342 }
9343
9344 /* Relax LONGJUMP1 relocation for nds32_elf_relax_section. */
9345
9346 static bfd_boolean
9347 nds32_elf_relax_longjump1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9348 Elf_Internal_Rela *internal_relocs, int *insn_len,
9349 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9350 Elf_Internal_Shdr *symtab_hdr)
9351 {
9352 /* There are 3 variations for LONGJUMP1
9353 case 4-4-2; 16-bit bit on, optimize off or optimize for space
9354 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9355 ori ta, ta, lo12(symbol) ; LO12S0
9356 jr5 ta ;
9357
9358 case 4-4-4; 16-bit off, optimize don't care
9359 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9360 ori ta, ta, lo12(symbol) ; LO12S0
9361 jr ta ;
9362
9363 case 4-4-4; 16-bit on, optimize for speed
9364 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9365 ori ta, ta, lo12(symbol) ; LO12S0
9366 jr ta ; */
9367
9368 /* Get the reloc for the address from which the register is
9369 being loaded. This reloc will tell us which function is
9370 actually being called. */
9371
9372 bfd_vma laddr;
9373 int seq_len; /* Original length of instruction sequence. */
9374 int insn16_on; /* 16-bit on/off. */
9375 uint32_t insn;
9376 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9377 int pic_ext_target = 0;
9378 bfd_signed_vma foff;
9379 uint16_t insn16;
9380 unsigned long reloc;
9381
9382 irelend = internal_relocs + sec->reloc_count;
9383 seq_len = GET_SEQ_LEN (irel->r_addend);
9384 laddr = irel->r_offset;
9385 *insn_len = seq_len;
9386 insn16_on = IS_16BIT_ON (irel->r_addend);
9387
9388 hi_irelfn =
9389 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9390 R_NDS32_HI20_RELA, laddr);
9391 lo_irelfn =
9392 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9393 R_NDS32_LO12S0_ORI_RELA, laddr + 4);
9394 if (hi_irelfn == irelend || lo_irelfn == irelend)
9395 {
9396 (*_bfd_error_handler)
9397 ("%B: warning: R_NDS32_LONGJUMP1 points to unrecognized"
9398 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9399 return FALSE;
9400 }
9401
9402 /* Get the value of the symbol referred to by the reloc. */
9403 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9404 &pic_ext_target);
9405
9406 if (pic_ext_target || foff == 0 || foff >= CONSERVATIVE_24BIT_S1
9407 || foff < -CONSERVATIVE_24BIT_S1)
9408 return FALSE;
9409
9410 if (insn16_on && foff >= -ACCURATE_8BIT_S1
9411 && foff < ACCURATE_8BIT_S1 && (seq_len & 0x2))
9412 {
9413 /* j8 label */
9414 /* 16-bit on, but not optimized for speed. */
9415 reloc = R_NDS32_9_PCREL_RELA;
9416 insn16 = INSN_J8;
9417 bfd_putb16 (insn16, contents + irel->r_offset);
9418 *insn_len = 2;
9419 irel->r_info =
9420 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
9421 }
9422 else
9423 {
9424 /* j label */
9425 reloc = R_NDS32_25_PCREL_RELA;
9426 insn = INSN_J;
9427 bfd_putb32 (insn, contents + irel->r_offset);
9428 *insn_len = 4;
9429 irel->r_info =
9430 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_INSN16);
9431 irel->r_addend = 0;
9432 }
9433
9434 hi_irelfn->r_info =
9435 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
9436 lo_irelfn->r_info =
9437 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9438
9439 if ((seq_len & 0x2) && ((*insn_len & 2) == 0))
9440 {
9441 insn16 = NDS32_NOP16;
9442 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9443 lo_irelfn->r_info =
9444 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9445 R_NDS32_INSN16);
9446 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9447 *insn_len += 2;
9448 }
9449 return TRUE;
9450 }
9451
9452 /* Revert condition branch. This function does not check if the input
9453 instruction is condition branch or not. */
9454
9455 static void
9456 nds32_elf_convert_branch (uint16_t insn16, uint32_t insn,
9457 uint16_t *re_insn16, uint32_t *re_insn)
9458 {
9459 uint32_t comp_insn = 0;
9460 uint16_t comp_insn16 = 0;
9461
9462 if (insn)
9463 {
9464 if (N32_OP6 (insn) == N32_OP6_BR1)
9465 {
9466 /* beqs label. */
9467 comp_insn = (insn ^ 0x4000) & 0xffffc000;
9468 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5)
9469 {
9470 /* Insn can be contracted to 16-bit implied r5. */
9471 comp_insn16 =
9472 (comp_insn & 0x4000) ? INSN_BNES38 : INSN_BEQS38;
9473 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
9474 }
9475 }
9476 else if (N32_OP6 (insn) == N32_OP6_BR3)
9477 {
9478 /* bnec $ta, imm11, label. */
9479 comp_insn = (insn ^ 0x80000) & 0xffffff00;
9480 }
9481 else
9482 {
9483 comp_insn = (insn ^ 0x10000) & 0xffffc000;
9484 if (N32_BR2_SUB (insn) == N32_BR2_BEQZ
9485 || N32_BR2_SUB (insn) == N32_BR2_BNEZ)
9486 {
9487 if (N32_IS_RT3 (insn))
9488 {
9489 /* Insn can be contracted to 16-bit. */
9490 comp_insn16 =
9491 (comp_insn & 0x10000) ? INSN_BNEZ38 : INSN_BEQZ38;
9492 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
9493 }
9494 else if (N32_RT5 (insn) == REG_R15)
9495 {
9496 /* Insn can be contracted to 16-bit. */
9497 comp_insn16 =
9498 (comp_insn & 0x10000) ? INSN_BNES38 : INSN_BEQS38;
9499 }
9500 }
9501 }
9502 }
9503 else
9504 {
9505 switch ((insn16 & 0xf000) >> 12)
9506 {
9507 case 0xc:
9508 /* beqz38 or bnez38 */
9509 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
9510 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNEZ : INSN_BEQZ;
9511 comp_insn |= ((comp_insn16 & 0x0700) >> 8) << 20;
9512 break;
9513
9514 case 0xd:
9515 /* beqs38 or bnes38 */
9516 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
9517 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNE : INSN_BEQ;
9518 comp_insn |= (((comp_insn16 & 0x0700) >> 8) << 20)
9519 | (REG_R5 << 15);
9520 break;
9521
9522 case 0xe:
9523 /* beqzS8 or bnezS8 */
9524 comp_insn16 = (insn16 ^ 0x0100) & 0xff00;
9525 comp_insn = (comp_insn16 & 0x0100) ? INSN_BNEZ : INSN_BEQZ;
9526 comp_insn |= REG_R15 << 20;
9527 break;
9528
9529 default:
9530 break;
9531 }
9532 }
9533 if (comp_insn && re_insn)
9534 *re_insn = comp_insn;
9535 if (comp_insn16 && re_insn16)
9536 *re_insn16 = comp_insn16;
9537 }
9538
9539 /* Relax LONGJUMP2 relocation for nds32_elf_relax_section. */
9540
9541 static bfd_boolean
9542 nds32_elf_relax_longjump2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9543 Elf_Internal_Rela *internal_relocs, int *insn_len,
9544 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9545 Elf_Internal_Shdr *symtab_hdr)
9546 {
9547 /* There are 3 variations for LONGJUMP2
9548 case 2-4; 1st insn convertible, 16-bit on,
9549 optimize off or optimize for space
9550 bnes38 rt, ra, $1 ; LONGJUMP2
9551 j label ; 25_PCREL
9552 $1:
9553
9554 case 4-4; 1st insn not convertible
9555 bne rt, ra, $1 ; LONGJUMP2
9556 j label ; 25_PCREL
9557 $1:
9558
9559 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
9560 bne rt, ra, $1 ; LONGJUMP2
9561 j label ; 25_PCREL
9562 $1: */
9563
9564 /* Get the reloc for the address from which the register is
9565 being loaded. This reloc will tell us which function is
9566 actually being called. */
9567
9568 bfd_vma laddr;
9569 int seq_len; /* Original length of instruction sequence. */
9570 Elf_Internal_Rela *i2_irelfn, *cond_irelfn, *irelend;
9571 int pic_ext_target = 0, first_size;
9572 unsigned int i;
9573 bfd_signed_vma foff;
9574 uint32_t insn, re_insn = 0;
9575 uint16_t insn16, re_insn16 = 0;
9576 unsigned long reloc, cond_reloc;
9577
9578 enum elf_nds32_reloc_type checked_types[] =
9579 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
9580
9581 irelend = internal_relocs + sec->reloc_count;
9582 seq_len = GET_SEQ_LEN (irel->r_addend);
9583 laddr = irel->r_offset;
9584 *insn_len = seq_len;
9585 first_size = (seq_len == 6) ? 2 : 4;
9586
9587 i2_irelfn =
9588 find_relocs_at_address_addr (irel, internal_relocs,
9589 irelend, R_NDS32_25_PCREL_RELA,
9590 laddr + first_size);
9591
9592 for (i = 0; i < sizeof (checked_types) / sizeof(checked_types[0]); i++)
9593 {
9594 cond_irelfn =
9595 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9596 checked_types[i], laddr);
9597 if (cond_irelfn != irelend)
9598 break;
9599 }
9600
9601 if (i2_irelfn == irelend || cond_irelfn == irelend)
9602 {
9603 (*_bfd_error_handler)
9604 ("%B: warning: R_NDS32_LONGJUMP2 points to unrecognized"
9605 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9606 return FALSE;
9607 }
9608
9609 /* Get the value of the symbol referred to by the reloc. */
9610 foff =
9611 calculate_offset (abfd, sec, i2_irelfn, isymbuf, symtab_hdr,
9612 &pic_ext_target);
9613 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_16BIT_S1
9614 || foff >= CONSERVATIVE_16BIT_S1)
9615 return FALSE;
9616
9617 /* Get the all corresponding instructions. */
9618 if (first_size == 4)
9619 {
9620 insn = bfd_getb32 (contents + laddr);
9621 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
9622 }
9623 else
9624 {
9625 insn16 = bfd_getb16 (contents + laddr);
9626 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
9627 }
9628
9629 if (re_insn16 && foff >= -(ACCURATE_8BIT_S1 - first_size)
9630 && foff < ACCURATE_8BIT_S1 - first_size)
9631 {
9632 if (first_size == 4)
9633 {
9634 /* Don't convert it to 16-bit now, keep this as relaxable for
9635 ``label reloc; INSN16''. */
9636
9637 /* Save comp_insn32 to buffer. */
9638 bfd_putb32 (re_insn, contents + irel->r_offset);
9639 *insn_len = 4;
9640 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
9641 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
9642 cond_reloc = R_NDS32_INSN16;
9643 }
9644 else
9645 {
9646 bfd_putb16 (re_insn16, contents + irel->r_offset);
9647 *insn_len = 2;
9648 reloc = R_NDS32_9_PCREL_RELA;
9649 cond_reloc = R_NDS32_NONE;
9650 }
9651 }
9652 else if (N32_OP6 (re_insn) == N32_OP6_BR1
9653 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
9654 && foff < ACCURATE_14BIT_S1 - first_size))
9655 {
9656 /* beqs label ; 15_PCREL */
9657 bfd_putb32 (re_insn, contents + irel->r_offset);
9658 *insn_len = 4;
9659 reloc = R_NDS32_15_PCREL_RELA;
9660 cond_reloc = R_NDS32_NONE;
9661 }
9662 else if (N32_OP6 (re_insn) == N32_OP6_BR2
9663 && foff >= -CONSERVATIVE_16BIT_S1
9664 && foff < CONSERVATIVE_16BIT_S1)
9665 {
9666 /* beqz label ; 17_PCREL */
9667 bfd_putb32 (re_insn, contents + irel->r_offset);
9668 *insn_len = 4;
9669 reloc = R_NDS32_17_PCREL_RELA;
9670 cond_reloc = R_NDS32_NONE;
9671 }
9672 else
9673 return FALSE;
9674
9675 /* Set all relocations. */
9676 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info), reloc);
9677 irel->r_addend = i2_irelfn->r_addend;
9678
9679 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
9680 cond_reloc);
9681 cond_irelfn->r_addend = 0;
9682
9683 if ((seq_len ^ *insn_len ) & 0x2)
9684 {
9685 insn16 = NDS32_NOP16;
9686 bfd_putb16 (insn16, contents + irel->r_offset + 4);
9687 i2_irelfn->r_offset = 4;
9688 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
9689 R_NDS32_INSN16);
9690 i2_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9691 *insn_len += 2;
9692 }
9693 else
9694 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
9695 R_NDS32_NONE);
9696 return TRUE;
9697 }
9698
9699 /* Relax LONGJUMP3 relocation for nds32_elf_relax_section. */
9700
9701 static bfd_boolean
9702 nds32_elf_relax_longjump3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9703 Elf_Internal_Rela *internal_relocs, int *insn_len,
9704 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9705 Elf_Internal_Shdr *symtab_hdr)
9706 {
9707 /* There are 5 variations for LONGJUMP3
9708 case 1: 2-4-4-2; 1st insn convertible, 16-bit on,
9709 optimize off or optimize for space
9710 bnes38 rt, ra, $1 ; LONGJUMP3
9711 sethi ta, hi20(symbol) ; HI20
9712 ori ta, ta, lo12(symbol) ; LO12S0
9713 jr5 ta ;
9714 $1: ;
9715
9716 case 2: 2-4-4-2; 1st insn convertible, 16-bit on, optimize for speed
9717 bnes38 rt, ra, $1 ; LONGJUMP3
9718 sethi ta, hi20(symbol) ; HI20
9719 ori ta, ta, lo12(symbol) ; LO12S0
9720 jr5 ta ;
9721 $1: ; LABEL
9722
9723 case 3: 4-4-4-2; 1st insn not convertible, 16-bit on,
9724 optimize off or optimize for space
9725 bne rt, ra, $1 ; LONGJUMP3
9726 sethi ta, hi20(symbol) ; HI20
9727 ori ta, ta, lo12(symbol) ; LO12S0
9728 jr5 ta ;
9729 $1: ;
9730
9731 case 4: 4-4-4-4; 1st insn don't care, 16-bit off, optimize don't care
9732 16-bit off if no INSN16
9733 bne rt, ra, $1 ; LONGJUMP3
9734 sethi ta, hi20(symbol) ; HI20
9735 ori ta, ta, lo12(symbol) ; LO12S0
9736 jr ta ;
9737 $1: ;
9738
9739 case 5: 4-4-4-4; 1st insn not convertible, 16-bit on, optimize for speed
9740 16-bit off if no INSN16
9741 bne rt, ra, $1 ; LONGJUMP3
9742 sethi ta, hi20(symbol) ; HI20
9743 ori ta, ta, lo12(symbol) ; LO12S0
9744 jr ta ;
9745 $1: ; LABEL */
9746
9747 /* Get the reloc for the address from which the register is
9748 being loaded. This reloc will tell us which function is
9749 actually being called. */
9750 enum elf_nds32_reloc_type checked_types[] =
9751 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
9752
9753 int reloc_off = 0, cond_removed = 0, convertible;
9754 bfd_vma laddr;
9755 int seq_len; /* Original length of instruction sequence. */
9756 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9757 int pic_ext_target = 0, first_size;
9758 unsigned int i;
9759 bfd_signed_vma foff;
9760 uint32_t insn, re_insn = 0;
9761 uint16_t insn16, re_insn16 = 0;
9762 unsigned long reloc, cond_reloc;
9763
9764 irelend = internal_relocs + sec->reloc_count;
9765 seq_len = GET_SEQ_LEN (irel->r_addend);
9766 laddr = irel->r_offset;
9767 *insn_len = seq_len;
9768
9769 convertible = IS_1ST_CONVERT (irel->r_addend);
9770
9771 if (convertible)
9772 first_size = 2;
9773 else
9774 first_size = 4;
9775
9776 /* Get all needed relocations. */
9777 hi_irelfn =
9778 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9779 R_NDS32_HI20_RELA, laddr + first_size);
9780 lo_irelfn =
9781 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9782 R_NDS32_LO12S0_ORI_RELA,
9783 laddr + first_size + 4);
9784
9785 for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
9786 {
9787 cond_irelfn =
9788 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9789 checked_types[i], laddr);
9790 if (cond_irelfn != irelend)
9791 break;
9792 }
9793
9794 if (hi_irelfn == irelend || lo_irelfn == irelend || cond_irelfn == irelend)
9795 {
9796 (*_bfd_error_handler)
9797 ("%B: warning: R_NDS32_LONGJUMP3 points to unrecognized"
9798 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9799 return FALSE;
9800 }
9801
9802 /* Get the value of the symbol referred to by the reloc. */
9803 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9804 &pic_ext_target);
9805
9806 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9807 || foff >= CONSERVATIVE_24BIT_S1)
9808 return FALSE;
9809
9810 /* Get the all corresponding instructions. */
9811 if (first_size == 4)
9812 {
9813 insn = bfd_getb32 (contents + laddr);
9814 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
9815 }
9816 else
9817 {
9818 insn16 = bfd_getb16 (contents + laddr);
9819 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
9820 }
9821
9822 /* For simplicity of coding, we are going to modify the section
9823 contents, the section relocs, and the BFD symbol table. We
9824 must tell the rest of the code not to free up this
9825 information. It would be possible to instead create a table
9826 of changes which have to be made, as is done in coff-mips.c;
9827 that would be more work, but would require less memory when
9828 the linker is run. */
9829
9830 if (re_insn16 && foff >= -ACCURATE_8BIT_S1 - first_size
9831 && foff < ACCURATE_8BIT_S1 - first_size)
9832 {
9833 if (!(seq_len & 0x2))
9834 {
9835 /* Don't convert it to 16-bit now, keep this as relaxable
9836 for ``label reloc; INSN1a''6. */
9837 /* Save comp_insn32 to buffer. */
9838 bfd_putb32 (re_insn, contents + irel->r_offset);
9839 *insn_len = 4;
9840 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
9841 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
9842 cond_reloc = R_NDS32_INSN16;
9843 }
9844 else
9845 {
9846 /* Not optimize for speed; convert sequence to 16-bit. */
9847 /* Save comp_insn16 to buffer. */
9848 bfd_putb16 (re_insn16, contents + irel->r_offset);
9849 *insn_len = 2;
9850 reloc = R_NDS32_9_PCREL_RELA;
9851 cond_reloc = R_NDS32_NONE;
9852 }
9853 cond_removed = 1;
9854 }
9855 else if (N32_OP6 (re_insn) == N32_OP6_BR1
9856 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
9857 && foff < ACCURATE_14BIT_S1 - first_size))
9858 {
9859 /* beqs label ; 15_PCREL */
9860 bfd_putb32 (re_insn, contents + irel->r_offset);
9861 *insn_len = 4;
9862 reloc = R_NDS32_15_PCREL_RELA;
9863 cond_reloc = R_NDS32_NONE;
9864 cond_removed = 1;
9865 }
9866 else if (N32_OP6 (re_insn) == N32_OP6_BR2
9867 && foff >= -CONSERVATIVE_16BIT_S1
9868 && foff < CONSERVATIVE_16BIT_S1)
9869 {
9870 /* beqz label ; 17_PCREL */
9871 bfd_putb32 (re_insn, contents + irel->r_offset);
9872 *insn_len = 4;
9873 reloc = R_NDS32_17_PCREL_RELA;
9874 cond_reloc = R_NDS32_NONE;
9875 cond_removed = 1;
9876 }
9877 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
9878 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
9879 {
9880 /* Relax to one of the following 3 variations
9881
9882 case 2-4; 1st insn convertible, 16-bit on, optimize off or optimize
9883 for space
9884 bnes38 rt, $1 ; LONGJUMP2
9885 j label ; 25_PCREL
9886 $1
9887
9888 case 4-4; 1st insn not convertible, others don't care
9889 bne rt, ra, $1 ; LONGJUMP2
9890 j label ; 25_PCREL
9891 $1
9892
9893 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
9894 bne rt, ra, $1 ; LONGJUMP2
9895 j label ; 25_PCREL
9896 $1 */
9897
9898 /* Offset for first instruction. */
9899
9900 /* Use j label as second instruction. */
9901 *insn_len = 4 + first_size;
9902 insn = INSN_J;
9903 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9904 reloc = R_NDS32_LONGJUMP2;
9905 cond_reloc = R_NDS32_25_PLTREL;
9906 }
9907 else
9908 return FALSE;
9909
9910 if (cond_removed == 1)
9911 {
9912 /* Set all relocations. */
9913 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
9914 irel->r_addend = hi_irelfn->r_addend;
9915
9916 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
9917 cond_reloc);
9918 cond_irelfn->r_addend = 0;
9919 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9920 R_NDS32_NONE);
9921 }
9922 else
9923 {
9924 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
9925 irel->r_addend = irel->r_addend;
9926 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9927 cond_reloc);
9928 }
9929
9930 if ((seq_len ^ *insn_len ) & 0x2)
9931 {
9932 insn16 = NDS32_NOP16;
9933 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9934 lo_irelfn->r_offset = *insn_len;
9935 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9936 R_NDS32_INSN16);
9937 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9938 *insn_len += 2;
9939 }
9940 else
9941 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9942 R_NDS32_NONE);
9943 return TRUE;
9944 }
9945
9946 /* Relax LONGCALL4 relocation for nds32_elf_relax_section. */
9947
9948 static bfd_boolean
9949 nds32_elf_relax_longcall4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9950 Elf_Internal_Rela *internal_relocs, int *insn_len,
9951 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9952 Elf_Internal_Shdr *symtab_hdr)
9953 {
9954 /* The pattern for LONGCALL4. Support for function cse.
9955 sethi ta, hi20(symbol) ; LONGCALL4/HI20
9956 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
9957 jral ta ; PTR_RES/EMPTY/INSN16 */
9958
9959 bfd_vma laddr;
9960 uint32_t insn;
9961 Elf_Internal_Rela *hi_irel, *ptr_irel, *insn_irel, *em_irel, *call_irel;
9962 Elf_Internal_Rela *irelend;
9963 int pic_ext_target = 0;
9964 bfd_signed_vma foff;
9965
9966 irelend = internal_relocs + sec->reloc_count;
9967 laddr = irel->r_offset;
9968
9969 /* Get the reloc for the address from which the register is
9970 being loaded. This reloc will tell us which function is
9971 actually being called. */
9972 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9973 R_NDS32_HI20_RELA, laddr);
9974
9975 if (hi_irel == irelend)
9976 {
9977 (*_bfd_error_handler)
9978 ("%B: warning: R_NDS32_LONGCALL4 points to unrecognized"
9979 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9980 return FALSE;
9981 }
9982
9983 /* Get the value of the symbol referred to by the reloc. */
9984 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr,
9985 &pic_ext_target);
9986
9987 /* This condition only happened when symbol is undefined. */
9988 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9989 || foff >= CONSERVATIVE_24BIT_S1)
9990 return FALSE;
9991
9992 /* Relax to: jal symbol; 25_PCREL */
9993 /* For simplicity of coding, we are going to modify the section
9994 contents, the section relocs, and the BFD symbol table. We
9995 must tell the rest of the code not to free up this
9996 information. It would be possible to instead create a table
9997 of changes which have to be made, as is done in coff-mips.c;
9998 that would be more work, but would require less memory when
9999 the linker is run. */
10000
10001 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10002 R_NDS32_PTR_RESOLVED, irel->r_addend);
10003 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10004 R_NDS32_EMPTY, irel->r_addend);
10005
10006 if (ptr_irel == irelend || em_irel == irelend)
10007 {
10008 (*_bfd_error_handler)
10009 ("%B: warning: R_NDS32_LONGCALL4 points to unrecognized"
10010 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10011 return FALSE;
10012 }
10013 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10014 insn = bfd_getb32 (contents + irel->r_addend);
10015 if (insn & 0x80000000)
10016 return FALSE;
10017
10018 /* Replace the long call with a jal. */
10019 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10020 R_NDS32_25_PCREL_RELA);
10021 ptr_irel->r_addend = 1;
10022
10023 /* We don't resolve this here but resolve it in relocate_section. */
10024 insn = INSN_JAL;
10025 bfd_putb32 (insn, contents + em_irel->r_offset);
10026
10027 irel->r_info =
10028 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10029
10030 /* If there is function cse, HI20 can not remove now. */
10031 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10032 R_NDS32_LONGCALL4, laddr);
10033 if (call_irel == irelend)
10034 {
10035 *insn_len = 0;
10036 hi_irel->r_info =
10037 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10038 }
10039
10040 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10041 R_NDS32_INSN16, irel->r_addend);
10042 if (insn_irel != irelend)
10043 insn_irel->r_info =
10044 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10045
10046 return TRUE;
10047 }
10048
10049 /* Relax LONGCALL5 relocation for nds32_elf_relax_section. */
10050
10051 static bfd_boolean
10052 nds32_elf_relax_longcall5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10053 Elf_Internal_Rela *internal_relocs, int *insn_len,
10054 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10055 Elf_Internal_Shdr *symtab_hdr)
10056 {
10057 /* The pattern for LONGCALL5.
10058 bltz rt, .L1 ; LONGCALL5/17_PCREL
10059 jal symbol ; 25_PCREL
10060 .L1: */
10061
10062 bfd_vma laddr;
10063 uint32_t insn;
10064 Elf_Internal_Rela *cond_irel, *irelend;
10065 int pic_ext_target = 0;
10066 bfd_signed_vma foff;
10067
10068 irelend = internal_relocs + sec->reloc_count;
10069 laddr = irel->r_offset;
10070 insn = bfd_getb32 (contents + laddr);
10071
10072 /* Get the reloc for the address from which the register is
10073 being loaded. This reloc will tell us which function is
10074 actually being called. */
10075 cond_irel =
10076 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10077 R_NDS32_25_PCREL_RELA, irel->r_addend);
10078 if (cond_irel == irelend)
10079 {
10080 (*_bfd_error_handler)
10081 ("%B: warning: R_NDS32_LONGCALL5 points to unrecognized"
10082 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10083 return FALSE;
10084 }
10085
10086 /* Get the value of the symbol referred to by the reloc. */
10087 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10088 &pic_ext_target);
10089
10090 if (foff == 0 || foff < -CONSERVATIVE_16BIT_S1
10091 || foff >= CONSERVATIVE_16BIT_S1)
10092 return FALSE;
10093
10094 /* Relax to bgezal rt, label ; 17_PCREL
10095 or bltzal rt, label ; 17_PCREL */
10096
10097 /* Convert to complimentary conditional call. */
10098 insn = CONVERT_CONDITION_CALL (insn);
10099
10100 /* For simplicity of coding, we are going to modify the section
10101 contents, the section relocs, and the BFD symbol table. We
10102 must tell the rest of the code not to free up this
10103 information. It would be possible to instead create a table
10104 of changes which have to be made, as is done in coff-mips.c;
10105 that would be more work, but would require less memory when
10106 the linker is run. */
10107
10108 /* Modify relocation and contents. */
10109 cond_irel->r_info =
10110 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_17_PCREL_RELA);
10111
10112 /* Replace the long call with a bgezal. */
10113 bfd_putb32 (insn, contents + cond_irel->r_offset);
10114 *insn_len = 0;
10115
10116 /* Clean unnessary relocations. */
10117 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10118
10119 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10120 R_NDS32_17_PCREL_RELA, laddr);
10121 cond_irel->r_info =
10122 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10123
10124 return TRUE;
10125 }
10126
10127 /* Relax LONGCALL6 relocation for nds32_elf_relax_section. */
10128
10129 static bfd_boolean
10130 nds32_elf_relax_longcall6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10131 Elf_Internal_Rela *internal_relocs, int *insn_len,
10132 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10133 Elf_Internal_Shdr *symtab_hdr)
10134 {
10135 /* The pattern for LONGCALL6.
10136 bltz rt, .L1 ; LONGCALL6/17_PCREL
10137 sethi ta, hi20(symbol) ; HI20/PTR
10138 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10139 jral ta ; PTR_RES/EMPTY/INSN16
10140 .L1 */
10141
10142 bfd_vma laddr;
10143 uint32_t insn;
10144 Elf_Internal_Rela *em_irel, *cond_irel, *irelend;
10145 int pic_ext_target = 0;
10146 bfd_signed_vma foff;
10147
10148 irelend = internal_relocs + sec->reloc_count;
10149 laddr = irel->r_offset;
10150
10151 /* Get the reloc for the address from which the register is
10152 being loaded. This reloc will tell us which function is
10153 actually being called. */
10154 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10155 R_NDS32_EMPTY, irel->r_addend);
10156
10157 if (em_irel == irelend)
10158 {
10159 (*_bfd_error_handler)
10160 ("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
10161 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10162 return FALSE;
10163 }
10164
10165 /* Get the value of the symbol referred to by the reloc. */
10166 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr,
10167 &pic_ext_target);
10168
10169 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10170 || foff >= CONSERVATIVE_24BIT_S1)
10171 return FALSE;
10172
10173 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10174 insn = bfd_getb32 (contents + irel->r_addend);
10175 if (insn & 0x80000000)
10176 return FALSE;
10177
10178 insn = bfd_getb32 (contents + laddr);
10179 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10180 {
10181 /* Relax to bgezal rt, label ; 17_PCREL
10182 or bltzal rt, label ; 17_PCREL */
10183
10184 /* Convert to complimentary conditional call. */
10185 *insn_len = 0;
10186 insn = CONVERT_CONDITION_CALL (insn);
10187 bfd_putb32 (insn, contents + em_irel->r_offset);
10188
10189 em_irel->r_info =
10190 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_17_PCREL_RELA);
10191
10192 /* Set resolved relocation. */
10193 cond_irel =
10194 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10195 R_NDS32_PTR_RESOLVED, irel->r_addend);
10196 if (cond_irel == irelend)
10197 {
10198 (*_bfd_error_handler)
10199 ("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
10200 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10201 return FALSE;
10202 }
10203 cond_irel->r_addend = 1;
10204
10205 /* Clear relocations. */
10206
10207 irel->r_info =
10208 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10209
10210 cond_irel =
10211 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10212 R_NDS32_17_PCREL_RELA, laddr);
10213 if (cond_irel != irelend)
10214 cond_irel->r_info =
10215 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10216
10217 cond_irel =
10218 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10219 R_NDS32_INSN16, irel->r_addend);
10220 if (cond_irel != irelend)
10221 cond_irel->r_info =
10222 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10223
10224 }
10225 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10226 {
10227 /* Relax to the following instruction sequence
10228 bltz rt, .L1 ; LONGCALL2/17_PCREL
10229 jal symbol ; 25_PCREL/PTR_RES
10230 .L1 */
10231 *insn_len = 4;
10232 /* Convert instruction. */
10233 insn = INSN_JAL;
10234 bfd_putb32 (insn, contents + em_irel->r_offset);
10235
10236 /* Convert relocations. */
10237 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10238 R_NDS32_25_PCREL_RELA);
10239 irel->r_info =
10240 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL5);
10241
10242 /* Set resolved relocation. */
10243 cond_irel =
10244 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10245 R_NDS32_PTR_RESOLVED, irel->r_addend);
10246 if (cond_irel == irelend)
10247 {
10248 (*_bfd_error_handler)
10249 ("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
10250 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10251 return FALSE;
10252 }
10253 cond_irel->r_addend = 1;
10254
10255 cond_irel =
10256 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10257 R_NDS32_INSN16, irel->r_addend);
10258 if (cond_irel != irelend)
10259 cond_irel->r_info =
10260 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10261 }
10262 return TRUE;
10263 }
10264
10265 /* Relax LONGJUMP4 relocation for nds32_elf_relax_section. */
10266
10267 static bfd_boolean
10268 nds32_elf_relax_longjump4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10269 Elf_Internal_Rela *internal_relocs, int *insn_len,
10270 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10271 Elf_Internal_Shdr *symtab_hdr)
10272 {
10273 /* The pattern for LONGJUMP4.
10274 sethi ta, hi20(symbol) ; LONGJUMP4/HI20
10275 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10276 jr ta ; PTR_RES/INSN16/EMPTY */
10277
10278 bfd_vma laddr;
10279 int seq_len; /* Original length of instruction sequence. */
10280 uint32_t insn;
10281 Elf_Internal_Rela *hi_irel, *ptr_irel, *em_irel, *call_irel, *irelend;
10282 int pic_ext_target = 0;
10283 bfd_signed_vma foff;
10284
10285 irelend = internal_relocs + sec->reloc_count;
10286 seq_len = GET_SEQ_LEN (irel->r_addend);
10287 laddr = irel->r_offset;
10288 *insn_len = seq_len;
10289
10290 /* Get the reloc for the address from which the register is
10291 being loaded. This reloc will tell us which function is
10292 actually being called. */
10293
10294 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10295 R_NDS32_HI20_RELA, laddr);
10296
10297 if (hi_irel == irelend)
10298 {
10299 (*_bfd_error_handler)
10300 ("%B: warning: R_NDS32_LONGJUMP4 points to unrecognized"
10301 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10302 return FALSE;
10303 }
10304
10305 /* Get the value of the symbol referred to by the reloc. */
10306 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr,
10307 &pic_ext_target);
10308
10309 if (pic_ext_target || foff == 0 || foff >= CONSERVATIVE_24BIT_S1
10310 || foff < -CONSERVATIVE_24BIT_S1)
10311 return FALSE;
10312
10313 /* Convert it to "j label", it may be converted to j8 in the final
10314 pass of relaxation. Therefore, we do not consider this currently. */
10315 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10316 R_NDS32_PTR_RESOLVED, irel->r_addend);
10317 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10318 R_NDS32_EMPTY, irel->r_addend);
10319
10320 if (ptr_irel == irelend || em_irel == irelend)
10321 {
10322 (*_bfd_error_handler)
10323 ("%B: warning: R_NDS32_LONGJUMP4 points to unrecognized"
10324 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10325 return FALSE;
10326 }
10327
10328 em_irel->r_info =
10329 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_25_PCREL_RELA);
10330 ptr_irel->r_addend = 1;
10331
10332 /* Write instruction. */
10333 insn = INSN_J;
10334 bfd_putb32 (insn, contents + em_irel->r_offset);
10335
10336 /* Clear relocations. */
10337 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10338
10339 /* If there is function cse, HI20 can not remove now. */
10340 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10341 R_NDS32_LONGJUMP4, laddr);
10342 if (call_irel == irelend)
10343 {
10344 *insn_len = 0;
10345 hi_irel->r_info =
10346 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10347 }
10348
10349 return TRUE;
10350 }
10351
10352 /* Relax LONGJUMP5 relocation for nds32_elf_relax_section. */
10353
10354 static bfd_boolean
10355 nds32_elf_relax_longjump5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10356 Elf_Internal_Rela *internal_relocs, int *insn_len,
10357 int *seq_len, bfd_byte *contents,
10358 Elf_Internal_Sym *isymbuf,
10359 Elf_Internal_Shdr *symtab_hdr)
10360 {
10361 /* There are 2 variations for LONGJUMP5
10362 case 2-4; 1st insn convertible, 16-bit on.
10363 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
10364 j label ; 25_PCREL/INSN16
10365 $1:
10366
10367 case 4-4; 1st insn not convertible
10368 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
10369 j label ; 25_PCREL/INSN16
10370 .L1: */
10371
10372 bfd_vma laddr;
10373 Elf_Internal_Rela *cond_irel, *irelend;
10374 int pic_ext_target = 0;
10375 unsigned int i;
10376 bfd_signed_vma foff;
10377 uint32_t insn, re_insn = 0;
10378 uint16_t insn16, re_insn16 = 0;
10379 unsigned long reloc;
10380
10381 enum elf_nds32_reloc_type checked_types[] =
10382 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10383 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10384
10385 irelend = internal_relocs + sec->reloc_count;
10386 laddr = irel->r_offset;
10387
10388 /* Get the reloc for the address from which the register is
10389 being loaded. This reloc will tell us which function is
10390 actually being called. */
10391
10392 cond_irel =
10393 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10394 R_NDS32_25_PCREL_RELA, irel->r_addend);
10395 if (cond_irel == irelend)
10396 {
10397 (*_bfd_error_handler)
10398 ("%B: warning: R_NDS32_LONGJUMP5 points to unrecognized"
10399 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10400 return FALSE;
10401 }
10402
10403 /* Get the value of the symbol referred to by the reloc. */
10404 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10405 &pic_ext_target);
10406
10407 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_16BIT_S1
10408 || foff >= CONSERVATIVE_16BIT_S1)
10409 return FALSE;
10410
10411 /* Get the all corresponding instructions. */
10412 insn = bfd_getb32 (contents + laddr);
10413 /* Check instruction size. */
10414 if (insn & 0x80000000)
10415 {
10416 *seq_len = 0;
10417 insn16 = insn >> 16;
10418 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10419 }
10420 else
10421 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10422
10423 if (N32_OP6 (re_insn) == N32_OP6_BR1
10424 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
10425 {
10426 /* beqs label ; 15_PCREL. */
10427 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10428 reloc = R_NDS32_15_PCREL_RELA;
10429 }
10430 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10431 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10432 {
10433 /* beqz label ; 17_PCREL. */
10434 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10435 reloc = R_NDS32_17_PCREL_RELA;
10436 }
10437 else if ( N32_OP6 (re_insn) == N32_OP6_BR3
10438 && foff >= -CONSERVATIVE_8BIT_S1 && foff < CONSERVATIVE_8BIT_S1)
10439 {
10440 /* beqc label ; 9_PCREL. */
10441 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10442 reloc = R_NDS32_WORD_9_PCREL_RELA;
10443 }
10444 else
10445 return FALSE;
10446
10447 /* Set all relocations. */
10448 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), reloc);
10449
10450 /* Clean relocations. */
10451 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10452 for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
10453 {
10454 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10455 checked_types[i], laddr);
10456 if (cond_irel != irelend)
10457 {
10458 if (*seq_len == 0
10459 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
10460 {
10461 /* If the branch instruction is 2 byte, it cannot remove
10462 directly. Only convert it to nop16 and remove it after
10463 checking alignment issue. */
10464 insn16 = NDS32_NOP16;
10465 bfd_putb16 (insn16, contents + laddr);
10466 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10467 }
10468 else
10469 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10470 R_NDS32_NONE);
10471 }
10472 }
10473 *insn_len = 0;
10474
10475 return TRUE;
10476 }
10477
10478 /* Relax LONGJUMP6 relocation for nds32_elf_relax_section. */
10479
10480 static bfd_boolean
10481 nds32_elf_relax_longjump6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10482 Elf_Internal_Rela *internal_relocs, int *insn_len,
10483 int *seq_len, bfd_byte *contents,
10484 Elf_Internal_Sym *isymbuf,
10485 Elf_Internal_Shdr *symtab_hdr)
10486 {
10487 /* There are 5 variations for LONGJUMP6
10488 case : 2-4-4-4; 1st insn convertible, 16-bit on.
10489 bnes38 rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
10490 sethi ta, hi20(symbol) ; HI20/PTR
10491 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10492 jr ta ; PTR_RES/INSN16/EMPTY
10493 .L1:
10494
10495 case : 4-4-4-4; 1st insn not convertible, 16-bit on.
10496 bne rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
10497 sethi ta, hi20(symbol) ; HI20/PTR
10498 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10499 jr ta ; PTR_RES/INSN16/EMPTY
10500 .L1: */
10501
10502 enum elf_nds32_reloc_type checked_types[] =
10503 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10504 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10505
10506 int reloc_off = 0, cond_removed = 0;
10507 bfd_vma laddr;
10508 Elf_Internal_Rela *cond_irel, *em_irel, *irelend, *insn_irel;
10509 int pic_ext_target = 0;
10510 unsigned int i;
10511 bfd_signed_vma foff;
10512 uint32_t insn, re_insn = 0;
10513 uint16_t insn16, re_insn16 = 0;
10514 unsigned long reloc;
10515
10516 irelend = internal_relocs + sec->reloc_count;
10517 laddr = irel->r_offset;
10518
10519 /* Get the reloc for the address from which the register is
10520 being loaded. This reloc will tell us which function is
10521 actually being called. */
10522 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10523 R_NDS32_EMPTY, irel->r_addend);
10524
10525 if (em_irel == irelend)
10526 {
10527 (*_bfd_error_handler)
10528 ("%B: warning: R_NDS32_LONGJUMP6 points to unrecognized"
10529 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10530 return FALSE;
10531 }
10532
10533 /* Get the value of the symbol referred to by the reloc. */
10534 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr,
10535 &pic_ext_target);
10536
10537 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10538 || foff >= CONSERVATIVE_24BIT_S1)
10539 return FALSE;
10540
10541 insn = bfd_getb32 (contents + laddr);
10542 /* Check instruction size. */
10543 if (insn & 0x80000000)
10544 {
10545 *seq_len = 0;
10546 insn16 = insn >> 16;
10547 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10548 }
10549 else
10550 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10551
10552 /* For simplicity of coding, we are going to modify the section
10553 contents, the section relocs, and the BFD symbol table. We
10554 must tell the rest of the code not to free up this
10555 information. It would be possible to instead create a table
10556 of changes which have to be made, as is done in coff-mips.c;
10557 that would be more work, but would require less memory when
10558 the linker is run. */
10559
10560 if (N32_OP6 (re_insn) == N32_OP6_BR1
10561 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
10562 {
10563 /* beqs label ; 15_PCREL */
10564 bfd_putb32 (re_insn, contents + em_irel->r_offset);
10565 reloc = R_NDS32_15_PCREL_RELA;
10566 cond_removed = 1;
10567 }
10568 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10569 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10570 {
10571 /* beqz label ; 17_PCREL */
10572 bfd_putb32 (re_insn, contents + em_irel->r_offset);
10573 reloc = R_NDS32_17_PCREL_RELA;
10574 cond_removed = 1;
10575 }
10576 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
10577 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
10578 {
10579 /* Relax to one of the following 2 variations
10580
10581 case 2-4; 1st insn convertible, 16-bit on.
10582 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
10583 j label ; 25_PCREL/INSN16
10584 $1:
10585
10586 case 4-4; 1st insn not convertible
10587 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
10588 j label ; 25_PCREL/INSN16
10589 .L1: */
10590
10591 /* Use j label as second instruction. */
10592 insn = INSN_J;
10593 reloc = R_NDS32_25_PCREL_RELA;
10594 bfd_putb32 (insn, contents + em_irel->r_offset);
10595 }
10596 else
10597 return FALSE;
10598
10599 /* Set all relocations. */
10600 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), reloc);
10601
10602 cond_irel =
10603 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10604 R_NDS32_PTR_RESOLVED, em_irel->r_offset);
10605 cond_irel->r_addend = 1;
10606
10607 /* Use INSN16 of first branch instruction to distinguish if keeping
10608 INSN16 of final instruction or not. */
10609 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10610 R_NDS32_INSN16, irel->r_offset);
10611 if (insn_irel == irelend)
10612 {
10613 /* Clean the final INSN16. */
10614 insn_irel =
10615 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10616 R_NDS32_INSN16, em_irel->r_offset);
10617 insn_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10618 R_NDS32_NONE);
10619 }
10620
10621 if (cond_removed == 1)
10622 {
10623 *insn_len = 0;
10624
10625 /* Clear relocations. */
10626 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10627
10628 for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
10629 {
10630 cond_irel =
10631 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10632 checked_types[i], laddr);
10633 if (cond_irel != irelend)
10634 {
10635 if (*seq_len == 0
10636 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
10637 {
10638 /* If the branch instruction is 2 byte, it cannot remove
10639 directly. Only convert it to nop16 and remove it after
10640 checking alignment issue. */
10641 insn16 = NDS32_NOP16;
10642 bfd_putb16 (insn16, contents + laddr);
10643 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10644 }
10645 else
10646 cond_irel->r_info =
10647 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10648 }
10649 }
10650 }
10651 else
10652 {
10653 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
10654 R_NDS32_LONGJUMP5);
10655 }
10656
10657 return TRUE;
10658 }
10659
10660 /* Relax LONGJUMP7 relocation for nds32_elf_relax_section. */
10661
10662 static bfd_boolean
10663 nds32_elf_relax_longjump7 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10664 Elf_Internal_Rela *internal_relocs, int *insn_len,
10665 int *seq_len, bfd_byte *contents,
10666 Elf_Internal_Sym *isymbuf,
10667 Elf_Internal_Shdr *symtab_hdr)
10668 {
10669 /* There are 2 variations for LONGJUMP5
10670 case 2-4; 1st insn convertible, 16-bit on.
10671 movi55 ta, imm11 ; LONGJUMP7/INSN16
10672 beq rt, ta, label ; 15_PCREL
10673
10674 case 4-4; 1st insn not convertible
10675 movi55 ta, imm11 ; LONGJUMP7/INSN16
10676 beq rt, ta, label ; 15_PCREL */
10677
10678 bfd_vma laddr;
10679 Elf_Internal_Rela *cond_irel, *irelend, *insn_irel;
10680 int pic_ext_target = 0;
10681 bfd_signed_vma foff;
10682 uint32_t insn, re_insn = 0;
10683 uint16_t insn16;
10684 uint32_t imm11;
10685
10686 irelend = internal_relocs + sec->reloc_count;
10687 laddr = irel->r_offset;
10688
10689 /* Get the reloc for the address from which the register is
10690 being loaded. This reloc will tell us which function is
10691 actually being called. */
10692
10693 cond_irel =
10694 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10695 R_NDS32_15_PCREL_RELA, irel->r_addend);
10696 if (cond_irel == irelend)
10697 {
10698 (*_bfd_error_handler)
10699 ("%B: warning: R_NDS32_LONGJUMP7 points to unrecognized"
10700 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10701 return FALSE;
10702 }
10703
10704 /* Get the value of the symbol referred to by the reloc. */
10705 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10706 &pic_ext_target);
10707
10708 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_8BIT_S1
10709 || foff >= CONSERVATIVE_8BIT_S1)
10710 return FALSE;
10711
10712 /* Get the first instruction for its size. */
10713 insn = bfd_getb32 (contents + laddr);
10714 if (insn & 0x80000000)
10715 {
10716 *seq_len = 0;
10717 /* Get the immediate from movi55. */
10718 imm11 = N16_IMM5S (insn >> 16);
10719 }
10720 else
10721 {
10722 /* Get the immediate from movi. */
10723 imm11 = N32_IMM20S (insn);
10724 }
10725
10726 /* Get the branch instruction. */
10727 insn = bfd_getb32 (contents + irel->r_addend);
10728 /* Convert instruction to BR3. */
10729 if ((insn >> 14) & 0x1)
10730 re_insn = N32_BR3 (BNEC, N32_RT5 (insn), imm11, 0);
10731 else
10732 re_insn = N32_BR3 (BEQC, N32_RT5 (insn), imm11, 0);
10733
10734 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10735
10736 /* Set all relocations. */
10737 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10738 R_NDS32_WORD_9_PCREL_RELA);
10739
10740 /* Clean relocations. */
10741 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10742 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10743 R_NDS32_INSN16, irel->r_offset);
10744 if (insn_irel != irelend)
10745 {
10746 if (*seq_len == 0)
10747 {
10748 /* If the first insntruction is 16bit, convert it to nop16. */
10749 insn16 = NDS32_NOP16;
10750 bfd_putb16 (insn16, contents + laddr);
10751 insn_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10752 }
10753 else
10754 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10755 R_NDS32_NONE);
10756 }
10757 *insn_len = 0;
10758
10759 return TRUE;
10760 }
10761
10762 #define GET_LOADSTORE_RANGE(addend) (((addend) >> 8) & 0x3f)
10763
10764 /* Relax LOADSTORE relocation for nds32_elf_relax_section. */
10765
10766 static bfd_boolean
10767 nds32_elf_relax_loadstore (struct bfd_link_info *link_info, bfd *abfd,
10768 asection *sec, Elf_Internal_Rela *irel,
10769 Elf_Internal_Rela *internal_relocs, int *insn_len,
10770 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10771 Elf_Internal_Shdr *symtab_hdr, int load_store_relax)
10772 {
10773 int eliminate_sethi = 0, range_type, i;
10774 bfd_vma local_sda, laddr;
10775 int seq_len; /* Original length of instruction sequence. */
10776 uint32_t insn;
10777 Elf_Internal_Rela *hi_irelfn = NULL, *irelend;
10778 bfd_vma access_addr = 0;
10779 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
10780 enum elf_nds32_reloc_type checked_types[] =
10781 { R_NDS32_HI20_RELA, R_NDS32_GOT_HI20,
10782 R_NDS32_GOTPC_HI20, R_NDS32_GOTOFF_HI20,
10783 R_NDS32_PLTREL_HI20, R_NDS32_PLT_GOTREL_HI20,
10784 R_NDS32_TLS_LE_HI20
10785 };
10786
10787 irelend = internal_relocs + sec->reloc_count;
10788 seq_len = GET_SEQ_LEN (irel->r_addend);
10789 laddr = irel->r_offset;
10790 *insn_len = seq_len;
10791
10792 /* Get the high part relocation. */
10793 for (i = 0; (unsigned) i < sizeof (checked_types); i++)
10794 {
10795 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10796 checked_types[i], laddr);
10797 if (hi_irelfn != irelend)
10798 break;
10799 }
10800
10801 if (hi_irelfn == irelend)
10802 {
10803 (*_bfd_error_handler)
10804 ("%B: warning: R_NDS32_LOADSTORE points to unrecognized"
10805 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10806 return FALSE;
10807 }
10808
10809 range_type = GET_LOADSTORE_RANGE (irel->r_addend);
10810 nds32_elf_final_sda_base (sec->output_section->owner,
10811 link_info, &local_sda, FALSE);
10812
10813 switch (ELF32_R_TYPE (hi_irelfn->r_info))
10814 {
10815 case R_NDS32_HI20_RELA:
10816 insn = bfd_getb32 (contents + laddr);
10817 access_addr =
10818 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10819
10820 if (range_type == NDS32_LOADSTORE_IMM)
10821 {
10822 struct elf_link_hash_entry *h = NULL;
10823 int indx;
10824
10825 if (ELF32_R_SYM (hi_irelfn->r_info) >= symtab_hdr->sh_info)
10826 {
10827 indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
10828 h = elf_sym_hashes (abfd)[indx];
10829 }
10830
10831 if ((access_addr < CONSERVATIVE_20BIT)
10832 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
10833 {
10834 eliminate_sethi = 1;
10835 break;
10836 }
10837
10838 /* This is avoid to relax symbol address which is fixed
10839 relocations. Ex: _stack. */
10840 if (h && bfd_is_abs_section (h->root.u.def.section))
10841 return FALSE;
10842 }
10843
10844 if (!load_store_relax)
10845 return FALSE;
10846
10847 /* Case for set gp register. */
10848 if (N32_RT5 (insn) == REG_GP)
10849 break;
10850
10851 if (range_type == NDS32_LOADSTORE_FLOAT_S
10852 || range_type == NDS32_LOADSTORE_FLOAT_S)
10853 {
10854 range_l = sdata_range[0][0];
10855 range_h = sdata_range[0][1];
10856 }
10857 else
10858 {
10859 range_l = sdata_range[1][0];
10860 range_h = sdata_range[1][1];
10861 }
10862 break;
10863
10864 case R_NDS32_GOT_HI20:
10865 access_addr =
10866 calculate_got_memory_address (abfd, link_info, hi_irelfn, symtab_hdr);
10867
10868 /* If this symbol is not in .got, the return value will be -1.
10869 Since the gp value is set to SDA_BASE but not GLOBAL_OFFSET_TABLE,
10870 a negative offset is allowed. */
10871 if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10872 && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10873 eliminate_sethi = 1;
10874 break;
10875
10876 case R_NDS32_PLT_GOTREL_HI20:
10877 access_addr = calculate_plt_memory_address (abfd, link_info, isymbuf,
10878 hi_irelfn, symtab_hdr);
10879
10880 if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10881 && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10882 eliminate_sethi = 1;
10883 break;
10884
10885 case R_NDS32_GOTOFF_HI20:
10886 access_addr =
10887 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10888
10889 if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10890 && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10891 eliminate_sethi = 1;
10892 break;
10893
10894 case R_NDS32_GOTPC_HI20:
10895 /* The access_addr must consider r_addend of hi_irel. */
10896 access_addr = sec->output_section->vma + sec->output_offset
10897 + irel->r_offset + hi_irelfn->r_addend;
10898
10899 if ((bfd_signed_vma) (local_sda - access_addr) < CONSERVATIVE_20BIT
10900 && (bfd_signed_vma) (local_sda - access_addr) >= -CONSERVATIVE_20BIT)
10901 eliminate_sethi = 1;
10902 break;
10903
10904 case R_NDS32_TLS_LE_HI20:
10905 access_addr =
10906 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10907 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
10908 access_addr -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
10909 if ((range_type == NDS32_LOADSTORE_IMM)
10910 && (bfd_signed_vma) (access_addr) < CONSERVATIVE_20BIT
10911 && (bfd_signed_vma) (access_addr) >= -CONSERVATIVE_20BIT)
10912 eliminate_sethi = 1;
10913 break;
10914
10915 default:
10916 return FALSE;
10917 }
10918
10919 /* Delete sethi instruction. */
10920 if (eliminate_sethi == 1
10921 || (local_sda <= access_addr && (access_addr - local_sda) < range_h)
10922 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
10923 {
10924 hi_irelfn->r_info =
10925 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
10926 irel->r_info =
10927 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10928 *insn_len = 0;
10929 }
10930 return TRUE;
10931 }
10932
10933 /* Relax LO12 relocation for nds32_elf_relax_section. */
10934
10935 static void
10936 nds32_elf_relax_lo12 (struct bfd_link_info *link_info, bfd *abfd,
10937 asection *sec, Elf_Internal_Rela *irel,
10938 Elf_Internal_Rela *internal_relocs, bfd_byte *contents,
10939 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
10940 {
10941 uint32_t insn;
10942 bfd_vma local_sda, laddr;
10943 unsigned long reloc;
10944 bfd_vma access_addr;
10945 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
10946 Elf_Internal_Rela *irelfn = NULL, *irelend;
10947 struct elf_link_hash_entry *h = NULL;
10948 int indx;
10949
10950 /* For SDA base relative relaxation. */
10951 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
10952 &local_sda, FALSE);
10953
10954 irelend = internal_relocs + sec->reloc_count;
10955 laddr = irel->r_offset;
10956 insn = bfd_getb32 (contents + laddr);
10957
10958 if (!is_sda_access_insn (insn) && N32_OP6 (insn) != N32_OP6_ORI)
10959 return;
10960
10961 access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
10962
10963 if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
10964 {
10965 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
10966 h = elf_sym_hashes (abfd)[indx];
10967 }
10968
10969 if (N32_OP6 (insn) == N32_OP6_ORI && access_addr < CONSERVATIVE_20BIT
10970 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
10971 {
10972 reloc = R_NDS32_20_RELA;
10973 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10974 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
10975 bfd_putb32 (insn, contents + laddr);
10976 }
10977 /* This is avoid to relax symbol address which is fixed
10978 relocations. Ex: _stack. */
10979 else if (N32_OP6 (insn) == N32_OP6_ORI
10980 && h && bfd_is_abs_section (h->root.u.def.section))
10981 return;
10982 else
10983 {
10984 range_l = sdata_range[1][0];
10985 range_h = sdata_range[1][1];
10986 switch (ELF32_R_TYPE (irel->r_info))
10987 {
10988 case R_NDS32_LO12S0_RELA:
10989 reloc = R_NDS32_SDA19S0_RELA;
10990 break;
10991 case R_NDS32_LO12S1_RELA:
10992 reloc = R_NDS32_SDA18S1_RELA;
10993 break;
10994 case R_NDS32_LO12S2_RELA:
10995 reloc = R_NDS32_SDA17S2_RELA;
10996 break;
10997 case R_NDS32_LO12S2_DP_RELA:
10998 range_l = sdata_range[0][0];
10999 range_h = sdata_range[0][1];
11000 reloc = R_NDS32_SDA12S2_DP_RELA;
11001 break;
11002 case R_NDS32_LO12S2_SP_RELA:
11003 range_l = sdata_range[0][0];
11004 range_h = sdata_range[0][1];
11005 reloc = R_NDS32_SDA12S2_SP_RELA;
11006 break;
11007 default:
11008 return;
11009 }
11010
11011 /* There are range_h and range_l because linker has to promise
11012 all sections move cross one page together. */
11013 if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11014 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11015 {
11016 if (N32_OP6 (insn) == N32_OP6_ORI && N32_RT5 (insn) == REG_GP)
11017 {
11018 /* Maybe we should add R_NDS32_INSN16 reloc type here
11019 or manually do some optimization. sethi can't be
11020 eliminated when updating $gp so the relative ori
11021 needs to be preserved. */
11022 return;
11023 }
11024 if (!turn_insn_to_sda_access (insn, ELF32_R_TYPE (irel->r_info),
11025 &insn))
11026 return;
11027 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11028 bfd_putb32 (insn, contents + laddr);
11029
11030 irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11031 R_NDS32_INSN16);
11032 /* SDA17 must keep INSN16 for converting fp_as_gp. */
11033 if (irelfn != irelend && reloc != R_NDS32_SDA17S2_RELA)
11034 irelfn->r_info =
11035 ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_NDS32_NONE);
11036
11037 }
11038 }
11039 return;
11040 }
11041
11042 /* Relax low part of PIC instruction pattern. */
11043
11044 static void
11045 nds32_elf_relax_piclo12 (struct bfd_link_info *link_info, bfd *abfd,
11046 asection *sec, Elf_Internal_Rela *irel,
11047 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11048 Elf_Internal_Shdr *symtab_hdr)
11049 {
11050 uint32_t insn;
11051 bfd_vma local_sda, laddr;
11052 bfd_signed_vma foff;
11053 unsigned long reloc;
11054
11055 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11056 &local_sda, FALSE);
11057 laddr = irel->r_offset;
11058 insn = bfd_getb32 (contents + laddr);
11059
11060 if (N32_OP6 (insn) != N32_OP6_ORI)
11061 return;
11062
11063 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12)
11064 {
11065 foff = calculate_got_memory_address (abfd, link_info, irel,
11066 symtab_hdr) - local_sda;
11067 reloc = R_NDS32_GOT20;
11068 }
11069 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12)
11070 {
11071 foff = calculate_plt_memory_address (abfd, link_info, isymbuf, irel,
11072 symtab_hdr) - local_sda;
11073 reloc = R_NDS32_PLT_GOTREL_LO20;
11074 }
11075 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12)
11076 {
11077 foff = calculate_memory_address (abfd, irel, isymbuf,
11078 symtab_hdr) - local_sda;
11079 reloc = R_NDS32_GOTOFF;
11080 }
11081 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12)
11082 {
11083 foff = local_sda - sec->output_section->vma + sec->output_offset
11084 + irel->r_offset + irel->r_addend;
11085 reloc = R_NDS32_GOTPC20;
11086 }
11087 else
11088 return;
11089
11090 if ((foff < CONSERVATIVE_20BIT) && (foff >= -CONSERVATIVE_20BIT))
11091 {
11092 /* Turn into MOVI. */
11093 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11094 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11095 bfd_putb32 (insn, contents + laddr);
11096 }
11097 }
11098
11099 /* Relax low part of LE TLS instruction pattern. */
11100
11101 static void
11102 nds32_elf_relax_letlslo12 (struct bfd_link_info *link_info, bfd *abfd,
11103 Elf_Internal_Rela *irel,
11104 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11105 Elf_Internal_Shdr *symtab_hdr)
11106 {
11107 uint32_t insn;
11108 bfd_vma laddr;
11109 bfd_signed_vma foff;
11110 unsigned long reloc;
11111
11112 laddr = irel->r_offset;
11113 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11114 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11115 foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11116 insn = bfd_getb32 (contents + laddr);
11117
11118 if ( (bfd_signed_vma) (foff) < CONSERVATIVE_20BIT
11119 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_20BIT)
11120 {
11121 /* Pattern sethi-ori transform to movi. */
11122 reloc = R_NDS32_TLS_LE_20;
11123 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11124 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11125 bfd_putb32 (insn, contents + laddr);
11126 }
11127 }
11128
11129 /* Relax LE TLS calculate address instruction pattern. */
11130
11131 static void
11132 nds32_elf_relax_letlsadd (struct bfd_link_info *link_info, bfd *abfd,
11133 asection *sec, Elf_Internal_Rela *irel,
11134 Elf_Internal_Rela *internal_relocs,
11135 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11136 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11137 {
11138 /* Local TLS non-pic
11139 sethi ta, hi20(symbol@tpoff) ; TLS_LE_HI20
11140 ori ta, ta, lo12(symbol@tpoff) ; TLS_LE_LO12
11141 add ra, ta, tp ; TLS_LE_ADD */
11142
11143 uint32_t insn;
11144 bfd_vma laddr;
11145 bfd_signed_vma foff;
11146 Elf_Internal_Rela *i1_irelfn, *irelend;
11147
11148 irelend = internal_relocs + sec->reloc_count;
11149 laddr = irel->r_offset;
11150 insn = bfd_getb32 (contents + laddr);
11151 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11152 R_NDS32_PTR_RESOLVED);
11153 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11154 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11155 foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11156
11157 /* The range is +/-16k. */
11158 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT
11159 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT)
11160 {
11161 /* Transform add to addi. */
11162 insn = N32_TYPE2 (ADDI, N32_RT5 (insn), N32_RB5 (insn), 0);
11163 irel->r_info =
11164 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S0);
11165
11166 bfd_putb32 (insn, contents + laddr);
11167 if (i1_irelfn != irelend)
11168 {
11169 i1_irelfn->r_addend |= 1;
11170 *again = TRUE;
11171 }
11172 }
11173 }
11174
11175 /* Relax LE TLS load store instruction pattern. */
11176
11177 static void
11178 nds32_elf_relax_letlsls (struct bfd_link_info *link_info, bfd *abfd,
11179 asection *sec, Elf_Internal_Rela *irel,
11180 Elf_Internal_Rela *internal_relocs,
11181 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11182 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11183 {
11184
11185 uint32_t insn;
11186 bfd_vma laddr;
11187 bfd_signed_vma foff;
11188 Elf_Internal_Rela *i1_irelfn, *irelend;
11189 int success = 0;
11190
11191 irelend = internal_relocs + sec->reloc_count;
11192 laddr = irel->r_offset;
11193 insn = bfd_getb32 (contents + laddr);
11194 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11195 R_NDS32_PTR_RESOLVED);
11196 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11197 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11198 foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11199
11200 switch ((N32_OP6 (insn) << 8) | (insn & 0xff))
11201 {
11202 case (N32_OP6_MEM << 8) | N32_MEM_LB:
11203 case (N32_OP6_MEM << 8) | N32_MEM_SB:
11204 case (N32_OP6_MEM << 8) | N32_MEM_LBS:
11205 /* The range is +/-16k. */
11206 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT
11207 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT)
11208 {
11209 insn =
11210 ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11211 irel->r_info =
11212 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S0);
11213 success = 1;
11214 break;
11215 }
11216 case (N32_OP6_MEM << 8) | N32_MEM_LH:
11217 case (N32_OP6_MEM << 8) | N32_MEM_SH:
11218 case (N32_OP6_MEM << 8) | N32_MEM_LHS:
11219 /* The range is +/-32k. */
11220 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT_S1
11221 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT_S1)
11222 {
11223 insn =
11224 ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11225 irel->r_info =
11226 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S1);
11227 success = 1;
11228 break;
11229 }
11230 case (N32_OP6_MEM << 8) | N32_MEM_LW:
11231 case (N32_OP6_MEM << 8) | N32_MEM_SW:
11232 /* The range is +/-64k. */
11233 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT_S2
11234 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT_S2)
11235 {
11236 insn =
11237 ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11238 irel->r_info =
11239 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S2);
11240 success = 1;
11241 break;
11242 }
11243 default:
11244 break;
11245 }
11246
11247 if (success)
11248 {
11249 bfd_putb32 (insn, contents + laddr);
11250 if (i1_irelfn != irelend)
11251 {
11252 i1_irelfn->r_addend |= 1;
11253 *again = TRUE;
11254 }
11255 }
11256 }
11257
11258 /* Relax PTR relocation for nds32_elf_relax_section. */
11259
11260 static bfd_boolean
11261 nds32_elf_relax_ptr (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11262 Elf_Internal_Rela *internal_relocs, int *insn_len,
11263 int *seq_len, bfd_byte *contents)
11264 {
11265 Elf_Internal_Rela *ptr_irel, *irelend, *count_irel, *re_irel;
11266
11267 irelend = internal_relocs + sec->reloc_count;
11268
11269 re_irel =
11270 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11271 R_NDS32_PTR_RESOLVED, irel->r_addend);
11272
11273 if (re_irel == irelend)
11274 {
11275 (*_bfd_error_handler)
11276 ("%B: warning: R_NDS32_PTR points to unrecognized reloc at 0x%lx.",
11277 abfd, (long) irel->r_offset);
11278 return FALSE;
11279 }
11280
11281 if (re_irel->r_addend != 1)
11282 return FALSE;
11283
11284 /* Pointed target is relaxed and no longer needs this void *,
11285 change the type to NONE. */
11286 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11287
11288 /* Find PTR_COUNT to decide remove it or not. If PTR_COUNT does
11289 not exist, it means only count 1 and remove it directly. */
11290 /* TODO: I hope we can obsolate R_NDS32_COUNT in the future. */
11291 count_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11292 R_NDS32_PTR_COUNT);
11293 ptr_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11294 R_NDS32_PTR);
11295 if (count_irel != irelend)
11296 {
11297 if (--count_irel->r_addend > 0)
11298 return FALSE;
11299 }
11300
11301 if (ptr_irel != irelend)
11302 return FALSE;
11303
11304 /* If the PTR_COUNT is already 0, remove current instruction. */
11305 *seq_len = nds32_elf_insn_size (abfd, contents, irel->r_offset);
11306 *insn_len = 0;
11307 return TRUE;
11308 }
11309
11310 /* Relax PLT_GOT_SUFF relocation for nds32_elf_relax_section. */
11311
11312 static void
11313 nds32_elf_relax_pltgot_suff (struct bfd_link_info *link_info, bfd *abfd,
11314 asection *sec, Elf_Internal_Rela *irel,
11315 Elf_Internal_Rela *internal_relocs,
11316 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11317 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11318 {
11319 uint32_t insn;
11320 bfd_signed_vma foff;
11321 Elf_Internal_Rela *i1_irelfn, *irelend;
11322 bfd_vma local_sda, laddr;
11323
11324 irelend = internal_relocs + sec->reloc_count;
11325 laddr = irel->r_offset;
11326 insn = bfd_getb32 (contents + laddr);
11327
11328 /* FIXME: It's a little trouble to turn JRAL5 to JAL since
11329 we need additional space. It might be help if we could
11330 borrow some space from instructions to be eliminated
11331 such as sethi, ori, add. */
11332 if (insn & 0x80000000)
11333 return;
11334
11335 if (nds32_elf_check_dup_relocs
11336 (irel, internal_relocs, irelend, R_NDS32_PLT_GOT_SUFF))
11337 return;
11338
11339 i1_irelfn =
11340 find_relocs_at_address (irel, internal_relocs, irelend,
11341 R_NDS32_PTR_RESOLVED);
11342
11343 /* FIXIT 090606
11344 The boundary should be reduced since the .plt section hasn't
11345 been created and the address of specific entry is still unknown
11346 Maybe the range between the function call and the begin of the
11347 .text section can be used to decide if the .plt is in the range
11348 of function call. */
11349
11350 if (N32_OP6 (insn) == N32_OP6_ALU1
11351 && N32_SUB5 (insn) == N32_ALU1_ADD)
11352 {
11353 /* Get the value of the symbol referred to by the reloc. */
11354 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11355 &local_sda, FALSE);
11356 foff = (bfd_signed_vma) (calculate_plt_memory_address
11357 (abfd, link_info, isymbuf, irel,
11358 symtab_hdr) - local_sda);
11359 /* This condition only happened when symbol is undefined. */
11360 if (foff == 0)
11361 return;
11362
11363 if (foff < -CONSERVATIVE_19BIT || foff >= CONSERVATIVE_19BIT)
11364 return;
11365 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11366 R_NDS32_PLT_GOTREL_LO19);
11367 /* addi.gp */
11368 insn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
11369 }
11370 else if (N32_OP6 (insn) == N32_OP6_JREG
11371 && N32_SUB5 (insn) == N32_JREG_JRAL)
11372 {
11373 /* Get the value of the symbol referred to by the reloc. */
11374 foff =
11375 calculate_plt_offset (abfd, sec, link_info, isymbuf, irel, symtab_hdr);
11376 /* This condition only happened when symbol is undefined. */
11377 if (foff == 0)
11378 return;
11379 if (foff < -CONSERVATIVE_24BIT_S1 || foff >= CONSERVATIVE_24BIT_S1)
11380 return;
11381 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_25_PLTREL);
11382 insn = INSN_JAL;
11383 }
11384 else
11385 return;
11386
11387 bfd_putb32 (insn, contents + laddr);
11388 if (i1_irelfn != irelend)
11389 {
11390 i1_irelfn->r_addend |= 1;
11391 *again = TRUE;
11392 }
11393 }
11394
11395 /* Relax GOT_SUFF relocation for nds32_elf_relax_section. */
11396
11397 static void
11398 nds32_elf_relax_got_suff (struct bfd_link_info *link_info, bfd *abfd,
11399 asection *sec, Elf_Internal_Rela *irel,
11400 Elf_Internal_Rela *internal_relocs,
11401 bfd_byte *contents, Elf_Internal_Shdr *symtab_hdr,
11402 bfd_boolean *again)
11403 {
11404 uint32_t insn;
11405 bfd_signed_vma foff;
11406 Elf_Internal_Rela *i1_irelfn, *irelend;
11407 bfd_vma local_sda, laddr;
11408
11409 irelend = internal_relocs + sec->reloc_count;
11410 laddr = irel->r_offset;
11411 insn = bfd_getb32 (contents + laddr);
11412 if (insn & 0x80000000)
11413 return;
11414
11415 if (nds32_elf_check_dup_relocs
11416 (irel, internal_relocs, irelend, R_NDS32_GOT_SUFF))
11417 return;
11418
11419 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11420 R_NDS32_PTR_RESOLVED);
11421
11422 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11423 &local_sda, FALSE);
11424 foff = calculate_got_memory_address (abfd, link_info, irel,
11425 symtab_hdr) - local_sda;
11426
11427 if (foff < CONSERVATIVE_19BIT && foff >= -CONSERVATIVE_19BIT)
11428 {
11429 /* Turn LW to LWI.GP. Change relocation type to R_NDS32_GOT_REL. */
11430 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
11431 irel->r_info =
11432 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_GOT17S2_RELA);
11433 bfd_putb32 (insn, contents + laddr);
11434 if (i1_irelfn != irelend)
11435 {
11436 i1_irelfn->r_addend |= 1;
11437 *again = TRUE;
11438 }
11439 }
11440 }
11441
11442 /* Relax PLT_GOT_SUFF relocation for nds32_elf_relax_section. */
11443
11444 static void
11445 nds32_elf_relax_gotoff_suff (struct bfd_link_info *link_info, bfd *abfd,
11446 asection *sec, Elf_Internal_Rela *irel,
11447 Elf_Internal_Rela *internal_relocs,
11448 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11449 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11450 {
11451 int opc_insn_gotoff;
11452 uint32_t insn;
11453 bfd_signed_vma foff;
11454 Elf_Internal_Rela *i1_irelfn, *i2_irelfn, *irelend;
11455 bfd_vma local_sda, laddr;
11456
11457 irelend = internal_relocs + sec->reloc_count;
11458 laddr = irel->r_offset;
11459 insn = bfd_getb32 (contents + laddr);
11460
11461 if (insn & 0x80000000)
11462 return;
11463
11464 if (nds32_elf_check_dup_relocs
11465 (irel, internal_relocs, irelend, R_NDS32_GOTOFF_SUFF))
11466 return;
11467
11468 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11469 R_NDS32_PTR_RESOLVED);
11470 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11471 &local_sda, FALSE);
11472 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11473 foff = foff - local_sda;
11474
11475 if (foff >= CONSERVATIVE_19BIT || foff < -CONSERVATIVE_19BIT)
11476 return;
11477
11478 /* Concatenate opcode and sub-opcode for switch case.
11479 It may be MEM or ALU1. */
11480 opc_insn_gotoff = (N32_OP6 (insn) << 8) | (insn & 0xff);
11481 switch (opc_insn_gotoff)
11482 {
11483 case (N32_OP6_MEM << 8) | N32_MEM_LW:
11484 /* 4-byte aligned. */
11485 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
11486 irel->r_info =
11487 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA17S2_RELA);
11488 break;
11489 case (N32_OP6_MEM << 8) | N32_MEM_SW:
11490 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
11491 irel->r_info =
11492 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA17S2_RELA);
11493 break;
11494 case (N32_OP6_MEM << 8) | N32_MEM_LH:
11495 /* 2-byte aligned. */
11496 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
11497 irel->r_info =
11498 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11499 break;
11500 case (N32_OP6_MEM << 8) | N32_MEM_LHS:
11501 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (18));
11502 irel->r_info =
11503 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11504 break;
11505 case (N32_OP6_MEM << 8) | N32_MEM_SH:
11506 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (19));
11507 irel->r_info =
11508 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11509 break;
11510 case (N32_OP6_MEM << 8) | N32_MEM_LB:
11511 /* 1-byte aligned. */
11512 insn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
11513 irel->r_info =
11514 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11515 break;
11516 case (N32_OP6_MEM << 8) | N32_MEM_LBS:
11517 insn = N32_TYPE1 (LBGP, N32_RT5 (insn), __BIT (19));
11518 irel->r_info =
11519 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11520 break;
11521 case (N32_OP6_MEM << 8) | N32_MEM_SB:
11522 insn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
11523 irel->r_info =
11524 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11525 break;
11526 case (N32_OP6_ALU1 << 8) | N32_ALU1_ADD:
11527 insn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
11528 irel->r_info =
11529 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11530 break;
11531 default:
11532 return;
11533 }
11534
11535 bfd_putb32 (insn, contents + laddr);
11536 if (i1_irelfn != irelend)
11537 {
11538 i1_irelfn->r_addend |= 1;
11539 *again = TRUE;
11540 }
11541 if ((i2_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11542 R_NDS32_INSN16)) != irelend)
11543 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11544
11545 }
11546
11547 static bfd_boolean
11548 nds32_relax_adjust_label (bfd *abfd, asection *sec,
11549 Elf_Internal_Rela *internal_relocs,
11550 bfd_byte *contents,
11551 nds32_elf_blank_t **relax_blank_list,
11552 int optimize, int opt_size)
11553 {
11554 /* This code block is used to adjust 4-byte alignment by relax a pair
11555 of instruction a time.
11556
11557 It recognizes three types of relocations.
11558 1. R_NDS32_LABEL - a aligment.
11559 2. R_NDS32_INSN16 - relax a 32-bit instruction to 16-bit.
11560 3. is_16bit_NOP () - remove a 16-bit instruction. */
11561
11562 /* TODO: It seems currently implementation only support 4-byte aligment.
11563 We should handle any-aligment. */
11564
11565 Elf_Internal_Rela *insn_rel = NULL, *label_rel = NULL, *irel;
11566 Elf_Internal_Rela *tmp_rel, *tmp2_rel = NULL;
11567 Elf_Internal_Rela rel_temp;
11568 Elf_Internal_Rela *irelend;
11569 bfd_vma address;
11570 uint16_t insn16;
11571
11572 /* Checking for branch relaxation relies on the relocations to
11573 be sorted on 'r_offset'. This is not guaranteed so we must sort. */
11574 nds32_insertion_sort (internal_relocs, sec->reloc_count,
11575 sizeof (Elf_Internal_Rela), compar_reloc);
11576
11577 irelend = internal_relocs + sec->reloc_count;
11578
11579 /* Force R_NDS32_LABEL before R_NDS32_INSN16. */
11580 /* FIXME: Can we generate the right order in assembler?
11581 So we don't have to swapping them here. */
11582
11583 for (label_rel = internal_relocs, insn_rel = internal_relocs;
11584 label_rel < irelend; label_rel++)
11585 {
11586 if (ELF32_R_TYPE (label_rel->r_info) != R_NDS32_LABEL)
11587 continue;
11588
11589 /* Find the first reloc has the same offset with label_rel. */
11590 while (insn_rel < irelend && insn_rel->r_offset < label_rel->r_offset)
11591 insn_rel++;
11592
11593 for (;insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset;
11594 insn_rel++)
11595 /* Check if there were R_NDS32_INSN16 and R_NDS32_LABEL at the same
11596 address. */
11597 if (ELF32_R_TYPE (insn_rel->r_info) == R_NDS32_INSN16)
11598 break;
11599
11600 if (insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset
11601 && insn_rel < label_rel)
11602 {
11603 /* Swap the two reloc if the R_NDS32_INSN16 is
11604 before R_NDS32_LABEL. */
11605 memcpy (&rel_temp, insn_rel, sizeof (Elf_Internal_Rela));
11606 memcpy (insn_rel, label_rel, sizeof (Elf_Internal_Rela));
11607 memcpy (label_rel, &rel_temp, sizeof (Elf_Internal_Rela));
11608 }
11609 }
11610
11611 label_rel = NULL;
11612 insn_rel = NULL;
11613 /* If there were a sequence of R_NDS32_LABEL end up with .align 2
11614 or higher, remove other R_NDS32_LABEL with lower alignment.
11615 If an R_NDS32_INSN16 in between R_NDS32_LABELs must be converted,
11616 then the R_NDS32_LABEL sequence is broke. */
11617 for (tmp_rel = internal_relocs; tmp_rel < irelend; tmp_rel++)
11618 {
11619 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_LABEL)
11620 {
11621 if (label_rel == NULL)
11622 {
11623 if (tmp_rel->r_addend < 2)
11624 label_rel = tmp_rel;
11625 continue;
11626 }
11627 else if (tmp_rel->r_addend > 1)
11628 {
11629 /* Remove all LABEL relocation from label_rel to tmp_rel
11630 including relocations with same offset as tmp_rel. */
11631 for (tmp2_rel = label_rel; tmp2_rel < tmp_rel
11632 || tmp2_rel->r_offset == tmp_rel->r_offset; tmp2_rel++)
11633 {
11634 if (ELF32_R_TYPE (tmp2_rel->r_info) == R_NDS32_LABEL
11635 && tmp2_rel->r_addend < 2)
11636 tmp2_rel->r_info =
11637 ELF32_R_INFO (ELF32_R_SYM (tmp2_rel->r_info),
11638 R_NDS32_NONE);
11639 }
11640 label_rel = NULL;
11641 }
11642 }
11643 else if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16 && label_rel)
11644 {
11645 /* A new INSN16 which can be converted, so clear label_rel. */
11646 if (is_convert_32_to_16 (abfd, sec, tmp_rel, internal_relocs,
11647 irelend, &insn16)
11648 || is_16bit_NOP (abfd, sec, tmp_rel))
11649 label_rel = NULL;
11650 }
11651 }
11652
11653 label_rel = NULL;
11654 insn_rel = NULL;
11655 /* Optimized for speed and nothing has not been relaxed.
11656 It's time to align labels.
11657 We may convert a 16-bit instruction right before a label to
11658 32-bit, in order to align the label if necessary
11659 all reloc entries has been sorted by r_offset. */
11660 for (irel = internal_relocs; irel < irelend; irel++)
11661 {
11662 if (ELF32_R_TYPE (irel->r_info) != R_NDS32_INSN16
11663 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL)
11664 continue;
11665
11666 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_INSN16)
11667 {
11668 /* A new INSN16 found, resize the old one. */
11669 if (is_convert_32_to_16
11670 (abfd, sec, irel, internal_relocs, irelend, &insn16)
11671 || is_16bit_NOP (abfd, sec, irel))
11672 {
11673 if (insn_rel)
11674 {
11675 /* Previous INSN16 reloc exists, reduce its
11676 size to 16-bit. */
11677 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11678 irelend, &insn16))
11679 {
11680 nds32_elf_write_16 (abfd, contents, insn_rel,
11681 internal_relocs, irelend, insn16);
11682
11683 if (!insert_nds32_elf_blank_recalc_total
11684 (relax_blank_list, insn_rel->r_offset + 2, 2))
11685 return FALSE;
11686 }
11687 else if (is_16bit_NOP (abfd, sec, insn_rel))
11688 {
11689 if (!insert_nds32_elf_blank_recalc_total
11690 (relax_blank_list, insn_rel->r_offset, 2))
11691 return FALSE;
11692 }
11693 insn_rel->r_info =
11694 ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info), R_NDS32_NONE);
11695 }
11696 /* Save the new one for later use. */
11697 insn_rel = irel;
11698 }
11699 else
11700 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11701 R_NDS32_NONE);
11702 }
11703 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL)
11704 {
11705 /* Search for label. */
11706 int force_relax = 0;
11707
11708 /* Label on 16-bit instruction or optimization
11709 needless, just reset this reloc. */
11710 insn16 = bfd_getb16 (contents + irel->r_offset);
11711 if ((irel->r_addend & 0x1f) < 2 && (!optimize || (insn16 & 0x8000)))
11712 {
11713 irel->r_info =
11714 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11715 continue;
11716 }
11717
11718 address =
11719 irel->r_offset - get_nds32_elf_blank_total (relax_blank_list,
11720 irel->r_offset, 1);
11721
11722 if (!insn_rel)
11723 {
11724 /* Check if there is case which can not be aligned. */
11725 if (irel->r_addend == 2 && address & 0x2)
11726 return FALSE;
11727 continue;
11728 }
11729
11730 /* Try to align this label. */
11731
11732 if ((irel->r_addend & 0x1f) < 2)
11733 {
11734 /* Check if there is a INSN16 at the same address.
11735 Label_rel always seats before insn_rel after
11736 our sort. */
11737
11738 /* Search for INSN16 at LABEL location. If INSN16 is at
11739 same location and this LABEL alignment is lower than 2,
11740 the INSN16 can be converted to 2-byte. */
11741 for (tmp_rel = irel;
11742 tmp_rel < irelend && tmp_rel->r_offset == irel->r_offset;
11743 tmp_rel++)
11744 {
11745 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16
11746 && (is_convert_32_to_16
11747 (abfd, sec, tmp_rel, internal_relocs,
11748 irelend, &insn16)
11749 || is_16bit_NOP (abfd, sec, tmp_rel)))
11750 {
11751 force_relax = 1;
11752 break;
11753 }
11754 }
11755 }
11756
11757 if (force_relax || irel->r_addend == 1 || address & 0x2)
11758 {
11759 /* Label not aligned. */
11760 /* Previous reloc exists, reduce its size to 16-bit. */
11761 if (is_convert_32_to_16 (abfd, sec, insn_rel,
11762 internal_relocs, irelend, &insn16))
11763 {
11764 nds32_elf_write_16 (abfd, contents, insn_rel,
11765 internal_relocs, irelend, insn16);
11766
11767 if (!insert_nds32_elf_blank_recalc_total
11768 (relax_blank_list, insn_rel->r_offset + 2, 2))
11769 return FALSE;
11770 }
11771 else if (is_16bit_NOP (abfd, sec, insn_rel))
11772 {
11773 if (!insert_nds32_elf_blank_recalc_total
11774 (relax_blank_list, insn_rel->r_offset, 2))
11775 return FALSE;
11776 }
11777
11778 }
11779 /* INSN16 reloc is used. */
11780 insn_rel = NULL;
11781 }
11782 }
11783
11784 address =
11785 sec->size - get_nds32_elf_blank_total (relax_blank_list, sec->size, 0);
11786 if (insn_rel && (address & 0x2 || opt_size))
11787 {
11788 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11789 irelend, &insn16))
11790 {
11791 nds32_elf_write_16 (abfd, contents, insn_rel, internal_relocs,
11792 irelend, insn16);
11793 if (!insert_nds32_elf_blank_recalc_total
11794 (relax_blank_list, insn_rel->r_offset + 2, 2))
11795 return FALSE;
11796 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
11797 R_NDS32_NONE);
11798 }
11799 else if (is_16bit_NOP (abfd, sec, insn_rel))
11800 {
11801 if (!insert_nds32_elf_blank_recalc_total
11802 (relax_blank_list, insn_rel->r_offset, 2))
11803 return FALSE;
11804 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
11805 R_NDS32_NONE);
11806 }
11807 }
11808 insn_rel = NULL;
11809 return TRUE;
11810 }
11811
11812 /* Pick relaxation round. */
11813
11814 static int
11815 nds32_elf_pick_relax (bfd_boolean init, asection *sec, bfd_boolean *again,
11816 struct elf_nds32_link_hash_table *table,
11817 struct bfd_link_info *link_info)
11818 {
11819 static asection *final_sec;
11820 static bfd_boolean set = FALSE;
11821 static bfd_boolean first = TRUE;
11822 int round_table[] = {
11823 NDS32_RELAX_NORMAL_ROUND,
11824 NDS32_RELAX_JUMP_IFC_ROUND,
11825 NDS32_RELAX_EX9_BUILD_ROUND,
11826 NDS32_RELAX_EX9_REPLACE_ROUND,
11827 };
11828 static int pass = 0;
11829 static int relax_round;
11830
11831 if (first)
11832 {
11833 /* Run an empty run to get the final section. */
11834 relax_round = NDS32_RELAX_EMPTY_ROUND;
11835
11836 /* It has to enter relax again because we can
11837 not make sure what the final turn is. */
11838 *again = TRUE;
11839 first = FALSE;
11840 }
11841
11842 if (!set && *again)
11843 {
11844 /* It is reentered when again is FALSE. */
11845 final_sec = sec;
11846 return relax_round;
11847 }
11848
11849 /* The second round begins. */
11850 set = TRUE;
11851
11852 relax_round = round_table[pass];
11853
11854 if (!init && final_sec == sec)
11855 {
11856 switch (relax_round)
11857 {
11858 case NDS32_RELAX_NORMAL_ROUND:
11859 if (!*again)
11860 {
11861 /* Normal relaxation done. */
11862 if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
11863 {
11864 pass++;
11865 *again = TRUE;
11866 }
11867 else if (table->target_optimize & NDS32_RELAX_EX9_ON)
11868 {
11869 pass += 2; /* NDS32_RELAX_EX9_BUILD_ROUND */
11870 *again = TRUE;
11871 }
11872 else if (table->ex9_import_file)
11873 {
11874 /* Import ex9 table. */
11875 if (table->update_ex9_table)
11876 pass += 2; /* NDS32_RELAX_EX9_BUILD_ROUND */
11877 else
11878 pass += 3; /* NDS32_RELAX_EX9_REPLACE_ROUND */
11879 nds32_elf_ex9_import_table (link_info);
11880 *again = TRUE;
11881 }
11882 }
11883 break;
11884 case NDS32_RELAX_JUMP_IFC_ROUND:
11885 if (!nds32_elf_ifc_finish (link_info))
11886 (*_bfd_error_handler) (_("error: Jump IFC Fail."));
11887 if (table->target_optimize & NDS32_RELAX_EX9_ON)
11888 {
11889 pass++;
11890 *again = TRUE;
11891 }
11892 break;
11893 case NDS32_RELAX_EX9_BUILD_ROUND:
11894 nds32_elf_ex9_finish (link_info);
11895 pass++;
11896 *again = TRUE;
11897 break;
11898 case NDS32_RELAX_EX9_REPLACE_ROUND:
11899 if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
11900 {
11901 /* Do jump IFC optimization again. */
11902 if (!nds32_elf_ifc_finish (link_info))
11903 (*_bfd_error_handler) (_("error: Jump IFC Fail."));
11904 }
11905 break;
11906 default:
11907 break;
11908 }
11909 }
11910
11911 return relax_round;
11912 }
11913
11914 static bfd_boolean
11915 nds32_elf_relax_section (bfd *abfd, asection *sec,
11916 struct bfd_link_info *link_info, bfd_boolean *again)
11917 {
11918 nds32_elf_blank_t *relax_blank_list = NULL;
11919 Elf_Internal_Shdr *symtab_hdr;
11920 Elf_Internal_Rela *internal_relocs;
11921 Elf_Internal_Rela *irel;
11922 Elf_Internal_Rela *irelend;
11923 Elf_Internal_Sym *isymbuf = NULL;
11924 bfd_byte *contents = NULL;
11925 bfd_boolean result = TRUE;
11926 int optimize = 0;
11927 int opt_size = 0;
11928 uint32_t insn;
11929 uint16_t insn16;
11930
11931 /* Target dependnet option. */
11932 struct elf_nds32_link_hash_table *table;
11933 int load_store_relax;
11934 int relax_round;
11935
11936 relax_blank_list = NULL;
11937
11938 *again = FALSE;
11939
11940 /* Nothing to do for
11941 * relocatable link or
11942 * non-relocatable section or
11943 * non-code section or
11944 * empty content or
11945 * no reloc entry. */
11946 if (link_info->relocatable
11947 || (sec->flags & SEC_RELOC) == 0
11948 || (sec->flags & SEC_EXCLUDE) == 1
11949 || (sec->flags & SEC_CODE) == 0
11950 || sec->size == 0)
11951 return TRUE;
11952
11953 /* 09.12.11 Workaround. */
11954 /* We have to adjust align for R_NDS32_LABEL if needed.
11955 The adjust approach only can fix 2-byte align once. */
11956 if (sec->alignment_power > 2)
11957 return TRUE;
11958
11959 /* The optimization type to do. */
11960
11961 table = nds32_elf_hash_table (link_info);
11962 relax_round = nds32_elf_pick_relax (TRUE, sec, again, table, link_info);
11963 switch (relax_round)
11964 {
11965 case NDS32_RELAX_JUMP_IFC_ROUND:
11966 /* Here is the entrance of ifc jump relaxation. */
11967 if (!nds32_elf_ifc_calc (link_info, abfd, sec))
11968 return FALSE;
11969 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11970 return TRUE;
11971
11972 case NDS32_RELAX_EX9_BUILD_ROUND:
11973 /* Here is the entrance of ex9 relaxation. There are two pass of
11974 ex9 relaxation. The one is to traverse all instructions and build
11975 the hash table. The other one is to compare instructions and replace
11976 it by ex9.it. */
11977 if (!nds32_elf_ex9_build_hash_table (abfd, sec, link_info))
11978 return FALSE;
11979 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11980 return TRUE;
11981
11982 case NDS32_RELAX_EX9_REPLACE_ROUND:
11983 if (!nds32_elf_ex9_replace_instruction (link_info, abfd, sec))
11984 return FALSE;
11985 return TRUE;
11986
11987 case NDS32_RELAX_EMPTY_ROUND:
11988 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11989 return TRUE;
11990
11991 case NDS32_RELAX_NORMAL_ROUND:
11992 default:
11993 if (sec->reloc_count == 0)
11994 return TRUE;
11995 break;
11996 }
11997
11998 /* The begining of general relaxation. */
11999
12000 if (is_SDA_BASE_set == 0)
12001 {
12002 bfd_vma gp;
12003 is_SDA_BASE_set = 1;
12004 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
12005 &gp, FALSE);
12006 relax_range_measurement (abfd);
12007 }
12008
12009 if (is_ITB_BASE_set == 0)
12010 {
12011 /* Set the _ITB_BASE_. */
12012 if (!nds32_elf_ex9_itb_base (link_info))
12013 {
12014 (*_bfd_error_handler) (_("%B: error: Cannot set _ITB_BASE_"), abfd);
12015 bfd_set_error (bfd_error_bad_value);
12016 }
12017 }
12018
12019 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12020 /* Relocations MUST be kept in memory, because relaxation adjust them. */
12021 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12022 TRUE /* keep_memory */);
12023 if (internal_relocs == NULL)
12024 goto error_return;
12025
12026 irelend = internal_relocs + sec->reloc_count;
12027 irel = find_relocs_at_address (internal_relocs, internal_relocs,
12028 irelend, R_NDS32_RELAX_ENTRY);
12029
12030 if (irel == irelend)
12031 return TRUE;
12032
12033 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
12034 {
12035 if (irel->r_addend & R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG)
12036 return TRUE;
12037
12038 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FLAG)
12039 optimize = 1;
12040
12041 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FOR_SPACE_FLAG)
12042 opt_size = 1;
12043 }
12044
12045 load_store_relax = table->load_store_relax;
12046
12047 /* Get symbol table and section content. */
12048 if (!nds32_get_section_contents (abfd, sec, &contents)
12049 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12050 goto error_return;
12051
12052 /* Do relax loop only when finalize is not done.
12053 Take care of relaxable relocs except INSN16. */
12054 for (irel = internal_relocs; irel < irelend; irel++)
12055 {
12056 int seq_len; /* Original length of instruction sequence. */
12057 int insn_len = 0; /* Final length of instruction sequence. */
12058 bfd_boolean removed;
12059
12060 insn = 0;
12061 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
12062 && (irel->r_addend & 0x1f) >= 2)
12063 optimize = 1;
12064
12065 /* Relocation Types
12066 R_NDS32_LONGCALL1 53
12067 R_NDS32_LONGCALL2 54
12068 R_NDS32_LONGCALL3 55
12069 R_NDS32_LONGJUMP1 56
12070 R_NDS32_LONGJUMP2 57
12071 R_NDS32_LONGJUMP3 58
12072 R_NDS32_LOADSTORE 59 */
12073 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL1
12074 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LOADSTORE)
12075 seq_len = GET_SEQ_LEN (irel->r_addend);
12076
12077 /* Relocation Types
12078 R_NDS32_LONGCALL4 107
12079 R_NDS32_LONGCALL5 108
12080 R_NDS32_LONGCALL6 109
12081 R_NDS32_LONGJUMP4 110
12082 R_NDS32_LONGJUMP5 111
12083 R_NDS32_LONGJUMP6 112
12084 R_NDS32_LONGJUMP7 113 */
12085 else if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL4
12086 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LONGJUMP7)
12087 seq_len = 4;
12088
12089 /* Relocation Types
12090 R_NDS32_LO12S0_RELA 30
12091 R_NDS32_LO12S1_RELA 29
12092 R_NDS32_LO12S2_RELA 28
12093 R_NDS32_LO12S2_SP_RELA 71
12094 R_NDS32_LO12S2_DP_RELA 70
12095 R_NDS32_GOT_LO12 46
12096 R_NDS32_GOTOFF_LO12 50
12097 R_NDS32_PLTREL_LO12 65
12098 R_NDS32_PLT_GOTREL_LO12 67
12099 R_NDS32_17IFC_PCREL_RELA 96
12100 R_NDS32_GOT_SUFF 193
12101 R_NDS32_GOTOFF_SUFF 194
12102 R_NDS32_PLT_GOT_SUFF 195
12103 R_NDS32_MULCALL_SUFF 196
12104 R_NDS32_PTR 197 */
12105 else if ((ELF32_R_TYPE (irel->r_info) <= R_NDS32_LO12S0_RELA
12106 && ELF32_R_TYPE (irel->r_info) >= R_NDS32_LO12S2_RELA)
12107 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_SP_RELA
12108 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_DP_RELA
12109 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12
12110 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12
12111 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12
12112 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLTREL_LO12
12113 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12
12114 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_GOT_SUFF
12115 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_PTR)
12116 || ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12117 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LO12
12118 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_ADD
12119 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LS)
12120 seq_len = 0;
12121 else
12122 continue;
12123
12124 insn_len = seq_len;
12125 removed = FALSE;
12126
12127 switch (ELF32_R_TYPE (irel->r_info))
12128 {
12129 case R_NDS32_LONGCALL1:
12130 removed = nds32_elf_relax_longcall1 (abfd, sec, irel, internal_relocs,
12131 &insn_len, contents, isymbuf,
12132 symtab_hdr);
12133 break;
12134 case R_NDS32_LONGCALL2:
12135 removed = nds32_elf_relax_longcall2 (abfd, sec, irel, internal_relocs,
12136 &insn_len, contents, isymbuf,
12137 symtab_hdr);
12138 break;
12139 case R_NDS32_LONGCALL3:
12140 removed = nds32_elf_relax_longcall3 (abfd, sec, irel, internal_relocs,
12141 &insn_len, contents, isymbuf,
12142 symtab_hdr);
12143 break;
12144 case R_NDS32_LONGJUMP1:
12145 removed = nds32_elf_relax_longjump1 (abfd, sec, irel, internal_relocs,
12146 &insn_len, contents, isymbuf,
12147 symtab_hdr);
12148 break;
12149 case R_NDS32_LONGJUMP2:
12150 removed = nds32_elf_relax_longjump2 (abfd, sec, irel, internal_relocs,
12151 &insn_len, contents, isymbuf,
12152 symtab_hdr);
12153 break;
12154 case R_NDS32_LONGJUMP3:
12155 removed = nds32_elf_relax_longjump3 (abfd, sec, irel, internal_relocs,
12156 &insn_len, contents, isymbuf,
12157 symtab_hdr);
12158 break;
12159 case R_NDS32_LONGCALL4:
12160 removed = nds32_elf_relax_longcall4 (abfd, sec, irel, internal_relocs,
12161 &insn_len, contents, isymbuf,
12162 symtab_hdr);
12163 break;
12164 case R_NDS32_LONGCALL5:
12165 removed = nds32_elf_relax_longcall5 (abfd, sec, irel, internal_relocs,
12166 &insn_len, contents, isymbuf,
12167 symtab_hdr);
12168 break;
12169 case R_NDS32_LONGCALL6:
12170 removed = nds32_elf_relax_longcall6 (abfd, sec, irel, internal_relocs,
12171 &insn_len, contents, isymbuf,
12172 symtab_hdr);
12173 break;
12174 case R_NDS32_LONGJUMP4:
12175 removed = nds32_elf_relax_longjump4 (abfd, sec, irel, internal_relocs,
12176 &insn_len, contents, isymbuf,
12177 symtab_hdr);
12178 break;
12179 case R_NDS32_LONGJUMP5:
12180 removed = nds32_elf_relax_longjump5 (abfd, sec, irel, internal_relocs,
12181 &insn_len, &seq_len, contents,
12182 isymbuf, symtab_hdr);
12183 break;
12184 case R_NDS32_LONGJUMP6:
12185 removed = nds32_elf_relax_longjump6 (abfd, sec, irel, internal_relocs,
12186 &insn_len, &seq_len, contents,
12187 isymbuf, symtab_hdr);
12188 break;
12189 case R_NDS32_LONGJUMP7:
12190 removed = nds32_elf_relax_longjump7 (abfd, sec, irel, internal_relocs,
12191 &insn_len, &seq_len, contents,
12192 isymbuf, symtab_hdr);
12193 break;
12194 case R_NDS32_LOADSTORE:
12195 removed = nds32_elf_relax_loadstore (link_info, abfd, sec, irel,
12196 internal_relocs, &insn_len,
12197 contents, isymbuf, symtab_hdr,
12198 load_store_relax);
12199 break;
12200 case R_NDS32_LO12S0_RELA:
12201 case R_NDS32_LO12S1_RELA:
12202 case R_NDS32_LO12S2_DP_RELA:
12203 case R_NDS32_LO12S2_SP_RELA:
12204 case R_NDS32_LO12S2_RELA:
12205 /* Relax for low part. */
12206 nds32_elf_relax_lo12 (link_info, abfd, sec, irel, internal_relocs,
12207 contents, isymbuf, symtab_hdr);
12208
12209 /* It is impossible to delete blank, so just continue. */
12210 continue;
12211 case R_NDS32_GOT_LO12:
12212 case R_NDS32_GOTOFF_LO12:
12213 case R_NDS32_PLTREL_LO12:
12214 case R_NDS32_PLT_GOTREL_LO12:
12215 case R_NDS32_GOTPC_LO12:
12216 /* Relax for PIC gp-relative low part. */
12217 nds32_elf_relax_piclo12 (link_info, abfd, sec, irel, contents,
12218 isymbuf, symtab_hdr);
12219
12220 /* It is impossible to delete blank, so just continue. */
12221 continue;
12222 case R_NDS32_TLS_LE_LO12:
12223 /* Relax for LE TLS low part. */
12224 nds32_elf_relax_letlslo12 (link_info, abfd, irel, contents,
12225 isymbuf, symtab_hdr);
12226
12227 /* It is impossible to delete blank, so just continue. */
12228 continue;
12229 case R_NDS32_TLS_LE_ADD:
12230 nds32_elf_relax_letlsadd (link_info, abfd, sec, irel, internal_relocs,
12231 contents, isymbuf, symtab_hdr, again);
12232 /* It is impossible to delete blank, so just continue. */
12233 continue;
12234 case R_NDS32_TLS_LE_LS:
12235 nds32_elf_relax_letlsls (link_info, abfd, sec, irel, internal_relocs,
12236 contents, isymbuf, symtab_hdr, again);
12237 continue;
12238 case R_NDS32_PTR:
12239 removed = nds32_elf_relax_ptr (abfd, sec, irel, internal_relocs,
12240 &insn_len, &seq_len, contents);
12241 break;
12242 case R_NDS32_PLT_GOT_SUFF:
12243 nds32_elf_relax_pltgot_suff (link_info, abfd, sec, irel,
12244 internal_relocs, contents,
12245 isymbuf, symtab_hdr, again);
12246 /* It is impossible to delete blank, so just continue. */
12247 continue;
12248 case R_NDS32_GOT_SUFF:
12249 nds32_elf_relax_got_suff (link_info, abfd, sec, irel,
12250 internal_relocs, contents,
12251 symtab_hdr, again);
12252 /* It is impossible to delete blank, so just continue. */
12253 continue;
12254 case R_NDS32_GOTOFF_SUFF:
12255 nds32_elf_relax_gotoff_suff (link_info, abfd, sec, irel,
12256 internal_relocs, contents,
12257 isymbuf, symtab_hdr, again);
12258 /* It is impossible to delete blank, so just continue. */
12259 continue;
12260 default:
12261 continue;
12262
12263 }
12264 if (removed && seq_len - insn_len > 0)
12265 {
12266 if (!insert_nds32_elf_blank
12267 (&relax_blank_list, irel->r_offset + insn_len,
12268 seq_len - insn_len))
12269 goto error_return;
12270 *again = TRUE;
12271 }
12272 }
12273
12274 calc_nds32_blank_total (relax_blank_list);
12275
12276 if (table->relax_fp_as_gp)
12277 {
12278 if (!nds32_relax_fp_as_gp (link_info, abfd, sec, internal_relocs,
12279 irelend, isymbuf))
12280 goto error_return;
12281
12282 if (*again == FALSE)
12283 {
12284 if (!nds32_fag_remove_unused_fpbase (abfd, sec, internal_relocs,
12285 irelend))
12286 goto error_return;
12287 }
12288 }
12289
12290 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12291
12292 if (*again == FALSE)
12293 {
12294 if (!nds32_relax_adjust_label (abfd, sec, internal_relocs, contents,
12295 &relax_blank_list, optimize, opt_size))
12296 goto error_return;
12297 }
12298
12299 /* It doesn't matter optimize_for_space_no_align anymore.
12300 If object file is assembled with flag '-Os',
12301 the we don't adjust jump-destination on 4-byte boundary. */
12302
12303 if (relax_blank_list)
12304 {
12305 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12306 relax_blank_list = NULL;
12307 }
12308
12309 if (*again == FALSE)
12310 {
12311 /* Closing the section, so we don't relax it anymore. */
12312 bfd_vma sec_size_align;
12313 Elf_Internal_Rela *tmp_rel;
12314
12315 /* Pad to alignment boundary. Only handle current section alignment. */
12316 sec_size_align = (sec->size + (~((-1) << sec->alignment_power)))
12317 & ((-1) << sec->alignment_power);
12318 if ((sec_size_align - sec->size) & 0x2)
12319 {
12320 insn16 = NDS32_NOP16;
12321 bfd_putb16 (insn16, contents + sec->size);
12322 sec->size += 2;
12323 }
12324
12325 while (sec_size_align != sec->size)
12326 {
12327 insn = NDS32_NOP32;
12328 bfd_putb32 (insn, contents + sec->size);
12329 sec->size += 4;
12330 }
12331
12332 tmp_rel = find_relocs_at_address (internal_relocs, internal_relocs,
12333 irelend, R_NDS32_RELAX_ENTRY);
12334 if (tmp_rel != irelend)
12335 tmp_rel->r_addend |= R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG;
12336
12337 clean_nds32_elf_blank ();
12338 }
12339
12340 finish:
12341 if (internal_relocs != NULL
12342 && elf_section_data (sec)->relocs != internal_relocs)
12343 free (internal_relocs);
12344
12345 if (contents != NULL
12346 && elf_section_data (sec)->this_hdr.contents != contents)
12347 free (contents);
12348
12349 if (isymbuf != NULL && symtab_hdr->contents != (bfd_byte *) isymbuf)
12350 free (isymbuf);
12351
12352 return result;
12353
12354 error_return:
12355 result = FALSE;
12356 goto finish;
12357 }
12358
12359 static struct bfd_elf_special_section const nds32_elf_special_sections[] =
12360 {
12361 {".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE},
12362 {".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE},
12363 {NULL, 0, 0, 0, 0}
12364 };
12365
12366 static bfd_boolean
12367 nds32_elf_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
12368 struct bfd_link_info *info,
12369 void *finfo ATTRIBUTE_UNUSED,
12370 bfd_boolean (*func) (void *, const char *,
12371 Elf_Internal_Sym *,
12372 asection *,
12373 struct elf_link_hash_entry *)
12374 ATTRIBUTE_UNUSED)
12375 {
12376 FILE *sym_ld_script = NULL;
12377 struct elf_nds32_link_hash_table *table;
12378
12379 table = nds32_elf_hash_table (info);
12380 sym_ld_script = table->sym_ld_script;
12381
12382 if (check_start_export_sym)
12383 fprintf (sym_ld_script, "}\n");
12384
12385 return TRUE;
12386 }
12387
12388 static enum elf_reloc_type_class
12389 nds32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
12390 const asection *rel_sec ATTRIBUTE_UNUSED,
12391 const Elf_Internal_Rela *rela)
12392 {
12393 switch ((int) ELF32_R_TYPE (rela->r_info))
12394 {
12395 case R_NDS32_RELATIVE:
12396 return reloc_class_relative;
12397 case R_NDS32_JMP_SLOT:
12398 return reloc_class_plt;
12399 case R_NDS32_COPY:
12400 return reloc_class_copy;
12401 default:
12402 return reloc_class_normal;
12403 }
12404 }
12405
12406 /* Put target dependent option into info hash table. */
12407 void
12408 bfd_elf32_nds32_set_target_option (struct bfd_link_info *link_info,
12409 int relax_fp_as_gp,
12410 int eliminate_gc_relocs,
12411 FILE * sym_ld_script, int load_store_relax,
12412 int target_optimize, int relax_status,
12413 int relax_round, FILE * ex9_export_file,
12414 FILE * ex9_import_file,
12415 int update_ex9_table, int ex9_limit,
12416 bfd_boolean ex9_loop_aware,
12417 bfd_boolean ifc_loop_aware)
12418 {
12419 struct elf_nds32_link_hash_table *table;
12420
12421 table = nds32_elf_hash_table (link_info);
12422 if (table == NULL)
12423 return;
12424
12425 table->relax_fp_as_gp = relax_fp_as_gp;
12426 table->eliminate_gc_relocs = eliminate_gc_relocs;
12427 table->sym_ld_script = sym_ld_script;
12428 table ->load_store_relax = load_store_relax;
12429 table->target_optimize = target_optimize;
12430 table->relax_status = relax_status;
12431 table->relax_round = relax_round;
12432 table->ex9_export_file = ex9_export_file;
12433 table->ex9_import_file = ex9_import_file;
12434 table->update_ex9_table = update_ex9_table;
12435 table->ex9_limit = ex9_limit;
12436 table->ex9_loop_aware = ex9_loop_aware;
12437 table->ifc_loop_aware = ifc_loop_aware;
12438 }
12439 \f
12440 /* These functions and data-structures are used for fp-as-gp
12441 optimization. */
12442
12443 #define FAG_THRESHOLD 3 /* At least 3 gp-access. */
12444 /* lwi37.fp covers 508 bytes, but there may be 32-byte padding between
12445 the read-only section and read-write section. */
12446 #define FAG_WINDOW (508 - 32)
12447
12448 /* An nds32_fag represent a gp-relative access.
12449 We find best fp-base by using a sliding window
12450 to find a base address which can cover most gp-access. */
12451 struct nds32_fag
12452 {
12453 struct nds32_fag *next; /* NULL-teminated linked list. */
12454 bfd_vma addr; /* The address of this fag. */
12455 Elf_Internal_Rela **relas; /* The relocations associated with this fag.
12456 It is used for applying FP7U2_FLAG. */
12457 int count; /* How many times this address is referred.
12458 There should be exactly `count' relocations
12459 in relas. */
12460 int relas_capcity; /* The buffer size of relas.
12461 We use an array instead of linked-list,
12462 and realloc is used to adjust buffer size. */
12463 };
12464
12465 static void
12466 nds32_fag_init (struct nds32_fag *head)
12467 {
12468 memset (head, 0, sizeof (struct nds32_fag));
12469 }
12470
12471 static void
12472 nds32_fag_verify (struct nds32_fag *head)
12473 {
12474 struct nds32_fag *iter;
12475 struct nds32_fag *prev;
12476
12477 prev = NULL;
12478 iter = head->next;
12479 while (iter)
12480 {
12481 if (prev && prev->addr >= iter->addr)
12482 puts ("Bug in fp-as-gp insertion.");
12483 prev = iter;
12484 iter = iter->next;
12485 }
12486 }
12487
12488 /* Insert a fag in ascending order.
12489 If a fag of the same address already exists,
12490 they are chained by relas array. */
12491
12492 static void
12493 nds32_fag_insert (struct nds32_fag *head, bfd_vma addr,
12494 Elf_Internal_Rela * rel)
12495 {
12496 struct nds32_fag *iter;
12497 struct nds32_fag *new_fag;
12498 const int INIT_RELAS_CAP = 4;
12499
12500 for (iter = head;
12501 iter->next && iter->next->addr <= addr;
12502 iter = iter->next)
12503 /* Find somewhere to insert. */ ;
12504
12505 /* `iter' will be equal to `head' if the list is empty. */
12506 if (iter != head && iter->addr == addr)
12507 {
12508 /* The address exists in the list.
12509 Insert `rel' into relocation list, relas. */
12510
12511 /* Check whether relas is big enough. */
12512 if (iter->count >= iter->relas_capcity)
12513 {
12514 iter->relas_capcity *= 2;
12515 iter->relas = bfd_realloc
12516 (iter->relas, iter->relas_capcity * sizeof (void *));
12517 }
12518 iter->relas[iter->count++] = rel;
12519 return;
12520 }
12521
12522 /* This is a new address. Create a fag node for it. */
12523 new_fag = bfd_malloc (sizeof (struct nds32_fag));
12524 memset (new_fag, 0, sizeof (*new_fag));
12525 new_fag->addr = addr;
12526 new_fag->count = 1;
12527 new_fag->next = iter->next;
12528 new_fag->relas_capcity = INIT_RELAS_CAP;
12529 new_fag->relas = (Elf_Internal_Rela **)
12530 bfd_malloc (new_fag->relas_capcity * sizeof (void *));
12531 new_fag->relas[0] = rel;
12532 iter->next = new_fag;
12533
12534 nds32_fag_verify (head);
12535 }
12536
12537 static void
12538 nds32_fag_free_list (struct nds32_fag *head)
12539 {
12540 struct nds32_fag *iter;
12541
12542 iter = head->next;
12543 while (iter)
12544 {
12545 struct nds32_fag *tmp = iter;
12546 iter = iter->next;
12547 free (tmp->relas);
12548 tmp->relas = NULL;
12549 free (tmp);
12550 }
12551 }
12552
12553 /* Find the best fp-base address.
12554 The relocation associated with that address is returned,
12555 so we can track the symbol instead of a fixed address.
12556
12557 When relaxation, the address of an datum may change,
12558 because a text section is shrinked, so the data section
12559 moves forward. If the aligments of text and data section
12560 are different, their distance may change too.
12561 Therefore, tracking a fixed address is not appriate. */
12562
12563 static int
12564 nds32_fag_find_base (struct nds32_fag *head, struct nds32_fag **bestpp)
12565 {
12566 struct nds32_fag *base; /* First fag in the window. */
12567 struct nds32_fag *last; /* First fag outside the window. */
12568 int accu = 0; /* Usage accumulation. */
12569 struct nds32_fag *best; /* Best fag. */
12570 int baccu = 0; /* Best accumulation. */
12571
12572 /* Use first fag for initial, and find the last fag in the window.
12573
12574 In each iteration, we could simply subtract previous fag
12575 and accumulate following fags which are inside the window,
12576 untill we each the end. */
12577
12578 if (head->next == NULL)
12579 {
12580 *bestpp = NULL;
12581 return 0;
12582 }
12583
12584 /* Initialize base. */
12585 base = head->next;
12586 best = base;
12587 for (last = base;
12588 last && last->addr < base->addr + FAG_WINDOW;
12589 last = last->next)
12590 accu += last->count;
12591
12592 baccu = accu;
12593
12594 /* Record the best base in each iteration. */
12595 while (base->next)
12596 {
12597 accu -= base->count;
12598 base = base->next;
12599 /* Account fags in window. */
12600 for (/* Nothing. */;
12601 last && last->addr < base->addr + FAG_WINDOW;
12602 last = last->next)
12603 accu += last->count;
12604
12605 /* A better fp-base? */
12606 if (accu > baccu)
12607 {
12608 best = base;
12609 baccu = accu;
12610 }
12611 }
12612
12613 if (bestpp)
12614 *bestpp = best;
12615 return baccu;
12616 }
12617
12618 /* Apply R_NDS32_INSN16_FP7U2_FLAG on gp-relative accesses,
12619 so we can convert it fo fp-relative access later.
12620 `best_fag' is the best fp-base. Only those inside the window
12621 of best_fag is applied the flag. */
12622
12623 static bfd_boolean
12624 nds32_fag_mark_relax (struct bfd_link_info *link_info,
12625 bfd *abfd, struct nds32_fag *best_fag,
12626 Elf_Internal_Rela *internal_relocs,
12627 Elf_Internal_Rela *irelend)
12628 {
12629 struct nds32_fag *ifag;
12630 bfd_vma best_fpbase, gp;
12631 bfd *output_bfd;
12632
12633 output_bfd = abfd->sections->output_section->owner;
12634 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
12635 best_fpbase = best_fag->addr;
12636
12637 if (best_fpbase > gp + sdata_range[1][1]
12638 || best_fpbase < gp - sdata_range[1][0])
12639 return FALSE;
12640
12641 /* Mark these inside the window R_NDS32_INSN16_FP7U2_FLAG flag,
12642 so we know they can be converted to lwi37.fp. */
12643 for (ifag = best_fag;
12644 ifag && ifag->addr < best_fpbase + FAG_WINDOW; ifag = ifag->next)
12645 {
12646 int i;
12647
12648 for (i = 0; i < ifag->count; i++)
12649 {
12650 Elf_Internal_Rela *insn16_rel;
12651 Elf_Internal_Rela *fag_rel;
12652
12653 fag_rel = ifag->relas[i];
12654
12655 /* Only if this is within the WINDOWS, FP7U2_FLAG
12656 is applied. */
12657
12658 insn16_rel = find_relocs_at_address
12659 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12660
12661 if (insn16_rel != irelend)
12662 insn16_rel->r_addend = R_NDS32_INSN16_FP7U2_FLAG;
12663 }
12664 }
12665 return TRUE;
12666 }
12667
12668 /* Reset INSN16 to clean fp as gp. */
12669
12670 static void
12671 nds32_fag_unmark_relax (struct nds32_fag *fag,
12672 Elf_Internal_Rela *internal_relocs,
12673 Elf_Internal_Rela *irelend)
12674 {
12675 struct nds32_fag *ifag;
12676 int i;
12677 Elf_Internal_Rela *insn16_rel;
12678 Elf_Internal_Rela *fag_rel;
12679
12680 for (ifag = fag; ifag; ifag = ifag->next)
12681 {
12682 for (i = 0; i < ifag->count; i++)
12683 {
12684 fag_rel = ifag->relas[i];
12685
12686 /* Restore the INSN16 relocation. */
12687 insn16_rel = find_relocs_at_address
12688 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12689
12690 if (insn16_rel != irelend)
12691 insn16_rel->r_addend &= ~R_NDS32_INSN16_FP7U2_FLAG;
12692 }
12693 }
12694 }
12695
12696 /* This is the main function of fp-as-gp optimization.
12697 It should be called by relax_section. */
12698
12699 static bfd_boolean
12700 nds32_relax_fp_as_gp (struct bfd_link_info *link_info,
12701 bfd *abfd, asection *sec,
12702 Elf_Internal_Rela *internal_relocs,
12703 Elf_Internal_Rela *irelend,
12704 Elf_Internal_Sym *isymbuf)
12705 {
12706 Elf_Internal_Rela *begin_rel = NULL;
12707 Elf_Internal_Rela *irel;
12708 struct nds32_fag fag_head;
12709 Elf_Internal_Shdr *symtab_hdr;
12710 bfd_byte *contents;
12711 bfd_boolean ifc_inside = FALSE;
12712
12713 /* FIXME: Can we bfd_elf_link_read_relocs for the relocs? */
12714
12715 /* Per-function fp-base selection.
12716 1. Create a list for all the gp-relative access.
12717 2. Base on those gp-relative address,
12718 find a fp-base which can cover most access.
12719 3. Use the fp-base for fp-as-gp relaxation.
12720
12721 NOTE: If fp-as-gp is not worth to do, (e.g., less than 3 times),
12722 we should
12723 1. delete the `la $fp, _FP_BASE_' instruction and
12724 2. not convert lwi.gp to lwi37.fp.
12725
12726 To delete the _FP_BASE_ instruction, we simply apply
12727 R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG flag in the r_addend to disable it.
12728
12729 To suppress the conversion, we simply NOT to apply
12730 R_NDS32_INSN16_FP7U2_FLAG flag. */
12731
12732 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12733
12734 if (!nds32_get_section_contents (abfd, sec, &contents)
12735 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12736 return FALSE;
12737
12738 /* Check whether it is worth for fp-as-gp optimization,
12739 i.e., at least 3 gp-load.
12740
12741 Set R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG if we should NOT
12742 apply this optimization. */
12743
12744 for (irel = internal_relocs; irel < irelend; irel++)
12745 {
12746 /* We recognize R_NDS32_RELAX_REGION_BEGIN/_END for the region.
12747 One we enter the begin of the region, we track all the LW/ST
12748 instructions, so when we leave the region, we try to find
12749 the best fp-base address for those LW/ST instructions. */
12750
12751 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12752 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12753 {
12754 /* Begin of the region. */
12755 if (begin_rel)
12756 (*_bfd_error_handler) (_("%B: Nested OMIT_FP in %A."), abfd, sec);
12757
12758 begin_rel = irel;
12759 nds32_fag_init (&fag_head);
12760 ifc_inside = FALSE;
12761 }
12762 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12763 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12764 {
12765 int accu;
12766 struct nds32_fag *best_fag, *tmp_fag;
12767 int dist;
12768
12769 /* End of the region.
12770 Check whether it is worth to do fp-as-gp. */
12771
12772 if (begin_rel == NULL)
12773 {
12774 (*_bfd_error_handler) (_("%B: Unmatched OMIT_FP in %A."), abfd, sec);
12775 continue;
12776 }
12777
12778 accu = nds32_fag_find_base (&fag_head, &best_fag);
12779
12780 /* Clean FP7U2_FLAG because they may set ever. */
12781 tmp_fag = fag_head.next;
12782 nds32_fag_unmark_relax (tmp_fag, internal_relocs, irelend);
12783
12784 /* Check if it is worth, and FP_BASE is near enough to SDA_BASE. */
12785 if (accu < FAG_THRESHOLD
12786 || !nds32_fag_mark_relax (link_info, abfd, best_fag,
12787 internal_relocs, irelend))
12788 {
12789 /* Not worth to do fp-as-gp. */
12790 begin_rel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12791 begin_rel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12792 irel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12793 irel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12794 nds32_fag_free_list (&fag_head);
12795 begin_rel = NULL;
12796 continue;
12797 }
12798
12799 /* R_SYM of R_NDS32_RELAX_REGION_BEGIN is not used by assembler,
12800 so we use it to record the distance to the reloction of best
12801 fp-base. */
12802 dist = best_fag->relas[0] - begin_rel;
12803 BFD_ASSERT (dist > 0 && dist < 0xffffff);
12804 /* Use high 16 bits of addend to record the _FP_BASE_ matched
12805 relocation. And get the base value when relocating. */
12806 begin_rel->r_addend &= (0x1 << 16) - 1;
12807 begin_rel->r_addend |= dist << 16;
12808
12809 nds32_fag_free_list (&fag_head);
12810 begin_rel = NULL;
12811 }
12812
12813 if (begin_rel == NULL || ifc_inside)
12814 /* Skip if we are not in the region of fp-as-gp. */
12815 continue;
12816
12817 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S2_RELA
12818 || ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA17S2_RELA)
12819 {
12820 bfd_vma addr;
12821 uint32_t insn;
12822
12823 /* A gp-relative access is found. Insert it to the fag-list. */
12824
12825 /* Rt is necessary an RT3, so it can be converted to lwi37.fp. */
12826 insn = bfd_getb32 (contents + irel->r_offset);
12827 if (!N32_IS_RT3 (insn))
12828 continue;
12829
12830 addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
12831 nds32_fag_insert (&fag_head, addr, irel);
12832 }
12833 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA_FP7U2_RELA)
12834 {
12835 begin_rel = NULL;
12836 }
12837 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12838 || ELF32_R_TYPE (irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
12839 {
12840 /* Suppress fp as gp when encounter ifc. */
12841 ifc_inside = TRUE;
12842 }
12843 }
12844
12845 return TRUE;
12846 }
12847
12848 /* Remove unused `la $fp, _FD_BASE_' instruction. */
12849
12850 static bfd_boolean
12851 nds32_fag_remove_unused_fpbase (bfd *abfd, asection *sec,
12852 Elf_Internal_Rela *internal_relocs,
12853 Elf_Internal_Rela *irelend)
12854 {
12855 Elf_Internal_Rela *irel;
12856 Elf_Internal_Shdr *symtab_hdr;
12857 bfd_byte *contents = NULL;
12858 nds32_elf_blank_t *relax_blank_list = NULL;
12859 bfd_boolean result = TRUE;
12860 bfd_boolean unused_region = FALSE;
12861
12862 /*
12863 NOTE: Disable fp-as-gp if we encounter ifcall relocations.
12864 * R_NDS32_17IFC_PCREL_RELA
12865 * R_NDS32_10IFCU_PCREL_RELA
12866
12867 CASE??????????????
12868 */
12869
12870 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12871 nds32_get_section_contents (abfd, sec, &contents);
12872
12873 for (irel = internal_relocs; irel < irelend; irel++)
12874 {
12875 /* To remove unused fp-base, we simply find the REGION_NOT_OMIT_FP
12876 we marked to in previous pass.
12877 DO NOT scan relocations again, since we've alreadly decided it
12878 and set the flag. */
12879 const char *syname;
12880 int syndx;
12881 uint32_t insn;
12882
12883 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12884 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
12885 unused_region = TRUE;
12886 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12887 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
12888 unused_region = FALSE;
12889
12890 /* We're not in the region. */
12891 if (!unused_region)
12892 continue;
12893
12894 /* _FP_BASE_ must be a GLOBAL symbol. */
12895 syndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
12896 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
12897 continue;
12898
12899 /* The symbol name must be _FP_BASE_. */
12900 syname = elf_sym_hashes (abfd)[syndx]->root.root.string;
12901 if (strcmp (syname, FP_BASE_NAME) != 0)
12902 continue;
12903
12904 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA19S0_RELA)
12905 {
12906 /* addi.gp $fp, -256 */
12907 insn = bfd_getb32 (contents + irel->r_offset);
12908 if (insn != INSN_ADDIGP_TO_FP)
12909 continue;
12910 }
12911 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S0_RELA)
12912 {
12913 /* addi $fp, $gp, -256 */
12914 insn = bfd_getb32 (contents + irel->r_offset);
12915 if (insn != INSN_ADDI_GP_TO_FP)
12916 continue;
12917 }
12918 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_20_RELA)
12919 {
12920 /* movi $fp, FP_BASE */
12921 insn = bfd_getb32 (contents + irel->r_offset);
12922 if (insn != INSN_MOVI_TO_FP)
12923 continue;
12924 }
12925 else
12926 continue;
12927
12928 /* We got here because a FP_BASE instruction is found. */
12929 if (!insert_nds32_elf_blank_recalc_total
12930 (&relax_blank_list, irel->r_offset, 4))
12931 goto error_return;
12932 }
12933
12934 finish:
12935 if (relax_blank_list)
12936 {
12937 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12938 relax_blank_list = NULL;
12939 }
12940 return result;
12941
12942 error_return:
12943 result = FALSE;
12944 goto finish;
12945 }
12946
12947 /* This is a version of bfd_generic_get_relocated_section_contents.
12948 We need this variety because relaxation will modify the dwarf
12949 infomation. When there is undefined symbol reference error mesage,
12950 linker need to dump line number where the symbol be used. However
12951 the address is be relaxed, it can not get the original dwarf contents.
12952 The variety only modify function call for reading in the section. */
12953
12954 static bfd_byte *
12955 nds32_elf_get_relocated_section_contents (bfd *abfd,
12956 struct bfd_link_info *link_info,
12957 struct bfd_link_order *link_order,
12958 bfd_byte *data,
12959 bfd_boolean relocatable,
12960 asymbol **symbols)
12961 {
12962 bfd *input_bfd = link_order->u.indirect.section->owner;
12963 asection *input_section = link_order->u.indirect.section;
12964 long reloc_size;
12965 arelent **reloc_vector;
12966 long reloc_count;
12967
12968 reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
12969 if (reloc_size < 0)
12970 return NULL;
12971
12972 /* Read in the section. */
12973 if (!nds32_get_section_contents (input_bfd, input_section, &data))
12974 return NULL;
12975
12976 if (reloc_size == 0)
12977 return data;
12978
12979 reloc_vector = (arelent **) bfd_malloc (reloc_size);
12980 if (reloc_vector == NULL)
12981 return NULL;
12982
12983 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
12984 reloc_vector, symbols);
12985 if (reloc_count < 0)
12986 goto error_return;
12987
12988 if (reloc_count > 0)
12989 {
12990 arelent **parent;
12991 for (parent = reloc_vector; *parent != NULL; parent++)
12992 {
12993 char *error_message = NULL;
12994 asymbol *symbol;
12995 bfd_reloc_status_type r;
12996
12997 symbol = *(*parent)->sym_ptr_ptr;
12998 if (symbol->section && discarded_section (symbol->section))
12999 {
13000 bfd_byte *p;
13001 static reloc_howto_type none_howto
13002 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
13003 "unused", FALSE, 0, 0, FALSE);
13004
13005 p = data + (*parent)->address * bfd_octets_per_byte (input_bfd);
13006 _bfd_clear_contents ((*parent)->howto, input_bfd, input_section,
13007 p);
13008 (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
13009 (*parent)->addend = 0;
13010 (*parent)->howto = &none_howto;
13011 r = bfd_reloc_ok;
13012 }
13013 else
13014 r = bfd_perform_relocation (input_bfd, *parent, data,
13015 input_section,
13016 relocatable ? abfd : NULL,
13017 &error_message);
13018
13019 if (relocatable)
13020 {
13021 asection *os = input_section->output_section;
13022
13023 /* A partial link, so keep the relocs. */
13024 os->orelocation[os->reloc_count] = *parent;
13025 os->reloc_count++;
13026 }
13027
13028 if (r != bfd_reloc_ok)
13029 {
13030 switch (r)
13031 {
13032 case bfd_reloc_undefined:
13033 if (!((*link_info->callbacks->undefined_symbol)
13034 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13035 input_bfd, input_section, (*parent)->address, TRUE)))
13036 goto error_return;
13037 break;
13038 case bfd_reloc_dangerous:
13039 BFD_ASSERT (error_message != NULL);
13040 if (!((*link_info->callbacks->reloc_dangerous)
13041 (link_info, error_message, input_bfd, input_section,
13042 (*parent)->address)))
13043 goto error_return;
13044 break;
13045 case bfd_reloc_overflow:
13046 if (!((*link_info->callbacks->reloc_overflow)
13047 (link_info, NULL,
13048 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13049 (*parent)->howto->name, (*parent)->addend,
13050 input_bfd, input_section, (*parent)->address)))
13051 goto error_return;
13052 break;
13053 case bfd_reloc_outofrange:
13054 /* PR ld/13730:
13055 This error can result when processing some partially
13056 complete binaries. Do not abort, but issue an error
13057 message instead. */
13058 link_info->callbacks->einfo
13059 (_("%X%P: %B(%A): relocation \"%R\" goes out of range\n"),
13060 abfd, input_section, * parent);
13061 goto error_return;
13062
13063 default:
13064 abort ();
13065 break;
13066 }
13067 }
13068 }
13069 }
13070
13071 free (reloc_vector);
13072 return data;
13073
13074 error_return:
13075 free (reloc_vector);
13076 return NULL;
13077 }
13078 \f
13079 /* Link-time IFC relaxation.
13080 In this optimization, we chains jump instructions
13081 of the same destination with ifcall. */
13082
13083
13084 /* List to save jal and j relocation. */
13085 struct elf_nds32_ifc_symbol_entry
13086 {
13087 asection *sec;
13088 struct elf_link_hash_entry *h;
13089 struct elf_nds32_ifc_irel_list *irel_head;
13090 unsigned long insn;
13091 int times;
13092 int enable; /* Apply ifc. */
13093 int ex9_enable; /* Apply ifc after ex9. */
13094 struct elf_nds32_ifc_symbol_entry *next;
13095 };
13096
13097 struct elf_nds32_ifc_irel_list
13098 {
13099 Elf_Internal_Rela *irel;
13100 asection *sec;
13101 bfd_vma addr;
13102 /* If this is set, then it is the last instruction for
13103 ifc-chain, so it must be keep for the actual branching. */
13104 int keep;
13105 struct elf_nds32_ifc_irel_list *next;
13106 };
13107
13108 static struct elf_nds32_ifc_symbol_entry *ifc_symbol_head = NULL;
13109
13110 /* Insert symbol of jal and j for ifc. */
13111
13112 static void
13113 nds32_elf_ifc_insert_symbol (asection *sec,
13114 struct elf_link_hash_entry *h,
13115 Elf_Internal_Rela *irel,
13116 unsigned long insn)
13117 {
13118 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13119
13120 /* Check there is target of existing entry the same as the new one. */
13121 while (ptr != NULL)
13122 {
13123 if (((h == NULL && ptr->sec == sec
13124 && ELF32_R_SYM (ptr->irel_head->irel->r_info) == ELF32_R_SYM (irel->r_info)
13125 && ptr->irel_head->irel->r_addend == irel->r_addend)
13126 || h != NULL)
13127 && ptr->h == h
13128 && ptr->insn == insn)
13129 {
13130 /* The same target exist, so insert into list. */
13131 struct elf_nds32_ifc_irel_list *irel_list = ptr->irel_head;
13132
13133 while (irel_list->next != NULL)
13134 irel_list = irel_list->next;
13135 irel_list->next = bfd_malloc (sizeof (struct elf_nds32_ifc_irel_list));
13136 irel_list = irel_list->next;
13137 irel_list->irel = irel;
13138 irel_list->keep = 1;
13139
13140 if (h == NULL)
13141 irel_list->sec = NULL;
13142 else
13143 irel_list->sec = sec;
13144 irel_list->next = NULL;
13145 return;
13146 }
13147 if (ptr->next == NULL)
13148 break;
13149 ptr = ptr->next;
13150 }
13151
13152 /* There is no same target entry, so build a new one. */
13153 if (ifc_symbol_head == NULL)
13154 {
13155 ifc_symbol_head = bfd_malloc (sizeof (struct elf_nds32_ifc_symbol_entry));
13156 ptr = ifc_symbol_head;
13157 }
13158 else
13159 {
13160 ptr->next = bfd_malloc (sizeof (struct elf_nds32_ifc_symbol_entry));
13161 ptr = ptr->next;
13162 }
13163
13164 ptr->h = h;
13165 ptr->irel_head = bfd_malloc (sizeof (struct elf_nds32_ifc_irel_list));
13166 ptr->irel_head->irel = irel;
13167 ptr->insn = insn;
13168 ptr->irel_head->keep = 1;
13169
13170 if (h == NULL)
13171 {
13172 /* Local symbols. */
13173 ptr->sec = sec;
13174 ptr->irel_head->sec = NULL;
13175 }
13176 else
13177 {
13178 /* Global symbol. */
13179 ptr->sec = NULL;
13180 ptr->irel_head->sec = sec;
13181 }
13182
13183 ptr->irel_head->next = NULL;
13184 ptr->times = 0;
13185 ptr->enable = 0;
13186 ptr->ex9_enable = 0;
13187 ptr->next = NULL;
13188 }
13189
13190 /* Gather all jal and j instructions. */
13191
13192 static bfd_boolean
13193 nds32_elf_ifc_calc (struct bfd_link_info *info,
13194 bfd *abfd, asection *sec)
13195 {
13196 Elf_Internal_Rela *internal_relocs;
13197 Elf_Internal_Rela *irelend;
13198 Elf_Internal_Rela *irel;
13199 Elf_Internal_Shdr *symtab_hdr;
13200 bfd_byte *contents = NULL;
13201 uint32_t insn, insn_with_reg;
13202 unsigned long r_symndx;
13203 struct elf_link_hash_entry *h;
13204 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
13205 struct elf_nds32_link_hash_table *table;
13206 bfd_boolean ifc_loop_aware;
13207
13208 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
13209 TRUE /* keep_memory */);
13210 irelend = internal_relocs + sec->reloc_count;
13211 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13212
13213 /* Check if the object enable ifc. */
13214 irel = find_relocs_at_address (internal_relocs, internal_relocs, irelend,
13215 R_NDS32_RELAX_ENTRY);
13216
13217 if (irel == NULL
13218 || irel >= irelend
13219 || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
13220 || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
13221 && !(irel->r_addend & R_NDS32_RELAX_ENTRY_IFC_FLAG)))
13222 return TRUE;
13223
13224 if (!nds32_get_section_contents (abfd, sec, &contents))
13225 return FALSE;
13226
13227 table = nds32_elf_hash_table (info);
13228 ifc_loop_aware = table->ifc_loop_aware;
13229 while (irel != NULL && irel < irelend)
13230 {
13231 /* Traverse all relocation and gather all of them to build the list. */
13232
13233 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN)
13234 {
13235 if (ifc_loop_aware == 1
13236 && (irel->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG) != 0)
13237 {
13238 /* Check the region if loop or not. If it is true and
13239 ifc-loop-aware is true, ignore the region till region end. */
13240 while (irel != NULL
13241 && irel < irelend
13242 && (ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
13243 || (irel->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG) != 0))
13244 irel++;
13245 }
13246 }
13247
13248 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA)
13249 {
13250 insn = bfd_getb32 (contents + irel->r_offset);
13251 nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
13252 r_symndx = ELF32_R_SYM (irel->r_info);
13253 if (r_symndx < symtab_hdr->sh_info)
13254 {
13255 /* Local symbol. */
13256 nds32_elf_ifc_insert_symbol (sec, NULL, irel, insn_with_reg);
13257 }
13258 else
13259 {
13260 /* External symbol. */
13261 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13262 nds32_elf_ifc_insert_symbol (sec, h, irel, insn_with_reg);
13263 }
13264 }
13265 irel++;
13266 }
13267 return TRUE;
13268 }
13269
13270 /* Determine whether j and jal should be substituted. */
13271
13272 static void
13273 nds32_elf_ifc_filter (struct bfd_link_info *info)
13274 {
13275 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13276 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13277 struct elf_nds32_ifc_irel_list *irel_keeper = NULL;
13278 struct elf_nds32_link_hash_table *table;
13279 int target_optimize;
13280 bfd_vma address;
13281
13282 table = nds32_elf_hash_table (info);
13283 target_optimize = table->target_optimize;
13284 while (ptr)
13285 {
13286 irel_ptr = ptr->irel_head;
13287 if (ptr->h == NULL)
13288 {
13289 /* Local symbol. */
13290 irel_keeper = irel_ptr;
13291 while (irel_ptr && irel_ptr->next)
13292 {
13293 /* Check there is jump target can be used. */
13294 if ((irel_ptr->next->irel->r_offset
13295 - irel_keeper->irel->r_offset) > 1022)
13296 irel_keeper = irel_ptr->next;
13297 else
13298 {
13299 ptr->enable = 1;
13300 irel_ptr->keep = 0;
13301 }
13302 irel_ptr = irel_ptr->next;
13303 }
13304 }
13305 else
13306 {
13307 /* Global symbol. */
13308 /* We have to get the absolute address and decide
13309 whether to keep it or not. */
13310 while (irel_ptr)
13311 {
13312 address = (irel_ptr->irel->r_offset
13313 + irel_ptr->sec->output_section->vma
13314 + irel_ptr->sec->output_offset);
13315 irel_ptr->addr = address;
13316 irel_ptr = irel_ptr->next;
13317 }
13318
13319 irel_ptr = ptr->irel_head;
13320 while (irel_ptr)
13321 {
13322 /* Sort by address. */
13323 struct elf_nds32_ifc_irel_list *irel_dest = irel_ptr;
13324 struct elf_nds32_ifc_irel_list *irel_temp = irel_ptr;
13325 struct elf_nds32_ifc_irel_list *irel_ptr_prev = NULL;
13326 struct elf_nds32_ifc_irel_list *irel_dest_prev = NULL;
13327
13328 /* Get the smallest one. */
13329 while (irel_temp->next)
13330 {
13331 if (irel_temp->next->addr < irel_dest->addr)
13332 {
13333 irel_dest_prev = irel_temp;
13334 irel_dest = irel_temp->next;
13335 }
13336 irel_temp = irel_temp->next;
13337 }
13338
13339 if (irel_dest != irel_ptr)
13340 {
13341 if (irel_ptr_prev)
13342 irel_ptr_prev->next = irel_dest;
13343 if (irel_dest_prev)
13344 irel_dest_prev->next = irel_ptr;
13345 irel_temp = irel_ptr->next;
13346 irel_ptr->next = irel_dest->next;
13347 irel_dest->next = irel_temp;
13348 }
13349 irel_ptr_prev = irel_ptr;
13350 irel_ptr = irel_ptr->next;
13351 }
13352
13353 irel_ptr = ptr->irel_head;
13354 irel_keeper = irel_ptr;
13355 while (irel_ptr && irel_ptr->next)
13356 {
13357 if ((irel_ptr->next->addr - irel_keeper->addr) > 1022)
13358 irel_keeper = irel_ptr->next;
13359 else
13360 {
13361 ptr->enable = 1;
13362 irel_ptr->keep = 0;
13363 }
13364 irel_ptr = irel_ptr->next;
13365 }
13366 }
13367
13368 /* Ex9 enable. Reserve it for ex9. */
13369 if ((target_optimize & NDS32_RELAX_EX9_ON)
13370 && ptr->irel_head != irel_keeper)
13371 ptr->enable = 0;
13372 ptr = ptr->next;
13373 }
13374 }
13375
13376 /* Determine whether j and jal should be substituted after ex9 done. */
13377
13378 static void
13379 nds32_elf_ifc_filter_after_ex9 (void)
13380 {
13381 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13382 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13383
13384 while (ptr)
13385 {
13386 if (ptr->enable == 0)
13387 {
13388 /* Check whether ifc is applied or not. */
13389 irel_ptr = ptr->irel_head;
13390 ptr->ex9_enable = 1;
13391 while (irel_ptr)
13392 {
13393 if (ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_TRAN)
13394 {
13395 /* Ex9 already. */
13396 ptr->ex9_enable = 0;
13397 break;
13398 }
13399 irel_ptr = irel_ptr->next;
13400 }
13401 }
13402 ptr = ptr->next;
13403 }
13404 }
13405
13406 /* Wrapper to do ifc relaxation. */
13407
13408 bfd_boolean
13409 nds32_elf_ifc_finish (struct bfd_link_info *info)
13410 {
13411 int relax_status;
13412 struct elf_nds32_link_hash_table *table;
13413
13414 table = nds32_elf_hash_table (info);
13415 relax_status = table->relax_status;
13416
13417 if (!(relax_status & NDS32_RELAX_JUMP_IFC_DONE))
13418 nds32_elf_ifc_filter (info);
13419 else
13420 nds32_elf_ifc_filter_after_ex9 ();
13421
13422 if (!nds32_elf_ifc_replace (info))
13423 return FALSE;
13424
13425 if (table)
13426 table->relax_status |= NDS32_RELAX_JUMP_IFC_DONE;
13427 return TRUE;
13428 }
13429
13430 /* Traverse the result of ifc filter and replace it with ifcall9. */
13431
13432 static bfd_boolean
13433 nds32_elf_ifc_replace (struct bfd_link_info *info)
13434 {
13435 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13436 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13437 nds32_elf_blank_t *relax_blank_list = NULL;
13438 bfd_byte *contents = NULL;
13439 Elf_Internal_Rela *internal_relocs;
13440 Elf_Internal_Rela *irel;
13441 Elf_Internal_Rela *irelend;
13442 unsigned short insn16 = INSN_IFCALL9;
13443 struct elf_nds32_link_hash_table *table;
13444 int relax_status;
13445
13446 table = nds32_elf_hash_table (info);
13447 relax_status = table->relax_status;
13448
13449 while (ptr)
13450 {
13451 /* Traverse the ifc gather list, and replace the
13452 filter entries by ifcall9. */
13453 if ((!(relax_status & NDS32_RELAX_JUMP_IFC_DONE) && ptr->enable == 1)
13454 || ((relax_status & NDS32_RELAX_JUMP_IFC_DONE)
13455 && ptr->ex9_enable == 1))
13456 {
13457 irel_ptr = ptr->irel_head;
13458 if (ptr->h == NULL)
13459 {
13460 /* Local symbol. */
13461 internal_relocs = _bfd_elf_link_read_relocs
13462 (ptr->sec->owner, ptr->sec, NULL, NULL, TRUE /* keep_memory */);
13463 irelend = internal_relocs + ptr->sec->reloc_count;
13464
13465 if (!nds32_get_section_contents (ptr->sec->owner, ptr->sec,
13466 &contents))
13467 return FALSE;
13468
13469 while (irel_ptr)
13470 {
13471 if (irel_ptr->keep == 0 && irel_ptr->next)
13472 {
13473 /* The one can be replaced. We have to check whether
13474 there is any alignment point in the region. */
13475 irel = irel_ptr->irel;
13476 while (((irel_ptr->next->keep == 0
13477 && irel < irel_ptr->next->irel)
13478 || (irel_ptr->next->keep == 1 && irel < irelend))
13479 && !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13480 && (irel->r_addend & 0x1f) == 2))
13481 irel++;
13482 if (irel >= irelend
13483 || !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13484 && (irel->r_addend & 0x1f) == 2
13485 && ((irel->r_offset - get_nds32_elf_blank_total
13486 (&relax_blank_list, irel->r_offset, 1))
13487 & 0x02) == 0))
13488 {
13489 /* Replace by ifcall9. */
13490 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13491 if (!insert_nds32_elf_blank_recalc_total
13492 (&relax_blank_list, irel_ptr->irel->r_offset + 2, 2))
13493 return FALSE;
13494 irel_ptr->irel->r_info =
13495 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13496 R_NDS32_10IFCU_PCREL_RELA);
13497 }
13498 }
13499 irel_ptr = irel_ptr->next;
13500 }
13501
13502 /* Delete the redundant code. */
13503 if (relax_blank_list)
13504 {
13505 nds32_elf_relax_delete_blanks (ptr->sec->owner, ptr->sec,
13506 relax_blank_list);
13507 relax_blank_list = NULL;
13508 }
13509 }
13510 else
13511 {
13512 /* Global symbol. */
13513 while (irel_ptr)
13514 {
13515 if (irel_ptr->keep == 0 && irel_ptr->next)
13516 {
13517 /* The one can be replaced, and we have to check
13518 whether there is any alignment point in the region. */
13519 internal_relocs = _bfd_elf_link_read_relocs
13520 (irel_ptr->sec->owner, irel_ptr->sec, NULL, NULL,
13521 TRUE /* keep_memory */);
13522 irelend = internal_relocs + irel_ptr->sec->reloc_count;
13523 if (!nds32_get_section_contents
13524 (irel_ptr->sec->owner, irel_ptr->sec, &contents))
13525 return FALSE;
13526
13527 irel = irel_ptr->irel;
13528 while (((irel_ptr->sec == irel_ptr->next->sec
13529 && irel_ptr->next->keep == 0
13530 && irel < irel_ptr->next->irel)
13531 || ((irel_ptr->sec != irel_ptr->next->sec
13532 || irel_ptr->next->keep == 1)
13533 && irel < irelend))
13534 && !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13535 && (irel->r_addend & 0x1f) == 2))
13536 irel++;
13537 if (irel >= irelend
13538 || !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13539 && (irel->r_addend & 0x1f) == 2
13540 && ((irel->r_offset
13541 - get_nds32_elf_blank_total (&relax_blank_list,
13542 irel->r_offset, 1)) & 0x02) == 0))
13543 {
13544 /* Replace by ifcall9. */
13545 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13546 if (!insert_nds32_elf_blank_recalc_total
13547 (&relax_blank_list, irel_ptr->irel->r_offset + 2, 2))
13548 return FALSE;
13549
13550 /* Delete the redundant code, and clear the relocation. */
13551 nds32_elf_relax_delete_blanks (irel_ptr->sec->owner,
13552 irel_ptr->sec,
13553 relax_blank_list);
13554 irel_ptr->irel->r_info =
13555 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13556 R_NDS32_10IFCU_PCREL_RELA);
13557 relax_blank_list = NULL;
13558 }
13559 }
13560
13561 irel_ptr = irel_ptr->next;
13562 }
13563 }
13564 }
13565 ptr = ptr->next;
13566 }
13567
13568 return TRUE;
13569 }
13570
13571 /* Relocate ifcall. */
13572
13573 static bfd_boolean
13574 nds32_elf_ifc_reloc (void)
13575 {
13576 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13577 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13578 struct elf_nds32_ifc_irel_list *irel_keeper = NULL;
13579 bfd_vma relocation, address;
13580 unsigned short insn16;
13581 bfd_byte *contents = NULL;
13582 static bfd_boolean done = FALSE;
13583
13584 if (done)
13585 return TRUE;
13586
13587 done = TRUE;
13588
13589 while (ptr)
13590 {
13591 /* Check the entry is enable ifcall. */
13592 if (ptr->enable == 1 || ptr->ex9_enable == 1)
13593 {
13594 /* Get the reserve jump. */
13595 irel_ptr = ptr->irel_head;
13596 while (irel_ptr)
13597 {
13598 if (irel_ptr->keep == 1)
13599 {
13600 irel_keeper = irel_ptr;
13601 break;
13602 }
13603 irel_ptr = irel_ptr->next;
13604 }
13605
13606 irel_ptr = ptr->irel_head;
13607 if (ptr->h == NULL)
13608 {
13609 /* Local symbol. */
13610 if (!nds32_get_section_contents (ptr->sec->owner, ptr->sec, &contents))
13611 return FALSE;
13612
13613 while (irel_ptr)
13614 {
13615 if (irel_ptr->keep == 0
13616 && ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13617 {
13618 relocation = irel_keeper->irel->r_offset;
13619 relocation = relocation - irel_ptr->irel->r_offset;
13620 while (irel_keeper && relocation > 1022)
13621 {
13622 irel_keeper = irel_keeper->next;
13623 if (irel_keeper && irel_keeper->keep == 1)
13624 {
13625 relocation = irel_keeper->irel->r_offset;
13626 relocation = relocation - irel_ptr->irel->r_offset;
13627 }
13628 }
13629 if (relocation > 1022)
13630 {
13631 /* Double check. */
13632 irel_keeper = ptr->irel_head;
13633 while (irel_keeper)
13634 {
13635 if (irel_keeper->keep == 1)
13636 {
13637 relocation = irel_keeper->irel->r_offset;
13638 relocation = relocation - irel_ptr->irel->r_offset;
13639 }
13640 if (relocation <= 1022)
13641 break;
13642 irel_keeper = irel_keeper->next;
13643 }
13644 if (!irel_keeper)
13645 return FALSE;
13646 }
13647 irel_ptr->irel->r_info =
13648 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13649 R_NDS32_NONE);
13650 insn16 = INSN_IFCALL9 | (relocation >> 1);
13651 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13652 }
13653 irel_ptr = irel_ptr->next;
13654 }
13655 }
13656 else
13657 {
13658 /* Global symbol. */
13659 while (irel_ptr)
13660 {
13661 if (irel_ptr->keep == 0
13662 && ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13663 {
13664 /* Get the distance between ifcall and jump. */
13665 relocation = (irel_keeper->irel->r_offset
13666 + irel_keeper->sec->output_section->vma
13667 + irel_keeper->sec->output_offset);
13668 address = (irel_ptr->irel->r_offset
13669 + irel_ptr->sec->output_section->vma
13670 + irel_ptr->sec->output_offset);
13671 relocation = relocation - address;
13672
13673 /* The distance is over ragne, find callee again. */
13674 while (irel_keeper && relocation > 1022)
13675 {
13676 irel_keeper = irel_keeper->next;
13677 if (irel_keeper && irel_keeper->keep ==1)
13678 {
13679 relocation = (irel_keeper->irel->r_offset
13680 + irel_keeper->sec->output_section->vma
13681 + irel_keeper->sec->output_offset);
13682 relocation = relocation - address;
13683 }
13684 }
13685
13686 if (relocation > 1022)
13687 {
13688 /* Double check. */
13689 irel_keeper = ptr->irel_head;
13690 while (irel_keeper)
13691 {
13692 if (irel_keeper->keep == 1)
13693 {
13694
13695 relocation = (irel_keeper->irel->r_offset
13696 + irel_keeper->sec->output_section->vma
13697 + irel_keeper->sec->output_offset);
13698 relocation = relocation - address;
13699 }
13700 if (relocation <= 1022)
13701 break;
13702 irel_keeper = irel_keeper->next;
13703 }
13704 if (!irel_keeper)
13705 return FALSE;
13706 }
13707 if (!nds32_get_section_contents
13708 (irel_ptr->sec->owner, irel_ptr->sec, &contents))
13709 return FALSE;
13710 insn16 = INSN_IFCALL9 | (relocation >> 1);
13711 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13712 irel_ptr->irel->r_info =
13713 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13714 R_NDS32_NONE);
13715 }
13716 irel_ptr =irel_ptr->next;
13717 }
13718 }
13719 }
13720 ptr = ptr->next;
13721 }
13722
13723 return TRUE;
13724 }
13725
13726 /* End of IFC relaxation. */
13727 \f
13728 /* EX9 Instruction Table Relaxation. */
13729
13730 /* Global hash list. */
13731 struct elf_link_hash_entry_list
13732 {
13733 struct elf_link_hash_entry *h;
13734 struct elf_link_hash_entry_list *next;
13735 };
13736
13737 /* Save different destination but same insn. */
13738 struct elf_link_hash_entry_mul_list
13739 {
13740 /* Global symbol times. */
13741 int times;
13742 /* Save relocation for each global symbol but useful?? */
13743 Elf_Internal_Rela *irel;
13744 /* For sethi, two sethi may have the same high-part but different low-parts. */
13745 Elf_Internal_Rela rel_backup;
13746 struct elf_link_hash_entry_list *h_list;
13747 struct elf_link_hash_entry_mul_list *next;
13748 };
13749
13750 /* Instruction hash table. */
13751 struct elf_nds32_code_hash_entry
13752 {
13753 struct bfd_hash_entry root;
13754 int times;
13755 /* For insn that can use relocation or constant ex: sethi. */
13756 int const_insn;
13757 asection *sec;
13758 struct elf_link_hash_entry_mul_list *m_list;
13759 /* Using r_addend. */
13760 Elf_Internal_Rela *irel;
13761 /* Using r_info. */
13762 Elf_Internal_Rela rel_backup;
13763 };
13764
13765 /* Instruction count list. */
13766 struct elf_nds32_insn_times_entry
13767 {
13768 const char *string;
13769 int times;
13770 int order;
13771 asection *sec;
13772 struct elf_link_hash_entry_mul_list *m_list;
13773 Elf_Internal_Rela *irel;
13774 Elf_Internal_Rela rel_backup;
13775 struct elf_nds32_insn_times_entry *next;
13776 };
13777
13778 /* J and JAL symbol list. */
13779 struct elf_nds32_symbol_entry
13780 {
13781 char *string;
13782 unsigned long insn;
13783 struct elf_nds32_symbol_entry *next;
13784 };
13785
13786 /* Relocation list. */
13787 struct elf_nds32_irel_entry
13788 {
13789 Elf_Internal_Rela *irel;
13790 struct elf_nds32_irel_entry *next;
13791 };
13792
13793 /* ex9.it insn need to be fixed. */
13794 struct elf_nds32_ex9_refix
13795 {
13796 Elf_Internal_Rela *irel;
13797 asection *sec;
13798 struct elf_link_hash_entry *h;
13799 int order;
13800 struct elf_nds32_ex9_refix *next;
13801 };
13802
13803 static struct bfd_hash_table ex9_code_table;
13804 static struct elf_nds32_insn_times_entry *ex9_insn_head = NULL;
13805 static struct elf_nds32_ex9_refix *ex9_refix_head = NULL;
13806
13807 /* EX9 hash function. */
13808
13809 static struct bfd_hash_entry *
13810 nds32_elf_code_hash_newfunc (struct bfd_hash_entry *entry,
13811 struct bfd_hash_table *table,
13812 const char *string)
13813 {
13814 struct elf_nds32_code_hash_entry *ret;
13815
13816 /* Allocate the structure if it has not already been allocated by a
13817 subclass. */
13818 if (entry == NULL)
13819 {
13820 entry = (struct bfd_hash_entry *)
13821 bfd_hash_allocate (table, sizeof (*ret));
13822 if (entry == NULL)
13823 return entry;
13824 }
13825
13826 /* Call the allocation method of the superclass. */
13827 entry = bfd_hash_newfunc (entry, table, string);
13828 if (entry == NULL)
13829 return entry;
13830
13831 ret = (struct elf_nds32_code_hash_entry*) entry;
13832 ret->times = 0;
13833 ret->const_insn = 0;
13834 ret->m_list = NULL;
13835 ret->sec = NULL;
13836 ret->irel = NULL;
13837 return &ret->root;
13838 }
13839
13840 /* Insert ex9 entry
13841 this insert must be stable sorted by times. */
13842
13843 static void
13844 nds32_elf_ex9_insert_entry (struct elf_nds32_insn_times_entry *ptr)
13845 {
13846 struct elf_nds32_insn_times_entry *temp;
13847 struct elf_nds32_insn_times_entry *temp2;
13848
13849 if (ex9_insn_head == NULL)
13850 {
13851 ex9_insn_head = ptr;
13852 ptr->next = NULL;
13853 }
13854 else
13855 {
13856 temp = ex9_insn_head;
13857 temp2 = ex9_insn_head;
13858 while (temp->next &&
13859 (temp->next->times >= ptr->times
13860 || temp->times == -1))
13861 {
13862 if (temp->times == -1)
13863 temp2 = temp;
13864 temp = temp->next;
13865 }
13866 if (ptr->times > temp->times && temp->times != -1)
13867 {
13868 ptr->next = temp;
13869 if (temp2->times == -1)
13870 temp2->next = ptr;
13871 else
13872 ex9_insn_head = ptr;
13873 }
13874 else if (temp->next == NULL)
13875 {
13876 temp->next = ptr;
13877 ptr->next = NULL;
13878 }
13879 else
13880 {
13881 ptr->next = temp->next;
13882 temp->next = ptr;
13883 }
13884 }
13885 }
13886
13887 /* Examine each insn times in hash table.
13888 Handle multi-link hash entry.
13889
13890 TODO: This function doesn't assign so much info since it is fake. */
13891
13892 static int
13893 nds32_elf_examine_insn_times (struct elf_nds32_code_hash_entry *h)
13894 {
13895 struct elf_nds32_insn_times_entry *ptr;
13896 int times;
13897
13898 if (h->m_list == NULL)
13899 {
13900 /* Local symbol insn or insn without relocation. */
13901 if (h->times < 3)
13902 return TRUE;
13903
13904 ptr = (struct elf_nds32_insn_times_entry *)
13905 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13906 ptr->times = h->times;
13907 ptr->string = h->root.string;
13908 ptr->m_list = NULL;
13909 ptr->sec = h->sec;
13910 ptr->irel = h->irel;
13911 ptr->rel_backup = h->rel_backup;
13912 nds32_elf_ex9_insert_entry (ptr);
13913 }
13914 else
13915 {
13916 /* Global symbol insn. */
13917 /* Only sethi insn has multiple m_list. */
13918 struct elf_link_hash_entry_mul_list *m_list = h->m_list;
13919
13920 times = 0;
13921 while (m_list)
13922 {
13923 times += m_list->times;
13924 m_list = m_list->next;
13925 }
13926 if (times >= 3)
13927 {
13928 m_list = h->m_list;
13929 ptr = (struct elf_nds32_insn_times_entry *)
13930 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13931 ptr->times = times; /* Use the total times. */
13932 ptr->string = h->root.string;
13933 ptr->m_list = m_list;
13934 ptr->sec = h->sec;
13935 ptr->irel = m_list->irel;
13936 ptr->rel_backup = m_list->rel_backup;
13937 nds32_elf_ex9_insert_entry (ptr);
13938 }
13939 if (h->const_insn == 1)
13940 {
13941 /* sethi with constant value. */
13942 if (h->times < 3)
13943 return TRUE;
13944
13945 ptr = (struct elf_nds32_insn_times_entry *)
13946 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13947 ptr->times = h->times;
13948 ptr->string = h->root.string;
13949 ptr->m_list = NULL;
13950 ptr->sec = NULL;
13951 ptr->irel = NULL;
13952 ptr->rel_backup = h->rel_backup;
13953 nds32_elf_ex9_insert_entry (ptr);
13954 }
13955 }
13956 return TRUE;
13957 }
13958
13959 /* Count each insn times in hash table.
13960 Handle multi-link hash entry. */
13961
13962 static int
13963 nds32_elf_count_insn_times (struct elf_nds32_code_hash_entry *h)
13964 {
13965 int reservation, times;
13966 unsigned long relocation, min_relocation;
13967 struct elf_nds32_insn_times_entry *ptr;
13968
13969 if (h->m_list == NULL)
13970 {
13971 /* Local symbol insn or insn without relocation. */
13972 if (h->times < 3)
13973 return TRUE;
13974 ptr = (struct elf_nds32_insn_times_entry *)
13975 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13976 ptr->times = h->times;
13977 ptr->string = h->root.string;
13978 ptr->m_list = NULL;
13979 ptr->sec = h->sec;
13980 ptr->irel = h->irel;
13981 ptr->rel_backup = h->rel_backup;
13982 nds32_elf_ex9_insert_entry (ptr);
13983 }
13984 else
13985 {
13986 /* Global symbol insn. */
13987 /* Only sethi insn has multiple m_list. */
13988 struct elf_link_hash_entry_mul_list *m_list = h->m_list;
13989
13990 if (ELF32_R_TYPE (m_list->rel_backup.r_info) == R_NDS32_HI20_RELA
13991 && m_list->next != NULL)
13992 {
13993 /* Sethi insn has different symbol or addend but has same hi20. */
13994 times = 0;
13995 reservation = 1;
13996 relocation = 0;
13997 min_relocation = 0xffffffff;
13998 while (m_list)
13999 {
14000 /* Get the minimum sethi address
14001 and calculate how many entry the sethi-list have to use. */
14002 if ((m_list->h_list->h->root.type == bfd_link_hash_defined
14003 || m_list->h_list->h->root.type == bfd_link_hash_defweak)
14004 && (m_list->h_list->h->root.u.def.section != NULL
14005 && m_list->h_list->h->root.u.def.section->output_section != NULL))
14006 {
14007 relocation = (m_list->h_list->h->root.u.def.value +
14008 m_list->h_list->h->root.u.def.section->output_section->vma +
14009 m_list->h_list->h->root.u.def.section->output_offset);
14010 relocation += m_list->irel->r_addend;
14011 }
14012 else
14013 relocation = 0;
14014 if (relocation < min_relocation)
14015 min_relocation = relocation;
14016 times += m_list->times;
14017 m_list = m_list->next;
14018 }
14019 if (min_relocation < ex9_relax_size)
14020 reservation = (min_relocation >> 12) + 1;
14021 else
14022 reservation = (min_relocation >> 12)
14023 - ((min_relocation - ex9_relax_size) >> 12) + 1;
14024 if (reservation < (times / 3))
14025 {
14026 /* Efficient enough to use ex9. */
14027 int i;
14028
14029 for (i = reservation ; i > 0; i--)
14030 {
14031 /* Allocate number of reservation ex9 entry. */
14032 ptr = (struct elf_nds32_insn_times_entry *)
14033 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14034 ptr->times = h->m_list->times / reservation;
14035 ptr->string = h->root.string;
14036 ptr->m_list = h->m_list;
14037 ptr->sec = h->sec;
14038 ptr->irel = h->m_list->irel;
14039 ptr->rel_backup = h->m_list->rel_backup;
14040 nds32_elf_ex9_insert_entry (ptr);
14041 }
14042 }
14043 }
14044 else
14045 {
14046 /* Normal global symbol that means no different address symbol
14047 using same ex9 entry. */
14048 if (m_list->times >= 3)
14049 {
14050 ptr = (struct elf_nds32_insn_times_entry *)
14051 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14052 ptr->times = m_list->times;
14053 ptr->string = h->root.string;
14054 ptr->m_list = h->m_list;
14055 ptr->sec = h->sec;
14056 ptr->irel = h->m_list->irel;
14057 ptr->rel_backup = h->m_list->rel_backup;
14058 nds32_elf_ex9_insert_entry (ptr);
14059 }
14060 }
14061
14062 if (h->const_insn == 1)
14063 {
14064 /* sethi with constant value. */
14065 if (h->times < 3)
14066 return TRUE;
14067
14068 ptr = (struct elf_nds32_insn_times_entry *)
14069 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14070 ptr->times = h->times;
14071 ptr->string = h->root.string;
14072 ptr->m_list = NULL;
14073 ptr->sec = NULL;
14074 ptr->irel = NULL;
14075 ptr->rel_backup = h->rel_backup;
14076 nds32_elf_ex9_insert_entry (ptr);
14077 }
14078 }
14079
14080 return TRUE;
14081 }
14082
14083 /* Hash table traverse function. */
14084
14085 static void
14086 nds32_elf_code_hash_traverse (int (*func) (struct elf_nds32_code_hash_entry*))
14087 {
14088 unsigned int i;
14089
14090 ex9_code_table.frozen = 1;
14091 for (i = 0; i < ex9_code_table.size; i++)
14092 {
14093 struct bfd_hash_entry *p;
14094
14095 for (p = ex9_code_table.table[i]; p != NULL; p = p->next)
14096 if (!func ((struct elf_nds32_code_hash_entry *) p))
14097 goto out;
14098 }
14099 out:
14100 ex9_code_table.frozen = 0;
14101 }
14102
14103
14104 /* Give order number to insn list. */
14105
14106 static void
14107 nds32_elf_order_insn_times (struct bfd_link_info *info)
14108 {
14109 struct elf_nds32_insn_times_entry *ex9_insn;
14110 struct elf_nds32_insn_times_entry *temp = NULL;
14111 struct elf_nds32_link_hash_table *table;
14112 int ex9_limit;
14113 int number = 0;
14114
14115 if (ex9_insn_head == NULL)
14116 return;
14117
14118 /* The max number of entries is 512. */
14119 ex9_insn = ex9_insn_head;
14120 table = nds32_elf_hash_table (info);
14121 ex9_limit = table->ex9_limit;
14122
14123 ex9_insn = ex9_insn_head;
14124
14125 while (ex9_insn != NULL && number < ex9_limit)
14126 {
14127 ex9_insn->order = number;
14128 number++;
14129 temp = ex9_insn;
14130 ex9_insn = ex9_insn->next;
14131 }
14132
14133 if (ex9_insn && temp)
14134 temp->next = NULL;
14135
14136 while (ex9_insn != NULL)
14137 {
14138 /* Free useless entry. */
14139 temp = ex9_insn;
14140 ex9_insn = ex9_insn->next;
14141 free (temp);
14142 }
14143 }
14144
14145 /* Build .ex9.itable section. */
14146
14147 static void
14148 nds32_elf_ex9_build_itable (struct bfd_link_info *link_info)
14149 {
14150 asection *table_sec;
14151 struct elf_nds32_insn_times_entry *ptr;
14152 bfd *it_abfd;
14153 int number = 0;
14154 bfd_byte *contents = NULL;
14155
14156 for (it_abfd = link_info->input_bfds; it_abfd != NULL;
14157 it_abfd = it_abfd->link.next)
14158 {
14159 /* Find the section .ex9.itable, and put all entries into it. */
14160 table_sec = bfd_get_section_by_name (it_abfd, ".ex9.itable");
14161 if (table_sec != NULL)
14162 {
14163 if (!nds32_get_section_contents (it_abfd, table_sec, &contents))
14164 return;
14165
14166 for (ptr = ex9_insn_head; ptr !=NULL ; ptr = ptr->next)
14167 number++;
14168
14169 table_sec->size = number * 4;
14170
14171 if (number == 0)
14172 return;
14173
14174 elf_elfheader (link_info->output_bfd)->e_flags |= E_NDS32_HAS_EX9_INST;
14175 number = 0;
14176 for (ptr = ex9_insn_head; ptr !=NULL ; ptr = ptr->next)
14177 {
14178 long val;
14179
14180 val = strtol (ptr->string, NULL, 16);
14181 bfd_putb32 ((bfd_vma) val, (char *) contents + (number * 4));
14182 number++;
14183 }
14184 break;
14185 }
14186 }
14187 }
14188
14189 /* Get insn with regs according to relocation type. */
14190
14191 static void
14192 nds32_elf_get_insn_with_reg (Elf_Internal_Rela *irel,
14193 uint32_t insn, uint32_t *insn_with_reg)
14194 {
14195 reloc_howto_type *howto = NULL;
14196
14197 if (irel == NULL
14198 || (ELF32_R_TYPE (irel->r_info) >= (int) ARRAY_SIZE (nds32_elf_howto_table)
14199 && (ELF32_R_TYPE (irel->r_info) - R_NDS32_RELAX_ENTRY)
14200 >= (int) ARRAY_SIZE (nds32_elf_relax_howto_table)))
14201 {
14202 *insn_with_reg = insn;
14203 return;
14204 }
14205
14206 howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
14207 *insn_with_reg = insn & (0xffffffff ^ howto->dst_mask);
14208 }
14209
14210 /* Mask number of address bits according to relocation. */
14211
14212 static unsigned long
14213 nds32_elf_irel_mask (Elf_Internal_Rela *irel)
14214 {
14215 reloc_howto_type *howto = NULL;
14216
14217 if (irel == NULL
14218 || (ELF32_R_TYPE (irel->r_info) >= (int) ARRAY_SIZE (nds32_elf_howto_table)
14219 && (ELF32_R_TYPE (irel->r_info) - R_NDS32_RELAX_ENTRY)
14220 >= (int) ARRAY_SIZE (nds32_elf_relax_howto_table)))
14221 return 0;
14222
14223 howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
14224 return howto->dst_mask;
14225 }
14226
14227 static void
14228 nds32_elf_insert_irel_entry (struct elf_nds32_irel_entry **irel_list,
14229 struct elf_nds32_irel_entry *irel_ptr)
14230 {
14231 if (*irel_list == NULL)
14232 {
14233 *irel_list = irel_ptr;
14234 irel_ptr->next = NULL;
14235 }
14236 else
14237 {
14238 irel_ptr->next = *irel_list;
14239 *irel_list = irel_ptr;
14240 }
14241 }
14242
14243 static void
14244 nds32_elf_ex9_insert_fix (asection * sec, Elf_Internal_Rela * irel,
14245 struct elf_link_hash_entry *h, int order)
14246 {
14247 struct elf_nds32_ex9_refix *ptr;
14248
14249 ptr = bfd_malloc (sizeof (struct elf_nds32_ex9_refix));
14250 ptr->sec = sec;
14251 ptr->irel = irel;
14252 ptr->h = h;
14253 ptr->order = order;
14254 ptr->next = NULL;
14255
14256 if (ex9_refix_head == NULL)
14257 ex9_refix_head = ptr;
14258 else
14259 {
14260 struct elf_nds32_ex9_refix *temp = ex9_refix_head;
14261
14262 while (temp->next != NULL)
14263 temp = temp->next;
14264 temp->next = ptr;
14265 }
14266 }
14267
14268 enum
14269 {
14270 DATA_EXIST = 1,
14271 CLEAN_PRE = 1 << 1,
14272 PUSH_PRE = 1 << 2
14273 };
14274
14275 /* Check relocation type if supporting for ex9. */
14276
14277 static int
14278 nds32_elf_ex9_relocation_check (struct bfd_link_info *info,
14279 Elf_Internal_Rela **irel,
14280 Elf_Internal_Rela *irelend,
14281 nds32_elf_blank_t *relax_blank_list,
14282 asection *sec,bfd_vma *off,
14283 bfd_byte *contents)
14284 {
14285 /* Suppress ex9 if `.no_relax ex9' or inner loop. */
14286 bfd_boolean nested_ex9, nested_loop;
14287 bfd_boolean ex9_loop_aware;
14288 /* We use the highest 1 byte of result to record
14289 how many bytes location counter has to move. */
14290 int result = 0;
14291 Elf_Internal_Rela *irel_save = NULL;
14292 struct elf_nds32_link_hash_table *table;
14293
14294 table = nds32_elf_hash_table (info);
14295 ex9_loop_aware = table->ex9_loop_aware;
14296
14297 while ((*irel) != NULL && (*irel) < irelend && *off == (*irel)->r_offset)
14298 {
14299 switch (ELF32_R_TYPE ((*irel)->r_info))
14300 {
14301 case R_NDS32_RELAX_REGION_BEGIN:
14302 /* Ignore code block. */
14303 nested_ex9 = FALSE;
14304 nested_loop = FALSE;
14305 if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG)
14306 || (ex9_loop_aware
14307 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG)))
14308 {
14309 /* Check the region if loop or not. If it is true and
14310 ex9-loop-aware is true, ignore the region till region end. */
14311 /* To save the status for in .no_relax ex9 region and
14312 loop region to conform the block can do ex9 relaxation. */
14313 nested_ex9 = ((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG);
14314 nested_loop = (ex9_loop_aware
14315 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG));
14316 while ((*irel) && (*irel) < irelend && (nested_ex9 || nested_loop))
14317 {
14318 (*irel)++;
14319 if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_RELAX_REGION_BEGIN)
14320 {
14321 /* There may be nested region. */
14322 if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG) != 0)
14323 nested_ex9 = TRUE;
14324 else if (ex9_loop_aware
14325 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG))
14326 nested_loop = TRUE;
14327 }
14328 else if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_RELAX_REGION_END)
14329 {
14330 /* The end of region. */
14331 if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG) != 0)
14332 nested_ex9 = FALSE;
14333 else if (ex9_loop_aware
14334 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG))
14335 nested_loop = FALSE;
14336 }
14337 else if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_LABEL
14338 && ((*irel)->r_addend & 0x1f) == 2)
14339 {
14340 /* Alignment exist in the region. */
14341 result |= CLEAN_PRE;
14342 if (((*irel)->r_offset -
14343 get_nds32_elf_blank_total (&relax_blank_list,
14344 (*irel)->r_offset, 0)) & 0x02)
14345 result |= PUSH_PRE;
14346 }
14347 }
14348 if ((*irel) >= irelend)
14349 *off = sec->size;
14350 else
14351 *off = (*irel)->r_offset;
14352
14353 /* The final instruction in the region, regard this one as data to ignore it. */
14354 result |= DATA_EXIST;
14355 return result;
14356 }
14357 break;
14358
14359 case R_NDS32_LABEL:
14360 if (((*irel)->r_addend & 0x1f) == 2)
14361 {
14362 /* Check this point is align and decide to do ex9 or not. */
14363 result |= CLEAN_PRE;
14364 if (((*irel)->r_offset -
14365 get_nds32_elf_blank_total (&relax_blank_list,
14366 (*irel)->r_offset, 0)) & 0x02)
14367 result |= PUSH_PRE;
14368 }
14369 break;
14370 case R_NDS32_32_RELA:
14371 /* Data. */
14372 result |= (4 << 24);
14373 result |= DATA_EXIST;
14374 break;
14375 case R_NDS32_16_RELA:
14376 /* Data. */
14377 result |= (2 << 24);
14378 result |= DATA_EXIST;
14379 break;
14380 case R_NDS32_DATA:
14381 /* Data. */
14382 /* The least code alignment is 2. If the data is only one byte,
14383 we have to shift one more byte. */
14384 if ((*irel)->r_addend == 1)
14385 result |= ((*irel)->r_addend << 25) ;
14386 else
14387 result |= ((*irel)->r_addend << 24) ;
14388
14389 result |= DATA_EXIST;
14390 break;
14391
14392 case R_NDS32_25_PCREL_RELA:
14393 case R_NDS32_SDA16S3_RELA:
14394 case R_NDS32_SDA15S3_RELA:
14395 case R_NDS32_SDA15S3:
14396 case R_NDS32_SDA17S2_RELA:
14397 case R_NDS32_SDA15S2_RELA:
14398 case R_NDS32_SDA12S2_SP_RELA:
14399 case R_NDS32_SDA12S2_DP_RELA:
14400 case R_NDS32_SDA15S2:
14401 case R_NDS32_SDA18S1_RELA:
14402 case R_NDS32_SDA15S1_RELA:
14403 case R_NDS32_SDA15S1:
14404 case R_NDS32_SDA19S0_RELA:
14405 case R_NDS32_SDA15S0_RELA:
14406 case R_NDS32_SDA15S0:
14407 case R_NDS32_HI20_RELA:
14408 case R_NDS32_LO12S0_ORI_RELA:
14409 case R_NDS32_LO12S0_RELA:
14410 case R_NDS32_LO12S1_RELA:
14411 case R_NDS32_LO12S2_RELA:
14412 /* These relocation is supported ex9 relaxation currently. */
14413 /* We have to save the relocation for using later, since we have
14414 to check there is any alignment in the same address. */
14415 irel_save = *irel;
14416 break;
14417 default:
14418 /* Not support relocations. */
14419 if (ELF32_R_TYPE ((*irel)->r_info) < ARRAY_SIZE (nds32_elf_howto_table)
14420 && ELF32_R_TYPE ((*irel)->r_info) != R_NDS32_NONE
14421 && ELF32_R_TYPE ((*irel)->r_info) != R_NDS32_INSN16)
14422 {
14423 /* Note: To optimize aggressively, it maybe can ignore R_NDS32_INSN16 here.
14424 But we have to consider if there is any side-effect. */
14425 if (!(result & DATA_EXIST))
14426 {
14427 /* We have to confirm there is no data relocation in the
14428 same address. In general case, this won't happen. */
14429 /* We have to do ex9 conservative, for those relocation not
14430 considerd we ignore instruction. */
14431 result |= DATA_EXIST;
14432 if (*(contents + *off) & 0x80)
14433 result |= (2 << 24);
14434 else
14435 result |= (4 << 24);
14436 break;
14437 }
14438 }
14439 }
14440 if ((*irel) < irelend
14441 && ((*irel) + 1) < irelend
14442 && (*irel)->r_offset == ((*irel) + 1)->r_offset)
14443 /* There are relocations pointing to the same address, we have to
14444 check all of them. */
14445 (*irel)++;
14446 else
14447 {
14448 if (irel_save)
14449 *irel = irel_save;
14450 return result;
14451 }
14452 }
14453 return result;
14454 }
14455
14456 /* Replace with ex9 instruction. */
14457
14458 static bfd_boolean
14459 nds32_elf_ex9_push_insn (uint16_t insn16, bfd_byte *contents, bfd_vma pre_off,
14460 nds32_elf_blank_t **relax_blank_list,
14461 struct elf_nds32_irel_entry *pre_irel_ptr,
14462 struct elf_nds32_irel_entry **irel_list)
14463 {
14464 if (insn16 != 0)
14465 {
14466 /* Implement the ex9 relaxation. */
14467 bfd_putb16 (insn16, contents + pre_off);
14468 if (!insert_nds32_elf_blank_recalc_total (relax_blank_list,
14469 pre_off + 2, 2))
14470 return FALSE;
14471 if (pre_irel_ptr != NULL)
14472 nds32_elf_insert_irel_entry (irel_list, pre_irel_ptr);
14473 }
14474 return TRUE;
14475 }
14476
14477 /* Replace input file instruction which is in ex9 itable. */
14478
14479 static bfd_boolean
14480 nds32_elf_ex9_replace_instruction (struct bfd_link_info *info, bfd *abfd, asection *sec)
14481 {
14482 struct elf_nds32_insn_times_entry *ex9_insn = ex9_insn_head;
14483 bfd_byte *contents = NULL;
14484 bfd_vma off;
14485 uint16_t insn16, insn_ex9;
14486 /* `pre_*' are used to track previous instruction that can use ex9.it. */
14487 bfd_vma pre_off = -1;
14488 uint16_t pre_insn16 = 0;
14489 struct elf_nds32_irel_entry *pre_irel_ptr = NULL;
14490 Elf_Internal_Rela *internal_relocs;
14491 Elf_Internal_Rela *irel;
14492 Elf_Internal_Rela *irelend;
14493 Elf_Internal_Shdr *symtab_hdr;
14494 Elf_Internal_Sym *isym = NULL;
14495 nds32_elf_blank_t *relax_blank_list = NULL;
14496 uint32_t insn = 0;
14497 uint32_t insn_with_reg = 0;
14498 uint32_t it_insn;
14499 uint32_t it_insn_with_reg;
14500 unsigned long r_symndx;
14501 asection *isec;
14502 struct elf_nds32_irel_entry *irel_list = NULL;
14503 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
14504 int data_flag, do_replace, save_irel;
14505 struct elf_link_hash_entry_list *h_list;
14506
14507
14508 /* Load section instructions, relocations, and symbol table. */
14509 if (!nds32_get_section_contents (abfd, sec, &contents)
14510 || !nds32_get_local_syms (abfd, sec, &isym))
14511 return FALSE;
14512 internal_relocs =
14513 _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, TRUE /* keep_memory */);
14514 irelend = internal_relocs + sec->reloc_count;
14515 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
14516
14517 off = 0;
14518
14519 /* Check if the object enable ex9. */
14520 irel = find_relocs_at_address (internal_relocs, internal_relocs,
14521 irelend, R_NDS32_RELAX_ENTRY);
14522
14523 /* Check this section trigger ex9 relaxation. */
14524 if (irel == NULL
14525 || irel >= irelend
14526 || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
14527 || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
14528 && !(irel->r_addend & R_NDS32_RELAX_ENTRY_EX9_FLAG)))
14529 return TRUE;
14530
14531 irel = internal_relocs;
14532
14533 /* Check alignment and fetch proper relocation. */
14534 while (off < sec->size)
14535 {
14536 struct elf_link_hash_entry *h = NULL;
14537 struct elf_nds32_irel_entry *irel_ptr = NULL;
14538
14539 /* Syn the instruction and the relocation. */
14540 while (irel != NULL && irel < irelend && irel->r_offset < off)
14541 irel++;
14542
14543 data_flag = nds32_elf_ex9_relocation_check (info, &irel, irelend,
14544 relax_blank_list, sec,
14545 &off, contents);
14546 if (data_flag & PUSH_PRE)
14547 if (!nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14548 &relax_blank_list, pre_irel_ptr,
14549 &irel_list))
14550 return FALSE;
14551
14552 if (data_flag & CLEAN_PRE)
14553 {
14554 pre_off = 0;
14555 pre_insn16 = 0;
14556 pre_irel_ptr = NULL;
14557 }
14558 if (data_flag & DATA_EXIST)
14559 {
14560 /* We save the move offset in the highest byte. */
14561 off += (data_flag >> 24);
14562 continue;
14563 }
14564
14565 if (*(contents + off) & 0x80)
14566 {
14567 /* 2-byte instruction. */
14568 off += 2;
14569 continue;
14570 }
14571
14572 /* Load the instruction and its opcode with register for comparing. */
14573 ex9_insn = ex9_insn_head;
14574 insn = bfd_getb32 (contents + off);
14575 insn_with_reg = 0;
14576 while (ex9_insn)
14577 {
14578 it_insn = strtol (ex9_insn->string, NULL, 16);
14579 it_insn_with_reg = 0;
14580 do_replace = 0;
14581 save_irel = 0;
14582
14583 if (irel != NULL && irel < irelend && irel->r_offset == off)
14584 {
14585 /* Insn with relocation. */
14586 nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
14587
14588 if (ex9_insn->irel != NULL)
14589 nds32_elf_get_insn_with_reg (ex9_insn->irel, it_insn,
14590 &it_insn_with_reg);
14591
14592 if (ex9_insn->irel != NULL
14593 && (ELF32_R_TYPE (irel->r_info) ==
14594 ELF32_R_TYPE (ex9_insn->irel->r_info))
14595 && (insn_with_reg == it_insn_with_reg))
14596 {
14597 /* Insn relocation and format is the same as table entry. */
14598
14599 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA
14600 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_ORI_RELA
14601 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_RELA
14602 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S1_RELA
14603 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_RELA
14604 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
14605 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
14606 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
14607 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
14608 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
14609 && ELF32_R_TYPE (irel->r_info) <=
14610 R_NDS32_SDA12S2_SP_RELA)
14611 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
14612 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
14613 {
14614 r_symndx = ELF32_R_SYM (irel->r_info);
14615 if (r_symndx < symtab_hdr->sh_info)
14616 {
14617 /* Local symbol. */
14618 int shndx = isym[r_symndx].st_shndx;
14619
14620 isec = elf_elfsections (abfd)[shndx]->bfd_section;
14621 if (ex9_insn->sec == isec
14622 && ex9_insn->irel->r_addend == irel->r_addend
14623 && ex9_insn->irel->r_info == irel->r_info)
14624 {
14625 do_replace = 1;
14626 save_irel = 1;
14627 }
14628 }
14629 else
14630 {
14631 /* External symbol. */
14632 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14633 if (ex9_insn->m_list)
14634 {
14635 h_list = ex9_insn->m_list->h_list;
14636 while (h_list)
14637 {
14638 if (h == h_list->h
14639 && (ex9_insn->m_list->irel->r_addend ==
14640 irel->r_addend))
14641 {
14642 do_replace = 1;
14643 save_irel = 1;
14644 break;
14645 }
14646 h_list = h_list->next;
14647 }
14648 }
14649 }
14650 }
14651 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_HI20_RELA)
14652 {
14653 r_symndx = ELF32_R_SYM (irel->r_info);
14654 if (r_symndx < symtab_hdr->sh_info)
14655 {
14656 /* Local symbols. Compare its base symbol and offset. */
14657 int shndx = isym[r_symndx].st_shndx;
14658
14659 isec = elf_elfsections (abfd)[shndx]->bfd_section;
14660 if (ex9_insn->sec == isec
14661 && ex9_insn->irel->r_addend == irel->r_addend
14662 && ex9_insn->irel->r_info == irel->r_info)
14663 {
14664 do_replace = 1;
14665 save_irel = 1;
14666 }
14667 }
14668 else
14669 {
14670 /* External symbol. */
14671 struct elf_link_hash_entry_mul_list *m_list;
14672
14673 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14674 m_list = ex9_insn->m_list;
14675
14676 while (m_list)
14677 {
14678 h_list = m_list->h_list;
14679
14680 while (h_list)
14681 {
14682 if (h == h_list->h
14683 && (m_list->irel->r_addend
14684 == irel->r_addend))
14685 {
14686 do_replace = 1;
14687 save_irel = 1;
14688 if (ex9_insn->next
14689 && ex9_insn->m_list
14690 && ex9_insn->m_list == ex9_insn->next->m_list)
14691 {
14692 /* sethi multiple entry must be fixed */
14693 nds32_elf_ex9_insert_fix (sec, irel,
14694 h, ex9_insn->order);
14695 }
14696 break;
14697 }
14698 h_list = h_list->next;
14699 }
14700 m_list = m_list->next;
14701 }
14702 }
14703 }
14704 }
14705
14706 /* Import table: Check the symbol hash table and the
14707 jump target. Only R_NDS32_25_PCREL_RELA now. */
14708 else if (ex9_insn->times == -1
14709 && ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA)
14710 {
14711 nds32_elf_get_insn_with_reg (irel, it_insn, &it_insn_with_reg);
14712 if (insn_with_reg == it_insn_with_reg)
14713 {
14714 char code[10];
14715 bfd_vma relocation;
14716
14717 r_symndx = ELF32_R_SYM (irel->r_info);
14718 if (r_symndx >= symtab_hdr->sh_info)
14719 {
14720 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14721 if ((h->root.type == bfd_link_hash_defined
14722 || h->root.type == bfd_link_hash_defweak)
14723 && h->root.u.def.section != NULL
14724 && h->root.u.def.section->output_section != NULL
14725 && h->root.u.def.section->gc_mark == 1
14726 && bfd_is_abs_section (h->root.u.def.section)
14727 && h->root.u.def.value > sec->size)
14728 {
14729 relocation = h->root.u.def.value +
14730 h->root.u.def.section->output_section->vma +
14731 h->root.u.def.section->output_offset;
14732 relocation += irel->r_addend;
14733 insn = insn_with_reg
14734 | ((relocation >> 1) & 0xffffff);
14735 snprintf (code, sizeof (code), "%08x", insn);
14736 if (strcmp (code, ex9_insn->string) == 0)
14737 {
14738 do_replace = 1;
14739 save_irel = 1;
14740 }
14741 }
14742 }
14743 }
14744 }
14745 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
14746 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
14747 || ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
14748 {
14749 /* These relocations do not have to relocate contens, so it can
14750 be regard as instruction without relocation. */
14751 if (insn == it_insn && ex9_insn->irel == NULL)
14752 do_replace = 1;
14753 }
14754 }
14755 else
14756 {
14757 /* Instruction without relocation, we only
14758 have to compare their byte code. */
14759 if (insn == it_insn && ex9_insn->irel == NULL)
14760 do_replace = 1;
14761 }
14762
14763 /* Insntruction match so replacing the code here. */
14764 if (do_replace == 1)
14765 {
14766 /* There are two formats of ex9 instruction. */
14767 if (ex9_insn->order < 32)
14768 insn_ex9 = INSN_EX9_IT_2;
14769 else
14770 insn_ex9 = INSN_EX9_IT_1;
14771 insn16 = insn_ex9 | ex9_insn->order;
14772
14773 /* Insert ex9 instruction. */
14774 nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14775 &relax_blank_list, pre_irel_ptr,
14776 &irel_list);
14777 pre_off = off;
14778 pre_insn16 = insn16;
14779
14780 if (save_irel)
14781 {
14782 /* For instuction with relocation do relax. */
14783 irel_ptr = (struct elf_nds32_irel_entry *)
14784 bfd_malloc (sizeof (struct elf_nds32_irel_entry));
14785 irel_ptr->irel = irel;
14786 irel_ptr->next = NULL;
14787 pre_irel_ptr = irel_ptr;
14788 }
14789 else
14790 pre_irel_ptr = NULL;
14791 break;
14792 }
14793 ex9_insn = ex9_insn->next;
14794 }
14795 off += 4;
14796 }
14797
14798 /* Insert ex9 instruction. */
14799 nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14800 &relax_blank_list, pre_irel_ptr,
14801 &irel_list);
14802
14803 /* Delete the redundant code. */
14804 if (relax_blank_list)
14805 {
14806 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
14807 relax_blank_list = NULL;
14808 }
14809
14810 /* Clear the relocation that is replaced by ex9. */
14811 while (irel_list)
14812 {
14813 struct elf_nds32_irel_entry *irel_ptr;
14814
14815 irel_ptr = irel_list;
14816 irel_list = irel_ptr->next;
14817 irel_ptr->irel->r_info =
14818 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info), R_NDS32_TRAN);
14819 free (irel_ptr);
14820 }
14821 return TRUE;
14822 }
14823
14824 /* Initialize ex9 hash table. */
14825
14826 int
14827 nds32_elf_ex9_init (void)
14828 {
14829 if (!bfd_hash_table_init_n (&ex9_code_table, nds32_elf_code_hash_newfunc,
14830 sizeof (struct elf_nds32_code_hash_entry),
14831 1023))
14832 {
14833 (*_bfd_error_handler) (_("Linker: cannot init ex9 hash table error \n"));
14834 return FALSE;
14835 }
14836 return TRUE;
14837 }
14838
14839 /* Predict how many bytes will be relaxed with ex9 and ifc. */
14840
14841 static void
14842 nds32_elf_ex9_total_relax (struct bfd_link_info *info)
14843 {
14844 struct elf_nds32_insn_times_entry *ex9_insn;
14845 struct elf_nds32_insn_times_entry *temp;
14846 int target_optimize;
14847 struct elf_nds32_link_hash_table *table;
14848
14849 if (ex9_insn_head == NULL)
14850 return;
14851
14852 table = nds32_elf_hash_table (info);
14853 target_optimize = table->target_optimize;
14854 ex9_insn = ex9_insn_head;
14855 while (ex9_insn)
14856 {
14857 ex9_relax_size = ex9_insn->times * 2 + ex9_relax_size;
14858 temp = ex9_insn;
14859 ex9_insn = ex9_insn->next;
14860 free (temp);
14861 }
14862 ex9_insn_head = NULL;
14863
14864 if ((target_optimize & NDS32_RELAX_JUMP_IFC_ON))
14865 {
14866 /* Examine ifc reduce size. */
14867 struct elf_nds32_ifc_symbol_entry *ifc_ent = ifc_symbol_head;
14868 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
14869 int size = 0;
14870
14871 while (ifc_ent)
14872 {
14873 if (ifc_ent->enable == 0)
14874 {
14875 /* Not ifc yet. */
14876 irel_ptr = ifc_ent->irel_head;
14877 while (irel_ptr)
14878 {
14879 size += 2;
14880 irel_ptr = irel_ptr->next;
14881 }
14882 }
14883 size -= 2;
14884 ifc_ent = ifc_ent->next;
14885 }
14886 ex9_relax_size += size;
14887 }
14888 }
14889
14890 /* Finish ex9 table. */
14891
14892 void
14893 nds32_elf_ex9_finish (struct bfd_link_info *link_info)
14894 {
14895 nds32_elf_code_hash_traverse (nds32_elf_examine_insn_times);
14896 nds32_elf_order_insn_times (link_info);
14897 nds32_elf_ex9_total_relax (link_info);
14898 /* Traverse the hash table and count its times. */
14899 nds32_elf_code_hash_traverse (nds32_elf_count_insn_times);
14900 nds32_elf_order_insn_times (link_info);
14901 nds32_elf_ex9_build_itable (link_info);
14902 }
14903
14904 /* Relocate the entries in ex9 table. */
14905
14906 static bfd_vma
14907 nds32_elf_ex9_reloc_insn (struct elf_nds32_insn_times_entry *ptr,
14908 struct bfd_link_info *link_info)
14909 {
14910 Elf_Internal_Sym *isym = NULL;
14911 bfd_vma relocation = -1;
14912 struct elf_link_hash_entry *h;
14913
14914 if (ptr->m_list != NULL)
14915 {
14916 /* Global symbol. */
14917 h = ptr->m_list->h_list->h;
14918 if ((h->root.type == bfd_link_hash_defined
14919 || h->root.type == bfd_link_hash_defweak)
14920 && h->root.u.def.section != NULL
14921 && h->root.u.def.section->output_section != NULL)
14922 {
14923
14924 relocation = h->root.u.def.value +
14925 h->root.u.def.section->output_section->vma +
14926 h->root.u.def.section->output_offset;
14927 relocation += ptr->m_list->irel->r_addend;
14928 }
14929 else
14930 relocation = 0;
14931 }
14932 else if (ptr->sec !=NULL)
14933 {
14934 /* Local symbol. */
14935 Elf_Internal_Sym sym;
14936 asection *sec = NULL;
14937 asection isec;
14938 asection *isec_ptr = &isec;
14939 Elf_Internal_Rela irel_backup = *(ptr->irel);
14940 asection *sec_backup = ptr->sec;
14941 bfd *abfd = ptr->sec->owner;
14942
14943 if (!nds32_get_local_syms (abfd, sec, &isym))
14944 return FALSE;
14945 isym = isym + ELF32_R_SYM (ptr->irel->r_info);
14946
14947 sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
14948 if (sec != NULL)
14949 *isec_ptr = *sec;
14950 sym = *isym;
14951
14952 /* The purpose is same as elf_link_input_bfd. */
14953 if (isec_ptr != NULL
14954 && isec_ptr->sec_info_type == SEC_INFO_TYPE_MERGE
14955 && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
14956 {
14957 sym.st_value =
14958 _bfd_merged_section_offset (ptr->sec->output_section->owner, &isec_ptr,
14959 elf_section_data (isec_ptr)->sec_info,
14960 isym->st_value);
14961 }
14962 relocation = _bfd_elf_rela_local_sym (link_info->output_bfd, &sym,
14963 &ptr->sec, ptr->irel);
14964 if (ptr->irel != NULL)
14965 relocation += ptr->irel->r_addend;
14966
14967 /* Restore origin value since there may be some insntructions that
14968 could not be replaced with ex9.it. */
14969 *(ptr->irel) = irel_backup;
14970 ptr->sec = sec_backup;
14971 }
14972
14973 return relocation;
14974 }
14975
14976 /* Import ex9 table and build list. */
14977
14978 void
14979 nds32_elf_ex9_import_table (struct bfd_link_info *info)
14980 {
14981 int num = 0;
14982 bfd_byte *contents;
14983 unsigned long insn;
14984 FILE *ex9_import_file;
14985 int update_ex9_table;
14986 struct elf_nds32_link_hash_table *table;
14987
14988 table = nds32_elf_hash_table (info);
14989 ex9_import_file = table->ex9_import_file;
14990 rewind (table->ex9_import_file);
14991
14992 contents = bfd_malloc (sizeof (bfd_byte) * 4);
14993
14994 /* Read instructions from the input file and build the list. */
14995 while (!feof (ex9_import_file))
14996 {
14997 char *code;
14998 struct elf_nds32_insn_times_entry *ptr;
14999 size_t nread;
15000
15001 nread = fread (contents, sizeof (bfd_byte) * 4, 1, ex9_import_file);
15002 /* Ignore the final byte 0x0a. */
15003 if (nread < 1)
15004 break;
15005 insn = bfd_getb32 (contents);
15006 code = bfd_malloc (sizeof (char) * 9);
15007 snprintf (code, 9, "%08lx", insn);
15008 ptr = bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
15009 ptr->string = code;
15010 ptr->order = num;
15011 ptr->times = -1;
15012 ptr->sec = NULL;
15013 ptr->m_list = NULL;
15014 ptr->rel_backup.r_offset = 0;
15015 ptr->rel_backup.r_info = 0;
15016 ptr->rel_backup.r_addend = 0;
15017 ptr->irel = NULL;
15018 ptr->next = NULL;
15019 nds32_elf_ex9_insert_entry (ptr);
15020 num++;
15021 }
15022
15023 update_ex9_table = table->update_ex9_table;
15024 if (update_ex9_table == 1)
15025 {
15026 /* It has to consider of sethi need to use multiple page
15027 but it not be done yet. */
15028 nds32_elf_code_hash_traverse (nds32_elf_examine_insn_times);
15029 nds32_elf_order_insn_times (info);
15030 }
15031 }
15032
15033 /* Export ex9 table. */
15034
15035 static void
15036 nds32_elf_ex9_export (struct bfd_link_info *info,
15037 bfd_byte *contents, int size)
15038 {
15039 FILE *ex9_export_file;
15040 struct elf_nds32_link_hash_table *table;
15041
15042 table = nds32_elf_hash_table (info);
15043 ex9_export_file = table->ex9_export_file;
15044 fwrite (contents, sizeof (bfd_byte), size, ex9_export_file);
15045 fclose (ex9_export_file);
15046 }
15047
15048 /* Adjust relocations of J and JAL in ex9.itable.
15049 Export ex9 table. */
15050
15051 static void
15052 nds32_elf_ex9_reloc_jmp (struct bfd_link_info *link_info)
15053 {
15054 asection *table_sec = NULL;
15055 struct elf_nds32_insn_times_entry *ex9_insn = ex9_insn_head;
15056 struct elf_nds32_insn_times_entry *temp_ptr, *temp_ptr2;
15057 bfd *it_abfd;
15058 uint32_t insn, insn_with_reg, source_insn;
15059 bfd_byte *contents = NULL, *source_contents = NULL;
15060 int size = 0;
15061 bfd_vma gp;
15062 int shift, update_ex9_table, offset = 0;
15063 reloc_howto_type *howto = NULL;
15064 Elf_Internal_Rela rel_backup;
15065 unsigned short insn_ex9;
15066 struct elf_nds32_link_hash_table *table;
15067 FILE *ex9_export_file;
15068 static bfd_boolean done = FALSE;
15069
15070 if (done)
15071 return;
15072
15073 done = TRUE;
15074
15075 table = nds32_elf_hash_table (link_info);
15076 if (table)
15077 table->relax_status |= NDS32_RELAX_EX9_DONE;
15078
15079
15080 update_ex9_table = table->update_ex9_table;
15081 /* Generated ex9.itable exactly. */
15082 if (update_ex9_table == 0)
15083 {
15084 for (it_abfd = link_info->input_bfds; it_abfd != NULL;
15085 it_abfd = it_abfd->link.next)
15086 {
15087 table_sec = bfd_get_section_by_name (it_abfd, ".ex9.itable");
15088 if (table_sec != NULL)
15089 break;
15090 }
15091
15092 if (table_sec != NULL)
15093 {
15094 bfd *output_bfd;
15095
15096 output_bfd = table_sec->output_section->owner;
15097 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15098 if (table_sec->size == 0)
15099 return;
15100
15101 if (!nds32_get_section_contents (it_abfd, table_sec, &contents))
15102 return;
15103 }
15104 }
15105 else
15106 {
15107 /* Set gp. */
15108 bfd *output_bfd;
15109
15110 output_bfd = link_info->input_bfds->sections->output_section->owner;
15111 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15112 contents = bfd_malloc (sizeof (bfd_byte) * 2048);
15113 }
15114
15115 /* Relocate instruction. */
15116 while (ex9_insn)
15117 {
15118 bfd_vma relocation, min_relocation = 0xffffffff;
15119
15120 insn = strtol (ex9_insn->string, NULL, 16);
15121 insn_with_reg = 0;
15122 if (ex9_insn->m_list != NULL || ex9_insn->sec != NULL)
15123 {
15124 if (ex9_insn->m_list)
15125 rel_backup = ex9_insn->m_list->rel_backup;
15126 else
15127 rel_backup = ex9_insn->rel_backup;
15128
15129 nds32_elf_get_insn_with_reg (&rel_backup, insn, &insn_with_reg);
15130 howto =
15131 bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE
15132 (rel_backup.r_info));
15133 shift = howto->rightshift;
15134 if (ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_25_PCREL_RELA
15135 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S0_ORI_RELA
15136 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S0_RELA
15137 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S1_RELA
15138 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S2_RELA)
15139 {
15140 relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15141 insn =
15142 insn_with_reg | ((relocation >> shift) &
15143 nds32_elf_irel_mask (&rel_backup));
15144 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15145 }
15146 else if ((ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA15S3
15147 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA15S0)
15148 || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA15S3_RELA
15149 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA15S0_RELA)
15150 || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA12S2_DP_RELA
15151 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA12S2_SP_RELA)
15152 || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA16S3_RELA
15153 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA19S0_RELA))
15154 {
15155 relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15156 insn =
15157 insn_with_reg | (((relocation - gp) >> shift) &
15158 nds32_elf_irel_mask (&rel_backup));
15159 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15160 }
15161 else if (ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_HI20_RELA)
15162 {
15163 /* Sethi may be multiple entry for one insn. */
15164 if (ex9_insn->next && ex9_insn->m_list
15165 && ex9_insn->m_list == ex9_insn->next->m_list)
15166 {
15167 struct elf_link_hash_entry_mul_list *m_list;
15168 struct elf_nds32_ex9_refix *fix_ptr;
15169 struct elf_link_hash_entry *h;
15170
15171 temp_ptr = ex9_insn;
15172 temp_ptr2 = ex9_insn;
15173 m_list = ex9_insn->m_list;
15174 while (m_list)
15175 {
15176 h = m_list->h_list->h;
15177 relocation = h->root.u.def.value +
15178 h->root.u.def.section->output_section->vma +
15179 h->root.u.def.section->output_offset;
15180 relocation += m_list->irel->r_addend;
15181
15182 if (relocation < min_relocation)
15183 min_relocation = relocation;
15184 m_list = m_list->next;
15185 }
15186 relocation = min_relocation;
15187
15188 /* Put insntruction into ex9 table. */
15189 insn = insn_with_reg
15190 | ((relocation >> shift) & nds32_elf_irel_mask (&rel_backup));
15191 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15192 relocation = relocation + 0x1000; /* hi20 */
15193
15194 while (ex9_insn->next && ex9_insn->m_list
15195 && ex9_insn->m_list == ex9_insn->next->m_list)
15196 {
15197 /* Multiple sethi. */
15198 ex9_insn = ex9_insn->next;
15199 size += 4;
15200 insn =
15201 insn_with_reg | ((relocation >> shift) &
15202 nds32_elf_irel_mask (&rel_backup));
15203 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15204 relocation = relocation + 0x1000; /* hi20 */
15205 }
15206
15207 fix_ptr = ex9_refix_head;
15208 while (fix_ptr)
15209 {
15210 /* Fix ex9 insn. */
15211 /* temp_ptr2 points to the head of multiple sethi. */
15212 temp_ptr = temp_ptr2;
15213 while (fix_ptr->order != temp_ptr->order && fix_ptr->next)
15214 {
15215 fix_ptr = fix_ptr->next;
15216 }
15217 if (fix_ptr->order != temp_ptr->order)
15218 break;
15219
15220 /* Set source insn. */
15221 relocation =
15222 fix_ptr->h->root.u.def.value +
15223 fix_ptr->h->root.u.def.section->output_section->vma +
15224 fix_ptr->h->root.u.def.section->output_offset;
15225 relocation += fix_ptr->irel->r_addend;
15226 /* sethi imm is imm20s. */
15227 source_insn = insn_with_reg | ((relocation >> shift) & 0xfffff);
15228
15229 while (temp_ptr)
15230 {
15231 /* Match entry and source code. */
15232 insn = bfd_getb32 (contents + (temp_ptr->order) * 4 + offset);
15233 if (insn == source_insn)
15234 {
15235 /* Fix the ex9 insn. */
15236 if (temp_ptr->order != fix_ptr->order)
15237 {
15238 if (!nds32_get_section_contents
15239 (fix_ptr->sec->owner, fix_ptr->sec,
15240 &source_contents))
15241 (*_bfd_error_handler)
15242 (_("Linker: error cannot fixed ex9 relocation \n"));
15243 if (temp_ptr->order < 32)
15244 insn_ex9 = INSN_EX9_IT_2;
15245 else
15246 insn_ex9 = INSN_EX9_IT_1;
15247 insn_ex9 = insn_ex9 | temp_ptr->order;
15248 bfd_putb16 (insn_ex9, source_contents + fix_ptr->irel->r_offset);
15249 }
15250 break;
15251 }
15252 else
15253 {
15254 if (!temp_ptr->next || temp_ptr->m_list != temp_ptr->next->m_list)
15255 (*_bfd_error_handler)
15256 (_("Linker: error cannot fixed ex9 relocation \n"));
15257 else
15258 temp_ptr = temp_ptr->next;
15259 }
15260 }
15261 fix_ptr = fix_ptr->next;
15262 }
15263 }
15264 else
15265 {
15266 relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15267 insn = insn_with_reg
15268 | ((relocation >> shift) & nds32_elf_irel_mask (&rel_backup));
15269 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15270 }
15271 }
15272 }
15273 else
15274 {
15275 /* Insn without relocation does not have to be fixed
15276 if need to update export table. */
15277 if (update_ex9_table == 1)
15278 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15279 }
15280 ex9_insn = ex9_insn->next;
15281 size += 4;
15282 }
15283
15284 ex9_export_file = table->ex9_export_file;
15285 if (ex9_export_file != NULL)
15286 nds32_elf_ex9_export (link_info, contents, table_sec->size);
15287 else if (update_ex9_table == 1)
15288 {
15289 table->ex9_export_file = table->ex9_import_file;
15290 rewind (table->ex9_export_file);
15291 nds32_elf_ex9_export (link_info, contents, size);
15292 }
15293 }
15294
15295 /* Generate ex9 hash table. */
15296
15297 static bfd_boolean
15298 nds32_elf_ex9_build_hash_table (bfd *abfd, asection *sec,
15299 struct bfd_link_info *link_info)
15300 {
15301 Elf_Internal_Rela *internal_relocs;
15302 Elf_Internal_Rela *irelend;
15303 Elf_Internal_Rela *irel;
15304 Elf_Internal_Rela *jrel;
15305 Elf_Internal_Rela rel_backup;
15306 Elf_Internal_Shdr *symtab_hdr;
15307 Elf_Internal_Sym *isym = NULL;
15308 asection *isec;
15309 struct elf_link_hash_entry **sym_hashes;
15310 bfd_byte *contents = NULL;
15311 bfd_vma off = 0;
15312 unsigned long r_symndx;
15313 uint32_t insn, insn_with_reg;
15314 struct elf_link_hash_entry *h;
15315 int data_flag, shift, align;
15316 bfd_vma relocation;
15317 /* Suppress ex9 if `.no_relax ex9' or inner loop. */
15318 reloc_howto_type *howto = NULL;
15319
15320 sym_hashes = elf_sym_hashes (abfd);
15321 /* Load section instructions, relocations, and symbol table. */
15322 if (!nds32_get_section_contents (abfd, sec, &contents))
15323 return FALSE;
15324
15325 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
15326 TRUE /* keep_memory */);
15327 irelend = internal_relocs + sec->reloc_count;
15328 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
15329 if (!nds32_get_local_syms (abfd, sec, &isym))
15330 return FALSE;
15331
15332 /* Check the object if enable ex9. */
15333 irel = find_relocs_at_address (internal_relocs, internal_relocs, irelend,
15334 R_NDS32_RELAX_ENTRY);
15335
15336 /* Check this section trigger ex9 relaxation. */
15337 if (irel == NULL
15338 || irel >= irelend
15339 || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
15340 || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
15341 && !(irel->r_addend & R_NDS32_RELAX_ENTRY_EX9_FLAG)))
15342 return TRUE;
15343
15344 irel = internal_relocs;
15345
15346 /* Push each insn into hash table. */
15347 while (off < sec->size)
15348 {
15349 char code[10];
15350 struct elf_nds32_code_hash_entry *entry;
15351
15352 while (irel != NULL && irel < irelend && irel->r_offset < off)
15353 irel++;
15354
15355 data_flag = nds32_elf_ex9_relocation_check (link_info, &irel, irelend,
15356 NULL, sec, &off, contents);
15357 if (data_flag & DATA_EXIST)
15358 {
15359 /* We save the move offset in the highest byte. */
15360 off += (data_flag >> 24);
15361 continue;
15362 }
15363
15364 if (*(contents + off) & 0x80)
15365 {
15366 off += 2;
15367 }
15368 else
15369 {
15370 h = NULL;
15371 isec = NULL;
15372 jrel = NULL;
15373 rel_backup.r_info = 0;
15374 rel_backup.r_offset = 0;
15375 rel_backup.r_addend = 0;
15376 /* Load the instruction and its opcode with register for comparing. */
15377 insn = bfd_getb32 (contents + off);
15378 insn_with_reg = 0;
15379 if (irel != NULL && irel < irelend && irel->r_offset == off)
15380 {
15381 nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
15382 howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
15383 shift = howto->rightshift;
15384 align = (1 << shift) - 1;
15385 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA
15386 || ELF32_R_TYPE (irel->r_info) == R_NDS32_HI20_RELA
15387 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_ORI_RELA
15388 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_RELA
15389 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S1_RELA
15390 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_RELA
15391 ||(ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
15392 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
15393 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
15394 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
15395 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
15396 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA12S2_SP_RELA)
15397 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
15398 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
15399 {
15400 r_symndx = ELF32_R_SYM (irel->r_info);
15401 jrel = irel;
15402 rel_backup = *irel;
15403 if (r_symndx < symtab_hdr->sh_info)
15404 {
15405 /* Local symbol. */
15406 int shndx = isym[r_symndx].st_shndx;
15407
15408 bfd_vma st_value = (isym + r_symndx)->st_value;
15409 isec = elf_elfsections (abfd)[shndx]->bfd_section;
15410 relocation = (isec->output_section->vma + isec->output_offset
15411 + st_value + irel->r_addend);
15412 }
15413 else
15414 {
15415 /* External symbol. */
15416 bfd_boolean warned ATTRIBUTE_UNUSED;
15417 bfd_boolean ignored ATTRIBUTE_UNUSED;
15418 bfd_boolean unresolved_reloc ATTRIBUTE_UNUSED;
15419 asection *sym_sec;
15420
15421 /* Maybe there is a better way to get h and relocation */
15422 RELOC_FOR_GLOBAL_SYMBOL (link_info, abfd, sec, irel,
15423 r_symndx, symtab_hdr, sym_hashes,
15424 h, sym_sec, relocation,
15425 unresolved_reloc, warned, ignored);
15426 relocation += irel->r_addend;
15427 if ((h->root.type != bfd_link_hash_defined
15428 && h->root.type != bfd_link_hash_defweak)
15429 || strcmp (h->root.root.string, "_FP_BASE_") == 0)
15430 {
15431 off += 4;
15432 continue;
15433 }
15434 }
15435
15436 /* Check for gp relative instruction alignment. */
15437 if ((ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
15438 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
15439 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
15440 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
15441 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
15442 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA12S2_SP_RELA)
15443 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
15444 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
15445 {
15446 bfd_vma gp;
15447 bfd *output_bfd = sec->output_section->owner;
15448 bfd_reloc_status_type r;
15449
15450 /* If the symbol is in the abs section, the out_bfd will be null.
15451 This happens when the relocation has a symbol@GOTOFF. */
15452 r = nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15453 if (r != bfd_reloc_ok)
15454 {
15455 off += 4;
15456 continue;
15457 }
15458
15459 relocation -= gp;
15460
15461 /* Make sure alignment is correct. */
15462 if (relocation & align)
15463 {
15464 /* Incorrect alignment. */
15465 (*_bfd_error_handler)
15466 (_("%s: warning: unaligned small data access. "
15467 "For entry: {%d, %d, %d}, addr = 0x%x, align = 0x%x."),
15468 bfd_get_filename (abfd), irel->r_offset,
15469 irel->r_info, irel->r_addend, relocation, align);
15470 off += 4;
15471 continue;
15472 }
15473 }
15474
15475 insn = insn_with_reg
15476 | ((relocation >> shift) & nds32_elf_irel_mask (irel));
15477 }
15478 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
15479 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
15480 || ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
15481 {
15482 /* These relocations do not have to relocate contens, so it can
15483 be regard as instruction without relocation. */
15484 }
15485 else
15486 {
15487 off += 4;
15488 continue;
15489 }
15490 }
15491
15492 snprintf (code, sizeof (code), "%08x", insn);
15493 /* Copy "code". */
15494 entry = (struct elf_nds32_code_hash_entry*)
15495 bfd_hash_lookup (&ex9_code_table, code, TRUE, TRUE);
15496 if (entry == NULL)
15497 {
15498 (*_bfd_error_handler)
15499 (_("%P%F: failed creating ex9.it %s hash table: %E\n"), code);
15500 return FALSE;
15501 }
15502 if (h)
15503 {
15504 if (h->root.type == bfd_link_hash_undefined)
15505 return TRUE;
15506 /* Global symbol. */
15507 /* In order to do sethi with different symbol but same value. */
15508 if (entry->m_list == NULL)
15509 {
15510 struct elf_link_hash_entry_mul_list *m_list_new;
15511 struct elf_link_hash_entry_list *h_list_new;
15512
15513 m_list_new = (struct elf_link_hash_entry_mul_list *)
15514 bfd_malloc (sizeof (struct elf_link_hash_entry_mul_list));
15515 h_list_new = (struct elf_link_hash_entry_list *)
15516 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15517 entry->m_list = m_list_new;
15518 m_list_new->h_list = h_list_new;
15519 m_list_new->rel_backup = rel_backup;
15520 m_list_new->times = 1;
15521 m_list_new->irel = jrel;
15522 m_list_new->next = NULL;
15523 h_list_new->h = h;
15524 h_list_new->next = NULL;
15525 }
15526 else
15527 {
15528 struct elf_link_hash_entry_mul_list *m_list = entry->m_list;
15529 struct elf_link_hash_entry_list *h_list;
15530
15531 while (m_list)
15532 {
15533 /* Build the different symbols that point to the same address. */
15534 h_list = m_list->h_list;
15535 if (h_list->h->root.u.def.value == h->root.u.def.value
15536 && h_list->h->root.u.def.section->output_section->vma
15537 == h->root.u.def.section->output_section->vma
15538 && h_list->h->root.u.def.section->output_offset
15539 == h->root.u.def.section->output_offset
15540 && m_list->rel_backup.r_addend == rel_backup.r_addend)
15541 {
15542 m_list->times++;
15543 m_list->irel = jrel;
15544 while (h_list->h != h && h_list->next)
15545 h_list = h_list->next;
15546 if (h_list->h != h)
15547 {
15548 struct elf_link_hash_entry_list *h_list_new;
15549
15550 h_list_new = (struct elf_link_hash_entry_list *)
15551 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15552 h_list->next = h_list_new;
15553 h_list_new->h = h;
15554 h_list_new->next = NULL;
15555 }
15556 break;
15557 }
15558 /* The sethi case may have different address but the
15559 hi20 is the same. */
15560 else if (ELF32_R_TYPE (jrel->r_info) == R_NDS32_HI20_RELA
15561 && m_list->next == NULL)
15562 {
15563 struct elf_link_hash_entry_mul_list *m_list_new;
15564 struct elf_link_hash_entry_list *h_list_new;
15565
15566 m_list_new = (struct elf_link_hash_entry_mul_list *)
15567 bfd_malloc (sizeof (struct elf_link_hash_entry_mul_list));
15568 h_list_new = (struct elf_link_hash_entry_list *)
15569 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15570 m_list->next = m_list_new;
15571 m_list_new->h_list = h_list_new;
15572 m_list_new->rel_backup = rel_backup;
15573 m_list_new->times = 1;
15574 m_list_new->irel = jrel;
15575 m_list_new->next = NULL;
15576 h_list_new->h = h;
15577 h_list_new->next = NULL;
15578 break;
15579 }
15580 m_list = m_list->next;
15581 }
15582 if (!m_list)
15583 {
15584 off += 4;
15585 continue;
15586 }
15587 }
15588 }
15589 else
15590 {
15591 /* Local symbol and insn without relocation*/
15592 entry->times++;
15593 entry->rel_backup = rel_backup;
15594 }
15595
15596 /* Use in sethi insn with constant and global symbol in same format. */
15597 if (!jrel)
15598 entry->const_insn = 1;
15599 else
15600 entry->irel = jrel;
15601 entry->sec = isec;
15602 off += 4;
15603 }
15604 }
15605 return TRUE;
15606 }
15607
15608 /* Set the _ITB_BASE, and point it to ex9 table. */
15609
15610 bfd_boolean
15611 nds32_elf_ex9_itb_base (struct bfd_link_info *link_info)
15612 {
15613 bfd *abfd;
15614 asection *sec;
15615 bfd *output_bfd = NULL;
15616 struct bfd_link_hash_entry *bh = NULL;
15617
15618 if (is_ITB_BASE_set == 1)
15619 return TRUE;
15620
15621 is_ITB_BASE_set = 1;
15622
15623 bh = bfd_link_hash_lookup (link_info->hash, "_ITB_BASE_", FALSE, FALSE, TRUE);
15624
15625 if (bh && (bh->type == bfd_link_hash_defined
15626 || bh->type == bfd_link_hash_defweak))
15627 return TRUE;
15628
15629 for (abfd = link_info->input_bfds; abfd != NULL;
15630 abfd = abfd->link.next)
15631 {
15632 sec = bfd_get_section_by_name (abfd, ".ex9.itable");
15633 if (sec != NULL)
15634 {
15635 output_bfd = sec->output_section->owner;
15636 break;
15637 }
15638 }
15639 if (output_bfd == NULL)
15640 {
15641 output_bfd = link_info->output_bfd;
15642 if (output_bfd->sections == NULL)
15643 return TRUE;
15644 else
15645 sec = bfd_abs_section_ptr;
15646 }
15647 bh = bfd_link_hash_lookup (link_info->hash, "_ITB_BASE_",
15648 FALSE, FALSE, TRUE);
15649 return (_bfd_generic_link_add_one_symbol
15650 (link_info, output_bfd, "_ITB_BASE_",
15651 BSF_GLOBAL | BSF_WEAK, sec, 0,
15652 (const char *) NULL, FALSE, get_elf_backend_data
15653 (output_bfd)->collect, &bh));
15654 } /* End EX9.IT */
15655 \f
15656
15657 #define ELF_ARCH bfd_arch_nds32
15658 #define ELF_MACHINE_CODE EM_NDS32
15659 #define ELF_MAXPAGESIZE 0x1000
15660 #define ELF_TARGET_ID NDS32_ELF_DATA
15661
15662 #define TARGET_BIG_SYM nds32_elf32_be_vec
15663 #define TARGET_BIG_NAME "elf32-nds32be"
15664 #define TARGET_LITTLE_SYM nds32_elf32_le_vec
15665 #define TARGET_LITTLE_NAME "elf32-nds32le"
15666
15667 #define elf_info_to_howto nds32_info_to_howto
15668 #define elf_info_to_howto_rel nds32_info_to_howto_rel
15669
15670 #define bfd_elf32_bfd_link_hash_table_create nds32_elf_link_hash_table_create
15671 #define bfd_elf32_bfd_merge_private_bfd_data nds32_elf_merge_private_bfd_data
15672 #define bfd_elf32_bfd_print_private_bfd_data nds32_elf_print_private_bfd_data
15673 #define bfd_elf32_bfd_relax_section nds32_elf_relax_section
15674 #define bfd_elf32_bfd_set_private_flags nds32_elf_set_private_flags
15675
15676 #define bfd_elf32_mkobject nds32_elf_mkobject
15677 #define elf_backend_action_discarded nds32_elf_action_discarded
15678 #define elf_backend_add_symbol_hook nds32_elf_add_symbol_hook
15679 #define elf_backend_check_relocs nds32_elf_check_relocs
15680 #define elf_backend_adjust_dynamic_symbol nds32_elf_adjust_dynamic_symbol
15681 #define elf_backend_create_dynamic_sections nds32_elf_create_dynamic_sections
15682 #define elf_backend_finish_dynamic_sections nds32_elf_finish_dynamic_sections
15683 #define elf_backend_finish_dynamic_symbol nds32_elf_finish_dynamic_symbol
15684 #define elf_backend_size_dynamic_sections nds32_elf_size_dynamic_sections
15685 #define elf_backend_relocate_section nds32_elf_relocate_section
15686 #define elf_backend_gc_mark_hook nds32_elf_gc_mark_hook
15687 #define elf_backend_gc_sweep_hook nds32_elf_gc_sweep_hook
15688 #define elf_backend_grok_prstatus nds32_elf_grok_prstatus
15689 #define elf_backend_grok_psinfo nds32_elf_grok_psinfo
15690 #define elf_backend_reloc_type_class nds32_elf_reloc_type_class
15691 #define elf_backend_copy_indirect_symbol nds32_elf_copy_indirect_symbol
15692 #define elf_backend_link_output_symbol_hook nds32_elf_output_symbol_hook
15693 #define elf_backend_output_arch_syms nds32_elf_output_arch_syms
15694 #define elf_backend_object_p nds32_elf_object_p
15695 #define elf_backend_final_write_processing nds32_elf_final_write_processing
15696 #define elf_backend_special_sections nds32_elf_special_sections
15697 #define bfd_elf32_bfd_get_relocated_section_contents \
15698 nds32_elf_get_relocated_section_contents
15699
15700 #define elf_backend_can_gc_sections 1
15701 #define elf_backend_can_refcount 1
15702 #define elf_backend_want_got_plt 1
15703 #define elf_backend_plt_readonly 1
15704 #define elf_backend_want_plt_sym 0
15705 #define elf_backend_got_header_size 12
15706 #define elf_backend_may_use_rel_p 1
15707 #define elf_backend_default_use_rela_p 1
15708 #define elf_backend_may_use_rela_p 1
15709
15710 #include "elf32-target.h"
15711
15712 #undef ELF_MAXPAGESIZE
15713 #define ELF_MAXPAGESIZE 0x2000
15714
15715 #undef TARGET_BIG_SYM
15716 #define TARGET_BIG_SYM nds32_elf32_linux_be_vec
15717 #undef TARGET_BIG_NAME
15718 #define TARGET_BIG_NAME "elf32-nds32be-linux"
15719 #undef TARGET_LITTLE_SYM
15720 #define TARGET_LITTLE_SYM nds32_elf32_linux_le_vec
15721 #undef TARGET_LITTLE_NAME
15722 #define TARGET_LITTLE_NAME "elf32-nds32le-linux"
15723 #undef elf32_bed
15724 #define elf32_bed elf32_nds32_lin_bed
15725
15726 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.34271 seconds and 5 git commands to generate.