]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf32-nds32.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Delete duplicate target short-cuts to dynamic sections
[thirdparty/binutils-gdb.git] / bfd / elf32-nds32.c
1 /* NDS32-specific support for 32-bit ELF.
2 Copyright (C) 2012-2016 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
81 (bfd *, struct bfd_link_info *);
82 static bfd_boolean nds32_elf_print_private_bfd_data (bfd *, void *);
83 static bfd_boolean nds32_elf_gc_sweep_hook
84 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
85 static bfd_boolean nds32_elf_check_relocs
86 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
87 static asection *nds32_elf_gc_mark_hook
88 (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
89 struct elf_link_hash_entry *, Elf_Internal_Sym *);
90 static bfd_boolean nds32_elf_adjust_dynamic_symbol
91 (struct bfd_link_info *, struct elf_link_hash_entry *);
92 static bfd_boolean nds32_elf_size_dynamic_sections
93 (bfd *, struct bfd_link_info *);
94 static bfd_boolean nds32_elf_create_dynamic_sections
95 (bfd *, struct bfd_link_info *);
96 static bfd_boolean nds32_elf_finish_dynamic_sections
97 (bfd *, struct bfd_link_info *info);
98 static bfd_boolean nds32_elf_finish_dynamic_symbol
99 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
100 Elf_Internal_Sym *);
101 static bfd_boolean nds32_elf_mkobject (bfd *);
102
103 /* Nds32 helper functions. */
104 static bfd_reloc_status_type nds32_elf_final_sda_base
105 (bfd *, struct bfd_link_info *, bfd_vma *, bfd_boolean);
106 static bfd_boolean allocate_dynrelocs (struct elf_link_hash_entry *, void *);
107 static bfd_boolean readonly_dynrelocs (struct elf_link_hash_entry *, void *);
108 static Elf_Internal_Rela *find_relocs_at_address
109 (Elf_Internal_Rela *, Elf_Internal_Rela *,
110 Elf_Internal_Rela *, enum elf_nds32_reloc_type);
111 static bfd_vma calculate_memory_address
112 (bfd *, Elf_Internal_Rela *, Elf_Internal_Sym *, Elf_Internal_Shdr *);
113 static int nds32_get_section_contents (bfd *, asection *,
114 bfd_byte **, bfd_boolean);
115 static bfd_boolean nds32_elf_ex9_build_hash_table
116 (bfd *, asection *, struct bfd_link_info *);
117 static bfd_boolean nds32_elf_ex9_itb_base (struct bfd_link_info *);
118 static void nds32_elf_ex9_import_table (struct bfd_link_info *);
119 static void nds32_elf_ex9_finish (struct bfd_link_info *);
120 static void nds32_elf_ex9_reloc_jmp (struct bfd_link_info *);
121 static void nds32_elf_get_insn_with_reg
122 (Elf_Internal_Rela *, uint32_t, uint32_t *);
123 static int nds32_get_local_syms (bfd *, asection *ATTRIBUTE_UNUSED,
124 Elf_Internal_Sym **);
125 static bfd_boolean nds32_elf_ex9_replace_instruction
126 (struct bfd_link_info *, bfd *, asection *);
127 static bfd_boolean nds32_elf_ifc_calc (struct bfd_link_info *, bfd *,
128 asection *);
129 static bfd_boolean nds32_elf_ifc_finish (struct bfd_link_info *);
130 static bfd_boolean nds32_elf_ifc_replace (struct bfd_link_info *);
131 static bfd_boolean nds32_elf_ifc_reloc (void);
132 static bfd_boolean nds32_relax_fp_as_gp
133 (struct bfd_link_info *link_info, bfd *abfd, asection *sec,
134 Elf_Internal_Rela *internal_relocs, Elf_Internal_Rela *irelend,
135 Elf_Internal_Sym *isymbuf);
136 static bfd_boolean nds32_fag_remove_unused_fpbase
137 (bfd *abfd, asection *sec, Elf_Internal_Rela *internal_relocs,
138 Elf_Internal_Rela *irelend);
139 static bfd_byte *
140 nds32_elf_get_relocated_section_contents (bfd *abfd,
141 struct bfd_link_info *link_info,
142 struct bfd_link_order *link_order,
143 bfd_byte *data,
144 bfd_boolean relocatable,
145 asymbol **symbols);
146
147 enum
148 {
149 MACH_V1 = bfd_mach_n1h,
150 MACH_V2 = bfd_mach_n1h_v2,
151 MACH_V3 = bfd_mach_n1h_v3,
152 MACH_V3M = bfd_mach_n1h_v3m
153 };
154
155 #define MIN(a, b) ((a) > (b) ? (b) : (a))
156 #define MAX(a, b) ((a) > (b) ? (a) : (b))
157
158 /* The name of the dynamic interpreter. This is put in the .interp
159 section. */
160 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
161
162 /* The nop opcode we use. */
163 #define NDS32_NOP32 0x40000009
164 #define NDS32_NOP16 0x9200
165
166 /* The size in bytes of an entry in the procedure linkage table. */
167 #define PLT_ENTRY_SIZE 24
168 #define PLT_HEADER_SIZE 24
169
170 /* The first entry in a procedure linkage table are reserved,
171 and the initial contents are unimportant (we zero them out).
172 Subsequent entries look like this. */
173 #define PLT0_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(.got+4) */
174 #define PLT0_ENTRY_WORD1 0x58f78000 /* ori r15, r25, LO12(.got+4) */
175 #define PLT0_ENTRY_WORD2 0x05178000 /* lwi r17, [r15+0] */
176 #define PLT0_ENTRY_WORD3 0x04f78001 /* lwi r15, [r15+4] */
177 #define PLT0_ENTRY_WORD4 0x4a003c00 /* jr r15 */
178
179 /* $ta is change to $r15 (from $r25). */
180 #define PLT0_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[1]@GOT) */
181 #define PLT0_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[1]@GOT) */
182 #define PLT0_PIC_ENTRY_WORD2 0x40f7f400 /* add r15, gp, r15 */
183 #define PLT0_PIC_ENTRY_WORD3 0x05178000 /* lwi r17, [r15+0] */
184 #define PLT0_PIC_ENTRY_WORD4 0x04f78001 /* lwi r15, [r15+4] */
185 #define PLT0_PIC_ENTRY_WORD5 0x4a003c00 /* jr r15 */
186
187 #define PLT_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(&got[n+3]) */
188 #define PLT_ENTRY_WORD1 0x04f78000 /* lwi r15, r15, LO12(&got[n+3]) */
189 #define PLT_ENTRY_WORD2 0x4a003c00 /* jr r15 */
190 #define PLT_ENTRY_WORD3 0x45000000 /* movi r16, sizeof(RELA) * n */
191 #define PLT_ENTRY_WORD4 0x48000000 /* j .plt0. */
192
193 #define PLT_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[n+3]@GOT) */
194 #define PLT_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[n+3]@GOT) */
195 #define PLT_PIC_ENTRY_WORD2 0x38febc02 /* lw r15, [gp+r15] */
196 #define PLT_PIC_ENTRY_WORD3 0x4a003c00 /* jr r15 */
197 #define PLT_PIC_ENTRY_WORD4 0x45000000 /* movi r16, sizeof(RELA) * n */
198 #define PLT_PIC_ENTRY_WORD5 0x48000000 /* j .plt0 */
199
200 /* These are macros used to get the relocation accurate value. */
201 #define ACCURATE_8BIT_S1 (0x100)
202 #define ACCURATE_U9BIT_S1 (0x400)
203 #define ACCURATE_12BIT_S1 (0x2000)
204 #define ACCURATE_14BIT_S1 (0x4000)
205 #define ACCURATE_19BIT (0x40000)
206
207 /* These are macros used to get the relocation conservative value. */
208 #define CONSERVATIVE_8BIT_S1 (0x100 - 4)
209 #define CONSERVATIVE_14BIT_S1 (0x4000 - 4)
210 #define CONSERVATIVE_16BIT_S1 (0x10000 - 4)
211 #define CONSERVATIVE_24BIT_S1 (0x1000000 - 4)
212 /* These must be more conservative because the address may be in
213 different segment. */
214 #define CONSERVATIVE_15BIT (0x4000 - 0x1000)
215 #define CONSERVATIVE_15BIT_S1 (0x8000 - 0x1000)
216 #define CONSERVATIVE_15BIT_S2 (0x10000 - 0x1000)
217 #define CONSERVATIVE_19BIT (0x40000 - 0x1000)
218 #define CONSERVATIVE_20BIT (0x80000 - 0x1000)
219
220 /* Size of small data/bss sections, used to calculate SDA_BASE. */
221 static long got_size = 0;
222 static int is_SDA_BASE_set = 0;
223 static int is_ITB_BASE_set = 0;
224
225 /* Convert ELF-VER in eflags to string for debugging purpose. */
226 static const char *const nds32_elfver_strtab[] =
227 {
228 "ELF-1.2",
229 "ELF-1.3",
230 "ELF-1.4",
231 };
232
233 /* The nds32 linker needs to keep track of the number of relocs that it
234 decides to copy in check_relocs for each symbol. This is so that
235 it can discard PC relative relocs if it doesn't need them when
236 linking with -Bsymbolic. We store the information in a field
237 extending the regular ELF linker hash table. */
238
239 /* This structure keeps track of the number of PC relative relocs we
240 have copied for a given symbol. */
241
242 struct elf_nds32_pcrel_relocs_copied
243 {
244 /* Next section. */
245 struct elf_nds32_pcrel_relocs_copied *next;
246 /* A section in dynobj. */
247 asection *section;
248 /* Number of relocs copied in this section. */
249 bfd_size_type count;
250 };
251
252 /* The sh linker needs to keep track of the number of relocs that it
253 decides to copy as dynamic relocs in check_relocs for each symbol.
254 This is so that it can later discard them if they are found to be
255 unnecessary. We store the information in a field extending the
256 regular ELF linker hash table. */
257
258 struct elf_nds32_dyn_relocs
259 {
260 struct elf_nds32_dyn_relocs *next;
261
262 /* The input section of the reloc. */
263 asection *sec;
264
265 /* Total number of relocs copied for the input section. */
266 bfd_size_type count;
267
268 /* Number of pc-relative relocs copied for the input section. */
269 bfd_size_type pc_count;
270 };
271
272 /* Nds32 ELF linker hash entry. */
273
274 struct elf_nds32_link_hash_entry
275 {
276 struct elf_link_hash_entry root;
277
278 /* Track dynamic relocs copied for this symbol. */
279 struct elf_nds32_dyn_relocs *dyn_relocs;
280
281 /* For checking relocation type. */
282 #define GOT_UNKNOWN 0
283 #define GOT_NORMAL 1
284 #define GOT_TLS_IE 2
285 unsigned int tls_type;
286 };
287
288 /* Get the nds32 ELF linker hash table from a link_info structure. */
289
290 #define FP_BASE_NAME "_FP_BASE_"
291 static int check_start_export_sym = 0;
292 static size_t ex9_relax_size = 0; /* Save ex9 predicted reducing size. */
293
294 /* The offset for executable tls relaxation. */
295 #define TP_OFFSET 0x0
296
297 struct elf_nds32_obj_tdata
298 {
299 struct elf_obj_tdata root;
300
301 /* tls_type for each local got entry. */
302 char *local_got_tls_type;
303 };
304
305 #define elf_nds32_tdata(bfd) \
306 ((struct elf_nds32_obj_tdata *) (bfd)->tdata.any)
307
308 #define elf32_nds32_local_got_tls_type(bfd) \
309 (elf_nds32_tdata (bfd)->local_got_tls_type)
310
311 #define elf32_nds32_hash_entry(ent) ((struct elf_nds32_link_hash_entry *)(ent))
312
313 static bfd_boolean
314 nds32_elf_mkobject (bfd *abfd)
315 {
316 return bfd_elf_allocate_object (abfd, sizeof (struct elf_nds32_obj_tdata),
317 NDS32_ELF_DATA);
318 }
319
320 /* Relocations used for relocation. */
321 static reloc_howto_type nds32_elf_howto_table[] =
322 {
323 /* This reloc does nothing. */
324 HOWTO (R_NDS32_NONE, /* type */
325 0, /* rightshift */
326 3, /* size (0 = byte, 1 = short, 2 = long) */
327 0, /* bitsize */
328 FALSE, /* pc_relative */
329 0, /* bitpos */
330 complain_overflow_dont, /* complain_on_overflow */
331 bfd_elf_generic_reloc, /* special_function */
332 "R_NDS32_NONE", /* name */
333 FALSE, /* partial_inplace */
334 0, /* src_mask */
335 0, /* dst_mask */
336 FALSE), /* pcrel_offset */
337
338 /* A 16 bit absolute relocation. */
339 HOWTO (R_NDS32_16, /* type */
340 0, /* rightshift */
341 1, /* size (0 = byte, 1 = short, 2 = long) */
342 16, /* bitsize */
343 FALSE, /* pc_relative */
344 0, /* bitpos */
345 complain_overflow_bitfield, /* complain_on_overflow */
346 nds32_elf_generic_reloc, /* special_function */
347 "R_NDS32_16", /* name */
348 FALSE, /* partial_inplace */
349 0xffff, /* src_mask */
350 0xffff, /* dst_mask */
351 FALSE), /* pcrel_offset */
352
353 /* A 32 bit absolute relocation. */
354 HOWTO (R_NDS32_32, /* type */
355 0, /* rightshift */
356 2, /* size (0 = byte, 1 = short, 2 = long) */
357 32, /* bitsize */
358 FALSE, /* pc_relative */
359 0, /* bitpos */
360 complain_overflow_bitfield, /* complain_on_overflow */
361 nds32_elf_generic_reloc, /* special_function */
362 "R_NDS32_32", /* name */
363 FALSE, /* partial_inplace */
364 0xffffffff, /* src_mask */
365 0xffffffff, /* dst_mask */
366 FALSE), /* pcrel_offset */
367
368 /* A 20 bit address. */
369 HOWTO (R_NDS32_20, /* type */
370 0, /* rightshift */
371 2, /* size (0 = byte, 1 = short, 2 = long) */
372 20, /* bitsize */
373 FALSE, /* pc_relative */
374 0, /* bitpos */
375 complain_overflow_unsigned, /* complain_on_overflow */
376 nds32_elf_generic_reloc, /* special_function */
377 "R_NDS32_20", /* name */
378 FALSE, /* partial_inplace */
379 0xfffff, /* src_mask */
380 0xfffff, /* dst_mask */
381 FALSE), /* pcrel_offset */
382
383 /* An PC Relative 9-bit relocation, shifted by 2.
384 This reloc is complicated because relocations are relative to pc & -4.
385 i.e. branches in the right insn slot use the address of the left insn
386 slot for pc. */
387 /* ??? It's not clear whether this should have partial_inplace set or not.
388 Branch relaxing in the assembler can store the addend in the insn,
389 and if bfd_install_relocation gets called the addend may get added
390 again. */
391 HOWTO (R_NDS32_9_PCREL, /* type */
392 1, /* rightshift */
393 1, /* size (0 = byte, 1 = short, 2 = long) */
394 8, /* bitsize */
395 TRUE, /* pc_relative */
396 0, /* bitpos */
397 complain_overflow_signed, /* complain_on_overflow */
398 nds32_elf_9_pcrel_reloc, /* special_function */
399 "R_NDS32_9_PCREL", /* name */
400 FALSE, /* partial_inplace */
401 0xff, /* src_mask */
402 0xff, /* dst_mask */
403 TRUE), /* pcrel_offset */
404
405 /* A relative 15 bit relocation, right shifted by 1. */
406 HOWTO (R_NDS32_15_PCREL, /* type */
407 1, /* rightshift */
408 2, /* size (0 = byte, 1 = short, 2 = long) */
409 14, /* bitsize */
410 TRUE, /* pc_relative */
411 0, /* bitpos */
412 complain_overflow_signed, /* complain_on_overflow */
413 bfd_elf_generic_reloc, /* special_function */
414 "R_NDS32_15_PCREL", /* name */
415 FALSE, /* partial_inplace */
416 0x3fff, /* src_mask */
417 0x3fff, /* dst_mask */
418 TRUE), /* pcrel_offset */
419
420 /* A relative 17 bit relocation, right shifted by 1. */
421 HOWTO (R_NDS32_17_PCREL, /* type */
422 1, /* rightshift */
423 2, /* size (0 = byte, 1 = short, 2 = long) */
424 16, /* bitsize */
425 TRUE, /* pc_relative */
426 0, /* bitpos */
427 complain_overflow_signed, /* complain_on_overflow */
428 bfd_elf_generic_reloc, /* special_function */
429 "R_NDS32_17_PCREL", /* name */
430 FALSE, /* partial_inplace */
431 0xffff, /* src_mask */
432 0xffff, /* dst_mask */
433 TRUE), /* pcrel_offset */
434
435 /* A relative 25 bit relocation, right shifted by 1. */
436 /* ??? It's not clear whether this should have partial_inplace set or not.
437 Branch relaxing in the assembler can store the addend in the insn,
438 and if bfd_install_relocation gets called the addend may get added
439 again. */
440 HOWTO (R_NDS32_25_PCREL, /* type */
441 1, /* rightshift */
442 2, /* size (0 = byte, 1 = short, 2 = long) */
443 24, /* bitsize */
444 TRUE, /* pc_relative */
445 0, /* bitpos */
446 complain_overflow_signed, /* complain_on_overflow */
447 bfd_elf_generic_reloc, /* special_function */
448 "R_NDS32_25_PCREL", /* name */
449 FALSE, /* partial_inplace */
450 0xffffff, /* src_mask */
451 0xffffff, /* dst_mask */
452 TRUE), /* pcrel_offset */
453
454 /* High 20 bits of address when lower 12 is or'd in. */
455 HOWTO (R_NDS32_HI20, /* type */
456 12, /* rightshift */
457 2, /* size (0 = byte, 1 = short, 2 = long) */
458 20, /* bitsize */
459 FALSE, /* pc_relative */
460 0, /* bitpos */
461 complain_overflow_dont,/* complain_on_overflow */
462 nds32_elf_hi20_reloc, /* special_function */
463 "R_NDS32_HI20", /* name */
464 FALSE, /* partial_inplace */
465 0x000fffff, /* src_mask */
466 0x000fffff, /* dst_mask */
467 FALSE), /* pcrel_offset */
468
469 /* Lower 12 bits of address. */
470 HOWTO (R_NDS32_LO12S3, /* type */
471 3, /* rightshift */
472 2, /* size (0 = byte, 1 = short, 2 = long) */
473 9, /* bitsize */
474 FALSE, /* pc_relative */
475 0, /* bitpos */
476 complain_overflow_dont,/* complain_on_overflow */
477 nds32_elf_lo12_reloc, /* special_function */
478 "R_NDS32_LO12S3", /* name */
479 FALSE, /* partial_inplace */
480 0x000001ff, /* src_mask */
481 0x000001ff, /* dst_mask */
482 FALSE), /* pcrel_offset */
483
484 /* Lower 12 bits of address. */
485 HOWTO (R_NDS32_LO12S2, /* type */
486 2, /* rightshift */
487 2, /* size (0 = byte, 1 = short, 2 = long) */
488 10, /* bitsize */
489 FALSE, /* pc_relative */
490 0, /* bitpos */
491 complain_overflow_dont,/* complain_on_overflow */
492 nds32_elf_lo12_reloc, /* special_function */
493 "R_NDS32_LO12S2", /* name */
494 FALSE, /* partial_inplace */
495 0x000003ff, /* src_mask */
496 0x000003ff, /* dst_mask */
497 FALSE), /* pcrel_offset */
498
499 /* Lower 12 bits of address. */
500 HOWTO (R_NDS32_LO12S1, /* type */
501 1, /* rightshift */
502 2, /* size (0 = byte, 1 = short, 2 = long) */
503 11, /* bitsize */
504 FALSE, /* pc_relative */
505 0, /* bitpos */
506 complain_overflow_dont,/* complain_on_overflow */
507 nds32_elf_lo12_reloc, /* special_function */
508 "R_NDS32_LO12S1", /* name */
509 FALSE, /* partial_inplace */
510 0x000007ff, /* src_mask */
511 0x000007ff, /* dst_mask */
512 FALSE), /* pcrel_offset */
513
514 /* Lower 12 bits of address. */
515 HOWTO (R_NDS32_LO12S0, /* type */
516 0, /* rightshift */
517 2, /* size (0 = byte, 1 = short, 2 = long) */
518 12, /* bitsize */
519 FALSE, /* pc_relative */
520 0, /* bitpos */
521 complain_overflow_dont,/* complain_on_overflow */
522 nds32_elf_lo12_reloc, /* special_function */
523 "R_NDS32_LO12S0", /* name */
524 FALSE, /* partial_inplace */
525 0x00000fff, /* src_mask */
526 0x00000fff, /* dst_mask */
527 FALSE), /* pcrel_offset */
528
529 /* Small data area 15 bits offset. */
530 HOWTO (R_NDS32_SDA15S3, /* type */
531 3, /* rightshift */
532 2, /* size (0 = byte, 1 = short, 2 = long) */
533 15, /* bitsize */
534 FALSE, /* pc_relative */
535 0, /* bitpos */
536 complain_overflow_signed, /* complain_on_overflow */
537 nds32_elf_sda15_reloc, /* special_function */
538 "R_NDS32_SDA15S3", /* name */
539 FALSE, /* partial_inplace */
540 0x00007fff, /* src_mask */
541 0x00007fff, /* dst_mask */
542 FALSE), /* pcrel_offset */
543
544 /* Small data area 15 bits offset. */
545 HOWTO (R_NDS32_SDA15S2, /* type */
546 2, /* rightshift */
547 2, /* size (0 = byte, 1 = short, 2 = long) */
548 15, /* bitsize */
549 FALSE, /* pc_relative */
550 0, /* bitpos */
551 complain_overflow_signed, /* complain_on_overflow */
552 nds32_elf_sda15_reloc, /* special_function */
553 "R_NDS32_SDA15S2", /* name */
554 FALSE, /* partial_inplace */
555 0x00007fff, /* src_mask */
556 0x00007fff, /* dst_mask */
557 FALSE), /* pcrel_offset */
558
559 /* Small data area 15 bits offset. */
560 HOWTO (R_NDS32_SDA15S1, /* type */
561 1, /* rightshift */
562 2, /* size (0 = byte, 1 = short, 2 = long) */
563 15, /* bitsize */
564 FALSE, /* pc_relative */
565 0, /* bitpos */
566 complain_overflow_signed, /* complain_on_overflow */
567 nds32_elf_sda15_reloc, /* special_function */
568 "R_NDS32_SDA15S1", /* name */
569 FALSE, /* partial_inplace */
570 0x00007fff, /* src_mask */
571 0x00007fff, /* dst_mask */
572 FALSE), /* pcrel_offset */
573
574 /* Small data area 15 bits offset. */
575 HOWTO (R_NDS32_SDA15S0, /* type */
576 0, /* rightshift */
577 2, /* size (0 = byte, 1 = short, 2 = long) */
578 15, /* bitsize */
579 FALSE, /* pc_relative */
580 0, /* bitpos */
581 complain_overflow_signed, /* complain_on_overflow */
582 nds32_elf_sda15_reloc, /* special_function */
583 "R_NDS32_SDA15S0", /* name */
584 FALSE, /* partial_inplace */
585 0x00007fff, /* src_mask */
586 0x00007fff, /* dst_mask */
587 FALSE), /* pcrel_offset */
588
589 /* GNU extension to record C++ vtable hierarchy */
590 HOWTO (R_NDS32_GNU_VTINHERIT, /* type */
591 0, /* rightshift */
592 2, /* size (0 = byte, 1 = short, 2 = long) */
593 0, /* bitsize */
594 FALSE, /* pc_relative */
595 0, /* bitpos */
596 complain_overflow_dont,/* complain_on_overflow */
597 NULL, /* special_function */
598 "R_NDS32_GNU_VTINHERIT", /* name */
599 FALSE, /* partial_inplace */
600 0, /* src_mask */
601 0, /* dst_mask */
602 FALSE), /* pcrel_offset */
603
604 /* GNU extension to record C++ vtable member usage */
605 HOWTO (R_NDS32_GNU_VTENTRY, /* type */
606 0, /* rightshift */
607 2, /* size (0 = byte, 1 = short, 2 = long) */
608 0, /* bitsize */
609 FALSE, /* pc_relative */
610 0, /* bitpos */
611 complain_overflow_dont,/* complain_on_overflow */
612 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
613 "R_NDS32_GNU_VTENTRY", /* name */
614 FALSE, /* partial_inplace */
615 0, /* src_mask */
616 0, /* dst_mask */
617 FALSE), /* pcrel_offset */
618
619 /* A 16 bit absolute relocation. */
620 HOWTO (R_NDS32_16_RELA, /* type */
621 0, /* rightshift */
622 1, /* size (0 = byte, 1 = short, 2 = long) */
623 16, /* bitsize */
624 FALSE, /* pc_relative */
625 0, /* bitpos */
626 complain_overflow_bitfield, /* complain_on_overflow */
627 bfd_elf_generic_reloc, /* special_function */
628 "R_NDS32_16_RELA", /* name */
629 FALSE, /* partial_inplace */
630 0xffff, /* src_mask */
631 0xffff, /* dst_mask */
632 FALSE), /* pcrel_offset */
633
634 /* A 32 bit absolute relocation. */
635 HOWTO (R_NDS32_32_RELA, /* type */
636 0, /* rightshift */
637 2, /* size (0 = byte, 1 = short, 2 = long) */
638 32, /* bitsize */
639 FALSE, /* pc_relative */
640 0, /* bitpos */
641 complain_overflow_bitfield, /* complain_on_overflow */
642 bfd_elf_generic_reloc, /* special_function */
643 "R_NDS32_32_RELA", /* name */
644 FALSE, /* partial_inplace */
645 0xffffffff, /* src_mask */
646 0xffffffff, /* dst_mask */
647 FALSE), /* pcrel_offset */
648
649 /* A 20 bit address. */
650 HOWTO (R_NDS32_20_RELA, /* type */
651 0, /* rightshift */
652 2, /* size (0 = byte, 1 = short, 2 = long) */
653 20, /* bitsize */
654 FALSE, /* pc_relative */
655 0, /* bitpos */
656 complain_overflow_signed, /* complain_on_overflow */
657 bfd_elf_generic_reloc, /* special_function */
658 "R_NDS32_20_RELA", /* name */
659 FALSE, /* partial_inplace */
660 0xfffff, /* src_mask */
661 0xfffff, /* dst_mask */
662 FALSE), /* pcrel_offset */
663
664 HOWTO (R_NDS32_9_PCREL_RELA, /* type */
665 1, /* rightshift */
666 1, /* size (0 = byte, 1 = short, 2 = long) */
667 8, /* bitsize */
668 TRUE, /* pc_relative */
669 0, /* bitpos */
670 complain_overflow_signed, /* complain_on_overflow */
671 bfd_elf_generic_reloc, /* special_function */
672 "R_NDS32_9_PCREL_RELA",/* name */
673 FALSE, /* partial_inplace */
674 0xff, /* src_mask */
675 0xff, /* dst_mask */
676 TRUE), /* pcrel_offset */
677
678 /* A relative 15 bit relocation, right shifted by 1. */
679 HOWTO (R_NDS32_15_PCREL_RELA, /* type */
680 1, /* rightshift */
681 2, /* size (0 = byte, 1 = short, 2 = long) */
682 14, /* bitsize */
683 TRUE, /* pc_relative */
684 0, /* bitpos */
685 complain_overflow_signed, /* complain_on_overflow */
686 bfd_elf_generic_reloc, /* special_function */
687 "R_NDS32_15_PCREL_RELA", /* name */
688 FALSE, /* partial_inplace */
689 0x3fff, /* src_mask */
690 0x3fff, /* dst_mask */
691 TRUE), /* pcrel_offset */
692
693 /* A relative 17 bit relocation, right shifted by 1. */
694 HOWTO (R_NDS32_17_PCREL_RELA, /* type */
695 1, /* rightshift */
696 2, /* size (0 = byte, 1 = short, 2 = long) */
697 16, /* bitsize */
698 TRUE, /* pc_relative */
699 0, /* bitpos */
700 complain_overflow_signed, /* complain_on_overflow */
701 bfd_elf_generic_reloc, /* special_function */
702 "R_NDS32_17_PCREL_RELA", /* name */
703 FALSE, /* partial_inplace */
704 0xffff, /* src_mask */
705 0xffff, /* dst_mask */
706 TRUE), /* pcrel_offset */
707
708 /* A relative 25 bit relocation, right shifted by 2. */
709 HOWTO (R_NDS32_25_PCREL_RELA, /* type */
710 1, /* rightshift */
711 2, /* size (0 = byte, 1 = short, 2 = long) */
712 24, /* bitsize */
713 TRUE, /* pc_relative */
714 0, /* bitpos */
715 complain_overflow_signed, /* complain_on_overflow */
716 bfd_elf_generic_reloc, /* special_function */
717 "R_NDS32_25_PCREL_RELA", /* name */
718 FALSE, /* partial_inplace */
719 0xffffff, /* src_mask */
720 0xffffff, /* dst_mask */
721 TRUE), /* pcrel_offset */
722
723 /* High 20 bits of address when lower 16 is or'd in. */
724 HOWTO (R_NDS32_HI20_RELA, /* type */
725 12, /* rightshift */
726 2, /* size (0 = byte, 1 = short, 2 = long) */
727 20, /* bitsize */
728 FALSE, /* pc_relative */
729 0, /* bitpos */
730 complain_overflow_dont,/* complain_on_overflow */
731 bfd_elf_generic_reloc, /* special_function */
732 "R_NDS32_HI20_RELA", /* name */
733 FALSE, /* partial_inplace */
734 0x000fffff, /* src_mask */
735 0x000fffff, /* dst_mask */
736 FALSE), /* pcrel_offset */
737
738 /* Lower 12 bits of address. */
739 HOWTO (R_NDS32_LO12S3_RELA, /* type */
740 3, /* rightshift */
741 2, /* size (0 = byte, 1 = short, 2 = long) */
742 9, /* bitsize */
743 FALSE, /* pc_relative */
744 0, /* bitpos */
745 complain_overflow_dont,/* complain_on_overflow */
746 bfd_elf_generic_reloc, /* special_function */
747 "R_NDS32_LO12S3_RELA", /* name */
748 FALSE, /* partial_inplace */
749 0x000001ff, /* src_mask */
750 0x000001ff, /* dst_mask */
751 FALSE), /* pcrel_offset */
752
753 /* Lower 12 bits of address. */
754 HOWTO (R_NDS32_LO12S2_RELA, /* type */
755 2, /* rightshift */
756 2, /* size (0 = byte, 1 = short, 2 = long) */
757 10, /* bitsize */
758 FALSE, /* pc_relative */
759 0, /* bitpos */
760 complain_overflow_dont,/* complain_on_overflow */
761 bfd_elf_generic_reloc, /* special_function */
762 "R_NDS32_LO12S2_RELA", /* name */
763 FALSE, /* partial_inplace */
764 0x000003ff, /* src_mask */
765 0x000003ff, /* dst_mask */
766 FALSE), /* pcrel_offset */
767
768 /* Lower 12 bits of address. */
769 HOWTO (R_NDS32_LO12S1_RELA, /* type */
770 1, /* rightshift */
771 2, /* size (0 = byte, 1 = short, 2 = long) */
772 11, /* bitsize */
773 FALSE, /* pc_relative */
774 0, /* bitpos */
775 complain_overflow_dont,/* complain_on_overflow */
776 bfd_elf_generic_reloc, /* special_function */
777 "R_NDS32_LO12S1_RELA", /* name */
778 FALSE, /* partial_inplace */
779 0x000007ff, /* src_mask */
780 0x000007ff, /* dst_mask */
781 FALSE), /* pcrel_offset */
782
783 /* Lower 12 bits of address. */
784 HOWTO (R_NDS32_LO12S0_RELA, /* type */
785 0, /* rightshift */
786 2, /* size (0 = byte, 1 = short, 2 = long) */
787 12, /* bitsize */
788 FALSE, /* pc_relative */
789 0, /* bitpos */
790 complain_overflow_dont,/* complain_on_overflow */
791 bfd_elf_generic_reloc, /* special_function */
792 "R_NDS32_LO12S0_RELA", /* name */
793 FALSE, /* partial_inplace */
794 0x00000fff, /* src_mask */
795 0x00000fff, /* dst_mask */
796 FALSE), /* pcrel_offset */
797
798 /* Small data area 15 bits offset. */
799 HOWTO (R_NDS32_SDA15S3_RELA, /* type */
800 3, /* rightshift */
801 2, /* size (0 = byte, 1 = short, 2 = long) */
802 15, /* bitsize */
803 FALSE, /* pc_relative */
804 0, /* bitpos */
805 complain_overflow_signed, /* complain_on_overflow */
806 bfd_elf_generic_reloc, /* special_function */
807 "R_NDS32_SDA15S3_RELA",/* name */
808 FALSE, /* partial_inplace */
809 0x00007fff, /* src_mask */
810 0x00007fff, /* dst_mask */
811 FALSE), /* pcrel_offset */
812
813 /* Small data area 15 bits offset. */
814 HOWTO (R_NDS32_SDA15S2_RELA, /* type */
815 2, /* rightshift */
816 2, /* size (0 = byte, 1 = short, 2 = long) */
817 15, /* bitsize */
818 FALSE, /* pc_relative */
819 0, /* bitpos */
820 complain_overflow_signed, /* complain_on_overflow */
821 bfd_elf_generic_reloc, /* special_function */
822 "R_NDS32_SDA15S2_RELA",/* name */
823 FALSE, /* partial_inplace */
824 0x00007fff, /* src_mask */
825 0x00007fff, /* dst_mask */
826 FALSE), /* pcrel_offset */
827
828 HOWTO (R_NDS32_SDA15S1_RELA, /* type */
829 1, /* rightshift */
830 2, /* size (0 = byte, 1 = short, 2 = long) */
831 15, /* bitsize */
832 FALSE, /* pc_relative */
833 0, /* bitpos */
834 complain_overflow_signed, /* complain_on_overflow */
835 bfd_elf_generic_reloc, /* special_function */
836 "R_NDS32_SDA15S1_RELA",/* name */
837 FALSE, /* partial_inplace */
838 0x00007fff, /* src_mask */
839 0x00007fff, /* dst_mask */
840 FALSE), /* pcrel_offset */
841
842 HOWTO (R_NDS32_SDA15S0_RELA, /* type */
843 0, /* rightshift */
844 2, /* size (0 = byte, 1 = short, 2 = long) */
845 15, /* bitsize */
846 FALSE, /* pc_relative */
847 0, /* bitpos */
848 complain_overflow_signed, /* complain_on_overflow */
849 bfd_elf_generic_reloc, /* special_function */
850 "R_NDS32_SDA15S0_RELA",/* name */
851 FALSE, /* partial_inplace */
852 0x00007fff, /* src_mask */
853 0x00007fff, /* dst_mask */
854 FALSE), /* pcrel_offset */
855
856 /* GNU extension to record C++ vtable hierarchy */
857 HOWTO (R_NDS32_RELA_GNU_VTINHERIT, /* type */
858 0, /* rightshift */
859 2, /* size (0 = byte, 1 = short, 2 = long) */
860 0, /* bitsize */
861 FALSE, /* pc_relative */
862 0, /* bitpos */
863 complain_overflow_dont,/* complain_on_overflow */
864 NULL, /* special_function */
865 "R_NDS32_RELA_GNU_VTINHERIT", /* name */
866 FALSE, /* partial_inplace */
867 0, /* src_mask */
868 0, /* dst_mask */
869 FALSE), /* pcrel_offset */
870
871 /* GNU extension to record C++ vtable member usage */
872 HOWTO (R_NDS32_RELA_GNU_VTENTRY, /* type */
873 0, /* rightshift */
874 2, /* size (0 = byte, 1 = short, 2 = long) */
875 0, /* bitsize */
876 FALSE, /* pc_relative */
877 0, /* bitpos */
878 complain_overflow_dont,/* complain_on_overflow */
879 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
880 "R_NDS32_RELA_GNU_VTENTRY", /* name */
881 FALSE, /* partial_inplace */
882 0, /* src_mask */
883 0, /* dst_mask */
884 FALSE), /* pcrel_offset */
885
886 /* Like R_NDS32_20, but referring to the GOT table entry for
887 the symbol. */
888 HOWTO (R_NDS32_GOT20, /* type */
889 0, /* rightshift */
890 2, /* size (0 = byte, 1 = short, 2 = long) */
891 20, /* bitsize */
892 FALSE, /* pc_relative */
893 0, /* bitpos */
894 complain_overflow_signed, /* complain_on_overflow */
895 bfd_elf_generic_reloc, /* special_function */
896 "R_NDS32_GOT20", /* name */
897 FALSE, /* partial_inplace */
898 0xfffff, /* src_mask */
899 0xfffff, /* dst_mask */
900 FALSE), /* pcrel_offset */
901
902 /* Like R_NDS32_PCREL, but referring to the procedure linkage table
903 entry for the symbol. */
904 HOWTO (R_NDS32_25_PLTREL, /* type */
905 1, /* rightshift */
906 2, /* size (0 = byte, 1 = short, 2 = long) */
907 24, /* bitsize */
908 TRUE, /* pc_relative */
909 0, /* bitpos */
910 complain_overflow_signed, /* complain_on_overflow */
911 bfd_elf_generic_reloc, /* special_function */
912 "R_NDS32_25_PLTREL", /* name */
913 FALSE, /* partial_inplace */
914 0xffffff, /* src_mask */
915 0xffffff, /* dst_mask */
916 TRUE), /* pcrel_offset */
917
918 /* This is used only by the dynamic linker. The symbol should exist
919 both in the object being run and in some shared library. The
920 dynamic linker copies the data addressed by the symbol from the
921 shared library into the object, because the object being
922 run has to have the data at some particular address. */
923 HOWTO (R_NDS32_COPY, /* type */
924 0, /* rightshift */
925 2, /* size (0 = byte, 1 = short, 2 = long) */
926 32, /* bitsize */
927 FALSE, /* pc_relative */
928 0, /* bitpos */
929 complain_overflow_bitfield, /* complain_on_overflow */
930 bfd_elf_generic_reloc, /* special_function */
931 "R_NDS32_COPY", /* name */
932 FALSE, /* partial_inplace */
933 0xffffffff, /* src_mask */
934 0xffffffff, /* dst_mask */
935 FALSE), /* pcrel_offset */
936
937 /* Like R_NDS32_20, but used when setting global offset table
938 entries. */
939 HOWTO (R_NDS32_GLOB_DAT, /* type */
940 0, /* rightshift */
941 2, /* size (0 = byte, 1 = short, 2 = long) */
942 32, /* bitsize */
943 FALSE, /* pc_relative */
944 0, /* bitpos */
945 complain_overflow_bitfield, /* complain_on_overflow */
946 bfd_elf_generic_reloc, /* special_function */
947 "R_NDS32_GLOB_DAT", /* name */
948 FALSE, /* partial_inplace */
949 0xffffffff, /* src_mask */
950 0xffffffff, /* dst_mask */
951 FALSE), /* pcrel_offset */
952
953 /* Marks a procedure linkage table entry for a symbol. */
954 HOWTO (R_NDS32_JMP_SLOT, /* type */
955 0, /* rightshift */
956 2, /* size (0 = byte, 1 = short, 2 = long) */
957 32, /* bitsize */
958 FALSE, /* pc_relative */
959 0, /* bitpos */
960 complain_overflow_bitfield, /* complain_on_overflow */
961 bfd_elf_generic_reloc, /* special_function */
962 "R_NDS32_JMP_SLOT", /* name */
963 FALSE, /* partial_inplace */
964 0xffffffff, /* src_mask */
965 0xffffffff, /* dst_mask */
966 FALSE), /* pcrel_offset */
967
968 /* Used only by the dynamic linker. When the object is run, this
969 longword is set to the load address of the object, plus the
970 addend. */
971 HOWTO (R_NDS32_RELATIVE, /* type */
972 0, /* rightshift */
973 2, /* size (0 = byte, 1 = short, 2 = long) */
974 32, /* bitsize */
975 FALSE, /* pc_relative */
976 0, /* bitpos */
977 complain_overflow_bitfield, /* complain_on_overflow */
978 bfd_elf_generic_reloc, /* special_function */
979 "R_NDS32_RELATIVE", /* name */
980 FALSE, /* partial_inplace */
981 0xffffffff, /* src_mask */
982 0xffffffff, /* dst_mask */
983 FALSE), /* pcrel_offset */
984
985 HOWTO (R_NDS32_GOTOFF, /* type */
986 0, /* rightshift */
987 2, /* size (0 = byte, 1 = short, 2 = long) */
988 20, /* bitsize */
989 FALSE, /* pc_relative */
990 0, /* bitpos */
991 complain_overflow_signed, /* complain_on_overflow */
992 bfd_elf_generic_reloc, /* special_function */
993 "R_NDS32_GOTOFF", /* name */
994 FALSE, /* partial_inplace */
995 0xfffff, /* src_mask */
996 0xfffff, /* dst_mask */
997 FALSE), /* pcrel_offset */
998
999 /* An PC Relative 20-bit relocation used when setting PIC offset
1000 table register. */
1001 HOWTO (R_NDS32_GOTPC20, /* type */
1002 0, /* rightshift */
1003 2, /* size (0 = byte, 1 = short, 2 = long) */
1004 20, /* bitsize */
1005 TRUE, /* pc_relative */
1006 0, /* bitpos */
1007 complain_overflow_signed, /* complain_on_overflow */
1008 bfd_elf_generic_reloc, /* special_function */
1009 "R_NDS32_GOTPC20", /* name */
1010 FALSE, /* partial_inplace */
1011 0xfffff, /* src_mask */
1012 0xfffff, /* dst_mask */
1013 TRUE), /* pcrel_offset */
1014
1015 /* Like R_NDS32_HI20, but referring to the GOT table entry for
1016 the symbol. */
1017 HOWTO (R_NDS32_GOT_HI20, /* type */
1018 12, /* rightshift */
1019 2, /* size (0 = byte, 1 = short, 2 = long) */
1020 20, /* bitsize */
1021 FALSE, /* pc_relative */
1022 0, /* bitpos */
1023 complain_overflow_dont,/* complain_on_overflow */
1024 bfd_elf_generic_reloc, /* special_function */
1025 "R_NDS32_GOT_HI20", /* name */
1026 FALSE, /* partial_inplace */
1027 0x000fffff, /* src_mask */
1028 0x000fffff, /* dst_mask */
1029 FALSE), /* pcrel_offset */
1030 HOWTO (R_NDS32_GOT_LO12, /* type */
1031 0, /* rightshift */
1032 2, /* size (0 = byte, 1 = short, 2 = long) */
1033 12, /* bitsize */
1034 FALSE, /* pc_relative */
1035 0, /* bitpos */
1036 complain_overflow_dont,/* complain_on_overflow */
1037 bfd_elf_generic_reloc, /* special_function */
1038 "R_NDS32_GOT_LO12", /* name */
1039 FALSE, /* partial_inplace */
1040 0x00000fff, /* src_mask */
1041 0x00000fff, /* dst_mask */
1042 FALSE), /* pcrel_offset */
1043
1044 /* An PC Relative relocation used when setting PIC offset table register.
1045 Like R_NDS32_HI20, but referring to the GOT table entry for
1046 the symbol. */
1047 HOWTO (R_NDS32_GOTPC_HI20, /* type */
1048 12, /* rightshift */
1049 2, /* size (0 = byte, 1 = short, 2 = long) */
1050 20, /* bitsize */
1051 FALSE, /* pc_relative */
1052 0, /* bitpos */
1053 complain_overflow_dont,/* complain_on_overflow */
1054 bfd_elf_generic_reloc, /* special_function */
1055 "R_NDS32_GOTPC_HI20", /* name */
1056 FALSE, /* partial_inplace */
1057 0x000fffff, /* src_mask */
1058 0x000fffff, /* dst_mask */
1059 TRUE), /* pcrel_offset */
1060 HOWTO (R_NDS32_GOTPC_LO12, /* type */
1061 0, /* rightshift */
1062 2, /* size (0 = byte, 1 = short, 2 = long) */
1063 12, /* bitsize */
1064 FALSE, /* pc_relative */
1065 0, /* bitpos */
1066 complain_overflow_dont, /* complain_on_overflow */
1067 bfd_elf_generic_reloc, /* special_function */
1068 "R_NDS32_GOTPC_LO12", /* name */
1069 FALSE, /* partial_inplace */
1070 0x00000fff, /* src_mask */
1071 0x00000fff, /* dst_mask */
1072 TRUE), /* pcrel_offset */
1073
1074 HOWTO (R_NDS32_GOTOFF_HI20, /* type */
1075 12, /* rightshift */
1076 2, /* size (0 = byte, 1 = short, 2 = long) */
1077 20, /* bitsize */
1078 FALSE, /* pc_relative */
1079 0, /* bitpos */
1080 complain_overflow_dont,/* complain_on_overflow */
1081 bfd_elf_generic_reloc, /* special_function */
1082 "R_NDS32_GOTOFF_HI20", /* name */
1083 FALSE, /* partial_inplace */
1084 0x000fffff, /* src_mask */
1085 0x000fffff, /* dst_mask */
1086 FALSE), /* pcrel_offset */
1087 HOWTO (R_NDS32_GOTOFF_LO12, /* type */
1088 0, /* rightshift */
1089 2, /* size (0 = byte, 1 = short, 2 = long) */
1090 12, /* bitsize */
1091 FALSE, /* pc_relative */
1092 0, /* bitpos */
1093 complain_overflow_dont,/* complain_on_overflow */
1094 bfd_elf_generic_reloc, /* special_function */
1095 "R_NDS32_GOTOFF_LO12", /* name */
1096 FALSE, /* partial_inplace */
1097 0x00000fff, /* src_mask */
1098 0x00000fff, /* dst_mask */
1099 FALSE), /* pcrel_offset */
1100
1101 /* Alignment hint for relaxable instruction. This is used with
1102 R_NDS32_LABEL as a pair. Relax this instruction from 4 bytes to 2
1103 in order to make next label aligned on word boundary. */
1104 HOWTO (R_NDS32_INSN16, /* type */
1105 0, /* rightshift */
1106 2, /* size (0 = byte, 1 = short, 2 = long) */
1107 32, /* bitsize */
1108 FALSE, /* pc_relative */
1109 0, /* bitpos */
1110 complain_overflow_dont,/* complain_on_overflow */
1111 nds32_elf_ignore_reloc,/* special_function */
1112 "R_NDS32_INSN16", /* name */
1113 FALSE, /* partial_inplace */
1114 0x00000fff, /* src_mask */
1115 0x00000fff, /* dst_mask */
1116 FALSE), /* pcrel_offset */
1117
1118 /* Alignment hint for label. */
1119 HOWTO (R_NDS32_LABEL, /* type */
1120 0, /* rightshift */
1121 2, /* size (0 = byte, 1 = short, 2 = long) */
1122 32, /* bitsize */
1123 FALSE, /* pc_relative */
1124 0, /* bitpos */
1125 complain_overflow_dont,/* complain_on_overflow */
1126 nds32_elf_ignore_reloc,/* special_function */
1127 "R_NDS32_LABEL", /* name */
1128 FALSE, /* partial_inplace */
1129 0xffffffff, /* src_mask */
1130 0xffffffff, /* dst_mask */
1131 FALSE), /* pcrel_offset */
1132
1133 /* Relax hint for unconditional call sequence */
1134 HOWTO (R_NDS32_LONGCALL1, /* type */
1135 0, /* rightshift */
1136 2, /* size (0 = byte, 1 = short, 2 = long) */
1137 32, /* bitsize */
1138 FALSE, /* pc_relative */
1139 0, /* bitpos */
1140 complain_overflow_dont,/* complain_on_overflow */
1141 nds32_elf_ignore_reloc,/* special_function */
1142 "R_NDS32_LONGCALL1", /* name */
1143 FALSE, /* partial_inplace */
1144 0xffffffff, /* src_mask */
1145 0xffffffff, /* dst_mask */
1146 FALSE), /* pcrel_offset */
1147
1148 /* Relax hint for conditional call sequence. */
1149 HOWTO (R_NDS32_LONGCALL2, /* type */
1150 0, /* rightshift */
1151 2, /* size (0 = byte, 1 = short, 2 = long) */
1152 32, /* bitsize */
1153 FALSE, /* pc_relative */
1154 0, /* bitpos */
1155 complain_overflow_dont,/* complain_on_overflow */
1156 nds32_elf_ignore_reloc,/* special_function */
1157 "R_NDS32_LONGCALL2", /* name */
1158 FALSE, /* partial_inplace */
1159 0xffffffff, /* src_mask */
1160 0xffffffff, /* dst_mask */
1161 FALSE), /* pcrel_offset */
1162
1163 /* Relax hint for conditional call sequence. */
1164 HOWTO (R_NDS32_LONGCALL3, /* type */
1165 0, /* rightshift */
1166 2, /* size (0 = byte, 1 = short, 2 = long) */
1167 32, /* bitsize */
1168 FALSE, /* pc_relative */
1169 0, /* bitpos */
1170 complain_overflow_dont,/* complain_on_overflow */
1171 nds32_elf_ignore_reloc,/* special_function */
1172 "R_NDS32_LONGCALL3", /* name */
1173 FALSE, /* partial_inplace */
1174 0xffffffff, /* src_mask */
1175 0xffffffff, /* dst_mask */
1176 FALSE), /* pcrel_offset */
1177
1178 /* Relax hint for unconditional branch sequence. */
1179 HOWTO (R_NDS32_LONGJUMP1, /* type */
1180 0, /* rightshift */
1181 2, /* size (0 = byte, 1 = short, 2 = long) */
1182 32, /* bitsize */
1183 FALSE, /* pc_relative */
1184 0, /* bitpos */
1185 complain_overflow_dont,/* complain_on_overflow */
1186 nds32_elf_ignore_reloc,/* special_function */
1187 "R_NDS32_LONGJUMP1", /* name */
1188 FALSE, /* partial_inplace */
1189 0xffffffff, /* src_mask */
1190 0xffffffff, /* dst_mask */
1191 FALSE), /* pcrel_offset */
1192
1193 /* Relax hint for conditional branch sequence. */
1194 HOWTO (R_NDS32_LONGJUMP2, /* type */
1195 0, /* rightshift */
1196 2, /* size (0 = byte, 1 = short, 2 = long) */
1197 32, /* bitsize */
1198 FALSE, /* pc_relative */
1199 0, /* bitpos */
1200 complain_overflow_dont,/* complain_on_overflow */
1201 nds32_elf_ignore_reloc,/* special_function */
1202 "R_NDS32_LONGJUMP2", /* name */
1203 FALSE, /* partial_inplace */
1204 0xffffffff, /* src_mask */
1205 0xffffffff, /* dst_mask */
1206 FALSE), /* pcrel_offset */
1207
1208 /* Relax hint for conditional branch sequence. */
1209 HOWTO (R_NDS32_LONGJUMP3, /* type */
1210 0, /* rightshift */
1211 2, /* size (0 = byte, 1 = short, 2 = long) */
1212 32, /* bitsize */
1213 FALSE, /* pc_relative */
1214 0, /* bitpos */
1215 complain_overflow_dont,/* complain_on_overflow */
1216 nds32_elf_ignore_reloc,/* special_function */
1217 "R_NDS32_LONGJUMP3", /* name */
1218 FALSE, /* partial_inplace */
1219 0xffffffff, /* src_mask */
1220 0xffffffff, /* dst_mask */
1221 FALSE), /* pcrel_offset */
1222
1223 /* Relax hint for load/store sequence. */
1224 HOWTO (R_NDS32_LOADSTORE, /* type */
1225 0, /* rightshift */
1226 2, /* size (0 = byte, 1 = short, 2 = long) */
1227 32, /* bitsize */
1228 FALSE, /* pc_relative */
1229 0, /* bitpos */
1230 complain_overflow_dont,/* complain_on_overflow */
1231 nds32_elf_ignore_reloc,/* special_function */
1232 "R_NDS32_LOADSTORE", /* name */
1233 FALSE, /* partial_inplace */
1234 0xffffffff, /* src_mask */
1235 0xffffffff, /* dst_mask */
1236 FALSE), /* pcrel_offset */
1237
1238 /* Relax hint for load/store sequence. */
1239 HOWTO (R_NDS32_9_FIXED_RELA, /* type */
1240 0, /* rightshift */
1241 1, /* size (0 = byte, 1 = short, 2 = long) */
1242 16, /* bitsize */
1243 FALSE, /* pc_relative */
1244 0, /* bitpos */
1245 complain_overflow_dont,/* complain_on_overflow */
1246 nds32_elf_ignore_reloc,/* special_function */
1247 "R_NDS32_9_FIXED_RELA",/* name */
1248 FALSE, /* partial_inplace */
1249 0x000000ff, /* src_mask */
1250 0x000000ff, /* dst_mask */
1251 FALSE), /* pcrel_offset */
1252
1253 /* Relax hint for load/store sequence. */
1254 HOWTO (R_NDS32_15_FIXED_RELA, /* type */
1255 0, /* rightshift */
1256 2, /* size (0 = byte, 1 = short, 2 = long) */
1257 32, /* bitsize */
1258 FALSE, /* pc_relative */
1259 0, /* bitpos */
1260 complain_overflow_dont,/* complain_on_overflow */
1261 nds32_elf_ignore_reloc,/* special_function */
1262 "R_NDS32_15_FIXED_RELA", /* name */
1263 FALSE, /* partial_inplace */
1264 0x00003fff, /* src_mask */
1265 0x00003fff, /* dst_mask */
1266 FALSE), /* pcrel_offset */
1267
1268 /* Relax hint for load/store sequence. */
1269 HOWTO (R_NDS32_17_FIXED_RELA, /* type */
1270 0, /* rightshift */
1271 2, /* size (0 = byte, 1 = short, 2 = long) */
1272 32, /* bitsize */
1273 FALSE, /* pc_relative */
1274 0, /* bitpos */
1275 complain_overflow_dont,/* complain_on_overflow */
1276 nds32_elf_ignore_reloc,/* special_function */
1277 "R_NDS32_17_FIXED_RELA", /* name */
1278 FALSE, /* partial_inplace */
1279 0x0000ffff, /* src_mask */
1280 0x0000ffff, /* dst_mask */
1281 FALSE), /* pcrel_offset */
1282
1283 /* Relax hint for load/store sequence. */
1284 HOWTO (R_NDS32_25_FIXED_RELA, /* type */
1285 0, /* rightshift */
1286 2, /* size (0 = byte, 1 = short, 2 = long) */
1287 32, /* bitsize */
1288 FALSE, /* pc_relative */
1289 0, /* bitpos */
1290 complain_overflow_dont,/* complain_on_overflow */
1291 nds32_elf_ignore_reloc,/* special_function */
1292 "R_NDS32_25_FIXED_RELA", /* name */
1293 FALSE, /* partial_inplace */
1294 0x00ffffff, /* src_mask */
1295 0x00ffffff, /* dst_mask */
1296 FALSE), /* pcrel_offset */
1297
1298 /* High 20 bits of PLT symbol offset relative to PC. */
1299 HOWTO (R_NDS32_PLTREL_HI20, /* type */
1300 12, /* rightshift */
1301 2, /* size (0 = byte, 1 = short, 2 = long) */
1302 20, /* bitsize */
1303 FALSE, /* pc_relative */
1304 0, /* bitpos */
1305 complain_overflow_dont,/* complain_on_overflow */
1306 bfd_elf_generic_reloc, /* special_function */
1307 "R_NDS32_PLTREL_HI20", /* name */
1308 FALSE, /* partial_inplace */
1309 0x000fffff, /* src_mask */
1310 0x000fffff, /* dst_mask */
1311 FALSE), /* pcrel_offset */
1312
1313 /* Low 12 bits of PLT symbol offset relative to PC. */
1314 HOWTO (R_NDS32_PLTREL_LO12, /* type */
1315 0, /* rightshift */
1316 2, /* size (0 = byte, 1 = short, 2 = long) */
1317 12, /* bitsize */
1318 FALSE, /* pc_relative */
1319 0, /* bitpos */
1320 complain_overflow_dont,/* complain_on_overflow */
1321 bfd_elf_generic_reloc, /* special_function */
1322 "R_NDS32_PLTREL_LO12", /* name */
1323 FALSE, /* partial_inplace */
1324 0x00000fff, /* src_mask */
1325 0x00000fff, /* dst_mask */
1326 FALSE), /* pcrel_offset */
1327
1328 /* High 20 bits of PLT symbol offset relative to GOT (GP). */
1329 HOWTO (R_NDS32_PLT_GOTREL_HI20, /* type */
1330 12, /* rightshift */
1331 2, /* size (0 = byte, 1 = short, 2 = long) */
1332 20, /* bitsize */
1333 FALSE, /* pc_relative */
1334 0, /* bitpos */
1335 complain_overflow_dont,/* complain_on_overflow */
1336 bfd_elf_generic_reloc, /* special_function */
1337 "R_NDS32_PLT_GOTREL_HI20", /* name */
1338 FALSE, /* partial_inplace */
1339 0x000fffff, /* src_mask */
1340 0x000fffff, /* dst_mask */
1341 FALSE), /* pcrel_offset */
1342
1343 /* Low 12 bits of PLT symbol offset relative to GOT (GP). */
1344 HOWTO (R_NDS32_PLT_GOTREL_LO12, /* type */
1345 0, /* rightshift */
1346 2, /* size (0 = byte, 1 = short, 2 = long) */
1347 12, /* bitsize */
1348 FALSE, /* pc_relative */
1349 0, /* bitpos */
1350 complain_overflow_dont,/* complain_on_overflow */
1351 bfd_elf_generic_reloc, /* special_function */
1352 "R_NDS32_PLT_GOTREL_LO12", /* name */
1353 FALSE, /* partial_inplace */
1354 0x00000fff, /* src_mask */
1355 0x00000fff, /* dst_mask */
1356 FALSE), /* pcrel_offset */
1357
1358 /* Small data area 12 bits offset. */
1359 HOWTO (R_NDS32_SDA12S2_DP_RELA, /* type */
1360 2, /* rightshift */
1361 2, /* size (0 = byte, 1 = short, 2 = long) */
1362 12, /* bitsize */
1363 FALSE, /* pc_relative */
1364 0, /* bitpos */
1365 complain_overflow_signed, /* complain_on_overflow */
1366 bfd_elf_generic_reloc, /* special_function */
1367 "R_NDS32_SDA12S2_DP_RELA", /* name */
1368 FALSE, /* partial_inplace */
1369 0x00000fff, /* src_mask */
1370 0x00000fff, /* dst_mask */
1371 FALSE), /* pcrel_offset */
1372
1373 /* Small data area 12 bits offset. */
1374 HOWTO (R_NDS32_SDA12S2_SP_RELA, /* type */
1375 2, /* rightshift */
1376 2, /* size (0 = byte, 1 = short, 2 = long) */
1377 12, /* bitsize */
1378 FALSE, /* pc_relative */
1379 0, /* bitpos */
1380 complain_overflow_signed, /* complain_on_overflow */
1381 bfd_elf_generic_reloc, /* special_function */
1382 "R_NDS32_SDA12S2_SP_RELA", /* name */
1383 FALSE, /* partial_inplace */
1384 0x00000fff, /* src_mask */
1385 0x00000fff, /* dst_mask */
1386 FALSE), /* pcrel_offset */
1387 /* Lower 12 bits of address. */
1388
1389 HOWTO (R_NDS32_LO12S2_DP_RELA, /* type */
1390 2, /* rightshift */
1391 2, /* size (0 = byte, 1 = short, 2 = long) */
1392 10, /* bitsize */
1393 FALSE, /* pc_relative */
1394 0, /* bitpos */
1395 complain_overflow_dont,/* complain_on_overflow */
1396 bfd_elf_generic_reloc, /* special_function */
1397 "R_NDS32_LO12S2_DP_RELA", /* name */
1398 FALSE, /* partial_inplace */
1399 0x000003ff, /* src_mask */
1400 0x000003ff, /* dst_mask */
1401 FALSE), /* pcrel_offset */
1402
1403 /* Lower 12 bits of address. */
1404 HOWTO (R_NDS32_LO12S2_SP_RELA,/* type */
1405 2, /* rightshift */
1406 2, /* size (0 = byte, 1 = short, 2 = long) */
1407 10, /* bitsize */
1408 FALSE, /* pc_relative */
1409 0, /* bitpos */
1410 complain_overflow_dont,/* complain_on_overflow */
1411 bfd_elf_generic_reloc, /* special_function */
1412 "R_NDS32_LO12S2_SP_RELA", /* name */
1413 FALSE, /* partial_inplace */
1414 0x000003ff, /* src_mask */
1415 0x000003ff, /* dst_mask */
1416 FALSE), /* pcrel_offset */
1417 /* Lower 12 bits of address. Special identity for or case. */
1418 HOWTO (R_NDS32_LO12S0_ORI_RELA, /* type */
1419 0, /* rightshift */
1420 2, /* size (0 = byte, 1 = short, 2 = long) */
1421 12, /* bitsize */
1422 FALSE, /* pc_relative */
1423 0, /* bitpos */
1424 complain_overflow_dont,/* complain_on_overflow */
1425 bfd_elf_generic_reloc, /* special_function */
1426 "R_NDS32_LO12S0_ORI_RELA", /* name */
1427 FALSE, /* partial_inplace */
1428 0x00000fff, /* src_mask */
1429 0x00000fff, /* dst_mask */
1430 FALSE), /* pcrel_offset */
1431 /* Small data area 19 bits offset. */
1432 HOWTO (R_NDS32_SDA16S3_RELA, /* type */
1433 3, /* rightshift */
1434 2, /* size (0 = byte, 1 = short, 2 = long) */
1435 16, /* bitsize */
1436 FALSE, /* pc_relative */
1437 0, /* bitpos */
1438 complain_overflow_signed, /* complain_on_overflow */
1439 bfd_elf_generic_reloc, /* special_function */
1440 "R_NDS32_SDA16S3_RELA",/* name */
1441 FALSE, /* partial_inplace */
1442 0x0000ffff, /* src_mask */
1443 0x0000ffff, /* dst_mask */
1444 FALSE), /* pcrel_offset */
1445
1446 /* Small data area 15 bits offset. */
1447 HOWTO (R_NDS32_SDA17S2_RELA, /* type */
1448 2, /* rightshift */
1449 2, /* size (0 = byte, 1 = short, 2 = long) */
1450 17, /* bitsize */
1451 FALSE, /* pc_relative */
1452 0, /* bitpos */
1453 complain_overflow_signed, /* complain_on_overflow */
1454 bfd_elf_generic_reloc, /* special_function */
1455 "R_NDS32_SDA17S2_RELA",/* name */
1456 FALSE, /* partial_inplace */
1457 0x0001ffff, /* src_mask */
1458 0x0001ffff, /* dst_mask */
1459 FALSE), /* pcrel_offset */
1460
1461 HOWTO (R_NDS32_SDA18S1_RELA, /* type */
1462 1, /* rightshift */
1463 2, /* size (0 = byte, 1 = short, 2 = long) */
1464 18, /* bitsize */
1465 FALSE, /* pc_relative */
1466 0, /* bitpos */
1467 complain_overflow_signed, /* complain_on_overflow */
1468 bfd_elf_generic_reloc, /* special_function */
1469 "R_NDS32_SDA18S1_RELA",/* name */
1470 FALSE, /* partial_inplace */
1471 0x0003ffff, /* src_mask */
1472 0x0003ffff, /* dst_mask */
1473 FALSE), /* pcrel_offset */
1474
1475 HOWTO (R_NDS32_SDA19S0_RELA, /* type */
1476 0, /* rightshift */
1477 2, /* size (0 = byte, 1 = short, 2 = long) */
1478 19, /* bitsize */
1479 FALSE, /* pc_relative */
1480 0, /* bitpos */
1481 complain_overflow_signed, /* complain_on_overflow */
1482 bfd_elf_generic_reloc, /* special_function */
1483 "R_NDS32_SDA19S0_RELA",/* name */
1484 FALSE, /* partial_inplace */
1485 0x0007ffff, /* src_mask */
1486 0x0007ffff, /* dst_mask */
1487 FALSE), /* pcrel_offset */
1488 HOWTO (R_NDS32_DWARF2_OP1_RELA, /* type */
1489 0, /* rightshift */
1490 0, /* size (0 = byte, 1 = short, 2 = long) */
1491 8, /* bitsize */
1492 FALSE, /* pc_relative */
1493 0, /* bitpos */
1494 complain_overflow_dont,/* complain_on_overflow */
1495 nds32_elf_ignore_reloc,/* special_function */
1496 "R_NDS32_DWARF2_OP1_RELA", /* name */
1497 FALSE, /* partial_inplace */
1498 0xff, /* src_mask */
1499 0xff, /* dst_mask */
1500 FALSE), /* pcrel_offset */
1501 HOWTO (R_NDS32_DWARF2_OP2_RELA, /* type */
1502 0, /* rightshift */
1503 1, /* size (0 = byte, 1 = short, 2 = long) */
1504 16, /* bitsize */
1505 FALSE, /* pc_relative */
1506 0, /* bitpos */
1507 complain_overflow_dont,/* complain_on_overflow */
1508 nds32_elf_ignore_reloc,/* special_function */
1509 "R_NDS32_DWARF2_OP2_RELA", /* name */
1510 FALSE, /* partial_inplace */
1511 0xffff, /* src_mask */
1512 0xffff, /* dst_mask */
1513 FALSE), /* pcrel_offset */
1514 HOWTO (R_NDS32_DWARF2_LEB_RELA, /* type */
1515 0, /* rightshift */
1516 2, /* size (0 = byte, 1 = short, 2 = long) */
1517 32, /* bitsize */
1518 FALSE, /* pc_relative */
1519 0, /* bitpos */
1520 complain_overflow_dont,/* complain_on_overflow */
1521 nds32_elf_ignore_reloc,/* special_function */
1522 "R_NDS32_DWARF2_LEB_RELA", /* name */
1523 FALSE, /* partial_inplace */
1524 0xffffffff, /* src_mask */
1525 0xffffffff, /* dst_mask */
1526 FALSE), /* pcrel_offset */
1527 HOWTO (R_NDS32_UPDATE_TA_RELA,/* type */
1528 0, /* rightshift */
1529 1, /* size (0 = byte, 1 = short, 2 = long) */
1530 16, /* bitsize */
1531 FALSE, /* pc_relative */
1532 0, /* bitpos */
1533 complain_overflow_dont,/* complain_on_overflow */
1534 nds32_elf_ignore_reloc,/* special_function */
1535 "R_NDS32_UPDATE_TA_RELA", /* name */
1536 FALSE, /* partial_inplace */
1537 0xffff, /* src_mask */
1538 0xffff, /* dst_mask */
1539 FALSE), /* pcrel_offset */
1540 /* Like R_NDS32_PCREL, but referring to the procedure linkage table
1541 entry for the symbol. */
1542 HOWTO (R_NDS32_9_PLTREL, /* type */
1543 1, /* rightshift */
1544 1, /* size (0 = byte, 1 = short, 2 = long) */
1545 8, /* bitsize */
1546 TRUE, /* pc_relative */
1547 0, /* bitpos */
1548 complain_overflow_signed, /* complain_on_overflow */
1549 bfd_elf_generic_reloc, /* special_function */
1550 "R_NDS32_9_PLTREL", /* name */
1551 FALSE, /* partial_inplace */
1552 0xff, /* src_mask */
1553 0xff, /* dst_mask */
1554 TRUE), /* pcrel_offset */
1555 /* Low 20 bits of PLT symbol offset relative to GOT (GP). */
1556 HOWTO (R_NDS32_PLT_GOTREL_LO20, /* type */
1557 0, /* rightshift */
1558 2, /* size (0 = byte, 1 = short, 2 = long) */
1559 20, /* bitsize */
1560 FALSE, /* pc_relative */
1561 0, /* bitpos */
1562 complain_overflow_dont,/* complain_on_overflow */
1563 bfd_elf_generic_reloc, /* special_function */
1564 "R_NDS32_PLT_GOTREL_LO20", /* name */
1565 FALSE, /* partial_inplace */
1566 0x000fffff, /* src_mask */
1567 0x000fffff, /* dst_mask */
1568 FALSE), /* pcrel_offset */
1569 /* low 15 bits of PLT symbol offset relative to GOT (GP) */
1570 HOWTO (R_NDS32_PLT_GOTREL_LO15, /* type */
1571 0, /* rightshift */
1572 2, /* size (0 = byte, 1 = short, 2 = long) */
1573 15, /* bitsize */
1574 FALSE, /* pc_relative */
1575 0, /* bitpos */
1576 complain_overflow_dont,/* complain_on_overflow */
1577 bfd_elf_generic_reloc, /* special_function */
1578 "R_NDS32_PLT_GOTREL_LO15", /* name */
1579 FALSE, /* partial_inplace */
1580 0x00007fff, /* src_mask */
1581 0x00007fff, /* dst_mask */
1582 FALSE), /* pcrel_offset */
1583 /* Low 19 bits of PLT symbol offset relative to GOT (GP). */
1584 HOWTO (R_NDS32_PLT_GOTREL_LO19, /* type */
1585 0, /* rightshift */
1586 2, /* size (0 = byte, 1 = short, 2 = long) */
1587 19, /* bitsize */
1588 FALSE, /* pc_relative */
1589 0, /* bitpos */
1590 complain_overflow_dont,/* complain_on_overflow */
1591 bfd_elf_generic_reloc, /* special_function */
1592 "R_NDS32_PLT_GOTREL_LO19", /* name */
1593 FALSE, /* partial_inplace */
1594 0x0007ffff, /* src_mask */
1595 0x0007ffff, /* dst_mask */
1596 FALSE), /* pcrel_offset */
1597 HOWTO (R_NDS32_GOT_LO15, /* type */
1598 0, /* rightshift */
1599 2, /* size (0 = byte, 1 = short, 2 = long) */
1600 15, /* bitsize */
1601 FALSE, /* pc_relative */
1602 0, /* bitpos */
1603 complain_overflow_dont,/* complain_on_overflow */
1604 bfd_elf_generic_reloc, /* special_function */
1605 "R_NDS32_GOT_LO15", /* name */
1606 FALSE, /* partial_inplace */
1607 0x00007fff, /* src_mask */
1608 0x00007fff, /* dst_mask */
1609 FALSE), /* pcrel_offset */
1610 HOWTO (R_NDS32_GOT_LO19, /* type */
1611 0, /* rightshift */
1612 2, /* size (0 = byte, 1 = short, 2 = long) */
1613 19, /* bitsize */
1614 FALSE, /* pc_relative */
1615 0, /* bitpos */
1616 complain_overflow_dont,/* complain_on_overflow */
1617 bfd_elf_generic_reloc, /* special_function */
1618 "R_NDS32_GOT_LO19", /* name */
1619 FALSE, /* partial_inplace */
1620 0x0007ffff, /* src_mask */
1621 0x0007ffff, /* dst_mask */
1622 FALSE), /* pcrel_offset */
1623 HOWTO (R_NDS32_GOTOFF_LO15, /* type */
1624 0, /* rightshift */
1625 2, /* size (0 = byte, 1 = short, 2 = long) */
1626 15, /* bitsize */
1627 FALSE, /* pc_relative */
1628 0, /* bitpos */
1629 complain_overflow_dont,/* complain_on_overflow */
1630 bfd_elf_generic_reloc, /* special_function */
1631 "R_NDS32_GOTOFF_LO15", /* name */
1632 FALSE, /* partial_inplace */
1633 0x00007fff, /* src_mask */
1634 0x00007fff, /* dst_mask */
1635 FALSE), /* pcrel_offset */
1636 HOWTO (R_NDS32_GOTOFF_LO19, /* type */
1637 0, /* rightshift */
1638 2, /* size (0 = byte, 1 = short, 2 = long) */
1639 19, /* bitsize */
1640 FALSE, /* pc_relative */
1641 0, /* bitpos */
1642 complain_overflow_dont,/* complain_on_overflow */
1643 bfd_elf_generic_reloc, /* special_function */
1644 "R_NDS32_GOTOFF_LO19", /* name */
1645 FALSE, /* partial_inplace */
1646 0x0007ffff, /* src_mask */
1647 0x0007ffff, /* dst_mask */
1648 FALSE), /* pcrel_offset */
1649 /* GOT 15 bits offset. */
1650 HOWTO (R_NDS32_GOT15S2_RELA, /* type */
1651 2, /* rightshift */
1652 2, /* size (0 = byte, 1 = short, 2 = long) */
1653 15, /* bitsize */
1654 FALSE, /* pc_relative */
1655 0, /* bitpos */
1656 complain_overflow_signed, /* complain_on_overflow */
1657 bfd_elf_generic_reloc, /* special_function */
1658 "R_NDS32_GOT15S2_RELA",/* name */
1659 FALSE, /* partial_inplace */
1660 0x00007fff, /* src_mask */
1661 0x00007fff, /* dst_mask */
1662 FALSE), /* pcrel_offset */
1663 /* GOT 17 bits offset. */
1664 HOWTO (R_NDS32_GOT17S2_RELA, /* type */
1665 2, /* rightshift */
1666 2, /* size (0 = byte, 1 = short, 2 = long) */
1667 17, /* bitsize */
1668 FALSE, /* pc_relative */
1669 0, /* bitpos */
1670 complain_overflow_signed, /* complain_on_overflow */
1671 bfd_elf_generic_reloc, /* special_function */
1672 "R_NDS32_GOT17S2_RELA",/* name */
1673 FALSE, /* partial_inplace */
1674 0x0001ffff, /* src_mask */
1675 0x0001ffff, /* dst_mask */
1676 FALSE), /* pcrel_offset */
1677 /* A 5 bit address. */
1678 HOWTO (R_NDS32_5_RELA, /* type */
1679 0, /* rightshift */
1680 1, /* size (0 = byte, 1 = short, 2 = long) */
1681 5, /* bitsize */
1682 FALSE, /* pc_relative */
1683 0, /* bitpos */
1684 complain_overflow_signed, /* complain_on_overflow */
1685 bfd_elf_generic_reloc, /* special_function */
1686 "R_NDS32_5_RELA", /* name */
1687 FALSE, /* partial_inplace */
1688 0x1f, /* src_mask */
1689 0x1f, /* dst_mask */
1690 FALSE), /* pcrel_offset */
1691 HOWTO (R_NDS32_10_UPCREL_RELA,/* type */
1692 1, /* rightshift */
1693 1, /* size (0 = byte, 1 = short, 2 = long) */
1694 9, /* bitsize */
1695 TRUE, /* pc_relative */
1696 0, /* bitpos */
1697 complain_overflow_unsigned, /* complain_on_overflow */
1698 bfd_elf_generic_reloc, /* special_function */
1699 "R_NDS32_10_UPCREL_RELA", /* name */
1700 FALSE, /* partial_inplace */
1701 0x1ff, /* src_mask */
1702 0x1ff, /* dst_mask */
1703 TRUE), /* pcrel_offset */
1704 HOWTO (R_NDS32_SDA_FP7U2_RELA,/* type */
1705 2, /* rightshift */
1706 1, /* size (0 = byte, 1 = short, 2 = long) */
1707 7, /* bitsize */
1708 FALSE, /* pc_relative */
1709 0, /* bitpos */
1710 complain_overflow_unsigned, /* complain_on_overflow */
1711 bfd_elf_generic_reloc, /* special_function */
1712 "R_NDS32_SDA_FP7U2_RELA", /* name */
1713 FALSE, /* partial_inplace */
1714 0x0000007f, /* src_mask */
1715 0x0000007f, /* dst_mask */
1716 FALSE), /* pcrel_offset */
1717 HOWTO (R_NDS32_WORD_9_PCREL_RELA, /* type */
1718 1, /* rightshift */
1719 2, /* size (0 = byte, 1 = short, 2 = long) */
1720 8, /* bitsize */
1721 TRUE, /* pc_relative */
1722 0, /* bitpos */
1723 complain_overflow_signed, /* complain_on_overflow */
1724 bfd_elf_generic_reloc, /* special_function */
1725 "R_NDS32_WORD_9_PCREL_RELA", /* name */
1726 FALSE, /* partial_inplace */
1727 0xff, /* src_mask */
1728 0xff, /* dst_mask */
1729 TRUE), /* pcrel_offset */
1730 HOWTO (R_NDS32_25_ABS_RELA, /* type */
1731 1, /* rightshift */
1732 2, /* size (0 = byte, 1 = short, 2 = long) */
1733 24, /* bitsize */
1734 FALSE, /* pc_relative */
1735 0, /* bitpos */
1736 complain_overflow_dont,/* complain_on_overflow */
1737 bfd_elf_generic_reloc, /* special_function */
1738 "R_NDS32_25_ABS_RELA", /* name */
1739 FALSE, /* partial_inplace */
1740 0xffffff, /* src_mask */
1741 0xffffff, /* dst_mask */
1742 FALSE), /* pcrel_offset */
1743
1744 /* A relative 17 bit relocation for ifc, right shifted by 1. */
1745 HOWTO (R_NDS32_17IFC_PCREL_RELA, /* type */
1746 1, /* rightshift */
1747 2, /* size (0 = byte, 1 = short, 2 = long) */
1748 16, /* bitsize */
1749 TRUE, /* pc_relative */
1750 0, /* bitpos */
1751 complain_overflow_signed, /* complain_on_overflow */
1752 bfd_elf_generic_reloc, /* special_function */
1753 "R_NDS32_17IFC_PCREL_RELA", /* name */
1754 FALSE, /* partial_inplace */
1755 0xffff, /* src_mask */
1756 0xffff, /* dst_mask */
1757 TRUE), /* pcrel_offset */
1758
1759 /* A relative unsigned 10 bit relocation for ifc, right shifted by 1. */
1760 HOWTO (R_NDS32_10IFCU_PCREL_RELA, /* type */
1761 1, /* rightshift */
1762 1, /* size (0 = byte, 1 = short, 2 = long) */
1763 9, /* bitsize */
1764 TRUE, /* pc_relative */
1765 0, /* bitpos */
1766 complain_overflow_unsigned, /* complain_on_overflow */
1767 bfd_elf_generic_reloc, /* special_function */
1768 "R_NDS32_10IFCU_PCREL_RELA", /* name */
1769 FALSE, /* partial_inplace */
1770 0x1ff, /* src_mask */
1771 0x1ff, /* dst_mask */
1772 TRUE), /* pcrel_offset */
1773
1774 /* Like R_NDS32_HI20, but referring to the TLS entry for the symbol. */
1775 HOWTO (R_NDS32_TLS_LE_HI20, /* type */
1776 12, /* rightshift */
1777 2, /* size (0 = byte, 1 = short, 2 = long) */
1778 20, /* bitsize */
1779 FALSE, /* pc_relative */
1780 0, /* bitpos */
1781 complain_overflow_dont, /* complain_on_overflow */
1782 bfd_elf_generic_reloc, /* special_function */
1783 "R_NDS32_TLS_LE_HI20", /* name */
1784 FALSE, /* partial_inplace */
1785 0x000fffff, /* src_mask */
1786 0x000fffff, /* dst_mask */
1787 FALSE), /* pcrel_offset */
1788 HOWTO (R_NDS32_TLS_LE_LO12, /* type */
1789 0, /* rightshift */
1790 2, /* size (0 = byte, 1 = short, 2 = long) */
1791 12, /* bitsize */
1792 FALSE, /* pc_relative */
1793 0, /* bitpos */
1794 complain_overflow_dont, /* complain_on_overflow */
1795 bfd_elf_generic_reloc, /* special_function */
1796 "R_NDS32_TLS_LE_LO12", /* name */
1797 FALSE, /* partial_inplace */
1798 0x00000fff, /* src_mask */
1799 0x00000fff, /* dst_mask */
1800 FALSE), /* pcrel_offset */
1801
1802 /* Like R_NDS32_HI20, but referring to the TLS entry for the symbol. */
1803 HOWTO (R_NDS32_TLS_IE_HI20, /* type */
1804 12, /* rightshift */
1805 2, /* size (0 = byte, 1 = short, 2 = long) */
1806 20, /* bitsize */
1807 FALSE, /* pc_relative */
1808 0, /* bitpos */
1809 complain_overflow_dont, /* complain_on_overflow */
1810 bfd_elf_generic_reloc, /* special_function */
1811 "R_NDS32_TLS_IE_HI20", /* name */
1812 FALSE, /* partial_inplace */
1813 0x000fffff, /* src_mask */
1814 0x000fffff, /* dst_mask */
1815 FALSE), /* pcrel_offset */
1816 HOWTO (R_NDS32_TLS_IE_LO12S2, /* type */
1817 2, /* rightshift */
1818 2, /* size (0 = byte, 1 = short, 2 = long) */
1819 10, /* bitsize */
1820 FALSE, /* pc_relative */
1821 0, /* bitpos */
1822 complain_overflow_dont, /* complain_on_overflow */
1823 bfd_elf_generic_reloc, /* special_function */
1824 "R_NDS32_TLS_IE_LO12S2", /* name */
1825 FALSE, /* partial_inplace */
1826 0x000003ff, /* src_mask */
1827 0x000003ff, /* dst_mask */
1828 FALSE), /* pcrel_offset */
1829 /* Mark a TLS IE entry in GOT. */
1830 HOWTO (R_NDS32_TLS_TPOFF, /* type */
1831 0, /* rightshift */
1832 2, /* size (0 = byte, 1 = short, 2 = long) */
1833 32, /* bitsize */
1834 FALSE, /* pc_relative */
1835 0, /* bitpos */
1836 complain_overflow_bitfield, /* complain_on_overflow */
1837 bfd_elf_generic_reloc, /* special_function */
1838 "R_NDS32_TLS_TPOFF", /* name */
1839 FALSE, /* partial_inplace */
1840 0xffffffff, /* src_mask */
1841 0xffffffff, /* dst_mask */
1842 FALSE), /* pcrel_offset */
1843 /* A 20 bit address. */
1844 HOWTO (R_NDS32_TLS_LE_20, /* type */
1845 0, /* rightshift */
1846 2, /* size (0 = byte, 1 = short, 2 = long) */
1847 20, /* bitsize */
1848 FALSE, /* pc_relative */
1849 0, /* bitpos */
1850 complain_overflow_signed, /* complain_on_overflow */
1851 bfd_elf_generic_reloc, /* special_function */
1852 "R_NDS32_TLS_LE_20", /* name */
1853 FALSE, /* partial_inplace */
1854 0xfffff, /* src_mask */
1855 0xfffff, /* dst_mask */
1856 FALSE), /* pcrel_offset */
1857 HOWTO (R_NDS32_TLS_LE_15S0, /* type */
1858 0, /* rightshift */
1859 2, /* size (0 = byte, 1 = short, 2 = long) */
1860 15, /* bitsize */
1861 FALSE, /* pc_relative */
1862 0, /* bitpos */
1863 complain_overflow_signed, /* complain_on_overflow */
1864 bfd_elf_generic_reloc, /* special_function */
1865 "R_NDS32_TLS_LE_15S0", /* name */
1866 FALSE, /* partial_inplace */
1867 0x7fff, /* src_mask */
1868 0x7fff, /* dst_mask */
1869 FALSE), /* pcrel_offset */
1870 HOWTO (R_NDS32_TLS_LE_15S1, /* type */
1871 1, /* rightshift */
1872 2, /* size (0 = byte, 1 = short, 2 = long) */
1873 15, /* bitsize */
1874 FALSE, /* pc_relative */
1875 0, /* bitpos */
1876 complain_overflow_signed, /* complain_on_overflow */
1877 bfd_elf_generic_reloc, /* special_function */
1878 "R_NDS32_TLS_LE_15S1", /* name */
1879 FALSE, /* partial_inplace */
1880 0x7fff, /* src_mask */
1881 0x7fff, /* dst_mask */
1882 FALSE), /* pcrel_offset */
1883 HOWTO (R_NDS32_TLS_LE_15S2, /* type */
1884 2, /* rightshift */
1885 2, /* size (0 = byte, 1 = short, 2 = long) */
1886 15, /* bitsize */
1887 FALSE, /* pc_relative */
1888 0, /* bitpos */
1889 complain_overflow_signed, /* complain_on_overflow */
1890 bfd_elf_generic_reloc, /* special_function */
1891 "R_NDS32_TLS_LE_15S2", /* name */
1892 FALSE, /* partial_inplace */
1893 0x7fff, /* src_mask */
1894 0x7fff, /* dst_mask */
1895 FALSE), /* pcrel_offset */
1896
1897 /* Relax hint for unconditional call sequence */
1898 HOWTO (R_NDS32_LONGCALL4, /* type */
1899 0, /* rightshift */
1900 2, /* size (0 = byte, 1 = short, 2 = long) */
1901 32, /* bitsize */
1902 FALSE, /* pc_relative */
1903 0, /* bitpos */
1904 complain_overflow_dont, /* complain_on_overflow */
1905 nds32_elf_ignore_reloc, /* special_function */
1906 "R_NDS32_LONGCALL4", /* name */
1907 FALSE, /* partial_inplace */
1908 0xffffffff, /* src_mask */
1909 0xffffffff, /* dst_mask */
1910 FALSE), /* pcrel_offset */
1911
1912 /* Relax hint for conditional call sequence. */
1913 HOWTO (R_NDS32_LONGCALL5, /* type */
1914 0, /* rightshift */
1915 2, /* size (0 = byte, 1 = short, 2 = long) */
1916 32, /* bitsize */
1917 FALSE, /* pc_relative */
1918 0, /* bitpos */
1919 complain_overflow_dont, /* complain_on_overflow */
1920 nds32_elf_ignore_reloc, /* special_function */
1921 "R_NDS32_LONGCALL5", /* name */
1922 FALSE, /* partial_inplace */
1923 0xffffffff, /* src_mask */
1924 0xffffffff, /* dst_mask */
1925 FALSE), /* pcrel_offset */
1926
1927 /* Relax hint for conditional call sequence. */
1928 HOWTO (R_NDS32_LONGCALL6, /* type */
1929 0, /* rightshift */
1930 2, /* size (0 = byte, 1 = short, 2 = long) */
1931 32, /* bitsize */
1932 FALSE, /* pc_relative */
1933 0, /* bitpos */
1934 complain_overflow_dont, /* complain_on_overflow */
1935 nds32_elf_ignore_reloc, /* special_function */
1936 "R_NDS32_LONGCALL6", /* name */
1937 FALSE, /* partial_inplace */
1938 0xffffffff, /* src_mask */
1939 0xffffffff, /* dst_mask */
1940 FALSE), /* pcrel_offset */
1941
1942 /* Relax hint for unconditional branch sequence. */
1943 HOWTO (R_NDS32_LONGJUMP4, /* type */
1944 0, /* rightshift */
1945 2, /* size (0 = byte, 1 = short, 2 = long) */
1946 32, /* bitsize */
1947 FALSE, /* pc_relative */
1948 0, /* bitpos */
1949 complain_overflow_dont, /* complain_on_overflow */
1950 nds32_elf_ignore_reloc, /* special_function */
1951 "R_NDS32_LONGJUMP4", /* name */
1952 FALSE, /* partial_inplace */
1953 0xffffffff, /* src_mask */
1954 0xffffffff, /* dst_mask */
1955 FALSE), /* pcrel_offset */
1956
1957 /* Relax hint for conditional branch sequence. */
1958 HOWTO (R_NDS32_LONGJUMP5, /* type */
1959 0, /* rightshift */
1960 2, /* size (0 = byte, 1 = short, 2 = long) */
1961 32, /* bitsize */
1962 FALSE, /* pc_relative */
1963 0, /* bitpos */
1964 complain_overflow_dont, /* complain_on_overflow */
1965 nds32_elf_ignore_reloc, /* special_function */
1966 "R_NDS32_LONGJUMP5", /* name */
1967 FALSE, /* partial_inplace */
1968 0xffffffff, /* src_mask */
1969 0xffffffff, /* dst_mask */
1970 FALSE), /* pcrel_offset */
1971
1972 /* Relax hint for conditional branch sequence. */
1973 HOWTO (R_NDS32_LONGJUMP6, /* type */
1974 0, /* rightshift */
1975 2, /* size (0 = byte, 1 = short, 2 = long) */
1976 32, /* bitsize */
1977 FALSE, /* pc_relative */
1978 0, /* bitpos */
1979 complain_overflow_dont, /* complain_on_overflow */
1980 nds32_elf_ignore_reloc, /* special_function */
1981 "R_NDS32_LONGJUMP6", /* name */
1982 FALSE, /* partial_inplace */
1983 0xffffffff, /* src_mask */
1984 0xffffffff, /* dst_mask */
1985 FALSE), /* pcrel_offset */
1986
1987 /* Relax hint for conditional branch sequence. */
1988 HOWTO (R_NDS32_LONGJUMP7, /* type */
1989 0, /* rightshift */
1990 2, /* size (0 = byte, 1 = short, 2 = long) */
1991 32, /* bitsize */
1992 FALSE, /* pc_relative */
1993 0, /* bitpos */
1994 complain_overflow_dont, /* complain_on_overflow */
1995 nds32_elf_ignore_reloc, /* special_function */
1996 "R_NDS32_LONGJUMP7", /* name */
1997 FALSE, /* partial_inplace */
1998 0xffffffff, /* src_mask */
1999 0xffffffff, /* dst_mask */
2000 FALSE), /* pcrel_offset */
2001 };
2002
2003 /* Relocations used for relaxation. */
2004 static reloc_howto_type nds32_elf_relax_howto_table[] =
2005 {
2006 HOWTO (R_NDS32_RELAX_ENTRY, /* type */
2007 0, /* rightshift */
2008 2, /* size (0 = byte, 1 = short, 2 = long) */
2009 32, /* bitsize */
2010 FALSE, /* pc_relative */
2011 0, /* bitpos */
2012 complain_overflow_dont,/* complain_on_overflow */
2013 nds32_elf_ignore_reloc,/* special_function */
2014 "R_NDS32_RELAX_ENTRY", /* name */
2015 FALSE, /* partial_inplace */
2016 0xffffffff, /* src_mask */
2017 0xffffffff, /* dst_mask */
2018 FALSE), /* pcrel_offset */
2019 HOWTO (R_NDS32_GOT_SUFF, /* type */
2020 0, /* rightshift */
2021 2, /* size (0 = byte, 1 = short, 2 = long) */
2022 32, /* bitsize */
2023 FALSE, /* pc_relative */
2024 0, /* bitpos */
2025 complain_overflow_dont,/* complain_on_overflow */
2026 nds32_elf_ignore_reloc,/* special_function */
2027 "R_NDS32_GOT_SUFF", /* name */
2028 FALSE, /* partial_inplace */
2029 0xffffffff, /* src_mask */
2030 0xffffffff, /* dst_mask */
2031 FALSE), /* pcrel_offset */
2032 HOWTO (R_NDS32_GOTOFF_SUFF, /* type */
2033 0, /* rightshift */
2034 2, /* size (0 = byte, 1 = short, 2 = long) */
2035 32, /* bitsize */
2036 FALSE, /* pc_relative */
2037 0, /* bitpos */
2038 complain_overflow_bitfield, /* complain_on_overflow */
2039 nds32_elf_ignore_reloc,/* special_function */
2040 "R_NDS32_GOTOFF_SUFF", /* name */
2041 FALSE, /* partial_inplace */
2042 0xffffffff, /* src_mask */
2043 0xffffffff, /* dst_mask */
2044 FALSE), /* pcrel_offset */
2045 HOWTO (R_NDS32_PLT_GOT_SUFF, /* type */
2046 0, /* rightshift */
2047 2, /* size (0 = byte, 1 = short, 2 = long) */
2048 32, /* bitsize */
2049 FALSE, /* pc_relative */
2050 0, /* bitpos */
2051 complain_overflow_dont,/* complain_on_overflow */
2052 nds32_elf_ignore_reloc,/* special_function */
2053 "R_NDS32_PLT_GOT_SUFF",/* name */
2054 FALSE, /* partial_inplace */
2055 0xffffffff, /* src_mask */
2056 0xffffffff, /* dst_mask */
2057 FALSE), /* pcrel_offset */
2058 HOWTO (R_NDS32_MULCALL_SUFF, /* type */
2059 0, /* rightshift */
2060 2, /* size (0 = byte, 1 = short, 2 = long) */
2061 32, /* bitsize */
2062 FALSE, /* pc_relative */
2063 0, /* bitpos */
2064 complain_overflow_dont,/* complain_on_overflow */
2065 nds32_elf_ignore_reloc,/* special_function */
2066 "R_NDS32_MULCALL_SUFF",/* name */
2067 FALSE, /* partial_inplace */
2068 0xffffffff, /* src_mask */
2069 0xffffffff, /* dst_mask */
2070 FALSE), /* pcrel_offset */
2071 HOWTO (R_NDS32_PTR, /* type */
2072 0, /* rightshift */
2073 2, /* size (0 = byte, 1 = short, 2 = long) */
2074 32, /* bitsize */
2075 FALSE, /* pc_relative */
2076 0, /* bitpos */
2077 complain_overflow_dont,/* complain_on_overflow */
2078 nds32_elf_ignore_reloc,/* special_function */
2079 "R_NDS32_PTR", /* name */
2080 FALSE, /* partial_inplace */
2081 0xffffffff, /* src_mask */
2082 0xffffffff, /* dst_mask */
2083 FALSE), /* pcrel_offset */
2084 HOWTO (R_NDS32_PTR_COUNT, /* type */
2085 0, /* rightshift */
2086 2, /* size (0 = byte, 1 = short, 2 = long) */
2087 32, /* bitsize */
2088 FALSE, /* pc_relative */
2089 0, /* bitpos */
2090 complain_overflow_dont,/* complain_on_overflow */
2091 nds32_elf_ignore_reloc,/* special_function */
2092 "R_NDS32_PTR_COUNT", /* name */
2093 FALSE, /* partial_inplace */
2094 0xffffffff, /* src_mask */
2095 0xffffffff, /* dst_mask */
2096 FALSE), /* pcrel_offset */
2097 HOWTO (R_NDS32_PTR_RESOLVED, /* type */
2098 0, /* rightshift */
2099 2, /* size (0 = byte, 1 = short, 2 = long) */
2100 32, /* bitsize */
2101 FALSE, /* pc_relative */
2102 0, /* bitpos */
2103 complain_overflow_dont,/* complain_on_overflow */
2104 nds32_elf_ignore_reloc,/* special_function */
2105 "R_NDS32_PTR_RESOLVED",/* name */
2106 FALSE, /* partial_inplace */
2107 0xffffffff, /* src_mask */
2108 0xffffffff, /* dst_mask */
2109 FALSE), /* pcrel_offset */
2110 HOWTO (R_NDS32_PLTBLOCK, /* type */
2111 0, /* rightshift */
2112 2, /* size (0 = byte, 1 = short, 2 = long) */
2113 32, /* bitsize */
2114 FALSE, /* pc_relative */
2115 0, /* bitpos */
2116 complain_overflow_dont,/* complain_on_overflow */
2117 nds32_elf_ignore_reloc,/* special_function */
2118 "R_NDS32_PLTBLOCK", /* name */
2119 FALSE, /* partial_inplace */
2120 0xffffffff, /* src_mask */
2121 0xffffffff, /* dst_mask */
2122 FALSE), /* pcrel_offset */
2123 HOWTO (R_NDS32_RELAX_REGION_BEGIN, /* type */
2124 0, /* rightshift */
2125 2, /* size (0 = byte, 1 = short, 2 = long) */
2126 32, /* bitsize */
2127 FALSE, /* pc_relative */
2128 0, /* bitpos */
2129 complain_overflow_dont,/* complain_on_overflow */
2130 nds32_elf_ignore_reloc,/* special_function */
2131 "R_NDS32_RELAX_REGION_BEGIN", /* name */
2132 FALSE, /* partial_inplace */
2133 0xffffffff, /* src_mask */
2134 0xffffffff, /* dst_mask */
2135 FALSE), /* pcrel_offset */
2136 HOWTO (R_NDS32_RELAX_REGION_END, /* type */
2137 0, /* rightshift */
2138 2, /* size (0 = byte, 1 = short, 2 = long) */
2139 32, /* bitsize */
2140 FALSE, /* pc_relative */
2141 0, /* bitpos */
2142 complain_overflow_dont,/* complain_on_overflow */
2143 nds32_elf_ignore_reloc,/* special_function */
2144 "R_NDS32_RELAX_REGION_END", /* name */
2145 FALSE, /* partial_inplace */
2146 0xffffffff, /* src_mask */
2147 0xffffffff, /* dst_mask */
2148 FALSE), /* pcrel_offset */
2149 HOWTO (R_NDS32_MINUEND, /* type */
2150 0, /* rightshift */
2151 2, /* size (0 = byte, 1 = short, 2 = long) */
2152 32, /* bitsize */
2153 FALSE, /* pc_relative */
2154 0, /* bitpos */
2155 complain_overflow_dont,/* complain_on_overflow */
2156 nds32_elf_ignore_reloc,/* special_function */
2157 "R_NDS32_MINUEND", /* name */
2158 FALSE, /* partial_inplace */
2159 0xffffffff, /* src_mask */
2160 0xffffffff, /* dst_mask */
2161 FALSE), /* pcrel_offset */
2162 HOWTO (R_NDS32_SUBTRAHEND, /* type */
2163 0, /* rightshift */
2164 2, /* size (0 = byte, 1 = short, 2 = long) */
2165 32, /* bitsize */
2166 FALSE, /* pc_relative */
2167 0, /* bitpos */
2168 complain_overflow_dont,/* complain_on_overflow */
2169 nds32_elf_ignore_reloc,/* special_function */
2170 "R_NDS32_SUBTRAHEND", /* name */
2171 FALSE, /* partial_inplace */
2172 0xffffffff, /* src_mask */
2173 0xffffffff, /* dst_mask */
2174 FALSE), /* pcrel_offset */
2175 HOWTO (R_NDS32_DIFF8, /* type */
2176 0, /* rightshift */
2177 0, /* size (0 = byte, 1 = short, 2 = long) */
2178 8, /* bitsize */
2179 FALSE, /* pc_relative */
2180 0, /* bitpos */
2181 complain_overflow_dont,/* complain_on_overflow */
2182 nds32_elf_ignore_reloc,/* special_function */
2183 "R_NDS32_DIFF8", /* name */
2184 FALSE, /* partial_inplace */
2185 0x000000ff, /* src_mask */
2186 0x000000ff, /* dst_mask */
2187 FALSE), /* pcrel_offset */
2188 HOWTO (R_NDS32_DIFF16, /* type */
2189 0, /* rightshift */
2190 1, /* size (0 = byte, 1 = short, 2 = long) */
2191 16, /* bitsize */
2192 FALSE, /* pc_relative */
2193 0, /* bitpos */
2194 complain_overflow_dont,/* complain_on_overflow */
2195 nds32_elf_ignore_reloc,/* special_function */
2196 "R_NDS32_DIFF16", /* name */
2197 FALSE, /* partial_inplace */
2198 0x0000ffff, /* src_mask */
2199 0x0000ffff, /* dst_mask */
2200 FALSE), /* pcrel_offset */
2201 HOWTO (R_NDS32_DIFF32, /* type */
2202 0, /* rightshift */
2203 2, /* size (0 = byte, 1 = short, 2 = long) */
2204 32, /* bitsize */
2205 FALSE, /* pc_relative */
2206 0, /* bitpos */
2207 complain_overflow_dont,/* complain_on_overflow */
2208 nds32_elf_ignore_reloc,/* special_function */
2209 "R_NDS32_DIFF32", /* name */
2210 FALSE, /* partial_inplace */
2211 0xffffffff, /* src_mask */
2212 0xffffffff, /* dst_mask */
2213 FALSE), /* pcrel_offset */
2214 HOWTO (R_NDS32_DIFF_ULEB128, /* type */
2215 0, /* rightshift */
2216 0, /* size (0 = byte, 1 = short, 2 = long) */
2217 0, /* bitsize */
2218 FALSE, /* pc_relative */
2219 0, /* bitpos */
2220 complain_overflow_dont,/* complain_on_overflow */
2221 nds32_elf_ignore_reloc,/* special_function */
2222 "R_NDS32_DIFF_ULEB128",/* name */
2223 FALSE, /* partial_inplace */
2224 0xffffffff, /* src_mask */
2225 0xffffffff, /* dst_mask */
2226 FALSE), /* pcrel_offset */
2227 HOWTO (R_NDS32_DATA, /* type */
2228 0, /* rightshift */
2229 2, /* size (0 = byte, 1 = short, 2 = long) */
2230 32, /* bitsize */
2231 FALSE, /* pc_relative */
2232 0, /* bitpos */
2233 complain_overflow_dont,/* complain_on_overflow */
2234 nds32_elf_ignore_reloc,/* special_function */
2235 "R_NDS32_DATA", /* name */
2236 FALSE, /* partial_inplace */
2237 0xffffffff, /* src_mask */
2238 0xffffffff, /* dst_mask */
2239 FALSE), /* pcrel_offset */
2240 HOWTO (R_NDS32_TRAN, /* type */
2241 0, /* rightshift */
2242 2, /* size (0 = byte, 1 = short, 2 = long) */
2243 32, /* bitsize */
2244 FALSE, /* pc_relative */
2245 0, /* bitpos */
2246 complain_overflow_dont,/* complain_on_overflow */
2247 nds32_elf_ignore_reloc,/* special_function */
2248 "R_NDS32_TRAN", /* name */
2249 FALSE, /* partial_inplace */
2250 0xffffffff, /* src_mask */
2251 0xffffffff, /* dst_mask */
2252 FALSE), /* pcrel_offset */
2253 HOWTO (R_NDS32_TLS_LE_ADD, /* type */
2254 0, /* rightshift */
2255 2, /* size (0 = byte, 1 = short, 2 = long) */
2256 32, /* bitsize */
2257 FALSE, /* pc_relative */
2258 0, /* bitpos */
2259 complain_overflow_dont, /* complain_on_overflow */
2260 nds32_elf_ignore_reloc, /* special_function */
2261 "R_NDS32_TLS_LE_ADD", /* name */
2262 FALSE, /* partial_inplace */
2263 0xffffffff, /* src_mask */
2264 0xffffffff, /* dst_mask */
2265 FALSE), /* pcrel_offset */
2266 HOWTO (R_NDS32_TLS_LE_LS, /* type */
2267 0, /* rightshift */
2268 2, /* size (0 = byte, 1 = short, 2 = long) */
2269 32, /* bitsize */
2270 FALSE, /* pc_relative */
2271 0, /* bitpos */
2272 complain_overflow_dont, /* complain_on_overflow */
2273 nds32_elf_ignore_reloc, /* special_function */
2274 "R_NDS32_TLS_LE_LS", /* name */
2275 FALSE, /* partial_inplace */
2276 0xffffffff, /* src_mask */
2277 0xffffffff, /* dst_mask */
2278 FALSE), /* pcrel_offset */
2279 HOWTO (R_NDS32_EMPTY, /* type */
2280 0, /* rightshift */
2281 2, /* size (0 = byte, 1 = short, 2 = long) */
2282 32, /* bitsize */
2283 FALSE, /* pc_relative */
2284 0, /* bitpos */
2285 complain_overflow_dont, /* complain_on_overflow */
2286 nds32_elf_ignore_reloc, /* special_function */
2287 "R_NDS32_EMPTY", /* name */
2288 FALSE, /* partial_inplace */
2289 0xffffffff, /* src_mask */
2290 0xffffffff, /* dst_mask */
2291 FALSE), /* pcrel_offset */
2292 };
2293
2294 \f
2295 /* nds32_insertion_sort sorts an array with nmemb elements of size size.
2296 This prototype is the same as qsort (). */
2297
2298 void
2299 nds32_insertion_sort (void *base, size_t nmemb, size_t size,
2300 int (*compar) (const void *lhs, const void *rhs))
2301 {
2302 char *ptr = (char *) base;
2303 int i, j;
2304 char *tmp = xmalloc (size);
2305
2306 /* If i is less than j, i is inserted before j.
2307
2308 |---- j ----- i --------------|
2309 \ / \ /
2310 sorted unsorted
2311 */
2312
2313 for (i = 1; i < (int) nmemb; i++)
2314 {
2315 for (j = (i - 1); j >= 0; j--)
2316 if (compar (ptr + i * size, ptr + j * size) >= 0)
2317 break;
2318
2319 j++;
2320
2321 if (i == j)
2322 continue; /* i is in order. */
2323
2324 memcpy (tmp, ptr + i * size, size);
2325 memmove (ptr + (j + 1) * size, ptr + j * size, (i - j) * size);
2326 memcpy (ptr + j * size, tmp, size);
2327 }
2328 free (tmp);
2329 }
2330
2331 /* Sort relocation by r_offset.
2332
2333 We didn't use qsort () in stdlib, because quick-sort is not a stable sorting
2334 algorithm. Relocations at the same r_offset must keep their order.
2335 For example, RELAX_ENTRY must be the very first relocation entry.
2336
2337 Currently, this function implements insertion-sort.
2338
2339 FIXME: If we already sort them in assembler, why bother sort them
2340 here again? */
2341
2342 static int
2343 compar_reloc (const void *lhs, const void *rhs)
2344 {
2345 const Elf_Internal_Rela *l = (const Elf_Internal_Rela *) lhs;
2346 const Elf_Internal_Rela *r = (const Elf_Internal_Rela *) rhs;
2347
2348 if (l->r_offset > r->r_offset)
2349 return 1;
2350 else if (l->r_offset == r->r_offset)
2351 return 0;
2352 else
2353 return -1;
2354 }
2355
2356 /* Functions listed below are only used for old relocs.
2357 * nds32_elf_9_pcrel_reloc
2358 * nds32_elf_do_9_pcrel_reloc
2359 * nds32_elf_hi20_reloc
2360 * nds32_elf_relocate_hi20
2361 * nds32_elf_lo12_reloc
2362 * nds32_elf_sda15_reloc
2363 * nds32_elf_generic_reloc
2364 */
2365
2366 /* Handle the R_NDS32_9_PCREL & R_NDS32_9_PCREL_RELA reloc. */
2367
2368 static bfd_reloc_status_type
2369 nds32_elf_9_pcrel_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2370 void *data, asection *input_section, bfd *output_bfd,
2371 char **error_message ATTRIBUTE_UNUSED)
2372 {
2373 /* This part is from bfd_elf_generic_reloc. */
2374 if (output_bfd != (bfd *) NULL
2375 && (symbol->flags & BSF_SECTION_SYM) == 0
2376 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2377 {
2378 reloc_entry->address += input_section->output_offset;
2379 return bfd_reloc_ok;
2380 }
2381
2382 if (output_bfd != NULL)
2383 {
2384 /* FIXME: See bfd_perform_relocation. Is this right? */
2385 return bfd_reloc_continue;
2386 }
2387
2388 return nds32_elf_do_9_pcrel_reloc (abfd, reloc_entry->howto,
2389 input_section,
2390 data, reloc_entry->address,
2391 symbol->section,
2392 (symbol->value
2393 + symbol->section->output_section->vma
2394 + symbol->section->output_offset),
2395 reloc_entry->addend);
2396 }
2397
2398 /* Utility to actually perform an R_NDS32_9_PCREL reloc. */
2399 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
2400
2401 static bfd_reloc_status_type
2402 nds32_elf_do_9_pcrel_reloc (bfd *abfd, reloc_howto_type *howto,
2403 asection *input_section, bfd_byte *data,
2404 bfd_vma offset,
2405 asection *symbol_section ATTRIBUTE_UNUSED,
2406 bfd_vma symbol_value, bfd_vma addend)
2407 {
2408 bfd_signed_vma relocation;
2409 unsigned short x;
2410 bfd_reloc_status_type status;
2411
2412 /* Sanity check the address (offset in section). */
2413 if (offset > bfd_get_section_limit (abfd, input_section))
2414 return bfd_reloc_outofrange;
2415
2416 relocation = symbol_value + addend;
2417 /* Make it pc relative. */
2418 relocation -= (input_section->output_section->vma
2419 + input_section->output_offset);
2420 /* These jumps mask off the lower two bits of the current address
2421 before doing pcrel calculations. */
2422 relocation -= (offset & -(bfd_vma) 2);
2423
2424 if (relocation < -ACCURATE_8BIT_S1 || relocation >= ACCURATE_8BIT_S1)
2425 status = bfd_reloc_overflow;
2426 else
2427 status = bfd_reloc_ok;
2428
2429 x = bfd_getb16 (data + offset);
2430
2431 relocation >>= howto->rightshift;
2432 relocation <<= howto->bitpos;
2433 x = (x & ~howto->dst_mask)
2434 | (((x & howto->src_mask) + relocation) & howto->dst_mask);
2435
2436 bfd_putb16 ((bfd_vma) x, data + offset);
2437
2438 return status;
2439 }
2440
2441 /* Handle the R_NDS32_HI20_[SU]LO relocs.
2442 HI20_SLO is for the add3 and load/store with displacement instructions.
2443 HI20 is for the or3 instruction.
2444 For R_NDS32_HI20_SLO, the lower 16 bits are sign extended when added to
2445 the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
2446 we must add one to the high 16 bytes (which will get subtracted off when
2447 the low 16 bits are added).
2448 These relocs have to be done in combination with an R_NDS32_LO12 reloc
2449 because there is a carry from the LO12 to the HI20. Here we just save
2450 the information we need; we do the actual relocation when we see the LO12.
2451 This code is copied from the elf32-mips.c. We also support an arbitrary
2452 number of HI20 relocs to be associated with a single LO12 reloc. The
2453 assembler sorts the relocs to ensure each HI20 immediately precedes its
2454 LO12. However if there are multiple copies, the assembler may not find
2455 the real LO12 so it picks the first one it finds. */
2456
2457 struct nds32_hi20
2458 {
2459 struct nds32_hi20 *next;
2460 bfd_byte *addr;
2461 bfd_vma addend;
2462 };
2463
2464 static struct nds32_hi20 *nds32_hi20_list;
2465
2466 static bfd_reloc_status_type
2467 nds32_elf_hi20_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2468 asymbol *symbol, void *data, asection *input_section,
2469 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2470 {
2471 bfd_reloc_status_type ret;
2472 bfd_vma relocation;
2473 struct nds32_hi20 *n;
2474
2475 /* This part is from bfd_elf_generic_reloc.
2476 If we're relocating, and this an external symbol, we don't want
2477 to change anything. */
2478 if (output_bfd != (bfd *) NULL
2479 && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0)
2480 {
2481 reloc_entry->address += input_section->output_offset;
2482 return bfd_reloc_ok;
2483 }
2484
2485 /* Sanity check the address (offset in section). */
2486 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2487 return bfd_reloc_outofrange;
2488
2489 ret = bfd_reloc_ok;
2490 if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2491 ret = bfd_reloc_undefined;
2492
2493 if (bfd_is_com_section (symbol->section))
2494 relocation = 0;
2495 else
2496 relocation = symbol->value;
2497
2498 relocation += symbol->section->output_section->vma;
2499 relocation += symbol->section->output_offset;
2500 relocation += reloc_entry->addend;
2501
2502 /* Save the information, and let LO12 do the actual relocation. */
2503 n = (struct nds32_hi20 *) bfd_malloc ((bfd_size_type) sizeof *n);
2504 if (n == NULL)
2505 return bfd_reloc_outofrange;
2506
2507 n->addr = (bfd_byte *) data + reloc_entry->address;
2508 n->addend = relocation;
2509 n->next = nds32_hi20_list;
2510 nds32_hi20_list = n;
2511
2512 if (output_bfd != (bfd *) NULL)
2513 reloc_entry->address += input_section->output_offset;
2514
2515 return ret;
2516 }
2517
2518 /* Handle an NDS32 ELF HI20 reloc. */
2519
2520 static void
2521 nds32_elf_relocate_hi20 (bfd *input_bfd ATTRIBUTE_UNUSED,
2522 int type ATTRIBUTE_UNUSED, Elf_Internal_Rela *relhi,
2523 Elf_Internal_Rela *rello, bfd_byte *contents,
2524 bfd_vma addend)
2525 {
2526 unsigned long insn;
2527 bfd_vma addlo;
2528
2529 insn = bfd_getb32 (contents + relhi->r_offset);
2530
2531 addlo = bfd_getb32 (contents + rello->r_offset);
2532 addlo &= 0xfff;
2533
2534 addend += ((insn & 0xfffff) << 20) + addlo;
2535
2536 insn = (insn & 0xfff00000) | ((addend >> 12) & 0xfffff);
2537 bfd_putb32 (insn, contents + relhi->r_offset);
2538 }
2539
2540 /* Do an R_NDS32_LO12 relocation. This is a straightforward 12 bit
2541 inplace relocation; this function exists in order to do the
2542 R_NDS32_HI20_[SU]LO relocation described above. */
2543
2544 static bfd_reloc_status_type
2545 nds32_elf_lo12_reloc (bfd *input_bfd, arelent *reloc_entry, asymbol *symbol,
2546 void *data, asection *input_section, bfd *output_bfd,
2547 char **error_message)
2548 {
2549 /* This part is from bfd_elf_generic_reloc.
2550 If we're relocating, and this an external symbol, we don't want
2551 to change anything. */
2552 if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2553 && reloc_entry->addend == 0)
2554 {
2555 reloc_entry->address += input_section->output_offset;
2556 return bfd_reloc_ok;
2557 }
2558
2559 if (nds32_hi20_list != NULL)
2560 {
2561 struct nds32_hi20 *l;
2562
2563 l = nds32_hi20_list;
2564 while (l != NULL)
2565 {
2566 unsigned long insn;
2567 unsigned long val;
2568 unsigned long vallo;
2569 struct nds32_hi20 *next;
2570
2571 /* Do the HI20 relocation. Note that we actually don't need
2572 to know anything about the LO12 itself, except where to
2573 find the low 12 bits of the addend needed by the LO12. */
2574 insn = bfd_getb32 (l->addr);
2575 vallo = bfd_getb32 ((bfd_byte *) data + reloc_entry->address);
2576 vallo &= 0xfff;
2577 switch (reloc_entry->howto->type)
2578 {
2579 case R_NDS32_LO12S3:
2580 vallo <<= 3;
2581 break;
2582
2583 case R_NDS32_LO12S2:
2584 vallo <<= 2;
2585 break;
2586
2587 case R_NDS32_LO12S1:
2588 vallo <<= 1;
2589 break;
2590
2591 case R_NDS32_LO12S0:
2592 vallo <<= 0;
2593 break;
2594 }
2595
2596 val = ((insn & 0xfffff) << 12) + vallo;
2597 val += l->addend;
2598
2599 insn = (insn & ~(bfd_vma) 0xfffff) | ((val >> 12) & 0xfffff);
2600 bfd_putb32 ((bfd_vma) insn, l->addr);
2601
2602 next = l->next;
2603 free (l);
2604 l = next;
2605 }
2606
2607 nds32_hi20_list = NULL;
2608 }
2609
2610 /* Now do the LO12 reloc in the usual way.
2611 ??? It would be nice to call bfd_elf_generic_reloc here,
2612 but we have partial_inplace set. bfd_elf_generic_reloc will
2613 pass the handling back to bfd_install_relocation which will install
2614 a section relative addend which is wrong. */
2615 return nds32_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
2616 input_section, output_bfd, error_message);
2617 }
2618
2619 /* Do generic partial_inplace relocation.
2620 This is a local replacement for bfd_elf_generic_reloc. */
2621
2622 static bfd_reloc_status_type
2623 nds32_elf_generic_reloc (bfd *input_bfd, arelent *reloc_entry,
2624 asymbol *symbol, void *data, asection *input_section,
2625 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2626 {
2627 bfd_reloc_status_type ret;
2628 bfd_vma relocation;
2629 bfd_byte *inplace_address;
2630
2631 /* This part is from bfd_elf_generic_reloc.
2632 If we're relocating, and this an external symbol, we don't want
2633 to change anything. */
2634 if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2635 && reloc_entry->addend == 0)
2636 {
2637 reloc_entry->address += input_section->output_offset;
2638 return bfd_reloc_ok;
2639 }
2640
2641 /* Now do the reloc in the usual way.
2642 ??? It would be nice to call bfd_elf_generic_reloc here,
2643 but we have partial_inplace set. bfd_elf_generic_reloc will
2644 pass the handling back to bfd_install_relocation which will install
2645 a section relative addend which is wrong. */
2646
2647 /* Sanity check the address (offset in section). */
2648 if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
2649 return bfd_reloc_outofrange;
2650
2651 ret = bfd_reloc_ok;
2652 if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2653 ret = bfd_reloc_undefined;
2654
2655 if (bfd_is_com_section (symbol->section) || output_bfd != (bfd *) NULL)
2656 relocation = 0;
2657 else
2658 relocation = symbol->value;
2659
2660 /* Only do this for a final link. */
2661 if (output_bfd == (bfd *) NULL)
2662 {
2663 relocation += symbol->section->output_section->vma;
2664 relocation += symbol->section->output_offset;
2665 }
2666
2667 relocation += reloc_entry->addend;
2668 switch (reloc_entry->howto->type)
2669 {
2670 case R_NDS32_LO12S3:
2671 relocation >>= 3;
2672 break;
2673
2674 case R_NDS32_LO12S2:
2675 relocation >>= 2;
2676 break;
2677
2678 case R_NDS32_LO12S1:
2679 relocation >>= 1;
2680 break;
2681
2682 case R_NDS32_LO12S0:
2683 default:
2684 relocation >>= 0;
2685 break;
2686 }
2687
2688 inplace_address = (bfd_byte *) data + reloc_entry->address;
2689
2690 #define DOIT(x) \
2691 x = ((x & ~reloc_entry->howto->dst_mask) | \
2692 (((x & reloc_entry->howto->src_mask) + relocation) & \
2693 reloc_entry->howto->dst_mask))
2694
2695 switch (reloc_entry->howto->size)
2696 {
2697 case 1:
2698 {
2699 short x = bfd_getb16 (inplace_address);
2700
2701 DOIT (x);
2702 bfd_putb16 ((bfd_vma) x, inplace_address);
2703 }
2704 break;
2705 case 2:
2706 {
2707 unsigned long x = bfd_getb32 (inplace_address);
2708
2709 DOIT (x);
2710 bfd_putb32 ((bfd_vma) x, inplace_address);
2711 }
2712 break;
2713 default:
2714 BFD_ASSERT (0);
2715 }
2716
2717 if (output_bfd != (bfd *) NULL)
2718 reloc_entry->address += input_section->output_offset;
2719
2720 return ret;
2721 }
2722
2723 /* Handle the R_NDS32_SDA15 reloc.
2724 This reloc is used to compute the address of objects in the small data area
2725 and to perform loads and stores from that area.
2726 The lower 15 bits are sign extended and added to the register specified
2727 in the instruction, which is assumed to point to _SDA_BASE_.
2728
2729 Since the lower 15 bits offset is left-shifted 0, 1 or 2 bits depending on
2730 the access size, this must be taken care of. */
2731
2732 static bfd_reloc_status_type
2733 nds32_elf_sda15_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2734 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2735 asection *input_section, bfd *output_bfd,
2736 char **error_message ATTRIBUTE_UNUSED)
2737 {
2738 /* This part is from bfd_elf_generic_reloc. */
2739 if (output_bfd != (bfd *) NULL
2740 && (symbol->flags & BSF_SECTION_SYM) == 0
2741 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2742 {
2743 reloc_entry->address += input_section->output_offset;
2744 return bfd_reloc_ok;
2745 }
2746
2747 if (output_bfd != NULL)
2748 {
2749 /* FIXME: See bfd_perform_relocation. Is this right? */
2750 return bfd_reloc_continue;
2751 }
2752
2753 /* FIXME: not sure what to do here yet. But then again, the linker
2754 may never call us. */
2755 abort ();
2756 }
2757
2758 /* nds32_elf_ignore_reloc is the special function for
2759 relocation types which don't need to be relocated
2760 like relaxation relocation types.
2761 This function simply return bfd_reloc_ok when it is
2762 invoked. */
2763
2764 static bfd_reloc_status_type
2765 nds32_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2766 asymbol *symbol ATTRIBUTE_UNUSED,
2767 void *data ATTRIBUTE_UNUSED, asection *input_section,
2768 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2769 {
2770 if (output_bfd != NULL)
2771 reloc_entry->address += input_section->output_offset;
2772
2773 return bfd_reloc_ok;
2774 }
2775 \f
2776
2777 /* Map BFD reloc types to NDS32 ELF reloc types. */
2778
2779 struct nds32_reloc_map_entry
2780 {
2781 bfd_reloc_code_real_type bfd_reloc_val;
2782 unsigned char elf_reloc_val;
2783 };
2784
2785 static const struct nds32_reloc_map_entry nds32_reloc_map[] =
2786 {
2787 {BFD_RELOC_NONE, R_NDS32_NONE},
2788 {BFD_RELOC_16, R_NDS32_16_RELA},
2789 {BFD_RELOC_32, R_NDS32_32_RELA},
2790 {BFD_RELOC_NDS32_20, R_NDS32_20_RELA},
2791 {BFD_RELOC_NDS32_5, R_NDS32_5_RELA},
2792 {BFD_RELOC_NDS32_9_PCREL, R_NDS32_9_PCREL_RELA},
2793 {BFD_RELOC_NDS32_WORD_9_PCREL, R_NDS32_WORD_9_PCREL_RELA},
2794 {BFD_RELOC_NDS32_15_PCREL, R_NDS32_15_PCREL_RELA},
2795 {BFD_RELOC_NDS32_17_PCREL, R_NDS32_17_PCREL_RELA},
2796 {BFD_RELOC_NDS32_25_PCREL, R_NDS32_25_PCREL_RELA},
2797 {BFD_RELOC_NDS32_10_UPCREL, R_NDS32_10_UPCREL_RELA},
2798 {BFD_RELOC_NDS32_HI20, R_NDS32_HI20_RELA},
2799 {BFD_RELOC_NDS32_LO12S3, R_NDS32_LO12S3_RELA},
2800 {BFD_RELOC_NDS32_LO12S2, R_NDS32_LO12S2_RELA},
2801 {BFD_RELOC_NDS32_LO12S1, R_NDS32_LO12S1_RELA},
2802 {BFD_RELOC_NDS32_LO12S0, R_NDS32_LO12S0_RELA},
2803 {BFD_RELOC_NDS32_LO12S0_ORI, R_NDS32_LO12S0_ORI_RELA},
2804 {BFD_RELOC_NDS32_SDA15S3, R_NDS32_SDA15S3_RELA},
2805 {BFD_RELOC_NDS32_SDA15S2, R_NDS32_SDA15S2_RELA},
2806 {BFD_RELOC_NDS32_SDA15S1, R_NDS32_SDA15S1_RELA},
2807 {BFD_RELOC_NDS32_SDA15S0, R_NDS32_SDA15S0_RELA},
2808 {BFD_RELOC_VTABLE_INHERIT, R_NDS32_RELA_GNU_VTINHERIT},
2809 {BFD_RELOC_VTABLE_ENTRY, R_NDS32_RELA_GNU_VTENTRY},
2810
2811 {BFD_RELOC_NDS32_GOT20, R_NDS32_GOT20},
2812 {BFD_RELOC_NDS32_9_PLTREL, R_NDS32_9_PLTREL},
2813 {BFD_RELOC_NDS32_25_PLTREL, R_NDS32_25_PLTREL},
2814 {BFD_RELOC_NDS32_COPY, R_NDS32_COPY},
2815 {BFD_RELOC_NDS32_GLOB_DAT, R_NDS32_GLOB_DAT},
2816 {BFD_RELOC_NDS32_JMP_SLOT, R_NDS32_JMP_SLOT},
2817 {BFD_RELOC_NDS32_RELATIVE, R_NDS32_RELATIVE},
2818 {BFD_RELOC_NDS32_GOTOFF, R_NDS32_GOTOFF},
2819 {BFD_RELOC_NDS32_GOTPC20, R_NDS32_GOTPC20},
2820 {BFD_RELOC_NDS32_GOT_HI20, R_NDS32_GOT_HI20},
2821 {BFD_RELOC_NDS32_GOT_LO12, R_NDS32_GOT_LO12},
2822 {BFD_RELOC_NDS32_GOT_LO15, R_NDS32_GOT_LO15},
2823 {BFD_RELOC_NDS32_GOT_LO19, R_NDS32_GOT_LO19},
2824 {BFD_RELOC_NDS32_GOTPC_HI20, R_NDS32_GOTPC_HI20},
2825 {BFD_RELOC_NDS32_GOTPC_LO12, R_NDS32_GOTPC_LO12},
2826 {BFD_RELOC_NDS32_GOTOFF_HI20, R_NDS32_GOTOFF_HI20},
2827 {BFD_RELOC_NDS32_GOTOFF_LO12, R_NDS32_GOTOFF_LO12},
2828 {BFD_RELOC_NDS32_GOTOFF_LO15, R_NDS32_GOTOFF_LO15},
2829 {BFD_RELOC_NDS32_GOTOFF_LO19, R_NDS32_GOTOFF_LO19},
2830 {BFD_RELOC_NDS32_INSN16, R_NDS32_INSN16},
2831 {BFD_RELOC_NDS32_LABEL, R_NDS32_LABEL},
2832 {BFD_RELOC_NDS32_LONGCALL1, R_NDS32_LONGCALL1},
2833 {BFD_RELOC_NDS32_LONGCALL2, R_NDS32_LONGCALL2},
2834 {BFD_RELOC_NDS32_LONGCALL3, R_NDS32_LONGCALL3},
2835 {BFD_RELOC_NDS32_LONGCALL4, R_NDS32_LONGCALL4},
2836 {BFD_RELOC_NDS32_LONGCALL5, R_NDS32_LONGCALL5},
2837 {BFD_RELOC_NDS32_LONGCALL6, R_NDS32_LONGCALL6},
2838 {BFD_RELOC_NDS32_LONGJUMP1, R_NDS32_LONGJUMP1},
2839 {BFD_RELOC_NDS32_LONGJUMP2, R_NDS32_LONGJUMP2},
2840 {BFD_RELOC_NDS32_LONGJUMP3, R_NDS32_LONGJUMP3},
2841 {BFD_RELOC_NDS32_LONGJUMP4, R_NDS32_LONGJUMP4},
2842 {BFD_RELOC_NDS32_LONGJUMP5, R_NDS32_LONGJUMP5},
2843 {BFD_RELOC_NDS32_LONGJUMP6, R_NDS32_LONGJUMP6},
2844 {BFD_RELOC_NDS32_LONGJUMP7, R_NDS32_LONGJUMP7},
2845 {BFD_RELOC_NDS32_LOADSTORE, R_NDS32_LOADSTORE},
2846 {BFD_RELOC_NDS32_9_FIXED, R_NDS32_9_FIXED_RELA},
2847 {BFD_RELOC_NDS32_15_FIXED, R_NDS32_15_FIXED_RELA},
2848 {BFD_RELOC_NDS32_17_FIXED, R_NDS32_17_FIXED_RELA},
2849 {BFD_RELOC_NDS32_25_FIXED, R_NDS32_25_FIXED_RELA},
2850 {BFD_RELOC_NDS32_PLTREL_HI20, R_NDS32_PLTREL_HI20},
2851 {BFD_RELOC_NDS32_PLTREL_LO12, R_NDS32_PLTREL_LO12},
2852 {BFD_RELOC_NDS32_PLT_GOTREL_HI20, R_NDS32_PLT_GOTREL_HI20},
2853 {BFD_RELOC_NDS32_PLT_GOTREL_LO12, R_NDS32_PLT_GOTREL_LO12},
2854 {BFD_RELOC_NDS32_PLT_GOTREL_LO15, R_NDS32_PLT_GOTREL_LO15},
2855 {BFD_RELOC_NDS32_PLT_GOTREL_LO19, R_NDS32_PLT_GOTREL_LO19},
2856 {BFD_RELOC_NDS32_PLT_GOTREL_LO20, R_NDS32_PLT_GOTREL_LO20},
2857 {BFD_RELOC_NDS32_SDA12S2_DP, R_NDS32_SDA12S2_DP_RELA},
2858 {BFD_RELOC_NDS32_SDA12S2_SP, R_NDS32_SDA12S2_SP_RELA},
2859 {BFD_RELOC_NDS32_LO12S2_DP, R_NDS32_LO12S2_DP_RELA},
2860 {BFD_RELOC_NDS32_LO12S2_SP, R_NDS32_LO12S2_SP_RELA},
2861 {BFD_RELOC_NDS32_SDA16S3, R_NDS32_SDA16S3_RELA},
2862 {BFD_RELOC_NDS32_SDA17S2, R_NDS32_SDA17S2_RELA},
2863 {BFD_RELOC_NDS32_SDA18S1, R_NDS32_SDA18S1_RELA},
2864 {BFD_RELOC_NDS32_SDA19S0, R_NDS32_SDA19S0_RELA},
2865 {BFD_RELOC_NDS32_SDA_FP7U2_RELA, R_NDS32_SDA_FP7U2_RELA},
2866 {BFD_RELOC_NDS32_DWARF2_OP1, R_NDS32_DWARF2_OP1_RELA},
2867 {BFD_RELOC_NDS32_DWARF2_OP2, R_NDS32_DWARF2_OP2_RELA},
2868 {BFD_RELOC_NDS32_DWARF2_LEB, R_NDS32_DWARF2_LEB_RELA},
2869 {BFD_RELOC_NDS32_UPDATE_TA, R_NDS32_UPDATE_TA_RELA},
2870 {BFD_RELOC_NDS32_GOT_SUFF, R_NDS32_GOT_SUFF},
2871 {BFD_RELOC_NDS32_GOTOFF_SUFF, R_NDS32_GOTOFF_SUFF},
2872 {BFD_RELOC_NDS32_GOT15S2, R_NDS32_GOT15S2_RELA},
2873 {BFD_RELOC_NDS32_GOT17S2, R_NDS32_GOT17S2_RELA},
2874 {BFD_RELOC_NDS32_PTR, R_NDS32_PTR},
2875 {BFD_RELOC_NDS32_PTR_COUNT, R_NDS32_PTR_COUNT},
2876 {BFD_RELOC_NDS32_PLT_GOT_SUFF, R_NDS32_PLT_GOT_SUFF},
2877 {BFD_RELOC_NDS32_PTR_RESOLVED, R_NDS32_PTR_RESOLVED},
2878 {BFD_RELOC_NDS32_RELAX_ENTRY, R_NDS32_RELAX_ENTRY},
2879 {BFD_RELOC_NDS32_MULCALL_SUFF, R_NDS32_MULCALL_SUFF},
2880 {BFD_RELOC_NDS32_PLTBLOCK, R_NDS32_PLTBLOCK},
2881 {BFD_RELOC_NDS32_RELAX_REGION_BEGIN, R_NDS32_RELAX_REGION_BEGIN},
2882 {BFD_RELOC_NDS32_RELAX_REGION_END, R_NDS32_RELAX_REGION_END},
2883 {BFD_RELOC_NDS32_MINUEND, R_NDS32_MINUEND},
2884 {BFD_RELOC_NDS32_SUBTRAHEND, R_NDS32_SUBTRAHEND},
2885 {BFD_RELOC_NDS32_EMPTY, R_NDS32_EMPTY},
2886
2887 {BFD_RELOC_NDS32_DIFF8, R_NDS32_DIFF8},
2888 {BFD_RELOC_NDS32_DIFF16, R_NDS32_DIFF16},
2889 {BFD_RELOC_NDS32_DIFF32, R_NDS32_DIFF32},
2890 {BFD_RELOC_NDS32_DIFF_ULEB128, R_NDS32_DIFF_ULEB128},
2891 {BFD_RELOC_NDS32_25_ABS, R_NDS32_25_ABS_RELA},
2892 {BFD_RELOC_NDS32_DATA, R_NDS32_DATA},
2893 {BFD_RELOC_NDS32_TRAN, R_NDS32_TRAN},
2894 {BFD_RELOC_NDS32_17IFC_PCREL, R_NDS32_17IFC_PCREL_RELA},
2895 {BFD_RELOC_NDS32_10IFCU_PCREL, R_NDS32_10IFCU_PCREL_RELA},
2896 {BFD_RELOC_NDS32_TLS_LE_HI20, R_NDS32_TLS_LE_HI20},
2897 {BFD_RELOC_NDS32_TLS_LE_LO12, R_NDS32_TLS_LE_LO12},
2898 {BFD_RELOC_NDS32_TLS_LE_ADD, R_NDS32_TLS_LE_ADD},
2899 {BFD_RELOC_NDS32_TLS_LE_LS, R_NDS32_TLS_LE_LS},
2900 {BFD_RELOC_NDS32_TLS_IE_HI20, R_NDS32_TLS_IE_HI20},
2901 {BFD_RELOC_NDS32_TLS_IE_LO12S2, R_NDS32_TLS_IE_LO12S2},
2902 {BFD_RELOC_NDS32_TLS_TPOFF, R_NDS32_TLS_TPOFF},
2903 {BFD_RELOC_NDS32_TLS_LE_20, R_NDS32_TLS_LE_20},
2904 {BFD_RELOC_NDS32_TLS_LE_15S0, R_NDS32_TLS_LE_15S0},
2905 {BFD_RELOC_NDS32_TLS_LE_15S1, R_NDS32_TLS_LE_15S1},
2906 {BFD_RELOC_NDS32_TLS_LE_15S2, R_NDS32_TLS_LE_15S2},
2907 };
2908
2909 /* Patch tag. */
2910
2911 static reloc_howto_type *
2912 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2913 const char *r_name)
2914 {
2915 unsigned int i;
2916
2917 for (i = 0; i < ARRAY_SIZE (nds32_elf_howto_table); i++)
2918 if (nds32_elf_howto_table[i].name != NULL
2919 && strcasecmp (nds32_elf_howto_table[i].name, r_name) == 0)
2920 return &nds32_elf_howto_table[i];
2921
2922 for (i = 0; i < ARRAY_SIZE (nds32_elf_relax_howto_table); i++)
2923 if (nds32_elf_relax_howto_table[i].name != NULL
2924 && strcasecmp (nds32_elf_relax_howto_table[i].name, r_name) == 0)
2925 return &nds32_elf_relax_howto_table[i];
2926
2927 return NULL;
2928 }
2929
2930 static reloc_howto_type *
2931 bfd_elf32_bfd_reloc_type_table_lookup (enum elf_nds32_reloc_type code)
2932 {
2933 if (code < R_NDS32_RELAX_ENTRY)
2934 {
2935 BFD_ASSERT (code < ARRAY_SIZE (nds32_elf_howto_table));
2936 return &nds32_elf_howto_table[code];
2937 }
2938 else
2939 {
2940 BFD_ASSERT ((size_t) (code - R_NDS32_RELAX_ENTRY)
2941 < ARRAY_SIZE (nds32_elf_relax_howto_table));
2942 return &nds32_elf_relax_howto_table[code - R_NDS32_RELAX_ENTRY];
2943 }
2944 }
2945
2946 static reloc_howto_type *
2947 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2948 bfd_reloc_code_real_type code)
2949 {
2950 unsigned int i;
2951
2952 for (i = 0; i < ARRAY_SIZE (nds32_reloc_map); i++)
2953 {
2954 if (nds32_reloc_map[i].bfd_reloc_val == code)
2955 return bfd_elf32_bfd_reloc_type_table_lookup
2956 (nds32_reloc_map[i].elf_reloc_val);
2957 }
2958
2959 return NULL;
2960 }
2961
2962 /* Set the howto pointer for an NDS32 ELF reloc. */
2963
2964 static void
2965 nds32_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2966 Elf_Internal_Rela *dst)
2967 {
2968 enum elf_nds32_reloc_type r_type;
2969
2970 r_type = ELF32_R_TYPE (dst->r_info);
2971 if (r_type > R_NDS32_GNU_VTENTRY)
2972 {
2973 /* xgettext:c-format */
2974 _bfd_error_handler (_("%B: invalid NDS32 reloc number: %d"), abfd, r_type);
2975 r_type = 0;
2976 }
2977 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
2978 }
2979
2980 static void
2981 nds32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2982 Elf_Internal_Rela *dst)
2983 {
2984 BFD_ASSERT ((ELF32_R_TYPE (dst->r_info) == R_NDS32_NONE)
2985 || ((ELF32_R_TYPE (dst->r_info) > R_NDS32_GNU_VTENTRY)
2986 && (ELF32_R_TYPE (dst->r_info) < R_NDS32_max)));
2987 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (dst->r_info));
2988 }
2989
2990 /* Support for core dump NOTE sections.
2991 Reference to include/linux/elfcore.h in Linux. */
2992
2993 static bfd_boolean
2994 nds32_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2995 {
2996 int offset;
2997 size_t size;
2998
2999 switch (note->descsz)
3000 {
3001 case 0x114:
3002 /* Linux/NDS32 32-bit, ABI1 */
3003
3004 /* pr_cursig */
3005 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3006
3007 /* pr_pid */
3008 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3009
3010 /* pr_reg */
3011 offset = 72;
3012 size = 200;
3013 break;
3014
3015 case 0xfc:
3016 /* Linux/NDS32 32-bit */
3017
3018 /* pr_cursig */
3019 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3020
3021 /* pr_pid */
3022 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3023
3024 /* pr_reg */
3025 offset = 72;
3026 size = 176;
3027 break;
3028
3029 default:
3030 return FALSE;
3031 }
3032
3033 /* Make a ".reg" section. */
3034 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3035 size, note->descpos + offset);
3036 }
3037
3038 static bfd_boolean
3039 nds32_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3040 {
3041 switch (note->descsz)
3042 {
3043 case 124:
3044 /* Linux/NDS32 */
3045
3046 /* __kernel_uid_t, __kernel_gid_t are short on NDS32 platform. */
3047 elf_tdata (abfd)->core->program =
3048 _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3049 elf_tdata (abfd)->core->command =
3050 _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3051 break;
3052
3053 default:
3054 return FALSE;
3055 }
3056
3057 /* Note that for some reason, a spurious space is tacked
3058 onto the end of the args in some (at least one anyway)
3059 implementations, so strip it off if it exists. */
3060 {
3061 char *command = elf_tdata (abfd)->core->command;
3062 int n = strlen (command);
3063
3064 if (0 < n && command[n - 1] == ' ')
3065 command[n - 1] = '\0';
3066 }
3067
3068 return TRUE;
3069 }
3070
3071 /* Hook called by the linker routine which adds symbols from an object
3072 file. We must handle the special NDS32 section numbers here.
3073 We also keep watching for whether we need to create the sdata special
3074 linker sections. */
3075
3076 static bfd_boolean
3077 nds32_elf_add_symbol_hook (bfd *abfd,
3078 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3079 Elf_Internal_Sym *sym,
3080 const char **namep ATTRIBUTE_UNUSED,
3081 flagword *flagsp ATTRIBUTE_UNUSED,
3082 asection **secp, bfd_vma *valp)
3083 {
3084 switch (sym->st_shndx)
3085 {
3086 case SHN_COMMON:
3087 /* Common symbols less than the GP size are automatically
3088 treated as SHN_MIPS_SCOMMON symbols. */
3089 if (sym->st_size > elf_gp_size (abfd)
3090 || ELF_ST_TYPE (sym->st_info) == STT_TLS)
3091 break;
3092
3093 /* st_value is the alignemnt constraint.
3094 That might be its actual size if it is an array or structure. */
3095 switch (sym->st_value)
3096 {
3097 case 1:
3098 *secp = bfd_make_section_old_way (abfd, ".scommon_b");
3099 break;
3100 case 2:
3101 *secp = bfd_make_section_old_way (abfd, ".scommon_h");
3102 break;
3103 case 4:
3104 *secp = bfd_make_section_old_way (abfd, ".scommon_w");
3105 break;
3106 case 8:
3107 *secp = bfd_make_section_old_way (abfd, ".scommon_d");
3108 break;
3109 default:
3110 return TRUE;
3111 }
3112
3113 (*secp)->flags |= SEC_IS_COMMON;
3114 *valp = sym->st_size;
3115 break;
3116 }
3117
3118 return TRUE;
3119 }
3120
3121
3122 /* This function can figure out the best location for a base register to access
3123 data relative to this base register
3124 INPUT:
3125 sda_d0: size of first DOUBLE WORD data section
3126 sda_w0: size of first WORD data section
3127 sda_h0: size of first HALF WORD data section
3128 sda_b : size of BYTE data section
3129 sda_hi: size of second HALF WORD data section
3130 sda_w1: size of second WORD data section
3131 sda_d1: size of second DOUBLE WORD data section
3132 OUTPUT:
3133 offset (always positive) from the beginning of sda_d0 if OK
3134 a negative error value if fail
3135 NOTE:
3136 these 7 sections have to be located back to back if exist
3137 a pass in 0 value for non-existing section */
3138
3139 /* Due to the interpretation of simm15 field of load/store depending on
3140 data accessing size, the organization of base register relative data shall
3141 like the following figure
3142 -------------------------------------------
3143 | DOUBLE WORD sized data (range +/- 128K)
3144 -------------------------------------------
3145 | WORD sized data (range +/- 64K)
3146 -------------------------------------------
3147 | HALF WORD sized data (range +/- 32K)
3148 -------------------------------------------
3149 | BYTE sized data (range +/- 16K)
3150 -------------------------------------------
3151 | HALF WORD sized data (range +/- 32K)
3152 -------------------------------------------
3153 | WORD sized data (range +/- 64K)
3154 -------------------------------------------
3155 | DOUBLE WORD sized data (range +/- 128K)
3156 -------------------------------------------
3157 Its base register shall be set to access these data freely. */
3158
3159 /* We have to figure out the SDA_BASE value, so that we can adjust the
3160 symbol value correctly. We look up the symbol _SDA_BASE_ in the output
3161 BFD. If we can't find it, we're stuck. We cache it in the ELF
3162 target data. We don't need to adjust the symbol value for an
3163 external symbol if we are producing relocatable output. */
3164
3165 static asection *sda_rela_sec = NULL;
3166
3167 #define SDA_SECTION_NUM 10
3168
3169 static bfd_reloc_status_type
3170 nds32_elf_final_sda_base (bfd *output_bfd, struct bfd_link_info *info,
3171 bfd_vma *psb, bfd_boolean add_symbol)
3172 {
3173 int relax_fp_as_gp;
3174 struct elf_nds32_link_hash_table *table;
3175 struct bfd_link_hash_entry *h, *h2;
3176 long unsigned int total = 0;
3177
3178 h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
3179 if (!h || (h->type != bfd_link_hash_defined && h->type != bfd_link_hash_defweak))
3180 {
3181 asection *first = NULL, *final = NULL, *temp;
3182 bfd_vma sda_base;
3183 /* The first section must be 4-byte aligned to promise _SDA_BASE_ being
3184 4 byte-aligned. Therefore, it has to set the first section ".data"
3185 4 byte-aligned. */
3186 static const char sec_name[SDA_SECTION_NUM][10] =
3187 {
3188 ".data", ".got", ".sdata_d", ".sdata_w", ".sdata_h", ".sdata_b",
3189 ".sbss_b", ".sbss_h", ".sbss_w", ".sbss_d"
3190 };
3191 size_t i = 0;
3192
3193 if (output_bfd->sections == NULL)
3194 {
3195 *psb = elf_gp (output_bfd);
3196 return bfd_reloc_ok;
3197 }
3198
3199 /* Get the first and final section. */
3200 while (i < sizeof (sec_name) / sizeof (sec_name [0]))
3201 {
3202 temp = bfd_get_section_by_name (output_bfd, sec_name[i]);
3203 if (temp && !first && (temp->size != 0 || temp->rawsize != 0))
3204 first = temp;
3205 if (temp && (temp->size != 0 || temp->rawsize != 0))
3206 final = temp;
3207
3208 /* Summarize the sections in order to check if joining .bss. */
3209 if (temp && temp->size != 0)
3210 total += temp->size;
3211 else if (temp && temp->rawsize != 0)
3212 total += temp->rawsize;
3213
3214 i++;
3215 }
3216
3217 /* Check .bss size. */
3218 temp = bfd_get_section_by_name (output_bfd, ".bss");
3219 if (temp)
3220 {
3221 if (temp->size != 0)
3222 total += temp->size;
3223 else if (temp->rawsize != 0)
3224 total += temp->rawsize;
3225
3226 if (total < 0x80000)
3227 {
3228 if (!first && (temp->size != 0 || temp->rawsize != 0))
3229 first = temp;
3230 if ((temp->size != 0 || temp->rawsize != 0))
3231 final = temp;
3232 }
3233 }
3234
3235 if (first && final)
3236 {
3237 /* The middle of data region. */
3238 sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3239
3240 /* Find the section sda_base located. */
3241 i = 0;
3242 while (i < sizeof (sec_name) / sizeof (sec_name [0]))
3243 {
3244 final = bfd_get_section_by_name (output_bfd, sec_name[i]);
3245 if (final && (final->size != 0 || final->rawsize != 0)
3246 && sda_base >= final->vma)
3247 {
3248 first = final;
3249 i++;
3250 }
3251 else
3252 break;
3253 }
3254 }
3255 else
3256 {
3257 /* There is not any data section in output bfd, and set _SDA_BASE_ in
3258 first output section. */
3259 first = output_bfd->sections;
3260 while (first && first->size == 0 && first->rawsize == 0)
3261 first = first->next;
3262 if (!first)
3263 {
3264 *psb = elf_gp (output_bfd);
3265 return bfd_reloc_ok;
3266 }
3267 sda_base = first->vma + first->rawsize;
3268 }
3269
3270 sda_base -= first->vma;
3271 sda_base = sda_base & (~7);
3272
3273 if (!_bfd_generic_link_add_one_symbol
3274 (info, output_bfd, "_SDA_BASE_", BSF_GLOBAL | BSF_WEAK, first,
3275 (bfd_vma) sda_base, (const char *) NULL, FALSE,
3276 get_elf_backend_data (output_bfd)->collect, &h))
3277 return FALSE;
3278
3279 sda_rela_sec = first;
3280
3281 table = nds32_elf_hash_table (info);
3282 relax_fp_as_gp = table->relax_fp_as_gp;
3283 if (relax_fp_as_gp)
3284 {
3285 h2 = bfd_link_hash_lookup (info->hash, FP_BASE_NAME,
3286 FALSE, FALSE, FALSE);
3287 /* Define a weak FP_BASE_NAME here to prevent the undefined symbol.
3288 And set FP equal to SDA_BASE to do relaxation for
3289 la $fp, _FP_BASE_. */
3290 if (!_bfd_generic_link_add_one_symbol
3291 (info, output_bfd, FP_BASE_NAME, BSF_GLOBAL | BSF_WEAK,
3292 first, (bfd_vma) sda_base, (const char *) NULL,
3293 FALSE, get_elf_backend_data (output_bfd)->collect, &h2))
3294 return FALSE;
3295 }
3296 }
3297
3298 if (add_symbol == TRUE)
3299 {
3300 if (h)
3301 {
3302 /* Now set gp. */
3303 elf_gp (output_bfd) = (h->u.def.value
3304 + h->u.def.section->output_section->vma
3305 + h->u.def.section->output_offset);
3306 }
3307 else
3308 {
3309 _bfd_error_handler (_("error: Can't find symbol: _SDA_BASE_."));
3310 return bfd_reloc_dangerous;
3311 }
3312 }
3313
3314 *psb = h->u.def.value + h->u.def.section->output_section->vma
3315 + h->u.def.section->output_offset;
3316 return bfd_reloc_ok;
3317 }
3318 \f
3319
3320 /* Return size of a PLT entry. */
3321 #define elf_nds32_sizeof_plt(info) PLT_ENTRY_SIZE
3322
3323
3324 /* Create an entry in an nds32 ELF linker hash table. */
3325
3326 static struct bfd_hash_entry *
3327 nds32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
3328 struct bfd_hash_table *table,
3329 const char *string)
3330 {
3331 struct elf_nds32_link_hash_entry *ret;
3332
3333 ret = (struct elf_nds32_link_hash_entry *) entry;
3334
3335 /* Allocate the structure if it has not already been allocated by a
3336 subclass. */
3337 if (ret == NULL)
3338 ret = (struct elf_nds32_link_hash_entry *)
3339 bfd_hash_allocate (table, sizeof (struct elf_nds32_link_hash_entry));
3340
3341 if (ret == NULL)
3342 return (struct bfd_hash_entry *) ret;
3343
3344 /* Call the allocation method of the superclass. */
3345 ret = (struct elf_nds32_link_hash_entry *)
3346 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
3347
3348 if (ret != NULL)
3349 {
3350 struct elf_nds32_link_hash_entry *eh;
3351
3352 eh = (struct elf_nds32_link_hash_entry *) ret;
3353 eh->dyn_relocs = NULL;
3354 eh->tls_type = GOT_UNKNOWN;
3355 }
3356
3357 return (struct bfd_hash_entry *) ret;
3358 }
3359
3360 /* Create an nds32 ELF linker hash table. */
3361
3362 static struct bfd_link_hash_table *
3363 nds32_elf_link_hash_table_create (bfd *abfd)
3364 {
3365 struct elf_nds32_link_hash_table *ret;
3366
3367 bfd_size_type amt = sizeof (struct elf_nds32_link_hash_table);
3368
3369 ret = (struct elf_nds32_link_hash_table *) bfd_zmalloc (amt);
3370 if (ret == NULL)
3371 return NULL;
3372
3373 /* patch tag. */
3374 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3375 nds32_elf_link_hash_newfunc,
3376 sizeof (struct elf_nds32_link_hash_entry),
3377 NDS32_ELF_DATA))
3378 {
3379 free (ret);
3380 return NULL;
3381 }
3382
3383 return &ret->root.root;
3384 }
3385
3386 /* Create dynamic sections when linking against a dynamic object. */
3387
3388 static bfd_boolean
3389 nds32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3390 {
3391 struct elf_nds32_link_hash_table *htab;
3392 flagword flags, pltflags;
3393 register asection *s;
3394 const struct elf_backend_data *bed;
3395 int ptralign = 2; /* 32-bit */
3396
3397 bed = get_elf_backend_data (abfd);
3398
3399 htab = nds32_elf_hash_table (info);
3400
3401 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3402 .rel[a].bss sections. */
3403
3404 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3405 | SEC_LINKER_CREATED);
3406
3407 pltflags = flags;
3408 pltflags |= SEC_CODE;
3409 if (bed->plt_not_loaded)
3410 pltflags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
3411 if (bed->plt_readonly)
3412 pltflags |= SEC_READONLY;
3413
3414 s = bfd_make_section (abfd, ".plt");
3415 htab->root.splt = s;
3416 if (s == NULL
3417 || !bfd_set_section_flags (abfd, s, pltflags)
3418 || !bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3419 return FALSE;
3420
3421 if (bed->want_plt_sym)
3422 {
3423 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3424 .plt section. */
3425 struct bfd_link_hash_entry *bh = NULL;
3426 struct elf_link_hash_entry *h;
3427
3428 if (!(_bfd_generic_link_add_one_symbol
3429 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3430 (bfd_vma) 0, (const char *) NULL, FALSE,
3431 get_elf_backend_data (abfd)->collect, &bh)))
3432 return FALSE;
3433
3434 h = (struct elf_link_hash_entry *) bh;
3435 h->def_regular = 1;
3436 h->type = STT_OBJECT;
3437
3438 if (bfd_link_pic (info) && !bfd_elf_link_record_dynamic_symbol (info, h))
3439 return FALSE;
3440 }
3441
3442 s = bfd_make_section (abfd,
3443 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3444 htab->root.srelplt = s;
3445 if (s == NULL
3446 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3447 || !bfd_set_section_alignment (abfd, s, ptralign))
3448 return FALSE;
3449
3450 if (htab->root.sgot == NULL && !_bfd_elf_create_got_section (abfd, info))
3451 return FALSE;
3452
3453 {
3454 const char *secname;
3455 char *relname;
3456 flagword secflags;
3457 asection *sec;
3458
3459 for (sec = abfd->sections; sec; sec = sec->next)
3460 {
3461 secflags = bfd_get_section_flags (abfd, sec);
3462 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3463 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3464 continue;
3465 secname = bfd_get_section_name (abfd, sec);
3466 relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3467 strcpy (relname, ".rela");
3468 strcat (relname, secname);
3469 if (bfd_get_section_by_name (abfd, secname))
3470 continue;
3471 s = bfd_make_section (abfd, relname);
3472 if (s == NULL
3473 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3474 || !bfd_set_section_alignment (abfd, s, ptralign))
3475 return FALSE;
3476 }
3477 }
3478
3479 if (bed->want_dynbss)
3480 {
3481 /* The .dynbss section is a place to put symbols which are defined
3482 by dynamic objects, are referenced by regular objects, and are
3483 not functions. We must allocate space for them in the process
3484 image and use a R_*_COPY reloc to tell the dynamic linker to
3485 initialize them at run time. The linker script puts the .dynbss
3486 section into the .bss section of the final image. */
3487 s = bfd_make_section (abfd, ".dynbss");
3488 htab->sdynbss = s;
3489 if (s == NULL
3490 || !bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
3491 return FALSE;
3492 /* The .rel[a].bss section holds copy relocs. This section is not
3493 normally needed. We need to create it here, though, so that the
3494 linker will map it to an output section. We can't just create it
3495 only if we need it, because we will not know whether we need it
3496 until we have seen all the input files, and the first time the
3497 main linker code calls BFD after examining all the input files
3498 (size_dynamic_sections) the input sections have already been
3499 mapped to the output sections. If the section turns out not to
3500 be needed, we can discard it later. We will never need this
3501 section when generating a shared object, since they do not use
3502 copy relocs. */
3503 if (!bfd_link_pic (info))
3504 {
3505 s = bfd_make_section (abfd, (bed->default_use_rela_p
3506 ? ".rela.bss" : ".rel.bss"));
3507 htab->srelbss = s;
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 return TRUE;
3516 }
3517
3518 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3519 static void
3520 nds32_elf_copy_indirect_symbol (struct bfd_link_info *info,
3521 struct elf_link_hash_entry *dir,
3522 struct elf_link_hash_entry *ind)
3523 {
3524 struct elf_nds32_link_hash_entry *edir, *eind;
3525
3526 edir = (struct elf_nds32_link_hash_entry *) dir;
3527 eind = (struct elf_nds32_link_hash_entry *) ind;
3528
3529 if (eind->dyn_relocs != NULL)
3530 {
3531 if (edir->dyn_relocs != NULL)
3532 {
3533 struct elf_nds32_dyn_relocs **pp;
3534 struct elf_nds32_dyn_relocs *p;
3535
3536 if (ind->root.type == bfd_link_hash_indirect)
3537 abort ();
3538
3539 /* Add reloc counts against the weak sym to the strong sym
3540 list. Merge any entries against the same section. */
3541 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
3542 {
3543 struct elf_nds32_dyn_relocs *q;
3544
3545 for (q = edir->dyn_relocs; q != NULL; q = q->next)
3546 if (q->sec == p->sec)
3547 {
3548 q->pc_count += p->pc_count;
3549 q->count += p->count;
3550 *pp = p->next;
3551 break;
3552 }
3553 if (q == NULL)
3554 pp = &p->next;
3555 }
3556 *pp = edir->dyn_relocs;
3557 }
3558
3559 edir->dyn_relocs = eind->dyn_relocs;
3560 eind->dyn_relocs = NULL;
3561 }
3562
3563 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3564 }
3565 \f
3566
3567 /* Adjust a symbol defined by a dynamic object and referenced by a
3568 regular object. The current definition is in some section of the
3569 dynamic object, but we're not including those sections. We have to
3570 change the definition to something the rest of the link can
3571 understand. */
3572
3573 static bfd_boolean
3574 nds32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3575 struct elf_link_hash_entry *h)
3576 {
3577 struct elf_nds32_link_hash_table *htab;
3578 struct elf_nds32_link_hash_entry *eh;
3579 struct elf_nds32_dyn_relocs *p;
3580 bfd *dynobj;
3581 asection *s;
3582 unsigned int power_of_two;
3583
3584 dynobj = elf_hash_table (info)->dynobj;
3585
3586 /* Make sure we know what is going on here. */
3587 BFD_ASSERT (dynobj != NULL
3588 && (h->needs_plt
3589 || h->u.weakdef != NULL
3590 || (h->def_dynamic && h->ref_regular && !h->def_regular)));
3591
3592
3593 /* If this is a function, put it in the procedure linkage table. We
3594 will fill in the contents of the procedure linkage table later,
3595 when we know the address of the .got section. */
3596 if (h->type == STT_FUNC || h->needs_plt)
3597 {
3598 if (!bfd_link_pic (info)
3599 && !h->def_dynamic
3600 && !h->ref_dynamic
3601 && h->root.type != bfd_link_hash_undefweak
3602 && h->root.type != bfd_link_hash_undefined)
3603 {
3604 /* This case can occur if we saw a PLT reloc in an input
3605 file, but the symbol was never referred to by a dynamic
3606 object. In such a case, we don't actually need to build
3607 a procedure linkage table, and we can just do a PCREL
3608 reloc instead. */
3609 h->plt.offset = (bfd_vma) - 1;
3610 h->needs_plt = 0;
3611 }
3612
3613 return TRUE;
3614 }
3615 else
3616 h->plt.offset = (bfd_vma) - 1;
3617
3618 /* If this is a weak symbol, and there is a real definition, the
3619 processor independent code will have arranged for us to see the
3620 real definition first, and we can just use the same value. */
3621 if (h->u.weakdef != NULL)
3622 {
3623 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3624 || h->u.weakdef->root.type == bfd_link_hash_defweak);
3625 h->root.u.def.section = h->u.weakdef->root.u.def.section;
3626 h->root.u.def.value = h->u.weakdef->root.u.def.value;
3627 return TRUE;
3628 }
3629
3630 /* This is a reference to a symbol defined by a dynamic object which
3631 is not a function. */
3632
3633 /* If we are creating a shared library, we must presume that the
3634 only references to the symbol are via the global offset table.
3635 For such cases we need not do anything here; the relocations will
3636 be handled correctly by relocate_section. */
3637 if (bfd_link_pic (info))
3638 return TRUE;
3639
3640 /* If there are no references to this symbol that do not use the
3641 GOT, we don't need to generate a copy reloc. */
3642 if (!h->non_got_ref)
3643 return TRUE;
3644
3645 /* If -z nocopyreloc was given, we won't generate them either. */
3646 if (info->nocopyreloc)
3647 {
3648 h->non_got_ref = 0;
3649 return TRUE;
3650 }
3651
3652 eh = (struct elf_nds32_link_hash_entry *) h;
3653 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3654 {
3655 s = p->sec->output_section;
3656 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
3657 break;
3658 }
3659
3660 /* If we didn't find any dynamic relocs in sections which needs the
3661 copy reloc, then we'll be keeping the dynamic relocs and avoiding
3662 the copy reloc. */
3663 if (p == NULL)
3664 {
3665 h->non_got_ref = 0;
3666 return TRUE;
3667 }
3668
3669 /* We must allocate the symbol in our .dynbss section, which will
3670 become part of the .bss section of the executable. There will be
3671 an entry for this symbol in the .dynsym section. The dynamic
3672 object will contain position independent code, so all references
3673 from the dynamic object to this symbol will go through the global
3674 offset table. The dynamic linker will use the .dynsym entry to
3675 determine the address it must put in the global offset table, so
3676 both the dynamic object and the regular object will refer to the
3677 same memory location for the variable. */
3678
3679 htab = nds32_elf_hash_table (info);
3680 s = htab->sdynbss;
3681 BFD_ASSERT (s != NULL);
3682
3683 /* We must generate a R_NDS32_COPY reloc to tell the dynamic linker
3684 to copy the initial value out of the dynamic object and into the
3685 runtime process image. We need to remember the offset into the
3686 .rela.bss section we are going to use. */
3687 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3688 {
3689 asection *srel;
3690
3691 srel = htab->srelbss;
3692 BFD_ASSERT (srel != NULL);
3693 srel->size += sizeof (Elf32_External_Rela);
3694 h->needs_copy = 1;
3695 }
3696
3697 /* We need to figure out the alignment required for this symbol. I
3698 have no idea how ELF linkers handle this. */
3699 power_of_two = bfd_log2 (h->size);
3700 if (power_of_two > 3)
3701 power_of_two = 3;
3702
3703 /* Apply the required alignment. */
3704 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
3705 if (power_of_two > bfd_get_section_alignment (dynobj, s))
3706 {
3707 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
3708 return FALSE;
3709 }
3710
3711 /* Define the symbol as being at this point in the section. */
3712 h->root.u.def.section = s;
3713 h->root.u.def.value = s->size;
3714
3715 /* Increment the section size to make room for the symbol. */
3716 s->size += h->size;
3717
3718 return TRUE;
3719 }
3720
3721 /* Allocate space in .plt, .got and associated reloc sections for
3722 dynamic relocs. */
3723
3724 static bfd_boolean
3725 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3726 {
3727 struct bfd_link_info *info;
3728 struct elf_nds32_link_hash_table *htab;
3729 struct elf_nds32_link_hash_entry *eh;
3730 struct elf_nds32_dyn_relocs *p;
3731
3732 if (h->root.type == bfd_link_hash_indirect)
3733 return TRUE;
3734
3735 if (h->root.type == bfd_link_hash_warning)
3736 /* When warning symbols are created, they **replace** the "real"
3737 entry in the hash table, thus we never get to see the real
3738 symbol in a hash traversal. So look at it now. */
3739 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3740
3741 info = (struct bfd_link_info *) inf;
3742 htab = nds32_elf_hash_table (info);
3743
3744 eh = (struct elf_nds32_link_hash_entry *) h;
3745
3746 if (htab->root.dynamic_sections_created && h->plt.refcount > 0)
3747 {
3748 /* Make sure this symbol is output as a dynamic symbol.
3749 Undefined weak syms won't yet be marked as dynamic. */
3750 if (h->dynindx == -1 && !h->forced_local)
3751 {
3752 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3753 return FALSE;
3754 }
3755
3756 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
3757 {
3758 asection *s = htab->root.splt;
3759
3760 /* If this is the first .plt entry, make room for the special
3761 first entry. */
3762 if (s->size == 0)
3763 s->size += PLT_ENTRY_SIZE;
3764
3765 h->plt.offset = s->size;
3766
3767 /* If this symbol is not defined in a regular file, and we are
3768 not generating a shared library, then set the symbol to this
3769 location in the .plt. This is required to make function
3770 pointers compare as equal between the normal executable and
3771 the shared library. */
3772 if (!bfd_link_pic (info) && !h->def_regular)
3773 {
3774 h->root.u.def.section = s;
3775 h->root.u.def.value = h->plt.offset;
3776 }
3777
3778 /* Make room for this entry. */
3779 s->size += PLT_ENTRY_SIZE;
3780
3781 /* We also need to make an entry in the .got.plt section, which
3782 will be placed in the .got section by the linker script. */
3783 htab->root.sgotplt->size += 4;
3784
3785 /* We also need to make an entry in the .rel.plt section. */
3786 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
3787 }
3788 else
3789 {
3790 h->plt.offset = (bfd_vma) - 1;
3791 h->needs_plt = 0;
3792 }
3793 }
3794 else
3795 {
3796 h->plt.offset = (bfd_vma) - 1;
3797 h->needs_plt = 0;
3798 }
3799
3800 if (h->got.refcount > 0)
3801 {
3802 asection *s;
3803 bfd_boolean dyn;
3804 int tls_type = elf32_nds32_hash_entry (h)->tls_type;
3805
3806 /* Make sure this symbol is output as a dynamic symbol.
3807 Undefined weak syms won't yet be marked as dynamic. */
3808 if (h->dynindx == -1 && !h->forced_local)
3809 {
3810 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3811 return FALSE;
3812 }
3813
3814 s = htab->root.sgot;
3815 h->got.offset = s->size;
3816
3817 if (tls_type == GOT_UNKNOWN)
3818 abort ();
3819 else if (tls_type == GOT_NORMAL
3820 || tls_type == GOT_TLS_IE)
3821 /* Need a GOT slot. */
3822 s->size += 4;
3823
3824 dyn = htab->root.dynamic_sections_created;
3825 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
3826 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3827 }
3828 else
3829 h->got.offset = (bfd_vma) - 1;
3830
3831 if (eh->dyn_relocs == NULL)
3832 return TRUE;
3833
3834 /* In the shared -Bsymbolic case, discard space allocated for
3835 dynamic pc-relative relocs against symbols which turn out to be
3836 defined in regular objects. For the normal shared case, discard
3837 space for pc-relative relocs that have become local due to symbol
3838 visibility changes. */
3839
3840 if (bfd_link_pic (info))
3841 {
3842 if (h->def_regular && (h->forced_local || info->symbolic))
3843 {
3844 struct elf_nds32_dyn_relocs **pp;
3845
3846 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
3847 {
3848 p->count -= p->pc_count;
3849 p->pc_count = 0;
3850 if (p->count == 0)
3851 *pp = p->next;
3852 else
3853 pp = &p->next;
3854 }
3855 }
3856 }
3857 else
3858 {
3859 /* For the non-shared case, discard space for relocs against
3860 symbols which turn out to need copy relocs or are not dynamic. */
3861
3862 if (!h->non_got_ref
3863 && ((h->def_dynamic
3864 && !h->def_regular)
3865 || (htab->root.dynamic_sections_created
3866 && (h->root.type == bfd_link_hash_undefweak
3867 || h->root.type == bfd_link_hash_undefined))))
3868 {
3869 /* Make sure this symbol is output as a dynamic symbol.
3870 Undefined weak syms won't yet be marked as dynamic. */
3871 if (h->dynindx == -1 && !h->forced_local)
3872 {
3873 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3874 return FALSE;
3875 }
3876
3877 /* If that succeeded, we know we'll be keeping all the
3878 relocs. */
3879 if (h->dynindx != -1)
3880 goto keep;
3881 }
3882
3883 eh->dyn_relocs = NULL;
3884
3885 keep:;
3886 }
3887
3888 /* Finally, allocate space. */
3889 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3890 {
3891 asection *sreloc = elf_section_data (p->sec)->sreloc;
3892 sreloc->size += p->count * sizeof (Elf32_External_Rela);
3893 }
3894
3895 return TRUE;
3896 }
3897
3898 /* Find any dynamic relocs that apply to read-only sections. */
3899
3900 static bfd_boolean
3901 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3902 {
3903 struct elf_nds32_link_hash_entry *eh;
3904 struct elf_nds32_dyn_relocs *p;
3905
3906 if (h->root.type == bfd_link_hash_warning)
3907 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3908
3909 eh = (struct elf_nds32_link_hash_entry *) h;
3910 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3911 {
3912 asection *s = p->sec->output_section;
3913
3914 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3915 {
3916 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3917
3918 info->flags |= DF_TEXTREL;
3919
3920 /* Not an error, just cut short the traversal. */
3921 return FALSE;
3922 }
3923 }
3924 return TRUE;
3925 }
3926
3927 /* Set the sizes of the dynamic sections. */
3928
3929 static bfd_boolean
3930 nds32_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3931 struct bfd_link_info *info)
3932 {
3933 struct elf_nds32_link_hash_table *htab;
3934 bfd *dynobj;
3935 asection *s;
3936 bfd_boolean relocs;
3937 bfd *ibfd;
3938
3939 htab = nds32_elf_hash_table (info);
3940 dynobj = htab->root.dynobj;
3941 BFD_ASSERT (dynobj != NULL);
3942
3943 if (htab->root.dynamic_sections_created)
3944 {
3945 /* Set the contents of the .interp section to the interpreter. */
3946 if (!bfd_link_pic (info) && !info->nointerp)
3947 {
3948 s = bfd_get_section_by_name (dynobj, ".interp");
3949 BFD_ASSERT (s != NULL);
3950 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3951 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3952 }
3953 }
3954
3955 /* Set up .got offsets for local syms, and space for local dynamic
3956 relocs. */
3957 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3958 {
3959 bfd_signed_vma *local_got;
3960 bfd_signed_vma *end_local_got;
3961 bfd_size_type locsymcount;
3962 Elf_Internal_Shdr *symtab_hdr;
3963 asection *srel;
3964
3965 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
3966 continue;
3967
3968 for (s = ibfd->sections; s != NULL; s = s->next)
3969 {
3970 struct elf_nds32_dyn_relocs *p;
3971
3972 for (p = ((struct elf_nds32_dyn_relocs *)
3973 elf_section_data (s)->local_dynrel);
3974 p != NULL; p = p->next)
3975 {
3976 if (!bfd_is_abs_section (p->sec)
3977 && bfd_is_abs_section (p->sec->output_section))
3978 {
3979 /* Input section has been discarded, either because
3980 it is a copy of a linkonce section or due to
3981 linker script /DISCARD/, so we'll be discarding
3982 the relocs too. */
3983 }
3984 else if (p->count != 0)
3985 {
3986 srel = elf_section_data (p->sec)->sreloc;
3987 srel->size += p->count * sizeof (Elf32_External_Rela);
3988 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3989 info->flags |= DF_TEXTREL;
3990 }
3991 }
3992 }
3993
3994 local_got = elf_local_got_refcounts (ibfd);
3995 if (!local_got)
3996 continue;
3997
3998 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3999 locsymcount = symtab_hdr->sh_info;
4000 end_local_got = local_got + locsymcount;
4001 s = htab->root.sgot;
4002 srel = htab->root.srelgot;
4003 for (; local_got < end_local_got; ++local_got)
4004 {
4005 if (*local_got > 0)
4006 {
4007 *local_got = s->size;
4008 s->size += 4;
4009 if (bfd_link_pic (info))
4010 srel->size += sizeof (Elf32_External_Rela);
4011 }
4012 else
4013 *local_got = (bfd_vma) - 1;
4014 }
4015 }
4016
4017 /* Allocate global sym .plt and .got entries, and space for global
4018 sym dynamic relocs. */
4019 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (void *) info);
4020
4021 /* We now have determined the sizes of the various dynamic sections.
4022 Allocate memory for them. */
4023 relocs = FALSE;
4024 for (s = dynobj->sections; s != NULL; s = s->next)
4025 {
4026 if ((s->flags & SEC_LINKER_CREATED) == 0)
4027 continue;
4028
4029 if (s == htab->root.splt)
4030 {
4031 /* Strip this section if we don't need it; see the
4032 comment below. */
4033 }
4034 else if (s == htab->root.sgot)
4035 {
4036 got_size += s->size;
4037 }
4038 else if (s == htab->root.sgotplt)
4039 {
4040 got_size += s->size;
4041 }
4042 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
4043 {
4044 if (s->size != 0 && s != htab->root.srelplt)
4045 relocs = TRUE;
4046
4047 /* We use the reloc_count field as a counter if we need
4048 to copy relocs into the output file. */
4049 s->reloc_count = 0;
4050 }
4051 else
4052 {
4053 /* It's not one of our sections, so don't allocate space. */
4054 continue;
4055 }
4056
4057 if (s->size == 0)
4058 {
4059 /* If we don't need this section, strip it from the
4060 output file. This is mostly to handle .rela.bss and
4061 .rela.plt. We must create both sections in
4062 create_dynamic_sections, because they must be created
4063 before the linker maps input sections to output
4064 sections. The linker does that before
4065 adjust_dynamic_symbol is called, and it is that
4066 function which decides whether anything needs to go
4067 into these sections. */
4068 s->flags |= SEC_EXCLUDE;
4069 continue;
4070 }
4071
4072 /* Allocate memory for the section contents. We use bfd_zalloc
4073 here in case unused entries are not reclaimed before the
4074 section's contents are written out. This should not happen,
4075 but this way if it does, we get a R_NDS32_NONE reloc instead
4076 of garbage. */
4077 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4078 if (s->contents == NULL)
4079 return FALSE;
4080 }
4081
4082
4083 if (htab->root.dynamic_sections_created)
4084 {
4085 /* Add some entries to the .dynamic section. We fill in the
4086 values later, in nds32_elf_finish_dynamic_sections, but we
4087 must add the entries now so that we get the correct size for
4088 the .dynamic section. The DT_DEBUG entry is filled in by the
4089 dynamic linker and used by the debugger. */
4090 #define add_dynamic_entry(TAG, VAL) \
4091 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4092
4093 if (!bfd_link_pic (info))
4094 {
4095 if (!add_dynamic_entry (DT_DEBUG, 0))
4096 return FALSE;
4097 }
4098
4099 if (htab->root.splt->size != 0)
4100 {
4101 if (!add_dynamic_entry (DT_PLTGOT, 0)
4102 || !add_dynamic_entry (DT_PLTRELSZ, 0)
4103 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4104 || !add_dynamic_entry (DT_JMPREL, 0))
4105 return FALSE;
4106 }
4107
4108 if (relocs)
4109 {
4110 if (!add_dynamic_entry (DT_RELA, 0)
4111 || !add_dynamic_entry (DT_RELASZ, 0)
4112 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
4113 return FALSE;
4114
4115 /* If any dynamic relocs apply to a read-only section,
4116 then we need a DT_TEXTREL entry. */
4117 if ((info->flags & DF_TEXTREL) == 0)
4118 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
4119 (void *) info);
4120
4121 if ((info->flags & DF_TEXTREL) != 0)
4122 {
4123 if (!add_dynamic_entry (DT_TEXTREL, 0))
4124 return FALSE;
4125 }
4126 }
4127 }
4128 #undef add_dynamic_entry
4129
4130 return TRUE;
4131 }
4132
4133 static bfd_reloc_status_type
4134 nds32_relocate_contents (reloc_howto_type *howto, bfd *input_bfd,
4135 bfd_vma relocation, bfd_byte *location)
4136 {
4137 int size;
4138 bfd_vma x = 0;
4139 bfd_reloc_status_type flag;
4140 unsigned int rightshift = howto->rightshift;
4141 unsigned int bitpos = howto->bitpos;
4142
4143 /* If the size is negative, negate RELOCATION. This isn't very
4144 general. */
4145 if (howto->size < 0)
4146 relocation = -relocation;
4147
4148 /* Get the value we are going to relocate. */
4149 size = bfd_get_reloc_size (howto);
4150 switch (size)
4151 {
4152 default:
4153 abort ();
4154 break;
4155 case 0:
4156 return bfd_reloc_ok;
4157 case 2:
4158 x = bfd_getb16 (location);
4159 break;
4160 case 4:
4161 x = bfd_getb32 (location);
4162 break;
4163 }
4164
4165 /* Check for overflow. FIXME: We may drop bits during the addition
4166 which we don't check for. We must either check at every single
4167 operation, which would be tedious, or we must do the computations
4168 in a type larger than bfd_vma, which would be inefficient. */
4169 flag = bfd_reloc_ok;
4170 if (howto->complain_on_overflow != complain_overflow_dont)
4171 {
4172 bfd_vma addrmask, fieldmask, signmask, ss;
4173 bfd_vma a, b, sum;
4174
4175 /* Get the values to be added together. For signed and unsigned
4176 relocations, we assume that all values should be truncated to
4177 the size of an address. For bitfields, all the bits matter.
4178 See also bfd_check_overflow. */
4179 fieldmask = N_ONES (howto->bitsize);
4180 signmask = ~fieldmask;
4181 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4182 a = (relocation & addrmask) >> rightshift;
4183 b = (x & howto->src_mask & addrmask) >> bitpos;
4184
4185 switch (howto->complain_on_overflow)
4186 {
4187 case complain_overflow_signed:
4188 /* If any sign bits are set, all sign bits must be set.
4189 That is, A must be a valid negative address after
4190 shifting. */
4191 signmask = ~(fieldmask >> 1);
4192 /* Fall through. */
4193
4194 case complain_overflow_bitfield:
4195 /* Much like the signed check, but for a field one bit
4196 wider. We allow a bitfield to represent numbers in the
4197 range -2**n to 2**n-1, where n is the number of bits in the
4198 field. Note that when bfd_vma is 32 bits, a 32-bit reloc
4199 can't overflow, which is exactly what we want. */
4200 ss = a & signmask;
4201 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4202 flag = bfd_reloc_overflow;
4203
4204 /* We only need this next bit of code if the sign bit of B
4205 is below the sign bit of A. This would only happen if
4206 SRC_MASK had fewer bits than BITSIZE. Note that if
4207 SRC_MASK has more bits than BITSIZE, we can get into
4208 trouble; we would need to verify that B is in range, as
4209 we do for A above. */
4210 ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4211 ss >>= bitpos;
4212
4213 /* Set all the bits above the sign bit. */
4214 b = (b ^ ss) - ss;
4215
4216 /* Now we can do the addition. */
4217 sum = a + b;
4218
4219 /* See if the result has the correct sign. Bits above the
4220 sign bit are junk now; ignore them. If the sum is
4221 positive, make sure we did not have all negative inputs;
4222 if the sum is negative, make sure we did not have all
4223 positive inputs. The test below looks only at the sign
4224 bits, and it really just
4225 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4226
4227 We mask with addrmask here to explicitly allow an address
4228 wrap-around. The Linux kernel relies on it, and it is
4229 the only way to write assembler code which can run when
4230 loaded at a location 0x80000000 away from the location at
4231 which it is linked. */
4232 if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4233 flag = bfd_reloc_overflow;
4234
4235 break;
4236
4237 case complain_overflow_unsigned:
4238 /* Checking for an unsigned overflow is relatively easy:
4239 trim the addresses and add, and trim the result as well.
4240 Overflow is normally indicated when the result does not
4241 fit in the field. However, we also need to consider the
4242 case when, e.g., fieldmask is 0x7fffffff or smaller, an
4243 input is 0x80000000, and bfd_vma is only 32 bits; then we
4244 will get sum == 0, but there is an overflow, since the
4245 inputs did not fit in the field. Instead of doing a
4246 separate test, we can check for this by or-ing in the
4247 operands when testing for the sum overflowing its final
4248 field. */
4249 sum = (a + b) & addrmask;
4250 if ((a | b | sum) & signmask)
4251 flag = bfd_reloc_overflow;
4252 break;
4253
4254 default:
4255 abort ();
4256 }
4257 }
4258
4259 /* Put RELOCATION in the right bits. */
4260 relocation >>= (bfd_vma) rightshift;
4261 relocation <<= (bfd_vma) bitpos;
4262
4263 /* Add RELOCATION to the right bits of X. */
4264 /* FIXME : 090616
4265 Because the relaxation may generate duplicate relocation at one address,
4266 an addition to immediate in the instruction may cause the relocation added
4267 several times.
4268 This bug should be fixed in assembler, but a check is also needed here. */
4269 if (howto->partial_inplace)
4270 x = ((x & ~howto->dst_mask)
4271 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4272 else
4273 x = ((x & ~howto->dst_mask) | ((relocation) & howto->dst_mask));
4274
4275
4276 /* Put the relocated value back in the object file. */
4277 switch (size)
4278 {
4279 default:
4280 case 0:
4281 case 1:
4282 case 8:
4283 abort ();
4284 break;
4285 case 2:
4286 bfd_putb16 (x, location);
4287 break;
4288 case 4:
4289 bfd_putb32 (x, location);
4290 break;
4291 }
4292
4293 return flag;
4294 }
4295
4296 static bfd_reloc_status_type
4297 nds32_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
4298 asection *input_section, bfd_byte *contents,
4299 bfd_vma address, bfd_vma value, bfd_vma addend)
4300 {
4301 bfd_vma relocation;
4302
4303 /* Sanity check the address. */
4304 if (address > bfd_get_section_limit (input_bfd, input_section))
4305 return bfd_reloc_outofrange;
4306
4307 /* This function assumes that we are dealing with a basic relocation
4308 against a symbol. We want to compute the value of the symbol to
4309 relocate to. This is just VALUE, the value of the symbol, plus
4310 ADDEND, any addend associated with the reloc. */
4311 relocation = value + addend;
4312
4313 /* If the relocation is PC relative, we want to set RELOCATION to
4314 the distance between the symbol (currently in RELOCATION) and the
4315 location we are relocating. Some targets (e.g., i386-aout)
4316 arrange for the contents of the section to be the negative of the
4317 offset of the location within the section; for such targets
4318 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF)
4319 simply leave the contents of the section as zero; for such
4320 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not
4321 need to subtract out the offset of the location within the
4322 section (which is just ADDRESS). */
4323 if (howto->pc_relative)
4324 {
4325 relocation -= (input_section->output_section->vma
4326 + input_section->output_offset);
4327 if (howto->pcrel_offset)
4328 relocation -= address;
4329 }
4330
4331 return nds32_relocate_contents (howto, input_bfd, relocation,
4332 contents + address);
4333 }
4334
4335 static bfd_boolean
4336 nds32_elf_output_symbol_hook (struct bfd_link_info *info,
4337 const char *name,
4338 Elf_Internal_Sym *elfsym ATTRIBUTE_UNUSED,
4339 asection *input_sec,
4340 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4341 {
4342 const char *source;
4343 FILE *sym_ld_script = NULL;
4344 struct elf_nds32_link_hash_table *table;
4345
4346 table = nds32_elf_hash_table (info);
4347 sym_ld_script = table->sym_ld_script;
4348 if (!sym_ld_script)
4349 return TRUE;
4350
4351 if (!h || !name || *name == '\0')
4352 return TRUE;
4353
4354 if (input_sec->flags & SEC_EXCLUDE)
4355 return TRUE;
4356
4357 if (!check_start_export_sym)
4358 {
4359 fprintf (sym_ld_script, "SECTIONS\n{\n");
4360 check_start_export_sym = 1;
4361 }
4362
4363 if (h->root.type == bfd_link_hash_defined
4364 || h->root.type == bfd_link_hash_defweak)
4365 {
4366 if (!h->root.u.def.section->output_section)
4367 return TRUE;
4368
4369 if (bfd_is_const_section (input_sec))
4370 source = input_sec->name;
4371 else
4372 source = input_sec->owner->filename;
4373
4374 fprintf (sym_ld_script, "\t%s = 0x%08lx;\t /* %s */\n",
4375 h->root.root.string,
4376 (long) (h->root.u.def.value
4377 + h->root.u.def.section->output_section->vma
4378 + h->root.u.def.section->output_offset), source);
4379 }
4380
4381 return TRUE;
4382 }
4383
4384 /* Relocate an NDS32/D ELF section.
4385 There is some attempt to make this function usable for many architectures,
4386 both for RELA and REL type relocs, if only to serve as a learning tool.
4387
4388 The RELOCATE_SECTION function is called by the new ELF backend linker
4389 to handle the relocations for a section.
4390
4391 The relocs are always passed as Rela structures; if the section
4392 actually uses Rel structures, the r_addend field will always be
4393 zero.
4394
4395 This function is responsible for adjust the section contents as
4396 necessary, and (if using Rela relocs and generating a
4397 relocatable output file) adjusting the reloc addend as
4398 necessary.
4399
4400 This function does not have to worry about setting the reloc
4401 address or the reloc symbol index.
4402
4403 LOCAL_SYMS is a pointer to the swapped in local symbols.
4404
4405 LOCAL_SECTIONS is an array giving the section in the input file
4406 corresponding to the st_shndx field of each local symbol.
4407
4408 The global hash table entry for the global symbols can be found
4409 via elf_sym_hashes (input_bfd).
4410
4411 When generating relocatable output, this function must handle
4412 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
4413 going to be the section symbol corresponding to the output
4414 section, which means that the addend must be adjusted
4415 accordingly. */
4416
4417 static bfd_vma
4418 dtpoff_base (struct bfd_link_info *info)
4419 {
4420 /* If tls_sec is NULL, we should have signalled an error already. */
4421 if (elf_hash_table (info)->tls_sec == NULL)
4422 return 0;
4423 return elf_hash_table (info)->tls_sec->vma;
4424 }
4425
4426 static bfd_boolean
4427 nds32_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
4428 struct bfd_link_info * info,
4429 bfd * input_bfd,
4430 asection * input_section,
4431 bfd_byte * contents,
4432 Elf_Internal_Rela * relocs,
4433 Elf_Internal_Sym * local_syms,
4434 asection ** local_sections)
4435 {
4436 Elf_Internal_Shdr *symtab_hdr;
4437 struct elf_link_hash_entry **sym_hashes;
4438 Elf_Internal_Rela *rel, *relend;
4439 bfd_boolean ret = TRUE; /* Assume success. */
4440 int align = 0;
4441 bfd_reloc_status_type r;
4442 const char *errmsg = NULL;
4443 bfd_vma gp;
4444 struct elf_nds32_link_hash_table *htab;
4445 bfd *dynobj;
4446 bfd_vma *local_got_offsets;
4447 asection *sgot, *splt, *sreloc;
4448 bfd_vma high_address;
4449 struct elf_nds32_link_hash_table *table;
4450 int eliminate_gc_relocs;
4451 bfd_vma fpbase_addr;
4452
4453 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4454 sym_hashes = elf_sym_hashes (input_bfd);
4455 htab = nds32_elf_hash_table (info);
4456 high_address = bfd_get_section_limit (input_bfd, input_section);
4457
4458 dynobj = htab->root.dynobj;
4459 local_got_offsets = elf_local_got_offsets (input_bfd);
4460
4461 sgot = htab->root.sgot;
4462 splt = htab->root.splt;
4463 sreloc = NULL;
4464
4465 rel = relocs;
4466 relend = relocs + input_section->reloc_count;
4467
4468 table = nds32_elf_hash_table (info);
4469 eliminate_gc_relocs = table->eliminate_gc_relocs;
4470 /* By this time, we can adjust the value of _SDA_BASE_. */
4471 if ((!bfd_link_relocatable (info)))
4472 {
4473 is_SDA_BASE_set = 1;
4474 r = nds32_elf_final_sda_base (output_bfd, info, &gp, TRUE);
4475 if (r != bfd_reloc_ok)
4476 return FALSE;
4477 }
4478
4479 if (is_ITB_BASE_set == 0)
4480 {
4481 /* Set the _ITB_BASE_. */
4482 if (!nds32_elf_ex9_itb_base (info))
4483 {
4484 _bfd_error_handler (_("%B: error: Cannot set _ITB_BASE_"),
4485 output_bfd);
4486 bfd_set_error (bfd_error_bad_value);
4487 }
4488 }
4489
4490 if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
4491 if (!nds32_elf_ifc_reloc ())
4492 _bfd_error_handler (_("error: IFC relocation error."));
4493
4494 /* Relocation for .ex9.itable. */
4495 if (table->target_optimize & NDS32_RELAX_EX9_ON
4496 || (table->ex9_import_file && table->update_ex9_table))
4497 nds32_elf_ex9_reloc_jmp (info);
4498
4499 /* Use gp as fp to prevent truncated fit. Because in relaxation time
4500 the fp value is set as gp, and it has be reverted for instruction
4501 setting fp. */
4502 fpbase_addr = elf_gp (output_bfd);
4503
4504 for (rel = relocs; rel < relend; rel++)
4505 {
4506 enum elf_nds32_reloc_type r_type;
4507 reloc_howto_type *howto = NULL;
4508 unsigned long r_symndx;
4509 struct elf_link_hash_entry *h = NULL;
4510 Elf_Internal_Sym *sym = NULL;
4511 asection *sec;
4512 bfd_vma relocation;
4513
4514 /* We can't modify r_addend here as elf_link_input_bfd has an assert to
4515 ensure it's zero (we use REL relocs, not RELA). Therefore this
4516 should be assigning zero to `addend', but for clarity we use
4517 `r_addend'. */
4518
4519 bfd_vma addend = rel->r_addend;
4520 bfd_vma offset = rel->r_offset;
4521
4522 r_type = ELF32_R_TYPE (rel->r_info);
4523 if (r_type >= R_NDS32_max)
4524 {
4525 /* xgettext:c-format */
4526 _bfd_error_handler (_("%B: error: unknown relocation type %d."),
4527 input_bfd, r_type);
4528 bfd_set_error (bfd_error_bad_value);
4529 ret = FALSE;
4530 continue;
4531 }
4532
4533 if (r_type == R_NDS32_GNU_VTENTRY
4534 || r_type == R_NDS32_GNU_VTINHERIT
4535 || r_type == R_NDS32_NONE
4536 || r_type == R_NDS32_RELA_GNU_VTENTRY
4537 || r_type == R_NDS32_RELA_GNU_VTINHERIT
4538 || (r_type >= R_NDS32_INSN16 && r_type <= R_NDS32_25_FIXED_RELA)
4539 || r_type == R_NDS32_DATA
4540 || r_type == R_NDS32_TRAN
4541 || (r_type >= R_NDS32_LONGCALL4 && r_type <= R_NDS32_LONGJUMP7))
4542 continue;
4543
4544 /* If we enter the fp-as-gp region. Resolve the address
4545 of best fp-base. */
4546 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_BEGIN
4547 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
4548 {
4549 int dist;
4550
4551 /* Distance to relocation of best fp-base is encoded in R_SYM. */
4552 dist = rel->r_addend >> 16;
4553 fpbase_addr = calculate_memory_address (input_bfd, rel + dist,
4554 local_syms, symtab_hdr);
4555 }
4556 else if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_END
4557 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
4558 {
4559 fpbase_addr = elf_gp (output_bfd);
4560 }
4561
4562 if (((r_type >= R_NDS32_DWARF2_OP1_RELA
4563 && r_type <= R_NDS32_DWARF2_LEB_RELA)
4564 || r_type >= R_NDS32_RELAX_ENTRY) && !bfd_link_relocatable (info))
4565 continue;
4566
4567 howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
4568 r_symndx = ELF32_R_SYM (rel->r_info);
4569
4570 /* This is a final link. */
4571 sym = NULL;
4572 sec = NULL;
4573 h = NULL;
4574
4575 if (r_symndx < symtab_hdr->sh_info)
4576 {
4577 /* Local symbol. */
4578 sym = local_syms + r_symndx;
4579 sec = local_sections[r_symndx];
4580
4581 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4582 addend = rel->r_addend;
4583 }
4584 else
4585 {
4586 /* External symbol. */
4587 bfd_boolean warned, ignored, unresolved_reloc;
4588 int symndx = r_symndx - symtab_hdr->sh_info;
4589
4590 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4591 r_symndx, symtab_hdr, sym_hashes, h, sec,
4592 relocation, unresolved_reloc, warned,
4593 ignored);
4594
4595 /* la $fp, _FP_BASE_ is per-function (region).
4596 Handle it specially. */
4597 switch ((int) r_type)
4598 {
4599 case R_NDS32_SDA19S0_RELA:
4600 case R_NDS32_SDA15S0_RELA:
4601 case R_NDS32_20_RELA:
4602 if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
4603 FP_BASE_NAME) == 0)
4604 {
4605 relocation = fpbase_addr;
4606 break;
4607 }
4608 }
4609
4610 }
4611
4612 if (bfd_link_relocatable (info))
4613 {
4614 /* This is a relocatable link. We don't have to change
4615 anything, unless the reloc is against a section symbol,
4616 in which case we have to adjust according to where the
4617 section symbol winds up in the output section. */
4618 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4619 rel->r_addend += sec->output_offset + sym->st_value;
4620
4621 continue;
4622 }
4623
4624 /* Sanity check the address. */
4625 if (offset > high_address)
4626 {
4627 r = bfd_reloc_outofrange;
4628 goto check_reloc;
4629 }
4630
4631 if ((r_type >= R_NDS32_DWARF2_OP1_RELA
4632 && r_type <= R_NDS32_DWARF2_LEB_RELA)
4633 || r_type >= R_NDS32_RELAX_ENTRY)
4634 continue;
4635
4636 switch ((int) r_type)
4637 {
4638 case R_NDS32_GOTOFF:
4639 /* Relocation is relative to the start of the global offset
4640 table (for ld24 rx, #uimm24), e.g. access at label+addend
4641
4642 ld24 rx. #label@GOTOFF + addend
4643 sub rx, r12. */
4644 case R_NDS32_GOTOFF_HI20:
4645 case R_NDS32_GOTOFF_LO12:
4646 case R_NDS32_GOTOFF_LO15:
4647 case R_NDS32_GOTOFF_LO19:
4648 BFD_ASSERT (sgot != NULL);
4649
4650 relocation -= elf_gp (output_bfd);
4651 break;
4652
4653 case R_NDS32_9_PLTREL:
4654 case R_NDS32_25_PLTREL:
4655 /* Relocation is to the entry for this symbol in the
4656 procedure linkage table. */
4657
4658 /* The native assembler will generate a 25_PLTREL reloc
4659 for a local symbol if you assemble a call from one
4660 section to another when using -K pic. */
4661 if (h == NULL)
4662 break;
4663
4664 if (h->forced_local)
4665 break;
4666
4667 /* We didn't make a PLT entry for this symbol. This
4668 happens when statically linking PIC code, or when
4669 using -Bsymbolic. */
4670 if (h->plt.offset == (bfd_vma) - 1)
4671 break;
4672
4673 relocation = (splt->output_section->vma
4674 + splt->output_offset + h->plt.offset);
4675 break;
4676
4677 case R_NDS32_PLT_GOTREL_HI20:
4678 case R_NDS32_PLT_GOTREL_LO12:
4679 case R_NDS32_PLT_GOTREL_LO15:
4680 case R_NDS32_PLT_GOTREL_LO19:
4681 case R_NDS32_PLT_GOTREL_LO20:
4682 if (h == NULL || h->forced_local || h->plt.offset == (bfd_vma) - 1)
4683 {
4684 /* We didn't make a PLT entry for this symbol. This
4685 happens when statically linking PIC code, or when
4686 using -Bsymbolic. */
4687 relocation -= elf_gp (output_bfd);
4688 break;
4689 }
4690
4691 relocation = (splt->output_section->vma
4692 + splt->output_offset + h->plt.offset);
4693
4694 relocation -= elf_gp (output_bfd);
4695 break;
4696
4697 case R_NDS32_PLTREL_HI20:
4698 case R_NDS32_PLTREL_LO12:
4699
4700 /* Relocation is to the entry for this symbol in the
4701 procedure linkage table. */
4702
4703 /* The native assembler will generate a 25_PLTREL reloc
4704 for a local symbol if you assemble a call from one
4705 section to another when using -K pic. */
4706 if (h == NULL)
4707 break;
4708
4709 if (h->forced_local)
4710 break;
4711
4712 if (h->plt.offset == (bfd_vma) - 1)
4713 /* We didn't make a PLT entry for this symbol. This
4714 happens when statically linking PIC code, or when
4715 using -Bsymbolic. */
4716 break;
4717
4718 if (splt == NULL)
4719 break;
4720
4721 relocation = (splt->output_section->vma
4722 + splt->output_offset
4723 + h->plt.offset + 4)
4724 - (input_section->output_section->vma
4725 + input_section->output_offset
4726 + rel->r_offset);
4727
4728 break;
4729
4730 case R_NDS32_GOTPC20:
4731 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
4732 ld24 rx,#_GLOBAL_OFFSET_TABLE_ */
4733 relocation = elf_gp (output_bfd);
4734 break;
4735
4736 case R_NDS32_GOTPC_HI20:
4737 case R_NDS32_GOTPC_LO12:
4738 {
4739 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
4740 bl .+4
4741 seth rx,#high(_GLOBAL_OFFSET_TABLE_)
4742 or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
4743 or
4744 bl .+4
4745 seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
4746 add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
4747 */
4748 relocation = elf_gp (output_bfd);
4749 relocation -= (input_section->output_section->vma
4750 + input_section->output_offset + rel->r_offset);
4751 break;
4752 }
4753
4754 case R_NDS32_GOT20:
4755 /* Fall through. */
4756 case R_NDS32_GOT_HI20:
4757 case R_NDS32_GOT_LO12:
4758 case R_NDS32_GOT_LO15:
4759 case R_NDS32_GOT_LO19:
4760 /* Relocation is to the entry for this symbol in the global
4761 offset table. */
4762 BFD_ASSERT (sgot != NULL);
4763
4764 if (h != NULL)
4765 {
4766 bfd_boolean dyn;
4767 bfd_vma off;
4768
4769 off = h->got.offset;
4770 BFD_ASSERT (off != (bfd_vma) - 1);
4771 dyn = htab->root.dynamic_sections_created;
4772 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4773 bfd_link_pic (info),
4774 h)
4775 || (bfd_link_pic (info)
4776 && (info->symbolic
4777 || h->dynindx == -1
4778 || h->forced_local) && h->def_regular))
4779 {
4780 /* This is actually a static link, or it is a
4781 -Bsymbolic link and the symbol is defined
4782 locally, or the symbol was forced to be local
4783 because of a version file. We must initialize
4784 this entry in the global offset table. Since the
4785 offset must always be a multiple of 4, we use the
4786 least significant bit to record whether we have
4787 initialized it already.
4788
4789 When doing a dynamic link, we create a .rela.got
4790 relocation entry to initialize the value. This
4791 is done in the finish_dynamic_symbol routine. */
4792 if ((off & 1) != 0)
4793 off &= ~1;
4794 else
4795 {
4796 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4797 h->got.offset |= 1;
4798 }
4799 }
4800 relocation = sgot->output_section->vma + sgot->output_offset + off
4801 - elf_gp (output_bfd);
4802 }
4803 else
4804 {
4805 bfd_vma off;
4806 bfd_byte *loc;
4807
4808 BFD_ASSERT (local_got_offsets != NULL
4809 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
4810
4811 off = local_got_offsets[r_symndx];
4812
4813 /* The offset must always be a multiple of 4. We use
4814 the least significant bit to record whether we have
4815 already processed this entry. */
4816 if ((off & 1) != 0)
4817 off &= ~1;
4818 else
4819 {
4820 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4821
4822 if (bfd_link_pic (info))
4823 {
4824 asection *srelgot;
4825 Elf_Internal_Rela outrel;
4826
4827 /* We need to generate a R_NDS32_RELATIVE reloc
4828 for the dynamic linker. */
4829 srelgot = htab->root.srelgot;
4830 BFD_ASSERT (srelgot != NULL);
4831
4832 outrel.r_offset = (elf_gp (output_bfd)
4833 + sgot->output_offset + off);
4834 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
4835 outrel.r_addend = relocation;
4836 loc = srelgot->contents;
4837 loc +=
4838 srelgot->reloc_count * sizeof (Elf32_External_Rela);
4839 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4840 ++srelgot->reloc_count;
4841 }
4842 local_got_offsets[r_symndx] |= 1;
4843 }
4844 relocation = sgot->output_section->vma + sgot->output_offset + off
4845 - elf_gp (output_bfd);
4846 }
4847
4848 break;
4849
4850 case R_NDS32_16_RELA:
4851 case R_NDS32_20_RELA:
4852 case R_NDS32_5_RELA:
4853 case R_NDS32_32_RELA:
4854 case R_NDS32_9_PCREL_RELA:
4855 case R_NDS32_WORD_9_PCREL_RELA:
4856 case R_NDS32_10_UPCREL_RELA:
4857 case R_NDS32_15_PCREL_RELA:
4858 case R_NDS32_17_PCREL_RELA:
4859 case R_NDS32_25_PCREL_RELA:
4860 case R_NDS32_HI20_RELA:
4861 case R_NDS32_LO12S3_RELA:
4862 case R_NDS32_LO12S2_RELA:
4863 case R_NDS32_LO12S2_DP_RELA:
4864 case R_NDS32_LO12S2_SP_RELA:
4865 case R_NDS32_LO12S1_RELA:
4866 case R_NDS32_LO12S0_RELA:
4867 case R_NDS32_LO12S0_ORI_RELA:
4868 if (bfd_link_pic (info) && r_symndx != 0
4869 && (input_section->flags & SEC_ALLOC) != 0
4870 && (eliminate_gc_relocs == 0
4871 || (sec && (sec->flags & SEC_EXCLUDE) == 0))
4872 && ((r_type != R_NDS32_9_PCREL_RELA
4873 && r_type != R_NDS32_WORD_9_PCREL_RELA
4874 && r_type != R_NDS32_10_UPCREL_RELA
4875 && r_type != R_NDS32_15_PCREL_RELA
4876 && r_type != R_NDS32_17_PCREL_RELA
4877 && r_type != R_NDS32_25_PCREL_RELA
4878 && !(r_type == R_NDS32_32_RELA
4879 && strcmp (input_section->name, ".eh_frame") == 0))
4880 || (h != NULL && h->dynindx != -1
4881 && (!info->symbolic || !h->def_regular))))
4882 {
4883 Elf_Internal_Rela outrel;
4884 bfd_boolean skip, relocate;
4885 bfd_byte *loc;
4886
4887 /* When generating a shared object, these relocations
4888 are copied into the output file to be resolved at run
4889 time. */
4890
4891 if (sreloc == NULL)
4892 {
4893 const char *name;
4894
4895 name = bfd_elf_string_from_elf_section
4896 (input_bfd, elf_elfheader (input_bfd)->e_shstrndx,
4897 elf_section_data (input_section)->rela.hdr->sh_name);
4898 if (name == NULL)
4899 return FALSE;
4900
4901 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
4902 && strcmp (bfd_get_section_name (input_bfd,
4903 input_section),
4904 name + 5) == 0);
4905
4906 sreloc = bfd_get_section_by_name (dynobj, name);
4907 BFD_ASSERT (sreloc != NULL);
4908 }
4909
4910 skip = FALSE;
4911 relocate = FALSE;
4912
4913 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
4914 info,
4915 input_section,
4916 rel->r_offset);
4917 if (outrel.r_offset == (bfd_vma) - 1)
4918 skip = TRUE;
4919 else if (outrel.r_offset == (bfd_vma) - 2)
4920 skip = TRUE, relocate = TRUE;
4921 outrel.r_offset += (input_section->output_section->vma
4922 + input_section->output_offset);
4923
4924 if (skip)
4925 memset (&outrel, 0, sizeof outrel);
4926 else if (r_type == R_NDS32_17_PCREL_RELA
4927 || r_type == R_NDS32_15_PCREL_RELA
4928 || r_type == R_NDS32_25_PCREL_RELA)
4929 {
4930 BFD_ASSERT (h != NULL && h->dynindx != -1);
4931 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4932 outrel.r_addend = rel->r_addend;
4933 }
4934 else
4935 {
4936 /* h->dynindx may be -1 if this symbol was marked to
4937 become local. */
4938 if (h == NULL
4939 || ((info->symbolic || h->dynindx == -1)
4940 && h->def_regular))
4941 {
4942 relocate = TRUE;
4943 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
4944 outrel.r_addend = relocation + rel->r_addend;
4945 }
4946 else
4947 {
4948 BFD_ASSERT (h->dynindx != -1);
4949 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4950 outrel.r_addend = rel->r_addend;
4951 }
4952 }
4953
4954 loc = sreloc->contents;
4955 loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
4956 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4957 ++sreloc->reloc_count;
4958
4959 /* If this reloc is against an external symbol, we do
4960 not want to fiddle with the addend. Otherwise, we
4961 need to include the symbol value so that it becomes
4962 an addend for the dynamic reloc. */
4963 if (!relocate)
4964 continue;
4965 }
4966 break;
4967
4968 case R_NDS32_25_ABS_RELA:
4969 if (bfd_link_pic (info))
4970 {
4971 _bfd_error_handler
4972 (_("%s: warning: cannot deal R_NDS32_25_ABS_RELA in shared "
4973 "mode."), bfd_get_filename (input_bfd));
4974 return FALSE;
4975 }
4976 break;
4977
4978 case R_NDS32_9_PCREL:
4979 r = nds32_elf_do_9_pcrel_reloc (input_bfd, howto, input_section,
4980 contents, offset,
4981 sec, relocation, addend);
4982 goto check_reloc;
4983
4984 case R_NDS32_HI20:
4985 {
4986 Elf_Internal_Rela *lorel;
4987
4988 /* We allow an arbitrary number of HI20 relocs before the
4989 LO12 reloc. This permits gcc to emit the HI and LO relocs
4990 itself. */
4991 for (lorel = rel + 1;
4992 (lorel < relend
4993 && ELF32_R_TYPE (lorel->r_info) == R_NDS32_HI20); lorel++)
4994 continue;
4995 if (lorel < relend
4996 && (ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S3
4997 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S2
4998 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S1
4999 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S0))
5000 {
5001 nds32_elf_relocate_hi20 (input_bfd, r_type, rel, lorel,
5002 contents, relocation + addend);
5003 r = bfd_reloc_ok;
5004 }
5005 else
5006 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5007 contents, offset, relocation,
5008 addend);
5009 }
5010
5011 goto check_reloc;
5012
5013 case R_NDS32_GOT17S2_RELA:
5014 case R_NDS32_GOT15S2_RELA:
5015 {
5016 bfd_vma off;
5017
5018 BFD_ASSERT (sgot != NULL);
5019
5020 if (h != NULL)
5021 {
5022 bfd_boolean dyn;
5023
5024 off = h->got.offset;
5025 BFD_ASSERT (off != (bfd_vma) - 1);
5026
5027 dyn = htab->root.dynamic_sections_created;
5028 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL
5029 (dyn, bfd_link_pic (info), h)
5030 || (bfd_link_pic (info)
5031 && (info->symbolic
5032 || h->dynindx == -1
5033 || h->forced_local)
5034 && h->def_regular))
5035 {
5036 /* This is actually a static link, or it is a
5037 -Bsymbolic link and the symbol is defined
5038 locally, or the symbol was forced to be local
5039 because of a version file. We must initialize
5040 this entry in the global offset table. Since the
5041 offset must always be a multiple of 4, we use the
5042 least significant bit to record whether we have
5043 initialized it already.
5044
5045 When doing a dynamic link, we create a .rela.got
5046 relocation entry to initialize the value. This
5047 is done in the finish_dynamic_symbol routine. */
5048 if ((off & 1) != 0)
5049 off &= ~1;
5050 else
5051 {
5052 bfd_put_32 (output_bfd, relocation,
5053 sgot->contents + off);
5054 h->got.offset |= 1;
5055 }
5056 }
5057 }
5058 else
5059 {
5060 bfd_byte *loc;
5061
5062 BFD_ASSERT (local_got_offsets != NULL
5063 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5064
5065 off = local_got_offsets[r_symndx];
5066
5067 /* The offset must always be a multiple of 4. We use
5068 the least significant bit to record whether we have
5069 already processed this entry. */
5070 if ((off & 1) != 0)
5071 off &= ~1;
5072 else
5073 {
5074 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5075
5076 if (bfd_link_pic (info))
5077 {
5078 asection *srelgot;
5079 Elf_Internal_Rela outrel;
5080
5081 /* We need to generate a R_NDS32_RELATIVE reloc
5082 for the dynamic linker. */
5083 srelgot = htab->root.srelgot;
5084 BFD_ASSERT (srelgot != NULL);
5085
5086 outrel.r_offset = (elf_gp (output_bfd)
5087 + sgot->output_offset + off);
5088 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5089 outrel.r_addend = relocation;
5090 loc = srelgot->contents;
5091 loc +=
5092 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5093 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5094 ++srelgot->reloc_count;
5095 }
5096 local_got_offsets[r_symndx] |= 1;
5097 }
5098 }
5099 relocation = sgot->output_section->vma + sgot->output_offset + off
5100 - elf_gp (output_bfd);
5101 }
5102 if (relocation & align)
5103 {
5104 /* Incorrect alignment. */
5105 _bfd_error_handler
5106 (_("%B: warning: unaligned access to GOT entry."), input_bfd);
5107 ret = FALSE;
5108 r = bfd_reloc_dangerous;
5109 goto check_reloc;
5110 }
5111 break;
5112
5113 case R_NDS32_SDA16S3_RELA:
5114 case R_NDS32_SDA15S3_RELA:
5115 case R_NDS32_SDA15S3:
5116 align = 0x7;
5117 goto handle_sda;
5118
5119 case R_NDS32_SDA17S2_RELA:
5120 case R_NDS32_SDA15S2_RELA:
5121 case R_NDS32_SDA12S2_SP_RELA:
5122 case R_NDS32_SDA12S2_DP_RELA:
5123 case R_NDS32_SDA15S2:
5124 case R_NDS32_SDA_FP7U2_RELA:
5125 align = 0x3;
5126 goto handle_sda;
5127
5128 case R_NDS32_SDA18S1_RELA:
5129 case R_NDS32_SDA15S1_RELA:
5130 case R_NDS32_SDA15S1:
5131 align = 0x1;
5132 goto handle_sda;
5133
5134 case R_NDS32_SDA19S0_RELA:
5135 case R_NDS32_SDA15S0_RELA:
5136 case R_NDS32_SDA15S0:
5137 {
5138 align = 0x0;
5139 handle_sda:
5140 BFD_ASSERT (sec != NULL);
5141
5142 /* If the symbol is in the abs section, the out_bfd will be null.
5143 This happens when the relocation has a symbol@GOTOFF. */
5144 r = nds32_elf_final_sda_base (output_bfd, info, &gp, FALSE);
5145 if (r != bfd_reloc_ok)
5146 {
5147 _bfd_error_handler
5148 (_("%B: warning: relocate SDA_BASE failed."), input_bfd);
5149 ret = FALSE;
5150 goto check_reloc;
5151 }
5152
5153 /* At this point `relocation' contains the object's
5154 address. */
5155 if (r_type == R_NDS32_SDA_FP7U2_RELA)
5156 {
5157 relocation -= fpbase_addr;
5158 }
5159 else
5160 relocation -= gp;
5161 /* Now it contains the offset from _SDA_BASE_. */
5162
5163 /* Make sure alignment is correct. */
5164
5165 if (relocation & align)
5166 {
5167 /* Incorrect alignment. */
5168 _bfd_error_handler
5169 /* xgettext:c-format */
5170 (_("%B(%A): warning: unaligned small data access of type %d."),
5171 input_bfd, input_section, r_type);
5172 ret = FALSE;
5173 goto check_reloc;
5174 }
5175 }
5176
5177 break;
5178 case R_NDS32_17IFC_PCREL_RELA:
5179 case R_NDS32_10IFCU_PCREL_RELA:
5180 /* do nothing */
5181 break;
5182
5183 case R_NDS32_TLS_LE_HI20:
5184 case R_NDS32_TLS_LE_LO12:
5185 case R_NDS32_TLS_LE_20:
5186 case R_NDS32_TLS_LE_15S0:
5187 case R_NDS32_TLS_LE_15S1:
5188 case R_NDS32_TLS_LE_15S2:
5189 if (elf_hash_table (info)->tls_sec != NULL)
5190 relocation -= (elf_hash_table (info)->tls_sec->vma + TP_OFFSET);
5191 break;
5192 case R_NDS32_TLS_IE_HI20:
5193 case R_NDS32_TLS_IE_LO12S2:
5194 {
5195 /* Relocation is to the entry for this symbol in the global
5196 offset table. */
5197 unsigned int tls_type;
5198 asection *srelgot;
5199 Elf_Internal_Rela outrel;
5200 bfd_vma off;
5201 bfd_byte *loc;
5202 int indx = 0;
5203
5204 BFD_ASSERT (sgot != NULL);
5205 if (h != NULL)
5206 {
5207 bfd_boolean dyn;
5208
5209 off = h->got.offset;
5210 BFD_ASSERT (off != (bfd_vma) - 1);
5211 dyn = htab->root.dynamic_sections_created;
5212 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
5213 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5214 && (!bfd_link_pic (info)
5215 || !SYMBOL_REFERENCES_LOCAL (info, h)))
5216 indx = h->dynindx;
5217 }
5218 else
5219 {
5220 /* Never happen currently. */
5221 BFD_ASSERT (local_got_offsets != NULL
5222 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5223
5224 off = local_got_offsets[r_symndx];
5225
5226 tls_type = elf32_nds32_local_got_tls_type (input_bfd)[r_symndx];
5227 }
5228 relocation = sgot->output_section->vma + sgot->output_offset + off;
5229
5230 if (r_type == R_NDS32_TLS_IE_LO12S2)
5231 break;
5232
5233 /* The offset must always be a multiple of 4. We use
5234 the least significant bit to record whether we have
5235 already processed this entry. */
5236 if ((off & 1) != 0)
5237 off &= ~1;
5238 else
5239 {
5240 bfd_boolean need_relocs = FALSE;
5241 srelgot = htab->root.srelgot;
5242 if ((bfd_link_pic (info) || indx != 0)
5243 && (h == NULL
5244 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5245 || h->root.type != bfd_link_hash_undefweak))
5246 {
5247 need_relocs = TRUE;
5248 BFD_ASSERT (srelgot != NULL);
5249 }
5250 if (tls_type & GOT_TLS_IE)
5251 {
5252 if (need_relocs)
5253 {
5254 if (h->dynindx == 0)
5255 outrel.r_addend = relocation - dtpoff_base (info);
5256 else
5257 outrel.r_addend = 0;
5258 outrel.r_offset = (sgot->output_section->vma
5259 + sgot->output_offset
5260 + off);
5261 outrel.r_info =
5262 ELF32_R_INFO (h->dynindx, R_NDS32_TLS_TPOFF);
5263
5264 loc = srelgot->contents;
5265 loc +=
5266 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5267 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5268 ++srelgot->reloc_count;
5269 }
5270 else
5271 bfd_put_32 (output_bfd, h->root.u.def.value - TP_OFFSET,
5272 sgot->contents + off);
5273 }
5274 }
5275 }
5276 break;
5277
5278 /* DON'T fall through. */
5279
5280 default:
5281 /* OLD_NDS32_RELOC. */
5282
5283 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5284 contents, offset, relocation, addend);
5285 goto check_reloc;
5286 }
5287
5288 switch ((int) r_type)
5289 {
5290 case R_NDS32_20_RELA:
5291 case R_NDS32_5_RELA:
5292 case R_NDS32_9_PCREL_RELA:
5293 case R_NDS32_WORD_9_PCREL_RELA:
5294 case R_NDS32_10_UPCREL_RELA:
5295 case R_NDS32_15_PCREL_RELA:
5296 case R_NDS32_17_PCREL_RELA:
5297 case R_NDS32_25_PCREL_RELA:
5298 case R_NDS32_25_ABS_RELA:
5299 case R_NDS32_HI20_RELA:
5300 case R_NDS32_LO12S3_RELA:
5301 case R_NDS32_LO12S2_RELA:
5302 case R_NDS32_LO12S2_DP_RELA:
5303 case R_NDS32_LO12S2_SP_RELA:
5304 case R_NDS32_LO12S1_RELA:
5305 case R_NDS32_LO12S0_RELA:
5306 case R_NDS32_LO12S0_ORI_RELA:
5307 case R_NDS32_SDA16S3_RELA:
5308 case R_NDS32_SDA17S2_RELA:
5309 case R_NDS32_SDA18S1_RELA:
5310 case R_NDS32_SDA19S0_RELA:
5311 case R_NDS32_SDA15S3_RELA:
5312 case R_NDS32_SDA15S2_RELA:
5313 case R_NDS32_SDA12S2_DP_RELA:
5314 case R_NDS32_SDA12S2_SP_RELA:
5315 case R_NDS32_SDA15S1_RELA:
5316 case R_NDS32_SDA15S0_RELA:
5317 case R_NDS32_SDA_FP7U2_RELA:
5318 case R_NDS32_9_PLTREL:
5319 case R_NDS32_25_PLTREL:
5320 case R_NDS32_GOT20:
5321 case R_NDS32_GOT_HI20:
5322 case R_NDS32_GOT_LO12:
5323 case R_NDS32_GOT_LO15:
5324 case R_NDS32_GOT_LO19:
5325 case R_NDS32_GOT15S2_RELA:
5326 case R_NDS32_GOT17S2_RELA:
5327 case R_NDS32_GOTPC20:
5328 case R_NDS32_GOTPC_HI20:
5329 case R_NDS32_GOTPC_LO12:
5330 case R_NDS32_GOTOFF:
5331 case R_NDS32_GOTOFF_HI20:
5332 case R_NDS32_GOTOFF_LO12:
5333 case R_NDS32_GOTOFF_LO15:
5334 case R_NDS32_GOTOFF_LO19:
5335 case R_NDS32_PLTREL_HI20:
5336 case R_NDS32_PLTREL_LO12:
5337 case R_NDS32_PLT_GOTREL_HI20:
5338 case R_NDS32_PLT_GOTREL_LO12:
5339 case R_NDS32_PLT_GOTREL_LO15:
5340 case R_NDS32_PLT_GOTREL_LO19:
5341 case R_NDS32_PLT_GOTREL_LO20:
5342 case R_NDS32_17IFC_PCREL_RELA:
5343 case R_NDS32_10IFCU_PCREL_RELA:
5344 case R_NDS32_TLS_LE_HI20:
5345 case R_NDS32_TLS_LE_LO12:
5346 case R_NDS32_TLS_IE_HI20:
5347 case R_NDS32_TLS_IE_LO12S2:
5348 case R_NDS32_TLS_LE_20:
5349 case R_NDS32_TLS_LE_15S0:
5350 case R_NDS32_TLS_LE_15S1:
5351 case R_NDS32_TLS_LE_15S2:
5352 /* Instruction related relocs must handle endian properly. */
5353 /* NOTE: PIC IS NOT HANDLE YET; DO IT LATER. */
5354 r = nds32_elf_final_link_relocate (howto, input_bfd,
5355 input_section, contents,
5356 rel->r_offset, relocation,
5357 rel->r_addend);
5358 break;
5359
5360 default:
5361 /* All other relocs can use default handler. */
5362 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5363 contents, rel->r_offset,
5364 relocation, rel->r_addend);
5365 break;
5366 }
5367
5368 check_reloc:
5369
5370 if (r != bfd_reloc_ok)
5371 {
5372 /* FIXME: This should be generic enough to go in a utility. */
5373 const char *name;
5374
5375 if (h != NULL)
5376 name = h->root.root.string;
5377 else
5378 {
5379 name = bfd_elf_string_from_elf_section
5380 (input_bfd, symtab_hdr->sh_link, sym->st_name);
5381 if (name == NULL || *name == '\0')
5382 name = bfd_section_name (input_bfd, sec);
5383 }
5384
5385 if (errmsg != NULL)
5386 goto common_error;
5387
5388 switch (r)
5389 {
5390 case bfd_reloc_overflow:
5391 (*info->callbacks->reloc_overflow)
5392 (info, (h ? &h->root : NULL), name, howto->name,
5393 (bfd_vma) 0, input_bfd, input_section, offset);
5394 break;
5395
5396 case bfd_reloc_undefined:
5397 (*info->callbacks->undefined_symbol)
5398 (info, name, input_bfd, input_section, offset, TRUE);
5399 break;
5400
5401 case bfd_reloc_outofrange:
5402 errmsg = _("internal error: out of range error");
5403 goto common_error;
5404
5405 case bfd_reloc_notsupported:
5406 errmsg = _("internal error: unsupported relocation error");
5407 goto common_error;
5408
5409 case bfd_reloc_dangerous:
5410 errmsg = _("internal error: dangerous error");
5411 goto common_error;
5412
5413 default:
5414 errmsg = _("internal error: unknown error");
5415 /* Fall through. */
5416
5417 common_error:
5418 (*info->callbacks->warning) (info, errmsg, name, input_bfd,
5419 input_section, offset);
5420 break;
5421 }
5422 }
5423 }
5424
5425 return ret;
5426 }
5427
5428 /* Finish up dynamic symbol handling. We set the contents of various
5429 dynamic sections here. */
5430
5431 static bfd_boolean
5432 nds32_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
5433 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
5434 {
5435 struct elf_nds32_link_hash_table *htab;
5436 bfd_byte *loc;
5437
5438 htab = nds32_elf_hash_table (info);
5439
5440 if (h->plt.offset != (bfd_vma) - 1)
5441 {
5442 asection *splt;
5443 asection *sgot;
5444 asection *srela;
5445
5446 bfd_vma plt_index;
5447 bfd_vma got_offset;
5448 bfd_vma local_plt_offset;
5449 Elf_Internal_Rela rela;
5450
5451 /* This symbol has an entry in the procedure linkage table. Set
5452 it up. */
5453
5454 BFD_ASSERT (h->dynindx != -1);
5455
5456 splt = htab->root.splt;
5457 sgot = htab->root.sgotplt;
5458 srela = htab->root.srelplt;
5459 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
5460
5461 /* Get the index in the procedure linkage table which
5462 corresponds to this symbol. This is the index of this symbol
5463 in all the symbols for which we are making plt entries. The
5464 first entry in the procedure linkage table is reserved. */
5465 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
5466
5467 /* Get the offset into the .got table of the entry that
5468 corresponds to this function. Each .got entry is 4 bytes.
5469 The first three are reserved. */
5470 got_offset = (plt_index + 3) * 4;
5471
5472 /* Fill in the entry in the procedure linkage table. */
5473 if (!bfd_link_pic (info))
5474 {
5475 unsigned long insn;
5476
5477 insn = PLT_ENTRY_WORD0 + (((sgot->output_section->vma
5478 + sgot->output_offset + got_offset) >> 12)
5479 & 0xfffff);
5480 bfd_putb32 (insn, splt->contents + h->plt.offset);
5481
5482 insn = PLT_ENTRY_WORD1 + (((sgot->output_section->vma
5483 + sgot->output_offset + got_offset) & 0x0fff)
5484 >> 2);
5485 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
5486
5487 insn = PLT_ENTRY_WORD2;
5488 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
5489
5490 insn = PLT_ENTRY_WORD3 + (plt_index & 0x7ffff);
5491 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
5492
5493 insn = PLT_ENTRY_WORD4
5494 + (((unsigned int) ((-(h->plt.offset + 16)) >> 1)) & 0xffffff);
5495 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
5496 local_plt_offset = 12;
5497 }
5498 else
5499 {
5500 /* sda_base must be set at this time. */
5501 unsigned long insn;
5502 long offset;
5503
5504 /* FIXME, sda_base is 65536, it will damage opcode. */
5505 /* insn = PLT_PIC_ENTRY_WORD0 + (((got_offset - sda_base) >> 2) & 0x7fff); */
5506 offset = sgot->output_section->vma + sgot->output_offset + got_offset
5507 - elf_gp (output_bfd);
5508 insn = PLT_PIC_ENTRY_WORD0 + ((offset >> 12) & 0xfffff);
5509 bfd_putb32 (insn, splt->contents + h->plt.offset);
5510
5511 insn = PLT_PIC_ENTRY_WORD1 + (offset & 0xfff);
5512 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
5513
5514 insn = PLT_PIC_ENTRY_WORD2;
5515 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
5516
5517 insn = PLT_PIC_ENTRY_WORD3;
5518 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
5519
5520 insn = PLT_PIC_ENTRY_WORD4 + (plt_index & 0x7fffff);
5521 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
5522
5523 insn = PLT_PIC_ENTRY_WORD5
5524 + (((unsigned int) ((-(h->plt.offset + 20)) >> 1)) & 0xffffff);
5525 bfd_putb32 (insn, splt->contents + h->plt.offset + 20);
5526
5527 local_plt_offset = 16;
5528 }
5529
5530 /* Fill in the entry in the global offset table,
5531 so it will fall through to the next instruction for the first time. */
5532 bfd_put_32 (output_bfd,
5533 (splt->output_section->vma + splt->output_offset
5534 + h->plt.offset + local_plt_offset),
5535 sgot->contents + got_offset);
5536
5537 /* Fill in the entry in the .rela.plt section. */
5538 rela.r_offset = (sgot->output_section->vma
5539 + sgot->output_offset + got_offset);
5540 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_JMP_SLOT);
5541 rela.r_addend = 0;
5542 loc = srela->contents;
5543 loc += plt_index * sizeof (Elf32_External_Rela);
5544 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5545
5546 if (!h->def_regular)
5547 {
5548 /* Mark the symbol as undefined, rather than as defined in
5549 the .plt section. Leave the value alone. */
5550 sym->st_shndx = SHN_UNDEF;
5551 if (!h->ref_regular_nonweak)
5552 sym->st_value = 0;
5553 }
5554 }
5555
5556 if (h->got.offset != (bfd_vma) - 1)
5557 {
5558 asection *sgot;
5559 asection *srela;
5560 Elf_Internal_Rela rela;
5561
5562 /* This symbol has an entry in the global offset table.
5563 Set it up. */
5564
5565 sgot = htab->root.sgot;
5566 srela = htab->root.srelgot;
5567 BFD_ASSERT (sgot != NULL && srela != NULL);
5568
5569 rela.r_offset = (sgot->output_section->vma
5570 + sgot->output_offset + (h->got.offset & ~1));
5571
5572 /* If this is a -Bsymbolic link, and the symbol is defined
5573 locally, we just want to emit a RELATIVE reloc. Likewise if
5574 the symbol was forced to be local because of a version file.
5575 The entry in the global offset table will already have been
5576 initialized in the relocate_section function. */
5577 if (bfd_link_pic (info)
5578 && (info->symbolic
5579 || h->dynindx == -1 || h->forced_local) && h->def_regular)
5580 {
5581 rela.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5582 rela.r_addend = (h->root.u.def.value
5583 + h->root.u.def.section->output_section->vma
5584 + h->root.u.def.section->output_offset);
5585 }
5586 else
5587 {
5588 BFD_ASSERT ((h->got.offset & 1) == 0);
5589 bfd_put_32 (output_bfd, (bfd_vma) 0,
5590 sgot->contents + h->got.offset);
5591 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_GLOB_DAT);
5592 rela.r_addend = 0;
5593 }
5594
5595 loc = srela->contents;
5596 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
5597 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5598 ++srela->reloc_count;
5599 }
5600
5601 if (h->needs_copy)
5602 {
5603 asection *s;
5604 Elf_Internal_Rela rela;
5605
5606 /* This symbols needs a copy reloc. Set it up. */
5607
5608 BFD_ASSERT (h->dynindx != -1
5609 && (h->root.type == bfd_link_hash_defined
5610 || h->root.type == bfd_link_hash_defweak));
5611
5612 s = bfd_get_section_by_name (h->root.u.def.section->owner, ".rela.bss");
5613 BFD_ASSERT (s != NULL);
5614
5615 rela.r_offset = (h->root.u.def.value
5616 + h->root.u.def.section->output_section->vma
5617 + h->root.u.def.section->output_offset);
5618 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_COPY);
5619 rela.r_addend = 0;
5620 loc = s->contents;
5621 loc += s->reloc_count * sizeof (Elf32_External_Rela);
5622 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5623 ++s->reloc_count;
5624 }
5625
5626 /* Mark some specially defined symbols as absolute. */
5627 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5628 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
5629 sym->st_shndx = SHN_ABS;
5630
5631 return TRUE;
5632 }
5633
5634
5635 /* Finish up the dynamic sections. */
5636
5637 static bfd_boolean
5638 nds32_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
5639 {
5640 struct elf_nds32_link_hash_table *htab;
5641 bfd *dynobj;
5642 asection *sdyn;
5643 asection *sgot;
5644
5645 htab = nds32_elf_hash_table (info);
5646 dynobj = htab->root.dynobj;
5647
5648 sgot = htab->root.sgotplt;
5649 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5650
5651 if (htab->root.dynamic_sections_created)
5652 {
5653 asection *splt;
5654 Elf32_External_Dyn *dyncon, *dynconend;
5655
5656 BFD_ASSERT (sgot != NULL && sdyn != NULL);
5657
5658 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5659 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5660
5661 for (; dyncon < dynconend; dyncon++)
5662 {
5663 Elf_Internal_Dyn dyn;
5664 asection *s;
5665
5666 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5667
5668 switch (dyn.d_tag)
5669 {
5670 default:
5671 break;
5672
5673 case DT_PLTGOT:
5674 s = htab->root.sgotplt;
5675 goto get_vma;
5676 case DT_JMPREL:
5677 s = htab->root.srelplt;
5678 get_vma:
5679 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5680 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5681 break;
5682
5683 case DT_PLTRELSZ:
5684 s = htab->root.srelplt;
5685 dyn.d_un.d_val = s->size;
5686 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5687 break;
5688
5689 case DT_RELASZ:
5690 /* My reading of the SVR4 ABI indicates that the
5691 procedure linkage table relocs (DT_JMPREL) should be
5692 included in the overall relocs (DT_RELA). This is
5693 what Solaris does. However, UnixWare can not handle
5694 that case. Therefore, we override the DT_RELASZ entry
5695 here to make it not include the JMPREL relocs. Since
5696 the linker script arranges for .rela.plt to follow all
5697 other relocation sections, we don't have to worry
5698 about changing the DT_RELA entry. */
5699 if (htab->root.srelplt != NULL)
5700 {
5701 s = htab->root.srelplt;
5702 dyn.d_un.d_val -= s->size;
5703 }
5704 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5705 break;
5706 }
5707 }
5708
5709 /* Fill in the first entry in the procedure linkage table. */
5710 splt = htab->root.splt;
5711 if (splt && splt->size > 0)
5712 {
5713 if (bfd_link_pic (info))
5714 {
5715 unsigned long insn;
5716 long offset;
5717
5718 /* FIXME, sda_base is 65536, it will damage opcode. */
5719 /* insn = PLT_PIC_ENTRY_WORD0 + (((got_offset - sda_base) >> 2) & 0x7fff); */
5720 offset = sgot->output_section->vma + sgot->output_offset + 4
5721 - elf_gp (output_bfd);
5722 insn = PLT0_PIC_ENTRY_WORD0 | ((offset >> 12) & 0xfffff);
5723 bfd_putb32 (insn, splt->contents);
5724
5725 /* insn = PLT0_PIC_ENTRY_WORD0 | (((8 - sda_base) >> 2) & 0x7fff) ; */
5726 /* here has a typo? */
5727 insn = PLT0_PIC_ENTRY_WORD1 | (offset & 0xfff);
5728 bfd_putb32 (insn, splt->contents + 4);
5729
5730 insn = PLT0_PIC_ENTRY_WORD2;
5731 bfd_putb32 (insn, splt->contents + 8);
5732
5733 insn = PLT0_PIC_ENTRY_WORD3;
5734 bfd_putb32 (insn, splt->contents + 12);
5735
5736 insn = PLT0_PIC_ENTRY_WORD4;
5737 bfd_putb32 (insn, splt->contents + 16);
5738
5739 insn = PLT0_PIC_ENTRY_WORD5;
5740 bfd_putb32 (insn, splt->contents + 20);
5741 }
5742 else
5743 {
5744 unsigned long insn;
5745 unsigned long addr;
5746
5747 /* addr = .got + 4 */
5748 addr = sgot->output_section->vma + sgot->output_offset + 4;
5749 insn = PLT0_ENTRY_WORD0 | ((addr >> 12) & 0xfffff);
5750 bfd_putb32 (insn, splt->contents);
5751
5752 insn = PLT0_ENTRY_WORD1 | (addr & 0x0fff);
5753 bfd_putb32 (insn, splt->contents + 4);
5754
5755 insn = PLT0_ENTRY_WORD2;
5756 bfd_putb32 (insn, splt->contents + 8);
5757
5758 insn = PLT0_ENTRY_WORD3;
5759 bfd_putb32 (insn, splt->contents + 12);
5760
5761 insn = PLT0_ENTRY_WORD4;
5762 bfd_putb32 (insn, splt->contents + 16);
5763 }
5764
5765 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
5766 PLT_ENTRY_SIZE;
5767 }
5768 }
5769
5770 /* Fill in the first three entries in the global offset table. */
5771 if (sgot && sgot->size > 0)
5772 {
5773 if (sdyn == NULL)
5774 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5775 else
5776 bfd_put_32 (output_bfd,
5777 sdyn->output_section->vma + sdyn->output_offset,
5778 sgot->contents);
5779 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5780 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5781
5782 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
5783 }
5784
5785 return TRUE;
5786 }
5787 \f
5788
5789 /* Set the right machine number. */
5790
5791 static bfd_boolean
5792 nds32_elf_object_p (bfd *abfd)
5793 {
5794 static unsigned int cur_arch = 0;
5795
5796 if (E_N1_ARCH != (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH))
5797 {
5798 /* E_N1_ARCH is a wild card, so it is set only when no others exist. */
5799 cur_arch = (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH);
5800 }
5801
5802 switch (cur_arch)
5803 {
5804 default:
5805 case E_N1_ARCH:
5806 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1);
5807 break;
5808 case E_N1H_ARCH:
5809 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h);
5810 break;
5811 case E_NDS_ARCH_STAR_V2_0:
5812 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v2);
5813 break;
5814 case E_NDS_ARCH_STAR_V3_0:
5815 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3);
5816 break;
5817 case E_NDS_ARCH_STAR_V3_M:
5818 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3m);
5819 break;
5820 }
5821
5822 return TRUE;
5823 }
5824
5825 /* Store the machine number in the flags field. */
5826
5827 static void
5828 nds32_elf_final_write_processing (bfd *abfd,
5829 bfd_boolean linker ATTRIBUTE_UNUSED)
5830 {
5831 unsigned long val;
5832 static unsigned int cur_mach = 0;
5833
5834 if (bfd_mach_n1 != bfd_get_mach (abfd))
5835 {
5836 cur_mach = bfd_get_mach (abfd);
5837 }
5838
5839 switch (cur_mach)
5840 {
5841 case bfd_mach_n1:
5842 /* Only happen when object is empty, since the case is abandon. */
5843 val = E_N1_ARCH;
5844 val |= E_NDS_ABI_AABI;
5845 val |= E_NDS32_ELF_VER_1_4;
5846 break;
5847 case bfd_mach_n1h:
5848 val = E_N1H_ARCH;
5849 break;
5850 case bfd_mach_n1h_v2:
5851 val = E_NDS_ARCH_STAR_V2_0;
5852 break;
5853 case bfd_mach_n1h_v3:
5854 val = E_NDS_ARCH_STAR_V3_0;
5855 break;
5856 case bfd_mach_n1h_v3m:
5857 val = E_NDS_ARCH_STAR_V3_M;
5858 break;
5859 default:
5860 val = 0;
5861 break;
5862 }
5863
5864 elf_elfheader (abfd)->e_flags &= ~EF_NDS_ARCH;
5865 elf_elfheader (abfd)->e_flags |= val;
5866 }
5867
5868 /* Function to keep NDS32 specific file flags. */
5869
5870 static bfd_boolean
5871 nds32_elf_set_private_flags (bfd *abfd, flagword flags)
5872 {
5873 BFD_ASSERT (!elf_flags_init (abfd)
5874 || elf_elfheader (abfd)->e_flags == flags);
5875
5876 elf_elfheader (abfd)->e_flags = flags;
5877 elf_flags_init (abfd) = TRUE;
5878 return TRUE;
5879 }
5880
5881 static unsigned int
5882 convert_e_flags (unsigned int e_flags, unsigned int arch)
5883 {
5884 if ((e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9)
5885 {
5886 /* From 0.9 to 1.0. */
5887 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V1_0;
5888
5889 /* Invert E_NDS32_HAS_NO_MAC_INST. */
5890 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
5891 if (arch == E_NDS_ARCH_STAR_V1_0)
5892 {
5893 /* Done. */
5894 return e_flags;
5895 }
5896 }
5897
5898 /* From 1.0 to 2.0. */
5899 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V2_0;
5900
5901 /* Clear E_NDS32_HAS_MFUSR_PC_INST. */
5902 e_flags &= ~E_NDS32_HAS_MFUSR_PC_INST;
5903
5904 /* Invert E_NDS32_HAS_NO_MAC_INST. */
5905 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
5906 return e_flags;
5907 }
5908
5909 static bfd_boolean
5910 nds32_check_vec_size (bfd *ibfd)
5911 {
5912 static unsigned int nds32_vec_size = 0;
5913
5914 asection *sec_t = NULL;
5915 bfd_byte *contents = NULL;
5916
5917 sec_t = bfd_get_section_by_name (ibfd, ".nds32_e_flags");
5918
5919 if (sec_t && sec_t->size >= 4)
5920 {
5921 /* Get vec_size in file. */
5922 unsigned int flag_t;
5923
5924 nds32_get_section_contents (ibfd, sec_t, &contents, TRUE);
5925 flag_t = bfd_get_32 (ibfd, contents);
5926
5927 /* The value could only be 4 or 16. */
5928
5929 if (!nds32_vec_size)
5930 /* Set if not set yet. */
5931 nds32_vec_size = (flag_t & 0x3);
5932 else if (nds32_vec_size != (flag_t & 0x3))
5933 {
5934 _bfd_error_handler
5935 /* xgettext:c-format */
5936 (_("%B: ISR vector size mismatch"
5937 " with previous modules, previous %u-byte, current %u-byte"),
5938 ibfd,
5939 nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
5940 (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
5941 return FALSE;
5942 }
5943 else
5944 /* Only keep the first vec_size section. */
5945 sec_t->flags |= SEC_EXCLUDE;
5946 }
5947
5948 return TRUE;
5949 }
5950
5951 /* Merge backend specific data from an object file to the output
5952 object file when linking. */
5953
5954 static bfd_boolean
5955 nds32_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
5956 {
5957 bfd *obfd = info->output_bfd;
5958 flagword out_flags;
5959 flagword in_flags;
5960 flagword out_16regs;
5961 flagword in_no_mac;
5962 flagword out_no_mac;
5963 flagword in_16regs;
5964 flagword out_version;
5965 flagword in_version;
5966 flagword out_fpu_config;
5967 flagword in_fpu_config;
5968
5969 /* TODO: Revise to use object-attributes instead. */
5970 if (!nds32_check_vec_size (ibfd))
5971 return FALSE;
5972
5973 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5974 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5975 return TRUE;
5976
5977 if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
5978 {
5979 _bfd_error_handler
5980 (_("%B: warning: Endian mismatch with previous modules."), ibfd);
5981
5982 bfd_set_error (bfd_error_bad_value);
5983 return FALSE;
5984 }
5985
5986 in_version = elf_elfheader (ibfd)->e_flags & EF_NDS32_ELF_VERSION;
5987 if (in_version == E_NDS32_ELF_VER_1_2)
5988 {
5989 _bfd_error_handler
5990 (_("%B: warning: Older version of object file encountered, "
5991 "Please recompile with current tool chain."), ibfd);
5992 }
5993
5994 /* We may need to merge V1 and V2 arch object files to V2. */
5995 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
5996 != (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
5997 {
5998 /* Need to convert version. */
5999 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6000 == E_NDS_ARCH_STAR_RESERVED)
6001 {
6002 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6003 }
6004 else if ((elf_elfheader (obfd)->e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9
6005 || (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6006 > (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6007 {
6008 elf_elfheader (obfd)->e_flags =
6009 convert_e_flags (elf_elfheader (obfd)->e_flags,
6010 (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH));
6011 }
6012 else
6013 {
6014 elf_elfheader (ibfd)->e_flags =
6015 convert_e_flags (elf_elfheader (ibfd)->e_flags,
6016 (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH));
6017 }
6018 }
6019
6020 /* Extract some flags. */
6021 in_flags = elf_elfheader (ibfd)->e_flags
6022 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6023 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6024
6025 /* The following flags need special treatment. */
6026 in_16regs = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6027 in_no_mac = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6028 in_fpu_config = elf_elfheader (ibfd)->e_flags & E_NDS32_FPU_REG_CONF;
6029
6030 /* Extract some flags. */
6031 out_flags = elf_elfheader (obfd)->e_flags
6032 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6033 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6034
6035 /* The following flags need special treatment. */
6036 out_16regs = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6037 out_no_mac = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6038 out_fpu_config = elf_elfheader (obfd)->e_flags & E_NDS32_FPU_REG_CONF;
6039 out_version = elf_elfheader (obfd)->e_flags & EF_NDS32_ELF_VERSION;
6040 if (!elf_flags_init (obfd))
6041 {
6042 /* If the input is the default architecture then do not
6043 bother setting the flags for the output architecture,
6044 instead allow future merges to do this. If no future
6045 merges ever set these flags then they will retain their
6046 unitialised values, which surprise surprise, correspond
6047 to the default values. */
6048 if (bfd_get_arch_info (ibfd)->the_default)
6049 return TRUE;
6050
6051 elf_flags_init (obfd) = TRUE;
6052 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6053
6054 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
6055 && bfd_get_arch_info (obfd)->the_default)
6056 {
6057 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
6058 bfd_get_mach (ibfd));
6059 }
6060
6061 return TRUE;
6062 }
6063
6064 /* Check flag compatibility. */
6065 if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
6066 {
6067 _bfd_error_handler
6068 (_("%B: error: ABI mismatch with previous modules."), ibfd);
6069
6070 bfd_set_error (bfd_error_bad_value);
6071 return FALSE;
6072 }
6073
6074 if ((in_flags & EF_NDS_ARCH) != (out_flags & EF_NDS_ARCH))
6075 {
6076 if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
6077 {
6078 _bfd_error_handler
6079 (_("%B: error: Instruction set mismatch with previous modules."), ibfd);
6080
6081 bfd_set_error (bfd_error_bad_value);
6082 return FALSE;
6083 }
6084 }
6085
6086 /* When linking with V1.2 and V1.3 objects together the output is V1.2.
6087 and perf ext1 and DIV are mergerd to perf ext1. */
6088 if (in_version == E_NDS32_ELF_VER_1_2 || out_version == E_NDS32_ELF_VER_1_2)
6089 {
6090 elf_elfheader (obfd)->e_flags =
6091 (in_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6092 | (out_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6093 | (((in_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6094 ? E_NDS32_HAS_EXT_INST : 0)
6095 | (((out_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6096 ? E_NDS32_HAS_EXT_INST : 0)
6097 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6098 | ((in_version > out_version) ? out_version : in_version);
6099 }
6100 else
6101 {
6102 if (in_version != out_version)
6103 _bfd_error_handler
6104 /* xgettext:c-format */
6105 (_("%B: warning: Incompatible elf-versions %s and %s."),
6106 ibfd, nds32_elfver_strtab[out_version],
6107 nds32_elfver_strtab[in_version]);
6108
6109 elf_elfheader (obfd)->e_flags = in_flags | out_flags
6110 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6111 | (in_fpu_config > out_fpu_config ? in_fpu_config : out_fpu_config)
6112 | (in_version > out_version ? out_version : in_version);
6113 }
6114
6115 return TRUE;
6116 }
6117
6118 /* Display the flags field. */
6119
6120 static bfd_boolean
6121 nds32_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6122 {
6123 FILE *file = (FILE *) ptr;
6124
6125 BFD_ASSERT (abfd != NULL && ptr != NULL);
6126
6127 _bfd_elf_print_private_bfd_data (abfd, ptr);
6128
6129 fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
6130
6131 switch (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH)
6132 {
6133 default:
6134 case E_N1_ARCH:
6135 fprintf (file, _(": n1 instructions"));
6136 break;
6137 case E_N1H_ARCH:
6138 fprintf (file, _(": n1h instructions"));
6139 break;
6140 }
6141
6142 fputc ('\n', file);
6143
6144 return TRUE;
6145 }
6146
6147 static unsigned int
6148 nds32_elf_action_discarded (asection *sec)
6149 {
6150
6151 if (strncmp
6152 (".gcc_except_table", sec->name, sizeof (".gcc_except_table") - 1) == 0)
6153 return 0;
6154
6155 return _bfd_elf_default_action_discarded (sec);
6156 }
6157
6158 static asection *
6159 nds32_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info,
6160 Elf_Internal_Rela *rel, struct elf_link_hash_entry *h,
6161 Elf_Internal_Sym *sym)
6162 {
6163 if (h != NULL)
6164 switch (ELF32_R_TYPE (rel->r_info))
6165 {
6166 case R_NDS32_GNU_VTINHERIT:
6167 case R_NDS32_GNU_VTENTRY:
6168 case R_NDS32_RELA_GNU_VTINHERIT:
6169 case R_NDS32_RELA_GNU_VTENTRY:
6170 return NULL;
6171 }
6172
6173 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6174 }
6175
6176 static bfd_boolean
6177 nds32_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info, asection *sec,
6178 const Elf_Internal_Rela *relocs)
6179 {
6180 /* Update the got entry reference counts for the section being removed. */
6181 Elf_Internal_Shdr *symtab_hdr;
6182 struct elf_link_hash_entry **sym_hashes;
6183 bfd_signed_vma *local_got_refcounts;
6184 const Elf_Internal_Rela *rel, *relend;
6185
6186 elf_section_data (sec)->local_dynrel = NULL;
6187
6188 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6189 sym_hashes = elf_sym_hashes (abfd);
6190 local_got_refcounts = elf_local_got_refcounts (abfd);
6191
6192 relend = relocs + sec->reloc_count;
6193 for (rel = relocs; rel < relend; rel++)
6194 {
6195 unsigned long r_symndx;
6196 struct elf_link_hash_entry *h = NULL;
6197
6198 r_symndx = ELF32_R_SYM (rel->r_info);
6199 if (r_symndx >= symtab_hdr->sh_info)
6200 {
6201 /* External symbol. */
6202 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6203 while (h->root.type == bfd_link_hash_indirect
6204 || h->root.type == bfd_link_hash_warning)
6205 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6206 }
6207
6208 switch (ELF32_R_TYPE (rel->r_info))
6209 {
6210 case R_NDS32_GOT_HI20:
6211 case R_NDS32_GOT_LO12:
6212 case R_NDS32_GOT_LO15:
6213 case R_NDS32_GOT_LO19:
6214 case R_NDS32_GOT17S2_RELA:
6215 case R_NDS32_GOT15S2_RELA:
6216 case R_NDS32_GOTOFF:
6217 case R_NDS32_GOTOFF_HI20:
6218 case R_NDS32_GOTOFF_LO12:
6219 case R_NDS32_GOTOFF_LO15:
6220 case R_NDS32_GOTOFF_LO19:
6221 case R_NDS32_GOT20:
6222 case R_NDS32_GOTPC_HI20:
6223 case R_NDS32_GOTPC_LO12:
6224 case R_NDS32_GOTPC20:
6225 if (h != NULL)
6226 {
6227 if (h->got.refcount > 0)
6228 h->got.refcount--;
6229 }
6230 else
6231 {
6232 if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
6233 local_got_refcounts[r_symndx]--;
6234 }
6235 break;
6236
6237 case R_NDS32_16_RELA:
6238 case R_NDS32_20_RELA:
6239 case R_NDS32_5_RELA:
6240 case R_NDS32_32_RELA:
6241 case R_NDS32_HI20_RELA:
6242 case R_NDS32_LO12S3_RELA:
6243 case R_NDS32_LO12S2_RELA:
6244 case R_NDS32_LO12S2_DP_RELA:
6245 case R_NDS32_LO12S2_SP_RELA:
6246 case R_NDS32_LO12S1_RELA:
6247 case R_NDS32_LO12S0_RELA:
6248 case R_NDS32_LO12S0_ORI_RELA:
6249 case R_NDS32_SDA16S3_RELA:
6250 case R_NDS32_SDA17S2_RELA:
6251 case R_NDS32_SDA18S1_RELA:
6252 case R_NDS32_SDA19S0_RELA:
6253 case R_NDS32_SDA15S3_RELA:
6254 case R_NDS32_SDA15S2_RELA:
6255 case R_NDS32_SDA12S2_DP_RELA:
6256 case R_NDS32_SDA12S2_SP_RELA:
6257 case R_NDS32_SDA15S1_RELA:
6258 case R_NDS32_SDA15S0_RELA:
6259 case R_NDS32_SDA_FP7U2_RELA:
6260 case R_NDS32_15_PCREL_RELA:
6261 case R_NDS32_17_PCREL_RELA:
6262 case R_NDS32_25_PCREL_RELA:
6263 if (h != NULL)
6264 {
6265 struct elf_nds32_link_hash_entry *eh;
6266 struct elf_nds32_dyn_relocs **pp;
6267 struct elf_nds32_dyn_relocs *p;
6268
6269 if (!bfd_link_pic (info) && h->plt.refcount > 0)
6270 h->plt.refcount -= 1;
6271
6272 eh = (struct elf_nds32_link_hash_entry *) h;
6273
6274 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6275 if (p->sec == sec)
6276 {
6277 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
6278 || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA
6279 || ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA)
6280 p->pc_count -= 1;
6281 p->count -= 1;
6282 if (p->count == 0)
6283 *pp = p->next;
6284 break;
6285 }
6286 }
6287 break;
6288
6289 case R_NDS32_9_PLTREL:
6290 case R_NDS32_25_PLTREL:
6291 if (h != NULL)
6292 {
6293 if (h->plt.refcount > 0)
6294 h->plt.refcount--;
6295 }
6296 break;
6297
6298 default:
6299 break;
6300 }
6301 }
6302
6303 return TRUE;
6304 }
6305
6306 /* Look through the relocs for a section during the first phase.
6307 Since we don't do .gots or .plts, we just need to consider the
6308 virtual table relocs for gc. */
6309
6310 static bfd_boolean
6311 nds32_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
6312 asection *sec, const Elf_Internal_Rela *relocs)
6313 {
6314 Elf_Internal_Shdr *symtab_hdr;
6315 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6316 const Elf_Internal_Rela *rel;
6317 const Elf_Internal_Rela *rel_end;
6318 struct elf_nds32_link_hash_table *htab;
6319 bfd *dynobj;
6320 asection *sreloc = NULL;
6321
6322 if (bfd_link_relocatable (info))
6323 return TRUE;
6324
6325 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6326 sym_hashes = elf_sym_hashes (abfd);
6327 sym_hashes_end =
6328 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
6329 if (!elf_bad_symtab (abfd))
6330 sym_hashes_end -= symtab_hdr->sh_info;
6331
6332 htab = nds32_elf_hash_table (info);
6333 dynobj = htab->root.dynobj;
6334
6335 rel_end = relocs + sec->reloc_count;
6336 for (rel = relocs; rel < rel_end; rel++)
6337 {
6338 enum elf_nds32_reloc_type r_type;
6339 struct elf_link_hash_entry *h;
6340 unsigned long r_symndx;
6341 int tls_type, old_tls_type;
6342
6343 r_symndx = ELF32_R_SYM (rel->r_info);
6344 r_type = ELF32_R_TYPE (rel->r_info);
6345 if (r_symndx < symtab_hdr->sh_info)
6346 h = NULL;
6347 else
6348 {
6349 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6350 while (h->root.type == bfd_link_hash_indirect
6351 || h->root.type == bfd_link_hash_warning)
6352 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6353 }
6354
6355 /* Some relocs require a global offset table. We create
6356 got section here, since these relocation need got section
6357 and it is not created yet. */
6358 if (htab->root.sgot == NULL)
6359 {
6360 switch (r_type)
6361 {
6362 case R_NDS32_GOT_HI20:
6363 case R_NDS32_GOT_LO12:
6364 case R_NDS32_GOT_LO15:
6365 case R_NDS32_GOT_LO19:
6366 case R_NDS32_GOT17S2_RELA:
6367 case R_NDS32_GOT15S2_RELA:
6368 case R_NDS32_GOTOFF:
6369 case R_NDS32_GOTOFF_HI20:
6370 case R_NDS32_GOTOFF_LO12:
6371 case R_NDS32_GOTOFF_LO15:
6372 case R_NDS32_GOTOFF_LO19:
6373 case R_NDS32_GOTPC20:
6374 case R_NDS32_GOTPC_HI20:
6375 case R_NDS32_GOTPC_LO12:
6376 case R_NDS32_GOT20:
6377 case R_NDS32_TLS_IE_HI20:
6378 case R_NDS32_TLS_IE_LO12S2:
6379 if (dynobj == NULL)
6380 htab->root.dynobj = dynobj = abfd;
6381 if (!_bfd_elf_create_got_section (dynobj, info))
6382 return FALSE;
6383 break;
6384
6385 default:
6386 break;
6387 }
6388 }
6389
6390 switch ((int) r_type)
6391 {
6392 case R_NDS32_GOT_HI20:
6393 case R_NDS32_GOT_LO12:
6394 case R_NDS32_GOT_LO15:
6395 case R_NDS32_GOT_LO19:
6396 case R_NDS32_GOT20:
6397 case R_NDS32_TLS_IE_HI20:
6398 case R_NDS32_TLS_IE_LO12S2:
6399 switch (r_type)
6400 {
6401 case R_NDS32_TLS_IE_HI20:
6402 case R_NDS32_TLS_IE_LO12S2:
6403 tls_type = GOT_TLS_IE;
6404 break;
6405 default:
6406 tls_type = GOT_NORMAL;
6407 break;
6408 }
6409 if (h != NULL)
6410 {
6411 old_tls_type = elf32_nds32_hash_entry (h)->tls_type;
6412 h->got.refcount += 1;
6413 }
6414 else
6415 {
6416 bfd_signed_vma *local_got_refcounts;
6417
6418 /* This is a global offset table entry for a local
6419 symbol. */
6420 local_got_refcounts = elf_local_got_refcounts (abfd);
6421 if (local_got_refcounts == NULL)
6422 {
6423 bfd_size_type size;
6424
6425 size = symtab_hdr->sh_info;
6426 size *= sizeof (bfd_signed_vma);
6427 local_got_refcounts = (bfd_signed_vma *) bfd_zalloc (abfd, size);
6428 if (local_got_refcounts == NULL)
6429 return FALSE;
6430 elf_local_got_refcounts (abfd) = local_got_refcounts;
6431 }
6432 local_got_refcounts[r_symndx] += 1;
6433 old_tls_type = elf32_nds32_local_got_tls_type (abfd)[r_symndx];
6434 }
6435
6436 /* We will already have issued an error message if there
6437 is a TLS/non-TLS mismatch, based on the symbol
6438 type. So just combine any TLS types needed. */
6439 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
6440 && tls_type != GOT_NORMAL)
6441 tls_type |= old_tls_type;
6442
6443 if (old_tls_type != tls_type)
6444 {
6445 if (h != NULL)
6446 elf32_nds32_hash_entry (h)->tls_type = tls_type;
6447 else
6448 elf32_nds32_local_got_tls_type (abfd)[r_symndx] = tls_type;
6449 }
6450 break;
6451 case R_NDS32_9_PLTREL:
6452 case R_NDS32_25_PLTREL:
6453 case R_NDS32_PLTREL_HI20:
6454 case R_NDS32_PLTREL_LO12:
6455 case R_NDS32_PLT_GOTREL_HI20:
6456 case R_NDS32_PLT_GOTREL_LO12:
6457 case R_NDS32_PLT_GOTREL_LO15:
6458 case R_NDS32_PLT_GOTREL_LO19:
6459 case R_NDS32_PLT_GOTREL_LO20:
6460
6461 /* This symbol requires a procedure linkage table entry. We
6462 actually build the entry in adjust_dynamic_symbol,
6463 because this might be a case of linking PIC code without
6464 linking in any dynamic objects, in which case we don't
6465 need to generate a procedure linkage table after all. */
6466
6467 /* If this is a local symbol, we resolve it directly without
6468 creating a procedure linkage table entry. */
6469 if (h == NULL)
6470 continue;
6471
6472 if (h->forced_local)
6473 break;
6474
6475 elf32_nds32_hash_entry (h)->tls_type = GOT_NORMAL;
6476 h->needs_plt = 1;
6477 h->plt.refcount += 1;
6478 break;
6479
6480 case R_NDS32_16_RELA:
6481 case R_NDS32_20_RELA:
6482 case R_NDS32_5_RELA:
6483 case R_NDS32_32_RELA:
6484 case R_NDS32_HI20_RELA:
6485 case R_NDS32_LO12S3_RELA:
6486 case R_NDS32_LO12S2_RELA:
6487 case R_NDS32_LO12S2_DP_RELA:
6488 case R_NDS32_LO12S2_SP_RELA:
6489 case R_NDS32_LO12S1_RELA:
6490 case R_NDS32_LO12S0_RELA:
6491 case R_NDS32_LO12S0_ORI_RELA:
6492 case R_NDS32_SDA16S3_RELA:
6493 case R_NDS32_SDA17S2_RELA:
6494 case R_NDS32_SDA18S1_RELA:
6495 case R_NDS32_SDA19S0_RELA:
6496 case R_NDS32_SDA15S3_RELA:
6497 case R_NDS32_SDA15S2_RELA:
6498 case R_NDS32_SDA12S2_DP_RELA:
6499 case R_NDS32_SDA12S2_SP_RELA:
6500 case R_NDS32_SDA15S1_RELA:
6501 case R_NDS32_SDA15S0_RELA:
6502 case R_NDS32_SDA_FP7U2_RELA:
6503 case R_NDS32_15_PCREL_RELA:
6504 case R_NDS32_17_PCREL_RELA:
6505 case R_NDS32_25_PCREL_RELA:
6506
6507 if (h != NULL && !bfd_link_pic (info))
6508 {
6509 h->non_got_ref = 1;
6510 h->plt.refcount += 1;
6511 }
6512
6513 /* If we are creating a shared library, and this is a reloc against
6514 a global symbol, or a non PC relative reloc against a local
6515 symbol, then we need to copy the reloc into the shared library.
6516 However, if we are linking with -Bsymbolic, we do not need to
6517 copy a reloc against a global symbol which is defined in an
6518 object we are including in the link (i.e., DEF_REGULAR is set).
6519 At this point we have not seen all the input files, so it is
6520 possible that DEF_REGULAR is not set now but will be set later
6521 (it is never cleared). We account for that possibility below by
6522 storing information in the dyn_relocs field of the hash table
6523 entry. A similar situation occurs when creating shared libraries
6524 and symbol visibility changes render the symbol local.
6525
6526 If on the other hand, we are creating an executable, we may need
6527 to keep relocations for symbols satisfied by a dynamic library
6528 if we manage to avoid copy relocs for the symbol. */
6529 if ((bfd_link_pic (info)
6530 && (sec->flags & SEC_ALLOC) != 0
6531 && ((r_type != R_NDS32_25_PCREL_RELA
6532 && r_type != R_NDS32_15_PCREL_RELA
6533 && r_type != R_NDS32_17_PCREL_RELA
6534 && !(r_type == R_NDS32_32_RELA
6535 && strcmp (sec->name, ".eh_frame") == 0))
6536 || (h != NULL
6537 && (!info->symbolic
6538 || h->root.type == bfd_link_hash_defweak
6539 || !h->def_regular))))
6540 || (!bfd_link_pic (info)
6541 && (sec->flags & SEC_ALLOC) != 0
6542 && h != NULL
6543 && (h->root.type == bfd_link_hash_defweak
6544 || !h->def_regular)))
6545 {
6546 struct elf_nds32_dyn_relocs *p;
6547 struct elf_nds32_dyn_relocs **head;
6548
6549 if (dynobj == NULL)
6550 htab->root.dynobj = dynobj = abfd;
6551
6552 /* When creating a shared object, we must copy these
6553 relocs into the output file. We create a reloc
6554 section in dynobj and make room for the reloc. */
6555 if (sreloc == NULL)
6556 {
6557 const char *name;
6558
6559 name = bfd_elf_string_from_elf_section
6560 (abfd, elf_elfheader (abfd)->e_shstrndx,
6561 elf_section_data (sec)->rela.hdr->sh_name);
6562 if (name == NULL)
6563 return FALSE;
6564
6565 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6566 && strcmp (bfd_get_section_name (abfd, sec),
6567 name + 5) == 0);
6568
6569 sreloc = bfd_get_section_by_name (dynobj, name);
6570 if (sreloc == NULL)
6571 {
6572 flagword flags;
6573
6574 sreloc = bfd_make_section (dynobj, name);
6575 flags = (SEC_HAS_CONTENTS | SEC_READONLY
6576 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6577 if ((sec->flags & SEC_ALLOC) != 0)
6578 flags |= SEC_ALLOC | SEC_LOAD;
6579 if (sreloc == NULL
6580 || !bfd_set_section_flags (dynobj, sreloc, flags)
6581 || !bfd_set_section_alignment (dynobj, sreloc, 2))
6582 return FALSE;
6583
6584 elf_section_type (sreloc) = SHT_RELA;
6585 }
6586 elf_section_data (sec)->sreloc = sreloc;
6587 }
6588
6589 /* If this is a global symbol, we count the number of
6590 relocations we need for this symbol. */
6591 if (h != NULL)
6592 head = &((struct elf_nds32_link_hash_entry *) h)->dyn_relocs;
6593 else
6594 {
6595 asection *s;
6596 void *vpp;
6597
6598 Elf_Internal_Sym *isym;
6599 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
6600 if (isym == NULL)
6601 return FALSE;
6602
6603 /* Track dynamic relocs needed for local syms too. */
6604 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6605 if (s == NULL)
6606 return FALSE;
6607
6608 vpp = &elf_section_data (s)->local_dynrel;
6609 head = (struct elf_nds32_dyn_relocs **) vpp;
6610 }
6611
6612 p = *head;
6613 if (p == NULL || p->sec != sec)
6614 {
6615 bfd_size_type amt = sizeof (*p);
6616 p = (struct elf_nds32_dyn_relocs *) bfd_alloc (dynobj, amt);
6617 if (p == NULL)
6618 return FALSE;
6619 p->next = *head;
6620 *head = p;
6621 p->sec = sec;
6622 p->count = 0;
6623 p->pc_count = 0;
6624 }
6625
6626 p->count += 1;
6627 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA
6628 || ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
6629 || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA)
6630 p->pc_count += 1;
6631 }
6632 break;
6633
6634 /* This relocation describes the C++ object vtable hierarchy.
6635 Reconstruct it for later use during GC. */
6636 case R_NDS32_RELA_GNU_VTINHERIT:
6637 case R_NDS32_GNU_VTINHERIT:
6638 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6639 return FALSE;
6640 break;
6641
6642 /* This relocation describes which C++ vtable entries are actually
6643 used. Record for later use during GC. */
6644 case R_NDS32_GNU_VTENTRY:
6645 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6646 return FALSE;
6647 break;
6648 case R_NDS32_RELA_GNU_VTENTRY:
6649 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6650 return FALSE;
6651 break;
6652 }
6653 }
6654
6655 return TRUE;
6656 }
6657
6658 /* Write VAL in uleb128 format to P, returning a pointer to the
6659 following byte.
6660 This code is copied from elf-attr.c. */
6661
6662 static bfd_byte *
6663 write_uleb128 (bfd_byte *p, unsigned int val)
6664 {
6665 bfd_byte c;
6666 do
6667 {
6668 c = val & 0x7f;
6669 val >>= 7;
6670 if (val)
6671 c |= 0x80;
6672 *(p++) = c;
6673 }
6674 while (val);
6675 return p;
6676 }
6677
6678 static bfd_signed_vma
6679 calculate_offset (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
6680 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr,
6681 int *pic_ext_target)
6682 {
6683 bfd_signed_vma foff;
6684 bfd_vma symval, addend;
6685 asection *sym_sec;
6686
6687 /* Get the value of the symbol referred to by the reloc. */
6688 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6689 {
6690 Elf_Internal_Sym *isym;
6691
6692 /* A local symbol. */
6693 isym = isymbuf + ELF32_R_SYM (irel->r_info);
6694
6695 if (isym->st_shndx == SHN_UNDEF)
6696 sym_sec = bfd_und_section_ptr;
6697 else if (isym->st_shndx == SHN_ABS)
6698 sym_sec = bfd_abs_section_ptr;
6699 else if (isym->st_shndx == SHN_COMMON)
6700 sym_sec = bfd_com_section_ptr;
6701 else
6702 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6703 symval = isym->st_value + sym_sec->output_section->vma
6704 + sym_sec->output_offset;
6705 }
6706 else
6707 {
6708 unsigned long indx;
6709 struct elf_link_hash_entry *h;
6710 bfd *owner;
6711
6712 /* An external symbol. */
6713 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6714 h = elf_sym_hashes (abfd)[indx];
6715 BFD_ASSERT (h != NULL);
6716
6717 if (h->root.type != bfd_link_hash_defined
6718 && h->root.type != bfd_link_hash_defweak)
6719 /* This appears to be a reference to an undefined
6720 symbol. Just ignore it--it will be caught by the
6721 regular reloc processing. */
6722 return 0;
6723 owner = h->root.u.def.section->owner;
6724 if (owner && (elf_elfheader (owner)->e_flags & E_NDS32_HAS_PIC))
6725 *pic_ext_target = 1;
6726
6727 if (h->root.u.def.section->flags & SEC_MERGE)
6728 {
6729 sym_sec = h->root.u.def.section;
6730 symval = _bfd_merged_section_offset (abfd, &sym_sec,
6731 elf_section_data (sym_sec)->sec_info,
6732 h->root.u.def.value);
6733 symval = symval + sym_sec->output_section->vma
6734 + sym_sec->output_offset;
6735 }
6736 else
6737 symval = (h->root.u.def.value
6738 + h->root.u.def.section->output_section->vma
6739 + h->root.u.def.section->output_offset);
6740 }
6741
6742 addend = irel->r_addend;
6743
6744 foff = (symval + addend
6745 - (irel->r_offset + sec->output_section->vma + sec->output_offset));
6746 return foff;
6747 }
6748
6749 static bfd_vma
6750 calculate_plt_memory_address (bfd *abfd, struct bfd_link_info *link_info,
6751 Elf_Internal_Sym *isymbuf,
6752 Elf_Internal_Rela *irel,
6753 Elf_Internal_Shdr *symtab_hdr)
6754 {
6755 bfd_vma symval;
6756
6757 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6758 {
6759 Elf_Internal_Sym *isym;
6760 asection *sym_sec;
6761 /* A local symbol. */
6762 isym = isymbuf + ELF32_R_SYM (irel->r_info);
6763
6764 if (isym->st_shndx == SHN_UNDEF)
6765 sym_sec = bfd_und_section_ptr;
6766 else if (isym->st_shndx == SHN_ABS)
6767 sym_sec = bfd_abs_section_ptr;
6768 else if (isym->st_shndx == SHN_COMMON)
6769 sym_sec = bfd_com_section_ptr;
6770 else
6771 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6772 symval = isym->st_value + sym_sec->output_section->vma
6773 + sym_sec->output_offset;
6774 }
6775 else
6776 {
6777 unsigned long indx;
6778 struct elf_link_hash_entry *h;
6779 struct elf_nds32_link_hash_table *htab;
6780 asection *splt;
6781
6782 /* An external symbol. */
6783 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6784 h = elf_sym_hashes (abfd)[indx];
6785 BFD_ASSERT (h != NULL);
6786 htab = nds32_elf_hash_table (link_info);
6787 splt = htab->root.splt;
6788
6789 while (h->root.type == bfd_link_hash_indirect
6790 || h->root.type == bfd_link_hash_warning)
6791 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6792
6793 if (h->plt.offset == (bfd_vma) - 1)
6794 {
6795 if (h->root.type != bfd_link_hash_defined
6796 && h->root.type != bfd_link_hash_defweak)
6797 /* This appears to be a reference to an undefined
6798 * symbol. Just ignore it--it will be caught by the
6799 * regular reloc processing. */
6800 return 0;
6801 symval = (h->root.u.def.value
6802 + h->root.u.def.section->output_section->vma
6803 + h->root.u.def.section->output_offset);
6804 }
6805 else
6806 symval = splt->output_section->vma + h->plt.offset;
6807 }
6808
6809 return symval;
6810 }
6811
6812 static bfd_signed_vma
6813 calculate_plt_offset (bfd *abfd, asection *sec, struct bfd_link_info *link_info,
6814 Elf_Internal_Sym *isymbuf, Elf_Internal_Rela *irel,
6815 Elf_Internal_Shdr *symtab_hdr)
6816 {
6817 bfd_vma foff;
6818 if ((foff = calculate_plt_memory_address (abfd, link_info, isymbuf, irel,
6819 symtab_hdr)) == 0)
6820 return 0;
6821 else
6822 return foff - (irel->r_offset
6823 + sec->output_section->vma + sec->output_offset);
6824 }
6825 \f
6826 /* Convert a 32-bit instruction to 16-bit one.
6827 INSN is the input 32-bit instruction, INSN16 is the output 16-bit
6828 instruction. If INSN_TYPE is not NULL, it the CGEN instruction
6829 type of INSN16. Return 1 if successful. */
6830
6831 static int
6832 nds32_convert_32_to_16_alu1 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
6833 int *pinsn_type)
6834 {
6835 uint16_t insn16 = 0;
6836 int insn_type = 0;
6837 unsigned long mach = bfd_get_mach (abfd);
6838
6839 if (N32_SH5 (insn) != 0)
6840 return 0;
6841
6842 switch (N32_SUB5 (insn))
6843 {
6844 case N32_ALU1_ADD_SLLI:
6845 case N32_ALU1_ADD_SRLI:
6846 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
6847 {
6848 insn16 = N16_TYPE333 (ADD333, N32_RT5 (insn), N32_RA5 (insn),
6849 N32_RB5 (insn));
6850 insn_type = NDS32_INSN_ADD333;
6851 }
6852 else if (N32_IS_RT4 (insn))
6853 {
6854 if (N32_RT5 (insn) == N32_RA5 (insn))
6855 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RB5 (insn));
6856 else if (N32_RT5 (insn) == N32_RB5 (insn))
6857 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RA5 (insn));
6858 insn_type = NDS32_INSN_ADD45;
6859 }
6860 break;
6861
6862 case N32_ALU1_SUB_SLLI:
6863 case N32_ALU1_SUB_SRLI:
6864 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
6865 {
6866 insn16 = N16_TYPE333 (SUB333, N32_RT5 (insn), N32_RA5 (insn),
6867 N32_RB5 (insn));
6868 insn_type = NDS32_INSN_SUB333;
6869 }
6870 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6871 {
6872 insn16 = N16_TYPE45 (SUB45, N32_RT54 (insn), N32_RB5 (insn));
6873 insn_type = NDS32_INSN_SUB45;
6874 }
6875 break;
6876
6877 case N32_ALU1_AND_SLLI:
6878 case N32_ALU1_AND_SRLI:
6879 /* and $rt, $rt, $rb -> and33 for v3, v3m. */
6880 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6881 && N32_IS_RB3 (insn))
6882 {
6883 if (N32_RT5 (insn) == N32_RA5 (insn))
6884 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RB5 (insn));
6885 else if (N32_RT5 (insn) == N32_RB5 (insn))
6886 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RA5 (insn));
6887 if (insn16)
6888 insn_type = NDS32_INSN_AND33;
6889 }
6890 break;
6891
6892 case N32_ALU1_XOR_SLLI:
6893 case N32_ALU1_XOR_SRLI:
6894 /* xor $rt, $rt, $rb -> xor33 for v3, v3m. */
6895 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6896 && N32_IS_RB3 (insn))
6897 {
6898 if (N32_RT5 (insn) == N32_RA5 (insn))
6899 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RB5 (insn));
6900 else if (N32_RT5 (insn) == N32_RB5 (insn))
6901 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RA5 (insn));
6902 if (insn16)
6903 insn_type = NDS32_INSN_XOR33;
6904 }
6905 break;
6906
6907 case N32_ALU1_OR_SLLI:
6908 case N32_ALU1_OR_SRLI:
6909 /* or $rt, $rt, $rb -> or33 for v3, v3m. */
6910 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6911 && N32_IS_RB3 (insn))
6912 {
6913 if (N32_RT5 (insn) == N32_RA5 (insn))
6914 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RB5 (insn));
6915 else if (N32_RT5 (insn) == N32_RB5 (insn))
6916 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RA5 (insn));
6917 if (insn16)
6918 insn_type = NDS32_INSN_OR33;
6919 }
6920 break;
6921 case N32_ALU1_NOR:
6922 /* nor $rt, $ra, $ra -> not33 for v3, v3m. */
6923 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RB3 (insn)
6924 && N32_RA5 (insn) == N32_RB5 (insn))
6925 {
6926 insn16 = N16_MISC33 (NOT33, N32_RT5 (insn), N32_RA5 (insn));
6927 insn_type = NDS32_INSN_NOT33;
6928 }
6929 break;
6930 case N32_ALU1_SRAI:
6931 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6932 {
6933 insn16 = N16_TYPE45 (SRAI45, N32_RT54 (insn), N32_UB5 (insn));
6934 insn_type = NDS32_INSN_SRAI45;
6935 }
6936 break;
6937
6938 case N32_ALU1_SRLI:
6939 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6940 {
6941 insn16 = N16_TYPE45 (SRLI45, N32_RT54 (insn), N32_UB5 (insn));
6942 insn_type = NDS32_INSN_SRLI45;
6943 }
6944 break;
6945
6946 case N32_ALU1_SLLI:
6947 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_UB5 (insn) < 8)
6948 {
6949 insn16 = N16_TYPE333 (SLLI333, N32_RT5 (insn), N32_RA5 (insn),
6950 N32_UB5 (insn));
6951 insn_type = NDS32_INSN_SLLI333;
6952 }
6953 break;
6954
6955 case N32_ALU1_ZEH:
6956 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6957 {
6958 insn16 = N16_BFMI333 (ZEH33, N32_RT5 (insn), N32_RA5 (insn));
6959 insn_type = NDS32_INSN_ZEH33;
6960 }
6961 break;
6962
6963 case N32_ALU1_SEB:
6964 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6965 {
6966 insn16 = N16_BFMI333 (SEB33, N32_RT5 (insn), N32_RA5 (insn));
6967 insn_type = NDS32_INSN_SEB33;
6968 }
6969 break;
6970
6971 case N32_ALU1_SEH:
6972 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6973 {
6974 insn16 = N16_BFMI333 (SEH33, N32_RT5 (insn), N32_RA5 (insn));
6975 insn_type = NDS32_INSN_SEH33;
6976 }
6977 break;
6978
6979 case N32_ALU1_SLT:
6980 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
6981 {
6982 /* Implicit r15. */
6983 insn16 = N16_TYPE45 (SLT45, N32_RA54 (insn), N32_RB5 (insn));
6984 insn_type = NDS32_INSN_SLT45;
6985 }
6986 break;
6987
6988 case N32_ALU1_SLTS:
6989 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
6990 {
6991 /* Implicit r15. */
6992 insn16 = N16_TYPE45 (SLTS45, N32_RA54 (insn), N32_RB5 (insn));
6993 insn_type = NDS32_INSN_SLTS45;
6994 }
6995 break;
6996 }
6997
6998 if ((insn16 & 0x8000) == 0)
6999 return 0;
7000
7001 if (pinsn16)
7002 *pinsn16 = insn16;
7003 if (pinsn_type)
7004 *pinsn_type = insn_type;
7005 return 1;
7006 }
7007
7008 static int
7009 nds32_convert_32_to_16_alu2 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7010 int *pinsn_type)
7011 {
7012 uint16_t insn16 = 0;
7013 int insn_type;
7014 unsigned long mach = bfd_get_mach (abfd);
7015
7016 /* TODO: bset, bclr, btgl, btst. */
7017 if (__GF (insn, 6, 4) != 0)
7018 return 0;
7019
7020 switch (N32_IMMU (insn, 6))
7021 {
7022 case N32_ALU2_MUL:
7023 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7024 && N32_IS_RB3 (insn))
7025 {
7026 if (N32_RT5 (insn) == N32_RA5 (insn))
7027 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RB5 (insn));
7028 else if (N32_RT5 (insn) == N32_RB5 (insn))
7029 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RA5 (insn));
7030 if (insn16)
7031 insn_type = NDS32_INSN_MUL33;
7032 }
7033 }
7034
7035 if ((insn16 & 0x8000) == 0)
7036 return 0;
7037
7038 if (pinsn16)
7039 *pinsn16 = insn16;
7040 if (pinsn_type)
7041 *pinsn_type = insn_type;
7042 return 1;
7043 }
7044
7045 int
7046 nds32_convert_32_to_16 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7047 int *pinsn_type)
7048 {
7049 int op6;
7050 uint16_t insn16 = 0;
7051 int insn_type;
7052 unsigned long mach = bfd_get_mach (abfd);
7053
7054 /* Decode 32-bit instruction. */
7055 if (insn & 0x80000000)
7056 {
7057 /* Not 32-bit insn. */
7058 return 0;
7059 }
7060
7061 op6 = N32_OP6 (insn);
7062
7063 /* Convert it to 16-bit instruction. */
7064 switch (op6)
7065 {
7066 case N32_OP6_MOVI:
7067 if (IS_WITHIN_S (N32_IMM20S (insn), 5))
7068 {
7069 insn16 = N16_TYPE55 (MOVI55, N32_RT5 (insn), N32_IMM20S (insn));
7070 insn_type = NDS32_INSN_MOVI55;
7071 }
7072 else if (mach >= MACH_V3 && N32_IMM20S (insn) >= 16
7073 && N32_IMM20S (insn) < 48 && N32_IS_RT4 (insn))
7074 {
7075 insn16 = N16_TYPE45 (MOVPI45, N32_RT54 (insn),
7076 N32_IMM20S (insn) - 16);
7077 insn_type = NDS32_INSN_MOVPI45;
7078 }
7079 break;
7080
7081 case N32_OP6_ADDI:
7082 if (N32_IMM15S (insn) == 0)
7083 {
7084 /* Do not convert `addi $sp, $sp, 0' to `mov55 $sp, $sp',
7085 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7086 if (mach <= MACH_V2
7087 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7088 {
7089 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7090 insn_type = NDS32_INSN_MOV55;
7091 }
7092 }
7093 else if (N32_IMM15S (insn) > 0)
7094 {
7095 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) < 8)
7096 {
7097 insn16 = N16_TYPE333 (ADDI333, N32_RT5 (insn), N32_RA5 (insn),
7098 N32_IMM15S (insn));
7099 insn_type = NDS32_INSN_ADDI333;
7100 }
7101 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7102 && N32_IMM15S (insn) < 32)
7103 {
7104 insn16 = N16_TYPE45 (ADDI45, N32_RT54 (insn), N32_IMM15S (insn));
7105 insn_type = NDS32_INSN_ADDI45;
7106 }
7107 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7108 && N32_RT5 (insn) == N32_RA5 (insn)
7109 && N32_IMM15S (insn) < 512)
7110 {
7111 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7112 insn_type = NDS32_INSN_ADDI10_SP;
7113 }
7114 else if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7115 && N32_RA5 (insn) == REG_SP && N32_IMM15S (insn) < 256
7116 && (N32_IMM15S (insn) % 4 == 0))
7117 {
7118 insn16 = N16_TYPE36 (ADDRI36_SP, N32_RT5 (insn),
7119 N32_IMM15S (insn) >> 2);
7120 insn_type = NDS32_INSN_ADDRI36_SP;
7121 }
7122 }
7123 else
7124 {
7125 /* Less than 0. */
7126 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) > -8)
7127 {
7128 insn16 = N16_TYPE333 (SUBI333, N32_RT5 (insn), N32_RA5 (insn),
7129 0 - N32_IMM15S (insn));
7130 insn_type = NDS32_INSN_SUBI333;
7131 }
7132 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7133 && N32_IMM15S (insn) > -32)
7134 {
7135 insn16 = N16_TYPE45 (SUBI45, N32_RT54 (insn),
7136 0 - N32_IMM15S (insn));
7137 insn_type = NDS32_INSN_SUBI45;
7138 }
7139 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7140 && N32_RT5 (insn) == N32_RA5 (insn)
7141 && N32_IMM15S (insn) >= -512)
7142 {
7143 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7144 insn_type = NDS32_INSN_ADDI10_SP;
7145 }
7146 }
7147 break;
7148
7149 case N32_OP6_ORI:
7150 if (N32_IMM15S (insn) == 0)
7151 {
7152 /* Do not convert `ori $sp, $sp, 0' to `mov55 $sp, $sp',
7153 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7154 if (mach <= MACH_V2
7155 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7156 {
7157 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7158 insn_type = NDS32_INSN_MOV55;
7159 }
7160 }
7161 break;
7162
7163 case N32_OP6_SUBRI:
7164 if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7165 && N32_IS_RA3 (insn) && N32_IMM15S (insn) == 0)
7166 {
7167 insn16 = N16_MISC33 (NEG33, N32_RT5 (insn), N32_RA5 (insn));
7168 insn_type = NDS32_INSN_NEG33;
7169 }
7170 break;
7171
7172 case N32_OP6_ANDI:
7173 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7174 {
7175 if (N32_IMM15U (insn) == 1)
7176 {
7177 insn16 = N16_BFMI333 (XLSB33, N32_RT5 (insn), N32_RA5 (insn));
7178 insn_type = NDS32_INSN_XLSB33;
7179 }
7180 else if (N32_IMM15U (insn) == 0x7ff)
7181 {
7182 insn16 = N16_BFMI333 (X11B33, N32_RT5 (insn), N32_RA5 (insn));
7183 insn_type = NDS32_INSN_X11B33;
7184 }
7185 else if (N32_IMM15U (insn) == 0xff)
7186 {
7187 insn16 = N16_BFMI333 (ZEB33, N32_RT5 (insn), N32_RA5 (insn));
7188 insn_type = NDS32_INSN_ZEB33;
7189 }
7190 else if (mach >= MACH_V3 && N32_RT5 (insn) == N32_RA5 (insn)
7191 && N32_IMM15U (insn) < 256)
7192 {
7193 int imm15u = N32_IMM15U (insn);
7194
7195 if (__builtin_popcount (imm15u) == 1)
7196 {
7197 /* BMSKI33 */
7198 int imm3u = __builtin_ctz (imm15u);
7199
7200 insn16 = N16_BFMI333 (BMSKI33, N32_RT5 (insn), imm3u);
7201 insn_type = NDS32_INSN_BMSKI33;
7202 }
7203 else if (imm15u != 0 && __builtin_popcount (imm15u + 1) == 1)
7204 {
7205 /* FEXTI33 */
7206 int imm3u = __builtin_ctz (imm15u + 1) - 1;
7207
7208 insn16 = N16_BFMI333 (FEXTI33, N32_RT5 (insn), imm3u);
7209 insn_type = NDS32_INSN_FEXTI33;
7210 }
7211 }
7212 }
7213 break;
7214
7215 case N32_OP6_SLTI:
7216 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7217 && IS_WITHIN_U (N32_IMM15S (insn), 5))
7218 {
7219 insn16 = N16_TYPE45 (SLTI45, N32_RA54 (insn), N32_IMM15S (insn));
7220 insn_type = NDS32_INSN_SLTI45;
7221 }
7222 break;
7223
7224 case N32_OP6_SLTSI:
7225 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7226 && IS_WITHIN_U (N32_IMM15S (insn), 5))
7227 {
7228 insn16 = N16_TYPE45 (SLTSI45, N32_RA54 (insn), N32_IMM15S (insn));
7229 insn_type = NDS32_INSN_SLTSI45;
7230 }
7231 break;
7232
7233 case N32_OP6_LWI:
7234 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7235 {
7236 insn16 = N16_TYPE45 (LWI450, N32_RT54 (insn), N32_RA5 (insn));
7237 insn_type = NDS32_INSN_LWI450;
7238 }
7239 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7240 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7241 {
7242 insn16 = N16_TYPE333 (LWI333, N32_RT5 (insn), N32_RA5 (insn),
7243 N32_IMM15S (insn));
7244 insn_type = NDS32_INSN_LWI333;
7245 }
7246 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7247 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7248 {
7249 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7250 insn_type = NDS32_INSN_LWI37;
7251 }
7252 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7253 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7254 {
7255 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 0, N32_IMM15S (insn));
7256 insn_type = NDS32_INSN_LWI37_SP;
7257 }
7258 else if (mach >= MACH_V2 && N32_IS_RT4 (insn) && N32_RA5 (insn) == REG_R8
7259 && -32 <= N32_IMM15S (insn) && N32_IMM15S (insn) < 0)
7260 {
7261 insn16 = N16_TYPE45 (LWI45_FE, N32_RT54 (insn),
7262 N32_IMM15S (insn) + 32);
7263 insn_type = NDS32_INSN_LWI45_FE;
7264 }
7265 break;
7266
7267 case N32_OP6_SWI:
7268 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7269 {
7270 insn16 = N16_TYPE45 (SWI450, N32_RT54 (insn), N32_RA5 (insn));
7271 insn_type = NDS32_INSN_SWI450;
7272 }
7273 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7274 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7275 {
7276 insn16 = N16_TYPE333 (SWI333, N32_RT5 (insn), N32_RA5 (insn),
7277 N32_IMM15S (insn));
7278 insn_type = NDS32_INSN_SWI333;
7279 }
7280 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7281 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7282 {
7283 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7284 insn_type = NDS32_INSN_SWI37;
7285 }
7286 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7287 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7288 {
7289 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 1, N32_IMM15S (insn));
7290 insn_type = NDS32_INSN_SWI37_SP;
7291 }
7292 break;
7293
7294 case N32_OP6_LWI_BI:
7295 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7296 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7297 {
7298 insn16 = N16_TYPE333 (LWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7299 N32_IMM15S (insn));
7300 insn_type = NDS32_INSN_LWI333_BI;
7301 }
7302 break;
7303
7304 case N32_OP6_SWI_BI:
7305 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7306 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7307 {
7308 insn16 = N16_TYPE333 (SWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7309 N32_IMM15S (insn));
7310 insn_type = NDS32_INSN_SWI333_BI;
7311 }
7312 break;
7313
7314 case N32_OP6_LHI:
7315 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7316 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7317 {
7318 insn16 = N16_TYPE333 (LHI333, N32_RT5 (insn), N32_RA5 (insn),
7319 N32_IMM15S (insn));
7320 insn_type = NDS32_INSN_LHI333;
7321 }
7322 break;
7323
7324 case N32_OP6_SHI:
7325 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7326 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7327 {
7328 insn16 = N16_TYPE333 (SHI333, N32_RT5 (insn), N32_RA5 (insn),
7329 N32_IMM15S (insn));
7330 insn_type = NDS32_INSN_SHI333;
7331 }
7332 break;
7333
7334 case N32_OP6_LBI:
7335 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7336 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7337 {
7338 insn16 = N16_TYPE333 (LBI333, N32_RT5 (insn), N32_RA5 (insn),
7339 N32_IMM15S (insn));
7340 insn_type = NDS32_INSN_LBI333;
7341 }
7342 break;
7343
7344 case N32_OP6_SBI:
7345 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7346 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7347 {
7348 insn16 = N16_TYPE333 (SBI333, N32_RT5 (insn), N32_RA5 (insn),
7349 N32_IMM15S (insn));
7350 insn_type = NDS32_INSN_SBI333;
7351 }
7352 break;
7353
7354 case N32_OP6_ALU1:
7355 return nds32_convert_32_to_16_alu1 (abfd, insn, pinsn16, pinsn_type);
7356
7357 case N32_OP6_ALU2:
7358 return nds32_convert_32_to_16_alu2 (abfd, insn, pinsn16, pinsn_type);
7359
7360 case N32_OP6_BR1:
7361 if (!IS_WITHIN_S (N32_IMM14S (insn), 8))
7362 goto done;
7363
7364 if ((insn & __BIT (14)) == 0)
7365 {
7366 /* N32_BR1_BEQ */
7367 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
7368 && N32_RT5 (insn) != REG_R5)
7369 insn16 = N16_TYPE38 (BEQS38, N32_RT5 (insn), N32_IMM14S (insn));
7370 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
7371 && N32_RA5 (insn) != REG_R5)
7372 insn16 = N16_TYPE38 (BEQS38, N32_RA5 (insn), N32_IMM14S (insn));
7373 insn_type = NDS32_INSN_BEQS38;
7374 break;
7375 }
7376 else
7377 {
7378 /* N32_BR1_BNE */
7379 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
7380 && N32_RT5 (insn) != REG_R5)
7381 insn16 = N16_TYPE38 (BNES38, N32_RT5 (insn), N32_IMM14S (insn));
7382 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
7383 && N32_RA5 (insn) != REG_R5)
7384 insn16 = N16_TYPE38 (BNES38, N32_RA5 (insn), N32_IMM14S (insn));
7385 insn_type = NDS32_INSN_BNES38;
7386 break;
7387 }
7388 break;
7389
7390 case N32_OP6_BR2:
7391 switch (N32_BR2_SUB (insn))
7392 {
7393 case N32_BR2_BEQZ:
7394 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
7395 {
7396 insn16 = N16_TYPE38 (BEQZ38, N32_RT5 (insn), N32_IMM16S (insn));
7397 insn_type = NDS32_INSN_BEQZ38;
7398 }
7399 else if (N32_RT5 (insn) == REG_R15
7400 && IS_WITHIN_S (N32_IMM16S (insn), 8))
7401 {
7402 insn16 = N16_TYPE8 (BEQZS8, N32_IMM16S (insn));
7403 insn_type = NDS32_INSN_BEQZS8;
7404 }
7405 break;
7406
7407 case N32_BR2_BNEZ:
7408 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
7409 {
7410 insn16 = N16_TYPE38 (BNEZ38, N32_RT5 (insn), N32_IMM16S (insn));
7411 insn_type = NDS32_INSN_BNEZ38;
7412 }
7413 else if (N32_RT5 (insn) == REG_R15
7414 && IS_WITHIN_S (N32_IMM16S (insn), 8))
7415 {
7416 insn16 = N16_TYPE8 (BNEZS8, N32_IMM16S (insn));
7417 insn_type = NDS32_INSN_BNEZS8;
7418 }
7419 break;
7420
7421 case N32_BR2_IFCALL:
7422 if (IS_WITHIN_U (N32_IMM16S (insn), 9))
7423 {
7424 insn16 = N16_TYPE9 (IFCALL9, N32_IMM16S (insn));
7425 insn_type = NDS32_INSN_IFCALL9;
7426 }
7427 break;
7428 }
7429 break;
7430
7431 case N32_OP6_JI:
7432 if ((insn & __BIT (24)) == 0)
7433 {
7434 /* N32_JI_J */
7435 if (IS_WITHIN_S (N32_IMM24S (insn), 8))
7436 {
7437 insn16 = N16_TYPE8 (J8, N32_IMM24S (insn));
7438 insn_type = NDS32_INSN_J8;
7439 }
7440 }
7441 break;
7442
7443 case N32_OP6_JREG:
7444 if (__GF (insn, 8, 2) != 0)
7445 goto done;
7446
7447 switch (N32_IMMU (insn, 5))
7448 {
7449 case N32_JREG_JR:
7450 if (N32_JREG_HINT (insn) == 0)
7451 {
7452 /* jr */
7453 insn16 = N16_TYPE5 (JR5, N32_RB5 (insn));
7454 insn_type = NDS32_INSN_JR5;
7455 }
7456 else if (N32_JREG_HINT (insn) == 1)
7457 {
7458 /* ret */
7459 insn16 = N16_TYPE5 (RET5, N32_RB5 (insn));
7460 insn_type = NDS32_INSN_RET5;
7461 }
7462 else if (N32_JREG_HINT (insn) == 3)
7463 {
7464 /* ifret = mov55 $sp, $sp */
7465 insn16 = N16_TYPE55 (MOV55, REG_SP, REG_SP);
7466 insn_type = NDS32_INSN_IFRET;
7467 }
7468 break;
7469
7470 case N32_JREG_JRAL:
7471 /* It's convertible when return rt5 is $lp and address
7472 translation is kept. */
7473 if (N32_RT5 (insn) == REG_LP && N32_JREG_HINT (insn) == 0)
7474 {
7475 insn16 = N16_TYPE5 (JRAL5, N32_RB5 (insn));
7476 insn_type = NDS32_INSN_JRAL5;
7477 }
7478 break;
7479 }
7480 break;
7481
7482 case N32_OP6_MISC:
7483 if (N32_SUB5 (insn) == N32_MISC_BREAK && N32_SWID (insn) < 32)
7484 {
7485 /* For v3, swid above 31 are used for ex9.it. */
7486 insn16 = N16_TYPE5 (BREAK16, N32_SWID (insn));
7487 insn_type = NDS32_INSN_BREAK16;
7488 }
7489 break;
7490
7491 default:
7492 /* This instruction has no 16-bit variant. */
7493 goto done;
7494 }
7495
7496 done:
7497 /* Bit-15 of insn16 should be set for a valid instruction. */
7498 if ((insn16 & 0x8000) == 0)
7499 return 0;
7500
7501 if (pinsn16)
7502 *pinsn16 = insn16;
7503 if (pinsn_type)
7504 *pinsn_type = insn_type;
7505 return 1;
7506 }
7507
7508 static int
7509 special_convert_32_to_16 (unsigned long insn, uint16_t *pinsn16,
7510 Elf_Internal_Rela *reloc)
7511 {
7512 uint16_t insn16 = 0;
7513
7514 if ((reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG) == 0
7515 || (ELF32_R_TYPE (reloc->r_info) != R_NDS32_INSN16))
7516 return 0;
7517
7518 if (!N32_IS_RT3 (insn))
7519 return 0;
7520
7521 switch (N32_OP6 (insn))
7522 {
7523 case N32_OP6_LWI:
7524 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
7525 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7526 break;
7527 case N32_OP6_SWI:
7528 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
7529 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7530 break;
7531 case N32_OP6_HWGP:
7532 if (!IS_WITHIN_U (N32_IMM17S (insn), 7))
7533 break;
7534
7535 if (__GF (insn, 17, 3) == 6)
7536 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM17S (insn));
7537 else if (__GF (insn, 17, 3) == 7)
7538 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM17S (insn));
7539 break;
7540 }
7541
7542 if ((insn16 & 0x8000) == 0)
7543 return 0;
7544
7545 *pinsn16 = insn16;
7546 return 1;
7547 }
7548
7549 /* Convert a 16-bit instruction to 32-bit one.
7550 INSN16 it the input and PINSN it the point to output.
7551 Return non-zero on successful. Otherwise 0 is returned. */
7552
7553 int
7554 nds32_convert_16_to_32 (bfd *abfd, uint16_t insn16, uint32_t *pinsn)
7555 {
7556 uint32_t insn = 0xffffffff;
7557 unsigned long mach = bfd_get_mach (abfd);
7558
7559 /* NOTE: push25, pop25 and movd44 do not have 32-bit variants. */
7560
7561 switch (__GF (insn16, 9, 6))
7562 {
7563 case 0x4: /* add45 */
7564 insn = N32_ALU1 (ADD, N16_RT4 (insn16), N16_RT4 (insn16),
7565 N16_RA5 (insn16));
7566 goto done;
7567 case 0x5: /* sub45 */
7568 insn = N32_ALU1 (SUB, N16_RT4 (insn16), N16_RT4 (insn16),
7569 N16_RA5 (insn16));
7570 goto done;
7571 case 0x6: /* addi45 */
7572 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
7573 N16_IMM5U (insn16));
7574 goto done;
7575 case 0x7: /* subi45 */
7576 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
7577 -N16_IMM5U (insn16));
7578 goto done;
7579 case 0x8: /* srai45 */
7580 insn = N32_ALU1 (SRAI, N16_RT4 (insn16), N16_RT4 (insn16),
7581 N16_IMM5U (insn16));
7582 goto done;
7583 case 0x9: /* srli45 */
7584 insn = N32_ALU1 (SRLI, N16_RT4 (insn16), N16_RT4 (insn16),
7585 N16_IMM5U (insn16));
7586 goto done;
7587 case 0xa: /* slli333 */
7588 insn = N32_ALU1 (SLLI, N16_RT3 (insn16), N16_RA3 (insn16),
7589 N16_IMM3U (insn16));
7590 goto done;
7591 case 0xc: /* add333 */
7592 insn = N32_ALU1 (ADD, N16_RT3 (insn16), N16_RA3 (insn16),
7593 N16_RB3 (insn16));
7594 goto done;
7595 case 0xd: /* sub333 */
7596 insn = N32_ALU1 (SUB, N16_RT3 (insn16), N16_RA3 (insn16),
7597 N16_RB3 (insn16));
7598 goto done;
7599 case 0xe: /* addi333 */
7600 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
7601 N16_IMM3U (insn16));
7602 goto done;
7603 case 0xf: /* subi333 */
7604 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
7605 -N16_IMM3U (insn16));
7606 goto done;
7607 case 0x10: /* lwi333 */
7608 insn = N32_TYPE2 (LWI, N16_RT3 (insn16), N16_RA3 (insn16),
7609 N16_IMM3U (insn16));
7610 goto done;
7611 case 0x12: /* lhi333 */
7612 insn = N32_TYPE2 (LHI, N16_RT3 (insn16), N16_RA3 (insn16),
7613 N16_IMM3U (insn16));
7614 goto done;
7615 case 0x13: /* lbi333 */
7616 insn = N32_TYPE2 (LBI, N16_RT3 (insn16), N16_RA3 (insn16),
7617 N16_IMM3U (insn16));
7618 goto done;
7619 case 0x11: /* lwi333.bi */
7620 insn = N32_TYPE2 (LWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
7621 N16_IMM3U (insn16));
7622 goto done;
7623 case 0x14: /* swi333 */
7624 insn = N32_TYPE2 (SWI, N16_RT3 (insn16), N16_RA3 (insn16),
7625 N16_IMM3U (insn16));
7626 goto done;
7627 case 0x16: /* shi333 */
7628 insn = N32_TYPE2 (SHI, N16_RT3 (insn16), N16_RA3 (insn16),
7629 N16_IMM3U (insn16));
7630 goto done;
7631 case 0x17: /* sbi333 */
7632 insn = N32_TYPE2 (SBI, N16_RT3 (insn16), N16_RA3 (insn16),
7633 N16_IMM3U (insn16));
7634 goto done;
7635 case 0x15: /* swi333.bi */
7636 insn = N32_TYPE2 (SWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
7637 N16_IMM3U (insn16));
7638 goto done;
7639 case 0x18: /* addri36.sp */
7640 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), REG_SP,
7641 N16_IMM6U (insn16) << 2);
7642 goto done;
7643 case 0x19: /* lwi45.fe */
7644 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), REG_R8,
7645 (N16_IMM5U (insn16) - 32));
7646 goto done;
7647 case 0x1a: /* lwi450 */
7648 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
7649 goto done;
7650 case 0x1b: /* swi450 */
7651 insn = N32_TYPE2 (SWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
7652 goto done;
7653
7654 /* These are r15 implied instructions. */
7655 case 0x30: /* slts45 */
7656 insn = N32_ALU1 (SLTS, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
7657 goto done;
7658 case 0x31: /* slt45 */
7659 insn = N32_ALU1 (SLT, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
7660 goto done;
7661 case 0x32: /* sltsi45 */
7662 insn = N32_TYPE2 (SLTSI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
7663 goto done;
7664 case 0x33: /* slti45 */
7665 insn = N32_TYPE2 (SLTI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
7666 goto done;
7667 case 0x34: /* beqzs8, bnezs8 */
7668 if (insn16 & __BIT (8))
7669 insn = N32_BR2 (BNEZ, REG_TA, N16_IMM8S (insn16));
7670 else
7671 insn = N32_BR2 (BEQZ, REG_TA, N16_IMM8S (insn16));
7672 goto done;
7673
7674 case 0x35: /* break16, ex9.it */
7675 /* Only consider range of v3 break16. */
7676 insn = N32_TYPE0 (MISC, (N16_IMM5U (insn16) << 5) | N32_MISC_BREAK);
7677 goto done;
7678
7679 case 0x3c: /* ifcall9 */
7680 insn = N32_BR2 (IFCALL, 0, N16_IMM9U (insn16));
7681 goto done;
7682 case 0x3d: /* movpi45 */
7683 insn = N32_TYPE1 (MOVI, N16_RT4 (insn16), N16_IMM5U (insn16) + 16);
7684 goto done;
7685
7686 case 0x3f: /* MISC33 */
7687 switch (insn16 & 0x7)
7688 {
7689 case 2: /* neg33 */
7690 insn = N32_TYPE2 (SUBRI, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7691 break;
7692 case 3: /* not33 */
7693 insn = N32_ALU1 (NOR, N16_RT3 (insn16), N16_RA3 (insn16),
7694 N16_RA3 (insn16));
7695 break;
7696 case 4: /* mul33 */
7697 insn = N32_ALU2 (MUL, N16_RT3 (insn16), N16_RT3 (insn16),
7698 N16_RA3 (insn16));
7699 break;
7700 case 5: /* xor33 */
7701 insn = N32_ALU1 (XOR, N16_RT3 (insn16), N16_RT3 (insn16),
7702 N16_RA3 (insn16));
7703 break;
7704 case 6: /* and33 */
7705 insn = N32_ALU1 (AND, N16_RT3 (insn16), N16_RT3 (insn16),
7706 N16_RA3 (insn16));
7707 break;
7708 case 7: /* or33 */
7709 insn = N32_ALU1 (OR, N16_RT3 (insn16), N16_RT3 (insn16),
7710 N16_RA3 (insn16));
7711 break;
7712 }
7713 goto done;
7714
7715 case 0xb:
7716 switch (insn16 & 0x7)
7717 {
7718 case 0: /* zeb33 */
7719 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0xff);
7720 break;
7721 case 1: /* zeh33 */
7722 insn = N32_ALU1 (ZEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7723 break;
7724 case 2: /* seb33 */
7725 insn = N32_ALU1 (SEB, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7726 break;
7727 case 3: /* seh33 */
7728 insn = N32_ALU1 (SEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7729 break;
7730 case 4: /* xlsb33 */
7731 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 1);
7732 break;
7733 case 5: /* x11b33 */
7734 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0x7ff);
7735 break;
7736 case 6: /* bmski33 */
7737 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
7738 1 << __GF (insn16, 3, 3));
7739 break;
7740 case 7: /* fexti33 */
7741 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
7742 (1 << (__GF (insn16, 3, 3) + 1)) - 1);
7743 break;
7744 }
7745 goto done;
7746 }
7747
7748 switch (__GF (insn16, 10, 5))
7749 {
7750 case 0x0: /* mov55 or ifret16 */
7751 if (mach >= MACH_V3 && N16_RT5 (insn16) == REG_SP
7752 && N16_RT5 (insn16) == N16_RA5 (insn16))
7753 insn = N32_JREG (JR, 0, 0, 0, 3);
7754 else
7755 insn = N32_TYPE2 (ADDI, N16_RT5 (insn16), N16_RA5 (insn16), 0);
7756 goto done;
7757 case 0x1: /* movi55 */
7758 insn = N32_TYPE1 (MOVI, N16_RT5 (insn16), N16_IMM5S (insn16));
7759 goto done;
7760 case 0x1b: /* addi10s (V2) */
7761 insn = N32_TYPE2 (ADDI, REG_SP, REG_SP, N16_IMM10S (insn16));
7762 goto done;
7763 }
7764
7765 switch (__GF (insn16, 11, 4))
7766 {
7767 case 0x7: /* lwi37.fp/swi37.fp */
7768 if (insn16 & __BIT (7)) /* swi37.fp */
7769 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
7770 else /* lwi37.fp */
7771 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
7772 goto done;
7773 case 0x8: /* beqz38 */
7774 insn = N32_BR2 (BEQZ, N16_RT38 (insn16), N16_IMM8S (insn16));
7775 goto done;
7776 case 0x9: /* bnez38 */
7777 insn = N32_BR2 (BNEZ, N16_RT38 (insn16), N16_IMM8S (insn16));
7778 goto done;
7779 case 0xa: /* beqs38/j8, implied r5 */
7780 if (N16_RT38 (insn16) == 5)
7781 insn = N32_JI (J, N16_IMM8S (insn16));
7782 else
7783 insn = N32_BR1 (BEQ, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
7784 goto done;
7785 case 0xb: /* bnes38 and others */
7786 if (N16_RT38 (insn16) == 5)
7787 {
7788 switch (__GF (insn16, 5, 3))
7789 {
7790 case 0: /* jr5 */
7791 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 0);
7792 break;
7793 case 4: /* ret5 */
7794 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 1);
7795 break;
7796 case 1: /* jral5 */
7797 insn = N32_JREG (JRAL, REG_LP, N16_RA5 (insn16), 0, 0);
7798 break;
7799 case 2: /* ex9.it imm5 */
7800 /* ex9.it had no 32-bit variantl. */
7801 break;
7802 case 5: /* add5.pc */
7803 /* add5.pc had no 32-bit variantl. */
7804 break;
7805 }
7806 }
7807 else /* bnes38 */
7808 insn = N32_BR1 (BNE, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
7809 goto done;
7810 case 0xe: /* lwi37/swi37 */
7811 if (insn16 & (1 << 7)) /* swi37.sp */
7812 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
7813 else /* lwi37.sp */
7814 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
7815 goto done;
7816 }
7817
7818 done:
7819 if (insn & 0x80000000)
7820 return 0;
7821
7822 if (pinsn)
7823 *pinsn = insn;
7824 return 1;
7825 }
7826 \f
7827 static bfd_boolean
7828 is_sda_access_insn (unsigned long insn)
7829 {
7830 switch (N32_OP6 (insn))
7831 {
7832 case N32_OP6_LWI:
7833 case N32_OP6_LHI:
7834 case N32_OP6_LHSI:
7835 case N32_OP6_LBI:
7836 case N32_OP6_LBSI:
7837 case N32_OP6_SWI:
7838 case N32_OP6_SHI:
7839 case N32_OP6_SBI:
7840 case N32_OP6_LWC:
7841 case N32_OP6_LDC:
7842 case N32_OP6_SWC:
7843 case N32_OP6_SDC:
7844 return TRUE;
7845 default:
7846 ;
7847 }
7848 return FALSE;
7849 }
7850
7851 static unsigned long
7852 turn_insn_to_sda_access (uint32_t insn, bfd_signed_vma type, uint32_t *pinsn)
7853 {
7854 uint32_t oinsn = 0;
7855
7856 switch (type)
7857 {
7858 case R_NDS32_GOT_LO12:
7859 case R_NDS32_GOTOFF_LO12:
7860 case R_NDS32_PLTREL_LO12:
7861 case R_NDS32_PLT_GOTREL_LO12:
7862 case R_NDS32_LO12S0_RELA:
7863 switch (N32_OP6 (insn))
7864 {
7865 case N32_OP6_LBI:
7866 /* lbi.gp */
7867 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
7868 break;
7869 case N32_OP6_LBSI:
7870 /* lbsi.gp */
7871 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), __BIT (19));
7872 break;
7873 case N32_OP6_SBI:
7874 /* sbi.gp */
7875 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
7876 break;
7877 case N32_OP6_ORI:
7878 /* addi.gp */
7879 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
7880 break;
7881 }
7882 break;
7883
7884 case R_NDS32_LO12S1_RELA:
7885 switch (N32_OP6 (insn))
7886 {
7887 case N32_OP6_LHI:
7888 /* lhi.gp */
7889 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
7890 break;
7891 case N32_OP6_LHSI:
7892 /* lhsi.gp */
7893 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (18));
7894 break;
7895 case N32_OP6_SHI:
7896 /* shi.gp */
7897 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (19));
7898 break;
7899 }
7900 break;
7901
7902 case R_NDS32_LO12S2_RELA:
7903 switch (N32_OP6 (insn))
7904 {
7905 case N32_OP6_LWI:
7906 /* lwi.gp */
7907 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
7908 break;
7909 case N32_OP6_SWI:
7910 /* swi.gp */
7911 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
7912 break;
7913 }
7914 break;
7915
7916 case R_NDS32_LO12S2_DP_RELA:
7917 case R_NDS32_LO12S2_SP_RELA:
7918 oinsn = (insn & 0x7ff07000) | (REG_GP << 15);
7919 break;
7920 }
7921
7922 if (oinsn)
7923 *pinsn = oinsn;
7924
7925 return oinsn != 0;
7926 }
7927
7928 /* Linker hasn't found the correct merge section for non-section symbol
7929 in relax time, this work is left to the function elf_link_input_bfd().
7930 So for non-section symbol, _bfd_merged_section_offset is also needed
7931 to find the correct symbol address. */
7932
7933 static bfd_vma
7934 nds32_elf_rela_local_sym (bfd *abfd, Elf_Internal_Sym *sym,
7935 asection **psec, Elf_Internal_Rela *rel)
7936 {
7937 asection *sec = *psec;
7938 bfd_vma relocation;
7939
7940 relocation = (sec->output_section->vma
7941 + sec->output_offset + sym->st_value);
7942 if ((sec->flags & SEC_MERGE) && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
7943 {
7944 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
7945 rel->r_addend =
7946 _bfd_merged_section_offset (abfd, psec,
7947 elf_section_data (sec)->sec_info,
7948 sym->st_value + rel->r_addend);
7949 else
7950 rel->r_addend =
7951 _bfd_merged_section_offset (abfd, psec,
7952 elf_section_data (sec)->sec_info,
7953 sym->st_value) + rel->r_addend;
7954
7955 if (sec != *psec)
7956 {
7957 /* If we have changed the section, and our original section is
7958 marked with SEC_EXCLUDE, it means that the original
7959 SEC_MERGE section has been completely subsumed in some
7960 other SEC_MERGE section. In this case, we need to leave
7961 some info around for --emit-relocs. */
7962 if ((sec->flags & SEC_EXCLUDE) != 0)
7963 sec->kept_section = *psec;
7964 sec = *psec;
7965 }
7966 rel->r_addend -= relocation;
7967 rel->r_addend += sec->output_section->vma + sec->output_offset;
7968 }
7969 return relocation;
7970 }
7971
7972 static bfd_vma
7973 calculate_memory_address (bfd *abfd, Elf_Internal_Rela *irel,
7974 Elf_Internal_Sym *isymbuf,
7975 Elf_Internal_Shdr *symtab_hdr)
7976 {
7977 bfd_signed_vma foff;
7978 bfd_vma symval, addend;
7979 Elf_Internal_Rela irel_fn;
7980 Elf_Internal_Sym *isym;
7981 asection *sym_sec;
7982
7983 /* Get the value of the symbol referred to by the reloc. */
7984 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
7985 {
7986 /* A local symbol. */
7987 isym = isymbuf + ELF32_R_SYM (irel->r_info);
7988
7989 if (isym->st_shndx == SHN_UNDEF)
7990 sym_sec = bfd_und_section_ptr;
7991 else if (isym->st_shndx == SHN_ABS)
7992 sym_sec = bfd_abs_section_ptr;
7993 else if (isym->st_shndx == SHN_COMMON)
7994 sym_sec = bfd_com_section_ptr;
7995 else
7996 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
7997 memcpy (&irel_fn, irel, sizeof (Elf_Internal_Rela));
7998 symval = nds32_elf_rela_local_sym (abfd, isym, &sym_sec, &irel_fn);
7999 addend = irel_fn.r_addend;
8000 }
8001 else
8002 {
8003 unsigned long indx;
8004 struct elf_link_hash_entry *h;
8005
8006 /* An external symbol. */
8007 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8008 h = elf_sym_hashes (abfd)[indx];
8009 BFD_ASSERT (h != NULL);
8010
8011 while (h->root.type == bfd_link_hash_indirect
8012 || h->root.type == bfd_link_hash_warning)
8013 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8014
8015 if (h->root.type != bfd_link_hash_defined
8016 && h->root.type != bfd_link_hash_defweak)
8017 /* This appears to be a reference to an undefined
8018 symbol. Just ignore it--it will be caught by the
8019 regular reloc processing. */
8020 return 0;
8021
8022 if (h->root.u.def.section->flags & SEC_MERGE)
8023 {
8024 sym_sec = h->root.u.def.section;
8025 symval = _bfd_merged_section_offset (abfd, &sym_sec, elf_section_data
8026 (sym_sec)->sec_info, h->root.u.def.value);
8027 symval = symval + sym_sec->output_section->vma
8028 + sym_sec->output_offset;
8029 }
8030 else
8031 symval = (h->root.u.def.value
8032 + h->root.u.def.section->output_section->vma
8033 + h->root.u.def.section->output_offset);
8034 addend = irel->r_addend;
8035 }
8036
8037 foff = symval + addend;
8038
8039 return foff;
8040 }
8041
8042 static bfd_vma
8043 calculate_got_memory_address (bfd *abfd, struct bfd_link_info *link_info,
8044 Elf_Internal_Rela *irel,
8045 Elf_Internal_Shdr *symtab_hdr)
8046 {
8047 int symndx;
8048 bfd_vma *local_got_offsets;
8049 /* Get the value of the symbol referred to by the reloc. */
8050 struct elf_link_hash_entry *h;
8051 struct elf_nds32_link_hash_table *htab = nds32_elf_hash_table (link_info);
8052
8053 /* An external symbol. */
8054 symndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8055 h = elf_sym_hashes (abfd)[symndx];
8056 while (h->root.type == bfd_link_hash_indirect
8057 || h->root.type == bfd_link_hash_warning)
8058 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8059
8060 if (symndx >= 0)
8061 {
8062 BFD_ASSERT (h != NULL);
8063 return (htab->root.sgot->output_section->vma
8064 + htab->root.sgot->output_offset
8065 + h->got.offset);
8066 }
8067 else
8068 {
8069 local_got_offsets = elf_local_got_offsets (abfd);
8070 BFD_ASSERT (local_got_offsets != NULL);
8071 return (htab->root.sgot->output_section->vma
8072 + htab->root.sgot->output_offset
8073 + local_got_offsets[ELF32_R_SYM (irel->r_info)]);
8074 }
8075
8076 /* The _GLOBAL_OFFSET_TABLE_ may be undefweak(or should be?). */
8077 /* The check of h->root.type is passed. */
8078 }
8079
8080 static int
8081 is_16bit_NOP (bfd *abfd ATTRIBUTE_UNUSED,
8082 asection *sec, Elf_Internal_Rela *rel)
8083 {
8084 bfd_byte *contents;
8085 unsigned short insn16;
8086
8087 if (!(rel->r_addend & R_NDS32_INSN16_CONVERT_FLAG))
8088 return FALSE;
8089 contents = elf_section_data (sec)->this_hdr.contents;
8090 insn16 = bfd_getb16 (contents + rel->r_offset);
8091 if (insn16 == NDS32_NOP16)
8092 return TRUE;
8093 return FALSE;
8094 }
8095
8096 /* It checks whether the instruction could be converted to
8097 16-bit form and returns the converted one.
8098
8099 `internal_relocs' is supposed to be sorted. */
8100
8101 static int
8102 is_convert_32_to_16 (bfd *abfd, asection *sec,
8103 Elf_Internal_Rela *reloc,
8104 Elf_Internal_Rela *internal_relocs,
8105 Elf_Internal_Rela *irelend,
8106 uint16_t *insn16)
8107 {
8108 #define NORMAL_32_TO_16 (1 << 0)
8109 #define SPECIAL_32_TO_16 (1 << 1)
8110 bfd_byte *contents = NULL;
8111 bfd_signed_vma off;
8112 bfd_vma mem_addr;
8113 uint32_t insn = 0;
8114 Elf_Internal_Rela *pc_rel;
8115 int pic_ext_target = 0;
8116 Elf_Internal_Shdr *symtab_hdr;
8117 Elf_Internal_Sym *isymbuf = NULL;
8118 int convert_type;
8119 bfd_vma offset;
8120
8121 if (reloc->r_offset + 4 > sec->size)
8122 return FALSE;
8123
8124 offset = reloc->r_offset;
8125
8126 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
8127 return FALSE;
8128 insn = bfd_getb32 (contents + offset);
8129
8130 if (nds32_convert_32_to_16 (abfd, insn, insn16, NULL))
8131 convert_type = NORMAL_32_TO_16;
8132 else if (special_convert_32_to_16 (insn, insn16, reloc))
8133 convert_type = SPECIAL_32_TO_16;
8134 else
8135 return FALSE;
8136
8137 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8138 if (!nds32_get_local_syms (abfd, sec, &isymbuf))
8139 return FALSE;
8140
8141 /* Find the first relocation of the same relocation-type,
8142 so we iteratie them forward. */
8143 pc_rel = reloc;
8144 while ((pc_rel - 1) >= internal_relocs && pc_rel[-1].r_offset == offset)
8145 pc_rel--;
8146
8147 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8148 {
8149 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8150 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8151 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA
8152 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8153 {
8154 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr,
8155 &pic_ext_target);
8156 if (off >= ACCURATE_8BIT_S1 || off < -ACCURATE_8BIT_S1
8157 || off == 0)
8158 return FALSE;
8159 break;
8160 }
8161 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8162 {
8163 /* movi => movi55 */
8164 mem_addr = calculate_memory_address (abfd, pc_rel, isymbuf,
8165 symtab_hdr);
8166 /* mem_addr is unsigned, but the value should
8167 be between [-16, 15]. */
8168 if ((mem_addr + 0x10) >> 5)
8169 return FALSE;
8170 break;
8171 }
8172 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_20)
8173 || (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_LO12))
8174 {
8175 /* It never happen movi to movi55 for R_NDS32_TLS_LE_20,
8176 because it can be relaxed to addi for TLS_LE_ADD. */
8177 return FALSE;
8178 }
8179 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8180 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8181 && (reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG)
8182 && convert_type == SPECIAL_32_TO_16)
8183 {
8184 /* fp-as-gp
8185 We've selected a best fp-base for this access, so we can
8186 always resolve it anyway. Do nothing. */
8187 break;
8188 }
8189 else if ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_NONE
8190 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_RELA_GNU_VTINHERIT))
8191 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_RELA_GNU_VTENTRY)
8192 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_INSN16))
8193 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_LOADSTORE)
8194 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_DWARF2_OP1_RELA)))
8195 {
8196 /* Prevent unresolved addi instruction translate
8197 to addi45 or addi333. */
8198 return FALSE;
8199 }
8200 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8201 {
8202 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr,
8203 &pic_ext_target);
8204 if (off >= ACCURATE_U9BIT_S1 || off <= 0)
8205 return FALSE;
8206 break;
8207 }
8208 }
8209
8210 return TRUE;
8211 }
8212
8213 static void
8214 nds32_elf_write_16 (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *contents,
8215 Elf_Internal_Rela *reloc,
8216 Elf_Internal_Rela *internal_relocs,
8217 Elf_Internal_Rela *irelend,
8218 unsigned short insn16)
8219 {
8220 Elf_Internal_Rela *pc_rel;
8221 bfd_vma offset;
8222
8223 offset = reloc->r_offset;
8224 bfd_putb16 (insn16, contents + offset);
8225 /* Find the first relocation of the same relocation-type,
8226 so we iteratie them forward. */
8227 pc_rel = reloc;
8228 while ((pc_rel - 1) > internal_relocs && pc_rel[-1].r_offset == offset)
8229 pc_rel--;
8230
8231 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8232 {
8233 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8234 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8235 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA)
8236 {
8237 pc_rel->r_info =
8238 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PCREL_RELA);
8239 }
8240 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8241 pc_rel->r_info =
8242 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PLTREL);
8243 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8244 pc_rel->r_info =
8245 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_5_RELA);
8246 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8247 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8248 pc_rel->r_info =
8249 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_SDA_FP7U2_RELA);
8250 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8251 pc_rel->r_info =
8252 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_10IFCU_PCREL_RELA);
8253 }
8254 }
8255
8256 /* Find a relocation of type specified by `reloc_type'
8257 of the same r_offset with reloc.
8258 If not found, return irelend.
8259
8260 Assuming relocations are sorted by r_offset,
8261 we find the relocation from `reloc' backward untill relocs,
8262 or find it from `reloc' forward untill irelend. */
8263
8264 static Elf_Internal_Rela *
8265 find_relocs_at_address (Elf_Internal_Rela *reloc,
8266 Elf_Internal_Rela *relocs,
8267 Elf_Internal_Rela *irelend,
8268 enum elf_nds32_reloc_type reloc_type)
8269 {
8270 Elf_Internal_Rela *rel_t;
8271
8272 /* Find backward. */
8273 for (rel_t = reloc;
8274 rel_t >= relocs && rel_t->r_offset == reloc->r_offset;
8275 rel_t--)
8276 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8277 return rel_t;
8278
8279 /* We didn't find it backward. Try find it forward. */
8280 for (rel_t = reloc;
8281 rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8282 rel_t++)
8283 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8284 return rel_t;
8285
8286 return irelend;
8287 }
8288
8289 /* Find a relocation of specified type and offset.
8290 `reloc' is just a refence point to find a relocation at specified offset.
8291 If not found, return irelend.
8292
8293 Assuming relocations are sorted by r_offset,
8294 we find the relocation from `reloc' backward untill relocs,
8295 or find it from `reloc' forward untill irelend. */
8296
8297 static Elf_Internal_Rela *
8298 find_relocs_at_address_addr (Elf_Internal_Rela *reloc,
8299 Elf_Internal_Rela *relocs,
8300 Elf_Internal_Rela *irelend,
8301 enum elf_nds32_reloc_type reloc_type,
8302 bfd_vma offset_p)
8303 {
8304 Elf_Internal_Rela *rel_t = NULL;
8305
8306 /* First, we try to find a relocation of offset `offset_p',
8307 and then we use find_relocs_at_address to find specific type. */
8308
8309 if (reloc->r_offset > offset_p)
8310 {
8311 /* Find backward. */
8312 for (rel_t = reloc;
8313 rel_t >= relocs && rel_t->r_offset > offset_p; rel_t--)
8314 /* Do nothing. */;
8315 }
8316 else if (reloc->r_offset < offset_p)
8317 {
8318 /* Find forward. */
8319 for (rel_t = reloc;
8320 rel_t < irelend && rel_t->r_offset < offset_p; rel_t++)
8321 /* Do nothing. */;
8322 }
8323 else
8324 rel_t = reloc;
8325
8326 /* Not found? */
8327 if (rel_t < relocs || rel_t == irelend || rel_t->r_offset != offset_p)
8328 return irelend;
8329
8330 return find_relocs_at_address (rel_t, relocs, irelend, reloc_type);
8331 }
8332
8333 static bfd_boolean
8334 nds32_elf_check_dup_relocs (Elf_Internal_Rela *reloc,
8335 Elf_Internal_Rela *internal_relocs,
8336 Elf_Internal_Rela *irelend,
8337 unsigned char reloc_type)
8338 {
8339 Elf_Internal_Rela *rel_t;
8340
8341 for (rel_t = reloc;
8342 rel_t >= internal_relocs && rel_t->r_offset == reloc->r_offset;
8343 rel_t--)
8344 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8345 {
8346 if (ELF32_R_SYM (rel_t->r_info) == ELF32_R_SYM (reloc->r_info)
8347 && rel_t->r_addend == reloc->r_addend)
8348 continue;
8349 return TRUE;
8350 }
8351
8352 for (rel_t = reloc; rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8353 rel_t++)
8354 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8355 {
8356 if (ELF32_R_SYM (rel_t->r_info) == ELF32_R_SYM (reloc->r_info)
8357 && rel_t->r_addend == reloc->r_addend)
8358 continue;
8359 return TRUE;
8360 }
8361
8362 return FALSE;
8363 }
8364
8365 typedef struct nds32_elf_blank nds32_elf_blank_t;
8366 struct nds32_elf_blank
8367 {
8368 /* Where the blank begins. */
8369 bfd_vma offset;
8370 /* The size of the blank. */
8371 bfd_vma size;
8372 /* The accumulative size before this blank. */
8373 bfd_vma total_size;
8374 nds32_elf_blank_t *next;
8375 nds32_elf_blank_t *prev;
8376 };
8377
8378 static nds32_elf_blank_t *blank_free_list = NULL;
8379
8380 static nds32_elf_blank_t *
8381 create_nds32_elf_blank (bfd_vma offset_p, bfd_vma size_p)
8382 {
8383 nds32_elf_blank_t *blank_t;
8384
8385 if (blank_free_list)
8386 {
8387 blank_t = blank_free_list;
8388 blank_free_list = blank_free_list->next;
8389 }
8390 else
8391 blank_t = bfd_malloc (sizeof (nds32_elf_blank_t));
8392
8393 if (blank_t == NULL)
8394 return NULL;
8395
8396 blank_t->offset = offset_p;
8397 blank_t->size = size_p;
8398 blank_t->total_size = 0;
8399 blank_t->next = NULL;
8400 blank_t->prev = NULL;
8401
8402 return blank_t;
8403 }
8404
8405 static void
8406 remove_nds32_elf_blank (nds32_elf_blank_t *blank_p)
8407 {
8408 if (blank_free_list)
8409 {
8410 blank_free_list->prev = blank_p;
8411 blank_p->next = blank_free_list;
8412 }
8413 else
8414 blank_p->next = NULL;
8415
8416 blank_p->prev = NULL;
8417 blank_free_list = blank_p;
8418 }
8419
8420 static void
8421 clean_nds32_elf_blank (void)
8422 {
8423 nds32_elf_blank_t *blank_t;
8424
8425 while (blank_free_list)
8426 {
8427 blank_t = blank_free_list;
8428 blank_free_list = blank_free_list->next;
8429 free (blank_t);
8430 }
8431 }
8432
8433 static nds32_elf_blank_t *
8434 search_nds32_elf_blank (nds32_elf_blank_t *blank_p, bfd_vma addr)
8435 {
8436 nds32_elf_blank_t *blank_t;
8437
8438 if (!blank_p)
8439 return NULL;
8440 blank_t = blank_p;
8441
8442 while (blank_t && addr < blank_t->offset)
8443 blank_t = blank_t->prev;
8444 while (blank_t && blank_t->next && addr >= blank_t->next->offset)
8445 blank_t = blank_t->next;
8446
8447 return blank_t;
8448 }
8449
8450 static bfd_vma
8451 get_nds32_elf_blank_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
8452 int overwrite)
8453 {
8454 nds32_elf_blank_t *blank_t;
8455
8456 blank_t = search_nds32_elf_blank (*blank_p, addr);
8457 if (!blank_t)
8458 return 0;
8459
8460 if (overwrite)
8461 *blank_p = blank_t;
8462
8463 if (addr < blank_t->offset + blank_t->size)
8464 return blank_t->total_size + (addr - blank_t->offset);
8465 else
8466 return blank_t->total_size + blank_t->size;
8467 }
8468
8469 static bfd_boolean
8470 insert_nds32_elf_blank (nds32_elf_blank_t **blank_p, bfd_vma addr, bfd_vma len)
8471 {
8472 nds32_elf_blank_t *blank_t, *blank_t2;
8473
8474 if (!*blank_p)
8475 {
8476 *blank_p = create_nds32_elf_blank (addr, len);
8477 return *blank_p ? TRUE : FALSE;
8478 }
8479
8480 blank_t = search_nds32_elf_blank (*blank_p, addr);
8481
8482 if (blank_t == NULL)
8483 {
8484 blank_t = create_nds32_elf_blank (addr, len);
8485 if (!blank_t)
8486 return FALSE;
8487 while ((*blank_p)->prev != NULL)
8488 *blank_p = (*blank_p)->prev;
8489 blank_t->next = *blank_p;
8490 (*blank_p)->prev = blank_t;
8491 (*blank_p) = blank_t;
8492 return TRUE;
8493 }
8494
8495 if (addr < blank_t->offset + blank_t->size)
8496 {
8497 if (addr > blank_t->offset + blank_t->size)
8498 blank_t->size = addr - blank_t->offset;
8499 }
8500 else
8501 {
8502 blank_t2 = create_nds32_elf_blank (addr, len);
8503 if (!blank_t2)
8504 return FALSE;
8505 if (blank_t->next)
8506 {
8507 blank_t->next->prev = blank_t2;
8508 blank_t2->next = blank_t->next;
8509 }
8510 blank_t2->prev = blank_t;
8511 blank_t->next = blank_t2;
8512 *blank_p = blank_t2;
8513 }
8514
8515 return TRUE;
8516 }
8517
8518 static bfd_boolean
8519 insert_nds32_elf_blank_recalc_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
8520 bfd_vma len)
8521 {
8522 nds32_elf_blank_t *blank_t;
8523
8524 if (!insert_nds32_elf_blank (blank_p, addr, len))
8525 return FALSE;
8526
8527 blank_t = *blank_p;
8528
8529 if (!blank_t->prev)
8530 {
8531 blank_t->total_size = 0;
8532 blank_t = blank_t->next;
8533 }
8534
8535 while (blank_t)
8536 {
8537 blank_t->total_size = blank_t->prev->total_size + blank_t->prev->size;
8538 blank_t = blank_t->next;
8539 }
8540
8541 return TRUE;
8542 }
8543
8544 static void
8545 calc_nds32_blank_total (nds32_elf_blank_t *blank_p)
8546 {
8547 nds32_elf_blank_t *blank_t;
8548 bfd_vma total_size = 0;
8549
8550 if (!blank_p)
8551 return;
8552
8553 blank_t = blank_p;
8554 while (blank_t->prev)
8555 blank_t = blank_t->prev;
8556 while (blank_t)
8557 {
8558 blank_t->total_size = total_size;
8559 total_size += blank_t->size;
8560 blank_t = blank_t->next;
8561 }
8562 }
8563
8564 static bfd_boolean
8565 nds32_elf_relax_delete_blanks (bfd *abfd, asection *sec,
8566 nds32_elf_blank_t *blank_p)
8567 {
8568 Elf_Internal_Shdr *symtab_hdr; /* Symbol table header of this bfd. */
8569 Elf_Internal_Sym *isym = NULL; /* Symbol table of this bfd. */
8570 Elf_Internal_Sym *isymend; /* Symbol entry iterator. */
8571 unsigned int sec_shndx; /* The section the be relaxed. */
8572 bfd_byte *contents; /* Contents data of iterating section. */
8573 Elf_Internal_Rela *internal_relocs;
8574 Elf_Internal_Rela *irel;
8575 Elf_Internal_Rela *irelend;
8576 struct elf_link_hash_entry **sym_hashes;
8577 struct elf_link_hash_entry **end_hashes;
8578 unsigned int symcount;
8579 asection *sect;
8580 nds32_elf_blank_t *blank_t;
8581 nds32_elf_blank_t *blank_t2;
8582 nds32_elf_blank_t *blank_head;
8583
8584 blank_head = blank_t = blank_p;
8585 while (blank_head->prev != NULL)
8586 blank_head = blank_head->prev;
8587 while (blank_t->next != NULL)
8588 blank_t = blank_t->next;
8589
8590 if (blank_t->offset + blank_t->size <= sec->size)
8591 {
8592 blank_t->next = create_nds32_elf_blank (sec->size + 4, 0);
8593 blank_t->next->prev = blank_t;
8594 }
8595 if (blank_head->offset > 0)
8596 {
8597 blank_head->prev = create_nds32_elf_blank (0, 0);
8598 blank_head->prev->next = blank_head;
8599 blank_head = blank_head->prev;
8600 }
8601
8602 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
8603
8604 /* The deletion must stop at the next ALIGN reloc for an alignment
8605 power larger than the number of bytes we are deleting. */
8606
8607 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8608 if (!nds32_get_local_syms (abfd, sec, &isym))
8609 return FALSE;
8610
8611 if (isym == NULL)
8612 {
8613 isym = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8614 symtab_hdr->sh_info, 0, NULL, NULL, NULL);
8615 symtab_hdr->contents = (bfd_byte *) isym;
8616 }
8617
8618 if (isym == NULL || symtab_hdr->sh_info == 0)
8619 return FALSE;
8620
8621 blank_t = blank_head;
8622 calc_nds32_blank_total (blank_head);
8623
8624 for (sect = abfd->sections; sect != NULL; sect = sect->next)
8625 {
8626 /* Adjust all the relocs. */
8627
8628 /* Relocations MUST be kept in memory, because relaxation adjust them. */
8629 internal_relocs = _bfd_elf_link_read_relocs (abfd, sect, NULL, NULL,
8630 TRUE /* keep_memory */);
8631 irelend = internal_relocs + sect->reloc_count;
8632
8633 blank_t = blank_head;
8634 blank_t2 = blank_head;
8635
8636 if (!(sect->flags & SEC_RELOC))
8637 continue;
8638
8639 nds32_get_section_contents (abfd, sect, &contents, TRUE);
8640
8641 for (irel = internal_relocs; irel < irelend; irel++)
8642 {
8643 bfd_vma raddr;
8644
8645 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_DIFF8
8646 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_DIFF32
8647 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
8648 {
8649 unsigned long val = 0;
8650 unsigned long mask;
8651 long before, between;
8652 long offset = 0;
8653
8654 switch (ELF32_R_TYPE (irel->r_info))
8655 {
8656 case R_NDS32_DIFF8:
8657 offset = bfd_get_8 (abfd, contents + irel->r_offset);
8658 break;
8659 case R_NDS32_DIFF16:
8660 offset = bfd_get_16 (abfd, contents + irel->r_offset);
8661 break;
8662 case R_NDS32_DIFF32:
8663 val = bfd_get_32 (abfd, contents + irel->r_offset);
8664 /* Get the signed bit and mask for the high part. The
8665 gcc will alarm when right shift 32-bit since the
8666 type size of long may be 32-bit. */
8667 mask = 0 - (val >> 31);
8668 if (mask)
8669 offset = (val | (mask - 0xffffffff));
8670 else
8671 offset = val;
8672 break;
8673 default:
8674 BFD_ASSERT (0);
8675 }
8676
8677 /* DIFF value
8678 0 |encoded in location|
8679 |------------|-------------------|---------
8680 sym+off(addend)
8681 -- before ---| *****************
8682 --------------------- between ---|
8683
8684 We only care how much data are relax between DIFF,
8685 marked as ***. */
8686
8687 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
8688 between = get_nds32_elf_blank_total (&blank_t,
8689 irel->r_addend + offset, 0);
8690 if (between == before)
8691 goto done_adjust_diff;
8692
8693 switch (ELF32_R_TYPE (irel->r_info))
8694 {
8695 case R_NDS32_DIFF8:
8696 bfd_put_8 (abfd, offset - (between - before),
8697 contents + irel->r_offset);
8698 break;
8699 case R_NDS32_DIFF16:
8700 bfd_put_16 (abfd, offset - (between - before),
8701 contents + irel->r_offset);
8702 break;
8703 case R_NDS32_DIFF32:
8704 bfd_put_32 (abfd, offset - (between - before),
8705 contents + irel->r_offset);
8706 break;
8707 }
8708 }
8709 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_DIFF_ULEB128
8710 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
8711 {
8712 bfd_vma val = 0;
8713 unsigned int len = 0;
8714 unsigned long before, between;
8715 bfd_byte *endp, *p;
8716
8717 val = read_unsigned_leb128 (abfd, contents + irel->r_offset,
8718 &len);
8719
8720 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
8721 between = get_nds32_elf_blank_total (&blank_t,
8722 irel->r_addend + val, 0);
8723 if (between == before)
8724 goto done_adjust_diff;
8725
8726 p = contents + irel->r_offset;
8727 endp = p + len -1;
8728 memset (p, 0x80, len);
8729 *(endp) = 0;
8730 p = write_uleb128 (p, val - (between - before)) - 1;
8731 if (p < endp)
8732 *p |= 0x80;
8733 }
8734 done_adjust_diff:
8735
8736 if (sec == sect)
8737 {
8738 raddr = irel->r_offset;
8739 irel->r_offset -= get_nds32_elf_blank_total (&blank_t2,
8740 irel->r_offset, 1);
8741
8742 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
8743 continue;
8744 if (blank_t2 && blank_t2->next
8745 && (blank_t2->offset > raddr
8746 || blank_t2->next->offset <= raddr))
8747 _bfd_error_handler
8748 (_("%B: Error: search_nds32_elf_blank reports wrong node\n"), abfd);
8749
8750 /* Mark reloc in deleted portion as NONE.
8751 For some relocs like R_NDS32_LABEL that doesn't modify the
8752 content in the section. R_NDS32_LABEL doesn't belong to the
8753 instruction in the section, so we should preserve it. */
8754 if (raddr >= blank_t2->offset
8755 && raddr < blank_t2->offset + blank_t2->size
8756 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL
8757 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_BEGIN
8758 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
8759 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
8760 && ELF32_R_TYPE (irel->r_info) != R_NDS32_SUBTRAHEND
8761 && ELF32_R_TYPE (irel->r_info) != R_NDS32_MINUEND)
8762 {
8763 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
8764 R_NDS32_NONE);
8765 continue;
8766 }
8767 }
8768
8769 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE
8770 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
8771 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
8772 continue;
8773
8774 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info
8775 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx
8776 && ELF_ST_TYPE (isym[ELF32_R_SYM (irel->r_info)].st_info) == STT_SECTION)
8777 {
8778 if (irel->r_addend <= sec->size)
8779 irel->r_addend -=
8780 get_nds32_elf_blank_total (&blank_t, irel->r_addend, 1);
8781 }
8782 }
8783 }
8784
8785 /* Adjust the local symbols defined in this section. */
8786 blank_t = blank_head;
8787 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
8788 {
8789 if (isym->st_shndx == sec_shndx)
8790 {
8791 if (isym->st_value <= sec->size)
8792 {
8793 bfd_vma ahead;
8794 bfd_vma orig_addr = isym->st_value;
8795
8796 ahead = get_nds32_elf_blank_total (&blank_t, isym->st_value, 1);
8797 isym->st_value -= ahead;
8798
8799 /* Adjust function size. */
8800 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC
8801 && isym->st_size > 0)
8802 isym->st_size -=
8803 get_nds32_elf_blank_total
8804 (&blank_t, orig_addr + isym->st_size, 0) - ahead;
8805 }
8806 }
8807 }
8808
8809 /* Now adjust the global symbols defined in this section. */
8810 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
8811 - symtab_hdr->sh_info);
8812 sym_hashes = elf_sym_hashes (abfd);
8813 end_hashes = sym_hashes + symcount;
8814 blank_t = blank_head;
8815 for (; sym_hashes < end_hashes; sym_hashes++)
8816 {
8817 struct elf_link_hash_entry *sym_hash = *sym_hashes;
8818
8819 if ((sym_hash->root.type == bfd_link_hash_defined
8820 || sym_hash->root.type == bfd_link_hash_defweak)
8821 && sym_hash->root.u.def.section == sec)
8822 {
8823 if (sym_hash->root.u.def.value <= sec->size)
8824 {
8825 bfd_vma ahead;
8826 bfd_vma orig_addr = sym_hash->root.u.def.value;
8827
8828 ahead = get_nds32_elf_blank_total (&blank_t, sym_hash->root.u.def.value, 1);
8829 sym_hash->root.u.def.value -= ahead;
8830
8831 /* Adjust function size. */
8832 if (sym_hash->type == STT_FUNC)
8833 sym_hash->size -=
8834 get_nds32_elf_blank_total
8835 (&blank_t, orig_addr + sym_hash->size, 0) - ahead;
8836
8837 }
8838 }
8839 }
8840
8841 contents = elf_section_data (sec)->this_hdr.contents;
8842 blank_t = blank_head;
8843 while (blank_t->next)
8844 {
8845 /* Actually delete the bytes. */
8846
8847 /* If current blank is the last blank overlap with current section,
8848 go to finish process. */
8849 if (sec->size <= (blank_t->next->offset))
8850 break;
8851
8852 memmove (contents + blank_t->offset - blank_t->total_size,
8853 contents + blank_t->offset + blank_t->size,
8854 blank_t->next->offset - (blank_t->offset + blank_t->size));
8855
8856 blank_t = blank_t->next;
8857 }
8858
8859 if (sec->size > (blank_t->offset + blank_t->size))
8860 {
8861 /* There are remaining code between blank and section boundary.
8862 Move the remaining code to appropriate location. */
8863 memmove (contents + blank_t->offset - blank_t->total_size,
8864 contents + blank_t->offset + blank_t->size,
8865 sec->size - (blank_t->offset + blank_t->size));
8866 sec->size -= blank_t->total_size + blank_t->size;
8867 }
8868 else
8869 /* This blank is not entirely included in the section,
8870 reduce the section size by only part of the blank size. */
8871 sec->size -= blank_t->total_size + (sec->size - blank_t->offset);
8872
8873 while (blank_head)
8874 {
8875 blank_t = blank_head;
8876 blank_head = blank_head->next;
8877 remove_nds32_elf_blank (blank_t);
8878 }
8879
8880 return TRUE;
8881 }
8882
8883 /* Get the contents of a section. */
8884
8885 static int
8886 nds32_get_section_contents (bfd *abfd, asection *sec,
8887 bfd_byte **contents_p, bfd_boolean cache)
8888 {
8889 /* Get the section contents. */
8890 if (elf_section_data (sec)->this_hdr.contents != NULL)
8891 *contents_p = elf_section_data (sec)->this_hdr.contents;
8892 else
8893 {
8894 if (!bfd_malloc_and_get_section (abfd, sec, contents_p))
8895 return FALSE;
8896 if (cache)
8897 elf_section_data (sec)->this_hdr.contents = *contents_p;
8898 }
8899
8900 return TRUE;
8901 }
8902
8903 /* Get the contents of the internal symbol of abfd. */
8904
8905 static int
8906 nds32_get_local_syms (bfd *abfd, asection *sec ATTRIBUTE_UNUSED,
8907 Elf_Internal_Sym **isymbuf_p)
8908 {
8909 Elf_Internal_Shdr *symtab_hdr;
8910 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8911
8912 /* Read this BFD's local symbols if we haven't done so already. */
8913 if (*isymbuf_p == NULL && symtab_hdr->sh_info != 0)
8914 {
8915 *isymbuf_p = (Elf_Internal_Sym *) symtab_hdr->contents;
8916 if (*isymbuf_p == NULL)
8917 {
8918 *isymbuf_p = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8919 symtab_hdr->sh_info, 0,
8920 NULL, NULL, NULL);
8921 if (*isymbuf_p == NULL)
8922 return FALSE;
8923 }
8924 }
8925 symtab_hdr->contents = (bfd_byte *) (*isymbuf_p);
8926
8927 return TRUE;
8928 }
8929
8930 /* Range of small data. */
8931 static bfd_vma sdata_range[2][2];
8932 static bfd_vma const sdata_init_range[2] =
8933 { ACCURATE_12BIT_S1, ACCURATE_19BIT };
8934
8935 static int
8936 nds32_elf_insn_size (bfd *abfd ATTRIBUTE_UNUSED,
8937 bfd_byte *contents, bfd_vma addr)
8938 {
8939 unsigned long insn = bfd_getb32 (contents + addr);
8940
8941 if (insn & 0x80000000)
8942 return 2;
8943
8944 return 4;
8945 }
8946
8947 /* Set the gp relax range. We have to measure the safe range
8948 to do gp relaxation. */
8949
8950 static void
8951 relax_range_measurement (bfd *abfd)
8952 {
8953 asection *sec_f, *sec_b;
8954 /* For upper bound. */
8955 bfd_vma maxpgsz = get_elf_backend_data (abfd)->maxpagesize;
8956 bfd_vma align;
8957 static int decide_relax_range = 0;
8958 int i;
8959 int range_number = sizeof (sdata_init_range) / sizeof (sdata_init_range[0]);
8960
8961 if (decide_relax_range)
8962 return;
8963 decide_relax_range = 1;
8964
8965 if (sda_rela_sec == NULL)
8966 {
8967 /* Since there is no data sections, we assume the range is page size. */
8968 for (i = 0; i < range_number; i++)
8969 {
8970 sdata_range[i][0] = sdata_init_range[i] - 0x1000;
8971 sdata_range[i][1] = sdata_init_range[i] - 0x1000;
8972 }
8973 return;
8974 }
8975
8976 /* Get the biggest alignment power after the gp located section. */
8977 sec_f = sda_rela_sec->output_section;
8978 sec_b = sec_f->next;
8979 align = 0;
8980 while (sec_b != NULL)
8981 {
8982 if ((unsigned)(1 << sec_b->alignment_power) > align)
8983 align = (1 << sec_b->alignment_power);
8984 sec_b = sec_b->next;
8985 }
8986
8987 /* I guess we can not determine the section before
8988 gp located section, so we assume the align is max page size. */
8989 for (i = 0; i < range_number; i++)
8990 {
8991 sdata_range[i][1] = sdata_init_range[i] - align;
8992 BFD_ASSERT (sdata_range[i][1] <= sdata_init_range[i]);
8993 sdata_range[i][0] = sdata_init_range[i] - maxpgsz;
8994 BFD_ASSERT (sdata_range[i][0] <= sdata_init_range[i]);
8995 }
8996 }
8997
8998 /* These are macros used to check flags encoded in r_addend.
8999 They are only used by nds32_elf_relax_section (). */
9000 #define GET_SEQ_LEN(addend) ((addend) & 0x000000ff)
9001 #define IS_1ST_CONVERT(addend) ((addend) & 0x80000000)
9002 #define IS_OPTIMIZE(addend) ((addend) & 0x40000000)
9003 #define IS_16BIT_ON(addend) ((addend) & 0x20000000)
9004
9005 static const char * unrecognized_reloc_msg =
9006 /* xgettext:c-format */
9007 N_("%B: warning: %s points to unrecognized reloc at 0x%lx.");
9008
9009 /* Relax LONGCALL1 relocation for nds32_elf_relax_section. */
9010
9011 static bfd_boolean
9012 nds32_elf_relax_longcall1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9013 Elf_Internal_Rela *internal_relocs, int *insn_len,
9014 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9015 Elf_Internal_Shdr *symtab_hdr)
9016 {
9017 /* There are 3 variations for LONGCALL1
9018 case 4-4-2; 16-bit on, optimize off or optimize for space
9019 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9020 ori ta, ta, lo12(symbol) ; LO12S0
9021 jral5 ta ;
9022
9023 case 4-4-4; 16-bit off, optimize don't care
9024 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9025 ori ta, ta, lo12(symbol) ; LO12S0
9026 jral ta ;
9027
9028 case 4-4-4; 16-bit on, optimize for speed
9029 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9030 ori ta, ta, lo12(symbol) ; LO12S0
9031 jral ta ;
9032 Check code for -mlong-calls output. */
9033
9034 /* Get the reloc for the address from which the register is
9035 being loaded. This reloc will tell us which function is
9036 actually being called. */
9037
9038 bfd_vma laddr;
9039 int seq_len; /* Original length of instruction sequence. */
9040 uint32_t insn;
9041 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9042 int pic_ext_target = 0;
9043 bfd_signed_vma foff;
9044 uint16_t insn16;
9045
9046 irelend = internal_relocs + sec->reloc_count;
9047 seq_len = GET_SEQ_LEN (irel->r_addend);
9048 laddr = irel->r_offset;
9049 *insn_len = seq_len;
9050
9051 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9052 R_NDS32_HI20_RELA, laddr);
9053 lo_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9054 R_NDS32_LO12S0_ORI_RELA,
9055 laddr + 4);
9056
9057 if (hi_irelfn == irelend || lo_irelfn == irelend)
9058 {
9059 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL1",
9060 (long) irel->r_offset);
9061 return FALSE;
9062 }
9063
9064 /* Get the value of the symbol referred to by the reloc. */
9065 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9066 &pic_ext_target);
9067
9068 /* This condition only happened when symbol is undefined. */
9069 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9070 || foff >= CONSERVATIVE_24BIT_S1)
9071 return FALSE;
9072
9073 /* Relax to: jal symbol; 25_PCREL */
9074 /* For simplicity of coding, we are going to modify the section
9075 contents, the section relocs, and the BFD symbol table. We
9076 must tell the rest of the code not to free up this
9077 information. It would be possible to instead create a table
9078 of changes which have to be made, as is done in coff-mips.c;
9079 that would be more work, but would require less memory when
9080 the linker is run. */
9081
9082 /* Replace the long call with a jal. */
9083 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9084 R_NDS32_25_PCREL_RELA);
9085 irel->r_addend = hi_irelfn->r_addend;
9086
9087 /* We don't resolve this here but resolve it in relocate_section. */
9088 insn = INSN_JAL;
9089 bfd_putb32 (insn, contents + irel->r_offset);
9090
9091 hi_irelfn->r_info =
9092 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9093 lo_irelfn->r_info =
9094 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9095 *insn_len = 4;
9096
9097 if (seq_len & 0x2)
9098 {
9099 insn16 = NDS32_NOP16;
9100 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9101 lo_irelfn->r_info =
9102 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9103 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9104 *insn_len += 2;
9105 }
9106 return TRUE;
9107 }
9108
9109 #define CONVERT_CONDITION_CALL(insn) (((insn) & 0xffff0000) ^ 0x90000)
9110 /* Relax LONGCALL2 relocation for nds32_elf_relax_section. */
9111
9112 static bfd_boolean
9113 nds32_elf_relax_longcall2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9114 Elf_Internal_Rela *internal_relocs, int *insn_len,
9115 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9116 Elf_Internal_Shdr *symtab_hdr)
9117 {
9118 /* bltz rt, .L1 ; LONGCALL2
9119 jal symbol ; 25_PCREL
9120 .L1: */
9121
9122 /* Get the reloc for the address from which the register is
9123 being loaded. This reloc will tell us which function is
9124 actually being called. */
9125
9126 bfd_vma laddr;
9127 uint32_t insn;
9128 Elf_Internal_Rela *i1_irelfn, *cond_irelfn, *irelend;
9129 int pic_ext_target = 0;
9130 bfd_signed_vma foff;
9131
9132 irelend = internal_relocs + sec->reloc_count;
9133 laddr = irel->r_offset;
9134 i1_irelfn =
9135 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9136 R_NDS32_25_PCREL_RELA, laddr + 4);
9137
9138 if (i1_irelfn == irelend)
9139 {
9140 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL2",
9141 (long) irel->r_offset);
9142 return FALSE;
9143 }
9144
9145 insn = bfd_getb32 (contents + laddr);
9146
9147 /* Get the value of the symbol referred to by the reloc. */
9148 foff = calculate_offset (abfd, sec, i1_irelfn, isymbuf, symtab_hdr,
9149 &pic_ext_target);
9150
9151 if (foff == 0 || foff < -CONSERVATIVE_16BIT_S1
9152 || foff >= CONSERVATIVE_16BIT_S1)
9153 return FALSE;
9154
9155 /* Relax to bgezal rt, label ; 17_PCREL
9156 or bltzal rt, label ; 17_PCREL */
9157
9158 /* Convert to complimentary conditional call. */
9159 insn = CONVERT_CONDITION_CALL (insn);
9160
9161 /* For simplicity of coding, we are going to modify the section
9162 contents, the section relocs, and the BFD symbol table. We
9163 must tell the rest of the code not to free up this
9164 information. It would be possible to instead create a table
9165 of changes which have to be made, as is done in coff-mips.c;
9166 that would be more work, but would require less memory when
9167 the linker is run. */
9168
9169 /* Clean unnessary relocations. */
9170 i1_irelfn->r_info =
9171 ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info), R_NDS32_NONE);
9172 cond_irelfn =
9173 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9174 R_NDS32_17_PCREL_RELA, laddr);
9175 if (cond_irelfn != irelend)
9176 cond_irelfn->r_info =
9177 ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info), R_NDS32_NONE);
9178
9179 /* Replace the long call with a bgezal. */
9180 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info),
9181 R_NDS32_17_PCREL_RELA);
9182 irel->r_addend = i1_irelfn->r_addend;
9183
9184 bfd_putb32 (insn, contents + irel->r_offset);
9185
9186 *insn_len = 4;
9187 return TRUE;
9188 }
9189
9190 /* Relax LONGCALL3 relocation for nds32_elf_relax_section. */
9191
9192 static bfd_boolean
9193 nds32_elf_relax_longcall3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9194 Elf_Internal_Rela *internal_relocs, int *insn_len,
9195 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9196 Elf_Internal_Shdr *symtab_hdr)
9197 {
9198 /* There are 3 variations for LONGCALL3
9199 case 4-4-4-2; 16-bit on, optimize off or optimize for space
9200 bltz rt, $1 ; LONGCALL3
9201 sethi ta, hi20(symbol) ; HI20
9202 ori ta, ta, lo12(symbol) ; LO12S0
9203 jral5 ta ;
9204 $1
9205
9206 case 4-4-4-4; 16-bit off, optimize don't care
9207 bltz rt, $1 ; LONGCALL3
9208 sethi ta, hi20(symbol) ; HI20
9209 ori ta, ta, lo12(symbol) ; LO12S0
9210 jral ta ;
9211 $1
9212
9213 case 4-4-4-4; 16-bit on, optimize for speed
9214 bltz rt, $1 ; LONGCALL3
9215 sethi ta, hi20(symbol) ; HI20
9216 ori ta, ta, lo12(symbol) ; LO12S0
9217 jral ta ;
9218 $1 */
9219
9220 /* Get the reloc for the address from which the register is
9221 being loaded. This reloc will tell us which function is
9222 actually being called. */
9223
9224 bfd_vma laddr;
9225 int seq_len; /* Original length of instruction sequence. */
9226 uint32_t insn;
9227 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9228 int pic_ext_target = 0;
9229 bfd_signed_vma foff;
9230 uint16_t insn16;
9231
9232 irelend = internal_relocs + sec->reloc_count;
9233 seq_len = GET_SEQ_LEN (irel->r_addend);
9234 laddr = irel->r_offset;
9235 *insn_len = seq_len;
9236
9237 hi_irelfn =
9238 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9239 R_NDS32_HI20_RELA, laddr + 4);
9240 lo_irelfn =
9241 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9242 R_NDS32_LO12S0_ORI_RELA, laddr + 8);
9243
9244 if (hi_irelfn == irelend || lo_irelfn == irelend)
9245 {
9246 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL3",
9247 (long) irel->r_offset);
9248 return FALSE;
9249 }
9250
9251 /* Get the value of the symbol referred to by the reloc. */
9252 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9253 &pic_ext_target);
9254
9255 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9256 || foff >= CONSERVATIVE_24BIT_S1)
9257 return FALSE;
9258
9259 insn = bfd_getb32 (contents + laddr);
9260 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
9261 {
9262 /* Relax to bgezal rt, label ; 17_PCREL
9263 or bltzal rt, label ; 17_PCREL */
9264
9265 /* Convert to complimentary conditional call. */
9266 insn = CONVERT_CONDITION_CALL (insn);
9267 bfd_putb32 (insn, contents + irel->r_offset);
9268
9269 *insn_len = 4;
9270 irel->r_info =
9271 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9272 hi_irelfn->r_info =
9273 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9274 lo_irelfn->r_info =
9275 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9276
9277 cond_irelfn =
9278 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9279 R_NDS32_17_PCREL_RELA, laddr);
9280 if (cond_irelfn != irelend)
9281 {
9282 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9283 R_NDS32_17_PCREL_RELA);
9284 cond_irelfn->r_addend = hi_irelfn->r_addend;
9285 }
9286
9287 if (seq_len & 0x2)
9288 {
9289 insn16 = NDS32_NOP16;
9290 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9291 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9292 R_NDS32_INSN16);
9293 hi_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9294 insn_len += 2;
9295 }
9296 }
9297 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
9298 {
9299 /* Relax to the following instruction sequence
9300 bltz rt, $1 ; LONGCALL2
9301 jal symbol ; 25_PCREL
9302 $1 */
9303 *insn_len = 8;
9304 insn = INSN_JAL;
9305 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9306
9307 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9308 R_NDS32_25_PCREL_RELA);
9309 irel->r_info =
9310 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL2);
9311
9312 lo_irelfn->r_info =
9313 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9314
9315 if (seq_len & 0x2)
9316 {
9317 insn16 = NDS32_NOP16;
9318 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9319 lo_irelfn->r_info =
9320 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9321 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9322 insn_len += 2;
9323 }
9324 }
9325 return TRUE;
9326 }
9327
9328 /* Relax LONGJUMP1 relocation for nds32_elf_relax_section. */
9329
9330 static bfd_boolean
9331 nds32_elf_relax_longjump1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9332 Elf_Internal_Rela *internal_relocs, int *insn_len,
9333 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9334 Elf_Internal_Shdr *symtab_hdr)
9335 {
9336 /* There are 3 variations for LONGJUMP1
9337 case 4-4-2; 16-bit bit on, optimize off or optimize for space
9338 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9339 ori ta, ta, lo12(symbol) ; LO12S0
9340 jr5 ta ;
9341
9342 case 4-4-4; 16-bit off, optimize don't care
9343 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9344 ori ta, ta, lo12(symbol) ; LO12S0
9345 jr ta ;
9346
9347 case 4-4-4; 16-bit on, optimize for speed
9348 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9349 ori ta, ta, lo12(symbol) ; LO12S0
9350 jr ta ; */
9351
9352 /* Get the reloc for the address from which the register is
9353 being loaded. This reloc will tell us which function is
9354 actually being called. */
9355
9356 bfd_vma laddr;
9357 int seq_len; /* Original length of instruction sequence. */
9358 int insn16_on; /* 16-bit on/off. */
9359 uint32_t insn;
9360 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9361 int pic_ext_target = 0;
9362 bfd_signed_vma foff;
9363 uint16_t insn16;
9364 unsigned long reloc;
9365
9366 irelend = internal_relocs + sec->reloc_count;
9367 seq_len = GET_SEQ_LEN (irel->r_addend);
9368 laddr = irel->r_offset;
9369 *insn_len = seq_len;
9370 insn16_on = IS_16BIT_ON (irel->r_addend);
9371
9372 hi_irelfn =
9373 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9374 R_NDS32_HI20_RELA, laddr);
9375 lo_irelfn =
9376 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9377 R_NDS32_LO12S0_ORI_RELA, laddr + 4);
9378 if (hi_irelfn == irelend || lo_irelfn == irelend)
9379 {
9380 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP1",
9381 (long) irel->r_offset);
9382 return FALSE;
9383 }
9384
9385 /* Get the value of the symbol referred to by the reloc. */
9386 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9387 &pic_ext_target);
9388
9389 if (pic_ext_target || foff == 0 || foff >= CONSERVATIVE_24BIT_S1
9390 || foff < -CONSERVATIVE_24BIT_S1)
9391 return FALSE;
9392
9393 if (insn16_on && foff >= -ACCURATE_8BIT_S1
9394 && foff < ACCURATE_8BIT_S1 && (seq_len & 0x2))
9395 {
9396 /* j8 label */
9397 /* 16-bit on, but not optimized for speed. */
9398 reloc = R_NDS32_9_PCREL_RELA;
9399 insn16 = INSN_J8;
9400 bfd_putb16 (insn16, contents + irel->r_offset);
9401 *insn_len = 2;
9402 irel->r_info =
9403 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
9404 }
9405 else
9406 {
9407 /* j label */
9408 reloc = R_NDS32_25_PCREL_RELA;
9409 insn = INSN_J;
9410 bfd_putb32 (insn, contents + irel->r_offset);
9411 *insn_len = 4;
9412 irel->r_info =
9413 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_INSN16);
9414 irel->r_addend = 0;
9415 }
9416
9417 hi_irelfn->r_info =
9418 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
9419 lo_irelfn->r_info =
9420 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9421
9422 if ((seq_len & 0x2) && ((*insn_len & 2) == 0))
9423 {
9424 insn16 = NDS32_NOP16;
9425 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9426 lo_irelfn->r_info =
9427 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9428 R_NDS32_INSN16);
9429 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9430 *insn_len += 2;
9431 }
9432 return TRUE;
9433 }
9434
9435 /* Revert condition branch. This function does not check if the input
9436 instruction is condition branch or not. */
9437
9438 static void
9439 nds32_elf_convert_branch (uint16_t insn16, uint32_t insn,
9440 uint16_t *re_insn16, uint32_t *re_insn)
9441 {
9442 uint32_t comp_insn = 0;
9443 uint16_t comp_insn16 = 0;
9444
9445 if (insn)
9446 {
9447 if (N32_OP6 (insn) == N32_OP6_BR1)
9448 {
9449 /* beqs label. */
9450 comp_insn = (insn ^ 0x4000) & 0xffffc000;
9451 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5)
9452 {
9453 /* Insn can be contracted to 16-bit implied r5. */
9454 comp_insn16 =
9455 (comp_insn & 0x4000) ? INSN_BNES38 : INSN_BEQS38;
9456 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
9457 }
9458 }
9459 else if (N32_OP6 (insn) == N32_OP6_BR3)
9460 {
9461 /* bnec $ta, imm11, label. */
9462 comp_insn = (insn ^ 0x80000) & 0xffffff00;
9463 }
9464 else
9465 {
9466 comp_insn = (insn ^ 0x10000) & 0xffffc000;
9467 if (N32_BR2_SUB (insn) == N32_BR2_BEQZ
9468 || N32_BR2_SUB (insn) == N32_BR2_BNEZ)
9469 {
9470 if (N32_IS_RT3 (insn))
9471 {
9472 /* Insn can be contracted to 16-bit. */
9473 comp_insn16 =
9474 (comp_insn & 0x10000) ? INSN_BNEZ38 : INSN_BEQZ38;
9475 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
9476 }
9477 else if (N32_RT5 (insn) == REG_R15)
9478 {
9479 /* Insn can be contracted to 16-bit. */
9480 comp_insn16 =
9481 (comp_insn & 0x10000) ? INSN_BNES38 : INSN_BEQS38;
9482 }
9483 }
9484 }
9485 }
9486 else
9487 {
9488 switch ((insn16 & 0xf000) >> 12)
9489 {
9490 case 0xc:
9491 /* beqz38 or bnez38 */
9492 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
9493 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNEZ : INSN_BEQZ;
9494 comp_insn |= ((comp_insn16 & 0x0700) >> 8) << 20;
9495 break;
9496
9497 case 0xd:
9498 /* beqs38 or bnes38 */
9499 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
9500 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNE : INSN_BEQ;
9501 comp_insn |= (((comp_insn16 & 0x0700) >> 8) << 20)
9502 | (REG_R5 << 15);
9503 break;
9504
9505 case 0xe:
9506 /* beqzS8 or bnezS8 */
9507 comp_insn16 = (insn16 ^ 0x0100) & 0xff00;
9508 comp_insn = (comp_insn16 & 0x0100) ? INSN_BNEZ : INSN_BEQZ;
9509 comp_insn |= REG_R15 << 20;
9510 break;
9511
9512 default:
9513 break;
9514 }
9515 }
9516 if (comp_insn && re_insn)
9517 *re_insn = comp_insn;
9518 if (comp_insn16 && re_insn16)
9519 *re_insn16 = comp_insn16;
9520 }
9521
9522 /* Relax LONGJUMP2 relocation for nds32_elf_relax_section. */
9523
9524 static bfd_boolean
9525 nds32_elf_relax_longjump2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9526 Elf_Internal_Rela *internal_relocs, int *insn_len,
9527 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9528 Elf_Internal_Shdr *symtab_hdr)
9529 {
9530 /* There are 3 variations for LONGJUMP2
9531 case 2-4; 1st insn convertible, 16-bit on,
9532 optimize off or optimize for space
9533 bnes38 rt, ra, $1 ; LONGJUMP2
9534 j label ; 25_PCREL
9535 $1:
9536
9537 case 4-4; 1st insn not convertible
9538 bne rt, ra, $1 ; LONGJUMP2
9539 j label ; 25_PCREL
9540 $1:
9541
9542 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
9543 bne rt, ra, $1 ; LONGJUMP2
9544 j label ; 25_PCREL
9545 $1: */
9546
9547 /* Get the reloc for the address from which the register is
9548 being loaded. This reloc will tell us which function is
9549 actually being called. */
9550
9551 bfd_vma laddr;
9552 int seq_len; /* Original length of instruction sequence. */
9553 Elf_Internal_Rela *i2_irelfn, *cond_irelfn, *irelend;
9554 int pic_ext_target = 0, first_size;
9555 unsigned int i;
9556 bfd_signed_vma foff;
9557 uint32_t insn, re_insn = 0;
9558 uint16_t insn16, re_insn16 = 0;
9559 unsigned long reloc, cond_reloc;
9560
9561 enum elf_nds32_reloc_type checked_types[] =
9562 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
9563
9564 irelend = internal_relocs + sec->reloc_count;
9565 seq_len = GET_SEQ_LEN (irel->r_addend);
9566 laddr = irel->r_offset;
9567 *insn_len = seq_len;
9568 first_size = (seq_len == 6) ? 2 : 4;
9569
9570 i2_irelfn =
9571 find_relocs_at_address_addr (irel, internal_relocs,
9572 irelend, R_NDS32_25_PCREL_RELA,
9573 laddr + first_size);
9574
9575 for (i = 0; i < sizeof (checked_types) / sizeof(checked_types[0]); i++)
9576 {
9577 cond_irelfn =
9578 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9579 checked_types[i], laddr);
9580 if (cond_irelfn != irelend)
9581 break;
9582 }
9583
9584 if (i2_irelfn == irelend || cond_irelfn == irelend)
9585 {
9586 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP2",
9587 (long) irel->r_offset);
9588 return FALSE;
9589 }
9590
9591 /* Get the value of the symbol referred to by the reloc. */
9592 foff =
9593 calculate_offset (abfd, sec, i2_irelfn, isymbuf, symtab_hdr,
9594 &pic_ext_target);
9595 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_16BIT_S1
9596 || foff >= CONSERVATIVE_16BIT_S1)
9597 return FALSE;
9598
9599 /* Get the all corresponding instructions. */
9600 if (first_size == 4)
9601 {
9602 insn = bfd_getb32 (contents + laddr);
9603 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
9604 }
9605 else
9606 {
9607 insn16 = bfd_getb16 (contents + laddr);
9608 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
9609 }
9610
9611 if (re_insn16 && foff >= -(ACCURATE_8BIT_S1 - first_size)
9612 && foff < ACCURATE_8BIT_S1 - first_size)
9613 {
9614 if (first_size == 4)
9615 {
9616 /* Don't convert it to 16-bit now, keep this as relaxable for
9617 ``label reloc; INSN16''. */
9618
9619 /* Save comp_insn32 to buffer. */
9620 bfd_putb32 (re_insn, contents + irel->r_offset);
9621 *insn_len = 4;
9622 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
9623 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
9624 cond_reloc = R_NDS32_INSN16;
9625 }
9626 else
9627 {
9628 bfd_putb16 (re_insn16, contents + irel->r_offset);
9629 *insn_len = 2;
9630 reloc = R_NDS32_9_PCREL_RELA;
9631 cond_reloc = R_NDS32_NONE;
9632 }
9633 }
9634 else if (N32_OP6 (re_insn) == N32_OP6_BR1
9635 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
9636 && foff < ACCURATE_14BIT_S1 - first_size))
9637 {
9638 /* beqs label ; 15_PCREL */
9639 bfd_putb32 (re_insn, contents + irel->r_offset);
9640 *insn_len = 4;
9641 reloc = R_NDS32_15_PCREL_RELA;
9642 cond_reloc = R_NDS32_NONE;
9643 }
9644 else if (N32_OP6 (re_insn) == N32_OP6_BR2
9645 && foff >= -CONSERVATIVE_16BIT_S1
9646 && foff < CONSERVATIVE_16BIT_S1)
9647 {
9648 /* beqz label ; 17_PCREL */
9649 bfd_putb32 (re_insn, contents + irel->r_offset);
9650 *insn_len = 4;
9651 reloc = R_NDS32_17_PCREL_RELA;
9652 cond_reloc = R_NDS32_NONE;
9653 }
9654 else
9655 return FALSE;
9656
9657 /* Set all relocations. */
9658 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info), reloc);
9659 irel->r_addend = i2_irelfn->r_addend;
9660
9661 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
9662 cond_reloc);
9663 cond_irelfn->r_addend = 0;
9664
9665 if ((seq_len ^ *insn_len ) & 0x2)
9666 {
9667 insn16 = NDS32_NOP16;
9668 bfd_putb16 (insn16, contents + irel->r_offset + 4);
9669 i2_irelfn->r_offset = 4;
9670 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
9671 R_NDS32_INSN16);
9672 i2_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9673 *insn_len += 2;
9674 }
9675 else
9676 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
9677 R_NDS32_NONE);
9678 return TRUE;
9679 }
9680
9681 /* Relax LONGJUMP3 relocation for nds32_elf_relax_section. */
9682
9683 static bfd_boolean
9684 nds32_elf_relax_longjump3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9685 Elf_Internal_Rela *internal_relocs, int *insn_len,
9686 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9687 Elf_Internal_Shdr *symtab_hdr)
9688 {
9689 /* There are 5 variations for LONGJUMP3
9690 case 1: 2-4-4-2; 1st insn convertible, 16-bit on,
9691 optimize off or optimize for space
9692 bnes38 rt, ra, $1 ; LONGJUMP3
9693 sethi ta, hi20(symbol) ; HI20
9694 ori ta, ta, lo12(symbol) ; LO12S0
9695 jr5 ta ;
9696 $1: ;
9697
9698 case 2: 2-4-4-2; 1st insn convertible, 16-bit on, optimize for speed
9699 bnes38 rt, ra, $1 ; LONGJUMP3
9700 sethi ta, hi20(symbol) ; HI20
9701 ori ta, ta, lo12(symbol) ; LO12S0
9702 jr5 ta ;
9703 $1: ; LABEL
9704
9705 case 3: 4-4-4-2; 1st insn not convertible, 16-bit on,
9706 optimize off or optimize for space
9707 bne rt, ra, $1 ; LONGJUMP3
9708 sethi ta, hi20(symbol) ; HI20
9709 ori ta, ta, lo12(symbol) ; LO12S0
9710 jr5 ta ;
9711 $1: ;
9712
9713 case 4: 4-4-4-4; 1st insn don't care, 16-bit off, optimize don't care
9714 16-bit off if no INSN16
9715 bne rt, ra, $1 ; LONGJUMP3
9716 sethi ta, hi20(symbol) ; HI20
9717 ori ta, ta, lo12(symbol) ; LO12S0
9718 jr ta ;
9719 $1: ;
9720
9721 case 5: 4-4-4-4; 1st insn not convertible, 16-bit on, optimize for speed
9722 16-bit off if no INSN16
9723 bne rt, ra, $1 ; LONGJUMP3
9724 sethi ta, hi20(symbol) ; HI20
9725 ori ta, ta, lo12(symbol) ; LO12S0
9726 jr ta ;
9727 $1: ; LABEL */
9728
9729 /* Get the reloc for the address from which the register is
9730 being loaded. This reloc will tell us which function is
9731 actually being called. */
9732 enum elf_nds32_reloc_type checked_types[] =
9733 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
9734
9735 int reloc_off = 0, cond_removed = 0, convertible;
9736 bfd_vma laddr;
9737 int seq_len; /* Original length of instruction sequence. */
9738 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9739 int pic_ext_target = 0, first_size;
9740 unsigned int i;
9741 bfd_signed_vma foff;
9742 uint32_t insn, re_insn = 0;
9743 uint16_t insn16, re_insn16 = 0;
9744 unsigned long reloc, cond_reloc;
9745
9746 irelend = internal_relocs + sec->reloc_count;
9747 seq_len = GET_SEQ_LEN (irel->r_addend);
9748 laddr = irel->r_offset;
9749 *insn_len = seq_len;
9750
9751 convertible = IS_1ST_CONVERT (irel->r_addend);
9752
9753 if (convertible)
9754 first_size = 2;
9755 else
9756 first_size = 4;
9757
9758 /* Get all needed relocations. */
9759 hi_irelfn =
9760 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9761 R_NDS32_HI20_RELA, laddr + first_size);
9762 lo_irelfn =
9763 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9764 R_NDS32_LO12S0_ORI_RELA,
9765 laddr + first_size + 4);
9766
9767 for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
9768 {
9769 cond_irelfn =
9770 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9771 checked_types[i], laddr);
9772 if (cond_irelfn != irelend)
9773 break;
9774 }
9775
9776 if (hi_irelfn == irelend || lo_irelfn == irelend || cond_irelfn == irelend)
9777 {
9778 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP3",
9779 (long) irel->r_offset);
9780 return FALSE;
9781 }
9782
9783 /* Get the value of the symbol referred to by the reloc. */
9784 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9785 &pic_ext_target);
9786
9787 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9788 || foff >= CONSERVATIVE_24BIT_S1)
9789 return FALSE;
9790
9791 /* Get the all corresponding instructions. */
9792 if (first_size == 4)
9793 {
9794 insn = bfd_getb32 (contents + laddr);
9795 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
9796 }
9797 else
9798 {
9799 insn16 = bfd_getb16 (contents + laddr);
9800 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
9801 }
9802
9803 /* For simplicity of coding, we are going to modify the section
9804 contents, the section relocs, and the BFD symbol table. We
9805 must tell the rest of the code not to free up this
9806 information. It would be possible to instead create a table
9807 of changes which have to be made, as is done in coff-mips.c;
9808 that would be more work, but would require less memory when
9809 the linker is run. */
9810
9811 if (re_insn16 && foff >= -ACCURATE_8BIT_S1 - first_size
9812 && foff < ACCURATE_8BIT_S1 - first_size)
9813 {
9814 if (!(seq_len & 0x2))
9815 {
9816 /* Don't convert it to 16-bit now, keep this as relaxable
9817 for ``label reloc; INSN1a''6. */
9818 /* Save comp_insn32 to buffer. */
9819 bfd_putb32 (re_insn, contents + irel->r_offset);
9820 *insn_len = 4;
9821 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
9822 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
9823 cond_reloc = R_NDS32_INSN16;
9824 }
9825 else
9826 {
9827 /* Not optimize for speed; convert sequence to 16-bit. */
9828 /* Save comp_insn16 to buffer. */
9829 bfd_putb16 (re_insn16, contents + irel->r_offset);
9830 *insn_len = 2;
9831 reloc = R_NDS32_9_PCREL_RELA;
9832 cond_reloc = R_NDS32_NONE;
9833 }
9834 cond_removed = 1;
9835 }
9836 else if (N32_OP6 (re_insn) == N32_OP6_BR1
9837 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
9838 && foff < ACCURATE_14BIT_S1 - first_size))
9839 {
9840 /* beqs label ; 15_PCREL */
9841 bfd_putb32 (re_insn, contents + irel->r_offset);
9842 *insn_len = 4;
9843 reloc = R_NDS32_15_PCREL_RELA;
9844 cond_reloc = R_NDS32_NONE;
9845 cond_removed = 1;
9846 }
9847 else if (N32_OP6 (re_insn) == N32_OP6_BR2
9848 && foff >= -CONSERVATIVE_16BIT_S1
9849 && foff < CONSERVATIVE_16BIT_S1)
9850 {
9851 /* beqz label ; 17_PCREL */
9852 bfd_putb32 (re_insn, contents + irel->r_offset);
9853 *insn_len = 4;
9854 reloc = R_NDS32_17_PCREL_RELA;
9855 cond_reloc = R_NDS32_NONE;
9856 cond_removed = 1;
9857 }
9858 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
9859 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
9860 {
9861 /* Relax to one of the following 3 variations
9862
9863 case 2-4; 1st insn convertible, 16-bit on, optimize off or optimize
9864 for space
9865 bnes38 rt, $1 ; LONGJUMP2
9866 j label ; 25_PCREL
9867 $1
9868
9869 case 4-4; 1st insn not convertible, others don't care
9870 bne rt, ra, $1 ; LONGJUMP2
9871 j label ; 25_PCREL
9872 $1
9873
9874 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
9875 bne rt, ra, $1 ; LONGJUMP2
9876 j label ; 25_PCREL
9877 $1 */
9878
9879 /* Offset for first instruction. */
9880
9881 /* Use j label as second instruction. */
9882 *insn_len = 4 + first_size;
9883 insn = INSN_J;
9884 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9885 reloc = R_NDS32_LONGJUMP2;
9886 cond_reloc = R_NDS32_25_PLTREL;
9887 }
9888 else
9889 return FALSE;
9890
9891 if (cond_removed == 1)
9892 {
9893 /* Set all relocations. */
9894 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
9895 irel->r_addend = hi_irelfn->r_addend;
9896
9897 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
9898 cond_reloc);
9899 cond_irelfn->r_addend = 0;
9900 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9901 R_NDS32_NONE);
9902 }
9903 else
9904 {
9905 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
9906 irel->r_addend = irel->r_addend;
9907 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9908 cond_reloc);
9909 }
9910
9911 if ((seq_len ^ *insn_len ) & 0x2)
9912 {
9913 insn16 = NDS32_NOP16;
9914 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9915 lo_irelfn->r_offset = *insn_len;
9916 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9917 R_NDS32_INSN16);
9918 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9919 *insn_len += 2;
9920 }
9921 else
9922 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9923 R_NDS32_NONE);
9924 return TRUE;
9925 }
9926
9927 /* Relax LONGCALL4 relocation for nds32_elf_relax_section. */
9928
9929 static bfd_boolean
9930 nds32_elf_relax_longcall4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9931 Elf_Internal_Rela *internal_relocs, int *insn_len,
9932 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9933 Elf_Internal_Shdr *symtab_hdr)
9934 {
9935 /* The pattern for LONGCALL4. Support for function cse.
9936 sethi ta, hi20(symbol) ; LONGCALL4/HI20
9937 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
9938 jral ta ; PTR_RES/EMPTY/INSN16 */
9939
9940 bfd_vma laddr;
9941 uint32_t insn;
9942 Elf_Internal_Rela *hi_irel, *ptr_irel, *insn_irel, *em_irel, *call_irel;
9943 Elf_Internal_Rela *irelend;
9944 int pic_ext_target = 0;
9945 bfd_signed_vma foff;
9946
9947 irelend = internal_relocs + sec->reloc_count;
9948 laddr = irel->r_offset;
9949
9950 /* Get the reloc for the address from which the register is
9951 being loaded. This reloc will tell us which function is
9952 actually being called. */
9953 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9954 R_NDS32_HI20_RELA, laddr);
9955
9956 if (hi_irel == irelend)
9957 {
9958 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
9959 (long) irel->r_offset);
9960 return FALSE;
9961 }
9962
9963 /* Get the value of the symbol referred to by the reloc. */
9964 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr,
9965 &pic_ext_target);
9966
9967 /* This condition only happened when symbol is undefined. */
9968 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9969 || foff >= CONSERVATIVE_24BIT_S1)
9970 return FALSE;
9971
9972 /* Relax to: jal symbol; 25_PCREL */
9973 /* For simplicity of coding, we are going to modify the section
9974 contents, the section relocs, and the BFD symbol table. We
9975 must tell the rest of the code not to free up this
9976 information. It would be possible to instead create a table
9977 of changes which have to be made, as is done in coff-mips.c;
9978 that would be more work, but would require less memory when
9979 the linker is run. */
9980
9981 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9982 R_NDS32_PTR_RESOLVED, irel->r_addend);
9983 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9984 R_NDS32_EMPTY, irel->r_addend);
9985
9986 if (ptr_irel == irelend || em_irel == irelend)
9987 {
9988 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
9989 (long) irel->r_offset);
9990 return FALSE;
9991 }
9992 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
9993 insn = bfd_getb32 (contents + irel->r_addend);
9994 if (insn & 0x80000000)
9995 return FALSE;
9996
9997 /* Replace the long call with a jal. */
9998 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
9999 R_NDS32_25_PCREL_RELA);
10000 ptr_irel->r_addend = 1;
10001
10002 /* We don't resolve this here but resolve it in relocate_section. */
10003 insn = INSN_JAL;
10004 bfd_putb32 (insn, contents + em_irel->r_offset);
10005
10006 irel->r_info =
10007 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10008
10009 /* If there is function cse, HI20 can not remove now. */
10010 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10011 R_NDS32_LONGCALL4, laddr);
10012 if (call_irel == irelend)
10013 {
10014 *insn_len = 0;
10015 hi_irel->r_info =
10016 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10017 }
10018
10019 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10020 R_NDS32_INSN16, irel->r_addend);
10021 if (insn_irel != irelend)
10022 insn_irel->r_info =
10023 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10024
10025 return TRUE;
10026 }
10027
10028 /* Relax LONGCALL5 relocation for nds32_elf_relax_section. */
10029
10030 static bfd_boolean
10031 nds32_elf_relax_longcall5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10032 Elf_Internal_Rela *internal_relocs, int *insn_len,
10033 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10034 Elf_Internal_Shdr *symtab_hdr)
10035 {
10036 /* The pattern for LONGCALL5.
10037 bltz rt, .L1 ; LONGCALL5/17_PCREL
10038 jal symbol ; 25_PCREL
10039 .L1: */
10040
10041 bfd_vma laddr;
10042 uint32_t insn;
10043 Elf_Internal_Rela *cond_irel, *irelend;
10044 int pic_ext_target = 0;
10045 bfd_signed_vma foff;
10046
10047 irelend = internal_relocs + sec->reloc_count;
10048 laddr = irel->r_offset;
10049 insn = bfd_getb32 (contents + laddr);
10050
10051 /* Get the reloc for the address from which the register is
10052 being loaded. This reloc will tell us which function is
10053 actually being called. */
10054 cond_irel =
10055 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10056 R_NDS32_25_PCREL_RELA, irel->r_addend);
10057 if (cond_irel == irelend)
10058 {
10059 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL5",
10060 (long) irel->r_offset);
10061 return FALSE;
10062 }
10063
10064 /* Get the value of the symbol referred to by the reloc. */
10065 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10066 &pic_ext_target);
10067
10068 if (foff == 0 || foff < -CONSERVATIVE_16BIT_S1
10069 || foff >= CONSERVATIVE_16BIT_S1)
10070 return FALSE;
10071
10072 /* Relax to bgezal rt, label ; 17_PCREL
10073 or bltzal rt, label ; 17_PCREL */
10074
10075 /* Convert to complimentary conditional call. */
10076 insn = CONVERT_CONDITION_CALL (insn);
10077
10078 /* For simplicity of coding, we are going to modify the section
10079 contents, the section relocs, and the BFD symbol table. We
10080 must tell the rest of the code not to free up this
10081 information. It would be possible to instead create a table
10082 of changes which have to be made, as is done in coff-mips.c;
10083 that would be more work, but would require less memory when
10084 the linker is run. */
10085
10086 /* Modify relocation and contents. */
10087 cond_irel->r_info =
10088 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_17_PCREL_RELA);
10089
10090 /* Replace the long call with a bgezal. */
10091 bfd_putb32 (insn, contents + cond_irel->r_offset);
10092 *insn_len = 0;
10093
10094 /* Clean unnessary relocations. */
10095 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10096
10097 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10098 R_NDS32_17_PCREL_RELA, laddr);
10099 cond_irel->r_info =
10100 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10101
10102 return TRUE;
10103 }
10104
10105 /* Relax LONGCALL6 relocation for nds32_elf_relax_section. */
10106
10107 static bfd_boolean
10108 nds32_elf_relax_longcall6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10109 Elf_Internal_Rela *internal_relocs, int *insn_len,
10110 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10111 Elf_Internal_Shdr *symtab_hdr)
10112 {
10113 /* The pattern for LONGCALL6.
10114 bltz rt, .L1 ; LONGCALL6/17_PCREL
10115 sethi ta, hi20(symbol) ; HI20/PTR
10116 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10117 jral ta ; PTR_RES/EMPTY/INSN16
10118 .L1 */
10119
10120 bfd_vma laddr;
10121 uint32_t insn;
10122 Elf_Internal_Rela *em_irel, *cond_irel, *irelend;
10123 int pic_ext_target = 0;
10124 bfd_signed_vma foff;
10125
10126 irelend = internal_relocs + sec->reloc_count;
10127 laddr = irel->r_offset;
10128
10129 /* Get the reloc for the address from which the register is
10130 being loaded. This reloc will tell us which function is
10131 actually being called. */
10132 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10133 R_NDS32_EMPTY, irel->r_addend);
10134
10135 if (em_irel == irelend)
10136 {
10137 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL6",
10138 (long) irel->r_offset);
10139 return FALSE;
10140 }
10141
10142 /* Get the value of the symbol referred to by the reloc. */
10143 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr,
10144 &pic_ext_target);
10145
10146 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10147 || foff >= CONSERVATIVE_24BIT_S1)
10148 return FALSE;
10149
10150 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10151 insn = bfd_getb32 (contents + irel->r_addend);
10152 if (insn & 0x80000000)
10153 return FALSE;
10154
10155 insn = bfd_getb32 (contents + laddr);
10156 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10157 {
10158 /* Relax to bgezal rt, label ; 17_PCREL
10159 or bltzal rt, label ; 17_PCREL */
10160
10161 /* Convert to complimentary conditional call. */
10162 *insn_len = 0;
10163 insn = CONVERT_CONDITION_CALL (insn);
10164 bfd_putb32 (insn, contents + em_irel->r_offset);
10165
10166 em_irel->r_info =
10167 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_17_PCREL_RELA);
10168
10169 /* Set resolved relocation. */
10170 cond_irel =
10171 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10172 R_NDS32_PTR_RESOLVED, irel->r_addend);
10173 if (cond_irel == irelend)
10174 {
10175 _bfd_error_handler (unrecognized_reloc_msg, abfd,
10176 "R_NDS32_LONGCALL6", (long) irel->r_offset);
10177 return FALSE;
10178 }
10179 cond_irel->r_addend = 1;
10180
10181 /* Clear relocations. */
10182
10183 irel->r_info =
10184 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10185
10186 cond_irel =
10187 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10188 R_NDS32_17_PCREL_RELA, laddr);
10189 if (cond_irel != irelend)
10190 cond_irel->r_info =
10191 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10192
10193 cond_irel =
10194 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10195 R_NDS32_INSN16, irel->r_addend);
10196 if (cond_irel != irelend)
10197 cond_irel->r_info =
10198 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10199
10200 }
10201 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10202 {
10203 /* Relax to the following instruction sequence
10204 bltz rt, .L1 ; LONGCALL2/17_PCREL
10205 jal symbol ; 25_PCREL/PTR_RES
10206 .L1 */
10207 *insn_len = 4;
10208 /* Convert instruction. */
10209 insn = INSN_JAL;
10210 bfd_putb32 (insn, contents + em_irel->r_offset);
10211
10212 /* Convert relocations. */
10213 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10214 R_NDS32_25_PCREL_RELA);
10215 irel->r_info =
10216 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL5);
10217
10218 /* Set resolved relocation. */
10219 cond_irel =
10220 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10221 R_NDS32_PTR_RESOLVED, irel->r_addend);
10222 if (cond_irel == irelend)
10223 {
10224 _bfd_error_handler (unrecognized_reloc_msg, abfd,
10225 "R_NDS32_LONGCALL6", (long) irel->r_offset);
10226 return FALSE;
10227 }
10228 cond_irel->r_addend = 1;
10229
10230 cond_irel =
10231 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10232 R_NDS32_INSN16, irel->r_addend);
10233 if (cond_irel != irelend)
10234 cond_irel->r_info =
10235 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10236 }
10237 return TRUE;
10238 }
10239
10240 /* Relax LONGJUMP4 relocation for nds32_elf_relax_section. */
10241
10242 static bfd_boolean
10243 nds32_elf_relax_longjump4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10244 Elf_Internal_Rela *internal_relocs, int *insn_len,
10245 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10246 Elf_Internal_Shdr *symtab_hdr)
10247 {
10248 /* The pattern for LONGJUMP4.
10249 sethi ta, hi20(symbol) ; LONGJUMP4/HI20
10250 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10251 jr ta ; PTR_RES/INSN16/EMPTY */
10252
10253 bfd_vma laddr;
10254 int seq_len; /* Original length of instruction sequence. */
10255 uint32_t insn;
10256 Elf_Internal_Rela *hi_irel, *ptr_irel, *em_irel, *call_irel, *irelend;
10257 int pic_ext_target = 0;
10258 bfd_signed_vma foff;
10259
10260 irelend = internal_relocs + sec->reloc_count;
10261 seq_len = GET_SEQ_LEN (irel->r_addend);
10262 laddr = irel->r_offset;
10263 *insn_len = seq_len;
10264
10265 /* Get the reloc for the address from which the register is
10266 being loaded. This reloc will tell us which function is
10267 actually being called. */
10268
10269 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10270 R_NDS32_HI20_RELA, laddr);
10271
10272 if (hi_irel == irelend)
10273 {
10274 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
10275 (long) irel->r_offset);
10276 return FALSE;
10277 }
10278
10279 /* Get the value of the symbol referred to by the reloc. */
10280 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr,
10281 &pic_ext_target);
10282
10283 if (pic_ext_target || foff == 0 || foff >= CONSERVATIVE_24BIT_S1
10284 || foff < -CONSERVATIVE_24BIT_S1)
10285 return FALSE;
10286
10287 /* Convert it to "j label", it may be converted to j8 in the final
10288 pass of relaxation. Therefore, we do not consider this currently. */
10289 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10290 R_NDS32_PTR_RESOLVED, irel->r_addend);
10291 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10292 R_NDS32_EMPTY, irel->r_addend);
10293
10294 if (ptr_irel == irelend || em_irel == irelend)
10295 {
10296 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
10297 (long) irel->r_offset);
10298 return FALSE;
10299 }
10300
10301 em_irel->r_info =
10302 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_25_PCREL_RELA);
10303 ptr_irel->r_addend = 1;
10304
10305 /* Write instruction. */
10306 insn = INSN_J;
10307 bfd_putb32 (insn, contents + em_irel->r_offset);
10308
10309 /* Clear relocations. */
10310 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10311
10312 /* If there is function cse, HI20 can not remove now. */
10313 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10314 R_NDS32_LONGJUMP4, laddr);
10315 if (call_irel == irelend)
10316 {
10317 *insn_len = 0;
10318 hi_irel->r_info =
10319 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10320 }
10321
10322 return TRUE;
10323 }
10324
10325 /* Relax LONGJUMP5 relocation for nds32_elf_relax_section. */
10326
10327 static bfd_boolean
10328 nds32_elf_relax_longjump5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10329 Elf_Internal_Rela *internal_relocs, int *insn_len,
10330 int *seq_len, bfd_byte *contents,
10331 Elf_Internal_Sym *isymbuf,
10332 Elf_Internal_Shdr *symtab_hdr)
10333 {
10334 /* There are 2 variations for LONGJUMP5
10335 case 2-4; 1st insn convertible, 16-bit on.
10336 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
10337 j label ; 25_PCREL/INSN16
10338 $1:
10339
10340 case 4-4; 1st insn not convertible
10341 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
10342 j label ; 25_PCREL/INSN16
10343 .L1: */
10344
10345 bfd_vma laddr;
10346 Elf_Internal_Rela *cond_irel, *irelend;
10347 int pic_ext_target = 0;
10348 unsigned int i;
10349 bfd_signed_vma foff;
10350 uint32_t insn, re_insn = 0;
10351 uint16_t insn16, re_insn16 = 0;
10352 unsigned long reloc;
10353
10354 enum elf_nds32_reloc_type checked_types[] =
10355 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10356 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10357
10358 irelend = internal_relocs + sec->reloc_count;
10359 laddr = irel->r_offset;
10360
10361 /* Get the reloc for the address from which the register is
10362 being loaded. This reloc will tell us which function is
10363 actually being called. */
10364
10365 cond_irel =
10366 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10367 R_NDS32_25_PCREL_RELA, irel->r_addend);
10368 if (cond_irel == irelend)
10369 {
10370 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP5",
10371 (long) irel->r_offset);
10372 return FALSE;
10373 }
10374
10375 /* Get the value of the symbol referred to by the reloc. */
10376 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10377 &pic_ext_target);
10378
10379 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_16BIT_S1
10380 || foff >= CONSERVATIVE_16BIT_S1)
10381 return FALSE;
10382
10383 /* Get the all corresponding instructions. */
10384 insn = bfd_getb32 (contents + laddr);
10385 /* Check instruction size. */
10386 if (insn & 0x80000000)
10387 {
10388 *seq_len = 0;
10389 insn16 = insn >> 16;
10390 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10391 }
10392 else
10393 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10394
10395 if (N32_OP6 (re_insn) == N32_OP6_BR1
10396 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
10397 {
10398 /* beqs label ; 15_PCREL. */
10399 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10400 reloc = R_NDS32_15_PCREL_RELA;
10401 }
10402 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10403 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10404 {
10405 /* beqz label ; 17_PCREL. */
10406 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10407 reloc = R_NDS32_17_PCREL_RELA;
10408 }
10409 else if ( N32_OP6 (re_insn) == N32_OP6_BR3
10410 && foff >= -CONSERVATIVE_8BIT_S1 && foff < CONSERVATIVE_8BIT_S1)
10411 {
10412 /* beqc label ; 9_PCREL. */
10413 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10414 reloc = R_NDS32_WORD_9_PCREL_RELA;
10415 }
10416 else
10417 return FALSE;
10418
10419 /* Set all relocations. */
10420 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), reloc);
10421
10422 /* Clean relocations. */
10423 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10424 for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
10425 {
10426 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10427 checked_types[i], laddr);
10428 if (cond_irel != irelend)
10429 {
10430 if (*seq_len == 0
10431 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
10432 {
10433 /* If the branch instruction is 2 byte, it cannot remove
10434 directly. Only convert it to nop16 and remove it after
10435 checking alignment issue. */
10436 insn16 = NDS32_NOP16;
10437 bfd_putb16 (insn16, contents + laddr);
10438 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10439 }
10440 else
10441 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10442 R_NDS32_NONE);
10443 }
10444 }
10445 *insn_len = 0;
10446
10447 return TRUE;
10448 }
10449
10450 /* Relax LONGJUMP6 relocation for nds32_elf_relax_section. */
10451
10452 static bfd_boolean
10453 nds32_elf_relax_longjump6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10454 Elf_Internal_Rela *internal_relocs, int *insn_len,
10455 int *seq_len, bfd_byte *contents,
10456 Elf_Internal_Sym *isymbuf,
10457 Elf_Internal_Shdr *symtab_hdr)
10458 {
10459 /* There are 5 variations for LONGJUMP6
10460 case : 2-4-4-4; 1st insn convertible, 16-bit on.
10461 bnes38 rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
10462 sethi ta, hi20(symbol) ; HI20/PTR
10463 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10464 jr ta ; PTR_RES/INSN16/EMPTY
10465 .L1:
10466
10467 case : 4-4-4-4; 1st insn not convertible, 16-bit on.
10468 bne rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
10469 sethi ta, hi20(symbol) ; HI20/PTR
10470 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10471 jr ta ; PTR_RES/INSN16/EMPTY
10472 .L1: */
10473
10474 enum elf_nds32_reloc_type checked_types[] =
10475 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10476 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10477
10478 int reloc_off = 0, cond_removed = 0;
10479 bfd_vma laddr;
10480 Elf_Internal_Rela *cond_irel, *em_irel, *irelend, *insn_irel;
10481 int pic_ext_target = 0;
10482 unsigned int i;
10483 bfd_signed_vma foff;
10484 uint32_t insn, re_insn = 0;
10485 uint16_t insn16, re_insn16 = 0;
10486 unsigned long reloc;
10487
10488 irelend = internal_relocs + sec->reloc_count;
10489 laddr = irel->r_offset;
10490
10491 /* Get the reloc for the address from which the register is
10492 being loaded. This reloc will tell us which function is
10493 actually being called. */
10494 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10495 R_NDS32_EMPTY, irel->r_addend);
10496
10497 if (em_irel == irelend)
10498 {
10499 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP6",
10500 (long) irel->r_offset);
10501 return FALSE;
10502 }
10503
10504 /* Get the value of the symbol referred to by the reloc. */
10505 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr,
10506 &pic_ext_target);
10507
10508 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10509 || foff >= CONSERVATIVE_24BIT_S1)
10510 return FALSE;
10511
10512 insn = bfd_getb32 (contents + laddr);
10513 /* Check instruction size. */
10514 if (insn & 0x80000000)
10515 {
10516 *seq_len = 0;
10517 insn16 = insn >> 16;
10518 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10519 }
10520 else
10521 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10522
10523 /* For simplicity of coding, we are going to modify the section
10524 contents, the section relocs, and the BFD symbol table. We
10525 must tell the rest of the code not to free up this
10526 information. It would be possible to instead create a table
10527 of changes which have to be made, as is done in coff-mips.c;
10528 that would be more work, but would require less memory when
10529 the linker is run. */
10530
10531 if (N32_OP6 (re_insn) == N32_OP6_BR1
10532 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
10533 {
10534 /* beqs label ; 15_PCREL */
10535 bfd_putb32 (re_insn, contents + em_irel->r_offset);
10536 reloc = R_NDS32_15_PCREL_RELA;
10537 cond_removed = 1;
10538 }
10539 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10540 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10541 {
10542 /* beqz label ; 17_PCREL */
10543 bfd_putb32 (re_insn, contents + em_irel->r_offset);
10544 reloc = R_NDS32_17_PCREL_RELA;
10545 cond_removed = 1;
10546 }
10547 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
10548 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
10549 {
10550 /* Relax to one of the following 2 variations
10551
10552 case 2-4; 1st insn convertible, 16-bit on.
10553 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
10554 j label ; 25_PCREL/INSN16
10555 $1:
10556
10557 case 4-4; 1st insn not convertible
10558 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
10559 j label ; 25_PCREL/INSN16
10560 .L1: */
10561
10562 /* Use j label as second instruction. */
10563 insn = INSN_J;
10564 reloc = R_NDS32_25_PCREL_RELA;
10565 bfd_putb32 (insn, contents + em_irel->r_offset);
10566 }
10567 else
10568 return FALSE;
10569
10570 /* Set all relocations. */
10571 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), reloc);
10572
10573 cond_irel =
10574 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10575 R_NDS32_PTR_RESOLVED, em_irel->r_offset);
10576 cond_irel->r_addend = 1;
10577
10578 /* Use INSN16 of first branch instruction to distinguish if keeping
10579 INSN16 of final instruction or not. */
10580 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10581 R_NDS32_INSN16, irel->r_offset);
10582 if (insn_irel == irelend)
10583 {
10584 /* Clean the final INSN16. */
10585 insn_irel =
10586 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10587 R_NDS32_INSN16, em_irel->r_offset);
10588 insn_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10589 R_NDS32_NONE);
10590 }
10591
10592 if (cond_removed == 1)
10593 {
10594 *insn_len = 0;
10595
10596 /* Clear relocations. */
10597 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10598
10599 for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
10600 {
10601 cond_irel =
10602 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10603 checked_types[i], laddr);
10604 if (cond_irel != irelend)
10605 {
10606 if (*seq_len == 0
10607 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
10608 {
10609 /* If the branch instruction is 2 byte, it cannot remove
10610 directly. Only convert it to nop16 and remove it after
10611 checking alignment issue. */
10612 insn16 = NDS32_NOP16;
10613 bfd_putb16 (insn16, contents + laddr);
10614 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10615 }
10616 else
10617 cond_irel->r_info =
10618 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10619 }
10620 }
10621 }
10622 else
10623 {
10624 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
10625 R_NDS32_LONGJUMP5);
10626 }
10627
10628 return TRUE;
10629 }
10630
10631 /* Relax LONGJUMP7 relocation for nds32_elf_relax_section. */
10632
10633 static bfd_boolean
10634 nds32_elf_relax_longjump7 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10635 Elf_Internal_Rela *internal_relocs, int *insn_len,
10636 int *seq_len, bfd_byte *contents,
10637 Elf_Internal_Sym *isymbuf,
10638 Elf_Internal_Shdr *symtab_hdr)
10639 {
10640 /* There are 2 variations for LONGJUMP5
10641 case 2-4; 1st insn convertible, 16-bit on.
10642 movi55 ta, imm11 ; LONGJUMP7/INSN16
10643 beq rt, ta, label ; 15_PCREL
10644
10645 case 4-4; 1st insn not convertible
10646 movi55 ta, imm11 ; LONGJUMP7/INSN16
10647 beq rt, ta, label ; 15_PCREL */
10648
10649 bfd_vma laddr;
10650 Elf_Internal_Rela *cond_irel, *irelend, *insn_irel;
10651 int pic_ext_target = 0;
10652 bfd_signed_vma foff;
10653 uint32_t insn, re_insn = 0;
10654 uint16_t insn16;
10655 uint32_t imm11;
10656
10657 irelend = internal_relocs + sec->reloc_count;
10658 laddr = irel->r_offset;
10659
10660 /* Get the reloc for the address from which the register is
10661 being loaded. This reloc will tell us which function is
10662 actually being called. */
10663
10664 cond_irel =
10665 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10666 R_NDS32_15_PCREL_RELA, irel->r_addend);
10667 if (cond_irel == irelend)
10668 {
10669 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP7",
10670 (long) irel->r_offset);
10671 return FALSE;
10672 }
10673
10674 /* Get the value of the symbol referred to by the reloc. */
10675 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10676 &pic_ext_target);
10677
10678 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_8BIT_S1
10679 || foff >= CONSERVATIVE_8BIT_S1)
10680 return FALSE;
10681
10682 /* Get the first instruction for its size. */
10683 insn = bfd_getb32 (contents + laddr);
10684 if (insn & 0x80000000)
10685 {
10686 *seq_len = 0;
10687 /* Get the immediate from movi55. */
10688 imm11 = N16_IMM5S (insn >> 16);
10689 }
10690 else
10691 {
10692 /* Get the immediate from movi. */
10693 imm11 = N32_IMM20S (insn);
10694 }
10695
10696 /* Get the branch instruction. */
10697 insn = bfd_getb32 (contents + irel->r_addend);
10698 /* Convert instruction to BR3. */
10699 if ((insn >> 14) & 0x1)
10700 re_insn = N32_BR3 (BNEC, N32_RT5 (insn), imm11, 0);
10701 else
10702 re_insn = N32_BR3 (BEQC, N32_RT5 (insn), imm11, 0);
10703
10704 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10705
10706 /* Set all relocations. */
10707 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10708 R_NDS32_WORD_9_PCREL_RELA);
10709
10710 /* Clean relocations. */
10711 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10712 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10713 R_NDS32_INSN16, irel->r_offset);
10714 if (insn_irel != irelend)
10715 {
10716 if (*seq_len == 0)
10717 {
10718 /* If the first insntruction is 16bit, convert it to nop16. */
10719 insn16 = NDS32_NOP16;
10720 bfd_putb16 (insn16, contents + laddr);
10721 insn_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10722 }
10723 else
10724 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10725 R_NDS32_NONE);
10726 }
10727 *insn_len = 0;
10728
10729 return TRUE;
10730 }
10731
10732 #define GET_LOADSTORE_RANGE(addend) (((addend) >> 8) & 0x3f)
10733
10734 /* Relax LOADSTORE relocation for nds32_elf_relax_section. */
10735
10736 static bfd_boolean
10737 nds32_elf_relax_loadstore (struct bfd_link_info *link_info, bfd *abfd,
10738 asection *sec, Elf_Internal_Rela *irel,
10739 Elf_Internal_Rela *internal_relocs, int *insn_len,
10740 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10741 Elf_Internal_Shdr *symtab_hdr, int load_store_relax)
10742 {
10743 int eliminate_sethi = 0, range_type;
10744 unsigned int i;
10745 bfd_vma local_sda, laddr;
10746 int seq_len; /* Original length of instruction sequence. */
10747 uint32_t insn;
10748 Elf_Internal_Rela *hi_irelfn = NULL, *irelend;
10749 bfd_vma access_addr = 0;
10750 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
10751 enum elf_nds32_reloc_type checked_types[] =
10752 { R_NDS32_HI20_RELA, R_NDS32_GOT_HI20,
10753 R_NDS32_GOTPC_HI20, R_NDS32_GOTOFF_HI20,
10754 R_NDS32_PLTREL_HI20, R_NDS32_PLT_GOTREL_HI20,
10755 R_NDS32_TLS_LE_HI20
10756 };
10757
10758 irelend = internal_relocs + sec->reloc_count;
10759 seq_len = GET_SEQ_LEN (irel->r_addend);
10760 laddr = irel->r_offset;
10761 *insn_len = seq_len;
10762
10763 /* Get the high part relocation. */
10764 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10765 {
10766 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10767 checked_types[i], laddr);
10768 if (hi_irelfn != irelend)
10769 break;
10770 }
10771
10772 if (hi_irelfn == irelend)
10773 {
10774 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LOADSTORE",
10775 (long) irel->r_offset);
10776 return FALSE;
10777 }
10778
10779 range_type = GET_LOADSTORE_RANGE (irel->r_addend);
10780 nds32_elf_final_sda_base (sec->output_section->owner,
10781 link_info, &local_sda, FALSE);
10782
10783 switch (ELF32_R_TYPE (hi_irelfn->r_info))
10784 {
10785 case R_NDS32_HI20_RELA:
10786 insn = bfd_getb32 (contents + laddr);
10787 access_addr =
10788 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10789
10790 if (range_type == NDS32_LOADSTORE_IMM)
10791 {
10792 struct elf_link_hash_entry *h = NULL;
10793 int indx;
10794
10795 if (ELF32_R_SYM (hi_irelfn->r_info) >= symtab_hdr->sh_info)
10796 {
10797 indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
10798 h = elf_sym_hashes (abfd)[indx];
10799 }
10800
10801 if ((access_addr < CONSERVATIVE_20BIT)
10802 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
10803 {
10804 eliminate_sethi = 1;
10805 break;
10806 }
10807
10808 /* This is avoid to relax symbol address which is fixed
10809 relocations. Ex: _stack. */
10810 if (h && bfd_is_abs_section (h->root.u.def.section))
10811 return FALSE;
10812 }
10813
10814 if (!load_store_relax)
10815 return FALSE;
10816
10817 /* Case for set gp register. */
10818 if (N32_RT5 (insn) == REG_GP)
10819 break;
10820
10821 if (range_type == NDS32_LOADSTORE_FLOAT_S
10822 || range_type == NDS32_LOADSTORE_FLOAT_S)
10823 {
10824 range_l = sdata_range[0][0];
10825 range_h = sdata_range[0][1];
10826 }
10827 else
10828 {
10829 range_l = sdata_range[1][0];
10830 range_h = sdata_range[1][1];
10831 }
10832 break;
10833
10834 case R_NDS32_GOT_HI20:
10835 access_addr =
10836 calculate_got_memory_address (abfd, link_info, hi_irelfn, symtab_hdr);
10837
10838 /* If this symbol is not in .got, the return value will be -1.
10839 Since the gp value is set to SDA_BASE but not GLOBAL_OFFSET_TABLE,
10840 a negative offset is allowed. */
10841 if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10842 && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10843 eliminate_sethi = 1;
10844 break;
10845
10846 case R_NDS32_PLT_GOTREL_HI20:
10847 access_addr = calculate_plt_memory_address (abfd, link_info, isymbuf,
10848 hi_irelfn, symtab_hdr);
10849
10850 if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10851 && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10852 eliminate_sethi = 1;
10853 break;
10854
10855 case R_NDS32_GOTOFF_HI20:
10856 access_addr =
10857 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10858
10859 if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10860 && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10861 eliminate_sethi = 1;
10862 break;
10863
10864 case R_NDS32_GOTPC_HI20:
10865 /* The access_addr must consider r_addend of hi_irel. */
10866 access_addr = sec->output_section->vma + sec->output_offset
10867 + irel->r_offset + hi_irelfn->r_addend;
10868
10869 if ((bfd_signed_vma) (local_sda - access_addr) < CONSERVATIVE_20BIT
10870 && (bfd_signed_vma) (local_sda - access_addr) >= -CONSERVATIVE_20BIT)
10871 eliminate_sethi = 1;
10872 break;
10873
10874 case R_NDS32_TLS_LE_HI20:
10875 access_addr =
10876 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10877 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
10878 access_addr -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
10879 if ((range_type == NDS32_LOADSTORE_IMM)
10880 && (bfd_signed_vma) (access_addr) < CONSERVATIVE_20BIT
10881 && (bfd_signed_vma) (access_addr) >= -CONSERVATIVE_20BIT)
10882 eliminate_sethi = 1;
10883 break;
10884
10885 default:
10886 return FALSE;
10887 }
10888
10889 /* Delete sethi instruction. */
10890 if (eliminate_sethi == 1
10891 || (local_sda <= access_addr && (access_addr - local_sda) < range_h)
10892 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
10893 {
10894 hi_irelfn->r_info =
10895 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
10896 irel->r_info =
10897 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10898 *insn_len = 0;
10899 }
10900 return TRUE;
10901 }
10902
10903 /* Relax LO12 relocation for nds32_elf_relax_section. */
10904
10905 static void
10906 nds32_elf_relax_lo12 (struct bfd_link_info *link_info, bfd *abfd,
10907 asection *sec, Elf_Internal_Rela *irel,
10908 Elf_Internal_Rela *internal_relocs, bfd_byte *contents,
10909 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
10910 {
10911 uint32_t insn;
10912 bfd_vma local_sda, laddr;
10913 unsigned long reloc;
10914 bfd_vma access_addr;
10915 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
10916 Elf_Internal_Rela *irelfn = NULL, *irelend;
10917 struct elf_link_hash_entry *h = NULL;
10918 int indx;
10919
10920 /* For SDA base relative relaxation. */
10921 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
10922 &local_sda, FALSE);
10923
10924 irelend = internal_relocs + sec->reloc_count;
10925 laddr = irel->r_offset;
10926 insn = bfd_getb32 (contents + laddr);
10927
10928 if (!is_sda_access_insn (insn) && N32_OP6 (insn) != N32_OP6_ORI)
10929 return;
10930
10931 access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
10932
10933 if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
10934 {
10935 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
10936 h = elf_sym_hashes (abfd)[indx];
10937 }
10938
10939 if (N32_OP6 (insn) == N32_OP6_ORI && access_addr < CONSERVATIVE_20BIT
10940 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
10941 {
10942 reloc = R_NDS32_20_RELA;
10943 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10944 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
10945 bfd_putb32 (insn, contents + laddr);
10946 }
10947 /* This is avoid to relax symbol address which is fixed
10948 relocations. Ex: _stack. */
10949 else if (N32_OP6 (insn) == N32_OP6_ORI
10950 && h && bfd_is_abs_section (h->root.u.def.section))
10951 return;
10952 else
10953 {
10954 range_l = sdata_range[1][0];
10955 range_h = sdata_range[1][1];
10956 switch (ELF32_R_TYPE (irel->r_info))
10957 {
10958 case R_NDS32_LO12S0_RELA:
10959 reloc = R_NDS32_SDA19S0_RELA;
10960 break;
10961 case R_NDS32_LO12S1_RELA:
10962 reloc = R_NDS32_SDA18S1_RELA;
10963 break;
10964 case R_NDS32_LO12S2_RELA:
10965 reloc = R_NDS32_SDA17S2_RELA;
10966 break;
10967 case R_NDS32_LO12S2_DP_RELA:
10968 range_l = sdata_range[0][0];
10969 range_h = sdata_range[0][1];
10970 reloc = R_NDS32_SDA12S2_DP_RELA;
10971 break;
10972 case R_NDS32_LO12S2_SP_RELA:
10973 range_l = sdata_range[0][0];
10974 range_h = sdata_range[0][1];
10975 reloc = R_NDS32_SDA12S2_SP_RELA;
10976 break;
10977 default:
10978 return;
10979 }
10980
10981 /* There are range_h and range_l because linker has to promise
10982 all sections move cross one page together. */
10983 if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
10984 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
10985 {
10986 if (N32_OP6 (insn) == N32_OP6_ORI && N32_RT5 (insn) == REG_GP)
10987 {
10988 /* Maybe we should add R_NDS32_INSN16 reloc type here
10989 or manually do some optimization. sethi can't be
10990 eliminated when updating $gp so the relative ori
10991 needs to be preserved. */
10992 return;
10993 }
10994 if (!turn_insn_to_sda_access (insn, ELF32_R_TYPE (irel->r_info),
10995 &insn))
10996 return;
10997 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10998 bfd_putb32 (insn, contents + laddr);
10999
11000 irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11001 R_NDS32_INSN16);
11002 /* SDA17 must keep INSN16 for converting fp_as_gp. */
11003 if (irelfn != irelend && reloc != R_NDS32_SDA17S2_RELA)
11004 irelfn->r_info =
11005 ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_NDS32_NONE);
11006
11007 }
11008 }
11009 return;
11010 }
11011
11012 /* Relax low part of PIC instruction pattern. */
11013
11014 static void
11015 nds32_elf_relax_piclo12 (struct bfd_link_info *link_info, bfd *abfd,
11016 asection *sec, Elf_Internal_Rela *irel,
11017 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11018 Elf_Internal_Shdr *symtab_hdr)
11019 {
11020 uint32_t insn;
11021 bfd_vma local_sda, laddr;
11022 bfd_signed_vma foff;
11023 unsigned long reloc;
11024
11025 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11026 &local_sda, FALSE);
11027 laddr = irel->r_offset;
11028 insn = bfd_getb32 (contents + laddr);
11029
11030 if (N32_OP6 (insn) != N32_OP6_ORI)
11031 return;
11032
11033 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12)
11034 {
11035 foff = calculate_got_memory_address (abfd, link_info, irel,
11036 symtab_hdr) - local_sda;
11037 reloc = R_NDS32_GOT20;
11038 }
11039 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12)
11040 {
11041 foff = calculate_plt_memory_address (abfd, link_info, isymbuf, irel,
11042 symtab_hdr) - local_sda;
11043 reloc = R_NDS32_PLT_GOTREL_LO20;
11044 }
11045 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12)
11046 {
11047 foff = calculate_memory_address (abfd, irel, isymbuf,
11048 symtab_hdr) - local_sda;
11049 reloc = R_NDS32_GOTOFF;
11050 }
11051 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12)
11052 {
11053 foff = local_sda - sec->output_section->vma + sec->output_offset
11054 + irel->r_offset + irel->r_addend;
11055 reloc = R_NDS32_GOTPC20;
11056 }
11057 else
11058 return;
11059
11060 if ((foff < CONSERVATIVE_20BIT) && (foff >= -CONSERVATIVE_20BIT))
11061 {
11062 /* Turn into MOVI. */
11063 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11064 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11065 bfd_putb32 (insn, contents + laddr);
11066 }
11067 }
11068
11069 /* Relax low part of LE TLS instruction pattern. */
11070
11071 static void
11072 nds32_elf_relax_letlslo12 (struct bfd_link_info *link_info, bfd *abfd,
11073 Elf_Internal_Rela *irel,
11074 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11075 Elf_Internal_Shdr *symtab_hdr)
11076 {
11077 uint32_t insn;
11078 bfd_vma laddr;
11079 bfd_signed_vma foff;
11080 unsigned long reloc;
11081
11082 laddr = irel->r_offset;
11083 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11084 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11085 foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11086 insn = bfd_getb32 (contents + laddr);
11087
11088 if ( (bfd_signed_vma) (foff) < CONSERVATIVE_20BIT
11089 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_20BIT)
11090 {
11091 /* Pattern sethi-ori transform to movi. */
11092 reloc = R_NDS32_TLS_LE_20;
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 LE TLS calculate address instruction pattern. */
11100
11101 static void
11102 nds32_elf_relax_letlsadd (struct bfd_link_info *link_info, bfd *abfd,
11103 asection *sec, Elf_Internal_Rela *irel,
11104 Elf_Internal_Rela *internal_relocs,
11105 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11106 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11107 {
11108 /* Local TLS non-pic
11109 sethi ta, hi20(symbol@tpoff) ; TLS_LE_HI20
11110 ori ta, ta, lo12(symbol@tpoff) ; TLS_LE_LO12
11111 add ra, ta, tp ; TLS_LE_ADD */
11112
11113 uint32_t insn;
11114 bfd_vma laddr;
11115 bfd_signed_vma foff;
11116 Elf_Internal_Rela *i1_irelfn, *irelend;
11117
11118 irelend = internal_relocs + sec->reloc_count;
11119 laddr = irel->r_offset;
11120 insn = bfd_getb32 (contents + laddr);
11121 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11122 R_NDS32_PTR_RESOLVED);
11123 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11124 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11125 foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11126
11127 /* The range is +/-16k. */
11128 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT
11129 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT)
11130 {
11131 /* Transform add to addi. */
11132 insn = N32_TYPE2 (ADDI, N32_RT5 (insn), N32_RB5 (insn), 0);
11133 irel->r_info =
11134 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S0);
11135
11136 bfd_putb32 (insn, contents + laddr);
11137 if (i1_irelfn != irelend)
11138 {
11139 i1_irelfn->r_addend |= 1;
11140 *again = TRUE;
11141 }
11142 }
11143 }
11144
11145 /* Relax LE TLS load store instruction pattern. */
11146
11147 static void
11148 nds32_elf_relax_letlsls (struct bfd_link_info *link_info, bfd *abfd,
11149 asection *sec, Elf_Internal_Rela *irel,
11150 Elf_Internal_Rela *internal_relocs,
11151 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11152 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11153 {
11154
11155 uint32_t insn;
11156 bfd_vma laddr;
11157 bfd_signed_vma foff;
11158 Elf_Internal_Rela *i1_irelfn, *irelend;
11159 int success = 0;
11160
11161 irelend = internal_relocs + sec->reloc_count;
11162 laddr = irel->r_offset;
11163 insn = bfd_getb32 (contents + laddr);
11164 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11165 R_NDS32_PTR_RESOLVED);
11166 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11167 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11168 foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11169
11170 switch ((N32_OP6 (insn) << 8) | (insn & 0xff))
11171 {
11172 case (N32_OP6_MEM << 8) | N32_MEM_LB:
11173 case (N32_OP6_MEM << 8) | N32_MEM_SB:
11174 case (N32_OP6_MEM << 8) | N32_MEM_LBS:
11175 /* The range is +/-16k. */
11176 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT
11177 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT)
11178 {
11179 insn =
11180 ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11181 irel->r_info =
11182 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S0);
11183 success = 1;
11184 break;
11185 }
11186 /* Fall through. */
11187 case (N32_OP6_MEM << 8) | N32_MEM_LH:
11188 case (N32_OP6_MEM << 8) | N32_MEM_SH:
11189 case (N32_OP6_MEM << 8) | N32_MEM_LHS:
11190 /* The range is +/-32k. */
11191 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT_S1
11192 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT_S1)
11193 {
11194 insn =
11195 ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11196 irel->r_info =
11197 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S1);
11198 success = 1;
11199 break;
11200 }
11201 /* Fall through. */
11202 case (N32_OP6_MEM << 8) | N32_MEM_LW:
11203 case (N32_OP6_MEM << 8) | N32_MEM_SW:
11204 /* The range is +/-64k. */
11205 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT_S2
11206 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT_S2)
11207 {
11208 insn =
11209 ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11210 irel->r_info =
11211 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S2);
11212 success = 1;
11213 break;
11214 }
11215 /* Fall through. */
11216 default:
11217 break;
11218 }
11219
11220 if (success)
11221 {
11222 bfd_putb32 (insn, contents + laddr);
11223 if (i1_irelfn != irelend)
11224 {
11225 i1_irelfn->r_addend |= 1;
11226 *again = TRUE;
11227 }
11228 }
11229 }
11230
11231 /* Relax PTR relocation for nds32_elf_relax_section. */
11232
11233 static bfd_boolean
11234 nds32_elf_relax_ptr (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11235 Elf_Internal_Rela *internal_relocs, int *insn_len,
11236 int *seq_len, bfd_byte *contents)
11237 {
11238 Elf_Internal_Rela *ptr_irel, *irelend, *count_irel, *re_irel;
11239
11240 irelend = internal_relocs + sec->reloc_count;
11241
11242 re_irel =
11243 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11244 R_NDS32_PTR_RESOLVED, irel->r_addend);
11245
11246 if (re_irel == irelend)
11247 {
11248 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_PTR",
11249 (long) irel->r_offset);
11250 return FALSE;
11251 }
11252
11253 if (re_irel->r_addend != 1)
11254 return FALSE;
11255
11256 /* Pointed target is relaxed and no longer needs this void *,
11257 change the type to NONE. */
11258 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11259
11260 /* Find PTR_COUNT to decide remove it or not. If PTR_COUNT does
11261 not exist, it means only count 1 and remove it directly. */
11262 /* TODO: I hope we can obsolate R_NDS32_COUNT in the future. */
11263 count_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11264 R_NDS32_PTR_COUNT);
11265 ptr_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11266 R_NDS32_PTR);
11267 if (count_irel != irelend)
11268 {
11269 if (--count_irel->r_addend > 0)
11270 return FALSE;
11271 }
11272
11273 if (ptr_irel != irelend)
11274 return FALSE;
11275
11276 /* If the PTR_COUNT is already 0, remove current instruction. */
11277 *seq_len = nds32_elf_insn_size (abfd, contents, irel->r_offset);
11278 *insn_len = 0;
11279 return TRUE;
11280 }
11281
11282 /* Relax PLT_GOT_SUFF relocation for nds32_elf_relax_section. */
11283
11284 static void
11285 nds32_elf_relax_pltgot_suff (struct bfd_link_info *link_info, bfd *abfd,
11286 asection *sec, Elf_Internal_Rela *irel,
11287 Elf_Internal_Rela *internal_relocs,
11288 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11289 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11290 {
11291 uint32_t insn;
11292 bfd_signed_vma foff;
11293 Elf_Internal_Rela *i1_irelfn, *irelend;
11294 bfd_vma local_sda, laddr;
11295
11296 irelend = internal_relocs + sec->reloc_count;
11297 laddr = irel->r_offset;
11298 insn = bfd_getb32 (contents + laddr);
11299
11300 /* FIXME: It's a little trouble to turn JRAL5 to JAL since
11301 we need additional space. It might be help if we could
11302 borrow some space from instructions to be eliminated
11303 such as sethi, ori, add. */
11304 if (insn & 0x80000000)
11305 return;
11306
11307 if (nds32_elf_check_dup_relocs
11308 (irel, internal_relocs, irelend, R_NDS32_PLT_GOT_SUFF))
11309 return;
11310
11311 i1_irelfn =
11312 find_relocs_at_address (irel, internal_relocs, irelend,
11313 R_NDS32_PTR_RESOLVED);
11314
11315 /* FIXIT 090606
11316 The boundary should be reduced since the .plt section hasn't
11317 been created and the address of specific entry is still unknown
11318 Maybe the range between the function call and the begin of the
11319 .text section can be used to decide if the .plt is in the range
11320 of function call. */
11321
11322 if (N32_OP6 (insn) == N32_OP6_ALU1
11323 && N32_SUB5 (insn) == N32_ALU1_ADD)
11324 {
11325 /* Get the value of the symbol referred to by the reloc. */
11326 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11327 &local_sda, FALSE);
11328 foff = (bfd_signed_vma) (calculate_plt_memory_address
11329 (abfd, link_info, isymbuf, irel,
11330 symtab_hdr) - local_sda);
11331 /* This condition only happened when symbol is undefined. */
11332 if (foff == 0)
11333 return;
11334
11335 if (foff < -CONSERVATIVE_19BIT || foff >= CONSERVATIVE_19BIT)
11336 return;
11337 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11338 R_NDS32_PLT_GOTREL_LO19);
11339 /* addi.gp */
11340 insn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
11341 }
11342 else if (N32_OP6 (insn) == N32_OP6_JREG
11343 && N32_SUB5 (insn) == N32_JREG_JRAL)
11344 {
11345 /* Get the value of the symbol referred to by the reloc. */
11346 foff =
11347 calculate_plt_offset (abfd, sec, link_info, isymbuf, irel, symtab_hdr);
11348 /* This condition only happened when symbol is undefined. */
11349 if (foff == 0)
11350 return;
11351 if (foff < -CONSERVATIVE_24BIT_S1 || foff >= CONSERVATIVE_24BIT_S1)
11352 return;
11353 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_25_PLTREL);
11354 insn = INSN_JAL;
11355 }
11356 else
11357 return;
11358
11359 bfd_putb32 (insn, contents + laddr);
11360 if (i1_irelfn != irelend)
11361 {
11362 i1_irelfn->r_addend |= 1;
11363 *again = TRUE;
11364 }
11365 }
11366
11367 /* Relax GOT_SUFF relocation for nds32_elf_relax_section. */
11368
11369 static void
11370 nds32_elf_relax_got_suff (struct bfd_link_info *link_info, bfd *abfd,
11371 asection *sec, Elf_Internal_Rela *irel,
11372 Elf_Internal_Rela *internal_relocs,
11373 bfd_byte *contents, Elf_Internal_Shdr *symtab_hdr,
11374 bfd_boolean *again)
11375 {
11376 uint32_t insn;
11377 bfd_signed_vma foff;
11378 Elf_Internal_Rela *i1_irelfn, *irelend;
11379 bfd_vma local_sda, laddr;
11380
11381 irelend = internal_relocs + sec->reloc_count;
11382 laddr = irel->r_offset;
11383 insn = bfd_getb32 (contents + laddr);
11384 if (insn & 0x80000000)
11385 return;
11386
11387 if (nds32_elf_check_dup_relocs
11388 (irel, internal_relocs, irelend, R_NDS32_GOT_SUFF))
11389 return;
11390
11391 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11392 R_NDS32_PTR_RESOLVED);
11393
11394 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11395 &local_sda, FALSE);
11396 foff = calculate_got_memory_address (abfd, link_info, irel,
11397 symtab_hdr) - local_sda;
11398
11399 if (foff < CONSERVATIVE_19BIT && foff >= -CONSERVATIVE_19BIT)
11400 {
11401 /* Turn LW to LWI.GP. Change relocation type to R_NDS32_GOT_REL. */
11402 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
11403 irel->r_info =
11404 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_GOT17S2_RELA);
11405 bfd_putb32 (insn, contents + laddr);
11406 if (i1_irelfn != irelend)
11407 {
11408 i1_irelfn->r_addend |= 1;
11409 *again = TRUE;
11410 }
11411 }
11412 }
11413
11414 /* Relax PLT_GOT_SUFF relocation for nds32_elf_relax_section. */
11415
11416 static void
11417 nds32_elf_relax_gotoff_suff (struct bfd_link_info *link_info, bfd *abfd,
11418 asection *sec, Elf_Internal_Rela *irel,
11419 Elf_Internal_Rela *internal_relocs,
11420 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11421 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11422 {
11423 int opc_insn_gotoff;
11424 uint32_t insn;
11425 bfd_signed_vma foff;
11426 Elf_Internal_Rela *i1_irelfn, *i2_irelfn, *irelend;
11427 bfd_vma local_sda, laddr;
11428
11429 irelend = internal_relocs + sec->reloc_count;
11430 laddr = irel->r_offset;
11431 insn = bfd_getb32 (contents + laddr);
11432
11433 if (insn & 0x80000000)
11434 return;
11435
11436 if (nds32_elf_check_dup_relocs
11437 (irel, internal_relocs, irelend, R_NDS32_GOTOFF_SUFF))
11438 return;
11439
11440 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11441 R_NDS32_PTR_RESOLVED);
11442 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11443 &local_sda, FALSE);
11444 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11445 foff = foff - local_sda;
11446
11447 if (foff >= CONSERVATIVE_19BIT || foff < -CONSERVATIVE_19BIT)
11448 return;
11449
11450 /* Concatenate opcode and sub-opcode for switch case.
11451 It may be MEM or ALU1. */
11452 opc_insn_gotoff = (N32_OP6 (insn) << 8) | (insn & 0xff);
11453 switch (opc_insn_gotoff)
11454 {
11455 case (N32_OP6_MEM << 8) | N32_MEM_LW:
11456 /* 4-byte aligned. */
11457 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
11458 irel->r_info =
11459 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA17S2_RELA);
11460 break;
11461 case (N32_OP6_MEM << 8) | N32_MEM_SW:
11462 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
11463 irel->r_info =
11464 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA17S2_RELA);
11465 break;
11466 case (N32_OP6_MEM << 8) | N32_MEM_LH:
11467 /* 2-byte aligned. */
11468 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
11469 irel->r_info =
11470 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11471 break;
11472 case (N32_OP6_MEM << 8) | N32_MEM_LHS:
11473 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (18));
11474 irel->r_info =
11475 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11476 break;
11477 case (N32_OP6_MEM << 8) | N32_MEM_SH:
11478 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (19));
11479 irel->r_info =
11480 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11481 break;
11482 case (N32_OP6_MEM << 8) | N32_MEM_LB:
11483 /* 1-byte aligned. */
11484 insn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
11485 irel->r_info =
11486 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11487 break;
11488 case (N32_OP6_MEM << 8) | N32_MEM_LBS:
11489 insn = N32_TYPE1 (LBGP, N32_RT5 (insn), __BIT (19));
11490 irel->r_info =
11491 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11492 break;
11493 case (N32_OP6_MEM << 8) | N32_MEM_SB:
11494 insn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
11495 irel->r_info =
11496 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11497 break;
11498 case (N32_OP6_ALU1 << 8) | N32_ALU1_ADD:
11499 insn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
11500 irel->r_info =
11501 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11502 break;
11503 default:
11504 return;
11505 }
11506
11507 bfd_putb32 (insn, contents + laddr);
11508 if (i1_irelfn != irelend)
11509 {
11510 i1_irelfn->r_addend |= 1;
11511 *again = TRUE;
11512 }
11513 if ((i2_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11514 R_NDS32_INSN16)) != irelend)
11515 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11516
11517 }
11518
11519 static bfd_boolean
11520 nds32_relax_adjust_label (bfd *abfd, asection *sec,
11521 Elf_Internal_Rela *internal_relocs,
11522 bfd_byte *contents,
11523 nds32_elf_blank_t **relax_blank_list,
11524 int optimize, int opt_size)
11525 {
11526 /* This code block is used to adjust 4-byte alignment by relax a pair
11527 of instruction a time.
11528
11529 It recognizes three types of relocations.
11530 1. R_NDS32_LABEL - a aligment.
11531 2. R_NDS32_INSN16 - relax a 32-bit instruction to 16-bit.
11532 3. is_16bit_NOP () - remove a 16-bit instruction. */
11533
11534 /* TODO: It seems currently implementation only support 4-byte aligment.
11535 We should handle any-aligment. */
11536
11537 Elf_Internal_Rela *insn_rel = NULL, *label_rel = NULL, *irel;
11538 Elf_Internal_Rela *tmp_rel, *tmp2_rel = NULL;
11539 Elf_Internal_Rela rel_temp;
11540 Elf_Internal_Rela *irelend;
11541 bfd_vma address;
11542 uint16_t insn16;
11543
11544 /* Checking for branch relaxation relies on the relocations to
11545 be sorted on 'r_offset'. This is not guaranteed so we must sort. */
11546 nds32_insertion_sort (internal_relocs, sec->reloc_count,
11547 sizeof (Elf_Internal_Rela), compar_reloc);
11548
11549 irelend = internal_relocs + sec->reloc_count;
11550
11551 /* Force R_NDS32_LABEL before R_NDS32_INSN16. */
11552 /* FIXME: Can we generate the right order in assembler?
11553 So we don't have to swapping them here. */
11554
11555 for (label_rel = internal_relocs, insn_rel = internal_relocs;
11556 label_rel < irelend; label_rel++)
11557 {
11558 if (ELF32_R_TYPE (label_rel->r_info) != R_NDS32_LABEL)
11559 continue;
11560
11561 /* Find the first reloc has the same offset with label_rel. */
11562 while (insn_rel < irelend && insn_rel->r_offset < label_rel->r_offset)
11563 insn_rel++;
11564
11565 for (;insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset;
11566 insn_rel++)
11567 /* Check if there were R_NDS32_INSN16 and R_NDS32_LABEL at the same
11568 address. */
11569 if (ELF32_R_TYPE (insn_rel->r_info) == R_NDS32_INSN16)
11570 break;
11571
11572 if (insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset
11573 && insn_rel < label_rel)
11574 {
11575 /* Swap the two reloc if the R_NDS32_INSN16 is
11576 before R_NDS32_LABEL. */
11577 memcpy (&rel_temp, insn_rel, sizeof (Elf_Internal_Rela));
11578 memcpy (insn_rel, label_rel, sizeof (Elf_Internal_Rela));
11579 memcpy (label_rel, &rel_temp, sizeof (Elf_Internal_Rela));
11580 }
11581 }
11582
11583 label_rel = NULL;
11584 insn_rel = NULL;
11585 /* If there were a sequence of R_NDS32_LABEL end up with .align 2
11586 or higher, remove other R_NDS32_LABEL with lower alignment.
11587 If an R_NDS32_INSN16 in between R_NDS32_LABELs must be converted,
11588 then the R_NDS32_LABEL sequence is broke. */
11589 for (tmp_rel = internal_relocs; tmp_rel < irelend; tmp_rel++)
11590 {
11591 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_LABEL)
11592 {
11593 if (label_rel == NULL)
11594 {
11595 if (tmp_rel->r_addend < 2)
11596 label_rel = tmp_rel;
11597 continue;
11598 }
11599 else if (tmp_rel->r_addend > 1)
11600 {
11601 /* Remove all LABEL relocation from label_rel to tmp_rel
11602 including relocations with same offset as tmp_rel. */
11603 for (tmp2_rel = label_rel; tmp2_rel < tmp_rel
11604 || tmp2_rel->r_offset == tmp_rel->r_offset; tmp2_rel++)
11605 {
11606 if (ELF32_R_TYPE (tmp2_rel->r_info) == R_NDS32_LABEL
11607 && tmp2_rel->r_addend < 2)
11608 tmp2_rel->r_info =
11609 ELF32_R_INFO (ELF32_R_SYM (tmp2_rel->r_info),
11610 R_NDS32_NONE);
11611 }
11612 label_rel = NULL;
11613 }
11614 }
11615 else if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16 && label_rel)
11616 {
11617 /* A new INSN16 which can be converted, so clear label_rel. */
11618 if (is_convert_32_to_16 (abfd, sec, tmp_rel, internal_relocs,
11619 irelend, &insn16)
11620 || is_16bit_NOP (abfd, sec, tmp_rel))
11621 label_rel = NULL;
11622 }
11623 }
11624
11625 label_rel = NULL;
11626 insn_rel = NULL;
11627 /* Optimized for speed and nothing has not been relaxed.
11628 It's time to align labels.
11629 We may convert a 16-bit instruction right before a label to
11630 32-bit, in order to align the label if necessary
11631 all reloc entries has been sorted by r_offset. */
11632 for (irel = internal_relocs; irel < irelend; irel++)
11633 {
11634 if (ELF32_R_TYPE (irel->r_info) != R_NDS32_INSN16
11635 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL)
11636 continue;
11637
11638 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_INSN16)
11639 {
11640 /* A new INSN16 found, resize the old one. */
11641 if (is_convert_32_to_16
11642 (abfd, sec, irel, internal_relocs, irelend, &insn16)
11643 || is_16bit_NOP (abfd, sec, irel))
11644 {
11645 if (insn_rel)
11646 {
11647 /* Previous INSN16 reloc exists, reduce its
11648 size to 16-bit. */
11649 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11650 irelend, &insn16))
11651 {
11652 nds32_elf_write_16 (abfd, contents, insn_rel,
11653 internal_relocs, irelend, insn16);
11654
11655 if (!insert_nds32_elf_blank_recalc_total
11656 (relax_blank_list, insn_rel->r_offset + 2, 2))
11657 return FALSE;
11658 }
11659 else if (is_16bit_NOP (abfd, sec, insn_rel))
11660 {
11661 if (!insert_nds32_elf_blank_recalc_total
11662 (relax_blank_list, insn_rel->r_offset, 2))
11663 return FALSE;
11664 }
11665 insn_rel->r_info =
11666 ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info), R_NDS32_NONE);
11667 }
11668 /* Save the new one for later use. */
11669 insn_rel = irel;
11670 }
11671 else
11672 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11673 R_NDS32_NONE);
11674 }
11675 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL)
11676 {
11677 /* Search for label. */
11678 int force_relax = 0;
11679
11680 /* Label on 16-bit instruction or optimization
11681 needless, just reset this reloc. */
11682 insn16 = bfd_getb16 (contents + irel->r_offset);
11683 if ((irel->r_addend & 0x1f) < 2 && (!optimize || (insn16 & 0x8000)))
11684 {
11685 irel->r_info =
11686 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11687 continue;
11688 }
11689
11690 address =
11691 irel->r_offset - get_nds32_elf_blank_total (relax_blank_list,
11692 irel->r_offset, 1);
11693
11694 if (!insn_rel)
11695 {
11696 /* Check if there is case which can not be aligned. */
11697 if (irel->r_addend == 2 && address & 0x2)
11698 return FALSE;
11699 continue;
11700 }
11701
11702 /* Try to align this label. */
11703
11704 if ((irel->r_addend & 0x1f) < 2)
11705 {
11706 /* Check if there is a INSN16 at the same address.
11707 Label_rel always seats before insn_rel after
11708 our sort. */
11709
11710 /* Search for INSN16 at LABEL location. If INSN16 is at
11711 same location and this LABEL alignment is lower than 2,
11712 the INSN16 can be converted to 2-byte. */
11713 for (tmp_rel = irel;
11714 tmp_rel < irelend && tmp_rel->r_offset == irel->r_offset;
11715 tmp_rel++)
11716 {
11717 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16
11718 && (is_convert_32_to_16
11719 (abfd, sec, tmp_rel, internal_relocs,
11720 irelend, &insn16)
11721 || is_16bit_NOP (abfd, sec, tmp_rel)))
11722 {
11723 force_relax = 1;
11724 break;
11725 }
11726 }
11727 }
11728
11729 if (force_relax || irel->r_addend == 1 || address & 0x2)
11730 {
11731 /* Label not aligned. */
11732 /* Previous reloc exists, reduce its size to 16-bit. */
11733 if (is_convert_32_to_16 (abfd, sec, insn_rel,
11734 internal_relocs, irelend, &insn16))
11735 {
11736 nds32_elf_write_16 (abfd, contents, insn_rel,
11737 internal_relocs, irelend, insn16);
11738
11739 if (!insert_nds32_elf_blank_recalc_total
11740 (relax_blank_list, insn_rel->r_offset + 2, 2))
11741 return FALSE;
11742 }
11743 else if (is_16bit_NOP (abfd, sec, insn_rel))
11744 {
11745 if (!insert_nds32_elf_blank_recalc_total
11746 (relax_blank_list, insn_rel->r_offset, 2))
11747 return FALSE;
11748 }
11749
11750 }
11751 /* INSN16 reloc is used. */
11752 insn_rel = NULL;
11753 }
11754 }
11755
11756 address =
11757 sec->size - get_nds32_elf_blank_total (relax_blank_list, sec->size, 0);
11758 if (insn_rel && (address & 0x2 || opt_size))
11759 {
11760 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11761 irelend, &insn16))
11762 {
11763 nds32_elf_write_16 (abfd, contents, insn_rel, internal_relocs,
11764 irelend, insn16);
11765 if (!insert_nds32_elf_blank_recalc_total
11766 (relax_blank_list, insn_rel->r_offset + 2, 2))
11767 return FALSE;
11768 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
11769 R_NDS32_NONE);
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 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
11777 R_NDS32_NONE);
11778 }
11779 }
11780 insn_rel = NULL;
11781 return TRUE;
11782 }
11783
11784 /* Pick relaxation round. */
11785
11786 static int
11787 nds32_elf_pick_relax (bfd_boolean init, asection *sec, bfd_boolean *again,
11788 struct elf_nds32_link_hash_table *table,
11789 struct bfd_link_info *link_info)
11790 {
11791 static asection *final_sec, *first_sec = NULL;
11792 static bfd_boolean normal_again = FALSE;
11793 static bfd_boolean set = FALSE;
11794 static bfd_boolean first = TRUE;
11795 int round_table[] = {
11796 NDS32_RELAX_NORMAL_ROUND,
11797 NDS32_RELAX_JUMP_IFC_ROUND,
11798 NDS32_RELAX_EX9_BUILD_ROUND,
11799 NDS32_RELAX_EX9_REPLACE_ROUND,
11800 };
11801 static int pass = 0;
11802 static int relax_round;
11803
11804 /* The new round. */
11805 if (init && first_sec == sec)
11806 {
11807 set = TRUE;
11808 normal_again = FALSE;
11809 }
11810
11811 if (first)
11812 {
11813 /* Run an empty run to get the final section. */
11814 relax_round = NDS32_RELAX_EMPTY_ROUND;
11815
11816 /* It has to enter relax again because we can
11817 not make sure what the final turn is. */
11818 *again = TRUE;
11819
11820 first = FALSE;
11821 first_sec = sec;
11822 }
11823
11824 if (!set)
11825 {
11826 /* Not reenter yet. */
11827 final_sec = sec;
11828 return relax_round;
11829 }
11830
11831 relax_round = round_table[pass];
11832
11833 if (!init && relax_round == NDS32_RELAX_NORMAL_ROUND && *again)
11834 normal_again = TRUE;
11835
11836 if (!init && final_sec == sec)
11837 {
11838 switch (relax_round)
11839 {
11840 case NDS32_RELAX_NORMAL_ROUND:
11841 if (!normal_again)
11842 {
11843 /* Normal relaxation done. */
11844 if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
11845 {
11846 pass++;
11847 *again = TRUE;
11848 }
11849 else if (table->target_optimize & NDS32_RELAX_EX9_ON)
11850 {
11851 pass += 2; /* NDS32_RELAX_EX9_BUILD_ROUND */
11852 *again = TRUE;
11853 }
11854 else if (table->ex9_import_file)
11855 {
11856 /* Import ex9 table. */
11857 if (table->update_ex9_table)
11858 pass += 2; /* NDS32_RELAX_EX9_BUILD_ROUND */
11859 else
11860 pass += 3; /* NDS32_RELAX_EX9_REPLACE_ROUND */
11861 nds32_elf_ex9_import_table (link_info);
11862 *again = TRUE;
11863 }
11864 }
11865 break;
11866 case NDS32_RELAX_JUMP_IFC_ROUND:
11867 if (!nds32_elf_ifc_finish (link_info))
11868 _bfd_error_handler (_("error: Jump IFC Fail."));
11869 if (table->target_optimize & NDS32_RELAX_EX9_ON)
11870 {
11871 pass++;
11872 *again = TRUE;
11873 }
11874 break;
11875 case NDS32_RELAX_EX9_BUILD_ROUND:
11876 nds32_elf_ex9_finish (link_info);
11877 pass++;
11878 *again = TRUE;
11879 break;
11880 case NDS32_RELAX_EX9_REPLACE_ROUND:
11881 if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
11882 {
11883 /* Do jump IFC optimization again. */
11884 if (!nds32_elf_ifc_finish (link_info))
11885 _bfd_error_handler (_("error: Jump IFC Fail."));
11886 }
11887 break;
11888 default:
11889 break;
11890 }
11891 }
11892
11893 return relax_round;
11894 }
11895
11896 static bfd_boolean
11897 nds32_elf_relax_section (bfd *abfd, asection *sec,
11898 struct bfd_link_info *link_info, bfd_boolean *again)
11899 {
11900 nds32_elf_blank_t *relax_blank_list = NULL;
11901 Elf_Internal_Shdr *symtab_hdr;
11902 Elf_Internal_Rela *internal_relocs;
11903 Elf_Internal_Rela *irel;
11904 Elf_Internal_Rela *irelend;
11905 Elf_Internal_Sym *isymbuf = NULL;
11906 bfd_byte *contents = NULL;
11907 bfd_boolean result = TRUE;
11908 int optimize = 0;
11909 int opt_size = 0;
11910 uint32_t insn;
11911 uint16_t insn16;
11912
11913 /* Target dependnet option. */
11914 struct elf_nds32_link_hash_table *table;
11915 int load_store_relax;
11916 int relax_round;
11917
11918 relax_blank_list = NULL;
11919
11920 *again = FALSE;
11921
11922 /* Nothing to do for
11923 * relocatable link or
11924 * non-relocatable section or
11925 * non-code section or
11926 * empty content or
11927 * no reloc entry. */
11928 if (bfd_link_relocatable (link_info)
11929 || (sec->flags & SEC_RELOC) == 0
11930 || (sec->flags & SEC_EXCLUDE) == 1
11931 || (sec->flags & SEC_CODE) == 0
11932 || sec->size == 0)
11933 return TRUE;
11934
11935 /* 09.12.11 Workaround. */
11936 /* We have to adjust align for R_NDS32_LABEL if needed.
11937 The adjust approach only can fix 2-byte align once. */
11938 if (sec->alignment_power > 2)
11939 return TRUE;
11940
11941 /* The optimization type to do. */
11942
11943 table = nds32_elf_hash_table (link_info);
11944 relax_round = nds32_elf_pick_relax (TRUE, sec, again, table, link_info);
11945 switch (relax_round)
11946 {
11947 case NDS32_RELAX_JUMP_IFC_ROUND:
11948 /* Here is the entrance of ifc jump relaxation. */
11949 if (!nds32_elf_ifc_calc (link_info, abfd, sec))
11950 return FALSE;
11951 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11952 return TRUE;
11953
11954 case NDS32_RELAX_EX9_BUILD_ROUND:
11955 /* Here is the entrance of ex9 relaxation. There are two pass of
11956 ex9 relaxation. The one is to traverse all instructions and build
11957 the hash table. The other one is to compare instructions and replace
11958 it by ex9.it. */
11959 if (!nds32_elf_ex9_build_hash_table (abfd, sec, link_info))
11960 return FALSE;
11961 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11962 return TRUE;
11963
11964 case NDS32_RELAX_EX9_REPLACE_ROUND:
11965 if (!nds32_elf_ex9_replace_instruction (link_info, abfd, sec))
11966 return FALSE;
11967 return TRUE;
11968
11969 case NDS32_RELAX_EMPTY_ROUND:
11970 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11971 return TRUE;
11972
11973 case NDS32_RELAX_NORMAL_ROUND:
11974 default:
11975 if (sec->reloc_count == 0)
11976 return TRUE;
11977 break;
11978 }
11979
11980 /* The begining of general relaxation. */
11981
11982 if (is_SDA_BASE_set == 0)
11983 {
11984 bfd_vma gp;
11985 is_SDA_BASE_set = 1;
11986 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11987 &gp, FALSE);
11988 relax_range_measurement (abfd);
11989 }
11990
11991 if (is_ITB_BASE_set == 0)
11992 {
11993 /* Set the _ITB_BASE_. */
11994 if (!nds32_elf_ex9_itb_base (link_info))
11995 {
11996 _bfd_error_handler (_("%B: error: Cannot set _ITB_BASE_"), abfd);
11997 bfd_set_error (bfd_error_bad_value);
11998 }
11999 }
12000
12001 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12002 /* Relocations MUST be kept in memory, because relaxation adjust them. */
12003 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12004 TRUE /* keep_memory */);
12005 if (internal_relocs == NULL)
12006 goto error_return;
12007
12008 irelend = internal_relocs + sec->reloc_count;
12009 irel = find_relocs_at_address (internal_relocs, internal_relocs,
12010 irelend, R_NDS32_RELAX_ENTRY);
12011
12012 if (irel == irelend)
12013 return TRUE;
12014
12015 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
12016 {
12017 if (irel->r_addend & R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG)
12018 {
12019 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12020 return TRUE;
12021 }
12022
12023 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FLAG)
12024 optimize = 1;
12025
12026 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FOR_SPACE_FLAG)
12027 opt_size = 1;
12028 }
12029
12030 load_store_relax = table->load_store_relax;
12031
12032 /* Get symbol table and section content. */
12033 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12034 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12035 goto error_return;
12036
12037 /* Do relax loop only when finalize is not done.
12038 Take care of relaxable relocs except INSN16. */
12039 for (irel = internal_relocs; irel < irelend; irel++)
12040 {
12041 int seq_len; /* Original length of instruction sequence. */
12042 int insn_len = 0; /* Final length of instruction sequence. */
12043 bfd_boolean removed;
12044
12045 insn = 0;
12046 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
12047 && (irel->r_addend & 0x1f) >= 2)
12048 optimize = 1;
12049
12050 /* Relocation Types
12051 R_NDS32_LONGCALL1 53
12052 R_NDS32_LONGCALL2 54
12053 R_NDS32_LONGCALL3 55
12054 R_NDS32_LONGJUMP1 56
12055 R_NDS32_LONGJUMP2 57
12056 R_NDS32_LONGJUMP3 58
12057 R_NDS32_LOADSTORE 59 */
12058 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL1
12059 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LOADSTORE)
12060 seq_len = GET_SEQ_LEN (irel->r_addend);
12061
12062 /* Relocation Types
12063 R_NDS32_LONGCALL4 107
12064 R_NDS32_LONGCALL5 108
12065 R_NDS32_LONGCALL6 109
12066 R_NDS32_LONGJUMP4 110
12067 R_NDS32_LONGJUMP5 111
12068 R_NDS32_LONGJUMP6 112
12069 R_NDS32_LONGJUMP7 113 */
12070 else if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL4
12071 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LONGJUMP7)
12072 seq_len = 4;
12073
12074 /* Relocation Types
12075 R_NDS32_LO12S0_RELA 30
12076 R_NDS32_LO12S1_RELA 29
12077 R_NDS32_LO12S2_RELA 28
12078 R_NDS32_LO12S2_SP_RELA 71
12079 R_NDS32_LO12S2_DP_RELA 70
12080 R_NDS32_GOT_LO12 46
12081 R_NDS32_GOTOFF_LO12 50
12082 R_NDS32_PLTREL_LO12 65
12083 R_NDS32_PLT_GOTREL_LO12 67
12084 R_NDS32_17IFC_PCREL_RELA 96
12085 R_NDS32_GOT_SUFF 193
12086 R_NDS32_GOTOFF_SUFF 194
12087 R_NDS32_PLT_GOT_SUFF 195
12088 R_NDS32_MULCALL_SUFF 196
12089 R_NDS32_PTR 197 */
12090 else if ((ELF32_R_TYPE (irel->r_info) <= R_NDS32_LO12S0_RELA
12091 && ELF32_R_TYPE (irel->r_info) >= R_NDS32_LO12S2_RELA)
12092 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_SP_RELA
12093 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_DP_RELA
12094 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12
12095 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12
12096 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12
12097 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLTREL_LO12
12098 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12
12099 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_GOT_SUFF
12100 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_PTR)
12101 || ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12102 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LO12
12103 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_ADD
12104 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LS)
12105 seq_len = 0;
12106 else
12107 continue;
12108
12109 insn_len = seq_len;
12110 removed = FALSE;
12111
12112 switch (ELF32_R_TYPE (irel->r_info))
12113 {
12114 case R_NDS32_LONGCALL1:
12115 removed = nds32_elf_relax_longcall1 (abfd, sec, irel, internal_relocs,
12116 &insn_len, contents, isymbuf,
12117 symtab_hdr);
12118 break;
12119 case R_NDS32_LONGCALL2:
12120 removed = nds32_elf_relax_longcall2 (abfd, sec, irel, internal_relocs,
12121 &insn_len, contents, isymbuf,
12122 symtab_hdr);
12123 break;
12124 case R_NDS32_LONGCALL3:
12125 removed = nds32_elf_relax_longcall3 (abfd, sec, irel, internal_relocs,
12126 &insn_len, contents, isymbuf,
12127 symtab_hdr);
12128 break;
12129 case R_NDS32_LONGJUMP1:
12130 removed = nds32_elf_relax_longjump1 (abfd, sec, irel, internal_relocs,
12131 &insn_len, contents, isymbuf,
12132 symtab_hdr);
12133 break;
12134 case R_NDS32_LONGJUMP2:
12135 removed = nds32_elf_relax_longjump2 (abfd, sec, irel, internal_relocs,
12136 &insn_len, contents, isymbuf,
12137 symtab_hdr);
12138 break;
12139 case R_NDS32_LONGJUMP3:
12140 removed = nds32_elf_relax_longjump3 (abfd, sec, irel, internal_relocs,
12141 &insn_len, contents, isymbuf,
12142 symtab_hdr);
12143 break;
12144 case R_NDS32_LONGCALL4:
12145 removed = nds32_elf_relax_longcall4 (abfd, sec, irel, internal_relocs,
12146 &insn_len, contents, isymbuf,
12147 symtab_hdr);
12148 break;
12149 case R_NDS32_LONGCALL5:
12150 removed = nds32_elf_relax_longcall5 (abfd, sec, irel, internal_relocs,
12151 &insn_len, contents, isymbuf,
12152 symtab_hdr);
12153 break;
12154 case R_NDS32_LONGCALL6:
12155 removed = nds32_elf_relax_longcall6 (abfd, sec, irel, internal_relocs,
12156 &insn_len, contents, isymbuf,
12157 symtab_hdr);
12158 break;
12159 case R_NDS32_LONGJUMP4:
12160 removed = nds32_elf_relax_longjump4 (abfd, sec, irel, internal_relocs,
12161 &insn_len, contents, isymbuf,
12162 symtab_hdr);
12163 break;
12164 case R_NDS32_LONGJUMP5:
12165 removed = nds32_elf_relax_longjump5 (abfd, sec, irel, internal_relocs,
12166 &insn_len, &seq_len, contents,
12167 isymbuf, symtab_hdr);
12168 break;
12169 case R_NDS32_LONGJUMP6:
12170 removed = nds32_elf_relax_longjump6 (abfd, sec, irel, internal_relocs,
12171 &insn_len, &seq_len, contents,
12172 isymbuf, symtab_hdr);
12173 break;
12174 case R_NDS32_LONGJUMP7:
12175 removed = nds32_elf_relax_longjump7 (abfd, sec, irel, internal_relocs,
12176 &insn_len, &seq_len, contents,
12177 isymbuf, symtab_hdr);
12178 break;
12179 case R_NDS32_LOADSTORE:
12180 removed = nds32_elf_relax_loadstore (link_info, abfd, sec, irel,
12181 internal_relocs, &insn_len,
12182 contents, isymbuf, symtab_hdr,
12183 load_store_relax);
12184 break;
12185 case R_NDS32_LO12S0_RELA:
12186 case R_NDS32_LO12S1_RELA:
12187 case R_NDS32_LO12S2_DP_RELA:
12188 case R_NDS32_LO12S2_SP_RELA:
12189 case R_NDS32_LO12S2_RELA:
12190 /* Relax for low part. */
12191 nds32_elf_relax_lo12 (link_info, abfd, sec, irel, internal_relocs,
12192 contents, isymbuf, symtab_hdr);
12193
12194 /* It is impossible to delete blank, so just continue. */
12195 continue;
12196 case R_NDS32_GOT_LO12:
12197 case R_NDS32_GOTOFF_LO12:
12198 case R_NDS32_PLTREL_LO12:
12199 case R_NDS32_PLT_GOTREL_LO12:
12200 case R_NDS32_GOTPC_LO12:
12201 /* Relax for PIC gp-relative low part. */
12202 nds32_elf_relax_piclo12 (link_info, abfd, sec, irel, contents,
12203 isymbuf, symtab_hdr);
12204
12205 /* It is impossible to delete blank, so just continue. */
12206 continue;
12207 case R_NDS32_TLS_LE_LO12:
12208 /* Relax for LE TLS low part. */
12209 nds32_elf_relax_letlslo12 (link_info, abfd, irel, contents,
12210 isymbuf, symtab_hdr);
12211
12212 /* It is impossible to delete blank, so just continue. */
12213 continue;
12214 case R_NDS32_TLS_LE_ADD:
12215 nds32_elf_relax_letlsadd (link_info, abfd, sec, irel, internal_relocs,
12216 contents, isymbuf, symtab_hdr, again);
12217 /* It is impossible to delete blank, so just continue. */
12218 continue;
12219 case R_NDS32_TLS_LE_LS:
12220 nds32_elf_relax_letlsls (link_info, abfd, sec, irel, internal_relocs,
12221 contents, isymbuf, symtab_hdr, again);
12222 continue;
12223 case R_NDS32_PTR:
12224 removed = nds32_elf_relax_ptr (abfd, sec, irel, internal_relocs,
12225 &insn_len, &seq_len, contents);
12226 break;
12227 case R_NDS32_PLT_GOT_SUFF:
12228 nds32_elf_relax_pltgot_suff (link_info, abfd, sec, irel,
12229 internal_relocs, contents,
12230 isymbuf, symtab_hdr, again);
12231 /* It is impossible to delete blank, so just continue. */
12232 continue;
12233 case R_NDS32_GOT_SUFF:
12234 nds32_elf_relax_got_suff (link_info, abfd, sec, irel,
12235 internal_relocs, contents,
12236 symtab_hdr, again);
12237 /* It is impossible to delete blank, so just continue. */
12238 continue;
12239 case R_NDS32_GOTOFF_SUFF:
12240 nds32_elf_relax_gotoff_suff (link_info, abfd, sec, irel,
12241 internal_relocs, contents,
12242 isymbuf, symtab_hdr, again);
12243 /* It is impossible to delete blank, so just continue. */
12244 continue;
12245 default:
12246 continue;
12247
12248 }
12249 if (removed && seq_len - insn_len > 0)
12250 {
12251 if (!insert_nds32_elf_blank
12252 (&relax_blank_list, irel->r_offset + insn_len,
12253 seq_len - insn_len))
12254 goto error_return;
12255 *again = TRUE;
12256 }
12257 }
12258
12259 calc_nds32_blank_total (relax_blank_list);
12260
12261 if (table->relax_fp_as_gp)
12262 {
12263 if (!nds32_relax_fp_as_gp (link_info, abfd, sec, internal_relocs,
12264 irelend, isymbuf))
12265 goto error_return;
12266
12267 if (*again == FALSE)
12268 {
12269 if (!nds32_fag_remove_unused_fpbase (abfd, sec, internal_relocs,
12270 irelend))
12271 goto error_return;
12272 }
12273 }
12274
12275 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12276
12277 if (*again == FALSE)
12278 {
12279 if (!nds32_relax_adjust_label (abfd, sec, internal_relocs, contents,
12280 &relax_blank_list, optimize, opt_size))
12281 goto error_return;
12282 }
12283
12284 /* It doesn't matter optimize_for_space_no_align anymore.
12285 If object file is assembled with flag '-Os',
12286 the we don't adjust jump-destination on 4-byte boundary. */
12287
12288 if (relax_blank_list)
12289 {
12290 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12291 relax_blank_list = NULL;
12292 }
12293
12294 if (*again == FALSE)
12295 {
12296 /* Closing the section, so we don't relax it anymore. */
12297 bfd_vma sec_size_align;
12298 Elf_Internal_Rela *tmp_rel;
12299
12300 /* Pad to alignment boundary. Only handle current section alignment. */
12301 sec_size_align = (sec->size + (~((-1U) << sec->alignment_power)))
12302 & ((-1U) << sec->alignment_power);
12303 if ((sec_size_align - sec->size) & 0x2)
12304 {
12305 insn16 = NDS32_NOP16;
12306 bfd_putb16 (insn16, contents + sec->size);
12307 sec->size += 2;
12308 }
12309
12310 while (sec_size_align != sec->size)
12311 {
12312 insn = NDS32_NOP32;
12313 bfd_putb32 (insn, contents + sec->size);
12314 sec->size += 4;
12315 }
12316
12317 tmp_rel = find_relocs_at_address (internal_relocs, internal_relocs,
12318 irelend, R_NDS32_RELAX_ENTRY);
12319 if (tmp_rel != irelend)
12320 tmp_rel->r_addend |= R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG;
12321
12322 clean_nds32_elf_blank ();
12323 }
12324
12325 finish:
12326 if (internal_relocs != NULL
12327 && elf_section_data (sec)->relocs != internal_relocs)
12328 free (internal_relocs);
12329
12330 if (contents != NULL
12331 && elf_section_data (sec)->this_hdr.contents != contents)
12332 free (contents);
12333
12334 if (isymbuf != NULL && symtab_hdr->contents != (bfd_byte *) isymbuf)
12335 free (isymbuf);
12336
12337 return result;
12338
12339 error_return:
12340 result = FALSE;
12341 goto finish;
12342 }
12343
12344 static struct bfd_elf_special_section const nds32_elf_special_sections[] =
12345 {
12346 {".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE},
12347 {".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE},
12348 {NULL, 0, 0, 0, 0}
12349 };
12350
12351 static bfd_boolean
12352 nds32_elf_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
12353 struct bfd_link_info *info,
12354 void *finfo ATTRIBUTE_UNUSED,
12355 bfd_boolean (*func) (void *, const char *,
12356 Elf_Internal_Sym *,
12357 asection *,
12358 struct elf_link_hash_entry *)
12359 ATTRIBUTE_UNUSED)
12360 {
12361 FILE *sym_ld_script = NULL;
12362 struct elf_nds32_link_hash_table *table;
12363
12364 table = nds32_elf_hash_table (info);
12365 sym_ld_script = table->sym_ld_script;
12366
12367 if (check_start_export_sym)
12368 fprintf (sym_ld_script, "}\n");
12369
12370 return TRUE;
12371 }
12372
12373 static enum elf_reloc_type_class
12374 nds32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
12375 const asection *rel_sec ATTRIBUTE_UNUSED,
12376 const Elf_Internal_Rela *rela)
12377 {
12378 switch ((int) ELF32_R_TYPE (rela->r_info))
12379 {
12380 case R_NDS32_RELATIVE:
12381 return reloc_class_relative;
12382 case R_NDS32_JMP_SLOT:
12383 return reloc_class_plt;
12384 case R_NDS32_COPY:
12385 return reloc_class_copy;
12386 default:
12387 return reloc_class_normal;
12388 }
12389 }
12390
12391 /* Put target dependent option into info hash table. */
12392 void
12393 bfd_elf32_nds32_set_target_option (struct bfd_link_info *link_info,
12394 int relax_fp_as_gp,
12395 int eliminate_gc_relocs,
12396 FILE * sym_ld_script, int load_store_relax,
12397 int target_optimize, int relax_status,
12398 int relax_round, FILE * ex9_export_file,
12399 FILE * ex9_import_file,
12400 int update_ex9_table, int ex9_limit,
12401 bfd_boolean ex9_loop_aware,
12402 bfd_boolean ifc_loop_aware)
12403 {
12404 struct elf_nds32_link_hash_table *table;
12405
12406 table = nds32_elf_hash_table (link_info);
12407 if (table == NULL)
12408 return;
12409
12410 table->relax_fp_as_gp = relax_fp_as_gp;
12411 table->eliminate_gc_relocs = eliminate_gc_relocs;
12412 table->sym_ld_script = sym_ld_script;
12413 table ->load_store_relax = load_store_relax;
12414 table->target_optimize = target_optimize;
12415 table->relax_status = relax_status;
12416 table->relax_round = relax_round;
12417 table->ex9_export_file = ex9_export_file;
12418 table->ex9_import_file = ex9_import_file;
12419 table->update_ex9_table = update_ex9_table;
12420 table->ex9_limit = ex9_limit;
12421 table->ex9_loop_aware = ex9_loop_aware;
12422 table->ifc_loop_aware = ifc_loop_aware;
12423 }
12424 \f
12425 /* These functions and data-structures are used for fp-as-gp
12426 optimization. */
12427
12428 #define FAG_THRESHOLD 3 /* At least 3 gp-access. */
12429 /* lwi37.fp covers 508 bytes, but there may be 32-byte padding between
12430 the read-only section and read-write section. */
12431 #define FAG_WINDOW (508 - 32)
12432
12433 /* An nds32_fag represent a gp-relative access.
12434 We find best fp-base by using a sliding window
12435 to find a base address which can cover most gp-access. */
12436 struct nds32_fag
12437 {
12438 struct nds32_fag *next; /* NULL-teminated linked list. */
12439 bfd_vma addr; /* The address of this fag. */
12440 Elf_Internal_Rela **relas; /* The relocations associated with this fag.
12441 It is used for applying FP7U2_FLAG. */
12442 int count; /* How many times this address is referred.
12443 There should be exactly `count' relocations
12444 in relas. */
12445 int relas_capcity; /* The buffer size of relas.
12446 We use an array instead of linked-list,
12447 and realloc is used to adjust buffer size. */
12448 };
12449
12450 static void
12451 nds32_fag_init (struct nds32_fag *head)
12452 {
12453 memset (head, 0, sizeof (struct nds32_fag));
12454 }
12455
12456 static void
12457 nds32_fag_verify (struct nds32_fag *head)
12458 {
12459 struct nds32_fag *iter;
12460 struct nds32_fag *prev;
12461
12462 prev = NULL;
12463 iter = head->next;
12464 while (iter)
12465 {
12466 if (prev && prev->addr >= iter->addr)
12467 puts ("Bug in fp-as-gp insertion.");
12468 prev = iter;
12469 iter = iter->next;
12470 }
12471 }
12472
12473 /* Insert a fag in ascending order.
12474 If a fag of the same address already exists,
12475 they are chained by relas array. */
12476
12477 static void
12478 nds32_fag_insert (struct nds32_fag *head, bfd_vma addr,
12479 Elf_Internal_Rela * rel)
12480 {
12481 struct nds32_fag *iter;
12482 struct nds32_fag *new_fag;
12483 const int INIT_RELAS_CAP = 4;
12484
12485 for (iter = head;
12486 iter->next && iter->next->addr <= addr;
12487 iter = iter->next)
12488 /* Find somewhere to insert. */ ;
12489
12490 /* `iter' will be equal to `head' if the list is empty. */
12491 if (iter != head && iter->addr == addr)
12492 {
12493 /* The address exists in the list.
12494 Insert `rel' into relocation list, relas. */
12495
12496 /* Check whether relas is big enough. */
12497 if (iter->count >= iter->relas_capcity)
12498 {
12499 iter->relas_capcity *= 2;
12500 iter->relas = bfd_realloc
12501 (iter->relas, iter->relas_capcity * sizeof (void *));
12502 }
12503 iter->relas[iter->count++] = rel;
12504 return;
12505 }
12506
12507 /* This is a new address. Create a fag node for it. */
12508 new_fag = bfd_malloc (sizeof (struct nds32_fag));
12509 memset (new_fag, 0, sizeof (*new_fag));
12510 new_fag->addr = addr;
12511 new_fag->count = 1;
12512 new_fag->next = iter->next;
12513 new_fag->relas_capcity = INIT_RELAS_CAP;
12514 new_fag->relas = (Elf_Internal_Rela **)
12515 bfd_malloc (new_fag->relas_capcity * sizeof (void *));
12516 new_fag->relas[0] = rel;
12517 iter->next = new_fag;
12518
12519 nds32_fag_verify (head);
12520 }
12521
12522 static void
12523 nds32_fag_free_list (struct nds32_fag *head)
12524 {
12525 struct nds32_fag *iter;
12526
12527 iter = head->next;
12528 while (iter)
12529 {
12530 struct nds32_fag *tmp = iter;
12531 iter = iter->next;
12532 free (tmp->relas);
12533 tmp->relas = NULL;
12534 free (tmp);
12535 }
12536 }
12537
12538 /* Find the best fp-base address.
12539 The relocation associated with that address is returned,
12540 so we can track the symbol instead of a fixed address.
12541
12542 When relaxation, the address of an datum may change,
12543 because a text section is shrinked, so the data section
12544 moves forward. If the aligments of text and data section
12545 are different, their distance may change too.
12546 Therefore, tracking a fixed address is not appriate. */
12547
12548 static int
12549 nds32_fag_find_base (struct nds32_fag *head, struct nds32_fag **bestpp)
12550 {
12551 struct nds32_fag *base; /* First fag in the window. */
12552 struct nds32_fag *last; /* First fag outside the window. */
12553 int accu = 0; /* Usage accumulation. */
12554 struct nds32_fag *best; /* Best fag. */
12555 int baccu = 0; /* Best accumulation. */
12556
12557 /* Use first fag for initial, and find the last fag in the window.
12558
12559 In each iteration, we could simply subtract previous fag
12560 and accumulate following fags which are inside the window,
12561 untill we each the end. */
12562
12563 if (head->next == NULL)
12564 {
12565 *bestpp = NULL;
12566 return 0;
12567 }
12568
12569 /* Initialize base. */
12570 base = head->next;
12571 best = base;
12572 for (last = base;
12573 last && last->addr < base->addr + FAG_WINDOW;
12574 last = last->next)
12575 accu += last->count;
12576
12577 baccu = accu;
12578
12579 /* Record the best base in each iteration. */
12580 while (base->next)
12581 {
12582 accu -= base->count;
12583 base = base->next;
12584 /* Account fags in window. */
12585 for (/* Nothing. */;
12586 last && last->addr < base->addr + FAG_WINDOW;
12587 last = last->next)
12588 accu += last->count;
12589
12590 /* A better fp-base? */
12591 if (accu > baccu)
12592 {
12593 best = base;
12594 baccu = accu;
12595 }
12596 }
12597
12598 if (bestpp)
12599 *bestpp = best;
12600 return baccu;
12601 }
12602
12603 /* Apply R_NDS32_INSN16_FP7U2_FLAG on gp-relative accesses,
12604 so we can convert it fo fp-relative access later.
12605 `best_fag' is the best fp-base. Only those inside the window
12606 of best_fag is applied the flag. */
12607
12608 static bfd_boolean
12609 nds32_fag_mark_relax (struct bfd_link_info *link_info,
12610 bfd *abfd, struct nds32_fag *best_fag,
12611 Elf_Internal_Rela *internal_relocs,
12612 Elf_Internal_Rela *irelend)
12613 {
12614 struct nds32_fag *ifag;
12615 bfd_vma best_fpbase, gp;
12616 bfd *output_bfd;
12617
12618 output_bfd = abfd->sections->output_section->owner;
12619 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
12620 best_fpbase = best_fag->addr;
12621
12622 if (best_fpbase > gp + sdata_range[1][1]
12623 || best_fpbase < gp - sdata_range[1][0])
12624 return FALSE;
12625
12626 /* Mark these inside the window R_NDS32_INSN16_FP7U2_FLAG flag,
12627 so we know they can be converted to lwi37.fp. */
12628 for (ifag = best_fag;
12629 ifag && ifag->addr < best_fpbase + FAG_WINDOW; ifag = ifag->next)
12630 {
12631 int i;
12632
12633 for (i = 0; i < ifag->count; i++)
12634 {
12635 Elf_Internal_Rela *insn16_rel;
12636 Elf_Internal_Rela *fag_rel;
12637
12638 fag_rel = ifag->relas[i];
12639
12640 /* Only if this is within the WINDOWS, FP7U2_FLAG
12641 is applied. */
12642
12643 insn16_rel = find_relocs_at_address
12644 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12645
12646 if (insn16_rel != irelend)
12647 insn16_rel->r_addend = R_NDS32_INSN16_FP7U2_FLAG;
12648 }
12649 }
12650 return TRUE;
12651 }
12652
12653 /* Reset INSN16 to clean fp as gp. */
12654
12655 static void
12656 nds32_fag_unmark_relax (struct nds32_fag *fag,
12657 Elf_Internal_Rela *internal_relocs,
12658 Elf_Internal_Rela *irelend)
12659 {
12660 struct nds32_fag *ifag;
12661 int i;
12662 Elf_Internal_Rela *insn16_rel;
12663 Elf_Internal_Rela *fag_rel;
12664
12665 for (ifag = fag; ifag; ifag = ifag->next)
12666 {
12667 for (i = 0; i < ifag->count; i++)
12668 {
12669 fag_rel = ifag->relas[i];
12670
12671 /* Restore the INSN16 relocation. */
12672 insn16_rel = find_relocs_at_address
12673 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12674
12675 if (insn16_rel != irelend)
12676 insn16_rel->r_addend &= ~R_NDS32_INSN16_FP7U2_FLAG;
12677 }
12678 }
12679 }
12680
12681 /* This is the main function of fp-as-gp optimization.
12682 It should be called by relax_section. */
12683
12684 static bfd_boolean
12685 nds32_relax_fp_as_gp (struct bfd_link_info *link_info,
12686 bfd *abfd, asection *sec,
12687 Elf_Internal_Rela *internal_relocs,
12688 Elf_Internal_Rela *irelend,
12689 Elf_Internal_Sym *isymbuf)
12690 {
12691 Elf_Internal_Rela *begin_rel = NULL;
12692 Elf_Internal_Rela *irel;
12693 struct nds32_fag fag_head;
12694 Elf_Internal_Shdr *symtab_hdr;
12695 bfd_byte *contents;
12696 bfd_boolean ifc_inside = FALSE;
12697
12698 /* FIXME: Can we bfd_elf_link_read_relocs for the relocs? */
12699
12700 /* Per-function fp-base selection.
12701 1. Create a list for all the gp-relative access.
12702 2. Base on those gp-relative address,
12703 find a fp-base which can cover most access.
12704 3. Use the fp-base for fp-as-gp relaxation.
12705
12706 NOTE: If fp-as-gp is not worth to do, (e.g., less than 3 times),
12707 we should
12708 1. delete the `la $fp, _FP_BASE_' instruction and
12709 2. not convert lwi.gp to lwi37.fp.
12710
12711 To delete the _FP_BASE_ instruction, we simply apply
12712 R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG flag in the r_addend to disable it.
12713
12714 To suppress the conversion, we simply NOT to apply
12715 R_NDS32_INSN16_FP7U2_FLAG flag. */
12716
12717 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12718
12719 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12720 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12721 return FALSE;
12722
12723 /* Check whether it is worth for fp-as-gp optimization,
12724 i.e., at least 3 gp-load.
12725
12726 Set R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG if we should NOT
12727 apply this optimization. */
12728
12729 for (irel = internal_relocs; irel < irelend; irel++)
12730 {
12731 /* We recognize R_NDS32_RELAX_REGION_BEGIN/_END for the region.
12732 One we enter the begin of the region, we track all the LW/ST
12733 instructions, so when we leave the region, we try to find
12734 the best fp-base address for those LW/ST instructions. */
12735
12736 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12737 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12738 {
12739 /* Begin of the region. */
12740 if (begin_rel)
12741 /* xgettext:c-format */
12742 _bfd_error_handler (_("%B: Nested OMIT_FP in %A."), abfd, sec);
12743
12744 begin_rel = irel;
12745 nds32_fag_init (&fag_head);
12746 ifc_inside = FALSE;
12747 }
12748 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12749 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12750 {
12751 int accu;
12752 struct nds32_fag *best_fag, *tmp_fag;
12753 int dist;
12754
12755 /* End of the region.
12756 Check whether it is worth to do fp-as-gp. */
12757
12758 if (begin_rel == NULL)
12759 {
12760 /* xgettext:c-format */
12761 _bfd_error_handler (_("%B: Unmatched OMIT_FP in %A."), abfd, sec);
12762 continue;
12763 }
12764
12765 accu = nds32_fag_find_base (&fag_head, &best_fag);
12766
12767 /* Clean FP7U2_FLAG because they may set ever. */
12768 tmp_fag = fag_head.next;
12769 nds32_fag_unmark_relax (tmp_fag, internal_relocs, irelend);
12770
12771 /* Check if it is worth, and FP_BASE is near enough to SDA_BASE. */
12772 if (accu < FAG_THRESHOLD
12773 || !nds32_fag_mark_relax (link_info, abfd, best_fag,
12774 internal_relocs, irelend))
12775 {
12776 /* Not worth to do fp-as-gp. */
12777 begin_rel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12778 begin_rel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12779 irel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12780 irel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12781 nds32_fag_free_list (&fag_head);
12782 begin_rel = NULL;
12783 continue;
12784 }
12785
12786 /* R_SYM of R_NDS32_RELAX_REGION_BEGIN is not used by assembler,
12787 so we use it to record the distance to the reloction of best
12788 fp-base. */
12789 dist = best_fag->relas[0] - begin_rel;
12790 BFD_ASSERT (dist > 0 && dist < 0xffffff);
12791 /* Use high 16 bits of addend to record the _FP_BASE_ matched
12792 relocation. And get the base value when relocating. */
12793 begin_rel->r_addend &= (0x1 << 16) - 1;
12794 begin_rel->r_addend |= dist << 16;
12795
12796 nds32_fag_free_list (&fag_head);
12797 begin_rel = NULL;
12798 }
12799
12800 if (begin_rel == NULL || ifc_inside)
12801 /* Skip if we are not in the region of fp-as-gp. */
12802 continue;
12803
12804 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S2_RELA
12805 || ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA17S2_RELA)
12806 {
12807 bfd_vma addr;
12808 uint32_t insn;
12809
12810 /* A gp-relative access is found. Insert it to the fag-list. */
12811
12812 /* Rt is necessary an RT3, so it can be converted to lwi37.fp. */
12813 insn = bfd_getb32 (contents + irel->r_offset);
12814 if (!N32_IS_RT3 (insn))
12815 continue;
12816
12817 addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
12818 nds32_fag_insert (&fag_head, addr, irel);
12819 }
12820 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA_FP7U2_RELA)
12821 {
12822 begin_rel = NULL;
12823 }
12824 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12825 || ELF32_R_TYPE (irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
12826 {
12827 /* Suppress fp as gp when encounter ifc. */
12828 ifc_inside = TRUE;
12829 }
12830 }
12831
12832 return TRUE;
12833 }
12834
12835 /* Remove unused `la $fp, _FD_BASE_' instruction. */
12836
12837 static bfd_boolean
12838 nds32_fag_remove_unused_fpbase (bfd *abfd, asection *sec,
12839 Elf_Internal_Rela *internal_relocs,
12840 Elf_Internal_Rela *irelend)
12841 {
12842 Elf_Internal_Rela *irel;
12843 Elf_Internal_Shdr *symtab_hdr;
12844 bfd_byte *contents = NULL;
12845 nds32_elf_blank_t *relax_blank_list = NULL;
12846 bfd_boolean result = TRUE;
12847 bfd_boolean unused_region = FALSE;
12848
12849 /*
12850 NOTE: Disable fp-as-gp if we encounter ifcall relocations.
12851 * R_NDS32_17IFC_PCREL_RELA
12852 * R_NDS32_10IFCU_PCREL_RELA
12853
12854 CASE??????????????
12855 */
12856
12857 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12858 nds32_get_section_contents (abfd, sec, &contents, TRUE);
12859
12860 for (irel = internal_relocs; irel < irelend; irel++)
12861 {
12862 /* To remove unused fp-base, we simply find the REGION_NOT_OMIT_FP
12863 we marked to in previous pass.
12864 DO NOT scan relocations again, since we've alreadly decided it
12865 and set the flag. */
12866 const char *syname;
12867 int syndx;
12868 uint32_t insn;
12869
12870 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12871 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
12872 unused_region = TRUE;
12873 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12874 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
12875 unused_region = FALSE;
12876
12877 /* We're not in the region. */
12878 if (!unused_region)
12879 continue;
12880
12881 /* _FP_BASE_ must be a GLOBAL symbol. */
12882 syndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
12883 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
12884 continue;
12885
12886 /* The symbol name must be _FP_BASE_. */
12887 syname = elf_sym_hashes (abfd)[syndx]->root.root.string;
12888 if (strcmp (syname, FP_BASE_NAME) != 0)
12889 continue;
12890
12891 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA19S0_RELA)
12892 {
12893 /* addi.gp $fp, -256 */
12894 insn = bfd_getb32 (contents + irel->r_offset);
12895 if (insn != INSN_ADDIGP_TO_FP)
12896 continue;
12897 }
12898 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S0_RELA)
12899 {
12900 /* addi $fp, $gp, -256 */
12901 insn = bfd_getb32 (contents + irel->r_offset);
12902 if (insn != INSN_ADDI_GP_TO_FP)
12903 continue;
12904 }
12905 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_20_RELA)
12906 {
12907 /* movi $fp, FP_BASE */
12908 insn = bfd_getb32 (contents + irel->r_offset);
12909 if (insn != INSN_MOVI_TO_FP)
12910 continue;
12911 }
12912 else
12913 continue;
12914
12915 /* We got here because a FP_BASE instruction is found. */
12916 if (!insert_nds32_elf_blank_recalc_total
12917 (&relax_blank_list, irel->r_offset, 4))
12918 goto error_return;
12919 }
12920
12921 finish:
12922 if (relax_blank_list)
12923 {
12924 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12925 relax_blank_list = NULL;
12926 }
12927 return result;
12928
12929 error_return:
12930 result = FALSE;
12931 goto finish;
12932 }
12933
12934 /* This is a version of bfd_generic_get_relocated_section_contents.
12935 We need this variety because relaxation will modify the dwarf
12936 infomation. When there is undefined symbol reference error mesage,
12937 linker need to dump line number where the symbol be used. However
12938 the address is be relaxed, it can not get the original dwarf contents.
12939 The variety only modify function call for reading in the section. */
12940
12941 static bfd_byte *
12942 nds32_elf_get_relocated_section_contents (bfd *abfd,
12943 struct bfd_link_info *link_info,
12944 struct bfd_link_order *link_order,
12945 bfd_byte *data,
12946 bfd_boolean relocatable,
12947 asymbol **symbols)
12948 {
12949 bfd *input_bfd = link_order->u.indirect.section->owner;
12950 asection *input_section = link_order->u.indirect.section;
12951 long reloc_size;
12952 arelent **reloc_vector;
12953 long reloc_count;
12954
12955 reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
12956 if (reloc_size < 0)
12957 return NULL;
12958
12959 /* Read in the section. */
12960 if (!nds32_get_section_contents (input_bfd, input_section, &data, FALSE))
12961 return NULL;
12962
12963 if (reloc_size == 0)
12964 return data;
12965
12966 reloc_vector = (arelent **) bfd_malloc (reloc_size);
12967 if (reloc_vector == NULL)
12968 return NULL;
12969
12970 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
12971 reloc_vector, symbols);
12972 if (reloc_count < 0)
12973 goto error_return;
12974
12975 if (reloc_count > 0)
12976 {
12977 arelent **parent;
12978 for (parent = reloc_vector; *parent != NULL; parent++)
12979 {
12980 char *error_message = NULL;
12981 asymbol *symbol;
12982 bfd_reloc_status_type r;
12983
12984 symbol = *(*parent)->sym_ptr_ptr;
12985 if (symbol->section && discarded_section (symbol->section))
12986 {
12987 bfd_byte *p;
12988 static reloc_howto_type none_howto
12989 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
12990 "unused", FALSE, 0, 0, FALSE);
12991
12992 p = data + (*parent)->address * bfd_octets_per_byte (input_bfd);
12993 _bfd_clear_contents ((*parent)->howto, input_bfd, input_section,
12994 p);
12995 (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
12996 (*parent)->addend = 0;
12997 (*parent)->howto = &none_howto;
12998 r = bfd_reloc_ok;
12999 }
13000 else
13001 r = bfd_perform_relocation (input_bfd, *parent, data,
13002 input_section,
13003 relocatable ? abfd : NULL,
13004 &error_message);
13005
13006 if (relocatable)
13007 {
13008 asection *os = input_section->output_section;
13009
13010 /* A partial link, so keep the relocs. */
13011 os->orelocation[os->reloc_count] = *parent;
13012 os->reloc_count++;
13013 }
13014
13015 if (r != bfd_reloc_ok)
13016 {
13017 switch (r)
13018 {
13019 case bfd_reloc_undefined:
13020 (*link_info->callbacks->undefined_symbol)
13021 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13022 input_bfd, input_section, (*parent)->address, TRUE);
13023 break;
13024 case bfd_reloc_dangerous:
13025 BFD_ASSERT (error_message != NULL);
13026 (*link_info->callbacks->reloc_dangerous)
13027 (link_info, error_message,
13028 input_bfd, input_section, (*parent)->address);
13029 break;
13030 case bfd_reloc_overflow:
13031 (*link_info->callbacks->reloc_overflow)
13032 (link_info, NULL,
13033 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13034 (*parent)->howto->name, (*parent)->addend,
13035 input_bfd, input_section, (*parent)->address);
13036 break;
13037 case bfd_reloc_outofrange:
13038 /* PR ld/13730:
13039 This error can result when processing some partially
13040 complete binaries. Do not abort, but issue an error
13041 message instead. */
13042 link_info->callbacks->einfo
13043 /* xgettext:c-format */
13044 (_("%X%P: %B(%A): relocation \"%R\" goes out of range\n"),
13045 abfd, input_section, * parent);
13046 goto error_return;
13047
13048 default:
13049 abort ();
13050 break;
13051 }
13052 }
13053 }
13054 }
13055
13056 free (reloc_vector);
13057 return data;
13058
13059 error_return:
13060 free (reloc_vector);
13061 return NULL;
13062 }
13063 \f
13064 /* Link-time IFC relaxation.
13065 In this optimization, we chains jump instructions
13066 of the same destination with ifcall. */
13067
13068
13069 /* List to save jal and j relocation. */
13070 struct elf_nds32_ifc_symbol_entry
13071 {
13072 asection *sec;
13073 struct elf_link_hash_entry *h;
13074 struct elf_nds32_ifc_irel_list *irel_head;
13075 unsigned long insn;
13076 int times;
13077 int enable; /* Apply ifc. */
13078 int ex9_enable; /* Apply ifc after ex9. */
13079 struct elf_nds32_ifc_symbol_entry *next;
13080 };
13081
13082 struct elf_nds32_ifc_irel_list
13083 {
13084 Elf_Internal_Rela *irel;
13085 asection *sec;
13086 bfd_vma addr;
13087 /* If this is set, then it is the last instruction for
13088 ifc-chain, so it must be keep for the actual branching. */
13089 int keep;
13090 struct elf_nds32_ifc_irel_list *next;
13091 };
13092
13093 static struct elf_nds32_ifc_symbol_entry *ifc_symbol_head = NULL;
13094
13095 /* Insert symbol of jal and j for ifc. */
13096
13097 static void
13098 nds32_elf_ifc_insert_symbol (asection *sec,
13099 struct elf_link_hash_entry *h,
13100 Elf_Internal_Rela *irel,
13101 unsigned long insn)
13102 {
13103 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13104
13105 /* Check there is target of existing entry the same as the new one. */
13106 while (ptr != NULL)
13107 {
13108 if (((h == NULL && ptr->sec == sec
13109 && ELF32_R_SYM (ptr->irel_head->irel->r_info) == ELF32_R_SYM (irel->r_info)
13110 && ptr->irel_head->irel->r_addend == irel->r_addend)
13111 || h != NULL)
13112 && ptr->h == h
13113 && ptr->insn == insn)
13114 {
13115 /* The same target exist, so insert into list. */
13116 struct elf_nds32_ifc_irel_list *irel_list = ptr->irel_head;
13117
13118 while (irel_list->next != NULL)
13119 irel_list = irel_list->next;
13120 irel_list->next = bfd_malloc (sizeof (struct elf_nds32_ifc_irel_list));
13121 irel_list = irel_list->next;
13122 irel_list->irel = irel;
13123 irel_list->keep = 1;
13124
13125 if (h == NULL)
13126 irel_list->sec = NULL;
13127 else
13128 irel_list->sec = sec;
13129 irel_list->next = NULL;
13130 return;
13131 }
13132 if (ptr->next == NULL)
13133 break;
13134 ptr = ptr->next;
13135 }
13136
13137 /* There is no same target entry, so build a new one. */
13138 if (ifc_symbol_head == NULL)
13139 {
13140 ifc_symbol_head = bfd_malloc (sizeof (struct elf_nds32_ifc_symbol_entry));
13141 ptr = ifc_symbol_head;
13142 }
13143 else
13144 {
13145 ptr->next = bfd_malloc (sizeof (struct elf_nds32_ifc_symbol_entry));
13146 ptr = ptr->next;
13147 }
13148
13149 ptr->h = h;
13150 ptr->irel_head = bfd_malloc (sizeof (struct elf_nds32_ifc_irel_list));
13151 ptr->irel_head->irel = irel;
13152 ptr->insn = insn;
13153 ptr->irel_head->keep = 1;
13154
13155 if (h == NULL)
13156 {
13157 /* Local symbols. */
13158 ptr->sec = sec;
13159 ptr->irel_head->sec = NULL;
13160 }
13161 else
13162 {
13163 /* Global symbol. */
13164 ptr->sec = NULL;
13165 ptr->irel_head->sec = sec;
13166 }
13167
13168 ptr->irel_head->next = NULL;
13169 ptr->times = 0;
13170 ptr->enable = 0;
13171 ptr->ex9_enable = 0;
13172 ptr->next = NULL;
13173 }
13174
13175 /* Gather all jal and j instructions. */
13176
13177 static bfd_boolean
13178 nds32_elf_ifc_calc (struct bfd_link_info *info,
13179 bfd *abfd, asection *sec)
13180 {
13181 Elf_Internal_Rela *internal_relocs;
13182 Elf_Internal_Rela *irelend;
13183 Elf_Internal_Rela *irel;
13184 Elf_Internal_Shdr *symtab_hdr;
13185 bfd_byte *contents = NULL;
13186 uint32_t insn, insn_with_reg;
13187 unsigned long r_symndx;
13188 struct elf_link_hash_entry *h;
13189 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
13190 struct elf_nds32_link_hash_table *table;
13191 bfd_boolean ifc_loop_aware;
13192
13193 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
13194 TRUE /* keep_memory */);
13195 irelend = internal_relocs + sec->reloc_count;
13196 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13197
13198 /* Check if the object enable ifc. */
13199 irel = find_relocs_at_address (internal_relocs, internal_relocs, irelend,
13200 R_NDS32_RELAX_ENTRY);
13201
13202 if (irel == NULL
13203 || irel >= irelend
13204 || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
13205 || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
13206 && !(irel->r_addend & R_NDS32_RELAX_ENTRY_IFC_FLAG)))
13207 return TRUE;
13208
13209 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
13210 return FALSE;
13211
13212 table = nds32_elf_hash_table (info);
13213 ifc_loop_aware = table->ifc_loop_aware;
13214 while (irel != NULL && irel < irelend)
13215 {
13216 /* Traverse all relocation and gather all of them to build the list. */
13217
13218 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN)
13219 {
13220 if (ifc_loop_aware == 1
13221 && (irel->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG) != 0)
13222 {
13223 /* Check the region if loop or not. If it is true and
13224 ifc-loop-aware is true, ignore the region till region end. */
13225 while (irel != NULL
13226 && irel < irelend
13227 && (ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
13228 || (irel->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG) != 0))
13229 irel++;
13230 }
13231 }
13232
13233 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA)
13234 {
13235 insn = bfd_getb32 (contents + irel->r_offset);
13236 nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
13237 r_symndx = ELF32_R_SYM (irel->r_info);
13238 if (r_symndx < symtab_hdr->sh_info)
13239 {
13240 /* Local symbol. */
13241 nds32_elf_ifc_insert_symbol (sec, NULL, irel, insn_with_reg);
13242 }
13243 else
13244 {
13245 /* External symbol. */
13246 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13247 nds32_elf_ifc_insert_symbol (sec, h, irel, insn_with_reg);
13248 }
13249 }
13250 irel++;
13251 }
13252 return TRUE;
13253 }
13254
13255 /* Determine whether j and jal should be substituted. */
13256
13257 static void
13258 nds32_elf_ifc_filter (struct bfd_link_info *info)
13259 {
13260 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13261 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13262 struct elf_nds32_ifc_irel_list *irel_keeper = NULL;
13263 struct elf_nds32_link_hash_table *table;
13264 int target_optimize;
13265 bfd_vma address;
13266
13267 table = nds32_elf_hash_table (info);
13268 target_optimize = table->target_optimize;
13269 while (ptr)
13270 {
13271 irel_ptr = ptr->irel_head;
13272 if (ptr->h == NULL)
13273 {
13274 /* Local symbol. */
13275 irel_keeper = irel_ptr;
13276 while (irel_ptr && irel_ptr->next)
13277 {
13278 /* Check there is jump target can be used. */
13279 if ((irel_ptr->next->irel->r_offset
13280 - irel_keeper->irel->r_offset) > 1022)
13281 irel_keeper = irel_ptr->next;
13282 else
13283 {
13284 ptr->enable = 1;
13285 irel_ptr->keep = 0;
13286 }
13287 irel_ptr = irel_ptr->next;
13288 }
13289 }
13290 else
13291 {
13292 /* Global symbol. */
13293 /* We have to get the absolute address and decide
13294 whether to keep it or not. */
13295 while (irel_ptr)
13296 {
13297 address = (irel_ptr->irel->r_offset
13298 + irel_ptr->sec->output_section->vma
13299 + irel_ptr->sec->output_offset);
13300 irel_ptr->addr = address;
13301 irel_ptr = irel_ptr->next;
13302 }
13303
13304 irel_ptr = ptr->irel_head;
13305 while (irel_ptr)
13306 {
13307 /* Sort by address. */
13308 struct elf_nds32_ifc_irel_list *irel_dest = irel_ptr;
13309 struct elf_nds32_ifc_irel_list *irel_temp = irel_ptr;
13310 struct elf_nds32_ifc_irel_list *irel_ptr_prev = NULL;
13311 struct elf_nds32_ifc_irel_list *irel_dest_prev = NULL;
13312
13313 /* Get the smallest one. */
13314 while (irel_temp->next)
13315 {
13316 if (irel_temp->next->addr < irel_dest->addr)
13317 {
13318 irel_dest_prev = irel_temp;
13319 irel_dest = irel_temp->next;
13320 }
13321 irel_temp = irel_temp->next;
13322 }
13323
13324 if (irel_dest != irel_ptr)
13325 {
13326 if (irel_ptr_prev)
13327 irel_ptr_prev->next = irel_dest;
13328 if (irel_dest_prev)
13329 irel_dest_prev->next = irel_ptr;
13330 irel_temp = irel_ptr->next;
13331 irel_ptr->next = irel_dest->next;
13332 irel_dest->next = irel_temp;
13333 }
13334 irel_ptr_prev = irel_ptr;
13335 irel_ptr = irel_ptr->next;
13336 }
13337
13338 irel_ptr = ptr->irel_head;
13339 irel_keeper = irel_ptr;
13340 while (irel_ptr && irel_ptr->next)
13341 {
13342 if ((irel_ptr->next->addr - irel_keeper->addr) > 1022)
13343 irel_keeper = irel_ptr->next;
13344 else
13345 {
13346 ptr->enable = 1;
13347 irel_ptr->keep = 0;
13348 }
13349 irel_ptr = irel_ptr->next;
13350 }
13351 }
13352
13353 /* Ex9 enable. Reserve it for ex9. */
13354 if ((target_optimize & NDS32_RELAX_EX9_ON)
13355 && ptr->irel_head != irel_keeper)
13356 ptr->enable = 0;
13357 ptr = ptr->next;
13358 }
13359 }
13360
13361 /* Determine whether j and jal should be substituted after ex9 done. */
13362
13363 static void
13364 nds32_elf_ifc_filter_after_ex9 (void)
13365 {
13366 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13367 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13368
13369 while (ptr)
13370 {
13371 if (ptr->enable == 0)
13372 {
13373 /* Check whether ifc is applied or not. */
13374 irel_ptr = ptr->irel_head;
13375 ptr->ex9_enable = 1;
13376 while (irel_ptr)
13377 {
13378 if (ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_TRAN)
13379 {
13380 /* Ex9 already. */
13381 ptr->ex9_enable = 0;
13382 break;
13383 }
13384 irel_ptr = irel_ptr->next;
13385 }
13386 }
13387 ptr = ptr->next;
13388 }
13389 }
13390
13391 /* Wrapper to do ifc relaxation. */
13392
13393 bfd_boolean
13394 nds32_elf_ifc_finish (struct bfd_link_info *info)
13395 {
13396 int relax_status;
13397 struct elf_nds32_link_hash_table *table;
13398
13399 table = nds32_elf_hash_table (info);
13400 relax_status = table->relax_status;
13401
13402 if (!(relax_status & NDS32_RELAX_JUMP_IFC_DONE))
13403 nds32_elf_ifc_filter (info);
13404 else
13405 nds32_elf_ifc_filter_after_ex9 ();
13406
13407 if (!nds32_elf_ifc_replace (info))
13408 return FALSE;
13409
13410 if (table)
13411 table->relax_status |= NDS32_RELAX_JUMP_IFC_DONE;
13412 return TRUE;
13413 }
13414
13415 /* Traverse the result of ifc filter and replace it with ifcall9. */
13416
13417 static bfd_boolean
13418 nds32_elf_ifc_replace (struct bfd_link_info *info)
13419 {
13420 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13421 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13422 nds32_elf_blank_t *relax_blank_list = NULL;
13423 bfd_byte *contents = NULL;
13424 Elf_Internal_Rela *internal_relocs;
13425 Elf_Internal_Rela *irel;
13426 Elf_Internal_Rela *irelend;
13427 unsigned short insn16 = INSN_IFCALL9;
13428 struct elf_nds32_link_hash_table *table;
13429 int relax_status;
13430
13431 table = nds32_elf_hash_table (info);
13432 relax_status = table->relax_status;
13433
13434 while (ptr)
13435 {
13436 /* Traverse the ifc gather list, and replace the
13437 filter entries by ifcall9. */
13438 if ((!(relax_status & NDS32_RELAX_JUMP_IFC_DONE) && ptr->enable == 1)
13439 || ((relax_status & NDS32_RELAX_JUMP_IFC_DONE)
13440 && ptr->ex9_enable == 1))
13441 {
13442 irel_ptr = ptr->irel_head;
13443 if (ptr->h == NULL)
13444 {
13445 /* Local symbol. */
13446 internal_relocs = _bfd_elf_link_read_relocs
13447 (ptr->sec->owner, ptr->sec, NULL, NULL, TRUE /* keep_memory */);
13448 irelend = internal_relocs + ptr->sec->reloc_count;
13449
13450 if (!nds32_get_section_contents (ptr->sec->owner, ptr->sec,
13451 &contents, TRUE))
13452 return FALSE;
13453
13454 while (irel_ptr)
13455 {
13456 if (irel_ptr->keep == 0 && irel_ptr->next)
13457 {
13458 /* The one can be replaced. We have to check whether
13459 there is any alignment point in the region. */
13460 irel = irel_ptr->irel;
13461 while (((irel_ptr->next->keep == 0
13462 && irel < irel_ptr->next->irel)
13463 || (irel_ptr->next->keep == 1 && irel < irelend))
13464 && !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13465 && (irel->r_addend & 0x1f) == 2))
13466 irel++;
13467 if (irel >= irelend
13468 || !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13469 && (irel->r_addend & 0x1f) == 2
13470 && ((irel->r_offset - get_nds32_elf_blank_total
13471 (&relax_blank_list, irel->r_offset, 1))
13472 & 0x02) == 0))
13473 {
13474 /* Replace by ifcall9. */
13475 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13476 if (!insert_nds32_elf_blank_recalc_total
13477 (&relax_blank_list, irel_ptr->irel->r_offset + 2, 2))
13478 return FALSE;
13479 irel_ptr->irel->r_info =
13480 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13481 R_NDS32_10IFCU_PCREL_RELA);
13482 }
13483 }
13484 irel_ptr = irel_ptr->next;
13485 }
13486
13487 /* Delete the redundant code. */
13488 if (relax_blank_list)
13489 {
13490 nds32_elf_relax_delete_blanks (ptr->sec->owner, ptr->sec,
13491 relax_blank_list);
13492 relax_blank_list = NULL;
13493 }
13494 }
13495 else
13496 {
13497 /* Global symbol. */
13498 while (irel_ptr)
13499 {
13500 if (irel_ptr->keep == 0 && irel_ptr->next)
13501 {
13502 /* The one can be replaced, and we have to check
13503 whether there is any alignment point in the region. */
13504 internal_relocs = _bfd_elf_link_read_relocs
13505 (irel_ptr->sec->owner, irel_ptr->sec, NULL, NULL,
13506 TRUE /* keep_memory */);
13507 irelend = internal_relocs + irel_ptr->sec->reloc_count;
13508 if (!nds32_get_section_contents (irel_ptr->sec->owner,
13509 irel_ptr->sec, &contents,
13510 TRUE))
13511 return FALSE;
13512
13513 irel = irel_ptr->irel;
13514 while (((irel_ptr->sec == irel_ptr->next->sec
13515 && irel_ptr->next->keep == 0
13516 && irel < irel_ptr->next->irel)
13517 || ((irel_ptr->sec != irel_ptr->next->sec
13518 || irel_ptr->next->keep == 1)
13519 && irel < irelend))
13520 && !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13521 && (irel->r_addend & 0x1f) == 2))
13522 irel++;
13523 if (irel >= irelend
13524 || !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13525 && (irel->r_addend & 0x1f) == 2
13526 && ((irel->r_offset
13527 - get_nds32_elf_blank_total (&relax_blank_list,
13528 irel->r_offset, 1)) & 0x02) == 0))
13529 {
13530 /* Replace by ifcall9. */
13531 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13532 if (!insert_nds32_elf_blank_recalc_total
13533 (&relax_blank_list, irel_ptr->irel->r_offset + 2, 2))
13534 return FALSE;
13535
13536 /* Delete the redundant code, and clear the relocation. */
13537 nds32_elf_relax_delete_blanks (irel_ptr->sec->owner,
13538 irel_ptr->sec,
13539 relax_blank_list);
13540 irel_ptr->irel->r_info =
13541 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13542 R_NDS32_10IFCU_PCREL_RELA);
13543 relax_blank_list = NULL;
13544 }
13545 }
13546
13547 irel_ptr = irel_ptr->next;
13548 }
13549 }
13550 }
13551 ptr = ptr->next;
13552 }
13553
13554 return TRUE;
13555 }
13556
13557 /* Relocate ifcall. */
13558
13559 static bfd_boolean
13560 nds32_elf_ifc_reloc (void)
13561 {
13562 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13563 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13564 struct elf_nds32_ifc_irel_list *irel_keeper = NULL;
13565 bfd_vma relocation, address;
13566 unsigned short insn16;
13567 bfd_byte *contents = NULL;
13568 static bfd_boolean done = FALSE;
13569
13570 if (done)
13571 return TRUE;
13572
13573 done = TRUE;
13574
13575 while (ptr)
13576 {
13577 /* Check the entry is enable ifcall. */
13578 if (ptr->enable == 1 || ptr->ex9_enable == 1)
13579 {
13580 /* Get the reserve jump. */
13581 irel_ptr = ptr->irel_head;
13582 while (irel_ptr)
13583 {
13584 if (irel_ptr->keep == 1)
13585 {
13586 irel_keeper = irel_ptr;
13587 break;
13588 }
13589 irel_ptr = irel_ptr->next;
13590 }
13591
13592 irel_ptr = ptr->irel_head;
13593 if (ptr->h == NULL)
13594 {
13595 /* Local symbol. */
13596 if (!nds32_get_section_contents (ptr->sec->owner, ptr->sec,
13597 &contents, TRUE))
13598 return FALSE;
13599
13600 while (irel_ptr)
13601 {
13602 if (irel_ptr->keep == 0
13603 && ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13604 {
13605 relocation = irel_keeper->irel->r_offset;
13606 relocation = relocation - irel_ptr->irel->r_offset;
13607 while (irel_keeper && relocation > 1022)
13608 {
13609 irel_keeper = irel_keeper->next;
13610 if (irel_keeper && irel_keeper->keep == 1)
13611 {
13612 relocation = irel_keeper->irel->r_offset;
13613 relocation = relocation - irel_ptr->irel->r_offset;
13614 }
13615 }
13616 if (relocation > 1022)
13617 {
13618 /* Double check. */
13619 irel_keeper = ptr->irel_head;
13620 while (irel_keeper)
13621 {
13622 if (irel_keeper->keep == 1)
13623 {
13624 relocation = irel_keeper->irel->r_offset;
13625 relocation = relocation - irel_ptr->irel->r_offset;
13626 }
13627 if (relocation <= 1022)
13628 break;
13629 irel_keeper = irel_keeper->next;
13630 }
13631 if (!irel_keeper)
13632 return FALSE;
13633 }
13634 irel_ptr->irel->r_info =
13635 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13636 R_NDS32_NONE);
13637 insn16 = INSN_IFCALL9 | (relocation >> 1);
13638 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13639 }
13640 irel_ptr = irel_ptr->next;
13641 }
13642 }
13643 else
13644 {
13645 /* Global symbol. */
13646 while (irel_ptr)
13647 {
13648 if (irel_ptr->keep == 0
13649 && ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13650 {
13651 /* Get the distance between ifcall and jump. */
13652 relocation = (irel_keeper->irel->r_offset
13653 + irel_keeper->sec->output_section->vma
13654 + irel_keeper->sec->output_offset);
13655 address = (irel_ptr->irel->r_offset
13656 + irel_ptr->sec->output_section->vma
13657 + irel_ptr->sec->output_offset);
13658 relocation = relocation - address;
13659
13660 /* The distance is over ragne, find callee again. */
13661 while (irel_keeper && relocation > 1022)
13662 {
13663 irel_keeper = irel_keeper->next;
13664 if (irel_keeper && irel_keeper->keep ==1)
13665 {
13666 relocation = (irel_keeper->irel->r_offset
13667 + irel_keeper->sec->output_section->vma
13668 + irel_keeper->sec->output_offset);
13669 relocation = relocation - address;
13670 }
13671 }
13672
13673 if (relocation > 1022)
13674 {
13675 /* Double check. */
13676 irel_keeper = ptr->irel_head;
13677 while (irel_keeper)
13678 {
13679 if (irel_keeper->keep == 1)
13680 {
13681
13682 relocation = (irel_keeper->irel->r_offset
13683 + irel_keeper->sec->output_section->vma
13684 + irel_keeper->sec->output_offset);
13685 relocation = relocation - address;
13686 }
13687 if (relocation <= 1022)
13688 break;
13689 irel_keeper = irel_keeper->next;
13690 }
13691 if (!irel_keeper)
13692 return FALSE;
13693 }
13694 if (!nds32_get_section_contents
13695 (irel_ptr->sec->owner, irel_ptr->sec, &contents, TRUE))
13696 return FALSE;
13697 insn16 = INSN_IFCALL9 | (relocation >> 1);
13698 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13699 irel_ptr->irel->r_info =
13700 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13701 R_NDS32_NONE);
13702 }
13703 irel_ptr =irel_ptr->next;
13704 }
13705 }
13706 }
13707 ptr = ptr->next;
13708 }
13709
13710 return TRUE;
13711 }
13712
13713 /* End of IFC relaxation. */
13714 \f
13715 /* EX9 Instruction Table Relaxation. */
13716
13717 /* Global hash list. */
13718 struct elf_link_hash_entry_list
13719 {
13720 struct elf_link_hash_entry *h;
13721 struct elf_link_hash_entry_list *next;
13722 };
13723
13724 /* Save different destination but same insn. */
13725 struct elf_link_hash_entry_mul_list
13726 {
13727 /* Global symbol times. */
13728 int times;
13729 /* Save relocation for each global symbol but useful?? */
13730 Elf_Internal_Rela *irel;
13731 /* For sethi, two sethi may have the same high-part but different low-parts. */
13732 Elf_Internal_Rela rel_backup;
13733 struct elf_link_hash_entry_list *h_list;
13734 struct elf_link_hash_entry_mul_list *next;
13735 };
13736
13737 /* Instruction hash table. */
13738 struct elf_nds32_code_hash_entry
13739 {
13740 struct bfd_hash_entry root;
13741 int times;
13742 /* For insn that can use relocation or constant ex: sethi. */
13743 int const_insn;
13744 asection *sec;
13745 struct elf_link_hash_entry_mul_list *m_list;
13746 /* Using r_addend. */
13747 Elf_Internal_Rela *irel;
13748 /* Using r_info. */
13749 Elf_Internal_Rela rel_backup;
13750 };
13751
13752 /* Instruction count list. */
13753 struct elf_nds32_insn_times_entry
13754 {
13755 const char *string;
13756 int times;
13757 int order;
13758 asection *sec;
13759 struct elf_link_hash_entry_mul_list *m_list;
13760 Elf_Internal_Rela *irel;
13761 Elf_Internal_Rela rel_backup;
13762 struct elf_nds32_insn_times_entry *next;
13763 };
13764
13765 /* J and JAL symbol list. */
13766 struct elf_nds32_symbol_entry
13767 {
13768 char *string;
13769 unsigned long insn;
13770 struct elf_nds32_symbol_entry *next;
13771 };
13772
13773 /* Relocation list. */
13774 struct elf_nds32_irel_entry
13775 {
13776 Elf_Internal_Rela *irel;
13777 struct elf_nds32_irel_entry *next;
13778 };
13779
13780 /* ex9.it insn need to be fixed. */
13781 struct elf_nds32_ex9_refix
13782 {
13783 Elf_Internal_Rela *irel;
13784 asection *sec;
13785 struct elf_link_hash_entry *h;
13786 int order;
13787 struct elf_nds32_ex9_refix *next;
13788 };
13789
13790 static struct bfd_hash_table ex9_code_table;
13791 static struct elf_nds32_insn_times_entry *ex9_insn_head = NULL;
13792 static struct elf_nds32_ex9_refix *ex9_refix_head = NULL;
13793
13794 /* EX9 hash function. */
13795
13796 static struct bfd_hash_entry *
13797 nds32_elf_code_hash_newfunc (struct bfd_hash_entry *entry,
13798 struct bfd_hash_table *table,
13799 const char *string)
13800 {
13801 struct elf_nds32_code_hash_entry *ret;
13802
13803 /* Allocate the structure if it has not already been allocated by a
13804 subclass. */
13805 if (entry == NULL)
13806 {
13807 entry = (struct bfd_hash_entry *)
13808 bfd_hash_allocate (table, sizeof (*ret));
13809 if (entry == NULL)
13810 return entry;
13811 }
13812
13813 /* Call the allocation method of the superclass. */
13814 entry = bfd_hash_newfunc (entry, table, string);
13815 if (entry == NULL)
13816 return entry;
13817
13818 ret = (struct elf_nds32_code_hash_entry*) entry;
13819 ret->times = 0;
13820 ret->const_insn = 0;
13821 ret->m_list = NULL;
13822 ret->sec = NULL;
13823 ret->irel = NULL;
13824 return &ret->root;
13825 }
13826
13827 /* Insert ex9 entry
13828 this insert must be stable sorted by times. */
13829
13830 static void
13831 nds32_elf_ex9_insert_entry (struct elf_nds32_insn_times_entry *ptr)
13832 {
13833 struct elf_nds32_insn_times_entry *temp;
13834 struct elf_nds32_insn_times_entry *temp2;
13835
13836 if (ex9_insn_head == NULL)
13837 {
13838 ex9_insn_head = ptr;
13839 ptr->next = NULL;
13840 }
13841 else
13842 {
13843 temp = ex9_insn_head;
13844 temp2 = ex9_insn_head;
13845 while (temp->next &&
13846 (temp->next->times >= ptr->times
13847 || temp->times == -1))
13848 {
13849 if (temp->times == -1)
13850 temp2 = temp;
13851 temp = temp->next;
13852 }
13853 if (ptr->times > temp->times && temp->times != -1)
13854 {
13855 ptr->next = temp;
13856 if (temp2->times == -1)
13857 temp2->next = ptr;
13858 else
13859 ex9_insn_head = ptr;
13860 }
13861 else if (temp->next == NULL)
13862 {
13863 temp->next = ptr;
13864 ptr->next = NULL;
13865 }
13866 else
13867 {
13868 ptr->next = temp->next;
13869 temp->next = ptr;
13870 }
13871 }
13872 }
13873
13874 /* Examine each insn times in hash table.
13875 Handle multi-link hash entry.
13876
13877 TODO: This function doesn't assign so much info since it is fake. */
13878
13879 static int
13880 nds32_elf_examine_insn_times (struct elf_nds32_code_hash_entry *h)
13881 {
13882 struct elf_nds32_insn_times_entry *ptr;
13883 int times;
13884
13885 if (h->m_list == NULL)
13886 {
13887 /* Local symbol insn or insn without relocation. */
13888 if (h->times < 3)
13889 return TRUE;
13890
13891 ptr = (struct elf_nds32_insn_times_entry *)
13892 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13893 ptr->times = h->times;
13894 ptr->string = h->root.string;
13895 ptr->m_list = NULL;
13896 ptr->sec = h->sec;
13897 ptr->irel = h->irel;
13898 ptr->rel_backup = h->rel_backup;
13899 nds32_elf_ex9_insert_entry (ptr);
13900 }
13901 else
13902 {
13903 /* Global symbol insn. */
13904 /* Only sethi insn has multiple m_list. */
13905 struct elf_link_hash_entry_mul_list *m_list = h->m_list;
13906
13907 times = 0;
13908 while (m_list)
13909 {
13910 times += m_list->times;
13911 m_list = m_list->next;
13912 }
13913 if (times >= 3)
13914 {
13915 m_list = h->m_list;
13916 ptr = (struct elf_nds32_insn_times_entry *)
13917 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13918 ptr->times = times; /* Use the total times. */
13919 ptr->string = h->root.string;
13920 ptr->m_list = m_list;
13921 ptr->sec = h->sec;
13922 ptr->irel = m_list->irel;
13923 ptr->rel_backup = m_list->rel_backup;
13924 nds32_elf_ex9_insert_entry (ptr);
13925 }
13926 if (h->const_insn == 1)
13927 {
13928 /* sethi with constant value. */
13929 if (h->times < 3)
13930 return TRUE;
13931
13932 ptr = (struct elf_nds32_insn_times_entry *)
13933 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13934 ptr->times = h->times;
13935 ptr->string = h->root.string;
13936 ptr->m_list = NULL;
13937 ptr->sec = NULL;
13938 ptr->irel = NULL;
13939 ptr->rel_backup = h->rel_backup;
13940 nds32_elf_ex9_insert_entry (ptr);
13941 }
13942 }
13943 return TRUE;
13944 }
13945
13946 /* Count each insn times in hash table.
13947 Handle multi-link hash entry. */
13948
13949 static int
13950 nds32_elf_count_insn_times (struct elf_nds32_code_hash_entry *h)
13951 {
13952 int reservation, times;
13953 unsigned long relocation, min_relocation;
13954 struct elf_nds32_insn_times_entry *ptr;
13955
13956 if (h->m_list == NULL)
13957 {
13958 /* Local symbol insn or insn without relocation. */
13959 if (h->times < 3)
13960 return TRUE;
13961 ptr = (struct elf_nds32_insn_times_entry *)
13962 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13963 ptr->times = h->times;
13964 ptr->string = h->root.string;
13965 ptr->m_list = NULL;
13966 ptr->sec = h->sec;
13967 ptr->irel = h->irel;
13968 ptr->rel_backup = h->rel_backup;
13969 nds32_elf_ex9_insert_entry (ptr);
13970 }
13971 else
13972 {
13973 /* Global symbol insn. */
13974 /* Only sethi insn has multiple m_list. */
13975 struct elf_link_hash_entry_mul_list *m_list = h->m_list;
13976
13977 if (ELF32_R_TYPE (m_list->rel_backup.r_info) == R_NDS32_HI20_RELA
13978 && m_list->next != NULL)
13979 {
13980 /* Sethi insn has different symbol or addend but has same hi20. */
13981 times = 0;
13982 reservation = 1;
13983 relocation = 0;
13984 min_relocation = 0xffffffff;
13985 while (m_list)
13986 {
13987 /* Get the minimum sethi address
13988 and calculate how many entry the sethi-list have to use. */
13989 if ((m_list->h_list->h->root.type == bfd_link_hash_defined
13990 || m_list->h_list->h->root.type == bfd_link_hash_defweak)
13991 && (m_list->h_list->h->root.u.def.section != NULL
13992 && m_list->h_list->h->root.u.def.section->output_section != NULL))
13993 {
13994 relocation = (m_list->h_list->h->root.u.def.value +
13995 m_list->h_list->h->root.u.def.section->output_section->vma +
13996 m_list->h_list->h->root.u.def.section->output_offset);
13997 relocation += m_list->irel->r_addend;
13998 }
13999 else
14000 relocation = 0;
14001 if (relocation < min_relocation)
14002 min_relocation = relocation;
14003 times += m_list->times;
14004 m_list = m_list->next;
14005 }
14006 if (min_relocation < ex9_relax_size)
14007 reservation = (min_relocation >> 12) + 1;
14008 else
14009 reservation = (min_relocation >> 12)
14010 - ((min_relocation - ex9_relax_size) >> 12) + 1;
14011 if (reservation < (times / 3))
14012 {
14013 /* Efficient enough to use ex9. */
14014 int i;
14015
14016 for (i = reservation ; i > 0; i--)
14017 {
14018 /* Allocate number of reservation ex9 entry. */
14019 ptr = (struct elf_nds32_insn_times_entry *)
14020 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14021 ptr->times = h->m_list->times / reservation;
14022 ptr->string = h->root.string;
14023 ptr->m_list = h->m_list;
14024 ptr->sec = h->sec;
14025 ptr->irel = h->m_list->irel;
14026 ptr->rel_backup = h->m_list->rel_backup;
14027 nds32_elf_ex9_insert_entry (ptr);
14028 }
14029 }
14030 }
14031 else
14032 {
14033 /* Normal global symbol that means no different address symbol
14034 using same ex9 entry. */
14035 if (m_list->times >= 3)
14036 {
14037 ptr = (struct elf_nds32_insn_times_entry *)
14038 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14039 ptr->times = m_list->times;
14040 ptr->string = h->root.string;
14041 ptr->m_list = h->m_list;
14042 ptr->sec = h->sec;
14043 ptr->irel = h->m_list->irel;
14044 ptr->rel_backup = h->m_list->rel_backup;
14045 nds32_elf_ex9_insert_entry (ptr);
14046 }
14047 }
14048
14049 if (h->const_insn == 1)
14050 {
14051 /* sethi with constant value. */
14052 if (h->times < 3)
14053 return TRUE;
14054
14055 ptr = (struct elf_nds32_insn_times_entry *)
14056 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14057 ptr->times = h->times;
14058 ptr->string = h->root.string;
14059 ptr->m_list = NULL;
14060 ptr->sec = NULL;
14061 ptr->irel = NULL;
14062 ptr->rel_backup = h->rel_backup;
14063 nds32_elf_ex9_insert_entry (ptr);
14064 }
14065 }
14066
14067 return TRUE;
14068 }
14069
14070 /* Hash table traverse function. */
14071
14072 static void
14073 nds32_elf_code_hash_traverse (int (*func) (struct elf_nds32_code_hash_entry*))
14074 {
14075 unsigned int i;
14076
14077 ex9_code_table.frozen = 1;
14078 for (i = 0; i < ex9_code_table.size; i++)
14079 {
14080 struct bfd_hash_entry *p;
14081
14082 for (p = ex9_code_table.table[i]; p != NULL; p = p->next)
14083 if (!func ((struct elf_nds32_code_hash_entry *) p))
14084 goto out;
14085 }
14086 out:
14087 ex9_code_table.frozen = 0;
14088 }
14089
14090
14091 /* Give order number to insn list. */
14092
14093 static void
14094 nds32_elf_order_insn_times (struct bfd_link_info *info)
14095 {
14096 struct elf_nds32_insn_times_entry *ex9_insn;
14097 struct elf_nds32_insn_times_entry *temp = NULL;
14098 struct elf_nds32_link_hash_table *table;
14099 int ex9_limit;
14100 int number = 0;
14101
14102 if (ex9_insn_head == NULL)
14103 return;
14104
14105 /* The max number of entries is 512. */
14106 ex9_insn = ex9_insn_head;
14107 table = nds32_elf_hash_table (info);
14108 ex9_limit = table->ex9_limit;
14109
14110 ex9_insn = ex9_insn_head;
14111
14112 while (ex9_insn != NULL && number < ex9_limit)
14113 {
14114 ex9_insn->order = number;
14115 number++;
14116 temp = ex9_insn;
14117 ex9_insn = ex9_insn->next;
14118 }
14119
14120 if (ex9_insn && temp)
14121 temp->next = NULL;
14122
14123 while (ex9_insn != NULL)
14124 {
14125 /* Free useless entry. */
14126 temp = ex9_insn;
14127 ex9_insn = ex9_insn->next;
14128 free (temp);
14129 }
14130 }
14131
14132 /* Build .ex9.itable section. */
14133
14134 static void
14135 nds32_elf_ex9_build_itable (struct bfd_link_info *link_info)
14136 {
14137 asection *table_sec;
14138 struct elf_nds32_insn_times_entry *ptr;
14139 bfd *it_abfd;
14140 int number = 0;
14141 bfd_byte *contents = NULL;
14142
14143 for (it_abfd = link_info->input_bfds; it_abfd != NULL;
14144 it_abfd = it_abfd->link.next)
14145 {
14146 /* Find the section .ex9.itable, and put all entries into it. */
14147 table_sec = bfd_get_section_by_name (it_abfd, ".ex9.itable");
14148 if (table_sec != NULL)
14149 {
14150 if (!nds32_get_section_contents (it_abfd, table_sec, &contents, TRUE))
14151 return;
14152
14153 for (ptr = ex9_insn_head; ptr !=NULL ; ptr = ptr->next)
14154 number++;
14155
14156 table_sec->size = number * 4;
14157
14158 if (number == 0)
14159 return;
14160
14161 elf_elfheader (link_info->output_bfd)->e_flags |= E_NDS32_HAS_EX9_INST;
14162 number = 0;
14163 for (ptr = ex9_insn_head; ptr !=NULL ; ptr = ptr->next)
14164 {
14165 long val;
14166
14167 val = strtol (ptr->string, NULL, 16);
14168 bfd_putb32 ((bfd_vma) val, (char *) contents + (number * 4));
14169 number++;
14170 }
14171 break;
14172 }
14173 }
14174 }
14175
14176 /* Get insn with regs according to relocation type. */
14177
14178 static void
14179 nds32_elf_get_insn_with_reg (Elf_Internal_Rela *irel,
14180 uint32_t insn, uint32_t *insn_with_reg)
14181 {
14182 reloc_howto_type *howto = NULL;
14183
14184 if (irel == NULL
14185 || (ELF32_R_TYPE (irel->r_info) >= (int) ARRAY_SIZE (nds32_elf_howto_table)
14186 && (ELF32_R_TYPE (irel->r_info) - R_NDS32_RELAX_ENTRY)
14187 >= (int) ARRAY_SIZE (nds32_elf_relax_howto_table)))
14188 {
14189 *insn_with_reg = insn;
14190 return;
14191 }
14192
14193 howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
14194 *insn_with_reg = insn & (0xffffffff ^ howto->dst_mask);
14195 }
14196
14197 /* Mask number of address bits according to relocation. */
14198
14199 static unsigned long
14200 nds32_elf_irel_mask (Elf_Internal_Rela *irel)
14201 {
14202 reloc_howto_type *howto = NULL;
14203
14204 if (irel == NULL
14205 || (ELF32_R_TYPE (irel->r_info) >= (int) ARRAY_SIZE (nds32_elf_howto_table)
14206 && (ELF32_R_TYPE (irel->r_info) - R_NDS32_RELAX_ENTRY)
14207 >= (int) ARRAY_SIZE (nds32_elf_relax_howto_table)))
14208 return 0;
14209
14210 howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
14211 return howto->dst_mask;
14212 }
14213
14214 static void
14215 nds32_elf_insert_irel_entry (struct elf_nds32_irel_entry **irel_list,
14216 struct elf_nds32_irel_entry *irel_ptr)
14217 {
14218 if (*irel_list == NULL)
14219 {
14220 *irel_list = irel_ptr;
14221 irel_ptr->next = NULL;
14222 }
14223 else
14224 {
14225 irel_ptr->next = *irel_list;
14226 *irel_list = irel_ptr;
14227 }
14228 }
14229
14230 static void
14231 nds32_elf_ex9_insert_fix (asection * sec, Elf_Internal_Rela * irel,
14232 struct elf_link_hash_entry *h, int order)
14233 {
14234 struct elf_nds32_ex9_refix *ptr;
14235
14236 ptr = bfd_malloc (sizeof (struct elf_nds32_ex9_refix));
14237 ptr->sec = sec;
14238 ptr->irel = irel;
14239 ptr->h = h;
14240 ptr->order = order;
14241 ptr->next = NULL;
14242
14243 if (ex9_refix_head == NULL)
14244 ex9_refix_head = ptr;
14245 else
14246 {
14247 struct elf_nds32_ex9_refix *temp = ex9_refix_head;
14248
14249 while (temp->next != NULL)
14250 temp = temp->next;
14251 temp->next = ptr;
14252 }
14253 }
14254
14255 enum
14256 {
14257 DATA_EXIST = 1,
14258 CLEAN_PRE = 1 << 1,
14259 PUSH_PRE = 1 << 2
14260 };
14261
14262 /* Check relocation type if supporting for ex9. */
14263
14264 static int
14265 nds32_elf_ex9_relocation_check (struct bfd_link_info *info,
14266 Elf_Internal_Rela **irel,
14267 Elf_Internal_Rela *irelend,
14268 nds32_elf_blank_t *relax_blank_list,
14269 asection *sec,bfd_vma *off,
14270 bfd_byte *contents)
14271 {
14272 /* Suppress ex9 if `.no_relax ex9' or inner loop. */
14273 bfd_boolean nested_ex9, nested_loop;
14274 bfd_boolean ex9_loop_aware;
14275 /* We use the highest 1 byte of result to record
14276 how many bytes location counter has to move. */
14277 int result = 0;
14278 Elf_Internal_Rela *irel_save = NULL;
14279 struct elf_nds32_link_hash_table *table;
14280
14281 table = nds32_elf_hash_table (info);
14282 ex9_loop_aware = table->ex9_loop_aware;
14283
14284 while ((*irel) != NULL && (*irel) < irelend && *off == (*irel)->r_offset)
14285 {
14286 switch (ELF32_R_TYPE ((*irel)->r_info))
14287 {
14288 case R_NDS32_RELAX_REGION_BEGIN:
14289 /* Ignore code block. */
14290 nested_ex9 = FALSE;
14291 nested_loop = FALSE;
14292 if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG)
14293 || (ex9_loop_aware
14294 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG)))
14295 {
14296 /* Check the region if loop or not. If it is true and
14297 ex9-loop-aware is true, ignore the region till region end. */
14298 /* To save the status for in .no_relax ex9 region and
14299 loop region to conform the block can do ex9 relaxation. */
14300 nested_ex9 = ((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG);
14301 nested_loop = (ex9_loop_aware
14302 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG));
14303 while ((*irel) && (*irel) < irelend && (nested_ex9 || nested_loop))
14304 {
14305 (*irel)++;
14306 if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_RELAX_REGION_BEGIN)
14307 {
14308 /* There may be nested region. */
14309 if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG) != 0)
14310 nested_ex9 = TRUE;
14311 else if (ex9_loop_aware
14312 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG))
14313 nested_loop = TRUE;
14314 }
14315 else if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_RELAX_REGION_END)
14316 {
14317 /* The end of region. */
14318 if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG) != 0)
14319 nested_ex9 = FALSE;
14320 else if (ex9_loop_aware
14321 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG))
14322 nested_loop = FALSE;
14323 }
14324 else if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_LABEL
14325 && ((*irel)->r_addend & 0x1f) == 2)
14326 {
14327 /* Alignment exist in the region. */
14328 result |= CLEAN_PRE;
14329 if (((*irel)->r_offset -
14330 get_nds32_elf_blank_total (&relax_blank_list,
14331 (*irel)->r_offset, 0)) & 0x02)
14332 result |= PUSH_PRE;
14333 }
14334 }
14335 if ((*irel) >= irelend)
14336 *off = sec->size;
14337 else
14338 *off = (*irel)->r_offset;
14339
14340 /* The final instruction in the region, regard this one as data to ignore it. */
14341 result |= DATA_EXIST;
14342 return result;
14343 }
14344 break;
14345
14346 case R_NDS32_LABEL:
14347 if (((*irel)->r_addend & 0x1f) == 2)
14348 {
14349 /* Check this point is align and decide to do ex9 or not. */
14350 result |= CLEAN_PRE;
14351 if (((*irel)->r_offset -
14352 get_nds32_elf_blank_total (&relax_blank_list,
14353 (*irel)->r_offset, 0)) & 0x02)
14354 result |= PUSH_PRE;
14355 }
14356 break;
14357 case R_NDS32_32_RELA:
14358 /* Data. */
14359 result |= (4 << 24);
14360 result |= DATA_EXIST;
14361 break;
14362 case R_NDS32_16_RELA:
14363 /* Data. */
14364 result |= (2 << 24);
14365 result |= DATA_EXIST;
14366 break;
14367 case R_NDS32_DATA:
14368 /* Data. */
14369 /* The least code alignment is 2. If the data is only one byte,
14370 we have to shift one more byte. */
14371 if ((*irel)->r_addend == 1)
14372 result |= ((*irel)->r_addend << 25) ;
14373 else
14374 result |= ((*irel)->r_addend << 24) ;
14375
14376 result |= DATA_EXIST;
14377 break;
14378
14379 case R_NDS32_25_PCREL_RELA:
14380 case R_NDS32_SDA16S3_RELA:
14381 case R_NDS32_SDA15S3_RELA:
14382 case R_NDS32_SDA15S3:
14383 case R_NDS32_SDA17S2_RELA:
14384 case R_NDS32_SDA15S2_RELA:
14385 case R_NDS32_SDA12S2_SP_RELA:
14386 case R_NDS32_SDA12S2_DP_RELA:
14387 case R_NDS32_SDA15S2:
14388 case R_NDS32_SDA18S1_RELA:
14389 case R_NDS32_SDA15S1_RELA:
14390 case R_NDS32_SDA15S1:
14391 case R_NDS32_SDA19S0_RELA:
14392 case R_NDS32_SDA15S0_RELA:
14393 case R_NDS32_SDA15S0:
14394 case R_NDS32_HI20_RELA:
14395 case R_NDS32_LO12S0_ORI_RELA:
14396 case R_NDS32_LO12S0_RELA:
14397 case R_NDS32_LO12S1_RELA:
14398 case R_NDS32_LO12S2_RELA:
14399 /* These relocation is supported ex9 relaxation currently. */
14400 /* We have to save the relocation for using later, since we have
14401 to check there is any alignment in the same address. */
14402 irel_save = *irel;
14403 break;
14404 default:
14405 /* Not support relocations. */
14406 if (ELF32_R_TYPE ((*irel)->r_info) < ARRAY_SIZE (nds32_elf_howto_table)
14407 && ELF32_R_TYPE ((*irel)->r_info) != R_NDS32_NONE
14408 && ELF32_R_TYPE ((*irel)->r_info) != R_NDS32_INSN16)
14409 {
14410 /* Note: To optimize aggressively, it maybe can ignore R_NDS32_INSN16 here.
14411 But we have to consider if there is any side-effect. */
14412 if (!(result & DATA_EXIST))
14413 {
14414 /* We have to confirm there is no data relocation in the
14415 same address. In general case, this won't happen. */
14416 /* We have to do ex9 conservative, for those relocation not
14417 considerd we ignore instruction. */
14418 result |= DATA_EXIST;
14419 if (*(contents + *off) & 0x80)
14420 result |= (2 << 24);
14421 else
14422 result |= (4 << 24);
14423 break;
14424 }
14425 }
14426 }
14427 if ((*irel) < irelend
14428 && ((*irel) + 1) < irelend
14429 && (*irel)->r_offset == ((*irel) + 1)->r_offset)
14430 /* There are relocations pointing to the same address, we have to
14431 check all of them. */
14432 (*irel)++;
14433 else
14434 {
14435 if (irel_save)
14436 *irel = irel_save;
14437 return result;
14438 }
14439 }
14440 return result;
14441 }
14442
14443 /* Replace with ex9 instruction. */
14444
14445 static bfd_boolean
14446 nds32_elf_ex9_push_insn (uint16_t insn16, bfd_byte *contents, bfd_vma pre_off,
14447 nds32_elf_blank_t **relax_blank_list,
14448 struct elf_nds32_irel_entry *pre_irel_ptr,
14449 struct elf_nds32_irel_entry **irel_list)
14450 {
14451 if (insn16 != 0)
14452 {
14453 /* Implement the ex9 relaxation. */
14454 bfd_putb16 (insn16, contents + pre_off);
14455 if (!insert_nds32_elf_blank_recalc_total (relax_blank_list,
14456 pre_off + 2, 2))
14457 return FALSE;
14458 if (pre_irel_ptr != NULL)
14459 nds32_elf_insert_irel_entry (irel_list, pre_irel_ptr);
14460 }
14461 return TRUE;
14462 }
14463
14464 /* Replace input file instruction which is in ex9 itable. */
14465
14466 static bfd_boolean
14467 nds32_elf_ex9_replace_instruction (struct bfd_link_info *info, bfd *abfd, asection *sec)
14468 {
14469 struct elf_nds32_insn_times_entry *ex9_insn = ex9_insn_head;
14470 bfd_byte *contents = NULL;
14471 bfd_vma off;
14472 uint16_t insn16, insn_ex9;
14473 /* `pre_*' are used to track previous instruction that can use ex9.it. */
14474 bfd_vma pre_off = -1;
14475 uint16_t pre_insn16 = 0;
14476 struct elf_nds32_irel_entry *pre_irel_ptr = NULL;
14477 Elf_Internal_Rela *internal_relocs;
14478 Elf_Internal_Rela *irel;
14479 Elf_Internal_Rela *irelend;
14480 Elf_Internal_Shdr *symtab_hdr;
14481 Elf_Internal_Sym *isym = NULL;
14482 nds32_elf_blank_t *relax_blank_list = NULL;
14483 uint32_t insn = 0;
14484 uint32_t insn_with_reg = 0;
14485 uint32_t it_insn;
14486 uint32_t it_insn_with_reg;
14487 unsigned long r_symndx;
14488 asection *isec;
14489 struct elf_nds32_irel_entry *irel_list = NULL;
14490 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
14491 int data_flag, do_replace, save_irel;
14492 struct elf_link_hash_entry_list *h_list;
14493
14494
14495 /* Load section instructions, relocations, and symbol table. */
14496 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
14497 || !nds32_get_local_syms (abfd, sec, &isym))
14498 return FALSE;
14499 internal_relocs =
14500 _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, TRUE /* keep_memory */);
14501 irelend = internal_relocs + sec->reloc_count;
14502 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
14503
14504 off = 0;
14505
14506 /* Check if the object enable ex9. */
14507 irel = find_relocs_at_address (internal_relocs, internal_relocs,
14508 irelend, R_NDS32_RELAX_ENTRY);
14509
14510 /* Check this section trigger ex9 relaxation. */
14511 if (irel == NULL
14512 || irel >= irelend
14513 || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
14514 || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
14515 && !(irel->r_addend & R_NDS32_RELAX_ENTRY_EX9_FLAG)))
14516 return TRUE;
14517
14518 irel = internal_relocs;
14519
14520 /* Check alignment and fetch proper relocation. */
14521 while (off < sec->size)
14522 {
14523 struct elf_link_hash_entry *h = NULL;
14524 struct elf_nds32_irel_entry *irel_ptr = NULL;
14525
14526 /* Syn the instruction and the relocation. */
14527 while (irel != NULL && irel < irelend && irel->r_offset < off)
14528 irel++;
14529
14530 data_flag = nds32_elf_ex9_relocation_check (info, &irel, irelend,
14531 relax_blank_list, sec,
14532 &off, contents);
14533 if (data_flag & PUSH_PRE)
14534 if (!nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14535 &relax_blank_list, pre_irel_ptr,
14536 &irel_list))
14537 return FALSE;
14538
14539 if (data_flag & CLEAN_PRE)
14540 {
14541 pre_off = 0;
14542 pre_insn16 = 0;
14543 pre_irel_ptr = NULL;
14544 }
14545 if (data_flag & DATA_EXIST)
14546 {
14547 /* We save the move offset in the highest byte. */
14548 off += (data_flag >> 24);
14549 continue;
14550 }
14551
14552 if (*(contents + off) & 0x80)
14553 {
14554 /* 2-byte instruction. */
14555 off += 2;
14556 continue;
14557 }
14558
14559 /* Load the instruction and its opcode with register for comparing. */
14560 ex9_insn = ex9_insn_head;
14561 insn = bfd_getb32 (contents + off);
14562 insn_with_reg = 0;
14563 while (ex9_insn)
14564 {
14565 it_insn = strtol (ex9_insn->string, NULL, 16);
14566 it_insn_with_reg = 0;
14567 do_replace = 0;
14568 save_irel = 0;
14569
14570 if (irel != NULL && irel < irelend && irel->r_offset == off)
14571 {
14572 /* Insn with relocation. */
14573 nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
14574
14575 if (ex9_insn->irel != NULL)
14576 nds32_elf_get_insn_with_reg (ex9_insn->irel, it_insn,
14577 &it_insn_with_reg);
14578
14579 if (ex9_insn->irel != NULL
14580 && (ELF32_R_TYPE (irel->r_info) ==
14581 ELF32_R_TYPE (ex9_insn->irel->r_info))
14582 && (insn_with_reg == it_insn_with_reg))
14583 {
14584 /* Insn relocation and format is the same as table entry. */
14585
14586 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA
14587 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_ORI_RELA
14588 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_RELA
14589 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S1_RELA
14590 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_RELA
14591 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
14592 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
14593 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
14594 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
14595 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
14596 && ELF32_R_TYPE (irel->r_info) <=
14597 R_NDS32_SDA12S2_SP_RELA)
14598 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
14599 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
14600 {
14601 r_symndx = ELF32_R_SYM (irel->r_info);
14602 if (r_symndx < symtab_hdr->sh_info)
14603 {
14604 /* Local symbol. */
14605 int shndx = isym[r_symndx].st_shndx;
14606
14607 isec = elf_elfsections (abfd)[shndx]->bfd_section;
14608 if (ex9_insn->sec == isec
14609 && ex9_insn->irel->r_addend == irel->r_addend
14610 && ex9_insn->irel->r_info == irel->r_info)
14611 {
14612 do_replace = 1;
14613 save_irel = 1;
14614 }
14615 }
14616 else
14617 {
14618 /* External symbol. */
14619 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14620 if (ex9_insn->m_list)
14621 {
14622 h_list = ex9_insn->m_list->h_list;
14623 while (h_list)
14624 {
14625 if (h == h_list->h
14626 && (ex9_insn->m_list->irel->r_addend ==
14627 irel->r_addend))
14628 {
14629 do_replace = 1;
14630 save_irel = 1;
14631 break;
14632 }
14633 h_list = h_list->next;
14634 }
14635 }
14636 }
14637 }
14638 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_HI20_RELA)
14639 {
14640 r_symndx = ELF32_R_SYM (irel->r_info);
14641 if (r_symndx < symtab_hdr->sh_info)
14642 {
14643 /* Local symbols. Compare its base symbol and offset. */
14644 int shndx = isym[r_symndx].st_shndx;
14645
14646 isec = elf_elfsections (abfd)[shndx]->bfd_section;
14647 if (ex9_insn->sec == isec
14648 && ex9_insn->irel->r_addend == irel->r_addend
14649 && ex9_insn->irel->r_info == irel->r_info)
14650 {
14651 do_replace = 1;
14652 save_irel = 1;
14653 }
14654 }
14655 else
14656 {
14657 /* External symbol. */
14658 struct elf_link_hash_entry_mul_list *m_list;
14659
14660 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14661 m_list = ex9_insn->m_list;
14662
14663 while (m_list)
14664 {
14665 h_list = m_list->h_list;
14666
14667 while (h_list)
14668 {
14669 if (h == h_list->h
14670 && (m_list->irel->r_addend
14671 == irel->r_addend))
14672 {
14673 do_replace = 1;
14674 save_irel = 1;
14675 if (ex9_insn->next
14676 && ex9_insn->m_list
14677 && ex9_insn->m_list == ex9_insn->next->m_list)
14678 {
14679 /* sethi multiple entry must be fixed */
14680 nds32_elf_ex9_insert_fix (sec, irel,
14681 h, ex9_insn->order);
14682 }
14683 break;
14684 }
14685 h_list = h_list->next;
14686 }
14687 m_list = m_list->next;
14688 }
14689 }
14690 }
14691 }
14692
14693 /* Import table: Check the symbol hash table and the
14694 jump target. Only R_NDS32_25_PCREL_RELA now. */
14695 else if (ex9_insn->times == -1
14696 && ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA)
14697 {
14698 nds32_elf_get_insn_with_reg (irel, it_insn, &it_insn_with_reg);
14699 if (insn_with_reg == it_insn_with_reg)
14700 {
14701 char code[10];
14702 bfd_vma relocation;
14703
14704 r_symndx = ELF32_R_SYM (irel->r_info);
14705 if (r_symndx >= symtab_hdr->sh_info)
14706 {
14707 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14708 if ((h->root.type == bfd_link_hash_defined
14709 || h->root.type == bfd_link_hash_defweak)
14710 && h->root.u.def.section != NULL
14711 && h->root.u.def.section->output_section != NULL
14712 && h->root.u.def.section->gc_mark == 1
14713 && bfd_is_abs_section (h->root.u.def.section)
14714 && h->root.u.def.value > sec->size)
14715 {
14716 relocation = h->root.u.def.value +
14717 h->root.u.def.section->output_section->vma +
14718 h->root.u.def.section->output_offset;
14719 relocation += irel->r_addend;
14720 insn = insn_with_reg
14721 | ((relocation >> 1) & 0xffffff);
14722 snprintf (code, sizeof (code), "%08x", insn);
14723 if (strcmp (code, ex9_insn->string) == 0)
14724 {
14725 do_replace = 1;
14726 save_irel = 1;
14727 }
14728 }
14729 }
14730 }
14731 }
14732 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
14733 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
14734 || ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
14735 {
14736 /* These relocations do not have to relocate contens, so it can
14737 be regard as instruction without relocation. */
14738 if (insn == it_insn && ex9_insn->irel == NULL)
14739 do_replace = 1;
14740 }
14741 }
14742 else
14743 {
14744 /* Instruction without relocation, we only
14745 have to compare their byte code. */
14746 if (insn == it_insn && ex9_insn->irel == NULL)
14747 do_replace = 1;
14748 }
14749
14750 /* Insntruction match so replacing the code here. */
14751 if (do_replace == 1)
14752 {
14753 /* There are two formats of ex9 instruction. */
14754 if (ex9_insn->order < 32)
14755 insn_ex9 = INSN_EX9_IT_2;
14756 else
14757 insn_ex9 = INSN_EX9_IT_1;
14758 insn16 = insn_ex9 | ex9_insn->order;
14759
14760 /* Insert ex9 instruction. */
14761 nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14762 &relax_blank_list, pre_irel_ptr,
14763 &irel_list);
14764 pre_off = off;
14765 pre_insn16 = insn16;
14766
14767 if (save_irel)
14768 {
14769 /* For instuction with relocation do relax. */
14770 irel_ptr = (struct elf_nds32_irel_entry *)
14771 bfd_malloc (sizeof (struct elf_nds32_irel_entry));
14772 irel_ptr->irel = irel;
14773 irel_ptr->next = NULL;
14774 pre_irel_ptr = irel_ptr;
14775 }
14776 else
14777 pre_irel_ptr = NULL;
14778 break;
14779 }
14780 ex9_insn = ex9_insn->next;
14781 }
14782 off += 4;
14783 }
14784
14785 /* Insert ex9 instruction. */
14786 nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14787 &relax_blank_list, pre_irel_ptr,
14788 &irel_list);
14789
14790 /* Delete the redundant code. */
14791 if (relax_blank_list)
14792 {
14793 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
14794 relax_blank_list = NULL;
14795 }
14796
14797 /* Clear the relocation that is replaced by ex9. */
14798 while (irel_list)
14799 {
14800 struct elf_nds32_irel_entry *irel_ptr;
14801
14802 irel_ptr = irel_list;
14803 irel_list = irel_ptr->next;
14804 irel_ptr->irel->r_info =
14805 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info), R_NDS32_TRAN);
14806 free (irel_ptr);
14807 }
14808 return TRUE;
14809 }
14810
14811 /* Initialize ex9 hash table. */
14812
14813 int
14814 nds32_elf_ex9_init (void)
14815 {
14816 if (!bfd_hash_table_init_n (&ex9_code_table, nds32_elf_code_hash_newfunc,
14817 sizeof (struct elf_nds32_code_hash_entry),
14818 1023))
14819 {
14820 _bfd_error_handler (_("Linker: cannot init ex9 hash table error \n"));
14821 return FALSE;
14822 }
14823 return TRUE;
14824 }
14825
14826 /* Predict how many bytes will be relaxed with ex9 and ifc. */
14827
14828 static void
14829 nds32_elf_ex9_total_relax (struct bfd_link_info *info)
14830 {
14831 struct elf_nds32_insn_times_entry *ex9_insn;
14832 struct elf_nds32_insn_times_entry *temp;
14833 int target_optimize;
14834 struct elf_nds32_link_hash_table *table;
14835
14836 if (ex9_insn_head == NULL)
14837 return;
14838
14839 table = nds32_elf_hash_table (info);
14840 target_optimize = table->target_optimize;
14841 ex9_insn = ex9_insn_head;
14842 while (ex9_insn)
14843 {
14844 ex9_relax_size = ex9_insn->times * 2 + ex9_relax_size;
14845 temp = ex9_insn;
14846 ex9_insn = ex9_insn->next;
14847 free (temp);
14848 }
14849 ex9_insn_head = NULL;
14850
14851 if ((target_optimize & NDS32_RELAX_JUMP_IFC_ON))
14852 {
14853 /* Examine ifc reduce size. */
14854 struct elf_nds32_ifc_symbol_entry *ifc_ent = ifc_symbol_head;
14855 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
14856 int size = 0;
14857
14858 while (ifc_ent)
14859 {
14860 if (ifc_ent->enable == 0)
14861 {
14862 /* Not ifc yet. */
14863 irel_ptr = ifc_ent->irel_head;
14864 while (irel_ptr)
14865 {
14866 size += 2;
14867 irel_ptr = irel_ptr->next;
14868 }
14869 }
14870 size -= 2;
14871 ifc_ent = ifc_ent->next;
14872 }
14873 ex9_relax_size += size;
14874 }
14875 }
14876
14877 /* Finish ex9 table. */
14878
14879 void
14880 nds32_elf_ex9_finish (struct bfd_link_info *link_info)
14881 {
14882 nds32_elf_code_hash_traverse (nds32_elf_examine_insn_times);
14883 nds32_elf_order_insn_times (link_info);
14884 nds32_elf_ex9_total_relax (link_info);
14885 /* Traverse the hash table and count its times. */
14886 nds32_elf_code_hash_traverse (nds32_elf_count_insn_times);
14887 nds32_elf_order_insn_times (link_info);
14888 nds32_elf_ex9_build_itable (link_info);
14889 }
14890
14891 /* Relocate the entries in ex9 table. */
14892
14893 static bfd_vma
14894 nds32_elf_ex9_reloc_insn (struct elf_nds32_insn_times_entry *ptr,
14895 struct bfd_link_info *link_info)
14896 {
14897 Elf_Internal_Sym *isym = NULL;
14898 bfd_vma relocation = -1;
14899 struct elf_link_hash_entry *h;
14900
14901 if (ptr->m_list != NULL)
14902 {
14903 /* Global symbol. */
14904 h = ptr->m_list->h_list->h;
14905 if ((h->root.type == bfd_link_hash_defined
14906 || h->root.type == bfd_link_hash_defweak)
14907 && h->root.u.def.section != NULL
14908 && h->root.u.def.section->output_section != NULL)
14909 {
14910
14911 relocation = h->root.u.def.value +
14912 h->root.u.def.section->output_section->vma +
14913 h->root.u.def.section->output_offset;
14914 relocation += ptr->m_list->irel->r_addend;
14915 }
14916 else
14917 relocation = 0;
14918 }
14919 else if (ptr->sec !=NULL)
14920 {
14921 /* Local symbol. */
14922 Elf_Internal_Sym sym;
14923 asection *sec = NULL;
14924 asection isec;
14925 asection *isec_ptr = &isec;
14926 Elf_Internal_Rela irel_backup = *(ptr->irel);
14927 asection *sec_backup = ptr->sec;
14928 bfd *abfd = ptr->sec->owner;
14929
14930 if (!nds32_get_local_syms (abfd, sec, &isym))
14931 return FALSE;
14932 isym = isym + ELF32_R_SYM (ptr->irel->r_info);
14933
14934 sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
14935 if (sec != NULL)
14936 *isec_ptr = *sec;
14937 sym = *isym;
14938
14939 /* The purpose is same as elf_link_input_bfd. */
14940 if (isec_ptr != NULL
14941 && isec_ptr->sec_info_type == SEC_INFO_TYPE_MERGE
14942 && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
14943 {
14944 sym.st_value =
14945 _bfd_merged_section_offset (ptr->sec->output_section->owner, &isec_ptr,
14946 elf_section_data (isec_ptr)->sec_info,
14947 isym->st_value);
14948 }
14949 relocation = _bfd_elf_rela_local_sym (link_info->output_bfd, &sym,
14950 &ptr->sec, ptr->irel);
14951 if (ptr->irel != NULL)
14952 relocation += ptr->irel->r_addend;
14953
14954 /* Restore origin value since there may be some insntructions that
14955 could not be replaced with ex9.it. */
14956 *(ptr->irel) = irel_backup;
14957 ptr->sec = sec_backup;
14958 }
14959
14960 return relocation;
14961 }
14962
14963 /* Import ex9 table and build list. */
14964
14965 void
14966 nds32_elf_ex9_import_table (struct bfd_link_info *info)
14967 {
14968 int num = 0;
14969 bfd_byte *contents;
14970 unsigned long insn;
14971 FILE *ex9_import_file;
14972 int update_ex9_table;
14973 struct elf_nds32_link_hash_table *table;
14974
14975 table = nds32_elf_hash_table (info);
14976 ex9_import_file = table->ex9_import_file;
14977 rewind (table->ex9_import_file);
14978
14979 contents = bfd_malloc (sizeof (bfd_byte) * 4);
14980
14981 /* Read instructions from the input file and build the list. */
14982 while (!feof (ex9_import_file))
14983 {
14984 char *code;
14985 struct elf_nds32_insn_times_entry *ptr;
14986 size_t nread;
14987
14988 nread = fread (contents, sizeof (bfd_byte) * 4, 1, ex9_import_file);
14989 /* Ignore the final byte 0x0a. */
14990 if (nread < 1)
14991 break;
14992 insn = bfd_getb32 (contents);
14993 code = bfd_malloc (sizeof (char) * 9);
14994 snprintf (code, 9, "%08lx", insn);
14995 ptr = bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14996 ptr->string = code;
14997 ptr->order = num;
14998 ptr->times = -1;
14999 ptr->sec = NULL;
15000 ptr->m_list = NULL;
15001 ptr->rel_backup.r_offset = 0;
15002 ptr->rel_backup.r_info = 0;
15003 ptr->rel_backup.r_addend = 0;
15004 ptr->irel = NULL;
15005 ptr->next = NULL;
15006 nds32_elf_ex9_insert_entry (ptr);
15007 num++;
15008 }
15009
15010 update_ex9_table = table->update_ex9_table;
15011 if (update_ex9_table == 1)
15012 {
15013 /* It has to consider of sethi need to use multiple page
15014 but it not be done yet. */
15015 nds32_elf_code_hash_traverse (nds32_elf_examine_insn_times);
15016 nds32_elf_order_insn_times (info);
15017 }
15018 }
15019
15020 /* Export ex9 table. */
15021
15022 static void
15023 nds32_elf_ex9_export (struct bfd_link_info *info,
15024 bfd_byte *contents, int size)
15025 {
15026 FILE *ex9_export_file;
15027 struct elf_nds32_link_hash_table *table;
15028
15029 table = nds32_elf_hash_table (info);
15030 ex9_export_file = table->ex9_export_file;
15031 fwrite (contents, sizeof (bfd_byte), size, ex9_export_file);
15032 fclose (ex9_export_file);
15033 }
15034
15035 /* Adjust relocations of J and JAL in ex9.itable.
15036 Export ex9 table. */
15037
15038 static void
15039 nds32_elf_ex9_reloc_jmp (struct bfd_link_info *link_info)
15040 {
15041 asection *table_sec = NULL;
15042 struct elf_nds32_insn_times_entry *ex9_insn = ex9_insn_head;
15043 struct elf_nds32_insn_times_entry *temp_ptr, *temp_ptr2;
15044 bfd *it_abfd;
15045 uint32_t insn, insn_with_reg, source_insn;
15046 bfd_byte *contents = NULL, *source_contents = NULL;
15047 int size = 0;
15048 bfd_vma gp;
15049 int shift, update_ex9_table, offset = 0;
15050 reloc_howto_type *howto = NULL;
15051 Elf_Internal_Rela rel_backup;
15052 unsigned short insn_ex9;
15053 struct elf_nds32_link_hash_table *table;
15054 FILE *ex9_export_file;
15055 static bfd_boolean done = FALSE;
15056
15057 if (done)
15058 return;
15059
15060 done = TRUE;
15061
15062 table = nds32_elf_hash_table (link_info);
15063 if (table)
15064 table->relax_status |= NDS32_RELAX_EX9_DONE;
15065
15066
15067 update_ex9_table = table->update_ex9_table;
15068 /* Generated ex9.itable exactly. */
15069 if (update_ex9_table == 0)
15070 {
15071 for (it_abfd = link_info->input_bfds; it_abfd != NULL;
15072 it_abfd = it_abfd->link.next)
15073 {
15074 table_sec = bfd_get_section_by_name (it_abfd, ".ex9.itable");
15075 if (table_sec != NULL)
15076 break;
15077 }
15078
15079 if (table_sec != NULL)
15080 {
15081 bfd *output_bfd;
15082
15083 output_bfd = table_sec->output_section->owner;
15084 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15085 if (table_sec->size == 0)
15086 return;
15087
15088 if (!nds32_get_section_contents (it_abfd, table_sec, &contents, TRUE))
15089 return;
15090 }
15091 }
15092 else
15093 {
15094 /* Set gp. */
15095 bfd *output_bfd;
15096
15097 output_bfd = link_info->input_bfds->sections->output_section->owner;
15098 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15099 contents = bfd_malloc (sizeof (bfd_byte) * 2048);
15100 }
15101
15102 /* Relocate instruction. */
15103 while (ex9_insn)
15104 {
15105 bfd_vma relocation, min_relocation = 0xffffffff;
15106
15107 insn = strtol (ex9_insn->string, NULL, 16);
15108 insn_with_reg = 0;
15109 if (ex9_insn->m_list != NULL || ex9_insn->sec != NULL)
15110 {
15111 if (ex9_insn->m_list)
15112 rel_backup = ex9_insn->m_list->rel_backup;
15113 else
15114 rel_backup = ex9_insn->rel_backup;
15115
15116 nds32_elf_get_insn_with_reg (&rel_backup, insn, &insn_with_reg);
15117 howto =
15118 bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE
15119 (rel_backup.r_info));
15120 shift = howto->rightshift;
15121 if (ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_25_PCREL_RELA
15122 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S0_ORI_RELA
15123 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S0_RELA
15124 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S1_RELA
15125 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S2_RELA)
15126 {
15127 relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15128 insn =
15129 insn_with_reg | ((relocation >> shift) &
15130 nds32_elf_irel_mask (&rel_backup));
15131 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15132 }
15133 else if ((ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA15S3
15134 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA15S0)
15135 || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA15S3_RELA
15136 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA15S0_RELA)
15137 || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA12S2_DP_RELA
15138 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA12S2_SP_RELA)
15139 || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA16S3_RELA
15140 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA19S0_RELA))
15141 {
15142 relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15143 insn =
15144 insn_with_reg | (((relocation - gp) >> shift) &
15145 nds32_elf_irel_mask (&rel_backup));
15146 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15147 }
15148 else if (ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_HI20_RELA)
15149 {
15150 /* Sethi may be multiple entry for one insn. */
15151 if (ex9_insn->next && ex9_insn->m_list
15152 && ex9_insn->m_list == ex9_insn->next->m_list)
15153 {
15154 struct elf_link_hash_entry_mul_list *m_list;
15155 struct elf_nds32_ex9_refix *fix_ptr;
15156 struct elf_link_hash_entry *h;
15157
15158 temp_ptr = ex9_insn;
15159 temp_ptr2 = ex9_insn;
15160 m_list = ex9_insn->m_list;
15161 while (m_list)
15162 {
15163 h = m_list->h_list->h;
15164 relocation = h->root.u.def.value +
15165 h->root.u.def.section->output_section->vma +
15166 h->root.u.def.section->output_offset;
15167 relocation += m_list->irel->r_addend;
15168
15169 if (relocation < min_relocation)
15170 min_relocation = relocation;
15171 m_list = m_list->next;
15172 }
15173 relocation = min_relocation;
15174
15175 /* Put insntruction into ex9 table. */
15176 insn = insn_with_reg
15177 | ((relocation >> shift) & nds32_elf_irel_mask (&rel_backup));
15178 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15179 relocation = relocation + 0x1000; /* hi20 */
15180
15181 while (ex9_insn->next && ex9_insn->m_list
15182 && ex9_insn->m_list == ex9_insn->next->m_list)
15183 {
15184 /* Multiple sethi. */
15185 ex9_insn = ex9_insn->next;
15186 size += 4;
15187 insn =
15188 insn_with_reg | ((relocation >> shift) &
15189 nds32_elf_irel_mask (&rel_backup));
15190 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15191 relocation = relocation + 0x1000; /* hi20 */
15192 }
15193
15194 fix_ptr = ex9_refix_head;
15195 while (fix_ptr)
15196 {
15197 /* Fix ex9 insn. */
15198 /* temp_ptr2 points to the head of multiple sethi. */
15199 temp_ptr = temp_ptr2;
15200 while (fix_ptr->order != temp_ptr->order && fix_ptr->next)
15201 {
15202 fix_ptr = fix_ptr->next;
15203 }
15204 if (fix_ptr->order != temp_ptr->order)
15205 break;
15206
15207 /* Set source insn. */
15208 relocation =
15209 fix_ptr->h->root.u.def.value +
15210 fix_ptr->h->root.u.def.section->output_section->vma +
15211 fix_ptr->h->root.u.def.section->output_offset;
15212 relocation += fix_ptr->irel->r_addend;
15213 /* sethi imm is imm20s. */
15214 source_insn = insn_with_reg | ((relocation >> shift) & 0xfffff);
15215
15216 while (temp_ptr)
15217 {
15218 /* Match entry and source code. */
15219 insn = bfd_getb32 (contents + (temp_ptr->order) * 4 + offset);
15220 if (insn == source_insn)
15221 {
15222 /* Fix the ex9 insn. */
15223 if (temp_ptr->order != fix_ptr->order)
15224 {
15225 if (!nds32_get_section_contents
15226 (fix_ptr->sec->owner, fix_ptr->sec,
15227 &source_contents, TRUE))
15228 _bfd_error_handler
15229 (_("Linker: error cannot fixed ex9 relocation \n"));
15230 if (temp_ptr->order < 32)
15231 insn_ex9 = INSN_EX9_IT_2;
15232 else
15233 insn_ex9 = INSN_EX9_IT_1;
15234 insn_ex9 = insn_ex9 | temp_ptr->order;
15235 bfd_putb16 (insn_ex9, source_contents + fix_ptr->irel->r_offset);
15236 }
15237 break;
15238 }
15239 else
15240 {
15241 if (!temp_ptr->next || temp_ptr->m_list != temp_ptr->next->m_list)
15242 _bfd_error_handler
15243 (_("Linker: error cannot fixed ex9 relocation \n"));
15244 else
15245 temp_ptr = temp_ptr->next;
15246 }
15247 }
15248 fix_ptr = fix_ptr->next;
15249 }
15250 }
15251 else
15252 {
15253 relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15254 insn = insn_with_reg
15255 | ((relocation >> shift) & nds32_elf_irel_mask (&rel_backup));
15256 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15257 }
15258 }
15259 }
15260 else
15261 {
15262 /* Insn without relocation does not have to be fixed
15263 if need to update export table. */
15264 if (update_ex9_table == 1)
15265 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15266 }
15267 ex9_insn = ex9_insn->next;
15268 size += 4;
15269 }
15270
15271 ex9_export_file = table->ex9_export_file;
15272 if (ex9_export_file != NULL)
15273 nds32_elf_ex9_export (link_info, contents, table_sec->size);
15274 else if (update_ex9_table == 1)
15275 {
15276 table->ex9_export_file = table->ex9_import_file;
15277 rewind (table->ex9_export_file);
15278 nds32_elf_ex9_export (link_info, contents, size);
15279 }
15280 }
15281
15282 /* Generate ex9 hash table. */
15283
15284 static bfd_boolean
15285 nds32_elf_ex9_build_hash_table (bfd *abfd, asection *sec,
15286 struct bfd_link_info *link_info)
15287 {
15288 Elf_Internal_Rela *internal_relocs;
15289 Elf_Internal_Rela *irelend;
15290 Elf_Internal_Rela *irel;
15291 Elf_Internal_Rela *jrel;
15292 Elf_Internal_Rela rel_backup;
15293 Elf_Internal_Shdr *symtab_hdr;
15294 Elf_Internal_Sym *isym = NULL;
15295 asection *isec;
15296 struct elf_link_hash_entry **sym_hashes;
15297 bfd_byte *contents = NULL;
15298 bfd_vma off = 0;
15299 unsigned long r_symndx;
15300 uint32_t insn, insn_with_reg;
15301 struct elf_link_hash_entry *h;
15302 int data_flag, shift, align;
15303 bfd_vma relocation;
15304 /* Suppress ex9 if `.no_relax ex9' or inner loop. */
15305 reloc_howto_type *howto = NULL;
15306
15307 sym_hashes = elf_sym_hashes (abfd);
15308 /* Load section instructions, relocations, and symbol table. */
15309 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
15310 return FALSE;
15311
15312 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
15313 TRUE /* keep_memory */);
15314 irelend = internal_relocs + sec->reloc_count;
15315 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
15316 if (!nds32_get_local_syms (abfd, sec, &isym))
15317 return FALSE;
15318
15319 /* Check the object if enable ex9. */
15320 irel = find_relocs_at_address (internal_relocs, internal_relocs, irelend,
15321 R_NDS32_RELAX_ENTRY);
15322
15323 /* Check this section trigger ex9 relaxation. */
15324 if (irel == NULL
15325 || irel >= irelend
15326 || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
15327 || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
15328 && !(irel->r_addend & R_NDS32_RELAX_ENTRY_EX9_FLAG)))
15329 return TRUE;
15330
15331 irel = internal_relocs;
15332
15333 /* Push each insn into hash table. */
15334 while (off < sec->size)
15335 {
15336 char code[10];
15337 struct elf_nds32_code_hash_entry *entry;
15338
15339 while (irel != NULL && irel < irelend && irel->r_offset < off)
15340 irel++;
15341
15342 data_flag = nds32_elf_ex9_relocation_check (link_info, &irel, irelend,
15343 NULL, sec, &off, contents);
15344 if (data_flag & DATA_EXIST)
15345 {
15346 /* We save the move offset in the highest byte. */
15347 off += (data_flag >> 24);
15348 continue;
15349 }
15350
15351 if (*(contents + off) & 0x80)
15352 {
15353 off += 2;
15354 }
15355 else
15356 {
15357 h = NULL;
15358 isec = NULL;
15359 jrel = NULL;
15360 rel_backup.r_info = 0;
15361 rel_backup.r_offset = 0;
15362 rel_backup.r_addend = 0;
15363 /* Load the instruction and its opcode with register for comparing. */
15364 insn = bfd_getb32 (contents + off);
15365 insn_with_reg = 0;
15366 if (irel != NULL && irel < irelend && irel->r_offset == off)
15367 {
15368 nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
15369 howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
15370 shift = howto->rightshift;
15371 align = (1 << shift) - 1;
15372 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA
15373 || ELF32_R_TYPE (irel->r_info) == R_NDS32_HI20_RELA
15374 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_ORI_RELA
15375 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_RELA
15376 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S1_RELA
15377 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_RELA
15378 ||(ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
15379 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
15380 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
15381 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
15382 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
15383 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA12S2_SP_RELA)
15384 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
15385 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
15386 {
15387 r_symndx = ELF32_R_SYM (irel->r_info);
15388 jrel = irel;
15389 rel_backup = *irel;
15390 if (r_symndx < symtab_hdr->sh_info)
15391 {
15392 /* Local symbol. */
15393 int shndx = isym[r_symndx].st_shndx;
15394
15395 bfd_vma st_value = (isym + r_symndx)->st_value;
15396 isec = elf_elfsections (abfd)[shndx]->bfd_section;
15397 relocation = (isec->output_section->vma + isec->output_offset
15398 + st_value + irel->r_addend);
15399 }
15400 else
15401 {
15402 /* External symbol. */
15403 bfd_boolean warned ATTRIBUTE_UNUSED;
15404 bfd_boolean ignored ATTRIBUTE_UNUSED;
15405 bfd_boolean unresolved_reloc ATTRIBUTE_UNUSED;
15406 asection *sym_sec;
15407
15408 /* Maybe there is a better way to get h and relocation */
15409 RELOC_FOR_GLOBAL_SYMBOL (link_info, abfd, sec, irel,
15410 r_symndx, symtab_hdr, sym_hashes,
15411 h, sym_sec, relocation,
15412 unresolved_reloc, warned, ignored);
15413 relocation += irel->r_addend;
15414 if ((h->root.type != bfd_link_hash_defined
15415 && h->root.type != bfd_link_hash_defweak)
15416 || strcmp (h->root.root.string, "_FP_BASE_") == 0)
15417 {
15418 off += 4;
15419 continue;
15420 }
15421 }
15422
15423 /* Check for gp relative instruction alignment. */
15424 if ((ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
15425 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
15426 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
15427 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
15428 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
15429 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA12S2_SP_RELA)
15430 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
15431 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
15432 {
15433 bfd_vma gp;
15434 bfd *output_bfd = sec->output_section->owner;
15435 bfd_reloc_status_type r;
15436
15437 /* If the symbol is in the abs section, the out_bfd will be null.
15438 This happens when the relocation has a symbol@GOTOFF. */
15439 r = nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15440 if (r != bfd_reloc_ok)
15441 {
15442 off += 4;
15443 continue;
15444 }
15445
15446 relocation -= gp;
15447
15448 /* Make sure alignment is correct. */
15449 if (relocation & align)
15450 {
15451 /* Incorrect alignment. */
15452 _bfd_error_handler
15453 /* xgettext:c-format */
15454 (_("%s: warning: unaligned small data access. "
15455 "For entry: {%d, %d, %d}, addr = 0x%x, align = 0x%x."),
15456 bfd_get_filename (abfd), irel->r_offset,
15457 irel->r_info, irel->r_addend, relocation, align);
15458 off += 4;
15459 continue;
15460 }
15461 }
15462
15463 insn = insn_with_reg
15464 | ((relocation >> shift) & nds32_elf_irel_mask (irel));
15465 }
15466 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
15467 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
15468 || ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
15469 {
15470 /* These relocations do not have to relocate contens, so it can
15471 be regard as instruction without relocation. */
15472 }
15473 else
15474 {
15475 off += 4;
15476 continue;
15477 }
15478 }
15479
15480 snprintf (code, sizeof (code), "%08x", insn);
15481 /* Copy "code". */
15482 entry = (struct elf_nds32_code_hash_entry*)
15483 bfd_hash_lookup (&ex9_code_table, code, TRUE, TRUE);
15484 if (entry == NULL)
15485 {
15486 _bfd_error_handler
15487 (_("%P%F: failed creating ex9.it %s hash table: %E\n"), code);
15488 return FALSE;
15489 }
15490 if (h)
15491 {
15492 if (h->root.type == bfd_link_hash_undefined)
15493 return TRUE;
15494 /* Global symbol. */
15495 /* In order to do sethi with different symbol but same value. */
15496 if (entry->m_list == NULL)
15497 {
15498 struct elf_link_hash_entry_mul_list *m_list_new;
15499 struct elf_link_hash_entry_list *h_list_new;
15500
15501 m_list_new = (struct elf_link_hash_entry_mul_list *)
15502 bfd_malloc (sizeof (struct elf_link_hash_entry_mul_list));
15503 h_list_new = (struct elf_link_hash_entry_list *)
15504 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15505 entry->m_list = m_list_new;
15506 m_list_new->h_list = h_list_new;
15507 m_list_new->rel_backup = rel_backup;
15508 m_list_new->times = 1;
15509 m_list_new->irel = jrel;
15510 m_list_new->next = NULL;
15511 h_list_new->h = h;
15512 h_list_new->next = NULL;
15513 }
15514 else
15515 {
15516 struct elf_link_hash_entry_mul_list *m_list = entry->m_list;
15517 struct elf_link_hash_entry_list *h_list;
15518
15519 while (m_list)
15520 {
15521 /* Build the different symbols that point to the same address. */
15522 h_list = m_list->h_list;
15523 if (h_list->h->root.u.def.value == h->root.u.def.value
15524 && h_list->h->root.u.def.section->output_section->vma
15525 == h->root.u.def.section->output_section->vma
15526 && h_list->h->root.u.def.section->output_offset
15527 == h->root.u.def.section->output_offset
15528 && m_list->rel_backup.r_addend == rel_backup.r_addend)
15529 {
15530 m_list->times++;
15531 m_list->irel = jrel;
15532 while (h_list->h != h && h_list->next)
15533 h_list = h_list->next;
15534 if (h_list->h != h)
15535 {
15536 struct elf_link_hash_entry_list *h_list_new;
15537
15538 h_list_new = (struct elf_link_hash_entry_list *)
15539 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15540 h_list->next = h_list_new;
15541 h_list_new->h = h;
15542 h_list_new->next = NULL;
15543 }
15544 break;
15545 }
15546 /* The sethi case may have different address but the
15547 hi20 is the same. */
15548 else if (ELF32_R_TYPE (jrel->r_info) == R_NDS32_HI20_RELA
15549 && m_list->next == NULL)
15550 {
15551 struct elf_link_hash_entry_mul_list *m_list_new;
15552 struct elf_link_hash_entry_list *h_list_new;
15553
15554 m_list_new = (struct elf_link_hash_entry_mul_list *)
15555 bfd_malloc (sizeof (struct elf_link_hash_entry_mul_list));
15556 h_list_new = (struct elf_link_hash_entry_list *)
15557 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15558 m_list->next = m_list_new;
15559 m_list_new->h_list = h_list_new;
15560 m_list_new->rel_backup = rel_backup;
15561 m_list_new->times = 1;
15562 m_list_new->irel = jrel;
15563 m_list_new->next = NULL;
15564 h_list_new->h = h;
15565 h_list_new->next = NULL;
15566 break;
15567 }
15568 m_list = m_list->next;
15569 }
15570 if (!m_list)
15571 {
15572 off += 4;
15573 continue;
15574 }
15575 }
15576 }
15577 else
15578 {
15579 /* Local symbol and insn without relocation*/
15580 entry->times++;
15581 entry->rel_backup = rel_backup;
15582 }
15583
15584 /* Use in sethi insn with constant and global symbol in same format. */
15585 if (!jrel)
15586 entry->const_insn = 1;
15587 else
15588 entry->irel = jrel;
15589 entry->sec = isec;
15590 off += 4;
15591 }
15592 }
15593 return TRUE;
15594 }
15595
15596 /* Set the _ITB_BASE, and point it to ex9 table. */
15597
15598 bfd_boolean
15599 nds32_elf_ex9_itb_base (struct bfd_link_info *link_info)
15600 {
15601 bfd *abfd;
15602 asection *sec;
15603 bfd *output_bfd = NULL;
15604 struct bfd_link_hash_entry *bh = NULL;
15605
15606 if (is_ITB_BASE_set == 1)
15607 return TRUE;
15608
15609 is_ITB_BASE_set = 1;
15610
15611 bh = bfd_link_hash_lookup (link_info->hash, "_ITB_BASE_", FALSE, FALSE, TRUE);
15612
15613 if (bh && (bh->type == bfd_link_hash_defined
15614 || bh->type == bfd_link_hash_defweak))
15615 return TRUE;
15616
15617 for (abfd = link_info->input_bfds; abfd != NULL;
15618 abfd = abfd->link.next)
15619 {
15620 sec = bfd_get_section_by_name (abfd, ".ex9.itable");
15621 if (sec != NULL)
15622 {
15623 output_bfd = sec->output_section->owner;
15624 break;
15625 }
15626 }
15627 if (output_bfd == NULL)
15628 {
15629 output_bfd = link_info->output_bfd;
15630 if (output_bfd->sections == NULL)
15631 return TRUE;
15632 else
15633 sec = bfd_abs_section_ptr;
15634 }
15635 bh = bfd_link_hash_lookup (link_info->hash, "_ITB_BASE_",
15636 FALSE, FALSE, TRUE);
15637 return (_bfd_generic_link_add_one_symbol
15638 (link_info, output_bfd, "_ITB_BASE_",
15639 BSF_GLOBAL | BSF_WEAK, sec, 0,
15640 (const char *) NULL, FALSE, get_elf_backend_data
15641 (output_bfd)->collect, &bh));
15642 } /* End EX9.IT */
15643 \f
15644
15645 #define ELF_ARCH bfd_arch_nds32
15646 #define ELF_MACHINE_CODE EM_NDS32
15647 #define ELF_MAXPAGESIZE 0x1000
15648 #define ELF_TARGET_ID NDS32_ELF_DATA
15649
15650 #define TARGET_BIG_SYM nds32_elf32_be_vec
15651 #define TARGET_BIG_NAME "elf32-nds32be"
15652 #define TARGET_LITTLE_SYM nds32_elf32_le_vec
15653 #define TARGET_LITTLE_NAME "elf32-nds32le"
15654
15655 #define elf_info_to_howto nds32_info_to_howto
15656 #define elf_info_to_howto_rel nds32_info_to_howto_rel
15657
15658 #define bfd_elf32_bfd_link_hash_table_create nds32_elf_link_hash_table_create
15659 #define bfd_elf32_bfd_merge_private_bfd_data nds32_elf_merge_private_bfd_data
15660 #define bfd_elf32_bfd_print_private_bfd_data nds32_elf_print_private_bfd_data
15661 #define bfd_elf32_bfd_relax_section nds32_elf_relax_section
15662 #define bfd_elf32_bfd_set_private_flags nds32_elf_set_private_flags
15663
15664 #define bfd_elf32_mkobject nds32_elf_mkobject
15665 #define elf_backend_action_discarded nds32_elf_action_discarded
15666 #define elf_backend_add_symbol_hook nds32_elf_add_symbol_hook
15667 #define elf_backend_check_relocs nds32_elf_check_relocs
15668 #define elf_backend_adjust_dynamic_symbol nds32_elf_adjust_dynamic_symbol
15669 #define elf_backend_create_dynamic_sections nds32_elf_create_dynamic_sections
15670 #define elf_backend_finish_dynamic_sections nds32_elf_finish_dynamic_sections
15671 #define elf_backend_finish_dynamic_symbol nds32_elf_finish_dynamic_symbol
15672 #define elf_backend_size_dynamic_sections nds32_elf_size_dynamic_sections
15673 #define elf_backend_relocate_section nds32_elf_relocate_section
15674 #define elf_backend_gc_mark_hook nds32_elf_gc_mark_hook
15675 #define elf_backend_gc_sweep_hook nds32_elf_gc_sweep_hook
15676 #define elf_backend_grok_prstatus nds32_elf_grok_prstatus
15677 #define elf_backend_grok_psinfo nds32_elf_grok_psinfo
15678 #define elf_backend_reloc_type_class nds32_elf_reloc_type_class
15679 #define elf_backend_copy_indirect_symbol nds32_elf_copy_indirect_symbol
15680 #define elf_backend_link_output_symbol_hook nds32_elf_output_symbol_hook
15681 #define elf_backend_output_arch_syms nds32_elf_output_arch_syms
15682 #define elf_backend_object_p nds32_elf_object_p
15683 #define elf_backend_final_write_processing nds32_elf_final_write_processing
15684 #define elf_backend_special_sections nds32_elf_special_sections
15685 #define bfd_elf32_bfd_get_relocated_section_contents \
15686 nds32_elf_get_relocated_section_contents
15687
15688 #define elf_backend_can_gc_sections 1
15689 #define elf_backend_can_refcount 1
15690 #define elf_backend_want_got_plt 1
15691 #define elf_backend_plt_readonly 1
15692 #define elf_backend_want_plt_sym 0
15693 #define elf_backend_got_header_size 12
15694 #define elf_backend_may_use_rel_p 1
15695 #define elf_backend_default_use_rela_p 1
15696 #define elf_backend_may_use_rela_p 1
15697
15698 #include "elf32-target.h"
15699
15700 #undef ELF_MAXPAGESIZE
15701 #define ELF_MAXPAGESIZE 0x2000
15702
15703 #undef TARGET_BIG_SYM
15704 #define TARGET_BIG_SYM nds32_elf32_linux_be_vec
15705 #undef TARGET_BIG_NAME
15706 #define TARGET_BIG_NAME "elf32-nds32be-linux"
15707 #undef TARGET_LITTLE_SYM
15708 #define TARGET_LITTLE_SYM nds32_elf32_linux_le_vec
15709 #undef TARGET_LITTLE_NAME
15710 #define TARGET_LITTLE_NAME "elf32-nds32le-linux"
15711 #undef elf32_bed
15712 #define elf32_bed elf32_nds32_lin_bed
15713
15714 #include "elf32-target.h"
A mirror of the official binutils-gdb repository